Exemple #1
0
        //===========================================================================
        /// <summary>
        /// Sub-class of DaqDevice that provides methods specific to the USB-2001-TC
        /// </summary>
        /// <param name="deviceInfo">A device info object</param>
        //===========================================================================
        internal Usb2001Tc(DeviceInfo deviceInfo)
            : base(deviceInfo, 0x200)
        {
            Ai = new Usb2001TcAi(this, deviceInfo);

            m_memLockAddr = 0x400;
            m_memUnlockCode = 0xAA55;
            m_memLockCode = 0xFFFF;

            // 5/27/2011: version 2.0
            m_defaultDevCapsImage = new byte[]
                {   0x1F,0x8B,0x08,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0xED,0xBD,0x07,0x60,0x1C,0x49,
                    0x96,0x25,0x26,0x2F,0x6D,0xCA,0x7B,0x7F,0x4A,0xF5,0x4A,0xD7,0xE0,0x74,0xA1,0x08,
                    0x80,0x60,0x13,0x24,0xD8,0x90,0x40,0x10,0xEC,0xC1,0x88,0xCD,0xE6,0x92,0xEC,0x1D,
                    0x69,0x47,0x23,0x29,0xAB,0x2A,0x81,0xCA,0x65,0x56,0x65,0x5D,0x66,0x16,0x40,0xCC,
                    0xED,0x9D,0xBC,0xF7,0xDE,0x7B,0xEF,0xBD,0xF7,0xDE,0x7B,0xEF,0xBD,0xF7,0xBA,0x3B,
                    0x9D,0x4E,0x27,0xF7,0xDF,0xFF,0x3F,0x5C,0x66,0x64,0x01,0x6C,0xF6,0xCE,0x4A,0xDA,
                    0xC9,0x9E,0x21,0x80,0xAA,0xC8,0x1F,0x3F,0x7E,0x7C,0x1F,0x3F,0x22,0xF6,0xF6,0x1F,
                    0xFE,0xEE,0x7B,0xE3,0x9D,0x9D,0xDF,0x7D,0xF7,0xD1,0xCE,0xA3,0x6F,0x3D,0xFA,0xBD,
                    0x1F,0xED,0xE2,0xBF,0xDF,0x1D,0xFF,0xCA,0x5F,0x3B,0xFC,0xD7,0x9E,0xFB,0x6B,0x67,
                    0xFF,0xE0,0xFE,0x83,0xFB,0xF4,0xD9,0x3D,0xFE,0x74,0x8F,0x3E,0x7D,0xB0,0x3F,0xE2,
                    0x4F,0xF6,0x6D,0xAB,0xFB,0x00,0x78,0x9F,0x1B,0x00,0xD4,0xFE,0x03,0xFA,0xF3,0x53,
                    0x0B,0x7F,0xFF,0x00,0x20,0x1F,0xDA,0xAF,0x1F,0x7C,0x0A,0x70,0x3B,0x0E,0xDE,0x83,
                    0xD1,0x83,0x83,0xD1,0x83,0x87,0xA3,0x83,0x9D,0xD1,0xC1,0xEE,0xE8,0x60,0x6F,0x74,
                    0x70,0x6F,0x74,0xB0,0x8F,0x46,0x40,0x6B,0x87,0xBB,0xD8,0xF9,0xDD,0xF7,0x77,0x1F,
                    0x1C,0x3C,0x3C,0xB8,0xFF,0x70,0x6F,0xFF,0xFF,0x01,0x21,0x2A,0x8A,0xE0,0xC6,0x00,
                    0x00,0x00 };
        }
Exemple #2
0
        //=================================================================================================================
        /// <summary>
        /// ctor 
        /// </summary>
        /// <param name="daqDevice">The DaqDevice object that creates this component</param>
        /// <param name="deviceInfo">The DeviceInfo oject passed down to the driver interface</param>
        //=================================================================================================================
        public Usb2001TcAi(DaqDevice daqDevice, DeviceInfo deviceInfo)
            : base(daqDevice, deviceInfo, 1)
        {
            // default is scale data...
            m_scaleData = true;

                // create thermocouple types...
            m_tcTypes = new ThermocoupleTypes[m_maxChannels];

            m_thermocouples = new Thermocouple[m_maxChannels];

                // create an array for CJC values
            m_cjcValues = new double[m_maxChannels];

                // create an array of channel types...
            m_aiChannelType[0] = AiChannelTypes.Temperature;

                // get the tc type...
            m_tcTypes[0] = GetTcType(0);

            if (m_tcTypes[0] != ThermocoupleTypes.NotSet)
            {
                    // create the thermocouple object...
                m_thermocouples[0] = Thermocouple.CreateThermocouple(m_tcTypes[0]);
            }
        }
Exemple #3
0
        //=================================================================================================================
        /// <summary>
        /// ctor 
        /// </summary>
        /// <param name="daqDevice">The DaqDevice object that creates this component</param>
        /// <param name="deviceInfo">The DeviceInfo oject passed down to the driver interface</param>
        //=================================================================================================================
        internal Usb7204Ai(DaqDevice daqDevice, DeviceInfo deviceInfo)
            : base(daqDevice, deviceInfo, 8)
        {
            m_previousChMode = PropertyValues.DIFF;

            m_adjustScanRateForChannelCount = true;
        }
Exemple #4
0
 //=================================================================================================================
 /// <summary>
 /// ctor 
 /// </summary>
 /// <param name="daqDevice">The DaqDevice object that creates this component</param>
 /// <param name="deviceInfo">The DeviceInfo oject passed down to the driver interface</param>
 //=================================================================================================================
 internal AiComponent(DaqDevice daqDevice, DeviceInfo deviceInfo, int maxChannels)
     : base(daqDevice, deviceInfo, maxChannels)
 {
     m_calibrateData = true;
     m_aiQueueList.Clear();
     m_rateCalculatorDecrementCount = 1;
 }
Exemple #5
0
        protected string m_fpgaFileName; // = "USB_1608G.rbf";

        #endregion Fields

        #region Constructors

        //===========================================================================
        /// <summary>
        /// ctor
        /// </summary>
        /// <param name="deviceInfo">deviceInfo</param>
        //===========================================================================
        internal Usb1608GBase(DeviceInfo deviceInfo)
            : base(deviceInfo, 0x7100)
        {
            switch (deviceInfo.Pid)
            {
                case (0x110):
                case (0x111):
                case (0x112):
                    {
                        m_fpgaFileName = "USB_1608G.rbf";
                        break;
                    }
                case (0x134):
                case (0x135):
                case (0x136):
                    {
                        m_fpgaFileName = "USB_1608G_2.rbf";
                        break;
                    }
            }

            m_memLockAddr = 0x8000;
            m_memUnlockCode = 0xAA55;
            m_memLockCode = 0xFFFF;
        }
Exemple #6
0
        //===========================================================================
        /// <summary>
        /// ctor
        /// </summary>
        /// <param name="deviceInfo">deviceInfo</param>
        //===========================================================================
        internal Usb24082Ao(DeviceInfo deviceInfo)
            : base(deviceInfo)
        {
            Ai = new Usb2408xAi(this, deviceInfo);
            Ao = new Usb2408Ao(this, deviceInfo);
            Dio = new DioComponent(this, deviceInfo, 1);
            Ctr = new VirtualSSEventCounter(this, deviceInfo, 2);

            m_memAddrCmd = 0x00;
            m_memLockAddr = 0x00;
            m_memUnlockCode = 0xAA55;
            m_memLockCode = 0xFFFF;

            // 1/10/2012: version 1.1
            m_defaultDevCapsImage = new byte[]
                {
                    0x1F,0x8B,0x08,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0xED,0xBD,0x07,0x60,0x1C,0x49,
                    0x96,0x25,0x26,0x2F,0x6D,0xCA,0x7B,0x7F,0x4A,0xF5,0x4A,0xD7,0xE0,0x74,0xA1,0x08,
                    0x80,0x60,0x13,0x24,0xD8,0x90,0x40,0x10,0xEC,0xC1,0x88,0xCD,0xE6,0x92,0xEC,0x1D,
                    0x69,0x47,0x23,0x29,0xAB,0x2A,0x81,0xCA,0x65,0x56,0x65,0x5D,0x66,0x16,0x40,0xCC,
                    0xED,0x9D,0xBC,0xF7,0xDE,0x7B,0xEF,0xBD,0xF7,0xDE,0x7B,0xEF,0xBD,0xF7,0xBA,0x3B,
                    0x9D,0x4E,0x27,0xF7,0xDF,0xFF,0x3F,0x5C,0x66,0x64,0x01,0x6C,0xF6,0xCE,0x4A,0xDA,
                    0xC9,0x9E,0x21,0x80,0xAA,0xC8,0x1F,0x3F,0x7E,0x7C,0x1F,0x3F,0x22,0xF6,0xEE,0xEF,
                    0xFF,0xEE,0xBB,0xE3,0x9D,0x9D,0xDF,0x7D,0xF7,0xD1,0xCE,0xA3,0x6F,0x3D,0xFA,0xBD,
                    0x1F,0xED,0x3D,0xDA,0x7D,0xF4,0xF0,0xD3,0x47,0xBB,0xFA,0xC1,0xCE,0xF6,0x03,0xFE,
                    0x68,0x67,0xB4,0x3B,0xDA,0xDD,0xDD,0xA3,0xFF,0xDF,0xB3,0xDF,0x1D,0x6C,0xEF,0xDE,
                    0xA7,0xAF,0xF0,0x07,0x3E,0xDA,0xE5,0xF7,0xF9,0xAF,0x4F,0xE9,0xCF,0x3D,0xEF,0xCF,
                    0x07,0x0F,0x1E,0xEC,0xED,0xDE,0xA7,0x0F,0xF7,0x1F,0xE8,0xA7,0xF4,0xDF,0xEE,0x03,
                    0xFA,0xE0,0x9E,0xD7,0x29,0xFF,0x09,0x28,0xF8,0xF3,0xDE,0x68,0x7F,0xF4,0xE9,0xE8,
                    0x60,0xB4,0x4B,0x3D,0x3F,0x1C,0xED,0xED,0x8C,0xF6,0x76,0xF9,0xFB,0xBD,0x1B,0xBE,
                    0xBF,0xC7,0x28,0xA3,0x03,0xFD,0x60,0x3F,0xFC,0xE0,0xBE,0x45,0x80,0x3B,0xC4,0x00,
                    0x76,0xCC,0x38,0xF6,0xEF,0xF3,0x27,0x7B,0xF6,0x0D,0xFD,0xC0,0xC1,0xDC,0x7F,0xC0,
                    0x1F,0x38,0x98,0xFC,0xC1,0xDE,0xC3,0x10,0x28,0xFD,0xED,0x5E,0x79,0xA0,0x9F,0xB8,
                    0x77,0xF8,0x93,0x7B,0x3E,0xB9,0xE5,0x6F,0x79,0x07,0x9F,0x3C,0x78,0x30,0x7A,0x70,
                    0x30,0x7A,0xF0,0x70,0x74,0xB0,0x33,0x3A,0xD8,0x1D,0x1D,0xEC,0x8D,0x0E,0xEE,0x8D,
                    0x0E,0xF6,0xA5,0xD9,0xFE,0x2D,0x9A,0xED,0xDF,0xB7,0xD0,0xF7,0x0F,0xF0,0x37,0xE8,
                    0x2C,0x84,0x7B,0xF8,0x60,0xF4,0xF0,0x60,0xF4,0xF0,0x21,0x51,0x8E,0x48,0xB7,0x43,
                    0xD3,0xBA,0x43,0xD3,0xBA,0x73,0x8F,0xFE,0xBF,0x4F,0xFF,0xBF,0x4F,0xFF,0xFF,0x94,
                    0xFE,0x8F,0x71,0xED,0xDB,0x29,0x64,0x42,0x7C,0x6A,0x47,0xC9,0x30,0x1F,0xF8,0x5D,
                    0xEC,0x3D,0x32,0x34,0xA0,0xF9,0x26,0x88,0xE3,0x87,0xFB,0xF4,0xD9,0xAE,0xE3,0x89,
                    0xBD,0xF1,0x7D,0x7C,0xB0,0x13,0x6B,0x65,0x58,0x85,0x48,0xBB,0x8B,0xBF,0x0D,0x93,
                    0xD0,0x5B,0x3B,0x0C,0x7B,0xD7,0x01,0xFF,0x94,0xDF,0x38,0xB0,0x6F,0x3C,0xA0,0x01,
                    0xEC,0x03,0xF4,0xFE,0xBE,0xC5,0x67,0x77,0x87,0x46,0x07,0xC6,0xD8,0x21,0xFE,0xD8,
                    0x05,0xC8,0x3D,0x47,0xED,0xFB,0xF7,0x46,0xF7,0x01,0xE3,0xBE,0x81,0xB1,0xF3,0xE8,
                    0xFE,0x0E,0xDE,0x37,0xC3,0xA3,0xD1,0xE2,0x6B,0x87,0x04,0x75,0x89,0x89,0xB3,0x88,
                    0xD3,0x5F,0x7B,0x78,0x79,0x87,0xB9,0xE7,0xD3,0x4F,0x47,0x9F,0x3E,0x18,0x7D,0x7A,
                    0x30,0xFA,0xF4,0x21,0x7D,0xB1,0xCF,0x42,0x23,0x84,0xDE,0x1F,0x3D,0xBC,0x8F,0xB6,
                    0xFC,0x09,0x8F,0xE6,0x3E,0xFE,0x76,0x54,0xDD,0x23,0xB9,0x7B,0xE8,0x41,0xDE,0xA3,
                    0xBF,0xF6,0x80,0x06,0x71,0xA4,0x0C,0x0E,0xDF,0xEF,0xD9,0x0F,0x08,0xB3,0xBD,0x87,
                    0xFB,0x0F,0x3F,0x7D,0xB0,0x47,0x80,0x89,0xA3,0x76,0xBD,0x6F,0xD0,0x72,0xDF,0x6F,
                    0xCA,0xAF,0x3E,0xF0,0x80,0x1D,0x3C,0x40,0x93,0xA0,0xF3,0xFD,0xA0,0xF3,0x7D,0x4F,
                    0x66,0x3F,0xBD,0x7F,0xFF,0xDE,0x7D,0xFA,0x44,0xF8,0x06,0xAF,0xDF,0xA3,0xBF,0xBA,
                    0x6F,0xEF,0xDD,0xB7,0x5F,0xEF,0xA3,0x75,0xC0,0x21,0xFB,0x21,0x87,0xEC,0x13,0x99,
                    0x15,0x1B,0x47,0x1D,0xFA,0xD0,0x60,0xA0,0x8D,0x7C,0x0D,0x71,0xEF,0xE1,0xEF,0x7E,
                    0xDF,0xE7,0xAB,0x1D,0xEA,0xF4,0xBE,0xCF,0x54,0xBB,0xF8,0xD3,0x63,0x29,0x6D,0xE0,
                    0xF8,0xE9,0x21,0x20,0x74,0xF9,0xE9,0xBE,0x3F,0xD7,0x7B,0xF4,0x67,0x38,0xD7,0x7B,
                    0xBB,0x7B,0xF7,0x1E,0xEE,0xEF,0xDD,0x7F,0x78,0xEF,0xFF,0x01,0x88,0x5E,0x01,0xAC,
                    0x1D,0x05,0x00,0x00                };
        }
Exemple #7
0
 //=================================================================================================================
 /// <summary>
 /// ctor 
 /// </summary>
 /// <param name="daqDevice">The DaqDevice object that creates this component</param>
 /// <param name="deviceInfo">The DeviceInfo oject passed down to the driver interface</param>
 //=================================================================================================================
 public DioComponent(DaqDevice daqDevice, DeviceInfo deviceInfo, int maxChannels)
     : base(daqDevice, deviceInfo, maxChannels)
 {
     // dimension arrays here initialize them in Initialize()
     m_portWidths = new int[m_maxChannels];
     m_configMasks = new int[m_maxChannels];
     m_outputValues = new int[m_maxChannels];
 }
        //===========================================================================
        /// <summary>
        /// Sub-class of DaqDevice that provides methods specific to the USB-7202
        /// </summary>
        /// <param name="deviceInfo">A device info object</param>
        //===========================================================================
        internal Usb1408FSPlus(DeviceInfo deviceInfo)
            : base(deviceInfo, 0x040)
        {
            Ai = new Usb1208FSPlusAi(this, deviceInfo);
             Ao = new Usb1208FSPlusAo(this, deviceInfo);
             Dio = new DioComponent(this, deviceInfo, 2);
             Ctr = new VirtualSSEventCounter(this, deviceInfo, 1);

             m_memReadCmd = 0x32;
             m_memWriteCmd = 0x32;

             m_memLockAddr = 0x000;
             m_memUnlockCode = 0x0000;
             m_memLockCode = 0x0000;

             m_eepromAssistant = new EepromAssistantIV(m_driverInterface);

             // 1/16/2012: version 1.0
             m_defaultDevCapsImage = new byte[]
                { 0x1F,0x8B,0x08,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0xED,0xBD,0x07,0x60,0x1C,0x49,
                  0x96,0x25,0x26,0x2F,0x6D,0xCA,0x7B,0x7F,0x4A,0xF5,0x4A,0xD7,0xE0,0x74,0xA1,0x08,
                  0x80,0x60,0x13,0x24,0xD8,0x90,0x40,0x10,0xEC,0xC1,0x88,0xCD,0xE6,0x92,0xEC,0x1D,
                  0x69,0x47,0x23,0x29,0xAB,0x2A,0x81,0xCA,0x65,0x56,0x65,0x5D,0x66,0x16,0x40,0xCC,
                  0xED,0x9D,0xBC,0xF7,0xDE,0x7B,0xEF,0xBD,0xF7,0xDE,0x7B,0xEF,0xBD,0xF7,0xBA,0x3B,
                  0x9D,0x4E,0x27,0xF7,0xDF,0xFF,0x3F,0x5C,0x66,0x64,0x01,0x6C,0xF6,0xCE,0x4A,0xDA,
                  0xC9,0x9E,0x21,0x80,0xAA,0xC8,0x1F,0x3F,0x7E,0x7C,0x1F,0x3F,0x22,0xF6,0xEE,0xDD,
                  0xFB,0xDD,0x77,0xC7,0x3B,0xBF,0xFB,0xEE,0xA3,0x9D,0x47,0xDF,0x7A,0xF4,0x7B,0x3F,
                  0xDA,0x7B,0x44,0xBF,0x8D,0x76,0x1F,0xED,0x8E,0xE8,0xF3,0x47,0xF8,0xEF,0xF7,0xC6,
                  0x27,0x8F,0x0E,0xF8,0xAF,0x3D,0xFD,0x6B,0x9F,0xFE,0xBA,0x47,0xBF,0x7D,0x8B,0x5B,
                  0xDC,0xE3,0xBF,0xF6,0xE8,0x2F,0xBC,0xBD,0x37,0xBA,0x37,0xDA,0x1F,0xDD,0x1F,0x7D,
                  0x3A,0x7A,0x30,0x3A,0x18,0x3D,0xFC,0xDD,0xF1,0x96,0x81,0xB2,0xFB,0xE9,0xBD,0x83,
                  0x7B,0xFC,0x89,0x81,0x64,0x3E,0xD9,0xE7,0xDE,0xF9,0x93,0x1D,0x60,0x73,0xDF,0x42,
                  0xDF,0xBF,0xCF,0x7F,0xEE,0xF9,0x7F,0x7E,0xAA,0xAD,0xE9,0x4F,0x20,0xB6,0xFF,0xC0,
                  0xFE,0xBD,0xBB,0xBF,0xF7,0xBB,0xEF,0x3D,0x7A,0x68,0xA1,0xED,0x1F,0xEC,0x10,0x3C,
                  0xC2,0x60,0xD7,0x7E,0xB4,0x33,0xDE,0xD9,0xBD,0x87,0x8F,0x76,0xFA,0xAD,0xF6,0x1C,
                  0xE0,0x87,0xF8,0xDB,0x00,0xA6,0x26,0x3B,0x0F,0x3F,0xA5,0x4F,0xF6,0x05,0x51,0x0C,
                  0x69,0x77,0xE7,0xE1,0x68,0x77,0x97,0x5F,0x7B,0xE8,0xD1,0x89,0xFF,0x74,0x84,0xA2,
                  0x3F,0x0F,0x3C,0xEC,0xD0,0xF1,0x9E,0x23,0xF5,0xFD,0x7B,0xA3,0xFB,0x68,0xB3,0x6F,
                  0x46,0xB4,0xF3,0x08,0xF8,0xDF,0x37,0xAF,0x08,0x39,0xE8,0x95,0x5D,0xF7,0xCA,0xC3,
                  0xD1,0xA7,0xFC,0xD1,0x9E,0xFD,0xE8,0xE0,0xFE,0xE8,0x00,0xC8,0xDD,0x77,0xE8,0x7E,
                  0xBA,0xFF,0xBB,0xD3,0x94,0xDC,0xB3,0x3D,0x7F,0xBA,0x87,0xBF,0x1D,0xF2,0x9F,0xEE,
                  0x8F,0x3E,0xBD,0x3F,0x7A,0xB8,0x37,0x7A,0x78,0x8F,0xBE,0xB8,0xD7,0x85,0xB5,0xFF,
                  0xC8,0xD1,0x6B,0x8F,0xFE,0x32,0x74,0x61,0x3A,0xDC,0xA7,0x0F,0x00,0x59,0x26,0x64,
                  0x0F,0xAD,0xC3,0xE9,0xA3,0xF6,0xF7,0xED,0xF7,0xFB,0x68,0xEE,0xCF,0xD0,0xEE,0xA7,
                  0xBF,0xFB,0xFD,0xEE,0x7C,0xE0,0x13,0x37,0x1D,0xF7,0x77,0x30,0x1D,0xF7,0xBD,0x69,
                  0xDC,0xC5,0x27,0xF8,0x28,0x9C,0xA1,0xFB,0x21,0xE1,0xEE,0xF7,0x26,0xEC,0x7E,0x87,
                  0x26,0xF7,0x1F,0xDD,0x73,0x34,0x39,0xB8,0xFF,0xBB,0x3F,0x08,0xC6,0xF9,0xE0,0xD1,
                  0x1E,0x08,0xBF,0xB3,0x2D,0x3C,0xFB,0xE9,0xA7,0xA3,0x4F,0x1F,0xD0,0x87,0xFB,0xC0,
                  0x6C,0x87,0x3F,0x7A,0xB8,0x3F,0x7A,0x88,0xB7,0xF6,0xB4,0x19,0xBF,0x77,0x1F,0x9F,
                  0x84,0x14,0x78,0xE8,0xC1,0xDD,0xA5,0xBF,0xF6,0x3E,0x65,0x10,0x78,0xE1,0x01,0xBE,
                  0xDD,0xD3,0x3F,0x09,0xCD,0xBD,0x87,0xFB,0x0F,0x3F,0x7D,0xB0,0x47,0x60,0xE9,0xE3,
                  0x07,0xB6,0xD9,0xC1,0x03,0xFA,0xBB,0x23,0x15,0xF7,0x1E,0xDC,0x3B,0xD8,0xF9,0x74,
                  0x7F,0x6F,0xE7,0xFF,0x01,0xA4,0x40,0x83,0xF0,0xB6,0x03,0x00,0x00};
        }
        internal WindowsUsbInterop(DeviceInfo deviceInfo, CriticalParams criticalParams)
            : base(deviceInfo, criticalParams)
        {
            //m_aiScanResetPacket.TransferType = UsbTransferTypes.ControlOut;
            //m_aiScanResetPacket.Request = 0x80;
            //m_aiScanResetPacket.DeferTransfer = false;
            //m_aiScanResetPacket.BytesTransfered = 0;

            //for (int i = 0; i < m_aiScanResetPacket.Length; i++)
            //    m_aiScanResetPacket.Buffer[i] = m_aiScanStatusMessage[i];
        }
Exemple #10
0
        //===========================================================================
        /// <summary>
        /// ctor
        /// </summary>
        /// <param name="deviceInfo">deviceInfo</param>
        //===========================================================================
        internal Usb20x(DeviceInfo deviceInfo)
            : base(deviceInfo, 0x0040)
        {
            m_memLockAddr = 0x00;
            m_memAddrCmd = 0x00;

            m_memReadCmd = 0x32;
            m_memWriteCmd = 0x32;
            m_memOffsetLength = 2;

            m_eepromAssistant = new EepromAssistantIV(m_driverInterface);
        }
        //===================================================================================================
        /// <summary>
        /// ctor
        /// </summary>
        /// <param name="daqDevice">A reference to the DaqDevice object that creates this component</param>
        /// <param name="deviceInfo">A referemce tp the DeviceInfo object that the Driver Interace uses</param>
        //===================================================================================================
        public VirtualSSEventCounter(DaqDevice daqDevice, DeviceInfo deviceInfo, int maxChannels)
            : base(daqDevice, deviceInfo, maxChannels)
        {
            m_lastCount = new uint[maxChannels];
            m_isCounting = new bool[maxChannels];

            for (int i = 0; i < maxChannels; i++)
            {
                m_lastCount[i] = 0;
                m_isCounting[i] = false;
            }
        }
Exemple #12
0
        //===========================================================================
        /// <summary>
        /// ctor
        /// </summary>
        /// <param name="deviceInfo">deviceInfo</param>
        //===========================================================================
        internal Usb1608GX2Ao(DeviceInfo deviceInfo)
            : base(deviceInfo)
        {
            Ai = new Usb1608GAi(this, deviceInfo);
            Ao = new Usb1608GXAo(this, deviceInfo);
            Dio = new DioComponent(this, deviceInfo, 1);
            Ctr = new VirtualSSEventCounter(this, deviceInfo, 2);
            Tmr = new PulseTimer(this, deviceInfo, 1);

            // 1/10/2012: version 1.1
            m_defaultDevCapsImage = new byte[]
                {  0x1F,0x8B,0x08,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0xED,0xBD,0x07,0x60,0x1C,0x49,
                    0x96,0x25,0x26,0x2F,0x6D,0xCA,0x7B,0x7F,0x4A,0xF5,0x4A,0xD7,0xE0,0x74,0xA1,0x08,
                    0x80,0x60,0x13,0x24,0xD8,0x90,0x40,0x10,0xEC,0xC1,0x88,0xCD,0xE6,0x92,0xEC,0x1D,
                    0x69,0x47,0x23,0x29,0xAB,0x2A,0x81,0xCA,0x65,0x56,0x65,0x5D,0x66,0x16,0x40,0xCC,
                    0xED,0x9D,0xBC,0xF7,0xDE,0x7B,0xEF,0xBD,0xF7,0xDE,0x7B,0xEF,0xBD,0xF7,0xBA,0x3B,
                    0x9D,0x4E,0x27,0xF7,0xDF,0xFF,0x3F,0x5C,0x66,0x64,0x01,0x6C,0xF6,0xCE,0x4A,0xDA,
                    0xC9,0x9E,0x21,0x80,0xAA,0xC8,0x1F,0x3F,0x7E,0x7C,0x1F,0x3F,0x22,0xF6,0x1E,0xEC,
                    0xFF,0xEE,0xBB,0xE3,0x9D,0x9D,0xDF,0x7D,0xF7,0xD1,0xCE,0xA3,0x6F,0x3D,0xFA,0xBD,
                    0x1F,0xED,0x3D,0xDA,0x7D,0xF4,0xF0,0xD3,0x47,0xBB,0xFA,0xC1,0xCE,0xF6,0x03,0xFE,
                    0x68,0x67,0xB4,0x6B,0x3F,0x3B,0xD8,0xDE,0xBD,0x4F,0x1F,0xE1,0x0F,0x7C,0x84,0xFF,
                    0x7E,0x6F,0xF9,0xEB,0x53,0xFE,0x73,0x4F,0xFF,0x3C,0xF8,0xDD,0xF1,0xFB,0xB7,0xF4,
                    0xAF,0x4F,0xEF,0xDF,0xBF,0x77,0x9F,0x3E,0xB9,0xE7,0x75,0xC3,0x7F,0xEE,0xD2,0x07,
                    0xF8,0xF3,0xDE,0x68,0x7F,0xF4,0x60,0xF4,0x90,0x3F,0xDB,0xEB,0x7D,0xB6,0x6F,0x01,
                    0xED,0x32,0xB6,0xF7,0xF9,0x3D,0x74,0xB7,0x7F,0x9F,0xFF,0xDC,0xF3,0xFF,0xFC,0x54,
                    0x5B,0xD3,0x9F,0xC0,0xE2,0x81,0xED,0x93,0xFF,0xDC,0x7F,0x60,0xBF,0xDE,0xBD,0xF7,
                    0xF0,0x77,0xDF,0x7B,0xF4,0xD0,0x02,0xBF,0xBF,0x83,0x87,0x3E,0xDA,0xDD,0xB5,0x9F,
                    0xED,0x8C,0x77,0x76,0xF7,0xD1,0x6C,0x77,0x27,0xD2,0xCE,0x8C,0x90,0xC0,0x72,0x1B,
                    0x03,0x7B,0xE7,0xD1,0xFE,0x0E,0x8D,0x90,0x3E,0x71,0xD0,0x77,0xF9,0xEF,0x03,0xFB,
                    0xC6,0x83,0xDD,0xD1,0x2E,0xE1,0xBB,0xF7,0x68,0x5F,0x86,0x07,0x0C,0x77,0x77,0x1E,
                    0x8E,0x76,0x77,0x0E,0x46,0xBB,0xBB,0x00,0xBF,0xE7,0x66,0xE5,0xFE,0xBD,0xD1,0xFD,
                    0x7D,0xFA,0xE8,0xBE,0x79,0x7F,0x87,0xBE,0x45,0x9B,0x7B,0xC1,0xF0,0xE8,0x9D,0x5D,
                    0xFB,0xF7,0xC1,0xFD,0xD1,0x01,0xFA,0xDC,0xDB,0xEB,0x7D,0xB4,0x6F,0x68,0x44,0x60,
                    0x00,0xD5,0xE1,0x7D,0x7F,0x77,0xEF,0x77,0xA7,0x29,0xB8,0xA7,0x1F,0x10,0x35,0xF9,
                    0x6F,0x87,0xE2,0xA7,0xFB,0xA3,0x4F,0xEF,0x8F,0x1E,0xEE,0x8D,0x1E,0xDE,0xA3,0x2F,
                    0xEE,0x75,0x61,0xEF,0x3F,0x72,0xB4,0xDB,0xA3,0xBF,0xBA,0x3C,0xB0,0xCF,0x3C,0x20,
                    0xB3,0x75,0x8F,0xFE,0x0A,0xA7,0x96,0xDA,0xDF,0xB7,0x5F,0xEF,0xA3,0x75,0x30,0x99,
                    0xFB,0xE1,0x64,0xEE,0x77,0x27,0xF3,0x7E,0x7F,0x32,0xEF,0x47,0x26,0xF3,0x7E,0x64,
                    0x32,0xEF,0x77,0x26,0xF3,0xBE,0x3F,0x99,0x7B,0x3B,0xD4,0xDB,0xFD,0x90,0x6A,0xF7,
                    0xFB,0xA4,0xBE,0xDF,0x25,0xE4,0x03,0x8F,0x18,0xBB,0xF4,0xD7,0x1E,0x66,0x6F,0x47,
                    0xC8,0xF8,0xE9,0xE8,0xD3,0x07,0xA3,0x4F,0x0F,0x46,0x9F,0x3E,0xA4,0x2F,0xF6,0x77,
                    0xEC,0x17,0x0F,0xF7,0x47,0x0F,0xEF,0xA3,0x2D,0x7F,0xC2,0x7D,0xDD,0xC7,0xDF,0x21,
                    0xA1,0x1E,0x06,0x64,0x7E,0xF8,0x68,0x0F,0xA8,0xED,0x6C,0x8B,0x40,0x3E,0xC0,0xF7,
                    0x7B,0xF6,0x03,0x62,0xC6,0xBD,0x87,0xFB,0x0F,0x3F,0x7D,0xB0,0x47,0x80,0x1F,0x3E,
                    0xDA,0xDF,0xF5,0xBE,0x41,0xCB,0x7D,0xBF,0x29,0xBF,0xFA,0xC0,0x03,0x76,0xF0,0x00,
                    0x4D,0x82,0xCE,0x77,0xF1,0xB9,0x1B,0x17,0xFD,0x29,0xDD,0x4B,0xFB,0x87,0xF8,0xE0,
                    0xDE,0x81,0xFD,0xE0,0xFE,0x03,0x6E,0x61,0x87,0xE3,0x21,0x83,0x86,0xFB,0xF6,0x8B,
                    0x4F,0xF7,0x77,0x64,0x2E,0xF0,0xF1,0x7D,0xFE,0x98,0x09,0xC2,0x3D,0xDC,0xFB,0xD4,
                    0x7D,0xC0,0x2D,0xEE,0x63,0xAA,0x45,0x51,0xEC,0xEE,0x7F,0x4A,0xA2,0xC4,0xDD,0x7C,
                    0xBA,0x63,0x3F,0x85,0xB4,0xEF,0xEE,0xED,0xEF,0x1D,0xEC,0xDC,0xDF,0xDD,0xFB,0x7F,
                    0x00,0xB4,0x1A,0x2D,0x78,0xEB,0x04,0x00,0x00 };
        }
Exemple #13
0
 //=================================================================================================================
 /// <summary>
 /// ctor 
 /// </summary>
 /// <param name="daqDevice">The DaqDevice object that creates this component</param>
 /// <param name="deviceInfo">The DeviceInfo oject passed down to the driver interface</param>
 //=================================================================================================================
 internal Usb1608GAi(DaqDevice daqDevice, DeviceInfo deviceInfo)
     : base(daqDevice, deviceInfo, 16)
 {
     // create channel mappings
     m_channelMappings.Add(0, 8);
     m_channelMappings.Add(1, 9);
     m_channelMappings.Add(2, 10);
     m_channelMappings.Add(3, 11);
     m_channelMappings.Add(4, 12);
     m_channelMappings.Add(5, 13);
     m_channelMappings.Add(6, 14);
     m_channelMappings.Add(7, 15);
 }
Exemple #14
0
        //=====================================================================================
        /// <summary>
        /// Device-specific constructor used by the driver interface
        /// </summary>
        /// <param name="deviceNumber">The device number</param>
        //=====================================================================================
        internal LibUsbInterop(DeviceInfo deviceInfo, CriticalParams criticalParams)
            : base(deviceInfo, criticalParams)
        {
            InitializeDevice(m_deviceInfo);

            if (m_errorCode == ErrorCodes.NoErrors && !m_deviceInitialized)
                m_errorCode = ErrorCodes.DeviceNotInitialized;

            m_maxTransferSize = 8192;

            #if DEBUG
            //LibUsbInterop.LibUsbSetDebug(IntPtr.Zero, 3);
            #endif
        }
            //============================================================================================
            /// <summary>
            /// Uses reflection to create the specific DaqDevice object
            /// </summary>
            /// <param name="deviceInfo">A deviceInfo object</param>
            /// <returns>An instance of the DaqDevice object associated with the device PID</returns>
            //============================================================================================
            internal static DaqDevice CreateDeviceObject(DeviceInfo deviceInfo)
            {
                if (m_supportedDevices.Count == 0)
                    GenerateSupportedDeviceList();

                // create a specific daq device sub-class
                string targetDeviceClass;

                if (m_supportedDevices.TryGetValue(deviceInfo.Pid, out targetDeviceClass))
                {
                    // get the assembly
                    Assembly DAQFlexApi = Assembly.GetExecutingAssembly();

                    // get the namespace of the daq device base class
                    string nameSpace = typeof(DaqDevice).Namespace;

                    // get the class type associated with the target device class name
                    Type deviceClassType = DAQFlexApi.GetType(String.Format("{0}.{1}", nameSpace, targetDeviceClass));

                    // get the constructor info from the class type
                    ConstructorInfo ci = deviceClassType.GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic,
                                                                        null,
                                                                        new Type[] { typeof(DeviceInfo) },
                                                                        null);

                    // invoke the constructor to create the DaqDevice object
                    try
                    {
                        DaqDevice targetDeviceObject = (DaqDevice)ci.Invoke(new Object[] { deviceInfo });
                        return targetDeviceObject;
                    }
                    catch (Exception ex)
                    {
                        if (ex.InnerException is DaqException)
                        {
                            DaqException dex = ex.InnerException as DaqException;
                            throw dex;
                        }
                        else
                        {
                            throw ex;
                        }
                    }
                }
                else
                {
                    throw new DaqException(ErrorMessages.InvalidDeviceIdentifier, ErrorCodes.InvalidDeviceIdentifier);
                }
            }
Exemple #16
0
        //===========================================================================
        /// <summary>
        /// Sub-class of DaqDevice that provides methods specific to the USB-7202
        /// </summary>
        /// <param name="deviceInfo">A device info object</param>
        //===========================================================================
        internal Usb1608FSPlus(DeviceInfo deviceInfo)
            : base(deviceInfo, 0x040)
        {
            Ai = new Usb1608FSPlusAi(this, deviceInfo);
            Dio = new DioComponent(this, deviceInfo, 1);
            Ctr = new VirtualSSEventCounter(this, deviceInfo, 1);

            m_memReadCmd = 0x32;
            m_memWriteCmd = 0x32;

            m_memLockAddr = 0x000;
            m_memUnlockCode = 0x0000;
            m_memLockCode = 0x0000;

            m_eepromAssistant = new EepromAssistantIV(m_driverInterface);

            // 2/10/2012: version 1.2
            m_defaultDevCapsImage = new byte[]
                {  0x1F,0x8B,0x08,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0xED,0xBD,0x07,0x60,0x1C,0x49,
                    0x96,0x25,0x26,0x2F,0x6D,0xCA,0x7B,0x7F,0x4A,0xF5,0x4A,0xD7,0xE0,0x74,0xA1,0x08,
                    0x80,0x60,0x13,0x24,0xD8,0x90,0x40,0x10,0xEC,0xC1,0x88,0xCD,0xE6,0x92,0xEC,0x1D,
                    0x69,0x47,0x23,0x29,0xAB,0x2A,0x81,0xCA,0x65,0x56,0x65,0x5D,0x66,0x16,0x40,0xCC,
                    0xED,0x9D,0xBC,0xF7,0xDE,0x7B,0xEF,0xBD,0xF7,0xDE,0x7B,0xEF,0xBD,0xF7,0xBA,0x3B,
                    0x9D,0x4E,0x27,0xF7,0xDF,0xFF,0x3F,0x5C,0x66,0x64,0x01,0x6C,0xF6,0xCE,0x4A,0xDA,
                    0xC9,0x9E,0x21,0x80,0xAA,0xC8,0x1F,0x3F,0x7E,0x7C,0x1F,0x3F,0x22,0xF6,0xEE,0xED,
                    0xFF,0xEE,0xBB,0xE3,0xBD,0xDF,0x7D,0xF7,0xD1,0xCE,0xA3,0x6F,0x3D,0xFA,0xBD,0x1F,
                    0xED,0xD2,0x7F,0x3B,0xBF,0x3B,0xFE,0x95,0xBF,0x76,0x1E,0x1D,0xD0,0x5F,0x7B,0xF6,
                    0xAF,0x4F,0xEF,0xDF,0xBF,0x77,0x9F,0x3E,0xB9,0xC7,0x2D,0xF6,0xE8,0xDF,0x7B,0xA3,
                    0xFD,0xD1,0x83,0xD1,0x43,0xFA,0x6C,0xDF,0xB6,0xDA,0xDD,0x01,0x8C,0xFB,0xDC,0x06,
                    0xB0,0xF6,0xF1,0xCA,0xA7,0xB6,0x83,0x7D,0xC0,0xDC,0x7F,0x60,0xFF,0xDE,0xBD,0xF7,
                    0xF0,0x77,0xDF,0x7B,0xF4,0xD0,0xBE,0xBE,0xBF,0x83,0x87,0x3E,0xDA,0x75,0x68,0xEC,
                    0x8C,0x77,0x76,0xD0,0x6A,0xD7,0xE0,0xC9,0xBD,0x68,0x33,0x83,0x1F,0xF5,0xC9,0x7F,
                    0xDF,0x73,0xD8,0xDB,0x36,0xF7,0xFB,0xA0,0x02,0x84,0xB5,0x99,0xC3,0x52,0x40,0x19,
                    0x2C,0x77,0x1E,0xDD,0xDB,0x7B,0xF0,0xE9,0x01,0x7D,0xB4,0x27,0x18,0x60,0xEC,0xF7,
                    0xEF,0x8D,0xEE,0xEF,0x8F,0xEE,0x7F,0x4A,0x9F,0xDE,0x3F,0xB0,0x0D,0xF7,0x18,0xD2,
                    0xDE,0xAE,0x6B,0xF6,0x70,0xF4,0xE9,0xCE,0xE8,0x00,0xCD,0x76,0xDD,0x28,0x01,0x6B,
                    0xD7,0xBC,0x45,0xFF,0xED,0xDF,0xA3,0x0F,0xF6,0xF7,0xED,0x5B,0xBB,0x3B,0x0F,0x47,
                    0xBB,0xBB,0x00,0xB5,0x6F,0x90,0x22,0xD8,0x80,0xBC,0x67,0xDB,0x1C,0xDC,0x17,0xB0,
                    0xF7,0xCC,0x88,0x99,0xB8,0x84,0x8D,0x43,0xFB,0xD3,0xFD,0xDF,0xFD,0xDE,0xA3,0x3D,
                    0xF7,0xFD,0xA7,0x7B,0xF8,0xDB,0x75,0xF3,0xE9,0xFE,0xE8,0xD3,0xFB,0xA3,0x87,0x7B,
                    0xA3,0x87,0xF7,0x7E,0xF7,0x07,0x8F,0x1C,0xC1,0x77,0xE9,0xAF,0x3D,0xA0,0xB7,0x23,
                    0xCD,0x3E,0x1D,0x7D,0xFA,0x60,0xF4,0xE9,0xC1,0xE8,0xD3,0x87,0xF8,0x82,0x3F,0x67,
                    0x84,0xEE,0xDF,0xA7,0xBF,0xC3,0xA9,0xA7,0xBF,0x77,0xEC,0x8B,0x0F,0xF7,0x47,0x0F,
                    0xEF,0xFF,0xEE,0x0F,0x03,0xC8,0x0F,0x1F,0xED,0x7D,0xAA,0x10,0x76,0x1F,0x3D,0xD8,
                    0xC1,0xDF,0x16,0xE0,0xFE,0xDE,0xC3,0xFD,0x87,0x9F,0x3E,0xD8,0xE3,0x97,0xF6,0x77,
                    0xED,0xE7,0x68,0xB5,0xEF,0x9A,0xF1,0x4B,0x0F,0x2C,0x90,0x83,0x07,0xF8,0x3A,0xC0,
                    0x62,0xF7,0xC1,0xC3,0x7B,0xF7,0xF7,0xEE,0xED,0x7D,0xBA,0xF3,0xFF,0x00,0x91,0x24,
                    0x82,0x8E,0xE5,0x02,0x00,0x00 };
        }
Exemple #17
0
        //===========================================================================
        /// <summary>
        /// Sub-class of DaqDevice that provides methods specific to the USB-7204
        /// </summary>
        /// <param name="deviceInfo">A device info object</param>
        //===========================================================================
        internal Usb7204(DeviceInfo deviceInfo)
            : base(deviceInfo, 0x200)
        {
            Ai = new Usb7204Ai(this, deviceInfo);
            Ao = new Usb7204Ao(this, deviceInfo);
            Dio = new DioComponent(this, deviceInfo, 2);
            Ctr = new EventCounter(this, deviceInfo, 1);

            m_memLockAddr = 0x400;
            m_memUnlockCode = 0xAA55;
            m_memLockCode = 0xFFFF;

            // 1/10/2012: version 1.2
            m_defaultDevCapsImage = new byte[]
                {
                    0x1F,0x8B,0x08,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0xED,0xBD,0x07,0x60,0x1C,0x49,
                    0x96,0x25,0x26,0x2F,0x6D,0xCA,0x7B,0x7F,0x4A,0xF5,0x4A,0xD7,0xE0,0x74,0xA1,0x08,
                    0x80,0x60,0x13,0x24,0xD8,0x90,0x40,0x10,0xEC,0xC1,0x88,0xCD,0xE6,0x92,0xEC,0x1D,
                    0x69,0x47,0x23,0x29,0xAB,0x2A,0x81,0xCA,0x65,0x56,0x65,0x5D,0x66,0x16,0x40,0xCC,
                    0xED,0x9D,0xBC,0xF7,0xDE,0x7B,0xEF,0xBD,0xF7,0xDE,0x7B,0xEF,0xBD,0xF7,0xBA,0x3B,
                    0x9D,0x4E,0x27,0xF7,0xDF,0xFF,0x3F,0x5C,0x66,0x64,0x01,0x6C,0xF6,0xCE,0x4A,0xDA,
                    0xC9,0x9E,0x21,0x80,0xAA,0xC8,0x1F,0x3F,0x7E,0x7C,0x1F,0x3F,0x22,0xF6,0xF6,0xF7,
                    0x7E,0xF7,0xDD,0xF1,0xEE,0xCE,0xEF,0xBE,0xFB,0x68,0xE7,0xD1,0xB7,0x1E,0xFD,0xDE,
                    0x8F,0xF6,0x1E,0xD1,0x6F,0xA3,0xDD,0x47,0xBB,0xA3,0x7B,0xF4,0x19,0xFE,0xFB,0xBD,
                    0xF1,0xC9,0xA3,0x03,0xFA,0x6B,0xCF,0xFE,0xB5,0xBF,0xF3,0xF0,0x3E,0x7D,0x70,0x8F,
                    0xFE,0xF8,0x16,0x37,0x92,0xC6,0x7B,0xE6,0x6B,0x6E,0x6C,0xFF,0x32,0x8D,0xF7,0xA8,
                    0x31,0x60,0xEC,0x8D,0xEE,0x8D,0xF6,0x47,0xF7,0x47,0x9F,0x8E,0x1E,0x8C,0x0E,0x46,
                    0x0F,0xE9,0xBB,0x7D,0xEE,0x1B,0x8D,0x77,0x77,0x80,0xCB,0x7D,0x0B,0x78,0xFF,0x3E,
                    0xFF,0xB9,0xE7,0xFF,0xF9,0xA9,0xB6,0xA6,0x3F,0x0F,0x7E,0xF7,0xBD,0x47,0x0F,0xED,
                    0xCB,0xF7,0x77,0xE8,0xA1,0x4F,0x76,0x77,0xED,0x47,0x3B,0xE3,0xFB,0x9F,0x3E,0xC4,
                    0x47,0x3B,0xFD,0x56,0x7B,0x0E,0x0E,0x37,0x79,0x60,0x9B,0xDC,0xDB,0x7B,0xF0,0x29,
                    0x40,0xEF,0x3A,0xD8,0xBB,0x9F,0xE2,0xEF,0x03,0xFB,0xCA,0x83,0xDD,0xD1,0x2E,0x61,
                    0x43,0xC3,0x74,0x84,0xBB,0x7F,0x6F,0x74,0x7F,0x9F,0x3E,0xBA,0x6F,0x9A,0xA1,0x33,
                    0x34,0xD9,0x75,0x4D,0x1E,0x8E,0x3E,0xDD,0x19,0x7D,0xBA,0x8B,0x4F,0xF7,0xEC,0xA7,
                    0x07,0xF7,0x47,0x07,0x80,0x7F,0xDF,0xA1,0xF0,0xE9,0xFE,0xEF,0x4E,0x14,0xBB,0x67,
                    0xFB,0xFB,0x74,0x0F,0x7F,0xEF,0xDB,0x57,0x3E,0xDD,0x1F,0x7D,0x7A,0x9F,0x3E,0xBA,
                    0xD7,0x85,0xB2,0xFF,0xC8,0x8D,0x7E,0x8F,0xFE,0x32,0xA3,0xD4,0x89,0xD8,0x7F,0x04,
                    0x98,0x42,0xCD,0xBD,0x07,0xF4,0x67,0x48,0x7B,0x6A,0x7F,0xDF,0x7E,0x4F,0xE3,0xBB,
                    0xEF,0x13,0x73,0x17,0x7F,0x3A,0x42,0xEE,0x32,0x21,0xEF,0xFB,0x84,0xBC,0xFF,0x00,
                    0x7F,0xBB,0x51,0xEC,0xEE,0xEC,0xED,0xD3,0x27,0xE1,0xB8,0x1E,0x04,0x18,0x3E,0x78,
                    0xB4,0x07,0x72,0xED,0x6C,0x0B,0x83,0x7D,0xFA,0xE9,0xE8,0xD3,0x07,0xF8,0x50,0x3F,
                    0xE3,0x46,0xF7,0xEF,0xD3,0x27,0x21,0xA2,0x0F,0x3D,0x20,0xBB,0xF4,0xD7,0x1E,0xB8,
                    0x62,0x87,0x91,0x78,0x80,0x6F,0xF7,0xF4,0x4F,0x1A,0xF6,0xDE,0xC3,0xFD,0x87,0x9F,
                    0x3E,0xD8,0xA3,0xC1,0xD3,0xC7,0x0F,0x6C,0xB3,0x83,0x07,0xF4,0x77,0x08,0xF4,0xDE,
                    0x83,0xFB,0xFB,0xF7,0xEF,0xDF,0xDF,0xDD,0xFD,0x7F,0x00,0x38,0xE6,0xC9,0xB0,0x18,
                    0x03,0x00,0x00 };
        }
Exemple #18
0
        //=====================================================================================
        /// <summary>
        /// Device-specific constructor used by the driver interface
        /// </summary>
        /// <param name="deviceNumber">The device number</param>
        //=====================================================================================
        internal McUsbInterop(DeviceInfo deviceInfo, CriticalParams criticalParams)
            : base(deviceInfo, criticalParams)
        {
            m_deviceInfo = deviceInfo;

            InitializeDevice(m_deviceInfo);

            if (m_errorCode == ErrorCodes.NoErrors && !m_deviceInitialized)
                m_errorCode = ErrorCodes.DeviceNotInitialized;

            // create a setup packet for reading device status
            m_statusPacket = new WindowsUsbSetupPacket();
            m_statusPacket.RequestType = ControlRequestType.VENDOR_CONTROL_IN;
            m_statusPacket.Request = 0x44;
            m_statusPacket.Value = 0;
            m_statusPacket.Index = 0;
            m_statusPacket.Length = 2;
            m_statusBuffer = new byte[2];
            m_maxTransferSize = 256000;
        }
Exemple #19
0
        //===========================================================================
        /// <summary>
        /// Sub-class of DaqDevice that provides methods specific to the USB-7202
        /// </summary>
        /// <param name="deviceInfo">A device info object</param>
        //===========================================================================
        internal Usb7202(DeviceInfo deviceInfo)
            : base(deviceInfo, 0x200)
        {
            Ai = new Usb7202Ai(this, deviceInfo);
            Dio = new DioComponent(this, deviceInfo, 1);
            Ctr = new EventCounter(this, deviceInfo, 1);

            m_memLockAddr = 0x400;
            m_memUnlockCode = 0xAA55;
            m_memLockCode = 0xFFFF;

            // 1/10/2012: version 1.2
            m_defaultDevCapsImage = new byte[]
                {
                    0x1F,0x8B,0x08,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0xED,0xBD,0x07,0x60,0x1C,0x49,
                    0x96,0x25,0x26,0x2F,0x6D,0xCA,0x7B,0x7F,0x4A,0xF5,0x4A,0xD7,0xE0,0x74,0xA1,0x08,
                    0x80,0x60,0x13,0x24,0xD8,0x90,0x40,0x10,0xEC,0xC1,0x88,0xCD,0xE6,0x92,0xEC,0x1D,
                    0x69,0x47,0x23,0x29,0xAB,0x2A,0x81,0xCA,0x65,0x56,0x65,0x5D,0x66,0x16,0x40,0xCC,
                    0xED,0x9D,0xBC,0xF7,0xDE,0x7B,0xEF,0xBD,0xF7,0xDE,0x7B,0xEF,0xBD,0xF7,0xBA,0x3B,
                    0x9D,0x4E,0x27,0xF7,0xDF,0xFF,0x3F,0x5C,0x66,0x64,0x01,0x6C,0xF6,0xCE,0x4A,0xDA,
                    0xC9,0x9E,0x21,0x80,0xAA,0xC8,0x1F,0x3F,0x7E,0x7C,0x1F,0x3F,0x22,0xF6,0xF6,0x77,
                    0x7E,0xF7,0xDD,0xF1,0x2E,0xFD,0xF3,0x68,0xE7,0xD1,0xB7,0x1E,0xFD,0xDE,0x8F,0x76,
                    0xE9,0x3F,0xFC,0xB5,0xAB,0x7F,0xED,0x3C,0x3A,0xA0,0xBF,0xF6,0xEC,0x5F,0x9F,0xDE,
                    0xBF,0x7F,0xEF,0x3E,0x7D,0x72,0x8F,0x5B,0xEC,0xD1,0xBF,0xF7,0x46,0xFB,0xA3,0x07,
                    0xA3,0x87,0xF4,0xD9,0xBE,0x6D,0xB5,0xBB,0x03,0x18,0xF7,0xB9,0x0D,0x60,0xED,0xE3,
                    0x95,0x4F,0x6D,0x07,0xFB,0x07,0xBF,0xFB,0xDE,0xA3,0x87,0x7E,0x6B,0x7A,0xE8,0xA3,
                    0x5D,0xD7,0xEB,0xCE,0xF8,0xFE,0xA7,0x0F,0xF1,0x91,0x41,0x6B,0xE7,0xD1,0x7D,0xD3,
                    0xCA,0x60,0x43,0x3D,0xF0,0xDF,0xF7,0x6C,0x93,0x3D,0x0B,0xE9,0xBE,0xF7,0x19,0xFE,
                    0x76,0xB8,0x59,0x30,0x0E,0x1F,0x01,0xF3,0xC0,0x36,0xB9,0xB7,0xF7,0xE0,0x53,0xA0,
                    0xB8,0x27,0x9D,0x63,0x94,0xF7,0xEF,0x8D,0xEE,0xEF,0x8F,0xEE,0x7F,0x4A,0x9F,0xDE,
                    0x3F,0xF0,0x60,0xA1,0xD5,0xAE,0x6B,0xF5,0x70,0xF4,0xE9,0xCE,0xE8,0x00,0xAD,0xF6,
                    0xF6,0xEC,0xA7,0x07,0xF7,0xE5,0xA3,0x7B,0x06,0x51,0xA5,0xC0,0x7D,0xD7,0xE3,0xA7,
                    0xFB,0xBF,0xFB,0xBD,0x47,0x7B,0xEE,0xFB,0x4F,0xF7,0xF0,0xF7,0xBE,0x05,0xF1,0xE9,
                    0xFE,0xE8,0xD3,0xFB,0xBF,0xFB,0x83,0x47,0x8E,0x40,0xBB,0xF4,0xD7,0x1E,0x30,0xD9,
                    0x91,0x06,0x9F,0x8E,0x3E,0x7D,0x30,0xFA,0xF4,0x60,0x44,0x54,0x7B,0xC0,0xF3,0xB5,
                    0x23,0xA3,0xBF,0x8F,0xD7,0xC2,0x99,0x79,0x18,0x80,0x79,0xF8,0x68,0xEF,0x53,0x6D,
                    0xBE,0xFB,0xE8,0x01,0xBE,0x75,0x6F,0xEF,0xEF,0x3D,0xDC,0x7F,0xF8,0xE9,0x83,0xBD,
                    0x87,0xF7,0xF1,0xF1,0x03,0xDB,0xEC,0xE0,0x01,0xFD,0x1D,0x02,0xBD,0xB7,0xFB,0xE0,
                    0xC1,0xDE,0xA7,0x07,0x0F,0xF6,0x76,0xFF,0x1F,0x5E,0xF7,0x66,0x42,0x54,0x02,0x00,
                    0x00 };
        }
Exemple #20
0
        //=================================================================================================================
        /// <summary>
        /// ctor 
        /// </summary>
        /// <param name="daqDevice">The DaqDevice object that creates this component</param>
        /// <param name="deviceInfo">The DeviceInfo oject passed down to the driver interface</param>
        //=================================================================================================================
        internal Usb2408xAi(DaqDevice daqDevice, DeviceInfo deviceInfo)
            : base(daqDevice, deviceInfo, 16)
        {
            // default is scale data...
            m_scaleData = true;

                // create thermocouple types...
            m_tcTypes = new ThermocoupleTypes[m_maxChannels / 2];

            m_thermocouples = new Thermocouple[m_maxChannels / 2];

                // create an array for CJC values
            m_cjcValues = new double[m_maxChannels / 2];

                // create channel types...
            for (int i = 0; i < m_maxChannels; i++)
            {
                m_aiChannelType[i] = GetChannelType(i);
            }

                // create thermocouple objects...
            for (int i = 0; i < (m_maxChannels / 2); i++)
            {
                m_tcTypes[i] = GetTcType(i);

                if (m_tcTypes[i] != ThermocoupleTypes.NotSet)
                {
                    m_thermocouples[i] = Thermocouple.CreateThermocouple(m_tcTypes[i]);
                }
            }

            // create channel mappings
            m_channelMappings.Add(0, 8);
            m_channelMappings.Add(1, 9);
            m_channelMappings.Add(2, 10);
            m_channelMappings.Add(3, 11);
            m_channelMappings.Add(4, 12);
            m_channelMappings.Add(5, 13);
            m_channelMappings.Add(6, 14);
            m_channelMappings.Add(7, 15);
        }
Exemple #21
0
        internal Usb202(DeviceInfo deviceInfo)
            : base(deviceInfo)
        {
            Ai = new Usb20xAi(this, deviceInfo);
            Dio = new DioComponent(this, deviceInfo, 1);
            Ctr = new VirtualSSEventCounter(this, deviceInfo, 1);
            Ao = new Usb20xAo(this, deviceInfo);

            // 8/26/2013: version 1.0
            m_defaultDevCapsImage = new byte[] {
                0x1F,0x8B,0x08,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0xED,0xBD,0x07,0x60,0x1C,0x49,
                0x96,0x25,0x26,0x2F,0x6D,0xCA,0x7B,0x7F,0x4A,0xF5,0x4A,0xD7,0xE0,0x74,0xA1,0x08,
                0x80,0x60,0x13,0x24,0xD8,0x90,0x40,0x10,0xEC,0xC1,0x88,0xCD,0xE6,0x92,0xEC,0x1D,
                0x69,0x47,0x23,0x29,0xAB,0x2A,0x81,0xCA,0x65,0x56,0x65,0x5D,0x66,0x16,0x40,0xCC,
                0xED,0x9D,0xBC,0xF7,0xDE,0x7B,0xEF,0xBD,0xF7,0xDE,0x7B,0xEF,0xBD,0xF7,0xBA,0x3B,
                0x9D,0x4E,0x27,0xF7,0xDF,0xFF,0x3F,0x5C,0x66,0x64,0x01,0x6C,0xF6,0xCE,0x4A,0xDA,
                0xC9,0x9E,0x21,0x80,0xAA,0xC8,0x1F,0x3F,0x7E,0x7C,0x1F,0x3F,0x22,0xF6,0x1E,0xDC,
                0xFF,0xDD,0x77,0xC7,0x3B,0xBB,0xBF,0xFB,0xEE,0xA3,0x9D,0x47,0xDF,0x7A,0xF4,0x7B,
                0x3F,0xDA,0xA5,0xFF,0x76,0x7E,0x77,0xFC,0x2B,0x7F,0xED,0x3C,0x3A,0xA0,0xBF,0xEE,
                0xF1,0xDF,0xF8,0xF4,0x1E,0xFD,0xB5,0x67,0xBF,0xDB,0xDF,0x79,0x48,0xEF,0x3F,0xDA,
                0xB7,0x1F,0xEC,0xED,0xE0,0xE5,0xFB,0xB6,0xF9,0x3E,0xBE,0xFE,0xD4,0x42,0xDE,0x07,
                0xB0,0xFD,0x07,0xF6,0xEF,0xDD,0xDD,0x4F,0x7F,0xF7,0xBD,0x47,0x0F,0xED,0xEB,0xBB,
                0x3B,0x78,0xE8,0xA3,0x5D,0xD7,0xFF,0x0E,0xA1,0x87,0x56,0xBB,0x06,0x41,0xBF,0x99,
                0x41,0x85,0xA0,0x3E,0xC4,0xDF,0x06,0x34,0xB5,0xF9,0xF4,0xDE,0xC1,0x3E,0x3E,0x72,
                0xD0,0x0F,0xF0,0xE7,0x81,0xEB,0x7C,0xFF,0x1E,0x7D,0xB0,0x2F,0xC8,0xEF,0xE1,0x83,
                0x1D,0xC0,0xD8,0xDB,0xB1,0x1F,0xDC,0xBF,0x37,0xBA,0x0F,0x18,0x7B,0xBB,0xF6,0xA3,
                0x83,0xFB,0xA3,0x03,0x60,0xB3,0xB7,0xD7,0xFB,0x68,0xDF,0x8C,0x93,0xC8,0x40,0x7F,
                0xDE,0x37,0x3D,0x09,0x55,0xEE,0x3D,0xDA,0xBB,0xE7,0xBA,0xDE,0x7B,0x88,0x0F,0x5C,
                0xD7,0x9F,0xEE,0x8F,0x3E,0xBD,0x3F,0x7A,0xB8,0x37,0x7A,0x78,0xEF,0x77,0xDF,0x7F,
                0xE4,0x06,0xBF,0x47,0x7F,0x75,0xC8,0xBD,0xFF,0x08,0x70,0x84,0xBC,0x7B,0x9F,0xD2,
                0x9F,0x1E,0xF5,0xEF,0xEF,0xA0,0xFD,0x7D,0xFB,0xFD,0x3E,0x9A,0x77,0xE8,0xFD,0xC0,
                0x03,0xBF,0x4B,0x7F,0xED,0x01,0xCF,0x1D,0xC1,0xE2,0xD3,0xD1,0xA7,0x0F,0x46,0x9F,
                0x1E,0x8C,0x3E,0x7D,0x48,0x5F,0xEC,0xEF,0xD8,0x2F,0x1E,0xEE,0x8F,0xA8,0xE7,0x07,
                0x8C,0xCA,0x8E,0x76,0x85,0xBF,0xC3,0x89,0x7F,0x18,0x40,0x7E,0x48,0xD8,0x69,0xF3,
                0xDD,0x47,0x0F,0xF0,0xAD,0x7B,0x7B,0x7F,0xEF,0xE1,0xFE,0xC3,0x4F,0x1F,0xEC,0x11,
                0xD0,0x87,0x8F,0xF6,0x77,0xED,0xE7,0x68,0xB5,0xEF,0x9A,0xF1,0x4B,0x0F,0x2C,0x90,
                0x83,0x07,0xF8,0x3A,0xA4,0xEA,0xC1,0xBD,0x4F,0x1F,0xEE,0x3D,0x7C,0xF8,0xE9,0xEE,
                0xFF,0x03,0x6E,0x2C,0xBF,0xDB,0xCA,0x02,0x00,0x00
            };
        }
Exemple #22
0
        internal Usb205(DeviceInfo deviceInfo)
            : base(deviceInfo)
        {
            Ai = new Usb20xAi(this, deviceInfo);
            Dio = new DioComponent(this, deviceInfo, 1);
            Ctr = new VirtualSSEventCounter(this, deviceInfo, 1);
            Ao = new Usb20xAo(this, deviceInfo);

            // 8/26/2013: version 1.0
            m_defaultDevCapsImage = new byte[] {
               0x1F,0x8B,0x08,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0xED,0xBD,0x07,0x60,0x1C,0x49,
                0x96,0x25,0x26,0x2F,0x6D,0xCA,0x7B,0x7F,0x4A,0xF5,0x4A,0xD7,0xE0,0x74,0xA1,0x08,
                0x80,0x60,0x13,0x24,0xD8,0x90,0x40,0x10,0xEC,0xC1,0x88,0xCD,0xE6,0x92,0xEC,0x1D,
                0x69,0x47,0x23,0x29,0xAB,0x2A,0x81,0xCA,0x65,0x56,0x65,0x5D,0x66,0x16,0x40,0xCC,
                0xED,0x9D,0xBC,0xF7,0xDE,0x7B,0xEF,0xBD,0xF7,0xDE,0x7B,0xEF,0xBD,0xF7,0xBA,0x3B,
                0x9D,0x4E,0x27,0xF7,0xDF,0xFF,0x3F,0x5C,0x66,0x64,0x01,0x6C,0xF6,0xCE,0x4A,0xDA,
                0xC9,0x9E,0x21,0x80,0xAA,0xC8,0x1F,0x3F,0x7E,0x7C,0x1F,0x3F,0x22,0xF6,0x1E,0x7C,
                0xFA,0xBB,0xEF,0x8E,0x77,0x76,0x7F,0xF7,0xDD,0x47,0x3B,0x8F,0xBE,0xF5,0xE8,0xF7,
                0x7E,0xB4,0x4B,0xFF,0xED,0xFC,0xEE,0xF8,0x57,0xFE,0xDA,0x79,0x74,0x40,0x7F,0xDD,
                0xE3,0xBF,0xF1,0xE9,0x3D,0xFA,0x6B,0xCF,0x7E,0xB7,0xBF,0xF3,0xF0,0x3E,0x7D,0xB0,
                0x6F,0x3F,0xD8,0xDB,0xC1,0xCB,0xF7,0x6D,0xF3,0x7D,0x7C,0xFD,0xA9,0x85,0xBC,0x0F,
                0x60,0xFB,0x0F,0xEC,0xDF,0xBB,0xBB,0x9F,0xFE,0xEE,0x7B,0x8F,0x1E,0xDA,0xD7,0xEF,
                0xEF,0xE0,0xA1,0x8F,0x76,0x5D,0xFF,0x3B,0x84,0x1E,0x5A,0xED,0x1A,0x04,0xFD,0x66,
                0x06,0x15,0x82,0xFA,0x10,0x7F,0x1B,0xD0,0x3B,0xF4,0xD5,0xDE,0xC1,0x01,0x3E,0x72,
                0xD0,0xF9,0xCF,0x03,0xD7,0xF9,0xFE,0x3D,0xFA,0x60,0x5F,0x90,0xDF,0xC3,0x07,0x3B,
                0x80,0xB1,0xB7,0x63,0x3F,0xB8,0x7F,0x6F,0x74,0x7F,0x1F,0x1F,0xED,0xDA,0x8F,0x0E,
                0xEE,0x8F,0x0E,0x80,0xCD,0xDE,0x5E,0xEF,0xA3,0x7D,0x33,0x4E,0x22,0x03,0xFD,0x79,
                0xDF,0xF4,0x24,0x54,0xB9,0xF7,0x68,0xEF,0x9E,0xEB,0x7A,0xEF,0x21,0x3E,0x70,0x5D,
                0x7F,0xBA,0x3F,0xFA,0xF4,0xFE,0xE8,0xE1,0xDE,0xE8,0xE1,0xBD,0xDF,0x7D,0xFF,0x91,
                0x1B,0xFC,0x1E,0xFD,0xD5,0x21,0xF7,0xFE,0x23,0xC0,0x11,0xF2,0xEE,0x7D,0x4A,0x7F,
                0x7A,0xD4,0xBF,0xBF,0x83,0xF6,0xF7,0xED,0xF7,0xFB,0x68,0xDE,0xA1,0xF7,0x03,0x0F,
                0xFC,0x2E,0xFD,0xB5,0x07,0x3C,0x77,0x04,0x8B,0x4F,0x47,0x9F,0x3E,0x18,0x7D,0x7A,
                0x30,0xFA,0xF4,0x21,0x7D,0xB1,0xBF,0x63,0xBF,0x78,0xB8,0x3F,0xA2,0x9E,0x1F,0x30,
                0x2A,0x3B,0xDA,0x15,0xFE,0x0E,0x27,0xFE,0x61,0x00,0xF9,0x21,0x61,0xA7,0xCD,0x77,
                0x1F,0x3D,0xC0,0xB7,0xEE,0xED,0xFD,0xBD,0x87,0xFB,0x0F,0x3F,0x7D,0xB0,0x47,0x40,
                0x1F,0x3E,0xDA,0xDF,0xB5,0x9F,0xA3,0xD5,0xBE,0x6B,0xC6,0x2F,0x3D,0xB0,0x40,0x0E,
                0x1E,0xE0,0xEB,0x90,0xAA,0x0F,0xF6,0x3F,0xFD,0x74,0x7F,0xFF,0xE0,0xFE,0xEE,0xFF,
                0x03,0xB0,0x53,0x10,0xFE,0xCA,0x02,0x00,0x00
            };
        }
 //=================================================================================================================
 /// <summary>
 /// ctor 
 /// </summary>
 /// <param name="daqDevice">The DaqDevice object that creates this component</param>
 /// <param name="deviceInfo">The DeviceInfo oject passed down to the driver interface</param>
 //=================================================================================================================
 internal FixedModeAiComponent(DaqDevice daqDevice, DeviceInfo deviceInfo, int maxChannels)
     : base(daqDevice, deviceInfo, maxChannels)
 {
 }
 //=================================================================================================================
 /// <summary>
 /// ctor 
 /// </summary>
 /// <param name="daqDevice">The DaqDevice object that creates this component</param>
 /// <param name="deviceInfo">The DeviceInfo oject passed down to the driver interface</param>
 //=================================================================================================================
 internal Usb1208FSPlusAi(DaqDevice daqDevice, DeviceInfo deviceInfo)
     : base(daqDevice, deviceInfo)
 {
     m_adjustScanRateForChannelCount = false;
 }
 //=================================================================================================================
 /// <summary>
 /// ctor 
 /// </summary>
 /// <param name="daqDevice">The DaqDevice object that creates this component</param>
 /// <param name="deviceInfo">The DeviceInfo oject passed down to the driver interface</param>
 //=================================================================================================================
 public Usb1208FSPlusAo(DaqDevice daqDevice, DeviceInfo deviceInfo)
     : base(daqDevice, deviceInfo, 2)
 {
 }
 //===================================================================================================
 /// <summary>
 /// Overrides abstact method in base class
 /// </summary>
 /// <param name="deviceInfo">A deviceInfo object</param>
 /// <returns>An empty string</returns>
 //===================================================================================================
 internal override string GetSerno(DeviceInfo deviceInfo)
 {
     System.Diagnostics.Debug.Assert(false, "GetSerno not implemented in UsbPlatformInterop");
     return String.Empty;
 }
        internal UsbPlatformInterop(DeviceInfo deviceInfo, CriticalParams criticalParams)
            : base(deviceInfo, criticalParams)
        {
            string msg;

            // create a device ID message
            msg = Messages.DEV_ID_QUERY;

            for (int i = 0; i < msg.Length; i++)
                m_devIdMessage[i] = (byte)msg[i];

            // create a mfg serno message
            msg = Messages.DEV_SERNO_QUERY;

            for (int i = 0; i < msg.Length; i++)
                m_sernoMessage[i] = (byte)msg[i];

            // create an aiscan status message
            msg = Messages.AISCAN_STATUS_QUERY;

            for (int i = 0; i < msg.Length; i++)
                m_aiScanStatusMessage[i] = (byte)msg[i];

            // create an aoscan status message
            msg = Messages.AOSCAN_STATUS_QUERY;

            for (int i = 0; i < msg.Length; i++)
                m_aoScanStatusMessage[i] = (byte)msg[i];

            // build an ai scan reset packet
            byte[] aiScanResetCmd = new byte[Constants.MAX_MESSAGE_LENGTH];

            msg = Messages.AISCAN_RESET;

            for (int i = 0; i < msg.Length; i++)
                aiScanResetCmd[i] = (byte)msg[i];

            m_aiScanResetPacket.TransferType = UsbTransferTypes.ControlOut;
            m_aiScanResetPacket.Request = 0x80;
            m_aiScanResetPacket.DeferTransfer = false;
            m_aiScanResetPacket.BytesTransfered = 0;

            for (int i = 0; i < aiScanResetCmd.Length; i++)
                m_aiScanResetPacket.Buffer[i] = aiScanResetCmd[i];

            // build an ao scan reset packet
            byte[] aoScanResetCmd = new byte[Constants.MAX_MESSAGE_LENGTH];

            msg = Messages.AOSCAN_RESET;

            for (int i = 0; i < msg.Length; i++)
                aoScanResetCmd[i] = (byte)msg[i];

            m_aoScanResetPacket.TransferType = UsbTransferTypes.ControlOut;
            m_aoScanResetPacket.Request = 0x80;
            m_aoScanResetPacket.DeferTransfer = false;
            m_aoScanResetPacket.BytesTransfered = 0;

            for (int i = 0; i < aoScanResetCmd.Length; i++)
                m_aoScanResetPacket.Buffer[i] = aoScanResetCmd[i];
        }
Exemple #28
0
 //=================================================================================================================
 /// <summary>
 /// Virtual method for setting the default values for the critical params
 /// </summary>
 //=================================================================================================================
 internal virtual void SetDefaultCriticalParams(DeviceInfo deviceInfo)
 {
 }
Exemple #29
0
 //=================================================================================================================
 /// <summary>
 /// ctor 
 /// </summary>
 /// <param name="daqDevice">The DaqDevice object that creates this component</param>
 /// <param name="deviceInfo">The DeviceInfo oject passed down to the driver interface</param>
 //=================================================================================================================
 internal IoComponent(DaqDevice daqDevice, DeviceInfo deviceInfo, int maxChannels)
 {
     m_daqDevice = daqDevice;
     m_deviceInfo = deviceInfo;
     m_maxChannels = maxChannels;
 }
 //=====================================================================================
 /// <summary>
 /// Device-specific constructor used by the driver interface
 /// </summary>
 /// <param name="deviceNumber">The device number</param>
 //=====================================================================================
 internal SynchronousUsbInterop(DeviceInfo deviceInfo, CriticalParams criticalParams)
     : base(deviceInfo, criticalParams)
 {
     m_readyToStartOutputScan = false;
 }