brick-pi 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e63e867f917f20a008427c1096e7ba94b267c890
+  data.tar.gz: 78a16b7c6cb6a76bf6c94bcea3091a2e52d0eedb
+SHA512:
+  metadata.gz: 34a9ac8a0def422ffd6d6fb5109d58e52288ec7efdcb4058395c6433a2b186896468c9e8b19f8d5494397da5091a78de95978a6676ca1c1f4856c1b1d395b43b
+  data.tar.gz: 2d082af9c7dc6311e142864f3f7164328e0c190a21dd817faef757fa657249576245649beeebdcfb66a70e3fe8017f908bf63edf48f591d2632d87a8dc236d77

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in brick_pi.gemspec
+gemspec
+gem "rake-compiler"

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Brandon Hays
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 TODO: Write your name
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,101 @@
+# BrickBot: A BrickPi library for Ruby
+
+ruby wrappers for the BrickPi Lego Mindstorms C library
+
+TODO: Write a gem description
+TODO: Tag, version, and publish as gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'brick_pi'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install brick_pi
+
+## Usage
+
+Currently, you only get a set of primitives to run motors. Expect more functionality around sensors and a more robust library supporting various configurations (e.g. 2-tracked vehicle).
+
+The Bot object starts and stops the robot. It contains 4 Motor objects, mapped to port A-D on your BrickPi.
+
+Here's a quick & dirty script to spin a motor:
+
+```ruby
+require 'brick_pi'
+
+# Instantiate the Bot
+bot = BrickPi::Bot.new
+
+# Set the speed for a motor, on a scale of 0 - 100
+bot.motor1.spin 50
+
+# Get this party started
+bot.start
+
+# Stop a single motor
+bot.motor1.stop
+
+# Stop all functions for a bot
+bot.stop
+```
+
+Once your bot is started, you can change the speed or direction of the motors at any time with the `Motor#spin` method.
+
+Here's a really yucky script I hacked together to let you drive a 2-tracked vehicle with an iCade 8-Bitty (which is basically a bluetooth keyboard that looks like an NES controller).
+
+It requires the Highline gem, so on the BrickPi you'll need to run `gem install highline`.
+
+```ruby
+require "highline/system_extensions"
+include HighLine::SystemExtensions
+HighLine::SystemExtensions.raw_no_echo_mode
+
+bot = BrickPi::Bot.new
+bot.start
+
+speed = 20
+loop do
+  char = HighLine::SystemExtensions.get_character
+  case char.chr
+  when 'w'
+    bot.motor1.spin speed
+    bot.motor2.spin speed
+  when 'd'
+    bot.motor1.spin speed
+    bot.motor2.spin 0 - speed
+  when 'a'
+    bot.motor1.spin 0 - speed
+    bot.motor2.spin speed
+  when 'x'
+    bot.motor1.spin 0 - speed
+    bot.motor2.spin 0 - speed
+  when 'o'
+    if speed >=0 && speed <= 80
+      speed += 20
+    end
+  when 'l'
+    if speed > 20 && speed <= 100
+      speed -= 20
+    end
+  when 'e', 'c', 'z', 'q'
+    bot.motor1.stop
+    bot.motor2.stop
+  end
+  sleep(5 / 1000)
+end
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/tehviking/brick_pi/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+
+require "rake/extensiontask"
+Rake::ExtensionTask.new("native", eval(File.read("brick_pi.gemspec"))) do |ext|
+  ext.ext_dir = "ext/brick_pi"
+  ext.lib_dir = "lib/brick_pi"
+  ext.source_pattern = "*.{c,h}"
+end

data/brick_pi.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'brick_pi/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "brick-pi"
+  spec.version       = BrickPi::VERSION
+  spec.authors       = ["Brandon Hays", "Charles Lowell"]
+  spec.email         = ["brandon.hays@gmail.com"]
+  spec.summary       = %q{Ruby library to run the BrickPi drivers for Lego Mindstorms}
+  spec.description   = %q{BrickPi uses a C library to communicate with Lego Mindstorms motors and sensors via GPIO on the Raspberry Pi. This library wraps the C and exposes a nicer, object-oriented interface via Ruby.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib", "ext"]
+  spec.extensions    = ["ext/brick_pi/extconf.rb"]
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+end

data/ext/brick_pi/BrickPi.h

@@ -0,0 +1,641 @@
+/*
+*  Matthew Richardson
+*  matthewrichardson37<at>gmail.com
+*  http://mattallen37.wordpress.com/
+*
+*  Updated by John Cole, Dexter Industries.   
+*
+*  Initial date: June 4, 2013
+*  Last updated: Oct 7, 2013
+*
+* These files have been made available online through a Creative Commons Attribution-ShareAlike 3.0  license.
+* (http://creativecommons.org/licenses/by-sa/3.0/)
+*
+*  This is a library of functions for the RPi to communicate with the BrickPi.
+*/
+/*
+##################################################################################################################
+* Debugging:
+* - NOTE THAT DEBUGGING ERROR MESSAGES ARE TURNED OFF BY DEFAULT.  To debug, just take the comment out of Line 38.
+* 
+* If you #define DEBUG in the program, the BrickPi.h drivers will print debug messages to the terminal. One common message is
+* "BrickPiRx error: -2", in function BrickPiUpdateValues(). This is caused by an error in the communication with one of the
+* microcontrollers on the BrickPi. When this happens, the drivers automatically re-try the communication several times before the
+* function gives up and returns -1 (unsuccessful) to the user-program.
+
+* Function BrickPiUpdateValues() will either return 0 (success), or -1 (error that could not automatically be resolved, even after
+* re-trying several times). We have rarely had BrickPiUpdateValues() retry more than once before the communication was successful.
+* A known cause for "BrickPiRx error: -2" is the RPi splitting the UART message. Sometimes the RPi will send e.g. 3 bytes, wait a
+* while, and then send 4 more, when it should have just sent 7 at once. During the pause between the packs of bytes, the BrickPi
+* microcontrollers will think the transmission is complete, realize the message doesn't make sense, throw it away, and not return
+* a message to the RPi. The RPi will then fail to receive a message in the specified amount of time, timeout, and then retry the
+* communication.
+*/
+
+#ifndef __BrickPi_h_
+#define __BrickPi_h_
+
+// #define DEBUG
+
+#include <wiringPi.h>
+
+#define PORT_A 0
+#define PORT_B 1
+#define PORT_C 2
+#define PORT_D 3
+
+#define PORT_1 0
+#define PORT_2 1
+#define PORT_3 2
+#define PORT_4 3
+
+#define MASK_D0_M 0x01
+#define MASK_D1_M 0x02
+#define MASK_9V   0x04
+#define MASK_D0_S 0x08
+#define MASK_D1_S 0x10
+
+#define BYTE_MSG_TYPE               0 // MSG_TYPE is the first byte.
+  #define MSG_TYPE_CHANGE_ADDR      1 // Change the UART address.
+  #define MSG_TYPE_SENSOR_TYPE      2 // Change/set the sensor type.
+  #define MSG_TYPE_VALUES           3 // Set the motor speed and direction, and return the sesnors and encoders.
+  #define MSG_TYPE_E_STOP           4 // Float motors immidately
+  #define MSG_TYPE_TIMEOUT_SETTINGS 5 // Set the timeout
+
+  // New UART address (MSG_TYPE_CHANGE_ADDR)
+    #define BYTE_NEW_ADDRESS     1
+  
+  // Sensor setup (MSG_TYPE_SENSOR_TYPE)
+    #define BYTE_SENSOR_1_TYPE   1
+    #define BYTE_SENSOR_2_TYPE   2
+  
+  // Timeout setup (MSG_TYPE_TIMEOUT_SETTINGS)
+    #define BYTE_TIMEOUT 1
+
+#define TYPE_MOTOR_PWM                 0
+#define TYPE_MOTOR_SPEED               1
+#define TYPE_MOTOR_POSITION            2
+
+#define TYPE_SENSOR_RAW                0 // - 31
+#define TYPE_SENSOR_LIGHT_OFF          0
+#define TYPE_SENSOR_LIGHT_ON           (MASK_D0_M | MASK_D0_S)
+#define TYPE_SENSOR_TOUCH              32
+#define TYPE_SENSOR_ULTRASONIC_CONT    33
+#define TYPE_SENSOR_ULTRASONIC_SS      34
+#define TYPE_SENSOR_RCX_LIGHT          35 // tested minimally
+#define TYPE_SENSOR_COLOR_FULL         36
+#define TYPE_SENSOR_COLOR_RED          37
+#define TYPE_SENSOR_COLOR_GREEN        38
+#define TYPE_SENSOR_COLOR_BLUE         39
+#define TYPE_SENSOR_COLOR_NONE         40
+#define TYPE_SENSOR_I2C                41
+#define TYPE_SENSOR_I2C_9V             42
+
+#define BIT_I2C_MID  0x01  // Do one of those funny clock pulses between writing and reading. defined for each device.
+#define BIT_I2C_SAME 0x02  // The transmit data, and the number of bytes to read and write isn't going to change. defined for each device.
+
+#define INDEX_RED   0
+#define INDEX_GREEN 1
+#define INDEX_BLUE  2
+#define INDEX_BLANK 3
+
+void BrickPiTx(unsigned char dest, unsigned char ByteCount, unsigned char OutArray[]);
+
+struct BrickPiStruct{
+  unsigned char Address        [2];     // Communication addresses
+  unsigned long Timeout           ;     // Communication timeout (how long in ms since the last valid communication before floating the motors). 0 disables the timeout.
+
+/*
+  Motors
+*/
+  int           MotorSpeed     [4];     // Motor speeds, from -255 to 255
+  unsigned char MotorEnable    [4];     // Motor enable/disable
+
+/*
+  Encoders
+*/
+  long          EncoderOffset  [4];     // Encoder offsets (not yet implemented)
+  long          Encoder        [4];     // Encoder values
+
+/*
+  Sensors
+*/
+  long          Sensor         [4];     // Primary sensor values
+  long          SensorArray    [4][4];  // For more sensor values for the sensor (e.g. for color sensor FULL mode).
+  unsigned char SensorType     [4];     // Sensor types
+  unsigned char SensorSettings [4][8];  // Sensor settings, used for specifying I2C settings.
+
+/*
+  I2C
+*/
+  unsigned char SensorI2CDevices[4];        // How many I2C devices are on each bus (1 - 8).
+  unsigned char SensorI2CSpeed  [4];        // The I2C speed.
+  unsigned char SensorI2CAddr   [4][8];     // The I2C address of each device on each bus.  
+  unsigned char SensorI2CWrite  [4][8];     // How many bytes to write
+  unsigned char SensorI2CRead   [4][8];     // How many bytes to read
+  unsigned char SensorI2COut    [4][8][16]; // The I2C bytes to write
+  unsigned char SensorI2CIn     [4][8][16]; // The I2C input buffers
+};
+
+struct BrickPiStruct BrickPi;
+
+//Store the button's of the MINDSENSORS PSP Controller
+struct button
+{
+	unsigned char   l1;
+	unsigned char   l2;
+	unsigned char   r1;
+	unsigned char   r2;
+	unsigned char   a;
+	unsigned char   b;
+	unsigned char   c;
+	unsigned char   d;
+	unsigned char   tri;
+	unsigned char   sqr;
+	unsigned char   cir;
+	unsigned char   cro;
+	unsigned char   ljb;  // joystick button state
+	unsigned char   rjb;  // joystick button state
+
+	int   ljx;   // analog value of joystick scaled from -127 to 127
+	int   ljy;   // analog value of joystick scaled from -127 to 127
+	int   rjx;   // analog value of joystick scaled from -127 to 127
+	int   rjy;   // analog value of joystick scaled from -127 to 127
+};
+//Initialize all the buttons to 0 of the MINDSENSORS PSP controller
+struct button init_psp (struct button b)
+{
+	b.l1 = 0;
+	b.l2 = 0;
+	b.r1 = 0;
+	b.r2 = 0;
+	b.a = 0;
+	b.b = 0;
+	b.c = 0;
+	b.d = 0;
+	b.tri = 0;
+	b.sqr = 0;
+	b.cir = 0;
+	b.cro = 0;
+	b.ljb = 0;
+	b.rjb = 0;
+	b.ljx = 0;
+	b.ljy = 0;
+	b.rjx = 0;
+	b.rjy = 0;
+	return b;
+}
+
+//Update all the buttons of the MINDSENSORS PSP controller
+//For all buttons:
+//	0:	Unpressed
+//	1:	Pressed
+//	
+//	Left and right joystick: -127 to 127 
+struct button upd(struct button b,int port)
+{
+	//Left and right joystick button press
+	b.ljb = ~(BrickPi.SensorI2CIn[port][0][0] >> 1) & 0x01;
+	b.rjb = ~(BrickPi.SensorI2CIn[port][0][0] >> 2) & 0x01;
+	
+	//For buttons a,b,c,d
+	b.d = ~(BrickPi.SensorI2CIn[port][0][0] >> 4) & 0x01;
+	b.c = ~(BrickPi.SensorI2CIn[port][0][0] >> 5) & 0x01;
+	b.b = ~(BrickPi.SensorI2CIn[port][0][0] >> 6) & 0x01;
+	b.a = ~(BrickPi.SensorI2CIn[port][0][0] >> 7) & 0x01;
+ 
+	//For buttons l1,l2,r1,r2
+	b.l2    = ~(BrickPi.SensorI2CIn[port][0][1] ) & 0x01;
+	b.r2    = ~(BrickPi.SensorI2CIn[port][0][1] >> 1) & 0x01;
+	b.l1    = ~(BrickPi.SensorI2CIn[port][0][1] >> 2) & 0x01;
+	b.r1    = ~(BrickPi.SensorI2CIn[port][0][1] >> 3) & 0x01;
+	
+	//For buttons square,triangle,cross,circle
+	b.tri    = ~(BrickPi.SensorI2CIn[port][0][1] >> 4) & 0x01;
+	b.cir    = ~(BrickPi.SensorI2CIn[port][0][1] >> 5) & 0x01;
+	b.cro = ~(BrickPi.SensorI2CIn[port][0][1] >> 6) & 0x01;
+	b.sqr    = ~(BrickPi.SensorI2CIn[port][0][1] >> 7) & 0x01;
+   
+   //Left joystick x and y , -127 to 127
+	b.ljx = -1*((BrickPi.SensorI2CIn[port][0][5]&0xff) - 128);
+	b.ljy = (BrickPi.SensorI2CIn[port][0][4]&0xff) - 128;
+	
+	//Right joystick x and y , -127 to 127
+	b.rjx = -1*((BrickPi.SensorI2CIn[port][0][3]&0xff) - 128);
+	b.rjy = (BrickPi.SensorI2CIn[port][0][2]&0xff) - 128;
+	return b;
+}
+//Show button values of the MINDSENSORS PSP controller
+void show_val(struct button b)
+{
+	printf("ljb rjb d c b a l2 r2 l1 r1 tri cir cro sqr\tljx\tljy\trjx\trjy\n");
+	printf("%d ",b.ljb);
+	printf("  %d ",b.rjb);
+	printf("  %d ",b.d);
+	printf("%d ",b.c);
+	printf("%d ",b.b);
+	printf("%d ",b.a);
+	         
+	printf("%d ",b.l2);
+	printf(" %d ",b.r2);
+	printf(" %d ",b.l1);
+	printf(" %d ",b.r1);
+	printf(" %d ",b.tri);
+	printf("  %d ",b.cir);
+	printf("  %d ",b.cro);
+	printf("  %d ",b.sqr);
+	printf("\t%d ",b.ljx);
+	printf("\t%d ",b.rjx);
+	printf("\t%d ",b.ljy);
+	printf("\t%d\n\n",b.rjy);
+}
+unsigned char Array[256];
+unsigned char BytesReceived;
+
+int BrickPiChangeAddress(unsigned char OldAddr, unsigned char NewAddr){
+  unsigned char i = 0;
+  Array[BYTE_MSG_TYPE] = MSG_TYPE_CHANGE_ADDR;
+  Array[BYTE_NEW_ADDRESS] = NewAddr;
+  BrickPiTx(OldAddr, 2, Array);
+    
+  if(BrickPiRx(&BytesReceived, Array, 5000))
+    return -1;
+  if(!(BytesReceived == 1 && Array[BYTE_MSG_TYPE] == MSG_TYPE_CHANGE_ADDR))
+    return -1;
+
+  return 0;
+}
+
+int BrickPiSetTimeout(){
+  unsigned char i = 0;
+  while(i < 2){
+    Array[BYTE_MSG_TYPE] = MSG_TYPE_TIMEOUT_SETTINGS;
+    Array[BYTE_TIMEOUT      ] = ( BrickPi.Timeout             & 0xFF);
+    Array[(BYTE_TIMEOUT + 1)] = ((BrickPi.Timeout / 256     ) & 0xFF);
+    Array[(BYTE_TIMEOUT + 2)] = ((BrickPi.Timeout / 65536   ) & 0xFF);
+    Array[(BYTE_TIMEOUT + 3)] = ((BrickPi.Timeout / 16777216) & 0xFF);
+    BrickPiTx(BrickPi.Address[i], 5, Array);
+    if(BrickPiRx(&BytesReceived, Array, 2500))
+      return -1;
+    if(!(BytesReceived == 1 && Array[BYTE_MSG_TYPE] == MSG_TYPE_TIMEOUT_SETTINGS))
+      return -1;
+    i++;
+  }
+  return 0;
+}
+
+unsigned int Bit_Offset = 0;
+
+void AddBits(unsigned char byte_offset, unsigned char bit_offset, unsigned char bits, unsigned long value){
+  unsigned char i = 0;
+  while(i < bits){
+    if(value & 0x01){
+      Array[(byte_offset + ((bit_offset + Bit_Offset + i) / 8))] |= (0x01 << ((bit_offset + Bit_Offset + i) % 8));
+    }
+    value /= 2;
+    i++;
+  }
+  Bit_Offset += bits;
+}
+
+unsigned long GetBits(unsigned char byte_offset, unsigned char bit_offset, unsigned char bits){
+  unsigned long Result = 0;
+  char i = bits;
+  while(i){
+    Result *= 2;
+    Result |= ((Array[(byte_offset + ((bit_offset + Bit_Offset + (i - 1)) / 8))] >> ((bit_offset + Bit_Offset + (i - 1)) % 8)) & 0x01);    
+    i--;
+  }
+  Bit_Offset += bits;
+  return Result;
+}
+
+unsigned char BitsNeeded(unsigned long value){
+  unsigned char i = 0;
+  while(i < 32){
+    if(!value)
+      return i;
+    value /= 2;
+    i++;
+  }
+  return 31;
+}
+
+int BrickPiSetupSensors(){
+  unsigned char i = 0;
+  while(i < 2){
+    int ii = 0;
+    while(ii < 256){
+      Array[ii] = 0;
+      ii++;
+    }
+    Bit_Offset = 0;
+    Array[BYTE_MSG_TYPE] = MSG_TYPE_SENSOR_TYPE;
+    Array[BYTE_SENSOR_1_TYPE] = BrickPi.SensorType[PORT_1 + (i * 2)];
+    Array[BYTE_SENSOR_2_TYPE] = BrickPi.SensorType[PORT_2 + (i * 2)];
+    ii = 0;
+    while(ii < 2){
+      unsigned char port = (i * 2) + ii;
+      if(Array[BYTE_SENSOR_1_TYPE + ii] == TYPE_SENSOR_I2C
+      || Array[BYTE_SENSOR_1_TYPE + ii] == TYPE_SENSOR_I2C_9V){
+        AddBits(3, 0, 8, BrickPi.SensorI2CSpeed[port]);
+        
+        if(BrickPi.SensorI2CDevices[port] > 8)
+          BrickPi.SensorI2CDevices[port] = 8;
+        
+        if(BrickPi.SensorI2CDevices[port] == 0)
+          BrickPi.SensorI2CDevices[port] = 1;
+        
+        AddBits(3, 0, 3, (BrickPi.SensorI2CDevices[port] - 1));
+        
+        unsigned char device = 0;
+        while(device < BrickPi.SensorI2CDevices[port]){
+          AddBits(3, 0, 7, (BrickPi.SensorI2CAddr[port][device] >> 1));
+          AddBits(3, 0, 2, BrickPi.SensorSettings[port][device]);
+          if(BrickPi.SensorSettings[port][device] & BIT_I2C_SAME){          
+            AddBits(3, 0, 4, BrickPi.SensorI2CWrite[port][device]);
+            AddBits(3, 0, 4, BrickPi.SensorI2CRead [port][device]);
+            unsigned char out_byte = 0;
+            while(out_byte < BrickPi.SensorI2CWrite[port][device]){
+              AddBits(3, 0, 8, BrickPi.SensorI2COut[port][device][out_byte]);
+              out_byte++;
+            }
+          }
+          device++;
+        }
+      }
+      ii++;
+    }
+    unsigned char UART_TX_BYTES = (((Bit_Offset + 7) / 8) + 3);
+    BrickPiTx(BrickPi.Address[i], UART_TX_BYTES, Array);
+    if(BrickPiRx(&BytesReceived, Array, 500000))
+      return -1;
+    if(!(BytesReceived == 1 && Array[BYTE_MSG_TYPE] == MSG_TYPE_SENSOR_TYPE))
+      return -1;
+    i++;
+  }
+  return 0;
+}
+
+unsigned char Retried = 0; // For re-trying a failed update.
+
+int BrickPiUpdateValues(){
+  unsigned char i = 0;
+  unsigned int ii = 0;
+  while(i < 2){
+    Retried = 0;    
+
+__RETRY_COMMUNICATION__:
+    
+    ii = 0;
+    while(ii < 256){
+      Array[ii] = 0;
+      ii++;
+    }
+    
+    Array[BYTE_MSG_TYPE] = MSG_TYPE_VALUES;
+    
+    Bit_Offset = 0;
+    
+//    AddBits(1, 0, 2, 0);     use this to disable encoder offset
+    
+    ii = 0;                 // use this for encoder offset support
+    while(ii < 2){
+      unsigned char port = (i * 2) + ii;
+      if(BrickPi.EncoderOffset[port]){
+        long Temp_Value = BrickPi.EncoderOffset[port];
+        unsigned char Temp_ENC_DIR;
+        unsigned char Temp_BitsNeeded;
+        
+        AddBits(1, 0, 1, 1);
+        if(Temp_Value < 0){
+          Temp_ENC_DIR = 1;
+          Temp_Value *= (-1);
+        }
+        Temp_BitsNeeded = (BitsNeeded(Temp_Value) + 1);
+        AddBits(1, 0, 5, Temp_BitsNeeded);
+        Temp_Value *= 2;
+        Temp_Value |= Temp_ENC_DIR;
+        AddBits(1, 0, Temp_BitsNeeded, Temp_Value);
+      }
+      else{
+        AddBits(1, 0, 1, 0);
+      }
+      ii++;
+    }
+    
+    int speed;
+    unsigned char dir;    
+    ii = 0;
+    while(ii < 2){
+      unsigned char port = (i * 2) + ii;
+      speed = BrickPi.MotorSpeed[port];
+      dir = 0;
+      if(speed < 0){
+        dir = 1;
+        speed *= (-1);
+      }
+      if(speed > 255){
+        speed = 255;
+      }
+      AddBits(1, 0, 10, ((((speed & 0xFF) << 2) | (dir << 1) | (BrickPi.MotorEnable[port] & 0x01)) & 0x3FF));
+      ii++;
+    }
+    
+    ii = 0;
+    while(ii < 2){
+      unsigned char port = (i * 2) + ii;
+      if(BrickPi.SensorType[port] == TYPE_SENSOR_I2C
+      || BrickPi.SensorType[port] == TYPE_SENSOR_I2C_9V){
+        unsigned char device = 0;
+        while(device < BrickPi.SensorI2CDevices[port]){
+          if(!(BrickPi.SensorSettings[port][device] & BIT_I2C_SAME)){
+            AddBits(1, 0, 4, BrickPi.SensorI2CWrite[port][device]);
+            AddBits(1, 0, 4, BrickPi.SensorI2CRead [port][device]);
+            unsigned char out_byte = 0;
+            while(out_byte < BrickPi.SensorI2CWrite[port][device]){
+              AddBits(1, 0, 8, BrickPi.SensorI2COut[port][device][out_byte]);
+              out_byte++;
+            }
+          }
+          device++;
+        }
+      }
+      ii++;
+    }
+    
+    unsigned char UART_TX_BYTES = (((Bit_Offset + 7) / 8) + 1);
+    BrickPiTx(BrickPi.Address[i], UART_TX_BYTES, Array);
+    
+    int result = BrickPiRx(&BytesReceived, Array, 7500);
+    
+    if(result != -2){                            // -2 is the only error that indicates that the BrickPi uC did not properly receive the message
+      BrickPi.EncoderOffset[((i * 2) + PORT_A)] = 0;
+      BrickPi.EncoderOffset[((i * 2) + PORT_B)] = 0;
+    }
+    
+    if(result || (Array[BYTE_MSG_TYPE] != MSG_TYPE_VALUES)){
+#ifdef DEBUG
+      printf("BrickPiRx error: %d\n", result);
+#endif
+      if(Retried < 2){
+        Retried++;
+        goto __RETRY_COMMUNICATION__;
+      }
+      else{
+#ifdef DEBUG
+        printf("Retry failed.\n");
+#endif
+        return -1;
+      }      
+    }
+    
+    Bit_Offset = 0;
+    
+    unsigned char Temp_BitsUsed[2] = {0, 0};         // Used for encoder values
+    Temp_BitsUsed[0] = GetBits(1, 0, 5);
+    Temp_BitsUsed[1] = GetBits(1, 0, 5);
+    unsigned long Temp_EncoderVal;
+    
+    ii = 0;
+    while(ii < 2){
+      Temp_EncoderVal = GetBits(1, 0, Temp_BitsUsed[ii]);
+      if(Temp_EncoderVal & 0x01){
+        Temp_EncoderVal /= 2;
+        BrickPi.Encoder[ii + (i * 2)] = Temp_EncoderVal * (-1);}
+      else{
+        BrickPi.Encoder[ii + (i * 2)] = (Temp_EncoderVal / 2);}      
+      ii++;
+    }
+
+    ii = 0;
+    while(ii < 2){
+      unsigned char port = ii + (i * 2);
+      switch(BrickPi.SensorType[port]){
+        case TYPE_SENSOR_TOUCH:
+          BrickPi.Sensor[port] = GetBits(1, 0, 1);
+        break;
+        case TYPE_SENSOR_ULTRASONIC_CONT:
+        case TYPE_SENSOR_ULTRASONIC_SS:
+          BrickPi.Sensor[port] = GetBits(1, 0, 8);
+        break;
+        case TYPE_SENSOR_COLOR_FULL:
+          BrickPi.Sensor[port] = GetBits(1, 0, 3);
+          BrickPi.SensorArray[port][INDEX_BLANK] = GetBits(1, 0, 10);
+          BrickPi.SensorArray[port][INDEX_RED  ] = GetBits(1, 0, 10);                
+          BrickPi.SensorArray[port][INDEX_GREEN] = GetBits(1, 0, 10);
+          BrickPi.SensorArray[port][INDEX_BLUE ] = GetBits(1, 0, 10);
+        break;          
+        case TYPE_SENSOR_I2C:
+        case TYPE_SENSOR_I2C_9V:
+          BrickPi.Sensor[port] = GetBits(1, 0, BrickPi.SensorI2CDevices[port]);
+          unsigned char device = 0;
+          while(device < BrickPi.SensorI2CDevices[port]){
+            if(BrickPi.Sensor[port] & (0x01 << device)){
+              unsigned char in_byte = 0;
+              while(in_byte < BrickPi.SensorI2CRead[port][device]){
+                BrickPi.SensorI2CIn[port][device][in_byte] = GetBits(1, 0, 8);
+                in_byte++;
+              }
+            }
+            device++;
+          }
+        break;      
+        case TYPE_SENSOR_LIGHT_OFF:
+        case TYPE_SENSOR_LIGHT_ON:
+        case TYPE_SENSOR_RCX_LIGHT:
+        case TYPE_SENSOR_COLOR_RED:
+        case TYPE_SENSOR_COLOR_GREEN:
+        case TYPE_SENSOR_COLOR_BLUE:
+        case TYPE_SENSOR_COLOR_NONE:
+        default:
+          BrickPi.Sensor[(ii + (i * 2))] = GetBits(1, 0, 10);
+      }        
+      ii++;
+    }      
+    i++;
+  }
+  return 0;
+}
+
+int UART_file_descriptor = 0; 
+
+int BrickPiSetup(){
+  UART_file_descriptor = serialOpen("/dev/ttyAMA0", 500000);
+  if(UART_file_descriptor == -1){
+    return -1;
+  }
+  return 0;
+}
+
+void BrickPiTx(unsigned char dest, unsigned char ByteCount, unsigned char OutArray[]){
+  unsigned char tx_buffer[256];
+  tx_buffer[0] = dest;
+  tx_buffer[1] = dest + ByteCount;
+  tx_buffer[2] = ByteCount;  
+  unsigned char i = 0;
+  while(i < ByteCount){
+    tx_buffer[1] += OutArray[i];
+    tx_buffer[i + 3] = OutArray[i];
+    i++;
+  }
+  i = 0;
+  while(i < (ByteCount + 3)){
+    serialPutchar(UART_file_descriptor, tx_buffer[i]);
+    i++;
+  }
+}
+
+int BrickPiRx(unsigned char *InBytes, unsigned char *InArray, long timeout){  // timeout in uS, not mS
+  unsigned char rx_buffer[256];
+  unsigned char RxBytes = 0;
+  unsigned char CheckSum = 0;
+  unsigned char i = 0;
+  int result;
+  unsigned long OrigionalTick = CurrentTickUs();
+  while(serialDataAvail(UART_file_descriptor) <= 0){
+    if(timeout && ((CurrentTickUs() - OrigionalTick) >= timeout))return -2;
+  }
+
+  RxBytes = 0;
+  while(RxBytes < serialDataAvail(UART_file_descriptor)){                                   // If it's been 1 ms since the last data was received, assume it's the end of the message.
+    RxBytes = serialDataAvail(UART_file_descriptor);
+    usleep(75);
+  }
+  
+  i = 0;  
+  while(i < RxBytes){
+    result = serialGetchar(UART_file_descriptor);
+    if(result >= 0){
+      rx_buffer[i] = result;
+    }
+    else{      
+      return -1;    
+    }
+    i++;    
+  }
+
+  if(RxBytes < 2)
+    return -4;
+  
+  if(RxBytes < (rx_buffer[1] + 2))
+    return -6;
+  
+  CheckSum = rx_buffer[1];
+  
+  i = 0;
+  while(i < (RxBytes - 2)){
+    CheckSum += rx_buffer[i + 2];
+    InArray[i] = rx_buffer[i + 2];
+    i++;
+  }
+  
+  if(CheckSum != rx_buffer[0])
+    return -5;
+  
+  *InBytes = (RxBytes - 2);
+
+  return 0;  
+}
+
+#endif

data/ext/brick_pi/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+find_header 'wiringPi.h'
+find_library 'wiringPi', 'serialOpen'
+create_makefile 'brick_pi/native'

data/ext/brick_pi/native.c

@@ -0,0 +1,65 @@
+#include "ruby.h";
+#include "tick.h";
+#include "BrickPi.h";
+
+VALUE bprb_BrickPiSetup(VALUE self) {
+    return INT2FIX(BrickPiSetup());
+}
+VALUE bprb_ClearTick(VALUE self) {
+    return INT2FIX(ClearTick());
+}
+
+VALUE bprb_MotorSpeed_set(VALUE self, VALUE key, VALUE value) {
+    int index = FIX2INT(key);
+    BrickPi.MotorSpeed[index] = FIX2INT(value);
+    return value;
+}
+
+VALUE bprb_Address_set(VALUE self, VALUE key, VALUE value) {
+    int index = FIX2INT(key);
+    BrickPi.Address[index] = FIX2INT(value);
+    return value;
+}
+
+VALUE bprb_MotorEnable_set(VALUE self, VALUE key, VALUE value) {
+    int index = FIX2INT(key);
+    BrickPi.MotorEnable[index] = FIX2INT(value);
+    return value;
+}
+
+VALUE bprb_Timeout_set(VALUE self, VALUE timeout) {
+    BrickPi.Timeout = FIX2INT(timeout);
+    return timeout;
+}
+
+VALUE bprb_BrickPiSetTimeout(VALUE self) {
+    return INT2FIX(BrickPiSetTimeout());
+}
+
+VALUE bprb_BrickPiUpdateValues(VALUE self) {
+    return INT2FIX(BrickPiUpdateValues());
+}
+
+void Init_native() {
+    VALUE BrickPi = rb_define_module("BrickPi");
+    VALUE Native = rb_define_module_under(BrickPi, "Native");
+    rb_define_singleton_method(Native, "BrickPiSetup", bprb_BrickPiSetup, 0);
+    rb_define_singleton_method(Native, "ClearTick", bprb_ClearTick, 0);
+    VALUE MotorSpeed = rb_define_module_under(Native, "MotorSpeed");
+    rb_define_singleton_method(MotorSpeed, "[]=", bprb_MotorSpeed_set, 2);
+    VALUE MotorEnable = rb_define_module_under(Native, "MotorEnable");
+    rb_define_singleton_method(MotorEnable, "[]=", bprb_MotorEnable_set, 2);
+    VALUE Address = rb_define_module_under(Native, "Address");
+    rb_define_singleton_method(Address, "[]=", bprb_Address_set, 2);
+    rb_define_singleton_method(Native, "Timeout=", bprb_Timeout_set, 1);
+    rb_define_singleton_method(Native, "BrickPiSetTimeout", bprb_BrickPiSetTimeout, 0);
+    rb_define_singleton_method(Native, "BrickPiUpdateValues", bprb_BrickPiUpdateValues, 0);
+    rb_define_const(Native, "PORT_A", INT2FIX(0));
+    rb_define_const(Native, "PORT_B", INT2FIX(1));
+    rb_define_const(Native, "PORT_C", INT2FIX(2));
+    rb_define_const(Native, "PORT_D", INT2FIX(3));
+    rb_define_const(Native, "PORT_1", INT2FIX(0));
+    rb_define_const(Native, "PORT_2", INT2FIX(1));
+    rb_define_const(Native, "PORT_3", INT2FIX(2));
+    rb_define_const(Native, "PORT_4", INT2FIX(3));
+}

data/ext/brick_pi/tick.h

@@ -0,0 +1,46 @@
+/*
+*  Matthew Richardson
+*  matthewrichardson37<at>gmail.com
+*  http://mattallen37.wordpress.com/
+*  Initial date: June 3, 2013
+*  Last updated: June 4, 2013
+*
+*  You may use this code as you wish, provided you give credit where it's due.
+*
+*  This is a library of functions for timing.
+*/
+
+#ifndef __tick_h_
+#define __tick_h_
+
+#include <time.h>
+
+// gcc -o program test.c -lrt
+
+struct timespec tick_struct;
+unsigned long sec_offset = 0;
+unsigned long nsec_offset = 0;
+
+int ClearTick(){
+  clock_gettime(CLOCK_REALTIME, &tick_struct);
+  sec_offset = tick_struct.tv_sec;
+  nsec_offset = tick_struct.tv_nsec;
+}
+
+unsigned long CurrentTickMs(){
+  clock_gettime(CLOCK_REALTIME, &tick_struct);
+  tick_struct.tv_sec -= sec_offset;
+  tick_struct.tv_nsec -= nsec_offset;
+  tick_struct.tv_nsec /= 1000000;
+  return ((tick_struct.tv_sec * 1000) + tick_struct.tv_nsec);
+}
+
+unsigned long CurrentTickUs(){
+  clock_gettime(CLOCK_REALTIME, &tick_struct);
+  tick_struct.tv_sec -= sec_offset;
+  tick_struct.tv_nsec -= nsec_offset;
+  tick_struct.tv_nsec /= 1000;
+  return ((tick_struct.tv_sec * 1000000) + tick_struct.tv_nsec);
+}
+
+#endif

data/lib/brick_pi.rb

@@ -0,0 +1,4 @@
+require "brick_pi/version"
+require "brick_pi/native"
+require "brick_pi/bot"
+require "brick_pi/motor"

data/lib/brick_pi/bot.rb

@@ -0,0 +1,36 @@
+require 'brick_pi'
+include BrickPi
+
+module BrickPi
+  class Bot
+    attr_accessor :motor1, :motor2
+
+    def initialize
+      Native.BrickPiSetup()
+      @motor1 = ::BrickPi::Motor.new(Native::PORT_A)
+      @motor2 = ::BrickPi::Motor.new(Native::PORT_B)
+      @motor3 = ::BrickPi::Motor.new(Native::PORT_C)
+      @motor4 = ::BrickPi::Motor.new(Native::PORT_D)
+      Native::Address[0] = 1
+      Native::Address[1] = 2
+    end
+
+    def start
+      @stop = false
+      Native.ClearTick()
+      Native.Timeout = 50
+      Native.BrickPiSetTimeout()
+
+      Thread.new do
+        until @stop do
+          Native.BrickPiUpdateValues()
+          sleep(50/1000)
+        end
+      end
+    end
+
+    def stop
+      @stop = true
+    end
+  end
+end

data/lib/brick_pi/motor.rb

@@ -0,0 +1,19 @@
+module BrickPi
+  class Motor
+    def initialize(port)
+      @port = port
+      Native::MotorEnable[@port] = 1
+    end
+
+    def spin(speed)
+      speed = [-100, [100, speed].min].max
+      motor_speed = (speed * 2.55).round
+      puts motor_speed
+      Native::MotorSpeed[@port] = motor_speed
+    end
+
+    def stop
+      spin 0
+    end
+  end
+end

data/lib/brick_pi/version.rb

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

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: brick-pi
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Brandon Hays
+- Charles Lowell
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: BrickPi uses a C library to communicate with Lego Mindstorms motors and
+  sensors via GPIO on the Raspberry Pi. This library wraps the C and exposes a nicer,
+  object-oriented interface via Ruby.
+email:
+- brandon.hays@gmail.com
+executables: []
+extensions:
+- ext/brick_pi/extconf.rb
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- LICENSE.txt
+- README.md
+- Rakefile
+- brick_pi.gemspec
+- ext/brick_pi/BrickPi.h
+- ext/brick_pi/extconf.rb
+- ext/brick_pi/native.c
+- ext/brick_pi/tick.h
+- lib/brick_pi.rb
+- lib/brick_pi/bot.rb
+- lib/brick_pi/motor.rb
+- lib/brick_pi/version.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Ruby library to run the BrickPi drivers for Lego Mindstorms
+test_files: []