Embedded C - Lecture 1

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

Agenda
 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.
2

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

 Embedded systems in our life

 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.

 Micro-Controller concepts

 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.oLinker
file2.o
file3.o
prog.hex

 Embedded systems market in Egypt

C for Embedded Systems vs. Embedded C
11

 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

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

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

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

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

#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

#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 IN_DEBUG_MODE is
defined.
19

• #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

• #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) /* Disable any optimization */
Example for ghs compiler:
#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

22
Preprocessor Compiler
File.c
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
Preprocessor Compiler Assembler
File.c
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
File.hex
Assembler
LinkerLinker 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).

25
File.hex
Assembler
LinkerLinker script
Library files
File.map
File.c
File.i
File.o
Other object files
File.s

 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

 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.
28
Error types
File.c
#iff
int x = 10;
error: invalid preprocessing directive #iff
File.c
#error CODE NOT READY
int x = 10;
error: #error CODE NOT READY

 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.
29
Error types
File.c
int x = 10;
int y = x3; error: 'x3' undeclared
File.c
int x = 10 error: expected ',' or ';' before 'int'

 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:
30
Error types
File.c
int main()
{
myFunc();
return 0;
}
undefined reference to `myFunc'

 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
File.c
int main()
{
int x = 10;
if(x > 10) /* compare is using higher than */
{
printf(“x is less than 10”); /*But logic is less than*/
funcLessThan();
}
else
{
printf(“x is higher than 10”);
funcHigherThan();
}
return 0;
}

Code Compilation using command line
32

 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

 Getting started
Now open command window in your project directory to start using these
commands
34
D:newProject>gcc --version
 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.
D:newProject>gcc --help
 Get gcc help
To get help about most common options.

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
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
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
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
(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
(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
(gdb) display y
 Display variable value
To display variable (for example variable called y) current value at break
point.
(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:

C language syntax quick revision
42

Mohamed AbdAllah
Embedded Systems Engineer
mohabdallah8@gmail.com
44

Embedded C - Lecture 1

More Related Content

What's hot (20)

Viewers also liked (19)

Similar to Embedded C - Lecture 1 (20)

More from Mohamed Abdallah (8)

Recently uploaded (20)

Embedded C - Lecture 1