Exemple #1
0
        /// <summary>
        ///     Force the sensor to make a reading and update the relevanyt properties.
        /// </summary>
        /// <param name="startAddress">Start address for the read operation.</param>
        /// <param name="amount">Amount of data to read from the EEPROM.</param>
        public byte[] Read(ushort startAddress, ushort amount)
        {
            CheckAddress(startAddress, amount);
            var address = new byte[2];

            address[0] = (byte)((startAddress >> 8) & 0xff);
            address[1] = (byte)(startAddress & 0xff);
            _eeprom.WriteBytes(address);
            return(_eeprom.ReadBytes(amount));
        }
 /// <summary>
 ///     Send a command to the display.
 /// </summary>
 /// <param name="command">Command byte to send to the display.</param>
 private void SendCommand(byte command)
 {
     if (connectionType == ConnectionType.SPI)
     {
         dataCommandPort.State = Command;
         spiDisplay.WriteByte(command);
     }
     else
     {
         i2cPeriferal.WriteBytes(new byte[] { 0x00, command });
     }
 }
 /// <summary>
 ///     Send a command to the display.
 /// </summary>
 /// <param name="command">Command byte to send to the display.</param>
 protected virtual void SendCommand(byte command)
 {
     if (connectionType == ConnectionType.SPI)
     {
         dataCommandPort.State = Command;
         _spiPeripheral.WriteByte(command);
     }
     else
     {
         _I2cPeripheral.WriteBytes(new byte[] { 0x00, command });
     }
 }
Exemple #4
0
        /// <summary>
        ///     Update the temperature and pressure from the sensor and set the Pressure property.
        /// </summary>
        public async Task Update()
        {
            //
            //  Tell the sensor to take a temperature and pressure reading, wait for
            //  3ms (see section 2.2 of the datasheet) and then read the ADC values.
            //
            mpl115a2.WriteBytes(new byte[] { Registers.StartConversion, 0x00 });

            await Task.Delay(5);

            var data = mpl115a2.ReadRegisters(Registers.PressureMSB, 4);
            //
            //  Extract the sensor data, note that this is a 10-bit reading so move
            //  the data right 6 bits (see section 3.1 of the datasheet).
            //
            var pressure    = (ushort)(((data[0] << 8) + data[1]) >> 6);
            var temperature = (ushort)(((data[2] << 8) + data[3]) >> 6);

            Conditions.Temperature = (float)((temperature - 498.0) / -5.35) + 25;
            //
            //  Now use the calculations in section 3.2 to determine the
            //  current pressure reading.
            //
            const double PRESSURE_CONSTANT   = 65.0 / 1023.0;
            var          compensatedPressure = coefficients.A0 + ((coefficients.B1 + (coefficients.C12 * temperature))
                                                                  * pressure) + (coefficients.B2 * temperature);

            Conditions.Pressure = (float)(PRESSURE_CONSTANT * compensatedPressure) + 50;
        }
Exemple #5
0
        //Set sensor resolution
        /*******************************************************************************************/
        //Sets the sensor resolution to one of four levels
        //Page 12:
        // 0/0 = 12bit RH, 14bit Temp
        // 0/1 = 8bit RH, 12bit Temp
        // 1/0 = 10bit RH, 13bit Temp
        // 1/1 = 11bit RH, 11bit Temp
        //Power on default is 0/0
        void SetResolution(SensorResolution resolution)
        {
            byte userData = si7021.ReadRegister(READ_USER_REGISTER); //Go get the current register state
                                                                     //userRegister &= 0b01111110; //Turn off the resolution bits
                                                                     //resolution &= 0b10000001; //Turn off all other bits but resolution bits
                                                                     //userRegister |= resolution; //Mask in the requested resolution bits
            var res = (byte)resolution;

            userData &= 0x73; //Turn off the resolution bits
            res      &= 0x81; //Turn off all other bits but resolution bits
            userData |= res;  //Mask in the requested resolution bits

            //Request a write to user register
            si7021.WriteBytes(new byte[] { WRITE_USER_REGISTER }); //Write to the user register
            si7021.WriteBytes(new byte[] { userData });            //Write the new resolution bits
        }
Exemple #6
0
        private async Task Update()
        {
            byte[]   readBuffer;
            BitArray bufferBits;

            //Send the command to the sensor to tell it to do the thing.
            i2cPeripheral.WriteBytes(mprlsMeasurementCommand);

            //Datasheet says wait 5 ms.
            await Task.Delay(5);

            while (true)
            {
                readBuffer = i2cPeripheral.ReadBytes(1);
                bufferBits = new BitArray(readBuffer);

                //From section 6.5 of the datasheet.
                this.IsDevicePowered          = bufferBits[6];
                this.IsDeviceBusy             = bufferBits[5];
                this.HasMemoryIntegrityFailed = bufferBits[2];
                this.InternalMathSaturated    = bufferBits[0];

                if (this.InternalMathSaturated)
                {
                    throw new InvalidOperationException("Sensor pressure has exceeded max value!");
                }

                if (this.HasMemoryIntegrityFailed)
                {
                    throw new InvalidOperationException("Sensor internal memory integrity check failed!");
                }

                if (!(this.IsDeviceBusy))
                {
                    break;
                }
            }

            readBuffer = i2cPeripheral.ReadBytes(4);

            RawPSIMeasurement = (readBuffer[1] << 16) | (readBuffer[2] << 8) | readBuffer[3];
            //Console.WriteLine(RawPSIMeasurement);

            //From Section 8.0 of the datasheet.
            CalculatedPSIMeasurement = (RawPSIMeasurement - 1677722) * (psiMax - psiMin);
            //Console.WriteLine(CalculatedPSIMeasurement);

            CalculatedPSIMeasurement /= 15099494 - 1677722;
            //Console.WriteLine(CalculatedPSIMeasurement);

            CalculatedPSIMeasurement += psiMin;
            //Console.WriteLine(CalculatedPSIMeasurement);

            //https://www.justintools.com/unit-conversion/pressure.php?k1=psi&k2=millibars
            CalculatedhPAMeasurement = CalculatedPSIMeasurement * 68.947572932;
            //Console.WriteLine(CalculatedhPAMeasurement);

            Conditions.Pressure = CalculatedPSIMeasurement;
        }
Exemple #7
0
        private long ReadUncompensatedTemperature()
        {
            // write register address
            bmp085.WriteBytes(new byte[] { 0xF4, 0x2E });

            // Required as per datasheet.
            Thread.Sleep(5);

            // write register address
            bmp085.WriteBytes(new byte[] { 0xF6 });

            // get MSB and LSB result
            byte[] data = new byte[2];
            data = bmp085.ReadBytes(2);

            return((data[0] << 8) | data[1]);
        }
Exemple #8
0
        /// <summary>
        /// Get ASG01DB VOC Gas Concentration
        /// </summary>
        /// <returns>Concentration (ppm)</returns>
        public double GetConcentration()
        {
            var data = new byte[] { ASG_DATA_MSB, ASG_DATA_LSB };

            sensor.WriteBytes(data);
            var readBuffer = sensor.ReadBytes(3);

            // CRC check
            //   if (!CheckCrc8(readBuffer, 2, readBuffer[1]))
            //   {
            //       return -1;
            //   }

            ushort res = BinaryPrimitives.ReadUInt16BigEndian(readBuffer.AsSpan(0, 2));

            return(res / 10.0);
        }
Exemple #9
0
        public byte[] Execute(int returnBytes, out UInt16 ResultCode)
        {
            lock (lockObject)
            {
                sas.WriteBytes(WriteBufferData);
#if DEBUGSERIAL
                Console.WriteLine($"TX: {BitConverter.ToString(WriteBufferData,0,WriteBufferData.Length)}");
#endif
                return(Read(returnBytes, out ResultCode));
            }
        }
Exemple #10
0
        void TransmitData()
        {
            i2cPeripheral.WriteBytes(transmissionData);

            Thread.Sleep(100);
        }