1738

# How Does 8×8 led matrix Work?

In this project, we make 8×8 LED matrix display and how it works and make coding for this project. First of all, we take any operating system for drove this LED matrix today we use Arduino for making this 8×8 Led Matrix using Arduino. Today we make This LED matrix for display any message on it. This display is a small version of the LED Hoarding board in hoarding board large LED Display use for making it. But that is not a big Display. It is a combination of this small display.

So today we discuss some Question for related to this topic.

• What is 8×8 led matrix Display?
• How to make 32*8 LED Matrix Display Video
• Structure of the LED matrix.
• How does 8×8 led matrix work?
• Which component require doing this projects?
• Logics For Display on it?
• Display various Image on it.

## What is 8×8 led matrix Display?

8×8 Led matrix display is one kind of small pixel display for print any BMP file in it. In this display, we not only print image in it but also we can also view a video in it. Usually, all display is work on Vision of perception method, and this display also works on the same bases it means that only one line of the Display glow at a time. Which are bribe show in Logic and working part? This Display contains 64 LED for making a Display. In this Display, we make Row and Collom for formatting a Display. We print on that display bu using a by accessing Row Collom Element.

## Structure of led matrix Display

Here we show 4×4 LED Matrix display in this image similar 8×8 display configured Structure of LED Matrix is shown in this image we make 4 row and 4 Collom for make this display. We connect all anode of the LED of Row, and all cathode of the LED In Collom or vice versa Are join Together which shown in this Image.

In this display when we apply potential at the point according to this LED glow. But if we want to print image on It we have to need Control Unit, so we use Arduino to drive this Circuit Which shown in an image.

## How does 8×8 led matrix work?

This Display based on Vision of perception So we can Glow only one line at a time. Due to It is very fast that’s why we don’t show blink, and we look one image. Our brain considers if 25 frames per second is a continuous image for us. If the icon is blinking more than 25 than time, then we see at one steady image.

Here we take one example for explaining it in this we make one heart shape for low frequency and how we can look at this image first is blinking and the second one is a steady image that is a result of this.

So this is a final result of the sequence.

Hear led flick 25 or more time in a single second, so we don’t see blink and our brain think this thing is steady.

• ## Which component require doing this projects?

Here we use some component for making 4×4 LEd matrix Display.

• 66x LED
• 2x Green LED
• 1x 7805 IC
• 1x 1N4007
• 1x 28 pin IC Base
• 1x Arduino Uno board
• 8x BC557 transistor
• 2x 74HC595 IC
• 1x 220e resistor
• 1x 100e resistor
• 8x 1k resistor
• 8x 470e Resistor
• 1x 10uf capacitor
• 2x 0.1uf Capacitor
• 2x 22pf Capacitor
• 1x 16 MHz crystal
• 1x 5v supply
• 1x Push switch
• 1x Terminal block
• 4x 5Wire connector
• 3x PCB 2″x3″

## Logics For Display on it?

In this Display, only one Collom glow at a time and one by one all 8 row glow rapidly for making Constant image Image. You can see a logic in this image printing heart shape.

## Coding for this Projects

const int clockPin=11; //11 clock
const int latchPin=12; //12 latch
const int dataPin= 13; //13 data

//int data=7;

void setup()
{
pinMode(11, OUTPUT);
pinMode(12, OUTPUT);
pinMode(13, OUTPUT);
Serial.begin(9600);
}
int x,y,z,r;

int mat_lan_limit; //8*8 squar
int display_length= 16; //length colloum
int display_Width = 7; //length colloum
int display_frame = 13; //length colloum
int display_Matrix= 8; //length colloum

unsigned char mat[]={

0x7c,0x0a,0x09,0x0a,0x7c,//0x00, //A 0
0x7f,0x49,0x49,0x36,0x00, //B 1
0x3e,0x41,0x41,0x22,0x00, //C 2
0x7f,0x41,0x41,0x3e,0x00, //D 3
0x7f,0x49,0x49,0x41,0x00, //E 4
0x7f,0x09,0x09,0x01,0x00, //F 5
0x3e,0x41,0x51,0x32,0x00, //G 6
0x7f,0x08,0x08,0x7f,0x00, //H 7
0x41,0x41,0x7f,0x41,0x41,//0x00, //I 8
0x31,0x41,0x3f,0x01,0x00, //J 9
0x7f,0x08,0x14,0x22,0x41,//0x00, //K 10
0x7f,0x40,0x40,0x40,0x00, //L 11
0x7f,0x02,0x04,0x02,0x7f,//0x00, //M 12
0x7f,0x04,0x08,0x10,0x7f,//0x00, //N 13
0x3e,0x41,0x41,0x41,0x3e,//0x00, //O 14
0x7f,0x09,0x09,0x06,0x00, //P 15
0x3e,0x41,0x51,0x3e,0x40,//0x00, //Q 16
0x7f,0x19,0x29,0x46,0x00, //R 17
0x26,0x49,0x49,0x32,0x00, //S 18
0x01,0x01,0x7f,0x01,0x01,//0x00, //T 19
0x3f,0x40,0x40,0x3f,0x00, //U 20
0x1f,0x20,0x40,0x20,0x1f,//0x00, //V 21
0x7f,0x20,0x10,0x20,0x7f,//0x00, //W 22
0x63,0x14,0x08,0x14,0x63,//0x00, //X 23
0x03,0x04,0x78,0x04,0x03,//0x00, //Y 24
0x61,0x51,0x49,0x45,0x43,//0x00, //Z 25

0x3e,0x41,0x41,0x3e,0x00,//0x00, //0 26
0x40,0x42,0x7f,0x40,0x00,//0x00, //1 27
0x62,0x51,0x49,0x46,0x00,//0x00, //2 28
0x22,0x49,0x49,0x36,0x00,//0x00, //3 29
0x18,0x14,0x12,0x7f,0x10,//0x00, //4 30
0x4f,0x49,0x49,0x31,0x00,//0x00, //5 31
0x3e,0x49,0x49,0x32,0x00,//0x00, //6 32
0x61,0x11,0x09,0x07,0x00,//0x00, //7 33
0x36,0x49,0x49,0x36,0x00,//0x00, //8 34
0x26,0x49,0x49,0x3e,0x00,//0x00, //9 35

0x1c,0x3e,0x7c,0x3e,0x1c,//0x00, //: 36

};

unsigned char matinv[300];

int mat1,mat2,line,seq,mat_lan;

void loop()
{
unsigned int invdata,invdata2,fram;

unsigned char x,tmp,z;

// You can use onlt A to Z and use ":" for print heart.
//
unsigned char printstr[]={": HELLO LEARN WITH FUN TECHNOLOGY :"};
//
// You can use onlt A to Z and use ":" for print heart.

unsigned char matptr[300];

x=0;
z=0;

while(printstr[x]!='\0')
{
if(printstr[x]<59)
{
tmp=printstr[x]-22;
}
else
{
tmp=printstr[x]-65;
}
if(printstr[x]==32)
{
matptr[z++]=0;
matptr[z++]=0;
matptr[z++]=0;
matptr[z++]=0;
}
else
{
for(y=0;y<5;y++)
{
matptr[z++]=mat[((tmp)*5)+y];
}
}
if((mat[(((tmp)*5)+y)-1])!=0)
{
matptr[z++]=0;
}
x++;
}

// matptr[z++]=0xff;

mat_lan_limit=z/8;
mat_lan_limit+=4;

for(x=0;x<4;x++)
{
for(y=0;y<8;y++)
{
matptr[z++]=0;
}
}
z--;

for(x=0;x<display_length;x++)
{
matptr[z++]=0;
}
x=0;

for(x=0;x<32;x++)
{
matinv[x]=0x00;
}

for(z=0;z<mat_lan_limit;z++)
{
for(y=0;y<display_Width;y++)
{
invdata=0;
for(x=0;x<display_Matrix;x++)
{
invdata2=matptr[((z*8)+x)];
invdata>>=1;
if(((invdata2>>=y)%2)==1){invdata+=0x80;}
}
matinv[((z+4)*8)+6-y]=invdata;
}
}

while(1)
{
delay(1000);
for(z=0;z<mat_lan_limit;z++)
{
for(seq=0;seq<8;seq++)
{
tmp=seq;
for(fram=0;fram<display_frame;fram++)
{
for(line=0;line<display_Width;line++)
{
mat1=matinv[(line)+(z*8)];
for(x=0;x<8;x++)
{
digitalWrite(dataPin,!(mat1%2));mat1>>=1;
digitalWrite(clockPin, 1);
digitalWrite(clockPin, 0);
}
mat1=matinv[(line)+((z+1)*8)];
for(x=0;x<8;x++)
{
digitalWrite(dataPin,!(mat1%2));mat1>>=1;
digitalWrite(clockPin, 1);
digitalWrite(clockPin, 0);
}
mat1=matinv[(line)+((z+2)*8)];
for(x=0;x<8;x++)
{
digitalWrite(dataPin,!(mat1%2));mat1>>=1;
digitalWrite(clockPin, 1);
digitalWrite(clockPin, 0);
}
mat1=matinv[(line)+((z+3)*8)];
for(x=0;x<8;x++)
{
digitalWrite(dataPin,!(mat1%2));mat1>>=1;
digitalWrite(clockPin, 1);
digitalWrite(clockPin, 0);
}
mat1=matinv[(line)+((z+4)*8)];
for(x=0;x<seq;x++)
{
digitalWrite(dataPin,!(mat1%2));mat1>>=1;
digitalWrite(clockPin, 1);
digitalWrite(clockPin, 0);
}
//////////////////////////////////////////////////////////
/*
for(x=0;x<seq;x++)
{
digitalWrite(clockPin, 1);
digitalWrite(clockPin, 0);
}*/
//////////////////////////////////////////////////////////////////////////////////////////
for(x=0;x<8;x++)
{
if(x==line+1){digitalWrite(dataPin,0);}////////////// LINE PRINT
else {digitalWrite(dataPin,1);}
digitalWrite(clockPin, 1);
digitalWrite(clockPin, 0);
}
//////////////////////////////////////////////////////////////////////////////////////////

digitalWrite(latchPin, 1);///////////////////// OP PRINT
digitalWrite(latchPin, 0);//delay(1);
/////////////////////////////////////////////////////////////////////////////

}
}
seq=tmp;
}
}
}
}

/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////