1 / 33

The C Language

The C Language. Topics to Cover…. ISR’s High Level Languages Compilers vs. Interpreters The C Language 1 st C Program C Style C Preprocessor printf Function eZ430X Header Files 2 nd C Program. Interrupt Service Routine. Interrupt Service Routines. Well-written ISRs:

eytan
Download Presentation

The C Language

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  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 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. 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) 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 …. 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 r4,r5 assembler Machine language programs 0100 0100 0000 0101 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. 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. Declare some integer variables Read in an integer Loop from startPoint down to0, printing counter as you go... A Second Program #include <stdio.h> #defineSTOP0 intmain(intargc, char*argv[]) { intcounter; intstartPoint; printf("\nEnter a positive number:"); scanf("%d", &startPoint); for(counter = startPoint; counter >= STOP; counter--) { printf("\nCount is: %d", counter); } return0; } Print a prompt Chapter 11

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

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

  26. 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 commands are not terminated with ‘;’ The C Language

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

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

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

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

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

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

  33. The C Language

More Related