env_period_card.cpp

Go to the documentation of this file.

#include "stdafx.h"
#include "DAEstatus.h"
#include "icputils.h"
#include "isisvme.h"
#include "env_period_card.h"
#include "dae_events.h"


// period card

template <class EnvPeriodPolicy>
EnvPeriodCard<EnvPeriodPolicy>::EnvPeriodCard(int position, ISISVME* vme, DAEstatus& status) : DAE2Card(position, vme, status), m_options(0)
{
        setLoggerName("EnvPeriodCard");
        std::ostringstream message;
        updateOptions(status);
        printStatus(message, status);
        status.addInfo(FAC_ENVCARD, message.str());
        if (checkOptions(NoCheckSRAM))
        {
                LOGSTR_WARNING("SRAM memory checking is currently DISABLED");
        }
        if (checkOptions(EventModeTimer))
        {
                LOGSTR_INFORMATION("Event mode timer");
        }
}

struct period_modes
{
        int bit;
        const char* unset;
        const char* set;
};

// list of bit number, unset meaning, set meaning
static const period_modes mode_list[] = {
        {15, "", "Reset Period card" },
        {13, "", "Clear Period Counters" },
        {11, "", "Muon MS Mode" },
//      {10, "Extract Trigger Veto Disabled", "Extract Trigger Veto Enabled" },
//      {9, "50Hz Veto Disabled", "50Hz Veto Enabled" },
//      {8, "Internal Period Clock Mode", "External Period Clock Mode" },
        {7, "", "Multiple Period sequence complete" },
        {6, "Single period sequence mode", "Multiple period sequence mode" },
        {5, "Internal period control mode", "External period control mode" },
        {4, "Non-period mode", "Period mode"},
        {3, "", "Run ended AND period sequence completed" },
        {2, "", "Period sequence complete" },
        {1, "", "End after period sequence complete has been requested" },
};

template <class EnvPeriodPolicy>
void EnvPeriodCard<EnvPeriodPolicy>::printStatus(std::ostream& os, DAEstatus& status)
{
        // period card
        DAE2Card::printStatus(os, status);
        isisU32_t value, value1;
        isisU32_t value32;
        isisU16_t value16;
        int i, nper;
        os << "This is a " << EnvPeriodPolicy::card_type << " combined ENVIRONMENT and PERIOD card" << std::endl;
        readRegister(ALT1SFV, &value32, status);
        value32 &= 0xff; // only 8 bits used, split 4/4 
        os << "ALT1 firmware version = " << (value32 >> 4) << "." << (value32 & 0x0f) << std::endl;
        os << "Current period number = " << getCurrentPeriodNumber(status) << (inDwellPeriod(status) ? " (DWELL)" : " (DAQ)") << std::endl;
        nper = getNumberOfPeriods(status);
        os << "Number of periods = " << nper << std::endl;
        readRegister(PSCNT, &value32, status);
        os << "Period sequence number = " << value32 << std::endl;
//      readRegister(PSLR, &value16, status);
//      os << "Period sequence limit register = " << value16 << std::endl;
//      getExtractTriggerVetoCount(&value32, status);
//      os << "Extract trigger veto count = " << value32 << std::endl;
        readRegister(PCREG, &value16, status);
//      readRegister(PCREG, &value32, status);
//      value16 = (isisU16_t)value32;
        os << "Summary of period control register, value = 0x" << std::hex << value16 << std::dec << std::endl;
        for(i=0; i<sizeof(mode_list)/sizeof(period_modes); i++)
        {
                if (value16 & (1 << mode_list[i].bit))
                {
                        os << "Bit " << mode_list[i].bit << " is SET (" <<  mode_list[i].set << ")" << std::endl;
                }
                else
                {
                        os << "Bit " << mode_list[i].bit << " is CLEAR (" <<  mode_list[i].unset << ")" << std::endl;
                }
        }
        // nper may be 0 from an uninitialised card
        if (nper < 1)
        {
                nper = 1;
        }
        isisU16_t* frames_needed = new isisU16_t[nper];
        isisU32_t* good_frames = new isisU32_t[nper];
        isisU32_t* raw_frames = new isisU32_t[nper];
        isisU16_t* dwell_flags = new isisU16_t[nper];
        isisU32_t* outputs = new isisU32_t[nper];
        readPERLUT(dwell_flags, frames_needed, nper, status);
        readOUTLUT(outputs, nper, status);
        getRawFrames(0, nper, raw_frames, status);
        getGoodFrames(0, nper, good_frames, status);
        os << "Summary of period card programming (1st 16 max)" << std::endl;
        for(i=0; i< (nper < 16 ? nper : 16); i++)
        {
                os << "Period " << i << (dwell_flags[i] != 0 ? " (DWELL)" : " (DAQ)") << std::endl; 
                os << "\tRequested frames = " << frames_needed[i] << " logic signal output = 0x" << std::hex << outputs[i] << std::dec << std::endl;
                os << "\tCurrent counters (should always be ZERO for DWELL): raw = " << raw_frames[i] << " good = " << good_frames[i] << std::endl;
        }
        delete[] frames_needed;
        delete[] good_frames;
        delete[] raw_frames;
        delete[] outputs;
        delete[] dwell_flags;
        readRegister(RCONTROL, &value, status);
        os << "RC register value = " << std::hex << "0x" << value << std::dec << std::endl;
    os << "Status: " << (value &  RCSTART ? "Running" : "Stopped") << std::endl;
        os << "Event mode: " << (value &  RCEVENTMODE ? "Enabled" : "Disabled") << std::endl;
        os << "Frame Sync: ";
        switch(value & RCFSSEL)
        {
                case 0:
                        os << "Internal";
                        break;
                case RCFSSMP:
                        os << "SMP";
                        break;
                case RCFSTOF:
                        os << "ISIS TOF";
                        break;
                case RCFSTOF1P:
                        os << "ISIS TOF (1st pulse)";
                        break;
                case RCFSMUONCK:
                        os << "Muon Cerenkov";
                        if (value & RCFSSCH2)
                        {
                                os << " (2nd pulse)"; 
                        }
                        else
                        {
                                os << " (1st pulse)"; 
                        }
                        break;
                case RCFSMUONMS:
                        os << "Muon MS mode";
                        break;

                default:
                        os << "Error";
                        break;
        }
        os << std::endl;
        getFrameSyncDelay(&value1, status);
        os << "Frame sync delay: " << value1 << "\n";
        printVetoDetails(os, status);

        getGoodFrames(&value1, status);
        getRawFrames(&value, status);
        os << "GOOD/RAW frames: " << value1 << "/" << value << "\n";
        os << "GOOD/TOTAL uamph: " << getGoodUAmpHours(status) << "/" << getGoodUAmpHours(status) << "\n";
        os << "Period Type: " << (usingHardwarePeriods(status) ? "Hardware" : "Software") << "\n";
        if (checkOptions(RotateFrameCountersRight))
        {
                os << "Single frame workaround enabled\n";
        }
        os << "Current DAE frame time drift (icp - dae) = " << frameTimerDrift(status) / 1000.0 << " ms\n";
        if (checkOptions(NoCheckSRAM))
        {
                os << "WARNING: SRAM memory checking is DISABLED\n";
        }
        // print period type
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::printVetoDetails(std::ostream& os, DAEstatus& status)
{
        int i;
        isisU32_t veto_reg, frames;
        readRegister(RVETO, &veto_reg, status);
        for(i=0; veto_details[i].name != NULL; i++)
        {
                readRegister(veto_details[i].counter_addr, &frames, status);
                os << veto_details[i].name << " is " << ((veto_reg & veto_details[i].mask) != 0 ? "ENABLED (vetoed " : "DISABLED (counted ") << frames << ") frames\n";
        }
        return DAEstatus::Success;
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::enableDelayedStart(DAEstatus& status)
{
    return clearRunControlBits(RCPERSZEQZERO, status); 
} 
    
template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::disableDelayedStart(DAEstatus& status)
{ 
    return setRunControlBits(RCPERSZEQZERO, true, status); 
} 

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::whichVeto(std::ostream& os, DAEstatus& status)
{
        static time_t last_call;
        static isisU32_t vframes1[100], rf1;
        int i;
        isisU32_t veto_reg, rf2, vframes2[100], poll_time;
        double rfdiff;
        int nveto;
        for(nveto = 0; veto_details[nveto].name != NULL; ++nveto)
                ;
        readRegister(RVETO, &veto_reg, status);
        for(i=0; i < nveto; i++)
        {
                readRegister(veto_details[i].counter_addr, &(vframes2[i]), status);
        }
        getRawFrames(&rf2, status);
        rfdiff = rf2 - rf1;
        rf1 = rf2;  // save value
        if (rfdiff <= 0)
        {
                rfdiff = 1;             // stop division by zero error if ISIS not running
                rf2 = 1;
        }
        poll_time = time(NULL) - last_call;
        time(&last_call);
        for(i=0; i < nveto; i++)
        {
                if ((veto_reg & veto_details[i].mask) != 0)  
                {
                        os << veto_details[i].name << " vetoed " << 
                                (int)(100.0 * (vframes2[i] - vframes1[i]) / rfdiff) << 
                                "% (last " << poll_time << " seconds), " <<
                                (int)(100.0 * vframes2[i] / rf2) <<  
                                "% (since run start)\n";
                }
                vframes1[i] = vframes2[i];
        }
        return DAEstatus::Success;
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::setPeriodControlBits(isisU32_t mask, bool preserve, DAEstatus& status)
{
    return setRegisterBits(PCREG, mask, preserve, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::clearPeriodControlBits(isisU32_t mask, DAEstatus& status)
{
        return clearRegisterBits(PCREG, mask, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::setAndClearPeriodControlBits(isisU32_t mask, bool preserve, DAEstatus& status)
{
        return setAndClearRegisterBits(PCREG, mask, preserve, status);
}

//int EnvPeriodCard<EnvPeriodPolicy>::clearVetoCounters(DAEstatus& status) 
//{ 
//      return setAndClearPeriodControlBits(PCCLRVETO, true, status); 
//}

//int EnvPeriodCard<EnvPeriodPolicy>::getExtractTriggerVetoCountLow(isisU16_t* value, DAEstatus& status) 
//{ 
//      return readRegister(EXTTRIGVC0, value, status); 
//}

//int EnvPeriodCard<EnvPeriodPolicy>::getExtractTriggerVetoCountHigh(isisU16_t* value, DAEstatus& status)
//{ 
//      return readRegister(EXTTRIGVC1, value, status); 
//}

//int EnvPeriodCard<EnvPeriodPolicy>::getExtractTriggerVetoCount(isisU32_t* value, DAEstatus& status)
//{
//      return readRegister16As32(EXTTRIGVC0, EXTTRIGVC1, value, status);
//}

//int EnvPeriodCard<EnvPeriodPolicy>::enableExtractTriggerVeto(DAEstatus& status) 
//{ 
//      return setPeriodControlBits(PCEXTTRIG, true, status); 
//}

//int EnvPeriodCard<EnvPeriodPolicy>::disableExtractTriggerVeto(DAEstatus& status) 
//{ 
//      return clearPeriodControlBits(PCEXTTRIG, status); 
//}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::lookupAccessOUTLUT(DAEstatus& status)
{
        return writeRegister16(LOOKTAR, TAROUTLUT, status); 
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::lookupAccessPERLUT(DAEstatus& status) 
{ 
        return writeRegister16(LOOKTAR, TARPERLUT, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::lookupFinished(DAEstatus& status)
{ 
        return writeRegister16(LOOKTAR, 0, status); 
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getCurrentPeriodNumber(DAEstatus& status)
{
        isisU16_t period;
        int stat = readRegister(MPCNT, &period, status);
        period &= 0x3fff;
        return period;
}

template <class EnvPeriodPolicy>
bool EnvPeriodCard<EnvPeriodPolicy>::inDwellPeriod(DAEstatus& status)
{
        isisU16_t period;
        readRegister(MPCNT, &period, status);
        return ((period & (1 << 14)) != 0);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::setNumberOfPeriods(isisU16_t n, DAEstatus& status)
{
        return writeRegister16(MPLIM, n, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getNumberOfPeriods(DAEstatus& status)
{
        isisU16_t n;
        readRegister(MPLIM, &n, status);
        if (n >= MAX_NUM_PERIODS)
        {
                return MAX_NUM_PERIODS;
        }
        else if (n <= 0)
        {
                return 1;
        }
        else
        {
                return n; // as this is a period number limit register
        }
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getCurrentPeriodSequence(DAEstatus& status)
{
        isisU32_t n;
        readRegister(PSCNT, &n, status);
        return n;
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::resetPeriodCard(DAEstatus& status)
{
        return setAndClearPeriodControlBits(PCRESET, true, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::clearPeriodCounters(DAEstatus& status)
{
//      setAndClearRegisterBits(MAT_1, (1 << 12), true, status);
        return setAndClearPeriodControlBits(PCCLRPC, true, status);
}

//int EnvPeriodCard<EnvPeriodPolicy>::enable50HzVeto(DAEstatus& status)
//{
//      return setPeriodControlBits(PC50HZENAB, true, status);
//}

//int EnvPeriodCard<EnvPeriodPolicy>::disable50HzVeto(DAEstatus& status)
//{
//      return clearPeriodControlBits(PC50HZENAB, status);
//}

//int EnvPeriodCard<EnvPeriodPolicy>::setInternalPeriodClockMode(DAEstatus& status)
//{
//      return clearPeriodControlBits(PCEXTPERCLK, status);
//}

//int EnvPeriodCard<EnvPeriodPolicy>::setExternalPeriodClockMode(DAEstatus& status)
//{
//      return setPeriodControlBits(PCEXTPERCLK, true, status);
//}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::setSinglePeriodSequenceMode(DAEstatus& status)
{
        return clearPeriodControlBits(PCMULENAB, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::setMultiplePeriodSequenceMode(int nseq, DAEstatus& status)
{
        writeRegister(PSLR, nseq, status);
        return setPeriodControlBits(PCMULENAB, true, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::enablePeriodMode(bool external_mode, DAEstatus& status)
{
        if (external_mode)
        {
                return setPeriodControlBits(PCENAB | PCEXTENAB, true, status);
        }
        else
        {
                clearPeriodControlBits(PCEXTENAB, status);
                return setPeriodControlBits(PCENAB, true, status);
        }
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::disablePeriodMode(DAEstatus& status)
{
        return clearPeriodControlBits(PCENAB, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::enableMSMode(DAEstatus& status)
{
        setOptions(MSMode);
        return setPeriodControlBits(PCMSM, true, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::disableMSMode(DAEstatus& status)
{
        clearOptions(MSMode);
        return clearPeriodControlBits(PCMSM, status);
}


template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::endRunAfterSequenceCompletes(DAEstatus& status)
{
        return setPeriodControlBits(PCENDAFTER, true, status);
}

template <class EnvPeriodPolicy>
bool EnvPeriodCard<EnvPeriodPolicy>::isRunEndedAndSequenceComplete(DAEstatus& status)
{
        isisU32_t value;
        readRegister(PCREG, &value, status);
        if (value & PCENDSEQCOMP)
        {
                clearPeriodControlBits(PCENDAFTER, status);
                return true;
        }
        else
        {
                return false;
        }
}

template <class EnvPeriodPolicy>
bool EnvPeriodCard<EnvPeriodPolicy>::isEndRunAfterSequenceCompletesInProgress(DAEstatus& status)
{
        isisU32_t value;
        readRegister(PCREG, &value, status);
        if ( ((value & PCENDSEQCOMP) == 0) && ((value & PCENDAFTER) != 0) )
        {
                return true;
        }
        else
        {
                return false;
        }
}

template <class EnvPeriodPolicy>
bool EnvPeriodCard<EnvPeriodPolicy>::isMultipleSequenceComplete(DAEstatus& status)
{
        if (registerBitsSet(PCREG, (PCENAB | PCMULENAB | PCMULCOMP), status))
        {
                return true;
        }
        else
        {
                return false;
        }
}

template <class EnvPeriodPolicy>
void EnvPeriodCard<EnvPeriodPolicy>::abortSequenceCompleteWait(DAEstatus& status)
{
        clearPeriodControlBits(PCENDAFTER, status);
}

// dwell_flag is 0 for DAQ period, 1 for DWELL period
template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::programPERLUT(isisU16_t* dwell_flags, isisU16_t* frames, int nperiod, DAEstatus& status)
{
        int i;
        ISISVME::TransferProps props = ISISVME::TransferLUTSpace;
        isisU32_t* pdata = new isisU32_t[nperiod];
        bool single_frames_only = true;
        for(i=0; i<nperiod; i++)
        {
                if (frames[i] != 1)
                {
                        single_frames_only = false;
                }
                pdata[i] = ((frames[i]) & 0xffff) + (dwell_flags[i] != 0 ? (1 << 31) : 0);
        }
        // disable workaround
        single_frames_only = false;
        if (single_frames_only && checkOptions(MSMode))
        {
                setOptions(RotateFrameCountersRight);
        }
        else
        {
                clearOptions(RotateFrameCountersRight);
        }
        lookupAccessPERLUT(status);
        zeroMemory<isisU32_t>(PERLUTSTART, PERLUTSIZE, 0xffffffff, props, status);
        writeMemory(PERLUTSTART, pdata, nperiod, 0xffffffff, props, status);
        lookupFinished(status);
        delete []pdata;
        return 0;
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::readPERLUT(isisU16_t* dwell_flags, isisU16_t* frames, int nperiod, DAEstatus& status)
{
        int i;
        ISISVME::TransferProps props = ISISVME::TransferLUTSpace;
        isisU32_t* pdata = new isisU32_t[nperiod];
        lookupAccessPERLUT(status);
        readMemory(PERLUTSTART, pdata, nperiod, props, status);
        lookupFinished(status);
        for(i=0; i<nperiod; i++)
        {
                frames[i] = (isisU16_t)(pdata[i] & 0xffff); // remove dwell flag
                dwell_flags[i] = ( (pdata[i] & (1 << 31)) ? 1 : 0 );
        }
        delete []pdata;
        return 0;
}

// may also need to duplicate up last value in location n+1
// in case counter in DAE increemnts too far briefly before reset
template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::programOUTLUT(isisU32_t* outputs, int nperiod, DAEstatus& status)
{
        lookupAccessOUTLUT(status);
        ISISVME::TransferProps props = ISISVME::TransferLUTSpace;
        zeroMemory<isisU32_t>(OUTLUTSTART, OUTLUTSIZE, OUTLUTMASK, props, status);
        writeMemory(OUTLUTSTART, outputs, nperiod, OUTLUTMASK, props, status);
// also write last output value to n+1 location; this is a workaround to catch the small
// amout of time that it might get read between a period increment and a period reset
//      tmp32 = outputs[nperiod-1];  // write last value again
//      writeMemory(OUTLUTSTART + 4*nperiod, &tmp32, 1, 0xffffffff, false, false, status);
        lookupFinished(status);
        return 0;
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::readOUTLUT(isisU32_t* outputs, int nperiod, DAEstatus& status)
{
        int i;
        ISISVME::TransferProps props = ISISVME::TransferLUTSpace;
        lookupAccessOUTLUT(status);
// we seem to need to start the outlut at address+1
        readMemory(OUTLUTSTART, outputs, nperiod, props, status);
        lookupFinished(status);
        for(i=0; i<nperiod; i++)
        {
                outputs[i] &= OUTLUTMASK; // remove junk from top bits if required
        }
        return 0;
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::zeroPeriodFrameCounters(DAEstatus& status)
{
        ISISVME::TransferProps props = ISISVME::TransferLUTSpace;
        uint32_t check_mask0 = (checkOptions(NoCheckSRAM) ? 0x0 : 0xffffffff);
        zeroMemory<isisU32_t>(RFCNT0START, RFCNT0SIZE, check_mask0, props, status);
        zeroMemory<isisU32_t>(GFCNT0START, GFCNT0SIZE, check_mask0, props, status);
        return 0;
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::zeroPeriodProtonCounters(DAEstatus& status)
{
        ISISVME::TransferProps props = ISISVME::TransferLUTSpace;
        EnvPeriodPolicy::ppp_memory_t check_mask0 = ( checkOptions(NoCheckSRAM) ? 0x0 : ~(static_cast<EnvPeriodPolicy::ppp_memory_t>(0)) );
        uint32_t check_mask1 = (checkOptions(NoCheckSRAM) ? 0x0 : 0x0000ffff);
        zeroMemory<EnvPeriodPolicy::ppp_memory_t>(RPCNT0START, RPCNT0SIZE, check_mask0, props, status);
        zeroMemory<EnvPeriodPolicy::ppp_memory_t>(GPCNT0START, GPCNT0SIZE, check_mask0, props, status);
#if 0
        if (RPCNT1START != RPCNT0START && RPCNT1SIZE > 0)
        {
                zeroMemory(RPCNT1START, RPCNT1SIZE, check_mask1, false, false, status);   // only 16 bits used
                zeroMemory(GPCNT1START, GPCNT1SIZE, check_mask1, false, false, status);   // only 16 bits used
        }
#endif
        return 0;
}

// spare SRAM counters
template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::zeroPeriodExtraCounters(DAEstatus& status)
{
        ISISVME::TransferProps props = ISISVME::TransferLUTSpace;
        uint32_t check_mask0 = (checkOptions(NoCheckSRAM) ? 0x0 : 0xffffffff);
        uint32_t check_mask1 = (checkOptions(NoCheckSRAM) ? 0x0 : 0x0000ffff);
        if (SPARE0SIZE > 0)
        {
                zeroMemory<isisU32_t>(SPARE0START, SPARE0SIZE, check_mask0, props, status); 
        }
        if (SPARE1SIZE > 0)
        {
                zeroMemory<isisU32_t>(SPARE1START, SPARE1SIZE, check_mask1, props, status); // only 16 bits used
        }
        return 0;
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getPeriodRawFrames(int period, isisU32_t* frames, DAEstatus& status)
{
        return getRawFrames(period, 1, frames, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getPeriodGoodFrames(int period, isisU32_t* frames, DAEstatus& status)
{
        return getGoodFrames(period, 1, frames, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getPeriodRequestedFrames(int period, isisU32_t* frames, DAEstatus& status)
{
        return getRequestedFrames(period, 1, frames, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getRequestedFrames(int period_start, int nperiod, isisU32_t frames[], DAEstatus& status)
{
        int i;
        ISISVME::TransferProps props = ISISVME::TransferLUTSpace;
        lookupAccessPERLUT(status);
        readMemory(PERLUTSTART+4*period_start, frames, nperiod, props, status);
        lookupFinished(status);
        for(i=0; i<nperiod; i++)
        {
                frames[i] = (frames[i] & 0xffff);  // remove dwell flag
        }
        return 0;
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getRawFrames(int period_start, int nperiod, isisU32_t frames[], DAEstatus& status)
{
        int i, n;
        ISISVME::TransferProps props = ISISVME::TransferLUTSpace;
//      int seq = getCurrentPeriodSequence(status);
//  isisU32_t* req_frames = new isisU32_t[nperiod];
//      getRequestedFrames(period_start, nperiod, req_frames, status);
        if (!checkOptions(RotateFrameCountersRight))
        {
                readMemory(RFCNT0START + 4*period_start, frames, nperiod, props, status);
                return status.result();
        }
// rotate counters
// sram  0 1 2 3
// nexus 1 2 3 0
        n = getNumberOfPeriods(status);
        isisU32_t* tmp_f = new isisU32_t[n];
        readMemory(RFCNT0START, tmp_f, n, props, status);
        for(i = 0; i < nperiod; i++)
        {
                frames[i] = tmp_f[(i + period_start + 1) % n];
        }
        delete[] tmp_f;

// not needed now
//      for(i=0; i<nperiod; i++)
//      {
//              frames[i] += (seq * req_frames[i]);
//      }
//      delete[] req_frames;
        return status.result();
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getGoodFrames(int period_start, int nperiod, isisU32_t frames[], DAEstatus& status)
{
        int i, j, n;
        ISISVME::TransferProps props = ISISVME::TransferLUTSpace;
//      int seq = getCurrentPeriodSequence(status);
//    isisU32_t* req_frames = new isisU32_t[nperiod];
//      getRequestedFrames(period_start, nperiod, req_frames, status);
        if (!checkOptions(RotateFrameCountersRight))
        {
// orig
//              readMemory(GFCNT0START + 4*period_start, frames, nperiod, false, false, status);

                // workaround for Matt
                // the good frames register for a dwell period should have 1 frame per sequence in it
                // if it has more than this then it has stolen them from the previos DAQ period and this
                // needs to be allowed for.
                n = getNumberOfPeriods(status);
                isisU32_t* tmp_f = new isisU32_t[n];
                readMemory(GFCNT0START, tmp_f, n, props, status);
                isisU16_t* dwell_flags = new isisU16_t[n];
                isisU16_t* frames_requested = new isisU16_t[n];
                int seq = getCurrentPeriodSequence(status);
                readPERLUT(dwell_flags, frames_requested, n, status);
                for(i=0; i<n; i++)
                {
                        j = (i + 1) % n;
                        if ( (dwell_flags[i] == 0) && (dwell_flags[j] != 0) && (tmp_f[j] > seq) )
                        {
                                tmp_f[i] = tmp_f[i] + (tmp_f[j] - seq);
                        }
                }
                for(i=0; i<nperiod; i++)
                {
                        frames[i] = tmp_f[i+period_start];
                }
                delete[] dwell_flags;
                delete[] frames_requested;
                delete[] tmp_f;
                return status.result();
        }
// rotate counters
// sram  0 1 2 3
// nexus 1 2 3 0
        n = getNumberOfPeriods(status);
        isisU32_t* tmp_f = new isisU32_t[n];
        readMemory(GFCNT0START, tmp_f, n, props, status);
        for(i = 0; i < nperiod; i++)
        {
                frames[i] = tmp_f[(i + period_start + 1) % n];
        }
        delete[] tmp_f;
// not needed now
//      for(i=0; i<nperiod; i++)
//      {
//              frames[i] += (seq * req_frames[i]);
//      }
//      delete[] req_frames;
        return status.result();
}

// in microseconds
template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::setPeriodOutputDelay(isisU32_t delay, DAEstatus& status)
{
        if ((delay >> 18) != 0)
        {
                status.add(FAC_ENVCARD, SEV_ERROR, ERRTYPE_INVCARD, "Period output delay too big (> 18 bits wide)");
        }
        return writeRegister(PEROUTDEL, delay, status); 
}

//int EnvPeriodCard<EnvPeriodPolicy>::startDataCollection(DAEstatus& status)
//{
//      return setRegisterBits(MAT_1, (1 << 4), true, status);
//}
        
//int EnvPeriodCard<EnvPeriodPolicy>::stopDataCollection(DAEstatus& status)
//{
//      return clearRegisterBits(MAT_1, (1 << 4), status);
//}



// environment card

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::setVetoRegisterBits(isisU32_t mask, bool preserve, DAEstatus& status)
{
    return setRegisterBits(RVETO, mask, preserve, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::clearVetoRegisterBits(isisU32_t mask, DAEstatus& status)
{
        return clearRegisterBits(RVETO, mask, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::setRunControlBits(isisU32_t mask, bool preserve, DAEstatus& status)
{
    return setRegisterBits(RCONTROL, mask, preserve, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::clearRunControlBits(isisU32_t mask, DAEstatus& status)
{
        return clearRegisterBits(RCONTROL, mask, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::setAndClearRunControlBits(isisU32_t mask, bool preserve, DAEstatus& status)
{
        return setAndClearRegisterBits(RCONTROL, mask, preserve, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::startRun(DAEstatus& status)
{
        resetRunController(status);
        syncFrameTimer(status);
        return setRunControlBits(RCSTART, true, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::stopRun(DAEstatus& status)
{
    clearRunControlBits(RCSTART, status);
    return resetRunController(status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::ClearFramesAndPPP(DAEstatus& status)
{
//      clearSMPVetoedFrames(status);
//      clearExternalVetoedFrames(status);
//      clearFIFOVetoedFrames(status);
    return setAndClearRegisterBits(RCONTROL, RCFCLEAR | RCPCLEAR, true, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::clearPPP(DAEstatus& status)
{
    return setAndClearRegisterBits(RCONTROL, RCPCLEAR, true, status);
}

template <class EnvPeriodPolicy>
FrameSync EnvPeriodCard<EnvPeriodPolicy>::getFrameSync(DAEstatus& status)
{
        isisU32_t value = 0;
        readRegister(RCONTROL, &value, status);
        switch(value & RCFSSEL)
        {
                case 0:
                        return FrameSyncInternalTest;
                        break;
                case RCFSSMP:
                        return FrameSyncSMP;
                        break;
                case RCFSTOF:
                        return FrameSyncISIS;
                        break;
                case RCFSTOF1P:
                        return FrameSyncISISFirstTS1Pulse;
                        break;
                case RCFSMUONCK:
                        return FrameSyncMuonCerenkov;
                        break;
                case RCFSMUONMS:
                        return FrameSyncMuonMS;
                        break;
                default:
                        break;
        }
        status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Invalid frame sync type %d\n", value & RCFSSEL);
        return FrameSyncInternalTest;
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::setFrameSync(FrameSync fs, DAEstatus& status)
{
        int stat = clearRunControlBits(RCFSSEL, status); // clear all FS bits first (sets to test clock)
        disableMSMode(status);
        switch(fs)
        {
                case FrameSyncInternalTest:
                        return stat;
                        break;

                case FrameSyncISIS:
                        return setRunControlBits(RCFSTOF, true, status);
                        break;

                case FrameSyncISISFirstTS1Pulse:
                        return setRunControlBits(RCFSTOF1P, true, status);
                        break;

                case FrameSyncSMP:
                        return setRunControlBits(RCFSSMP, true, status);
                        break;

                case FrameSyncMuonCerenkov:
                        return setRunControlBits(RCFSMUONCK, true, status);
                        break;

                case FrameSyncMuonMS:
                        enableMSMode(status);
                        return setRunControlBits(RCFSMUONMS, true, status);
                        break;

                default:
                        break;
        }
        status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Invalid frame sync type %d\n", fs);
        return DAEstatus::Failure;
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::setMuonPulse(int pulse, DAEstatus& status)
{
        if (pulse == 0) // first
        {
                return clearRunControlBits(RCFSSCH2, status);
        } 
        else if (pulse == 1) // second
        {
                return setRunControlBits(RCFSSCH2, true, status);
        }
        else
        {
                status.addWarningVa(FAC_DAE, "Invalid muon pulse number %d\n", pulse);
                return DAEstatus::Failure;
        }
}

template <class EnvPeriodPolicy>
bool EnvPeriodCard<EnvPeriodPolicy>::isRunning(DAEstatus& status)
{
        isisU32_t value;
    readRegister(RCONTROL, &value, status);
        if (value & RCSTART)
        {
                return true;
        }
        else
        {
                return false;
        }
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getRawFrames(isisU32_t* value, DAEstatus& status)
{
    return readRegister(FCOUNTR, value, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getGoodFrames(isisU32_t* value, DAEstatus& status)
{
// if in muon MSM
        if (checkOptions(MSMode))
        {
                return readRegister(SCHPULSE, value, status);
        }
        else
        {
                return readRegister(FCOUNTG, value, status);
        }
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getRawPPPLower(isisU32_t* value, DAEstatus& status)
{
    readRegister(PCOUNTR0, value, status);
        return 0;
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getRawPPPUpper(isisU32_t* value, DAEstatus& status)
{
    readRegister(PCOUNTR1, value, status);
        return 0;
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getRawPPP(isisU64_t* value, DAEstatus& status)
{
        isisU32_t value0 = 0, value1 = 0;
        readRegister(PCOUNTR0, &value0, status);
        readRegister(PCOUNTR1, &value1, status);
        *value = (isisU64_t)value0 | ((isisU64_t)value1 << 32);
        return 0;
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getGoodPPPLower(isisU32_t* value, DAEstatus& status)
{
    readRegister(PCOUNTG0, value, status);
        return 0;
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getGoodPPPUpper(isisU32_t* value, DAEstatus& status)
{
    readRegister(PCOUNTG1, value, status);
        return 0;
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getGoodPPP(isisU64_t* value, DAEstatus& status)
{
        isisU32_t value0 = 0, value1 = 0;
        readRegister(PCOUNTG0, &value0, status);
        readRegister(PCOUNTG1, &value1, status);
        *value = (isisU64_t)value0 | ((isisU64_t)value1 << 32);
        return 0;
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::resetRunController(DAEstatus& status)
{
    return setAndClearRunControlBits(RCRESET, true, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::enableSMPVeto(DAEstatus& status)
{
    return setVetoRegisterBits(RVSMP, true, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::enableExternalVeto(int veto_number, DAEstatus& status)
{
        switch(veto_number)
        {
                case 0:
                        return setVetoRegisterBits(RVEXT0, true, status);
                        break;
                case 1:
                        return setVetoRegisterBits(RVEXT1, true, status);
                        break;
                case 2:
                        return setVetoRegisterBits(RVEXT2, true, status);
                        break;
                case 3:
                        return setVetoRegisterBits(RVEXT3, true, status);
                        break;
                default:
                        status.addWarningVa(FAC_DAE, "Attempting to enable invalid veto number %d", veto_number);
                        break;
        }
        return DAEstatus::Success;
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::enableInternalVeto(DAEstatus& status)
{
    return setVetoRegisterBits(RVINT, true, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::enableFIFOVeto(DAEstatus& status)
{
    return setVetoRegisterBits(RVFIFO, true, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::enableFermiChopperVeto(int chopper_number, int delay, int width, DAEstatus& status)
{
        return enableFChopperVeto(chopper_number, delay, width, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::enableTS2PulseVeto(DAEstatus& status)
{
    return setVetoRegisterBits(RVTS2P, true, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::enableISIS50HzVeto(DAEstatus& status)
{
    return setVetoRegisterBits(RVHZ50, true, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::disableSMPVeto(DAEstatus& status)
{
    return clearVetoRegisterBits(RVSMP, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::disableExternalVeto(int veto_number, DAEstatus& status)
{
        switch(veto_number)
        {
                case 0:
                        return clearVetoRegisterBits(RVEXT0, status);
                        break;
                case 1:
                        return clearVetoRegisterBits(RVEXT1, status);
                        break;
                case 2:
                        return clearVetoRegisterBits(RVEXT2, status);
                        break;
                case 3:
                        return clearVetoRegisterBits(RVEXT3, status);
                        break;
                default:
                        status.addWarningVa(FAC_DAE, "Attempting to disable invalid veto number %d", veto_number);
                        break;
        }
        return DAEstatus::Success;
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::disableInternalVeto(DAEstatus& status)
{
    return clearVetoRegisterBits(RVINT, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::disableFIFOVeto(DAEstatus& status)
{
    return clearVetoRegisterBits(RVFIFO, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::disableFermiChopperVeto(int chopper_number, DAEstatus& status)
{
        return processFermiChopperVeto(chopper_number, boost::bind(&EnvPeriodCard<EnvPeriodPolicy>::clearVetoRegisterBits, this, _1, _2), status);
}

//int EnvPeriodCard<EnvPeriodPolicy>::processFermiChopperVeto(int chopper_number, int (EnvPeriodCard<EnvPeriodPolicy>::*func)(isisU32_t, DAEstatus&), DAEstatus& status)
template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::processFermiChopperVeto(int chopper_number, boost::function<int(isisU32_t, DAEstatus&)> func, DAEstatus& status)
{
        static const isisU32_t mapping[] = { RVFCHOP0, RVFCHOP1, RVFCHOP2, RVFCHOP3 };
        if ( chopper_number >= 0 && chopper_number < array_length(mapping) )
        {
                return func(mapping[chopper_number], status);
        }
        else
        {
                status.addWarningVa(FAC_DAE, "Attempting to process invalid fermi chopper number %d", chopper_number);
        }
        return DAEstatus::Success;
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::disableTS2PulseVeto(DAEstatus& status)
{
    return clearVetoRegisterBits(RVTS2P, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::disableISIS50HzVeto(DAEstatus& status)
{
    return clearVetoRegisterBits(RVHZ50, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getSMPVetoedFrames(isisU32_t* value, DAEstatus& status)
{
    return readRegister(SMPVETFRM, value, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getExternalVetoedFrames(int veto_number, isisU32_t* value, DAEstatus& status)
{
//                      return readRegister(EXTVETFRMTOT, value, status);
        switch(veto_number)
        {
                case 0:
                        return readRegister(EXT0VETFRM, value, status);
                        break;
                case 1:
                        return readRegister(EXT1VETFRM, value, status);
                        break;
                case 2:
                        return readRegister(EXT2VETFRM, value, status);
                        break;
                case 3:
                        return readRegister(EXT3VETFRM, value, status);
                        break;
                default:
                        status.addWarningVa(FAC_DAE, "Attempting to read invalid external veto number %d", veto_number);
                        break;
        }
        return DAEstatus::Success;
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getMSModeVetoedFrames(isisU32_t* value, DAEstatus& status)
{
    return readRegister(MSMVETFRM, value, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getFIFOVetoedFrames(isisU32_t* value, DAEstatus& status)
{
    return readRegister(FIFOVETFRM, value, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getInternalVetoedFrames(isisU32_t* value, DAEstatus& status)
{
    return readRegister(INTVETFRM, value, status);
}


template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getFermiChopperVetoedFrames(int chopper_number, isisU32_t* value, DAEstatus& status)
{
        static const isisU32_t mapping[] = { FC0VETFRM, FC1VETFRM, FC2VETFRM, FC3VETFRM };
        if ( chopper_number >=0 && chopper_number < array_length(mapping) )
        {
                return readRegister(mapping[chopper_number], value, status);
        }
        else
        {
                status.addWarningVa(FAC_DAE, "Attempting to read invalid fermi chopper number %d", chopper_number);
                return DAEstatus::Success;
        }
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getTS2PulseVetoedFrames(isisU32_t* value, DAEstatus& status)
{
    return readRegister(TS2PVETFRM, value, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getISIS50HzVetoedFrames(isisU32_t* value, DAEstatus& status)
{
    return readRegister(HZ50VETFRM, value, status);
}

//int EnvPeriodCard<EnvPeriodPolicy>::clearSMPVetoedFrames(DAEstatus& status)
//{
//    isisU16_t value = 0;
//    writeRegister(SMPVETFRM0, value, status);
//      writeRegister(SMPVETFRM1, value, status);
//      return 0;
//}

//int EnvPeriodCard<EnvPeriodPolicy>::clearExternalVetoedFrames(DAEstatus& status)
//{
//    isisU16_t value = 0;
//    writeRegister(EXTVETFRM0, value, status);
//      writeRegister(EXTVETFRM1, value, status);
//      return 0;
//}

//int EnvPeriodCard<EnvPeriodPolicy>::clearFIFOVetoedFrames(DAEstatus& status)
//{
//    isisU16_t value = 0;
//    writeRegister(FIFOVETFRM0, value, status);
//      writeRegister(FIFOVETFRM1, value, status);
//      return 0;
//}


template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::setFrameSyncDelay(isisU32_t value, DAEstatus& status)               // in us
{
        if (value < 0)
        {
                status.add(FAC_ENVCARD, SEV_ERROR, ERRTYPE_INVCARD, "Frame sync delay cannot be negative - set to zero");
                value = 0;
        }
// no longer required to be at least 1
//      if (value == 0)
//      {
//              value = 1;
//      }
        if ((value >> 18) != 0)
        {
                status.add(FAC_ENVCARD, SEV_ERROR, ERRTYPE_INVCARD, "Frame sync delay too big (> 18 bits wide)");
        }
        clearRunControlBits(RCFSENABLEOUT, status);
        setAndClearRunControlBits(RCDELFSFIFORS, true, status);
        writeRegister(FSDELAY, value, status);
        setRunControlBits(RCFSENABLEOUT, true, status);
        return 0;
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getFrameSyncDelay(isisU32_t* value, DAEstatus& status)              // in us
{
        isisU32_t fs_mask = ((1 << 18) - 1); // FS only 18 bits wide
        readRegister(FSDELAY, value, status);
        *value &= fs_mask;
        return 0;
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::enableHardwarePeriods(DAEstatus& status) 
{ 
    return clearRunControlBits(RCPERSZEQZERO, status); 
} 
    
template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::disableHardwarePeriods(DAEstatus& status) 
{ 
   return setRunControlBits(RCPERSZEQZERO, true, status); 
} 

template <class EnvPeriodPolicy>
bool EnvPeriodCard<EnvPeriodPolicy>::usingHardwarePeriods(DAEstatus& status)
{
                isisU32_t value;
// need to check with Matt...
//              readRegister(RCONTROL, &value, status);
//              if (value & RCPERSZEQZERO)
//              {
//                      return false;
//              }
//              else
//              {
//                      return true;
//              }
                readRegister(PCREG, &value, status);
                if (value & PCENAB)
                {
                        return true;
                }
                else
                {
                        return false;
                }
}
    
// converion factor is
//
// 4e13 / 1024 * 1.602e-19 * 1e6 / 3600 = 1.738e-6
//
// 4e13/1024 is a calibration: 1024 for 10 bit ADC, 4e13 for full load proton reading
//

#define PPP_TO_UAMPH    1.738E-6

template <class EnvPeriodPolicy>
float EnvPeriodCard<EnvPeriodPolicy>::getGoodUAmpHours(DAEstatus& status)
{
        float good_uamps = 0.0;
        isisU32_t low = 0, upper = 0;
        getGoodPPPLower(&low, status);
        getGoodPPPUpper(&upper, status);
        good_uamps = static_cast<float>((65536.0 * 65536.0 * upper + low) * PPP_TO_UAMPH);
        return good_uamps;
}

template <class EnvPeriodPolicy>
float EnvPeriodCard<EnvPeriodPolicy>::getRawUAmpHours(DAEstatus& status)
{
        float raw_uamps = 0.0;
        isisU32_t low = 0, middle = 0, upper = 0;
        getRawPPPLower(&low, status);
        getRawPPPUpper(&upper, status);
        raw_uamps = static_cast<float>((65536.0 * 65536.0 * upper + low) * PPP_TO_UAMPH);
        return raw_uamps;
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::updateOptions(DAEstatus& status)
{
        int i;
        isisU16_t nperiod;
        isisU16_t value16 = 0;
        m_options = 0;
        setOptions(NoCheckSRAM);  
        readRegister(PCREG, &value16, status);
        (value16 & PCMSM) ? setOptions(MSMode) : clearOptions(MSMode);
        readRegister(MPLIM, &nperiod, status);
        isisU32_t* req_frames = new isisU32_t[nperiod];
        getRequestedFrames(0, nperiod, req_frames, status);
        bool single_frames_only = true;
        for(i=0; i<nperiod; i++)
        {
                if (req_frames[i] != 1)
                {
                        single_frames_only = false;
                }
        }
        // disable workaround
        single_frames_only = false;
        (single_frames_only) ? setOptions(RotateFrameCountersRight) : clearOptions(RotateFrameCountersRight);
        delete[] req_frames;
        isisU32_t ft0;
        DAEstatus temp_status;
        if (readRegister(FRAMETIME0, &ft0, temp_status) == 1)
        {
                status.addInfo(FAC_DAE, "This card supports event mode timer");
                setOptions(EventModeTimer);
        }
        if (readRegister(FC0WINDLY, &ft0, temp_status) == 1)
        {
                status.addInfo(FAC_DAE, "This card supports fermi chopper veto");
                setOptions(FChopperVeto);
        }
        return status.result();
}

// delay and width in 20ns steps
template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::enableFChopperVeto(int chopper_number, int delay, int width, DAEstatus& status)
{
        static const isisU32_t delay_mapping[] = { FC0WINDLY, FC1WINDLY, FC2WINDLY, FC3WINDLY };
        static const isisU32_t window_mapping[] = { FC0WINWTH, FC1WINWTH, FC2WINWTH, FC3WINWTH };
        static const isisU32_t veto_mapping[] = { RVFCHOP0, RVFCHOP1, RVFCHOP2, RVFCHOP3 };

        if (m_options & EnvPeriodCard<EnvPeriodPolicy>::FChopperVeto)
        {
                writeRegister(delay_mapping[chopper_number], delay, status);
                writeRegister(window_mapping[chopper_number], width, status);
                status.addInfoVa(FAC_DAE, "Fermi chopper %d setting delay,width (us) = %f,%f\n", chopper_number, delay / 50.0, width / 50.0);
                return setVetoRegisterBits(veto_mapping[chopper_number], true, status);
        }
        else
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Fermi Chopper Veto Not Available");
                return DAEstatus::Failure;
        }
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::disableFChopperVeto(int chopper_number, DAEstatus& status)
{
        return disableFermiChopperVeto(chopper_number, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getFChopperVetoedFrames(int chopper_number, isisU32_t* value, DAEstatus& status)
{
        return getFermiChopperVetoedFrames(chopper_number, value, status);
}

template <class EnvPeriodPolicy>
float EnvPeriodCard<EnvPeriodPolicy>::getRawUAmpHoursPeriod(int period, DAEstatus& status)
{
        float raw_uamps = 0.0;
        isisU32_t low = 0, middle = 0, upper = 0;
        getRawPPPLowerPeriod(period, &low, status);
        getRawPPPUpperPeriod(period, &upper, status);
        raw_uamps = static_cast<float>((65536.0 * 65536.0 * upper + low) * PPP_TO_UAMPH);
        return raw_uamps;
}

template <class EnvPeriodPolicy>
float EnvPeriodCard<EnvPeriodPolicy>::getGoodUAmpHoursPeriod(int period, DAEstatus& status)
{
        float good_uamps = 0.0;
        isisU32_t low = 0, upper = 0;
        getGoodPPPLowerPeriod(period, &low, status);
        getGoodPPPUpperPeriod(period, &upper, status);
        good_uamps = static_cast<float>((65536.0 * 65536.0 * upper + low) * PPP_TO_UAMPH);
        return good_uamps;
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getRawPPPLowerPeriod(int period, isisU32_t* value, DAEstatus& status)
{
        ISISVME::TransferProps props = ISISVME::TransferLUTSpace;
        EnvPeriodPolicy::ppp_memory_t val;
        int stat = readMemory(RPCNT0START + sizeof(val)*period, &val, 1, props, status);
        *value = static_cast<isisU32_t>(val);
        return stat;
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getRawPPPUpperPeriod(int period, isisU32_t* value, DAEstatus& status)
{
        *value = 0;
#if 0
        int stat = readMemory(RPCNT1START + 4*period, value, 1, false, false, status);  // not valid for dae3
        (*value) &= 0xffff;     // only 16 bits valid
        return stat;
#else
        return DAEstatus::Success;
#endif
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getGoodPPPLowerPeriod(int period, isisU32_t* value, DAEstatus& status)
{
        EnvPeriodPolicy::ppp_memory_t val;
        ISISVME::TransferProps props = ISISVME::TransferLUTSpace;
        int stat = readMemory(GPCNT0START + sizeof(val)*period, &val, 1, props, status);
        *value = static_cast<isisU32_t>(val);
        return stat;
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::getGoodPPPUpperPeriod(int period, isisU32_t* value, DAEstatus& status)
{
        *value = 0;
#if 0
        int stat = readMemory(GPCNT1START + 4*period, value, 1, false, false, status);
        (*value) &= 0xffff;     // only 16 bits valid
        return stat;
#else
        return DAEstatus::Success;
#endif
}


// sync time to current computer time
// this counter runs at 20ns, FILETIME is in 100ns increments
// the counter is large enough to hold 5 * filetime
template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::syncFrameTimer(DAEstatus& status)
{
        if (!checkOptions(EventModeTimer))
        {
                return DAEstatus::Success;
        }
        FILETIME filetime;
        m_vme->lockInterface(0, status);   // get exclusive access to Visa/DAE
        ThreadPriorityRaiser thread_prio;  // raise thread priority until end of function
        // see how far we are currently out
        status.addInfoVa(FAC_DAE, "Previous DAE time drift (icp - dae) = %f ms", frameTimerDrift(status) / 1000.0);
        // compute delay
        isisU32_t delay;
        computeTimeOffsetDelay(delay, status);
        status.addInfoVa(FAC_DAE, "Time sync delay = %f ms", delay / 50000.0);
        // now update DAE time
        DAEEventHeader::DAETime daetime;
        // use order zero low bits, set high bits, set low bits as counter is free runnings and may wrap
        writeRegister(FRAMETIME0, 0, status);
        ICPTimer timer;
        //GetSystemTimeAsFileTime(&filetime);
        g_icp_clock.get()->getCurrentTimeAsFiletime(filetime);
        DAEEventList::FILETIMEToDAETime(filetime, daetime);
        writeRegister(FRAMETIME1, daetime.high, status);
        writeRegister(FRAMETIME0, daetime.low, status);
        status.addInfoVa(FAC_DAE, "DAE time drift (icp - dae) = %f ms", frameTimerDrift(status) / 1000.0);
        m_vme->unlockInterface(status);
        timer.info("Time to compute and set new DAE time values", status);
        status.addInfoVa(FAC_DAE, "Setting new DAE time to %s", DAEEventList::DAETimeAsString(daetime).c_str());
        return DAEstatus::Success;
}

template <class EnvPeriodPolicy>
double EnvPeriodCard<EnvPeriodPolicy>::frameTimerDrift(DAEstatus& status)
{
        FILETIME filetime1, filetime2;
        m_vme->lockInterface(0, status);   // get exclusive access to Visa/DAE
        ThreadPriorityRaiser thread_prio;  // raise thread priority until end of function
        readFrameTimer(filetime1, status);
        //GetSystemTimeAsFileTime(&filetime2);
        g_icp_clock.get()->getCurrentTimeAsFiletime(filetime2);
        m_vme->unlockInterface(status);
        return (double)diffFileTimes(filetime1, filetime2) / 10.0;   // from 100ns to us
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::readFrameTimer(FILETIME& ft, DAEstatus& status)
{
        if (!checkOptions(EventModeTimer))
        {
                memset(&ft, 0, sizeof(FILETIME));
                return DAEstatus::Success;
        }
        DAEEventHeader::DAETime daetime;
        isisU32_t ft0, ft1, temp32;
        readRegister(FRAMETIME0, &temp32, status); 
        readRegister(FRAMETIME1, &ft1, status);
        readRegister(FRAMETIME0, &ft0, status);
        if (ft0 < temp32)  // did ft0 wrap during the read? If so read again
        {
                readRegister(FRAMETIME1, &ft1, status);
                readRegister(FRAMETIME0, &ft0, status); 
        }
        daetime.low = ft0;
        daetime.high = ft1;
        DAEEventList::DAETimeToFILETIME(daetime, ft);
        return DAEstatus::Success;
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::computeTimeOffsetDelay(isisU32_t& delay, DAEstatus& status)
{
        writeRegister(FRAMETIME0, 0, status);
        readRegister(FRAMETIME0, &delay, status);
        return DAEstatus::Success;
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::enableEventMode(DAEstatus& status)
{
        return setRunControlBits(RCEVENTMODE, true, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::disableEventMode(DAEstatus& status)
{
        return clearRunControlBits(RCEVENTMODE, status);
}

template <class EnvPeriodPolicy>
int EnvPeriodCard<EnvPeriodPolicy>::resetCardState(DAEstatus& status)
{
        ISISVME::TransferProps props = ISISVME::TransferLUTSpace;
        LOGSTR_INFORMATION("Resetting card state");
//      uint32_t check_mask0 = (checkOptions(NoCheckSRAM) ? 0x0 : 0xffffffff);
//      uint32_t check_mask1 = (checkOptions(NoCheckSRAM) ? 0x0 : 0x0000ffff);
        uint32_t check_mask0 = 0x0;
        uint32_t check_mask1 = 0x0;

        writeRegister(FSDELAY, 0x1, status);
        writeRegister(FC0WINDLY, 0xfa0, status);
        writeRegister(FC0WINWTH, 0x5dc, status);

// mantalk 0 0 300 0 6
        writeRegister(MPCNT, 0x0, status);
        writeRegister(MPLIM, 0x0, status);
        writeRegister(PSCNT, 0x0, status);
        writeRegister(PSLR, 0x0, status);
        writeRegister(PERINCTOT, 0x0, status);
        writeRegister(PEROUTDEL, 0x0, status);

        writeRegister(LOOKTAR, 0x0, status);
        writeRegister(RVETO, 0x0, status);
        writeRegister(RCONTROL, 0xc006, status);
        writeRegister(PCREG, 0x8000, status);
        writeRegister(RCONTROL, 0x100008, status);
        writeRegister(PCREG, 0x0, status);

// mantalk 0 0 80000 0 10000
        zeroMemory<isisU32_t>(PERLUTSTART, PERLUTSIZE, check_mask0, props, status); // 0x10000 = 65536
// mantalk 0 0 c0000 0 4000
        zeroMemory<isisU32_t>(OUTLUTSTART, OUTLUTSIZE, check_mask0, props, status); // 0x4000 = 16384
// mantalk 0 0 100000 0 10000
        zeroMemory<isisU32_t>(RFCNT0START, RFCNT0SIZE, check_mask0, props, status); // 0x10000 = 65536
// mantalk 0 0 140000 0 10000
//      zeroMemory(RPCNT1START, RPCNT1SIZE, check_mask1, props, status); // 0x10000 = 65536   // not valid for dae3
        // zeroPeriodFrameCounters(status);
        // zeroPeriodProtonCounters(status);
        // zeroPeriodExtraCounters(status);

        return ISISVME::Success;
}

const DAE2EnvPeriodPolicy::veto_detail DAE2EnvPeriodPolicy::veto_details[] = {
        { "FIFO Veto", RVFIFO, FIFOVETFRM, false },
        { "SMP (chopper) Veto", RVSMP, SMPVETFRM, false },
        { "Internal Veto", RVINT, INTVETFRM, true },
        { "Fermi Chopper0 Veto", RVFCHOP0, FC0VETFRM, false },
//      { "Fermi Chopper1 Veto", RVFCHOP1, FC1VETFRM, false },
//      { "Fermi Chopper2 Veto", RVFCHOP2, FC2VETFRM, false },
//      { "Fermi Chopper3 Veto", RVFCHOP3, FC3VETFRM, false },
        { "TS2 Pulse Veto", RVTS2P, TS2PVETFRM, false },
        { "ISIS 50 Hz Veto", RVHZ50, HZ50VETFRM, false },
        { "MS Mode Veto", RVMSM, MSMVETFRM, true },
        { "External Veto 0", RVEXT0, EXT0VETFRM, false },
        { "External Veto 1", RVEXT1, EXT1VETFRM, false },
        { "External Veto 2", RVEXT2, EXT2VETFRM, false },
        { "External Veto 3", RVEXT3, EXT3VETFRM, false },
        { NULL, 0, 0, false } // must end with NULL name
};

const DAE3EnvPeriodPolicy::veto_detail DAE3EnvPeriodPolicy::veto_details[] = {
        { "FIFO Veto", RVFIFO, FIFOVETFRM, false },
        { "SMP (chopper) Veto", RVSMP, SMPVETFRM, false },
        { "Internal Veto", RVINT, INTVETFRM, true },
        { "Fermi Chopper0 Veto", RVFCHOP0, FC0VETFRM, false },
//      { "Fermi Chopper1 Veto", RVFCHOP1, FC1VETFRM, false },
//      { "Fermi Chopper2 Veto", RVFCHOP2, FC2VETFRM, false },
//      { "Fermi Chopper3 Veto", RVFCHOP3, FC3VETFRM, false },
        { "TS2 Pulse Veto", RVTS2P, TS2PVETFRM, false },
        { "ISIS 50 Hz Veto", RVHZ50, HZ50VETFRM, false },
        { "MS Mode Veto", RVMSM, MSMVETFRM, true },
        { "External Veto 0", RVEXT0, EXT0VETFRM, false },
        { "External Veto 1", RVEXT1, EXT1VETFRM, false },
        { "External Veto 2", RVEXT2, EXT2VETFRM, false },
        { "External Veto 3", RVEXT3, EXT3VETFRM, false },
        { NULL, 0, 0, false } // must end with NULL name
};

template class EnvPeriodCard<DAE2EnvPeriodPolicy>;
template class EnvPeriodCard<DAE3EnvPeriodPolicy>;