The document provides an agenda for an embedded C programming lecture that includes the following topics: definitions of embedded systems and the differences between C for embedded systems and embedded C, the code compilation process and types of errors, code compilation using the command line, and a quick revision of C language syntax. It concludes with assigning a task for students.

1. Prepared by: Mohamed AbdAllah
Embedded C-Programming
Lecture 1
1

2. Agenda
2
 What are Embedded Systems?
 C for Embedded Systems vs. Embedded C.
 Code Compilation process.
 Error types.
 Code Compilation using command line.
 C language syntax quick revision.
 Task 1.

3. Agenda
3

4. What are Embedded Systems?
4

5. Introduction to Embedded Systems
 What is an embedded system ?
An embedded system is a computer system with a dedicated function within
a larger mechanical or electrical system, sometimes with real-time
computing constraints. It is embedded as part of a complete device often
including hardware and mechanical parts.
Simply, it is application-specific systems which contain hardware and
software tailored for a particular task and are generally part of a larger
system.
sensor
switch
actuator
indicator

6. Introduction to Embedded Systems
 Embedded systems in our life

7. Introduction to Embedded Systems
 Embedded systems characteristics
• Cost of hardware and software.
• Memory.
• Power consumption.
• Operator interface.
• Reliability.
• Maintainability.
• Security.
• Safety.
• Real time critical.
• Interface to environment through sensors and actuators.

8. Introduction to Embedded Systems
 Micro-Controller concepts

9. Introduction to Embedded Systems
 Micro-Controller concepts
0010011000
ADD R16,R10
SUB R7,R3
Z = x + y ;
If (y==3)
return 0 ;
file1.c Compiler
file1.asm
Assembler
file1.o
Linker
file2.o
file3.o
prog.hex

10. Introduction to Embedded Systems
 Embedded systems market in Egypt

11. C for Embedded Systems vs. Embedded C
11

12.  C for Embedded Systems
• It is using the standard C language (mainly as described in ISO/IEC 9899
standard) but with a lot of customization and optimization to meet the
Embedded System requirements.
• C is generally used for desktop computers and can use the resources of
a desktop PC like memory, OS, etc. While C for Embedded Systems is for
microcontroller based applications so it has to deal with the limited
resources, such as RAM, ROM, I/O on an embedded processor.
 Embedded C
• It is an extension to the C standard (Under the ISO/IEC TR 18037
standard) to support specific complex topics in Embedded Systems
(Fixed point types, multiple memory areas, and I/O register mapping).
• Because Embedded C is an extension to the C standard, it uses the
same C language syntax.
12
C for Embedded Systems vs. Embedded C

13. Code Compilation process
13

14. Code Compilation process
Preprocessor
File.c
14
File.i
 Preprocessing
It is the first stage of compilation. It processes preprocessor directives like
include-files, conditional compilation instructions and macros.

15.  Examples on preprocessor directives:
• Including files:
#include <stdio.h>
Tells the preprocessor to copy the content of file stdio.h
it here.
and paste
15
Code Compilation process
File1.c
#include “File1.h”
int x = 10;
File1.h
void myFunc1();
void myFunc1();
File1.c
void myFunc1();
void myFunc1();
int x = 10;

16.  Examples on preprocessor directives:
• Object-like Macro:
#define LED_PIN 10
16
Tells the preprocessor that whenever the symbol LED_PIN
inside the code, replace it with 10.
So we can type inside the code:
is found
int x = LED_PIN;
ledInit(LED_PIN);
/* x will have the value 10 */
/*Initialize LED with value 10*/
#define MY_SECOND_NUMBER LED_PIN
Now MY_SECOND_NUMBER also has the value 10.
Code Compilation process

17.  Examples on preprocessor directives:
Macro definition is really helpful in code maintainability and change, for
example when a specific configuration value is used in all over the code in
a lot of lines, so to change this value only one line will be changed which is
the definition line itself instead of changing the value in all lines of code.
• Conditional compilation:
#if(LED_PIN==10)
printf(“LED_PIN=10”);
#endif
The printf line will be compiled only if the macro LED_PIN is
defined with value 10.
17
Code Compilation process

18.  Examples on preprocessor directives:
• Conditional compilation:
#define OPERATION_MODE 1
int main(void)
{
/* Mode of operation is decided before compilation */
#if(OPERATION_MODE==1)
startMode_1();
#elif(OPERATION_MODE==2)
startMode_2();
#else
/* Display Error message and stop process */
#error OPERATION_MODE must be 0 or 1
#endif
return 0;
}
18
Code Compilation process

19.  Examples on preprocessor directives:
• Conditional compilation:
#define IN_DEBUG_MODE
void testFunction(void)
{
#ifdef IN_DEBUG_MODE
printf(“DEBUG: entered testFunctionn”);
#endif
/* ANY CODE HERE */
#ifdef IN_DEBUG_MODE
printf(“DEBUG: exit testFunctionn”);
#endif
}
Debugging messages will be compiled only if
defined.
IN_DEBUG_MODE is
19
Code Compilation process

20.  Examples on preprocessor directives:
• #undef:
Used to undefine a macro.
#define IN_DEBUG_MODE
void testFunction(void)
{
#ifdef IN_DEBUG_MODE /* This will be compiled */
printf(“DEBUG: entered testFunctionn”);
#endif
#undef IN_DEBUG_MODE /* Undefine macro */
#ifdef IN_DEBUG_MODE /* This will not be compiled */
printf(“DEBUG: exit testFunctionn”);
#endif
}
20
Code Compilation process

21.  Examples on preprocessor directives:
• #pragma:
The #pragma directive is the method specified by the C standard for
providing additional information to the compiler, beyond what is
conveyed in the language itself.
Example for gcc compiler:
#pragma optimize(“”, off)
Example for ghs compiler:
/* Disable any optimization */
#pragma ghs section “.bss” = “.mySection”
/* It will put this array in section called “.mySection”
in memory*/
int myArray[1000];
#pragma ghs section
Note that #pragma is compiler dependent so caution shall be taken
when using it as it affects code portability. 21
Code Compilation process

22. Code Compilation process
Preprocessor Compiler
File.c
22
File.i File.s
 Compilation
It is the second stage. It takes the output of the preprocessor with the
source code, and generates assembly source code.

23. Code Compilation process
Preprocessor Compiler Assembler
File.c
23
File.i
File.o
File.s
 Assembler stage
It is the third stage of compilation. It takes the assembly source code and
produces the corresponding object code.

24. Code Compilation process
Preprocessor Compiler
File.hex
Assembler
Linker
Linker script
Library files
File.map
File.c
File.i
File.o
Other object files
File.s
 Linking
It is the final stage of compilation. It takes one or more object files or
libraries and linker script as input and combines them to produce a single
executable file. In doing so, it resolves references to external symbols,
assigns final addresses to procedures/functions and variables, and revises
code and data to reflect new addresses (a process called relocation). 24

25. Code Compilation process
Preprocessor Compiler
File.hex
Assembler
Linker
Linker script
Library files
File.map
File.c
File.i
File.o
Other object files
File.s
25

26.  Preprocessing
It is the first stage of compilation. It processes preprocessor directives like
include-files, conditional compilation instructions and macros.
 Compilation
It is the second stage. It takes the output of the preprocessor with the
source code, and generates assembly source code.
 Assembler stage
It is the third stage of compilation. It takes the assembly source code and
produces the corresponding object code.
 Linking
It is the final stage of compilation. It takes one or more object files or
libraries and linker script as input and combines them to produce a single
executable file. In doing so, it resolves references to external symbols,
assigns final addresses to procedures/functions and variables, and revises
code and data to reflect new addresses (a process called relocation).
26
Code Compilation process

27. Error types
27

28. Error types
 Preprocessor error
Any error that occurs during preprocessing stage, such as using undefined
macro, or finding #error directive, when this error occurs process stops
and doesn’t go to next stage.
File.c
#iff
int x = 10;
error: invalid preprocessing directive #iff
File.c
#error CODE NOT READY error: #err or CODE NOT READY
int x = 10;
28

29.  Compilation error (Syntax error)
Any error that occurs during compilation stage , such as using undefined
variable or miss spelling any of language words, when this error occurs
process stops and doesn’t go to next stage.
Error types
File.c
int x = 10;
int y = x3; error: 'x3' undeclared
File.c
int x = 10 error: expected ',' or ';' before 'int'
29

30.  Linker error
Any error that occurs during linking stage, such as using a function that the
linker can’t find in any of the object files, when this error occurs process
stops and no executable file is generated.
Example: if we compiled only File.c without any other source file:
Error types
File.c
int main()
{
myFunc(); undefined reference to `myFunc'
}
return 0;
30

31.  Logic error
It is an error in the program logic itself (program design or code flow) that
leads to wrong behavior during runtime, it is the most difficult error to find
as the compilation process succeeds but error occurs later at runtime.
31
Error types
/* compare is using higher than */
File.c
int main()
{
int x = 10;
if(x > 10)
{
printf(“x is less than 10”); /*But logic is less than*/
funcLessThan();
}
else
{
printf(“x is higher than 10”);
funcHigherThan();
}
return 0;
}

32. Code Compilation using command line
32

33.  Environment preparing
We will be using GNU Toolchain which includes:
• GNU C Compiler (GCC).
• GNU Make.
• GNU Binutils.
• GNU Debugger (GDB).
If you are using Linux OS then all of them are available without any need
to install them, but if you are using windows then install MinGW
(Minimalist GNU for Windows), download it from:
http://www.mingw.org/
Note: It is better to install it in a folder other than "Program Files“,
probably in another partition other than C:, and make sure that
installation folder doesn’t contain any spaces.
Setup environment variable PATH to include "<MINGW_HOME>/bin"
where <MINGW_HOME> is the MinGW installed directory that you have
chosen in the previous step.
33
Code Compilation using command line

34.  Getting started
Now open command window in your project directory to start using these
commands
 Get gcc version
This command gets gcc installed version, if version is displayed then we are
ready to use gcc, but if command failed then make sure that program is
installed correctly and make sure that "<MINGW_HOME>/bin folder is
added to PATH environment variable in Windows.
34
Code Compilation using command line
D:newProject>gcc --version
D:newProject>gcc --help
 Get gcc help
To get help about most common options.

35. Code Compilation using command line
35
D:newProject>gcc file1.c file2.c -o app.exe
 Preprocess, compile, link and generate executable
To do all compilation process in one step.
D:newProject>app.exe
 Run executable
To run output application executable.
D:newProject>gcc -E file1.c -o file1.i
 Preprocess only
To do preprocessing stage only.

36. Code Compilation using command line
36
D:newProject>gcc -S file1.c -o file1.asm
 Compile but don’t assemble
To generate assembly code but not object code.
D:newProject>gcc -c file1.c -o file1.o
 Compile and assemble but don’t link
To generate object code but no linking occurs.
D:newProject>gcc file1.o file2.o -o app.exe
 Link object files
To link all files.

37. Code Compilation using command line
37
D:newProject>gcc -Wa,-adhln -g -c file1.c > out.interleaved
 Show assembly code with C code
To generate one file containing C source code interleaved with the
corresponding assembly code.

38. Code Compilation using command line
38
D:newProject>gcc -g file1.c file2.c -o app.exe
 Add debugging information
To add debugging information to output application executable so that this
executable can be used later by the debugger.
D:newProject>gdb app.exe
 Start program debugging
To debug application during execution using GDB, so that we can set a
break point at a specific code line to halt program, see variables values,
step in code line by line and so on.
(gdb)
Note that now command prompt changes to the following line waiting for
debugger commands:

39. Code Compilation using command line
39
(gdb) b file2.c:8
 Set a break point
To set a break point at a specific line of code (fore example line 8 in file2.c)
so that program execution halts when reaching this line.
(gdb) r
 Start execution
To start running application till reaching first break point set.
(gdb) c
 Continue execution
To continue running application from current break point till reaching next
break point.

40. Code Compilation using command line
40
(gdb) s
 Step one line
To execute one more line of code and wait.
(gdb) s 3
 Step multiple lines
To execute number of lines of code and wait (for example 3 lines).
(gdb) list
 List code lines
To display 10 lines of C source code around current break point.

41. Code Compilation using command line
41
(gdb) display y
 Display variable value
To display variable
point.
(for example variable called y) current value at break
(gdb) quit
 Exit debugger
To exit debugger and return to command line.
D:newProject>
Note that now command prompt changes back to the original text:

42. C language syntax quick revision
42

43. Task 1
43

44. Mohamed AbdAllah
Embedded Systems Engineer
mohabdallah8@gmail.com
44