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

Agenda

3

What are Embedded Systems?

4

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.o Linker

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

13


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 testFunction\n”);

#endif

/* ANY CODE HERE */

#ifdef IN_DEBUG_MODE

printf(“DEBUG: exit testFunction\n”);

#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 testFunction\n”);

#endif

#undef IN_DEBUG_MODE /* Undefine macro */

#ifdef IN_DEBUG_MODE /* This will not be compiled */

printf(“DEBUG: exit testFunction\n”);

#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

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


25


File.hex

Assembler

Linker

Linker 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


Error types

27

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

Task 1

43

Mohamed AbdAllah Embedded Systems Engineer [email protected]

44

Embedded C - Lecture 1

Engineering

Transcript of Embedded C - Lecture 1