EEE111A/B Microprocessors

Transcription

1 EEE111A/B Microprocessors Lecture 10: C for Microcontroller Programmers 1 Objectives To understand the differences between a high-level language and assembly language. To review the elements of programming in C. To be able to write simple routines in C to run on a PIC Microcontroller. 2 Revision In Lecture 9 we described the need to be able to write to or read from an external peripheral using built-in parallel ports. In more detail: The PIC16F84 has two integral parallel ports which connect to the external world via pins on the IC. Port A has five bits connected to pins RA4 RA0 corresponding to bits 5 through 0 of File 05. Port B has eight bits connected to pins RB7 RB0 corresponding to bits 7 through 0 of File 06. Any pin can be set up in software to be either an input (can be read by software as the corresponding bit in the port) or an output (can be twiddled by changing the corresponding bit in the port). Each port has a shadow Data Direction register in Bank 1, called a TRIS register. Each bit in a TRIS register controls the configuration of it s corresponding pin, with a 0 for Output and 1 for Input. TRISA is located at File h 85 in Bank 1 and controls the function of pins RA4 RA0. TRISB is located at File h 86 in Bank 1 and controls the function of pins RB7 RB0. For example to make pin RA0 an output and the rest of the Port A pins to be an input, we have: bsf STATUS,RP0 ; Switch to Bank1 movlw b ; Bit settings for RA0 to be Output movwf TRISA ; Copy to Direction A register bcf STATUS,RP0 ; Back to Bank0 1

2 Where a pin is configured as an input, you can read if its state is low (logic 0) or high (logic 1) by checking the corresponding bit in the appropriate port. For example: CHECK btfss PORTA,4 ; Check thestateof pin RA4. IF set THEN skip goto CHECK ; ELSE go to CHECK Where a pin is configured as an output, you can write to it making it low (logic 0) or high (logic 1) by clearing or setting the corresponding bit in the appropriate port. For example: PULSE bsf PORTA,0 ; Bring pin RA0 high. bcf PORTA,0 ; Bring pin RA0 low. goto PULSE ; and repeat forever! 3 High Level Languages All the programs we have written up to the moment have been in the natural language of the machine itself; in this case of the mid-range PIC family. Whilst assembly-level software is a quantum step up from pure binary machine-level code nevertheless there is still a oneto-one relationship between machine and assembly-level instructions. This means that the programmer is forced to think in terms of the computing machine s internal structure that is of registers and memory rather than in terms of the problem itself. What is this difficulty with machine-oriented language? In order to improve the effectiveness, quality and reusability of a program, the coding language should be independent of the underlying processor s architecture and should have a syntax more oriented to problem-solving. The difficulty in coding large programs in a computer s native language was clearly appreciated within a few years of the introduction of commercial systems. Apart from anything else, computers quickly became obsolete with monotonous regularity, and programs needed to be rewritten for each model introduction. Large applications programs, even at that time, required many thousands of lines of code. Programmers were as rare as hen s teeth and worth their weight in gold. It was quickly deduced that for computers to be a commercial success, a means had to be found to preserve the investment in scarce programmers time. In developing a universal language, independent of the host hardware, the opportunity would be taken to allow the programmer to express the code in a more natural syntax related to problem-solving rather than in terms of memory, registers and flags. Of course there are many different classes of problem tasks which have to be coded, so a large number of languages have been developed since. 1 Amongst the first were Fortran (FORmula TRANslation) and COBOL (COmmon Business Oriented Language) in the early 1950s. 1 A popular definition of a computer scientist is one who, when presented with a problem to solve, invents a new language instead! 2

3 The former has a syntax that is oriented to scientific problems and the latter to business applications. Despite being around for over 40 years, the inertia of the many millions of lines of code written has made sure that many applications are still written in these antique languages. Other popular languages include Algol (ALGOrithmic Language), BASIC, Pascal, Modula, Ada, C, C++ and Java. Although writing programs in a high-level language may be easier and more productive for the programmer, the process of translation from the high-level source code to the target machine code is much more complex than the assembly process you have used in the laboratory and we covered in Lecture 4 Figure 8 of which is reproduced below as Fig. 1 on page 12. The translation package for this a high-level language is called a compiler and the process compilation. This means that your computer doing this translation process needs to be more powerful and the compiler software will, obviously, cost more! Figure 2 on page 12 shows the process in a somewhat simplified manner. With today s powerful personal computers, the problem of computing resources is not an issue anymore; but the cost of compilers may be. Typically a compiler running on a PC which will convert to PIC code costs between 100 up to 1,500 although this may include other debugging tools. The choice of a high-level language for embedded targets is crucial. Of major importance is the size of the machine code generated by a high-level language task implementation as compared with the equivalent assembly-level solution. Most embedded MCU circuitry is lean and mean, such as the code in the MCU in your smart card. Lean translates to physically small and mean maps to low processing power and memory capacity and cost! Most low-cost MCUs have a low-capability processor with a few hundred bytes of RAM and a few kilobytes of ROM Program store at best. Thus to be of any use the high-level language and the compiler must generate code that, if not as efficient as assembly-level (low-level), at least is in the same ball park. By far the most common high-level language used to source code for embedded micro circuitry is C. Historically C was developed as a language for writing operating systems. At its simplest level, an operating system (OS) is a program which makes the detailed hardware operation of the computer s terminals, such as keyboard and disk organisation, invisible to the operator. As such, the writer of an OS must be able to poke about the various registers and memory of the computer s peripherals and easily integrate with assembly-level driver routines. As conventional high-level languages and their compilers were profligate with resources, depending on a rich and fast environment, assembly language was mandatory up to the early 1970s, giving intimate machine contact and tight fast code. However, the sheer size of such a project means that it is likely to be a team effort, with all the difficulties in integrating the code and foibles of several people. A great deal of self-discipline and skill is demanded of such personnel, as is attention to documentation. Even with all this, the final result cannot be easily transplanted to machines with other processors, needing a nearly complete rewrite. Apart from its use as the language of choice for embedded micro circuits, C (together with its C++ and Java object-oriented offspring) is without doubt the most popular generalpurpose programming language at the time of writing. It has been called by its detractors a high-level assembler. However, this closeness of C to assembly-level code, together with the ability to mix code based on both levels in the one program, is of particular benefit for 3

4 embedded targets. The main advantages of the use of high-level language as source code for embedded targets are: It is more productive, in the sense that it takes around the same time to write, test and debug a line of code irrespective of language. By definition, a line of high-level code is equivalent to several lines of assembly code. Syntax is more oriented to human problem-solving. This improves productivity and accuracy, and makes the code easier to document, debug, maintain and adapt to changing circumstances. Programs are easier to port to different hardware platforms, although they are rarely 100% portable. Thus they are likely to have a longer productive life, being relatively immune to hardware developments. As such code is relatively hardware-independent, the customer base is considerably larger. This gives an economic impetus to produce extensive support libraries of standard functions, such as mathematical and communication modules, which can be reused in many projects. Of course there are disadvantages as well, specifically when code is being produced to run in poorly resourced micro-based circuitry. The code produced is less space-efficient and often runs more slowly than native assembly code. The compiler is much more expensive than an assembler. A professional product will often cost several thousand. Debugging can be difficult, as the actual code executed by the target processor is the generated assembler code. The processor does not execute high-level code directly. Products that facilitate high-level debugging are, again, very expensive. The majority of code now written for micros is now written in C or in a mixture of C and assembler languages. No matter what high-level language we use, the road from human thought to the summit of binary code that the machine can understand is shown in a rather diagrammatic form in Fig. 3 on page Human thought analyses the problem and devises a process to solve the problem; that is an algorithm. 2. Algorithm is converted to high-level language and typed in as source code. 3. A compiler is used to translate from high-level source syntax to low-level assembler syntax. 4. Assembler code is then added to other material, such as mathematics libraries, to give the machine code which the hardware will execute. 4

5 4 The C Language PIC Enhanced C compilers for micros usually use the standard C language, but with additions to make more easy use of the features that micros have; such as port pins. These additions also try and make the nasty realities of the hardware, such as bank switching and configuring pins, either invisible or at least easy to use. Any PIC-specific syntax below is that of the CCS compiler 2 which you will be using next year. This is not the place to learn a new language; you all are doing/have done an introductory module in C, so here we will just look at the very bare bones of the language. 4.1 Program Structure A typical skeleton structure of a C program looks like table 1. #include <header> /* Header files typically gives some info on library functions */ #byte /* Tell the compiler the location of a special purpose register */ #bit /* Givea bit in a Filea name */ function declarations;/* Any function besides main() should be named here with details */ global variables; /* Variables defined here are known throughout the program */ main() /* All C programs must havea main function */ /* Begin */ local variables /* Variables defined here are known only inside main() */ setup-up PIC ports /* For example, configure the port pins */ do this; /* Various statements */ call that; /* and interspaced with calls to other functions */ do the other; /* More statements */ etc; /* End */ /* Secondary functions. Any other functions are defined here */ function1() /* They havethesamestructureas main() and can becalled from */ /* main() or from other functions */ local variables; /* Variables defined here are known only inside function1() */ do this; call that; etc; function2() Local variables; /* Variables defined here are known only inside function2() */ do this; call that; etc; Table 1: Program structure. 2 Go to for more details. 5

6 #include This is a directive which allows the programmer to include header files, which typically give the compiler some information regarding library functions, such as the input/output (e.g. printf(), scanf()). In the case of the CCS PIC compiler, headers are used to give the compiler some information regarding the type of PIC; e.g. #include<16f84.h>. #byte A directive peculiar to the CCS compiler allowing the programmer to give a fixed File location a name; e.g. #byte FUEL = 6 /* Fuel is read at File 06; i.e. Port B */ where the /* bla bla */ pair is used by C to denote a comment. #bit A directive peculiar to the CCS compiler allowing the programmer to give a specified bit in any File location a name; e.g. #bit RED_LED = 5.0 /* TheRed LED is bit0 of File05 (or Port A) */ Global Variables Variables are defined as either integral (whole numbers) or floating-point (fractional-numbers). The former are of more use with microcontrollers and come in short, long, signed and unsigned varieties. If variables are named and defined in the preamble, then they are known everywhere in the program. Function Declarations Any user function, besides main() should be named in the preamble giving the type of variables being passed to the function and the type being returned. For example: /* count_of_ones is a function expecting a long int and returning an int */ int count_of_ones(long int); Main function All C programs have a main() function. Local Variables Variables used in a function should normally be defined at the beginning, before any executable code. Such variables will only be known inside the function. Executable Code After local variable definitions the body of a function consists of statements and calls to other functions. Secondary Functions Any functions besides the obligatory main() function are defined outside the main() function. They have the same structure as main() and can be called from main() or from themselves. Any local variables defined inside these secondary functions are known only within the function itself. 6

7 4.2 Selection Structures A selection structure is a way to make a decision. For example to increment a variable called number1 provided it is less than six or else to zero it, we have: if(number1 >= 5) number1 = 0; else number1++; where we are using the if-else structure to do the first statement if the outcome in the brackets following the if operator is true. The optional else gives a default action if the outcome is false. There doesn t have to be an if outcome. Note the use of the >= operator to denote Greater Than or Equivalent. Similar operators are == for Equivalent,!= for Not Equivalent, > for Greater Than, <= for Less Than or Equivalent and < for plain Less Than. Note that statements always are terminated with a semicolon ;. Actions can be compound statements with multiple statements enclosed in parenthesis; for example: if(fuel < 20) alarm = 0; lamp = 1; Multiple decisions can be made using a series of if-else-if tests. For example: if(fuel > 20) GREEN_LED = 1; RED_LED = 0; AMBER_LED = 0; BUZZER = 0; else if((fuel < 20) && (fuel >= 14)) GREEN_LED = 0; RED_LED = 0; AMBER_LED = 1; BUZZER = 0; else if((fuel < 15) && (fuel >= 8)) GREEN_LED = 0; RED_LED = 1; AMBER_LED = 0; BUZZER = 0; else GREEN_LED = 0; RED_LED = 1; AMBER_LED = 0; BUZZER = 1; As soon as a true test outcome is found, the adjacent statement is executed and the program jumps out of the if-else chain. In our example, if nothing is true the final else is executed. 7

8 4.3 LoopConstructions while The while loop structure is the fundamental method used to create a loop to do something a number of times, or even forever. For example find the integer square of a variable called number we have: i = 1; /* i is a number that is going to increment each loop pass*/ while(i < number) number = number - i; i = i + 2; root = i» 1;/* Notetheuseof» 1 to shift right once*/ where the program loops inside the Begin and End parenthesis until the test i < number fails. Execution then jumps to the first statement after the End parenthesis. Note that you can use the instruction break to prematurely jump completely out of the loop before time and the instruction continue to stop processing inside the loop and return to the top do-while This is similar to a plain while but the loop test for exit is done at the end of the loop. This means that the code inside the loop will always be executed at least once. For example: #bit RA0 = 5.0 /* Definepin RA0 as bit0 of File5 */ #bit RB7 = 6.7 /* Definepin RB7 as bit7 of File6 */ do RA0 = 1; /* Bring pin RA0 high */ RA0 = 0; /* Bring pin RA0 low */ while(rb7 == 1); /* as long as pin RB7 is high */ will keep pulsing pin RA0 as long as pin RB7 remains high. But even if pin RB7 is low, one pulse will be generated for The for loop constructor is really an enhanced while loop, which allows an initialisation on entry and an action at the end of each loop. For example to repeat the while example above: 8

9 for(i = 1; i < number; i = i + 2) number = number - i; root = i» 1 5 Examples 5.1 Example 1 To repeat Example 2 from Lecture 9 continually pulsing pin RB7 high and low every 6 µs. /* Preamble */ #include <16f84.h> /* Tell compiler to generate code for PIC16F84 */ #use delay(clock = ) /* Tell compiler clock is 4 MHz for delay functions*/ /* Main function */ main() set_tris_b(0x7f); /* Built-in function to set up TRIS regs. 0x7F = b */ while(true) /* Goes forever as TRUE is always TRUE */ output_high(pin_b7); /* Built-in function to bring a named pin high */ delay_us(3); /* Built-in function to delay microseconds */ output_low(pin_b7); /* Built-in function to bring a named pin low */ delay_us(3); Note the use of the built-in function set_tris_x() (known through the library header 16f84.h) to set up the TRISB register appropriately. The standard C prefix 0x denotes hexadecimal. Also there are a range of delay functions available to the programmer to give a fixed number of instructions (delay_cycles(n)), or number of milliseconds (delay_ms(n)) with n up to 65,535. Thus delay_ms(1000) will give a delay of a second. Also the built-in functions output_high(pin) and output_low(pin) know pins by their name. There is also an input(pin) function. Actually the program above is not very accurate, as the delay of the output_low(pin) and output_high(pin) functions take some time to execute. 5.2 Example 2 Repeat Example 4 of Lecture 9 to monitor the petrol reserve with a dashboard display. 9

10 #include<16f84.h> #byte FUEL = 06 /* Read Fuel at Port B (File 6) */ #bit RED_LED = 5.0 /* The Red LED is connected to bit0 of Port A (RA0) */ #bit GREEN_LED = 5.1 /* The Green LED is connected to bit1 of Port A (RA1) */ #bit BUZZER = 5.2 /* The Buzzer is connected to bit2 of Port A (RA2) */ main() set_tris_a(0xf8); /* b sets bottom 3 pins of Port A as Outputs*/ if(fuel > 10) GREEN_LED = 1; BUZZER = 0; RED_LED = 0; else if(fuel > 5) GREEN_LED = 0; BUZZER = 0; RED_LED = 1; else GREEN_LED = 0; BUZZER = 1; RED_LED = 0; The program says it all. In fact self documentation is one of the more important advantages of using a high-level language. Self Assessment Questions 1. Alter Example 1 to give a nominal 1 khz pulse rate. How would you alter your program if the clock rate were 20 MHz? 2. Based on the above, add code that will only commence this pulsing if the state of Port B is above decimal Modify Example 2 above with an Amber LED connected to pin RA3. This Amber LED is to light if the Fuel level is between 8 and 10 litres. 4. A digitally controlled oscillator is to be based on a PIC16F84 microcontroller. The period of the pulse from pin RA0 is to be in multiples of 100 µs, proportional to the reading from Port B. Thus, for example, if the Port B reading is 05 then the total period is to be 500 µs. Assume that the crystal clock is 20 MHz. 10

11 6 Key Concepts Assembly language C language A symbolic representation with a one-to-relationship to machine code. High-level language Machine code L A T E X2ε eee111_10.tex Version S.J. Katzen April 10,

12 Source code Assembler Machine code incf COUNT,f movf COUNT,w addlw 6 btfsc STATUS,DC movwf COUNT Translate return Figure 1: Conversion from assembly-level source code to machine code. while(n>0) sum = sum + n; --n; (a) First, compile to assembly-level code. Compile L28 movf _n,f btfsc STATUS,Z goto L41 movf _n,f addwf _sum,f btfsc STATUS,C incf _sum+1,f decf _n,f goto L28 L41 L28 movf _n,f btfsc STATUS,Z goto L Assemble movf _n,f addwf _sum,f btfsc STATUS,C incf _sum+1,f decf _n,f goto L L (b) Second, assemble-link to machine code. Figure 2: Conversion from high-level C source code to machine code. 12

13 Figure 3: Onion skin view of the steps leading to an executable program. 13