denko 0.13.0

data/lib/denko/one_wire/peripheral.rb

@@ -0,0 +1,62 @@
+module Denko
+  module OneWire
+    class Peripheral
+      include Behaviors::BusPeripheralAddressed
+      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?
+          match
+          bus.write(READ_SCRATCH)
+          bus.read(num_bytes)
+        end
+      end
+
+      def write_scratch(*bytes)
+        atomically do
+          match
+          bus.write(WRITE_SCRATCH)
+          bus.write(*bytes)
+        end
+      end
+
+      def copy_scratch
+        atomically do
+          match
+          bus.write(COPY_SCRATCH)
+          sleep 0.05
+          bus.reset if bus.parasite_power
+        end
+      end
+
+      def match
+        bus.reset
+        if bus.found_devices.count < 2
+          bus.write(SKIP_ROM)
+        else
+          bus.write(MATCH_ROM)
+          bus.write(address_bytes)
+        end
+      end
+
+      def address_bytes
+        Helper.address_to_bytes(self.address)
+      end
+
+      def serial_number
+        @serial_number ||= extract_serial
+      end
+
+      def extract_serial
+        # Remove CRC & family code.
+        serial = (@address & 0x00FFFFFFFFFFFFFF) >> 8
+        serial.to_s(16).rjust(12, "0")
+      end
+    end
+  end
+end

data/lib/denko/one_wire.rb

@@ -0,0 +1,9 @@
+module Denko
+  module OneWire
+    autoload :Constants,      "#{__dir__}/one_wire/constants"
+    autoload :Helper,         "#{__dir__}/one_wire/helper"
+    autoload :BusEnumeration, "#{__dir__}/one_wire/bus_enumeration"
+    autoload :Bus,            "#{__dir__}/one_wire/bus"
+    autoload :Peripheral,     "#{__dir__}/one_wire/peripheral"
+  end
+end

data/lib/denko/pulse_io/buzzer.rb

@@ -0,0 +1,25 @@
+module Denko
+  module PulseIO
+    class Buzzer < PWMOutput
+      def after_initialize(options={})
+        low
+      end
+
+      # Duration is in mills
+      def tone(frequency, duration=nil)
+        board.tone(pin, frequency, duration)
+      end
+
+      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
+    end
+  end
+end

data/lib/denko/pulse_io/ir_transmitter.rb

@@ -0,0 +1,22 @@
+module Denko
+  module PulseIO
+    class IRTransmitter
+      include Behaviors::OutputPin
+
+      def emit(pulses=[], options={})
+        if pulses.length > 256 || pulses.length < 1
+          raise ArgumentError, 'wrong number of IR pulses (expected 1 to 256)'
+        end
+
+        pulses.each_with_index do |pulse, index|
+          raise ArgumentError, 'non Numeric data in IR signal' unless pulse.is_a? Numeric
+          pulses[index] = pulse.round unless pulse.is_a? Integer
+          raise ArgumentError, 'pulse too long (max 65535 ms)' if pulse > 65535
+        end
+
+        frequency = options[:frequency] || 38
+        board.infrared_emit(pin, frequency, pulses)
+      end
+    end
+  end
+end

data/lib/denko/pulse_io/pwm_output.rb

@@ -0,0 +1,34 @@
+module Denko
+  module PulseIO
+    class PWMOutput < DigitalIO::Output
+      interrupt_with :write
+      
+      def initialize_pins(options={})
+        super(options)
+      end
+
+      def write(value)
+        if value == board.low
+          digital_write(board.low)
+        elsif value == board.pwm_high
+          digital_write(board.high)
+        else
+          pwm_write(value)
+        end
+      end
+
+      def pwm_write(value)
+        pwm_enable
+        board.pwm_write(pin, @state = value)
+      end
+
+      def pwm_enable
+        self.mode = :output_pwm unless mode == :output_pwm
+      end
+      
+      def pwm_disable
+        self.mode = :output
+      end
+    end
+  end
+end

data/lib/denko/pulse_io.rb

@@ -0,0 +1,7 @@
+module Denko
+  module PulseIO
+    autoload :PWMOutput,      "#{__dir__}/pulse_io/pwm_output"
+    autoload :Buzzer,         "#{__dir__}/pulse_io/buzzer"
+    autoload :IRTransmitter,  "#{__dir__}/pulse_io/ir_transmitter"
+  end
+end

data/lib/denko/rtc/ds3231.rb

@@ -0,0 +1,48 @@
+module Denko
+  module RTC
+    class DS3231
+      include I2C::Peripheral
+      require 'bcd'
+
+      def before_initialize(options={})
+        @i2c_address = 0x68
+        super(options)
+      end
+      
+      # Write start register 0x00, then bytes to set time.
+      def time=(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)
+      end
+      
+      def pre_callback_filter(bytes)
+        bcd_to_time(bytes)
+      end
+      
+      # Convert Time object to 7 byte BCD sequence.
+      def time_to_bcd(time)
+        [ BCD.decode(time.sec),
+          BCD.decode(time.min),
+          BCD.decode(time.hour),
+          BCD.decode(time.strftime('%u').to_i),
+          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) }
+        Time.new t[6] + 1970, t[5], t[4], t[2], t[1], t[0]
+      end
+    end
+  end
+end

data/lib/denko/rtc.rb

@@ -0,0 +1,5 @@
+module Denko
+  module RTC
+    autoload :DS3231, "#{__dir__}/rtc/ds3231"
+  end
+end

data/lib/denko/sensor/aht.rb

@@ -0,0 +1,165 @@
+module Denko
+  module Sensor
+    class AHT10
+      include I2C::Peripheral
+      include Behaviors::Poller
+
+      # Commands
+      INIT_AND_CALIBRATE   = [0xE1, 0x08, 0x00] 
+      READ_STATUS_REGISTER = [0x71]
+      START_MEASUREMENT    = [0xAC, 0x33, 0x00]
+      SOFT_RESET           = [0xBA]
+
+      # Delay Times (in seconds)
+      POWER_ON_DELAY = 0.100
+      COMMAND_DELAY  = 0.010
+      MEASURE_DELAY  = 0.080
+      RESET_DELAY    = 0.020
+
+      # CRC Constants
+      CRC_INITIAL_VALUE = 0xFF
+      CRC_POLYNOMIAL    = 0x31
+      MSBIT_MASK        = 0x80
+
+      # Status Register Masks
+      CALIBRATED        = 0x08
+      BUSY              = 0x80
+
+      # 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 }
+        @status_register = 0x00
+
+        sleep(self.class::POWER_ON_DELAY)
+        reset
+        calibrate
+      end
+
+      def reset
+        i2c_write(SOFT_RESET)
+        sleep(RESET_DELAY)
+      end
+
+      def calibrated?
+        # Should always be true, since INIT_AND_CALIBRATE always sets the calibration bit.
+        @status_register & CALIBRATED
+      end
+
+      def busy?
+        # Should always be false once correct wait times are used.
+        @status_register & BUSY
+      end
+
+      def calibrate
+        i2c_write(self.class::INIT_AND_CALIBRATE)
+        sleep(COMMAND_DELAY)
+        read_status_register
+      end
+
+      def read_status_register
+        read_using -> { i2c_read(READ_STATUS_REGISTER, 1) }
+        sleep(COMMAND_DELAY)
+      end
+
+      def _read
+        i2c_write(START_MEASUREMENT)
+        sleep(MEASURE_DELAY)
+        i2c_read(nil, 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
+
+        # 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
+      end
+
+      def update_state(reading)
+        @state_mutex.synchronize do
+          @state[:temperature] = reading[:temperature]
+          @state[:humidity]    = reading[:humidity]
+        end
+      end
+    end
+  end
+end
+
+module Denko
+  module Sensor
+    class AHT20 < AHT10
+      include I2C::Peripheral
+      include Behaviors::Poller
+      #
+      # 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] 
+      POWER_ON_DELAY     = 0.100
+      DATA_LENGTH        = 7
+
+      # CRC Constants (unique to AHT20)
+      CRC_INITIAL_VALUE = 0xFF
+      CRC_POLYNOMIAL    = 0x31
+      MSBIT_MASK        = 0x80
+
+      def pre_callback_filter(bytes)
+        # Handle reading status byte only.
+        return super(bytes) if bytes.length == 1
+
+        # Normal readings are 7 bytes given as:
+        #   [STATUS, H19-H12, H11-H4, H3-H0+T19-T16, T15-T8, T7-T0, CRC]
+        #
+        # Ignore everything if CRC fails.
+        return nil if calculate_crc(bytes) != bytes.last
+
+        # Same calculation as AHT10 once CRC passes.
+        super(bytes)
+      end
+
+      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