denko 0.13.0

data/lib/denko/sensor/bme280.rb

@@ -0,0 +1,366 @@
+module Denko
+  module Sensor
+    class BME280
+      include I2C::Peripheral
+      include Behaviors::Poller
+      
+      # Reading Mode Settings
+      SLEEP_MODE      = 0b00
+      ONESHOT_MODE    = 0b01 # 0b10 is also valid. Called "forced mode" in datasheet.
+      CONTINUOUS_MODE = 0b11 # Called "normal mode" in datashseet.
+
+      # Standby Times for Normal (Continuous) Mode in milliseconds
+      STANDBY_TIMES = {
+                        0.5  => 0b000,
+                        62.5 => 0b001,
+                        125  => 0b010,
+                        250  => 0b011,
+                        500  => 0b100,
+                        1000 => 0b101,
+                        10   => 0b110,
+                        20   => 0b111,
+                      }
+
+      #
+      # Oversample Setting Values
+      #
+      # Note: Each of the 3 sensors has a separate oversample setting, but temperature cannot
+      # be skipped, since the other 2 calculations depend on it.
+      #
+      # 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, # 0b110 and 0b111 are also valid for 16x.
+                            }
+                            
+      # IIR Filter Coefficients  
+      IIR_COEFFICIENTS = {
+                            0  =>  0b000,
+                            2  =>  0b001,
+                            4  =>  0b010,
+                            8  =>  0b011,
+                            16 =>  0b100, # 0b101, 0b110 and 0b111 are also valid for 16.
+                          }
+      
+      def before_initialize(options={})
+        @i2c_address = 0x76
+        super(options)
+      end
+
+      def after_initialize(options={})
+        super(options)
+        
+        # Avoid repeated memory allocation for callback data and state.
+        @reading   = { temperature: nil, humidity: nil, pressure: nil }
+        self.state = { temperature: nil, humidity: nil, pressure: nil }
+
+        #
+        # Setup defaults for the config registers:
+        #   Oneshot reading mode
+        #   1x sampling for all sensors
+        #   500ms standby time in continuous mode
+        #   IIR filter off
+        #
+        @registers = {
+          # Bits 0..1 control operating mode.
+          # Bits 2..4 control the pressure oversampling factor
+          # Bits 5..7 control the temperature oversampling factor.
+          f4: 0b00100110,
+        
+          # Bits 0..1 should always be 0.
+          # Bits 2..4 control the IIR filter coefficient.
+          # Bits 5..7 control the standby time when in continuous reading mode.
+          f5: 0b10000000,
+        }
+        # Bits 0..2 control the humidity oversampling factor, on BME280 only.
+        # Bits 3+ are unused.
+        @registers.merge!(f2: 0b00000001) if humidity_available?
+        
+        @calibration_data_loaded = false
+      end
+
+      #
+      # Configuration Methods
+      #
+      def oneshot_mode
+        @registers[:f4] = (@registers[:f4] & 0b11111100) | ONESHOT_MODE
+        write_settings
+      end
+
+      attr_reader :measurement_time
+      
+      def update_measurement_time
+        t_oversampling = 2 ** (((@registers[:f4] & 0b11100000) >> 5) - 1)
+        p_oversampling = 2 ** (((@registers[:f4] & 0b00011100) >> 2) - 1)
+
+        # Use the maximum measurement time from the datasheet.
+        @measurement_time = 1.25 + (2.3 * t_oversampling) + (2.3 * p_oversampling) + 0.575
+
+        if humidity_available?
+          h_oversampling = 2 ** ((@registers[:f2] & 0b00000111) - 1) if humidity_available?
+          @measurement_time = @measurement_time + (2.3 * h_oversampling) + 0.575
+        end
+
+        # Milliseconds to seconds
+        @measurement_time = @measurement_time / 1000
+      end
+      
+      def continuous_mode
+        @registers[:f4] = (@registers[:f4] & 0b11111100) | CONTINUOUS_MODE
+        write_settings 
+      end
+      
+      def standby_time=(ms)
+        raise ArgumentError, "invalid standby time: #{ms}" unless self.class::STANDBY_TIMES.keys.include? ms
+
+        @registers[:f5] = (@registers[:f5] & 0b00011111) | (self.class::STANDBY_TIMES[ms] << 5)
+        write_settings
+      end
+      
+      def temperature_samples=(factor)
+        raise ArgumentError, "invalid oversampling factor: #{factor}" unless OVERSAMPLE_FACTORS.keys.include? factor
+        raise ArgumentError, "temperature must be read. Invalid oversampling factor: #{factor}" if factor == 0
+        
+        @registers[:f4] = (@registers[:f4] & 0b00011111) | (OVERSAMPLE_FACTORS[factor] << 5)
+        write_settings
+      end
+      
+      def pressure_samples=(factor)
+        raise ArgumentError, "invalid oversampling factor: #{factor}" unless OVERSAMPLE_FACTORS.keys.include? factor
+        
+        @registers[:f4] = (@registers[:f4] & 0b11100011) | (OVERSAMPLE_FACTORS[factor] << 2)
+        write_settings
+      end
+      
+      def humidity_samples=(factor)
+        raise ArgumentError, "invalid oversampling factor: #{factor}" unless OVERSAMPLE_FACTORS.keys.include? factor
+        
+        @registers[:f2] = (@registers[:f2] & 0b11111000) | OVERSAMPLE_FACTORS[factor]
+        write_settings
+      end
+      
+      def iir_coefficient=(coeff)
+        raise ArgumentError, "invalid IIR coefficient: #{coeff}" unless IIR_COEFFICIENTS.keys.include? coeff
+        
+        @registers[:f5] = (@registers[:f5] & 0b11100011) | (IIR_COEFFICIENTS[coeff] << 2)
+        write_settings
+      end
+    
+      def write_settings
+        if humidity_available?
+          i2c_write [0xF2, @registers[:f2], 0xF4, @registers[:f4], 0xF5, @registers[:f5]] 
+        else
+          i2c_write [0xF4, @registers[:f4], 0xF5, @registers[:f5]]
+        end
+        update_measurement_time
+      end
+      
+      def config_register_bits
+        str = ""
+        @registers.each_key do |key|
+          str << "0x#{key.upcase}: #{@registers[key].to_s(2).rjust(8, '0')}\n"
+        end
+        str
+      end
+
+      #
+      # Reading Methods
+      # 
+      def _read
+        get_calibration_data unless calibration_data_loaded
+        write_settings
+        i2c_read 0xF7, 8
+      end
+      
+      def pre_callback_filter(data)
+        if data.length == 8
+          return decode_reading(data)
+        elsif data.length == 26
+          process_calibration_a(data)
+          return nil
+        elsif data.length == 7
+          process_calibration_b(data)
+          return nil
+        else
+          # Ignores readings that aren't 8 bytes.
+          return nil
+        end
+      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]
+            @state[:humidity]    = reading[:humidity]
+          end
+        end
+      end
+
+      def [](key)
+        @state_mutex.synchronize do
+          return @state[key]
+        end
+      end
+      
+      #
+      # Decoding Methods
+      #
+      def decode_reading(bytes)
+        # Always read temperature since t_fine is needed to calibrate other values.
+        temperature, t_fine = decode_temperature(bytes)
+        @reading[:temperature] = temperature
+      
+        # Pressure and humidity are optional. Humidity is not available on the BMP280.
+        @reading[:pressure] = decode_pressure(bytes, t_fine) if reading_pressure?
+        @reading[:humidity] = decode_humidity(bytes, t_fine) if reading_humidity?
+          
+        @reading
+      end
+      
+      def decode_temperature(bytes)
+        # Reformat raw temeprature bytes (20-bits in 24) to uint32.
+        adc_t = ((bytes[3] << 16) | (bytes[4] << 8) | (bytes[5])) >> 4
+                  
+        # Floating point temperature calculation from datasheet. Result in degrees Celsius.
+        var1 = (adc_t /  16384.0 - @calibration[:t1] / 1024.0) * @calibration[:t2]
+        var2 = (adc_t / 131072.0 - @calibration[:t1] / 8192.0) ** 2 * @calibration[:t3]
+        t_fine = var1 + var2
+        temperature = (var1 + var2) / 5120.0
+        [temperature, t_fine]
+      end
+      
+      def decode_pressure(bytes, t_fine)
+        # Reformat raw pressure bytes (20-bits in 24) to uint32.
+        adc_p = ((bytes[0] << 16) | (bytes[1] << 8) | (bytes[2])) >> 4
+        
+        # Floating point pressure calculation from datasheet. Result in Pascals.
+        var1 = (t_fine / 2.0) - 64000.0
+        var2 = var1 * var1 * @calibration[:p6] / 32768.0
+        var2 = var2 + var1 * @calibration[:p5] * 2.0
+        var2 = (var2 / 4.0) + (@calibration[:p4] * 65536.0)
+        var1 = (@calibration[:p3] * var1 * var1 / 524288.0 + @calibration[:p2] * var1) / 524288.0
+        var1 = (1.0 + var1 / 32768.0) * @calibration[:p1]
+        if var1 == 0
+          pressure = nil
+        else
+          pressure = 1048576.0 - adc_p
+          pressure = (pressure - (var2 / 4096.0)) * 6250.0 / var1
+          var1 = @calibration[:p9] * pressure * pressure / 2147483648.0
+          var2 = pressure * @calibration[:p8] / 32768.0
+          pressure = pressure + (var1 + var2 + @calibration[:p7]) / 16.0
+        end
+        pressure
+      end
+      
+      def decode_humidity(bytes, t_fine)
+        # Raw data for humidity is big-endian uint16.
+        adc_h = (bytes[6] << 8) | bytes[7]
+        
+        # Floating point humidity calculation from datasheet. Result in % RH.
+        humidity = t_fine - 76800.0
+        humidity = (adc_h - (@calibration[:h4] * 64.0 + @calibration[:h5] / 16384.0 * humidity)) *
+                    (@calibration[:h2] / 65536.0 * (1.0 + @calibration[:h6] / 67108864.0 * humidity * (1.0 + @calibration[:h3] / 67108864.0 * humidity)))
+        humidity = humidity * (1.0 - @calibration[:h1] * humidity / 524288.0)
+        humidity = 100.0 if humidity > 100
+        humidity = 0.0   if humidity < 0
+        humidity
+      end
+
+      def reading_pressure?
+        # Bits 2..4 of 0xF4 register must not be 0.
+        (@registers[:f4] >> 2 & 0b111) != OVERSAMPLE_FACTORS[0]
+      end
+      
+      def reading_humidity?
+        return false unless humidity_available?
+        # Lowest 3 bits of 0xF2 register must not be 0.
+        (@registers[:f2] & 0b111) != OVERSAMPLE_FACTORS[0]
+      end
+      
+      # No humidity on the BMP280.
+      def humidity_available?
+        !self.class.to_s.match(/bmp/i)
+      end
+      
+      #
+      # Calibration Methods
+      #
+      attr_reader :calibration_data_loaded
+      
+      def get_calibration_data        
+        # First group of calibration bytes, sent to #process_calibration_a.
+        read_using -> { i2c_read(0x88, 26) }
+
+        # Second group of calibration bytes, only on BME280, sent to #process_calibration_b.
+        if humidity_available?
+          read_using -> { i2c_read 0xE1, 7 }
+        end
+
+        if (@calibration[:cal_a] && @calibration[:cal_b]) || (@calibration[:cal_a] && !humidity_available?)
+          @calibration.delete(:cal_a).delete(:cal_b)
+          @calibration_data_loaded = true
+        end
+      end
+
+      def process_calibration_a(cal_a)
+        if cal_a
+          @calibration = {
+            t1: cal_a[0..1].pack('C*').unpack('S<')[0],
+            t2: cal_a[2..3].pack('C*').unpack('s<')[0],
+            t3: cal_a[4..5].pack('C*').unpack('s<')[0],
+
+            p1: cal_a[6..7].pack('C*').unpack('S<')[0],
+            p2: cal_a[8..9].pack('C*').unpack('s<')[0],
+            p3: cal_a[10..11].pack('C*').unpack('s<')[0],
+            p4: cal_a[12..13].pack('C*').unpack('s<')[0],
+            p5: cal_a[14..15].pack('C*').unpack('s<')[0],
+            p6: cal_a[16..17].pack('C*').unpack('s<')[0],
+            p7: cal_a[18..19].pack('C*').unpack('s<')[0],
+            p8: cal_a[20..21].pack('C*').unpack('s<')[0],
+            p9: cal_a[22..23].pack('C*').unpack('s<')[0],
+          }
+          @calibration[:cal_a] = cal_a
+        end
+      end
+
+      def process_calibration_b(cal_b)
+        if cal_b && @calibration[:cal_a]
+          @calibration.merge!(
+            h1: @calibration[:cal_a][25],
+            h2: cal_b[0..1].pack('C*').unpack('s<')[0],
+            h3: cal_b[2],
+            h4: [(cal_b[3] << 4) | (cal_b[4] & 0b00001111)].pack('S').unpack('s')[0],
+            h5: [(cal_b[5] << 4) | (cal_b[4] >> 4)        ].pack('S').unpack('s')[0],
+            h6: [cal_b[6]].pack('C').unpack('c')[0]
+          )
+          @calibration[:cal_b] = cal_b
+        end
+      end
+    end
+    
+    #
+    # BMP280 is mostly compatible with BME280, except for a few changes.
+    #
+    class BMP280 < BME280
+      # Last 2 standby times are different for the BMP280 vs BME280.
+      STANDBY_TIMES = {
+                        0.5  => 0b000,
+                        62.5 => 0b001,
+                        125  => 0b010,
+                        250  => 0b011,
+                        500  => 0b100,
+                        1000 => 0b101,
+                        2000 => 0b110,
+                        4000 => 0b111,
+                      }
+    end
+  end
+end

data/lib/denko/sensor/dht.rb

@@ -0,0 +1,43 @@
+module Denko
+  module Sensor
+    class DHT
+      include Behaviors::SinglePin
+      include Behaviors::Poller
+
+      def _read
+        board.pulse_read(pin, reset: board.low, reset_time: 20000, pulse_limit: 84, timeout: 100)
+      end
+
+      def pre_callback_filter(data)
+        decode(data.split(",").map(&:to_i))
+      end
+
+      def decode(data)
+        data = data.last(81)
+        return { error: 'missing data' } unless data.length == 81
+        data = data[0..79]
+
+        bytes = []
+        data.each_slice(16) do |b|
+          byte = 0b00000000
+          b.each_slice(2) do |x,y|
+            bit = (y<x) ? 0 : 1
+            byte = (byte << 1) | bit
+          end
+          bytes << byte
+        end
+        return { error: 'CRC failure' } unless crc(bytes)
+
+        celsius   = ((bytes[2] << 8) | bytes[3]).to_f / 10
+        humidity  = ((bytes[0] << 8) | bytes[1]).to_f / 10
+        fahrenheit = (celsius * 1.8 + 32).round(1)
+
+        { celsius: celsius, fahrenheit: fahrenheit, humidity: humidity }
+      end
+
+      def crc(bytes)
+        bytes[0..3].reduce(0, :+) & 0xFF == bytes[4]
+      end
+    end
+  end
+end

data/lib/denko/sensor/ds18b20.rb

@@ -0,0 +1,74 @@
+module Denko
+  module Sensor
+    class DS18B20 < OneWire::Peripheral
+      FAMILY_CODE = 0x28
+
+      def scratch
+        @state ? @state[:raw] : read_scratch(9)
+      end
+
+      def resolution
+        @resolution ||= decode_resolution(scratch)
+      end
+
+      def resolution=(bits)
+        unless (9..12).include?(bits)
+          raise ArgumentError, 'Invalid DS18B20 resolution, expected 9 to 12'
+        end
+
+        return bits if decode_resolution(scratch) == bits
+
+        eeprom = scratch[2..4]
+        eeprom[2] = 0b00011111 | ((bits - 9) << 5)
+        write_scratch(eeprom)
+        copy_scratch
+        @resolution = bits
+      end
+
+      def set_convert_time
+        @convert_time = 0.75 / (2 ** (12 - @resolution))
+      end
+
+      def convert
+        @resolution ||= 12
+        set_convert_time
+
+        atomically do
+          match
+          bus.write(CONVERT_T)
+          sleep @convert_time if bus.parasite_power
+        end
+        sleep @convert_time unless bus.parasite_power
+      end
+
+      def _read
+        convert
+        read_scratch(9) { |data| self.update(data) }
+      end
+
+      def pre_callback_filter(bytes)
+        return { crc_error: true } unless Helper.crc_check(bytes)
+        @resolution = decode_resolution(bytes)
+
+        decode_temperature(bytes).merge(raw: bytes)
+      end
+
+      #
+      # Temperature is the first 16 bits (2 bytes of 9 read).
+      # It's a signed, 2's complement, little-endian decimal. LSB = 2 ^ -4.
+      #
+      def decode_temperature(bytes)
+        celsius = bytes[0..1].pack('C*').unpack('s<')[0] * (2.0 ** -4)
+        fahrenheit = (celsius * 1.8 + 32).round(4)
+
+        {celsius: celsius, fahrenheit: fahrenheit}
+      end
+
+      def decode_resolution(bytes)
+        config_byte = bytes[4]
+        offset = config_byte >> 5
+        offset + 9
+      end
+    end
+  end
+end

data/lib/denko/sensor/htu21d.rb

@@ -0,0 +1,168 @@
+module Denko
+  module Sensor
+    class HTU21D
+      include I2C::Peripheral
+      include Behaviors::Reader
+
+      # Commands
+      SOFT_RESET                = 0xFE
+      WRITE_CONFIG              = 0xE6
+      READ_TEMPERATURE_BLOCKING = 0xE3
+      READ_HUMIDITY_BLOCKING    = 0xE5
+
+      # Config values
+      CONFIG_DEFAULT            = 0b00000011
+      HEATER_MASK               = 0b00000100
+      RESOLUTION_MASK           = 0b10000001
+
+      attr_reader :temperature, :humidity
+
+      def before_initialize(options={})
+        @i2c_address = 0x40
+        super(options)
+      end
+
+      def after_initialize(options={})
+        super(options)
+
+        # Avoid repeated memory allocation for callback data and state.
+        @reading   = [:temperatue, 0.0]
+        self.state = { temperature: nil, humidity: nil }
+        @mutex     = Mutex.new
+
+        # Temperature and humidity objects, to treat this like 2 sensors.
+        @temperature = Temperature.new(self)
+        @humidity    = Humidity.new(self)
+
+        @config = CONFIG_DEFAULT
+        reset
+        heater_off
+      end
+
+      def reset
+        i2c_write [SOFT_RESET]
+        sleep 0.015
+      end
+
+      def write_config
+        @mutex.synchronize do
+          i2c_write [WRITE_CONFIG, @config]
+        end
+      end
+
+      def heater_on?
+        (@config & HEATER_MASK) > 0
+      end
+
+      def heater_off?
+        !heater_on?
+      end
+
+      def heater_on
+        @config |= HEATER_MASK
+        write_config
+      end
+
+      def heater_off
+        @config &= ~HEATER_MASK
+        write_config
+      end
+
+      #
+      # Only 4 resolution combinations are available.
+      # Set by giving a bitmask from the datasheet:
+      #
+      RESOLUTIONS = {
+        0x00 => {temperature: 14, humidity: 12},
+        0x01 => {temperature: 12, humidity: 8},
+        0x80 => {temperature: 13, humidity: 10},
+        0x81 => {temperature: 11, humidity: 11},
+      }
+
+      def resolution=(setting)
+        raise ArgumentError, "wrong resolution setting given: #{mask}" unless RESOLUTIONS.keys.include? setting
+        @config &= ~RESOLUTION_MASK
+        @config |= setting
+        write_config
+      end
+
+      def resolution
+        resolution_bits = @config & RESOLUTION_MASK
+        raise StandardError, "cannot get resolution from config register: #{@config}" unless RESOLUTIONS[resolution_bits]
+        RESOLUTIONS[resolution_bits]
+      end
+
+      def [](key)
+        @state_mutex.synchronize do
+          return @state[key]
+        end
+      end
+      
+      def read_temperature
+        @mutex.synchronize do
+          result = read_using -> { i2c_read(READ_TEMPERATURE_BLOCKING, 3) }
+          result[1] if result
+        end
+      end
+
+      def read_humidity
+        @mutex.synchronize do
+          result = read_using -> { i2c_read(READ_HUMIDITY_BLOCKING, 3) }
+          result[1] if result
+        end
+      end
+
+      def pre_callback_filter(bytes)
+        # Raw value is first 2 bytes big-endian.
+        raw_value = (bytes[0] << 8) | bytes[1]
+
+        # Quietly ignore readings with bad CRC.
+        unless calculate_crc(raw_value) == bytes[2]
+          @humidity.update(nil)
+          @temperature.update(nil)
+          return nil
+        end
+
+        # Lowest 2 bits must be zeroed before conversion.
+        raw_value = raw_value & 0xFFFC
+
+        # Bit 1 of LSB determines type of reading; 0 for temperature, 1 for humidity.
+        if (bytes[1] & 0b00000010) > 0
+          @reading[0] = :humidity
+          @reading[1] = (raw_value.to_f / 524.288) - 6
+          @humidity.update(@reading[1])
+        else
+          @reading[0] = :temperature
+          @reading[1] = (175.72 * raw_value.to_f / 65536) - 46.8
+          @temperature.update(@reading[1])
+        end
+        @reading
+      end
+      
+      def update_state(reading)
+        @state_mutex.synchronize do
+          @state[reading[0]] = reading[1]
+        end
+      end
+
+      #
+      # CRC calculation adapted from offical driver, found here:
+      # https://github.com/TEConnectivity/HTU21D_Generic_C_Driver/blob/master/htu21d.c#L275
+      #
+      def calculate_crc(value)
+        polynomial = 0x988000   # x^8 + x^5 + x^4 + 1
+        msb        = 0x800000
+        mask       = 0xFF8000
+        result     = value << 8 # Pad right with length of output CRC
+
+        while msb != 0x80
+          result = ((result ^ polynomial) & mask) | (result & ~mask) if (result & msb !=0)
+          msb        >>= 1
+          mask       >>= 1
+          polynomial >>= 1
+        end
+        result
+      end
+    end
+  end
+end