denko 0.13.6 → 0.15.0

data/lib/denko/sensor/bme280.rb

@@ -3,7 +3,13 @@ module Denko
     class BME280
       include I2C::Peripheral
       include Behaviors::Poller
-      
+      include Behaviors::Lifecycle
+      include TemperatureHelper
+      include PressureHelper
+      include HumidityHelper
+
+      I2C_ADDRESS = 0x76
+
       # Reading Mode Settings
       SLEEP_MODE      = 0b00
       ONESHOT_MODE    = 0b01 # 0b10 is also valid. Called "forced mode" in datasheet.
@@ -38,8 +44,8 @@ module Denko
                               8  =>  0b100,
                               16 =>  0b101, # 0b110 and 0b111 are also valid for 16x.
                             }
-                            
-      # IIR Filter Coefficients  
+
+      # IIR Filter Coefficients
       IIR_COEFFICIENTS = {
                             0  =>  0b000,
                             2  =>  0b001,
@@ -47,19 +53,8 @@ module Denko
                             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 }
 
+      after_initialize do
         #
         # Setup defaults for the config registers:
         #   Oneshot reading mode
@@ -72,7 +67,7 @@ module Denko
           # 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.
@@ -81,10 +76,18 @@ module Denko
         # 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
 
+      def state
+        @state ||= { temperature: nil, humidity: nil, pressure: nil }
+      end
+
+      def reading
+        @reading ||= { temperature: nil, humidity: nil, pressure: nil }
+      end
+
       #
       # Configuration Methods
       #
@@ -94,7 +97,7 @@ module Denko
       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)
@@ -110,59 +113,59 @@ module Denko
         # Milliseconds to seconds
         @measurement_time = @measurement_time / 1000
       end
-      
+
       def continuous_mode
         @registers[:f4] = (@registers[:f4] & 0b11111100) | CONTINUOUS_MODE
-        write_settings 
+        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]] 
+          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 = ""
+        str = String.new
         @registers.each_key do |key|
           str << "0x#{key.upcase}: #{@registers[key].to_s(2).rjust(8, '0')}\n"
         end
@@ -171,64 +174,43 @@ module Denko
 
       #
       # Reading Methods
-      # 
+      #
       def _read
         get_calibration_data unless calibration_data_loaded
         write_settings
-        i2c_read 0xF7, 8
+        i2c_read 8, register: 0xF7
       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
+
+      def pre_callback_filter(bytes)
+        return nil unless bytes.length == 8
+
+        # 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 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
+        @state_mutex.lock
+        @state[:temperature] = reading[:temperature]
+        @state[:pressure]    = reading[:pressure]
+        @state[:humidity]    = reading[:humidity]
+        @state_mutex.unlock
+        @state
       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]
@@ -236,11 +218,11 @@ module Denko
         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
@@ -259,11 +241,11 @@ module Denko
         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)) *
@@ -278,30 +260,32 @@ module Denko
         # 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)
+        self.class.name.split('::').last.downcase.start_with? "bme"
       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.
+      def get_calibration_data
+        # Calibration A
+        cal_a_bytes = i2c_read_raw(26, register: 0x88)
+        process_calibration_a(cal_a_bytes) if cal_a_bytes
+
+        # Calibration B, only on BME280.
         if humidity_available?
-          read_using -> { i2c_read 0xE1, 7 }
+          cal_b_bytes = i2c_read_raw(7, register: 0xE1)
+          process_calibration_b(cal_b_bytes) if cal_b_bytes
         end
 
         if (@calibration[:cal_a] && @calibration[:cal_b]) || (@calibration[:cal_a] && !humidity_available?)
@@ -345,7 +329,7 @@ module Denko
         end
       end
     end
-    
+
     #
     # BMP280 is mostly compatible with BME280, except for a few changes.
     #

data/lib/denko/sensor/bmp180.rb

@@ -3,7 +3,12 @@ module Denko
     class BMP180
       include I2C::Peripheral
       include Behaviors::Poller
-      
+      include Behaviors::Lifecycle
+      include TemperatureHelper
+      include PressureHelper
+
+      I2C_ADDRESS = 0x77
+
       # Write this to register 0xE0 for soft reset
       SOFT_RESET = 0xB6
 
@@ -20,18 +25,7 @@ module Denko
         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 }
-
+      after_initialize do
         # Default to start conversion off, reading temperature, no pressure oversampling.
         @register = 0b00001110
         @calibration_data_loaded = false
@@ -43,6 +37,14 @@ module Denko
         soft_reset
       end
 
+      def state
+        @state ||= { temperature: nil, pressure: nil }
+      end
+
+      def reading
+        @reading ||= { temperature: nil, pressure: nil }
+      end
+
       #
       # Configuration Methods
       #
@@ -51,7 +53,7 @@ module Denko
       end
 
       attr_reader :measurement_time
-      
+
       def update_measurement_time
         # Get oversample bits from current register setting.
         oversample_exponent = (@register & 0b11000000) >> 6
@@ -69,7 +71,7 @@ module Denko
         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]
@@ -78,26 +80,33 @@ module Denko
       #
       # Reading Methods
       #
-      def _start_read_temperature
+      def _read_temperature
         @register = 0x2E
         write_settings
+        sleep(@measurement_time)
+        i2c_read(2, register: 0xF6)
       end
 
-      def _start_read_pressure
+      def _read_pressure
         @register = 0x34 | (@oss << 6)
         write_settings
+        sleep(@measurement_time)
+        i2c_read(3, register: 0xF6)
       end
 
-      def _read
+      # Workaround for :read callbacks getting automatically removed on first reading.
+      def read(*args, **kwargs, &block)
         get_calibration_data unless calibration_data_loaded
 
-        _start_read_temperature
-        sleep(@measurement_time)
-        i2c_read 0xF6, 2
+        read_using(self.method(:_read_temperature), *args, **kwargs)
+        read_using(self.method(:_read_pressure), *args, **kwargs, &block)
+      end
 
-        _start_read_pressure
-        sleep(@measurement_time)
-        i2c_read 0xF6, 3
+      def _read
+        get_calibration_data unless calibration_data_loaded
+
+        _read_temperature
+        _read_pressure
       end
 
       def pre_callback_filter(data)
@@ -111,9 +120,6 @@ module Denko
           @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.
@@ -121,29 +127,21 @@ module Denko
       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
+        @state_mutex.lock
+        @state[:temperature] = reading[:temperature]
+        @state[:pressure]    = reading[:pressure]
+        @state_mutex.unlock
+        @state
       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
+        reading[:temperature] = temperature
+        reading[:pressure] = decode_pressure(bytes, b5)
+        reading
       end
 
       def decode_temperature(bytes)
@@ -162,7 +160,7 @@ module Denko
         # 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)
@@ -194,10 +192,10 @@ module Denko
       # 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) }
+
+      def get_calibration_data
+        bytes = i2c_read_raw(22, register: 0xAA)
+        process_calibration(bytes) if bytes
       end
 
       def process_calibration(bytes)

data/lib/denko/sensor/dht.rb

@@ -1,15 +1,35 @@
 module Denko
   module Sensor
     class DHT
-      include Behaviors::SinglePin
+      include Behaviors::InputPin
       include Behaviors::Poller
+      include Behaviors::Lifecycle
+      include TemperatureHelper
+      include HumidityHelper
+
+      after_initialize do
+        # Small delay on startup to prevent Linux from reading too early.
+        sleep 0.100
+      end
+
+      def state
+        @state ||= { temperature: nil, humidity: nil }
+      end
+
+      def reading
+        @reading ||= { temperature: nil, humidity: nil }
+      end
 
       def _read
-        board.pulse_read(pin, reset: board.low, reset_time: 20000, pulse_limit: 84, timeout: 100)
+        board.pulse_read(pin, reset: board.low, reset_time: 10_000, pulse_limit: 84, timeout: 100)
       end
 
       def pre_callback_filter(data)
-        decode(data.split(",").map(&:to_i))
+        if data.class == String
+          decode(data.split(",").map(&:to_i))
+        else
+          decode(data)
+        end
       end
 
       def decode(data)
@@ -28,11 +48,18 @@ module Denko
         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)
+        reading[:temperature] = ((bytes[2] << 8) | bytes[3]).to_f / 10
+        reading[:humidity]    = ((bytes[0] << 8) | bytes[1]).to_f / 10
+
+        reading
+      end
 
-        { celsius: celsius, fahrenheit: fahrenheit, humidity: humidity }
+      def update_state(reading)
+        @state_mutex.lock
+        @state[:temperature] = reading[:temperature]
+        @state[:humidity]    = reading[:humidity]
+        @state_mutex.unlock
+        @state
       end
 
       def crc(bytes)

data/lib/denko/sensor/ds18b20.rb

@@ -1,36 +1,24 @@
 module Denko
   module Sensor
     class DS18B20 < OneWire::Peripheral
+      include Behaviors::Lifecycle
+      include TemperatureHelper
       FAMILY_CODE = 0x28
 
-      def scratch
-        @state ? @state[:raw] : read_scratch(9)
+      def state
+        @state ||= { temperature: nil }
       end
 
-      def resolution
-        @resolution ||= decode_resolution(scratch)
+      def reading
+        @reading ||= { temperature: nil }
       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))
+      def _read
+        convert
+        read_scratch(9) { |data| self.update(data) }
       end
 
       def convert
-        @resolution ||= 12
         set_convert_time
 
         atomically do
@@ -41,16 +29,30 @@ module Denko
         sleep @convert_time unless bus.parasite_power
       end
 
-      def _read
-        convert
-        read_scratch(9) { |data| self.update(data) }
+      def set_convert_time
+        @convert_time = 0.75 / (2 ** (12 - (@resolution || 12)))
       end
 
       def pre_callback_filter(bytes)
         return { crc_error: true } unless OneWire::Helper.crc(bytes)
-        @resolution = decode_resolution(bytes)
 
-        decode_temperature(bytes).merge(raw: bytes)
+        @resolution ||= decode_resolution(bytes)
+        reading[:temperature] = decode_temperature(bytes)
+
+        reading
+      end
+
+      def update_state(reading)
+        @state_mutex.lock
+        @state[:temperature] = reading[:temperature]
+        @state_mutex.unlock
+        @state
+      end
+
+      def decode_resolution(bytes)
+        config_byte = bytes[4]
+        offset = config_byte >> 5
+        offset + 9
       end
 
       #
@@ -58,16 +60,21 @@ module Denko
       # 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}
+        bytes[0..1].pack('C*').unpack('s<')[0] * (2.0 ** -4)
       end
 
-      def decode_resolution(bytes)
-        config_byte = bytes[4]
-        offset = config_byte >> 5
-        offset + 9
+      attr_reader :resolution
+
+      def resolution=(bits)
+        unless (9..12).include?(bits)
+          raise ArgumentError, 'Invalid DS18B20 resolution, expected 9 to 12'
+        end
+
+        eeprom = read_scratch(9)[2..4]
+        eeprom[2] = 0b00011111 | ((bits - 9) << 5)
+        write_scratch(eeprom)
+        copy_scratch
+        @resolution = bits
       end
     end
   end