denko 0.13.0

data/lib/denko/uart/bit_bang.rb

@@ -0,0 +1,69 @@
+module Denko
+  module UART
+    class UARTRxPin
+      include Behaviors::InputPin
+      include Behaviors::Callbacks
+    end
+
+    class BitBang
+      include Behaviors::MultiPin
+      include Behaviors::Callbacks
+      
+      attr_reader :baud
+
+      def initialize_pins(options={})
+        require_pin(:tx)
+        proxy_pin(:rx, UARTRxPin)
+      end
+
+      def after_initialize(options={})
+        hook_rx_callback
+        initialize_buffer
+        start(options[:baud] || 9600)
+      end
+
+      def initialize_buffer
+        @buffer       = ""
+        @buffer_mutex = Mutex.new
+        self.add_callback(:buffer) do |data|
+          @buffer_mutex.synchronize do
+            @buffer = "#{@buffer}#{data}"
+          end
+        end
+      end
+
+      def gets
+        @buffer_mutex.synchronize do
+          newline = @buffer.index("\n")
+          return nil unless newline
+          line = @buffer[0..newline-1]
+          @buffer = @buffer[newline+1..-1]
+          return line
+        end
+      end
+
+      def flush
+        @buffer_mutex.synchronize do
+          @buffer = ""
+        end
+      end
+
+      def start(baud)
+        @baud = baud
+        board.uart_bb_start(pins[:tx], pins[:rx], @baud)
+      end
+
+      def stop()
+        board.uart_bb_stop
+      end
+
+      def write(data)
+        board.uart_bb_write(data)
+      end
+
+      def hook_rx_callback
+        rx.add_callback {|data| self.update(data)}
+      end
+    end
+  end
+end

data/lib/denko/uart/hardware.rb

@@ -0,0 +1,65 @@
+module Denko
+  module UART
+    class Hardware
+      include Behaviors::SinglePin
+      include Behaviors::Callbacks
+
+      attr_reader :index, :baud
+      
+      def before_initialize(options={})
+        if options[:index] && (options[:index] > 0) && (options[:index] < 4)
+          @index = options[:index]
+        else
+          raise ArgumentError, "UART index (#{options[:index]}) not given or out of range (1..3)"
+        end
+
+        # Set pin to a "virtual pin" in 251 - 253 that will match the board.
+        options[:pin] = 250 + options[:index]
+      end
+
+      def after_initialize(options={})
+        initialize_buffer
+        start(options[:baud] ||= 9600)
+      end
+
+      def initialize_buffer
+        @buffer       = ""
+        @buffer_mutex = Mutex.new
+        self.add_callback(:buffer) do |data|
+          @buffer_mutex.synchronize do
+            @buffer = "#{@buffer}#{data}"
+          end
+        end
+      end
+
+      def gets
+        @buffer_mutex.synchronize do
+          newline = @buffer.index("\n")
+          return nil unless newline
+          line = @buffer[0..newline-1]
+          @buffer = @buffer[newline+1..-1]
+          return line
+        end
+      end
+
+      def flush
+        @buffer_mutex.synchronize do
+          @buffer = ""
+        end
+      end
+
+      def start(baud)
+        @baud = baud
+        board.uart_start(index, baud, true)
+      end
+
+      def stop()
+        board.uart_stop(index)
+      end
+
+      def write(data)
+        board.uart_write(index, data)
+      end
+    end
+  end
+end

data/lib/denko/uart.rb

@@ -0,0 +1,6 @@
+module Denko
+  module UART
+    autoload :Hardware, "#{__dir__}/uart/hardware"
+    autoload :BitBang,  "#{__dir__}/uart/bit_bang"
+  end
+end

data/lib/denko/version.rb

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

data/lib/denko.rb

@@ -0,0 +1,39 @@
+Thread.abort_on_exception = true
+
+module Denko
+  def self.root
+    File.expand_path '../..', __FILE__
+  end
+end
+
+# For method delegation.
+require 'forwardable'
+
+# Component support stuff.
+require_relative 'denko/version'
+require_relative 'denko/behaviors'
+require_relative 'denko/fonts'
+
+# Board stuff.
+require_relative 'denko/message'
+require_relative 'denko/connection'
+require_relative 'denko/board'
+
+# Basic IO components.
+require_relative 'denko/digital_io'
+require_relative 'denko/analog_io'
+require_relative 'denko/pulse_io'
+
+# Buses and interfaces.
+require_relative 'denko/uart'
+require_relative 'denko/spi'
+require_relative 'denko/i2c'
+require_relative 'denko/one_wire'
+
+# Everything else.
+require_relative 'denko/display'
+require_relative 'denko/eeprom'
+require_relative 'denko/led'
+require_relative 'denko/motor'
+require_relative 'denko/rtc'
+require_relative 'denko/sensor'

data/lib/denko_cli/generator.rb

@@ -0,0 +1,171 @@
+class DenkoCLI::Generator
+  require "fileutils"
+  require "denko_cli/packages"
+  require "denko_cli/targets"
+  require "denko/version"
+  
+  require "denko_cli/helper"
+  include DenkoCLI::Helper
+  
+  attr_accessor :options
+
+  def initialize(options={})
+    @options = options
+    append_target
+  end
+
+  def append_target
+    options[:target] = :mega unless options[:target]
+    # Preserve the source sketch name, since we need to copy that file.
+    options[:src_sketch_name] = options[:sketch_name].dup
+    options[:sketch_name] << "_#{options[:target]}" unless options[:target] == :mega
+    options[:sketch_name] << "_#{::Denko::VERSION}"
+  end
+
+  def self.run!(options={})
+    instance = self.new(options)
+
+    instance.read
+    instance.target_config
+    instance.user_config
+    instance.write
+  end
+
+  def read
+    @packages = PACKAGES
+    files_missing = false
+
+    # Replace each filepath with a hash containing the filepath and contents.
+    @packages.each_key do |k|
+      @packages[k][:files].map! do |f|
+        contents = File.read(File.join(options[:src_dir], "lib", f))
+        #
+        # Not using this anymroe. User has to install their own Arduino libraries.
+        #
+        # If the file is in src/vendor, it gets wrapped in an #ifdef
+        # corresponding to the package directive. The entire package can now
+        # be toggled in DenkoDefines.h. Without this, IDE would try to compile anyway.
+        # if f.match /\Avendor/
+        #  directive = @packages[k][:directive]
+        #  contents = "#include \"DenkoDefines.h\"\n#ifdef #{directive}\n" << contents << "\n#endif\n"
+        # end
+        { path: f, contents: contents }
+      rescue
+        files_missing = true
+        puts "File missing: #{f}"
+      end
+    end
+    
+    # Show the text file when vendor files are missing
+    if files_missing
+      missing_files
+    end
+
+    # Read in the sketch itself.
+    @sketch = File.read File.join(options[:src_dir], "#{options[:src_sketch_name]}.ino")
+  end
+
+  def user_config
+    if options[:baud] && serial?
+      @sketch.gsub! "115200", options[:baud]
+    end
+    if options[:mac] && ethernet?
+      octets = @options[:mac].split(':')
+      bytes = octets.map { |o| "0x#{o.upcase}" }
+      @sketch.gsub! "{ 0xDE, 0xAD, 0xBE, 0x30, 0x31, 0x32 }", bytes.inspect.gsub("[", "{").gsub("]", "}").gsub("\"", "")
+    end
+    if options[:ip] && ethernet?
+      @sketch.gsub! "192,168,0,77", options[:ip].gsub(".", ",")
+    end
+    if options[:ssid] && wifi?
+      @sketch.gsub! "yourNetwork", options[:ssid]
+    end
+    if options[:password] && wifi?
+      @sketch.gsub! "yourPassword", options[:password]
+    end
+    if options[:port]
+      @sketch.gsub! "int port = 3466", "int port = #{options[:port]}"
+    end
+    if options[:debug]
+      define("debug")
+    end
+    unless serial?
+      define("TXRX_SPI")
+    end
+  end
+
+  def target_config
+    target_packages = TARGETS[options[:target]]
+    target_packages.each do |t|
+      directive = PACKAGES[t][:directive]
+      define(directive) if directive
+    end
+
+    # Define the DENKO VERSION
+    gsub_defines("#define DENKO_VERSION __VERSION__", "#define DENKO_VERSION \"#{::Denko::VERSION}\"");
+  end
+
+  def define(directive)
+    gsub_defines /\/\/.*#{directive}\s*$/, "#define #{directive}"
+  end
+
+  # Run gsub! on contents of src/lib/Denko.h specifically.
+  def gsub_defines(from, to)
+    @packages[:core][:files].each do |f|
+      if f[:path].match /DenkoDefines.h/
+        f[:contents].gsub!(from, to)
+      end
+    end
+  end
+
+  def write
+    # Write the sketch itself first.
+    sketch = File.join(output_dir, sketch_filename)
+    File.open(sketch, 'w') { |f| f.write @sketch }
+
+    # Go through the @packages hash and copy source files.
+    # Exclude only for target hardware incompatibility.
+    # Eg. ESP8266 IR library is different and incompatible with AVR version.
+    @packages.each_key do |k|
+      # Check if the package should be included for this target.
+      package = @packages[k]
+      targeted = !package[:only] || package[:only].include?(options[:target])
+      excluded = package[:exclude] && package[:exclude].include?(options[:target])
+
+      # Append source file basename to the output dir to get output file path.
+      # Then write the file contents to the destination path.
+      if (targeted && !excluded)
+        package[:files].each do |file|
+          next unless file
+          dest_path = File.join(output_dir, file[:path].split('/')[-1])
+          File.open(dest_path, 'w') { |f| f.write file[:contents] }
+        end
+      end
+    end
+
+    # Return the location of the sketch file.
+    options[:sketch_file] = sketch
+    options[:sketch_folder] = output_dir
+    options
+  end
+
+  def output_dir
+    options[:output_dir] ||= make_output_dir
+  end
+
+  def make_output_dir
+    dir = File.join options[:working_dir], options[:sketch_name]
+    Dir::mkdir(dir) unless File.directory?(dir)
+    dir
+  end
+
+  %w(serial ethernet wifi).each do |sketch|
+    define_method("#{sketch}?") do
+      options[:sketch_name].match /#{sketch}/
+    end
+  end
+
+  def sketch_filename
+    "#{options[:sketch_name]}.ino"
+  end
+end

data/lib/denko_cli/helper.rb

@@ -0,0 +1,29 @@
+module DenkoCLI::Helper
+  def error(message, help=:usage)
+    $stderr.puts
+    $stderr.puts "Error: #{message}"
+    $stderr.puts
+    usage if help == :usage
+    targets if help == :targets
+  end
+
+  def usage
+    text = File.read(File.join(@options[:cli_dir], "usage.txt"))
+    $stderr.print text
+    $stderr.puts
+    exit(2)
+  end
+
+  def targets
+    text = File.read(File.join(@options[:cli_dir], "targets.txt"))
+    $stderr.print text
+    $stderr.puts
+    exit(2)
+  end
+  
+  def missing_files
+    text = File.read(File.join(@options[:cli_dir], "missing_files.txt"))
+    $stderr.print text
+    $stderr.puts
+  end
+end

data/lib/denko_cli/missing_files.txt

@@ -0,0 +1,20 @@
+  
+  If all the missing files are from the vendor directory, you have 2 options:
+
+  1) If you cloned the denko repo with git, please run:
+
+     git submodule update --init --recursive
+
+     Then try generating the sketch again.
+     This command clones the needed repos into denko's src/vendor folder.
+
+  2) If you installed the gem via gem install, you can ignore missing vendor
+    files and install the libraries in your Arduino app instead.
+
+     The libraries used are:
+     
+       IRremote v2.3.2
+       IRremoteESP8266 v2.3.2
+
+     In the Arduino app's library manager, search for them by name. Please
+     install the versions listed here. Newer or older versions may be incompatible.

data/lib/denko_cli/packages.rb

@@ -0,0 +1,101 @@
+class DenkoCLI::Generator
+
+# File locations are defined relative to the src/lib directory. 
+PACKAGES = {
+  # The core package is always included.
+  core: {
+    description: "Core Denko Library",
+    directive: nil,
+    files: [
+      "Denko.h",
+      "DenkoDefines.h",
+      "Denko.cpp",
+      "DenkoCoreIO.cpp",
+      "DenkoPulseInput.cpp",
+      "DenkoEEPROM.cpp",
+      "../../vendor/board-maps/BoardMap.h",
+    ]
+  },
+  one_wire: {
+    description: "OneWire bus support",
+    directive: "DENKO_ONE_WIRE",
+    files: [
+      "DenkoOneWire.cpp",
+    ]
+  },
+  spi_bb: {
+    description: "Bit Bang SPI support",
+    directive: "DENKO_SPI_BB",
+    files: [
+      "DenkoSPI.cpp",
+      "DenkoSPIBB.cpp",
+    ]
+  },
+  spi: {
+    description: "SPI support",
+    directive: "DENKO_SPI",
+    files: [
+      "DenkoSPI.cpp",
+    ]
+  },
+  i2c: {
+    description: "I2C device support",
+    directive: "DENKO_I2C",
+    files: [
+      "DenkoI2C.cpp",
+    ]
+  },
+  uart_bb: {
+    description: "Bit bang serial output",
+    directive: "DENKO_UART_BB",
+    only: [:mega, :mega168],
+    files: [
+      "DenkoUARTBB.cpp",
+    ]
+  },
+  uart: {
+    description: "Hardware UART I/O",
+    directive: "DENKO_UART",
+    files: [
+      "DenkoUART.cpp",
+    ]
+  },
+  servo: {
+    description: "Servo support",
+    directive: "DENKO_SERVO",
+    files: [
+      "DenkoServo.cpp",
+    ]
+  },
+  tone: {
+    description: "Tone support",
+    directive: "DENKO_TONE",
+    files: [
+      "DenkoTone.cpp",
+    ]
+  },
+  ir_out: {
+    description: "Transmit infrared signals",
+    directive: "DENKO_IR_OUT",
+    exclude: [:esp8266, :esp32],
+    files: [
+      "DenkoIROut.cpp",
+    ]
+  },
+  ir_out_esp: {
+    description: "Transmit infrared signals with the ESP8266 and ESP32",
+    directive: "DENKO_IR_OUT",
+    only: [:esp8266, :esp32],
+    files: [
+      "DenkoIROutESP.cpp",
+    ]
+  },
+  led_array: {
+    description: "Support for various protocols that control (RGB) LED arrays.",
+    directive: "DENKO_LED_ARRAY",
+    files: [
+      "DenkoLEDArray.cpp",
+    ]
+  }
+}
+end

data/lib/denko_cli/parser.rb

@@ -0,0 +1,73 @@
+class DenkoCLI::Parser
+  require 'denko_cli/helper'
+  include DenkoCLI::Helper
+
+  def initialize(options={})
+    @options = options
+  end
+
+  def self.run(options={})
+    self.new(options).parse
+  end
+
+  def parse
+    # Ensure we have arguments.
+    args = @options[:args].dup
+    error("No arguments given") if args.empty?
+
+    # Ensure task is the first argument.
+    @options[:task] = args.shift
+
+    # If the task is a help command, just run it, don't return.
+    usage if @options[:task].match /help|usage/
+    targets if @options[:task].match /targets/
+
+    # Ensure there's only one task
+    error "Invalid task '#{@options[:task]}'" unless DenkoCLI::TASKS.include? @options[:task]
+
+    # Parse the rest loosely.
+    loop do
+      case args[0]
+        when 'serial'
+          args.shift; set_sketch("serial")
+        when 'ethernet'
+          args.shift; set_sketch("ethernet")
+        when 'wifi'
+          args.shift; set_sketch("wifi")
+        when '--baud'
+          args.shift; @options[:baud] = args.shift
+        when '--target'
+          args.shift; set_target(args.shift)
+        when '--mac'
+          args.shift; @options[:mac] = args.shift
+        when '--ip'
+          args.shift; @options[:ip] = args.shift
+        when '--ssid'
+          args.shift; @options[:ssid] = args.shift
+        when '--password'
+          args.shift; @options[:password] = args.shift
+        when '--port'
+          args.shift; @options[:port] = args.shift
+        when '--debug'
+          args.shift; @options[:debug] = true
+        when /^-/
+          error "Invalid argument '#{args[0]}'"
+        else break
+      end
+    end
+    error "No valid sketch specified" if @options[:sketch_name].nil?
+
+    @options
+  end
+
+  def set_sketch(name)
+    error "More than one sketch specified" unless @options[:sketch_name].nil?
+    @options[:sketch_name] = "denko_#{name}"
+  end
+
+  def set_target(target)
+    targets = DenkoCLI::Generator::TARGETS.each_key.map{|a| a.to_s}
+    error "Invalid target '#{target}'", :targets unless targets.include?(target)
+    @options[:target] = target.to_sym
+  end
+end

data/lib/denko_cli/targets.rb

@@ -0,0 +1,30 @@
+class DenkoCLI::Generator
+  STANDARD_PACKAGES = PACKAGES.each_key.map do |package|
+                        package unless PACKAGES[package][:only]
+                      end.compact
+
+  TARGETS = {
+    # Core is core.
+    core: [:core],
+
+    # Specific features for the old mega168 chips.
+    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.
+    mega: STANDARD_PACKAGES + [:uart_bb],
+
+    # No tone or IR support on SAM3X / Due.
+    sam3x: STANDARD_PACKAGES - [:tone, :ir_out],
+    
+    # SAMD includes all standard packages.
+    samd: STANDARD_PACKAGES,
+
+    # ESP8266 + ESP32 use a different IR library.
+    esp8266: STANDARD_PACKAGES - [:ir_out] + [:ir_out_esp],
+    esp32:   STANDARD_PACKAGES - [:ir_out] + [:ir_out_esp],
+    
+    # RP2040 can't use WS2812 yet.
+    rp2040: STANDARD_PACKAGES - [:led_array],
+  }
+end