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