1 C Programming for Embedded Systems. Data RAM Pointer Types ...

P. Klimo Sep 2010
C Programming for Embedded Systems.
Initialization Library Code (start-up code) responsiblities:
1) Set up status and configuration registers
2) Set up the stack (and the memory heap)
3) Process the run-time initialization table to auto-initialize global
variables
4) Call main
5) Call exit when main returns
Pragmas and Compiler Directives: Processor specific additions to ANSI C.
The psect directive: breaks the code into different sections that are grouped together by the Linker.
Note: After the build you can view the map file (.map)
Bank1 Type Qualifier:
static bank0 unsigned char fred; // fred allocated to bank 0
Pointers:
Data RAM Pointer Types:
• 8 bit wide pointer accessing a pair of Banks (Banks 0 and 1 or Banks 2 and 3).
• 16 bit wide pointer accessing all Data memory space.
Data ROM Pointer Types:
• 8 bit pointer accessing first 256 addresses in the Program ROM.
• 16 bit pointer accessing entire ROM.
Examples:
void SendBuff1(char * ptr);
// parameters fetched from RAM
void SendBuff2(const char* ptr); // parameters fetched from ROM
char msg1[] = “hello”;
bank1 char[]= “hello”;
char *cp1 = msg1;
// an array in Bank 0 RAM that is initialized at start up.
// as above but data placed in Bank1
// pointer to RAM
1

P. Klimo Sep 2010
const char msg2 [] = “hello”;
const char *cp2 = msg2;
SendBuff1(msg1);
SendBuff2(msg2);
SendBuff2(“hello”);
SendBuff1(“hello”);
// stores string in Program ROM
// pointer to ROM
// accesses data in RAM
// accesses data in ROM
// same as above
// produces compiler error
Interrupts:
long tick_count;
void interrupt tc_int(void){
// keyword interrupt needed
tick_count++;
}
Variables storage:
global: Initialized are placed in the .init segment and non-initialized in the (.bss)
auto: Allocated to software stack created in memory Bank0.
static: Occupy fixed memory locations (defined by the psect directive).
volatile: will not be optimized by compiler
register: advice to compiler to store in CPU rather then RAM
Structures:
bank1 struct {
int number;
int* ptr;
}record;
struct record student;
student.number =78;
2

P. Klimo Sep 2010
Assessing Individual bits:
struct foo {
// Declare foo as a structure type
unsigned lo:1; // bit 0
unsigned dummy: 6; // bits 1 to 6
unsigned hi:1; // bit 7
} *ptrfoo; // Declare ptrfoo as a pointer to structure type foo
struct foo PortA;
// Define PortA as a structure foo
PortA.hi =0; // Initiate bit 7 of PortA to 0
ptrfoo=&PortA;
// Set pointer ptrfoo to point at PortA
ptrfoo->lo = 1; // Initiate bit 0 of PortA to 1
Macros:
#define TWO 2
// Define a constant macro
int y = TWO*3;
#define multiplyByTwo(x) 2*(x) // Define a “ function” macro
y = multiplyByTwo(3);
Typedef:
int myFunc tion(int r);
// Declare a function (defined elsewhere)
int k = 6;
typedef int (*Func)(int a) ptrFunc;
ptrFunc = myFunction;
// Define ptrFunc as a pointer to a function type
// Point to myFunction
ptrFunc(k); // Call myFunc tion with argument 6
3

P. Klimo Sep 2010
Pre-Processor:
#define HERE_WE_GO
# ifdef HERE_WE_GO
/* Do something */
#else
static bank1 unsigned char fred; // fred allocated to bank 1
/* do something else */
#endif
static bank3 unsigned char fred; // fred allocated to bank 3
Example of a Simple Source File:
const int a = 66;
int c = 23;
int myFunc( const int x, int y){
static int count =0;
int c;
c = x + y + count++;
// Define integer 66 in program ROM
// Initialize 2 bytes in the general RAM
// Define a function in the general RAM
// Private variable placed in the general RAM
// Automatic variable defined on the myFunc stack
// Will increment count between calls
return c;
}
void main(){
int b;
// The main function executes after initialization
// Automatic variable defined on main’s stack
while(1){
b = myFunc(a, c);
// Infinite Loop calls repeatedly calls myFunc
}
}
4

5
P. Klimo Sep 2010

P. Klimo Sep 2010
Explanation of the Compilation Process Example:
File1.c contains the C source code for the main function. This is the function that executes first.
Because of the #include directives the Pre-processor includes the two files, the one in angled brackets
resides in the compiler install directory, the one bracketed with “ should be placed in the Project
directory. The stdio.h header file declares the library printf function that is used in the main. The
header.h is a user created file that defines a new variable type Int16 based on the compiler’s
implementation of the integer variable (in this case 16 bit). Unlike a macro, the typedef performs strict
type checking. Note the use of the macro construct #ifndef etc that encloses the declarations in the
header file. This prevents the Pre-processor to include in any module the same file more than once in
case of a circular reference.
The two extern statements declare two functions that are defined outside the file1. This enables the
Pre-processor to compile the File1.c without any reference to any other files.
Following the declaration of the variables, three functions are called by the main. The function getArea
that is defined in the File2.c, the function printf that is defined in the Standard Library that must be
linked by the linker (either explicitly or by appropriately configuring the Project file) and the function
sum that is defined in the assembler File3.asm.
The File3.asm includes the assembler code for the function sum. The directive global allows the labels to
be exported to the linker. The _sum label (notice the leading underscore) is the starting address of the
subroutine sum. The label ?_sum is the address of the run-time function stack created by the main when
the function sum is called. In C the function parameters are copied by the caller (in this case the main)
onto the function stack in the reverse order. There are two parameters u and v, both one byte wide.
The rules between the caller and the callee (the function) are standardised for any C compiler. In this
case the second character (v) is passed in the CPU work register (w) and the first parameter (u) is copied
to the stack location ?_sum.
Having passed the parameters to CPU register an onto the function stack, the control is passed to the
subroutine starting at the memory location _sum. The machine code that resides there adds the value of
the parameter placed at ?_sum to the value of the working register and returns. Thus when the
function sum returns to the caller the w register in the CPU contains the sum of the two input
parameters. This value is used by the caller in the function printf.
On function return to the caller, it is the responsibility of the caller to “remove” the callee’s function
stack so any subsequent attempts to access the callee’s stack (e.g. the previously stored parameter at
the memory address ?_sum ) will have an unreliable outcome.
Having independently compiled the three source modules File1.c, File2.c and File3.asm, it is the role of
the linker to link them together with any pre-compiled library files to produce a single executable file. In
the case of embedded system, the format of the executive file normally chosen is the (Intel) hex file that
is used by the device programmer to download the code into the microprocessor’s program ROM.
6

P. Klimo Sep 2010
Example: Driving Seven Segment Display
Schematic
EasyPic 4 Board
Task:
Drive a single digit Seven Segment display, displaying digits between 0 and 9 at 1 second interval.
7

P. Klimo Sep 2010
Flow Diagram:
8

P. Klimo Sep 2010
CODE
/* File: 7SegDisplay_1D.c
Description:
Displays a digit on single 7-segment display. Segments connected to PORTD ( segment A to RD0, segment B to
RD1, etc); Common cathode is connected to the pin RA1 on PORTA. Incremented every 1s.
* Test configuration: MCU: P16F877A Dev.Board: EasyPIC4
Xtal: HS, 8 MHz SW: PICC.0 */
#include /* HI-tech compiler definitions */
/* PIC configuration: HS oscillator, Watch Dog Timer off, Browning Effect off, Low Voltage Mode off */
__CONFIG(HS&WDTDIS&PWRTDIS& BORDIS&LVPDIS ); // HiTec Pragmas
void Delay_ms(int ms);
unsigned short SendCode(unsigned short num);
unsigned short count;
// Delay routine
// Convert binary to seven segment code
// Display value
void main()
{ // Initialize Ports
PORTA = 0;
TRISA = 0xfd;
PORTD = 0;
TRISD = 0;
// Configure bit 1 of Port A as output
// by clearing bit 1 in the TRISA register
// Configure all bits of Port D as outputs
// by clearing the TRISD register
do { // Proceed incrementing the displayed digit from 0 to 9
for (count = 0; count

P. Klimo Sep 2010
//-------------- Returns 7-seg. Display code
unsigned short SendCode(unsigned short num) {
switch (num) {
case 0 : return 0x3F;
case 1 : return 0x06;
case 2 : return 0x5B;
case 3 : return 0x4F;
case 4 : return 0x66;
case 5 : return 0x6D;
case 6 : return 0x7D;
case 7 : return 0x07;
case 8 : return 0x7F;
case 9 : return 0x6F;
} //case end
}//
void Delay_ms(int ms){
unsigned int Xtal_Freq = 153; // about 1 second delay for 8MHz Xtal
unsigned int count = ms;
unsigned int i;
while(count>0){
for (i=0; i< Xtal_Freq; i++){;}
count--;
}
}
10