sim_period_card.cpp

Go to the documentation of this file.

#include "stdafx.h"

#include "vme_simulation.h"
#include "sim_period_card.h"
#include "isisvme.h"

SIMPeriodCard::SIMPeriodCard(int position, VMESimulation* vme, FaultMode fault_mode, DAEstatus& status) : 
    SIMDAE2Card(position, vme, ((1 << 30) | (1 << 31)), false, Working, status)
{
        m_type = PeriodCard;

        m_perlut = new isisU32_t[PERLUTSIZE];
        m_outlut = new isisU32_t[OUTLUTSIZE];
        m_rawframes = new isisU32_t[RFCNT0SIZE];
        m_goodframes = new isisU32_t[GFCNT0SIZE];
        addMapping(MPCNT, 1, &m_main_period_counter, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(MPLIM, 1, &m_main_period_limit, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(PSCNT, 1, &m_main_period_sequence_counter, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(EXTTRIGVC0, 1, &m_extract_vc_low, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(EXTTRIGVC1, 1, &m_extract_vc_high, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(LOOKTAR, 1, &m_lookup, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(PCREG, 1, &m_period_control, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(PERLUTSTART, PERLUTSIZE, m_perlut, "perlut", true, true, &m_lookup, TARPERLUT, false, false, fault_mode);
        addMapping(OUTLUTSTART, OUTLUTSIZE, m_outlut, "outlut", true, true, &m_lookup, TAROUTLUT, false, false, fault_mode);
        addMapping(RFCNT0START, RFCNT0SIZE, m_rawframes, "raw frames", true, true, NULL, 0, false, false, fault_mode);
        addMapping(GFCNT0START, GFCNT0SIZE, m_goodframes, "good frames", true, true, NULL, 0, false, false, fault_mode);

        addMapping(MAT_1, 1, &m_mat_counter, "", true, true, NULL, 0, false, false, fault_mode);

        m_is_running = true;
        m_veto_raised = false;
        m_main_period_sequence_counter = 0;
}

void SIMPeriodCard::printStatus(std::ostream& os)
{
        os << "SIMPeriod card at position " << m_position;
}

void SIMPeriodCard::updateCardAfterWrite(DAEstatus& status)
{
        if (m_period_control & PCRESET)
        {
                m_main_period_counter = 0;
                m_period_control = PCRESET; // clears all bits except reset bit
                m_extract_vc_low = m_extract_vc_high = 0;
                m_lookup = 0;
                m_main_period_sequence_counter = 0;
        }
        if (m_period_control & PCCLRPC)
        {
                m_main_period_counter = 0;
                m_main_period_sequence_counter = 0;
        }
        if (m_period_control & PCCLRVETO)
        {
                m_extract_vc_low = m_extract_vc_high = 0;
        }
}

// this is here just so we can set a breakpoint easily on a card read
void SIMPeriodCard::updateCardAfterRead(DAEstatus& status)
{
}

void SIMPeriodCard::simulate(int delay)
{
// pcount * 1.738e-6 = uahours
        int frame_incr = delay / 20; // an isis frame is 20 milliseconds
        int proton_incr = (int)( 180.0 * (double)delay / (1000.0 * 3600.0 * 1.738e-6) ) ; // 180uA current
        if (!(m_period_control & PCENAB))
        {
                return; // not using periods
        }
        if (!(m_period_control & PCEXTPERCLK))
        {
                return;
        }
        if (!(m_period_control & PCEXTTRIG))
        {
                return;
        }
        if (m_period_control & PCEXTENAB)
        {
                return; // using external periods
        }
        if (m_period_control & PCMULENAB)
        {
                return; // using external periods
        }
        bool is_dwell;
        int current_period, max_period, max_frames;
    current_period = m_main_period_counter & 0x3fff; // lower 14 bits
        is_dwell = ((m_main_period_counter & (1 << 14)) != 0);
        max_period = m_main_period_limit & 0x3fff;
    max_frames = 1 + (m_perlut[current_period] & 0xffff); 
                if ( m_vme->isRunning() )
                {
                        if (m_period_control & PCENDSEQCOMP) // pcard has finished sequence but env card still says running, so veto
                        {
                                m_veto_raised = true;
                                increment2(frame_incr, m_extract_vc_low, m_extract_vc_high);
                                increment(frame_incr, m_rawframes[current_period]);
                        }
                        else if (is_dwell)
                        {
                                m_veto_raised = true;
                                increment2(frame_incr, m_extract_vc_low, m_extract_vc_high);
                                increment(frame_incr, m_rawframes[current_period]);
                                increment(frame_incr, m_goodframes[current_period]);
                        }
                        else
                        {
                                m_veto_raised = false;
                                increment(frame_incr, m_rawframes[current_period]);
                                increment(frame_incr, m_goodframes[current_period]);
                        }
                        if (m_goodframes[current_period] >= max_frames*(1+m_main_period_sequence_counter) )
                        {
                                if (current_period < max_period)
                                {
                                        current_period++;
                                        m_main_period_counter = (current_period & 0x3fff) |
                                                           ((m_perlut[current_period] & 0x80000000) >> 17);
                                        if (!(m_perlut[current_period] & 0x80000000)) // not dwell 
                                        {
                                                m_vme->incrementDetectorCardPeriod();
                                        }
//                                      m_rawframes[current_period] = m_goodframes[current_period] = 0;
                                }
                                else if (m_period_control & PCENDAFTER)
                                {
                                        m_period_control |= PCENDSEQCOMP;
                                }
                                else
                                {
                                        current_period = 0;
                                        m_main_period_sequence_counter++;
                                        m_main_period_counter = (current_period & 0x3fff) |
                                                           ((m_perlut[current_period] & 0x80000000) >> 17);
                                        m_vme->resetDetectorCardPeriod();
//                                      m_rawframes[current_period] = m_goodframes[current_period] = 0;
                                }
                        }
                }
}

SIMPeriodCard::~SIMPeriodCard()
{
        delete[] m_perlut;
        delete[] m_outlut;
        delete[] m_rawframes;
        delete[] m_goodframes;
}