示例#1
0
        // creates the voltage value from the decimal value
        private double DecimalToVoltage(AdcPga pga, int temp, int resolution)
        {
            double voltage;

            switch (pga)
            {
            case AdcPga.G2P3:
                voltage = 6.144;
                break;

            case AdcPga.G1:
                voltage = 4.096;
                break;

            case AdcPga.G2:
                voltage = 2.048;
                break;

            case AdcPga.G4:
                voltage = 1.024;
                break;

            case AdcPga.G8:
                voltage = 0.512;
                break;

            case AdcPga.G16:
            default:
                voltage = 0.256;
                break;
            }

            return((double)temp * (voltage / (double)resolution));
        }
        /// <summary>
        /// Get a raw ADC reading
        /// </summary>
        /// <param name="channel">Channel0 - Channel3</param>
        /// <param name="size">Size12Bit, Size14Bit, Size16Bit, Size18Bit</param>
        /// <param name="pga">Gain1, Gain2, Gain4, Gain8</param>
        /// <param name="reading">value of ADC channel read at size & gain</param>
        /// <returns>StatusResults(FT260_STATUS, FT260_CONTROLLER_STATUS)</returns>
        public UsbI2C.StatusResults ReadAdc(AdcChannel channel, AdcSize size, AdcPga pga, out uint reading)
        {
            UsbI2C.StatusResults statusResults;
            reading = 0;

            byte[] control = { 0 };

            // start one-shot conversion on channel @ size and gain...

            control[0] = (byte)(0x80 | (((int)channel & 3) << 5 | (((int)size & 3) << 2) | ((int)pga & 3)));

            lock (_usbI2C)
            {
                statusResults = _usbI2C.Write(
                    _i2cAddress,
                    UsbI2C.FT260_I2C_FLAG.FT260_I2C_START_AND_STOP,
                    control,
                    (uint)control.Length);
            }

            if (statusResults.HasErrors())
            {
                return(statusResults);
            }

            // length of result depends upon size of conversion...

            byte[] result;
            if (size == AdcSize.Size18Bit)
            {
                result = new byte[4];
            }
            else
            {
                result = new byte[3];
            }

            // continuously read until conversion complete (/RDY bit = 1)...

            do
            {
                lock (_usbI2C)
                {
                    statusResults = _usbI2C.Read(
                        _i2cAddress,
                        UsbI2C.FT260_I2C_FLAG.FT260_I2C_START_AND_STOP,
                        result,
                        (uint)result.Length);
                }

                if (statusResults.HasErrors())
                {
                    return(statusResults);
                }

                Thread.Sleep(1);
            } while ((result[result.Length - 1] & 0x80) == 0x00);

            // assemble result depending upon size of conversion...

            if (size == AdcSize.Size18Bit)
            {
                reading = ((uint)(result[0] & 3) << 16) | ((uint)result[1] << 8) | (uint)result[2];
            }
            else
            {
                reading = ((uint)result[0] << 8) | (uint)result[1];
            }

            return(statusResults);
        }