C Programming for 8051 Page 1 of 16

Compilers produce hex files that is downloaded to ROM of microcontroller

Microcontrollers have limited on-chip ROM

Code space for 8051 is limited to 64K bytes

The reasons for writing programs in C

- It is easier and less time consuming to write in C than Assembly
- C is easier to modify and update
- You can use code available in function libraries
- C code is portable to other microcontroller with little or no modification
but
- has larger hex file size

DATA TYPES
- Unsigned char
- Signed char
- Unsigned int
- Signed int
- Sbit (single bit)
- Bit and sfr

Unsigned char
The character data type is the most natural choice
- Unsigned char is an 8-bit data type in the range of 0 – 255 (00 – FFH)
- One of the most widely used data types for the 8051
- Counter value
- ASCII characters
C compilers use the signed char as the default if we do not put the keyword unsigned

Write an 8051 C program to send values 00 – FF to port P1.

Solution:
#include <reg51.h>
void main(void)
{
unsigned char z;
for (z=0;z<=255;z++)
P1=z;
}

Write an 8051 C program to send hex values for ASCII characters of 0, 1, 2, 3, 4, 5, A, B, C, and D to
port P1.
Solution:
#include <reg51.h>
void main(void)
{
unsigned char mynum[]=“012345ABCD”;
unsigned char z;
for (z=0;z<=10;z++)
P1=mynum[z];
}
C Programming for 8051 Page 2 of 16

Write an 8051 C program to toggle all the bits of P1 continuously.

Solution:
//Toggle P1 forever
#include <reg51.h>
void main(void)
{
for (;;)
{
p1=0x55;
p1=0xAA;
}
}

Signed char
The signed char is an 8-bit data type
- Use the MSB D7 to represent – or +
- Give us values from –128 to +127

Write an 8051 C program to send values of –4 to +4 to port P1.

Solution:
//Singed numbers
#include <reg51.h>
void main(void)
{
char mynum[]={+1,-1,+2,-2,+3,-3,+4,-4};
unsigned char z;
for (z=0;z<=8;z++)
P1=mynum[z];
}

Unsigned and Signed int

The unsigned int is a 16-bit data type
- Takes a value in the range of 0 to 65535 (0000 – FFFFH)
- Define 16-bit variables such as memory addresses
- Set counter values of more than 256

Signed int is a 16-bit data type

- Use the MSB D15 to represent – or +
- We have 15 bits for the magnitude of the number from –32768 to +32767

Single Bit - Bit and sfr

The bit data type allows access to single bits of RAM bit-addressable memory spaces 20 – 2FH.
The sbit data type allows access to the single bits of the SFR registers.

Byte -size SFR registers

To access the byte-size SFR registers, use the sfr data type of RAM addresses space 80 – FFH.

Summary of Data Type Size in Bits Data Range/Usage

bit 1-bit RAM bit-addressable only
sbit 1-bit SFR bit-addressable only
C Programming for 8051 Page 3 of 16

(signed) char 8-bit -128 to +127

unsigned char 8-bit 0 to 255
(signed) int 16-bit -32768 to +32767
unsigned int 16-bit 0 to 65535
sfr 8-bit RAM addresses

Write an 8051 C program to toggle bit D0 of the port P1 (P1.0) 50,000 times.
Solution:
#include <reg51.h>
sbit MYBIT=P1^0;
void main(void)
{
unsigned int z;
for (z=0;z<=50000;z++)
{
MYBIT=0;
MYBIT=1;
}
}

TIME DELAY
There are two ways to create a time delay in 8051 C
- Using the 8051 timer
- Using a simple for loop

Three factors that can affect the accuracy of the delay

The 8051 design
- The number of machine cycle
- The number of clock periods per machine cycle
- The crystal frequency connected to the X1 – X2 input pins

Compiler choice
– C compiler converts the C statements and functions to Assembly language instructions
– Different compilers produce different code

Write an 8051 C program to toggle bits of P1 continuously forever with some delay.
Solution:
//Toggle P1 forever with some delay in between
//“on” and “off”
#include <reg51.h>
void main(void)
{
unsigned int x;
for (;;) //repeat forever
{
p1=0x55;
for (x=0;x<40000;x++); //delay size
//unknown
p1=0xAA;
for (x=0;x<40000;x++);
C Programming for 8051 Page 4 of 16

}
}
Use the oscilloscope to measure the exact duration

Write an 8051 C program to toggle bits of P1 ports continuously with a 250 ms.
Solution:
#include <reg51.h>
void MSDelay(unsigned int);
void main(void)
{
while (1) //repeat forever
{
p1=0x55;
MSDelay(250);
p1=0xAA;
MSDelay(250);
}
}
void MSDelay(unsigned int itime)
{
unsigned int i,j;
for (i=0;i<itime;i++)
for (j=0;j<1275;j++);
}

I/O PROGRAMMING
Byte Size I/O
Ports P0 – P3 are byte-accessible and we use the P0 – P3 labels as defined in the 8051/52 header file.

Write an 8051 C program that shows the count from 0 to FFH (0000 0000 to 1111 1111 in binary) on the
LEDs connected to bits P1 and P2.
Solution:
#include <reg51.h>
#defind LED P2;
void main(void)
{
P1=00; //clear P1
LED=0; //clear P2
for (;;) //repeat forever
{
P1++; //increment P1
LED++; //increment P2
}
}

Write an 8051 C program to get a byte of data form P1, wait ½ second, and then send it to P2.
Solution:
#include <reg51.h>
void MSDelay(unsigned int);
void main(void)
C Programming for 8051 Page 5 of 16

{
unsigned char mybyte;
P1=0xFF; //make P1 input port
while (1)
{
mybyte=P1; //get a byte from P1
MSDelay(500);
P2=mybyte; //send it to P2
}
}

Write an 8051 C program to get a byte of data form P0. If it is less than 100, send it to P1; otherwise,
send it to P2.
Solution:
#include <reg51.h>
void main(void)
{
unsigned char mybyte;
P0=0xFF; //make P0 input port
while (1)
{
mybyte=P0; //get a byte from P0
if (mybyte<100)
P1=mybyte; //send it to P1
else
P2=mybyte; //send it to P2
}
}

I/O PROGRAMMING
Bit-addressable I/O
Ports P0 – P3 are bit-addressable and we use sbit data type to access a single bit of P0 - P3
Use the Px^y format, where x is the port 0, 1, 2, or 3 and y is the bit 0 – 7 of that port

Write an 8051 C program to toggle only bit P2.4 continuously without disturbing the rest of the bits of
P2.
Solution:
//Toggling an individual bit
#include <reg51.h>
sbit mybit=P2^4;
void main(void)
{
while (1)
{
mybit=1; //turn on P2.4
mybit=0; //turn off P2.4
}
}
C Programming for 8051 Page 6 of 16

Write an 8051 C program to monitor bit P1.5. If it is high, send 55H to P0; otherwise, send AAH to P2.
Solution:
#include <reg51.h>
sbit mybit=P1^5;
void main(void)
{
mybit=1; //make mybit an input
while (1)
{
if (mybit==1)
P0=0x55;
else
P2=0xAA;
}
}

A door sensor is connected to the P1.1 pin, and a buzzer is connected to P1.7. Write an 8051 C program
to monitor the door sensor, and when it opens, sound the buzzer. You can sound the buzzer by sending a
square wave of a few hundred Hz.
Solution:
#include <reg51.h>
void MSDelay(unsigned int);
sbit Dsensor=P1^1;
sbit Buzzer=P1^7;
void main(void)
{
Dsensor=1; //make P1.1 an input
while (1)
{
while (Dsensor==1)//while it opens
{
Buzzer=0;
MSDelay(200);
Buzzer=1;
MSDelay(200);
}
}
}

The data pins of an LCD are connected to P1. The information is latched into the LCD whenever its
Enable pin goes from high to low. Write an 8051 C program to send “The Earth is but One Country” to
this LCD.
Solution:
#include <reg51.h>
#define LCDData P1 //LCDData declaration
sbit En=P2^0; //the enable pin
void main(void)
{
unsigned char message[] =“The Earth is but One Country”;
unsigned char z;
C Programming for 8051 Page 7 of 16

for (z=0;z<28;z++) //send 28 characters

{
LCDData=message[z];
En=1; //a highEn=0; //-to-low pulse to latch data
}
}

I/O PROGRAMMING
Accessing SFR Addresses 80 – FFH
To access the SFR RAM space 80 – FFH use the sfr data type

Write an 8051 C program to toggle all the bits of P0, P1, and P2
continuously with a 250 ms delay. Use the sfr keyword to declare the
port addresses.
Solution:
//Accessing Ports as SFRs using sfr data type
sfr P0=0x80;
sfr P1=0x90;
sfr P2=0xA0;
void MSDelay(unsigned int);
void main(void)
{
while (1)
{
P0=0x55;
P1=0x55;
P2=0x55;
MSDelay(250);
P0=0xAA;
P1=0xAA;
P2=0xAA;
MSDelay(250);
}
}

Access a single bit of any SFR RAM space 80 – FFH by specifying the bit address.
This is widely used for the new generation of 8051 microcontrollers.
Notice that there is no #include <reg51.h>.

Write an 8051 C program to turn bit P1.5 on and off 50,000 times.
Solution:
sbit MYBIT=0x95;
void main(void)
{
unsigned int z;
for (z=0;z<50000;z++)
{
MYBIT=1;
MYBIT=0;
}
C Programming for 8051 Page 8 of 16

Access a single bit by using bit Data Type for Bit-addressable RAM
Use bit data type to access data in a bit-addressable section of the data RAM space 20 – 2FH

Write an 8051 C program to get the status of bit P1.0, save it, and send it to P2.7 continuously.
Solution:
#include <reg51.h>
sbit inbit=P1^0;
sbit outbit=P2^7;
bit membit; //use bit to declare bit- addressable memory
void main(void)
{
while (1)
{
membit=inbit; //get a bit from P1.0
outbit=membit; //send it to P2.7
}
}

LOGIC OPERATIONS
Bit-wise Operators in C

Logical operators
- AND (&&), OR (||), and NOT (!)

Bit-wise operators
AND (&), OR (|), EX-OR (^), Invert (~), Shift Right (>>), and Shift Left (<<)

These operators are widely used in software engineering for embedded systems and control
A&B AND
A|B OR
A^B EX-OR
~B INVERT

Run the following program on your simulator and examine the results.
Solution:
#include <reg51.h>
void main(void)
{
P0=0x35 & 0x0F; //ANDing
P1=0x04 | 0x68; //ORing
P2=0x54 ^ 0x78; //XORing
P0=~0x55; //inversing
P1=0x9A >> 3; //shifting right 3
P2=0x77 >> 4; //shifting right 4
P0=0x6 << 4; //shifting left 4
}
C Programming for 8051 Page 9 of 16

Write an 8051 C program to toggle all the bits of P0 and P2 continuously with a 250 ms delay. Using the
inverting and Ex-OR operators, respectively.
Solution:
#include <reg51.h>
void MSDelay(unsigned int);
void main(void)
{
P0=0x55;
P2=0x55;
while (1)
{
P0=~P0;
P2=P2^0xFF;
MSDelay(250);
}
}

Write an 8051 C program to get bit P1.0 and send it to P2.7 after inverting it.
Solution:
#include <reg51.h>
sbit inbit=P1^0;
sbit outbit=P2^7;
bit membit;
void main(void)
{
while (1)
{
membit=inbit; //get a bit from P1.0
outbit=~membit; //invert it and send
//it to P2.7
}
}

Write an 8051 C program to read the P1.0 and P1.1 bits and issue an ASCII character to P0 according to
the following table.
P1.1 P1.0 send to P0
0 0 „0‟
0 1 „1‟
1 0 „2‟
1 1 „3‟
Solution:
#include <reg51.h>
void main(void)
{
unsignbed char z;
z=P1;
z=z&0x3;
...
switch (z)
{
C Programming for 8051 Page 10 of 16

case(0):
{
P0=„0‟;
break;
}
case(1):
{
P0=„1‟;
break;
}
case(2):
{
P0=„2‟;
break;
}
case(3):
{
P0=„3‟;
break;
}
}
}

DATA CONVERSION
Packed BCD to ASCII Conversion
Write an 8051 C program to convert packed BCD 0x29 to ASCII and display the bytes on P1 and P2.
Solution:
#include <reg51.h>
void main(void)
{
unsigned char x,y,z;
unsigned char mybyte=0x29;
x=mybyte&0x0F;
P1=x|0x30;
y=mybyte&0xF0;
y=y>>4;
P2=y|0x30;
}

DATA CONVERSION ASCII to Packed BCD Conversion

Write an 8051 C program to convert ASCII digits of „4‟ and „7‟ to

packed BCD and display them on P1.
Solution:
#include <reg51.h>
void main(void)
{
unsigned char bcdbyte;
unsigned char w=„4‟;
unsigned char z=„7‟;
C Programming for 8051 Page 11 of 16

w=w&0x0F;
w=w<<4;
z=z&0x0F;
bcdbyte=w|z;
P1=bcdbyte;
}

DATA CONVERSION Checksum Byte in ROM

Write an 8051 C program to calculate the checksum byte for the data 25H, 62H, 3FH, and 52H.
Solution:
#include <reg51.h>
void main(void)
{
unsigned char mydata[]={0x25,0x62,0x3F,0x52};
unsigned char sum=0;
unsigned char x;
unsigned char chksumbyte;
for (x=0;x<4;x++)
{
P2=mydata[x];
sum=sum+mydata[x];
P1=sum;
}
chksumbyte=~sum+1;
P1=chksumbyte;
}

Write an 8051 C program to perform the checksum operation to ensure data integrity. If data is good,
send ASCII character „G‟ to P0. Otherwise send „B‟ to P0.
Solution:
#include <reg51.h>
void main(void)
{
unsigned char mydata[]
={0x25,0x62,0x3F,0x52,0xE8};
unsigned char shksum=0;
unsigned char x;
for (x=0;x<5;x++)
chksum=chksum+mydata[x];
if (chksum==0)
P0=„G‟;
else
P0=„B‟;
}
C Programming for 8051 Page 12 of 16

DATA CONVERSION Binary (hex) to Decimal and ASCII Conversion

Write an 8051 C program to convert 11111101 (FD hex) to decimal and display the digits on P0, P1 and
P2.
Solution:
#include <reg51.h>
void main(void)
{
unsigned char x,binbyte,d1,d2,d3;
binbyte=0xFD;
x=binbyte/10;
d1=binbyte%10;
d2=x%10;
d3=x/10;
P0=d1;
P1=d2;
P2=d3;
}

ACCESSING CODE ROM

RAM Data Space Usage by 8051 C Compiler
The 8051 C compiler allocates RAM locations
- Bank 0 – addresses 0 – 7
- Individual variables – addresses 08 and beyond
- Array elements – addresses right after variables
Array elements need contiguous RAM locations and that limits the size of the array due to the fact that we
have only 128 bytes of RAM for everything
- Stack – addresses right after array Elements

Compile and single-step the following program on your 8051 simulator. Examine the contents of the 128-
byte RAM space to locate the ASCII values.
Solution:
#include <reg51.h>
void main(void)
{
unsigned char mynum[]=“ABCDEF”; //RAM space
unsigned char z;
for (z=0;z<=6;z++)
P1=mynum[z];
}

Write, compile and single-step the following program on your 8051 simulator. Examine the contents of
the code space to locate the values.
Solution:
#include <reg51.h>
void main(void)
{
unsigned char mydata[100]; //RAM space
unsigned char x,z=0;
for (x=0;x<100;x++)
C Programming for 8051 Page 13 of 16

{
z--;
mydata[x]=z;
P1=z;
}
}

ACCESSING CODE ROM 8052 RAM Data Space

One of the new features of the 8052 was an extra 128 bytes of RAM space
- The extra 128 bytes of RAM helps the 8051/52 C compiler to manage its registers and resources much
more effectively

We compile the C programs for the 8052 microcontroller

- Use the reg52.h header file
- Choose the 8052 option when compiling the program

- To make the C compiler use the code space instead of the RAM space, we need to put the keyword
code in front of the variable declaration

- Use the RAM data space to store array elements, therefore the size of the array is limited
- Use a separate area of the code space for data.
This allows the size of the array to be as long as you want if you have the on-chip ROM.
However, the more code space you use for data, the less space is left for your program code

Compile and single-step the following program on your 8051simulator. Examine the contents of the code
space to locate the ASCII values.
Solution:
#include <reg51.h>
void main(void)
{
code unsigned char mynum[]=“ABCDEF”;
unsigned char z;
for (z=0;z<=6;z++)
P1=mynum[z];
}

Compare and contrast the following programs and discuss the advantages and disadvantages of each
one.
(a)
#include <reg51.h>
void main(void)
{
P1=„H‟;
P1=„E‟;
P1=„L‟;
P1=„L‟;
P1=„O‟;
}
...
C Programming for 8051 Page 14 of 16

Short and simple, but the individual characters are embedded into the program and it mixes the code and
data together
...

(b)
#include <reg51.h>
void main(void)
{
unsigned char mydata[]=“HELLO”;
unsigned char z;
for (z=0;z<=5;z++)
P1=mydata[z];
}

(c)
#include <reg51.h>
void main(void)
{
code unsigned char mydata[]=“HELLO”;
unsigned char z;
for (z=0;z<=5;z++)
P1=mydata[z];
}

DATA SERIALIZATION
Serializing data is a way of sending a byte of data one bit at a time through a single pin of microcontroller
- Using the serial port
- Transfer data one bit a time and control the sequence of data and spaces in between them

In many new generations of devices such as LCD, ADC, and ROM the serial versions are becoming
popular since they take less space on a PCB

Write a C program to send out the value 44H serially one bit at a time via P1.0. The LSB should go out
first.
Solution:
#include <reg51.h>
sbit P1b0=P1^0;
sbit regALSB=ACC^0;
void main(void)
{
unsigned char conbyte=0x44;
unsigned char x;
ACC=conbyte;
for (x=0;x<8;x++)
{
P1b0=regALSB;
ACC=ACC>>1;
}
}
C Programming for 8051 Page 15 of 16

Write a C program to send out the value 44H serially one bit at a time via P1.0. The MSB should go out
first.
Solution:
#include <reg51.h>
sbit P1b0=P1^0;
sbit regAMSB=ACC^7;
void main(void)
{
unsigned char conbyte=0x44;
unsigned char x;
ACC=conbyte;
for (x=0;x<8;x++)
{
P1b0=regAMSB;
ACC=ACC<<1;
}
}

Write a C program to bring in a byte of data serially one bit at a time via P1.0. The LSB should come in
first.
Solution:
#include <reg51.h>
sbit P1b0=P1^0;
sbit ACCMSB=ACC^7;
bit membit;
void main(void)
{
unsigned char x;
for (x=0;x<8;x++)
{
membit=P1b0;
ACC=ACC>>1;
ACCMSB=membit;
}
P2=ACC;
}

Write a C program to bring in a byte of data serially one bit at a time via P1.0. The MSB should come in
first.
Solution:
#include <reg51.h>
sbit P1b0=P1^0;
sbit regALSB=ACC^0;
bit membit;
void main(void)
{
unsigned char x;
for (x=0;x<8;x++)
{
membit=P1b0;
C Programming for 8051 Page 16 of 16

ACC=ACC<<1;
regALSB=membit;
}
P2=ACC;
}