denko 0.13.6 → 0.15.0

data/lib/denko/one_wire/bus_enumerator.rb

@@ -44,17 +44,14 @@ module Denko
       def parse_search_result(result)
         address, complement = split_search_result(result)
 
-        if (address & complement) > 0
-          raise "OneWire device not connected or disconnected during search"
-        end
-
+        raise "OneWire device not connected, or disconnected during search" if (address & complement) > 0
         raise "CRC error during OneWire search" unless Helper.crc(address)
 
         # Gives 0 at every discrepancy we didn't write 1 for on this search.
         new_discrepancies = address ^ complement
 
         high_discrepancy = -1
-        (0..63).each { |i| high_discrepancy = i if new_discrepancies[i] == 0 }
+        (0..63).each { |i| high_discrepancy = i if ((new_discrepancies >> i) & 0b1 == 0) }
 
         # LSByte of address is product family.
         klass = family_lookup(address & 0xFF)
@@ -64,27 +61,41 @@ module Denko
 
       # Result is 16 bytes, 8 byte address and complement interleaved LSByte first.
       def split_search_result(data)
-        address = 0
+        address    = 0
         complement = 0
-
         data.reverse.each_slice(2) do |comp_byte, addr_byte|
-          address = (address << 8) | addr_byte
+          address    = (address << 8)    | addr_byte
           complement = (complement << 8) | comp_byte
         end
-
         [address, complement]
       end
 
-      # 
-      # Set FAMILY_CODE in peripheral class, and add the class to this array
-      # for the class to be identified during search.
+      #
+      # Set FAMILY_CODE in peripheral class, then add the peripheral class
+      # to this array (as a String, since no autoloading on mruby).
+      # The class can then be identified during a bus search.
       #
       PERIPHERAL_CLASSES = [
-        Sensor::DS18B20,
+        "Denko::Sensor::DS18B20",
       ]
 
+      def peripheral_classes
+        return @peripheral_classes if @peripheral_classes
+
+        @peripheral_classes = []
+        PERIPHERAL_CLASSES.each do |class_name|
+          begin
+            klass = Object.const_get(class_name)
+          rescue
+            next
+          end
+          @peripheral_classes << klass
+        end
+        @peripheral_classes
+      end
+
       def family_lookup(family_code)
-        PERIPHERAL_CLASSES.each do |klass|
+        peripheral_classes.each do |klass|
           if (klass.const_defined? "FAMILY_CODE")
             return klass if klass::FAMILY_CODE == family_code
           end

data/lib/denko/one_wire/helper.rb

@@ -2,7 +2,9 @@ module Denko
   module OneWire
     class Helper
       def self.address_to_bytes(address)
-        [address].pack('Q<').split("").map(&:ord)
+        bytes = []
+        8.times { |i| bytes[i] = address >> (8*i) & 0xFF }
+        bytes
       end
 
       def self.crc(data)
@@ -20,7 +22,7 @@ module Denko
         crc = 0b00000000
         bytes.take(bytes.length - 1).each do |byte|
           for bit in (0..7)
-            xor = byte[bit] ^ crc[0]
+            xor = ((byte >> bit) & 0b1) ^ (crc & 0b1)
             crc = crc ^ ((xor * (2 ** 3)) | (xor * (2 ** 4)))
             crc = crc >> 1
             crc = crc | (xor * (2 ** 7))

data/lib/denko/one_wire/peripheral.rb

@@ -5,9 +5,6 @@ module Denko
       include Behaviors::Poller
       include Constants
 
-      attr_reader :address
-      alias  :bus :board
-
       def read_scratch(num_bytes, &block)
         atomically do
           bus.add_callback(:read, &block) if block_given?

data/lib/denko/one_wire.rb

@@ -1,9 +1,22 @@
+# Represent files to be autoloaded in CRuby as an Array.
+# This allows Mruby::Build to parse and preload them instead.
+ONE_WIRE_FILES = [
+  [:Constants,      "constants"],
+  [:Helper,         "helper"],
+  [:BusEnumerator,  "bus_enumerator"],
+  [:Bus,            "bus"],
+  [:Peripheral,     "peripheral"],
+]
+
 module Denko
   module OneWire
-    autoload :Constants,      "#{__dir__}/one_wire/constants"
-    autoload :Helper,         "#{__dir__}/one_wire/helper"
-    autoload :BusEnumerator,  "#{__dir__}/one_wire/bus_enumerator"
-    autoload :Bus,            "#{__dir__}/one_wire/bus"
-    autoload :Peripheral,     "#{__dir__}/one_wire/peripheral"
+    ONE_WIRE_FILES.each do |file|
+      file_path = "#{__dir__}/one_wire/#{file[1]}"
+      if file[0]
+        autoload file[0], file_path
+      else
+        require file_path
+      end
+    end
   end
 end

data/lib/denko/pulse_io/buzzer.rb

@@ -1,8 +1,14 @@
 module Denko
   module PulseIO
     class Buzzer < PWMOutput
-      def after_initialize(options={})
-        low
+      include Behaviors::Lifecycle
+
+      before_initialize do
+        params[:mode] ||= :output_pwm
+      end
+
+      after_initialize do
+        board.no_tone(pin)
       end
 
       # Duration is in mills
@@ -13,13 +19,9 @@ module Denko
       def no_tone
         board.no_tone(pin)
       end
-      
-      # Kill the thread if running, and send no_tone.
-      def stop
-        stop_thread
-        board.no_tone(pin)
-      end
-      alias :off :stop
+
+      alias :stop :no_tone
+      alias :off  :no_tone
     end
   end
 end

data/lib/denko/pulse_io/{ir_transmitter.rb → ir_output.rb}

@@ -1,11 +1,12 @@
 module Denko
   module PulseIO
-    class IRTransmitter
-      include Behaviors::OutputPin
+    class IROutput
+      include Behaviors::SinglePin
+      include Behaviors::Lifecycle
 
-      def emit(pulses=[], frequency: 38)
-        if pulses.length > 256 || pulses.length < 1
-          raise ArgumentError, 'wrong number of IR pulses (expected 1 to 256)'
+      def write(pulses=[], frequency: 38)
+        if pulses.length > 255 || pulses.length < 1
+          raise ArgumentError, 'wrong number of IR pulses (expected 1 to 255)'
         end
 
         pulses.each_with_index do |pulse, index|

data/lib/denko/pulse_io/pwm_output.rb

@@ -1,33 +1,112 @@
 module Denko
   module PulseIO
     class PWMOutput < DigitalIO::Output
-      interrupt_with :write
-      
-      def initialize_pins(options={})
-        super(options)
+      include Behaviors::Lifecycle
+
+      interrupt_with :write, :pwm_write, :digital_write, :duty=
+
+      # Avoid setting :output mode if on PWM pin, and on a platform that muxes externally.
+      before_initialize do
+        b = params[:board]
+        p = params[:pin]
+        params[:mode] = :output_pwm if b.platform != :arduino && b.pin_is_pwm?(p)
+      end
+
+      # Call #pwm_enable immediately if params[:mode] was overriden to :output_pwm.
+      after_initialize do
+        pwm_enable if params[:mode] == :output_pwm
+      end
+
+      def duty=(percent)
+        if board.platform == :arduino
+          pwm_write((percent / 100.0 * pwm_high).round)
+        else
+          pwm_write((percent / 100.0 * period).round)
+        end
       end
 
-      def write(value)
-        if value == board.low
-          digital_write(board.low)
-        elsif value == board.pwm_high
-          digital_write(board.high)
+      def digital_write(value)
+        # Use regular #digital_write for speed until a PWM method is called.
+        unless pwm_enabled?
+          super(value)
         else
-          pwm_write(value)
+          # On Arduinos, disable PWM and switch back to regular #digital_write.
+          if board.platform == :arduino
+            pwm_disable
+            super(value)
+          # Can't do that on Linux, so mimic DigitalIO.
+          else
+            if value == 1
+              pwm_write(period)
+            else
+              pwm_write(0)
+            end
+          end
         end
       end
 
+      # Raw write. Takes nanoseconds on Linux, 0..pwm_high on Arduino.
       def pwm_write(value)
+        pwm_enable unless pwm_enabled?
+        board.pwm_write(pin, value)
+        self.state = value
+      end
+      alias :write :pwm_write
+
+      def frequency
+        @frequency ||= params[:frequency] || 1000
+      end
+
+      def period
+        @period ||= (1_000_000_000.0 / frequency).round
+      end
+
+      def resolution
+        @resolution ||= params[:resolution] || board.analog_write_resolution
+      end
+
+      def pwm_high
+        @pwm_high ||= (2**resolution-1)
+      end
+
+      def _frequency=(value)
+        @frequency = value
+        @period    = nil
+      end
+
+      def _resolution=(value)
+        @resolution = value
+        @pwm_high   = nil
+      end
+
+      def frequency=(value)
+        self._frequency = value
         pwm_enable
-        board.pwm_write(pin, @state = value)
       end
 
-      def pwm_enable
-        self.mode = :output_pwm unless mode == :output_pwm
+      def resolution=(value)
+        self._resolution = value
+        pwm_enable
       end
-      
+
+      def pwm_settings_hash
+        { frequency: frequency, period: period, resolution: resolution }
+      end
+
+      def pwm_enable(frequency: nil, resolution: nil)
+        self._frequency  = frequency if frequency
+        self._resolution = resolution if resolution
+
+        board.set_pin_mode(pin, :output_pwm, pwm_settings_hash)
+        @mode = :output_pwm
+      end
+
       def pwm_disable
-        self.mode = :output
+        self.mode = :output if board.platform == :arduino
+      end
+
+      def pwm_enabled?
+        self.mode == :output_pwm
       end
     end
   end

data/lib/denko/pulse_io.rb

@@ -1,7 +1,21 @@
+# Represent files to be autoloaded in CRuby as an Array.
+# This allows Mruby::Build to parse and preload them instead.
+PULSE_IO_FILES = [
+  # Pin and component setup stuff
+  [:PWMOutput, "pwm_output"],
+  [:Buzzer,    "buzzer"],
+  [:IROutput,  "ir_output"],
+]
+
 module Denko
   module PulseIO
-    autoload :PWMOutput,      "#{__dir__}/pulse_io/pwm_output"
-    autoload :Buzzer,         "#{__dir__}/pulse_io/buzzer"
-    autoload :IRTransmitter,  "#{__dir__}/pulse_io/ir_transmitter"
+    PULSE_IO_FILES.each do |file|
+      file_path = "#{__dir__}/pulse_io/#{file[1]}"
+      if file[0]
+        autoload file[0], file_path
+      else
+        require file_path
+      end
+    end
   end
 end

data/lib/denko/rtc/ds3231.rb

@@ -2,42 +2,41 @@ module Denko
   module RTC
     class DS3231
       include I2C::Peripheral
-      require 'bcd'
 
-      def before_initialize(options={})
-        @i2c_address = 0x68
-        super(options)
-      end
-      
+      I2C_ADDRESS = 0x68
+
       # Write start register 0x00, then bytes to set time.
       def time=(time)
-        i2c_write [0, time_to_bcd(time)]
+        i2c_write [0] + time_to_bcd(time)
         time
       end
-      
+
       # Do a blocking read when #time is called.
       alias :time :read
-      
+
       # Time data starts at register 0 and is 7 bytes long.
       def _read
-        i2c_read(0, 7)
+        i2c_read(7, register: 0)
       end
-      
+
       def pre_callback_filter(bytes)
         bcd_to_time(bytes)
       end
-      
+
       # Convert Time object to 7 byte BCD sequence.
       def time_to_bcd(time)
+        wday = time.wday
+        wday = 7 if wday == 0
+
         [ BCD.decode(time.sec),
           BCD.decode(time.min),
           BCD.decode(time.hour),
-          BCD.decode(time.strftime('%u').to_i),
+          BCD.decode(wday),
           BCD.decode(time.day),
           BCD.decode(time.month),
           BCD.decode(time.year - 1970) ]
       end
-      
+
       # Convert 7 byte BCD sequence to Time object.
       def bcd_to_time(bytes)
         t = bytes.map { |b| BCD.encode(b) }

data/lib/denko/rtc.rb

@@ -1,5 +1,18 @@
+# Represent files to be autoloaded in CRuby as an Array.
+# This allows Mruby::Build to parse and preload them instead.
+RTC_FILES = [
+  [:DS3231, "ds3231"],
+]
+
 module Denko
   module RTC
-    autoload :DS3231, "#{__dir__}/rtc/ds3231"
+    RTC_FILES.each do |file|
+      file_path = "#{__dir__}/rtc/#{file[1]}"
+      if file[0]
+        autoload file[0], file_path
+      else
+        require file_path
+      end
+    end
   end
 end

data/lib/denko/sensor/aht.rb

@@ -1,11 +1,15 @@
 module Denko
   module Sensor
-    class AHT10
+    class AHT1X
       include I2C::Peripheral
       include Behaviors::Poller
+      include Behaviors::Lifecycle
+      include TemperatureHelper
+
+      I2C_ADDRESS = 0x38
 
       # Commands
-      INIT_AND_CALIBRATE   = [0xE1, 0x08, 0x00] 
+      INIT_AND_CALIBRATE   = [0xE1, 0x08, 0x00]
       READ_STATUS_REGISTER = [0x71]
       START_MEASUREMENT    = [0xAC, 0x33, 0x00]
       SOFT_RESET           = [0xBA]
@@ -28,24 +32,21 @@ module Denko
       # Number of bytes in each reading.
       DATA_LENGTH       = 6
 
-      def before_initialize(options={})
-        @i2c_address = 0x38
-        super(options)
-      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 }
+      after_initialize do
         @status_register = 0x00
-
         sleep(self.class::POWER_ON_DELAY)
         reset
         calibrate
       end
 
+      def state
+        @state ||= { temperature: nil, humidity: nil }
+      end
+
+      def reading
+        @reading ||= { temperature: nil, humidity: nil }
+      end
+
       def reset
         i2c_write(SOFT_RESET)
         sleep(RESET_DELAY)
@@ -68,58 +69,48 @@ module Denko
       end
 
       def read_status_register
-        read_using -> { i2c_read(READ_STATUS_REGISTER, 1) }
+        bytes = i2c_read_raw(1, register: READ_STATUS_REGISTER)
+        @status_register = bytes[0] if bytes
         sleep(COMMAND_DELAY)
       end
 
       def _read
         i2c_write(START_MEASUREMENT)
         sleep(MEASURE_DELAY)
-        i2c_read(nil, self.class::DATA_LENGTH)
+        i2c_read(self.class::DATA_LENGTH)
       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]
 
         # Humidity uses the upper 4 bits of the shared byte as its lowest 4 bits.
         h_raw = ((bytes[1] << 16) | (bytes[2] << 8) | (bytes[3])) >> 4
-        @reading[:humidity] = (h_raw.to_f / 2**20) * 100
+        reading[:humidity] = (h_raw.to_f / 2**20) * 100
 
         # Temperature uses the lower 4 bits of the shared byte as its highest 4 bits.
         t_raw = ((bytes[3] & 0x0F) << 16) | (bytes[4] << 8) | bytes[5]
-        @reading[:temperature] = (t_raw.to_f / 2**20) * 200 - 50
+        reading[:temperature] = (t_raw.to_f / 2**20) * 200 - 50
 
-        @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
     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.
       #
-      INIT_AND_CALIBRATE = [0xBE, 0x08, 0x00] 
+      INIT_AND_CALIBRATE = [0xBE, 0x08, 0x00]
       POWER_ON_DELAY     = 0.100
       DATA_LENGTH        = 7
 
@@ -156,10 +147,16 @@ module Denko
             end
           end
         end
-        
+
         # Limit CRC size to 8 bits.
         crc = crc & 0xFF
       end
     end
+
+    #
+    # AHT3X and AHT2X have different specs, but work the same.
+    #
+    class AHT3X < AHT2X
+    end
   end
 end