Scribd
Upload
276 views

Arduino Code Sample

This document defines constants for the rows and columns of an 8x8 LED display matrix. It includes arrays containing the on/off patterns for letters of the alphabet. The main loop function sequentially displays letters on the matrix by calling the drawScreen function, with a short delay between letters to spell out the message "VOLTINE WHEN ENJOYING JAMMING KELLY".

Uploaded by

Von Russel Saring
Copyright
© © All Rights Reserved
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
276 views

Arduino Code Sample

This document defines constants for the rows and columns of an 8x8 LED display matrix. It includes arrays containing the on/off patterns for letters of the alphabet. The main loop function sequentially displays letters on the matrix by calling the drawScreen function, with a short delay between letters to spell out the message "VOLTINE WHEN ENJOYING JAMMING KELLY".

Uploaded by

Von Russel Saring
Copyright
© © All Rights Reserved
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
You are on page 1/ 5

#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
};
const byte col[] = {
COL_1,COL_2, COL_3, COL_4, COL_5, COL_6, COL_7, COL_8
};

// The display buffer


// It's prefilled with a smiling face (1 = ON, 0 = OFF)
byte ALL[] =
{B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111};
byte EX[] =
{B00000000,B00010000,B00010000,B00010000,B00010000,B00000000,B00010000,B00000000};
byte A[] =
{ B00000000,B00111100,B01100110,B01100110,B01111110,B01100110,B01100110,B01100110}
;
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 < 20) {
drawScreen(V);
} else if (timeCount < 40) {
// do nothing
} else if (timeCount < 60) {
drawScreen(O);

} else if (timeCount < 80) {


// nothing
} else if (timeCount < 100) {
drawScreen(N);
} else if (timeCount < 120) {
// nothing
} else if (timeCount < 140) {
drawScreen(E);
} else if (timeCount < 160) {
// nothing
} else if (timeCount < 180) {
drawScreen(L);
} else if (timeCount < 200) {
// nothing
} else if (timeCount < 220) {
drawScreen(M);
} else if (timeCount < 240) {

} else if (timeCount < 260) {


drawScreen(I);
} else if (timeCount < 280) {
// nothing
} else if (timeCount < 300) {
drawScreen(E);
} else if (timeCount < 320) {
// nothing
} else if (timeCount < 340) {
drawScreen(R);
} else if (timeCount < 360) {
// nothing
} else if (timeCount < 380) {
drawScreen(O);
} else if (timeCount < 400) {
// nothing
} else if (timeCount < 420) {
drawScreen(B);
} else if (timeCount < 440) {
// nothing
} else if (timeCount < 460) {
drawScreen(B);
} else if (timeCount < 480) {
// nothing
} else if (timeCount < 500) {
drawScreen(I);
} else if (timeCount < 520) {
// nothing
} else if (timeCount < 540) {
drawScreen(E);
} else if (timeCount < 560) {
// nothing
} else if (timeCount < 580) {
drawScreen(O);
} else if (timeCount < 600) {
// nothing
} else if (timeCount < 620) {
drawScreen(W);
} else if (timeCount < 640) {
// nothing
} else if (timeCount < 660) {
drawScreen(E);
} else if (timeCount < 680) {
// nothing
} else if (timeCount < 700) {
drawScreen(N);
} else if (timeCount < 720) {
// nothing
} else if (timeCount < 740) {
drawScreen(M);
} else if (timeCount < 760) {
// nothing
} else if (timeCount < 780) {
drawScreen(J);
} else if (timeCount < 800) {
// nothing
} else if (timeCount < 820) {
drawScreen(A);
} else if (timeCount < 840) {
// nothing
} else if (timeCount < 860) {
drawScreen(J);
} else if (timeCount < 880) {
// nothing
} else if (timeCount < 900) {
drawScreen(K);
} else if (timeCount < 920) {
// nothing
} else if (timeCount < 940) {
drawScreen(E);
} else if (timeCount < 960) {
// nothing
} else if (timeCount < 980) {
drawScreen(L);
} else if (timeCount < 1000) {
// nothing
} else if (timeCount < 1020) {
drawScreen(V);
} else if (timeCount < 1040) {
// nothing
} else if (timeCount < 1060) {
drawScreen(I);
} else if (timeCount < 1080) {
// nothing
} else if (timeCount < 1100) {
drawScreen(N);
} else if (timeCount < 1120) {
// nothing
} else if (timeCount < 1140) {
drawScreen(ALL);
} else if (timeCount < 2200) {

} else {
// end
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.
}

You might also like