vme_simulation.cpp

Go to the documentation of this file.

#include "stdafx.h"

#include "vme_simulation.h"
#include "sim_environment_card.h"
#include "sim_detector_card.h"
#include "sim_muon_detector_card.h"
//#include "sim_period_card.h"
#include "sim_env_period_card.h"
#include "icputils.h"


// Simulate a DAE with NSIMDETCARDS detector card (64Mb, position 1 to NSIMDETCARDS) 
// 1 Environment card (position 0) and 1 period card (position NSIMDETCARD+1)

//int VMESimulation::zeroDetectorCardPeriod()
//{
//      int k;
//      for(k=1; k<=NSIMDETCARDS; k++)
//      {
//              m_periodCounterLow[k] = m_periodCounterHigh[k] = 0;
//      }
//      return 0;
//

//int VMESimulation::incrementDetectorCardPeriod(int period)
//{
//      int k;
//      for(k=1; k<=NSIMDETCARDS; k++)
//      {
//              increment2(1, m_periodCounterLow[k], m_periodCounterHigh[k]);
//      }
//      return 0;
//}

template <class DAEPolicy>
VMESimulation<DAEPolicy>::VMESimulation(DAEstatus& status) : VMESimulationIface(), m_shutdown_requested(false), m_trigger_func(NULL), m_trigger_func_arg(NULL)
{
        int i;
        unsigned long ul;
        status.addInfo(FAC_SIMDAE, "Creating Simulated VME DAE");
        InitializeCriticalSection(&m_critical);
        srand((unsigned)time(NULL));

        m_sim_vme.push_back(this);
        int crate_number = m_sim_vme.size() - 1;
        if (crate_number == 0) // only environment card on first DAE
        {
//              m_card_list.push_back(new SIMEnvCard(0, this, Working, status));
                m_env_card_list.push_back(new MySIMEnvPeriodCard(0, this, Working, status));
        }
//      m_card_list.push_back(new SIMPeriodCard(3, this, status));

        bool sharedDetMemory = Poco::Util::Application::instance().config().getBool("isisicp.simulation.detcards.shared", false);
        std::string card_type = Poco::Util::Application::instance().config().getString("isisicp.simulation.detcards.type", "neutron");
        int numDetCards = Poco::Util::Application::instance().config().getInt(Poco::format("isisicp.simulation.detcards.crate%d.number", crate_number), 0);
        int numDataDaeDetCards = Poco::Util::Application::instance().config().getInt(Poco::format("isisicp.simulation.detcards.crate%d.datadae.number", crate_number), 0);
        for(i=1; i<=numDetCards; i++)
        {
                if (card_type == "muon")
                {
                        m_det_card_list.push_back(new SIMMuonDetectorCard<DAEPolicy::det_t>(i, this, sharedDetMemory, Working, status));
                }
                else
                {
                        m_det_card_list.push_back(new SIMDetectorCard<DAEPolicy::det_t>(i, this, sharedDetMemory, Working, true, status));
                }
        }
        for(i=1; i <= numDataDaeDetCards; i++)
        {
                m_det_card_list.push_back(new SIMDetectorCard<DAEPolicy::det_t>(i+numDetCards, this, sharedDetMemory, Working, false, status));
        }

//      m_card_list.push_back(new SIMDetectorCard(3, this, true, /*DetectedButNot*/Working, status));
        ul = _beginthread(simulation_routine, 0, (void*)this);
        if (ul == -1)
        {
                status.add(FAC_SIMDAE, SEV_ERROR, ERRTYPE_INVCARD, "error creating simulation thread");
        }
}

template <class DAEPolicy>
int VMESimulation<DAEPolicy>::getCardIds(std::vector<int>& card_ids)
{
        card_ids.clear();
        for(int i=0; i<m_env_card_list.size(); ++i)
        {
                card_ids.push_back(m_env_card_list[i]->position());
        }
        for(int i=0; i<m_det_card_list.size(); ++i)
        {
                card_ids.push_back(m_det_card_list[i]->position());
        }
//      typedef void (std::vector<int>::*push_back_t)(const int&);  // we need this because push_back is overloaded and hence ambiguous 
//      std::for_each(m_env_card_list.begin(), m_env_card_list.end(), 
//              boost::bind( (push_back_t)&std::vector<int>::push_back, boost::ref(card_ids), boost::bind(&MySIMDAE2Card::position, _1) ) 
//      );
//      std::for_each(m_det_card_list.begin(), m_det_card_list.end(), 
//              boost::bind( (push_back_t)&std::vector<int>::push_back, boost::ref(card_ids), boost::bind(&MySIMDAE2Card::position, _1) ) 
//      );
        return 0;
}

void VMESimulationIface::simulation_routine(void* arg)
{
        VMESimulationIface* dae = (VMESimulationIface*)arg;
        dae->simulation_routineImpl();
}

template <class DAEPolicy>
void VMESimulation<DAEPolicy>::simulation_routineImpl()
{
        int i;
        int delay = 20;   // in milliseconds, 20ms gives us 50Hz running
        Sleep(2000);    // to let other things complete
        VMESimulation<DAEPolicy>* dae = this;
        ICPCritical cs(&(dae->m_critical), false);
        struct timeb tb;
    while(!dae->shutdownRequested())
        {
                Sleep(delay);
                cs.lock();
                for(i=0; i< dae->m_det_card_list.size(); ++i)
                {
                        dae->m_det_card_list[i]->simulate(delay);
                }
                // do env card last so we get a frame number of zero for event mode
                if (dae->m_env_card_list.size() > 0)
                {
                        dae->m_env_card_list[0]->simulate(delay);
                }
                ftime(&tb);
                // should really call this 50 times
                dae->onTrigger(tb.time, tb.millitm, 8);   // 8 is frame sync, 9 is run
                cs.unlock();
        }
}

template <class DAEPolicy>
int VMESimulation<DAEPolicy>::onTrigger(time_t the_secs, unsigned short the_ms, int trig_id)
{ 
        if (m_trigger_func != NULL)
        {
                return (*m_trigger_func)(m_trigger_func_arg, the_secs, the_ms, trig_id);
        }
        else
        {
                return ISISVME::Success;
        }
}

template <class DAEPolicy>
VMESimulation<DAEPolicy>::~VMESimulation()
{
        int i;
        m_shutdown_requested = true;
        Sleep(300);
        for(i=0; i<m_det_card_list.size(); i++)
        {
                delete m_det_card_list[i];
                m_det_card_list[i] = 0;
        }
        for(i=0; i<m_env_card_list.size(); i++)
        {
                delete m_env_card_list[i];
                m_env_card_list[i] = 0;
        }
        DeleteCriticalSection(&m_critical);
}

template <class DAEPolicy>
int VMESimulation<DAEPolicy>::incrementDetectorCardPeriod()
{
        int i;
        ICPCritical cs(&m_critical);
        for(i=0; i< m_det_card_list.size(); i++)
        {
                if (m_det_card_list[i]->type() == MySIMDAE2Card::DetCard)
                {
                        ((MySIMDetectorCard*)m_det_card_list[i])->incrementPeriod();
                }
        }
        return 0;
}

template <class DAEPolicy>
int VMESimulation<DAEPolicy>::resetDetectorCardPeriod()
{
        int i;
        ICPCritical cs(&m_critical);
        for(i=0; i< m_det_card_list.size(); i++)
        {
                if (m_det_card_list[i]->type() == MySIMDAE2Card::DetCard)
                {
                        ((MySIMDetectorCard*)m_det_card_list[i])->resetPeriod();
                }
        }
        return 0;
}


template <class DAEPolicy>
bool VMESimulation<DAEPolicy>::initOK()
{
        return true;
}

template <class DAEPolicy>
int VMESimulation<DAEPolicy>::open(const char* device, DAEstatus& status)
{
        status.addInfoVa(FAC_SIMDAE, "Simulation open %s", device);
        return ISISVME::Success;
}

template <class DAEPolicy>
int VMESimulation<DAEPolicy>::openBackplane(const char* device_bp, DAEstatus& status)
{
        status.addInfoVa(FAC_SIMDAE, "Simulation open backplane %s", device_bp);
        return ISISVME::Success;
}

template <class DAEPolicy>
int VMESimulation<DAEPolicy>::lockDevice(int timeout, DAEstatus& status)
{
        return ISISVME::Success;
}

template <class DAEPolicy>
int VMESimulation<DAEPolicy>::unlockDevice(DAEstatus& status)
{
        return ISISVME::Success;
}

template <class DAEPolicy>
int VMESimulation<DAEPolicy>::readU16(unsigned long address, isisU16_t* data16, TransferProps props, DAEstatus& status)
{
        return simulateRead(props, address, data16, 1, status);
}

template <class DAEPolicy>
int VMESimulation<DAEPolicy>::readU16noRetry(unsigned long address, isisU16_t* data16, TransferProps props, DAEstatus& status)
{
        return readU16(address, data16, props, status);
}

template <class DAEPolicy>
int VMESimulation<DAEPolicy>::readU32(unsigned long address, isisU32_t* data32, TransferProps props, DAEstatus& status)
{
    return simulateRead(props, address, data32, 1, status);
}

template <class DAEPolicy>
int VMESimulation<DAEPolicy>::readU32noRetry(unsigned long address, isisU32_t* data32, TransferProps props, DAEstatus& status)
{
    return readU32(address, data32, props, status);
}

// nove nitems of 2 bytes
template <class DAEPolicy>
int VMESimulation<DAEPolicy>::readBlockU16(unsigned long address, isisU16_t* data16, 
                                                 long nitems, TransferProps props, DAEstatus& status)
{
        return simulateRead(props, address, data16, nitems, status);
}
// nove nitems of 4 bytes
template <class DAEPolicy>
int VMESimulation<DAEPolicy>::readBlockU32(unsigned long address, isisU32_t* data32, long nitems, TransferProps props, DAEstatus& status)
{
        return simulateRead(props, address, data32, nitems, status);
}
template <class DAEPolicy>
int VMESimulation<DAEPolicy>::writeU16(unsigned long address, isisU16_t data16, TransferProps props, DAEstatus& status)
{
        return simulateWrite(props, address, &data16, 1, status);
}
template <class DAEPolicy>
int VMESimulation<DAEPolicy>::writeU32(unsigned long address, isisU32_t data32, TransferProps props, DAEstatus& status)
{
        return simulateWrite(props, address, &data32, 1, status);
}
// nove nitems of 2 bytes
template <class DAEPolicy>
int VMESimulation<DAEPolicy>::writeBlockU16(unsigned long address, isisU16_t* data16, long nitems, TransferProps props, DAEstatus& status)
{
        return simulateWrite(props, address, data16, nitems, status);
}
// nove nitems of 4 bytes
template <class DAEPolicy>
int VMESimulation<DAEPolicy>::writeBlockU32(unsigned long address, isisU32_t* data32, long nitems, TransferProps props, DAEstatus& status)
{
    return simulateWrite(props, address, data32, nitems, status);
}

template <class DAEPolicy>
int VMESimulation<DAEPolicy>::close(DAEstatus& status)
{
        status.addInfo(FAC_SIMDAE, "Simulate close");
        return ISISVME::Success;
}
template <class DAEPolicy>
int VMESimulation<DAEPolicy>::scanBus(DAEstatus& status)
{
        status.addInfo(FAC_SIMDAE, "Simulate scan bus");
        return 3;
}

template <class DAEPolicy>
bool VMESimulation<DAEPolicy>::resetBus(DAEstatus& status)
{       
        status.addInfo(FAC_SIMDAE, "Simulate reset bus");
        return true;
}

template <class DAEPolicy>
int VMESimulation<DAEPolicy>::simulateRead(TransferProps props, unsigned long address, isisU16_t* data16, long nitems, DAEstatus& status)
{
        int i, stat = ISISVME::Error;
        ICPCritical cs(&m_critical);
        for(i=0; (i<m_det_card_list.size()) && (stat == ISISVME::Error); i++)
        {
                stat = m_det_card_list[i]->read16(props, address, data16, nitems, status);
                if (stat == ISISVME::Success)
                {
                        m_det_card_list[i]->updateCardAfterRead(status);
                }
        }
        for(i=0; (i<m_env_card_list.size()) && (stat == ISISVME::Error); i++)
        {
                stat = m_env_card_list[i]->read16(props, address, data16, nitems, status);
                if (stat == ISISVME::Success)
                {
                        m_env_card_list[i]->updateCardAfterRead(status);
                }
        }
        if (stat == ISISVME::Error)
        {
                std::ostringstream message;
                message << "Simulation error (read16) at " << std::hex << address << std::dec << std::endl;
                status.add(FAC_SIMDAE, SEV_ERROR, ERRTYPE_INVCARD, message.str());
        }
        return stat;
}

template <class DAEPolicy>
int VMESimulation<DAEPolicy>::simulateWrite(TransferProps props, unsigned long address, isisU16_t* data16, long nitems, DAEstatus& status)
{
        int i, stat = ISISVME::Error;
        ICPCritical cs(&m_critical);
        for(i=0; (i<m_det_card_list.size()) && (stat == ISISVME::Error); i++)
        {
                stat = m_det_card_list[i]->write16(props, address, data16, nitems, status);
                if (stat == ISISVME::Success)
                {
                        m_det_card_list[i]->updateCardAfterWrite(status);
                }
        }
        for(i=0; (i<m_env_card_list.size()) && (stat == ISISVME::Error); i++)
        {
                stat = m_env_card_list[i]->write16(props, address, data16, nitems, status);
                if (stat == ISISVME::Success)
                {
                        m_env_card_list[i]->updateCardAfterWrite(status);
                }
        }
        if (stat == ISISVME::Error)
        {
                std::ostringstream message;
                message << "Simulation error (write16) at " << std::hex << address << std::dec << std::endl;
                status.add(FAC_SIMDAE, SEV_ERROR, ERRTYPE_INVCARD, message.str());
        }
        return stat;
}

bool VMESimulationIface::isVetoing()
{
        bool res = false;
        for(int i=0; i<m_sim_vme.size(); i++)
        {
                res |= m_sim_vme[i]->isCrateVetoing();
        }
        return res;
}

template <class DAEPolicy>
bool VMESimulation<DAEPolicy>::isCrateVetoing()
{
        bool res = false;
        for(int i=0; i<m_det_card_list.size(); i++)
        {
                res |= m_det_card_list[i]->isVetoing();
        }
        for(int i=0; i<m_env_card_list.size(); i++)
        {
                res |= m_env_card_list[i]->isVetoing();
        }
        return res;
}

bool VMESimulationIface::isRunning()
{
        bool res = true;
        for(int i=0; i<m_sim_vme.size(); i++)
        {
                res &= m_sim_vme[i]->isCrateRunning();
        }
        return res;
}

int VMESimulationIface::frameNumber()
{
        int res = -1;
        for(int i=0; i<m_sim_vme.size(); ++i)
        {
                if ( (res = m_sim_vme[i]->frameNumberImpl()) != -1 )
                {
                        break;
                }
        }
        return res;
}

template <class DAEPolicy>
int VMESimulation<DAEPolicy>::frameNumberImpl()
{
        int res = -1;
        for(int i=0; i<m_env_card_list.size(); i++)
        {
                if (m_env_card_list[i]->type() == MySIMDAE2Card::EnvCard)
                {
                        res = (dynamic_cast<MySIMEnvCard*>(m_env_card_list[i]))->frameNumber();
                }
                if (m_env_card_list[i]->type() == MySIMDAE2Card::EnvPeriodCard)
                {
                        res = (dynamic_cast<MySIMEnvPeriodCard*>(m_env_card_list[i]))->frameNumber();
                }
        }
        return res;
}

template <class DAEPolicy>
bool VMESimulation<DAEPolicy>::isCrateRunning()
{
        bool res = true;
        for(int i=0; i<m_env_card_list.size(); i++)
        {
                if (m_env_card_list[i]->type() == MySIMDAE2Card::EnvCard)
                {
                        res &= ((MySIMEnvCard*)m_env_card_list[i])->isRunning();
                }
                if (m_env_card_list[i]->type() == MySIMDAE2Card::EnvPeriodCard)
                {
                        res &= ((MySIMEnvPeriodCard*)m_env_card_list[i])->isRunning();
                }
        }
        return res;
}
        
template <class DAEPolicy>
int VMESimulation<DAEPolicy>::simulateRead(TransferProps props, unsigned long address, isisU32_t* data32, long nitems, DAEstatus& status)
{
        int i, stat = ISISVME::Error;
        ICPCritical cs(&m_critical);
        for(i=0; (i<m_det_card_list.size()) && (stat == ISISVME::Error); i++)
        {
                stat = m_det_card_list[i]->read32(props, address, data32, nitems, status);
                if (stat == ISISVME::Success)
                {
                        m_det_card_list[i]->updateCardAfterRead(status);
                }
        }
        for(i=0; (i<m_env_card_list.size()) && (stat == ISISVME::Error); i++)
        {
                stat = m_env_card_list[i]->read32(props, address, data32, nitems, status);
                if (stat == ISISVME::Success)
                {
                        m_env_card_list[i]->updateCardAfterRead(status);
                }
        }
        if (stat == ISISVME::Error)
        {
                std::ostringstream message;
                message << "Simulation error (read32) at " << std::hex << address << std::dec << std::endl;
                status.add(FAC_SIMDAE, SEV_ERROR, ERRTYPE_INVCARD, message.str());
        }
        return stat;
}

template <class DAEPolicy>
int VMESimulation<DAEPolicy>::simulateRead(TransferProps props, unsigned long address, uint64_t* data64, long nitems, DAEstatus& status)
{
        return simulateRead(props, address, reinterpret_cast<isisU32_t*>(data64), 2 * nitems, status);
}


template <class DAEPolicy>
int VMESimulation<DAEPolicy>::simulateWrite(TransferProps props, unsigned long address, isisU32_t* data32, long nitems, DAEstatus& status)
{
        int i, stat = ISISVME::Error;
        ICPCritical cs(&m_critical);
        for(i=0; (i<m_det_card_list.size()) && (stat == ISISVME::Error); i++)
        {
                stat = m_det_card_list[i]->write32(props, address, data32, nitems, status);
                if (stat == ISISVME::Success)
                {
                        m_det_card_list[i]->updateCardAfterWrite(status);
                }
        }
        for(i=0; (i<m_env_card_list.size()) && (stat == ISISVME::Error); i++)
        {
                stat = m_env_card_list[i]->write32(props, address, data32, nitems, status);
                if (stat == ISISVME::Success)
                {
                        m_env_card_list[i]->updateCardAfterWrite(status);
                }
        }
        if (stat == ISISVME::Error)
        {
                std::ostringstream message;
                message << "Simulation error (write32) at " << std::hex << address << std::dec << std::endl;
                status.add(FAC_SIMDAE, SEV_ERROR, ERRTYPE_INVCARD, message.str());
        }
        return stat;
}

template <class DAEPolicy>
int VMESimulation<DAEPolicy>::simulateWrite(TransferProps props, unsigned long address, uint64_t* data64, long nitems, DAEstatus& status)
{
        return simulateWrite(props, address, reinterpret_cast<isisU32_t*>(data64), 2 * nitems, status);
}

template <class DAEPolicy>
int VMESimulation<DAEPolicy>::writeBlock(unsigned long address, isisU32_t* data, long nitems, TransferProps props, DAEstatus& status)
{
        return simulateWrite(props, address, data, nitems, status);
}

template <class DAEPolicy>
int VMESimulation<DAEPolicy>::writeBlock(unsigned long address, uint64_t* data, long nitems, TransferProps props, DAEstatus& status)
{
        return simulateWrite(props, address, data, nitems, status);
}

template <class DAEPolicy>
int VMESimulation<DAEPolicy>::readBlock(unsigned long address, isisU32_t* data, long nitems, TransferProps props, DAEstatus& status)
{
        return simulateRead(props, address, data, nitems, status);
}

template <class DAEPolicy>
int VMESimulation<DAEPolicy>::readBlock(unsigned long address, uint64_t* data, long nitems, TransferProps props, DAEstatus& status)
{
        return simulateRead(props, address, data, nitems, status);
}

std::vector<VMESimulationIface*> VMESimulationIface::m_sim_vme;

template class VMESimulation<DAE2Policy>;
template class VMESimulation<DAE3Policy>;