Adafruit 10DOF Sensor Library for BeagleBone Black

Screen Shot 2016-01-02 at 3.11.25 PM
L3GD20 Gyro Ouput in CSV Format

As part of my ongoing rover project, I have started writing C++ libraries for the various sensors and actuators. The first device I have begun to tackle writing a library for is the Adafruit 10DOF sensor. This sensor has libraries available for Arduino boards and in Python. Writing library code for the sensor hasn’t been without issues but has been a great learning experience. There are a lots of online tutorials but I have found that Derek Molloy’s tutorials have been consistently helpful. I recently bought Derek Molloy’s book Exploring BeagleBone: Tools and Techniques for Building with Embedded Linux to aid me in working with the BeagleBone Black. I did so because I found his freely available tutorials extremely thorough and have had the most success following them compared to other material online. His book includes the material in his tutorials plus more including  introductory topics such as administering Linux and basic electronic components to advanced topics such as interacting with the onboard Programmable Real-time Units (PRUs).

To start writing the driver for the 10DOF, I focused on one sensor at a time. I took the Arduino code for each sensor provided by Adafruit and went about replacing all calls to the Wire library to appropriate calls to the libmraa library. The 10DOF sensor uses the I2C bus to communicate with all the sensors and, initially, I used Derek Molloy’s I2CDevice class to handle communication. After some success with this class, I decided to use Intel’s libmraa for handling all communication between the BeagleBone  Black and peripherals. I made this switch because Molloy’s class is not as complete as libmraa and only deals with I2C communication whereas the libmraa api includes SPI, GPIO, UART and PWM functionality. This means I can use libmraa for controlling the motors and other sensors instead of having to write my own code or relying on separate libraries for sensors using different communication interfaces.

Writing the driver for each sensor was not as simple as replacing some functions in the Arduino code. The datatypes in the Arduino code had to be changed to match those recognized by the g++ compiler while staying true to the datatype used to store the data in the sensor’s registers. This required a close reading of each sensor’s data sheet to make sure I was storing the register data in variables with the same datatype. I won’t go into fine detail as to what changes I made since you can see the code yourself and compare it to the original Adafruit Arduino code.

There were a few times while working with the 10DOF sensor when I lost connection to it. This can occur when a register on a sensor is mishandled causing the sensor lock up becoming unresponsive. To deal with these lock ups when working remotely, I wired a P2N2222 transistor into the 10DOF sensor circuit so that I could power cycle the sensor if it became unresponsive. This has happened a couple of times while developing the driver software. I’ve been careful to make sure I’m properly working with the registers but mistakes still happen. Thankfully no damage was done and I haven’t needed to use this feature yet.

I’m still working on the driver and will post another update when it’s completed. The code for the BMP180, L3GD20 and LSM303 sensors can be found on my github page. Just make sure you have the libmraa library installed on your BeagleBone Black. This code is still under development and is provided with no warranty so use it at your own risk. If you have any comments on the code, please use the github issues page. My plan is to roll these separate libraries into one library for use with the 10DOF sensor but I will keep the repos for each sensor for those who buy the sensors individually.


Goeff 2.0: Following in the Tracks of the Mars Rovers

Laying the foundation.

We Can Rebuild Him…

After watching The Martian a few weeks ago, I was inspired to create my own semi-autonomous rover. Unfortunately, the privilege of space travel is still reserved for a few select exceptional individuals and even they may only get the chance once or twice. I’d still like to help push humanity towards the stars so towards this end I’d like to develop my skills with embedded electronics which control the probes and craft we use to explore our neighbors. So I decided to redevelop my previous “rover” I called Geoff. In his first form, Geoff was an object avoiding robot built with an Arduino Uno, IR distance sensor and the Dagu Rover 5 chassis.

With this project, my goal is to capture certain aspects of a semi-autonomous rovers like those we’ve sent to Mars. I’m also including features that are characteristic of probes used here at home like direct control. The goals I’ve chosen to focus on are listed:

  • Prioritized Reactions
    • Suspend activities and begin charging
    • Send logged data when threshold reached
  • Environmental Awareness
    • Map best route to goals
    • Reconnaissance using sensors with logging
  • Energy independence
    • Solar panels charge on-board batteries.
  • Remote Access and Control
    • Software updates
    • Navigation updates
    • Direct control

Better than he was before. Better… Stronger… Faster

In selecting the parts for Geoff 2.0, I strove to mimic the functionality of a Mars rover while keeping the price and difficulty within my means. I already have a BeagleBone Black and after some research found that it would be a capable board for this project. Not only does it support various ARM Linux distributions and plenty of GPIOs, it also include two realtime microcontrollers built in called Programmable Realtime Units (PRUs). With these, I can stick with the Debian image that it came with without patching the kernel or replacing it with a real time kernel. I still may move to a real time kernel in the future but that will be implemented later in the interest of quickly setting up the hardware and testing it.

Tentative Parts Listing

  • BeagleBone Black Rev C running Debian Wheezy (kernel version)
  • Navigation
    • Adafruit 10-DOF IMU Breakout – L3GD20H + LSM303 + BMP180
    • Adafruit Ultimate GPS
  • Power
    • 2 x USB / DC / Solar Lithium Ion/Polymer charger (v2)
    • INA219  High Side DC Current Sensor Breakout
    • 2 x Lithium Ion Battery – 3.7v 2000mAh (wired in serial)
    • UBEC DC/DC Step-Down (Buck) Converter 5V @ 3A
    • 2 x Medium 6V 2W Solar panel (2.0 Watt)
  • Drive
    • 4 x 7.2V DC motors
    • 4 x Quadrature Encoders
    • 2 x Adafruit TB6612 1.2A DC/Stepper Motor Driver Breakout Board
  • various sensors
    • temp and humidity
    • IR motion
    • object detection via sonar
    • CMUCam5 Pixy camera

The first system I have focused on after building the rover’s frame, pictured above, has been the power system. Since I want this rover to be autonomous, I have designed it to be as energy independent as possible. To achieve this, I designed a power system that incorporates LiPo battery packs that can be charged via a solar panel. Implementing and testing the solar component will be done later on in the project since we’re going into winter here in Alberta and because there is a lot of work to be done before the freedom solar panels grant is of any use.

This slideshow requires JavaScript.

Since the drive system will be one of the largest power hogs in the system, I have been working on it in tandem with the power system. The drive subsystem will consist of the four motors and encoders found in Dagu’s Rover 5 chassis. These motor are rated for 7.2V with a stall current of 2.5A  and a free run current of 210 mA. As mentioned above, power will come from two 3.7V LiPo batteries wired in serial with a total output of 7.4V. The drive system will be wired in parallel with the rest of the rover. Unregulated power will go the drive system, branching off before the 5V regulator. Regulated power will go to the BeagleBone Black, sensors, and motor drivers. The central power system circuit has been wired up and I’m in the process of creating a simple wiring harness  for the motors. Once that is complete, I’ll begin the process of writing programs to test the drive system’s wiring, power drain and capabilities.

I’ll be posting more updates as I continue my work be sure to come back for more soon! Here is a link to the Trello board I’m using to manage the project. I do comment on the tasks as needed and many tasks include checklists to document their stage of completion.

Update History:

11/16/2015: Update power sub-system fritzing diagram to fix errors and reflect changes made to circuit during implementation.