denko 0.13.5 → 0.14.0

data/lib/denko/sensor/htu21d.rb

@@ -2,7 +2,12 @@ module Denko
   module Sensor
     class HTU21D
       include I2C::Peripheral
-      include Behaviors::Reader
+      include Behaviors::Poller
+      include Behaviors::Lifecycle
+      include TemperatureHelper
+      include HumidityHelper
+
+      I2C_ADDRESS = 0x40
 
       # Commands
       SOFT_RESET                = 0xFE
@@ -15,39 +20,27 @@ module Denko
       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)
-
+      after_initialize do
         @config = CONFIG_DEFAULT
         reset
         heater_off
       end
 
+      def state
+        state_mutex.synchronize { @state ||= { temperature: nil, humidity: nil } }
+      end
+
+      def reading
+        @reading ||= { temperature: nil, humidity: nil }
+      end
+
       def reset
         i2c_write [SOFT_RESET]
         sleep 0.015
       end
 
       def write_config
-        @mutex.synchronize do
-          i2c_write [WRITE_CONFIG, @config]
-        end
+        i2c_write [WRITE_CONFIG, @config]
       end
 
       def heater_on?
@@ -92,61 +85,57 @@ module Denko
         RESOLUTIONS[resolution_bits]
       end
 
-      def [](key)
-        @state_mutex.synchronize do
-          return @state[key]
-        end
+      # Workaround for :read callbacks getting automatically removed on first reading.
+      def read(*args, **kwargs, &block)
+        read_using(self.method(:_read_temperature), *args, **kwargs)
+        read_using(self.method(:_read_humidity), *args, **kwargs, &block)
       end
-      
-      def read_temperature
-        @mutex.synchronize do
-          result = read_using -> { i2c_read(READ_TEMPERATURE_BLOCKING, 3) }
-          result[1] if result
-        end
+
+      def _read
+        _read_temperature
+        _read_humidity
       end
 
-      def read_humidity
-        @mutex.synchronize do
-          result = read_using -> { i2c_read(READ_HUMIDITY_BLOCKING, 3) }
-          result[1] if result
-        end
+      def _read_temperature
+        i2c_read(3, register: READ_TEMPERATURE_BLOCKING)
+      end
+
+      def _read_humidity
+        i2c_read(3, register: READ_HUMIDITY_BLOCKING)
       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
+        return { error: 'CRC failure' } unless calculate_crc(raw_value) == bytes[2]
 
         # 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.
+        # Bit 1 of LS byte 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] = humidity
-          @humidity.update(@reading[1])
+          reading[:humidity] = humidity
         else
-          @reading[0] = :temperature
-          @reading[1] = (175.72 * raw_value.to_f / 65536) - 46.8
-          @temperature.update(@reading[1])
+          reading[:temperature] = (175.72 * raw_value.to_f / 65536) - 46.8
         end
-        @reading
+
+        return nil unless (reading[:temperature] && reading[:humidity])
+
+        reading
       end
 
       def update_state(reading)
-        @state_mutex.synchronize do
-          @state[reading[0]] = reading[1]
+        state_mutex.synchronize do
+          @state[:temperature] = reading[:temperature]
+          @state[:humidity]    = reading[:humidity]
         end
+        # Reset so pre_callback_filter can check for both values.
+        reading[:temperature] = nil
+        reading[:humidity]    = nil
       end
 
       #

data/lib/denko/sensor/htu31d.rb

@@ -3,6 +3,11 @@ module Denko
     class HTU31D
       include I2C::Peripheral
       include Behaviors::Poller
+      include Behaviors::Lifecycle
+      include TemperatureHelper
+      include HumidityHelper
+
+      I2C_ADDRESS = 0x40
 
       # Commands
       RESET           = 0x1E
@@ -53,20 +58,20 @@ module Denko
         3 => 0.01198 * CONVERSION_SAFETY_FACTOR,
       }
 
-      def before_initialize(options={})
-        @i2c_address = 0x40
-        super(options)
+      def resolutions
+        @resolutions ||= { temperature: 0, humidity: 0 }
       end
 
-      def after_initialize(options={})
-        super(options)
+      after_initialize do
+        reset
+      end
 
-        # Avoid repeated memory allocation for callback data and state.
-        @reading     = { temperature: nil, humidity: nil }
-        self.state   = { temperature: nil, humidity: nil }
-        @resolutions = { temperature: 0, humidity: 0 }
+      def state
+        state_mutex.synchronize { @state = { temperature: nil, humidity: nil } }
+      end
 
-        reset
+      def reading
+        @reading ||= { temperature: nil, humidity: nil }
       end
 
       def reset
@@ -82,7 +87,7 @@ module Denko
       def heater_off?
         !@heater_on
       end
-      
+
       def heater_on
         i2c_write [HEATER_ON]
         @heater_on = true
@@ -92,31 +97,25 @@ module Denko
         i2c_write [HEATER_OFF]
         @heater_on = false
       end
-      
+
       def temperature_resolution
-        @resolutions[:temperature]
+        resolutions[:temperature]
       end
 
       def temperature_resolution=(setting)
         raise ArgumentError, "wrong resolution given: #{setting}. Must be in range 0..3" unless (0..3).include?(setting)
-        @resolutions[:temperature] = setting
+        resolutions[:temperature] = setting
       end
-      
+
       def humidity_resolution
-        @resolutions[:humidity]
+        resolutions[:humidity]
       end
-      
+
       def humidity_resolution=(setting)
         raise ArgumentError, "wrong resolution given: #{setting}. Must be in range 0..3" unless (0..3).include?(setting)
-        @resolutions[:humidity] = setting
+        resolutions[:humidity] = setting
       end
 
-      def [](key)
-        @state_mutex.synchronize do
-          return @state[key]
-        end
-      end
-      
       def _read
         # Calculate total conversion time.
         conversion_time = T_CONVERSION_TIMES[temperature_resolution] +
@@ -130,7 +129,7 @@ module Denko
         sleep conversion_time
 
         # Write the read command and read back 6 bytes.
-        i2c_read(READ_T_AND_H, 6)
+        i2c_read(6, register: READ_T_AND_H)
       end
 
       def pre_callback_filter(bytes)
@@ -139,26 +138,26 @@ module Denko
         # Temperature
         t_raw = (bytes[0] << 8) | bytes[1]
         if calculate_crc(t_raw) != bytes[2]
-          @reading[:temperature] = nil
+          reading[:temperature] = nil
         else
-          @reading[:temperature] = (165 * t_raw.to_f / 65535) - 40
+          reading[:temperature] = (165 * t_raw.to_f / 65535) - 40
         end
 
         # Humidity
         h_raw = (bytes[3] << 8) | bytes[4]
         if calculate_crc(h_raw) != bytes[5]
-          @reading[:humidity] = nil
+          reading[:humidity] = nil
         else
-          @reading[:humidity] = h_raw.to_f / 655.35
+          reading[:humidity] = h_raw.to_f / 655.35
         end
 
         # Ignore entire reading if either CRC failed.
-        return nil unless (@reading[:temperature] && @reading[:humidity])
-        @reading
+        return nil unless (reading[:temperature] && reading[:humidity])
+        reading
       end
-      
+
       def update_state(reading)
-        @state_mutex.synchronize do
+        state_mutex.synchronize do
           @state[:temperature] = reading[:temperature]
           @state[:humidity]    = reading[:humidity]
         end

data/lib/denko/sensor/qmp6988.rb

@@ -1,8 +1,13 @@
 module Denko
   module Sensor
     class QMP6988
+      include Behaviors::Lifecycle
       include I2C::Peripheral
       include Behaviors::Poller
+      include TemperatureHelper
+      include PressureHelper
+
+      I2C_ADDRESS = 0x70
 
       UPDATE_TIME           = 0.020
       RESET_REGISTER        = 0xE0
@@ -64,20 +69,9 @@ module Denko
         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 }
-
+      after_initialize do
         reset
-        
+
         # Get 5 config registers. Copy 0xF4 to modify it for control.
         get_config_registers
         @ctrl_meas_register = @registers[:f4].dup
@@ -95,6 +89,14 @@ module Denko
         get_calibration_data
       end
 
+      def state
+        state_mutex.synchronize { @state ||= { temperature: nil, pressure: nil } }
+      end
+
+      def reading
+        @reading ||= { temperature: nil, pressure: nil }
+      end
+
       #
       # Configuration Methods
       #
@@ -128,7 +130,7 @@ module Denko
         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)
@@ -162,7 +164,7 @@ module Denko
 
       def chip_id
         return @chip_id if @chip_id
-        i2c_read(CHIP_ID_REGISTER, 1)
+        i2c_read(1, register: CHIP_ID_REGISTER)
         sleep 0.001 while !@chip_id
         @chip_id
       end
@@ -176,9 +178,9 @@ module Denko
           i2c_write [CTRL_MEAS_REGISTER, @ctrl_meas_register]
           sleep @measurement_time
         end
-        
+
         # Read the data bytes.
-        i2c_read(DATA_REGISTER, DATA_LENGTH)
+        i2c_read(DATA_LENGTH, register: DATA_REGISTER)
       end
 
       def pre_callback_filter(bytes)
@@ -203,10 +205,10 @@ module Denko
         tr =  @calibration[:a0] +
               @calibration[:a1] * dt +
               @calibration[:a2] * (dt ** 2)
-        @reading[:temperature] = tr / 256.0
+        reading[:temperature] = tr / 256.0
 
         # Compensated pressure calculated in Pascals.
-        @reading[:pressure] = @calibration[:b00] +
+        reading[:pressure] =  @calibration[:b00] +
                               @calibration[:bt1] * tr +
                               @calibration[:bp1] * dp +
                               @calibration[:b11] * (tr * dp)  +
@@ -217,11 +219,11 @@ module Denko
                               @calibration[:bp3] * (dp ** 3)
 
         # Return reading for callbacks.
-        @reading
+        reading
       end
 
       def update_state(reading)
-        @state_mutex.synchronize do
+        state_mutex.synchronize do
           @state[:temperature] = reading[:temperature]
           @state[:pressure]    = reading[:pressure]
         end
@@ -229,7 +231,7 @@ module Denko
 
       def get_config_registers
         @registers = {}
-        i2c_read(IIR_REGISTER, CONFIG_LENGTH)
+        i2c_read(CONFIG_LENGTH, register: IIR_REGISTER)
         sleep 0.001 while @registers.empty?
         @registers
       end
@@ -260,7 +262,7 @@ module Denko
       }
 
       def get_calibration_data
-        i2c_read(CALIBRATION_REGISTER, CALIBRATION_LENGTH)
+        i2c_read(CALIBRATION_LENGTH, register: CALIBRATION_REGISTER)
       end
 
       def process_calibration(bytes)

data/lib/denko/sensor/rcwl9620.rb

@@ -4,15 +4,12 @@ module Denko
       include I2C::Peripheral
       include Behaviors::Poller
 
-      def before_initialize(options={})
-        @i2c_address = 0x57
-        super(options)
-      end
+      I2C_ADDRESS = 0x57
 
       def _read
         i2c_write(0x01)
         sleep(0.120)
-        i2c_read(nil, 3)
+        i2c_read(3)
       end
 
       def pre_callback_filter(bytes)

data/lib/denko/sensor/sht3x.rb

@@ -3,6 +3,11 @@ module Denko
     class SHT3X
       include I2C::Peripheral
       include Behaviors::Poller
+      include Behaviors::Lifecycle
+      include TemperatureHelper
+      include HumidityHelper
+
+      I2C_ADDRESS   = 0x44
 
       RESET                 = 0x30A2
       RESET_TIME            = 0.002
@@ -14,27 +19,24 @@ module Denko
         medium: { lsb: 0x0B, measurement_time: 0.007 },
         low:    { lsb: 0x16, measurement_time: 0.005 },
       }
-      
+
       # Unused
       READ_STATUS_REGISTER  = 0xF32D
       CLEAR_STATUS_REGISTER = 0x3041
       BREAK                 = 0x3093
       ART                   = 0x2B32
 
-      def before_initialize(options={})
-        @i2c_address = 0x44
-        super(options)
+      after_initialize do
+        reset
+        self.repeatability = :high
       end
 
-      def after_initialize(options={})
-        super(options)
-
-        # Avoid repeated memory allocation for callback data and state.
-        @reading     = { temperature: nil, humidity: nil }
-        self.state   = { temperature: nil, humidity: nil }
+      def state
+        state_mutex.synchronize { @state ||= { temperature: nil, humidity: nil } }
+      end
 
-        reset
-        self.repeatability = :high
+      def reading
+        @reading ||= { temperature: nil, humidity: nil }
       end
 
       def repeatability=(key)
@@ -46,31 +48,31 @@ module Denko
       def _read
         i2c_write [0x24, @measurement_lsb]
         sleep(@measurement_time)
-        i2c_read(FETCH_DATA, 6)
+        i2c_read(6, register: FETCH_DATA)
       end
 
       def pre_callback_filter(bytes)
         # Temperature is bytes 0 to 2: MSB, LSB, CRC
         if calculate_crc(bytes[0..2]) == bytes[2]
           t_raw = (bytes[0] << 8) | bytes[1]
-          @reading[:temperature] = (175 * t_raw / 65535.0) - 45
+          reading[:temperature] = (175 * t_raw / 65535.0) - 45
         else
-          @reading[:temperature] = nil
+          reading[:temperature] = nil
         end
 
         # Humidity is bytes 3 to 5: MSB, LSB, CRC
         if calculate_crc(bytes[3..5]) == bytes[5]
           h_raw = (bytes[3] << 8) | bytes[4]
-          @reading[:humidity] = 100 * h_raw / 65535.0
+          reading[:humidity] = 100 * h_raw / 65535.0
         else
-          @reading[:humidity] = nil
+          reading[:humidity] = nil
         end
 
-        @reading
+        reading
       end
 
       def update_state(reading)
-        @state_mutex.synchronize do
+        state_mutex.synchronize do
           @state[:temperature] = reading[:temperature]
           @state[:humidity]    = reading[:humidity]
         end
@@ -89,7 +91,7 @@ module Denko
       def heater_off?
         !@heater_on
       end
-      
+
       def heater_on
         i2c_write [HEATER_ON]
         @heater_on = true
@@ -119,7 +121,7 @@ module Denko
             end
           end
         end
-        
+
         # Limit CRC size to 8 bits.
         crc = crc & 0xFF
       end

data/lib/denko/sensor.rb

@@ -1,7 +1,6 @@
 module Denko
   module Sensor
-    autoload :Temperature, "#{__dir__}/sensor/virtual"
-    autoload :Humidity,    "#{__dir__}/sensor/virtual"
+    require "#{__dir__}/sensor/helper"
     autoload :DHT,         "#{__dir__}/sensor/dht"
     autoload :DS18B20,     "#{__dir__}/sensor/ds18b20"
     autoload :BMP180,      "#{__dir__}/sensor/bmp180"

data/lib/denko/spi/base_register.rb

@@ -1,37 +1,37 @@
 module Denko
   module SPI
     class BaseRegister
-      include Peripheral
+      include SPI::Peripheral::SinglePin
+      include Behaviors::Lifecycle
       #
-      # Registers act as a Board for components that need only digital pins in
-      # in their I/O direction. Give the register as a 'board' when initializing a
-      # new component, and pin numbers that map onto the registers parallel output pins.
+      # Registers can be a BoardProxy for components needing digital pins.
+      # Give the Register as board: and pin: is the Register's parallel pin number.
       #
       include Behaviors::BoardProxy
 
-      attr_reader :bytes
-
-      def before_initialize(options={})
-        super(options)
-        #
-        # To use the register as a board proxy, we need to know how many
-        # bytes there are and map each bit to a virtual pin.
-        # Defaults to 1 byte. Ignore if writing to the register directly.
-        #
-        @bytes = options[:bytes] || 1
-        #
-        # When used as a board proxy, store the state of each register
-        # pin as a 0 or 1 in an array that is (@bytes * 8) long. Zero out to start.
-        #
-        @state = Array.new(@bytes*8) { 0 }
+      # Default registers to 1 byte, or 8 pins when used as Board Proxy.
+      # Can be ignored if reading / writing the register directly.
+      def bytes
+        @bytes ||= 1
       end
+      attr_writer :bytes
 
-      def after_initialize(options={})
-        super(options)
+      before_initialize do
+        self.bytes = params[:bytes] if params[:bytes]
+      end
 
-        # Drive select pin high by default.
+      # Select pin is active-low. Disable.
+      after_initialize do
         self.high
       end
+
+      #
+      # When used as BoardProxy, store the state of each register
+      # pin as a 0 or 1 in an array that is (@bytes * 8) long.
+      #
+      def state
+        state_mutex.synchronize { @state ||= Array.new(bytes*8) { 0 } }
+      end
     end
   end
 end