Embedded C Programming with Keil

Language
Embedded C is most popular programming language in software field for
developing electronic gadgets. Each processor used in electronic system is
associated with embedded software.
Embedded C programming plays a key role in performing specific function
by the processor. In day-to-day life we used many electronic devices such
as mobile phone, washing machine, digital camera, etc. These all device
working is based on microcontroller that are programmed by embedded C.
Let's see the block diagram representation of embedded system
programming:

The Embedded C code written in above block diagram is used for blinking
the LED connected with Port0 of microcontroller.
33.1M
603
History of Java

In embedded system programming C code is preferred over other

language. Due to the following reasons:
o Easy to understand
 o High Reliability
o Portability
o Scalability

Embedded System Programming:

Basic Declaration
Let's see the block diagram of Embedded C Programming development:

Function is a collection of statements that is used for performing a specific

task and a collection of one or more functions is called a programming
language. Every language is consisting of basic elements and grammatical
rules. The C language programming is designed for function with variables,
character set, data types, keywords, expression and so on are used for
writing a C program.
The extension in C language is known as embedded C programming
language. As compared to above the embedded programming in C is also
have some additional features like data types, keywords and header file etc
is represented by
1. #include<microcontroller name.h>  

Basic Embedded C Programming Steps

Let's see the block diagram representation of Embedded C Programming
Steps:
The microcontroller programming is different for each type of operating
system. Even though there are many operating system are exist such as
Windows, Linux, RTOS, etc but RTOS has several advantage for embedded
system development.
Steps to run embedded c program in keil software

We are commonly use 7 steps to run embedded c program in keil software

Following some important steps to run embedded c program in keil software :

Step 1 : Open keil software (micro version 5)

we need to install keil micro version 5 software from it’s official site

click on keil software for download purpose setup file is no much big i.e. only 94 mb

run embedded c program in keil software

Step 2nd : Create new project in keil software

After successful installation of software we need to create our new project so for that click on project Tab
and select New microvision project

Create new project

in keil software

After the selection of this file we need to give name for the project file
 Create new project
file in keil software

In this article we are give file name as sachinexd

Step 3 : selection of Target device in keil

selection of Target device in keil

The next step is select device for Target so in this article we use AT89C52 Target device. In description
window we are clearly visible what is property of the selected devices.

add file to project in keil

we know that it is possible to write code in embedded c as well as assembly language so if we want to
write code in assembly language then we are click on No Tab if write this code in embedded c then click
on yes tab.

In this article we click on Yes because we are use here assembly language

Step 4 : Add New Item group in keil software

Add New Item group in keil software

Next step is Add New Item group in keil software so for that click right on Source group 1 and select Add
New Item to group ‘source Group 1’
Following windows are open after the Add New Item group in keil software so select C file (.c) and give
the name for this file . in below file we give simplepro name and add this file to source group.

Create new c source

file and add this file to project in keil

Step 5 : how to write embedded c program in keil software

At the left hand side we see created different Target file so for write embedded code click on file and click
on new.

Know we are ready to write embedded c code .

 how to write
embedded c program in keil software

Here we are write simple embedded code for practice purposed.

Step 6 : How to Build the embedded c program in keil

after the write source code we need to compile this program so click on build program menu . then
compiler execute our program one by one line and show result as like below pop-up window

How to Build the

embedded c program in keil

Build output show zero error and zero warning

Step 7 : How to use Start Stop debug section

For debug purpose we can use Start/ Stop debug section Tab

Start stop debug section

Summary :

In this article we saw how to write and run embedded c program in keil software so about this article you
have any query then free to ask me

Keil Programs

Keil is a German based Software development company. It provides several

development tools like

•         IDE (Integrated Development environment)

 •         Project Manager

•         Simulator

•         Debugger

•         C Cross Compiler , Cross Assembler, Locator/Linker

Keil Software provides you with software development tools for the 8051 family of

microcontrollers. With these tools, you can generate embedded applications for the

multitude of 8051 derivatives. Keil provides following tools for 8051 development

1.     C51 Optimizing C Cross Compiler,

2.     A51 Macro Assembler,

3.     8051 Utilities (linker, object file converter, library manager),

4.     Source-Level Debugger/Simulator,

5.     µVision for Windows Integrated Development Environment.

 

Let’s see some simple Keil Based Programs

Generate a square wave

Example-1: generate a square wave of 10 Hz at pin P1.0 of 8051 using timer

#include <reg51.h>               // include 8051 register file

sbit pin = P1^0;                    // decleare a variable type sbit for P1.0 

main()

      P1 = 0x00;                     // clear port

      TMOD = 0x09;                // initialize timer 0 as 16 bit timer 

loop:TL0 = 0xAF;                  // load valur 15535 = 3CAFh so after 

      TH0 = 0x3C;                   // 50000 counts timer 0 will be overflow

       pin = 1;                        // send high logic to P1.0

       TR0 = 1;                       // start timer

       while(TF0 == 0)  {}       // wait for first overflow for 50 ms

       TL0 = 0xAF;                 // again reload count

       TH0 = 0x3C;

       pin = 0;                       // now send 0 to P1.0

      while(TF0 == 0)  {}       // wait for 50 ms again  

  goto loop;                         // continue with the loop  

}
 

Make 8 to 1 multiplexer with enable

signal
Example-2: write a program to make 8 to 1 multiplexer with enable signal

#include<reg51.h>

sbit D0 = P0^0;                     // set P0.0-P0.7 (D0-D7) as input pins of mux

sbit D1 = P0^1;

sbit D2 = P0^2;

sbit D3 = P0^3;
sbit D4 = P0^4;

sbit D5 = P0^5;

sbit D6 = P0^6;

sbit D7 = P0^7;

sbit S0 = P1^0;                 // set P1.0-P1.2(S0-S2) as select pins of mux

sbit S1 = P1^1;

sbit S2 = P1^2;

sbit EN = P1^7;                // set P1.7 as enable pin

sbit pin = P3^5;               // set P3.5 as output 

main()

         P3=0x00;P0=0xFF;      // clear op and set all ips

        TMOD = 0x01;              // set timer 0 for 16 bit timer

 next:TL0 = 0xAF;                 // load count 

        TH0 = 0x3C; 

        while(EN==1){}           // wait till enable pin becomes 0

   if((S0==0)&&(S1==0)&&(S2==0)) pin = D0;                  // if select inputs are 000 op is

first ip

   else if((S0==1)&&(S1==0)&&(S2==0)) pin = D1;           // if select inputs are 001 op is

second ip

   else if((S0==0)&&(S1==1)&&(S2==0)) pin = D2;           // same as above

   else if((S0==1)&&(S1==1)&&(S2==0)) pin = D3;

   else if((S0==0)&&(S1==0)&&(S2==1)) pin = D4;

   else if((S0==1)&&(S1==0)&&(S2==1)) pin = D5;

   else if((S0==0)&&(S1==1)&&(S2==1)) pin = D6;

   else if((S0==1)&&(S1==1)&&(S2==1)) pin = D7;   

   else pin = 0;                                                                 // by default op is cleared

   TR0 = 1;                                                                      // start timer 0 

   while(TF0==0){}                                                          // wait until overflow means 50ms

   TR0 = 0;                                                                      // stop timer 

   goto next;                                                                    // go for next input 

} 

Parallel Input to Serial Output

Example-3: take parallel input from port P1 convert it into serial and send it via P0.0

#include<reg51.h>

sbit sout = P0^0;                          // serial out on P0.0

sbit D0 = P1^0;                            // parallal input from P1 (D0-D7)

sbit D1 = P1^1;

sbit D2 = P1^2;

sbit D3 = P1^3;

sbit D4 = P1^4;

sbit D5 = P1^5;

sbit D6 = P1^6;

sbit D7 = P1^7;

int i;
void delay(void);                         //  1 ms delay

main()

 {

    for(i=0;i<8;i++)                   // rotate loop for 8 times

      {

        sout = D0;                       // first bit out

        D0 = D1;                         // shift all bits in sequence 

        D1 = D2;

        D2 = D3;

        D3 = D4;

        D4 = D5;

        D5 = D6;

        D6 = D7;

        delay();                           // generate 1 ms delay after each bit shifted

      }

   }

void delay()

 {

    int k

    for(k=0;k<1000;k++);

  } 
Simultaneous Transmission & Reception
of Data
Example-4: write a program to simultaneously transmit and receive data.

#include <reg51.h>

main()

 {

       TMOD=0x20;          // set timer1 in 16 bit timer mode

       SCON=0x40;          // initialize serial communication

       TL1=0xFD;             // load timer 1 to generate baud rate of 96KBps

       TH1 = 0xFD;

       TR1 = 1;               // start timer 1  

loop:REN = 1;               // enable reception

      while(RI==0){}       // wait until data is received

      RI=0;                     // clear receive flag

      ACC = SBUF;          // get data in to acc

      REN = 0;                // now disable reception

      SBUF = ACC;          // start transmission

      while(TI==0){}       // wait until data transmitted

      TI=0;                    // clear transmission flag   

      goto loop;              // continue this cycle 

Interrupt Detection and Display on LED

Example-5: detect an external interrupt on P3.2 and P3.3. Indicate on LEDs connected

on P0.0 & P0.1

#include<reg51.h>

sbit op1=P0^0;                             // LED1 as output on P0.0

sbit op2=P0^1;                             // LED2 as ouput on P0.1

void delay(void);                           // 10 ms delay

void intrupt0(void) interrupt 0        // ext interrupt 0 vector

  op1=0;                                     // indication on LED1

  delay();

  op1=1;

void intrupt1(void) interrupt 2        // ext interrupt 1 vector

  op2=0;                                     // indication on LED2

  delay();

  op2=1;

void delay()                                 // delay for 10 ms

  int x;

  for(x=0;x<10000;x++);

}
void main()

  P0=0xFF;                                 // send all 1’s to P0 

  IE=0x85;                                  // enable both ext interrupts

  while(1);                                 // continuous loop

}
 

Blink LED for 5 seconds

Example-6: blink a LED on P2.0 for 5 second using timer 1

#include<reg51.h>

int c=0;                                  // initialize counter to 0

sbit LED= P2^0;                      // LED connected to P2.0

void timer1(void) interrupt 3     // timer 1 overflow vactor

 {

     TF1=0;                             // clear overflow flag  

     c++;                                 // increment counter

     if(c==100)                        // if 100 counts of 50 ms(= 5 sec) are over

          {

           TR1=0;                      // stop timer 

           LED=0;                      // LED off 

          } 

     TH1=0x3C;                      // other reaload timer 1 with

     TL1=0xAF;                      // 15535 to count 50 ms  

 }

void main()

 {

         P2=0x00;                   // clear op

        TMOD=0x90;               // set timer 1

        TH1=0x3C;                 // load count 15535

        TL1=0xAF;

        IE=0x88;                    // enable timer 1 interrupt

        LED=1;                      // LED on

        TR1=1;                     // timer 1 start

        while(1);                   // continuous loop

   }
 

SONAR
Example 7: send ultrasonic wave through P1.0 and receive its echo through P3.2.

generate an interrupt. Calculate the distance of object.

#include <reg51.h>

sbit tx = P1^0; // transmitter pin

int c=0,d=0; // counter and distance

void tmr0(void) interrupt 1 // timer 0 interrupt vector

   {
      TF0=0;                       // clear timer flag

      c++;                          // increment counter 

      TL0 = 0xAF;               // reload values

      TH0 = 0x3C;

   }

void int0(void) interrupt 0 // ext interrupt 0 vector

   {

       TR0 = 0;                  // stop timer 

       d = c*30;                // get distance = time*velocity

   } 

main()

    {

         IE=0x83;             // enable interrupts 

         IP=0x01;            // high priority for ext interrupt

         TMOD = 0x01;    // timer 0 as 16 bit timer

         P1 = 0x00;        // clear op port

         TL0 = 0xAF;       // load values for 50 ms

         TH0 = 0x3C;

          tx = 1;             // enable transmission

          TR0 = 1;          // start timer

          while(1);

}
 
Counting Number of 1s in input
Example 8: take input from P0. Count no of 1 in input

#include <reg51.h>

sbit D0 = B^0; // define D0-D7 as bits of reg B

sbit D1 = B^1;

sbit D2 = B^2;

sbit D3 = B^3;

sbit D4 = B^4;

sbit D5 = B^5;

sbit D6 = B^6;

sbit D7 = B^7;

unsigned bdata reg; // define reg as bit addressable variable

sbit b = reg^0; // define b as bit 0 of reg

void main()

     {

         unsigned int i,c=0; // initialize counter

         B=P0; // take input from P0 to B

         b=0;

         for(i=0;i<8;i++) // rotate bits of reg B

              { // 8 times

                   b=D7;

                   D7=D6;
                   D6=D5;

                   D5=D4;

                   D4=D3;

                   D3=D2;

                   D2=D1;

                   D1=D0;

                   if(b==1)c++; // check every bit if 1

              } 

           while(1); // loop continue 

        }
 

Count number of Keypress

Example 9: connect key with P3.2. Using interrupt count no of key press and display it

on common anode seven segment display connected to P0.

#include<reg51.h>

unsigned int c=0,x=0; //initialize key counter and key flag

void extint0(void) interrupt 0

   {

      x=1;                       // set key flag

      c++;                      // increment key count

      if(c==9)                 // if its 9

         {
           c=0;                // reset it to 0 and

           P0=0xC0;         // display 0

         } 

     } 

void main(void)

    {

           IE=0x81;         // enable ext int 0

           P0=0xC0;        // display 0

    loop:while(!x);      // check key flag

           switch(c)       // if it is set get the count

                  {

                    case 1: 

                        P0=0xF9; // display digit from 1 to 9

                        break;

                    case 2: 

                        P0=0xA4;

                        break;

                   case 3: 

                       P0=0xB0;

                       break;

                   case 4: 

                       P0=0x99;

                       break;
                 case 5: 

                      P0=0x92;

                      break;

                 case 6: 

                      P0=0x82;

                      break;

                 case 7: 

                      P0=0xF8;

                      break;

                 case 8: 

                      P0=0x80;

                      break;

                 case 9: 

                      P0=0x90;

                      break;

                } 

       x=0; // clear key flag

       goto loop; // loop continue

}
 

Detecting & Showing Number of

Keypressess
Example 10: connect 8 keys with P1. Detect key press and display number on CA 7

segment display connected to P0.

#include<reg51.h>

void main(void)

    {

        loop:P1=0xFF;                 // send all 1’s to P1             

        while(P1==0xFF);            // remain within loop till key is not pressed

         switch(P1)                    // when key pressed detect is

             {

                 case 0xFE: 

                       P0=0xF9; // and display digit from 1 to 8

                       break;

                  case 0xFD: 

                       P0=0xA4;

                       break;

                  case 0xFB: 

                       P0=0xB0;

                       break;

                  case 0xF7: 

                       P0=0x99;

                        break;

                  case 0xEF: 

                       P0=0x92;
                       break;

                   case 0xDF: 

                       P0=0x82;

                        break;

                  case 0xBF: 

                        P0=0xF8;

                        break;

                   case 0x7F: 

                        P0=0x80; 

                        break;

                    }

               goto loop;

        }