denko 0.14.0 → 0.15.0

data/lib/denko/sensor/aht.rb

@@ -1,6 +1,6 @@
 module Denko
   module Sensor
-    class AHT10
+    class AHT1X
       include I2C::Peripheral
       include Behaviors::Poller
       include Behaviors::Lifecycle
@@ -40,7 +40,7 @@ module Denko
       end
 
       def state
-        state_mutex.synchronize { @state = { temperature: nil, humidity: nil } }
+        @state ||= { temperature: nil, humidity: nil }
       end
 
       def reading
@@ -69,7 +69,8 @@ module Denko
       end
 
       def read_status_register
-        read_using -> { i2c_read(1, register: READ_STATUS_REGISTER) }
+        bytes = i2c_read_raw(1, register: READ_STATUS_REGISTER)
+        @status_register = bytes[0] if bytes
         sleep(COMMAND_DELAY)
       end
 
@@ -80,12 +81,6 @@ module Denko
       end
 
       def pre_callback_filter(bytes)
-        # Handle reading status byte only.
-        if bytes.length == 1
-          @status_register = bytes[0]
-          return nil
-        end
-
         # Normal readings are 6 bytes given as:
         #   [STATUS, H19-H12, H11-H4, H3-H0+T19-T16, T15-T8, T7-T0]
         @status_register = bytes[0]
@@ -102,20 +97,15 @@ module Denko
       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
     end
-  end
-end
 
-module Denko
-  module Sensor
-    class AHT20 < AHT10
-      include I2C::Peripheral
-      include Behaviors::Poller
+    class AHT2X < AHT1X
       #
       # Changed constants compared to AHT10. Always access with self.class::CONSTANT_NAME
       # in shared methods coming from the superclass.
@@ -162,5 +152,11 @@ module Denko
         crc = crc & 0xFF
       end
     end
+
+    #
+    # AHT3X and AHT2X have different specs, but work the same.
+    #
+    class AHT3X < AHT2X
+    end
   end
 end

data/lib/denko/sensor/bme280.rb

@@ -81,7 +81,7 @@ module Denko
       end
 
       def state
-        state_mutex.synchronize { @state = { temperature: nil, humidity: nil, pressure: nil } }
+        @state ||= { temperature: nil, humidity: nil, pressure: nil }
       end
 
       def reading
@@ -165,7 +165,7 @@ module Denko
       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
@@ -181,36 +181,9 @@ module Denko
         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
-      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 pre_callback_filter(bytes)
+        return nil unless bytes.length == 8
 
-      #
-      # 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
@@ -222,6 +195,18 @@ module Denko
         reading
       end
 
+      def update_state(reading)
+        @state_mutex.lock
+        @state[:temperature] = reading[:temperature]
+        @state[:pressure]    = reading[:pressure]
+        @state[:humidity]    = reading[:humidity]
+        @state_mutex.unlock
+        @state
+      end
+
+      #
+      # Decoding Methods
+      #
       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
@@ -284,7 +269,7 @@ module Denko
 
       # 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
 
       #
@@ -293,12 +278,14 @@ module Denko
       attr_reader :calibration_data_loaded
 
       def get_calibration_data
-        # First group of calibration bytes, sent to #process_calibration_a.
-        read_using -> { i2c_read(26, register: 0x88) }
+        # Calibration A
+        cal_a_bytes = i2c_read_raw(26, register: 0x88)
+        process_calibration_a(cal_a_bytes) if cal_a_bytes
 
-        # Second group of calibration bytes, only on BME280, sent to #process_calibration_b.
+        # Calibration B, only on BME280.
         if humidity_available?
-          read_using -> { i2c_read(7, register: 0xE1) }
+          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?)

data/lib/denko/sensor/bmp180.rb

@@ -38,7 +38,7 @@ module Denko
       end
 
       def state
-        state_mutex.synchronize { @state ||= { temperature: nil, pressure: nil } }
+        @state ||= { temperature: nil, pressure: nil }
       end
 
       def reading
@@ -120,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.
@@ -130,13 +127,11 @@ 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
 
       #
@@ -199,8 +194,8 @@ module Denko
       attr_reader :calibration_data_loaded
 
       def get_calibration_data
-        #  Calibration data is 22 bytes starting at address 0xAA.
-        read_using -> { i2c_read(22, register: 0xAA) }
+        bytes = i2c_read_raw(22, register: 0xAA)
+        process_calibration(bytes) if bytes
       end
 
       def process_calibration(bytes)

data/lib/denko/sensor/dht.rb

@@ -7,8 +7,13 @@ module Denko
       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_mutex.synchronize { @state ||= { temperature: nil, humidity: nil } }
+        @state ||= { temperature: nil, humidity: nil }
       end
 
       def reading
@@ -16,11 +21,15 @@ module Denko
       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)
@@ -46,10 +55,11 @@ module Denko
       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
 
       def crc(bytes)

data/lib/denko/sensor/ds18b20.rb

@@ -6,7 +6,7 @@ module Denko
       FAMILY_CODE = 0x28
 
       def state
-        state_mutex.synchronize { @state ||= { temperature: nil } }
+        @state ||= { temperature: nil }
       end
 
       def reading
@@ -43,9 +43,10 @@ module Denko
       end
 
       def update_state(reading)
-        state_mutex.synchronize do
-          @state[:temperature] = reading[:temperature]
-        end
+        @state_mutex.lock
+        @state[:temperature] = reading[:temperature]
+        @state_mutex.unlock
+        @state
       end
 
       def decode_resolution(bytes)

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/htu21d.rb

@@ -27,7 +27,7 @@ module Denko
       end
 
       def state
-        state_mutex.synchronize { @state ||= { temperature: nil, humidity: nil } }
+        @state ||= { temperature: nil, humidity: nil }
       end
 
       def reading
@@ -73,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
@@ -85,6 +85,14 @@ module Denko
         RESOLUTIONS[resolution_bits]
       end
 
+      def temperature_resolution
+        resolution[:temperature]
+      end
+
+      def humidity_resolution
+        resolution[:humidity]
+      end
+
       # Workaround for :read callbacks getting automatically removed on first reading.
       def read(*args, **kwargs, &block)
         read_using(self.method(:_read_temperature), *args, **kwargs)
@@ -129,13 +137,16 @@ module Denko
       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
+
         # Reset so pre_callback_filter can check for both values.
         reading[:temperature] = nil
         reading[:humidity]    = nil
+
+        @state
       end
 
       #

data/lib/denko/sensor/htu31d.rb

@@ -67,7 +67,7 @@ module Denko
       end
 
       def state
-        state_mutex.synchronize { @state = { temperature: nil, humidity: nil } }
+        @state ||= { temperature: nil, humidity: nil }
       end
 
       def reading
@@ -157,10 +157,11 @@ module Denko
       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

data/lib/denko/sensor/qmp6988.rb

@@ -90,7 +90,7 @@ module Denko
       end
 
       def state
-        state_mutex.synchronize { @state ||= { temperature: nil, pressure: nil } }
+        @state ||= { temperature: nil, pressure: nil }
       end
 
       def reading
@@ -164,8 +164,8 @@ module Denko
 
       def chip_id
         return @chip_id if @chip_id
-        i2c_read(1, register: CHIP_ID_REGISTER)
-        sleep 0.001 while !@chip_id
+        bytes = i2c_read_raw(1, register: CHIP_ID_REGISTER)
+        @chip_id = bytes[0] if bytes
         @chip_id
       end
 
@@ -184,19 +184,8 @@ module Denko
       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
+        return nil unless bytes.length == DATA_LENGTH
 
-      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)
@@ -223,21 +212,18 @@ module Denko
       end
 
       def update_state(reading)
-        state_mutex.synchronize do
-          @state[:temperature] = reading[:temperature]
-          @state[:pressure]    = reading[:pressure]
-        end
+        @state_mutex.lock
+        @state[:temperature] = reading[:temperature]
+        @state[:pressure]    = reading[:pressure]
+        @state_mutex.unlock
+        @state
       end
 
       def get_config_registers
-        @registers = {}
-        i2c_read(CONFIG_LENGTH, register: IIR_REGISTER)
-        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] }
+        bytes = i2c_read_raw(CONFIG_LENGTH, register: IIR_REGISTER)
+        if bytes
+          @registers = { f1: bytes[0], f2: bytes[1], f3: bytes[2], f4: bytes[3], f5: bytes[4] }
+        end
       end
       attr_reader :registers
 
@@ -262,10 +248,8 @@ module Denko
       }
 
       def get_calibration_data
-        i2c_read(CALIBRATION_LENGTH, register: CALIBRATION_REGISTER)
-      end
+        bytes = i2c_read_raw(CALIBRATION_LENGTH, register: CALIBRATION_REGISTER)
 
-      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)

data/lib/denko/sensor/rcwl9620.rb

@@ -7,6 +7,7 @@ module Denko
       I2C_ADDRESS = 0x57
 
       def _read
+        i2c_write(0x01)
         i2c_write(0x01)
         sleep(0.120)
         i2c_read(3)