Topics :
2. 3. 4. 4. 6. 7. 8. 9. 10. 10. Operating Systems vs. Embedded Systems. Usage of High Level Languages such as C. Assembly vs. C. Difference between Conventional C and Embedded C. Advantages Of Embedded C . Why C Language for Embedded Systems. Cross compilers. Bit wise operations and start up code. Reentrant functions , Volatile modifiers. Rules for embedded C programming.

Operating Systems vs. Embedded Systems
• In OS or most of the non-embedded concepts the processing is of main concern and the Input / output . • In Embedded , it is the input / output that is important and processing serves only to connect inputs with outputs.

• OS are not closely tied to the hardware, and, it manipulates hardware registers for memory management,task process switching,interrupt request etc. • Embedded Systems are closely tied to the hardware throughout the system. The system consists of manipulating the hardware registers. • Developing a program in C involves large memory caches, virtual memory,register sets.

• But Embedded systems have limited memory space and registers. • The development of OS does not have the restrictions of the size of the overall systems, power consumption to a larger extent. • The above parameter have to be considered in designing an Embedded Systems.

Usage of High Level Languages. C being a high level language and a familiar language, among the programmers it has become the first choice. Languages such as C are easy in coding.Because they are more reliable programs and they have increased programmer productivity and portability across hardware. C has its reputation increased and it is also implemented in operating systems.

Assembly v/s C.
• The assembly code are difficult to read and maintain. • The amount of code reusable from assembly code is very low. • C programs are easy to read,understand,maintain, because it possesses greater structure. • With C the programmer need not know the architecture of the processor. • Code developed in C will be more portable to other systems rather than in assembly.

Comparison between assembly and Embedded C program
• Assembly Org 00h mov r1,#05h mov r2,#06h mov a,r1 add a,r2 mov r3,a end • Embedded C main( ) { unsigned int a,b,c; a=0x5; b=0x6; c=a+b; Printf (“ %x”,c); }

Difference between Conventional C and Embedded C.
• Compliers for conventional C are TC, BC • Compilers for Embedded C are keil µvision - 2 & 3, PIC C etc. • Conventional C programs needs complier to compile the program & run it. • The embedded C program needs a cross compiler to compile & generate HEX code. • The programs in C are basically processor dependent whereas Embedded C programs are micro controller dependent.

The C program are used for developing an application and not suitable for embedded systems. The embedded C is an extension of the conventional C. i.e Embedded C has all the features of normal C, but has some extra added features which are not available in C. Many functions in C do not support Reentrant concept of functions.

• C are not memory specific. i.e variables cannot be put in the desired memory location but the location of variable can be found out. • In embedded C this can be done using specific inbuilt instructions. • C depends on particular processor or application. • Embedded C are Controller or target specific. • Embedded C allows direct communication with memory.

Why C for Micro controllers
• • • • • • Compatibility Direct access to hardware address Direct connection to interrupts Optimization consideration Development environment Reentrancy

Program flow in Cross Compilers
EDITOR Notepad or Dos











Linker / Locator

.HEX file To Micro Controller

Bit Level Programming & Optimization
Embedded C offers a unique concept of bit level programming. This concept is mainly used to declare a variable that will be stored in the bit addressable area of data memory. This is very useful because the variable declared in this fashion directly points the data in a particular segment of memory. Structures and Unions are possible in bit operation. The bits of the variable can be accessed without using previously declared bit names.

It can be defined in a simple way as Ex: Unsigned char bdata a=10; bit =b; b=a^3; (a=(10)d => ‘0a’ =0000 1010) b = 1; After the final execution , the value of b is 1.

Limitations of bit level program
Bit pointer is invalid. Array of bits is invalid.

Startup code
• Startup code is an extra piece of software that executes prior to main(). The startup code is generally written in assembly language and linked with any executable that you build. • It prepares the way for the execution of programs written in a high-level language. • Each such language has its own set of expectations about the run-time environment in which programs are executed. • For example, many languages utilize a stack. Space for the stack must be allocated and some registers or data structures initialized before software written in the high-level language can be properly executed.

• Startup code for an embedded system should be provided with the cross compiler. • If the compiler is designed to be used for embedded software development, it generally will be. But it is also important to consider whether this code and its proper use are well documented. • The startup code will be written in the assembly language of your target processor and should, ideally, be provided to you in source code form. If properly implemented, you shouldn't ever need to make any changes, but it's still helpful to look at it and understand what it does.

• Startup code for C/C++ usually performs the following actions: • Disable interrupts • Copy any initialized data from ROM to RAM • Zero the un-initialized data area • Allocate space for and initialize the stack • Create and initialize the heap • Execute the constructors and initializers for all global variables (C++ only) • Enable interrupts • Call main()

Embedded Software Development
• The embedded software development tools, cannot make assumption about the target platform. • The user has to provide some details of the system to the tools through explicit statements or instructions. • Once these data are given to the tools, these tools generate the expected outputs on the computer system itself so that the programmer can analyze or make suitable changes in the software to get the desired output.

Reentrancy, Static, Volatile keywords
• A variable is a named object that resides in the RAM. • In C programs each function call causes a frame to be pushed on to stack which contains function parameters and allocation of the locals of the functions. • In embedded C there is no stack allocated . • In a block of memory, a function is given a fixed address space for its local variables . • Thus recursive calls to a function will cause the data in the variables to be corrupted.

• In this, a separate copy of the locals for each function exists. • Because the stack is simulated reentrant functions are large. • Care should be taken that these function do not cross the memory limitations when copies of the functions are created. • This also requires the elimination of any bit parameters, locals and return values from reentrant functions.

Reentrant Functions
Function shared by several processes Reentrant Reentrant Function Function SAME TIME Another Function Reentrant
function known as Recursive function and INTERRUPTS

under Starts Again execution

int calc (char I, int b) reentrant { int x; x=table [ i ]; return (x * b); } Used in real-time applications where interrupt code & non-interrupt code must share a function.

called simultaneously
by two or more


Reentrant Functions
For each Reentrant Function a Reentrant STACK area is simulated in internal or external memory. Memory Model Small model reentrant functions simulate the reentrant stack in idata memory. Compact model reentrant functions simulate the reentrant stack in pdata memory. Large model reentrant functions simulate the reentrant stack in xdata memory.

• Volatile is global variable. • These are specifically used in case of ports or interrupts. Features : • Volatile takes 1 byte instruction. • Permanent memory location is allotted. • Type casting is not possible. • No optimization. • Volatile can modify the value dynamically. • Volatile modifier can change the value outside the scope of function.

# include<reg51.h> unsigned volatile char time; main( ) { time = 0; while(time<100) {}; // waits for 100 counts } void AutoUpdate(void) { time = time + 1; }

• Volatile modifier can change the value outside the scope of the function. • Usually the value of global variable changes only as a result of explicit statements in C functions i.e. currently executing. • Without volatile modifier the compiler may look at the two statements in main and conclude that since the while loop does not modify time it could never reach 100. • Volatile modifier disables the optimization and forces the prg to fetch a new value from that variable each time the variable is accessed.

Creating Environment Variables
• • 3. 4. 5. 6. 7. 8. 9. Declaring a variable involves 2 actions. First action is declaring the type and second action is defining it in memory. E.g. Unsigned char a; 8 bit unsigned number. Char c1; 8 bit unsigned numbers. Unsigned int a; 16 bit unsigned number. int i; 16 bit signed number. Short s; 16 bit signed number. Long l1; 4 signed 32 bit integer. Float & double are not used/ preferred in embedded C programs.

Automatic and Static Variables.
These contents are allowed to change, all the variables must be located in the RAM and not ROM. Automatic variables contains temporary information used only by one software module.These variables are allocated,used and then de-allocated from the stack.These variables provide protection limiting the scope of access in such a way that only the program that created the local variable can access it.The information stored in this are not permanent. Static variable is information shared by more than one program module. Static variables are not deallocated. The memory is permanent.

Compiling With An Embedded Compiler
PROGRAM BUILDING C SOURCE(.C) Other Object Files or Libraries (.obj or .lib) C51 Complier L52/BL51 Linker Absolute Object File DS51-Simulator/ Debugger Listing File (lst) MAP Files (map) In-Circuit Emulator

OHS51 Object Hex Converter HEX File (.hex) Program Device

Creating Executable Programs, temporary files,Include files and Library files.
• The C source code is compiled using c51 compiler by invoking C51.exe. • The command line is C51 source files [directives….] where Source files: is the name of the source program to be compiled. Directive: are directives to the compiler to control the function of the compiler

• The source code is usually developed in C or assembly which are executable programs. • C51 compiler generates a series of output files during compilation. • Basename.lst : (list file) these contain formatted source text with any errors detected by the compiler . • Basename.obj: (object code) These contain the relocatable object code.These are linked to an absolute module by L51 linker/locator. • Basename.I:contains source text as expanded by the preprocessor.All macros are expanded and all comments are deleted on this listing.32

• Basename.src: these are assembly source files generated from c source code.These are assembled with A51 assembler. • Basename.hex (I): this is a hex file or a binary file used to program the device. Include files: Embedded c program needs some important include and library files.Include files includes mainly the header files which are required to convert the source code suitable for application or device.

• Some of the most common header files used in the ARM LPC 2129 are “LPC21xx.h”. • Apart from these, common header used in conventional C i.e <stdio.h> can be used. • User can create own header files and reduce the code size. • Some of the important library functions are inbuilt features that help the user to access the internal memory location as well as external hardware pins of the device. • Some of these header files as well as the library functions are not available in conventional C.

Running the Compiler The most commonly used compilers are keil- 2,3 , Pic C and Hitech C.
In Keil micro-vision 2 or 3, A new project has to be created in the start. For that project, a target, usually a controller which is used for the application is selected . For that project a source group is added.Source group usually contains the source code files. Once the source code is developed ,this code is compiled by the cross compiler. This compilation is usually called as “Build”. During this stage, object files are created by the compiler.

After compilation, these are linked to the linker which produces a .hex code.These code formats are suitable for the micro controller.

Identifying Error Levels During compilation: There are three different categories in identifying the error levels during compilation. These errors are caused during 1.assembling 2.compiling and 3.Run time. The assembling errors are caused during the assembling of the source code.The compilation errors are generated during compilation. The above two errors are caused due to syntax errors in the program . These errors are generated by the compiler for the users reference. The errors and the reason for these are provided as help to the user in Keil library functions.

These are described under the heading as A51(assembling errors), C51(compile time errors) and Linking errors.

Run time errors:
The runtime errors are caused during the linking of the source code. The runtime errors are generated during runtime by loader/linker. These errors are not highlighted during the compile time. Because these errors does not affect the compiler while generating object code. These errors are caused when the processor cannot execute any instruction which are used in the program.

The errors and the reason for these are provided as help to the user in Keil library functions. Generation of Compiler output files A compiler mainly translates program written in a high level language into an equivalent set of opcodes for a particular processor.Each processor has its own unique machine language . A compiler that runs on one computer platform and produces code for another is called as “Cross compiler”. A compiler produces a series of files called as object files.

Uses OS as Platform

Cross Compiler
Uses OS as Platform

1. Edit the program 3. Compilation 5. Running / Execution 4. Output

2. Edit the program 4. Compilation Uses 2nd platform ie hardware Execution and output

.OBJ files: After the C file is compiled object files (.Obj) are generated.These files are used to link with other .obj , library (.Lib) files to generate an absolute object file.To invoke the linker L51 has to be used. The structure of these object files is defined by a standard format like COFF (“Common Object File Format”) or ELF(Extended Linker Format). Cross assembler: Assembler is also a compiler .It is also called as assembly language compiler.The assembler compiles and generates object files for an assembly program only.These assemblers produce the same object file as C compiler.

Debuggers: Are used for the step by step execution of the program.In this for each execution in steps, the debugger operates on the object code generated during compile time. Linkers: The different object files generated by the compiler are linked together to form a new object file. This file contains all the code and data from the input object files and are in the same object file format. MAP files generated by the linker gives information of absolute object file/absolute

location of program,which includes both data and code. Once the linking is finished, all the machine language codes from all the input object files will be in the text section of the new data. While the linker is in the process of merging the contents it also looks for unresolved symbols. After merging all the code & data sections & resolving all the symbol references, the linker produces a special relocatable copy of the program. i.e. The program is complete except that no memory address is allotted for data & code sections.

Locator / Loader:
• The tool that performs the conversion from relocatable program to executable binary images is called locater. The input to the locater is the information about the memory on the target address . • The locater uses the information to assign physical memory to each code & data sections within the locatable program. • It will then produce an output file that contains a binary memory image that can be loaded into the target ROM. • In 8051/ ARM the locater is built in the linker itself.

• The memory information required by the linker is passed in the form of a linker script. • This script informs the linker’s built in locator about the memory on the target board and instructs it to locate the data and BSS sections in the RAM. • The result of this final step of build process is an absolutely located binary image that can be downloaded to an embedded system or programmed in to a read –memory device.

Emulator :
Emulators are hardware devices which duplicate the functions of one system as that of the other system, so that second system appears to behave as the first system. Emulators are basically the processor modules which are custom programmed to behave as the actual target system as it was a real target. These are based on single processor. The processor are preprogrammed for the target requirement. In the actual circuit all the devices are physically present on the system so that they provide the desired signals to the processor or controller to do its job.

• In this, since the processor are preprogrammed, the signals generated by the actual devices on the target are particularly generated by the processor and the processor generates corresponding required output which should be actually generated by the target itself.

Simulators Simulators are software, present in the IDE that simulates the hardware conditions which would have been generated by the actual hardware components in the target. These help the programmer to debug the program step by step and check the proper flow of the program. This works on the concept of virtual circuit. We can check the output by simulating the required condition. 8051 Simulator simplifies code development with Micro C and Micro-IDE.

Errors in user programs can be found and fixed quickly in simulation mode by avoiding time consuming downloads to the target board. Support for hardware ports in simulation. Use real I/O ports from your target boards while simulating the program on your PC. Integrated Development Environment to edit, build, download, simulate and debug within the same program. Simulation of 8051 programs in C, Assembly or mixed level. Simulated program can be simultaneously viewed in C and Assembly. Variable window to watch C variable names, values and addresses.

Register window to watch the simulated special function registers including all ports. Memory window to watch and modify up to 4GB of simulated program memory, 256kB. Call stack window to view list of function calls that lead to current program line (traces all jumps and calls ) Terminal window to simulate the serial port ( both receive and transmit are simulated ) Output Window Debug Tab to watch debug messages Fully customizable window layout with dockable or floating debug windows. Stop Debugging button to stop simulation at any point Go button to start execution Step Into and Step Over buttons to single-step through the source code at C or Assembly level Unlimited number of breakpoints to stop execution at any C or Assembly source line.

Rules for developing Embedded C Program
Code Optimization.

2. Minimize local variables        If the number of local variables in a function is less,  the  compiler  will  be  able  to  fit  them  into  registers.  Hence,  it  will  be  avoiding  frame  pointer  operations  on  local  variables  that  are  kept  on  stack.  This  can  result  in  considerable  improvement  due  to  two  reasons: • • All  local  variables  are  in  registers  so  this  improves  performance over accessing them from memory.  If no local variables need to be saved on the stack,  the compiler will not incur the overhead of setting up  and restoring the frame pointer. 

1. Declare local variables in the inner most scope • Do not declare all the local variables in the outermost function scope. • If local variables are declared in the inner most scope. • If the parameter was declared in the outermost scope, all function calls would have incurred the overhead of object .

• Place case labels in narrow range •If the case labels are in a narrow range, the compiler does not generate a if-else-if cascade for the switch statement. • Instead, it generates a jump table of case labels along with manipulating the value of the switch to index the table. •This code generated is faster than if-else-if cascade code that is generated in cases where the case labels are far apart. •Also, performance of a jump table based switch statement is independent of the number of case entries in switch statement.

Reduce the number of parameters Function calls with large number of parameters may be expensive due to large number of parameter pushes on stack on each call. For the same reason, avoid passing complete structures Use references for parameter passing and return value for as parameters. Use pointers and references in such types bigger than 4 bytes cases.           Passing parameters by value results in the complete parameter being copied on to the stack. This is fine for regular types like integer, pointer etc. These types are generally restricted to four bytes. When passing bigger types, the cost of copying the object on the stack can be prohibitive.

Thus it is efficient to pass references as parameters. This way you save on the overhead of a temporary object creation, copying and destruction. This optimization can be performed easily without a major impact to the code by replacing pass by value parameters by const references. (It is important to pass const references so that a bug in the called function does not change the actual value of the parameter. Passing bigger objects as return values also has the same performance issues. A temporary return object is created in this case too.

•Use All the SFR’s in capital letters only. •Reduce the warnings in the program. •Make use of MACRO definitions in the program. •Always define the variables in the code memory by using the keyword code in declaration. •Eg unsigned int code a[] = { }; •Always define as unsigned type of declaration. •Make use of sbit definition for single bit declaration. •Eg sbit rs = P3^6; •Since these are not floating point co-processor, no decimal values can be given as input to them.

• So we cannot define the above declaration as sbit rs = P3.6. • The declaration like this below are invalid. P3^6 = 0; • P3^6 is bit addressable type & 0 is a 8 bit data which cannot be stored in single bit. • Permanent termination of the program is got by using while(1); • Infinite loop can be achieved by while(1) { ……… }

Sign up to vote on this title
UsefulNot useful