Subversion Repositories f9daq

// NativeExportsConsumerApp.cpp : Defines the entry point for the console application.

//

#include "stdafx.h"

#include <string.h>

#include <windows.h>

#include "AitMduManager.h"

#include "AitMduManager_DEF.h"

typedef unsigned short ushort;

typedef unsigned int uint;

extern "C"

{

        DLLIMPORT  void NE_Rainbow();

        DLLIMPORT  int  NE_Func(int a);

        DLLIMPORT  int  NE_Ptr2ByteArray(char *, int len);

        DLLIMPORT  char * NE_ByteArray2Ptr(char *, int *);

        DLLIMPORT  int  NE_Ptr2String(char *, int len);

        DLLIMPORT  int  NE_String2Ptr(char *);

        DLLIMPORT  char * NE_String();

        DLLIMPORT  unsigned int * NE_UInt(int *);

}

#ifdef _DEBUG

#pragma comment(lib, "../UnmanagedDllInterface/bin/Debug/AitSipmDAQDll.lib")

#else

#pragma comment(lib, "../UnmanagedDllInterface/bin/Release/AitSipmDAQDll.lib")

#endif

uint deviceId = 0;

int deviceIndex = -1;

int adcBufferLen;

ushort * adcBuffer;

int histograms[4][0xFFF];

int histogramTotalEvents = 0;

const double MONADC_SCALE = 65535.0;                    // 16-bit monitor ADC

const double DAC_SCALE = 65535.0;                       // 16-bit DAC

const double MONADC_VRANGE = 2.5;                       // 2.5V ADC voltage range

const double DISCR_OFFSETRANGE = 250.0;         // +/- 250mV discriminator offset range

const double DISCR_THRESHOLDRANGE = 1000.0;     // 0-1000mV discriminator threshold range

const double HV_IRANGE = 5.0;                           // 0-5.0mA HV current monitor range

const double HV_VRANGE = 80.0;                          // 0-80V HV voltage control range

const int INTEGRATOR_LSB = 10;                          // 10ns integrator time resolution

const double RAMPRATESCALE = 61036.0;           // Ramp rate register setting = (rate in V/s) / RAMPRATESCALE

const char statusNoDevice[0xFF] = "No Device Connected";

const char statusReconfig[0xFF] = "Reconfiguring Device ... ";

const char statusReset[0xFF] = "Resetting Device ... ";

const char statusReconnect[0xFF] = "Reconnecting Device ... ";

const char statusDone[0xFF] = "Done";

/*

void Sleep(int musec) {

}

*/

//----------------------------------------

// Utilities

//----------------------------------------

ushort SetBit(ushort data, int bitIndex, bool bitValue)

{

        if (bitValue == true)

                return (ushort)(data | (1 << bitIndex));

        else

                return (ushort)(data & ~(1 << bitIndex));

}

bool GetBit(int data, int bitIndex)

{

        return (data & (1 << bitIndex)) != 0;

}

ushort ReadSD4Register(int reg)

{

        return SD4_Read(deviceId, reg);

}

uint ReadSD4Register32(int addrHi, int addrLo)

{

        uint dataHi = (uint)SD4_Read(deviceId, addrHi);

        uint dataLo = (uint)SD4_Read(deviceId, addrLo);

        return (dataHi << 16) | dataLo;

}

void WriteSD4Register(int address, ushort data)

{

        SD4_Write(deviceId, address, data);

}

void WriteSD4Register32(int addrHi, int addrLo, uint data)

{

        WriteSD4Register(addrHi, (ushort)(data >> 16));

        WriteSD4Register(addrLo, (ushort)data);

}

void ReadModifyWrite(int reg, int bitIndex, bool bitValue)

{

        ushort regData = ReadSD4Register(reg);

        regData = SetBit(regData, bitIndex, bitValue);

        WriteSD4Register(reg, regData);

}

double LimitSetting(double value, double min, double max)

{

        double limited = value;

        if (limited > max) limited = max;

        if (limited < min) limited = min;

        return limited;

}

int ReadAdcBuffer()

{

        //if (adcBuffer == NULL)

        //      return -1;

        int bytes = 0;

        //printf("In\n%d\n%d\n%d\n", deviceId, ADDR_BUFFER, adcBufferLen);

        adcBuffer = SD4_ReadUShortArray(deviceId, ADDR_BUFFER, adcBufferLen, &bytes);

        return bytes;

}

// Equivalent to ReadAdcBuffer() except using byte buffer for acquisition

int ReadAdcByteBuffer()

{

        if (adcBuffer == NULL)

                return -1;

        int bytes = 0;

        char * byteBuffer = SD4_ReadByteArray(deviceId, ADDR_BUFFER, adcBufferLen * 2, &bytes);

        int byteIndex = 0;

        int words = bytes / 2;

        ushort dataword = 0;

        for (int i = 0; i < words; i++)

        {

                dataword = (ushort)(byteBuffer[byteIndex++] << 8);

                adcBuffer[i] = (ushort)(dataword | byteBuffer[byteIndex++]);

        }

        return words;

}

//----------------------------------------

// Monitor ADC

//----------------------------------------

double GetVoltage(int reg)

{

        return ReadSD4Register(reg) * MONADC_VRANGE / MONADC_SCALE;

}

double GetDetectorTemperature()

{

        // Temperature = 500mV + 1mV per degree C

        return (GetVoltage(ADDR_BASE_TEMPERATURE) - 0.5) / 0.01;

}

double GetHvVoltage(int reg)

{

        return GetVoltage(reg) / MONADC_VRANGE * HV_VRANGE;

}

double GetHvCurrentInUa()

{

        // 2.5V ADC input voltage = 5000 microamps

        return GetVoltage(ADDR_HV_IMON) * 2000.0;

}

double GetVoltage75(int reg)

{

        // 2.5V ADC input voltage = 7.5V monitor voltage

        return GetVoltage(reg) * 3.0;

}

//----------------------------------------

// Discriminator, Sum

//----------------------------------------

void SetSumGain(int gain)

{

        ushort csrDetector = ReadSD4Register(ADDR_CSR_DETECTOR);

        bool g1 = GetBit(gain, 0);

        bool g2 = GetBit(gain, 1);

        bool g3 = GetBit(gain, 2);

        bool g4 = GetBit(gain, 3);

        csrDetector = SetBit(csrDetector, BIT_CSR_DET_SUMGAIN1, g1);

        csrDetector = SetBit(csrDetector, BIT_CSR_DET_SUMGAIN2, g2);

        csrDetector = SetBit(csrDetector, BIT_CSR_DET_SUMGAIN3, g3);

        csrDetector = SetBit(csrDetector, BIT_CSR_DET_SUMGAIN4, g4);

        WriteSD4Register(ADDR_CSR_DETECTOR, (ushort)csrDetector);

}

void SetSumCoupling(bool acCoupling)

{

        ReadModifyWrite(ADDR_CSR_DETECTOR, BIT_CSR_DET_SUMCOUPLING, acCoupling);

}

void SetThreshold(double thresholdInMillivolts)

{

        thresholdInMillivolts = LimitSetting(thresholdInMillivolts, -DISCR_THRESHOLDRANGE, DISCR_THRESHOLDRANGE);

        WriteSD4Register(ADDR_DISCR_THRESHOLD, (ushort)(thresholdInMillivolts * DAC_SCALE / DISCR_THRESHOLDRANGE));

}

double GetThreshold()

{

        return ReadSD4Register(ADDR_DISCR_THRESHOLD) / DAC_SCALE * DISCR_THRESHOLDRANGE;

}

double GetSumOffsetInMv()

{

        // Sum offsets are with respect to the positive sum output polarity.

        return (ReadSD4Register(ADDR_DISCR_OFFSET) / DAC_SCALE * (DISCR_OFFSETRANGE * 2)) - DISCR_OFFSETRANGE;

}

void SetSumOffset(double milliVolts)

{

        // Sum offsets are with respect to the positive sum output polarity.

        // Actual output offset is multiplied by the selectable gain stage.

        WriteSD4Register(ADDR_DISCR_OFFSET, (ushort)((milliVolts + DISCR_OFFSETRANGE) * DAC_SCALE / (DISCR_OFFSETRANGE * 2)));

}

//----------------------------------------

// Trigger

//----------------------------------------

void SetTriggerInterval(int triggerInterval)

{

        WriteSD4Register32(ADDR_TG_INTERVALHI, ADDR_TG_INTERVALLO, (uint)(triggerInterval / INTEGRATOR_LSB));

}

void SetTriggerBurst(int triggerBurst)

{

        WriteSD4Register32(ADDR_TG_COUNTHI, ADDR_TG_COUNTLO, (uint)triggerBurst);

}

void EnableTrigger(int bitIndex)

{

        WriteSD4Register(ADDR_CSR_TRIGGER, SetBit(0, bitIndex, true));

}

void DisableTriggers()

{

        WriteSD4Register(ADDR_CSR_TRIGGER, 0);

}

void SetDeadTime(int deadTimeInNs)

{

        WriteSD4Register(ADDR_DEADTIME, (ushort)(deadTimeInNs / INTEGRATOR_LSB));

}

//----------------------------------------

// Integrators, ADCs

//----------------------------------------

void SetIntegrationTime(int integrationTime)

{

        WriteSD4Register(ADDR_ITIME, (ushort)(integrationTime / INTEGRATOR_LSB));

}

int GetIntegrationTime()

{

        return ReadSD4Register(ADDR_ITIME) * INTEGRATOR_LSB;

}

void SetAdcCoupling(bool acCoupling)

{

        ReadModifyWrite(ADDR_CSR_DETECTOR, BIT_CSR_DET_ADCCOUPLING, acCoupling);

}

void ResetAdc(bool reset)

{

        ushort cmd = 0;

        cmd = SetBit(cmd, BIT_CSR_MAIN_ADCRESET, reset);

        WriteSD4Register(ADDR_CSR_MAIN, cmd);

}

double GetAdcOffsetInMv(int reg)

{

        // ADC offset polarity is with respect to the positive ADC polarity (integrator output), not the main negative input signal polarity.

        // Actual output offset is multiplied by the selectable gain stage.

        return DISCR_OFFSETRANGE - (ReadSD4Register(reg) / DAC_SCALE * (DISCR_OFFSETRANGE * 2));

}

void SetAdcOffset(int reg, double milliVolts)

{

        // ADC offset polarity is with respect to the positive ADC polarity (integrator output), not the main negative input signal polarity.

        // Actual output offset is multiplied by the selectable gain stage.

        WriteSD4Register(reg, (ushort)((DISCR_OFFSETRANGE - milliVolts) * DAC_SCALE / (DISCR_OFFSETRANGE * 2)));

}

//----------------------------------------

// Event ID

//----------------------------------------

void AddEventCount(bool addEventCount)

{

        ReadModifyWrite(ADDR_EVENTID, BIT_EVENTID_COUNT, addEventCount);

}

void AddTimeStamp(bool addTimeStamp)

{

        ReadModifyWrite(ADDR_EVENTID, BIT_EVENTID_TIME, addTimeStamp);

}

void AddChannelNumber(bool addChannelNumber)

{

        ReadModifyWrite(ADDR_EVENTID, BIT_EVENTID_CHNUM, addChannelNumber);

}

//----------------------------------------

// Detector VA

//----------------------------------------

void SetDetectorVaOn(bool on)

{

        ReadModifyWrite(ADDR_CSR_DETECTOR, BIT_CSR_DET_VAENABLE, on);

}

void SetDetectorVaHiRange(bool range)

{

        ReadModifyWrite(ADDR_CSR_DETECTOR, BIT_CSR_DET_VAHIRNG, range);

}

//----------------------------------------

// High Voltage

//----------------------------------------

void SetHvCurrentLimit(double milliamps)

{

        milliamps = LimitSetting(milliamps, 0, HV_IRANGE);

        WriteSD4Register(ADDR_HV_ILIMIT, (ushort)(milliamps * DAC_SCALE / HV_IRANGE));

}

void SetHvVoltage(int reg, double volts)

{

        volts = LimitSetting(volts, 0, HV_VRANGE);

        WriteSD4Register(reg, (ushort)(volts * DAC_SCALE / HV_VRANGE));

}

double GetHvIlimitSetting()

{

        return ReadSD4Register(ADDR_HV_ILIMIT) / DAC_SCALE * HV_IRANGE;

}

double GetHvVoltageSetting()

{

        return ReadSD4Register(ADDR_HV_CTRL) / DAC_SCALE * HV_VRANGE;

}

void SetHvOn(bool hvOn)

{

        ReadModifyWrite(ADDR_CSR_DETECTOR, BIT_CSR_DET_HVENABLE, hvOn);

}

void SetMaximumHvSetting(double volts)

{

        SetHvVoltage(ADDR_HV_MAX, volts);

}

void CycleHvReset()

{

        // CAUTION: Holding HV in reset will force it to ignore the current limit

        ReadModifyWrite(ADDR_CSR_DETECTOR, BIT_CSR_DET_HVRESET, true);

        ReadModifyWrite(ADDR_CSR_DETECTOR, BIT_CSR_DET_HVRESET, false);

}

void SetRampRate(double voltsPerSecond)

{

        WriteSD4Register(ADDR_HV_RAMPRATE, (ushort)(RAMPRATESCALE / voltsPerSecond));

}

double GetRampRate()

{

        return RAMPRATESCALE / (ReadSD4Register(ADDR_HV_RAMPRATE) + 1);

}

void SetAdcGain(int gain)

{

        ushort csrDetector = ReadSD4Register(ADDR_CSR_DETECTOR);

        bool g1 = GetBit(gain, 0);

        bool g2 = GetBit(gain, 1);

        csrDetector = SetBit(csrDetector, BIT_CSR_DET_ADCGAIN1, g1);

        csrDetector = SetBit(csrDetector, BIT_CSR_DET_ADCGAIN2, g2);

        WriteSD4Register(ADDR_CSR_DETECTOR, (ushort)csrDetector);

}

void SetAdcOffsets(int offsetInMv)

{

        //nudOffset1.Value = offsetInMv;

        //nudOffset2.Value = offsetInMv;

        //nudOffset3.Value = offsetInMv;

        //nudOffset4.Value = offsetInMv;

        SetAdcOffset(ADDR_OFFSET1, offsetInMv);

        SetAdcOffset(ADDR_OFFSET2, offsetInMv);

        SetAdcOffset(ADDR_OFFSET3, offsetInMv);

        SetAdcOffset(ADDR_OFFSET4, offsetInMv);

}

void QuickSetupContinuous()

{

        // Set ADC reset

        ResetAdc(true);

        // Clear ADC reset

        ResetAdc(false);

        // Set trigger dead time to 200ns

        SetDeadTime(200);

        // Set event ID

        AddTimeStamp(true);

        AddEventCount(true);

        AddChannelNumber(true);

        // Enable detector amplifier voltage

        SetDetectorVaHiRange(false);

        SetDetectorVaOn(true);

        /*

        // Set HV current limit

        double iLimit = 2.5;

        nudHvIlimit.Value = (decimal)iLimit;

        SetHvCurrentLimit(iLimit);

        // Reset any HV faults

        CycleHvReset();

        // Enable bias voltage

        SetHvOn(false);

        SetHvOn(true);

        // Set bias voltage

        double hvVoltage = 30.0;

        nudHvVoltage.Value = (decimal)hvVoltage;

        SetHvVoltage(ADDR_HV_CTRL, hvVoltage);

        */

        // Set integration time

        int integrationTime = 350;

        //nudIntegrationTime.Value = integrationTime;

        SetIntegrationTime(integrationTime);

        // Set discriminator threshold

        int threshold = 50;

        //nudThreshold.Value = threshold;

        SetThreshold(threshold);

        // Set sum coupling

        SetSumCoupling(true);

        // Set sum gain

        int sumGain = 3;

        //nudSumGain.Value = sumGain;

        SetSumGain(sumGain);

        // Set sum offset

        int offset = 0;

        //nudSumOffset.Value = offset;

        SetSumOffset(offset);

        // Set ADC coupling

        SetAdcCoupling(false);

        // Set ADC gains

        int gain = 1;

        //nudAdcGain.Value = gain;

        SetAdcGain(gain);

        // Set all ADC offsets

        SetAdcOffsets(5);

        // Set internal trigger interval

        int triggerInterval = 1000;

        //nudTriggerInterval.Value = triggerInterval;

        SetTriggerInterval(triggerInterval);

        // Enable continuous trigger

        EnableTrigger(BIT_CSR_TRIG_CONTINUOUS);

        // Begin continuous acquisition

        //nudEventsPerAcquisition.Value = 50000;

        //cbAcquireContinuous.Checked = true;

        // Update histogram offsets

        //SetAllHistogramOffsets(0);

}

void QuickSetupDiscriminator()

{

        // Set ADC reset

        ResetAdc(true);

        // Clear ADC reset

        ResetAdc(false);

        // Set trigger dead time to 300ns

        SetDeadTime(500);

        // Set event ID

        AddTimeStamp(true);

        AddEventCount(true);

        AddChannelNumber(true);

        // Enable detector amplifier voltage

        SetDetectorVaHiRange(true);

        SetDetectorVaOn(true);

        // Set HV current limit

        double iLimit = 2.5;

        //nudHvIlimit.Value = (decimal)iLimit;

        SetHvCurrentLimit(iLimit);

        // Reset any HV faults

        CycleHvReset();

        // Enable bias voltage

        SetHvOn(false);

        SetHvOn(true);

        // Set bias voltage

        double hvVoltage = 30.0;

        //nudHvVoltage.Value = (decimal)hvVoltage;

        SetHvVoltage(ADDR_HV_CTRL, hvVoltage);

        // Set integration time

        int integrationTime = 350;

        //nudIntegrationTime.Value = integrationTime;

        SetIntegrationTime(integrationTime);

        // Set discriminator threshold

        int threshold = 50;

        //nudThreshold.Value = threshold;

        SetThreshold(threshold);

        // Set sum coupling

        SetSumCoupling(true);

        // Set sum gain

        int sumGain = 3;

        //nudSumGain.Value = sumGain;

        SetSumGain(sumGain);

        // Set sum offset

        int offset = 0;

        //nudSumOffset.Value = offset;

        SetSumOffset(offset);

        // Set ADC coupling

        SetAdcCoupling(false);

        // Set ADC gains

        int gain = 1;

        //nudAdcGain.Value = gain;

        SetAdcGain(gain);

        // Set all ADC offsets

        SetAdcOffsets(5);

        // Clear histograms

        //ClearHistograms();

        // Enable discriminator trigger

        EnableTrigger(BIT_CSR_TRIG_DISCR);

        // Begin continuous acquisition

        //nudEventsPerAcquisition.Value = 1000;

        //cbAcquireContinuous.Checked = true;

        // Update histogram offsets

        //SetAllHistogramOffsets(0);

}

void QuickSetupTriggerOff()

{

        //cbAcquireContinuous.Checked = false;

        DisableTriggers();

        SetHvOn(false);

        SetDetectorVaOn(false);

}

void ReadRegisters()

{

        if (deviceIndex < 0)

                return;

        // Voltages

        double lHvImon = GetHvCurrentInUa();

        double HvVmon = GetHvVoltage(ADDR_HV_VMON);

        double HvVmax = GetHvVoltage(ADDR_HV_MAX);

        double lDetPva = GetVoltage75(ADDR_BASE_PVA);

        double lDetNva = GetVoltage75(ADDR_BASE_NVA);

        double lPva = GetVoltage75(ADDR_MAIN_PVA);

        double lNva = GetVoltage75(ADDR_MAIN_NVA);

        double l12V = GetVoltage(ADDR_MAIN_P12);

        double l33V = GetVoltage75(ADDR_MAIN_P33);

        double l50V = GetVoltage75(ADDR_MAIN_P50);

        double Temperature = GetDetectorTemperature();

        double lRampRate = GetRampRate();

        // Integration time

        int lItime = GetIntegrationTime();

        // Buffer memory used

        int lBufferWords = ReadSD4Register(ADDR_BUFFERWORDS);

        // Offsets

        double  lOffset1 = GetAdcOffsetInMv(ADDR_OFFSET1);

        double  lOffset2 = GetAdcOffsetInMv(ADDR_OFFSET2);

        double  lOffset3 = GetAdcOffsetInMv(ADDR_OFFSET3);

        double  lOffset4 = GetAdcOffsetInMv(ADDR_OFFSET4);

        double  lSumOffset = GetSumOffsetInMv();

        // Main CSR

        int csrMain = ReadSD4Register(ADDR_CSR_MAIN);

        int lPvaStatus = GetBit(csrMain, BIT_CSR_MAIN_PVA);

        int lNvaStatus = GetBit(csrMain, BIT_CSR_MAIN_NVA);

        int l12vStatus = GetBit(csrMain, BIT_CSR_MAIN_P12);

        int l33vStatus = GetBit(csrMain, BIT_CSR_MAIN_P33);

        int l5vStatus = GetBit(csrMain, BIT_CSR_MAIN_P50);

        // Trigger CSR

        // Assumes only one trigger source is active

        char lTriggerSource[0xFF];

        int csrTrigger = ReadSD4Register(ADDR_CSR_TRIGGER);

        if (GetBit(csrTrigger, BIT_CSR_TRIG_CONTINUOUS))

                sprintf_s(lTriggerSource, 0xFF, "CONTINUOUS");

        else if (GetBit(csrTrigger, BIT_CSR_TRIG_BURST))

                sprintf_s(lTriggerSource, 0xFF, "BURST");

        else if (GetBit(csrTrigger, BIT_CSR_TRIG_DISCR))

                sprintf_s(lTriggerSource, 0xFF, "DISCRIMINATOR");

        else if (GetBit(csrTrigger, BIT_CSR_TRIG_EXTERNAL))

                sprintf_s(lTriggerSource, 0xFF, "EXTERNAL");

        else

                sprintf_s(lTriggerSource, 0xFF, "OFF");

        // Event ID CSR

        int csrEventId = ReadSD4Register(ADDR_EVENTID);

        int addTimeStamp = GetBit(csrEventId, BIT_EVENTID_TIME);

        int addEventCount = GetBit(csrEventId, BIT_EVENTID_COUNT);

        int addChannelNum = GetBit(csrEventId, BIT_EVENTID_CHNUM);

        //lTimeStamp.Text = addTimeStamp ? "+" : "";

        //lEventCount.Text = addEventCount ? "+" : "";

        //lChannelNum.Text = addChannelNum ? "+" : "";

        // Trigger generator

        int lTriggerInterval = ReadSD4Register32(ADDR_TG_INTERVALHI, ADDR_TG_INTERVALLO) * 10;

        int lTrigCount = ReadSD4Register32(ADDR_TG_COUNTHI, ADDR_TG_COUNTLO);

        ushort dum = 0;

        WriteSD4Register(ADDR_TC_COUNTLO, dum);         // latch counters by writing to any counter register

        int lTriggers = ReadSD4Register32(ADDR_TC_COUNTHI, ADDR_TC_COUNTLO);

        int lTriggerRate = ReadSD4Register32(ADDR_TC_RATEHI, ADDR_TC_RATELO);

        int lAdcConversions = ReadSD4Register32(ADDR_CONV_COUNTHI, ADDR_CONV_COUNTLO);

        double lThreshold = GetThreshold();

        double lHvIlimit = GetHvIlimitSetting();

        double lHvVoltage = GetHvVoltageSetting();

        // Detector CSR

        int csrDetector = ReadSD4Register(ADDR_CSR_DETECTOR);

        int lHvEnabled = GetBit(csrDetector, BIT_CSR_DET_HVENABLE);

        int lHvOn = GetBit(csrDetector, BIT_CSR_DET_HVGOOD);

        int lSumCoupling = GetBit(csrDetector, BIT_CSR_DET_SUMCOUPLING);

        int lSumGain =

                ((GetBit(csrDetector, BIT_CSR_DET_SUMGAIN4) ? 1 : 0) << 3) |

                ((GetBit(csrDetector, BIT_CSR_DET_SUMGAIN3) ? 1 : 0) << 2) |

                ((GetBit(csrDetector, BIT_CSR_DET_SUMGAIN2) ? 1 : 0) << 1) |

                ((GetBit(csrDetector, BIT_CSR_DET_SUMGAIN1) ? 1 : 0) << 0);

        int lAdcCoupling = GetBit(csrDetector, BIT_CSR_DET_ADCCOUPLING);

        int lAdcGain = ((GetBit(csrDetector, BIT_CSR_DET_ADCGAIN2) ? 1 : 0) << 1) |

                ((GetBit(csrDetector, BIT_CSR_DET_ADCGAIN1) ? 1 : 0) << 0);

        int lAmpEnabled = GetBit(csrDetector, BIT_CSR_DET_VAENABLE);

        int lAmpLevel = GetBit(csrDetector, BIT_CSR_DET_VAHIRNG);

        int lDetPvaStatus = GetBit(csrDetector, BIT_CSR_DET_PVAGOOD);

        int lDetNvaStatus = GetBit(csrDetector, BIT_CSR_DET_NVAGOOD);

        int lTemperatureOn = GetBit(csrDetector, BIT_CSR_DET_TEMPVALID);

}

//----------------------------------------

// Message list

//----------------------------------------

void AddMessage(const char * message)

{

        printf("%s\n", message);

}

//----------------------------------------

// MDU Events

//----------------------------------------

 /*

private void AitDeviceAttached(object sender, EventArgs e)

{

        MduManager.DeviceChangedEventArgs aitEventArgs = e as MduManager.DeviceChangedEventArgs;

        AddMessage(String.Format("Attached : Index={0}, ID={1:X8}", aitEventArgs.DeviceIndex, aitEventArgs.DeviceId));

        UpdateDeviceList();

}

private void AitDeviceRemoved(object sender, EventArgs e)

{

        MduManager.DeviceChangedEventArgs aitEventArgs = e as MduManager.DeviceChangedEventArgs;

        AddMessage(String.Format("Removed : Index={0}, ID={1:X8}", aitEventArgs.DeviceIndex, aitEventArgs.DeviceId));

        UpdateDeviceList();

}

*/

//----------------------------------------

// Device Control

//----------------------------------------

int UpdateDeviceList()

{

        deviceIndex = -1;

        deviceId = 0;

        int deviceCount = 0;

        uint * devIds = SD4_GetDeviceList(&deviceCount);

        for (int i = 0; i < deviceCount; i++) {

                printf("Device %d = 0x%8x\n", i, devIds[i]);

                deviceId = devIds[i];

                deviceIndex =     i;

        }

        return deviceCount;

}

void ResetDevice()

{

        if (deviceIndex >= 0)

        {

                AddMessage(statusReset);

                SD4_ResetFpga(deviceIndex);

                Sleep(500);

                UpdateDeviceList();

                AddMessage(statusReset);

                AddMessage(statusDone);

        }

        else

                AddMessage(statusNoDevice);

}

void ReconnectDevice()

{

        if (deviceIndex >= 0)

        {

                AddMessage(statusReconnect);

                SD4_Reconnect(deviceIndex);

                Sleep(500);

                AddMessage(statusReconnect);

                AddMessage(statusDone);

        }

        else

                AddMessage(statusNoDevice);

}

void ReconfigureDevice()

{

        if (deviceIndex >= 0)

        {

                AddMessage(statusReconfig);

                SD4_Reconfigure(deviceIndex);

                Sleep(500);

                SD4_ResetFpga(deviceIndex);

                UpdateDeviceList();

                AddMessage(statusReconfig);

                AddMessage(statusDone);

        }

        else

                AddMessage(statusNoDevice);

}

//----------------------------------------

// Initialize Device Connection

//----------------------------------------

void InitializeConnection()

{

        int ndevices = 0;

        unsigned int * devlist = SD4_FindDevices(&ndevices);

        printf("Found %d devices\n", ndevices);

        //SD4.DeviceAttached += new EventHandler(AitDeviceAttached);

        //SD4.DeviceRemoved += new EventHandler(AitDeviceRemoved);

        //tscbDeviceList.SelectedIndexChanged += new EventHandler(tscbDeviceList_SelectedIndexChanged);

        printf("Updated devices %d\n", UpdateDeviceList());

}

const int CHANNELS = 4;                 // 4-Channel DAQ

const int ADCMAX = 4096;                // 12-bit ADC

bool addTimeStamp = false;              // updated by ReadRegisters

bool addEventCount = false;             // updated by ReadRegisters

bool addChannelNum = false;             // updated by ReadRegisters

int TIMESTAMP_LSB = 10;                 // 10ns time stamp resolution

int GetAdcEventSize()

{

        int eventSize = CHANNELS;

        if (addTimeStamp == true)

                eventSize += 3;         // 3 16-bit words for time stamp

        if (addEventCount == true)

                eventSize += 2;         // 2 16-bit words for event count

        return eventSize;

}

int GetEventPosition(int eventNum)

{

        int adcBoardEventSize = GetAdcEventSize();