denko 0.13.0 → 0.13.2

data/lib/denko/behaviors/reader.rb

@@ -12,28 +12,29 @@ module Denko
       end
 
       #
-      # Delegate reading to another method that sends a command to the board. 
-      # Accepts blocks as one-time callbacks stored in the :read key.
-      # Blocks until a value is recieved from the board.
-      # Returns the value after #pre_callback_filter runs on it.
+      # Take a proc/lambda/method as the first agrument and use it to read.
+      # Arguments are passed through, allowing dynamic read methods to be defined.
+      # Eg. send commands (in args) to a bus, then wait for data read back.
+      # 
+      # Block given is added as a one-time callback in the :read key, and 
+      # the curent thread waits until data is received. Returns the result of
+      # calling #pre_callback_filter with the data.
       #
-      # Give procs as methods to build more complex functionality for buses.
-      #
-      def read_using(method, *args, **kwargs, &block)
+      def read_using(reader, *args, **kwargs, &block)
         add_callback(:read, &block) if block_given?
 
-        value = nil
+        return_value = nil
         add_callback(:read) do |filtered_data|
-          value = filtered_data
+          return_value = filtered_data
         end
         
-        method.call(*args, **kwargs)
-        block_until_read
+        reader.call(*args, **kwargs)
+        wait_for_read
 
-        value
+        return_value
       end
       
-      def block_until_read
+      def wait_for_read
         loop do
           break if !callbacks[:read]
           sleep 0.001

data/lib/denko/behaviors/single_pin.rb

@@ -11,15 +11,13 @@ module Denko
       
     protected
 
-      attr_writer :pin
-
       def convert_pins(options={})
         raise ArgumentError, 'a pin is required for this component' unless options[:pin]
         options[:pin] = board.convert_pin(options[:pin])
       end
 
       def initialize_pins(options={})
-        self.pin = options[:pin]
+        @pin = options[:pin]
       end
     end
   end

data/lib/denko/behaviors/state.rb

@@ -2,6 +2,7 @@ module Denko
   module Behaviors
     module State
       def initialize(options={})
+        # Component includes State, so no need to call super here.
         @state_mutex = Mutex.new
         @state = nil
       end

data/lib/denko/behaviors/subcomponents.rb

@@ -10,8 +10,6 @@ module Denko
       end
 
       def add_component(component)
-        components << component
-
         if component.respond_to?(:pin) && component.pin.class == Integer
           unless single_pin_components[component.pin]
             single_pin_components[component.pin] = component
@@ -20,6 +18,8 @@ module Denko
                                   "already in use by: #{single_pin_components[component.pin]}"
           end
         end
+
+        components << component
       end
 
       def remove_component(component)

data/lib/denko/board/core.rb

@@ -119,7 +119,7 @@ module Denko
     # CMD = 95
     def set_register_divider(value)
       unless DIVIDERS.include?(value)
-        raise ArgumentError, "error in divider: #{options[:divider]}. Should be one of: #{DIVIDERS.inspect}"
+        raise ArgumentError, "error in divider: #{value}. Should be one of: #{DIVIDERS.inspect}"
       end
       write Message.encode(command: 95, value: value)
     end

data/lib/denko/board/i2c.rb

@@ -7,10 +7,7 @@ module Denko
       3400000 => 0x03,
     }
 
-    # Might make this bigger based on board maps later, but stick with the lowest limit of the AVR boards for now.
-    def i2c_limit
-      32
-    end
+    attr_reader :i2c_limit
 
     def i2c_convert_frequency(freq)
       # Default to 100 kHz.

data/lib/denko/board/map.rb

@@ -6,10 +6,19 @@ module Denko
 
     attr_reader :map
     
+    def substitute_zero_pins
+      ["SDA", "SCL", "MOSI", "MISO", "SCK", "SS"].each do |name|
+        symbol      = name.to_sym
+        zero_symbol = (name + "0").to_sym
+        @map[symbol] = @map[zero_symbol] if (@map[zero_symbol] && !@map[symbol])
+      end
+    end
+
     def load_map(board_name)
       if board_name
         map_path = File.join(MAPS_FOLDER, "#{board_name}.yml")
         @map = YAML.load_file(map_path)
+        substitute_zero_pins
       else
         @map = nil
       end

data/lib/denko/board/servo.rb

@@ -1,15 +1,11 @@
 module Denko
   class Board
     # CMD = 10
-    def servo_toggle(pin, value=:off, options={})
-      options[:min] ||= 544
-      options[:max] ||= 2400
-      aux = pack :uint16, [options[:min], options[:max]]
-
+    def servo_toggle(pin, value=:off, min: 544, max: 2400)
       write Message.encode  command: 10,
                             pin: pin,
                             value: (value == :off) ? 0 : 1,
-                            aux_message: aux
+                            aux_message: pack(:uint16, [min, max])
     end
 
     # CMD = 11

data/lib/denko/board.rb

@@ -1,42 +1,54 @@
 # Require all files in board folder relative to this file.
-Dir["#{Denko.root}/lib/denko/board/*.rb"].each {|file| require file }
+Dir["#{Denko.root}/lib/denko/board/*.rb"].each { |file| require file }
 
 module Denko
   class Board
-    attr_reader :board_name, :version, :aux_limit, :eeprom_length
+    attr_reader :name, :version, :serial_buffer_size, :aux_limit, :eeprom_length
     attr_reader :low, :high, :analog_write_high, :analog_read_high
 
-    def initialize(io, options={})
-      # Connect the IO, and get the ACK.
-      @io = io
-      ack = io.handshake
-      @name, @version, @aux_limit, @eeprom_length = ack.split(",")
+    def initialize(transport, options={})
+      # Shake hands
+      @transport = transport
+      ack = transport.handshake
 
-      # Parse map, version and eeprom_legnth.
-      @name          = nil if @name.empty?
-      @version       = nil if @version.empty?
-      @eeprom_length = @eeprom_length.to_i
+      # Split handshake acknowledgement into separate values.
+      @name, @version, @serial_buffer_size, @aux_limit, @eeprom_length, @i2c_limit = ack.split(",")
+
+      # Tell transport how much serial buffer the board has, for flow control.
+      @serial_buffer_size = @serial_buffer_size.to_i
+      raise StandardError, "no serial buffer size given in handshake" if @serial_buffer_size < 1
+      @transport.remote_buffer_size = @serial_buffer_size
+
+      # Load board map by name.
+      @name = nil if @name.empty?
+      load_map(@name)
 
       # Leave room for null termination of aux messages.
       @aux_limit = @aux_limit.to_i - 1
 
-      # Load the board map.
-      @map = load_map(@name)
+      # Set I2C transaction size limit. Safe minimum is 32.
+      # This makes I2C fail silently if board does not implement.
+      @i2c_limit = @i2c_limit.to_i
+      @i2c_limit = 32 if @i2c_limit == 0
+
+      # Remaining settings
+      @version       = nil if @version.empty?
+      @eeprom_length = @eeprom_length.to_i
 
-      # Allow the IO to call #update on the board when messages received.
-      io.add_observer(self)
+      # Transport calls #update on board when data is received.
+      transport.add_observer(self)
       
       # Set digital and analog IO levels.
       @low  = 0
       @high = 1
       self.analog_write_resolution = options[:write_bits] || 8
-      self.analog_read_resolution = options[:read_bits] || 10
+      self.analog_read_resolution  = options[:read_bits]  || 10
     end
     
     def finish_write
-      sleep 0.001 while @io.writing?
+      sleep 0.001 while @transport.writing?
       write "\n91\n"
-      sleep 0.001 while @io.writing?
+      sleep 0.001 while @transport.writing?
     end
           
     def analog_write_resolution=(value)
@@ -64,7 +76,7 @@ module Denko
     alias :adc_high :analog_read_high
     
     def write(msg)
-      @io.write(msg)
+      @transport.write(msg)
     end
 
     #
@@ -78,7 +90,7 @@ module Denko
     # signal is read by the TxRx, telling it to resume transmisison.
     #
     def write_and_halt(msg)
-      @io.write(msg, true)
+      @transport.write(msg, true)
     end
 
     #

data/lib/denko/connection/board_uart.rb

@@ -1,11 +1,11 @@
 module Denko
   module Connection
     class BoardUART < Base
-      BAUD = 115200
+      DEFAULT_BAUD = 115200
 
-      def initialize(uart, options={})
+      def initialize(uart, baud: DEFAULT_BAUD)
         @uart = uart
-        @uart.start(options[:baud] || BAUD)
+        @uart.start(baud)
       end
 
       def baud

data/lib/denko/connection/flow_control.rb

@@ -1,11 +1,19 @@
 module Denko
   module Connection
     module FlowControl
-      BOARD_BUFFER = 63
       SLEEP_TIME = 0.001
 
+      # Let Board object tell us the remote buffer size after parsing handshake.
+      def remote_buffer_size=(size)
+        @transit_mutex.synchronize { @remote_buffer_size = size }
+      end
+
       def initialize(*args)
         super(*args)
+        # Start with minimum known buffer size. Board will update after handshake.
+        # WARNING: If not updated, and ack threshold on the board is > minimum,
+        # FlowControl will stop sending data, and appear to hang. Fix this.
+        @remote_buffer_size = 63
         reset_flow_control
         tx_resume
       end
@@ -93,7 +101,7 @@ module Denko
       # Keep transit mutex as short as possible, by only reserving bytes, and writing outside.
       def reserve_bytes(length)
         @transit_mutex.synchronize do
-          available = BOARD_BUFFER - @transit_bytes
+          available = @remote_buffer_size - @transit_bytes
           reserved = (length > available) ? available : length
           @transit_bytes += reserved
           reserved

data/lib/denko/digital_io/output.rb

@@ -16,7 +16,7 @@ module Denko
       end
 
       def digital_write(value)
-        board.digital_write(pin, value)
+        @board.digital_write(@pin, value)
         self.state = value
       end
       

data/lib/denko/display/hd44780.rb

@@ -63,7 +63,7 @@ module Denko
       end
 
       def after_initialize(options={})
-        super(options) if defined?(super)
+        super(options)
         
         # Default to 16x2 display if no options given.
         @columns = options[:columns] || 16
@@ -212,7 +212,7 @@ module Denko
         send(byte, board.low)
       end
       
-      def write(byte);
+      def write(byte)
         send(byte, board.high)
       end
 
@@ -229,27 +229,27 @@ module Denko
       end
       
       def write4(bits)
-        d4.write bits[4]
-        d5.write bits[5]
-        d6.write bits[6]
-        d7.write bits[7]
+        d4.write bits[4].to_i
+        d5.write bits[5].to_i
+        d6.write bits[6].to_i
+        d7.write bits[7].to_i
         pulse_enable
-        d4.write bits[0]
-        d5.write bits[1]
-        d6.write bits[2]
-        d7.write bits[3]
+        d4.write bits[0].to_i
+        d5.write bits[1].to_i
+        d6.write bits[2].to_i
+        d7.write bits[3].to_i
         pulse_enable
       end
 
       def write8(bits)
-        d0.write bits[0]
-        d1.write bits[1]
-        d2.write bits[2]
-        d3.write bits[3]
-        d4.write bits[4]
-        d5.write bits[5]
-        d6.write bits[6]
-        d7.write bits[7]
+        d0.write bits[0].to_i
+        d1.write bits[1].to_i
+        d2.write bits[2].to_i
+        d3.write bits[3].to_i
+        d4.write bits[4].to_i
+        d5.write bits[5].to_i
+        d6.write bits[6].to_i
+        d7.write bits[7].to_i
         pulse_enable
       end
 

data/lib/denko/led/seven_segment.rb

@@ -3,6 +3,9 @@ module Denko
     class SevenSegment
       include Behaviors::MultiPin
       
+      ALL_OFF = [0,0,0,0,0,0,0]
+      BLANK = " "
+
       def initialize_pins(options={})
         [:a, :b, :c, :d, :e, :f, :g].each do |symbol|
           proxy_pin(symbol, DigitalIO::Output)
@@ -20,28 +23,30 @@ module Denko
       attr_reader :segments
 
       def clear
-        segments.each do |pin|
-          pin.low if cathode
-          pin.high if anode
-        end
+        write(BLANK)
       end
 
-      def display(char)
-        char = char.to_s
-        return scroll(char) if char.length > 1
-        off; write(char); on
+      def display(string)
+        on unless on?
+        string = string.to_s.upcase
+        (string.length > 1) ? scroll(string) : write(string)
       end
 
       def on
         anode.high if anode
         cathode.low if cathode
+        @on = true
       end
 
       def off
         anode.low if anode
         cathode.high if cathode
+        @on = false
       end
 
+      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],
@@ -87,22 +92,16 @@ module Denko
       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
+        bits = CHARACTERS[char] || ALL_OFF
+        bits.each_with_index do |bit, index|
+          bit = 1^bit if anode
+          segments[index].write(bit) unless (segments[index].state == bit)
         end
       end
 
       def scroll(string)
         string.chars.each do |char|
-          display(char)
+          write(char)
           sleep(0.5)
         end
       end

data/lib/denko/message.rb

@@ -57,7 +57,7 @@ module Denko
       message = "#{command}#{message}\n"
     end
 
-    def self.pack(type, data, options={})
+    def self.pack(type, data, min: nil, max: nil)
       # Always pack as little endian.
       template =  case type
                   when :uint64  then 'Q<*'
@@ -70,20 +70,12 @@ module Denko
       # 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]})"
+      # Enforce min and max.
+      if min && str.length < min
+        raise ArgumentError, "too few bytes given (expected at least #{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]})"
+      if max && str.length > max
+        raise ArgumentError, "too many bytes given (expected at most #{max})"
       end
 
       str

data/lib/denko/one_wire/bus.rb

@@ -4,7 +4,7 @@ module Denko
       include Behaviors::SinglePin
       include Behaviors::BusControllerAddressed
       include Behaviors::Reader
-      include BusEnumeration
+      include BusEnumerator
       include Constants
 
       attr_reader :parasite_power

data/lib/denko/one_wire/{bus_enumeration.rb → bus_enumerator.rb}

@@ -1,6 +1,8 @@
 module Denko
   module OneWire
-    module BusEnumeration
+    module BusEnumerator
+      include Constants
+
       def _search(branch_mask)
         reset
         write(SEARCH_ROM)
@@ -42,12 +44,12 @@ module Denko
       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
 
+        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
 
@@ -73,12 +75,18 @@ module Denko
         [address, complement]
       end
 
-      # Set FAMILY_CODE in peripheral class to get it identified during search.
+      # 
+      # Set FAMILY_CODE in peripheral class, and add the class to this array
+      # for the class to be identified during search.
+      #
+      PERIPHERAL_CLASSES = [
+        Sensor::DS18B20,
+      ]
+
       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
+        PERIPHERAL_CLASSES.each do |klass|
+          if (klass.const_defined? "FAMILY_CODE")
+            return klass if klass::FAMILY_CODE == family_code
           end
         end
         return nil

data/lib/denko/one_wire/helper.rb

@@ -5,7 +5,7 @@ module Denko
         [address].pack('Q<').split("").map(&:ord)
       end
 
-      def self.crc_check(data)
+      def self.crc(data)
         calculated, received = self.calculate_crc(data)
         calculated == received
       end

data/lib/denko/one_wire.rb

@@ -2,7 +2,7 @@ module Denko
   module OneWire
     autoload :Constants,      "#{__dir__}/one_wire/constants"
     autoload :Helper,         "#{__dir__}/one_wire/helper"
-    autoload :BusEnumeration, "#{__dir__}/one_wire/bus_enumeration"
+    autoload :BusEnumerator,  "#{__dir__}/one_wire/bus_enumerator"
     autoload :Bus,            "#{__dir__}/one_wire/bus"
     autoload :Peripheral,     "#{__dir__}/one_wire/peripheral"
   end

data/lib/denko/pulse_io/ir_transmitter.rb

@@ -3,7 +3,7 @@ module Denko
     class IRTransmitter
       include Behaviors::OutputPin
 
-      def emit(pulses=[], options={})
+      def emit(pulses=[], frequency: 38)
         if pulses.length > 256 || pulses.length < 1
           raise ArgumentError, 'wrong number of IR pulses (expected 1 to 256)'
         end
@@ -14,7 +14,6 @@ module Denko
           raise ArgumentError, 'pulse too long (max 65535 ms)' if pulse > 65535
         end
 
-        frequency = options[:frequency] || 38
         board.infrared_emit(pin, frequency, pulses)
       end
     end

data/lib/denko/sensor/ds18b20.rb

@@ -47,7 +47,7 @@ module Denko
       end
 
       def pre_callback_filter(bytes)
-        return { crc_error: true } unless Helper.crc_check(bytes)
+        return { crc_error: true } unless OneWire::Helper.crc(bytes)
         @resolution = decode_resolution(bytes)
 
         decode_temperature(bytes).merge(raw: bytes)

data/lib/denko/version.rb

@@ -1,3 +1,3 @@
 module Denko
-  VERSION = "0.13.0"
+  VERSION = "0.13.2"
 end

data/lib/denko_cli/packages.rb

@@ -12,10 +12,16 @@ PACKAGES = {
       "Denko.cpp",
       "DenkoCoreIO.cpp",
       "DenkoPulseInput.cpp",
-      "DenkoEEPROM.cpp",
       "../../vendor/board-maps/BoardMap.h",
     ]
   },
+  eeprom: {
+    description: "Built-in EEPROM support",
+    directive: "DENKO_EEPROM",
+    files: [
+      "DenkoEEPROM.cpp",
+    ]
+  },
   one_wire: {
     description: "OneWire bus support",
     directive: "DENKO_ONE_WIRE",

data/lib/denko_cli/targets.rb

@@ -11,14 +11,17 @@ class DenkoCLI::Generator
     mega168: [:core, :one_wire, :tone, :i2c, :spi, :servo],
 
     # Other ATmega chips do everything.
-    # Add bit bang serial for 328p / UNO since ith as no extra hardware UART.
+    # Add bit bang serial for 328p / UNO since it has no extra hardware UART.
     mega: STANDARD_PACKAGES + [:uart_bb],
 
-    # No tone or IR support on SAM3X / Due.
-    sam3x: STANDARD_PACKAGES - [:tone, :ir_out],
+    # No tone, infrared or EEPROM on SAM3X / Due.
+    sam3x: STANDARD_PACKAGES - [:tone, :ir_out, :eeprom],
     
-    # SAMD includes all standard packages.
-    samd: STANDARD_PACKAGES,
+    # No EEPROM on SAMD / Zero.
+    samd: STANDARD_PACKAGES - [:eeprom],
+
+    # No IR out and WS2812 on the UNO R4. WS2812 compiles but doesn't work.
+    ra4m1: STANDARD_PACKAGES - [:ir_out, :led_array],
 
     # ESP8266 + ESP32 use a different IR library.
     esp8266: STANDARD_PACKAGES - [:ir_out] + [:ir_out_esp],