Programming 8x8 LED Matrix

Sending Bytes to an 8x8 LED Matrix.

  • 72,558 views
  • 20 comments
  • 66 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

Music Adaptive RGB LED with Arduino and Processing

Project in progress by ounane mohamed elfarouk

  • 553 views
  • 4 comments
  • 7 respects

Cellular IoT with Blynk & Hologram

by Moheeb Zara

  • 4,159 views
  • 9 comments
  • 12 respects

Step Sequencer

Project tutorial by costantinorizzuti

  • 722 views
  • 0 comments
  • 5 respects

Voice Controlled Rover

Project tutorial by Brink.IO

  • 472 views
  • 0 comments
  • 5 respects

WormGear Mechanism Test

Project tutorial by Brijesh Singh

  • 1,202 views
  • 3 comments
  • 4 respects

Add Remote Control to Your Lamp

Project tutorial by littlelab

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