Help with Sparkfun RGB Matrix

system · February 14, 2009, 2:57am

Hey everyone :) I just received an RGB matrix with the SPI backpack from Sparkfun and I need help figuring out how to use it. Currently, I have it hooked up to my Arduino Duemilanove as follows: SPI Input: MOSI -> Pin 11 CS -> Pin 10 SCLK -> Pin 13

SPI Output: MISO -> Pin 12 Gound -> Ground

I ran the test code located in the Arduino playground and every time, I just get some random combination of blue, green, and red lights. To my understanding, that's not whats supposed to happen so correct me if I'm wrong. I've programmed with the Arduino before but just basic things (flashing lights, countdown timers, and motion sensors) so I'm really new to this matrix. If anybody could write up a basic tutorial or point me to one, I would really appreciate it. (Not sure if this is in the right area so sorry if its not)

system · February 14, 2009, 3:12am

Did it come with any datasheets? The stock datasheet on their site suggests you really need a bit of decoupling for the power to the board (since current draw will change by quite a bit as you change the lights). It doesn't explicitly say if the SPI lines need pullups, but look for other SPI typical applications to see if that's required.

system · February 14, 2009, 10:25pm

It turns out that the backpack that is displayed on Sparkfun's webpage and datasheet does not match mine. The one that I have has SPI input on one side and SPI output on the other side. All pins are the same on each side (GND, MOSI, CS, SCLK, VCC, VCC) except for MISO instead of MOSI on the output side. Now, if I were to use a resistor, which pin would I hook it up to? I have looked in SOOOO many places and can't find any help. Let me know if you need any pics, would be glad to post some. Oh, and no, it didn't come with any datasheets strangely.

system · February 14, 2009, 10:58pm

I have the same modules as you - they are a new V2 module and have new controller code on the controller (supports up to 196 colors)!

You still communicate with the backpack the same way via SPI, but now the color is controlled via bit encoding (3x3x2). The top three bits control red, the next three control green, and the bottom two control blue.

It's much more powerful, the only downside of this is virtually every sample program that you'll find is not written for this new firmware.

See the post near the end of this thread by CTaylor from Sparkfun: http://www.sparkfun.com/commerce/tutorial_info.php?tutorials_id=91

system · February 14, 2009, 11:02pm

Thank you so much! That makes sense now. I was wondering why my boards was showing different shades of colors and on the data sheets it said that there were only 7 colors. Do you have a sample piece of code that I could look at? Also, that piece of code that CTaylor posted, is that supposed to work for my version of the matrix? I tried pasting the code into the Arduino window and it gives me errors about variables not being declared in certain scopes.

system · February 14, 2009, 11:39pm

The code from that thread is the new firmware that's actually running on the backpack, so you don't need to run it on the Arduino.

For testing you can start with any of the samples for the old version of this board, as the SPI communication stuff is still the same. You just need to create your own subroutine for setting the colors. To start, you might want to set the whole board to the same color using a binary number (ex: 0b11100000 is Red) to get an understanding of what bits control what colors.

Unfortunately, I haven't had a chance to do anything with mine yet, or I'd share my code with you.

I love SparkFun, but it seems like their products are coming out before the documentation more and more often.

system · February 15, 2009, 12:22am

Alright, thanks a lot for the help, gonna give your advice a shot. If you do write any basic code for it, I’d love to see it so feel free to PM me.

system · February 15, 2009, 2:02am

Okay, I've been able to make the matrix go completely red, completely green, and completely blue. The problem with blue and green is that the LED's flash constantly, but don't do that when the LED's are red. Also, how would I go about making arrays for the matrix to create images? Would I just do something like: int data[] = { 0b11100000,0b00011100,0b00000011, ... etc etc } Or is there an easier way to do this?

system · February 15, 2009, 3:37am

I just noticed this - disconnect ALL the wires from the SPI output on the LED Matrix! (that may be causing all of your problems). You are only supposed to use those if you’re piggyback other LED matrixes.

Try this sample - it is from somewhere in the forums, but I cannot find the original. I apologize to the original thread author for re-posting their work.

Also, you do not need to state the color number in binary, every time. I suggested that you test with it until you understood which bits where controlling which color - but stating the same value in hex is usually more common.

The program below draws a heart on the LED Matrix. Note that it specifies a 1 for the color (blue), and that each 1 is a BYTE not a bit. SO when you setup a matrix to display a picture/letter in this manner, you are taking up 64 bytes of memory. This is not ideal if you wanted to store a large number of images (say the entire alphabet).

I’m working on making some code to define some standard colors, and look into storing alphabet characters in bitfields, that can later be extracted and sent as bytes before transfer.

Anyway here’s the program - it should work fine on your backpack. If it doesn’t work then re-check your wiring, power and ground lines. Note - there is no wire for Pin12 and the backpack doesn’t use/need it.

(Sorry about the long post - the new ‘copy for forum’ tool in IDE 13 doesn’t work with the code notation.)

// Simple program to test using the Arduino with the RGB Matrix
// & Backpack from Sparkfun. Code is a combination of Heather Dewey-Hagborg,
// Arduino Forum user: Little-Scale, and // Daniel Hirschmann. Enjoy!
//
// The Backpack requires 125Khz SPI, which is the slowest rate
// at which the Arduino’s hardware SPI bus can communicate at.
//
// We need to send SPI to the backpack in the following steps:
// 1) Activate ChipSelect;
// 2) Wait 500microseconds;
// 3) Transfer 64bytes @ 125KHz (1 byte for each RGB LED in the matrix);
// 4) De-activate ChipSelect;
// 5) Wait 500microseconds
// Repeat however often you like!

#define CHIPSELECT 10//ss
#define SPICLOCK 13//sck
#define DATAOUT 11//MOSI / DI
#define DATAIN 12//MISO / DO

int data =
{0,0,0,0,0,0,0,0,
0,0,1,1,0,1,1,0,
0,1,0,0,1,0,0,1,
0,1,0,0,0,0,0,1,
0,0,1,0,0,0,1,0,
0,0,0,1,0,1,0,0,
0,0,0,0,1,0,0,0,
0,0,0,0,0,0,0,0
};

char spi_transfer(volatile char data)
{
SPDR = data; // Start the transmission
while (!(SPSR & (1<<SPIF))) // Wait the end of the transmission
{
};
}

void setup()
{
byte clr;
pinMode(DATAOUT,OUTPUT);
pinMode(SPICLOCK,OUTPUT);
pinMode(CHIPSELECT,OUTPUT);
digitalWrite(CHIPSELECT,HIGH); //disable device

SPCR = B01010001; //SPI Registers
SPSR = SPSR & B11111110; //make sure the speed is 125KHz

/*
SPCR bits:
7: SPIEE - enables SPI interrupt when high
6: SPE - enable SPI bus when high
5: DORD - LSB first when high, MSB first when low
4: MSTR - arduino is in master mode when high, slave when low
3: CPOL - data clock idle when high if 1, idle when low if 0
2: CPHA - data on falling edge of clock when high, rising edge when low
1: SPR1 - set speed of SPI bus
0: SPR0 - set speed of SPI bus (00 is fastest @ 4MHz, 11 is slowest @ 250KHz)
*/

clr=SPSR;
clr=SPDR;
delay(10);
}

void loop()
{
delay(100);
int index = 0;
digitalWrite(CHIPSELECT,LOW); // enable the ChipSelect on the backpack
delayMicroseconds(500);
for (int i=0;i<8;i++) for (int j=0;j<8;j++)
{
spi_transfer(data[index]);
index++;
}
digitalWrite(CHIPSELECT,HIGH); // disable the ChipSelect on the backpack
delayMicroseconds(500);
}

system · February 15, 2009, 2:18pm

Okay, the code that you gave me works great! The only thing is is that when I go to change the background color around the heart (change the 0’s to 100’s) the colors start to change sporadically. Do I need a resistor to fix this or is this just part of the issue that this code doesn’t work for this matrix?

system · February 15, 2009, 11:41pm

The only thing is is that when I go to change the background color around the heart (change the 0’s to 100’s) the colors start to change sporadically.

This should not be happening, so check for typos in your code. If that isn’t it, re-check your wiring. How are you powering the LCD module? Make sure its connected directly to a 5V source and not an Arduino output. Do you have both Vcc lines connected to 5V? (Perhaps turning on more LEDs is consuming more power than your source can provide.)

The only thing that has changed with this version of the LED Matrix is what byte you send it for what color. All of the other communication code is exactly the same.

When I change the 0’s in the data matrix to 100 (as shown below), the heart displays just fine. However, instead of drawing a blue heart on a black background, its now a blue heart on a redish-orange background.

This code reflects the changes that I made to the code that was originally posted above:

int data[] =
{100,100,100,100,100,100,100,100,
100,100,1,1,100,1,1,100,
100,1,100,100,1,100,100,1,
100,1,100,100,100,100,100,1,
100,100,1,100,100,100,1,100,
100,100,100,1,100,1,100,100,
100,100,100,100,1,100,100,100,
100,100,100,100,100,100,100,100};

system · February 16, 2009, 12:47am

Okay, now I feel like an idiot. I didn't even have the VCC lines attached to a power source at all :D What's the problem with having the VCC connected to the Arduino's 5v? I tried using that along with your code and it works like a charm. I would use a different supply but all I have are 9volt batteries.

system · February 16, 2009, 12:52am

New Update - Fix to SPI Clock Rate

I just discovered that the SPI rate was setup too fast in the sample code i was using. Try changing this line in setup:

SPCR = B01010011;             //SPI Registers

The (incorrect) code was working fine for me originally, but as I was trying to add more modules I started to have problems.

And to answer your question above:

What's the problem with having the VCC connected to the Arduino's 5v?

I was trying to state that you should NOT connect it to an output pin (say digital pin 13) and using the digital output to power it. It's okay to connect to the Arduino 5V pin, but be aware as the Datasheet mentions, it can dray up to 300mA of power.

system · February 16, 2009, 12:58am

Thanks, that would have caused me many problems if I ever tried adding more modules. Also, for scrolling messages, is there an easier way to make them other than making a whole bunch of “still images” and putting them in sequence?

system · February 17, 2009, 11:00pm

If anybody has some example code they would like to post for the new matrix, please feel free to do so. I would love to have some code to look off of and mess around with.

system · February 18, 2009, 2:37am

Sorry - I wont have any time to work on furthering my efforts until this weekend.

Unfortunately, it doesn't appear that many people have this new version of the board yet. However, there are many sample programs our there for the old matrix that you can use, and just tweak the color parameters.

wyojustin · February 20, 2009, 2:18am

Here is some code I’ve been working on for a bike tail light / turn signal. It is working great. It is written for the RG matrix.

/* Code to control a bike light and turn signal. Two LED SPI matricies available
from SparkFun are chained to the arduino
arduino->Master->Slave
This created a 16x8 matrix. Two consecutive writes fills both master and slave. If you have a AVR
programmer, you can just program the LED matrices them selves (Version 2).

Author
– Justin Shaw wyojustin@gmail.com
*/

/* define constants */
#define DATAOUT 11 //MOSI
#define DATAIN 12 //MISO // NOT USED
#define SPICLOCK 13 //sck
#define SLAVESELECT 10 //ss
#define LEFT_ENABLE 3
#define RIGHT_ENABLE 2
#define LEFT_PIN 4
#define RIGHT_PIN 5
#define ACC_X_PIN 6
#define ACC_Y_PIN 7
#define BREAK_PIN 6
#define WAIT 50 // min delay between frames.

#define BLACK 0
#define RED 1
#define GREEN 2
#define ORANGE 3

// globals
int count = 0; // how long has currtent mode been active?
int mode_id = 0; // current mode id to detect a change in modes
int target = 0; // nominal accel value, set in calibrate()
int tol = 0; // accel tolarance, set in calibrate()
char out_buffer[64]; // output buffer for led matrix

struct Mode{
// mode has two screens that alternate at period rate.
int id; // unique id
int foreground_color1;
int background_color1;
int foreground_color2;
int background_color2;
int period; // # of WAIT periods
byte *foreground; // bitmap image
};
Mode normal, left, right, left_break, right_break, breaklight, current_mode;

// here are the bitmaps that the various modes use.
byte BACKGROUND = {
B11111111,
B11111111,
B11111111,
B11111111,
B11111111,
B11111111,
B11111111,
B11111111
};

byte X = {
B11100111,
B01000010,
B00100100,
B00011000,
B00011000,
B00100100,
B01000010,
B11100111
};
byte CHECKED = {
B00001111,
B00001111,
B00001111,
B00001111,
B11110000,
B11110000,
B11110000,
B11110000
};

byte STOPSIGN = {
B00111100,
B01111110,
B11111111,
B11111111,
B11111111,
B11111111,
B01111110,
B00111100
};

byte UP = {
B00011000,
B00111100,
B01111110,
B11111111,
B00111100,
B00111100,
B00111100,
B00111100
};

byte DOWN = {
B00010000,
B00110000,
B01111111,
B11111111,
B11111111,
B01111111,
B00110000,
B00010000
};

byte RIGHT = {
B00001000,
B00001100,
B11111110,
B11111111,
B11111111,
B11111110,
B00001100,
B00001000
};

byte LEFT = {
B00010000,
B00110000,
B01111111,
B11111111,
B11111111,
B01111111,
B00110000,
B00010000
};

/* fix arduino bug that gets wrong PW */
int myPulseIn(int pin){
long start = millis();
long pulse_start;

// wait for low
while(millis() < start + 1000 && digitalRead(pin) == HIGH){
}
return pulseIn(pin, HIGH);
}

/*
Average several pulsewidth readings
pin – pin number
n – number of samples to average
*/
int ave_pulse(int pin, int n){
float out = 0.;

for(int i = 0; i < n; i++){
// out += pulseIn(pin, HIGH);
out += myPulseIn(pin);
}
Serial.println((long) (out / n));
return (int) (out / n);
}

/*
Write image to output buffer.
Should be preceeded by a call to fill_buffer()
/
void write_buffer(){
digitalWrite(SLAVESELECT,LOW); // enable
delay(5);
for(int i = 0; i < 64; i++){
shiftOut(DATAOUT, SPICLOCK, MSBFIRST, out_buffer);*

} *
digitalWrite(SLAVESELECT,HIGH); // disable device*
delay(5);*
}
/*
Fill a buffer usting bitmap (data) in the specified color
Bit locations with a 0 are untouched so layers can be added consecutivly
A call to fill_buffer() should preceed write_buffer.
The buffer is filled first to avoid timing errors involved in non-sequential writes
*/
void fill_buffer(byte* data, int color){
byte bit;*
for (int i = 0; i < 8; i++)*
{*
for(int j = 0; j < 8; j++){*
bit = data[7 - i] >> j & B0000001;*
if(bit){*
out_buffer[i * 8 + j] = color % 4;
}*
}*
}*
}
/*
Check turn signals and accel to determine mode
set current_mode as per the sensor state
reset count if mode has changed
*/
void get_mode(){
boolean left_val, right_val, break_val;*
int acc_y, pulse_y;*
Mode out;*
// get mode from turn signals*
left_val = digitalRead(LEFT_PIN) == LOW;*
right_val = digitalRead(RIGHT_PIN) == LOW;*
// read accel*
pulse_y = ave_pulse(ACC_Y_PIN, 1);*
if (mode_id == breaklight.id ||*
mode_id == right_break.id ||*
mode_id == left_break.id){*
break_val = pulse_y < target - tol / 2;*
}*
else{*
break_val = pulse_y < target - tol;*
} *
// select mode*
if(left_val && break_val){*
out = left_break;*
}*
else if(left_val){*
out = left;*
}*
else if(right_val && break_val){*
out = right_break;*
}*
else if(right_val){*
out = right;*
}*
else if(break_val){*
out = breaklight;*
}*
else{*
out = normal;*
}*
current_mode = out;*
// reset count if mode has changed*
if(current_mode.id != mode_id){*
count = 0;*
}*
mode_id = current_mode.id;*
}
/*
Calibrate accel. This should be stored but that would cost more hardware!
Assume level and still to calibrate horizontal.
*/
void calibrate(){
int maxx = 0, minn = 15000, n = 5;*
int y;*
float mean;*
fill_buffer(BACKGROUND, BLACK);*
fill_buffer(X, RED);*
write_buffer();*
write_buffer();*
for(int i = 0; i < n; i++){*
y = ave_pulse(ACC_Y_PIN, 1);*
if(y > maxx) maxx = y;*
if(y < minn) minn = y;*
mean += y;*
}*
mean /= n;*
target = mean;*
tol = 150;*
fill_buffer(BACKGROUND, BLACK);*
fill_buffer(X, GREEN);*
write_buffer();*
write_buffer();*
delay(1000);*
}
/*
Initialize pins and modes, calibrate.
*/
void setup(){
Serial.begin(9600);*
pinMode(DATAOUT, OUTPUT);*
pinMode(DATAIN, INPUT); // NOT USED*
pinMode(SPICLOCK,OUTPUT);*
pinMode(SLAVESELECT,OUTPUT);*
digitalWrite(SLAVESELECT,HIGH); //disable device*
pinMode(RIGHT_ENABLE, OUTPUT);*
digitalWrite(RIGHT_ENABLE, HIGH);*
pinMode(LEFT_ENABLE, OUTPUT);*
digitalWrite(LEFT_ENABLE, HIGH);*
// set up sensor inputs*
pinMode(LEFT_PIN,INPUT);*
pinMode(RIGHT_PIN,INPUT);*
pinMode(BREAK_PIN,INPUT);*
pinMode(ACC_X_PIN, INPUT);*
pinMode(ACC_Y_PIN, INPUT);*
// initialize modes*
normal.id = 0;*
normal.foreground_color1 = ORANGE;*
normal.background_color1 = BLACK;*
normal.foreground_color2 = BLACK;*
normal.background_color2 = ORANGE;*
normal.period = 8;*
normal.foreground = CHECKED;*
left.id = 1;*
left.foreground_color1 = BLACK;*
left.background_color1 = BLACK;*
left.foreground_color2 = ORANGE;*
left.background_color2 = BLACK;*
left.period = 8;*
left.foreground = LEFT;*
right.id = 2;*
right.foreground_color1 = ORANGE;*
right.background_color1 = BLACK;*
right.foreground_color2 = BLACK;*
right.background_color2 = BLACK;*
right.period = 8;*
right.foreground = RIGHT;*
left_break.id = 3;*
left_break.foreground_color1 = BLACK;*
left_break.background_color1 = BLACK;*
left_break.foreground_color2 = RED;*
left_break.background_color2 = BLACK;*
left_break.period = 4;*
left_break.foreground = LEFT;*
right_break.id = 4;*
right_break.foreground_color1 = RED;*
right_break.background_color1 = BLACK;*
right_break.foreground_color2 = BLACK;*
right_break.background_color2 = BLACK;*
right_break.period = 4;*
right_break.foreground = RIGHT;*
breaklight.id = 5;*
breaklight.foreground_color1 = RED;*
breaklight.background_color1 = BLACK;*
breaklight.foreground_color2 = BLACK;*
breaklight.background_color2 = BLACK;*
breaklight.period = 2;*
breaklight.foreground = BACKGROUND;*
calibrate();*
}
/*
Get current mode, display current mode, pause.
*/
void loop(){
digitalWrite(RIGHT_ENABLE, HIGH);*
digitalWrite(LEFT_ENABLE, HIGH);*
get_mode();*
if(count == 0){*
// mode has changed, fill both screens.*
fill_buffer(BACKGROUND, current_mode.background_color2);*
fill_buffer(current_mode.foreground, current_mode.foreground_color2);*
write_buffer();*
fill_buffer(BACKGROUND, current_mode.background_color1);*
fill_buffer(current_mode.foreground, current_mode.foreground_color1);*
write_buffer();*
digitalWrite(RIGHT_ENABLE, HIGH);*
digitalWrite(LEFT_ENABLE, HIGH);*
}*
else if(count % current_mode.period == 0){*
fill_buffer(BACKGROUND, current_mode.background_color1);*
fill_buffer(current_mode.foreground, current_mode.foreground_color1);*
write_buffer();*
digitalWrite(RIGHT_ENABLE, HIGH);*
digitalWrite(LEFT_ENABLE, HIGH);*
} *
else if (count % current_mode.period == current_mode.period / 2){*
fill_buffer(BACKGROUND, current_mode.background_color2);*
fill_buffer(current_mode.foreground, current_mode.foreground_color2);*
write_buffer();*
}*
else if( count % current_mode.period > current_mode.period / 2){*
digitalWrite(RIGHT_ENABLE, LOW);*
digitalWrite(LEFT_ENABLE, LOW);*
}*
delay(WAIT);*
count+= 1;*
}

system · February 22, 2009, 3:44am

Thanks for the code Justin. Now, are your matrices the new ones with Input on one side and Output on the other? Been trying to pick at your code to mess around with it and even just using some of the pieces you defined as backgrounds I've been gettin weird responses from my matrix. Either way, appreciate you posting your program.

wyojustin · February 24, 2009, 2:43am

You bet. I posted the schematic tonight too at http://wyoinnovation.blogspot.com.

I am using a brand new v8 backpack. If you let me know what it is doing, I might of had the same issue.

Justin

system · February 27, 2009, 2:13pm

Still haven't been able to make anything of jusstin's code, it's pretty complicated for me since I'm just getting started. Might als have to do with the fact that his was written for te RG matrix and not the RGB matrix. Anyway, if anybody else has a simple little program I can test out for a single matrix, I would be grteful to see it. Thanks!