Transcript Chapter 11 - The C Language

Chapter 11 The C Language
Topics to Cover…










ISR’s
High Level Languages
Compilers vs. Interpreters
The C Language
1st C Program
C Style
C Preprocessor
printf Function
eZ430X Header Files
2nd C Program
BYU CS/ECEn 124
The C Language
2
Interrupt Service Routine
Interrupt Service Routines

Well-written ISRs:




Should be short and fast
Should affect the rest of the system as little as
possible
Require a balance between doing very little – thereby
leaving the background code with lots of processing –
and doing a lot and leaving the background code with
nothing to do
Applications that use interrupts should:



Disable interrupts as little as possible
Respond to interrupts as quickly as possible
Communicate w/ISR only through global variables
(never through registers!!!)
BYU CS/ECEn 124
The C Language
3
Interrupt Service Routine
Interrupt Service Routines

Who empties the trash?
Disable
Interrupts
Main
Routine
BYU CS/ECEn 124
Interrupt
Service
Routine
Global
Variable
The C Language
4
Levels of Abstraction
Problems
Algorithms
High Level Languages
Language
Assembly code
Machine (ISA) Architecture
Machine code
Microarchitecture
MSP430 Architecture
Circuits
Logic gates, multiplexers, memory, etc.
Devices
Transistors
BYU CS/ECEn 124
The C Language
5
High Level Languages
High Level Languages


The closer a language is to your original specification, the
easier the program is to write.
Many, many programming languages








LISP - LISt Processing
PROLOG - logic programming
MATLAB - matrix and vector manipulations
BASIC – interpreter for small computers
APL – matrix and vectors
FORTRAN – formula translation
COBOL – business and accounting
PASCAL - procedural
….
BYU CS/ECEn 124
The C Language
6
High Level Languages
High Level Languages

During the part of our course, you will be
introduced to fundamental high-level
programming constructs:






Variables
Control structures
Functions
Arrays and Pointers
Simple data structures
Recursion
BYU CS/ECEn 124
The C Language
7
High Level Languages
High Level Languages

Allow us to use symbolic names for values


Programmer simply assigns each value a
name
Allow us to ignore many memory details, the
compiler takes care of …





register usage
variable allocation
loads and stores from memory
callee/caller protocol
stack management for subroutine calls
BYU CS/ECEn 124
The C Language
8
High Level Languages
High Level Languages

Provide abstraction of underlying hardware




Hide low level details (ISA) from programmer
Uniform interface (not tied to ISA) to program
Portable software (works on different ISAs)
The compiler generates the machine code
if ((a >= '0') && (a <= '9'))
{
sum = sum * 10;
sum = sum + (a - '0');
}
else ...
BYU CS/ECEn 124
The C Language
9
High Level Languages
High Level Languages

Provide expressiveness



Human-friendly orientation
Express complex tasks with smaller amount
of code
English-like and human readable




if-then-else…
while…
for...
switch…
BYU CS/ECEn 124
if(isCloudy)
get(umbrella);
else
get(sunglasses);
The C Language
10
High Level Languages
High Level Languages

Enhance code readability

Can read like a novel…


if written with readability in mind
Readability.. is very important



life cycle costs are more important than initial
programming costs
main()
Easier to debug
{
readInput();
Easier to maintain
checkForErrors();
doCalculation();
writeOutput();
}
BYU CS/ECEn 124
The C Language
11
High Level Languages
High Level Languages

Provide safeguards against bugs

Rules can lead to well-formed programs


Compilers can generate checks



structured programming (no GOTO statements)
array bounds checking
data type checking
Many languages provide explicit support for
assertions

something that should be true - if it isn’t, then error
assert(accountBalance >= 0);
BYU CS/ECEn 124
The C Language
12
Compilers vs Interpreters
Compilation vs. Interpretation

Interpretation: An interpreter reads the program
and performs the operations in the program


The program does not execute directly, but is
executed by the interpreter.
Compilation: A compiler translates the program
into a machine language program called an
executable image.

The executable image of the program directly
executes on the hardware.
The interpreter and compiler are themselves programs
BYU CS/ECEn 124
The C Language
13
Compilers vs Interpreters
Interpretation
Algorithm
by hand
High-Level Language Program
c = a + b;
Interpreter
read &
execute
program text
BYU CS/ECEn 124
The C Language
14
Compilers vs Interpreters
Interpretation

Program code is interpreted at runtime



lines of code are read in
interpreter determines what they represent
requested function is performed
interpret()
{
while(1)
// do forever
{
readInputLine();
if(line[0..3] == "mult")
doMultiply();
else if(line[0..2] == "add")
doAdd();
else ...
}
}
BYU CS/ECEn 124
Interpretation is common:
+ LISP
+ BASIC
+ Perl
+ Java
+ Matlab
+ LC-2 simulator
+ UNIX shell
+ MS-DOS command line
Interpretation can be slow...
The C Language
15
Compilers vs Interpreters
Compilation
Algorithm
by hand
C-language program
c = a + b;
The assembly language stage
is often skipped…
compiler
Assembly language program
ADD r0,r1,r2
assembler
Compiler often directly
generates machine code.
Machine language programs
0010110010010001111
to machine for execution
BYU CS/ECEn 124
The C Language
16
Compilers vs Interpreters
Compilation

Compilers convert high-level code to machine
code





compile once, execute many times
resulting machine code is optimized
may include intermediate step (assembly)
slower translation, but higher performance when
executed
Is an assembler considered a compiler?


assemblers do convert higher level code to machine
code, but…
they are usually in a class by themselves
BYU CS/ECEn 124
The C Language
17
The C Language
The C Programming Language


Developed 1972 by Dennis Ritchie at Bell Labs
C first developed for use in writing compilers
and operating systems (UNIX)





A low-level high-level language
Many variants of C
1989, the American National Standards Institute
standardized C (ANSI C, most commonly used C)
“The C Programming Language” by Kernighan and
Ritchie is the C “Bible”
C is predecessor to most of today’s procedural
languages such as C++ and Java.
BYU CS/ECEn 124
The C Language
18
The C Language
Compiling a C Program
C/C++ Code
Assembler Code
Object Code
Machine Code
BYU CS/ECEn 124
The C Language
19
The C Language
Compiling a C Program
C Source Code
C Compiler
C Preprocessor
Preprocessed
source code
1st Pass
Source Code
Analysis
2nd Pass
Symbol
Table
Code
Generation
Object module
Library & Object
Files
BYU CS/ECEn 124
Linker
The C Language
Executable
Image
20
1st C Program
A First Program
Tells compiler to use all the definitions
found in the msp430x22x4.h library.
A .h file is called a header file and
//************************************
containsP1.0
definitions and declarations.
// blinky.c: Software Toggle
//************************************
#include "msp430x22x4.h"
All programs must have a main()
routine. This one takes no
arguments (parameters).
void main(void)
{
int i = 0;
Stop WD w/Password
WDTCTL = WDTPW + WDTHOLD; // stop WD
P1DIR |= 0x01;
// P1.0 output
for (;;)
// loop
Set P1.0 as output
{
P1OUT ^= 0x01;
// toggle P1.0
Loop forever
while (--i);
// delay
}
Delay 65,536
}
Toggle P1.0
BYU CS/ECEn 124
The C Language
21
C Style
Comments

Use lots of comments
/* This is a comment */
// This is a single line comment

Comment each procedure telling:
/*----------------------------------*
* ProcedureName – what it does
*
* Parameters:
*
*
Param1 – what param1 is
*
*
Param2 – what param2 is
*
* Returns:
*
*
What is returned, if anything *
*----------------------------------*/

Use lots of white space (blank lines)
BYU CS/ECEn 124
The C Language
22
C Style
Indenting Style



Each new scope is indented 2 spaces from
previous
Put { on end of previous line, or start of next line
Style 2
Line matching } up below
Style is something of a
personal matter.
Everyone has their own
opinions…
What is presented here
is similar to that in
common use and a
good place to start...
BYU CS/ECEn 124
Style 1
if(a < b) {
b = a;
a = 0;
}
else {
a = b;
b = 0;
}
The C Language
if(a < b)
{
b = a;
a = 0;
}
else
{
a = b;
b = 0;
}
23
C Style
More On Indenting Style

For very long clauses, you may want to add a
comment to show what the brace is for:
if(a < b)
{
/* Lots of code here... */
} // end if(a < b)
else
{
/* Lots of code here... */
} // end else
BYU CS/ECEn 124
The C Language
24
C Preprocessor
The C Preprocessor

#define symbol code

The preprocessor replaces symbol with code
everywhere it appears in the program below
#define NUMBER_OF_MONKEYS 259
#define MAX_LENGTH 80
#define PI 3.14159

#include filename.h

The preprocessor replaces the #include directive itself
with the contents of header file filename.h
#include <stdio.h>
#include "myheader.h"
/* a system header file */
/* a user header file */
Preprocessor command are not terminated with ‘;’
BYU CS/ECEn 124
The C Language
25
eZ430X Header Files
eZ430X System Functions

eZ430X.h and eZ430X.c
int eZ430X_init(int clock_speed);
void ERROR2(int error);

// init system
// fatal error
Setting system clock
#include "msp430x22x4.h"
#include "eZ430X.h"
#define myClock
CALDCO_8MHZ
#define CLOCK
8000000
void main(void)
{
eZ430X_init(myClock);
ERROR2(5);
}
BYU CS/ECEn 124
// SMCLK = ~8 mhz
// init board
The C Language
26
eZ430X Header Files
C I/O

I/O facilities are not part of the C language itself


The ANSI standard defines a precise set of I/O
library functions for portability


Nonetheless, programs that do not interact with their
environment are useless
Programs that confine their system interactions to
facilities provided by the standard library can be
moved from one system to another without change.
The properties of the C I/O library functions are
specified in header files


<stdio.h> (C standard library)
"eZ430X.h", "lcd.h" (eZ430X)
BYU CS/ECEn 124
The C Language
27
printf Function
Output in C

String literal
printf( format_string, parameters )
Decimal
Integer
printf("\nHello World");
printf("\n%d plus %d is %d", x, y, x+y);
printf("\nIn hex it is %x", x+y);
printf("\nHello, I am %s. ", myname);
Hex
printf("\nIn ascii, 65 is %c. ", 65);
Integer

Output:
Hello world
Newline
String
5 plus 6 is 11
In hex it is b
Hello, I am Bambi.
In ascii, 65 is A.
BYU CS/ECEn 124
Character
The C Language
28
printf Function
LCD

lcd.c Prototypes

int lcd_init(void);

void lcd_volume(int volume);

void lcd_backlight(int backlight);




int lcd_display(int mode);
void lcd_clear(int value);
void lcd_image(const unsigned char* image,
int column, int page);
void lcd_blank(int column, int page,
int width, int height);

void lcd_cursor(int column, int page);

char lcd_putchar(char c);

void lcd_printf(char* fmt, ...);
BYU CS/ECEn 124
The C Language
29
printf Function
LCD

LCD - 100 x 160 x 4 pixels display
Page 12
Page 11
// 5 x 8 pixel Characters
lcd_cursor(40, 5);
lcd_printf("Hello World!");
Page 10
Page 9
Page 8
Y (0-99) 
Page 7
BYU CS/ECEn 124
Hello World!
Page 6
Page 5
Page 4
Page 3
Page 2
Page 1
Page 0
X (0-159) 
The C Language
30
2nd C Program
A Second Program
#include the lcd functions
//
//
//
//
File: ftoc.c
Date: 02/15/2010
Author: Joe Coder
Description: Output a table of Fahrenheit and Celsius temperatures.
#include "msp430x22x4.h"
#include "eZ430X.h"
#include "lcd.h"
Use #define’s for magic numbers
#define LOW 0
#define HIGH 100
#define STEP 10
// Starting temperature
// Ending temperature
// increment
int main(void)
{
int fahrenheit;
float celsius;
// Temperature in fahrenheit
// Temperature in celsius
WDTCTL = WDTPW + WDTHOLD;
eZ430X_init(CALDCO_1MHZ);
lcd_init();
Use meaningful names
for variables
// Stop WDT
// init board
// Loop through all the temperatures, printing the table
for(fahrenheit = LOW; fahrenheit <= HIGH; fahrenheit += STEP)
{
celsius = (fahrenheit - 32) / 1.8;
printf("\nf=%d, c=%.1f", fahrenheit, celsius);
}
}
BYU CS/ECEn 124
The C Language
1 digit to the right of the
decimal point.
31
BYU CS/ECEn 124
The C Language
32