Programming 8x8 LED Matrix

Sending Bytes to an 8x8 LED Matrix.

  • 56,774 views
  • 14 comments
  • 51 respects

Components and supplies

Apps and online services

About this project

This is a very easy project for starters like me, the idea of it is to show you how to send bytes to an 8x8 LED matrix.

I have programmed this with all the letters of the alphabet,if you wish to add something go HERE : http://embed.plnkr.co/3VUsekP3jC5xwSIQDVHx/

In that link you will be able to make more shapes.

In the right hand part of the page there will be an 8x8 matrix, with all the Leds off, by clicking them they will turn on and at the bottom of the page there will be the code that represents what you are doing to the matrix, when finished change the "sprite name " and paste the code in the code that I made.

To make this project work you will need the library:

  • FrequencyTimer2

Which you can download from:

Code

Here is the code Arduino
Startin from line 78 (drawScreen(A);) you can change the "A" to whatever you want it to say.But first make sure that you have already declared it
//http://embed.plnkr.co/3VUsekP3jC5xwSIQDVHx/preview

#define ROW_1 2
#define ROW_2 3
#define ROW_3 4
#define ROW_4 5
#define ROW_5 6
#define ROW_6 7
#define ROW_7 8
#define ROW_8 9

#define COL_1 10
#define COL_2 11
#define COL_3 12
#define COL_4 13
#define COL_5 A0
#define COL_6 A1
#define COL_7 A2
#define COL_8 A3

const byte rows[] = {
    ROW_1, ROW_2, ROW_3, ROW_4, ROW_5, ROW_6, ROW_7, ROW_8
};

// The display buffer
// It's prefilled with a smiling face (1 = ON, 0 = OFF)
byte TODOS[] = {B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111};
byte EX[] = {B00000000,B00010000,B00010000,B00010000,B00010000,B00000000,B00010000,B00000000};
byte A[] = {B00000000,B00011000,B00100100,B00100100,B00111100,B00100100,B00100100,B00000000};
byte B[] = {B01111000,B01001000,B01001000,B01110000,B01001000,B01000100,B01000100,B01111100};
byte C[] = {B00000000,B00011110,B00100000,B01000000,B01000000,B01000000,B00100000,B00011110};
byte D[] = {B00000000,B00111000,B00100100,B00100010,B00100010,B00100100,B00111000,B00000000};
byte E[] = {B00000000,B00111100,B00100000,B00111000,B00100000,B00100000,B00111100,B00000000};
byte F[] = {B00000000,B00111100,B00100000,B00111000,B00100000,B00100000,B00100000,B00000000};
byte G[] = {B00000000,B00111110,B00100000,B00100000,B00101110,B00100010,B00111110,B00000000};
byte H[] = {B00000000,B00100100,B00100100,B00111100,B00100100,B00100100,B00100100,B00000000};
byte I[] = {B00000000,B00111000,B00010000,B00010000,B00010000,B00010000,B00111000,B00000000};
byte J[] = {B00000000,B00011100,B00001000,B00001000,B00001000,B00101000,B00111000,B00000000};
byte K[] = {B00000000,B00100100,B00101000,B00110000,B00101000,B00100100,B00100100,B00000000};
byte L[] = {B00000000,B00100000,B00100000,B00100000,B00100000,B00100000,B00111100,B00000000};
byte M[] = {B00000000,B00000000,B01000100,B10101010,B10010010,B10000010,B10000010,B00000000};
byte N[] = {B00000000,B00100010,B00110010,B00101010,B00100110,B00100010,B00000000,B00000000};
byte O[] = {B00000000,B00111100,B01000010,B01000010,B01000010,B01000010,B00111100,B00000000};
byte P[] = {B00000000,B00111000,B00100100,B00100100,B00111000,B00100000,B00100000,B00000000};
byte Q[] = {B00000000,B00111100,B01000010,B01000010,B01000010,B01000110,B00111110,B00000001};
byte R[] = {B00000000,B00111000,B00100100,B00100100,B00111000,B00100100,B00100100,B00000000};
byte S[] = {B00000000,B00111100,B00100000,B00111100,B00000100,B00000100,B00111100,B00000000};
byte T[] = {B00000000,B01111100,B00010000,B00010000,B00010000,B00010000,B00010000,B00000000};
byte U[] = {B00000000,B01000010,B01000010,B01000010,B01000010,B00100100,B00011000,B00000000};
byte V[] = {B00000000,B00100010,B00100010,B00100010,B00010100,B00010100,B00001000,B00000000};
byte W[] = {B00000000,B10000010,B10010010,B01010100,B01010100,B00101000,B00000000,B00000000};
byte X[] = {B00000000,B01000010,B00100100,B00011000,B00011000,B00100100,B01000010,B00000000};
byte Y[] = {B00000000,B01000100,B00101000,B00010000,B00010000,B00010000,B00010000,B00000000};
byte Z[] = {B00000000,B00111100,B00000100,B00001000,B00010000,B00100000,B00111100,B00000000};

float timeCount = 0;

void setup() {
    // Open serial port
    Serial.begin(9600);
    
    // Set all used pins to OUTPUT
    // This is very important! If the pins are set to input
    // the display will be very dim.
    for (byte i = 2; i <= 13; i++)
        pinMode(i, OUTPUT);
    pinMode(A0, OUTPUT);
    pinMode(A1, OUTPUT);
    pinMode(A2, OUTPUT);
    pinMode(A3, OUTPUT);
}

void loop() {
  // This could be rewritten to not use a delay, which would make it appear brighter
delay(5);
timeCount += 1;
if(timeCount <  70) {
drawScreen(A);
} else if (timeCount <  1) {
// do nothing
} else if (timeCount <  150) {
drawScreen(R);
} else if (timeCount <  1) {
// nothing
} else if (timeCount <  270) {
drawScreen(D);
} else if (timeCount <  1) {
// nothing
} else if (timeCount <  350) {
drawScreen(U);
} else if (timeCount <  1) {
// nothing
} else if (timeCount <  430) {
drawScreen(I);
} else if (timeCount <  1) {
// nothing
} else if (timeCount <  510) {
drawScreen(N);
} else if (timeCount <  1) {
  
} else if (timeCount <  550) {
  drawScreen(O);
} else if (timeCount <  1) {
// do nothing
} else if (timeCount <  590) {
drawScreen(EX);
} else if (timeCount <  1) {
// nothing
} else if (timeCount <  630) {
drawScreen(EX);
} else if (timeCount <  1) {

//} else if (timeCount <  670) {
//drawScreen(A);
//} else if (timeCount <  1) {

//} else if (timeCount <  710) {
//drawScreen(R);
//} else if (timeCount <  1) {

//} else if (timeCount <  750) {
//drawScreen(D);
//} else if (timeCount <  1) {

//} else if (timeCount <  790) {
//drawScreen(U);
//} else if (timeCount <  1) {

//} else if (timeCount <  830) {
//drawScreen(I);
//} else if (timeCount <  1) {

//} else if (timeCount <  870) {

//} else if (timeCount <  1) {
  
//} else if (timeCount <  910) {
//  drawScreen(O);
//} else if (timeCount <  1) {

} else {
// back to the start
timeCount = 0;
}
}
 void  drawScreen(byte buffer2[]){
     
    
   // Turn on each row in series
    for (byte i = 0; i < 8; i++) {
        setColumns(buffer2[i]); // Set columns for this specific row
        
        digitalWrite(rows[i], HIGH);
        delay(2); // Set this to 50 or 100 if you want to see the multiplexing effect!
        digitalWrite(rows[i], LOW);
        
    }
}


void setColumns(byte b) {
    digitalWrite(COL_1, (~b >> 0) & 0x01); // Get the 1st bit: 10000000
    digitalWrite(COL_2, (~b >> 1) & 0x01); // Get the 2nd bit: 01000000
    digitalWrite(COL_3, (~b >> 2) & 0x01); // Get the 3rd bit: 00100000
    digitalWrite(COL_4, (~b >> 3) & 0x01); // Get the 4th bit: 00010000
    digitalWrite(COL_5, (~b >> 4) & 0x01); // Get the 5th bit: 00001000
    digitalWrite(COL_6, (~b >> 5) & 0x01); // Get the 6th bit: 00000100
    digitalWrite(COL_7, (~b >> 6) & 0x01); // Get the 7th bit: 00000010
    digitalWrite(COL_8, (~b >> 7) & 0x01); // Get the 8th bit: 00000001
    
    // If the polarity of your matrix is the opposite of mine
    // remove all the '~' above.
}

Schematics

Connections diagram
This is to make the connections easier
Matrix connections s9oj43nrtc

Comments

Similar projects you might like

Gesture Control Robot

Project tutorial by Raunak Oberai

  • 652 views
  • 4 comments
  • 6 respects

Matrix Orbital GTT TFT Thermometer

Project tutorial by MatrixOrbital

  • 499 views
  • 0 comments
  • 1 respect

Pathfinder

Project showcase by Maverick

  • 10,708 views
  • 7 comments
  • 75 respects

Micro Soldering Station

Project tutorial by Paulo Bruckmann

  • 10,177 views
  • 10 comments
  • 33 respects

Back Up SD File To Dropbox

Project tutorial by Andrei Florian

  • 2,893 views
  • 6 comments
  • 33 respects

Arduino-Powered Robot Controlled with The Tactigon

Project tutorial by the tactigon team

  • 500 views
  • 0 comments
  • 3 respects
Add projectSign up / Login