denko 0.13.3 → 0.13.4

data/lib/denko/sensor/bmp180.rb

@@ -0,0 +1,223 @@
+module Denko
+  module Sensor
+    class BMP180
+      include I2C::Peripheral
+      include Behaviors::Poller
+      
+      # Write this to register 0xE0 for soft reset
+      SOFT_RESET = 0xB6
+
+      #
+      # Pressure Oversample Setting Values
+      #
+      # General formula:
+      #   2 ** n, where n is the decimal value of the bits, up to 8x pressure oversampling.
+      #
+      OVERSAMPLE_FACTORS = {
+        1  =>  0b00,
+        2  =>  0b01,
+        4  =>  0b10,
+        8  =>  0b11,
+      }
+
+      def before_initialize(options={})
+        @i2c_address = 0x77
+        super(options)
+      end
+
+      def after_initialize(options={})
+        super(options)
+        
+        # Avoid repeated memory allocation for callback data and state.
+        @reading   = { temperature: nil, pressure: nil }
+        self.state = { temperature: nil, pressure: nil }
+
+        # Default to start conversion off, reading temperature, no pressure oversampling.
+        @register = 0b00001110
+        @calibration_data_loaded = false
+        @oss = 0b00
+
+        # Temporary storage for raw bytes, since two I2C reads are needed for temperature and pressure.
+        @raw_bytes = [0, 0, 0, 0, 0]
+
+        soft_reset
+      end
+
+      #
+      # Configuration Methods
+      #
+      def soft_reset
+        i2c_write(SOFT_RESET)
+      end
+
+      attr_reader :measurement_time
+      
+      def update_measurement_time
+        # Get oversample bits from current register setting.
+        oversample_exponent = (@register & 0b11000000) >> 6
+
+        # Calculate time in milliseconds.
+        extra_samples = (2 ** oversample_exponent) - 1
+        extra_time = extra_samples * 3
+        total_time = 4.5 + extra_time
+
+        # Sleep 1ms extra for safety and convert it to seconds.
+        @measurement_time = (total_time + 1) / 1000.0
+      end
+
+      def pressure_samples=(factor)
+        raise ArgumentError, "invalid oversampling factor: #{factor}" unless OVERSAMPLE_FACTORS.keys.include? factor
+        @oss = OVERSAMPLE_FACTORS[factor]
+      end
+    
+      def write_settings
+        update_measurement_time
+        i2c_write [0xF4, @register]
+      end
+
+      #
+      # Reading Methods
+      #
+      def _start_read_temperature
+        @register = 0x2E
+        write_settings
+      end
+
+      def _start_read_pressure
+        @register = 0x34 | (@oss << 6)
+        write_settings
+      end
+
+      def _read
+        get_calibration_data unless calibration_data_loaded
+
+        _start_read_temperature
+        sleep(@measurement_time)
+        i2c_read 0xF6, 2
+
+        _start_read_pressure
+        sleep(@measurement_time)
+        i2c_read 0xF6, 3
+      end
+
+      def pre_callback_filter(data)
+        # Temperature is 2 bytes.
+        if data.length == 2
+          @raw_bytes[0] = data[0]
+          @raw_bytes[1] = data[1]
+        # Pressure is 3 bytes and triggers callbacks.
+        elsif data.length == 3
+          @raw_bytes[2] = data[0]
+          @raw_bytes[3] = data[1]
+          @raw_bytes[4] = data[2]
+          return decode_reading(@raw_bytes)
+        # Calibration data is 22 bytes.
+        elsif data.length == 22
+          process_calibration(data)
+        end
+
+        # Anything other than pressure avoids callbacks.
+        return nil
+      end
+
+      def update_state(reading)
+        # Checking for Hash ignores calibration data and nil.
+        if reading.class == Hash
+          @state_mutex.synchronize do
+            @state[:temperature] = reading[:temperature]
+            @state[:pressure]    = reading[:pressure]
+          end
+        end
+      end
+
+      def [](key)
+        @state_mutex.synchronize do
+          return @state[key]
+        end
+      end
+      
+      #
+      # Decoding Methods
+      #
+      def decode_reading(bytes)
+        temperature, b5 = decode_temperature(bytes)
+        @reading[:temperature] = temperature
+        @reading[:pressure] = decode_pressure(bytes, b5)
+        @reading
+      end
+
+      def decode_temperature(bytes)
+        # Temperature is bytes [0..2], MSB first.
+        ut = bytes[0] << 8 | bytes[1]
+
+        # Calibration compensation from datasheet
+        x1 = (ut - @calibration[:ac6]) * @calibration[:ac5] / 32768
+        x2 = (@calibration[:mc] * 2048) / (x1 + @calibration[:md])
+        b5 = x1 + x2
+
+        # 160 instead of 16 since datasheet calculates to 0.1 C units.
+        # Float to force the final value into float, but keep b5 integer for pressure.
+        temperature = (b5 + 8) / 160.0
+
+        # Return temperature and b5 for pressure calculation.
+        [temperature, b5]
+      end
+      
+      def decode_pressure(bytes, b5)
+        # Pressure is bytes [2..3], MSB first.
+        up = ((bytes[2] << 16) | (bytes[3] << 8) | (bytes[4])) >> (8 - @oss)
+
+        # Calibration compensation from datasheet
+        b6 = b5 - 4000
+        x1 = (@calibration[:b2] * (b6 * b6 / 4096)) / 2048
+        x2 = @calibration[:ac2] * b6 / 2048
+        x3 = x1 + x2
+        b3 = (((@calibration[:ac1]*4 + x3) << @oss) + 2) / 4
+        x1 = @calibration[:ac3] * b6 / 8192
+        x2 = (@calibration[:b1] * (b6 * b6 / 4096)) / 65536
+        x3 = (x1 + x2 + 2) / 4
+        b4 = (@calibration[:ac4] * ((x3+32768) & 0xFFFF_FFFF)) / 32768
+        b7 = ((up & 0xFFFF_FFFF) - b3) * (50000 >> @oss)
+        if (b7 < 0x8000_0000)
+          p = (b7 * 2) / b4
+        else
+          p = (b7 / b4) * 2
+        end
+        x1 = (p / 256) * (p / 256)
+        x1 = (x1 * 3038) / 65536
+        x2 = (-7357 * p) / 65536
+        p = p + (x1 + x2 + 3791) / 16
+        pressure = p.to_f
+      end
+
+      #
+      # Calibration Methods
+      #
+      attr_reader :calibration_data_loaded
+      
+      def get_calibration_data        
+        #  Calibration data is 22 bytes starting at address 0xAA.
+        read_using -> { i2c_read(0xAA, 22) }
+      end
+
+      def process_calibration(bytes)
+        if bytes
+          @calibration = {
+            ac1: bytes[0..1].pack('C*').unpack('s>')[0],
+            ac2: bytes[2..3].pack('C*').unpack('s>')[0],
+            ac3: bytes[4..5].pack('C*').unpack('s>')[0],
+            ac4: bytes[6..7].pack('C*').unpack('S>')[0],
+            ac5: bytes[8..9].pack('C*').unpack('S>')[0],
+            ac6: bytes[10..11].pack('C*').unpack('S>')[0],
+            b1: bytes[12..13].pack('C*').unpack('s>')[0],
+            b2: bytes[14..15].pack('C*').unpack('s>')[0],
+            mb: bytes[16..17].pack('C*').unpack('s>')[0],
+            mc: bytes[18..19].pack('C*').unpack('s>')[0],
+            md: bytes[20..21].pack('C*').unpack('s>')[0],
+          }
+          @calibration_data_loaded = true
+        end
+      end
+    end
+  end
+end

data/lib/denko/sensor/generic_pir.rb

@@ -0,0 +1,8 @@
+module Denko
+  module Sensor
+    class GenericPIR < DigitalIO::Input
+      alias :on_motion_stop  :on_low
+      alias :on_motion_start :on_high
+    end
+  end
+end

data/lib/denko/sensor/htu21d.rb

@@ -128,8 +128,12 @@ module Denko
 
         # Bit 1 of LSB determines type of reading; 0 for temperature, 1 for humidity.
         if (bytes[1] & 0b00000010) > 0
+          # Calculate humidity and limit within 0-100 range.
+          humidity = (raw_value.to_f / 524.288) - 6
+          humidity = 0.0   if humidity < 0.0
+          humidity = 100.0 if humidity > 100.0
           @reading[0] = :humidity
-          @reading[1] = (raw_value.to_f / 524.288) - 6
+          @reading[1] = humidity
           @humidity.update(@reading[1])
         else
           @reading[0] = :temperature
@@ -138,7 +142,7 @@ module Denko
         end
         @reading
       end
-      
+
       def update_state(reading)
         @state_mutex.synchronize do
           @state[reading[0]] = reading[1]

data/lib/denko/sensor/qmp6988.rb

@@ -0,0 +1,308 @@
+module Denko
+  module Sensor
+    class QMP6988
+      include I2C::Peripheral
+      include Behaviors::Poller
+
+      UPDATE_TIME           = 0.020
+      RESET_REGISTER        = 0xE0
+      RESET_COMMAND         = 0xE6
+      CTRL_MEAS_REGISTER    = 0xF4
+      STANDBY_TIME_REGISTER = 0xF5
+      IIR_REGISTER          = 0xF1
+      CONFIG_LENGTH         = 5
+      DATA_REGISTER         = 0xF7
+      DATA_LENGTH           = 6
+      CALIBRATION_REGISTER  = 0xA0
+      CALIBRATION_LENGTH    = 25
+      CHIP_ID_REGISTER      = 0xD1
+      CHIP_ID_LENGTH        = 1
+      FORCED_MODE           = 0b01
+      NORMAL_MODE           = 0b11
+
+      # Standby Times for Normal (Continuous) Mode in milliseconds
+      STANDBY_TIMES = {
+        1    => 0b000,
+        5    => 0b001,
+        50   => 0b010,
+        250  => 0b011,
+        500  => 0b100,
+        1000 => 0b101,
+        2000 => 0b110,
+        4000 => 0b111,
+      }
+
+      #
+      # Oversample Setting Values
+      # Note: Each sensor has a separate oversample setting.
+      #
+      # General formula:
+      #   2 ** (n-1), where n is the decimal value of the bits, up to 16x max oversampling.
+      #
+      OVERSAMPLE_FACTORS = {
+        # 0  =>  0b000, # Sensor skipped. Value will be 0x800000.
+        1  =>  0b001,
+        2  =>  0b010,
+        4  =>  0b011,
+        8  =>  0b100,
+        16 =>  0b101,
+        32 =>  0b110,
+        64 =>  0b111,
+      }
+      #
+      # Single sample times (in milliseconds) for each sensor, derived from datasheet examples.
+      TEMPERATURE_SAMPLE_TIME = 0.9
+      PRESSURE_SAMPLE_TIME = 0.85
+
+      # IIR Filter Coefficients
+      IIR_COEFFICIENTS = {
+        0  =>  0b000,
+        2  =>  0b001,
+        4  =>  0b010,
+        8  =>  0b011,
+        16 =>  0b100,
+        32 =>  0b101, # 0b110 and 0b111 are also valid for 16.
+      }
+
+      def before_initialize(options={})
+        @i2c_address = 0x70
+        super(options)
+      end
+
+      def after_initialize(options={})
+        super(options)
+
+        # Avoid repeated memory allocation for callback data and state.
+        @reading     = { temperature: nil, pressure: nil }
+        self.state   = { temperature: nil, pressure: nil }
+
+        reset
+        
+        # Get 5 config registers. Copy 0xF4 to modify it for control.
+        get_config_registers
+        @ctrl_meas_register = @registers[:f4].dup
+
+        # Default settings
+        self.iir_coefficient = 0
+        self.temperature_samples = 1
+        self.pressure_samples = 1
+        self.forced_mode
+
+        # self.forced mode triggered an initial measurement so IIR works properly if enabled.
+        # Wait for those values to enter the data registers, but don't read them back.
+        sleep @measurement_time
+
+        get_calibration_data
+      end
+
+      #
+      # Configuration Methods
+      #
+      def reset
+        i2c_write [RESET_REGISTER, RESET_COMMAND]
+        sleep UPDATE_TIME
+      end
+
+      def iir_coefficient=(coeff)
+        raise ArgumentError, "invalid IIR coefficient: #{coeff}" unless IIR_COEFFICIENTS.keys.include? coeff
+        i2c_write [IIR_REGISTER, IIR_COEFFICIENTS[coeff]]
+        @iir_coefficient = coeff
+      end
+      attr_reader :iir_coefficient
+
+      def standby_time=(ms)
+        raise ArgumentError, "invalid standby time: #{ms}" unless self.class::STANDBY_TIMES.keys.include? ms
+        byte = STANDBY_TIMES[ms] << 5
+        @standby_time = ms
+        i2c_write [STANDBY_TIME_REGISTER, byte]
+        sleep UPDATE_TIME
+      end
+      attr_reader :standby_time
+
+      def temperature_samples=(factor)
+        raise ArgumentError, "invalid oversampling factor: #{factor}" unless OVERSAMPLE_FACTORS.keys.include? factor
+        @ctrl_meas_register = (@ctrl_meas_register & 0b00011111) | (OVERSAMPLE_FACTORS[factor] << 5)
+        @temperature_samples = factor
+        calculate_measurement_time
+        i2c_write [CTRL_MEAS_REGISTER, @ctrl_meas_register]
+        sleep UPDATE_TIME
+      end
+      attr_reader :temperature_samples
+      
+      def pressure_samples=(factor)
+        raise ArgumentError, "invalid oversampling factor: #{factor}" unless OVERSAMPLE_FACTORS.keys.include? factor
+        @ctrl_meas_register = (@ctrl_meas_register & 0b11100011) | (OVERSAMPLE_FACTORS[factor] << 2)
+        @pressure_samples = factor
+        calculate_measurement_time
+        i2c_write [CTRL_MEAS_REGISTER, @ctrl_meas_register]
+        sleep UPDATE_TIME
+      end
+      attr_reader :pressure_samples
+
+      def calculate_measurement_time
+        @measurement_time = (@temperature_samples.to_i * TEMPERATURE_SAMPLE_TIME) +
+                           (@pressure_samples.to_i * PRESSURE_SAMPLE_TIME)
+        # Add 5ms for safety and convert to seconds.
+        @measurement_time = (@measurement_time + 5) * 0.001
+      end
+
+      def forced_mode
+        @ctrl_meas_register = (@ctrl_meas_register & 0b11111100) | FORCED_MODE
+        i2c_write [CTRL_MEAS_REGISTER, @ctrl_meas_register]
+        @forced_mode = true
+        sleep UPDATE_TIME
+      end
+
+      def continuous_mode
+        @ctrl_meas_register = (@ctrl_meas_register & 0b11111100) | NORMAL_MODE
+        i2c_write [CTRL_MEAS_REGISTER, @ctrl_meas_register]
+        @forced_mode = false
+        sleep UPDATE_TIME
+      end
+
+      def chip_id
+        return @chip_id if @chip_id
+        i2c_read(CHIP_ID_REGISTER, 1)
+        sleep 0.001 while !@chip_id
+        @chip_id
+      end
+
+      #
+      # Reading & Processing
+      #
+      def _read
+        if @forced_mode
+          # Write CTRL_MEAS register to trigger reading, then wait for measurement.
+          i2c_write [CTRL_MEAS_REGISTER, @ctrl_meas_register]
+          sleep @measurement_time
+        end
+        
+        # Read the data bytes.
+        i2c_read(DATA_REGISTER, DATA_LENGTH)
+      end
+
+      def pre_callback_filter(bytes)
+        if bytes.length == DATA_LENGTH
+          return process_reading(bytes)
+        elsif bytes.length == CONFIG_LENGTH
+          process_config(bytes)
+        elsif bytes.length == CALIBRATION_LENGTH
+          process_calibration(bytes)
+        elsif bytes.length == CHIP_ID_LENGTH
+          @chip_id = bytes[0]
+        end
+        return nil
+      end
+
+      def process_reading(bytes)
+        # Temperature and pressure are 24-bits long each, and need 2^23 subtracted.
+        dt = ((bytes[3] << 16) + (bytes[4] << 8) + bytes[5]) - (0b1 << 23)
+        dp = ((bytes[0] << 16) + (bytes[1] << 8) + bytes[2]) - (0b1 << 23)
+
+        # Compensated temperature calculated in 1/256 of a degree Celsius.
+        tr =  @calibration[:a0] +
+              @calibration[:a1] * dt +
+              @calibration[:a2] * (dt ** 2)
+        @reading[:temperature] = tr / 256.0
+
+        # Compensated pressure calculated in Pascals.
+        @reading[:pressure] = @calibration[:b00] +
+                              @calibration[:bt1] * tr +
+                              @calibration[:bp1] * dp +
+                              @calibration[:b11] * (tr * dp)  +
+                              @calibration[:bt2] * (tr ** 2) +
+                              @calibration[:bp2] * (dp ** 2) +
+                              @calibration[:b12] * (dp * (tr ** 2)) +
+                              @calibration[:b21] * ((dp ** 2) * tr) +
+                              @calibration[:bp3] * (dp ** 3)
+
+        # Return reading for callbacks.
+        @reading
+      end
+
+      def update_state(reading)
+        @state_mutex.synchronize do
+          @state[:temperature] = reading[:temperature]
+          @state[:pressure]    = reading[:pressure]
+        end
+      end
+
+      def get_config_registers
+        @registers = {}
+        i2c_read(IIR_REGISTER, CONFIG_LENGTH)
+        sleep 0.001 while @registers.empty?
+        @registers
+      end
+
+      def process_config(bytes)
+        @registers = { f1: bytes[0], f2: bytes[1], f3: bytes[2], f4: bytes[3], f5: bytes[4] }
+      end
+      attr_reader :registers
+
+      #
+      # Calibration
+      #
+      attr_reader :calibration_data_loaded
+
+      CONVERSION_FACTORS = {
+        a1:  { A: -6.3e-03,   S: 4.3e-04 },
+        a2:  { A: -1.9e-11,   S: 1.2e-10 },
+        bt1: { A:  1.0e-01,   S: 9.1e-02 },
+        bt2: { A:  1.2e-08,   S: 1.2e-06 },
+        bp1: { A:  3.3e-02,   S: 1.9e-02 },
+        b11: { A:  2.1e-07,   S: 1.4e-07 },
+        bp2: { A: -6.3e-10,   S: 3.5e-10 },
+        b12: { A:  2.9e-13,   S: 7.6e-13 },
+        b21: { A:  2.1e-15,   S: 1.2e-14 },
+        bp3: { A:  1.3e-16,   S: 7.9e-17 },
+        a0:  16.0,
+        b00: 16.0,
+      }
+
+      def get_calibration_data
+        i2c_read(CALIBRATION_REGISTER, CALIBRATION_LENGTH)
+      end
+
+      def process_calibration(bytes)
+        if bytes
+          # These 2 values are 20-bit instead of 16-bit, so can't combine them with #pack.
+          a0_unsigned  = (bytes[18] << 12) + (bytes[19] << 4) + (bytes[24] & 0b00001111)
+          b00_unsigned = (bytes[0] << 12) + (bytes[1] << 4) + ((bytes[24] & 0b11110000) >> 4)
+
+          # Cast the raw bytes as big-endian signed.
+          @calibration_raw = {
+            # Shift these to 32-bit before converting to signed, then reverse the shift after.
+            a0: [(a0_unsigned << 12)].pack('L>').unpack('l>')[0] >> 12,
+            b00: [(b00_unsigned << 12)].pack('L>').unpack('l>')[0] >> 12,
+
+            a1: bytes[20..21].pack('C*').unpack('s>')[0],
+            a2: bytes[22..23].pack('C*').unpack('s>')[0],
+
+            b11: bytes[8..9].pack('C*').unpack('s>')[0],
+            b12: bytes[12..13].pack('C*').unpack('s>')[0],
+            b21: bytes[14..15].pack('C*').unpack('s>')[0],
+
+            bp1: bytes[6..7].pack('C*').unpack('s>')[0],
+            bp2: bytes[10..11].pack('C*').unpack('s>')[0],
+            bp3: bytes[16..17].pack('C*').unpack('s>')[0],
+
+            bt1: bytes[2..3].pack('C*').unpack('s>')[0],
+            bt2: bytes[4..5].pack('C*').unpack('s>')[0],
+          }
+
+          # Use conversion formulae to calculate compensation coefficients, all as floats.
+          @calibration = {}
+          @calibration_raw.keys.each do |key|
+            if CONVERSION_FACTORS[key].class == Float
+              @calibration[key] = @calibration_raw[key] / CONVERSION_FACTORS[key]
+            else
+              @calibration[key] = CONVERSION_FACTORS[key][:A] + (CONVERSION_FACTORS[key][:S] * @calibration_raw[key] / 32767.0)
+            end
+          end
+
+          @calibration_data_loaded = true
+        end
+      end
+    end
+  end
+end

data/lib/denko/sensor/rcwl9620.rb

@@ -0,0 +1,34 @@
+module Denko
+  module Sensor
+    class RCWL9620
+      include I2C::Peripheral
+      include Behaviors::Poller
+
+      def before_initialize(options={})
+        @i2c_address = 0x57
+        super(options)
+      end
+
+      def _read
+        i2c_write(0x01)
+        sleep(0.120)
+        i2c_read(nil, 3)
+      end
+
+      def pre_callback_filter(bytes)
+        # Data is in micrometers, 3 bytes, big-endian.
+        um = (bytes[0] << 16) + (bytes[1] << 8) + bytes[2]
+        mm = um / 1000.0
+
+        # Limit output between 20 and 4500mm.
+        if mm > 4500.0
+          return 4500.0
+        elsif mm < 20.0
+          return 20.0
+        else
+          return mm
+        end
+      end
+    end
+  end
+end