denko 0.13.6 → 0.15.0

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 ||= { 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,8 +164,8 @@ module Denko
 
       def chip_id
         return @chip_id if @chip_id
-        i2c_read(CHIP_ID_REGISTER, 1)
-        sleep 0.001 while !@chip_id
+        bytes = i2c_read_raw(1, register: CHIP_ID_REGISTER)
+        @chip_id = bytes[0] if bytes
         @chip_id
       end
 
@@ -176,25 +178,14 @@ 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)
-        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)
@@ -203,10 +194,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,25 +208,22 @@ module Denko
                               @calibration[:bp3] * (dp ** 3)
 
         # Return reading for callbacks.
-        @reading
+        reading
       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(IIR_REGISTER, CONFIG_LENGTH)
-        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
 
@@ -260,10 +248,8 @@ module Denko
       }
 
       def get_calibration_data
-        i2c_read(CALIBRATION_REGISTER, CALIBRATION_LENGTH)
-      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

@@ -4,15 +4,13 @@ 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)
         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 ||= { temperature: nil, humidity: nil }
+      end
 
-        reset
-        self.repeatability = :high
+      def reading
+        @reading ||= { temperature: nil, humidity: nil }
       end
 
       def repeatability=(key)
@@ -46,34 +48,35 @@ 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[: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 reset
@@ -89,7 +92,7 @@ module Denko
       def heater_off?
         !@heater_on
       end
-      
+
       def heater_on
         i2c_write [HEATER_ON]
         @heater_on = true
@@ -119,7 +122,7 @@ module Denko
             end
           end
         end
-        
+
         # Limit CRC size to 8 bits.
         crc = crc & 0xFF
       end

data/lib/denko/sensor/sht4x.rb

@@ -0,0 +1,125 @@
+module Denko
+  module Sensor
+    class SHT4X
+      include I2C::Peripheral
+      include Behaviors::Poller
+      include Behaviors::Lifecycle
+      include TemperatureHelper
+      include HumidityHelper
+
+      I2C_ADDRESS = 0x44
+
+      RESET       = 0x94
+      RESET_TIME  = 0.001
+      READ_SERIAL_NUMBER = 0x89
+
+      REPEATABILITIES = {
+        high:   {command: 0xFD, time: 0.010},
+        medium: {command: 0xF6, time: 0.005},
+        low:    {command: 0xE0, time: 0.003},
+      }
+
+      after_initialize do
+        reset
+        self.repeatability = :high
+      end
+
+      def state
+        @state ||= { temperature: nil, humidity: nil }
+      end
+
+      def reading
+        @reading ||= { temperature: nil, humidity: nil }
+      end
+
+      def repeatability=(key)
+        raise ArgumentError, "invalid repeatability setting: #{key}" unless REPEATABILITIES.keys.include? key
+        @measurement_command = REPEATABILITIES[key][:command]
+        @measurement_time = REPEATABILITIES[key][:time]
+      end
+
+      def _read
+        i2c_write [@measurement_command]
+        sleep(@measurement_time)
+        i2c_read(6)
+      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
+        else
+          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
+        else
+          reading[:humidity] = nil
+        end
+
+        reading
+      end
+
+      def update_state(reading)
+        @state_mutex.lock
+        @state[:temperature] = reading[:temperature]
+        @state[:humidity]    = reading[:humidity]
+        @state_mutex.unlock
+        @state
+      end
+
+      def reset
+        i2c_write [RESET]
+        sleep RESET_TIME
+      end
+
+      def serial
+        @serial ||= read_serial
+      end
+
+      def read_serial
+        i2c_write [READ_SERIAL_NUMBER]
+        sleep RESET_TIME
+        bytes = i2c_read_raw(6)
+        parse_serial(bytes)
+      end
+
+      def parse_serial(bytes)
+        # Serial bytes are laid out as [b0, b1, crc0+1, b2, b3, crc2+3]
+        if calculate_crc(bytes[0..2]) == bytes[2] && calculate_crc(bytes[3..5]) == bytes[5]
+          @serial = (bytes[0] << 24) | (bytes[1] << 16) | (bytes[3] << 8) | bytes[4]
+        else
+          @serial = nil
+        end
+      end
+
+      # CRC is same as AHT20 sensor. Copied from that file.
+      CRC_INITIAL_VALUE = 0xFF
+      CRC_POLYNOMIAL    = 0x31
+      MSBIT_MASK        = 0x80
+
+      def calculate_crc(bytes)
+        crc = CRC_INITIAL_VALUE
+
+        # Ignore last byte. That's the CRC value to compare with.
+        bytes.take(bytes.length - 1).each do |byte|
+          crc = crc ^ byte
+          8.times do
+            if (crc & MSBIT_MASK) > 0
+              crc = (crc << 1) ^ CRC_POLYNOMIAL
+            else
+              crc = crc << 1
+            end
+          end
+        end
+
+        # Limit CRC size to 8 bits.
+        crc = crc & 0xFF
+      end
+    end
+  end
+end

data/lib/denko/sensor/vl53l0x.rb

@@ -0,0 +1,58 @@
+module Denko
+  module Sensor
+    class VL53L0X
+      include I2C::Peripheral
+      include Behaviors::Poller
+      include Behaviors::Lifecycle
+      include Denko::AnalogIO::InputHelper
+
+      I2C_ADDRESS = 0x29
+
+      REFERENCE_REGISTER_START = 0xC0
+      REFERENCE_VALUES = [0xEE, 0xAA, 0x10]
+
+      SYSRANGE_START = 0x00
+      POWER_MANAGEMENT_GO1_POWER_FORCE = 0x80
+      INTERNAL_TUNING_1 = 0x91
+      INTERNAL_TUNING_2 = 0xFF
+      RESULT_RANGE_STATUS = 0x14
+
+      attr_reader :stop_variable
+      attr_accessor :correction_offset
+
+      after_initialize do
+        # Verify reference registerrs
+        reference_regs = i2c_read_raw(REFERENCE_VALUES.length, register: REFERENCE_REGISTER_START)
+        raise "reference registers do not match. May not be VL53L0X" unless reference_regs == REFERENCE_VALUES
+
+        # Initialization sequence
+        @stop_variable = i2c_read_raw(1, register: INTERNAL_TUNING_1)[0]
+        i2c_write [POWER_MANAGEMENT_GO1_POWER_FORCE, 0x01]
+        i2c_write [INTERNAL_TUNING_2, 0x01]
+        i2c_write [SYSRANGE_START, 0x00]
+        i2c_write [INTERNAL_TUNING_1, stop_variable]
+        i2c_write [SYSRANGE_START, 0x01]
+        i2c_write [INTERNAL_TUNING_2, 0x00]
+        i2c_write [POWER_MANAGEMENT_GO1_POWER_FORCE, 0x00]
+
+        # Wait for initialization to complete.
+        sleep 0.010 while (i2c_read_raw(1, register: SYSRANGE_START)[0] & 0b01 > 0)
+
+        # Go into continuous mode.
+        i2c_write [SYSRANGE_START, 0x02]
+      end
+
+      def _read
+        i2c_read(2, register: RESULT_RANGE_STATUS + 10)
+      end
+
+      def pre_callback_filter(bytes)
+        # Distance is 2 bytes, big-endian.
+        mm = (bytes[0] << 8) | bytes[1]
+        mm = mm + correction_offset if correction_offset
+        # super handles smoothing if enabled.
+        return (mm > 0) ? super(mm) : nil
+      end
+    end
+  end
+end

data/lib/denko/sensor.rb

@@ -1,20 +1,37 @@
+# Represent files to be autoloaded in CRuby as an Array.
+# This allows Mruby::Build to parse and preload them instead.
+SENSOR_FILES = [
+  [nil,          "helper"],
+  [:DHT,         "dht"],
+  [:DS18B20,     "ds18b20"],
+  [:BMP180,      "bmp180"],
+  [:BME280,      "bme280"],
+  [:BMP280,      "bme280"],
+  [:HDC1080,     "hdc1080"],
+  [:HTU21D,      "htu21d"],
+  [:HTU31D,      "htu31d"],
+  [:AHT1X,       "aht"],
+  [:AHT2X,       "aht"],
+  [:AHT3X,       "aht"],
+  [:SHT3X,       "sht3x"],
+  [:SHT4X,       "sht4x"],
+  [:QMP6988,     "qmp6988"],
+  [:RCWL9620,    "rcwl9620"],
+  [:HCSR04,      "hcsr04"],
+  [:JSNSR04T,    "jsnsr04t"],
+  [:GenericPIR,  "generic_pir"],
+  [:VL53L0X,     "vl53l0x"],
+]
+
 module Denko
   module Sensor
-    autoload :Temperature, "#{__dir__}/sensor/virtual"
-    autoload :Humidity,    "#{__dir__}/sensor/virtual"
-    autoload :DHT,         "#{__dir__}/sensor/dht"
-    autoload :DS18B20,     "#{__dir__}/sensor/ds18b20"
-    autoload :BMP180,      "#{__dir__}/sensor/bmp180"
-    autoload :BME280,      "#{__dir__}/sensor/bme280"
-    autoload :BMP280,      "#{__dir__}/sensor/bme280"
-    autoload :HTU21D,      "#{__dir__}/sensor/htu21d"
-    autoload :HTU31D,      "#{__dir__}/sensor/htu31d"
-    autoload :AHT10,       "#{__dir__}/sensor/aht"
-    autoload :AHT20,       "#{__dir__}/sensor/aht"
-    autoload :SHT3X,       "#{__dir__}/sensor/sht3x"
-    autoload :QMP6988,     "#{__dir__}/sensor/qmp6988"
-    autoload :RCWL9620,    "#{__dir__}/sensor/rcwl9620"
-    autoload :HCSR04,      "#{__dir__}/sensor/hcsr04"
-    autoload :GenericPIR,  "#{__dir__}/sensor/generic_pir"
+    SENSOR_FILES.each do |file|
+      file_path = "#{__dir__}/sensor/#{file[1]}"
+      if file[0]
+        autoload file[0], file_path
+      else
+        require file_path
+      end
+    end
   end
 end

data/lib/denko/spi/base_register.rb

@@ -1,37 +1,41 @@
 module Denko
   module SPI
     class BaseRegister
-      include Peripheral
+      include SPI::Peripheral
+      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 platform
+        :spi_register
+      end
 
-      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 }
+      def is_a_register?
+        true
       end
 
-      def after_initialize(options={})
-        super(options)
+      # 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 = params[:bytes] || 1
+      end
+      attr_writer :bytes
 
-        # 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 ||= Array.new(bytes*8) { 0 }
+      end
     end
   end
 end

data/lib/denko/spi/bit_bang.rb

@@ -2,28 +2,28 @@ module Denko
   module SPI
     class BitBang
       include Behaviors::MultiPin
-      include Behaviors::BusController
-      include Behaviors::Reader
+      include Behaviors::Lifecycle
+      include BusCommon
 
-      def initialize_pins(options={})
+      before_initialize do
+        param_pins = params[:pins]
         # Allow pin aliases.
-        pins[:input]  = pins[:input]  || pins[:poci] || pins[:miso]
-        pins[:output] = pins[:output] || pins[:pico] || pins[:mosi]
-        pins[:clock]  = pins[:clock]  || pins[:sck]  || pins[:clk]
-
-        # Clean up the pins hash.
-        [:poci, :miso, :pico, :mosi, :sck, :clk].each { |key| pins.delete(key) }
+        param_pins[:input]  = param_pins[:input]  || param_pins[:poci] || param_pins[:miso]
+        param_pins[:output] = param_pins[:output] || param_pins[:pico] || param_pins[:mosi]
+        param_pins[:clock]  = param_pins[:clock]  || param_pins[:sck]  || param_pins[:clk]
 
-        # Validate input or output pin.
-        unless pins[:input] || pins[:output]
-          raise ArgumentError, "no input or output pin given. Require either or both"
-        end
+        # Clean up the params hash.
+        [:poci, :miso, :pico, :mosi, :sck, :clk].each { |key| param_pins.delete(key) }
 
-        # If only output or input, set the other 255 for a one-directional bus.
-        pins[:input]  = 255 if pins[:output] && !pins[:input]
-        pins[:output] = 255 if pins[:input]  && !pins[:output]
+        # Validate param_pins.
+        raise ArgumentError, "either output or input pin required" unless param_pins[:input] || param_pins[:output]
+        raise ArgumentError, "clock pin required" unless param_pins[:clock]
+      end
 
-        require_pins(:clock, :input, :output)
+      def initialize_pins(options={})
+        proxy_pin :clock,   DigitalIO::CBitBang
+        proxy_pin :output,  DigitalIO::CBitBang if pins[:output]
+        proxy_pin :input,   DigitalIO::CBitBang if pins[:input]
       end
 
       def transfer(select_pin, write: [], read: 0, frequency: nil, mode: 0, bit_order: :msbfirst)
@@ -35,40 +35,6 @@ module Denko
         board.spi_bb_listen select_pin, clock: pins[:clock], input: pins[:input],
                                         read: read, mode: mode, bit_order: bit_order
       end
-
-      # Uses regular Board#spi_stop since listeners are shared.
-      def stop(pin)
-        board.spi_stop(pin)
-      end
-
-      # Delegate this to board so peripherals can initialize their select pins.
-      def set_pin_mode(*args)
-        board.set_pin_mode(*args)
-      end
-
-      def convert_pin(pin)
-        board.convert_pin(pin)
-      end
-
-      # Add peripheral to self and the board. It gets callbacks directly from the board.
-      def add_component(component)
-        # Treat pin 255 as the component having no select pin. Mostly for APA102.
-        return if component.pin == 255
-
-        pins = components.map { |c| c.pin }
-        if pins.include? component.pin
-          raise ArgumentError, "duplicate select pin for #{component}"
-        end
-
-        components << component
-        board.add_component(component)
-      end
-
-      # Remove peripheral from self and the board.
-      def remove_component(component)
-        components.delete(component)
-        board.remove_component(component)
-      end
     end
   end
 end