smalrubot 0.0.1

data/lib/smalrubot/board_not_found.rb

@@ -0,0 +1,3 @@
+module Smalrubot
+  class BoardNotFound < Exception; end
+end

data/lib/smalrubot/components.rb

@@ -0,0 +1,9 @@
+module Smalrubot
+  module Components
+    require 'smalrubot/components/base_component'
+    autoload :Led,        'smalrubot/components/led'
+    autoload :Button,     'smalrubot/components/button'
+    autoload :Sensor,     'smalrubot/components/sensor'
+    autoload :Servo,      'smalrubot/components/servo'
+  end
+end

data/lib/smalrubot/components/base_component.rb

@@ -0,0 +1,44 @@
+module Smalrubot
+  module Components
+    class BaseComponent
+      attr_reader :board, :pin, :pullup
+      alias :pins :pin
+
+      def initialize(options={})
+        self.board = options[:board]
+        self.pin = options[:pin] || options[:pins]
+        self.pullup = options[:pullup]
+
+        raise 'board and pin or pins are required for a component' if self.board.nil? || self.pin.nil?
+        after_initialize(options)
+      end
+
+      #
+      # As BaseComponent does a lot of work for you with regarding to setting up, it is
+      # best not to override #initialize and instead define an #after_initialize method
+      # within your subclass.
+      #
+      # @note This method should be implemented in the BaseComponent subclass.
+      #
+      def after_initialize(options={}) ; end
+
+      protected
+
+      attr_writer :board, :pin, :pullup
+      alias :pins= :pin=
+
+      def digital_write(pin=self.pin, value)
+        self.board.digital_write(pin, value)
+      end
+
+      def analog_write(pin=self.pin, value)
+        self.board.analog_write(pin, value)
+      end
+
+      def set_pin_mode(pin=self.pin, mode)
+        self.board.set_pin_mode(pin, mode, pullup)
+      end
+    end
+  end
+end
+

data/lib/smalrubot/components/led.rb

@@ -0,0 +1,18 @@
+module Smalrubot
+  module Components
+    class Led < BaseComponent
+      def after_initialize(options={})
+        set_pin_mode(:out)
+        off
+      end
+
+      def on
+        digital_write(Board::HIGH)
+      end
+
+      def off
+        digital_write(Board::LOW)
+      end
+    end
+  end
+end

data/lib/smalrubot/components/servo.rb

@@ -0,0 +1,21 @@
+module Smalrubot
+  module Components
+    class Servo < BaseComponent
+      attr_reader :position
+
+      def after_initialize(options={})
+        set_pin_mode(:out)
+        board.servo_toggle(pin, 1)
+        self.position = options[:position] || 0
+      end
+
+      def position=(value)
+        board.servo_write(pin, @position = angle(value))
+      end
+
+      def angle(value)
+        value == 180 ? value : value % 180
+      end
+    end
+  end
+end

data/lib/smalrubot/tx_rx.rb

@@ -0,0 +1,10 @@
+module Smalrubot
+  module TxRx
+    require 'smalrubot/tx_rx/base'
+    require 'smalrubot/tx_rx/serial'
+
+    def self.new(options={})
+      self::Serial.new(options)
+    end
+  end
+end

data/lib/smalrubot/tx_rx/base.rb

@@ -0,0 +1,54 @@
+require 'observer'
+require 'timeout'
+
+module Smalrubot
+  module TxRx
+    class Base
+      def read(timeout = 0.005)
+        line = gets(timeout)
+        if line && line.match(/\A\d+:/)
+          pin, message = line.chomp.split(/:/)
+          if pin && message
+            return pin, message
+          end
+        end
+      end
+
+      def write(message)
+        n = io.write(message)
+        Smalrubot.debug_log('write: %s(A:%d, E:%d)', message, n, message.length)
+        if n != message.length
+          raise "FATAL: n(#{n}) != message.length(#{message.length})"
+        end
+      end
+
+      def handshake
+        5.times do
+          write("!9000000.")
+          line = gets(1)
+          if line && line.match(/ACK:/)
+            flush_read
+            return line.chomp.split(/:/)[1].to_i
+          end
+        end
+      raise BoardNotFound
+      end
+
+      def flush_read
+        gets until gets == nil
+      end
+
+      RETURN_CODE = "\n".ord
+
+      def gets(timeout=0.005)
+        Timeout.timeout(timeout) do
+          s = io.gets
+          Smalrubot.debug_log("gets: %s", s)
+          return s
+        end
+      rescue Exception
+        nil
+      end
+    end
+  end
+end

data/lib/smalrubot/tx_rx/serial.rb

@@ -0,0 +1,70 @@
+require 'rubyserial'
+
+module Smalrubot
+  module TxRx
+    class Serial < Base
+      BAUD = 115200
+
+      def initialize(options={})
+        @device = options[:device]
+        @baud = options[:baud] || BAUD
+        @first_write = true
+      end
+
+      def io
+        @io ||= connect
+      end
+
+      def handshake
+        while tty_devices.length > 0
+          begin
+            if on_windows?
+              io; sleep 3
+            end
+
+            return super
+          rescue BoardNotFound
+            @tty_devices.shift
+            @io.close
+            @io = nil
+          end
+        end
+      end
+
+      private
+
+      def connect
+        tty_devices.dup.each do |device|
+          begin
+            serial = ::Serial.new(device, @baud)
+            Smalrubot.debug_log('found board: %s (%d)', device, @baud)
+            return serial
+          rescue Exception
+            @tty_devices.shift
+            Smalrubot.debug_log('could not access: %s', device)
+            Smalrubot.show_backtrace($!)
+          end
+        end
+        raise BoardNotFound
+      end
+
+      def tty_devices
+        if !@tty_devices
+          if @device
+            @tty_devices = [@device]
+          elsif on_windows?
+            @tty_devices = (1..256).map { |n| "COM#{n}" }
+          else
+            @tty_devices =
+              `ls /dev`.split("\n").grep(/usb|ACM/i).map{ |d| "/dev/#{d}" }
+          end
+        end
+        @tty_devices
+      end
+
+      def on_windows?
+        RUBY_PLATFORM.match /mswin|mingw/i
+      end
+    end
+  end
+end

data/lib/smalrubot/version.rb

@@ -0,0 +1,3 @@
+module Smalrubot
+  VERSION = "0.0.1"
+end

data/sketch/lib/Smalrubot.cpp

@@ -0,0 +1,158 @@
+/*
+  Library for smalrubot ruby gem.
+*/
+
+#include "Arduino.h"
+#include "Smalrubot.h"
+
+Smalrubot::Smalrubot(){
+  reset();
+}
+
+void Smalrubot::parse(char c) {
+  if (c == '!') index = 0;        // Reset request
+  else if (c == '.') process();   // End request and process
+  else request[index++] = c;      // Append to request
+}
+
+void Smalrubot::process() {
+  response[0] = '\0';
+
+  // Parse the request.
+  strncpy(cmdStr, request, 2);      cmdStr[2] =  '\0';
+  strncpy(pinStr, request + 2, 2);  pinStr[2] =  '\0';
+  strncpy(valStr, request + 4, 3);  valStr[3] =  '\0';
+  cmd = atoi(cmdStr);
+  pin = atoi(pinStr);
+  val = atoi(valStr);
+
+  #ifdef debug
+   Serial.print("Received request - "); Serial.println(request);
+   Serial.print("Command - ");          Serial.println(cmdStr);
+   Serial.print("Pin - ");              Serial.println(pinStr);
+   Serial.print("Value - ");            Serial.println(valStr);
+  #endif
+
+  // Call the command.
+  switch(cmd) {
+    case 0:  setMode             ();  break;
+    case 1:  dWrite              ();  break;
+    case 2:  dRead               ();  break;
+    case 3:  aWrite              ();  break;
+    case 4:  aRead               ();  break;
+    case 8:  servoToggle         ();  break;
+    case 9:  servoWrite          ();  break;
+    case 90: reset               ();  break;
+    default:                          break;
+  }
+  
+  // Write the response.
+  if (response[0] != '\0') writeResponse();
+  
+  #ifdef debug
+   Serial.print("Responded with - "); Serial.println(response);
+   Serial.println();
+  #endif
+}
+
+
+
+// WRITE CALLBACK
+void Smalrubot::setupWrite(void (*writeCallback)(char *str)) {
+  _writeCallback = writeCallback;
+}
+void Smalrubot::writeResponse() {
+  _writeCallback(response);
+}
+
+
+
+
+
+
+// API FUNCTIONS
+// CMD = 00 // Pin Mode
+void Smalrubot::setMode() {
+  if (val == 0) {
+    pinMode(pin, OUTPUT);
+    #ifdef debug
+      Serial.print("Set pin "); Serial.print(pin); Serial.print(" to "); Serial.println("OUTPUT mode");
+    #endif
+  }
+  else {
+    pinMode(pin, INPUT);
+    #ifdef debug
+      Serial.print("Set pin "); Serial.print(pin); Serial.print(" to "); Serial.println("INPTUT mode");
+    #endif
+  }
+}
+
+// CMD = 01 // Digital Write
+void Smalrubot::dWrite() {
+  if (val == 0) {
+    digitalWrite(pin, LOW);
+    #ifdef debug
+      Serial.print("Digital write "); Serial.print(LOW); Serial.print(" to pin "); Serial.println(pin);
+    #endif
+  }
+  else {
+    digitalWrite(pin, HIGH);
+    #ifdef debug
+      Serial.print("Digital write "); Serial.print(HIGH); Serial.print(" to pin "); Serial.println(pin);
+    #endif
+  }
+}
+
+// CMD = 02 // Digital Read
+void Smalrubot::dRead() {
+  rval = digitalRead(pin);
+  sprintf(response, "%02d:%02d", pin, rval);
+}
+
+// CMD = 03 // Analog (PWM) Write
+void Smalrubot::aWrite() {
+  analogWrite(pin,val);
+  #ifdef debug
+    Serial.print("Analog write "); Serial.print(val); Serial.print(" to pin "); Serial.println(pin);
+  #endif
+}
+
+// CMD = 04 // Analog Read
+void Smalrubot::aRead() {
+  rval = analogRead(pin);
+  sprintf(response, "%02d:%02d", pin, rval);
+}
+
+// CMD = 08
+// Attach the servo object to pin or detach it.
+void Smalrubot::servoToggle() {
+  if (val == 0) {
+    #ifdef debug
+      Serial.print("Detaching servo"); Serial.print(" on pin "); Serial.println(pin);
+    #endif
+    servos[pin - SERVO_OFFSET].detach();
+  }
+  else {
+    #ifdef debug
+      Serial.print("Attaching servo"); Serial.print(" on pin "); Serial.println(pin);
+    #endif
+    servos[pin - SERVO_OFFSET].attach(pin);
+  }
+}
+
+// CMD = 09
+// Write a value to the servo object.
+void Smalrubot::servoWrite() {
+  #ifdef debug
+    Serial.print("Servo write "); Serial.print(val); Serial.print(" to pin "); Serial.println(pin);
+  #endif
+  servos[pin - SERVO_OFFSET].write(val);
+}
+
+// CMD = 90
+void Smalrubot::reset() {
+  #ifdef debug
+    Serial.println("Reset the board to defaults.");
+  #endif
+  sprintf(response, "ACK:%02d", A0);
+}

data/sketch/lib/Smalrubot.h

@@ -0,0 +1,60 @@
+/*
+  Library for smalrubot ruby gem.
+*/
+
+#ifndef Smalrubot_h
+#define Smalrubot_h
+
+#include "Arduino.h"
+#include <Servo.h>
+
+// Allocate listener storage based on what board we're running.
+#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
+#  define PIN_COUNT 70
+#  define SERVO_OFFSET 22
+#else
+#  define PIN_COUNT 22
+#  define SERVO_OFFSET 2
+#endif
+
+// Uncomment this line to enable debugging mode.
+// #define debug true
+
+class Smalrubot {
+  public:
+    Smalrubot();
+    void setupWrite(void (*writeCallback)(char *str));
+    void parse(char c);
+    void process();
+
+  private:
+    // Request storage.
+    char request[8];
+    int index;
+    char cmdStr[3];
+    byte cmd;
+    char pinStr[3];
+    byte pin;
+    char valStr[4];
+    int val;
+
+    // Value and response storage.
+    int rval;
+    char response[8];
+    void (*_writeCallback)(char *str);
+    void writeResponse();
+
+    Servo servos[12];
+
+    // API-accessible functions.
+    void setMode               ();
+    void dWrite                ();
+    void dRead                 ();
+    void aWrite                ();
+    void aRead                 ();
+    void servoToggle           ();
+    void servoWrite            ();
+    void reset                 ();
+};
+
+#endif