nivisa.cpp

Go to the documentation of this file.

#include "stdafx.h"
#include "nivisa.h"
#include "icputils.h"

// default: only read/write at most 40Mb in one go; got system resouces problems on merlin when went higher
static int nitems_max_default = (getenv("ISISVME_NITEMS_MAX") != NULL ? atoi(getenv("ISISVME_NITEMS_MAX")) : 10*1024*1024);

class VisaAccessLock
{
        static Poco::RWLock m_interface_lock;
        static const DWORD INVALID_THREAD_ID;
        static DWORD m_locker_id;
        static LONG m_count;
public:
        VisaAccessLock()
        {
                if (GetCurrentThreadId() == INVALID_THREAD_ID)
                {
                        throw std::runtime_error("VisaAccessLock: invalid thread id");
                }
                // in poco cannot take out a read lock if alread have a write lock, so need to protect these cases
                if (GetCurrentThreadId() != m_locker_id)  // skip read lock if we already have a write lock
                {
                        m_interface_lock.readLock();
                }
        }
        ~VisaAccessLock()
        {
                if (GetCurrentThreadId() != m_locker_id)
                {
                        m_interface_lock.unlock();
                }
        }
        static void lockExclusive()
        {
                if (GetCurrentThreadId() != m_locker_id)
                {
                        m_interface_lock.writeLock();
                        m_locker_id = GetCurrentThreadId();
                        if (m_locker_id == INVALID_THREAD_ID)
                        {
                                throw std::runtime_error("VisaAccessLock: invalid thread id");
                        }
                }
                else
                {
                        InterlockedIncrement(&m_count);
                }
        }
        static void unlockExclusive()
        {
                if (m_count > 0)
                {
                        InterlockedDecrement(&m_count);
                }
                else
                {
                        m_locker_id = INVALID_THREAD_ID;
                        m_interface_lock.unlock();
                }
        }
};

Poco::RWLock VisaAccessLock::m_interface_lock;
const DWORD VisaAccessLock::INVALID_THREAD_ID = 0;
LONG VisaAccessLock::m_count = 0;
DWORD VisaAccessLock::m_locker_id = VisaAccessLock::INVALID_THREAD_ID;

void NIVisa::lockInterface(int timeout, DAEstatus& dstatus)
{
        VisaAccessLock::lockExclusive();
}

void NIVisa::unlockInterface(DAEstatus& dstatus)
{
        VisaAccessLock::unlockExclusive();
}

NIVisa::NIVisa(DAEstatus& dstatus) : ISISVME(), m_init_done(false), m_default_rm(VI_NULL), m_block_transfers(false), m_instr_le(VI_NULL), m_instr_be(VI_NULL), 
        m_instr_le_bt(VI_NULL), m_instr_be_bt(VI_NULL), m_instr_backplane(VI_NULL), m_device(""), m_device_bp(""), m_trigger_func(NULL), m_trigger_func_arg(NULL)
{
        InitializeCriticalSection(&m_job_critical);
        InitializeCriticalSection(&m_visa_critical);
        setLoggerName("NIVisa");
        reinit(dstatus);
}

bool NIVisa::initOK()
{
        return m_init_done;
}


int NIVisa::reinit(DAEstatus& dstatus)
{
        ViStatus status;
        VisaAccessLock visa_lock;
        ICPCritical cs(&m_visa_critical);
        m_init_done = false;
        LOGSTR_INFORMATION("Calling NIVisa::reinit()");
        dstatus.addInfo(FAC_DAE, "Calling NIVisa::reinit()");
        close(dstatus);
        if (m_default_rm != VI_NULL)
    {
        status = viClose(m_default_rm);
        m_default_rm = VI_NULL;
    }
        m_default_rm = VI_NULL;
        status = viOpenDefaultRM(&m_default_rm);
        if (status == VI_SUCCESS)
        {
                m_init_done = true;
        }
        else
        {
//              addError(VI_NULL, "viOpenDefaultRM", status, "Unable to open default VISA resouce manager", dstatus);
                std::ostringstream message;
                message << "viOpenDefaultRM(error code=" << status << ")";
                dstatus.add(FAC_NIVISA, SEV_ERROR, ERRTYPE_NIVISA, message.str());
                LOGSTR_ERROR(message);
                return ISISVME::Error;
        }
//                      status = viOpen(m_default_rm, "VXI0::BACKPLANE", VI_NULL, 
//                                      VI_NULL, &m_instr_backplane);
//                      if (status != VI_SUCCESS)
//                      {
//                              std::cerr << "viOpen (backplane)" << status << std::endl;
//                      }
        if (m_device != "")
        {
                open(m_device.c_str(), dstatus);
        }
        if (m_device_bp != "")
        {
                openBackplane(m_device_bp.c_str(), dstatus);
        }
        return ISISVME::Success;
}

int NIVisa::addJobid(ViJobId jobId, ViStatus vi_status)
{
        ICPCritical cs(&m_job_critical);
        m_jobid_map[jobId] = vi_status;
        return 0;
}

ViStatus _VI_FUNCH NIVisa::IOEventHandler(ViSession vi, ViEventType eventType, ViEvent context, ViAddr userHandle)
{
        VisaAccessLock visa_lock;
        ViJobId jobId;
        ViStatus vi_status;
        viGetAttribute(context, VI_ATTR_JOB_ID, &jobId);
        viGetAttribute(context, VI_ATTR_STATUS, &vi_status);
        NIVisa* vme = (NIVisa*)userHandle;
        vme->addJobid(jobId, vi_status);
        return VI_SUCCESS;
}

ViStatus _VI_FUNCH NIVisa::TriggerHandler(ViSession vi, ViEventType eventType, ViEvent context, ViAddr userHandle)
{
        VisaAccessLock visa_lock;
//      ViStatus vi_status;
//      ViEventType event_type;
        ViInt16 trig_id; // 0 to 7 is VI_TRIG_TTL0 to VI_TRIG_TTL7  8 is VI_TRIG_ECL0 9 is ECL1
//      ViUInt16 intr_id;
        struct timeb tb;
        ftime(&tb);
//      viGetAttribute(context, VI_ATTR_EVENT_TYPE, &event_type);   // should be VI_EVENT_TRIG
        NIVisa* vme = (NIVisa*)userHandle;
        if (eventType == VI_EVENT_TRIG)
        {
                viGetAttribute(context, VI_ATTR_RECV_TRIG_ID, &trig_id);
                vme->onTrigger(tb.time, tb.millitm, trig_id);
        }
//      if (eventType == VI_EVENT_VXI_SIGP)
//      {
//              status = viGetAttribute (context, VI_ATTR_SIGP_STATUS_ID, &intrID);
//      }
        return VI_SUCCESS;
}

int NIVisa::onTrigger(time_t the_secs, unsigned short the_ms, ViInt16 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;
        }
}

int NIVisa::open(const char* device, DAEstatus& dstatus)
{
        VisaAccessLock visa_lock;
        ICPCritical cs(&m_visa_critical);
        std::ostringstream message;
        ViStatus status;
        m_device = device;
//      std::cerr << "vi return add = " << (void*)&m_instr_le << std::endl;
        m_instr_le = VI_NULL;
    status = viOpen(m_default_rm, (char*)device, VI_NULL, 
                                        VI_NULL, &m_instr_le);
    if (status != VI_SUCCESS)
        {
                message << "Error opening \"" << device << "\"" << std::endl;
                addError(m_default_rm, "viOpen", status, message.str(), dstatus);
                return ISISVME::Error;
        }
        if (lockDevice(1000, dstatus) == ISISVME::Error)
        {
                return ISISVME::Error;
        }
        m_instr_le_bt = VI_NULL;
    status = viOpen(m_default_rm, (char*)device, VI_NULL, 
                                        VI_NULL, &m_instr_le_bt);
    if (status != VI_SUCCESS)
        {
                message << "Error opening \"" << device << "\"" << std::endl;
                addError(m_default_rm, "viOpen", status, message.str(), dstatus);
                return ISISVME::Error;
        }
        m_device = device;
        ViUInt16 interface_type;
        if (m_endian_workaround)
        {
                m_block_transfers = true;   // MXI2
        }
        else
        {
                m_block_transfers = false;  // USB
        }
        dstatus.addInfoVa(FAC_DAE, "Endian workaround %s, blocks transfers %s", 
                (m_endian_workaround ? "ENABLED" : "DISABLED"), 
                (m_block_transfers ? "ENABLED" : "DISABLED"));
        status = viGetAttribute(m_instr_le, VI_ATTR_INTF_TYPE, &interface_type);
        if (status == VI_SUCCESS)
        {
                switch(interface_type)
                {
                        case VI_INTF_USB:
                                dstatus.addInfo(FAC_DAE, "This is a USB DAE");
//                              m_endian_workaround = false;
                                break;

                        case VI_INTF_VXI:
                                dstatus.addInfo(FAC_DAE, "This is a VXI DAE");
//                              m_endian_workaround = true;
                                break;

                        default:
                                dstatus.addInfo(FAC_DAE, "This is an UNKNOWN DAE");
                                break;
                }
        }
        else
        {
                dstatus.addInfo(FAC_DAE, "Cannot access VI_ATTR_INTF_TYPE");
        }
        m_instr_be = VI_NULL;
    status = viOpen(m_default_rm, (char*)device, VI_NULL, 
                                        VI_NULL, &m_instr_be);  
    if (status != VI_SUCCESS)
        {
                addError(m_default_rm, "viOpen", status, "", dstatus);
                return ISISVME::Error;
        }
        m_instr_be_bt = VI_NULL;
    status = viOpen(m_default_rm, (char*)device, VI_NULL, 
                                        VI_NULL, &m_instr_be_bt);       
    if (status != VI_SUCCESS)
        {
                addError(m_default_rm, "viOpen", status, "", dstatus);
                return ISISVME::Error;
        }
        if (getenv("ISISVME_USE_PIO") != NULL)
        {
                if (status == VI_SUCCESS)
                {
                        dstatus.addInfoVa(FAC_DAE, "Using PIO rather than DMA\n");
                        status = viSetAttribute(m_instr_be, VI_ATTR_DMA_ALLOW_EN, VI_FALSE);
                        status = viSetAttribute(m_instr_be_bt, VI_ATTR_DMA_ALLOW_EN, VI_FALSE);
                }
                if (status == VI_SUCCESS)
                {
                        status = viSetAttribute(m_instr_le, VI_ATTR_DMA_ALLOW_EN, VI_FALSE);
                        status = viSetAttribute(m_instr_le_bt, VI_ATTR_DMA_ALLOW_EN, VI_FALSE);
                }
        }
        if (getenv("ISISVME_TIMEOUT") != NULL)
        {
                ViUInt32 time_out = atol(getenv("ISISVME_TIMEOUT"));
                if (status == VI_SUCCESS)
                {
                        dstatus.addInfoVa(FAC_DAE, "Setting timeout to %u ms\n", time_out);
                        status = viSetAttribute(m_instr_be, VI_ATTR_TMO_VALUE, time_out);
                        status = viSetAttribute(m_instr_be_bt, VI_ATTR_TMO_VALUE, time_out);
                }
                if (status == VI_SUCCESS)
                {
                        status = viSetAttribute(m_instr_le, VI_ATTR_TMO_VALUE, time_out);
                        status = viSetAttribute(m_instr_le_bt, VI_ATTR_TMO_VALUE, time_out);
                }
        }
        // disable SyncMXI protocol - see http://digital.ni.com/public.nsf/allkb/3688705B6D2A405486256E9F005953F6
        if (false)
        {
                if (status == VI_SUCCESS)
                {
                        dstatus.addInfoVa(FAC_DAE, "Disabling SyncMXI protocol\n");
                        status = viSetAttribute (m_instr_le, 0x3FFF0161, 0x0);
                        status = viSetAttribute (m_instr_le_bt, 0x3FFF0161, 0x0);
                }
                if (status == VI_SUCCESS)
                {
                        status = viSetAttribute (m_instr_be, 0x3FFF0161, 0x0);
                        status = viSetAttribute (m_instr_be_bt, 0x3FFF0161, 0x0);
                }
        }
    if (status != VI_SUCCESS)
        {
                addError(m_default_rm, "viSetAttribute", status, "", dstatus);
                return ISISVME::Error;
        }
#if DO_MOVE_ASYNC
        viInstallHandler(m_instr_le, VI_EVENT_IO_COMPLETION, IOEventHandler, this);
        viInstallHandler(m_instr_be, VI_EVENT_IO_COMPLETION, IOEventHandler, this);
        viInstallHandler(m_instr_le_bt, VI_EVENT_IO_COMPLETION, IOEventHandler, this);
        viInstallHandler(m_instr_be_bt, VI_EVENT_IO_COMPLETION, IOEventHandler, this);

        if (viEnableEvent(m_instr_le, VI_EVENT_IO_COMPLETION, VI_HNDLR, VI_NULL) != VI_SUCCESS)
        {
                addError(m_default_rm, "viEnableEvent", status, "", dstatus);
        }
        if (viEnableEvent(m_instr_be, VI_EVENT_IO_COMPLETION, VI_HNDLR, VI_NULL) != VI_SUCCESS)
        {
                addError(m_default_rm, "viEnableEvent", status, "", dstatus);
        }
        if (viEnableEvent(m_instr_le_bt, VI_EVENT_IO_COMPLETION, VI_HNDLR, VI_NULL) != VI_SUCCESS)
        {
                addError(m_default_rm, "viEnableEvent", status, "", dstatus);
        }
        if (viEnableEvent(m_instr_be_bt, VI_EVENT_IO_COMPLETION, VI_HNDLR, VI_NULL) != VI_SUCCESS)
        {
                addError(m_default_rm, "viEnableEvent", status, "", dstatus);
        }
#endif
        enableBlockTransfers(m_instr_le_bt, dstatus);
        enableBlockTransfers(m_instr_be_bt, dstatus);
        setEndian(m_instr_le, true, dstatus);
        return setEndian(m_instr_le_bt, true, dstatus);
}

int NIVisa::openBackplane(const char* device_bp, DAEstatus& dstatus)
{
        VisaAccessLock visa_lock;
        ICPCritical cs(&m_visa_critical);
        std::ostringstream message;
        ViStatus status;
        m_device_bp = device_bp;
    m_instr_backplane = VI_NULL;
    status = viOpen(m_default_rm, (char*)device_bp, VI_NULL, 
                                        VI_NULL, &m_instr_backplane);
    if (status != VI_SUCCESS)
        {
                message << "Error opening \"" << device_bp << "\"" << std::endl;
                addError(m_default_rm, "viOpen", status, message.str(), dstatus);
                return ISISVME::Error;
        }
        status = viInstallHandler(m_instr_backplane, VI_EVENT_TRIG, TriggerHandler, this);
        if (status != VI_SUCCESS)
        {
                addError(m_default_rm, "viInstallHandler", status, "", dstatus);
                return ISISVME::Error;
        }
//      status = viInstallHandler(m_instr_backplane, VI_EVENT_VXI_SIGP, TriggerHandler, this);
//      if (status != VI_SUCCESS)
//      {
//              addError(m_default_rm, "viInstallHandler", status, "", dstatus);
//              return ISISVME::Error;
//      }
        status = viSetAttribute(m_instr_backplane, VI_ATTR_TRIG_ID, VI_TRIG_ECL0);  // frame sync
        if (status != VI_SUCCESS)
        {
                addError(m_default_rm, "viSetAttribute", status, "", dstatus);
                return ISISVME::Error;
        }
        status = viEnableEvent(m_instr_backplane, VI_EVENT_TRIG, VI_HNDLR, VI_NULL);
        if (status != VI_SUCCESS)
        {
                addError(m_default_rm, "viEnableEvent", status, "", dstatus);
                return ISISVME::Error;
        }
//      status = viEnableEvent(m_instr_backplane, VI_EVENT_VXI_SIGP, VI_HNDLR, VI_NULL);
//      if (status != VI_SUCCESS)
//      {
//              addError(m_default_rm, "viEnableEvent", status, "", dstatus);
//              return ISISVME::Error;
//      }
        ViUInt32 my_uint32;
        status = viGetAttribute(m_instr_backplane, VI_ATTR_VXI_TRIG_SUPPORT, &my_uint32);
        if (status != VI_SUCCESS)
        {
                addError(m_default_rm, "viGetAttribute", status, "", dstatus);
                return ISISVME::Error;
        }
        if ( (my_uint32 & (1 << VI_TRIG_ECL0)) == 0)
        {
                dstatus.addInfo(FAC_DAE, "VI_TRIG_ECL0 not supported");
        }
        status = viGetAttribute(m_instr_backplane, VI_ATTR_VXI_TRIG_STATUS, &my_uint32);
        if (status != VI_SUCCESS)
        {
                addError(m_default_rm, "viGetAttribute", status, "", dstatus);
                return ISISVME::Error;
        }
//      if ( (my_uint32 & (1 << VI_TRIG_ECL0)) == 0)
//      {
//              dstatus.addInfo(FAC_DAE, "VI_TRIG_ECL0 not enabled");
//      }
        return ISISVME::Success;
}

int NIVisa::lockDevice(int timeout, DAEstatus& dstatus)
{
        VisaAccessLock visa_lock;
#if 0
        ViStatus status;
        ICPCritical cs(&m_critical);
        if (m_visa_lock_name == NULL)
        {
                m_visa_lock_name = new char[256];
                status = viLock(m_instr_le, VI_SHARED_LOCK, 1000 * timeout, 
                                                VI_NULL, m_visa_lock_name);
        }
        else
        {
                status = viLock(m_instr_le, VI_SHARED_LOCK, 1000 * timeout, 
                                                m_visa_lock_name, m_visa_lock_name);
        }
    if (status == VI_SUCCESS)
    {
                return ISISVME::Success;
    }
    else
    {
                addError(m_instr_le, "viLock", status, "", dstatus);
                return ISISVME::Error;
    }
#endif
        return ISISVME::Success;
}

int NIVisa::unlockDevice(DAEstatus& dstatus)
{
        VisaAccessLock visa_lock;
#if 0
        ViStatus status;
        ICPCritical cs(&m_critical);
        if (m_instr_le == VI_NULL)
        {
                return ISISVME::Success;
        }
    status = viUnlock(m_instr_le);
    if (status == VI_SUCCESS)
    {
                return ISISVME::Success;
    }
    else
    {
                addError(m_instr_le, "viUnlock", status, "", dstatus);
                return ISISVME::Error;
    }
#endif
        return ISISVME::Success;
}

template <typename F, typename T>
int NIVisa::retrySingle(F pFunc, unsigned long address, T data, TransferProps props, DAEstatus& dstatus)
{
        int current_sev = dstatus.severity();
        int i, stat = ISISVME::Error;
        for(i=0; i<m_tries; i++)
        {
                if (i > 0)
                {
                        Sleep(m_retry_time);
                        dstatus.resetSeverityToAtMost(SEV_WARNING);
                        if (i > 2)
                        {
                                LOGSTR_WARNING("retrySingle: address 0x" << std::hex << address << std::dec);
                                reinit(dstatus);
                        }
                }
                stat = (this->*pFunc)(address, data, props, dstatus);
                if (stat == ISISVME::Success)
                        break;
        }
        if ( !(dstatus >= current_sev) )
        {
                dstatus.resetSeverityToAtLeast(current_sev);
        }
        return stat;
}

template <typename F, typename T>
int NIVisa::retryBlock(F pFunc, unsigned long address, T data, long nitems, TransferProps props, DAEstatus& dstatus)
{
        int i, stat = ISISVME::Error;
        int current_sev = dstatus.severity();
        for(i=0; i<m_tries; i++)
        {
                if (i > 0)
                {
                        Sleep(m_retry_time);
                        dstatus.resetSeverityToAtMost(SEV_WARNING);
                        if (i > 2)
                        {
                                LOGSTR_WARNING("retryBlock: " << nitems << " items from address 0x" << std::hex << address << std::dec);
                                reinit(dstatus);
                        }
                }
                stat = (this->*pFunc)(address, data, nitems, props, dstatus);
                if (stat == ISISVME::Success)
                        break;
        }
        if ( !(dstatus >= current_sev) )
        {
                dstatus.resetSeverityToAtLeast(current_sev);
        }
        return stat;
}

int NIVisa::readU16(unsigned long address, isisU16_t* data16, TransferProps props, DAEstatus& dstatus)
{
        return retrySingle(&NIVisa::readU16impl, address, data16, props, dstatus);
}

int NIVisa::readU16noRetry(unsigned long address, isisU16_t* data16, TransferProps props, DAEstatus& dstatus)
{
        return readU16impl(address, data16, props, dstatus);
}


int NIVisa::readU16impl(unsigned long address, isisU16_t* data16, TransferProps props, DAEstatus& dstatus)
{
        VisaAccessLock visa_lock;
    ViStatus status;
        ViSession session;
        session = getSession(props);
    status = viIn16(session, VI_A32_SPACE, address, data16);
        if (status == VI_SUCCESS)
        {
                return ISISVME::Success;
    }
    else
    {
                addError(session, "viIn16", status, address, 1, "", dstatus);
                return ISISVME::Error;
    }
}

int NIVisa::readU32(unsigned long address, isisU32_t* data32, TransferProps props, DAEstatus& dstatus)
{
        return retrySingle(&NIVisa::readU32impl, address, data32, props, dstatus);
}

int NIVisa::readU32noRetry(unsigned long address, isisU32_t* data32, TransferProps props, DAEstatus& dstatus)
{
        return readU32impl(address, data32, props, dstatus);
}

int NIVisa::readU32impl(unsigned long address, isisU32_t* data32, TransferProps props, DAEstatus& dstatus)
{
        VisaAccessLock visa_lock;
    ViStatus status;
        ViSession session;
        ICPCritical cs(&m_visa_critical);   // just for safety - visa should be threadsafe
        session = getSession(props);
    status = viIn32(session, VI_A32_SPACE, address, data32);
        if (status == VI_SUCCESS)
        {
                return ISISVME::Success;
    }
    else
    {
                addError(session, "viIn32", status, address, 1, "", dstatus);
                return ISISVME::Error;
    }
}

int NIVisa::readBlockU16(unsigned long address, isisU16_t* data16, 
                                                 long nitems, TransferProps props, DAEstatus& dstatus)
{
        return retryBlock(&NIVisa::readBlockU16impl, address, data16, nitems, props, dstatus);
}

// nove nitems of 2 bytes
// need to check the use of nitems_max in particular is address increment 2*n or 4*n?
int NIVisa::readBlockU16impl(unsigned long address, isisU16_t* data16, 
                                                 long nitems, TransferProps props, DAEstatus& dstatus)
{
        VisaAccessLock visa_lock;
        int nitems_max;
        ViStatus status;
        ViSession session;
        session = getSession(props);
        if (nitems_max_default > 0)
        {
                nitems_max = nitems_max_default;
        }
        else
        {
                nitems_max = nitems;
        }
        int nitems_left = nitems;
        int n;
        bool error_signalled = false;
        while(nitems_left > 0)
        {
                n = (nitems_left > nitems_max ? nitems_max : nitems_left);
                status = viMoveIn16(session, VI_A32_SPACE, address, n, data16);
                if (status != VI_SUCCESS)
                {
                        addError(session, "viMoveIn16", status, address, n, "", dstatus);
                        error_signalled = true;
                }
                nitems_left -= n;
                data16 += n;
                address += (4*n);
        }
        if (error_signalled)
        {
                return ISISVME::Error;
        }
        else
    {
                return ISISVME::Success;
    }
}

int NIVisa::readBlockU32(unsigned long address, isisU32_t* data32, 
                                                 long nitems, TransferProps props, DAEstatus& dstatus)
{
        return retryBlock(&NIVisa::readBlockU32impl, address, data32, nitems, props, dstatus);
}

int NIVisa::readBlockU64(unsigned long address, uint64_t* data64, 
                                                 long nitems, TransferProps props, DAEstatus& dstatus)
{
        return retryBlock(&NIVisa::readBlockU64impl, address, data64, nitems, props, dstatus);
}

ViSession NIVisa::getSession(TransferProps props)
{
        bool little_endian = (props & ISISVME::TransferLittleEndian ? true : false);
        bool block_transfer = (props & ISISVME::TransferBlock ? true : false);
        ICPCritical cs(&m_visa_critical);  // so we wait for any reinit() that may be in progress
        if (little_endian)
        {
                if (block_transfer)
                {
                        return m_instr_le_bt;
                }
                else
                {
                        return m_instr_le;
                }
        }
        else
        {
                if (block_transfer)
                {
                        return m_instr_be_bt;
                }
                else
                {
                        return m_instr_be;
                }
        }
}

int NIVisa::readBlockU64impl(unsigned long address, uint64_t* data64, long nitems, TransferProps props, DAEstatus& dstatus)
{
        return readBlockU32impl(address, reinterpret_cast<isisU32_t*>(data64), 2 * nitems, props, dstatus); 
}

// nove nitems of 4 bytes
int NIVisa::readBlockU32impl(unsigned long address, isisU32_t* data32, long nitems, TransferProps props, DAEstatus& dstatus)
{
        VisaAccessLock visa_lock;
        bool little_endian = (props & ISISVME::TransferLittleEndian ? true : false);
        int i, nitems_max;
//      cout << "NIVisa::readBlockU32 0x" << hex << address << dec << " " << nitems << std::endl;
    ViStatus status;
        ViSession session;
        unsigned long k = address;
        isisU32_t* d32 = data32;
        ICPCritical cs(&m_visa_critical);   // just for safety - visa should be threadsafe
        session = getSession(props);
        if (nitems_max_default > 0)
        {
                nitems_max = nitems_max_default;
        }
        else
        {
                nitems_max = nitems;
        }
        int nitems_left = nitems;
        int n;
        bool error_signalled = false;
//      SYSTEMTIME s1, s2;
        double d, mb;
        while(!error_signalled && (nitems_left > 0))
        {
                n = (nitems_left > nitems_max ? nitems_max : nitems_left);
                mb = (double)((n * 4) / (1024 * 1024)); 
//              GetSystemTime(&s1);
                if (false /* n == 1 */)
                {
                        status = viIn32(session, VI_A32_SPACE, address, data32);
                }
                else
                {
                        if (false)
                        {
                                ViJobId jobid;
                                status = viMoveAsyncEx(session, VI_A32_SPACE, address, VI_WIDTH_32, VI_LOCAL_SPACE, 
                                                                        (ViBusAddress64)data32, VI_WIDTH_32, n, &jobid);
                                if (status == VI_SUCCESS_SYNC)
                                {
                                        status = VI_SUCCESS;
                                }
                                else if (status == VI_SUCCESS)
                                {
                                        jobid_map_t::iterator it;
                                        bool done = false;
                                        while(!done)
                                        {
                                                EnterCriticalSection(&m_job_critical); 
                                                if ( (it = m_jobid_map.find(jobid)) != m_jobid_map.end() )
                                                {
                                                        done = true;
                                                }
                                                else
                                                {
                                                        LeaveCriticalSection(&m_job_critical); 
                                                        Sleep(300);
                                                }
                                        }
                                        status = it->second;
                                        m_jobid_map.erase(it);
                                        LeaveCriticalSection(&m_job_critical); 
                                }
                        }
                        else
                        {
                                status = viMoveIn32(session, VI_A32_SPACE, address, n, data32);
                        }
                }
//              GetSystemTime(&s2);
                if (status != VI_SUCCESS)
                {
                        addError(session, "viMoveIn32", status, address, n, "", dstatus);
                        error_signalled = true;
                }
//              if (n > 100)
//              {
//                  d = 60.0 * (double)(s2.wMinute - s1.wMinute) +
//                              (double)(s2.wSecond - s1.wSecond) + 
//                              (double)(s2.wMilliseconds - s1.wMilliseconds) / 1000.0;
//                  cout << "Transfer rate / Mb/s = " << mb / d << std::endl;
//              }
                nitems_left -= n;
                data32 += n;
                address += (4*n);
        }
        if (m_endian_workaround && little_endian)
        {
            for(i=0; i<nitems; i++)
                {
                        d32[i] = (((d32[i]) << 24) & 0xff000000) | 
                                (((d32[i]) <<  8) & 0x00ff0000) |
                                (((d32[i]) >>  8) & 0x0000ff00) |
                                (((d32[i]) >> 24) & 0x000000ff);
                }
        }
//      for(i=0; i<30; i++)
//      {
//              std::cerr << hex << k + 4*i << " = " << d32[i] << dec << std::endl;
//      }
        if (error_signalled)
        {
                return ISISVME::Error;
        }
        else
    {
                return ISISVME::Success;
    }
}

int NIVisa::writeU16(unsigned long address, isisU16_t data16, TransferProps props, DAEstatus& dstatus)
{
        return retrySingle(&NIVisa::writeU16impl, address, data16, props, dstatus);
}

int NIVisa::writeU16impl(unsigned long address, isisU16_t data16, TransferProps props, DAEstatus& dstatus)
{
        VisaAccessLock visa_lock;
    ViStatus status;
        ViSession session;
        session = getSession(props);
        status = viOut16(session, VI_A32_SPACE, address, data16);
    if (status == VI_SUCCESS)
    {
                return ISISVME::Success;
    }
    else
    {
                addError(session, "viOut16", status, address, 1, "", dstatus);
                return ISISVME::Error;
    }
}

int NIVisa::writeU32(unsigned long address, isisU32_t data32, TransferProps props, DAEstatus& dstatus)
{
        return retrySingle(&NIVisa::writeU32impl, address, data32, props, dstatus);
}

int NIVisa::writeU32impl(unsigned long address, isisU32_t data32, TransferProps props, DAEstatus& dstatus)
{
        VisaAccessLock visa_lock;
    ViStatus status;
        ViSession session;
        session = getSession(props);
    status = viOut32(session, VI_A32_SPACE, address, data32);
        if (status == VI_SUCCESS)
    {
                return ISISVME::Success;
    }
    else
    {
                addError(session, "viOut32", status, address, 1, "", dstatus);
                return ISISVME::Error;
    }
}


int NIVisa::writeBlockU16(unsigned long address, isisU16_t* data16, long nitems, TransferProps props, DAEstatus& dstatus)
{
        return retryBlock(&NIVisa::writeBlockU16impl, address, data16, nitems, props, dstatus);
}


// nove nitems of 2 bytes
// need to check the use of nitems_max in particular is address increment 2*n or 4*n?
int NIVisa::writeBlockU16impl(unsigned long address, isisU16_t* data16, long nitems, TransferProps props, DAEstatus& dstatus)
{
        VisaAccessLock visa_lock;
        int nitems_max;
        ViStatus status;
        ViSession session;
        session = getSession(props);
        if (nitems_max_default > 0)
        {
                nitems_max = nitems_max_default;
        }
        else
        {
                nitems_max = nitems;
        }
        int nitems_left = nitems;
        int n;
        bool error_signalled = false;
        while(nitems_left > 0)
        {
                n = (nitems_left > nitems_max ? nitems_max : nitems_left);
                status = viMoveOut16(session, VI_A32_SPACE, address, n, data16);
                if (status != VI_SUCCESS)
                {
                        addError(session, "viMoveOut16", status, address, n, "", dstatus);
                        error_signalled = true;
                }
                nitems_left -= n;
                data16 += n;
                address += (4*n);
        }
        if (error_signalled)
        {
                return ISISVME::Error;
        }
        else
    {
                return ISISVME::Success;
    }
}


int NIVisa::writeBlockU32(unsigned long address, isisU32_t* data32, long nitems, TransferProps props, DAEstatus& dstatus)
{
        return retryBlock(&NIVisa::writeBlockU32impl, address, data32, nitems, props, dstatus);
}

int NIVisa::writeBlockU64(unsigned long address, uint64_t* data64, long nitems, TransferProps props, DAEstatus& dstatus)
{
        return retryBlock(&NIVisa::writeBlockU64impl, address, data64, nitems, props, dstatus);
}

int NIVisa::writeBlockU64impl(unsigned long address, uint64_t* data64, long nitems, TransferProps props, DAEstatus& dstatus)
{
        return writeBlockU32impl(address, reinterpret_cast<isisU32_t*>(data64), 2 * nitems, props, dstatus);
}

// nove nitems of 4 bytes
int NIVisa::writeBlockU32impl(unsigned long address, isisU32_t* data32, long nitems, TransferProps props, DAEstatus& dstatus)
{
        VisaAccessLock visa_lock;
        bool little_endian = (props & ISISVME::TransferLittleEndian ? true : false);
        int i, nitems_max;
    ViStatus status;
        ViSession session;
        unsigned long k = address;
        if (nitems_max_default > 0)
        {
                nitems_max = nitems_max_default;
        }
        else
        {
                nitems_max = nitems;
        }
        int nitems_left = nitems;
        int n;
        bool error_signalled = false;
        session = getSession(props);
        isisU32_t *data32_tmp = NULL;
    if (m_endian_workaround && little_endian)
        {
                data32_tmp = new isisU32_t[nitems];
            for(i=0; i<nitems; i++)
                {
                        data32_tmp[i] = (((data32[i]) << 24) & 0xff000000) | 
                                (((data32[i]) <<  8) & 0x00ff0000) |
                                (((data32[i]) >>  8) & 0x0000ff00) |
                                (((data32[i]) >> 24) & 0x000000ff);
                }
                data32 = data32_tmp;
        }
        while(!error_signalled && (nitems_left > 0))
        {
                n = (nitems_left > nitems_max ? nitems_max : nitems_left);
                if (false /* n == 1 */ )
                {
                        status = viOut32(session, VI_A32_SPACE, address, *data32);
                }
                else
                {
                        status = viMoveOut32(session, VI_A32_SPACE, address, n, data32);
                }
                if (status != VI_SUCCESS)
                {
                        addError(session, "viMoveOut32", status, address, n, "", dstatus);
                        error_signalled = true;
                }
                nitems_left -= n;
                data32 += n;
                address += (4*n);
        }
        if (data32_tmp != NULL)
        {
            delete[] data32_tmp;
                data32_tmp = NULL;
        }
        if (error_signalled)
        {
                return ISISVME::Error;
        }
        else
    {
                return ISISVME::Success;
    }
}

int NIVisa::setEndian(ViSession session, bool little_endian, DAEstatus& dstatus)
{
        VisaAccessLock visa_lock;
    ViStatus status;
    ViUInt16 order;
        if (little_endian)
        {
                order = VI_LITTLE_ENDIAN;
        }
        else
        {
                order = VI_BIG_ENDIAN;
        }
    status = viSetAttribute(session, VI_ATTR_DEST_BYTE_ORDER, order);
    if (status == VI_SUCCESS)
    {
        status = viSetAttribute(session, VI_ATTR_SRC_BYTE_ORDER, order);
    }
// we do not use viPeek() and viPoke() and so shoul dnot need to set this
//    if (status == VI_SUCCESS)
//    {
//        status = viSetAttribute(session, VI_ATTR_WIN_BYTE_ORDER, order);
//    }
    if (status == VI_SUCCESS)
    {
                return ISISVME::Success;
    }
    else
    {
                addError(session, "viSetAttribute(ENDIAN)", status, "", dstatus);
                return ISISVME::Error;
    }
}

int NIVisa::enableBlockTransfers(ViSession session, DAEstatus& dstatus)
{
        VisaAccessLock visa_lock;
    ViStatus status;
    ViUInt16 priv = VI_BLCK_PRIV;
        if (m_block_transfers)
        {
        status = viSetAttribute(session, VI_ATTR_DEST_ACCESS_PRIV, priv);
        if (status == VI_SUCCESS)
                {
            status = viSetAttribute(session, VI_ATTR_SRC_ACCESS_PRIV, priv);
                }
                if (status == VI_SUCCESS)
                {
                        return ISISVME::Success;
                }
                else
                {
                        addError(session, "viSetAttribute(BLCK_PRIV)", status, "", dstatus);
                        return ISISVME::Error;
                }
        }
        return ISISVME::Success;
}

int NIVisa::disableBlockTransfers(ViSession session, DAEstatus& dstatus)
{
        VisaAccessLock visa_lock;
    ViStatus status;
    ViUInt16 priv = VI_DATA_PRIV;
//      if (m_block_transfers)
//      {
        status = viSetAttribute(session, VI_ATTR_DEST_ACCESS_PRIV, priv);
        if (status == VI_SUCCESS)
                {
                        status = viSetAttribute(session, VI_ATTR_SRC_ACCESS_PRIV, priv);
                }
                if (status == VI_SUCCESS)
                {
                        return ISISVME::Success;
                }
                else
                {
                        addError(session, "viSetAttribute(DATA_PRIV)", status, "", dstatus);
                        return ISISVME::Error;
                }
//      }
        return ISISVME::Success;
}

int NIVisa::restoreTransferMode(ViSession session, int mode, DAEstatus& dstatus)
{
        VisaAccessLock visa_lock;
    ViStatus status;
        ViUInt16 priv = mode;
    status = viSetAttribute(session, VI_ATTR_DEST_ACCESS_PRIV, priv);
    if (status == VI_SUCCESS)
        {
                status = viSetAttribute(session, VI_ATTR_SRC_ACCESS_PRIV, priv);
        }
        if (status == VI_SUCCESS)
        {
                return ISISVME::Success;
        }
        else
        {
                addError(session, "restoreTransferMode", status, "", dstatus);
                return ISISVME::Error;
        }
}

int NIVisa::close(DAEstatus& dstatus)
{
        VisaAccessLock visa_lock;
        ICPCritical cs(&m_visa_critical);
        unlockDevice(dstatus);
        ViStatus status;
    if (m_instr_le != VI_NULL)
    {
        status = viClose(m_instr_le);
        m_instr_le = VI_NULL;
    }
    if (m_instr_be != VI_NULL)
    {
        status = viClose(m_instr_be);
        m_instr_be = VI_NULL;
    }
    if (m_instr_le_bt != VI_NULL)
    {
        status = viClose(m_instr_le_bt);
        m_instr_le_bt = VI_NULL;
    }
    if (m_instr_be_bt != VI_NULL)
    {
        status = viClose(m_instr_be_bt);
        m_instr_be_bt = VI_NULL;
    }
        if (m_instr_backplane != VI_NULL)
    {
                status = viDisableEvent(m_instr_backplane, VI_EVENT_TRIG, VI_ALL_MECH);
                status = viUninstallHandler(m_instr_backplane, VI_EVENT_TRIG, TriggerHandler, this);
        status = viClose(m_instr_backplane);
        m_instr_backplane = VI_NULL;
    }
        m_init_done = false;
        return ISISVME::Success;
}

int NIVisa::scanBus(DAEstatus& dstatus)
{
        VisaAccessLock visa_lock;
        ICPCritical cs(&m_visa_critical);
        std::ostringstream message;
        ViStatus status;
    ViChar descr[VI_FIND_BUFLEN];
    ViUInt32 i, numInstrs;
    ViFindList fList;
    status = viFindRsrc(m_default_rm, "?*VXI[0-9]*::?*INSTR?*",
                                                &fList, &numInstrs, descr);
    if (status != VI_SUCCESS)
        {
                addError(m_default_rm, "viFindRsc ( ?*VXI[0-9]*::?*INSTR?* )", status, "", dstatus);
        }
        if (numInstrs == 0)
        {
                dstatus.add(FAC_NIVISA, SEV_ERROR, ERRTYPE_NIVISA, "No VME devices found");
        }
        i = numInstrs;
    while(i--)
    {
                message << descr << '\n';
                viFindNext(fList, descr);
    }
        dstatus.addInfo(FAC_NIVISA, message.str());
    viClose(fList);
        return numInstrs;
}

bool NIVisa::resetBus(DAEstatus& dstatus)
{
//      resetBusDevice("VXI0::1::INSTR");
        VisaAccessLock visa_lock;
        ICPCritical cs(&m_visa_critical);
        ViStatus status;
        ViInt16 state;
        status = viAssertUtilSignal(m_instr_backplane, VI_UTIL_ASSERT_SYSRESET);
    if (status != VI_SUCCESS)
        {
                addError(m_instr_backplane, "viAssertUtilSignal(ASSERT_SYSRESET)", status, "", dstatus);
                return false;
        }
// During a SYSRESET devices assert SYSFAIL while their power up
// tests are being done. SYSFAIL must be asserted within 50ms of the
// start of the SYSRESET and remains asserted until reset is complete
        Sleep(200);
    bool reset_done = false;
        while(!reset_done)
        {
        status = viGetAttribute(m_instr_backplane, VI_ATTR_VXI_VME_SYSFAIL_STATE, &state);
        if (status != VI_SUCCESS)
                {
                        addError(m_instr_backplane, "viGetAttribute(SYSFAIL_STATE)", status, "", dstatus);
                        return false;
                }
            if (state == 0 /*VI_STATE_DEASSERTED*/ )
                {
                        reset_done = true;
                }
                else
                {
                        dstatus.addInfo(FAC_NIVISA, "VISA: Waiting for SYSFAIL to be removed from backplane");
                        Sleep(1000);
                }
        }
        return true;
}

bool NIVisa::resetBusDevice(const char* name, DAEstatus& dstatus)
{
        VisaAccessLock visa_lock;
        std::ostringstream message;
        ViStatus status;
        ViSession instr;
        ViUInt16 data16;
        unsigned enableA32;
        ICPCritical cs(&m_visa_critical);
    status = viOpen(m_default_rm, (char*)name, VI_NULL, 
                                        VI_NULL, &instr);
    if (status != VI_SUCCESS)
        {
                message << "viOpen " << name << " " << status << std::endl;
                dstatus.add(FAC_NIVISA, SEV_ERROR, ERRTYPE_NIVISA, message.str());
                return false;
        }
// read VME status/control register
        status = viIn16(instr, VI_A16_SPACE, 0x4, &data16);
    if (status != VI_SUCCESS)
        {
                message << "viOIn16 " << name << " " << status << std::endl;
                dstatus.add(FAC_NIVISA, SEV_ERROR, ERRTYPE_NIVISA, message.str());
                return false;
        }
    enableA32 = data16 & (1 << 15);
//      std::cerr << "VMEreset: a32 is " << enableA32 << std::endl;
// start board reset
        viOut16(instr, VI_A16_SPACE, 0x4, 0xffff);
//      wait at least 100 usec
        Sleep(1);
// end board reset
        viOut16(instr, VI_A16_SPACE, 0x4, 0xfffe);
// check bits 2 and 3 set
        viIn16(instr, VI_A16_SPACE, 0x4, &data16);
        if ((data16 & 0xc) != 0xc)
        {
                message << "VME reset failed 0x" << std::hex << data16 << std::dec << std::endl;
                dstatus.add(FAC_NIVISA, SEV_ERROR, ERRTYPE_NIVISA, message.str());
        }
// reset A32 mode
        viOut16(instr, VI_A16_SPACE, 0x4, 0x7ffc | enableA32);
    viClose(instr);    
        return true;
}

NIVisa::~NIVisa()
{
        ViStatus status;
        DAEstatus dstatus;
    close(dstatus);
        if (m_default_rm != VI_NULL)
    {
        status = viClose(m_default_rm);
        m_default_rm = VI_NULL;
    }
        DeleteCriticalSection(&m_job_critical);
        DeleteCriticalSection(&m_visa_critical);
}

int NIVisa::addError(ViSession session, const char* func, ViStatus status, const std::string& message, DAEstatus& dstatus)
{
        std::ostringstream oss;
        oss << message << '\n';
        printError(session, func, status, oss);
        dstatus.add(FAC_NIVISA, SEV_ERROR, ERRTYPE_NIVISA, oss.str());
        return 0;
}

int NIVisa::addError(ViSession session, const char * func, ViStatus status,
                                         unsigned long address, long nitems, const std::string& message, DAEstatus& dstatus)
{
        std::ostringstream oss;
        oss << message << '\n';
        printError(session, func, status, address, nitems, oss);
        dstatus.add(FAC_NIVISA, SEV_ERROR, ERRTYPE_NIVISA, oss.str());
        return 0;
}

int NIVisa::printError(ViSession session, const char * func, ViStatus status, std::ostream& os)
{
    ViChar desc[512];
    if (viStatusDesc(session, status, desc) == VI_SUCCESS)
    {
                os << "NIVISA: Error \"" << desc << "\" returned from \"" << func << "\"";
    }
    else
    {
                os << "NIVISA: Unknown Error code " << status << " returned from \"" << func << "\"";
    }
        return 0;
}

int NIVisa::printError(ViSession session, const char * func, ViStatus status,
                                           unsigned long address, long nitems, std::ostream& os)
{
    ViChar desc[512];  // needs to be at least 256 bytes according to NI manual
        desc[0] = '\0';
    if (viStatusDesc(session, status, desc) == VI_SUCCESS)
    {
                os << "NIVISA: Error \"" << desc << "\" (code 0x" << std::hex << status << std::dec << ") returned from \"" << func << "\" " 
                        << " while transferring " << nitems << " items at VME address 0x" 
                        << std::hex << address << std::dec;
    }
    else
    {
                os << "NIVISA: Unknown Error code " << status << " returned from \"" << func << "\"";
    }
        return 0;
}

int NIVisa::writeBlock(unsigned long address, isisU32_t* data, long nitems, TransferProps props, DAEstatus& status)
{
        return writeBlockU32(address, data, nitems, props, status);
}

int NIVisa::writeBlock(unsigned long address, uint64_t* data, long nitems, TransferProps props, DAEstatus& status)
{
        return writeBlockU64(address, data, nitems, props, status);
}

int NIVisa::readBlock(unsigned long address, isisU32_t* data, long nitems, TransferProps props, DAEstatus& status)
{
        return readBlockU32(address, data, nitems, props, status);
}

int NIVisa::readBlock(unsigned long address, uint64_t* data, long nitems, TransferProps props, DAEstatus& status)
{
        return readBlockU64(address, data, nitems, props, status);
}

#if 0
at startup
status = ViLock(instr, VI_SHARED_LOCK, 15000, "DAE2VMELock", accessKey);
// accessKey should now be "DAE2VMELock"
// before write
// not sure which pf these to use
ViLock(instr, VI_LOCK_EXCLUSIVE, 5000, "DAE2VMELock", VI_NULL)
ViLock(instr, VI_LOCK_EXCLUSIVE, 5000, VI_NULL, VI_NULL)
#endif

const int NIVisa::m_tries = 5;
const int NIVisa::m_retry_time = 1000;
bool NIVisa::m_endian_workaround = true;
char* NIVisa::m_visa_lock_name = NULL;