+ All Categories
Home > Documents > Keil C51 Cross Compiler - GMITgmitweb.gmit.ie/electronics/nokeeffe/Semester2_08... · Embedded...

Keil C51 Cross Compiler - GMITgmitweb.gmit.ie/electronics/nokeeffe/Semester2_08... · Embedded...

Date post: 16-May-2018
Author: vodien
View: 221 times
Download: 0 times
Share this document with a friend
Embed Size (px)
of 35 /35
Embedded Systems 2 2 - 1 C Programming Keil C51 Cross Compiler ANSI C Compiler Generates fast compact code for the 8051 and it’s derivatives Advantages of C over Assembler Do not need to know the microcontroller instruction set Register allocation and addressing modes are handled by the compiler Programming time is reduced Code may be ported easily to other microcontrollers (not 100% portable) C51 supports a number of C language extensions that have been added to support the 8051 microcontroller architecture e.g. Data types Memory types Pointers Interrupts
  • Embedded Systems 2 2 - 1 C Programming

    Keil C51 Cross Compiler

    ANSI C Compiler Generates fast compact code for the 8051 and its derivatives

    Advantages of C over Assembler Do not need to know the microcontroller instruction set Register allocation and addressing modes are handled by the compiler Programming time is reduced Code may be ported easily to other microcontrollers

    (not 100% portable) C51 supports a number of C language extensions that have been added to

    support the 8051 microcontroller architecture e.g. Data types Memory types Pointers Interrupts

  • Embedded Systems 2 2 - 2 C Programming

    C vs Assembly Language

    Code efficiency can be defined by 3 factors: -1. How long does it take to write the code2. What size is the code? (how many Bytes of code memory required?)3. How fast does the code run?

    C is much quicker to write and easier to understand and debug than assembler.

    Assembler will normally produce faster and more compact code than C Dependant on C compiler A good knowledge of the micro architecture and addressing modes will

    allow a programmer to produce very efficient C code

  • Embedded Systems 2 2 - 3 C Programming

    C51 Keywords

  • Embedded Systems 2 2 - 4 C Programming

    C51 Data Types

    = extension to ANSI C

  • Embedded Systems 2 2 - 5 C Programming

    C51 Memory Models

    Small All variables stored in internal data memory

    Be careful stack is placed here too Generates the fastest, most efficient code Default model for Keil uVision Projects

    Compact All variables stored in 1 page (256 bytes) of external data memory Accessed using MOVX @R0 Slower than small model, faster than large model

    Large All variables stored in external data memory (up to 64KByte) Accessed using MOVX @DPTR Generates more code than small or compact models

  • Embedded Systems 2 2 - 6 C Programming

    C51 Memory Models


  • Embedded Systems 2 2 - 7 C Programming

    C51 Memory Types Memory type extensions allow access to all 8051 memory types.

    A variable may be assigned to a specific memory space The memory type may be explicitly declared in a variable declaration

    variable_type variable_name; e.g. int data x;

    Program Memory CODE memory type Up to 64Kbytes (some or all may be located on 8051 chip)

    Data Memory 8051 derivatives have up to 256 bytes of internal data memory Lower 128 bytes can be directly or indirectly addressed Upper 128 bytes shares the same address space as the SFR registers and

    can only be indirectly addressed Can be expanded to 64KBytes off-chip

  • Embedded Systems 2 2 - 8 C Programming

    C51 Memory Types

    code Program memory (internal or external). unsigned char code const1 = 0x55; //define a constant char code string1[] = hello; //define a string

    data Lower 128 bytes of internal data memory Accessed by direct addressing (fastest variable access) unsigned int data x; //16-bit variable x

    idata All 256 bytes of internal data memory (8052 micro) Accessed by indirect addressing (slower)

  • Embedded Systems 2 2 - 9 C Programming

    C51 Memory Types

    bdata Bit addressable area of internal data memory (addresses 20H to 2FH) Allows data types that can be accessed at the bit level unsigned char bdata status; sbit flag1 = status^0;

    xdata External data memory Slower access than internal data memory unsigned char xdata var1;

  • Embedded Systems 2 2 - 10 C Programming

    8051 Memory Usage

    In a single chip 8051 application data memory is scarce 128 or 256 bytes on most 8051 derivatives

    Always declare variables as the smallest possible data type Declare flags to be of type bit Use chars instead of ints when a variables magnitude can be stored as 8


    Use code memory to store constants and strings

  • Embedded Systems 2 2 - 11 C Programming

    Example Code (1)

    sbit input = P1^0;void main(){

    unsigned char status;int x;


  • Embedded Systems 2 2 - 12 C Programming

    Program Branching Most embedded programs need to make some

    decisions e.g. perform a certain task only if a switch

    input is high An if-else statement is the most common method

    of coding a decision box of a flowchart.

    if (P1^0 == 1){

    //task A}else{

    //task B} Note that the brackets are only required if

    the if or else statement contains more then 1 line of code

    P1.0= 1?

    Task A Task B

    Y N

  • Embedded Systems 2 2 - 13 C Programming

    Wait Loops

    P1.0= 1?

    Task B



    Task A In some applications the program must wait until a certain condition is true before progressing to the next program task (wait loop) e.g. in a washing machine wait for the water to heat

    before starting the wash cycle

    A while statement is often used here

    //task Awhile(P1^0 == 0); //will stay here while P1.0 is low//can also write as while(P1^0 == 0) {}//task B

  • Embedded Systems 2 2 - 14 C Programming

    Continuous Loops

    An embedded program never ends It must contain a main loop than loops continuously e.g. a washing machine program continually tests the switch inputs

    A continuous loop is programmed using a loop with no condition while(1){ } while(1); for(;;){ } for(;;);

  • Embedded Systems 2 2 - 15 C Programming

    C Bitwise Operators

    NOT ~char data x = 0x05;x = ~x; //x=0xFA

    AND &char data x = 0x45;x &= 0x0F; //x = 0x05 Useful for clearing specific bits within a variable (masking)

    OR |char data x = 0x40;x |= 0x01; //x = 0x41 Useful for setting individual bits within a variable

    EXCLUSIVE OR ^char data x = 0x45;x ^= 0x0F; //x = 0x4A Useful for inverting individual bits within a variable

  • Embedded Systems 2 2 - 16 C Programming


    What is the value of variable x after the following code executes?

    unsigned char data x;x = 21;x &= 0xF0;x |= 0x03;

    Write C code to set the upper 4 bits of a char to 1100.

  • Embedded Systems 2 2 - 17 C Programming

    C Logical Operators

    Bitwise operators will change certain bits within a variable

    Logical operators produce a true or false answer They are used for looping and branching conditions

    C Logical Operators AND && OR || Equals = = Not Equal != Less < Less or Equal Greater or Equal >=

  • Embedded Systems 2 2 - 18 C Programming

    Example Code (2)

    //program to add 2 8-bit variables//a flag should be set if the result exceeds 100void main(){

    unsigned char data num1, num2;unsigned int data result;bit overflow;

    num1 = 10;num2 = 25;result = num1 + num2;if (result >100)

    overflow = 1;}

  • Embedded Systems 2 2 - 19 C Programming

    Accessing Port Pins

    Writing to an entire portP2 = 0x12; //Port 2 = 12H (00010010 binary)P2 &= 0xF0; //clear lower 4 bits of Port 2P2 |= 0x03; //set P2.0 and P2.1

    Reading from a portunsigned char data status;status = P1; //read from Port 1

    Before reading from a port pin, always write a 1 to the pin first.

  • Embedded Systems 2 2 - 20 C Programming

    Reading 8051 Port Pins

    We can only read the proper logic value of a pin if the latch contains a 1. If the latch contains a 0 the FET is on and a 0 will always be read.

  • Embedded Systems 2 2 - 21 C Programming

    Example Code (3)//Program to read from 8 switches connected to Port 1. The status of the switches//is written to 8 LEDs connected to Port 2. #include //SFR address definitionsvoid main(){

    unsigned char data status; //variable to hold switch status

    //continuous loop to read switches and display the statuswhile(1){

    status = P1;P2 = status;


  • Embedded Systems 2 2 - 22 C Programming

    Accessing Individual Port Pins

    Writing to a port pin//write a logic 1 to port 0 pin 1P0^1 = 1;

    In a program using lots of individual port pins it is better coding practice to name the pins according to their functionsbit power_led = P0^1;power_led = 1;

    Reading from a port pin//Turn on LED if switch is activesbit switch_input = P2^0;if (switch_input)

    power_led = 1;else

    power_led = 0;

  • Embedded Systems 2 2 - 23 C Programming

    Example Code (4)//program to flash an LED connected to Port 2 pin 0 every 0.2 seconds#include sbit LED = P2^0;void delay();void main(){

    while (1){

    LED = 0; //LED offdelay();LED = 1; //LED ondelay();


    //Delay functionvoid delay(){.}

  • Embedded Systems 2 2 - 24 C Programming

    Generating Delays

    Software Delays Uses looping mechanisms in C or assembly Does not use any microcontroller hardware resources Ties up the CPU while the delay is running Delay produced depends on the compiler

    Hardware Delays Uses a microcontroller timer Uses very little CPU resources (runs in background)

  • Embedded Systems 2 2 - 25 C Programming

    Software Delay

    Use a for loop Does not use any timer resources Uses CPU resources while running

    i.e. no other task can be performed during delay loop Can result in large amounts of machine code being generated Results may be different for different compilers

    The following code results in a 204 usecond delay for the 8051 operating off the 12MHz oscillator

    For loops can be nested to produce longer delays

    void delay(){

    unsigned char x;for (x=100; i > 0; x--);


  • Embedded Systems 2 2 - 26 C Programming

    Software Delay

    Using a decrementing for loopwill generate a DJNZ loop.Loop execution time = 204 machine cycles[1 + 1 + (100 *2) + 2]= 204usec for a 12MHz crystal.Change starting value to 98 toget a 200usec delay

  • Embedded Systems 2 2 - 27 C Programming

    Hardware Delay

    Use timer 0 or timer 1 Very efficient mechanism of producing accurate delays Timer mode, control and counter registers must be configured Timer run bit is used to start/stop the timer The timer flag can be polled to determine when required time delay has

    elapsed Using timer in interrupt mode uses very little CPU resources

    See timer notes for more details

  • Embedded Systems 2 2 - 28 C Programming

    C51 Functions

    Can specify Register bank used Memory Model Function as an interrupt Re-entrancy

    [return_type] func_name([args]) [model] [re-entrant] [interrupt n] [using n]

    int square(int x){

    return(x * x);}

  • Embedded Systems 2 2 - 29 C Programming

    Re-entrant Functions

    A re-entrant function is a function that can be called while it is still running. e.g. an interrupt occurs while the function is running and the service

    routine calls the same function.

    Keil compiler supports re-entrant functions. Beware of stack limitations

  • Embedded Systems 2 2 - 30 C Programming

    Scope of Variables

    A variable defined within a function will default to an automatic variable An automatic variable may be overlaid i.e. the linker may use the

    variables memory space for a variable in another function call. This will cause the variable to lose its value between function calls.

    If you want a variable to maintain its value between function calls, declare it as a static variable.

    static int x; Static variables cannot be overlaid by the linker

    Declare a variable as volatile if you want its value to be read each time it is used

  • Embedded Systems 2 2 - 31 C Programming

    Function Parameter Passing

    Up to 3 arguments may be passed in registers This improves system performance as no memory accesses are required If no registers are available fixed memory locations are used

  • Embedded Systems 2 2 - 32 C Programming

    Function Return Values

    Function return values are always passed in registers

  • Embedded Systems 2 2 - 33 C Programming

    Interrupt Functions

    Interrupt vector number is provided in the function declaration void timer0_int() interrupt 1 using 2


    Contents of A, B, DPTR and PSW are saved on stack when required All working registers used in the ISR are stored on the stack if the using

    attribute is not used to specify a register bank All registers are restored before exiting the ISR

  • Embedded Systems 2 2 - 34 C Programming

    Absolute Variable Location

    The _at_ keyword is used to assign an absolute memory address to a variable Useful for accessing memory mapped peripherals or specific memory

    locations Syntax

    type [memory_space] variable_name _at_ constant unsigned char xdata lcd _at_ 0x8000

    Absolute variables may not be initialised

  • Embedded Systems 2 2 - 35 C Programming

    C51 Pointers

    Generic pointers Same as ANSI C pointers char *ptr; Stored using 3 bytes Can be used to access any memory space Code generated executes more slowly than memory specific pointers

    Memory Specific Pointers Specify the memory area pointed to char data *ptr1; //pointer to char in data memory Stored as 1 (data, idata) or 2 bytes (code or xdata) Can also specify where pointer is stored

    char data * xdata ptr2; //pointer to data stored in xdata

    Keil C51 Cross CompilerC vs Assembly LanguageC51 KeywordsC51 Data TypesC51 Memory ModelsC51 Memory ModelsC51 Memory TypesC51 Memory TypesC51 Memory Types8051 Memory UsageExample Code (1)Program BranchingWait LoopsContinuous LoopsC Bitwise OperatorsQuestionC Logical OperatorsExample Code (2)Accessing Port PinsReading 8051 Port PinsExample Code (3)Accessing Individual Port PinsExample Code (4)Generating DelaysSoftware DelaySoftware DelayHardware DelayC51 FunctionsRe-entrant FunctionsScope of VariablesFunction Parameter PassingFunction Return ValuesInterrupt FunctionsAbsolute Variable LocationC51 Pointers