denko 0.14.0 → 0.15.0

data/lib/denko/led/apa102.rb

@@ -4,8 +4,6 @@ module Denko
       include Behaviors::BusPeripheral
       include Behaviors::Lifecycle
 
-      def pin; nil; end
-
       def length
         @length ||= params[:length] || 1
       end
@@ -94,7 +92,7 @@ module Denko
 
       def show
         data = start_frame + buffer + end_frame
-        bus.transfer(pin, write: data)
+        bus.transfer(nil, write: data)
       end
     end
   end

data/lib/denko/led/base.rb

@@ -14,5 +14,10 @@ module Denko
       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,20 +11,26 @@ 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(r, g, b)
-        red.write(r)
-        green.write(g)
-        blue.write(b)
+        red.duty   = r
+        green.duty = g
+        blue.duty  = b
+      end
+
+      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)

data/lib/denko/led/seven_segment.rb

@@ -99,7 +99,7 @@ module Denko
         bits = bits.map { |b| 1^b } if anode
 
         bits.each_with_index do |bit, index|
-          if board_is_register?
+          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)

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/motor/{stepper.rb → a3967.rb}

@@ -1,6 +1,6 @@
 module Denko
   module Motor
-    class Stepper
+    class A3967
       include Behaviors::MultiPin
       include Behaviors::Lifecycle
 

data/lib/denko/motor/servo.rb

@@ -1,8 +1,10 @@
 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
@@ -24,18 +26,22 @@ module Denko
       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)
+        write_microseconds(microseconds)
 
         self.state = value
       end
@@ -44,7 +50,7 @@ module Denko
         raise 'invalid speed value' if value > 100 || value < -100
 
         microseconds = (((value.to_f + 100) / 200) * (max - min)) + min
-        board.servo_write(pin, microseconds.round)
+        write_microseconds(microseconds)
 
         self.state = value
       end
@@ -56,7 +62,11 @@ module Denko
 
       def write_microseconds(value)
         raise 'invalid microsecond value' if value > max || value < min
-        board.servo_write(pin, value)
+        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

@@ -14,30 +14,34 @@ module Denko
       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
+        mutex.lock
 
-          reset
-          write(SKIP_ROM, READ_POWER_SUPPLY)
+        # Without driving low first, results are inconsistent.
+        board.set_pin_mode(self.pin, :output)
+        board.digital_write(self.pin, board.low)
+        sleep 0.1
 
-          # Only LSBIT matters, but we can only read whole bytes.
-          byte = read(1)
-          @parasite_power = (byte[0] == 0) ? true : false
-        end
+        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
 

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.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

@@ -20,12 +20,8 @@ module Denko
         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_output.rb

@@ -1,13 +1,9 @@
 module Denko
   module PulseIO
     class IROutput
-      include Behaviors::OutputPin
+      include Behaviors::SinglePin
       include Behaviors::Lifecycle
 
-      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)'

data/lib/denko/pulse_io/pwm_output.rb

@@ -5,21 +5,49 @@ module Denko
 
       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_is_piboard
-          pwm_write(percent)
+        if board.platform == :arduino
+          pwm_write((percent / 100.0 * pwm_high).round)
         else
-          pwm_write(((percent * pwm_high) / 100.0).round)
+          pwm_write((percent / 100.0 * period).round)
         end
       end
 
       def digital_write(value)
-        pwm_disable if pwm_enabled
-        super(value)
+        # Use regular #digital_write for speed until a PWM method is called.
+        unless pwm_enabled?
+          super(value)
+        else
+          # 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
+        pwm_enable unless pwm_enabled?
         board.pwm_write(pin, value)
         self.state = value
       end
@@ -29,6 +57,10 @@ module Denko
         @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
@@ -37,51 +69,44 @@ module Denko
         @pwm_high ||= (2**resolution-1)
       end
 
-      def frequency=(value)
+      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
       end
 
       def resolution=(value)
-        @resolution = value
-        @pwm_high   = (2**value-1)
+        self._resolution = value
         pwm_enable
       end
 
       def pwm_settings_hash
-        { frequency: frequency, resolution: resolution }
+        { frequency: frequency, period: period, resolution: resolution }
       end
 
       def pwm_enable(frequency: nil, resolution: nil)
-        @frequency  = frequency  if frequency
-        if resolution
-          @resolution = resolution
-          @pwm_high   = (2**resolution-1)
-        end
+        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
-        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
+      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 :IROutput,     "#{__dir__}/pulse_io/ir_output"
+    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

@@ -1,5 +1,3 @@
-require 'bcd'
-
 module Denko
   module RTC
     class DS3231
@@ -27,10 +25,13 @@ module Denko
 
       # 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) ]

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