EE403W Senior Project

Design

Section 4 – Embedded Systems

C Tutorial
 QUIZ

// initialization section
unsigned char x = 2;

// execution section
if (x = 7)
x = 0;

• Aft
After thi
this code
d runs, what
h t is
i the
th value
l stored
t d in
i the
th memory
location referenced by the variable ‘x’?

2
 ‘C’ Programming Language

Why program microcontrollers in ‘C’?

• More compact
p code (visually
( y speaking)
p g)
• Less cryptic code – easier to understand
• Easier to maintain/update
• Easier to manage large projects w/ multiple programmers
• More portable (to an extent)
• ‘C’ is a more marketable skill (than BASIC, etc)

Why NOT program in ‘C’?

• $$$ for a compiler
• Assembly potentially more compact code (memory size, execution speed)
- Assuming you have a competent assembly programmer on-hand
• M bbe quicker/easier
May i k / i for f very small
ll projects
j t tot code
d in
i ASM (< 1kbyte)
1kb t )

3
 ‘C’ Programming Language
C vs. Assembly Language
C Assembly Machine
i=3 LDAA #$03 4000:86 03
STAA $800 4002:7A 08 00

j=5 LDAA #$05 4005:86 05

STAA $
$801 4007:7A 08 01

k=i+j LDAA $800 400A:B6 08 00

ADDA $801 400D:BB 08 01
Compiler converts STAA $803 4010:7A 08 03

A
Assembler
bl converts
t Downloaded
D l d d
to chip
4
 ‘C’ Programming Language

Going from Assembly to Machine Code requires an Assembler

Example.s19
Example.asm Assembler Linker

Source code Object code Executable - 1s & 0s

that get loaded into
program memory

5
 ‘C’ Programming Language

Going from ‘C’ to Machine Code requires a Compiler,

Assembler & Linker Adds .lib,
lib function calls
calls,
Compiler and links all object files

Example.c Pre-
processor
p Linker Example.s19
p

Compile Assembler Example.o

Source code Optimize Example asm

Example.asm

Executable - 1s & 0s that

Iterative process, get loaded into program
multiple passes memory

Usually a compiler option

– optimize for code size,
execution speed
 ‘C’ Programming Language

Basic Program Structure

#______ are preprocessor directives

#include < stdio.h>

Every program needs 1 (and only 1)
void main( ) main function

{
printf("\nHello World\n");
} printf( ) is a function defined in stdio.h

Function is in brackets
 ‘C’ Programming Language

Use Lots of Comments!!!

1. Traditional ‘C’ comments

/* Everything between is a comment */

2. C++ style comments

// Everything on this line is a comment

3. Preprocessor-enforced comments
#if (0)
Everything between is a comment;
#endif
8
 ‘C’ Programming Language

Variable Names & Keywords

Variable Names - can be up to 31 characters long
- may use upper/lower case letters, digits 0-9, and ‘_’
- compiler & library vars use ‘_’ as first char in names

Reserved keywords – can’t be used for var names

auto double int struct
break else long switch
case enum register typedef
char
h extern
t return
t union
i
const float short unsigned
continue for signed void
default goto sizeof volatile
do if static while
 ‘C’ Programming Language

Data Types

char 8 bits Integers types are signed by

short 16 bits default.
l
long 32 bits
bi
long long 64 bits
float 32 bits / 10+/-38
+/-10 ~ 6.5 significant digits
double 64 bits +/-10+/-308 ~ 15 significant digits
int Usually depends on architecture
(32-bits for x86s 16 bits for HCS08)

Signed #s use Two

Two’ss complement form
• signed char is 8 bits, range is -128 to +127
• unsigned char is 8 bits, range is 0 to +255
 ‘C’ Programming Language
Straight binary (unsigned)
MSB LSB

1 0 0 1 1 1 0 1 = 0x9D
1 x 27 + 0 x 26 + 0 x 25 + 1 x 24 + 1 x 23 + 1 x 22 + 0 x 21 + 1 x 20 = 15710

Total range of possible values is 010 Æ 25510

To divide
di ide b
by ttwo,
o shift one position to the left

MSB LSB
LSB = 0 if even #
0 1 0 0 1 1 1 0 = 0x4E = 1 if odd #
0 x 27 + 1 x 26 + 0 x 25 + 0 x 24 + 1 x 23 + 1 x 22 + 1 x 21 + 0 x 20 = 7810
 ‘C’ Programming Language

Useful #
conversion
chart

12
 ‘C’ Programming Language

ASCII text
American
A i St d d Code
Standard C d
for Information Interchange

• ASCII iis often

f used d iin
computer systems to
represent characters
- Hyperterm
H
- Many LCD screens

13
 ‘C’ Programming Language

Math Operators

+ Addition
- Subtraction
* Multiplication Note: ‘*’ and ‘/’ have higher
/ Division pprecedence than ‘+’ and ‘-’
% Modulus operator
if Ans, Rem and the numbers 5 and 8 are integers, then
Ans = 5/8; // result is 0
Rem = 5%8; // result is 5
 ‘C’ Programming Language

Convert a number to ASCII

unsigned
i d char
h value;
l
…

value = 0xF5;; // 245 base 10

On hyperterm window you’d see …
temp1 = (value%10)+0x30;
temp2 = value/10; 2
temp3 = temp2/10+0x30;
temp2 = temp2%10+0x30; 4
5
printf(temp3”\n"); // MSB
printf(temp2”\n");
printf(temp1”\n"); // LSB
 ‘C’ Programming Language

Increment & Decrement

i = i + 1; is equivalent to … i++;
k = k - 1; “ “ k--;

C allows
ll pre- and
d post-incrementing
ti ti andd pre- and
d post-decrementing
td ti
num = 1; num = 0;
while (num++ < 3) while (++num < 3)
{ {
// do something // do something
}; }

Are these
code snippets
equivalent?
 ‘C’ Programming Language

Shift
x = 8;
x = x >> 2;
0000 1000 (810) → 0000 0010 (210)
Equivalent to dividing by 22

y = 8;
y = y << 3;
0000 1000 (810) → 0100 0000 (6410)
Equivalent to multiplying by 23
May take less clocks than executing a multiply or divide instruction
 ‘C’ Programming Language

Logical Operators
NOTE:
< less than if (0); // Is always false
<= less than or equal to
> greater than
h if (1); // Is always true
>= greater than or equal to
== is equal to
!= is not equal to Logical operators are binary operators
The statement
&& AND
|| OR if (A >= B) …

Returns 0 if the statement is false and 1

if true
 ‘C’ Programming Language

Bitwise Operators

& Bitwise AND

| Bitwise OR
~ Bitwise NOT Note:
^ Bitwise Exclusive OR
B &= MASK;
is equivalent to
#define MASK (%1111 0000)
B = B & MASK;
A = 0x88 & MASK; // result is 0x80
B = 0x88 | MASK; // result is 0xF8
C = 0x88 ^ MASK;; // result is 0x78
C = ~C; // result is 0x87
 ‘C’ Programming Language

Loops – for loop

start end increment

for (i=0; i<10; i++)

power[i] = volts[i] * current[i];

for(;;)
{
//loop forever
}
 ‘C’ Programming Language

Loops – while loop

cntr = 0;
while (cntr < 10) // loop will execute 10 times
{
num[cntr] = 5;
cntr++;
}

while (1)
{
// this loop will execute forever
}
 ‘C’ Programming Language

Loops – do while loop

cntr = 0;
do
{
num[cntr]
[ ] = 5;
cntr++;
} while (cntr < 10); // still executes 10 times
 ‘C’ Programming Language

If statement

if (num <= 10 || eli==7)

‘else if’ and ‘else’ never get tested if
{
“if (num<=10) is TRUE
// do
d something
thi
}
else if (num >= 20)
Can have onlyy one ‘if’ and one ‘else’, but
{ as many ‘else if’s as you want
// do something
}
else
{
// default case
}
 ‘C’ Programming Language

The switch statement

switch (buffer[3]) If you were to look at the assembly
{ or machine code, switch and if-else
case 1: statements are functionally
// execute function 1 equivalent. But if there are many
b k
break; cases, a switch statement is usually
case 2:
easier to look at, add to, etc.
//function eli
case 3:
case 5:
// execute function 2 Switch statements lend themselves
break; well to things like command parsers
… and
d state
t t machines.
hi
case n:
// execute function n
break;
default:
// execute function _ERROR
break;
}
 ‘C’ Programming Language

Functions
FUNCTION
type function_name( type, type, type, …) PROTOTYPE
- At top of ‘C’ file or
included in header
Return argument – can file
be char, int, etc. Values passed to a
function – one way
‘void’
void means no return copy to function
argument
‘void’ means no
If not ‘void’ function values passed
needs
d a ‘‘return
t (value)’
( l )’
statement at the end
 ‘C’ Programming Language

// Includes Functions (cont.)

#include <Timer.h>
// Function PROTOTYPES
// Function PROTOTYPES
void config_Timer (void);
void config_IO (void);

// MAIN Routine
void main (void)
{
// Configure Port I/O
config_IO ();
// Initialize Timer 3
config_Timer();
fi Ti ()
}
}

// Other Routines
Timer.h
void config_IO (void)
{
//Set up micro I/O ports
} Main.c

EE403W.4 Spring 26
 ‘C’ Programming Language

Note on Recursion / Reentrancy

n! = n * (n-1) * (n-2) * …
Function calculates a factorial by
llong factorial
f i l (int
(i n)) calling itself until n = 0.
0

{
Need to be careful doing this, every
if (n == 0) function call puts multiple bytes on the
return (1); stack. If not terminated correctly could
overflow the stack very easily.
else
return (n * factorial (n-1));
}
 ‘C’ Programming Language

Why use functions?

• Makes code more modular – easier to read
• If sections of code are repeated multiple times, putting that
code in a function saves code space
• If section of code is not repeated more than once, function call
adds extra code (and hence runtime)

• What iff you

y want the modularityy but not the extra stuff,
ff what
do you do?
 ‘C’ Programming Language

Macros
A way to “modularize” code without the penalty of a function call

In ‘file_name.h’ …
#define square (x) (x) * (x)

In ‘file
file_name.c
name.c’ …
Power = square (I) * R;

If you look at the compiled code,

code the macro definition gets inserted
as in-line code, whereas functions get treated as jumps to a single
block of code somewhere else in memory.
 ‘C’ Programming Language

Local Variables vs. Global Variables

// Function PROTOTYPES
void calc_number (void);
static unsigned char this_is_global;

// Main Routine
void main (void)
{
unsigned char this_is_local;
this_is_global = 10; This won’t compile - error.
this_is_local = this_is_global;
calc_number ( );
}
Why? Global var’s get dedicated
// Other Routines
void calc
calc_number
number (void)
memory locations, local variables
{ all share a section of ‘scratchpad’
unsigned temp1, temp2; memory – the compiler figures out
temp1 = this_is_global;
temp2 = this_is_local; exactly which variable gets which
} memory location
l ti att any one time.
ti
 ‘C’ Programming Language

How to share Global Variables among multiple ‘C’ files

// Main.c
#include <main.h> // main.h
unsigned char this_is_global = 7; extern unsigned char this_is_global;
extern void calc_number ( );
// Main Routine
void
id main
i (void)
( id)
{
unsigned char this_is_local; // Algorithm.c
this_is_local = this_is_global; #include <main.h>
calc_number ( );
run_algorithm ( ); // Routine
R ti
} void run_algorithm (void)
{
// Other Routines unsigned char this_is_local_too;
void calc
calc_number
number (void) this_is_local_too = this_is_g
global;
{ calc_number ( );
unsigned temp1; }
temp1 = this_is_global;
}

Variables and functions can be external / global.

 ‘C’ Programming Language

Arrays
unsigned char cnum[5] = {5, 7, 2, 8, 17}; // 5 bytes of memory
unsigned int inum[5]; // 10 bytes
fl fnum[5];
float f [5] // 20 bytes
b

Mem Location Value

0100 5
Address of cnum[0]
0101 7
0102 2
0103 8
0104 17
 ‘C’ Programming Language

Multidimensional Arrays
unsigned char cnum[2][3];
cnum[0][0] = 3;
cnum[0][1] = 6;
Mem Location
i Value
l
cnum[0][2] = 8;
cnum[1][0] = 1; 0100 3
cnum[1][1]
[1][1] = 0;
0 0101 6
cnum[1][2] = 12; 0102 8
0103 1
0104 0
0105 12
 ‘C’ Programming Language
Pointers
Memory Value
Location
* - deference operator F004 F00C p
& - address of F008 q

F00C 5 i
unsigned int *p, *q; F010 F004 r
unsigned
g int i;;
F014
unsigned int **r

i = 5;
p = &i; *p = 0; // like saying “set the contents of
// memory location pointed to by p
r = &p;
// to 0” (i.e. i = 0)
**r = ?
 ‘C’ Programming Language

Pointers – another example

You are working on a 16 bit machine, and the memory

location at absolute address 0x67A9 needs to be set to an
initialization value of 0xAA55. How do you do it?

iintt *ptr;
* t
ptr = (int *) 0x67A9; //Type Cast!
* = 00xAA55;
*ptr AA55
PORTA_DATA_REG = 1;

#define PORTA_DATA_REG *(unsigned char *)(0x0004)

 ‘C’ Programming Language
Advantage of Using Pointers
• Allows you to directly access machine
function call
memory
– i.e. contents of specific registers BufCopy (num, &outputBuf, &inputBuf);
• Helps to modularize code
– can pass a pointer in a function call

void BufCopy (char nbytes, char *DstBufPtr, char *SrcBufPtr)

{
while (nbytes-- > 0)
{
*DstBufPtr = *SrcBufPtr;
DstBufPtr++; SrcBufPtr++; function
}
}
 ‘C’ Programming Language

typedef, struct and union

struct FOURBYTES
{ union FLOAT Impedance [8],
char byte4; unsigned char I_bytes [8][4];
char byte3;
char byte2; Impedance [6].f = 23.556;
char byte1;
}
}; II_bytes
b t [6][0] = Impedance
I d [6].b.byte1;
[6] b b t 1
I_bytes [6][1] = Impedance [6].b.byte2;
typedef union FLOAT I_bytes [6][2] = Impedance [6].b.byte3;
{ I bytes [6][3] = Impedance [6].b.byte4;
I_bytes [6] b byte4;
float f;
struct FOURBYTES b;
};
 ‘C’ Programming Language

typedef, struct and union

typedef struct
{
unsigned char BIT_0 : 1;
unsigned
g char BIT_1 : 1;; // Definition
unsigned char BIT_2 : 1; BITFLAG UserFlags;
unsigned char BIT_3 : 1;
unsigned char BIT_4 : 1;
// In code
unsigned char BIT_5 : 1;
unsigned char BIT_6 : 1; UserFlags.BIT_0 = TRUE;
unsigned char BIT_7 : 1; UserFlags.BIT_1 = FALSE;
} BITFLAG;
BITFLAG

#define TRUE (1)

#define FALSE (0)
 ‘C’ Programming Language

Preprocessor Directives
#include
#define
#pragma #define
#d fi GREEN
#define RED
…
Conditional compilation
p #if (GREEN)
#if / #ifdef / #ifndef //compile this code
#elif …
#elif (RED)
#else // compile this code
#endif …
#endif
 ‘C’ Programming Language

Other keywords – void process_buttons (void)

{
static static unsigned char button_old = 0;

button_new = PORTA & %0000 0001;

1. Local variables declared if (button_new & button_old)
static maintain their value {
between function // button press TRUE 2 times
// in a row do something!
invocations }
2. Functions declared static b
button_old ld = button_new;
b
}
can only be called by
functions in the same
module
 ‘C’ Programming Language

Other keywords – volatile

• Wh
When a variable
i bl iis declared
d l d volatile,
l il theh compiler
il is
i forced
f d to
reload that variable every time it is used in the program.
Reserved for variables that change frequently.
- Hardware Registers
- Variables used in interrupt service routines (ISR)
- Variables shared by multiple tasks in multi
multi-threaded
threaded apps
Ex.
volatile unsigned char UART_Buffer
UART Buffer [48];
// UART_Buffer is used in the UART ISR to
// record the incoming data stream
 ‘C’ Programming Language

Other keywords – const

• Doesn’t mean ‘constant’, means ‘read-only’
• The program may not attempt to write a value to a const
variable
i bl
• Generates tighter code, compiler can take advantage of some
additional optimizations
p