Chapter 11 - The C Language

1. Chapter 11 - 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 The C Language

3. 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!!!) The C Language

4. Interrupt Service Routine Disable Interrupts Main Routine Interrupt Service Routine Interrupt Service Routines • Who empties the trash? Global Variable The C Language

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

6. 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 …. The C Language

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

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

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

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

11. 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 initialprogramming costs • Easier to debug • Easier to maintain main() { readInput(); checkForErrors(); doCalculation(); writeOutput(); } The C Language

12. High Level Languages 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); The C Language

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

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

15. 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 ... } } The C Language

16. by hand C-language program c = a + b; compiler Assembly language program ADD r0,r1,r2 assembler Machine language programs 0010110010010001111 to machine for execution Compilers vs Interpreters Compilation Algorithm The assembly language stage is often skipped… Compiler often directly generates machine code. The C Language

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

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

19. Assembler Code C/C++ Code Object Code Machine Code The C Language Compiling a C Program The C Language

20. C Preprocessor Preprocessed source code 1st Pass 2nd Pass Code Generation Source Code Analysis Symbol Table Object module Library & Object Files Linker ExecutableImage The C Language Compiling a C Program C Source Code C Compiler The C Language

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

22. 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) The C Language

23. Style 2 if(a < b) { b = a; a = 0; } else { a = b; b = 0; } Style 1 if(a < b) { b = a; a = 0; } else { a = b; b = 0; } 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 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... The C Language

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

25. 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> /* a system header file */ #include "myheader.h" /* a user header file */ Preprocessor command are not terminated with ‘;’ The C Language

26. 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 8000000 // SMCLK = ~8 mhz void main(void) { eZ430X_init(myClock); // init board ERROR2(5); } The C Language

27. 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) The C Language

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

29. 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, ...); The C Language

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

31. 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" #define LOW 0 // Starting temperature #define HIGH 100 // 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. The C Language

32. The C Language