denko 0.13.6 → 0.15.0

data/lib/denko/sensor/hcsr04.rb

@@ -1,19 +1,21 @@
 module Denko
   module Sensor
     class HCSR04
-      # Speed of sound in meters per second.
-      SPEED_OF_SOUND = 343.0
-
+      include Behaviors::Lifecycle
       include Behaviors::MultiPin
       include Behaviors::Poller
 
+      # Speed of sound in meters per second.
+      SPEED_OF_SOUND = 343.0
+
       def initialize_pins(options={})
         proxy_pin :trigger, DigitalIO::Output
         proxy_pin :echo,    DigitalIO::Input
       end
 
-      def after_initialize(options={})
-        super(options)
+      after_initialize do
+        # Avoid generating extraneous alerts when used with Denko::PiBoard.
+        echo.stop
 
         # Receive values from echo pin.
         echo.add_callback { |data| self.update(data) }

data/lib/denko/sensor/hdc1080.rb

@@ -0,0 +1,174 @@
+module Denko
+  module Sensor
+    class HDC1080
+      include I2C::Peripheral
+      include Behaviors::Poller
+      include Behaviors::Lifecycle
+      include TemperatureHelper
+      include HumidityHelper
+
+      I2C_ADDRESS = 0x40
+
+      # Config Register
+      CONFIG_ADDRESS = 0x02
+      CONFIG_DEFAULT = 0x10
+      RESET_MASK     = 0b10000000
+      HEATER_MASK    = 0b00100000
+      BATTERY_MASK   = 0b00001000
+
+      # Reading registers
+      TEMPERATURE_ADDRESS = 0x00
+      HUMIDITY_ADDRESS    = 0x01
+
+      def state
+        @state ||= { temperature: nil, humidity: nil }
+      end
+
+      def reading
+        @reading ||= { temperature: nil, humidity: nil }
+      end
+
+      after_initialize do
+        reset
+      end
+
+      def reset
+        @config = CONFIG_DEFAULT
+        @temperature_resolution = 14
+        @humidity_resolution    = 14
+        write_config(@config | RESET_MASK)
+        sleep 0.010
+      end
+
+      def write_config(config=@config)
+        # Actually 2 bytes, but 2nd byte is reserved and 0, so ignore it.
+        i2c_write [CONFIG_ADDRESS, config, 0]
+      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
+
+      def battery_low?
+        config = i2c_read_raw(2, register: CONFIG_ADDRESS)
+        (config[0] & BATTERY_MASK) > 0
+      end
+
+      # Conversion times from datasheet, but not really used.
+      TEMPERATURE_RESOLUTION_MASK = 0b00000100
+      TEMPERATURE_RESOLUTIONS = {
+        14 => { bits: 0b0, conversion_time: 0.007 },
+        11 => { bits: 0b1, conversion_time: 0.004 },
+      }
+
+      HUMIDITY_RESOLUTION_MASK = 0b00000011
+      HUMIDITY_RESOLUTIONS = {
+        14 => { bits: 0b00, conversion_time: 0.007 },
+        11 => { bits: 0b01, conversion_time: 0.004 },
+        8  => { bits: 0b10, conversion_time: 0.003 },
+      }
+
+      attr_reader :temperature_resolution, :humidity_resolution
+
+      def temperature_resolution=(res)
+        raise ArgumentError, "wrong temperature resolution given: #{res}" unless TEMPERATURE_RESOLUTIONS.keys.include? res
+        @config &= ~TEMPERATURE_RESOLUTION_MASK
+        @config |= (TEMPERATURE_RESOLUTIONS[res][:bits] << 2)
+        write_config
+        @temperature_resolution = res
+      end
+
+      def humidity_resolution=(res)
+        raise ArgumentError, "wrong humidity resolution given: #{res}" unless HUMIDITY_RESOLUTIONS.keys.include? res
+        @config &= ~HUMIDITY_RESOLUTION_MASK
+        @config |= HUMIDITY_RESOLUTIONS[res][:bits]
+        write_config
+        @humidity_resolution = res
+      end
+
+      def serial_number
+        device_info[:serial_number]
+      end
+
+      def manufacturer_id
+        device_info[:manufacturer_id]
+      end
+
+      def device_id
+        device_info[:device_id]
+      end
+
+      def device_info
+        return @device_info if @device_info
+
+        man_id_bytes = i2c_read_raw(2, register: 0xFE)
+        dev_id_bytes = i2c_read_raw(2, register: 0xFF)
+        serial_l = i2c_read_raw(2, register: 0xFD)
+        serial_m = i2c_read_raw(2, register: 0xFC)
+        serial_h = i2c_read_raw(2, register: 0xFB)
+
+        @device_info = {
+          manufacturer_id: man_id_bytes[0] << 8 | man_id_bytes[1],
+          device_id:       dev_id_bytes[0] << 8 | dev_id_bytes[1],
+          serial_number:   serial_h[0] << 32 | serial_h[1] << 24 | serial_m[0] << 16 | serial_m[1] << 8 | serial_l[0],
+        }
+      end
+
+      def _read
+        _start_conversion
+        # This is way more than given conversion times, but unreliable without.
+        sleep 0.200
+        _read_values
+      end
+
+      def _start_conversion
+        # Writing to temperature register triggers both reads.
+        i2c_write [TEMPERATURE_ADDRESS]
+      end
+
+      def _read_values
+        # Read 2 bytes each for temperature and humidity.
+        i2c_read(4)
+      end
+
+      def pre_callback_filter(bytes)
+        raw_t = bytes[0] << 8 | bytes[1]
+        raw_h = bytes[2] << 8 | bytes[3]
+
+        reading[:temperature] = ((raw_t.to_f / 2 ** 16) * 165) - 40
+        reading[:humidity]    =  (raw_h.to_f / 2 ** 16) * 100
+
+        return nil unless (reading[:temperature] && reading[:humidity])
+
+        reading
+      end
+
+      def update_state(reading)
+        @state_mutex.lock
+        @state[:temperature] = reading[:temperature]
+        @state[:humidity]    = reading[:humidity]
+        @state_mutex.unlock
+
+        # Reset so pre_callback_filter can check for both values.
+        reading[:temperature] = nil
+        reading[:humidity]    = nil
+
+        @state
+      end
+    end
+  end
+end

data/lib/denko/sensor/helper.rb

@@ -0,0 +1,37 @@
+module Denko
+  module Sensor
+    module TemperatureHelper
+      def temperature
+        state[:temperature]
+      end
+
+      def temperature_f
+        (temperature * 1.8 + 32).round(4)
+      end
+
+      def temperature_k
+        temperature + 273.15
+      end
+    end
+
+    module PressureHelper
+      def pressure
+        state[:pressure]
+      end
+
+      def pressure_atm
+        pressure / 101325.0
+      end
+
+      def pressure_bar
+        pressure / 100000.0
+      end
+    end
+
+    module HumidityHelper
+      def humidity
+        state[:humidity]
+      end
+    end
+  end
+end

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 ||= { 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?
@@ -80,7 +73,7 @@ module Denko
       }
 
       def resolution=(setting)
-        raise ArgumentError, "wrong resolution setting given: #{mask}" unless RESOLUTIONS.keys.include? setting
+        raise ArgumentError, "wrong resolution setting given: #{setting}" unless RESOLUTIONS.keys.include? setting
         @config &= ~RESOLUTION_MASK
         @config |= setting
         write_config
@@ -92,61 +85,68 @@ module Denko
         RESOLUTIONS[resolution_bits]
       end
 
-      def [](key)
-        @state_mutex.synchronize do
-          return @state[key]
-        end
+      def temperature_resolution
+        resolution[:temperature]
       end
-      
-      def read_temperature
-        @mutex.synchronize do
-          result = read_using -> { i2c_read(READ_TEMPERATURE_BLOCKING, 3) }
-          result[1] if result
-        end
+
+      def humidity_resolution
+        resolution[:humidity]
       end
 
-      def read_humidity
-        @mutex.synchronize do
-          result = read_using -> { i2c_read(READ_HUMIDITY_BLOCKING, 3) }
-          result[1] if result
-        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
+        _read_temperature
+        _read_humidity
+      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]
-        end
+        @state_mutex.lock
+        @state[:temperature] = reading[:temperature]
+        @state[:humidity]    = reading[:humidity]
+        @state_mutex.unlock
+
+        # Reset so pre_callback_filter can check for both values.
+        reading[:temperature] = nil
+        reading[:humidity]    = nil
+
+        @state
       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 ||= { 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,29 +138,30 @@ 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[:temperature] = reading[:temperature]
-          @state[:humidity]    = reading[:humidity]
-        end
+        @state_mutex.lock
+        @state[:temperature] = reading[:temperature]
+        @state[:humidity]    = reading[:humidity]
+        @state_mutex.unlock
+        @state
       end
 
       #

data/lib/denko/sensor/jsnsr04t.rb

@@ -0,0 +1,49 @@
+module Denko
+  module Sensor
+    #
+    # For JSN-SR04T sensor in mode 2 ONLY.
+    #
+    class JSNSR04T
+      include Behaviors::Component
+      include Behaviors::Lifecycle
+      include Behaviors::Poller
+
+      UART_CLASSES = [Denko::UART::Hardware, Denko::UART::BitBang]
+      TIMEOUT      = 0.500
+
+      attr_reader :uart
+
+      after_initialize do
+        unless params[:uart] && UART_CLASSES.include?(params[:uart].class)
+          raise ArgumentError, "JSN-SR04T driver only works in mode 2, and expects a UART in the :uart key"
+        end
+
+        raise StandardError, "UART baud must be 9600 for JSN-SR04T" unless params[:uart].baud == 9600
+
+        @uart = params[:uart]
+      end
+
+      def _read
+        # Trigger read
+        uart.write("U")
+
+        # Get line from UART
+        start = Time.now
+        line  = nil
+        until line || (Time.now - start > TIMEOUT)
+          line = uart.gets
+          sleep 0.010
+        end
+
+        # Extract mm as integer
+        if line && line.strip.end_with?("mm")
+          value = line.gsub("mm").strip.to_i
+          self.update(value)
+          return value
+        end
+
+        return nil
+      end
+    end
+  end
+end