denko 0.14.0 → 0.15.0

data/lib/denko/sensor/sht3x.rb

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

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,19 +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
-    require "#{__dir__}/sensor/helper"
-    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,7 +1,7 @@
 module Denko
   module SPI
     class BaseRegister
-      include SPI::Peripheral::SinglePin
+      include SPI::Peripheral
       include Behaviors::Lifecycle
       #
       # Registers can be a BoardProxy for components needing digital pins.
@@ -9,17 +9,21 @@ module Denko
       #
       include Behaviors::BoardProxy
 
+      def platform
+        :spi_register
+      end
+
+      def is_a_register?
+        true
+      end
+
       # 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
+        @bytes = params[:bytes] || 1
       end
       attr_writer :bytes
 
-      before_initialize do
-        self.bytes = params[:bytes] if params[:bytes]
-      end
-
       # Select pin is active-low. Disable.
       after_initialize do
         self.high
@@ -30,7 +34,7 @@ module Denko
       # 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 } }
+        @state ||= Array.new(bytes*8) { 0 }
       end
     end
   end

data/lib/denko/spi/bus_common.rb

@@ -3,34 +3,31 @@ module Denko
     module BusCommon
       include Behaviors::BusController
       include Behaviors::Reader
-      extend Forwardable
 
       # Add peripheral to self and the board. It gets callbacks directly from the board.
       def add_component(component)
-        # Ignore components with no select pin. Mostly for APA102.
-        return unless component.pin
-
-        pins = components.map { |c| c.pin }
-        if pins.include? component.pin
-          raise ArgumentError, "duplicate select pin for #{component}"
-        end
-
+        # Don't check for select pin uniqueness. Board handles that.
         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
 
-      # Forward pin control methods to the board, for select pin setup.
-      def_delegator :board, :convert_pin
-      def_delegator :board, :set_pin_mode
+      # Pass through to the real board for converting select/other pins.
+      def convert_pin(*args, **kwargs)
+        board.convert_pin(*args, **kwargs)
+      end
+
+      def set_pin_mode(*args, **kwargs)
+        board.set_pin_mode(*args, **kwargs)
+      end
 
       # If a component calls #stop, that's just a call to Board#spi_stop giving its select pin.
-      def_delegator :board, :spi_stop, :stop
+      def stop(*args, **kwargs)
+        board.spi_stop(*args, **kwargs)
+      end
     end
   end
 end

data/lib/denko/spi/input_register.rb

@@ -84,10 +84,8 @@ module Denko
 
         bits = byte_array_to_bit_array(byte_array)
 
-        callback_mutex.synchronize {
-          break unless @callbacks
-          break if @callbacks.empty?
-
+        @callback_mutex.lock
+        if @callbacks && !@callbacks.empty?
           # Arduino doesn't de-duplicate state. Do it, but honor :force_update callbacks.
           if (bits != state) || @callbacks[:force_update]
             @callbacks.each_value do |array|
@@ -98,7 +96,9 @@ module Denko
           # Remove both :read and :force update while inside the lock.
           @callbacks.delete(:read)
           @callbacks.delete(:force_update)
-        }
+        end
+        @callback_mutex.unlock
+
         self.state = bits
       end
 
@@ -107,7 +107,7 @@ module Denko
         if listening_pins[pin] && (value != state[pin])
           part.update(value)
         # Also update if the component forced a read.
-        # Always called inside callback_mutex, so @callbacks, not callbacks
+        # Always called inside @callback_mutex, so @callbacks, not callbacks
         elsif reading_pins[pin] && @callbacks[:force_update]
           part.update(value)
         end

data/lib/denko/spi/output_register.rb

@@ -14,8 +14,8 @@ module Denko
       #
       def write
         bytes = []
-        state_mutex.synchronize do
-          return if @previous_state == @state
+        @state_mutex.lock
+        if @state != @previous_state
           @state.each_slice(8) do |slice|
             # Convert nils in the slice to zero.
             zeroed = slice.map { |bit| bit.to_i }
@@ -27,9 +27,11 @@ module Denko
             # Pack bytes in reverse order.
             bytes.unshift byte
           end
+          spi_write(bytes)
           @previous_state = @state.dup
         end
-        spi_write(bytes)
+        @state_mutex.unlock
+        @state
       end
 
       #
@@ -41,12 +43,19 @@ module Denko
       end
 
       def bit_set(pin, value)
-        state_mutex.synchronize { @state[pin] = value }
+        @state_mutex.lock
+        @state[pin] = value
+        @state_mutex.unlock
+        value
       end
 
       def digital_read(pin)
         state[pin]
       end
+
+      def pin_is_pwm?(pin)
+        false
+      end
     end
   end
 end

data/lib/denko/spi/peripheral.rb

@@ -1,111 +1,109 @@
 module Denko
   module SPI
-    module Peripheral
-      module Core
-        include Behaviors::BusPeripheral
-        include Behaviors::Callbacks
-
-        def spi_frequency
-          @spi_frequency ||= params[:spi_frequency] || 1_000_000
-        end
-
-        def spi_mode
-          @spi_mode ||= params[:spi_mode] || 0
-        end
-
-        def spi_bit_order
-          @spi_bit_order ||= params[:spi_bit_order] || :msbfirst
+    class ChipSelect
+      include Behaviors::SinglePin
+      include Behaviors::Callbacks
+      include Behaviors::Lifecycle
+
+      before_initialize do
+        # It actually functions as an output.
+        params[:mode] = :output
+
+        # But we can't claim it on Linux (the SPI hardware handles it), so don't.
+        if !Denko.mruby? && Object.const_defined?("Denko::PiBoard")
+          board = params[:board]
+          if board.class.ancestors.include?(Denko::PiBoard)
+            params[:mode] = nil
+          end
         end
+      end
+    end
 
-        attr_writer :spi_frequency, :spi_mode, :spi_bit_order
-
-        #
-        # Delegate methods to the bus.
-        #
-        def spi_transfer(write: [], read: 0)
-          bus.transfer(select_pin, write: write, read: read, frequency: spi_frequency, mode: spi_mode, bit_order: spi_bit_order)
-        end
+    module Peripheral
+      include Behaviors::MultiPin
+      include Behaviors::BusPeripheral
+      include Behaviors::Callbacks
+      include Behaviors::Lifecycle
+
+      # We have the SPI bus set as our board, but the select pin,
+      # and any other pins, need to attach to the underlying board.
+      def proxy_pin(*args, **kwargs)
+        kwargs[:board] = bus.board
+        super(*args, **kwargs)
+      end
 
-        def spi_write(byte_array)
-          bus.transfer(select_pin, write: byte_array, frequency: spi_frequency, mode: spi_mode, bit_order: spi_bit_order)
+      # If given just one value in pin:, treat that as the select pin.
+      before_initialize do
+        if (params[:pin].class != Hash) && (!params[:pins])
+          params[:pins] = { select: params[:pin] }
+          params[:pin] = nil
         end
+      end
 
-        def spi_read(num_bytes)
-          bus.transfer(select_pin, read: num_bytes, frequency: spi_frequency, mode: spi_mode, bit_order: spi_bit_order)
-        end
+      # Chip select pin is always treated as a subcomponent
+      def initialize_pins(params={})
+        super(params)
+        proxy_pin :select, ChipSelect, mode: :output
+      end
 
-        def spi_listen(num_bytes)
-          bus.listen(select_pin, read: num_bytes, frequency: spi_frequency, mode: spi_mode, bit_order: spi_bit_order)
-        end
+      # SelectPin is a separate component that receives updates from Board.
+      # Forward them to the Peripheral
+      after_initialize do
+        select.add_callback(:peripheral_forwarder) { |data| self.update(data) }
+      end
 
-        def spi_stop
-          bus.stop(select_pin)
+      def ensure_byte_array(message)
+        if message.class == Array
+          # Byte array coming from PiBoard.
+          return message
+        else
+          # Split up comma delimited bytes coming from a microcontroller.
+          return message.split(",").map { |b| b.to_i }
         end
+      end
 
-        def ensure_byte_array(message)
-          if message.class == Array
-            # Byte array coming from PiBoard.
-            return message
-          else
-            # Split up comma delimited bytes coming from a microcontroller.
-            return message.split(",").map { |b| b.to_i }
-          end
-        end
+      def update(message)
+        super(ensure_byte_array(message))
+      end
 
-        def update(message)
-          super(ensure_byte_array(message))
-        end
+      #
+      # SPI Properties
+      #
+      def spi_frequency
+        @spi_frequency ||= params[:spi_frequency] || 1_000_000
       end
 
-      module ChipSelectBehavior
-        include Behaviors::SinglePin
-        include Behaviors::Callbacks
-        include Behaviors::Lifecycle
-
-        before_initialize do
-          # It actually functions as an output.
-          params[:mode] = :output
-
-          # But we can't claim it on Linux (the SPI hardware handles it), so don't.
-          if Object.const_defined?("Denko::PiBoard")
-            bus = params[:bus] || params[:board]
-            if bus.board.class.ancestors.include?(Denko::PiBoard)
-              params[:mode] = nil
-            end
-          end
-        end
+      def spi_mode
+        @spi_mode ||= params[:spi_mode] || 0
       end
 
-      class ChipSelect
-        include ChipSelectBehavior
+      def spi_bit_order
+        @spi_bit_order ||= params[:spi_bit_order] || :msbfirst
       end
 
-      module SinglePin
-        include Core
-        include ChipSelectBehavior
+      attr_writer :spi_frequency, :spi_mode, :spi_bit_order
 
-        def select_pin
-          pin
-        end
+      #
+      # Delegate methods to the bus.
+      #
+      def spi_transfer(write: [], read: 0)
+        bus.transfer(select.pin, write: write, read: read, frequency: spi_frequency, mode: spi_mode, bit_order: spi_bit_order)
       end
 
-      module MultiPin
-        include Core
-        include Behaviors::MultiPin
-        include Behaviors::Lifecycle
+      def spi_write(byte_array)
+        bus.transfer(select.pin, write: byte_array, frequency: spi_frequency, mode: spi_mode, bit_order: spi_bit_order)
+      end
 
-        def select_pin
-          self.select.pin
-        end
+      def spi_read(num_bytes)
+        bus.transfer(select.pin, read: num_bytes, frequency: spi_frequency, mode: spi_mode, bit_order: spi_bit_order)
+      end
 
-        def initialize_pins(params={})
-          super(params)
-          proxy_pin :select, ChipSelect, { board: bus.board, mode: :output }
-        end
+      def spi_listen(num_bytes)
+        bus.listen(select.pin, read: num_bytes, frequency: spi_frequency, mode: spi_mode, bit_order: spi_bit_order)
+      end
 
-        after_initialize do
-          select.add_callback(:peripheral_forwarder) { |data| self.update(data) }
-        end
+      def spi_stop
+        bus.stop(select.pin)
       end
     end
   end

data/lib/denko/spi.rb

@@ -1,15 +1,25 @@
+# Represent files to be autoloaded in CRuby as an Array.
+# This allows Mruby::Build to parse and preload them instead.
+SPI_FILES = [
+  [:BusCommon,      "bus_common"],
+  [:Bus,            "bus"],
+  [:BitBang,        "bit_bang"],
+  [:ChipSelect,     "peripheral"],
+  [:Peripheral,     "peripheral"],
+  [:BaseRegister,   "base_register"],
+  [:InputRegister,  "input_register"],
+  [:OutputRegister, "output_register"],
+]
+
 module Denko
   module SPI
-    autoload :BusCommon,      "#{__dir__}/spi/bus_common"
-    autoload :Bus,            "#{__dir__}/spi/bus"
-    autoload :BitBang,        "#{__dir__}/spi/bit_bang"
-    module Peripheral
-      autoload :Core,         "#{__dir__}/spi/peripheral"
-      autoload :SinglePin,    "#{__dir__}/spi/peripheral"
-      autoload :MultiPin,     "#{__dir__}/spi/peripheral"
+    SPI_FILES.each do |file|
+      file_path = "#{__dir__}/spi/#{file[1]}"
+      if file[0]
+        autoload file[0], file_path
+      else
+        require file_path
+      end
     end
-    autoload :BaseRegister,   "#{__dir__}/spi/base_register"
-    autoload :InputRegister,  "#{__dir__}/spi/input_register"
-    autoload :OutputRegister, "#{__dir__}/spi/output_register"
   end
 end