@ McGraw-Hill Education

Embedded System Design

I Semester M.Tech

1
 @ McGraw-Hill Education

PROPRIETARY MATERIAL. © 2009 The McGraw-Hill Companies, Inc. All rights reserved. No part of this PowerPoint slide may be displayed, reproduced or
distributed in any form or by any means, without the prior written permission of the publisher, or used beyond the limited distribution to teachers and educators
permitted by McGraw-Hill for their individual course preparation. If you are a student using this PowerPoint slide, you are using it without permission.
2
 @ McGraw-Hill Education

Syllabus Contents
• Introduction
• Typical Embedded System
• Characteristics and Quality Attributes of
Embedded Systems
• Hardware Software Co-Design and Program
Modeling
• Embedded Firmware Design and Development
• Real-Time Operating System (RTOS) based
Embedded System Design
• The Embedded System Development
Environment
• Trends in the Embedded Industry 3
 @ McGraw-Hill Education

• Embedded Firmware Design and

Development
– Embedded Firmware Design Approaches
• Super loop based approach
• Embedded Operating System based approach
– Embedded Firmware Development Languages
• Assembly Language
• High Level Language

4
 @ McGraw-Hill Education

Embedded Firmware Design & Development

The embedded firmware is responsible for controlling the
various peripherals of the embedded hardware and generating
response in accordance with the functional requirements of the
product.
The embedded firmware is usually stored in a permanent
memory (ROM) and it is non alterable by end users.
Designing Embedded firmware requires understanding of the
particular embedded product hardware, like various component
interfacing, memory map details, I/O port details, configuration
and register details of various hardware chips used and some
programming language (either low level Assembly Language or
High level language like C/C++ or a combination of the two).

5
 @ McGraw-Hill Education

Embedded Firmware Design & Development

The embedded firmware development process starts with
the conversion of the firmware requirements into a
program model using various modeling tools
There exist two basic approaches for the design and
implementation of embedded firmware, namely;
The Super loop based approach
The Embedded Operating System based approach
The decision on which approach needs to be adopted for
firmware development is purely dependent on the
complexity and system requirements

6
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Embedded firmware Design Approaches – The Super
loop
 Suitable for applications that are not time critical and
where the response time is not so important (Embedded
systems where missing deadlines are acceptable)
 Very similar to a conventional procedural programming
where the code is executed task by task
 The tasks are executed in a never ending loop. The task
listed on top on the program code is executed first and the
tasks just below the top are executed after completing the
first task
7
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Embedded firmware Design Approaches –
The Super loop
 A typical super loop implementation will look like:
1Configure the common parameters and perform
initialization for various hardware componentsvoid main ()
memory, registers etc. {
Configurations ();
2Start the first task and execute it Initializations ();
3Execute the second task while (1)
{
4Execute the next task Task 1 ();
5: Task 2 ();
//:
6: //:
Task n ();
7Execute the last defined task }
8Jump back to the first task and follow the same flow } 8
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Embedded firmware Design Approaches – The Super loop

Pros:
Doesn’t require an Operating System for task scheduling and
monitoring and free from OS related overheads
Simple and straight forward design
Reduced memory footprint
Cons:
Non Real time in execution behavior (As the number of tasks
increases the frequency at which a task gets CPU time for
execution also increases)
Any issues in any task execution may affect the functioning of
the product (This can be effectively tackled by using Watch Dog
Timers for task execution monitoring)
9
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Embedded firmware Design Approaches – The Super loop

Enhancements:
Combine Super loop based technique with interrupts
Execute the tasks (like keyboard handling) which
require Real time attention as Interrupt Service routines

10
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Embedded firmware Design Approaches – Embedded
OS based Approach
 The embedded device contains an Embedded Operating
System which can be one of:
A Real Time Operating System (RTOS)
A Customized General Purpose Operating System
(GPOS)
 The Embedded OS is responsible for scheduling the
execution of user tasks and the allocation of system
resources among multiple tasks
 Involves lot of OS related overheads apart from
managing and executing user defined tasks 11
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Embedded firmware Design Approaches – Embedded
OS based Approach
 Microsoft® Windows XP Embedded is an example of
GPOS for embedded devices
 Point of Sale (PoS) terminals, Gaming Stations, Tablet
PCs etc are examples of embedded devices running on
embedded GPOSs
 ‘Windows CE’, ‘Windows Mobile’,‘QNX’, ‘VxWorks’,
‘ThreadX’, ‘MicroC/OS-II’, ‘Embedded Linux’,
‘Symbian’ etc are examples of RTOSs employed in
Embedded Product development
 Mobile Phones, PDAs, Flight Control Systems etc are 12

examples of embedded devices that runs on RTOSs

 @ McGraw-Hill Education

Embedded Firmware Design & Development

Embedded firmware Development Languages/Options

Assembly Language
High Level Language
Subset of C (Embedded C)
Subset of C++ (Embedded C++)
Any other high level language with supported Cross-compiler
Mix of Assembly & High level Language
Mixing High Level Language (Like C) with Assembly Code
Mixing Assembly code with High Level Language (Like C)
Inline Assembly

13
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Embedded firmware Development Languages/Options –
Assembly Language

 ‘Assembly Language’ is the human readable notation of

‘machine language’
 ‘machine language’ is a processor understandable language
 Machine language is a binary representation and it consists of 1s
and 0s
 Assembly language and machine languages are
processor/controller dependent
 An Assembly language program written for one
processor/controller family will not work with others

14
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Embedded firmware Development Languages/Options –
Assembly Language
 Assembly language programming is the process of writing
processor specific machine code in mnemonic form,
converting the mnemonics into actual processor instructions
(machine language) and associated data using an assembler
 The general format of an assembly language instruction is an
Opcode followed by Operands
 The Opcode tells the processor/controller what to do and the
Operands provide the data and information required to perform
the action specified by the opcode
 It is not necessary that all opcode should have Operands
following them. Some of the Opcode implicitly contains the
operand and in such situation no operand is required. The operand
15
may be a single operand, dual operand or more
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Embedded firmware Development Languages/Options –
Assembly Language
The 8051 Assembly Instruction
MOV A, #30
Moves decimal value 30 to the 8051 Accumulator register. Here
MOV A is the Opcode and 30 is the operand (single operand). The
same instruction when written in machine language will look like
01110100 00011110
The first 8 bit binary value 01110100 represents the opcode MOV A
and the second 8 bit binary value 00011110 represents the
operand 30.

16
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Embedded firmware Development Languages/Options –
Assembly Language

 Assembly language instructions are written one per line

 A machine code program consists of a sequence of assembly
language instructions, where each statement contains a mnemonic
(Opcode + Operand)
 Each line of an assembly language program is split into four
fields as:
LABEL OPCODE OPERAND COMMENTS

17
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Embedded firmware Development Languages/Options –
Assembly Language
 LABEL is an optional field. A ‘LABEL’ is an identifier used
extensively in programs to reduce the reliance on programmers
for remembering where data or code is located. LABEL is
commonly used for representing
A memory location, address of a program, sub-routine, code
portion etc.
The maximum length of a label differs between assemblers.
Assemblers insist strict formats for labeling. Labels are always
suffixed by a colon and begin with a valid character. Labels can
contain number from 0 to 9 and special character _ (underscore).

18
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Embedded firmware Development Languages/Options – Assembly
Language

;##################################################################
##
; SUBROUTINE FOR GENERATING DELAY
; DELAY PARAMETR PASSED THROUGH REGISTER R1
; RETURN VALUE NONE
; REGISTERS USED: R0, R1
;##################################################################
## DELAY: MOV R0, #255 ; Load Register R0 with 255
DJNZ R1, DELAY ; Decrement R1 and loop till
R1= 0
RET ; Return to calling program

19
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Embedded firmware Development Languages/Options – Assembly
Language

The symbol ; represents the start of a comment.

Assembler ignores the text in a line after the ; symbol
while assembling the program
DELAY is a label for representing the start address of the
memory location where the piece of code is located in
code memory
The above piece of code can be executed by giving the
label DELAY as part of the instruction. E.g. LCALL
DELAY; LMP DELAY

20
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Embedded firmware Development Languages/Options – Assembly
Language – Source File to Hex File Translation

The Assembly language program written in assembly

code is saved as .asm (Assembly file) file or a .src
(source) file or a format supported by the assembler
Similar to ‘C’ and other high level language
programming, it is possible to have multiple source files
called modules in assembly language programming.
Each module is represented by a ‘.asm’ or ‘.src’ file or
the assembler supported file format similar to the ‘.c’
files in C programming
The software utility called ‘Assembler’ performs the
translation of assembly code to machine code 21
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Embedded firmware Development Languages/Options – Assembly
Language – Source File to Hex File Translation
The assemblers for different family of target machines
are different. A51 Macro Assembler from Keil software
is a popular assembler for the 8051 family micro
controller
Each source file can be assembled separately to
examine the syntax errors and incorrect assembly
instructions
Assembling of each source file generates a
corresponding object file. The object file does not
contain the absolute address of where the generated code
needs to be placed (a re-locatable code) on the program
22
memory
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Embedded firmware Development Languages/Options – Assembly
Language – Source File to Hex File Translation

The software program called linker/locater is

responsible for assigning absolute address to object files
during the linking process
The Absolute object file created from the object files
corresponding to different source code modules contain
information about the address where each instruction
needs to be placed in code memory
A software utility called ‘Object to Hex file converter’
translates the absolute object file to corresponding hex
file (binary file)
23
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Embedded firmware Development Languages/Options – Assembly
Language – Source File to Hex File Translation

Assembly language to machine language Conversion process24

 @ McGraw-Hill Education

Embedded Firmware Design & Development

Embedded firmware Development Languages/Options – Assembly
Language – Source File to Hex File Translation
Advantages:

Efficient Code Memory & Data Memory Usage (Memory

Optimization)
High Performance
Low level Hardware Access
Code Reverse Engineering

Drawbacks:

High Development time

Developer dependency
Non portable 25
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Embedded firmware Development Languages/Options
– High Level Language

 The embedded firmware is written in any high level

language like C, C++
 A software utility called ‘cross-compiler’ converts the
high level language to target processor specific machine
code
The cross-compilation of each module generates a
corresponding object file. The object file does not contain
the absolute address of where the generated code needs to
be placed (a re-locatable code) on the program memory 26
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Embedded firmware Development Languages/Options
– High Level Language
The software program called linker/locater is responsible
for assigning absolute address to object files during the
linking process
The Absolute object file created from the object files
corresponding to different source code modules contain
information about the address where each instruction
needs to be placed in code memory
A software utility called ‘Object to Hex file converter’
translates the absolute object file to corresponding hex file
(binary file)
27
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Embedded firmware Development Languages/Options – High Level
Language – Source File to Hex File Translation

Library Files

Source File 1
Module
(.c /.c++ etc) Object File 1
Cross-compiler
(Module-1)

Source File 2
Module
(.c /.c++ etc) Object File 2
Cross-compiler
(Module-2)

Object to Hex File Linker/

Absolute Object File
Converter Locator

Machine Code
(Hex File)
High level language to machine language
28
Conversion process
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Embedded firmware Development Languages/Options – High Levely
Language – Source File to Hex File Translation
Advantages:

Reduced Development time

Developer independency
Portability

29
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Embedded firmware Development Languages/Options
– Mixing of Assembly Language with High Level
Language

 Certain situations in Embedded firmware development

may require the mixing of Assembly Language with
high level language or vice versa. Interrupt handling,
Source code is already available in high level
language\Assembly Language etc are examples
 High Level language and low level language can be
mixed in three different ways
30
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Embedded firmware Development Languages/Options
– Mixing of Assembly Language with High Level
Language

Mixing Assembly Language with High level language

like ‘C’
Mixing High level language like ‘C’ with Assembly
Language
In line Assembly
 The passing of parameters and return values between the
high level and low level language is cross-compiler
specific 31
 @ McGraw-Hill Education

Embedded Firmware Design & Development

High Level Language – ‘C’ V/s Embedded C
 ‘C’ is a well structured, well defined and standardized general
purpose programming language with extensive bit manipulation
support
 ‘C’ offers a combination of the features of high level language
and assembly and helps in hardware access programming (system
level programming) as well as business package developments
(Application developments like pay roll systems, banking
applications etc)
 The conventional ‘C’ language follows ANSI standard and it
incorporates various library files for different operating systems
 A platform (Operating System) specific application, known as,
compiler is used for the conversion of programs written in ‘C’ to
the target processor (on which the OS is running) specific binary
32
files
 @ McGraw-Hill Education

Embedded Firmware Design & Development

High Level Language – ‘C’ V/s Embedded C
 Embedded C can be considered as a subset of conventional ‘C’
language
 Embedded C supports all ‘C’ instructions and incorporates a few
target processor specific functions/instructions
 The standard ANSI ‘C’ library implementation is always tailored
to the target processor/controller library files in Embedded C
 The implementation of target processor/controller specific
functions/instructions depends upon the processor/controller as
well as the supported cross-compiler for the particular Embedded
C language
 A software program called ‘Cross-compiler’ is used for the
conversion of programs written in Embedded C to target
processor/controller specific instructions 33
 @ McGraw-Hill Education

Embedded Firmware Design & Development

High Level Language Based Development – ‘Compiler’ V/s
‘Cross-Compiler’
 Compiler is a software tool that converts a source code written in
a high level language on top of a particular operating system
running on a specific target processor architecture (E.g. Intel
x86/Pentium).
 The operating system, the compiler program and the application
making use of the source code run on the same target processor.
 The source code is converted to the target processor specific
machine instructions
 A native compiler generates machine code for the same machine
(processor) on which it is running.
 Cross compiler is the software tools used in cross-platform
development applications 34
 @ McGraw-Hill Education

Embedded Firmware Design & Development

High Level Language Based Development – ‘Compiler’ V/s
‘Cross-Compiler’
 In cross-platform development, the compiler running on a
particular target processor/OS converts the source code to
machine code for a target processor whose architecture and
instruction set is different from the processor on which the
compiler is running or for an operating system which is different
from the current development environment OS
 Embedded system development is a typical example for cross-
platform development where embedded firmware is developed on
a machine with Intel/AMD or any other target processors and the
same is converted into machine code for any other target
processor architecture (E.g. 8051, PIC, ARM9 etc).
 Keil C51compiler from Keil software is an example for cross-
compiler for 8051 family architecture 35
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C

Keywords

auto double int struct

break else long switch

case enum register typedef

char extern return union

const float short unsigned

continue for signed void

default goto sizeof volatile

do if static while

36
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C

Data Type Size (Bits) Range Comments

char 8 -128 to +127 Signed Character
signed char 8 -128 to +127 Signed Character
unsigned char 8 0 to +255 Unsigned Character
short int 8 -128 to +127 Signed short integer
signed short int 8 -128 to +127 Signed short integer
unsigned short int 8 0 to +255 Unsigned short integer
int 16 -32,768 to +32,767 Signed integer
signed int 16 -32,768 to +32,767 Signed integer
unsigned int 16 0 to +65,535 Unsigned integer
long int 32 -2147,483,648 to Signed long integer
+2,147,483,647
signed long int 32 -2147,483,648 to Signed long integer
+2,147,483,647
unsigned long int 32 0 to +4,294,967,295 Unsigned long integer
float 32 3.4E-38 to 3.4E+38 Signed floating point
double 64 1.7E-308 to 1.7E+308 Signed floating point
(Double precision)
long double 80 3.4E-4932 to 3.4E+4932 Signed floating point (Long
Double precision)
37
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C

Storage Class Meaning Comments

Variables declared inside Scope and accessibility is restricted
auto a function. Default within the function where the variable is
storage class is auto declared. No initialization. Contains junk
values at the time of creation
Variables stored in the Same as auto in scope and access. The
register CPU register of decision on whether a variable needs to
processor. Reduces be kept in CPU register of the processor
access time of variable depends on the compiler
Retains the value throughout the
static Local variable with life program. By default initializes to zero on
time same as that of the variable creation. Accessibility depends
program on where the variable is declared
Variables accessible to all Can be modified by any function within a
extern functions in a file and all file or across multiple files (variable
files in a multiple file needs to be exported by one file and
program imported by other files using the same)
38
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C

Arithmetic Operation Comments

Operator
+ Addition Adds variables or numbers
- Subtraction Subtracts variables or numbers
* Multiplication Multiplies variables or numbers
/ Division Divides variables or numbers
% Remainder Finds the remainder of a division

Logical Operations
Operator Operation Comments
Performs logical AND operation. Output is true (logic 1) if
&& Logical AND both operands (left to and right to of && operator) are true
Performs logical OR operation. Output is true (logic 1) if
|| Logical OR either operand (operands to left or right of || operator) is
true
! Logical NOT Performs logical Negation. Operand is complemented
(logic 0 becomes 1 and vice versa)
39
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C
Branching Instructions
Conditional branching Explanation
Instruction
//if statement
if (expression) Evaluates the expression first and if it is true executes the statements given within the { }
{ braces and continue execution of statements following the closing curly brace (}). Skips
statement1; the execution of the statements within the curly brace { } if the expression is false and
statement2; continue execution of the statements following the closing curly brace (}).
………….; One way branching
}
statement 3;
…………..;
//if else statement
if (expression) Evaluates the expression first and if it is true executes the statements given within the { }
{ braces following if (expression) and continue execution of the statements following the
if_statement1; closing curly brace (}) of else block. Executes the statements within the curly brace { }
if_statement2; following the else, if the expression is false and continue execution of statements
…………….; following the closing curly brace (}) of else.
} Two way branching
else
{
else_statement1;
else_statement2;
……………….;
}
statement 3; 40
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C
Branching Instructions

Conditional branching Explanation

Instruction
//switch case statement
switch (expression) Tests the value of a given expression against a list of case values for a matching condition. The
{ expression and case values should be integers. value1, value2 etc are integers. If a match found,
case value1: executes the statement following the case and breaks from the switch. If no match found, executes
break; the default case.
case value2: Used for multiple branching.
break;
default:
break;
}
//Conditional operator
// ?exp1 : exp2 Used for assigning a value depending on the (expression). (expression) is calculated first and if it is
(expression) ?exp1: exp2 greater than 0, evaluates exp1 and returns it as a result of operation else evaluate exp2 and returns it
E.g. as result. The return value is assigned to some variable.
if (x>y) It is a Combination of if else with assignment statement.
a=1; Used for two way branching
else
a=0;
can be written using conditional
operator as
a=(x>y)? 1:0
//unconditional branching goto is used as un conditional branching instruction. goto transfers the program control indicated by
goto label a label following the goto statement. The label indicated by goto statement can be anywhere in the
program either before or after the goto label instruction. 41
goto is generally used to come out of deeply nested loops in abnormal conditions or errors.
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C
Loop Control Instructions
Looping Instruction Explanation
//while statement
while (expression) Entry controlled loop statement.
{ The expression is evaluated first and if it is true the body of the loop is entered and
body of while loop executed. Execution of ‘body of while loop’ is repeated till the expression becomes false.
}
// do while loop
do The ‘body of the loop’ is executed at least once. At the end of each execution of the ‘body
{ of the loop’, the while condition (expression) is evaluated and if it is true the loop is
body of do loop repeated, else loop is terminated.
}
while (expression);
//for loop
for (initialization; test for condition; Entry controlled loop. Enters and executes the ‘body of loop’ only if the test for condition
update variable) is true. for loop contains a loop control variable which may be initialized within the
{ initialization part of the loop. Multiple variables can be initialized with ‘,’ operator.
body of for loop
}

//exiting from loop Loops can be exited in two ways. First one is normal exit where loop is exited when the
break; expression/test for condition becomes false. Second one is forced exit. break and goto
goto label statements are used for forced exit.
break exits from the inner most loop in a deeply nested loop, whereas goto transfers the
program flow to a defined label.
42
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C
Loop Control Instructions
Looping Instruction Explanation
//skipping portion of a loop
while (expression) Certain situation demands the skipping of a portion of a loop for some
{ conditions. The ‘continue’ statement used inside a loop will skip the rest of
…………..; the portion following it and will transfer the program control to the
if (condition); beginning of the loop.
continue; //for loop with skipping
………….; for (initialization; test for condition; update variable)
} {
//do while with skipping …………….;
do if (condition)
{ continue;
…………….; …………….;
if (condition) }
continue;
…………….;
}
while (expression);

43
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C - Loops
//###########################################################
//using while loop
//###########################################################
char *status_reg = (char *) 0x3000; //Declares memory mapped register

while (*status_reg!=0x01); //Wait till status_reg = 0x01

//###########################################################
//using do while loop
//###########################################################
char *status_reg = (char*) 0x3000;

do
{

} while (*status_reg!=0x01); Loop till status_reg = 0x01

//###########################################################
//using for loop
//###########################################################
char *status_reg = (char*) 0x3000;

for (;(*status_reg!=0x01););
44
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Arrays
 Array is a collection of related elements (data types)
 Arrays are usually declared with data type of array, name of the array and the
number of related elements to be placed in the array
char arr [5];

Contents of each memory location†

0x10 0x00 0x23 0x03 0x45

arr[0] arr[1] arr[2] arr[3] arr[4]

0x8000 0x8001 0x8002 0x8003 0x8004

Address of the memory location where the array elements are stored†
Array representation in memory

&arr[0] 0x8000

arr[0] 0x10

Array element address and content relationship

45
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Array Initialisation
 Method 1: Initialise the entire array at the time of array declaration itself
 Method 2: Selective initialization where any member can be initialized or
altered with a value
//Initialization of array at the time of declaration

unsigned char arr[5] = {5, 10, 20, 3, 2};

unsigned char arr[ ] = {5, 10, 20, 3, 2};

//Selective initialization

unsigned char arr[5];

arr[0] = 5;
arr[1] = 10;
arr[2] = 20;
arr[3] = 3;
arr[4] = 2;
46
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Pointers
 Pointer is a memory pointing based technique for variable access and
modification
 To understand the pointer concept, consider the data memory orgnanisation of
8051 Memory Address
0x00
0x01

Data memory organization of 8051

0x7E
0x7F

 If we declare a character variable in ‘C’ as explained below, the cross-compiler

assigns a memory to the variable and store the value assigned to this variable in
its corresponding memory location

char input =10;

47
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Pointers
 Let us assume that the memory address assigned to the character variable input
by the cross-compiler is 0x45

Variable Name Memory Address Content

input 0x45 10

Relationship between variable name, address and data held by variable

 The content of memory location representing the variable input (0x45) can be
accessed and modified by using a pointer of type same as the variable (char for
the variable input in the example)
 In Embedded C the same is achieved through

char input; =10 //Declaring input as character variable

char *p; //Declaring a character pointer p (* denotes p is a pointer)
p = &input //Assigns the address of input as content to p

48
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Pointers
 Cross-compiler assigns a memory location to the character pointer variable ‘p’.
Let it be 0x00 (Arbitrary value chosen for illustration) and the memory location
holds the memory address of variable input (0x45) as content
 In ‘Embedded C’ the address assignment to pointer is done using the address of
operator & or it can be done using explicitly by giving a specific address

Variable Name Memory Address Content

input 0x45 10

p 0x00 0x45

Pointer based memory accessing technique

49
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Pointers & Arrays – Are they related?

Arrays are not equivalent to pointers and pointers are not equivalent to
arrays
The expression array name [] is equivalent to a pointer, of type specified
by the array, to the first element of an array
E.g. for the character array char arr[5], arr[ ] is equivalent to a character
pointer pointing to the first element of array arr (This feature is referred
as ‘equivalence of pointers and arrays’)
The array features like accessing and modifying members of an array
can be achieved using a pointer and pointer increment/decrement
operators
Arrays and pointer declarations are interchangeable when they are used
as parameters to functions

50
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Characters & Strings
 Character is a one byte data type and it can hold values
ranging from 0 to 255 (unsigned character) or -128 to
+127 (signed character)
 The term character literally refers to the alpha numeric
characters (English alphabets A to Z (both small letters
and Capital letters) and number representation from ‘0’
to ‘9’) and special characters like *, ?, ! Etc
 String is an array of characters
 A group of characters defined within a double quote
represents a constant string
51
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Characters & Strings
 ‘H’ is an example for a character, whereas “Hello” is an
example for a string. String always terminates with a
‘\0’ character
 The ‘\0’ character indicates the string termination
 Whenever you declare a string using a character array,
allocate space for the null terminator ‘\0’ in the array
length

E.g. char name [ ] = “HELLO” ;

char name [6] = {‘H’, ‘E’, ‘L’, ‘L’, ‘O’, ‘\0’};

52
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Input Output
Operations
 Conventional ‘C’ programs running on desktop
machines uses the standard string inputting (scanf()) and
string outputting (printf()) functions from the platform
specific I/O library for I/O operations
 Standard keyboard and monitor are used as the input and
output media for desktop application
 Embedded systems are compact and they need not
contain a standard keyboard or monitor screen for I/O
functions. Instead they incorporate application specific
keyboard and display units (Alpha numeric/graphic) as
53
user interfaces or uses serial ports as I/O interface
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Input Output
Operations
 Embedded C implements the tailored version of the
standard ANSI C I/O library depending on the I/O
interface of the embedded systems
 scanf() and printf() are the string input and output
functions respectively in ANSI C library
implementation
 stdio.h is the header file corresponding to the I/O library
in ANSI C implementation

54
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – String Operations
 string.h is the header file corresponding to the library file for
string operations in ANSI C implementation
 The Library function strcat (str1, str2) concatenates two strings
and stores the result in first string which is passed as parameter to
this function
 The null character (‘\0’) from the end of ‘str1’ is removed and
‘str2’ is appended to ‘str1’
 The string ‘str2’ remains unchanged
 As a precautionary measure, ensure that str1 (first parameter
of ‘strcat( )’ function) is declared with enough size to hold the
concatenated string.
 Library function ‘strcat()’ can also be used for appending a
constant string to a string variable 55
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – String Operations
 The Library function strcmp (str1, str2) concatenates two strings
and stores the result in first string which is passed as parameter to
this function
 The return value of ‘strcmp()’ will be zero if the two strings are
identical
 If the two strings are not equal and if the ASCII value of the first
non-matching character in the string str1 is greater than that of the
corresponding character for the second string str2, the return
value will be greater than zero.
 If the ASCII value of first non-matching character in the string
str1 is less than that of the corresponding character for the second
string str2, the return value will be less than zero
56
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – String Operations

 The function ‘strcmp()’ is case sensitive

 The library function ‘stricmp()’ is another string comparison function
which is non-case sensitive
 The Library function strlen () returns the length of a string excluding
the null termination character ‘\0’
 The Library function strcpy(str1, str2) implements string copying
 The string str2 is copied to str1
 String str2 remains unchanged
 The size of the character array which is passed as the first argument
the strcpy( ) function should be large enough to hold the copied
string
 strcpy() function can also be used for assigning a constant string to a
57
string variable
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Functions

 A function is a self contained and re-usable code snippet intended

to perform a specific task
 ‘Embedded C’ supports two different types of functions namely
 library functions
 user defined functions
 Library functions are the built in functions which is either part
of the standard ‘Embedded C’ library or user created library
files
 All library functions supported by a particular library is
implemented and exported in the same

58
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Functions

 ‘Embedded C’ supports two different types of functions namely

 printf(), scanf (), strcpy(), strcmp() etc are examples of
standard library functions
 A corresponding header (‘.h’) file for the library file provides
information about the various functions available to user in a
library file
 Users should include the header file corresponding to a
particular library file for calling the functions from that library
in the ‘C’ source file
 User defined functions are programmer created functions in
the source file (Not in a library file) for various reasons like
modularity, easy understanding of code, code reusability etc 59
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Functions

 The generic syntax for a function definition (implementation) is

illustrated below
Return type function name (argument list)

{
//Function body (Declarations & statements)
//Return statement
}

 Return type of a function tells – what is the data type of the

value returning by the function on completion of its execution
60
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Functions

 The general form of function declaration is

Linkage Type Return type function name (arguments);

E.g. static int add(int a, int b);

 The ‘Linkage Type’ specifies the linkage for the function. It can
be either ‘external’ or ‘internal’
 The ‘static’ keyword for the ‘Linkage Type’ specifies the
linkage of the function as internal whereas the ‘extern’ ‘Linkage
Type’ specifies ‘external’ linkage for the function

61
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Function Pointer

 A function pointer is a pointer variable pointing to a function

 The function pointer points to the memory address where the
first instruction corresponding to the function is located
 The general form of declaration of a function pointer is

return_type (*pointer_name) (argument list)

 ‘return_type’ represents the return type of the function,

‘pointer_name’ represents the name of the pointer and
‘argument list’ represents the data type of the arguments of the
function 62
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Function Pointer

//Function pointer to a function returning int and takes

no parameter
int (*fptr)();
//Function pointer to a function returning int and takes 1
parameter
int (*fptr)(int)

 The parenthesis () around the function pointer variable

differentiates it as a function pointer variable

63
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Structure

 structure is a variable holding a collection of data

types (int, float, char, long etc)
 The data types can be either unique or distinct
 The tag ‘struct’ declares a variable as structure

64
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Structure

 The general form of a structure declaration is

structstruct_name  struct_name is the name of the

structure

{ struct employee
//variable 1 declaration { char emp_name [20];//
Allowed maximum length for
//variable 2 to declaration name = 20
int emp_code;
//…………… char DOB [10]; // DD-
MM-YYYY Format (10
//variable n declaration character)
};
}; 65
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Structure Operations
Operator Operation Example
employee emp1,emp2;
= (Assignment) Assigns the values of one structure emp1.emp_code = 42170;
to another structure of same type strcpy(emp1.emp_name,"SHIBU");
strcpy(emp1.DOB,"");
emp2=emp1;
Compare individual members of
== (Checking the two structures of same type for employee emp1,emp2;
equality of all equality. Return 1 if all members emp1.emp_code = 42170;
members of two are identical in both structures else strcpy(emp1.emp_name,"SHIBU");
structures) return 0 strcpy(emp1.DOB,"");
if (emp2==emp1)
Compare individual members of
!= (Checking the two structures of same type for non employee emp1,emp2;
equality of all equality. Return 1 if all members emp1.emp_code = 42170;
members of two are not identical in both structures strcpy(emp1.emp_name,"SHIBU");
structures) else return 0 strcpy(emp1.DOB,"");
if (emp2!=emp1)
Returns the size of the structure
sizeof() (memory allocated for the structure employee emp1;
66
variable in bytes) sizeof (emp1);
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Structure Padding
(Packed Structure)
 Structure variables are always stored in the memory of
the target system with structure member variables in
the same order as they are declared in the structure
definition
 It is not necessary that the variables should be placed
in continuous physical memory locations
 For multi byte processors (processors with word length
greater than 1 byte (8 bits)), if the structure elements
are arranged in memory in such a way that they can be
accessed with lesser number of memory fetches, it
67
definitely speeds up the operation
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Structure Padding (Packed
Structure)
 structure padding is the process of arranging the structure
elements in memory in a way facilitating increased execution
speed
 As an example consider the following structure

typedef struct
{
char x;
int y;
} exmpl;

68
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Structure Padding (Packed
Structure)
Let us analyze the various possibilities of storing the above
structure within the memory.
Method-1 member variables of structure stored in consecutive
data memory locations
Memory
4x + 3 4x + 2 4x + 1 4x
Address
Byte 2 of Byte 1 of Byte 0 of
Data exmpl.x
exmpl.y exmpl.y exmpl.y

Byte 3 of
Data
exmpl.y

Memory
4(x + 1) + 3 4(x + 1) + 2 4(x + 1) + 1 4(x + 1)
Address

Memory representation for structure without padding 69

 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Structure Padding (Packed Structure)

Method-2 member variables of structure stored in data memory with padding

Memory
4x + 3 4x + 2 4x + 1 4x
Address

Data Padding Padding Padding exmpl.x

Byte 3 of Byte 2 of Byte 1 of Byte 0 of

Data
exmpl.y exmpl.y exmpl.y exmpl.y

Memory
4(x + 1) + 3 4(x + 1) + 2 4(x + 1) + 1 4(x + 1)
Address

Memory representation for structure with padding

70
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Structure and Bit fields

 Bit field is a useful feature supported by structures for bit

manipulation operation and setting up flags
 A set of bits in the structure bit field forms a ‘char’ or ‘int’
variable
 The general format of declaration of bit fields within structure is
illustrated below
struct struct_name
{
data type (char or int) bit_var 1_name : bit_size,
bit_var 2_name : bit_size,
………………………..,
………………………...,
bit_var n_name : bit_size; 71
};
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Structure and Bit fields

‘struct_name’ represents the name of the bit field

structure
‘data type’ is the data type which will be formed by
packing several bits
Only character (char) and integer (int/short int) data
types are allowed in bit field structures in Embedded
C applications
bit_var 1_name’ denotes the bit variable and ‘bit_size’
gives the number of bits required by the variable
‘bit_var 1_name ’ and so
The operator ‘:’ associates the number of bits required
72
with the bit variable
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Structure and Bit
fields

As an illustrative example let us see how the PSW

register of 8051 (which is a bit addressable 8 bit register)
can be represented in Embedded C

PSW.7 PSW.6 PSW.5 PSW.4 PSW.3 PSW.2 PSW.1 PSW.0

CY AC F0 RS1 RS0 OV P

73
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Structure and Bit fields
struct PSW
{
char P:1, /* Bit 0 of PSW : Parity Flag */
:1, /* Bit 1 of PSW : Unused */
OV:1, /* Bit 2 of PSW : Overflow Flag */
RS0:1, /* Bit 3 of PSW : Register Bank Select 0 bit
*/
RS1 :1, /* Bit 4 of PSW : Register Bank Select 1 bit
*/
F0:1, /* Bit 5 of PSW : User definable Flag */
AC :1, /* Bit 6 of PSW : Auxiliary Cary Flag */
C:1; /* Bit 7 of PSW : Carry Flag */
/*Note that the operator ‘;’ is used after the last bit field to*/
/* indicate end of bit field*/

};
 Each bit field variable is defined with a name and an associated
bit size representation
 If some of the bits are unused in a packed fashion, the same
can be skipped by merely giving the number of bytes to be74
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Union
 Union is a concept derived from structure and union
declarations follow the same syntax as that of
structures (structure tag is replaced by union tag)
 Though union looks similar to structure in declaration,
it differs from structure in the memory allocation
technique for the member variables
 Whenever a union variable is created, memory is
allocated only to the member variable of union
requiring the maximum storage size.
 For structure variables memory is allocated to each
member variables 75
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Union
 Even if a union variable contains different member variables of
different data types, existence is only for a single variable at a
time
 The size of a union returns the storage size of its member
variable occupying the maximum storage size
 The syntax for declaring union is given below
union union_name typedef union
{
{ //variable 1 declaration
//variable 1 declaration //variable 2 to declaration
//variable 2 to declaration //……………
//…………… //variable n declaration
//variable n declaration } union_name;
};
76
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Union

As an illustrative declare a union variable consisting of
an integer member variable and a character member
variable.
typedef union
{
int y;
//Integer variable
char z;
//Character variable
} example;
example ex1;
77
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Union

Assuming the storage location required for ‘int’ as 4
bytes and for ‘char’ as 1 byte, the memory allocated to
the union variable ex1 will be as shown below
Memory
ex1.z
Address 4x + 3 4x + 2 4x + 1 4x

Byte 3 of Byte 2 of Byte 1 of Byte 0 of

Data
exl.y exl.y exl.y exl.y

x =1, 2, 3… etc ex1.x

Memory representation for union

78
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Preprocessors & Macros

 Pre processor in ‘C’ is compiler/cross-compiler directives used

by compiler/ cross-compiler to filter the source code before
compilation/cross-compilation
 The pre processor directives are mere directions to the
compilers/cross compilers on how the source file should be
compiled/cross compiled
 No executable code is generated for pre processor directives on
compilation
 The syntax for pre processor directives is different from the
syntax of ‘C’ language. Each pre processor directive starts with
the ‘#’ symbol and ends without a semicolon (;)
79
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Preprocessors &
Macros

 Pre processor directives are normally placed before the

entry point function main() in a source file
 Pre processor directives are grouped into three
categories; namely
File inclusion pre processor directives
Compile control pre processor directives
Macro substitution pre processor directives

80
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Preprocessors & Macros
File inclusion pre processor directives
The file inclusion pre processor directives include external files
containing macro definitions, function declarations, constant
definitions etc to the current source file. ‘#include’ is the pre
processor directive used for file inclusion.
Eg: #include <stdio.h>
Compile control pre processor directives
Compile control pre processor directives are used for controlling the
compilation process such as skipping compilation of a portion of
code, adding debug features etc. The conditional control pre
processor directives are similar to the conditional statement if else in
‘C’. #ifdef, #ifndef, #else, #endif, #undef, etc are the compile control
pre processor directives. 81
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Preprocessors &
Macros
Macro substitution pre processor directives
Macro is a for creating portable inline codes. The
preprocessor directive used for defining macro is known as
macros substitution pre processor. The ‘#define’ pre
processor directive is used for coding macros
Eg: #define PI (3.1415)

82
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Constant Declaration
Constant data
Constant data informs that the data held by a variable is always
constant and cannot be modified by the application. Constants used
as scaling variables, ratio factors, various scientific computing
constants
E.g. const float PI = 3.1417;
Pointer to constant data
Pointer to constant data is a pointer which points to a data which is
read only. The pointer pointing to the data can be changed but the
data is non-modifiable. Example of pointer to constant data

const int* x; //Integer pointer x to constant data

int const* x //Same meaning as above definition
83
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Constant Declaration

Constant Pointer to data

Pointer whose address is always fixed. Used for representing
registers of devices mapped at fixed memory location in embedded
design. An RTC register with fixed memory map is an example

/*Explicit declaration of character pointer pointing to 8 bit

memory location, mapped at location 0x3007;

char *const x= (char*) 0x3007;

84
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Volatile Qualifier

The keyword ‘volatile’ prefixed with any variable as qualifier

informs the cross-compiler that the value of the variable is subject to
change at any point of time (subject to asynchronous modification)
other than the current statement of code where the control is at
present. Examples of variables which are subject to asynchronous
modifications are
•Variables common to Interrupt Service Routines (ISR) and other
functions of a file
•Memory mapped hardware registers
•Variables shared by different threads in a multi threaded application
(Not applicable to Super loop Firmware development approach)
85
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Volatile Qualifier
The ‘volatile’ keyword informs the cross compiler that the variable
with ‘volatile’ qualifier is subject to asynchronous change and there
by the cross compiler turns off any optimization (assumptions on the
variable) for these variable
The general form of declaring a volatile variable is given below.

//Declaring a volatile variable volatile data type variable name;

//or data type volatile variable name;
//Usage:
//Declares volatile variable
volatile char *status_reg = (char *) 0x3000;
while (*status_reg!=0x01); //Wait till status_reg = 0x01

86
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Volatile Qualifier
The ‘constant volatile’ Variable
Some variables used in embedded applications can be both
‘constant’ and ‘volatile’. A ‘Read only’ status register
of a memory mapped device is a typical example for
this. From a user point of view the ‘Read only’ status
registers can only be read but cannot modify. Hence it is
a constant variable. From the device point the contents
can be modified at any time by the device. So it is a
volatile variable. Typical declarations are given below.
volatile const int a; // Constant volatile integer
volatile const int* a; //Pointer to a Constant
87
volatile integer
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Volatile Qualifier

Volatile pointer
Volatile pointers is subject to change at any point after they are
initialized. Typical examples are pointer to arrays or buffers
modifiable by Interrupt Service Routines and pointers in dynamic
memory allocation. Pointers used in dynamic memory allocation
can be modified by the realloc() function. The general form of
declaration of a volatile pointer to a non-volatile variable is given
below.

data type* volatile variable name;

E.g. unsigned char* volatile a;

88
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Delay generation

The instruction execution speed of a processor is

dependent on the clock frequency at which the processor
is operating
for loops are usually used for delay generation in
Embedded C
For Super loop based embedded system design, the
parameters to the for loop should be adjusted properly,
depending on the target clock frequency to get precise
time delays
89
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Infinite Loops

 Infinite loops are created using various loop control instructions like while (),
do while (), for and goto labels
//Infinite loop using while
while (1)
{

//Infinite loop using do while

do
{

} while (1);

//Infinite loop using for loop

for (; ; ;)
{
}

//Infinite loop using for loop

label: //Task to be repeated
//………………
//………………
goto label; 90
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Bit Manipulation Operations

Bitwise AND
Operator ‘&’ performs Bitwise AND operations. Bitwise AND
operations are usually performed for selective clearing of bits and
testing the present state of a bit (Bitwise ANDing with ‘1’)

Bitwise OR
Operator ‘|’ performs Bitwise OR operations. Bitwise OR operation
is usually performed for selectively setting of bits and testing the
current state of a bit (Bitwise ORing with ‘0’)

91
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Bit Manipulation Operations

Bitwise Exclusive OR- XOR

Bitwise XOR operator ‘^’ acts on individual operand bits and
performs an ‘Excusive OR’ operation on the bits. Bitwise XOR
operation is used for toggling bits in embedded applications

Bitwise NOT
Bitwise NOT operations negates (inverts) the state of a bit. The
operator ‘~’ (tilde) is used as the Bitwise NOT operator in C.

92
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Bit Manipulation Operations

Setting and Clearing and Bits

Bitwise OR operation sets a specified bit of a variable
Eg: flag = flag | 1; //Sets 0th Bit

Bitwise OR operation combined with left shift operation of ‘1’ is

used for selectively setting any bit in a variable. For example the
following operation will set bit 6 of char variable flag.
//Sets 6th bit of flag. Bit numbering starts with 0.
flag = flag | (1<<6);
//OR
flag |= (1<<6); //Equivalent to flag = flag | (1<<6); 93
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Bit Manipulation Operations

Toggling Bits
Toggling a bit is performed to negate (toggle) the current state of a
bit. If current state of a specified bit is ‘1’, after toggling it
becomes ‘0’ and vice versa. Toggling is also known as inverting
bits. The Bitwise XOR operator is used for toggling the state of a
desired bit in an operand.
flag ^= (1<<6); //Toggle bit 6 of flag

94
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Bit Manipulation Operations
Extracting /Inserting Bits from/to Packed Variables
Consider a 16 bit int variable with name ‘date’ which holds Date, Month and Year as
shown below
Bit 9 to 15 Bit 5 to 8 Bit 0 to 4
15 9 5 0
Year (0 to 99) Month (1 to 12) Date (1 to 31)

char year = (date>>9) & 0x7F; //Extracts Year

date = date & ~ (0x7F<<9); //Clear the ‘Year’ fields
date |= (new_year <<9); //Set the value new_year at ‘Year’ location

Testing Bits
Bitwise operators can be used for checking the present status of a bit without modifying it for decision
making operations.

if (flag & (1<<6)) //Checks whether 6th bit of flag is ‘1’

95
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Coding Interrupt Service
Routines

 For Super loop based embedded firmware design, code the ISR as
per the support from the cross-compiler in use for target
processor.
 The example given below illustrates the coding of ISR in
Embedded C for C51 Cross compiler for 8051 processor
void interrupt_name (void) interrupt x using y
{
/*Process Interrupt*/
}
 interrupt_name is the function name for ISR
96
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Coding Interrupt Service
Routines
 The attribute ‘interrupt’ instructs the cross compiler that the
associated function is an interrupt service routine
 The interrupt attribute takes an argument x which is an integer
constant in the range 0 to 31 (supporting 32 interrupts). This
number is the interrupt number and it is essential for placing the
generated hex code corresponding to the ISR in the corresponding
Interrupt Vector Address
 using is an optional keyword for indicating which register bank is
used for the general purpose Registers R0 to R7 (For more details
on register banks and general purpose registers, refer to the
hardware description of 8051)
 The argument y for using attribute can take values from 0 to 3
(corresponding to the register banks 0 to 3 of 8051)
97
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Reentrant Vs Recursive
Functions

 A function which calls itself repeatedly is called a Recursive

Function
 Using recursion, a complex problem is split into its single simplest
form. The recursive function only knows how to solve that
simplest case
 Recursive functions are useful in evaluating certain types of
mathematical function, creating and accessing dynamic data
structures such as linked lists or binary trees
 Functions which can be shared safely with several processes
concurrently are called re-entrant functions
98
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Reentrant Vs Recursive
Functions

 When a re-entrant function is executing, another process can

interrupt the execution and can execute the same re-entrant
function
 The “another process” referred can be a thread in a multithreaded
application or can be an Interrupt Service Routine (ISR)
 Re-entrant function is also referred as ‘pure’ function
 It is not necessary that all recursive functions are re-entrant. But a
Re-entrant function can be invoked recursively by an application

99
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Dynamic Memory Allocation
The conceptual view of storage of an application and the variables related to the application
in an Operating System based execution environment is represented as

Auto Variables Stack

Dynamic Storage
Memory

Free Memory Heap

Alterable Data

Constant Data Static Storage

Memory
Source Code

100
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Memory Management
Functions
malloc()
malloc() function allocates a block of memory dynamically. The
malloc() function reserves a block of memory of size specified as
parameter to the function, in the heap memory and returns a pointer
of type void.
pointer = (pointer_type *) malloc (no. of bytes);
Eg: ptr= (char *) malloc(50);
calloc()
The library function calloc() allocates multiple blocks of storage
bytes and initializes each allocated byte to zero.
pointer = (pointer_type *) calloc (n, size of block);
ptr= (char *) calloc (50,1); 101
 @ McGraw-Hill Education

Embedded Firmware Design & Development

Programming in Embedded C – Memory Management
Functions

free()
The ‘C’ memory management library function free() is used for
releasing or de-allocating the memory allocated in the heap memory
by malloc() or calloc() functions
free (ptr);
realloc()
realloc() function is used for changing the size of allocated bytes in
a dynamically allocated memory block
realloc (pointer, modified size);

102