s07: the c language required:pm: ch 6, pgs 63-80 pm: ch 8.4, pgs 114-118 recommended: k&r,...
TRANSCRIPT
S07: The C Language
Required: PM: Ch 6, pgs 63-80PM: Ch 8.4, pgs 114-118
Recommended: K&R, Chapters 1-4 C programC++ Compiler 6.5 VariablesGlobal Variables ExpressionsOperators Control StatementsFunctions Library Functions
int i;main(){for(;i["]<i;++i){--i;}"];read('-'-'-',i+++"hell\ o, world!\\n",'/'/'/'));}read(j,i,p){write(j/p+p,i---j,i/i);}
-- Dishonorable mention, Obfuscated C Code Contest, 1984.
(Author requested anonymity.)
CS 224
BYU CS 224 The C Language 2
Chapter Project HomeworkS00: Introduction
Unit 1: Digital Logic
S01: Data TypesS02: Digital Logic
L01: Warm-upL02: FSM
HW01HW02
Unit 2: ISA
S03: ISAS04: MicroarchitectureS05: Stacks / InterruptsS06: Assembly
L03: BlinkyL04: MicroarchL05b: Traffic LightL06a: Morse Code
HW03HW04HW05HW06
Unit 3: C
S07: C LanguageS08: PointersS09: StructsS10: I/O
L07b: Morse IIL08a: LifeL09a: Pong
HW07HW08HW09HW10
Learning Objectives…
Learning Outcomes
After completing this section, you should be able to Discuss the advantages of using a
high level language. Explain the difference between a
compiler and an interpreter. Summarize the function of the C
preprocessor. Describe the compile/assembly/linker
process. List the main features of a C
Language program. Describe how C stream I/O works.
BYU CS 224 The C Language 3
Topics Compilers vs. Interpreters C Program
Symbol Table Variables & Operators Scope Expressions Precedence C Compilation
Frames C / Assembler Coding Practices I/O Streams
Terms…
Activation Record – A block of memory on the stack that is created when a function is called and contains all the local variables for a given invocation of a function.
Arithmetic Operator – Operator that returns a numerical value. Associativity – The execution order of same precedence operators. Bitwise Operator – Operator that performs bitwise logical operations. Data type – Representation and valid operations of data object. Expression – Combination of variables / operators that returns a single value. Global (static) – Variable permanently assigned to a memory location. Literal – An immutable data object. Local (automatic) – Variable stored in a functions activation record. Logical Operator – Operator that returns a logical (true/false) value. Operator – Performs an operation on operand(s). Scope - Extent of a variable/function’s availability in a program. Precedence – The execution order of operators. Variable - Symbolic name for a memory location that hold a value. Variable Coercion – Forcing mixed data type variables to a common type. Volatile – Variable modifier that prohibits optiminization by compiler.
BYU CS 224 The C Language 4
BYU CS 224 The C Language 5
Levels of Abstraction
Problems
Algorithms
Language
Machine (ISA) Architecture
Microarchitecture
Circuits
Devices Transistors
Logic gates, multiplexers, memory, etc.
MSP430 Architecture
Machine code
Assembly code
High Level Languages
BYU CS 224 The C Language 6
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 Ada – DOD large systems Java – Internet C, C++ ….
High Level Languages
BYU CS 224 The C Language 7
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.
High Level Languages
numberOfDays = 30;switch_A = ON;
numberOfDays = 30;switch_A = ON;
printf("Hello World!");printf("Hello World!");
Provide abstraction of underlying hardware Hide low level details (ISA) from programmer Portable software (works on different ISAs)
Provide expressiveness Express complex tasks with smaller amount of code English-like and human constructs if(isCloudy)
get(umbrella);else get(sunglasses);
if(isCloudy) get(umbrella);else get(sunglasses);main()
{ readInput(); checkForErrors(); doCalculation(); writeOutput();}
main(){ readInput(); checkForErrors(); doCalculation(); writeOutput();}
Enhance code readability Can read like a novel… Easier to debug/maintain
BYU CS 224 The C Language 8
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
High Level Languages
assert(accountBalance >= 0);assert(accountBalance >= 0);
High-level languages make complex programming simpler, while low-level languages tend to produce more efficient code
However, well-designed compilers frequently produce code comparable in efficiency to what most low-level programmers can produce by hand with better overall results
BYU CS 224 The C Language 9
Compilers vs Interpreters
temp=v[i];v[i]=v[i+1];v[i+1]=temp;
High-levellanguagestatements
Co
mp
iler
MOV.B 0x0001(SP),R14MOV.W SP,R15INCD.W R15ADD.W R15,R14MOV.B @R14,0x0000(SP)MOV.B 0x0001(SP),R14INC.W R14
Assembly
Ass
emb
ler
415E 0001410F532F5F0E4EE1 0000415E 0001531E
Objectcode
Ap
plic
ati
on
= Executable = Data Path
temp=v[i];v[i]=v[i+1];v[i+1]=temp;
Sourcecode
Inte
rpre
ter
Compilers vs Interpreters
BYU CS 224 The C Language 10
The C Programming Language
Developed between 1969 and 1973 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” (Also called the “White Book”.) C is one of the most popular programming languages of
all time – very few computer architectures exist for which there is no C.
C is predecessor to most of today’s procedural languages such as C++ and Java.
The C Language
BYU CS 224 The C Language 11
Dennis Ritchie (1940-2011)
Dennis Ritchie, the software developer who brought the world the C programming language and Unix operating system, has died at the age of 70.
Ritchie (known by the username "dmr") was part of a dynamic software development duo with Ken Thompson at Bell Labs,, which they joined in 1967 and 1966, respectively. Ritchie created the C programming language, which replaced the B programming language Thompson invented.
Two years later in 1969, they created Unix, initially designed for minicomputers. Unix was initially written in 1969 in assembly language and later in C. Unix went on to become key software for critical computing infrastructure around the world.
“UNIX is very simple, it just needs a genius to understand its simplicity.”
--Dennis Ritchie
BYU CS 224 The C Language 12
Compiling a C ProgramThe C Language
Object Code
Assembler Code
C/C++ Code
Machine Code
BYU CS 224 The C Language 13
Compiling a C ProgramThe C Language
Preprocessor Text
C Source Code
C Preprocessor
Library & ObjectFiles
ExecutableImage
Linker
C Compiler
Source CodeAnalysis
1st Pass
SymbolTable
Assembler
CodeGeneration
2nd Pass
Preprocessed C source code
Assembly Code
Object Code
Machine Code
BYU CS 224 The C Language 14
A First Program
//************************************// blinky.c: Software Toggle P1.0//************************************#include "msp430.h"
volatile unsigned int i; // no optimizationvoid main(void){ WDTCTL = WDTPW | WDTHOLD; // stop watchdog P4DIR |= 0x40; // P4.6 output for (;;) // loop { P4OUT ^= 0x40; // toggle P4.6 while (--i); // delay }}
1st C Program
Tells compiler to use all the definitions found in the msp430.h library. A .h file is called a header file and contains definitions and declarations.All C programs must have a main()
routine.
Stop WD w/Password
Set P4.6 as output
Loop forever
Toggle P4.6Delay 65,536
Allocate a RAM variable(.bss i,2)
BYU CS 224 The C Language 15
Style
Use lots of comments
/* This is a comment */ // This is a single line comment
C Style
Indents 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...
if(a < b) { b = a; a = 0; } else { a = b; b = 0; }
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; }
if(a < b) { b = a; a = 0; } else { a = b; b = 0; }
Style 2
BYU CS 224 The C Language 16
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 */
Macros
C Preprocessor
#define add(x,y) x+=y#define doLoop(x,y) do {x} while(y);doLoop(add(z,2),z<10) do {z+=2} while(z<10);
A C Program
What is a C program? Functions Global variables
Variables are symbolic names for memory locations that hold values
2 types of variables Local (automatic) Global (static)
Variable declarations include A symbolic name Data type (int, char, double) Scope (code region where the variable is defined)
Variables are stored in memory or in registers. The compiler keeps track of where a variable’s value is currently
stored. Operators manipulate values
BYU CS 224 The C Language 17
C Program
The C Symbol Table
The C compiler keeps track of variables in a program during compilation in a symbol table
A symbol table entry is created when a variable is declared.
Specifically, each symbol table entry contains: Variable name Variable data type (int, float, char, etc.) Variable storage class (auto, static) Where in memory the variable is stored (an offset) An identifier to indicate the variable’s scope
Variables must be declared and in scope before they can be used (referenced) by a program
BYU CS 224 The C Language 18
Variables & Operators
BYU CS 224 The C Language 19
Compiling a C ProgramThe C Language
Preprocessor Text
C Source Code
Library & ObjectFiles
ExecutableImage
Linker
C Compiler
Source CodeAnalysis
1st Pass
SymbolTable
Assembler
CodeGeneration
2nd Pass
Preprocessed C source code
Assembly Code
Object Code
Machine Code
C Preprocessor
MSP430 C Variable Data TypesType Size Representation Minimum Maximum
char, signed char 8 bits ASCII -128 127
unsigned char bool 8 bits ASCII 0 255
short, signed short 16 bits 2's complement -32768 32767
unsigned short 16 bits Binary 0 65535
int, signed int 16 bits 2's complement -32768 32767
unsigned int 16 bits Binary 0 65535
long, signed long 32 bits 2's complement -2,147,483,648 2,147,483,647
unsigned long 32 bits Binary 0 4,294,967,295
enum 16 bits 2's complement -32768 32767
float 32 bits IEEE 32-bit 1.175495e-38 3.4028235e+38
double 32 bits IEEE 32-bit 1.175495e-38 3.4028235e+38
long double 32 bits IEEE 32-bit 1.175495e-38 3.4028235e+38
pointers, references 16 bits Binary 0 0xFFFF
function pointers 16 bits Binary 0 0xFFFF
BYU CS 224 The C Language 20
Variables & Operators
Variable Declarations
BYU CS 224 The C Language 21
int i,j,k; // declaring more than one variableint i1, i2, i3, c3po; // numbers OK, except for first letter
int bananas = 10; // using an initializer
int monkey_count = 0; // two ways of doing ...int monkeyCount = 0; // ... multi-word names
int ab, Ab, aB, AB; // case sensitive namesint _compilerVar; // compiler uses _ as first char
char newline = ‘\n’; // a character with an initializerchar lineBuffer[32]; // an array of 32 chars (a string)
double bananasPerMonkey; // floating point declarationsdouble hugeNumber = 1.0E33; // positive exponentdouble tinyNumber = 1.0E-33; // negative exponentdouble fractionThing = 3.33333; // no exponent
Variables & Operators
Scope: Local versus Global
Extent of a variable/function’s availability in a program Local Variables (automatic)
Declared at the beginning of a block Stored in activation record on the stack Scope is from point of declaration to the
end of the block Un-initialized
Global Variables (static) Declared outside of a function Stored in Global Data Section of memory Scope is from point of declaration to the
end of the program May be initialized to zero
BYU CS 224 The C Language 22
{ // begin block int chimp; ...
}
Scope
int chimp;
{ // begin block ...
}
Literals/ Constants
Literal Values Unnamed constant values used in programs area = 3.14159 * radius * radius;
Constant Variables Variable declarations prefixed with the const qualifier Immutable named variables const double pi = 3.14159;
Symbolic Values Created using preprocessor directive #define #define PI 3.14159
How are the above the same? How are the above different?
BYU CS 224 The C Language 23
Variables
Quiz 7.1
Expand the following C pre-processor macros:
BYU CS 224 The C Language 24
#define MASK(bit) (0x80 >> ((bit)%8))#define SET_CELL(a2d,row,col) a2d[row][(col)/8] |= MASK(col)#define CLEAR_CELL(a2d,row,col) a2d[row][(col)/8] &= ~ MASK(col)#define TEST_CELL(a1d,col) (a1d[(col)/8] & MASK(col))
1. SET_CELL(life,row,col+1);
2. CLEAR_CELL(life,row,col);
3. if (TEST_CELL(temp,col)) { ... };
Variable Usage
Make your variable names meaningful Common naming conventions
Hungarian notation (prefix hints) gVariable, hMyRoutine
UpperCamelCase / lowerCamelCase for most identifiers MyInputByte, buzzerCounter
Underscores last_variable_used, number_of_days
all-upper-case for constants #define TRUE 1
Names beginning with underscore are reserved for compilers/libraries
__reserved, _Reserved Encapsulate your variables
Avoid global variables - explicitly pass parameters to functions Keep the scope as small as you can
BYU CS 224 The C Language 25
Variables
volatile
volatile proceeding a variable name instructs the compiler to prohibit caching the variable’s contents when optimizing code. always re-read the variable’s value when accessing the variable. not use computer registers to store a variable’s content.
BYU CS 224 The C Language 26
volatile int switches,dcntvoid main(void){
if (switches & 0x01) {...}}
#pragma vector=PORT1_VECTOR__interrupt void Port_1_ISR(void){ P1IFG &= ~0x0f; // P1.0-3 IFG cleared dcnt = DEBOUNCE_CNT; // enable debounce}
#pragma vector = WDT_VECTOR__interrupt void WDT_ISR(void){ if (dcnt && (--dcnt == 0)) switches = (P1IN ^ 0x0f) & 0x0f;}
Inform the compiler that integers switches and
dcnt are not to be optimized.
Pressing a switch sets
dcnt
Sample P1IN when dcnt equals 0
Variables
Operators and Expressions
Expressions are formed by combining variables with operators and ALWAYS return a single value in C.
i = 5 * x + 100;a = (a < b);
Operators Assignment –
changes the values of variables Arithmetic –
add, subtract, multiply, divide Bitwise –
AND, OR, XOR, NOT, and shifts on Integers Relational –
equality, inequality, less-than, etc. Logical –
AND, OR, NOT on Booleans Increment/Decrement
BYU CS 224 The C Language 27
C supports a rich set of operators that allow the
programmer to manipulate variables
Operators
The Assignment Operator
The operator symbol is the equal sign The expression on the right-hand side is evaluated and
assigned to the left-hand variable
BYU CS 224 The C Language 28
{ int x = 9;
x = x + 4;
}add.w #4,0(sp)
spX
Stack
0x05fa0x05fc0x05fe0x05f0
0x0600...
sub.w #2,spmov.w #9,0(sp)
Operators
sp
Arithmetic / Relational Operators
Arithmetic Operators Add (+), subtract (–), multiply (*), divide (/)
Integer; 5/3 = 1 (truncated to int) Floating point : 5.0 / 3.0 = 1.66666666
Modulus (%) Integer; remainder after integer division; 5 % 3 = 2
Relational operators return Boolean values: 0 if relation is FALSE 1 if relation is TRUE Comparisons
x == y equalityx != y inequalityx < y less-thanx <= y less-than-or-equalx > y greater-thanx >= y greater-than-or-equal
BYU CS 224 The C Language 29
x + y
x – y
x * y
x / y
x % y
Operators
Bitwise Operators
Perform bitwise logical operations across individual bits of a value. AND & OR | XOR ^ NOT ~
(1’s complement) Shifts are bitwise operators
SHIFT LEFT << SHIFT RIGHT >>
BYU CS 224 The C Language 30
x : 1 0 1 0 (binary) y : 1 1 0 0 (binary)
x & y : 1 0 0 0 (binary)
x | y : 1 1 1 0 (binary)
x ^ y : 0 1 1 0 (binary)
~x : 0 1 0 1 (binary)
Operators
x << y shift x y-places to the left (add zeros)x >> y shift x y-places to the right (sign extend)
Logical Operators
Logical operators evaluate to Boolean AND && OR | | NOT !
Don’t confuse with Bitwise operators Operate on Boolean inputs and produce Boolean outputs Boolean inputs (how values are interpreted):
Value not equal to zero TRUE Value equal to zero FALSE
BYU CS 224 The C Language 31
10 && 20 110 && 0 0
Operators
if( 'a' <= x <= 'z' ) statement; // wrong!if(('a' <= x) && (x <= 'z')) statement;
if(!x) statement;if(x == 0) statement;if(x) statement;if(x != 0) statement;
Same
Same
Order of Evaluation
Variable Coercion When executing expressions of mixed types, C automatically
converts integer to floating point and back again as needed.
Avoid the use of forced data conversion as operators may yield unanticipated results.
Order of expression evaluation: Precedence – higher precedence operators evaluate first. Associativity – operators of same precedence evaluate left to right
(with a few exceptions). Parentheses override all other evaluation rules.
BYU CS 224 The C Language 32
Expressions
int x = 1; x is declared an integerx = x + 4.3; integer + floating point ?? (result is x = 5)
Operator Precedence/Associativity
BYU CS 224 The C Language 33
OPERATORS ASSOCIATIVITY( ) [ ] -> . left to right! ~ ++ -- + - * & (type) sizeof right to left* / % left to right+ - left to right<< >> left to right< <= > >= left to right== != left to right& left to right^ left to right| left to right&& left to right|| left to right?: right to left= += -= *= /= %= &= ^= |= <<= >>= right to left, left to right
LogicalLogical
RelationalRelational
BitwiseBitwiseBitwise
Bitwise
Expressions
Unary operators associate right to left.
Quiz 7.2
Evaluate the variable result for the following:
BYU CS 224 The C Language 34
1. int a = 1, b = 2, c = 3, d = 4, e = 5;int result = a * b + c / d * e;
2. int a = 6, b = 5, c = 4, d = 3;int result = c + (d = b * a);
3. int w = 5, x = 4, y = 3, z = 2;int result = w % x / y * z;
Combined Assignment Operators
Arithmetic and bitwise operators can be combined with the assignment operator.
BYU CS 224 The C Language 35
x += y; x = x + (y);
x -= y; x = x – (y);
x *= y; x = x * (y);
x /= y; x = x / (y);
x %= y; x = x % (y);
x &= y; x = x & (y);
x |= y; x = x | (y);
x ^= y; x = x ^ (y);
x <<= y; x = x << (y);
x >>= y; x = x >> (y);
Expressions
Note: All of the expression on
the right is considered
parenthesized.
Conditional Expressions
Conditional expression C multiplexor operation Format: <boolean> ? <true expression> : <false expression> Example:
BYU CS 224 The C Language 36
Expressions
printf("%d dog%s", dogs, (dogs == 1) ? "" : "s");
This expression returns the value of y if x != 0, otherwise it returns the value of z
x ? y : z x
y z
0
x ? y : z
1
Quiz 7.3
What is the output?
BYU CS 224 The C Language 37
main(){ int i = 5,j = 10; i = i &= j && 10; printf("%d %d",i,j);}
main(){ int i = 4,j = 7; j = j || i++ && printf("Hello"); printf("%d %d", i, j);}
1.
2.
0x000a (x)
C to Assembly – Example 1
BYU CS 224 The C Language 38
{ int x = 10; int y = 20; int z = 30; x = x + 4; y = x + y - z;}
0x8696: 8031 0006 SUB.W #0x0006,SP0x869a: 40B1 000A 0000 MOV.W #0x000a,0x0000(SP)0x86a0: 40B1 0014 0002 MOV.W #0x0014,0x0002(SP)0x86a6: 40B1 001E 0004 MOV.W #0x001e,0x0004(SP)0x86ac: 52A1 0000 ADD.W #4,0x0000(SP)0x86b0: 411F 0002 MOV.W 0x0002(SP),R150x86b4: 512F ADD.W @SP,R150x86b6: 811F 0004 SUB.W 0x0004(SP),R150x86ba: 4F81 0002 MOV.W R15,0x0002(SP)0x86be: 5031 0006 ADD.W #0x0006,SP
SP
Stack
x0600x05fex05fcx05fax05f8x05f6
0x0014 (y)0x001e (z)
Compilation Examples
SP
0x000e (x)
C to Assembly – Example 2
BYU CS 224 The C Language 39
int main(int argc, char** argv){
unsigned int x = 7;unsigned int y = 5;unsigned int z;
z = x * y;return 0;
}
main:0x8040: 8031 000A SUB.W #0x000a,SP0x8044: 4D81 0002 MOV.W R13,0x0002(SP)0x8048: 4C81 0000 MOV.W R12,0x0000(SP)0x804c: 40B1 0007 0004 MOV.W #0x0007,0x0004(SP)0x8052: 40B1 0005 0006 MOV.W #0x0005,0x0006(SP)0x8058: 411C 0004 MOV.W 0x0004(SP),R120x805c: 411D 0006 MOV.W 0x0006(SP),R130x8060: 12B0 80DA CALL #__mpyi0x8064: 4C81 0008 MOV.W R12,0x0008(SP)0x8068: 430C CLR.W R120x806a: 5031 000A ADD.W #0x000a,SP0x806e: 4130 RET
__mpyi:0x80da: 430E CLR.W R14 mpyi_add_loop:0x80dc: C312 CLRC0x80de: 100C RRC R120x80e0: 2801 JLO (shift_test_mpyi)0x80e2: 5D0E ADD.W R13,R14 shift_test_mpyi:0x80e4: 5D0D RLA.W R130x80e6: 930C TST.W R120x80e8: 23F9 JNE (mpyi_add_loop)0x80ea: 4E0C MOV.W R14,R120x80ec: 4130 RET
SP
Stack
x0600x05fex05fcx05fa
x05f4
x05f8x05f6
ret adr
argc (r12)argv (r13)
z0x0005 (y)0x0007 (x)
Compilation Examples
SP
C to Assembly– Example 3
BYU CS 224 The C Language 40
main: SUB.W #0x0006,SP MOV.W 0x0002(SP),R15 ADD.W &inGlobal,R15 ADD.W 0x0004(SP),R15 MOV.W R15,0x0000(SP) ADD.W #0x0006,SP RET
Identifier Type Storage Class Offset Scope
inGlobal int Static absolute global
inLocalA int Auto 2(SP) main
inLocalB int Auto 4(SP) main
outLocal int Auto 0(SP) main
SymbolTable
int inGlobal;void main(void){ int outLocal; int inLocalA; int inLocalB; outLocal = inGobal + inLocalA + inLocalB; return;}
Compilation Examples
Quiz 7.4
Fill in the resulting values for x, y, and z after evaluating the construct. Assume for each row, x, y, and z are initialized to 10, 20, and 30 respectively.
BYU CS 224 The C Language 41
x=10 y=20 z=30
1) if (x = y) y = 100;
2) if (x < 10) y = 1;else if (x < 20) y = 5;else if (x < 30) y = 10;
3) switch ('a') { case 'a': y++; z *= 5; case 'b': --y; z /= 10;}
4) for (x=1; x<y; x++, y--) z = x + y;
5) while (!z) { z %= y;}
6) do { x = --y; z = x++;}while (z);
BYU CS 224 The C Language 43
C I/O
I/O facilities are not part of the C language itself Nonetheless, programs do interact with their environment!
Most digital I/O handled directly by C program #include "msp430.h" SPR’s, Ports, A/D, transponder, switches, LED’s, etc
The ANSI standard defines a 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
#include <stdio.h> (C standard library) #include "RBX430_lcd.h"
C Stream I/O
BYU CS 224 The C Language 44
C Data Streams
C I/O is character based, using streams. I/O streams must be opened / closed. In standard C there are 3 streams automatically opened before
main() is called: stdin is the input stream stdout is the output stream stderr stream for error messages
printf function outputs formatted values to stdout stream The printf function requires a format string followed by optional
parameters:
printf( "format string...", parameters... ); The format string contains two object types:
Ordinary characters that are copied to the output stream Conversion specifications which cause conversion and printing of the
next argument in the argument list.
C Stream I/O
BYU CS 224 The C Language 45
Printf Output in C
printf( format_string, parameters )
printf("Hello 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 11In hex it is bHello, I am Bambi.In ascii, 65 is A.
String literal
DecimalInteger
HexInteger
StringCharacterNewline
C Stream I/O
BYU CS 224 The C Language 46
RBX430_lcd.h Prototypes uint8 lcd_init(void); void lcd_clear(void); void lcd_backlight(uint8 backlight); void lcd_volume(uint8 volume); uint16 lcd_mode(int16 mode); uint8 lcd_cursor(uint16 x, uint16 y); uint16 lcd_printf(const char* fmt, ...); uint8 lcd_image(const uint8* image, int16 x, int16 y); uint8 lcd_bitImage(const uint8* image,
int16 x, int16 y, uint8 flag); uint8 lcd_wordImage(const uint16* image,
int16 x, int16 y, uint8 flag); uint8 lcd_blank(int16 x, int16 y, uint16 w, uint16 h); uint8 lcd_point(int16 x, int16 y, uint8 flag); void lcd_circle(int16 x, int16 y, uint16 r, uint8 pen); void lcd_rectangle(int16 x, int16 y,
uint16 w, uint16 h, uint8 pen);
LCD I/O
BYU CS 224 The C Language 47
LCD – 160 x 160 x 5 PixelsY
(0-1
59)
Hello World!
lcd_init();lcd_clear();// 5 x 8 pixel Characterslcd_cursor(40, 60);lcd_printf("Hello World!");
X (0-159)
LCD I/O