denko 0.13.0

data/lib/denko/led/seven_segment.rb

@@ -0,0 +1,111 @@
+module Denko
+  module LED
+    class SevenSegment
+      include Behaviors::MultiPin
+      
+      def initialize_pins(options={})
+        [:a, :b, :c, :d, :e, :f, :g].each do |symbol|
+          proxy_pin(symbol, DigitalIO::Output)
+        end
+
+        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
+      end
+
+      attr_reader :segments
+
+      def clear
+        segments.each do |pin|
+          pin.low if cathode
+          pin.high if anode
+        end
+      end
+
+      def display(char)
+        char = char.to_s
+        return scroll(char) if char.length > 1
+        off; write(char); on
+      end
+
+      def on
+        anode.high if anode
+        cathode.low if cathode
+      end
+
+      def off
+        anode.low if anode
+        cathode.high if cathode
+      end
+
+      CHARACTERS = {
+        '0' => [1,1,1,1,1,1,0],
+        '1' => [0,1,1,0,0,0,0],
+        '2' => [1,1,0,1,1,0,1],
+        '3' => [1,1,1,1,0,0,1],
+        '4' => [0,1,1,0,0,1,1],
+        '5' => [1,0,1,1,0,1,1],
+        '6' => [1,0,1,1,1,1,1],
+        '7' => [1,1,1,0,0,0,0],
+        '8' => [1,1,1,1,1,1,1],
+        '9' => [1,1,1,1,0,1,1],
+        ' ' => [0,0,0,0,0,0,0],
+        '_' => [0,0,0,1,0,0,0],
+        '-' => [0,0,0,0,0,0,1],
+        'A' => [1,1,1,0,1,1,1],
+        'B' => [0,0,1,1,1,1,1],
+        'C' => [0,0,0,1,1,0,1],
+        'D' => [0,1,1,1,1,0,1],
+        'E' => [1,0,0,1,1,1,1],
+        'F' => [1,0,0,0,1,1,1],
+        'G' => [1,0,1,1,1,1,0],
+        'H' => [0,0,1,0,1,1,1],
+        'I' => [0,0,1,0,0,0,0],
+        'J' => [0,1,1,1,1,0,0],
+        'K' => [1,0,1,0,1,1,1],
+        'L' => [0,0,0,1,1,1,0],
+        'M' => [1,1,1,0,1,1,0],
+        'N' => [0,0,1,0,1,0,1],
+        'O' => [0,0,1,1,1,0,1],
+        'P' => [1,1,0,0,1,1,1],
+        'Q' => [1,1,1,0,0,1,1],
+        'R' => [0,0,0,0,1,0,1],
+        'S' => [1,0,1,1,0,1,1],
+        'T' => [0,0,0,1,1,1,1],
+        'U' => [0,0,1,1,1,0,0],
+        'V' => [0,1,1,1,1,1,0],
+        'W' => [0,1,1,1,1,1,1],
+        'X' => [0,1,1,0,1,1,1],
+        'Y' => [0,1,1,1,0,1,1],
+        'Z' => [1,1,0,1,1,0,0],
+      }
+
+      private
+
+      def write(char)
+        bits = CHARACTERS[char.to_s.upcase]
+        unless bits
+          clear
+        else
+          bits.each_with_index do |bit, index|
+            if anode
+              bit == 0 ? bit = 1 : bit = 0
+            end
+            segments[index].write(bit) unless (segments[index].state == bit)
+          end
+        end
+      end
+
+      def scroll(string)
+        string.chars.each do |char|
+          display(char)
+          sleep(0.5)
+        end
+      end
+    end
+  end
+end

data/lib/denko/led/ws2812.rb

@@ -0,0 +1,48 @@
+module Denko
+  module LED
+    class WS2812
+      include Behaviors::SinglePin
+
+      attr_reader :length, :bpp
+
+      def after_initialize(options={})
+        super(options)
+        raise ArgumentError, "no length given for WS2812 array" unless options[:length]
+        @length = options[:length]
+
+        # This is BYTES per pixel, not bits per pixel.
+        @bpp = 3
+        off
+      end
+
+      def []=(index, array)
+        # Just do GRB order for now.
+        buffer[index*bpp]   = array[1]
+        buffer[index*bpp+1] = array[0]
+        buffer[index*bpp+2] = array[2]
+      end
+
+      def buffer
+        @buffer ||= Array.new(length * bpp) { 0 }
+      end
+
+      def all_on
+        buffer.map! { 255 } # should scale with brightness
+        show
+      end
+
+      def off
+        clear
+        show
+      end
+
+      def clear
+        buffer.map! { 0 }
+      end
+
+      def show
+        board.show_ws2812(self.pin, self.buffer)
+      end
+    end
+  end
+end

data/lib/denko/led.rb

@@ -0,0 +1,13 @@
+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)
+    end
+  end
+end

data/lib/denko/message.rb

@@ -0,0 +1,92 @@
+module Denko
+  module Message
+    BYTE_MAX = 255
+    VAL_MIN = 0
+    VAL_MAX = 9999
+
+    def self.encode(command: nil, pin: nil, value: nil, aux_message: nil)
+      # Start building message backwards with aux_message first.
+      if aux_message
+        # Convert it to String.
+        aux_message = aux_message.to_s
+
+        # Validate aux_message before escaping characters.
+        raise ArgumentError, 'aux_message is limited to 528 characters' if aux_message.length > 528
+
+        # Escape \ and \n.
+        aux_message = aux_message.gsub("\\","\\\\\\\\").gsub("\n", "\\\n")
+
+        # Start message with aux_message.
+        message = ".#{aux_message}"
+      else
+        # Or start with empty message.
+        message = ""
+      end
+
+      # Prepend value
+      if value
+        # Validate value
+        if (value.class != Integer || value < VAL_MIN || value > VAL_MAX)
+          raise ArgumentError, "value must be integer in range #{VAL_MIN} to #{VAL_MAX}"
+        end
+
+        message = ".#{value}#{message}"
+      elsif !message.empty?
+        message = ".#{message}"
+      end
+
+      # Prepend pin
+      if pin
+        # Validate pin
+        if (pin.class != Integer || pin < 0 || pin > BYTE_MAX)
+          raise ArgumentError, 'pin must be integer in range 0 to 255'
+        end
+
+        message = ".#{pin}#{message}"
+      elsif !message.empty?
+        message = ".#{message}"
+      end
+
+      # Validate command
+      raise ArgumentError, 'command missing from message' unless command
+      if command.class != Integer || command < 0 || command > BYTE_MAX
+        raise ArgumentError, 'command must be Integer in range 0 to 255'
+      end
+
+      # Prepend command and append newline.
+      message = "#{command}#{message}\n"
+    end
+
+    def self.pack(type, data, options={})
+      # Always pack as little endian.
+      template =  case type
+                  when :uint64  then 'Q<*'
+                  when :uint32  then 'L<*'
+                  when :uint16  then 'S<*'
+                  when :uint8   then 'C*'
+                  else raise ArgumentError, "unsupported pack format '#{type}'"
+                  end
+
+      # Can pass a single integer to get packed if we always [] then flatten.
+      str = [data].flatten.pack(template)
+
+      # Pad right with null bytes if asked.
+      if options[:pad] && options[:pad] > str.length
+        (options[:pad] - str.length).times do
+          str = str + "\x00"
+        end
+      end
+
+      if options[:min] && str.length < options[:min]
+        raise ArgumentError, "too few bytes given (expected at least #{options[:min]})"
+      end
+
+      # Max should probably always be set to avoid overruning aux message RAM.
+      if options[:max] && str.length > options[:max]
+        raise ArgumentError, "too many bytes given (expected at most #{options[:max]})"
+      end
+
+      str
+    end
+  end
+end

data/lib/denko/motor/l298.rb

@@ -0,0 +1,49 @@
+module Denko
+  module Motor
+    class L298
+      include Behaviors::MultiPin
+
+      attr_reader :speed
+      
+      def initialize_pins(options={})
+        proxy_pin :direction1,  DigitalIO::Output
+        proxy_pin :direction2,  DigitalIO::Output
+        proxy_pin :enable,      PulseIO::PWMOutput 
+      end
+                  
+      def after_initialize(options={})
+        off
+      end
+
+      def speed=(value)
+        enable.write(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
+      end
+    end
+  end
+end

data/lib/denko/motor/servo.rb

@@ -0,0 +1,51 @@
+module Denko
+  module Motor
+    class Servo
+      include Behaviors::SinglePin
+      include Behaviors::Threaded
+
+      def after_initialize(options={})
+        super(options)
+        @min = options[:min] || 544
+        @max = options[:max] || 2400
+        attach
+      end
+
+      def attach
+        board.servo_toggle(pin, :on, min: @min, max: @max)
+      end
+
+      def detach
+        board.servo_toggle(pin, :off)
+      end
+
+      def position=(value)
+        value = value % 180 unless value == 180
+
+        microseconds = ((value.to_f / 180) * (@max - @min)) + @min
+        board.servo_write(pin, microseconds.round)
+
+        @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)
+
+        @state = value
+      end
+
+      alias :angle=   :position=
+      alias :angle    :state
+      alias :position :state
+      alias :speed    :state
+
+      def write_microseconds(value)
+        raise 'invalid microsecond value' if value > @max || value < @min
+        board.servo_write(pin, value)
+      end
+    end
+  end
+end

data/lib/denko/motor/stepper.rb

@@ -0,0 +1,71 @@
+module Denko
+  module Motor
+    class Stepper
+      include Behaviors::MultiPin
+      
+      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        
+      end
+      
+      attr_reader :microsteps
+                  
+      def after_initialize(options={})
+        wake; on;
+        
+        if (ms1 && ms2)
+          self.microsteps = 8
+        end
+      end
+
+      def sleep
+        slp.low if slp
+      end
+
+      def wake
+        slp.high if slp
+      end
+
+      def off
+        enable.high if enable
+      end
+
+      def on
+        enable.low if enable
+      end
+
+      def microsteps=(steps)
+        if (ms1 && ms2)
+          case steps.to_i
+          when 1; ms2.low;  ms1.low
+          when 2; ms2.low;  ms1.high
+          when 4; ms2.high; ms1.low
+          when 8; ms2.high; ms1.high
+          end
+        else
+          raise ArgumentError, "ms1 and ms2 pins must be connected to GPIO pins to control microstepping."
+        end
+        @microsteps = steps
+      end
+
+      def step_cc
+        direction.high unless direction.high?
+        step.high
+        step.low
+      end
+
+      def step_cw
+        direction.low unless direction.low?
+        step.high
+        step.low
+      end
+
+      alias :step_ccw :step_cc
+    end
+  end
+end

data/lib/denko/motor.rb

@@ -0,0 +1,7 @@
+module Denko
+  module Motor
+    autoload :Servo,    "#{__dir__}/motor/servo"
+    autoload :Stepper,  "#{__dir__}/motor/stepper"
+    autoload :L298,     "#{__dir__}/motor/l298"
+  end
+end

data/lib/denko/one_wire/bus.rb

@@ -0,0 +1,61 @@
+module Denko
+  module OneWire
+    class Bus
+      include Behaviors::SinglePin
+      include Behaviors::BusControllerAddressed
+      include Behaviors::Reader
+      include BusEnumeration
+      include Constants
+
+      attr_reader :parasite_power
+
+      def after_initialize(options = {})
+        super(options)
+        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
+      end
+
+      def device_present
+        mutex.synchronize do
+          byte = read_using -> { reset(1) }
+          (byte == 0) ? true : false
+        end
+      end
+      alias :device_present? :device_present
+
+      def reset(get_presence=0)
+        board.one_wire_reset(pin, get_presence)
+      end
+
+      def _read(num_bytes)
+        board.one_wire_read(pin, num_bytes)
+      end
+
+      def write(*bytes)
+        bytes.flatten!
+        pp = parasite_power && [CONVERT_T, COPY_SCRATCH].include?(bytes.last)
+        board.one_wire_write(pin, pp, bytes)
+      end
+
+      def pre_callback_filter(bytes)
+        bytes = bytes.split(",").map(&:to_i)
+        bytes.length > 1 ? bytes : bytes[0]
+      end
+    end
+  end
+end

data/lib/denko/one_wire/bus_enumeration.rb

@@ -0,0 +1,88 @@
+module Denko
+  module OneWire
+    module BusEnumeration
+      def _search(branch_mask)
+        reset
+        write(SEARCH_ROM)
+        board.one_wire_search(pin, branch_mask)
+      end
+
+      def found_devices
+        @found_devices ||= []
+      end
+
+      def search
+        @found_devices = []
+        branch_mask = 0
+        high_discrepancy = 0
+
+        loop do
+          read_using -> { _search(branch_mask) } do |result|
+            device, high_discrepancy = parse_search_result(result)
+            @found_devices << device
+          end
+
+          # No unsearched discrepancies left.
+          break if high_discrepancy == -1
+
+          # Force highest new discrepancy to be a 1 on the next search.
+          # i.e. Go as deep as possible into each branch found then back out.
+          #
+          branch_mask = branch_mask | (2 ** high_discrepancy)
+
+          # Clear bits above high_discrepancy so we don't repeat branches.
+          # When high_discrepancy < MSB of branch_mask, this moves us
+          # one node out, closer to the root, and finishing the search.
+          #
+          unset_mask = 0xFFFFFFFFFFFFFFFF >> (63 - high_discrepancy)
+          branch_mask = branch_mask & unset_mask
+        end
+      end
+
+      def parse_search_result(result)
+        address, complement = split_search_result(result)
+
+        raise "CRC error during OneWire search" unless Helper.crc_check(address)
+
+        if (address & complement) > 0
+          raise "OneWire device not connected or disconnected during search"
+        end
+
+        # 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 }
+
+        # LSByte of address is product family.
+        klass = family_lookup(address & 0xFF)
+
+        [{class: klass, address: address}, high_discrepancy]
+      end
+
+      # Result is 16 bytes, 8 byte address and complement interleaved LSByte first.
+      def split_search_result(data)
+        address = 0
+        complement = 0
+
+        data.reverse.each_slice(2) do |comp_byte, addr_byte|
+          address = (address << 8) | addr_byte
+          complement = (complement << 8) | comp_byte
+        end
+
+        [address, complement]
+      end
+
+      # Set FAMILY_CODE in peripheral class to get it identified during search.
+      def family_lookup(family_code)
+        OneWire.constants.each do |const|
+          obj = OneWire.const_get(const)
+          if (obj.is_a? Class) && (obj.const_defined? "FAMILY_CODE")
+            return obj if obj::FAMILY_CODE == family_code
+          end
+        end
+        return nil
+      end
+    end
+  end
+end

data/lib/denko/one_wire/constants.rb

@@ -0,0 +1,17 @@
+module Denko
+  module OneWire
+    module Constants
+      READ_POWER_SUPPLY = 0xB4
+      CONVERT_T         = 0x44
+      SEARCH_ROM        = 0xF0
+      READ_ROM          = 0x33
+      SKIP_ROM          = 0xCC
+      MATCH_ROM         = 0x55
+      ALARM_SEARCH      = 0xEC
+      READ_SCRATCH      = 0xBE
+      WRITE_SCRATCH     = 0x4E
+      COPY_SCRATCH      = 0x48
+      RECALL_EEPROM     = 0xB8
+    end
+  end
+end

data/lib/denko/one_wire/helper.rb

@@ -0,0 +1,33 @@
+module Denko
+  module OneWire
+    class Helper
+      def self.address_to_bytes(address)
+        [address].pack('Q<').split("").map(&:ord)
+      end
+
+      def self.crc_check(data)
+        calculated, received = self.calculate_crc(data)
+        calculated == received
+      end
+      
+      def self.calculate_crc(data)
+        if data.class == Integer
+          bytes = address_to_bytes(data)
+        else
+          bytes = data
+        end
+
+        crc = 0b00000000
+        bytes.take(bytes.length - 1).each do |byte|
+          for bit in (0..7)
+            xor = byte[bit] ^ crc[0]
+            crc = crc ^ ((xor * (2 ** 3)) | (xor * (2 ** 4)))
+            crc = crc >> 1
+            crc = crc | (xor * (2 ** 7))
+          end
+        end
+        [crc, bytes.last]
+      end
+    end
+  end
+end