BLE controlled Minecraft nightlight

A few months ago my daughter asked me to print something for her on my 3D printer. I asked her what she wanted and she said "something Minecraft". We started looking at designs on thingiverse and came across a design for a Mincraft ore block. I thought it might be cool to make a night light out of it using Adafruit Neopixel LED strips and an Adafruit Pro Trinket microcontroller to change the colors. I ended up having a bit of scope creep on this project and it took way longer than I expected but the end result was pretty neat and I learned some new things. Originally I was just going to program the Arduino to cycle through colors but then I came across the Adafruit Bluefruit LE breakout board and realized it would be fairly easy to add BLE control to the project. In the end this was the most involved Arduino coding project I've done so far. At the bottom of this post there are links to download the 3D models and Arduino code if you want to build one yourself.

3D Printing

The first step in this project was to 3D print the plastic parts. I printed the cube at 1.5 times the original size which made the final dimensions 105mm on each side. I had to print it with supports for the holes and a brim to minimize lifting from the print bed. It took almost 18 hours to print it. After it was done printing I realized there wasn't good way to attach a base to the cube (other than glue) so I used OpenSCAD to add recessed corner posts with screw holes and reprinted it.


I used FreeCAD to design an insert that fits inside the cube. The LED strips sit in the channels and the electronics go in the square opening on the bottom.

Diffuser panels

With the 3D printing done the next step was to make some diffuser panels to go on the inside of the cube so you don't see the individual LEDs. I considered 3D printing the diffusers out of natural filament but that would have taken several hours. I had some scrap plexiglass in the garage so I cut out pieces to fit the top and four sides. I sanded both sides of the plexi with 80 grit sandpaper to make them opaque. I tested the diffusers with the LED flash light on my iPhone and they seemed to work pretty well.

Assembling and wiring the insert

The first step in assembling the insert was to cut and solder the LED strips. Adafruit Neopixel LED strips can be cut with scissors. There are cut lines printed on the strip between each LED. I designed the insert to fit three LEDs on each side and five on top. To minimize the number of jump wires I would need to solder I cut three strips and bent them around the edges.


I used the tip of my soldering iron to melt holes for the wiring to pass through to the center of the insert. With the strips set in place I soldered jumper wires onto the end of the LED strips, passing the wires through the holes so the wires were on the inside of the insert and not getting in the way of the LEDs. Then I used hot glue to attach the LED strips to the insert. The Neopixels are addressed by numbers starting with zero for the first LED on the strip so they need to be wired back up as a continuous strip. The strips are also directional so you need to pay attention to the arrows on the strips, wiring them so the arrows all face the same direction. I put a female header on the end of the of the strip wiring so I could plug it into the circuit board.

Breadboarding the control circuit

I hooked up the circuit on a breadboard to test it out before soldering. Controlling the LEDs only requires one digital pin. The BLE breakout board communicates over SPI.

Once I had everything wired up I loaded the Adafruit_NeoPixel strandtest example code to make sure all my LEDs were working correctly.

Soldering the control board

The two main components of the control board are the Pro Trinket microcontroller and the Bluefruit BLE breakout board. I decided to use headers so the microcontroller and BLE chip can be easily replaced if needed. I started with a half-size Adafruit Perma-Proto broad. To make the control circuit as compact as possible I placed the Pro Trinket on one side and the BLE board on the other. To do this I needed to cut the traces for a few holes. I used an X-ACTO to cut and scrape the traces. I used my multimeter to verify there was no continuity.

Cutting the traces on the Perma-Proto board

After cutting the traces I soldered on the headers for the Pro Trinket and the BLE breakout.

Pro Trinket plugged into its headers

BLE board plugged into its header

I finished up the wiring between the microcontroller and BLE board and added some male headers for connecting the LEDs and power input. After that I used a Dremel to cut down the proto-board as small as possible.


Here is the finished control circuit.

Power switch and power input

On the back of the cube I added a barrel connector for power and a small toggle switch. The toggle switch controls the power to the microcontroller and the LEDs. The power cable is routed through a small hole in the white insert.

Assembling all the parts

The insert was secured to the cube with countersunk head 4-40 screws. I added some stick on rubber feet and stuffed the control board in the square opening.


One mistake I made was using too much hot glue to attach the LED wiring inside the square hole of the insert. The extra glue caused the control board to protrude a couple millimeters. Not a huge deal but I would have liked the bottom to be completely flat. I had planned to put a cover on the bottom so I just designed it to account for the protrusion. I fired up FreeCAD again and whipped something up.

The cover was attached with pan head 4-40 screws.

Writing the code

For the Arduino code I started with Adafruit's nRF8001 echoDemo example. It basically does serial communication between the Arduino and an iPhone app.

Adafruit also provides a demo iPhone app called Bluefruit LE Connect. The app lets you interact with the BLE breakout board without having to do any iOS development.

After playing around with the color picker in the iOS app I saw it was sending RGB values formatted like this: !C180255

The exclamation point indicates a command, the next character indicates what kind of command, followed by red/green/blue values. This seemed like a good format for all of the commands I planned to send to the cube. I started planning out all the commands on my whiteboard.

One thing I hadn't worked with before on Arduino boards was EEPROM memory. I understood basically how it worked but hadn't actually used it in a project yet. Turn out to be very straight forward. On the Atmega328P chip there are 1024 possible EEPROM memory locations and you can store one byte of info in each location.

Here are the major features of my Arduino code on the cube:

• Set the whole cube to a single color
• Set the color of each side individually
• Activate animations (Pulse, Rainbow, and Cycle)
• Set a new BLE name on the cube and save it to EEPROM
• Save the current colors and animation settings to EEPROM
• Read settings from EEPROM on start up
• Set base values in EEPROM for new boards
• Flash green to confirm commands

I won't go into great detail about the code itself. You can read through it here if you would like. I tried to comment it well. I'm sure it can be improved quite a bit so feel free to send suggestions or pull requests.

Demo

Here is a (long) video showing most of the functions of the cube

Download links

As promised here are links to download everything if you want to make one of these yourself. The Fritzing diagram lists all the parts needed.

Arduino Code: https://github.com/matt448/MinecraftNightLight

Adafruit BLE Library: https://github.com/adafruit/Adafruit_nRF8001

3D Models: http://www.thingiverse.com/thing:1023004

iOS App: https://itunes.apple.com/us/app/adafruit-bluefruit-le-connect/id830125974

Arduino, CAN Bus and 29 bit extended IDs

I noticed in my blog traffic stats that people are searching for information about 29 bit CAN IDs and I have been curious about this topic myself. I haven't come across 29 bit CAN IDs in a vehicle until recently and seeing these extended IDs in use in a car made want to understand how to use them with Arduino boards and MCP2515 CAN controllers. I wrote a blog post back in October 2013 that covers how to send data between two Arduino boards using a CAN bus so you may want to check that out if you aren't familiar with how a CAN bus works. That post is available here. This post is specifically about using 29 bit CAN IDs with an Arduino and the MCP2515 CAN controller chip.

CAN Bus IDs

There are two types of CAN Bus IDs. In the first version of the CAN Bus spec (2.0A) the IDs were made up of 11 bits. These are also known as base frame format messages. This allows for message IDs between 0x000 and 0x7FF. Which works out to be 2048 possible CAN IDs.

Binary, Decimal and Hex representation of the max 11 bit ID

 As CAN Busses were added to heavy equipment and as vehicles became more complex those 2048 possible IDs were not enough to handle the increased number of sensors. CAN 2.0B was created which increased the size of IDs from 11 bits to 29 bits. CAN 2.0B allows for over 536 million different IDs. 29 bit messages are also known as extended frame format messages. 18 bits were added to the original 11 bits in an separate field in a CAN message. There is a flag in the message that signals if a message is an 11 bit or 29 bit message. 11 bit and 29 bit messages can coexist on the same CAN bus.

Binary, Decimal and Hex representation of the max 29 bit ID

There are some trade-offs with 29 bit CAN IDs though. The latency is increased, the messages use more bandwidth and error detection performance is decreased. But if you have run out of IDs I suppose these are worthwhile trade-offs.

11 bit code example

Let's take a look at a very simple example of using an MCP2515 CAN controller with an Arduino and 11 bit CAN IDs. I am using a Seeed Studio CAN-BUS Shield but the MCP2515 is just an SPI chip that can be wired up with minimal external components.
In this 11 bit example I am using a CAN ID of 0x07B in hex (123 in decimal).


Here you can see my receiver Arduino is receiving CAN messages with an ID of 123.

29 bit code example

Next let's look at an example of sending 29 bit CAN IDs. In this example I am using a CAN ID of 0x17F8140E in hex (or 402134030 in decimal).


Here you can see my receiver Arduino is receiving CAN messages with an ID of 402134030.

sendMsgBuf format

The key piece of this example code is the sendMsgBuf function. This function is part of the
MCP_CAN_lib. This is where messages are flagged as 11 bit or 29 bit.

11 bit: CAN.sendMsgBuf(0x07B, 0, 8, canMsg);

29 bit: CAN.sendMsgBuf(0x17F8140E, 1, 8, canMsg);

The format for this function is sendMsgBuf(can_id, id_type, dlc, data_buf)

can_id - id number for your message in hex or decimal.

id_type - flag for 11 or 29 bit message id. 0=11bit, 1=29bit

dlc - Number of bytes in the message data

data_buf - The data transmitted in the message.


If you are going to try out these examples you should download Cory Fowler's fork of the MCP_CAN_lib.


Resources

http://en.wikipedia.org/wiki/CAN_bus
https://github.com/coryjfowler/MCP_CAN_lib
http://www.seeedstudio.com/wiki/CAN-BUS_Shield

CAN Bus to UART using an Adafruit Pro Trinket

I have been fighting with the onboard CAN controller on my BeagleBone Black trying to
get it to work properly for months. In the process I learned about pin muxing, bone-capemgr and compiling overlays. I was able to bring up the can0 interface and receive can messages with candump but the interface was unstable. It would randomly hang and stop receiving messages. If I tried to send anything with cansend I would get a kernel stack traces in dmesg and the can0 interface would hang.  I tried Angstrom, Ubuntu and the latest Debian images all with the same results. Maybe my BBB board has a hardware problem. It is one of the early Rev B boards. Or maybe I'm running into some sort of kernel driver bug. Whatever the issue I am done trying to figure out what the eff is wrong with it and I just want to move forward with my project. (and yes I was using a transceiver). I considered bypassing the onboard can controller and talking to a MCP2515 over SPI but that gets into compiling a custom kernel for the BBB and I don't want to use up a SPI port. I mention all of this because I know someone out there will say "why didn't you just use the onboard can controller". I tried and I am done fighting with it.

My attempt at using the CAN controller on
the BBB with an MCP2562 transceiver

What now?

Once I decided I wasn't going to get the onboard BBB can controller to work I started thinking about options. My first attempt at a workaround was an Arduino Uno with a Seeed CAN Bus shield connected to the BBB with a USB cable. I read the data from the serial port created over the USB connection. While this worked it was a bit bulky and fragile. The USB cable is much too big, the Uno with a shield is big and the Uno would reset when serial communication started (though there is a workaround for this).

I took a break from this project for a while and in the meantime I ordered a few Adafruit Trinkets and Pro Trinkets just to play around with. The Pro Trinket has the same microcontroller as the Uno but the board is much, much smaller.

Size comparison between Uno, Pro Trinket and Trinket.
(Photo credit: Adafruit)

Pro Trinket CAN to UART Converter

The Pro Trinket has SPI and UART plus a bunch of digital and analog pins. After playing around with the Trinket I realized I could build a CAN Bus to UART converter that would be able to push CAN data into the BBB over a UART. The BeagleBone is a 3.3volt device so I used the 3volt version of the Pro Trinket so I didn't have to use any level shifters. For the CAN Bus controller I used an MCP2515 and for the CAN transceiver I used an MCP2562. The MCP2515 connects to the Arduino using a SPI connection. Here is the circuit I came up with:

Here is a Fritzing breadboard diagram of the circuit:

The UART serial connection between the Arduino and the BeagleBone runs at 115,200 bps so you might drop a few packets on a very busy CAN bus running at 500kbps. My Digital Dashboard project is only going to have a few devices broadcasting CAN packets so the UART speed will be more than enough for my purposes. The current version only transmits CAN data to the BBB. It should be fairly trivial to connect the BBB UART1 TX to the RX on the Arduino. It would also need a bit of code to parse the message received on the UART and write it to the CAN bus. I'm planning on adding the functionality soon and I'll write up another post when I have that done. I'm planning on changing the Arduino code to use an External Interrupt so the Trinket can perform a few other functions instead of just polling for incoming messages.

The Arduino Code

The way this works is the MCP2515 has an INT (interrupt) pin that signals when a CAN message has been received. The INT pin drives Pin3 on the Arduino low and triggers it to read messages from the MCP2515 buffer. Once a message has been read from the MCP2515 buffer it is formatted into a NMEA-ish string that is written to the serial port and transmitted to the BBB on UART1.

Screenshot of CAN data coming in on UART1

 Here is the Arduino code:

Setting up the BeagleBone

The pins on the BeagleBone need to be configured to be used as a UART. I used Adafruit's python IO library to do this. When you install their library it will create the overlays needed to configure the pins. Follow the instructions on their learn site here: https://learn.adafruit.com/setting-up-io-python-library-on-beaglebone-black. Here is the code to receive the CAN messages on BBB UART1:

Costs

The price for these parts wasn't bad at all

Adafruit Pro Trinket 3v - $9.95
16Mhz Crystal - $1.12
Two 22pF ceramic capacitors - $0.66
MCP2515 CAN controller - $2.18
MCP2562 CAN transceiver - $1.12

Total: $15.03


Well that's it for now. Next I'm going to work on modifying the code to use External Interrupts and then see if I can get it setup to receive messages over the UART. I also need to get this thing moved from the breadboard and soldered on to some protoboard.




Resources
http://www.embedded-things.com/bbb/enable-canbus-on-the-beaglebone-black/
http://www.adafruit.com/product/2010
https://learn.adafruit.com/setting-up-io-python-library-on-beaglebone-black/uart
http://ww1.microchip.com/downloads/en/DeviceDoc/21801d.pdf
http://ww1.microchip.com/downloads/en/DeviceDoc/25167B.pdf