1. 1 Motorola HC-11 Microcontrollers and Embedded Systems

2. 2 A microprocessorA microprocessor –Usually not cutting edge –Dependable All major bugs well knownAll major bugs well known –Predictable Critical for real-time processingCritical for real-time processing On-chip peripherals and memoryOn-chip peripherals and memory –Parallel and serial digital I/O –Analog I/O –Counters and timers Internal ROM and/or EPROMInternal ROM and/or EPROM What is a microcontroller?

3. 3 What are microcontrollers used in? Watches Watches Microwaves Microwaves Stereo Receivers Stereo Receivers Some products that you might know: NASA’s Sojourner Rover – 8-bit Intel 80C85 NASA’s Sojourner Rover – 8-bit Intel 80C85 Palm Vx handheld – 32-bit Motorola Dragonball EZ Palm Vx handheld – 32-bit Motorola Dragonball EZ Sonicare toothbrush – 8-bit Zilog Z8 Sonicare toothbrush – 8-bit Zilog Z8 The Vendo V-MAX 720 Soda Machine – Motorola HC11 The Vendo V-MAX 720 Soda Machine – Motorola HC11 Miele dishwasher – 8-bit Motorola 68HC05 Miele dishwasher – 8-bit Motorola 68HC05 Hunter 44550 Programmable Thermostat – (4-bit cpu) Hunter 44550 Programmable Thermostat – (4-bit cpu) Microcontrollers ATMs ATMs PDA’s, MP3 players PDA’s, MP3 players Automobiles Automobiles

4. 4 Microcontrollers Microcontroller unit sales are 15x higher than microprocessors. … and are MUCH, MUCH cheaper.

5. 5 Microcontrollers Microcontroller Markets Microcontrollers are a large marketMicrocontrollers are a large market 8-bit controllers are the largest, but not growing the fastest.8-bit controllers are the largest, but not growing the fastest.

6. 6 Microcontrollers 8-bit microcontroller growth rate for 2003 is at 9.42%.8-bit microcontroller growth rate for 2003 is at 9.42%. Microcontroller growth rate in general is 11.5%.Microcontroller growth rate in general is 11.5%. 8-bit controllers loosing market share in 2003. Was 62.36% in 1998 down to 56.76% in 2003.8-bit controllers loosing market share in 2003. Was 62.36% in 1998 down to 56.76% in 2003. Source: Cahners In-Stat Group

7. 7 16- and 32-bit and higher are on the rise. They will double their unit market share from 15.11% in 1998 up to 31.56% in 2003, decreasing 4-bit and 8-bit devices.16- and 32-bit and higher are on the rise. They will double their unit market share from 15.11% in 1998 up to 31.56% in 2003, decreasing 4-bit and 8-bit devices. But, in 2003, the 8-bit microcontrollers will outnumber the higher bit units by almost 80% in the market place.But, in 2003, the 8-bit microcontrollers will outnumber the higher bit units by almost 80% in the market place. Source: Cahners In-Stat Group Microcontrollers

8. 8 Microcontrollers So what languages are they being programmed in? Language‘98-’99‘99-’00 Assembly ~ 21% ~ 10% C ~ 69% ~ 80% C++ ~ 5% ~ 6% Java ~ 1 % ~ 2% Other ~ 3 % ~ 2% Source: TRON Association Survey 1998/99 & 1999/2000

9. 9 Motorola M68HC11 Motorola M68HC11 M6801 CPU coreM6801 CPU core ROM (8KB), EEPROM (512B), RAM (256B)ROM (8KB), EEPROM (512B), RAM (256B) –Counter/Timer system –A/D converter D/A in kitD/A in kit Parallel I/OParallel I/O Serial I/O (SPI and SCI)Serial I/O (SPI and SCI) Expansion busExpansion bus –To add more memory

10. 10 HC11 Architecture HC11

11. 11 8-bit8-bit CISCCISC Accumulator-basedAccumulator-based Results wind up in a 8-bit accumulator A or BResults wind up in a 8-bit accumulator A or B 16-bit results go to accumulator AB, called D16-bit results go to accumulator AB, called D Two index registers for addressing memory or for counting - X and YTwo index registers for addressing memory or for counting - X and Y Dedicated stack pointerDedicated stack pointer Push and Pop instructions use this – grows toward smaller memory addresses like in LC-3Push and Pop instructions use this – grows toward smaller memory addresses like in LC-3 Program CounterProgram Counter Condition CodesCondition Codes M8601 CPU Core

12. 12 Check out the lab manual It is online on the class website It is online on the class website Contains a section on the HC11 Contains a section on the HC11 It is a great reference It is a great reference Also get the programmer reference guide, free at BELS (basement of BE)

13. 13 M8601 CPU Core ALU – Arithmetic Logic Unit

14. 14 HC11 Microcontroller

15. 15 More present then in LC-3 More present then in LC-3 Single-bit flags set appropriately for most instructions (several instructions do not, including push and pop) Single-bit flags set appropriately for most instructions (several instructions do not, including push and pop) C Carry/Borrow V Overflow ZZero NNegative HHalf-Carry HC11 Microcontroller Condition Codes

16. 16 HC11 code What it does cmpa #4 Subtract AccA - 4, set CCR bge mylabel Branch if (CCR[Z]=1 OR CCR[N]=0) Example of how condition codes are used HC11 Microcontroller

17. 17 HC11 Assembly Syntax Have separate sections for data declarations and for instructionsHave separate sections for data declarations and for instructions –Use “.sect.data” for data sections –Use “.sect.text” for instructions sections. Have more data typesHave more data types –“.space” for array declarations –“.byte” declares just a byte –“.word” declares 16-bits also –“.asciz” declares a string of characters –“.ascii” declares a string, no NULL terminator Comments use a “C++” style “//”Comments use a “C++” style “//”

18. 18 Data Declaration Examples.sect.data myvar:.word0x1000 // init a word myarray:.space 20 // 20 entries mychar:.byte ‘a’ // a character mybyte:.byte 23 // DEC integer myhi:.asciz “Hi” // a string myhi2:.ascii “Hi” // a string.sect.text // Instructions would start here. // Can have many.text and.data sections.

19. 19 Bits set by the user to tell the processor how to do things IInterrupt Mask XXIRQ mask SDisable STOP instructions HC11 Microcontroller Configuration Registers

20. 20 Return to Addressing Modes Addressing Modes: LC-3 has: PC-Relative PC-Relative Base Displacement Base Displacement Indirect Indirect HC11 has many: Check opcode listings to see what modes work with what instructions Check opcode listings to see what modes work with what instructions Also check what condition codes are set Also check what condition codes are set

21. 21 HC11 Addressing Modes Immediate (IMM)Immediate (IMM) Extended (EXT)Extended (EXT) Direct (DIR)Direct (DIR) Indexed (INDX and INDY)Indexed (INDX and INDY) Inherent (INH)Inherent (INH) Relative (REL)Relative (REL) Supports these addressing modes:

22. 22 Immediate addressing 1 or 2 byte immediate depending on register involved (LDAA vs. LDD)1 or 2 byte immediate depending on register involved (LDAA vs. LDD) ALWAYS include a #ALWAYS include a # Several formats for different bases -- C-styleSeveral formats for different bases -- C-style constants instead of what is in the HC11 manual (don’t use !,$,@,%) Decimal:LDAA #245Decimal:LDAA #245 Hexadecimal:LDAA #0x61Hexadecimal:LDAA #0x61 Octal: LDAA #041Octal: LDAA #041 Binary:LDAA #0b11000011Binary:LDAA #0b11000011 ASCII:LDAA #’a’ASCII:LDAA #’a’ HC11 Addressing Modes

23. 23 Extended and Direct addressing Access an absolute memory locationAccess an absolute memory location Essentially the same mode, but with 8-bit (direct) or 16-bit (enhanced or extended) addressesEssentially the same mode, but with 8-bit (direct) or 16-bit (enhanced or extended) addresses The assembler will decide on which to use based on how many bits are neededThe assembler will decide on which to use based on how many bits are needed ExampleExample // Your data starts at address 0x4000:.sect.data var:.word0x1000 // Allocate/initialize a word // Note: a word is 16 bits!.sect.text SUBDvar// Subtract [var] from D SUBD0x4000// Subtract [var] from D HC11 Addressing Modes

24. 24 Indexed addressing Uses index register X or YUses index register X or Y Similar to LC-3 “LDR R0, R2, #3”Similar to LC-3 “LDR R0, R2, #3” But can access memory and use it all at once!!But can access memory and use it all at once!! ExampleExample #definemydef4// c preprocessor used ldx#var// Like LC-3 load address addd0,X// add contents of M[0+X] to D // (Note “addd X” doesn’t work) addd2,X// add contents of M[2+X] to D adddmydef*2, X// add contents of M[8+X] to D HC11 Addressing Modes

25. 25 Inherent addressing Opcode fully specifies operation; no addressingOpcode fully specifies operation; no addressing Examples:Examples: INCB increment accumulator B ASLA Arithmetic Shift Left accumulator A PSHY Push index register Y onto stack HC11 Addressing Modes

26. 26 Relative addressing Used for branches by the assembler Used for branches by the assembler Offsets from –128 to +128 bytes Offsets from –128 to +128 bytes Use jumps for longer branches Use jumps for longer branches HC11 Addressing Modes

27. 27 HC11 Address Modes Review ldab #0// loads the number 0 into b ldaa foo// loads the contents of byte // variable foo into “a” acc. ldy #foo// loads the address of foo into y ldab 0, x// loads the byte at address x+0 // into “b” acc. ldx 0// loads whatever is at memory // address 0 into “x” index. // You don't want this in 12c ever.

28. 28 Motorola 68HC11 Instructions HC11 Instructions have variable lengthsHC11 Instructions have variable lengths –not like LC-3 Careful coding can keep applications small and able to fit in the EPROMCareful coding can keep applications small and able to fit in the EPROM We don’t have to worry about this since we’re using Expansion ModeWe don’t have to worry about this since we’re using Expansion Mode –there is extra memory in the microkits. The opcode is always 1 byteThe opcode is always 1 byte An additional 0-3 bytes specify the data to work withAn additional 0-3 bytes specify the data to work with

29. 29 Motorola 68HC11 Instruction Set Accumulator and Memory InstructionsAccumulator and Memory Instructions Stack and Index Register InstructionsStack and Index Register Instructions Condition Code Register InstructionsCondition Code Register Instructions Program Control InstructionsProgram Control Instructions

30. 30 Accumulator and Memory Instructions Can be broken up into these 6 general types: 1.Loads, stores, and transfers 2.Arithmetic operations 3.Multiply and divide 4.Logical operations 5.Data testing and bit manipulation 6.Shifts and rotates HC11 Instructions

31. 31 HC11 Instructions Almost all MCU activities involve transferring data from memories or peripherals into the CPU or transferring results from the CPU into memory or I/O devices.

32. 32 HC11 Instructions This group of instructions supports arithmetic operations on a variety of operands; 8- and 16- bit operations are supported directly and can easily be extended to support multiple- word operands. Twos- complement (signed) and binary (unsigned) operations are supported directly.

33. 33 HC11 Instructions Compare instructions perform a subtract within the CPU to update the condition code bits without altering either operand. Although test instructions are provided, they are seldom needed since almost all other operations automatically update the condition code bits.

34. 34 HC11 Instructions One multiply and two divide instructions are provided. The 8-bit by 8-bit multiply produces a 16-bit result. The integer divide (IDIV) performs a 16-bit by 16-bit divide, producing a 16-bit result and a 16-bit remainder. The fractional divide (FDIV) divides a 16-bit numerator by a larger 16-bit denominator, producing a 16-bit result (a binary weighted fraction between 0 and 0.99998) and a 16-bit remainder.

35. 35 HC11 Instructions This group of instructions is used to perform the Boolean logical operations AND, inclusive OR, exclusive OR, and one’s complement.

36. 36 HC11 Instructions This group of instructions is used to operate on operands as small as a single bit, but these instructions can also operate on any combination of bits within any 8-bit location in the 64-Kbyte memory space.

37. 37 HC11 Instructions All the shift and rotate functions in the M68HC11 CPU involve the carry bit in the CCR in addition to the 8- or 16-bit operand in the instruction, which permits easy extension to multiple-word operands.

38. 38 Stack and Index Register Instructions HC11 Instructions

39. 39 HC11 Instructions This table summarizes the instructions available for the 16-bit index registers (X and Y) and the 16-bit stack pointer.

40. 40 HC11 System Stack The HC11 has a stack set up for usThe HC11 has a stack set up for us Memory is “byte” addressableMemory is “byte” addressableExample: PSHA // pushes accumulator A onto stack // SP = SP – 1 since a byte size // SP = SP – 1 since a byte size PSHY // pushes index register Y onto stack // SP = SP – 2 since a word size // SP = SP – 2 since a word size PULA // Pops off a byte from the stack into A // SP = SP + 1 // SP = SP + 1 PULY // Pops off a word from the stack into Y // SP = SP + 2 // SP = SP + 2

41. 41 HC11 Instructions Condition Code Register Instructions These instructions allow a programmer to manipulate bits of the CCR.

42. 42 Program Control Instructions 1. Branches 2. Jumps 3. Subroutine calls and returns 4. Interrupt handling 5. Miscellaneous HC11 Instructions

43. 43 These instructions allow the CPU to make decisions based on the contents of the condition code bits. All decision blocks in a flow chart would correspond to one of the conditional branch instructions summarized here HC11 Instructions

44. 44 HC11 Instructions The jump instruction allows control to be passed to any address in the 64-Kbyte memory map.

45. 45 HC11 Instructions These instructions provide an easy way to divide a programming task into manageable blocks called subroutines. The CPU automates the process of remembering the address in the main program where processing should resume after the subroutine is finished. This address is automatically pushed onto the stack when the subroutine is called and is pulled off the stack during the RTS instruction that ends the subroutine

46. 46 This group of instructions is related to interrupt operations, we will get to there use later. HC11 Instructions

47. 47 NOP is a do nothing instruction, just wastes an instruction cycle. STOP is used to put the CPU into a low power mode. TEST is a reserved instruction only used at the factory when making the chips. HC11 Instructions

48. 48 “C” Conversions “C” Addition c = x + y // Character variables ldab x addb y stab c HC11 Assembly // Integer variables ldd x addd y std c

49. 49 “C” Conversions HC11 Assembly // c goes in double acc // x, y are the index regs pshxxgdxpshytsx addd 0,x pulypulx HC11 Assembly // Using character registers // acc a = x, acc b = y. aba “C” Addition c = x + y “C” Addition x = x + y

50. 50 “C” Multiplication // c = short variable // a, b = char variables c = a * b HC11 Assembly ldaa a ldab b mul std c “C” Conversions

51. 51 “C” if statement: if(a > 10) y++; “HC11” Assembly: cmpa #10 ble endif iny endif: “C” Conversions

52. 52 “C” Conversions “C” if/else statement: char a; short y; if(a > 10) y++; else y--; “HC11” Assembly: cmpa #10 bgt if dey bra endif if:iny endif:

53. 53 “C” Conversions “C” if/else statement: char foo; short qux; if(foo > 10) qux++; else qux--; “HC11” Assembly: ldaa foo cmpa #10 bgt if ldy qux dey sty qux bra endif if:ldy qux iny sty qux endif:

54. 54 “C” Conversions “C” while statement: char a, b; while(a > 20) { a--; b *= 3; } “HC11” Assembly: while: cmpa #20 ble endwhile decapsha ldaa #3 mulpula bra while endwhile:

55. 55 “C” if/else statement: char foo; short qux; if(foo > 10) qux++; else qux--; “HC11” Assembly: ldaa foo cmpa #10 bgt if ldy qux iny sty qux bra endif if:ldy qux iny sty qux endif: “C” Conversions

56. 56 “C” do/while statement: int foo, bar, qux; do { foo -= 3; bar += qux; } while (foo > 7) “HC11” Assembly: do: ldd foo subd #3 std foo ldd bar addd qux std bar ldd foo cpd #7 bgt do “C” Conversions

57. 57 Summing the first 10 elements of an integer array, result in index register X: array:.space 20 ldx #0 ldab #0 while: cmpb #18 bgt endwhile ldy #array aby xgdx addd 0,y xgdxincbincb bra while endwhile: HC11 Example

58. 58 HC11 Example /*********************************************************** *Program 1. *Program 1. * A simple program to introduce the 68HC11 environment ***********************************************************/ * A simple program to introduce the 68HC11 environment ***********************************************************/ #include // sets stuff up for you, especially I/O.sect.data SIGNON:.asciz“CMPE12C Simulator” PROMPT:.asciz“>” // (continued…)

59. 59 HC11 Example Continued /************************************************************* * Your program starts where indicated by the label “main”. After startup * Code in v2_18g3.asm is done, it jumps to this label and continues running. **************************************************************/.sect.text main: ldx#SIGNON jsrOUTSTRING loop:ldx#PROMPT// address of prompt jsrOUTSTRING// write out to serial communications // interface (to PC) jsrGETCHAR// get a character from SCI, returns in A jsrOUTCHAR// write A to the SCI jsrOUTCRLF// write CR/LF to SCI jmploop

60. 60 Design environment:Design environment: –Edit & assemble on CATS machines –> hc11build file.asm Download program to the PCDownload program to the PC Upload to the microkit using serial cableUpload to the microkit using serial cable To use kits at homeTo use kits at home –9-12V AC adapter –Serial download cable Connection to CATS machinesConnection to CATS machines Free serial communication software (e.g. TeraTerm)Free serial communication software (e.g. TeraTerm) HC11 Micro Kit Usage

61. 61 Micro Kit Usage Always #include as part of your program Sets up memory, including stack pointer Sets up memory, including stack pointer Jumps to your “main” label Jumps to your “main” label Also includes a basic library of I/O routines Also includes a basic library of I/O routines Take a look at it! Take a look at it! http://www.soe.ucsc.edu/classes/cmpe012/Winter05/ http://www.soe.ucsc.edu/classes/cmpe012/Winter05/http://www.soe.ucsc.edu/classes/cmpe012/Winter05/ In the handouts and links page under HC11 Stuff

62. 62 Example recursive routine Fibonacci on the switches and LEDs /* Input: A. Returns A’th Fibonacci term in accumulator A */ fib:cmpa#2 bgtfibnot1 ldaa#1// return 1 if n <= 2 rts fibnot1:pshb// caller save protocol deca psha// save n-1 deca// call with n-2 jsrfib tab// transfer F(n-2) to b pula// a gets n-1 jsrfib aba// add accumulators pulb// restore B rts main:ldx#SWITCHES ldaa0,X jsrfib ldx#LEDS staa0,x jmpmain

63. 63 Microcontrollers are great little processors for I/O and data manipulationMicrocontrollers are great little processors for I/O and data manipulation The CISC-style programming makes assembly programming easierThe CISC-style programming makes assembly programming easier Variable instruction length can be a problem forVariable instruction length can be a problem for –Word-aligned machines –Super-scalar machines –Pipelines The RISC philosophy is toThe RISC philosophy is to –Use simple instructions and let the compiler optimize –Use loads and stores to support higher-speed registers Neither RISC, its CISC predecessors, nor CISCY RISCY has the definitive advantageNeither RISC, its CISC predecessors, nor CISCY RISCY has the definitive advantage –Depends on application, architecture, and implementation. Microcontroller/HC11 Summary

64. 64 Questions?

65. 65