denko 0.13.6 → 0.14.0

data/lib/denko/led/rgb.rb

@@ -21,17 +21,15 @@ module Denko
         off:     [000, 000, 000]
       }
 
-      def write(array)
-        red.write   array[0]
-        green.write array[1]
-        blue.write  array[2]
+      def write(r, g, b)
+        red.write(r)
+        green.write(g)
+        blue.write(b)
       end
 
       def color=(color)
-        return write(color) if color.class == Array
-
         color = color.to_sym
-        write(COLORS[color]) if COLORS.include? color
+        write(*COLORS[color]) if COLORS.include? color
       end
     end
   end

data/lib/denko/led/seven_segment.rb

@@ -2,7 +2,8 @@ module Denko
   module LED
     class SevenSegment
       include Behaviors::MultiPin
-      
+      include Behaviors::Lifecycle
+
       ALL_OFF = [0,0,0,0,0,0,0]
       BLANK = " "
 
@@ -14,13 +15,15 @@ module Denko
         proxy_pin :cathode, DigitalIO::Output, optional: true
         proxy_pin :anode,   DigitalIO::Output, optional: true
       end
-      
-      def after_initialize(options={})
-        @segments = [a,b,c,d,e,f,g]
-        clear; on
+
+      def segments
+        @segments ||= [a,b,c,d,e,f,g]
       end
 
-      attr_reader :segments
+      after_initialize do
+        clear
+        on
+      end
 
       def clear
         write(BLANK)
@@ -46,7 +49,7 @@ module Denko
 
       def on?;   @on; end
       def off?; !@on; end
-      
+
       CHARACTERS = {
         '0' => [1,1,1,1,1,1,0],
         '1' => [0,1,1,0,0,0,0],
@@ -93,9 +96,21 @@ module Denko
 
       def write(char)
         bits = CHARACTERS[char] || ALL_OFF
+        bits = bits.map { |b| 1^b } if anode
+
         bits.each_with_index do |bit, index|
-          bit = 1^bit if anode
-          segments[index].write(bit) unless (segments[index].state == bit)
+          if board_is_register?
+            # On a register, use #bit_set except for the last bit. This changes state in memory.
+            # #digital_write on the last bit causes the register to write to its parallel out.
+            if (index == bits.length-1)
+              segments[index].digital_write(bit)
+            else
+              board.bit_set(segments[index].pin, bit)
+            end
+          else
+            # On a board, only set bits if changed.
+            segments[index].digital_write(bit) unless (segments[index].state == bit)
+          end
         end
       end
 

data/lib/denko/led/ws2812.rb

@@ -2,16 +2,19 @@ module Denko
   module LED
     class WS2812
       include Behaviors::SinglePin
+      include Behaviors::Lifecycle
 
-      attr_reader :length, :bpp
+      def length
+        @length ||= params[:length] || 1
+      end
+
+      def bpp
+        @bpp ||= params[:bpp] || 3
+      end
 
-      def after_initialize(options={})
-        super(options)
-        raise ArgumentError, "no length given for WS2812 array" unless options[:length]
-        @length = options[:length]
+      attr_writer :length, :bpp
 
-        # This is BYTES per pixel, not bits per pixel.
-        @bpp = 3
+      after_initialize do
         off
       end
 

data/lib/denko/message.rb

@@ -5,6 +5,11 @@ module Denko
     VAL_MAX = 9999
 
     def self.encode(command: nil, pin: nil, value: nil, aux_message: nil)
+      # Optimized single byte binary message for digital write on pins 0..63.
+      if (command == 1) && (pin < 64) && (value == 1 || value == 0)
+        return (pin | 0b10000000 | (value << 6)).chr
+      end
+
       # Start building message backwards with aux_message first.
       if aux_message
         # Convert it to String.

data/lib/denko/motor/l298.rb

@@ -2,47 +2,48 @@ module Denko
   module Motor
     class L298
       include Behaviors::MultiPin
+      include Behaviors::Lifecycle
 
       attr_reader :speed
-      
+
       def initialize_pins(options={})
         proxy_pin :direction1,  DigitalIO::Output
         proxy_pin :direction2,  DigitalIO::Output
-        proxy_pin :enable,      PulseIO::PWMOutput 
+        proxy_pin :enable,      PulseIO::PWMOutput
       end
-                  
-      def after_initialize(options={})
+
+      after_initialize do
         off
       end
 
       def speed=(value)
-        enable.write(value)
+        enable.duty = value
         @speed = value
       end
-      
+
       def forward(value=nil)
         direction1.high
         direction2.low
         self.speed = value if value
       end
-      
+
       def reverse(value=nil)
         direction1.low
         direction2.high
         self.speed = value if value
       end
-      
+
       def idle
         direction1.low
         direction2.low
         self.speed = 0
       end
       alias :off :idle
-      
+
       def brake
         direction1.high
         direction2.high
-        self.speed = board.pwm_high
+        self.speed = 100
       end
     end
   end

data/lib/denko/motor/servo.rb

@@ -3,16 +3,28 @@ module Denko
     class Servo
       include Behaviors::SinglePin
       include Behaviors::Threaded
+      include Behaviors::Lifecycle
 
-      def after_initialize(options={})
-        super(options)
-        @min = options[:min] || 544
-        @max = options[:max] || 2400
+      before_initialize do
+        params[:mode] = :output_pwm
+      end
+
+      after_initialize do
         attach
       end
 
+      def min
+        @min ||= params[:min] || 500
+      end
+
+      def max
+        @max ||= params[:max] || 2500
+      end
+
+      attr_writer :min, :max
+
       def attach
-        board.servo_toggle(pin, :on, min: @min, max: @max)
+        board.servo_toggle(pin, :on, min: min, max: max)
       end
 
       def detach
@@ -22,19 +34,19 @@ module Denko
       def position=(value)
         value = value % 180 unless value == 180
 
-        microseconds = ((value.to_f / 180) * (@max - @min)) + @min
+        microseconds = ((value.to_f / 180) * (max - min)) + min
         board.servo_write(pin, microseconds.round)
 
-        @state = value
+        self.state = value
       end
 
       def speed=(value)
         raise 'invalid speed value' if value > 100 || value < -100
 
-        microseconds = (((value.to_f + 100) / 200) * (@max - @min)) + @min
+        microseconds = (((value.to_f + 100) / 200) * (max - min)) + min
         board.servo_write(pin, microseconds.round)
 
-        @state = value
+        self.state = value
       end
 
       alias :angle=   :position=
@@ -43,7 +55,7 @@ module Denko
       alias :speed    :state
 
       def write_microseconds(value)
-        raise 'invalid microsecond value' if value > @max || value < @min
+        raise 'invalid microsecond value' if value > max || value < min
         board.servo_write(pin, value)
       end
     end

data/lib/denko/motor/stepper.rb

@@ -2,25 +2,24 @@ module Denko
   module Motor
     class Stepper
       include Behaviors::MultiPin
-      
+      include Behaviors::Lifecycle
+
       def initialize_pins(options={})
         proxy_pin :step,      DigitalIO::Output
         proxy_pin :direction, DigitalIO::Output
-        
+
         proxy_pin :ms1,    DigitalIO::Output, optional: true
         proxy_pin :ms2,    DigitalIO::Output, optional: true
         proxy_pin :enable, DigitalIO::Output, optional: true
-        proxy_pin :slp,    DigitalIO::Output, optional: true        
+        proxy_pin :slp,    DigitalIO::Output, optional: true
       end
-      
+
       attr_reader :microsteps
-                  
-      def after_initialize(options={})
-        wake; on;
-        
-        if (ms1 && ms2)
-          self.microsteps = 8
-        end
+
+      after_initialize do
+        wake
+        on
+        self.microsteps = 8 if (ms1 && ms2)
       end
 
       def sleep
@@ -53,7 +52,7 @@ module Denko
         @microsteps = steps
       end
 
-      def step_cc
+      def step_ccw
         direction.high unless direction.high?
         step.high
         step.low
@@ -64,8 +63,6 @@ module Denko
         step.high
         step.low
       end
-
-      alias :step_ccw :step_cc
     end
   end
 end

data/lib/denko/mutex_stub.rb

@@ -0,0 +1,7 @@
+module Denko
+  class MutexStub
+    def synchronize(&block)
+      block.call
+    end
+  end
+end

data/lib/denko/one_wire/bus.rb

@@ -1,16 +1,15 @@
 module Denko
   module OneWire
-    class Bus
-      include Behaviors::SinglePin
+    class Bus < DigitalIO::CBitBang
       include Behaviors::BusControllerAddressed
       include Behaviors::Reader
+      include Behaviors::Lifecycle
       include BusEnumerator
       include Constants
 
       attr_reader :parasite_power
 
-      def after_initialize(options = {})
-        super(options)
+      after_initialize do
         read_power_supply
       end
 
@@ -53,7 +52,12 @@ module Denko
       end
 
       def pre_callback_filter(bytes)
-        bytes = bytes.split(",").map(&:to_i)
+        # C extensions respond with Ruby array
+        # External Board responds with comma delimited String
+        unless bytes.class == Array
+          bytes = bytes.split(",").map(&:to_i)
+        end
+
         bytes.length > 1 ? bytes : bytes[0]
       end
     end

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/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,7 +19,7 @@ module Denko
       def no_tone
         board.no_tone(pin)
       end
-      
+
       # Kill the thread if running, and send no_tone.
       def stop
         stop_thread

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

@@ -1,11 +1,16 @@
 module Denko
   module PulseIO
-    class IRTransmitter
+    class IROutput
       include Behaviors::OutputPin
+      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)'
+      before_initialize do
+        params[:mode] = :output_pwm
+      end
+
+      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,34 +1,88 @@
 module Denko
   module PulseIO
     class PWMOutput < DigitalIO::Output
-      interrupt_with :write
-      
-      def initialize_pins(options={})
-        super(options)
-      end
+      include Behaviors::Lifecycle
+
+      interrupt_with :write, :pwm_write, :digital_write, :duty=
 
-      def write(value)
-        if value == board.low
-          digital_write(board.low)
-        elsif value == board.pwm_high
-          digital_write(board.high)
+      def duty=(percent)
+        if board_is_piboard
+          pwm_write(percent)
         else
-          pwm_write(value)
+          pwm_write(((percent * pwm_high) / 100.0).round)
         end
       end
 
+      def digital_write(value)
+        pwm_disable if pwm_enabled
+        super(value)
+      end
+
       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 resolution
+        @resolution ||= params[:resolution] || board.analog_write_resolution
+      end
+
+      def pwm_high
+        @pwm_high ||= (2**resolution-1)
+      end
+
+      def frequency=(value)
+        @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)
+        @resolution = value
+        @pwm_high   = (2**value-1)
+        pwm_enable
       end
-      
+
+      def pwm_settings_hash
+        { frequency: frequency, resolution: resolution }
+      end
+
+      def pwm_enable(frequency: nil, resolution: nil)
+        @frequency  = frequency  if frequency
+        if resolution
+          @resolution = resolution
+          @pwm_high   = (2**resolution-1)
+        end
+
+        board.set_pin_mode(pin, :output_pwm, pwm_settings_hash)
+        @mode = :output_pwm
+      end
+
       def pwm_disable
         self.mode = :output
       end
+
+      def pwm_enabled
+        mode == :output_pwm
+      end
+
+      def board_is_piboard
+        @board_is_piboard ||= piboard_check
+      end
+
+      def piboard_check
+        if Object.const_defined?("Denko::PiBoard")
+          if board.class.ancestors.include?(Denko::PiBoard)
+            return true
+          end
+        end
+        false
+      end
     end
   end
 end

data/lib/denko/pulse_io.rb

@@ -1,7 +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"
+    autoload :PWMOutput,    "#{__dir__}/pulse_io/pwm_output"
+    autoload :Buzzer,       "#{__dir__}/pulse_io/buzzer"
+    autoload :IROutput,     "#{__dir__}/pulse_io/ir_output"
   end
 end

data/lib/denko/rtc/ds3231.rb

@@ -1,32 +1,30 @@
+require 'bcd'
+
 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)
         [ BCD.decode(time.sec),
@@ -37,7 +35,7 @@ module Denko
           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/sensor/aht.rb

@@ -3,9 +3,13 @@ module Denko
     class AHT10
       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_mutex.synchronize { @state = { temperature: nil, humidity: nil } }
+      end
+
+      def reading
+        @reading ||= { temperature: nil, humidity: nil }
+      end
+
       def reset
         i2c_write(SOFT_RESET)
         sleep(RESET_DELAY)
@@ -68,14 +69,14 @@ module Denko
       end
 
       def read_status_register
-        read_using -> { i2c_read(READ_STATUS_REGISTER, 1) }
+        read_using -> { i2c_read(1, register: READ_STATUS_REGISTER) }
         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)
@@ -91,17 +92,17 @@ module Denko
 
         # 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_mutex.synchronize do
           @state[:temperature] = reading[:temperature]
           @state[:humidity]    = reading[:humidity]
         end
@@ -119,7 +120,7 @@ module Denko
       # 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,7 +157,7 @@ module Denko
             end
           end
         end
-        
+
         # Limit CRC size to 8 bits.
         crc = crc & 0xFF
       end