Subversion Repositories f9daq

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

//

#include <utility.h>

#include <stdlib.h>

#include <stdio.h>

#include "AitMduManager.h"

#include "AitMduManager_DEF.h"

//Unhandled Exception: System.Runtime.InteropServices.MarshalDirectiveException: 

//Cannot marshal 'return value': Invalid managed/unmanaged type combination.

#ifdef _CVI_

#include <ansi_c.h>

#define AddMessageI(x) AddMessage("%s %d\n", #x, x);

#define AddMessageF(x) AddMessage("%s %f\n", #x, x);

#define AddMessageX(x) AddMessage("%s 0x%x\n", #x, x);

#define AddMessageS(x) AddMessage("%s %s\n", #x, x);   

int sprintf_s(const char *dest, int len, const char *format, ...) {

        va_list aptr;

        int ret;

        va_start(aptr, format);

        ret = vsnprintf(dest, len, format, aptr);

        va_end(aptr);

        return(ret);

}

#endif

typedef unsigned short ushort;

typedef unsigned int uint;

#ifdef __cplusplus

extern "C"

{

#endif

        __declspec(dllimport) void NE_Rainbow();

#ifdef __cplusplus

}

#endif

#ifndef _CVI_

#ifdef _DEBUG

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

#else

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

#endif

#endif

                //private MduManager SD4;

                uint deviceId = 0;

        int deviceIndex = -1;

        int adcBufferLen;

        ushort *adcBuffer;

        int histograms[4][0xFFF];

        int histogramtotal[0xFFF * 4];

        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";

        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

        void Sleep(int musec) {

      Delay(musec/1000.);

        }

        /*

                void AddMessage( const char * message)

                {

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

                }

                */

        int AddMessage(const char *format, ...) {

                va_list aptr;

                int ret;

                char strbuf[0xFF];

                va_start(aptr, format);

                ret = vsprintf(strbuf, format, aptr);

                va_end(aptr);

                //  SetCtrlVal(p1h,P1_STDIO,strbuf);

                printf("%s", strbuf);

                return(ret);

        }

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

        // 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/2;

}

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 = 28.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();

                AddMessageF(lHvImon);

                AddMessageF(HvVmon);

                AddMessageF(HvVmax);

                AddMessageF(lDetPva);

                AddMessageF(lDetNva);

                AddMessageF(lPva);

                AddMessageF(lNva);

                AddMessageF(l12V);

                AddMessageF(l33V);

                AddMessageF(l50V);

                AddMessageF(Temperature);

                AddMessageF(lRampRate);

                // 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);

                AddMessageF(lOffset1);

                AddMessageF(lOffset2);

                AddMessageF(lOffset3);

                AddMessageF(lOffset4);

                AddMessageF(lSumOffset);

                AddMessageX(csrMain);

                AddMessageX(lNvaStatus);

                AddMessageX(lNvaStatus);

                AddMessageX(l12vStatus);

                AddMessageX(l33vStatus);

                AddMessageX(l5vStatus);

                AddMessageI(lBufferWords);

                AddMessageI(lItime);

                // 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);

                addTimeStamp = GetBit(csrEventId, BIT_EVENTID_TIME);

                addEventCount = GetBit(csrEventId, BIT_EVENTID_COUNT);

                addChannelNum = GetBit(csrEventId, BIT_EVENTID_CHNUM);

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

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

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

                AddMessageS(lTriggerSource);

                AddMessageI(addTimeStamp);

                AddMessageI(addEventCount);

                AddMessageI(addEventCount);

                // 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();

                AddMessageI(lTriggerInterval);

                AddMessageI(lTrigCount);

                AddMessageI(lTriggers);

                AddMessageI(lTriggerRate);

                AddMessageI(lAdcConversions);

                AddMessageF(lThreshold);

                AddMessageF(lHvIlimit);

                AddMessageF(lHvVoltage);

                // 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);

    AddMessageI(lHvEnabled);

    AddMessageI(lHvOn);

    AddMessageI(lSumCoupling);

    AddMessageI(lSumGain);

    AddMessageI(lAdcCoupling);

    AddMessageI(lAdcGain );

    AddMessageI(lAmpEnabled);

    AddMessageI(lAmpLevel);

    AddMessageI(lDetPvaStatus );

    AddMessageI(lDetNvaStatus);

    AddMessageI(lTemperatureOn);

        }

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

        // Message list

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

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

        // 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

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

        void GetDeviceId() {

                deviceIndex = 0;

                deviceId = 1;

                /*

                if (tscbDeviceList.SelectedIndex >= 0)

                {

                 deviceIndex = 0; // tscbDeviceList.SelectedIndex;

                 deviceId = 1;  //UInt32.Parse((string)tscbDeviceList.SelectedItem, System.Globalization.NumberStyles.HexNumber);

                }

                else

                {

                 deviceIndex = -1;

                 deviceId = 0;

                }

                */

        }

        int UpdateDeviceList()

{