1. The C Language

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

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

4. Interrupt Service Routines
Who empties the trash?
Interrupt
Service
Routine
Disable
Interrupts
Main
Routine
Global
Variable
BYU CS/ECEn 124
The C Language

5. Levels of Abstraction High Level Languages Problems Algorithms
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

6. Outline of Second Half of this Course
During the second half of the course, you will be introduced to fundamental high-level programming constructs:
Variables (Chapter 13)
Control structures (Chapter 14)
Functions (Chapter 15)
Arrays and Pointers (Chapter 16)
Simple data structures (Chapter 17)
Input and Output (Chapter 18)
Recursion (Chapter 19)
BYU CS/ECEn 124
The C Language

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

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

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

10. 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…
if(isCloudy)
get(umbrella);
else
get(sunglasses);
BYU CS/ECEn 124
The C Language

11. 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
Easier to debug
Easier to maintain
main() {
readInput();
checkForErrors();
doCalculation();
writeOutput(); }
BYU CS/ECEn 124
The C Language

12. High Level Languages Provide safeguards against bugs
Rules can lead to well-formed programs
structured programming (no GOTO statements)
Compilers can generate checks
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

13. Compilation vs. Interpretation
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

14. High-Level Language Program read & execute program text
Compilers vs Interpreters
Interpretation
Algorithm
High-Level Language Program
c = a + b;
by hand
Interpreter
read & execute program text
BYU CS/ECEn 124
The C Language

15. Interpretation Program code is interpreted at runtime
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
Interpretation is common:
+ LISP
+ BASIC
+ Perl
+ Java
+ Matlab
+ LC-2 simulator
+ UNIX shell
+ MS-DOS command line
Interpretation can be slow...
interpret() {
while(1) // do forever
readInputLine();
if(line[0..3] == "mult")
doMultiply();
else if(line[0..2] == "add")
doAdd();
else ... }
BYU CS/ECEn 124
The C Language

16. Assembly language program Machine language programs
Compilers vs Interpreters
Compilation
Algorithm
C-language program
c = a + b;
by hand
Assembly language program
ADD r4,r5
compiler
The assembly language stage
is often skipped…
Compiler often directly
generates machine code.
Machine language programs
assembler
to machine for execution
BYU CS/ECEn 124
The C Language

17. Compilation Compilers convert high-level code to machine code
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

18. The C Programming Language
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

19. Compiling a C Program C/C++ Code Assembler Code Object Code
The C Language
Compiling a C Program
C/C++ Code
Assembler Code
Object Code
Machine Code
BYU CS/ECEn 124
The C Language

20. Compiling a C Program The C Language C Source Code C Compiler
C Preprocessor
Preprocessed
source code
Source Code
Analysis
1st Pass
Code
Generation
2nd Pass
Symbol
Table
Linker
Object module
Library & Object
Files
Executable Image
BYU CS/ECEn 124
The C Language

21. A First Program //************************************
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 contains definitions and declarations.
//************************************
// blinky.c: Software Toggle P1.0
#include "msp430x22x4.h"
void main(void) {
int i = 0;
WDTCTL = WDTPW + WDTHOLD; // stop WD
P1DIR |= 0x01; // P1.0 output
for (;;) // loop
P1OUT ^= 0x01; // toggle P1.0
while (--i); // delay }
All programs must have a main() routine. This one takes no arguments (parameters).
Stop WD w/Password
Set P1.0 as output
Loop forever
Delay 65,536
Toggle P1.0
BYU CS/ECEn 124
The C Language

22. Comments Use lots of comments
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

23. A Second Program
Define a macro called STOP. Anywhere the word STOP appears in the program below, it will be replaced by a 0. This substitution is done by the C preprocessor before the compiler ever gets the program to compile.
#include <stdio.h>
#define STOP 0
int main(int argc, char* argv[]) {
int counter;
int startPoint;
printf("\nEnter a positive number: ");
scanf("%d", &startPoint);
for(counter = startPoint; counter >= STOP; counter--) {
printf("\nCount is: %d", counter); }
return 0;
Declare some integer variables
Print a prompt
Read in an integer
Loop from startPoint down to 0, printing counter as you go...
ECEn/CS 124
Chapter 11

24. Indenting Style Each new scope is indented 2 spaces from previous
C Style
Indenting Style
Each new scope is indented 2 spaces from previous
Put { on end of previous line, or start of next line
Line matching } up below
if(a < b) {
b = a;
a = 0; }
else
a = b;
b = 0;
Style 2
if(a < b) {
b = a;
a = 0; }
else {
a = b;
b = 0;
Style 1
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
The C Language

25. More On Indenting Style
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
} // end else
BYU CS/ECEn 124
The C Language

26. Preprocessor commands are not terminated with ‘;’
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
#include filename.h
The preprocessor replaces the #include directive itself with the contents of header file filename.h
#include <stdio.h> /* a system header file */
#include "myheader.h" /* a user header file */
Preprocessor commands are not terminated with ‘;’
BYU CS/ECEn 124
The C Language

27. eZ430X System Functions eZ430X.h and eZ430X.c Setting system clock
eZ430X Header Files
eZ430X System Functions
eZ430X.h and eZ430X.c
int eZ430X_init(int clock_speed); // init system
void ERROR2(int error); // fatal error
Setting system clock
#include "msp430x22x4.h"
#include "eZ430X.h"
#define myClock CALDCO_8MHZ
#define CLOCK // SMCLK = ~8 mhz
void main(void) {
eZ430X_init(myClock); // init board
ERROR2(5); }
BYU CS/ECEn 124
The C Language

28. C I/O I/O facilities are not part of the C language itself
eZ430X Header Files
C I/O
I/O facilities are not part of the C language itself
Nonetheless, programs that do not interact with their environment are useless
The ANSI standard defines a precise set of I/O library functions for portability
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

29. Output in C printf( format_string, parameters ) Output: Hello world
printf Function
Output in C
String literal
printf( format_string, parameters )
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);
printf("\nIn ascii, 65 is %c. ", 65);
Output:
Hello world
5 plus 6 is 11
In hex it is b
Hello, I am Bambi.
In ascii, 65 is A.
Decimal
Integer
Hex
Integer
Newline
Character
String
BYU CS/ECEn 124
The C Language

30. LCD lcd.c Prototypes int lcd_init(void); void lcd_volume(int volume);
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

31. LCD LCD - 100 x 160 x 4 pixels display Hello World! Y (0-99) 
printf Function
LCD
LCD x 160 x 4 pixels display
Page 10
Page 9
Page 8
Page 7
Page 6
Page 5
Page 4
Page 3
Page 2
Page 1
Page 0
Page 12
Page 11
// 5 x 8 pixel Characters
lcd_cursor(40, 5);
lcd_printf("Hello World!");
Hello World!
Y (0-99) 
X (0-159) 
BYU CS/ECEn 124
The C Language

32. A Second Program 2nd C 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"
#define LOW // Starting temperature
#define HIGH // Ending temperature
#define STEP 10 // increment
int main(void) {
int fahrenheit; // Temperature in fahrenheit
float celsius; // Temperature in celsius
WDTCTL = WDTPW + WDTHOLD; // Stop WDT
eZ430X_init(CALDCO_1MHZ); // init board
lcd_init();
// 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); }
Use #define’s for magic numbers
Use meaningful names for variables
1 digit to the right of the decimal point.
BYU CS/ECEn 124
The C Language

33. BYU CS/ECEn 124
The C Language