Basics of Embedded
Programming
Smart Logic Academy 1
Course Flow
Write a Program in Embedded C
Bitwise operations in Embedded C
Embedded C program Structure
Control structures | Functions
Variable | Constants | Number system | Data Types
Selection of programming language for Embedded C Compiler
What is an Embedded System
embedded system working
Smart Logic Academy 2
Basics of Embedded C Programming
What is an Embedded System?
An Embedded System can be best described as a system which has both
the hardware and software and is designed to do a specific task.
Smart Logic Academy 3
Basics of Embedded C Programming
Example: Washing Machine
Smart Logic Academy 4
Example: Smart Car Basics of Embedded C Programming
Smart Logic Academy 5
Basics of Embedded C Programming
Programming Embedded Systems
Smart Logic Academy 6
Basics of Embedded C Programming
Embedded systems programming
•Embedded devices have resource constraints
•embedded systems typically uses smaller, less power consuming
components.
•Embedded systems are more tied to the hardware.
Smart Logic Academy 7
Basics of Embedded C Programming
Factors for Selecting the Programming Language
Size: The memory that the program occupies is very important as
Embedded Processors like Microcontrollers have a very limited
amount of ROM.
Speed: The programs must be very fast i.e. they must run as fast as
possible. The hardware should not be slowed down due to a
slow running software.
Portability: The same program can be compiled for different processors.
Ease of Implementation
Ease of Maintenance
Readability
Smart Logic Academy 8
Basics of Embedded C Programming
Language use for Embedded systems programming
•Machine Code
•Low level language, i.e., assembly
•High level language like C, C++, Java, Ada, etc.
•Application level language like Visual Basic, scripts, Access, etc.
Smart Logic Academy 9
Basics of Embedded C Programming
Assembly Language Programming
Smart Logic Academy 10
Basics of Embedded C Programming
C Programming & Embedded C Programming
•The C Programming Language is the most popular
C Programming
and widely used programming language.
•Embedded C Programming Language Embedded C
is an extension of C Program Language Programming
Smart Logic Academy 11
Basics of Embedded C Programming
Use of C in embedded systems is driven by following advantages
•it is small and reasonably simpler to learn, understand, program and debug.
•C Compilers are available for almost all
embedded devices Embedded C
Programming
•C has advantage of processor-independence
•C combines functionality of assembly language and features of high level
languages
•it is fairly efficient
Smart Logic Academy 12
Basics of Embedded C Programming
C++
Java
Assembly
Language Embedded C
Programming
Smart Logic Academy 13
Basics of Embedded C Programming
Difference between C and Embedded C
Though C and embedded C appear different and are used in different
contexts, they have more similarities than the differences. Most of the
constructs are same; the difference lies in their applications.
Smart Logic Academy 14
#include<reg51.h>
int main()
{
Embedded C
while(1) Compiler working
{
.I char R0=1,R1=2,A;
.src P0=R0+R1;
}
return 0;
}
.Lib .obj HERE: MOV R0,#01H
MOV R1,#02H
MOV A,R0
ADD A,R1
MOV P0,A
SJMP HERE
.abs
OH :03000000020800F3
converter :0C080000787FE4F6D8FD75810702000047
:0A00000078017902E829F58080F606
.Hex :00000001FF
Smart Logic Academy 15
Embedded C Assembly Machine code
#include<reg51.h>
Address Opcode Operand
int main()
{ 0000 78 01
HERE: MOV R0,#01H
while(1) 0002 79 02
MOV R1,#02H
{ 0004 E8
MOV A,R0
char R0=1,R1=2,A; 0005 29
ADD A,R1
P0=R0+R1; 0006 F5 80
MOV P0,A
} 0008 80 00
SJMP HERE
return 0; Note: Address of P0 = 80h
}
Smart Logic Academy 16
Basics of Embedded C Programming
Basic Embedded C program structure
#include <reg51.h> /* I/O port/register names/addresses
for the 8051xx microcontrollers */
int count; /* Global variables – accessible by all functions */
//global (static) variables – placed in RAM
int fun_delay (int x) /* Function definitions*/
//parameter x passed to the function, function returns an integer value
{
int i; //local (automatic) variables – allocated to stack or registers
for(i=0;i<=x;i++); // instructions to implement the function
}
Smart Logic Academy 17
Basics of Embedded C Programming
void main(void) /* Main program */
{
int k; //local (automatic) variable (stack or registers)
P1=0x00; /* Initialization section */ // instructions to initialize
k = 10; //variables, I/O ports, devices, function registers
while (1) /* Endless loop */
//Can also use: for(;;)
{ /* repeat forever */
P1=0x0FF;
Fun_delay( k ); // function call
P1=0x00;
Fun_delay( k ); // instructions to be repeated
}
}
Smart Logic Academy 18
Basics of Embedded C Programming
Basic data types in C51 compiler
Smart Logic Academy 19
Basics of Embedded C Programming
Basic data types in ARM C compiler
Smart Logic Academy 20
Basics of Embedded C Programming
stdint.h header
uint8_t, int8_t: unsigned, signed 8-bit integer
uint16_t, int16_t: unsigned, signed 16-bit integer
uint32_t, int32_t: unsigned, signed 32-bit integer
uint64_t, int64_t: unsigned, signed 64-bit integer
Smart Logic Academy 21
Basics of Embedded C Programming
Bitwise Operators in C
Smart Logic Academy 22
Basics of Embedded C Programming
Constant/literal
Constants in C programming language, as the name suggests are the data
that doesn't change. Constants are also known as literals.
Integer constants
For decimal literals : no prefix
is used.
123 /* decimal constant*/
Prefix used for hexadecimal: 0x / 0X
0x9b /* hexadecimal constant*/ Prefix used for octal: 0
O456 /* octal constant*/
Smart Logic Academy 23
Basics of Embedded C Programming
Character constants
Character constants hold a single character enclosed in single quotations
marks
m = ‘a’; //ASCII value 0x61
m= 0x01
Smart Logic Academy 24
Basics of Embedded C Programming
String Constants/Literals
String constants consist of any number of consecutive characters in
enclosed quotation marks (").
String(array) of characters:
char my_string[] = "My String";
// Compiler will interpret the above statement as
char my_string[10] = {'M', 'y', ' ', 'S', 't', 'r', 'i', 'n', 'g', '\0'};
Smart Logic Academy 25
Basics of Embedded C Programming
Variable arrays
•An array is a set of data, stored in consecutive memory locations, beginning
at a named address
• Declare array name and number of data elements, N
•Elements are “indexed”, with indices [0 .. N-1]
Int n[5]; //declare array of 5 “int” values
n[3] = 5; //set value of 4th array element
Smart Logic Academy 26
Basics of Embedded C Programming
Program variables
Int x,y,z; //declares 3 variables of type “int”
char a,b; //declares 2 variables of type “char”
Space for variables may be allocated in registers, RAM, or ROM/Flash
Variables can be automatic or static
Smart Logic Academy 27
Basics of Embedded C Programming
Automatic variables
Declare within a function/procedure
Variable is visible (has scope) only within that function
Space for the variable is allocated on the system stack when the
procedure is entered
De-allocated, to be re-used, when the procedure is exited
If only 1 or 2 variables, the compiler may allocate them to
registers within that procedure, instead of allocating memory
Values are not retained between procedure calls
Smart Logic Academy 28
Basics of Embedded C Programming
void delay ( )
{
Int i,j; //automatic variables –visible only within delay( )
for (i=0; i<100; i++) //outer loop
{
for (j=0; j<20000; j++) //inner loop
{
} //do nothing
}
}
Smart Logic Academy 29
Basics of Embedded C Programming
Static variables
Retained for use throughout the program in RAM locations that are not
reallocated during program execution.
Declare either within or outside of a function
If declared outside a function, the variable is global in scope, i.e.
known to all functions of the program
Use “normal” declarations.
Example: int count;
If declared within a function, insert key word static before the
variable definition. The variable is local in scope, i.e. known only
within this function.
Example: static int count;
Smart Logic Academy 30
Basics of Embedded C Programming
void main(void)
{
Int count = 0; //initialize global variable count
while (1)
{
math_op();
count++; //increment global variable count
}
}
Smart Logic Academy 31
Basics of Embedded C Programming
void math_op( )
{
int i; //automatic variable –allocated space on stack when
function entered
static int j; //static variable –allocated a fixed RAM location to
maintain the value
if (count == 0)
j = 0; //initialize static variable j first time math_op() entered
i= count; //initialize automatic variable ieach time math_op() entered
j = j + i; //change static variable j –value kept for next function call
} //return & de-allocate space used by automatic variable i.
Smart Logic Academy 32
Basics of Embedded C Programming
Arithmetic operations
Int i, j, k; // 32-bit signed integers
uint8_t m,n,p; // 8-bit unsigned numbers
i= j + k; // add 32-bit integers
m = n -5; // subtract 8-bit numbers
j = i* k; // multiply 32-bit integers
m = n / p; // quotient of 8-bit divide
m = n % p; // remainder of 8-bit divide
i= (j + k) * (i–2); //arithmetic expression
*, /, % are higher in precedence than +, -(higher precedence applied 1st)
Example: j * k + m / n = (j * k) + (m / n)
Smart Logic Academy 33
Basics of Embedded C Programming
Bit-parallel logical operators
Bit-parallel (bitwise) logical operators produce n-bit results of the
corresponding logical operation:
&(AND)
|(OR)
^(XOR)
~(Complement)
Smart Logic Academy 34
Basics of Embedded C Programming
Number System
Smart Logic Academy 35
Basics of Embedded C Programming
unsigned int n;
n = 0x64; //HexaDecimal
n = 100; //Decimal
n = 0144 //Octal
Smart Logic Academy 36
Basics of Embedded C Programming
Decimal: 100
Binary : 01100100
Grouping: 001 100 100 0110 0100
1 4 4 6 4
Octal Hexadecimal
Smart Logic Academy 37
Basics of Embedded C Programming
Bit level Operations in C
1. Bitwise OR operator denoted by ‘|‘
2. Bitwise AND operator denoted by ‘&‘
3. Bitwise Complement or Negation Operator denoted by ‘~‘
4. Bitwise Right Shift & Left Shift denoted by ‘>>‘ and ‘<<‘ respectively
5. Bitwise XOR operator denoted by ‘^‘
Smart Logic Academy 38
Basics of Embedded C Programming
unsigned char A,B,C; //we can declare an 8-bit number as a char
A = 0x66; // binary A = 01100110;
B = 0xB3; // binary B = 10110011;
C = A & B; // binary C = 00100010; i.e 0x22;
Smart Logic Academy 39
Basics of Embedded C Programming
unsigned int A,B,C;
A = 0x64; //binary A = 01100100
B = 0x10; //binary B = 00010000
C = A| B; // C=0x74 which is binary 01110100
Smart Logic Academy 40
Basics of Embedded C Programming
unsigned int A,B,C;
A = 0x64; //binary A = 01100100
B = 0xB3; //binary B = 10110011
C = A^B; // C = 0xD7 which is binary 11010111
Smart Logic Academy 41
Basics of Embedded C Programming
unsigned int A,B;
A= 0x64; //binary A = 0b01100100
B = ~ A; // B= 0x9B which is binary 0b10011011
Smart Logic Academy 42
Basics of Embedded C Programming
Shift operators
A >> B (right shift operand A by B bit positions)
A << B (left shift operand A by B bit positions)
Vacated bits are filled with 0’s.
Shift right/left fast way to multiply/divide by power of 2
Smart Logic Academy 43
Basics of Embedded C Programming
B = A << 2; // left shift A by 2
B = A >> 4; // right shift B by 4
Smart Logic Academy 44
Basics of Embedded C Programming
Bit masking
When we assign value directly to any register. This may change the value
of other bits which might be used to control other hardware feature. To
avoid such scenario best practice is to use bit masking.
Smart Logic Academy 45
1 – Start Basics of Embedded C Programming
REGT_8b
0 – Stop
LED 7 LED 6 LED 5 LED 4 LED 3 LED 2 LED 1 LED 0
Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0
1 1 1 0 0 0 0 0
REGT_8b Binary: 11100000 Hex: 0xE0
REGT_8b = 0x04 // Binary: 00000100 LED 2 on
REGT_8b = REGT_8b | (1<<2); // REGT_8b |= (1<<2);
1=00000001
1<<2 = 00000100
REGT_8b | (1<<2) = 11100000 | 00000100 = 11100100
LED 7 LED 6 LED 5 LED 4 LED 3 LED 2 LED 1 LED 0
Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0
1 1 1 0 0 1 0 0
Smart Logic Academy 46
1 – Start Basics of Embedded C Programming
REGT_8b
0 – Stop
LED 7 LED 6 LED 5 LED 4 LED 3 LED 2 LED 1 LED 0
Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0
1 1 1 0 0 0 0 0
REGT_8b = REGT_8b & (~(1<<6)); // REGT_8b &= ~(1<<6);
1=00000001
1<<6 = 0100 0000
~(1<<6) = 1011 1111
REGT_8b & (~(1<<6)) = 11100100 & 10111111 = 10100000
LED 7 LED 6 LED 5 LED 4 LED 3 LED 2 LED 1 LED 0
Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0
1 0 1 0 0 0 0 0
Smart Logic Academy 47
1 – Start Embedded C Programming
REGT_8b
0 – Stop
assume current value of REGT_8b as '11100011' which is 8 bit.
LED 7 LED 6 LED 5 LED 4 LED 3 LED 2 LED 1 LED 0
1 1 1 0 0 0 1 1
Stop LED 0 and LED 5 :
REGT_8b &= ~( (1<<0) | (1<<5) );
((1<<0) | (1<<5)) = ((00000001) | (00100000)) = 00100001
~(00100001) = 11011110
REGT_8b & 11011110 = (11100011) & (11011110) = 11000010
LED 7 LED 6 LED 5 LED 4 LED 3 LED 2 LED 1 LED 0
1 1 0 0 0 0 1 0
Smart Logic Academy 48
1 – Start Embedded C Programming
REGT_8b
0 – Stop
assume current value of REGT_8b as '11100011' which is 8 bit.
LED 7 LED 6 LED 5 LED 4 LED 3 LED 2 LED 1 LED 0
1 1 1 0 0 0 1 1
Start LED 3 and 4:
REGT_8b |= ( (1<<3) | (1<<4) );
((1<<3) | (1<<4)) = ((00001000) | (00010000)) = 00011000;
REGT_8b | (00011000) is = (11100011) | (00011000) = 11111011
LED 7 LED 6 LED 5 LED 4 LED 3 LED 2 LED 1 LED 0
1 1 1 1 1 0 1 1
Smart Logic Academy 49
1 – Start Embedded C Programming
REGT_8b
0 – Stop
assume current value of REGT_8b as '11100011' which is 8 bit.
LED 7 LED 6 LED 5 LED 4 LED 3 LED 2 LED 1 LED 0
1 1 1 0 0 0 1 1
Stop LED 7 and Start LED3:
REGT_8b = (REGT_8b | (1<<3)) & (~(1<<7));
(1<<7) = 10000000 ~(1<<7) = 01111111
(1<<3) = 00001000
(REGT_8b | (1<<3)) = (11100011) | (00001000) = 11101011
(REGT_8b | (1<<3)) & (~(1<<7)) = (11101011) & (01111111) = 01101011
LED 7 LED 6 LED 5 LED 4 LED 3 LED 2 LED 1 LED 0
0 1 1 0 1 0 1 1
Smart Logic Academy 50
Embedded C Programming
Monitoring Specific bit change in Registers
Many times we need to read certain Flags in a register that denotes change in
Hardware state.
Consider a 8 bit Register P0
Switch = 1 button pressed
Switch = 0 button released
P0. 7 P0. 6 P0. 5 P0. 4 P0. 3 P0. 2 P0. 1 P0.0
0 0 Switch 0 0 0 0 0
Smart Logic Academy 51
Monitoring Specific bit change in Registers Embedded C Programming
To monitor for the change in 5th bit from 0 to 1
While ( P0 & (1<<5) ) //wait indefinitely until 5th bit changes from 0 to 1
{ //do something //exit loop
}
1= 00000001
1<<5 = 00100000 P0. 7 P0. 6 P0. 5 P0. 4 P0. 3 P0. 2 P0. 1 P0.0
0 0 Switch 0 0 0 0 0
0
P0= 0x00 = 0000000
P0 & (1<<5) = 00000000 & 00100000 = 00000000
P0. 7 P0. 6 P0. 5 P0. 4 P0. 3 P0. 2 P0. 1 P0.0
0 0 Switch 0 0 0 0 0
1
P0= 0x20 = 00100000
P0 & (1<<5) = 00100000 & 00100000Smart
= 00100000
Logic Academy 52
Monitoring Specific bit change in Registers Embedded C Programming
To monitor for the change in 5th bit from 1 to 0
while ( ! (P0 & (1<<5) ) ) //wait indefinitely until 5th bit changes from 0 to 1
{ //do something //exit loop
}
1= 00000001
1<<5 = 00100000 P0. 7 P0. 6 P0. 5 P0. 4 P0. 3 P0. 2 P0. 1 P0.0
0 0 Switch 0 0 0 0 0
P0= 0x20 = 0010000 1
P0 & (1<<5) = 00100000 & 00100000 = 00100000
! (P0 & (1<<5)) = ! (00100000) = 00000000
P0. 7 P0. 6 P0. 5 P0. 4 P0. 3 P0. 2 P0. 1 P0.0
0 0 Switch 0 0 0 0 0
P0= 0x00 = 00000000 0
P0 & (1<<5) = 00000000 & 00100000 = 00000000
! (P0 & (1<<5)) = ! (00000000) = 00000001
Smart Logic Academy 53
Embedded C Programming
Monitoring Specific bit change in Registers
To monitor for the change in 5th bit from 0 to 1
While ( P0 & (1<<5) ) //wait indefinitely until 5th bit changes from 0 to 1
{
//do something //exit loop
}
To monitor for the change in 5th bit from 1 to 0 we just Negate the condition inside
while loop .
while ( ! (P0 & (1<<5) ) ) //wait indefinitely until 12th bit changes from 1 to 0
{ //do something //exit loop
}
Smart Logic Academy 54
Embedded C Programming
Extracting Bits REGHL_16
assume current value of REGHL_16 as ‘1000000110101011' which is 16 bit.
LED bit bit bit bit bit bit bit bit bit bit bit bit bit bit bit
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
1 0 0 0 0 0 0 1 1 0 1 0 1 0 1 1
Now we have asked to extract lower 8-bits and upper 8 bit register into REGH_8
and REGL_8
REGH_8 = ( REGHL_16 & 0XFF00 ) >>8; // binary 10000001
REGHL_16 & 0XFF00 = 10000001 00000000
( REGHL_16 & 0XFF00 ) >>8 = 00000000 10000001
REGL_8 = ( REGHL_16 & 0X00FF ) ; // binary 10101011
Smart Logic Academy 55
Embedded C Programming
C control structures
Control order in which instructions are executed
•Conditional execution
•Execute a set of statements if some condition is met
• Select one set of statements to be executed from several options,
depending on one or more conditions
•Iterative execution
•Repeated execution of a set of statements
•A specified number of times, or
•Until some condition is met, or
•While some condition is true
Smart Logic Academy 56
Embedded C Programming
IF-THEN structure
Execute a set of statements if and only if some condition is met
if (a < b)
{
statement s1;
statement s2;
….
}
Smart Logic Academy 57
Embedded C Programming
Boolean operators &&(AND) and ||(OR) produce
TRUE/FALSE results when testing multiple TRUE/FALSE
conditions
if ((n > 1) && (n < 5)) //test for n between 1 and 5
if ((c = ‘q’) || (c = ‘Q’)) //test c = lower or upper case Q
Note the difference between
Boolean operators &&, || and
bitwise logical operators &, |
Note that ==is a relational operator,
whereas =is an assignment operator
Smart Logic Academy 58
Embedded C Programming
IF-THEN-ELSE structure
Execute one set of statements if a condition is met and an alternate set if
the condition is not met.
if (a == 0)
{
statement s1;
statement s2;
}
else
{
statement s3;
statement s4:
} Smart Logic Academy 59
Embedded C Programming
Multiple ELSE-IF structure
Multi-way decision, with expressions evaluated in a specified order
if (n == 1)
{
statement1; //do if n == 1
else if (n == 2)
statement2; //do if n == 2
else if (n == 3)
statement3; //do if n == 3
else
statement4; //do if any other value of n
}
Smart Logic Academy 60
Embedded C Programming
SWITCH statement
Compact alternative to ELSE-IF structure, for multiway decision that tests
one variable or expression for a number of constant values.
switch ( n) //n is the variable to be tested
{
case 0: statement1; //do if n == 0
case 1: statement2; // do if n == 1
case 2: statement3; // do if n == 2
default: statement4; //if for any other n value
}
Smart Logic Academy 61
Embedded C Programming
WHILE loop structure
Repeat a set of statements (a “loop”) as long as some condition is met
while (a < b)
{
statement s1;
statement s2;
….
}
Smart Logic Academy 62
Embedded C Programming
DO-WHILE loop structure
Repeat a set of statements (one “loop”) until some condition is met
do
{
statement s1;
statement s2;
….
}
while (a < b);
Smart Logic Academy 63
Embedded C Programming
FOR loop structure
FOR loop is a more compact form of the WHILE loop structure
Smart Logic Academy 64
Embedded C Programming
/* Nested FOR loops to create a time delay */
for (i = 0; i < 100; i++)
{
//do outer loop 100 times
for (j = 0; j < 1000; j++)
{
//do inner loop 1000 times
//do “nothing” in inner loop
}
}
Smart Logic Academy 65
Embedded C Programming
C function
Functions partition large programs into a set of smaller tasks
•Helps manage program complexity
•Smaller tasks are easier to design and debug
•Functions can often be reused instead of starting over
•Can use of “libraries” of functions developed by 3rdparties, instead
of designing your own
•The function may return a result to the caller
•One or more arguments may be passed to the function/procedure
Smart Logic Academy 66
#include<reg51.h> Embedded C Programming
Int math_func( int k; int n) Function Declaration
Void main()
{
Int a,b,c;
a = 10; b =20;
c=math_func (a,b); Function call
}
Int math_func( int k; int n)
{
Int j; //local variable
j = n + k -5; //function body Function definition
return(j); //return the result
} Smart Logic Academy 67
Embedded C Programming
Bit-parallel logical operators
Bit-parallel (bitwise) logical operators produce n-bit results of the
corresponding logical operation:
&(AND)
|(OR)
^(XOR)
~(Complement)
Smart Logic Academy 68
