7-Segment Display Interfacing and Programming

5.1 Introduction

Till now you have learn what is an embedded system, basic memory
architecture of a microcontroller, how to implement assembly language and use of
some softwares like pinnacle 52, keil-C and flash magic; we also have come across
how to interface LEDs from a microcontroller and how to generate different pattern
through it. now its time to move forward and learn one more step ahead towards the
completion of our 6-weak training. so here today we will learn about 7-Segment
display; How to interface and program it; and some of the applications of it.

5.2 7-Segment Display



A 7-Segment display is a useful electronic component use to
produce numeric, alphabetic and some non-alphabetic symbols using a specific
arrangement of LEDs as shown in figure here.

A 7-Segment display has 10-Pins representing each a, b, c, b, e, f, g and
h LEDs respectively along with two extra pins for GND and VSS. following shown
an original 7-Segment display device along with its pin diagram. LED h is also
denoted by symbol dp.





















As we have studied in LED interfacing a 7-segment display is also
interfaced in same way as it is also made of LEDs. So we can interface LEDs in three
ways bu here difference is that 7-Segment displays comes in two types by
manufacturers i.e. "Common Anode" and "Common Cathode"; the logics are
shown in figure below.



and



and thus which logic is o implement is on the bases of these specifications provided
by manufacturer. interfacing in our case has been shown below.

5.3 7-Segment Display Interfacing

We interface 7-Segment display with port zero of microcontroller; and to
do so we connect P0.0 to P0.7 to Pin a to dp (h) of 7-Segment display respectively;
and connect Vss terminal of display to 5V Power supply and GND pin to ground.
the configuration is shown in figure below.




5.4 Cascading seven segment display

Here we have a question in mind that if we want to interface more then
one 7-Segment display with microcontroller what we will do??? as we are using one
port for one 7-segment display if we use all the four ports for four 7-Segment
display??? isn't it less efficient???

The answer of all these questions are hidden under this topic
"CASCADING" cascading refers to connecting similar or non-similar component
from the same connections with a reference of enabling and disabling each
components according to specification.

For cascading four 7-Segment display we use the following schem where
all the a to f (dp) pins of 7-segment display are connected paralleled to the port zero
of microcontroller along with common ground and Vss pin of all the four 7-segments
are use for enabling and disabling them so are connected to port two of
microcontroller along with NOT Gate in order to " " and thus clearing or sending "0"
on pins of port two cause enabling the display and signal "1" cause disabling it.





5.5 7-Segment Display Programming

Programming a 7-Segment display is so easy as to program a LED array
but here pattern should be generate in a manner so as it appears as a meaningful
character and with cascaded mode we also need to send "clear" (0) or "set bit" (1)
signal on respected pins of port two in order to enable or disable respected 7-
Segment display. The signals on Port zero which can generate meaningful characters
on 7-Segment display are listed in table below.




Example

Lets write a program to show character "3" on 7-Segment display.

Showing character "3" on 7-Segment display
;****************************************
;** Showing character "3" on 7-Segment display **
;****************************************

org 0000h ;Origin

main: ;Main subroutine

clr P2.0 ;Enabling Display-1
sbit P2.1 ;Disabling Display-2
sbit P2.2 ;Disabling Display-3
sbit P2.3 ;Disabling Display-4

mov P0,11110010b ;Sending LED pattern of character "3" at port
zero

jmp $

end ;End

OUTPUT








5.6 Generating counting from 0 to 9

0 to 9 Counter
;*************************************
;************ 0 to 9 Counter *************
;*************************************

org 0000h ;Start

main: ;Main Subroutine

clr P2.0 ;Enabling Display-1
sbit P2.1 ;Disabling Display-2
sbit P2.2 ;Disabling Display-3
sbit P2.3 ;Disabling Display-4

mov P0,#0FCh ;Sending character "0" to Port zero
call delay ;Calling Delay Function

mov P0,#60h ;Sending pattern of character "1" to Port
zero
call delay ;Calling Delay Function

mov P0,#0DAh ;Sending pattern of
character "2" to Port zero
call delay ;Calling Delay Function

mov P0,#0F2h ;Sending pattern of
character "3" to Port zero
call delay ;Calling Delay Function

mov P0,#66h ;Sending pattern of
character "4" to Port zero
call delay ;Calling Delay Function

mov P0,#0B6h ;Sending pattern of
character "5" to Port zero
call delay ;Calling Delay Function

mov P0,#0BEh ;Sending pattern of
character "6" to Port zero
call delay ;Calling Delay Function

mov P0,#0E0h ;Sending pattern of
character "7" to Port zero
call delay ;Calling Delay Function

mov P0,#0FEh ;Sending pattern of
character "8" to Port zero
call delay ;Calling Delay Function

mov P0,#0F6h ;Sending pattern of
character "9" to Port zero
call delay ;Calling Delay Function

jmp main ;Infinite Loop

delay: ;Delay Function

mov 40h,#0FFh ;Move FFh to memory location with address
40h
L1: ;Label "L1"
mov 41h,#99h ;Move 99h to memory 41h
djnz 41h,$ ;Jump here till 41h becomes zero
djnz 40h,L1 ;Jump to "L1" till 40h becomes zero
ret ;return

end ;End


OUTPUT




5.7 Generating counting from 0 to 9 [using array]

0 to 9 Counter using Array
;*************************************
;******** 0 to 9 Counter using Array*********
;*************************************

org 0000h

main:

clr P2.0 ;Enabling Display-1
sbit P2.1 ;Disabling Display-2
sbit P2.2 ;Disabling Display-3
sbit P2.3 ;Disabling Display-4

mov a,#00h

Up:
mov 30h,a
mov dptr,#arr
movc a,@a+dptr
mov P0,a
call delay
mov a, 30h
inc a
jmp Up

jmp main

arr:
db 11111100b
db 01100000b
db 11011010b
db 11110010b
db 01100110b
db 10110110b
db 10111110b
db 11100000b
db 11111110b
db 11110110b

delay:
mov 40h,#0FFh
L1:
mov 41h,#99h
djnz 41h,$
djnz 40h,L1
ret

end


OUTPUT






5.8 Generating two digit numbers

Two digit number
;*************************************
;*********** Two digit number ************
;*************************************

org 0000h

main:
clr P2.0
sbit P2.1
sbit P2.2
sbit P2.3

mov P0,#01100000b
call delay

clr P2.1
sbit P2.0
sbit P2.2
sbit P2.3

mov P0,#11011010b
call delay

jmp main

delay:
mov 40h,#50h
L1:
mov 41h,#99h
djnz 41h,$
djnz 40h,L1
ret

end


OUTPUT





5.9 Generating two four bit numbers alternatively

Alternating two four digit numbers
;************************************
;***** Alternating two four digit numbers *****
;************************************

org 0000h

main:
mov 30h,#0FFh

UP1:
clr P2.0
sbit P2.1
sbit P2.2
sbit P2.3

mov P0,#01100000b
call delay

clr P2.1
sbit P2.0
sbit P2.2
sbit P2.3

mov P0,#11011010b
call delay

clr P2.2
sbit P2.1
sbit P2.0
sbit P2.3

mov P0,#11110010b
call delay

clr P2.3
sbit P2.1
sbit P2.2
sbit P2.0

mov P0,#01100110b
call delay

djnz 30h,UP1
jmp $

mov 30h,#0FFh

UP2:
clr P2.0
sbit P2.1
sbit P2.2
sbit P2.3

mov P0,#10110110b
call delay

clr P2.1
sbit P2.0
sbit P2.2
sbit P2.3

mov P0,#10111110b
call delay

clr P2.2
sbit P2.1
sbit P2.0
sbit P2.3

mov P0,#11100000b
call delay

clr P2.3
sbit P2.1
sbit P2.2
sbit P2.0

mov P0,#11111110b
call delay

djnz 30h,UP2
jmp $
jmp main

delay:
mov 40h,#30h
L1:
mov 41h,#99h
djnz 41h,$
djnz 40h,L1
ret

end



OUTPUT









Program to implement 7-Segment Display with 8051 microcontroller
By ankur bhardwaj embedded
What is 7 Segment Display?

7 Segment Display is an array of 8 LEDs connected or arranged in a
special pattern together to form or display the digits from 0-9 and Dot functions also. The 7-
segments are arranged as a rectangle of two vertical segments on each side with one horizontal
segment on the top, middle, and bottom. Additionally, the seventh segment bisects the rectangle
horizontally. There are also fourteen-segment displays and sixteen-segment displays.

It is composed of 7 LEDs assigning specific alphabet to each and 1 LED acts as a dot in the display.
Every LED is assigned a name from 'a' to 'h' and is identified by its name. Seven LEDs 'a' to 'g' are
used to display the numerals while eighth LED 'h' is used to display the dot/decimal.

Concept:

A 7-segment is generally available in ten pin package. While eight pins correspond to the eight LEDs,
the remaining two pins (at middle) are common and internally shorted. These segments come in two
configurations, namely, Common cathode (CC) and Common anode (CA). In CC configuration, the
negative terminals of all LEDs are connected to the common pins. The common is connected to
ground and a particular LED glows when its corresponding pin is given high. In CA arrangement, the
common pin is given a high logic and the LED pins are given low to display a number.



Common Cathode and Common Anode Configuration

Configuration:

This below table specify how 7-segment will display the digit when one of the LED is OFF or ON
accordingly.



Packaging of 7-Segment Display:

Seven-segment displays can be packaged in a number of ways. Three typical packages are shown
above.

1. On the left we see three small digits in a single 12-pin DIP package. The individual digits are very
small, so a clear plastic bubble is molded over each digit to act as a magnifying lens.

The sides of the end bubbles are flattened so that additional packages of this type can be placed
end-to-end to create a display of as many digits as may be needed.

2. The second package is essentially a 14-pin DIP designed to be installed vertically.

Note that for this particular device, the decimal point is on the left. This is not true of all seven-
segment displays in this type of package.

One limitation of the DIP package is that it cannot support larger digits. To get larger displays for
easy reading at a distance, it is necessary to change the package size and shape.

3. The package on the right above is larger than the other two, and thus can display a digit that is
significantly larger than will fit on a standard DIP footprint. Even larger displays are also available;
some digital clocks sport digits that are two to five inches tall.

Interfacing with 8051


The circuit diagram shown above is of an AT89S51 microcontroller based 0 to 9 counter which has a
7 segment LED display interfaced to it in order to display the count. This simple circuit illustrates two
things. How to setup simple 0 to 9 up counter using 8051 and more importantly how to interface a
seven segment LED display to 8051 in order to display a particular result. The common cathode
seven segment display D1 is connected to the Port 1 of the microcontroller (AT89S51) as shown in
the circuit diagram. R3 to R10 are current limiting resistors. S3 is the reset switch and R2,C3 forms a
debouncing circuitry. C1, C2 and X1 are related to the clock circuit. The software part of the project
has to do the following tasks.
Form a 0 to 9 counter with a predetermined delay (around 1/2 second here).
Convert the current count into digit drive pattern.
Put the current digit drive pattern into a port for displaying.

Bui ld awe bsi te
We bpage de si gn
PcbLayouts
Thi sVide o
Proje cts

Code
#include "REG52.h"

#define SEG P2
sbit C1=P0^0; // BIT DEFINATION
long int i;
void main()
{
C1=C2=C3=1;
while(1)
{
SEG=0x06;
C1=0;
for(i=0;i<256;i++);
C1=1;

SEG=0x5B;
C1=0;
for(i=0;i<256;i++);
C1=1;

SEG=0x4F;
C1=0;
for(i=0;i<256;i++);
C1=1;

}
}

Explanation of Code:
- This code implements single seven segment LED display with common cathode to 8051
microcontroller. Connect common cathode pin to any port pin of microcontroller as we define it C1
in code. Now, ON/OFF that pin to view the character on display. Mark the values accordingly to
extract the HEX value and pass it to the port to seven segment to display character


Seven segment based digital clock with time set option using 8051
microcontroller (AT89C51)
MC009
Summary
Description
Circuit Diagram
Video
Code
Code2
Components
This digital clock not only displays time (on four seven segment displays) but also
provides the user an option to set the time. For this the user has to first press the
reset switch after which he/she can select and set a particular digit by incrementing
its value. To run the clock with the set time, the user needs to press the start button.
The seven segment and switches are interfaced with microcontroller AT89C51.

Seven segment based digital clock with time set option using 8051
microcontroller (AT89C51)
MC009
Summary
Description
Circuit Diagram
Video
Code
Code2
Components

This idea to provide option for setting time can be implemented in conjunction with the digital
clock circuit. The control options for time setting are provided by means of tactile switches
which are made active low. This circuit uses four such switches for following functions.

Switch 1 (S
1
) : Reset (to initiate the time set option)
Switch 2 (S
2
) : Select (to select the segment where value is to be changed)
Switch 3 (S
3
) : Increment (to increase the value at selected segment)
Switch 4 (S
4
) : Start (to start the clock with the set time options)

As soon as S
1
is pressed, the running clock stops and it goes into the reset mode where the
first segment is activated. The segment to be set can be selected in cyclic order each time
S
2
is pressed. After selecting the desired segment, its value can be changed by using S
3
.
Once the digits and hence the time is set, S
4
is pressed to start the clock again.
The seven segments are interfaced to port P
2
of the microcontroller through its data pins (a -
h). The enable pins are connected to pins 1-4 of port P
1
(P
1
^0 P
1
^3). The switches S
1
-S
4

are connected as following to provide ground to the corresponding pins of port P
1
:
S
1
: P
1
^4
S
2
: P
1
^5
S
3
: P
1
^6
S
4
: P
1
^7
Seven segment based digital clock with time set option using 8051
microcontroller (AT89C51)
MC009
Summary
Description
Circuit Diagram
Video
Code
Code2
Components



// Program to make a clock with time setting functionality.

#include<reg51.h>
sbit dig_ctrl_4=P1^0; //Declare the control pins of the seven
segment
sbit dig_ctrl_3=P1^1;
sbit dig_ctrl_2=P1^2;
sbit dig_ctrl_1=P1^3;
sbit reset=P1^4; // Reset pin to reset the clock.
sbit start=P1^7; //Start pin to start the clock after the time is set.
sbit incr=P1^6; //Increment pin to increase the digits during time setting.
sbit set=P1^5; // Set pin to set the time.
int sel_seg_to_incr=0;
int ret_seg_to_incre=0;
int recnt_incr_seg;
unsigned char dig_disp=0;
int min2=0;
int min1=0;
int sec2=0;
int sec1=0;
char dig_val[10]={0x40,0xF9,0x24,0x30,0x19,0x12,0x02,0xF8,0x00,0x10};
// to store values corresponding to digits 0 to 9

void delay(int a) //Function to provide a time delay of approx. 1 second
using Timer1.
{
int i;
for(i=0;i<a;i++)
{
TL1=0xFD;
TH1=0x4B;
TR1=1;
while(TF1==0);
TR1=0;
TF1=0;
}
}

int setfn() // Function to select minute and seconds digit to be set.
{
while(set==0)
{
switch(recnt_incr_seg)
{
case 1:
if(set==0) //select the min2 digit
{
dig_ctrl_4=1;
dig_ctrl_3=0;
dig_ctrl_2=0;
dig_ctrl_1=0;
recnt_incr_seg=1;
ret_seg_to_incre=1;
P2=dig_val[min2];
delay(20);
}

case 2:
if(set==0) // Select the min1 digit
{
dig_ctrl_4=0;
dig_ctrl_3=1;
dig_ctrl_2=0;
dig_ctrl_1=0;
recnt_incr_seg=2;
ret_seg_to_incre=2;
P2=dig_val[min1];
delay(20);
}

case 3:
if(set==0) //Select the sec 2 digit
{
dig_ctrl_4=0;
dig_ctrl_3=0;
dig_ctrl_2=1;
dig_ctrl_1=0;
recnt_incr_seg=3;
ret_seg_to_incre=3;
P2=dig_val[sec2];
delay(20);
}

case 4:
if(set==0) //Select the sec1 digit
{
recnt_incr_seg=1;
dig_ctrl_4=0;
dig_ctrl_3=0;
dig_ctrl_2=0;
dig_ctrl_1=1;
ret_seg_to_incre=4;
P2=dig_val[sec1];
delay(20);
recnt_incr_seg=1;
}
}
}
return(ret_seg_to_incre);
}

void increase(int a) //Function to set the minute or seconds digit
{
while(incr==0)
{
switch(a)
{
case 1: // To set the min2 digit.
P2=dig_val[min2]; //Display the value of min2
delay(15);
min2++;
if(min2==6)
min2=0;
P2=dig_val[min2];
delay(5);
break;

case 2: //To set the min1 digit.
P2=dig_val[min1];
delay(15);
min1++;
if(min1==10)
min1=0;
P2=dig_val[min1];
delay(5);
break;

case 3: // To set the sec2 digit.
P2=dig_val[sec2];
delay(15);
sec2++;
if(sec2==6)
sec2=0;
P2=dig_val[sec2];
delay(5);
break;

case 4: //To set the sec1 digit.
P2=dig_val[sec1];
delay(15);
sec1++;
if(sec1==10)
sec1=0;
P2=dig_val[sec1];
delay(5);
break;
}
}
}

void resetfn() // This function brings the clock to reset or set mode.
{
IE=0x80; //Disable timer0 interrupt to stop the display of the clock
sel_seg_to_incr=1;
recnt_incr_seg=1;
dig_ctrl_4=1;
dig_ctrl_3=0;
dig_ctrl_2=0;
dig_ctrl_1=0;
P2=dig_val[min2];
delay(5);
while(1)
{
if(start==0) //check if start pin is pressed
{
TMOD=0x11; //reset the timer0
TL0=0xf6;
TH0=0xFf;
IE=0x82; //enabling again the timer0 interrupt to start
displaying of the clock
TR0=1;
break; // break loop and return to main program
}

if(set==0) //if set pin is pressed call set function
sel_seg_to_incr=setfn();

if(incr==0) // if incr pin is pressed call incr function
increase(sel_seg_to_incr);
}
}
void display() interrupt 1 // function to display the values on
seven segmnet. For more details refer seven segment multiplexing.
{
TL0=0x36; //reloading timer0
TH0=0xf6;
P2=0xFF;
dig_ctrl_1 = dig_ctrl_3 = dig_ctrl_2 = dig_ctrl_4 = 0;
dig_disp++;
dig_disp=dig_disp%4;
switch(dig_disp)
{
case 0:
P2=dig_val[sec1];
dig_ctrl_1 = 1;
break;

case 1:
P2= dig_val[sec2];
dig_ctrl_2 = 1;
break;

case 2:
P2= dig_val[min1];
dig_ctrl_3 = 1;
break;

case 3:
P2= dig_val[min2];
dig_ctrl_4 = 1;
break;
}
}

void main() //main function the programs begins from here
{
set=1; //delaring set, reset, start and incr as input pins
reset=1;
start=1;
incr=1;
TMOD=0x11; //enabling timer0
TL0=0xf6; //loading timer0
TH0=0xFf;
IE=0x82; //initialize timer0 interrupt
TR0=1; //triggering timer0
while(1) //forward counting of clock
{
while(min2<6)
{
while(min1<10)
{
while(sec2<6)
{
while(sec1<10)
{
if(reset==0)
resetfn();
delay(20);
sec1++;
}
sec1=0;
sec2++;
}
sec1=0;
sec2=0;
min1++;
}
sec1=0;
sec2=0;
min1=0;
min2++;
}
min2=0;
}
}


Decimal Counter Using Two 7-segment displays and an
8051.

Introduction
The purpose of this lab is to implement a decimal counter which counts from 0 to 99. You
will have to write a C program for the 80X51 micro-controller. You will then compile your C
program using C51 compiler and burn it unto an 8051 stand alone chip. You will also have to
do some wiring in this lab. The 8051 chip requires some connections to function properly,
and the 7-segment displays need to be wired to the 8051. Schematics are provided below.

Before you can write your C program, you have to understand how the 7-segment displays
work. The 7-segment displays used in the lab are the LSD5061-11 display. Each of the
segment corresponds to a pin (see below for the pinout). In order to light up a particular
segment, it's pin must be set to 0V. Since these pins are connected to the 8051, we simply set
the corresponding pin on the 8051 to '0'. To turn a segment off, the pin must be set to 5V.
This is done by setting the corresponding pin on the 8051 to "1".

Instead of going through each of the seven pins and setting them to '1' or '0' each time we
want to display a number, we will use a lookup table unsigned char LookupTable[11] =
{ }. The location of the entry in the table corresponds to the correct pin settings to display
that number. Simply, LookupTable[0] returns the correct pin settings to display a "0" on the
7-segment display.

Now we have to figure out the correct entries into the table. We know that in order to display
a "0" on the 7-segment display we need to turn on segments s1, s2, s3, s4, s5, and s6. To turn
a segment on, we set the corresponding pin to "0". Segment s7 will need to be turned off. To
turn off this segment we set the corresponding pin to "1". Therefore, the pins will need to be
assigned the following values:

P2^0 = 0;
P2^1 = 0;
P2^2 = 0;
P2^3 = 0;
P2^4 = 0;
P2^5 = 0;
P2^6 = 0;
P2^7 = 1;
P2^8 = 1; //don't care what this value is since it is not used We set it to 1 because the 8051
pins are by default 1

The bit pattern desired is 1100 0000 (remeber that pin 8 is the highest bit). We then convert
the values into hexadecimal 1100 -> C and 0000 -> 0. We fill in the table with this value
0xC0. The "0x" is needed before the actual value to indicate to the compiler that it is a
hexadecimal value. Now when we call LookupTable[0] it will return the proper configuration
to display a "0" on the 7-segment display. You will need to fill in the rest of the values (1-9).
LookupTable[10] will indicate an error has occured, at this location segment s7 will be on,
the remaining segments will be off. (If you want, you can also look at the 7-segment display
datasheet.)




Assignment
In this lab :
You will implement a decimal counter using the C programming language for the
8051 micro-controller and display the count (0 to 99) on two 7-segment displays.
You will then burn your program on the 8051.
Make necessary connections the 8051 chip and the two 7-segment displays.
Verify the correctness of your circuit.
Apparatus Required
1. 330 resistors (4)
2. 7-segment display (2)
3. 5V power supply
4. 8051 chip
5. 12MHz crystal (clock)
Schematic
Segment number
LSD5061-11 Pin
number
8051 pin number
(One's place display)
8051 pin number
(Ten's place display)
s1 pin 1 P2.0 P3.0
s2 pin 2 P2.1 P3.1
s3 pin 4 P2.2 P3.2
s4 pin 6 P2.3 P3.3
s5 pin 7 P3.4 P2.4
s6 pin 9 P2.5 P3.5
s7 pin 10 P2.6 P3.6

Program

#pragma SMALL DB
#include

/* P0, P1, P2 and P3 are predefined port names and are bit
addressable */

unsigned char SetDisplay(unsigned char value){

unsigned char LookupTable[11] = { 0xC0, ... };

/* check to see if "value" is in bounds,
if not return an error */
if( ) {
/* return appropriate value */;
}
else {
/* return error value */;
}
}


/* Delay function */
void delay() {

int i, j;

for(i=0; i<1000; i++)
for(j=0; j<100; j++)
i = i + 0;
}


void main(void){
unsigned char count = 0; /* value held in one's place */

while(1) {
/* determine and display the one's place */
/* determine and dipslay the ten's place */

/* update the counter (remember to keep it within
bounds)*/

delay();
}
}

Procedure
Hardware
1. Wire up the circuit as shown in the schematic.
2. Pinouts are also available:
8051
7-segment display
Software
1. Map your network drive to P:\\Peart\cs122
2. Run the batch file cs122.bat
3. Create a directory for your program on the C: drive (i.e. C:\Temp\counter)
4. Using a text editor (i.e. notepad, etc...) type in the program provided and add any
necessary code to your program.
5. Compile your program to generate object file count.obj
6. c51 count.c

7. Link the object file to create your executable file count.omf.
bl51 count.obj to count.omf

8. Create a hex file, count.hex, used to burn your program unto the 8051 chip
9. oh51 count.omf

10. Copy your hex file to a floppy
11. copy count.hex A:\count.hex

Burning A Chip - Programmer: MP-51
1. Place the chip to be programmed on the slot making sure that the correct side is up
2. Use the arrow keys on the keyboard to choose options
3. Choose Type -> 51Controller -> PC89C52U
4. Choose File -> Load and enter the pathname of your hex file (i.e. A:\counter.hex)
5. Choose Command -> Program -> DeviceMemory -> Program Device Memory
6. The chip will be programmed. Remove it from the chip from the socket. It is now
ready to be plugged into your board.
Testing Your Program
1. Make sure that your chip has the power and ground connections as specified by the
schematic.
2. Connect pin 9 to ground.
3. Supply power to your board (make sure the power supply is set to 5V, if it is higher
you will damage the 8051 chip.)
4. Pulse pin 9 to power then return it to ground.
5. Your program should now be running. Test to see if it is working correctly.
6. If your program is not working as desired you will have to modfiy your program, then
compile and download unto the chip again.