denko 0.13.6 → 0.15.0

data/lib/denko/led/apa102.rb

@@ -1,39 +1,50 @@
 module Denko
   module LED
     class APA102
-      include SPI::Peripheral
+      include Behaviors::BusPeripheral
+      include Behaviors::Lifecycle
 
-      attr_reader :length, :bpp, :brightness
-
-      def before_initialize(options={})
-        options[:pin] = 255
-        super(options)
+      def length
+        @length ||= params[:length] || 1
       end
 
-      def after_initialize(options={})
-        super(options)
-
-        raise ArgumentError, "no length given for APA102 array" unless options[:length]
-        @length = options[:length]
+      # Start frame is always 32 0-bits (4 bytes).
+      def start_frame
+        @start_frame ||= Array.new(4) { 0 }
+      end
 
-        # Start frame is always 32 0-bits (4 bytes).
-        @start_frame = Array.new(4) { 0 }
+      def end_frame
+        return @end_frame if @end_frame
 
-        # End frame must be at least @length/2 bits long, and 32 bits (4 bytes) minimum.
-        end_frame_bytes = (@length / 16.0).ceil
+        # End frame must be at least length/2 bits long, and 32 bits (4 bytes) minimum.
+        end_frame_bytes = (length / 16.0).ceil
         end_frame_bytes = 4 if end_frame_bytes < 4
 
         # Use all 0's for end frame instead of 1's. Prevents extra pixel when using partial strip.
         @end_frame = Array.new(end_frame_bytes) { 0 }
+      end
+
+      # This is BYTES per pixel, not bits per pixel.
+      # 0th byte is per-pixel brightness (PWM applied to all 3 colors).
+      def bpp
+        @bpp ||= 4
+      end
 
-        # This is BYTES per pixel, not bits per pixel.
-        # 0th byte is per-pixel brightness (PWM applied to all 3 colors).
-        @bpp = 4
-        @buffer = Array.new(length * bpp) { 0 }
+      def buffer
+        @buffer ||= Array.new(length * bpp) { 0 }
+      end
+
+      attr_writer :buffer
+
+      before_initialize do
+        unless [Denko::SPI::Bus, Denko::SPI::BitBang].include? params[:bus].class
+          raise "APA102 must be connected to the output pin of a SPI bus"
+        end
+      end
 
+      after_initialize do
         # Default to max brightness.
         self.brightness = 31
-        
         off
       end
 
@@ -47,26 +58,26 @@ module Denko
         @masked_brightness = 0b11100000 | @brightness
 
         # Set brightness for all pixels.
-        (0..@length-1).each do |index|
-          @buffer[index*bpp+0] = @masked_brightness
+        (0..length-1).each do |index|
+          buffer[index*bpp+0] = @masked_brightness
         end
       end
 
       def []=(index, array)
         # Per-pixel brightness control, as optional 3rd indexed element of array.
         if array[3]
-          @buffer[index*bpp+0] = 0b11100000 | array[3]
+          buffer[index*bpp+0] = 0b11100000 | array[3]
         end
-        
+
         # APA102 uses BGR ordering.
-        @buffer[index*bpp+1] = array[2]
-        @buffer[index*bpp+2] = array[1]
-        @buffer[index*bpp+3] = array[0]
+        buffer[index*bpp+1] = array[2]
+        buffer[index*bpp+2] = array[1]
+        buffer[index*bpp+3] = array[0]
       end
 
       def all_on
         self.brightness = 31
-        @buffer = @buffer.each_slice(bpp).map { [@masked_brightness,255,255,255] }.flatten
+        self.buffer     = buffer.each_slice(bpp).map { [@masked_brightness,255,255,255] }.flatten
         show
       end
 
@@ -76,11 +87,12 @@ module Denko
       end
 
       def clear
-        @buffer = @buffer.each_slice(bpp).map { [@masked_brightness,0,0,0] }.flatten
+        self.buffer = buffer.each_slice(bpp).map { [@masked_brightness,0,0,0] }.flatten
       end
 
       def show
-        spi_write(@start_frame + @buffer + @end_frame)
+        data = start_frame + buffer + end_frame
+        bus.transfer(nil, write: data)
       end
     end
   end

data/lib/denko/led/base.rb

@@ -2,11 +2,22 @@ module Denko
   module LED
     class Base < PulseIO::PWMOutput
       def blink(interval=0.5)
-        threaded_loop do 
+        self.blink_interval = interval
+        threaded_loop do
           toggle
-          sleep interval
+          sleep @blink_interval
         end
       end
+
+      def blink_interval=(interval)
+        @blink_interval = interval
+      end
+      attr_reader :blink_interval
+    end
+
+    # Shortcut, so LED.new does LED::Base.new.
+    def self.new(options={})
+      self::Base.new(options)
     end
   end
 end

data/lib/denko/led/rgb.rb

@@ -11,27 +11,31 @@ module Denko
 
       # Format: [R, G, B]
       COLORS = {
-        red:     [255, 000, 000],
-        green:   [000, 255, 000],
-        blue:    [000, 000, 255],
-        cyan:    [000, 255, 255],
-        yellow:  [255, 255, 000],
-        magenta: [255, 000, 255],
-        white:   [255, 255, 255],
+        red:     [100, 000, 000],
+        green:   [000, 100, 000],
+        blue:    [000, 000, 100],
+        cyan:    [000, 100, 100],
+        yellow:  [100, 100, 000],
+        magenta: [100, 000, 100],
+        white:   [100, 100, 100],
         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.duty   = r
+        green.duty = g
+        blue.duty  = b
       end
 
-      def color=(color)
-        return write(color) if color.class == Array
+      def write_8_bit(r, g, b)
+        red.duty   = ((r / 255.0) * 100).round
+        green.duty = ((g / 255.0) * 100).round
+        blue.duty  = ((b / 255.0) * 100).round
+      end
 
+      def color=(color)
         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_a_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/led.rb

@@ -1,13 +1,22 @@
+# Represent files to be autoloaded in CRuby as an Array.
+# This allows Mruby::Build to parse and preload them instead.
+LED_FILES = [
+  [nil,           "base"],
+  [:RGB,          "rgb"],
+  [:SevenSegment, "seven_segment"],
+  [:WS2812,       "ws2812"],
+  [:APA102,       "apa102"],
+]
+
 module Denko
   module LED
-    autoload :Base,         "#{__dir__}/led/base"
-    autoload :RGB,          "#{__dir__}/led/rgb"
-    autoload :SevenSegment, "#{__dir__}/led/seven_segment"
-    autoload :WS2812,       "#{__dir__}/led/ws2812"
-    autoload :APA102,       "#{__dir__}/led/apa102"
-
-    def self.new(options={})
-      self::Base.new(options)
+    LED_FILES.each do |file|
+      file_path = "#{__dir__}/led/#{file[1]}"
+      if file[0]
+        autoload file[0], file_path
+      else
+        require file_path
+      end
     end
   end
 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/{stepper.rb → a3967.rb}

@@ -1,26 +1,25 @@
 module Denko
   module Motor
-    class Stepper
+    class A3967
       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/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

@@ -1,40 +1,58 @@
 module Denko
   module Motor
     class Servo
+      FREQUENCY = 50
+      PERIOD_NS = 20_000_000
+
       include Behaviors::SinglePin
-      include Behaviors::Threaded
+      include Behaviors::Lifecycle
+
+      before_initialize do
+        params[:mode] = :output_pwm
+      end
 
-      def after_initialize(options={})
-        super(options)
-        @min = options[:min] || 544
-        @max = options[:max] || 2400
+      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)
+        if board.platform == :arduino
+          board.servo_toggle(pin, :on, min: min, max: max)
+        else
+          board.set_pin_mode(pin, :output_pwm, {frequency: FREQUENCY, period: PERIOD_NS})
+        end
       end
 
       def detach
-        board.servo_toggle(pin, :off)
+        board.servo_toggle(pin, :off) if board.platform == :arduino
       end
 
       def position=(value)
         value = value % 180 unless value == 180
 
-        microseconds = ((value.to_f / 180) * (@max - @min)) + @min
-        board.servo_write(pin, microseconds.round)
+        microseconds = ((value.to_f / 180) * (max - min)) + min
+        write_microseconds(microseconds)
 
-        @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
-        board.servo_write(pin, microseconds.round)
+        microseconds = (((value.to_f + 100) / 200) * (max - min)) + min
+        write_microseconds(microseconds)
 
-        @state = value
+        self.state = value
       end
 
       alias :angle=   :position=
@@ -43,8 +61,12 @@ module Denko
       alias :speed    :state
 
       def write_microseconds(value)
-        raise 'invalid microsecond value' if value > @max || value < @min
-        board.servo_write(pin, value)
+        raise 'invalid microsecond value' if value > max || value < min
+        if board.platform == :arduino
+          board.servo_write(pin, value)
+        else
+          board.pwm_write(pin, (value * 1000.0).round)
+        end
       end
     end
   end

data/lib/denko/motor.rb

@@ -1,7 +1,20 @@
+# Represent files to be autoloaded in CRuby as an Array.
+# This allows Mruby::Build to parse and preload them instead.
+MOTOR_FILES = [
+  [:Servo,  "servo"],
+  [:A3967,  "a3967"],
+  [:L298,   "l298"],
+]
+
 module Denko
   module Motor
-    autoload :Servo,    "#{__dir__}/motor/servo"
-    autoload :Stepper,  "#{__dir__}/motor/stepper"
-    autoload :L298,     "#{__dir__}/motor/l298"
+    MOTOR_FILES.each do |file|
+      file_path = "#{__dir__}/motor/#{file[1]}"
+      if file[0]
+        autoload file[0], file_path
+      else
+        require file_path
+      end
+    end
   end
 end

data/lib/denko/one_wire/bus.rb

@@ -1,44 +1,47 @@
 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
 
       def read_power_supply
-        mutex.synchronize do
-          # Without driving low first, results are inconsistent.
-          board.set_pin_mode(self.pin, :output)
-          board.digital_write(self.pin, board.low)
-          sleep 0.1
-
-          reset
-          write(SKIP_ROM, READ_POWER_SUPPLY)
-
-          # Only LSBIT matters, but we can only read whole bytes.
-          byte = read(1)
-          @parasite_power = (byte[0] == 0) ? true : false
-        end
+        mutex.lock
+
+        # Without driving low first, results are inconsistent.
+        board.set_pin_mode(self.pin, :output)
+        board.digital_write(self.pin, board.low)
+        sleep 0.1
+
+        reset
+        write(SKIP_ROM, READ_POWER_SUPPLY)
+
+        # Only LSBIT matters, but we can only read whole bytes.
+        byte = read(1)
+        @parasite_power = (byte & 0b1 == 0) ? true : false
+
+        mutex.unlock
+        @parasite_power
       end
 
       def device_present
-        mutex.synchronize do
-          byte = read_using -> { reset(1) }
-          (byte == 0) ? true : false
-        end
+        mutex.lock
+        byte = read_using -> { reset(true) }
+        presence = (byte == 0) ? true : false
+        mutex.unlock
+        presence
       end
       alias :device_present? :device_present
 
-      def reset(get_presence=0)
+      def reset(get_presence=false)
         board.one_wire_reset(pin, get_presence)
       end
 
@@ -53,7 +56,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