dino 0.10.0 → 0.11.2

data/spec/lib/components/led_spec.rb

@@ -19,7 +19,7 @@ module Dino
         end
 
         it 'should set the pin to out' do
-          board.should_receive(:set_pin_mode).with(13, :out)
+          board.should_receive(:set_pin_mode).with(13, :out, nil)
           Led.new(pin: 13, board: board)
         end
 

data/spec/lib/components/rgb_led_spec.rb

@@ -5,7 +5,7 @@ module Dino
     describe RgbLed do
       let(:board) { mock(:board, analog_write: true, set_pin_mode: true) }
       let(:pins) { {red: 1, green: 2, blue: 3} }
-      let!(:rgb) {RgbLed.new(pins: pins, board: board)}
+      let(:rgb) { RgbLed.new(pins: pins, board: board)}
 
       describe '#initialize' do
         it 'should raise if it does not receive a pin' do
@@ -21,9 +21,9 @@ module Dino
         end
 
         it 'should set the pin to out' do
-          board.should_receive(:set_pin_mode).with(1, :out)
-          board.should_receive(:set_pin_mode).with(2, :out)
-          board.should_receive(:set_pin_mode).with(3, :out)
+          board.should_receive(:set_pin_mode).with(1, :out, nil)
+          board.should_receive(:set_pin_mode).with(2, :out, nil)
+          board.should_receive(:set_pin_mode).with(3, :out, nil)
 
           RgbLed.new(pins: pins, board: board)
         end
@@ -64,6 +64,51 @@ module Dino
         end
       end
 
+      describe '#cyan' do
+        it 'should set blue and green to high, red to low' do
+          board.should_receive(:analog_write).with(1, Board::LOW)
+          board.should_receive(:analog_write).with(2, Board::HIGH)
+          board.should_receive(:analog_write).with(3, Board::HIGH)
+          rgb.cyan
+        end
+      end
+
+      describe '#yellow' do
+        it 'should set red and green to high, blue to low' do
+          board.should_receive(:analog_write).with(1, Board::HIGH)
+          board.should_receive(:analog_write).with(2, Board::HIGH)
+          board.should_receive(:analog_write).with(3, Board::LOW)
+          rgb.yellow
+        end
+      end
+
+      describe '#magenta' do
+        it 'should set red and blue to high, green to low' do
+          board.should_receive(:analog_write).with(1, Board::HIGH)
+          board.should_receive(:analog_write).with(2, Board::LOW)
+          board.should_receive(:analog_write).with(3, Board::HIGH)
+          rgb.magenta
+        end
+      end
+
+      describe '#white' do
+        it 'should set all to high' do
+          board.should_receive(:analog_write).with(1, Board::HIGH)
+          board.should_receive(:analog_write).with(2, Board::HIGH)
+          board.should_receive(:analog_write).with(3, Board::HIGH)
+          rgb.white
+        end
+      end
+
+      describe '#off' do
+        it 'should set all to low' do
+          board.should_receive(:analog_write).with(1, Board::LOW)
+          board.should_receive(:analog_write).with(2, Board::LOW)
+          board.should_receive(:analog_write).with(3, Board::LOW)
+          rgb.off
+        end
+      end
+
       describe '#blinky' do
         it 'should set blue to high, red and green to low' do
           Array.any_instance.should_receive(:cycle).and_yield(:red).and_yield(:green).and_yield(:blue)

data/spec/lib/components/sensor_spec.rb

@@ -32,25 +32,29 @@ module Dino
       end
 
       describe '#when_data_received' do
-        it 'should add a callback back to the list of callbacks' do
+        
+        it "should add a callback to the list of callbacks" do
           sensor = Sensor.new(board: board, pin: 'a pin')
-          sensor.when_data_received 'Foo'
-          sensor.instance_variable_get(:@data_callbacks).should == ['Foo']
+          sensor.when_data_received { "this is a block" }
+          sensor.instance_variable_get(:@data_callbacks).should_not be_empty
         end
       end
 
       describe '#update' do
         it 'should call all callbacks passing in the given data' do
-          first_callback, second_callback = mock, mock
-          first_callback.should_receive(:call).with('Some data')
-          second_callback.should_receive(:call).with('Some data')
-
           sensor = Sensor.new(board: board, pin: 'a pin')
-
-          sensor.when_data_received first_callback
-          sensor.when_data_received second_callback
+          
+          first_block_data = nil
+          second_block_data = nil
+          sensor.when_data_received do |data|
+            first_block_data = data
+          end
+          sensor.when_data_received do |data|
+            second_block_data = data
+          end
 
           sensor.update('Some data')
+          [first_block_data, second_block_data].each { |block_data| block_data.should == "Some data" }
         end
       end
     end

data/spec/lib/components/servo_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 module Dino
   module Components
     describe Servo do
-      let(:board) { mock(:board, analog_write: true, set_pin_mode: true) }
+      let(:board) { mock(:board, analog_write: true, set_pin_mode: true, servo_toggle: true, servo_write: true) }
 
       describe '#initialize' do
         it 'should raise if it does not receive a pin' do
@@ -19,7 +19,7 @@ module Dino
         end
 
         it 'should set the pins to out' do
-          board.should_receive(:set_pin_mode).with(13, :out)
+          board.should_receive(:set_pin_mode).with(13, :out, nil)
           Servo.new(pin: 13, board: board)
         end
 
@@ -37,13 +37,18 @@ module Dino
           servo.instance_variable_get(:@position).should == 90
         end
 
-        it 'should modulate the position at 180' do
+        it 'should let you write up to 180' do
+          servo.position = 180
+          servo.instance_variable_get(:@position).should == 180
+        end
+
+        it 'should modulate when position > 180' do
           servo.position = 190
           servo.instance_variable_get(:@position).should == 10
         end
 
         it 'should write the new position to the board' do
-          servo.should_receive(:analog_write).with(10)
+          board.should_receive(:servo_write).with(13, 10)
           servo.position = 190
         end
       end

data/spec/lib/components/stepper_spec.rb

@@ -25,8 +25,8 @@ module Dino
         end
 
         it 'should set the pins to out' do
-          board.should_receive(:set_pin_mode).with(13, :out)
-          board.should_receive(:set_pin_mode).with(12, :out)
+          board.should_receive(:set_pin_mode).with(13, :out, nil)
+          board.should_receive(:set_pin_mode).with(12, :out, nil)
           Stepper.new(pins: {step: 13, direction: 12}, board: board)
         end
 

data/spec/lib/tx_rx/serial_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+module Dino
+  describe TxRx::Serial do
+    it { should be }
+
+    describe '#initialize' do
+      it 'should set first_write to true' do
+        TxRx::Serial.new.instance_variable_get(:@first_write).should == true
+      end
+
+      it 'should set the device and buad if specified' do
+        txrx = TxRx::Serial.new({device: "/dev/ttyACM0", baud: 9600})
+        txrx.instance_variable_get(:@baud).should == 9600
+        txrx.instance_variable_get(:@device).should == "/dev/ttyACM0"
+      end
+    end
+
+    describe '#io' do
+      context "on windows" do
+        it 'should instantiate a new SerialPort for the first available tty device' do
+          original_platform = RUBY_PLATFORM
+          Constants.redefine(:RUBY_PLATFORM, "mswin", :on => Object)
+          subject.should_receive(:tty_devices).and_return(["COM1", "COM2", "COM3"])
+
+          # COM2 is chosen as available for this test.
+          SerialPort.should_receive(:new).with("COM1", TxRx::Serial::BAUD).and_raise
+          SerialPort.should_receive(:new).with("COM2", TxRx::Serial::BAUD).and_return(mock_serial = mock)
+          SerialPort.should_not_receive(:new).with("COM3", TxRx::Serial::BAUD)
+
+          subject.io.should == mock_serial
+          Constants.redefine(:RUBY_PLATFORM, original_platform, :on => Object)
+        end
+      end
+
+      context "on unix" do
+        it 'should instantiate a new SerialPort for the first available tty device' do
+          subject.should_receive(:tty_devices).and_return(['/dev/ttyACM0', '/dev/tty.usbmodem1'])
+
+          # /dev/ttyACM0 is chosen as available for this test.
+          SerialPort.should_receive(:new).with('/dev/ttyACM0', TxRx::Serial::BAUD).and_return(mock_serial = mock)
+          SerialPort.should_not_receive(:new).with('/dev/tty.usbmodem1', TxRx::Serial::BAUD)
+
+          subject.io.should == mock_serial
+        end
+      end
+
+      it 'should connect to the specified device at the specified baud rate' do
+        subject.should_receive(:tty_devices).and_return(["/dev/ttyACM0"])
+        SerialPort.should_receive(:new).with('/dev/ttyACM0', 9600).and_return(mock_serial = mock)
+
+        subject.instance_variable_set(:@device, "/dev/ttyACM0")
+        subject.instance_variable_set(:@baud, 9600)
+
+        subject.io.should == mock_serial
+      end
+
+      it 'should use the existing io instance if set' do
+        subject.should_receive(:tty_devices).once.and_return(['/dev/tty.ACM0', '/dev/tty.usbmodem1'])
+        SerialPort.stub(:new).and_return(mock_serial = mock)
+
+        3.times { subject.io }
+        subject.io.should == mock_serial
+      end
+
+      it 'should raise a BoardNotFound exception if there is no board connected' do
+        SerialPort.stub(:new).and_raise
+        expect { subject.io }.to raise_exception BoardNotFound
+      end
+    end
+
+    describe '#read' do
+      it 'should create a new thread' do
+        Thread.should_receive :new
+        subject.read
+      end
+
+      it 'should get messages from the device' do
+        subject.stub(:io).and_return(mock_serial = mock)
+
+        IO.should_receive(:select).and_return(true)
+        Thread.should_receive(:new).and_yield
+        subject.should_receive(:loop).and_yield
+        mock_serial.should_receive(:gets).and_return("02:00\n")
+        subject.should_receive(:changed).and_return(true)
+        subject.should_receive(:notify_observers).with('02','00')
+
+        subject.read
+      end
+    end
+
+    describe '#close_read' do
+      it 'should kill the reading thread' do
+        subject.instance_variable_set(:@thread, mock_thread = mock)
+        Thread.should_receive(:kill).with(mock_thread)
+        subject.read
+        subject.close_read
+      end
+    end
+
+    describe '#write' do
+      it 'should write to the device' do
+        IO.should_receive(:select).and_return(true)
+
+        subject.stub(:io).and_return(mock_serial = mock)
+        mock_serial.should_receive(:syswrite).with('a message')
+        subject.write('a message')
+      end
+    end
+  end
+end

data/spec/lib/tx_rx/tcp_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+module Dino
+  describe TxRx::TCP do
+    before :each do
+      @host = "127.0.0.1"
+      @port = 3466
+      @instance = TxRx::TCP.new(@host, @port)
+    end
+
+    describe "#connect" do
+      it 'should raise a BoardNotFound exception if it cannot connect to the server' do
+        expect { @instance.io }.to raise_exception BoardNotFound
+      end
+
+      it 'should return the TCPSocket if connected' do
+        @server = TCPServer.new 3466
+        @instance.io.should be_a TCPSocket
+        @server.close
+      end
+    end
+
+    describe '#io' do
+      it 'should set io to a new TCPSocket with the specified host and port' do
+        TCPSocket.should_receive(:open).with(@host, @port)
+        @instance.io
+      end
+
+      it 'should use the existing io instance if set' do
+        @server = TCPServer.new 3466
+        socket = @instance.io
+        @instance.io.should be socket
+        @server.close
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,3 +1,12 @@
 require 'rspec'
 
-require File.expand_path(File.join('../..', 'lib/dino'), __FILE__)
+require File.expand_path(File.join('../..', 'lib/dino'), __FILE__)
+
+# Nice little helper module to redefine constants quietly.
+module Constants
+  def self.redefine(const, value, opts={})
+    opts = {:on => self.class}.merge(opts)
+    opts[:on].send(:remove_const, const) if self.class.const_defined?(const)
+    opts[:on].const_set(const, value)
+  end
+end

data/src/du/du.ino

@@ -0,0 +1,19 @@
+#include "Dino.h"
+#include <Servo.h>
+Dino dino;
+
+// Dino.h doesn't handle TXRX. Setup a function to tell it to write to Serial.
+void writeResponse(char *response) { Serial.print(response); Serial.print("\n"); }
+void (*writeCallback)(char *str) = writeResponse;
+
+void setup() {
+  Serial.begin(115200);
+  dino.setupWrite(writeCallback);
+}
+
+void loop() {
+  while(Serial.available() > 0) dino.parse(Serial.read());
+  dino.updateListeners();
+  Serial.flush();
+}
+

data/src/du_ethernet/du_ethernet.ino

@@ -0,0 +1,71 @@
+#include "Dino.h"
+#include <SPI.h>
+#include <Ethernet.h>
+#include <Servo.h>
+
+// Configure your MAC address, IP address, and HTTP port here.
+byte mac[] = { 0xDE, 0xAD, 0xBE, 0x30, 0x31, 0x32 };
+IPAddress ip(192,168,0,77);
+int port = 3466;
+
+Dino dino;
+EthernetServer server(port);
+EthernetClient client;
+char responseBuffer[65];
+
+
+// Dino.h doesn't handle TXRX. Setup a callback to receive the responses and buffer them.
+void bufferResponse(char *response) {
+   if (strlen(responseBuffer) > 56 ) {
+     writeResponses();
+     strcpy(responseBuffer, response);
+   } else {
+     strcat(responseBuffer, response);
+   }
+   strcat(responseBuffer, "\n");
+}
+void (*writeCallback)(char *str) = bufferResponse;
+
+// Write the buffered responses to the client.
+void writeResponses() {
+  if (responseBuffer[0] != '\0')
+    client.write(responseBuffer);
+    responseBuffer[0] = '\0';
+}
+
+
+void setup() {
+  // Explicitly disable the SD card.
+  pinMode(4,OUTPUT);
+  digitalWrite(4,HIGH);
+  
+  // Start up the network connection and server.
+  Ethernet.begin(mac, ip);
+  server.begin();
+    
+  // Start serial for debugging.
+  Serial.begin(9600);
+  Serial.print("Dino::TCP started at ");
+  Serial.print(Ethernet.localIP());
+  Serial.print(" on port ");
+  Serial.println(port);
+  
+  // Attach the write callback.
+  dino.setupWrite(writeCallback);
+}
+
+void loop() {
+  // Listen for connections.
+  client = server.available();
+  
+  // Handle a connection.
+  if (client) {
+    while (client.connected()) {
+      while (client.available()) dino.parse(client.read());
+      dino.updateListeners();
+      writeResponses();
+    }
+  }
+  client.stop();
+}
+

data/src/lib/Dino.cpp

@@ -0,0 +1,257 @@
+/*
+  Library for dino ruby gem.
+*/
+
+#include "Arduino.h"
+#include "Dino.h"
+
+Dino::Dino(){
+  reset();
+}
+
+void Dino::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 Dino::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 5:  addDigitalListener  ();  break;
+    case 6:  addAnalogListener   ();  break;
+    case 7:  removeListener      ();  break;
+    case 8:  servoToggle         ();  break;
+    case 9:  servoWrite          ();  break;
+    case 90: reset               ();  break;
+    case 97: setAnalogDivider    ();  break;
+    case 98: setHeartRate        ();  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 Dino::setupWrite(void (*writeCallback)(char *str)) {
+  _writeCallback = writeCallback;
+}
+void Dino::writeResponse() {
+  _writeCallback(response);
+}
+
+
+
+// LISTNENERS
+void Dino::updateListeners() {
+  if (timeSince(lastUpdate) > heartRate || timeSince(lastUpdate) < 0) {
+    lastUpdate = micros();
+    loopCount++;
+    updateDigitalListeners();
+    if (loopCount % analogDivider == 0) updateAnalogListeners();
+  }
+}
+void Dino::updateDigitalListeners() {
+  for (int i = 0; i < 22; i++) {
+    if (digitalListeners[i]) {
+      pin = i;
+      dRead();
+      if (rval != digitalListenerValues[i]) {
+        digitalListenerValues[i] = rval;
+        writeResponse();
+      } 
+    }
+  }
+}
+void Dino::updateAnalogListeners() {
+  for (int i = 0; i < 22; i++) {
+    if (analogListeners[i]) {
+      pin = i;
+      aRead();
+      writeResponse();
+    }
+  }
+}
+long Dino::timeSince(long event) {
+ long time = micros() - event;
+ return time;
+}
+
+
+
+// API FUNCTIONS
+// CMD = 00 // Pin Mode
+void Dino::setMode() {
+  if (val == 0) {
+    removeListener();
+    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 Dino::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 Dino::dRead() { 
+  rval = digitalRead(pin);
+  sprintf(response, "%02d:%02d", pin, rval);
+}
+
+// CMD = 03 // Analog (PWM) Write
+void Dino::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 Dino::aRead() {
+  rval = analogRead(pin);
+  sprintf(response, "%02d:%02d", pin, rval);
+}
+
+// CMD = 05
+// Listen for a digital signal on any pin.
+void Dino::addDigitalListener() {
+  removeListener();
+  digitalListeners[pin] = true;
+  digitalListenerValues[pin] = 2;
+  #ifdef debug
+    Serial.print("Added digital listener on pin "); Serial.println(pin);
+  #endif
+}
+
+// CMD = 06
+// Listen for an analog signal on analog pins only.
+void Dino::addAnalogListener() {
+  removeListener();
+  analogListeners[pin] = true;
+  #ifdef debug
+    Serial.print("Added analog listener on pin "); Serial.println(pin);
+  #endif
+}
+
+// CMD = 07
+// Remove analog and digital listeners from any pin.
+void Dino::removeListener() {
+  analogListeners[pin] = false;
+  digitalListeners[pin] = false;
+  #ifdef debug
+    Serial.print("Removed listeners on pin "); Serial.println(pin);
+  #endif
+}
+
+// CMD = 08
+// Attach the servo object to pin or detach it.
+void Dino::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 Dino::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 Dino::reset() {
+  heartRate = 4000; // Default heartRate is ~4ms.
+  loopCount = 0;
+  analogDivider = 4; // Update analog listeners every ~16ms.
+  for (int i = 0; i < 22; i++) digitalListeners[i] = false;
+  for (int i = 0; i < 22; i++) digitalListenerValues[i] = 2;
+  for (int i = 0; i < 22; i++)  analogListeners[i] = false;
+  lastUpdate = micros();
+  index = 0;
+  #ifdef debug
+    Serial.println("Reset the board to defaults.  pin ");
+  #endif
+  sprintf(response, "ACK:%02d", A0);
+}
+
+// CMD = 97
+// Set the analog divider. Powers of 2 up to 128 are valid.
+void Dino::setAnalogDivider() {
+  analogDivider = val;
+  #ifdef debug
+    Serial.print("Analog divider set to "); Serial.println(analogDivider);
+  #endif
+}
+
+// CMD = 98
+// Set the heart rate in milliseconds. Store it in microseconds.
+void Dino::setHeartRate() {
+  int rate = val;
+  heartRate = (rate * 1000);
+  #ifdef debug
+    Serial.print("Heart rate set to "); Serial.print(heartRate); Serial.println(" microseconds");
+  #endif
+}
+