VISVESVARAYA TECHNOLOGICAL

UNIVERSITY
BELAGAVI-590018

A Mini
Mini-Project Report on
“8*8*8 LED CUBE “
Submitted in partial fulfilment for the requirement of the award of
degree of

BACHELOR OF ENGINEERING
In
ELECTRONICS AND COMMUNICATION
ENGINEERING
By

MANISH MAYANK 1EP19EC025

MEGANA L 1EP19EC027
ANNU KUMARI 1EP19EC003
003
ASHWINI K S 1EP19EC004
004
Under the guidance of
Dr.Anita R,
Associate Professor,

Jnana Prabha, East Point Campus, Virgonagar Post , Avalahalli ,Bangalore-560049

560049

Department of Electronics & Communication Engineering

Page | 1
 2021-2022

Jnana Prabha, East Point Campus, Virgonagar Post, Avalahalli, Bangalore

Bangalore-560049
560049

Department of Electronics & Communication Engineering

C E RT I F I C A T E
This is to certify that the synopsis titled “8*8*8 LED CUBE”
is a bonafide wor
work being carrying out by Manish Mayank
bearing USN:1EP19EC027, Megana L bearing
USN:1EP19EC027
USN:1EP19EC027, Annu Kumari bearing USN:1EP19EC003,
USN:1EP19EC003
Ashwini K S bearing USN:1EP19EC004 in partial fulfilment for
the requirement of the award of degree of Bachelor of
Engineering in Electronics and Communication Engineering of
Visvesvaraya Technological University, Belagav
Belagavi,i, during the
academic year 2021
2021-2022.. It is certified that all the
corrections/suggestions indicated during intern
internal
al assessment
have been incorporated in this report and deposited in
departmental library. The report has been approved as it
satisfies the academic requirements prescribed by the
university.

Signature of Guide Signature of HOD Signatur

Signature of Principal

External viva:
Name of the Examiners: Signature with date

1.

2.

Page | 2
 DECLARATION
We, MANISH MAYANK bearing
USN:1EP19EC025, MEGANA L bearing
USN:1EP19EC027, ANNU KUMARI bearing
USN:1EP19EC003, ASHWINI K S bearing
USN:1EP19EC004 hereby declare that the
project titled “8*8*8 LED CUBE” is carried
out at EAST POINT COLLEGE OF
ENGINEERING AND TECHNOLOGY,
under the guidance of Dr.Anita R, Associate
Professor, department of ECE, East Point
College of Engineering and Technology,
Bangalore for partial fulfilment of the degree of
Bachelor of Engineering in Electronics and
Communication Engineering under
Visvesvaraya Technological University,
Belagavi.

Date:
Place: Bangalore

MANISH MAYANK(1EP19EC025)
MEGANA L (1EP19EC027)

ANNU KUMARI (1EP19EC003)

ASHWINI K S(1EP19EC004)

Page | 3
 ACKNOWLEDGEMENT
Behind every achievement lies an unfathomable sea of
gratitude to those who actuated it, without whom it
would never have come to existence. To them our
praise the word of gratitude imprinted not just on this
paper but deep in our heart.

We express our profound gratitude towards

Dr. S M Venkatpathi, Chairman, East Point College
of Engineering and Technology, for providing
necessary infrastructure and also honour to Dr. T.K
SATEESH, Principal, EPCET, for creating good
environment for carrying out our project.

We extend our earnest gratitude to Dr. Yogesh G S,

Head Of the Department , Electronics &
Communication Engineering ,EPCET for his
motivation and constant support.

Our sincere thanks to our guide Dr. Anita R,

Associate professor, Dept of ECE, for her guidance
and encouragement throughout the course of project
preparation and completion. Her timely assistance and
valuable suggestions were the motivation factor for
the completion of the project successfully.

Dr. Sachin Sharma, Professor and Dr. V. Navya,

Associate Professor, Dept of ECE, Mini-Project
Co-ordinators, who has helped us in several ways to
learn and explore things by guiding us and providing
us with all the required support.

We also thank all the teaching and non-teaching staff

of ECE Dept, for their valuable guidance. Last but not
least, we would like to utilize this opportunity to
express a sense of gratitude and love to beloved
family and to our dearest friends for their support and
strength.

Page | 4
 ABSTRACT

In this paper three dimensional display is been

presented in this paper which is driven by a
microcontroller. A new form of display has been
introduced in the LED arena. Any size cube of
A*A*A can be effectively implemented which are
cheap as well as rugged. A three dimensional mosaic
of light emitting diode is formed in a cube which is
comprised of light emitting diodes arranged in the
dimensional matrix. This LED cube is like a LED
screen, but it is special in that it has a third dimension,
making it 3D. Think of it as many transparent low
resolution displays. In normal displays it is normal to
try to stack the pixels as close as possible in order to
make it look better, but in a cube one must be able to
see through it, and more spacing between the pixels
(actually it's pixels since it is in 3d) is needed. The
spacing is a trade-off between how easy the layers
behind it are seen, and pixel fidelity. Since it is a lot
more work making a LED cube than a LED display,
they are usually low resolution. A LED display of 8x8
pixels are only 64 LEDs, but a LED cube in 8x8x8 is
512 LEDs. Cheapness and ruggedness is result of the
simplicity of this design. The circuit comprises of a
cube connected to a micro controller which is in turn
connected to a laptop. The
display patterns are sent by the laptop.

Keywords--- Arduino, Three Dimensional Array, LED

Cube, 512 LEDs, 8*8*8 LED

Page | 5
 TABLE OF CONTENTS
1. ABSTRACT 5

2. Introduction 7 -8

3. Requirements

 Hardware Requirements 10-11

 Software Requirements 12

4. Circuit Diagram and Explanation

 Circuit Diagram 13-15

 Explanation 16-18

5. Problem Statement 19

6. Solution Statement 20

7. Program Code

 Code 21-30

 Rotation 30

 Source file another 30-35

 Animation 36-47

8. Pictures Completing and Depicting 48-51

9. Advantages and Disadvantages 52

10. Detailed Plan of Action 53

11. Conclusion and Future Scope 54

12. References 55-56

Page | 6
 CHAPTER 1

INTRODUCTION
The goal of this paper is to be able to output and
modify the LED array fast enough to see a persistent
image. A three dimensional display is been presented
in this paper which is driven by a microcontroller. A
new form of display has been introduced in the LED
arena. Any size cube of A*A*A can be effectively
implemented which are dimensional mosaic of light
emitting diode is formed in a cube which is comprised
of light emitting diodes arranged in the dimensional
matrix.

Cheapness and ruggedness is result of the simplicity

of this design. The circuit comprises of a cube
connected to a micro controller which is in turn
connected to a laptop. A microcontroller has a
dedicated input device and often (but not always) has a
small LED or LCD display for output .Microcontroller
is often small and low cost. Today the technology has
advanced to such an extent that has come a need to
display electronic messages to satisfy all purposes,
whether it is business or domestic use. The solution
found to satisfy this need is the matrix display systems
using LED‟s and LCD‟s. Different kinds of matrix
systems are available today which are capable of
displaying messages, graphics, logos and moving
animation that are sure to capture and hold the attention
of any audience. It provides instantaneous, flexible
communications when and where they‟re needed most.

Page | 7
This LED cube has 512 LEDs. Obviously, having a
dedicated IO port for each LED would be very
impractical. We would need a micro controller with
512 IO ports, and run 512 wires through the cube.
Instead, LED cubes rely on an optical phenomenon
called persistence of vision (POV).If we flash a led
really fast, the image will stay on our retina for a little
while after the led turns off. By flashing each layer of
the cube one after another really fast, it gives the
illusion of a 3d image, when in fact we are looking at a
series of 2d images stacked onto one another. This is
also called multiplexing. With this setup, we only need
64 (for the anodes) + 8 (for each layer) IO ports to
control the LED cube.

The displays patterns are sent by the laptop. We have

chosen the implementation of this project based on our
teams experience and the simplest methods by which
we see to complete our goals. When constructing the
actual LED array we have chosen to construct the
array in layers, verifying that all LEDs function after
every step. Due to close proximity soldering there is a
high chance that some of them may burn out and we
would like to catch this early on.

Once we have all layers completed we will stack them

and solder the layers on by one till they are fully
assembled.

We shall also place several strong strands of wire to

support the structure and increase its integrity. [1] We
have chosen to do the main processing in C through
our MSP430. Since both team members have
significant experience in coding this device and
language it will help develop more intelligent and
succinct code.

Page | 8
 CHAPTER 2
LITERATURE SURVEY
At a glance 3D LED CUBE is an evolution from 2D
DISPLAY. Before this, 2D DISPLAY is usually used
in many electronic devices to display something. After
that, 3D takes a part on the electronic technology
world. The first era of 3D LED CUBE is built the
3x3x3 pocket led. It just use 27 led to shown some
text display or interactive design.

The cube's 3D construction is straightforward and

easy to solder using the included jig and instructions.
With use 27 led’s, the design or text that display is not
too clear. It runs using a PIC16F690 and a piece of
software written in VB.NET. After that, 4x4x4 LED
CUBE has been introduced. 64 led’s has been used to
show the 3D view. Many type of controller can be
used to develop this project. PCB is one of the
controller that been used. For example,
Atmel Atmega16 microcontroller and AVR
microcontroller. Each LED can be addressed
individually in software, enabling it to display
amazing 3d animations. On the programming side,
many type of coding can be built for this project such
as FPGA, mat lab and c language. Now 8x8x8 3D
LED CUBE with 512 led’s has been choose for this
project. It has two ways can be choose as controller
for this project or by arduino controller board .Have a
same concept, but with a different works. [2] C
language with hex files will be use to run the program

The reason why will choose C language because it

related with microcontroller interfacing subject that
had been taken for all electric and electronic student.
It will be use as software to run this program. This
unique way of displaying messages is a very eye
catching and much more stand out compared to the
two dimensional normal panel displays.

Page | 9
 CHAPTER 3

REQUIREMENTS
HARDWARE REQUIREMENTS:

1) 74HC595 IC

2) Arduino Nano

3) LED’s

4) Tinned Copper wire

5) IC Base

6) Transistor BD241B

7) Capacitor 100uF

8) Push Button

9) PCB Board

10) Resistor 220 ohm

Page | 10
Page | 11
SOFTWARE REQUIREMENTS:

• Arduino

Page | 12
 CHAPTER 4
CIRCUIT DIAGRAM AND
EXPLANATION

1.CIRCUIT DIAGRAM

Page | 13
2.Wiring of led cube

3.PCB LAYER

Page | 14
4.SOLIDERING LAYER

Page | 15
 EXPLANATION
A LED cube is like a LED screen, but it is special in
that it has a third dimension, making it 3D. Think of it
as many transparent low resolution displays. In normal
displays it is normal to try to stack the pixels as close as
possible in order to make it look better, but in a cube
one must be able to see trough it, and more spacing
between the pixels (actually it's voxels since it is in 3d)
is needed. The spacing is a trade-off between how easy
the layers behind it are seen, and voxel fidelity. Since it
is a lot more work making a LED cube than a LED
display, they are usually low resolution.

A LED display of 8x8 pixels are only 64 LEDs, but

a LED cube in 8x8x8 is 512 LEDs, an order of
magnitude harder to make! This is the reason LED
cubes are only made in low resolution. A LED cube
does not have to be symmetrical; it is possible to make
a 7x8x9, or even oddly shaped ones. This LED cube has
512 LEDs. Obviously, having a dedicated IO port for
each LED would be very impractical. Thus there comes
the need of a micro controller with 512 IO ports, and
run 512 wires through the cube. Instead, LED cubes
rely on an optical phenomenon called persistence of
vision (POV). When a led is flashed really fast, the
image will stay on the retina for a little while after the
led turns off. By flashing each layer of the cube one
after another really fast, it gives the illusion of a 3d
image, when in fact we are looking at a series of 2d
images stacked onto one another. This is also called
multiplexing.

With this setup, there exists the need of only 64 (for the
anodes) + 8 (for each layer) IO ports to control the
LED cube. There are anodes, cathodes, columns and
layers, for this led cube.

In order to light up an LED, we have to run current

from the anode to the cathode.
The LED cube is made up of columns and layers. The
cathode legs of every LED in a layer

Page | 16
are soldered together. All the anode legs in one column
are soldered together.

Each of the 64 columns is connected to the controller

board with a separate wire. Each column can be 3D
LED CUBE DISPLAY (8x8x8 PIXELS) controlled
individually. Each of the 8 layers also has a separate
wire going to the controller board. Each of the layers is
connected to a transistor that enables the cube to turn
on and off the flow of current through each layer. By
only turning on the transistor for one layer,
current from the anode columns can only flow through
that layer. The transistors for the other layers are off,
and the image outputted on the 64 anode wires are only
shown on the selected layer. To display the next layer,
simply turn off the transistor for the current layer,
change the image on the 64 anode wires to the image
for the next layer. Then turn on the transistor for the
next layer. Rinse and repeat very fast. The layers will
be referred to as layers, cathode layers or ground layers.
The columns will be referred to as columns, anode
columns or anodes.

1. In order to light up an LED, we have to run

current from the anode to the cathode.

2. The LED cube is made up of columns and

layers.

3. The cathode legs of every LED in a layer are

soldered together.

4. All the anode legs in one column are soldered

together.

5. Each of the 64 columns is connected to the

controller board with a separate wire.

6. Each column can be controlled individually.

Each of the 8 layers also has a separate wire
going to the controller board.

Page | 17
7. Each of the layers is connected to a
transistor that enables the cube to turn on
and off the flow of current through each
layer.

8. By only turning on the transistor for one

layer, current from the anode columns can
only flow through that layer.

9. The transistors for the other layers are off,

and the image outputted on the 64 anode
wires are only shown on the selected layer.

10. To display the next layer, simply turn

off the transistor for the current layer,
change the image on the 64 anode wires to
the image for the next layer.

Page | 18
 CHAPTER 5

PROBLEM STATEMENT
 Improper Functioning of LED’s.

 Building the Layers and Stacking up the layers.

 Light Quality , Temperature Dependance , Blue Pollution.

Page | 19
 CHAPTER 6

SOLUTION STATEMENT
 We need 512 LEDs. The first step is to test all the 512
LEDs. You can use a 3V Lithium Cell to test the individual
LED.

 In order to increase the strength of the layer, solder few

connecting wires between LEDs.

 In addition to acting as support bars, these wires will also

short all the cathodes of that particular layer.

 After completing eight layers, we will now proceed with

stacking those layers vertically. After completing eight
layers, we will now proceed with stacking those layers
vertically.

Page | 20
 CHAPTER 7

PROGRAM CODE

#include <SPI.h>
#define XAXIS 0
#define YAXIS 1
#define ZAXIS 2
#define POS_X 0
#define NEG_X 1
#define POS_Z 2
#define NEG_Z 3
#define POS_Y 4
#define NEG_Y 5
#define BUTTON_PIN 8
#define RED_LED 5
#define GREEN_LED 7
#define TOTAL_EFFECTS 8
#define RAIN 0
#define PLANE_BOING 1
#define SEND_VOXELS 2
#define WOOP_WOOP 3
#define CUBE_JUMP 4
#define GLOW 5
#define TEXT 6
#define LIT 7
#define RAIN_TIME 260
#define PLANE_BOING_TIME 220
#define SEND_VOXELS_TIME 140
#define WOOP_WOOP_TIME 350
#define CUBE_JUMP_TIME 200
#define GLOW_TIME 8
#define TEXT_TIME 300
#define CLOCK_TIME 500
uint8_t characters[10][8] =
{
{0x3C, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x3C},
//0

Page | 21
{0x10, 0x18, 0x14, 0x10, 0x10, 0x10, 0x10, 0x3C},
//1
{0x3C, 0x42, 0x40, 0x40, 0x3C, 0x02, 0x02, 0x7E},
//2
{0x3C, 0x40, 0x40, 0x3C, 0x40, 0x40, 0x42, 0x3C},
//3
{0x22, 0x22, 0x22, 0x22, 0x7E, 0x20, 0x20, 0x20},
//4
{0x7E, 0x02, 0x02, 0x3E, 0x40, 0x40, 0x42, 0x3C},
//5
{0x3C, 0x02, 0x02, 0x3E, 0x42, 0x42, 0x42, 0x3C},
//6
{0x3C, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40},
//7
{0x3C, 0x42, 0x42, 0x3C, 0x42, 0x42, 0x42, 0x3C},
//8
{0x3C, 0x42, 0x42, 0x42, 0x3C, 0x40, 0x40, 0x3C},
//9
}
;
uint8_t cube[8][8];
uint8_t currentEffect;
uint16_t timer; uint64_t randomTimer;
bool loading;
void setup() { loading = true; randomTimer = 0;
currentEffect = RAIN;
SPI.begin();
SPI.beginTransaction(SPISettings(8000000,
MSBFIRST, SPI_MODE0));
pinMode(BUTTON_PIN, INPUT_PULLUP);
pinMode(RED_LED, OUTPUT);
pinMode(GREEN_LED, OUTPUT);
randomSeed(analogRead(0));
digitalWrite(GREEN_LED, HIGH); } void loop() {
randomTimer++;
if (digitalRead(BUTTON_PIN) == LOW)
{
clearCube();
loading = true;
timer = 0;
currentEffect++;
if (currentEffect == TOTAL_EFFECTS) {
currentEffect = 0;

Page | 22
}
randomSeed(randomTimer); randomTimer = 0;
digitalWrite(RED_LED, HIGH);
digitalWrite(GREEN_LED, LOW);
delay(500);
digitalWrite(RED_LED, LOW);
digitalWrite(GREEN_LED, HIGH);
}
switch (currentEffect)
{
case RAIN: rain();
break;
case PLANE_BOING: planeBoing();
break;
case SEND_VOXELS: sendVoxels();
break;
case WOOP_WOOP: woopWoop();
break;
case CUBE_JUMP: cubeJump();
break; case GLOW: glow();
break;
case TEXT: text("0123456789", 10);
break; case LIT: lit();
break; default: rain();
}
renderCube();
}
void renderCube()
{
for (uint8_t i = 0; i < 8; i++)
{
digitalWrite(SS, LOW);
SPI.transfer(0x01 << i);
for (uint8_t j = 0; j < 8; j++)
{
SPI.transfer(cube[i][j]); } digitalWrite(SS, HIGH);
}
}
uint8_t planePosition = 0;
uint8_t planeDirection = 0;
bool looped = false;
void planeBoing()
{

Page | 23
 if (loading)
{
clearCube();
uint8_t axis = random(0, 3);
planePosition = random(0, 2) * 7;
setPlane(axis, planePosition);
if (axis == XAXIS)
{
if (planePosition == 0)
{
planeDirection = POS_X;
}
else
{
planeDirection = NEG_X;
}
}
else if (axis == YAXIS)
{
if (planePosition == 0)
{
planeDirection = POS_Y;
}
else
{
planeDirection = NEG_Y;
}
}
else if (axis == ZAXIS)
{
if (planePosition == 0)
{
planeDirection = POS_Z;
}
Else
{
planeDirection = NEG_Z;
}
}
timer = 0;
looped = false; loading = false;
}
timer++;

Page | 24
 if (timer > PLANE_BOING_TIME)
{
timer = 0;
shift(planeDirection);
if (planeDirection % 2 == 0)
{
planePosition++;
if (planePosition == 7)
{
if (looped)
{
loading = true;
}
Else
{
planeDirection++;
looped = true;
}
}
}
Else
{
planePosition--;
if (planePosition == 0)
{
if (looped)
{
loading = true;
}
else
{
planeDirection--;
looped = true;
}
}
}
}
}
void lit()
{
if (loading)
{
clearCube();

Page | 25
 for(uint8_t i=0; i<8; i++)
{
for(uint8_t j=0; j<8; j++)
{
cube[i][j] = 0xFF;
}
}
loading = false;
}
}
void setVoxel(uint8_t x, uint8_t y, uint8_t z)
{
cube[7 - y][7 - z] |= (0x01 << x);
}
void clearVoxel(uint8_t x, uint8_t y, uint8_t z)
{
cube[7 - y][7 - z] ^= (0x01 << x);
}
bool getVoxel(uint8_t x, uint8_t y, uint8_t z)
{
return (cube[7 - y][7 - z] & (0x01 << x)) == (0x01 <<
x);
}
void setPlane(uint8_t axis, uint8_t i)
{
for (uint8_t j = 0; j < 8; j++)
{
for (uint8_t k = 0; k < 8; k++)
{
if (axis == XAXIS)
{
setVoxel(i, j, k);
}
else if (axis == YAXIS)
{
setVoxel(j, i, k);
}
else if (axis == ZAXIS)
{
setVoxel(j, k, i);
}
}
}

Page | 26
 }
void shift(uint8_t dir)
{
if (dir == POS_X)
{
for (uint8_t y = 0; y < 8; y++)
{
for (uint8_t z = 0; z < 8; z++)
{
cube[y][z] = cube[y][z] << 1;
}
}
}
else if (dir == NEG_X)
{
for (uint8_t y = 0; y < 8; y++)
{
for (uint8_t z = 0; z < 8; z++)
{
cube[y][z] = cube[y][z] >> 1;
}
}
}
else if (dir == POS_Y)
{
for (uint8_t y = 1; y < 8; y++)
{
for (uint8_t z = 0; z < 8; z++)
{
cube[y - 1][z] = cube[y][z];
}
}
for (uint8_t i = 0; i < 8; i++)
{
cube[7][i] = 0;
}
}
else if (dir == NEG_Y)
{
for (uint8_t y = 7; y > 0; y--)
{
for (uint8_t z = 0; z < 8; z++)
{

Page | 27
cube[y][z] = cube[y - 1][z];
}
}
for (uint8_t i = 0; i < 8; i++)
{
cube[0][i] = 0;
}
}
else if (dir == POS_Z)
{
for (uint8_t y = 0; y < 8; y++)
{
for (uint8_t z = 1; z < 8; z++)
{
cube[y][z - 1] = cube[y][z];
}
}
for (uint8_t i = 0; i < 8; i++)
{
cube[0][i] = 0;
}
}
else if (dir == POS_Z)
{
for (uint8_t y = 0; y < 8; y++)
{
for (uint8_t z = 1; z < 8; z++)
{
cube[y][z - 1] = cube[y][z];
}
}
for (uint8_t i = 0; i < 8; i++)
{
cube[i][7] = 0;
}
}
else if (dir == NEG_Z)
{
for (uint8_t y = 0; y < 8; y++)
{
for (uint8_t z = 7; z > 0; z--)
{
cube[y][z] = cube[y][z - 1];

Page | 28
}
}
for (uint8_t i = 0; i < 8; i++)
{
cube[i][0] = 0;
}
}
}
void drawCube(uint8_t x, uint8_t y, uint8_t z, uint8_t
s)
{
for (uint8_t i = 0; i < s; i++)
{
setVoxel(x, y + i, z);
setVoxel(x + i, y, z);
setVoxel(x, y, z + i);
setVoxel(x + s - 1, y + i, z + s - 1);
setVoxel(x + i, y + s - 1, z + s - 1);
setVoxel(x + s - 1, y + s - 1, z + i);
setVoxel(x + s - 1, y + i, z);
setVoxel(x, y + i, z + s - 1);
setVoxel(x + i, y + s - 1, z);
setVoxel(x + i, y, z + s - 1);
setVoxel(x + s - 1, y, z + i);
setVoxel(x, y + s - 1, z + i);
}
}
void lightCube()
{
for (uint8_t i = 0; i < 8; i++)
{
for (uint8_t j = 0; j < 8; j++)
{
cube[i][j] = 0xFF;
}
}
}
void clearCube()
{
for (uint8_t i = 0; i < 8; i++)
{
for (uint8_t j = 0; j < 8; j++)
{

Page | 29
cube[i][j] = 0;
}
}
}

ROTATION
#ifndef ROTATION_H
#define ROTATION_H
#include <stdlib.h>
#include <avr/io.h>
#include <inttypes.h>
#define CL_LOOP_DELAY 30 //was 6
void rotate_90_auto ( uint8_t cycle );
void rotate_15_deg( void );
void rotate_30_deg( void );
void rotate_45_deg( void );
void rotate_60_deg( void );
void rotate_75_deg( void );
void rotate_90_deg( void );
#endif

SOURCE FILES
#include "ledcube.h"
#include <stdlib.h>
#include <inttypes.h>
#include <math.h>
#include "ab.h"
void cube_char( char ch, uint8_t z )
{
switch (ch)
{
case '0':
cube[0][2] |= z;
cube[0][3] |= z;
cube[0][4] |= z;
cube[1][1] |= z;
cube[1][5] |= z;
cube[2][1] |= z;
cube[2][2] |= z;
cube[2][5] |= z;

Page | 30
cube[3][1] |= z;
cube[3][3] |= z;
cube[3][5] |= z;
cube[4][1] |= z;
cube[4][4] |= z;
cube[4][5] |= z;
cube[5][1] |= z;
cube[5][5] |= z;
cube[6][2] |= z;
cube[6][3] |= z;
cube[6][4] |= z;
break;
case '1':
cube[0][2] |= z;
cube[0][3] |= z;
cube[0][4] |= z;
cube[1][3] |= z;
cube[2][3] |= z;
cube[3][3] |= z;
cube[4][3] |= z;
cube[5][2] |= z;
cube[5][3] |= z;
cube[6][3] |= z;
break;
case '2':
cube[0][1] |= z;
cube[0][2] |= z;
cube[0][3] |= z;
cube[0][4] |= z;
cube[0][5] |= z;
cube[1][2] |= z;
cube[2][3] |= z;
cube[3][4] |= z;
cube[4][5] |= z;
cube[5][1] |= z;
cube[5][5] |= z;
cube[6][2] |= z;
cube[6][3] |= z;
cube[6][4] |= z;
break;
case '3':
cube[0][2] |= z;
cube[0][3] |= z;
cube[0][4] |= z;

Page | 31
cube[1][1] |= z;
cube[1][5] |= z;
cube[2][5] |= z;
cube[3][4] |= z;
cube[4][3] |= z;
cube[5][4] |= z;
cube[6][1] |= z;
cube[6][2] |= z;
cube[6][3] |= z;
cube[6][4] |= z;
cube[6][5] |= z;
break;
case '4':
cube[0][4] |= z;
cube[1][4] |= z;
cube[2][1] |= z;
cube[2][2] |= z;
cube[2][3] |= z;
cube[2][4] |= z;
cube[2][5] |= z;
cube[3][1] |= z;
cube[3][4] |= z;
cube[4][2] |= z;
cube[4][4] |= z;
cube[5][3] |= z;
cube[5][4] |= z;
cube[6][4] |= z;
break;
case '5':
cube[0][2] |= z;
cube[0][3] |= z;
cube[0][4] |= z;
cube[1][1] |= z;
cube[1][5] |= z;
cube[2][5] |= z;
cube[3][5] |= z;
cube[4][1] |= z;
cube[4][2] |= z;
cube[4][3] |= z;
cube[4][4] |= z;
cube[5][1] |= z;
cube[6][1] |= z;
cube[6][2] |= z;
cube[6][3] |= z;

Page | 32
cube[6][4] |= z;
cube[6][5] |= z;
break;
case '6':
cube[0][2] |= z;
cube[0][3] |= z;
cube[0][4] |= z;
cube[1][1] |= z;
cube[1][5] |= z;
cube[2][1] |= z;
cube[2][5] |= z;
cube[3][1] |= z;
cube[3][2] |= z;
cube[3][3] |= z;
cube[3][4] |= z;
cube[4][1] |= z;
cube[5][2] |= z;
cube[6][3] |= z;
cube[6][4] |= z;
break;
case '7':
cube[0][2] |= z;
cube[1][2] |= z;
cube[2][2] |= z;
cube[3][3] |= z;
cube[4][4] |= z;
cube[5][5] |= z;
cube[6][1] |= z;
cube[6][2] |= z;
cube[6][3] |= z;
cube[6][4] |= z;
cube[6][5] |= z;
break;
case '8':
cube[0][2] |= z;
cube[0][3] |= z;
cube[0][4] |= z;
cube[1][1] |= z;
cube[1][5] |= z;
cube[2][1] |= z;
cube[2][5] |= z;
cube[3][2] |= z;
cube[3][3] |= z;
cube[3][4] |= z;

Page | 33
cube[4][1] |= z;
cube[4][5] |= z;
cube[5][1] |= z;
cube[5][5] |= z;
cube[6][2] |= z;
cube[6][3] |= z;
cube[6][4] |= z;
break;
case '9':
cube[0][2] |= z;
cube[0][3] |= z;
cube[1][4] |= z;
cube[2][5] |= z;
cube[3][2] |= z;
cube[3][3] |= z;
cube[3][4] |= z;
cube[3][5] |= z;
cube[4][1] |= z;
cube[4][5] |= z;
cube[5][1] |= z;
cube[5][5] |= z;
cube[6][2] |= z;
cube[6][3] |= z;
cube[6][4] |= z;
break;
case '!':
cube[0][3] |= z;
cube[3][3] |= z;
cube[4][3] |= z;
cube[5][2] |= z;
cube[5][3] |= z;
cube[5][4] |= z;
cube[6][1] |= z;
cube[6][2] |= z;
cube[6][3] |= z;
cube[6][4] |= z;
cube[6][5] |= z;
break;
case ':':
cube[1][2] |= z;
cube[1][3] |= z;
cube[2][2] |= z;
cube[2][3] |= z;
cube[4][2] |= z;

Page | 34
cube[4][3] |= z;
cube[5][2] |= z;
cube[5][3] |= z;
break;
case '.':
cube[1][2] |= z;
cube[1][3] |= z;
cube[2][2] |= z;
cube[2][3] |= z;
break;
case '?':
cube[0][3] |= z;
cube[2][3] |= z;
cube[3][4] |= z;
cube[4][5] |= z;
cube[5][1] |= z;
cube[5][5] |= z;
cube[6][2] |= z;
cube[6][3] |= z;
cube[6][4] |= z;
break;
case '&':
cube[0][2] |= z;
cube[0][3] |= z;
cube[0][5] |= z;
cube[1][1] |= z;
cube[1][4] |= z;
cube[2][1] |= z;
cube[2][3] |= z;
cube[2][5] |= z;
cube[3][2] |= z;
cube[4][1] |= z;
cube[4][3] |= z;
cube[5][1] |= z;
cube[5][4] |= z;
cube[6][2] |= z;
cube[6][3] |= z;
break;
default:
break;
}
}

ANIMATIONS

Page | 35
#include "ab.h"
#include "ledcube.h"
#include "animations.h"
#include <stdlib.h>
#include <avr/io.h>
#include <inttypes.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <math.h>
#include "rotation.h"
#include "translation.h"
void cube_stripes( void )
{
cube_clear();
for (uint8_t i = 0; i < 8; i++) {
cube[0][0] |= ( 1 << i );
cube[1][7] |= ( 1 << (7-i) );
cube[2][0] |= ( 1 << i );
cube[3][7] |= ( 1 << (7-i) );
cube[4][0] |= ( 1 << i );
cube[5][7] |= ( 1 << (7-i) );
cube[6][0] |= ( 1 << i );
cube[7][7] |= ( 1 << (7-i) );
cube_show_loop(STRIPES_DELAY);
}
for (uint8_t j = 1; j < 8; j++) {
cube_clear();
for (uint8_t i = 0; i < 8; i++) {
cube[0][j] |= ( 1 << i );
cube[1][7-j] |= ( 1 << i );
cube[2][j] |= ( 1 << i );
cube[3][7-j] |= ( 1 << i );
cube[4][j] |= ( 1 << i );
cube[5][7-j] |= ( 1 << i );
cube[6][j] |= ( 1 << i )

return 1;
}
uint8_t cube2_move_x_rev( char cube2[4][4], uint8_t
y, uint8_t x, uint8_t z )
{
if (!(cube2[y][x-1] & (1 << z))){
cube2[y][x] &= ~(1 << z);
cube2[y][x-1] |= (1 << z);

Page | 36
return 0;
}
return 1;
}
uint8_t cube2_move_z_fwd( char cube2[4][4], uint8_t
y, uint8_t x, uint8_t z )
{
if (!(cube2[y][x] & (1 << (z+1)))){
cube2[y][x] &= ~(1 << z);
cube2[y][x] |= (1 << (z+1));
return 0;
}
return 1;
}
uint8_t cube2_move_z_rev( char cube2[4][4], uint8_t
y, uint8_t x, uint8_t z )
{
if (!(cube2[y][x] & (1 << (z-1)))){
cube2[y][x] &= ~(1 << z);
cube2[y][x] |= (1 << (z-1));
return 0;
}
return 1;
}
void cube_2_auto_show( char cube2[4][4] )
{
for (uint8_t layer = 0; layer < 4; layer++){
cube_clear_layer(layer*2+1);
cube_clear_layer(layer*2);
for (uint8_t x = 0; x < 4; x++){
for (uint8_t z = 0; z < 4; z++){
if (cube2[layer][x] & ( 1 << z)) {
cube[layer*2][x*2] |= (1 << (z*2));
cube[layer*2][x*2] |= (1 << (z*2+1));
cube[layer*2][x*2+1] |= (1 << (z*2));
cube[layer*2][x*2+1] |= (1 << (z*2+1));
cube[layer*2+1][x*2] |= (1 << (z*2));
cube[layer*2+1][x*2] |= (1 << (z*2+1));
cube[layer*2+1][x*2+1] |= (1 << (z*2));
cube[layer*2+1][x*2+1] |= (1 << (z*2+1));
}
}
}
}

Page | 37
cube_show_loop(CUBE_AUTO_DELAY);
}
void cubes_2( void )
{
cube_clear();
for (uint8_t i = 0; i < 8; i++ ){
cube[0][i] = 0xFF;
cube[1][i] = 0xFF;
}
cube_show_loop(CUBES2_DELAY);
for (uint8_t i = 0; i < 6; i++) {
move_y_fwd(2,2,3,3);
move_y_fwd(2,6,3,7);
move_y_fwd(6,2,7,3);
move_y_fwd(6,6,7,7);
cube_show_loop(CUBES2_DELAY);
}
for (uint8_t i = 0; i < 4; i++) {
move_y_fwd(0,0,1,1);
move_y_fwd(0,4,1,5);
move_y_fwd(4,0,5,1);
move_y_fwd(4,4,5,5);
cube_show_loop(CUBES2_DELAY);
}
for (uint8_t i = 0; i < 2; i++) {
move_y_fwd(2,0,3,1);
move_y_fwd(6,0,7,1);
move_y_fwd(2,4,3,5);
move_y_fwd(6,4,7,5);
cube_show_loop(CUBES2_DELAY);
}
for (uint8_t i = 0; i < 4; i++) {
move_y_rev(6,2,7,3);
cube_show_loop(CUBES2_DELAY);
}
for (uint8_t i = 0; i < 2; i++) {
move_y_rev(4,0,5,1);
cube_show_loop(CUBES2_DELAY);
}
for (uint8_t i = 0; i < 6; i++) {
move_z_fwd(2,4,3,5);
cube_show_loop(CUBES2_DELAY);
}
for (uint8_t i = 0; i < 2; i++) {

Page | 38
move_y_rev(2,0,3,1);
cube_show_loop(CUBES2_DELAY);
}
for (uint8_t i = 0; i < 6; i++) {
move_z_fwd(0,2,1,3);
cube_show_loop(CUBES2_DELAY);
}
for (uint8_t i = 0; i < 4; i++) {
move_y_fwd(0,2,1,3);
cube_show_loop(CUBES2_DELAY);
}
for (uint8_t i = 0; i < 2; i++) {
move_x_fwd(2,4,3,5);
cube_show_loop(CUBES2_DELAY);
}
cube_show_loop(CUBES2_DELAY*10);
}
/* cubemoving 4x4 */
void cubes_4( void )
{
cube_clear();
for (uint8_t layer = 0; layer <= 3; layer++){
cube[layer][0] = 0b00001111;
cube[layer][1] = 0b00001111;
cube[layer][2] = 0b00001111;
cube[layer][3] = 0b00001111;
}
for (uint8_t layer = 4; layer <= 7; layer++){
cube[layer][4] = 0b11111111;
cube[layer][5] = 0b11111111;
cube[layer][6] = 0b11111111;
cube[layer][7] = 0b11111111;
}
cube_show_loop(CUBES4_DELAY);
for (uint8_t fourtimes = 0; fourtimes <= 3;
fourtimes++){
move_y_rev(4,0,7,3);
cube_show_loop(CUBES4_DELAY);
}
for (uint8_t fourtimes = 0; fourtimes <= 3;
fourtimes++){
move_z_fwd(0,0,3,3);
cube_show_loop(CUBES4_DELAY);
}

Page | 39
for (uint8_t fourtimes = 0; fourtimes <= 3;
fourtimes++){
move_y_fwd(0,4,3,7);
cube_show_loop(CUBES4_DELAY);
}
for (uint8_t fourtimes = 0; fourtimes <= 3;
fourtimes++){
move_y_rev(4,4,7,7);
cube_show_loop(CUBES4_DELAY);
}
for (uint8_t fourtimes = 0; fourtimes <= 3;
fourtimes++){
move_x_rev(0,0,3,3);
cube_show_loop(CUBES4_DELAY);
}
for (uint8_t fourtimes = 0; fourtimes <= 3;
fourtimes++){
move_z_rev(4,0,7,3);
cube_show_loop(CUBES4_DELAY);
}
for (uint8_t fourtimes = 0; fourtimes <= 3;
fourtimes++){
move_z_fwd(4,0,7,3);
cube_show_loop(CUBES4_DELAY);
}
for (uint8_t fourtimes = 0; fourtimes <= 3;
fourtimes++){
move_y_fwd(4,4,7,7);
cube_show_loop(CUBES4_DELAY);
}
for (uint8_t fourtimes = 0; fourtimes <= 3;
fourtimes++){
move_x_fwd(0,0,3,3);
cube_show_loop(CUBES4_DELAY);
}
for (uint8_t fourtimes = 0; fourtimes <= 3;
fourtimes++){
move_y_fwd(4,0,7,3);
cube_show_loop(CUBES4_DELAY);
}
for (uint8_t fourtimes = 0; fourtimes <= 3;
fourtimes++){
move_y_rev(0,4,3,7);
cube_show_loop(CUBES4_DELAY);

Page | 40
}
for (uint8_t fourtimes = 0; fourtimes <= 3;
fourtimes++){
move_z_rev(0,0,3,3);
cube_show_loop(CUBES4_DELAY);
}
}
/* shrinking outline */
void outline_shrink( void )
{
cube_clear();
for (uint8_t i = 1; i < 7; i++ ){
cube[i][0] = 0b10000001;
cube[i][7] = 0b10000001;
}
for (uint8_t i = 1; i < 7; i++){
cube[0][i] = 0b10000001;
cube[7][i] = 0b10000001;
}
cube[0][0] = 0xFF;
cube[7][0] = 0xFF;
cube[0][7] = 0xFF;
cube[7][7] = 0xFF;
cube_show_loop(OUT_SHRINK_DELAY);
for (uint8_t i = 2; i < 6; i++ ){
cube[i][1] = 0b01000010;
cube[i][6] = 0b01000010;
}
for (uint8_t i = 2; i < 6; i++){
cube[1][i] = 0b01000010;
cube[6][i] = 0b01000010;
}
cube[1][1] = 0b01111110;
cube[6][1] = 0b01111110;
cube[1][6] = 0b01111110;
cube[6][6] = 0b01111110;
cube_show_loop(OUT_SHRINK_DELAY);
for (uint8_t i = 3; i < 5; i++ ){
cube[i][2] = 0b00100100;
cube[i][5] = 0b00100100;
}
for (uint8_t i = 3; i < 5; i++){
cube[2][i] = 0b00100100;
cube[5][i] = 0b00100100;

Page | 41
}
cube[2][2] = 0b00111100;
cube[5][2] = 0b00111100;
cube[2][5] = 0b00111100;
cube[5][5] = 0b00111100;
cube_show_loop(OUT_SHRINK_DELAY);
cube[3][3] = 0b00011000;
cube[4][3] = 0b00011000;
cube[3][4] = 0b00011000;
cube[4][4] = 0b00011000;
cube_show_loop(10*OUT_SHRINK_DELAY);
}
void cube_explosion( void )
{
uint8_t led_state = 0b00011000;
for (uint8_t i = 0; i <= 4; i++){
for (uint8_t j = 3; j <= (i+3); j++) {
for (uint8_t k = 3; k <= (i+3); k++){
cube[j][7-k] = led_state;
cube[j][k] = led_state;
cube[7-j][7-k] = led_state;
cube[7-j][k] = led_state;
}
}
cube_show_loop(EXPLOSION_DELAY*(2*i+1));
led_state |= (1 << (3-i)) | (1 << (4+i));
}
cube_show_loop(EXPLOSION_DELAY);
for (uint8_t i = 0; i <= 4; i++){
led_state &= ~((1 << (3-i)) | (1 << (4+i)));
for (uint8_t j = 3; j <= (i+3); j++) {
for (uint8_t k = 3; k <= (i+3); k++){
cube[j][7-k] = led_state;
cube[j][k] = led_state;
cube[7-j][7-k] = led_state;
cube[7-j][k] = led_state;
}
}
cube_show_loop(EXPLOSION_DELAY*(2*i+1));
}
cube_show_loop(EXPLOSION_DELAY);
}
/* wipe */
void cube_wipe( void )

Page | 42
{
cube_test_y();
cube_show_loop(SWIPE_DELAY);
for (uint8_t layer = 0; layer < 7; layer++){
for (uint8_t i = 0; i < 8; i++){
cube[layer][i] = 0;
cube[layer+1][i] = 0xFF;
}
cube_show_loop(SWIPE_DELAY);
}
for (uint8_t layer = 0; layer < 7; layer++){
move_y_rev(0,0,7,7);
cube_show_loop(SWIPE_DELAY);
}
}
void cube_string_belt( char *string )
{
char cube_belt[25];
for (uint8_t i = 0; i < 25; i++) { cube_belt[i] = 0; }
string++;
string++;
while(*string){
set_char_to_belt(*string, cube_belt);
for (uint8_t i = 0; i < 6; i++){
show_belt(cube_belt);
move_belt_left(cube_belt);
}
string++;
}
/* move the rest out */
for (uint8_t i = 0; i < 18; i++){
show_belt(cube_belt);
move_belt_left(cube_belt);
}
}
void move_belt_left( char *belt )
{
for (uint8_t i = 25; i > 1; i--){
belt[i-1] = belt[i-2];
}
belt[0] = 0;
}
void set_char_to_belt( char character, char *belt )
{

Page | 43
cube_clear();
cli();
PORTC = 0x00;
cube_char(character, 1);
for (uint8_t layer = 0; layer < 8; layer++) {
for (uint8_t i = 1; i < 6; i++){
if (cube[layer][i] & 0x01)
belt[5-i] |= (1 << layer);
}
}
cube_clear();
sei();
}
void show_belt( char *belt )
{
cube_clear();
/* right side */
for (uint8_t i = 5; i <= 11; i++){
for (uint8_t j = 0; j < 8; j++){
if (belt[i] & (1 << j))
cube[j][7] |= (1 << (12-i));
}
}
/* front side */
for (uint8_t i = 12; i <= 17; i++){
for (uint8_t j = 0; j < 8; j++){
if (belt[i] & (1 << j))
cube[j][18-i] |= (1 << 0);
}
}
/* left side */
for (uint8_t i = 18; i <= 24; i++){
for (uint8_t j = 0; j < 8; j++){
if (belt[i] & (1 << j))
cube[j][0] |= (1 << (i-17));
}
}
cube_show_loop(SHOW_BELT_DELAY);
}
/* 2 fixed chars rotating */
void cube_fixed_string( void )
{
cube_clear();
_delay_ms(600);

Page | 44
cube_clear();
_delay_ms(600);
cube_char('3', 2);
_delay_ms(600);
rotate_90_deg();
_delay_ms(600);
rotate_90_deg();
_delay_ms(600);
cube_char('d', 2);
_delay_ms(600);
rotate_90_deg();
_delay_ms(600);
rotate_90_auto(8);
_delay_ms(600);
}
/* back to front moving */
void cube_string_to_front( char *string )
{
while(*string) {
_delay_ms(200);
for (uint8_t i = 8; i > 0; i--){
_delay_ms(200);
cube_clear();
_delay_ms(200);
cube_char(*string, (1 << (i-1)));
_delay_ms(300);
cube_show_loop(3);
_delay_ms(300);
}
string++;
_delay_ms(300);
}
}
void cube_string( char *string )
{
while(*string){
cube_clear();
cli();
PORTC = 0x00;
cube_char(*string, 16);
string++;
rotate_90_deg();
rotate_90_deg();
rotate_90_deg();

Page | 45
move_x_rev(1,0,6,7);
move_x_rev(1,0,6,7);
move_x_rev(1,0,6,7);
sei();
cube_show_loop(CUBE_STRING_DELAY);
move_x_fwd(1,0,6,7);
cube_show_loop(CUBE_STRING_DELAY);
move_x_fwd(1,0,6,7);
cube_show_loop(CUBE_STRING_DELAY);
move_x_fwd(1,0,6,7);
cube_show_loop(CUBE_STRING_DELAY);
rotate_90_auto(1);
move_z_rev(0,0,7,7);
cube_show_loop(CUBE_STRING_DELAY);
move_z_rev(0,0,7,7);
cube_show_loop(CUBE_STRING_DELAY);
move_z_rev(0,0,7,7);
cube_show_loop(CUBE_STRING_DELAY);
move_z_rev(0,0,7,7);
cube_show_loop(CUBE_STRING_DELAY);
cube_flash(5);
cube_explosion();
}
cube_explosion();
cube_explosion();
}
void cube_outline( void )
{
cube_clear();
cube_show_loop(OUTLINE_DELAY);
for (uint8_t i = 0; i < 8; i++) {
cube[0][0] |= (1 << i);
cube[i][0] |= 1;
cube[0][i] |= 1;
cube_show_loop(OUTLINE_DELAY);
}

for (uint8_t i = 1; i < 8; i++) {

cube[7][0] |= (1 << i);
cube[7][i] |= 1;
cube[i][0] |= 128;
cube[0][i] |= 128;
cube[0][7] |= (1 << i);
cube[i][7] |= 1;

Page | 46
cube_show_loop(OUTLINE_DELAY);
}
for (uint8_t i = 1; i < 8; i++) {
cube[7][i] |= 128;
cube[7][7] |= (1 << i);
cube[i][7] |= 128;
cube_show_loop(OUTLINE_DELAY);
}
cube_show_loop(20);
/* shrink */
cube_clear();
cube[1][1] = 0b01111110;
cube[1][6] = 0b01111110;
cube[6][1] = 0b01111110;
cube[6][6] = 0b01111110;
for (uint8_t i=2; i< 6; i++) {
cube[1][i] = 0b01000010;
cube[6][i] = 0b01000010;
cube[i][1] = 0b01000010;
cube[i][6] = 0b01000010;
}
cube_show_loop(30);
rotate_90_auto( 8 );
}
void cube_stars( void )
{
for (uint8_t j = 1; j < 30; j++){
for (uint8_t loops = 0; loops < 18; loops++){
cube_clear();
for (uint8_t i = 0; i< j; i++){
uint8_t randx = (uint8_t)rand()%8;
uint8_t randy = (uint8_t)rand()%8;
uint8_t randz = (uint8_t)rand()%8;
cube[randy][randx] = (1 << randz);
}
// cube[randy][randx] &= ~(1 << randz);

cube_show_loop(STARS_DELAY);
}
}
}

Page | 47
 CHAPTER 8

PICTURES DEPICTING AND

COMPLETION MODEL

Page | 48
Page | 49
Page | 50
Page | 51
 CHAPTER 9

ADVANTAGES AND
DISADVANTAGES

ADVANTAGES:

a. Energy Efficient
b. No warm up Period
c. Not Affected by Cold Temperatures
d. Directional
e. Environmental friendly
f. Controllable

DISADVANTAGES:

a. Blue Hazzard
b. Light Quality
c. Temperature Dependance
d. Blue Pollution
e. Voltage Sensitivity

Page | 52
 CHAPTER 10

DETAILED PLAN OF ACTION

• Selection of working LED’s.

• Soldering LED’s in CUBE s.
• Construction of circuit according
to circuit Diagram.
• Integrating LED cube to the
Circuit.
• Uploading the code.

Page | 53
 CHAPTER 11

CONCLUSION AND FUTURE SCOPE

We were successful in completing our mini project “3D

LED CUBE DISPLAY (8x8x8 Pixels)”. It was a
wonderful experience as we attained basic knowledge
on different steps in circuit manufacturing such as
circuit testing and debugging, soldering components,
PCB fabrication etc that will surely help us in our
career in electronics field. By doing this project we also
came to know about the advantages and disadvantages
of our project and its future development. Today we
have a 3D world; a 3D revolution will be formed in the
upcoming years.

This project can be upgraded to a great extent by

suitable add-ons and we expect a bright future for
ourproject in the coming years.

The main applications of our project include toys,

advertisements, study material, research purposes
etc………

Page | 54
 CHAPTER 12

REFERENCES
[1] Aruna pant et al., (2016) “Three Dimensional
Array, 512 LEDs, LED Cube”. Published in
International Journal of Modern Trends in
Engineering and Science, ISSN no: 2348-3121.

[2] Shin-Mim Liu and Kaung-Chang Chou, “The

Design and Implementation of a Low Cost 360 Degree
Color LED Display System”, IEEE Transaction and
Consumer Electronics, Volume 57, No. 2, May 2011.

[3] Ding Yanchuang and GuoJinying ,“LED Display

Screen and Proteus Simulation based on single chip

[4] Microprocessor”, 2nd INT. Conference

(ICIECS) ,Vol. 1 ,No. 4 , 25-26 DEC. 2010
.
[5] Chao – Huang Wei and Phuong –Nhung Bui
“Implementing a web based remote controlled system
for Led dot matrix display”.

[6] Anurag Singh et al., (2015) “Three Dimensional

Cubic Display and Lattice Analysis Using 89C51
Microcontroller”. Published in International Journal of
Engineering Research & Management Technology ,
ISSN: 2348-4039.

Page | 55
Page | 56