Mikrovezérlők Alkalmazástechnikája

Átírás

1 Gingl Zoltán, 2015, Szeged Mikrovezérlők Alkalmazástechnikája 1

2 Intel MCS-51 utasításkészlettel kompatibilis Módosított 8051 mag: CIP órajel/gépi ciklus 1 órajel/gépi ciklus 12MHz akár 100MHz on-chip debug alacsony fogyasztású módok sokkal több megszakítás sokkal több periféria sokkal jobb perifériák valódi önálló számítógép 2

3 3

4 Tápfeszültség: 2V..5V Tápszűrés: kondenzátorok Programozó/debug csatlakozó A RESET vonalon opcionális R 4

5 PSW ALU TMP1 TMP2 ACC RAM ADDRESS RAM PROGRAM ADDRESS REGISTER DATA POINTER PROGRAM COUNTER PC INCREMENTER BUFFER FLASH/PGM MEMORY STACK POINTER INTERRUPT CONTROLLER MEMORY INTERFACE SFR INTERFACE INTERNAL BUS INSTRUCTION REGISTER I/O PORTS PERIPHERALS 5

6 Registers Reset value A, ACC accumulator, ALU results 0 B general purpose register and register for multiplication, division 0 R0..R7 general purpose registers, also used for indirect addressing 0 PSW Bit 7: CY carry bit (ADDC, SUBB) 0 Bit 6: AC aux carry (at 3rd bit, 4-bit arithmetics) 0 Bit 5: F0 user flag 0 Bit 4: RS1 R0..R7 at R0..R7 at R0..R7 at R0..R7 at 0 Bit 3: RS0 00: 0x00 01: 0x08 10: 0x10 11: 0x18 0 Bit 2: OV overflow (MUL, DIV, ADD, SUBB) 0 Bit 1: F1 user flag 0 Bit 0: PAR parity bit: 1, if sum of bits in A is 1 0 DPH, DPL DPTR, data pointer, 16-bit indirect addressing 0 SP stack pointer 7 6

7 Harvard architektúra külön adat- és programmemória a programmemória nem írható a programmemória adatokat is tárolhat (csak olvasás) Adatamemória: RAM, XRAM Programmemória: flash Silicon Laboratories módosítás a programmemória (flash) speciális módban írható 7

8 Felső 128 byte Csak indirekt címzéssel MOV R0, #0B0h MOV Alsó 128 byte Direkt/indirekt címzéssel MOV A, 10 MOV A, 71h MOV 0B0h, a 0x80 0x00 0x80-0xFF 0x00-0x7F 8

9 0x20-0x2F 128 bit egyedileg elérhető Bitváltozók számára MOV C,22.3h carry a 22h című byte 3. bitje 0x30-0x7F 0x00-0x1F Az R0..R7 regiszterbank helye változtatható (PSW: RS1,RS0) Figyelembe kell vennünk a programozásnál Hasznos a regiszterek tartalmának őrzéséhez Tipikusan interrupt rutinokban BIT ADDRESSABLE RS1,RS0=11 RS1,RS0=10 RS1,RS0=01 RS1,RS0=00 0x20-0x2F 0x18-0x1F 0x10-0x17 0x08-0x0F 0x00-0x07 9

10 RESET után: a veremmutató értéke 0x07 R0..R7: 0x00-0x07 A veremmutató növekszik, ha használjuk A veremmutató átmehet a felső 128 byte-ra is! Szokásos stílus: boot után SP=adatok utáni cím A verem méretét a programozó dönti el! (?)-0xFF general RAM 0x08-(?) stack (after RESET) 0x00-0x07 R0..R7 10

11 Az integrált perifáriák, regiszterek elérése: memory mapping memória írás/olvasás műveletekkel direkt címzés a 0x80-0xFF belső RAM területen ADD A,240 ; B regiszter SFR elérése MOV A,PSW ; Az ACC, B, DPH, DPL, SP regiszterek is elérhetők 11

12 Address xB8 IP 0xB0 0xA8 IE 0xA0 P2 0x98 SCON SBUF 0x90 P1 0x88 TCON TMOD TL0 TH0 TL1 TH1 0x80 P0 SP DPL DPH Column 0 is bit addressable 12

13 Cím xF8 0xF0 B 0xE8 0xE0 ACC 0xD8 0xD0 PSW 0xC8 0xC0 Az 0. oszlop bitcímezhető 13

14 16-bit címtartomány maximum 64kbyte eredeti 8051: XRAM külön chipen mai 8051 architektúrákon: integrált (512 byte-8kbyte) integrált+külső Elérés: movx (indirekt) 16-bites cím MOV MOVX 8-bites cím MOV MOVX DPTR,#0A000H R0,#10H felső 8-bit egy SFR-ben (pl. EMI0CN) 14

15 Külön chip-en van a RAM SRAM áramkörök csatlakoztathatók Lehet sebességkorlát (pl. 100ns elérési idő) Lehet akár külső periféria is, ami SRAM-szerű: ADC, DAC, UART, Később részletezzük a hardver működését 15

16 Program tárolására Régebben külső UV-EPROM, EEPROM Ma: flash, áramkörben programozható Programozó adapterrel írható Flash: tápfeszültség nélkül megőrzi tartalmát Endurance: hányszor írható ( 10k-100k) Data retention: az adatokat meddig őrzi ( év) Biztonsági bitek: titkosítás lehetséges a flash olvasása tiltható (törölhetőség) 16

17 Programot és konstansokat is tárol Például: ADD A,#10 ; 10-et ad a-hot, a 10 konstans MOV A,PSW ; a PSW egy SFR cím, 0D0h, konstans Közvetlenül is elérhető: CLR A MOV DPTR,#LOOKUPTABLE MOVC A,@A+DPTR ; lookuptable+a címről olvas Hasznos lookup táblázatok, egyéb paraméterek tárolására 17

18 A CIP-51 mag olvassa (PC program counter) Kiosztás: 0000h: RESET-kor ide kerül a vezérlés 0003h: 0. megszakítás címe 000Bh: 1. megszakítás címe A tényleges program az interrupt tábla után van A fordító és a linker osztja el assemblernél különösen figyelnünk kell! 18

19 Addressing mode MNEMONIC Description register MOV A,B A B immediate constant MOV A, #10 direct MOV A, 10 MOV A, P0 A 10 (value) A byte at address 10 A bits at port P0 (SFR) indirect MOV A byte at address pointed by R0 19

20 0x00-0xFF 0x00-0x7F SFR 0x80-0xFF (direct) 0x80-0xFF (indirect) 0x30-0x7F 0x00-0x7F (direct, indirect) BIT ADDRESSABLE RS1,RS0=11 RS1,RS0=10 RS1,RS0=01 RS1,RS0=00 0x20-0x2F 0x18-0x1F 0x10-0x17 0x08-0x0F 0x00-0x07 20

21 XRAM ON-CHIP 0x0100- (16-bit indirect) 0x0000-0x00FF (8-bit indirect) OFF-CHIP 0x0100-0xFFFF (16-bit indirect) 0x0000-0x00FF (8-bit indirect) 21

22 n: a legnagyobb használt megszakítás sorszáma FLASH RESERVED (C8051F410: 512 bytes) PROGRAM/DATA (0x0003+n x 8) INTERRUPT VECTORS 0x0003 (0x0003+n x 8 1) 0x0000 0x0002: RESET VECTOR 22

23 MNEMONIC OPERATION ADDRESSING FLAG DIR IND REG IMM CY AC OV P ADD A,<byte> A = A + <byte> ADDC A,<byte> A = A + <byte> + C SUBB A,<byte> A = A <byte> C INC A A = A + 1 INC <byte> <byte> = <byte> + 1 INC DPTR DPTR = DPTR + 1 only DPTR DEC A A = A 1 only A DEC <byte> <byte> = <byte> 1 MUL AB B:A = B x A only A és B 0 DIV AB A = Int[A/B] B = Mod[A/B] only A és B 0 DA A Decimal Adjust only A 23

24 MNEMONIC OPERATION ADDRESSING FLAG DIR IND REG IMM P ANL A,<byte> A = A.AND. <byte> ANL <byte>,a <byte> = <byte>.and.a ANL <byte>,#data <byte> = <byte>.and.#data ORL A,<byte> A = A.OR.<byte> ORL <byte>,a <byte> = <byte>.or.a ORL <byte>,#data <byte> = <byte>.or.#data XRL A,<byte> A = A.XOR. <byte> XRL <byte>,a <byte> = <byte>.xor.a XRL <byte>,#data <byte> = <byte>.xor.#data 24

25 MNEMONIC OPERATION ADDRESSING FLAG CY AC OV P CRL A A = 00H only A CPL A A =.NOT.A only A RL A Rotate ACC Left 1 bit only A RLC A Rotate Left through Carry only A RR A Rotate ACC Right 1 bit only A RRC A Rotate Right through Carry only A SWAP A Swap Nibbles in A only A 25

26 MNEMONIC ANL C,bit C = C.AND.bit ANL C,/bit C = C.AND..NOT.bit ORL C,bit C = C.OR.bit ORL C,/bit C = C.OR..NOT.bit MOV C,bit C = bit MOV bit,c bit = C CLR C C = 0 CLR bit bit = 0 SETB C C = 1 SETB bit bit = 1 CPL C C =.NOT.C CPL bit bit =.NOT.bit OPERATION 26

27 MNEMONIC OPERATION ADDRESSING DIR IND REG IMM MOV A,<src> A = <src> MOV <dest>,a <dest> = A MOV <dest>,<src> <dest> = <src> MOV DPTR,#data16 DPTR = 16-bit immediate constant PUSH <src> INC POP <dest> MOV :DEC SP XCH A,<byte> ACC and <byte> exchange data XCHD A,@Ri ACC exchange low nibbles 27

28 MNEMONIC MOVX MOVX MOVC MOVC OPERATION A A A A A + DPTR) A + PC) 28

29 MNEMONIC JMP <addr> ACALL <addr> LCALL <addr> Jump to <addr> PC <addr> Jump to A + DPTR PC A + DPTR OPERATION Call subroutine at 11-bit <addr> SP SP-1) PC PC <addr> Call subroutine at 16-bit <addr> SP SP-1) PC PC <addr> 29

30 MNEMONIC RET RETI NOP Return from subroutine SP-1) SP SP-2 OPERATION Return from interrupt SP-1) SP SP-2 az interrupt logika visszaállítása No operation 30

31 MNEMONIC OPERATION ADDRESSING DIR IND REG IMM JZ rel Jump if A = 0 only A JNZ rel Jump if A!=0 only A DJNZ <byte>,rel Decrement and jump if not zero CJNE A,<byte>,rel Jump if A p <byte> CJNE <byte>,#data,rel Jump if <byte> p #data JC rel Jump if C = 1 JNC rel Jump if C = 0 JB bit,rel Jump if bit = 1 JNB bit,rel Jump if bit = 0 JBC bit,rel Jump if bit = 1; CLR bit 31

32 Utasítások: 1-3 byte hossz, 1-8 ciklus cycles 1 2 2/4 3 3/ /6 6 8 instructions Példák instruction 1. byte 2. byte 3. byte cycles ADD A, Rn nnn 1 ADD A, # ANL 15,# DIV AB JZ <rel address> rel address 2/4 32

33 Előre nem ismert időben bekövetkező esemény beavatkozást igényel Belső áramkörök vagy külső események gombnyomás számláló átfordul adat érkezett egy külső eszköztől Esemény kezelése: alprogram (szubrutin) Meghívása: hardver (interrupt controller) Többféle megszakítás lehet, mindhez más rutin 33

34 Detect ( t) LCALL (5 t) Interrupt handler RETI (6 t) main program paused t t t t Instruction #1 Instruction #2 Instruction #3 latency: 7 t -19 t IRQ 34

35 A főprogram fut, bárhol előfordulhat megszakítás Megszakításkor: a főprogram éppen folyamatban levő művelete lefut a vezérlés átkerül a megfelelő megszakítási rutinra a rutin lefut a vezérlés visszakerül a főprogram következő utasítására A megszakítási rutin is a regisztereket, RAM-ot használja el kell menteni a rutin elején vissza kell állítani a rutin végén A megszakítások tilthatók/engedélyezhetők EA: globális engedélyezés/tiltás bit Számos egyedi engedélyező bit 35

36 Megszakítási kérelemkor az eseményhez tartozó flag 1-re vált A rutin végén a programnak törölnie kell (néhány automatikusan törlődik) Ha nem töröljük, a rutin befejezésekor újra megszakítás történik tipikus hiba! A flag bármikor lekérdezhető A flag akár állítható is, ez eseményt szimulál! hasznos a program tesztelésekor 36

37 /INT0 és /INT1, külső logikai jelek Állítható: 0 vagy 1 aktív Állítható: állapotvezérelt: a flag maga a bemenő jel élvezérelt: le/felfutó él a flag-et aktívvá teszi 37

38 ha egy állapotra kell reagálni folyamatosan megszakítás generálódik, ha aktív a rutinnak meg kell szüntetnie a kiváltó okot bizonyos külső perifériák ilyen viselkedésűek ha túl rövid ideig aktív, elmaradhat a megszakítás port pin polarity IRQ enable XOR AND IRQ flag IRQ rutin IRQ rutin IRQ rutin IRQ rutin 38

39 39

40 ha egyes események bekövetkeztére kell reagálni csak az aktív váltás generál megszakítást egyébként nem számít a jelszint akkor is megszakítás, ha igen rövid az impulzus (2 óraciklus a garantált detektálási minimum) port pin polarity IRQ enable XOR D C Q IRQ flag IRQ rutin IRQ rutin IRQ rutin 40

41 41

42 Ha fut egy megszakítás és beérkezik egy másik? ha a másik prioritása nagyobb, akkor újabb megszakítás történik, de további már nem lehet egyébként előbb befejeződik az előző, aztán indul a másik ha futás közben ugyanolyan esemény több is generálódik, csak egy hajtódik végre, a többi elvész! 42

43 A rutin elvileg beállíthat perifériákat, portbiteket Figyelni kell a következetes használatra! Ne keverjük a főprogram és megszakítási rutin által végzett feladatokat! Amit tipikusan el kell menteni/vissza kell állítani: PSW ACC illetve minden használt regisztert, amit a főprogram is használ Hova mentsük el? Hogyan állítsuk vissza? 43

44 Példa esemény: soros porton adat érkezett RI: flag, ami 1-re állítódik RI-t a hardver nem törli, ha a megszakítási rutinra kerül a vezérlés SBUF: a beérkezett adat SFR-je 44

45 Példa esemény: soros porton adat érkezett: push ACC ; ACC (az A SFR-je) a verembe push PSW ; a státuszbitek a verembe clr RI ; a flag törlése mov A,SBUF ; adat beolvasása, A módosul anl A, #1 ; A és PSW is módosul mov P0,A ; az A tartalma a P0 portra pop PSW ; PSW helyreállítása ; fordított sorrend! pop ACC ; ACC (A) helyreállítása reti ; visszatérés és ; megszakítások alapállapotba 45

46 Regiszterbank váltása a PSW RS1,RS0 bitjeivel A regiszterbankot a POP PSW visszaállítja Vigyázat: a verem RESET alapértékét módosítani kell! push ACC ; ACC (az A SFR-je) a verembe push PSW ; a státuszbitek a verembe mov PSW,#8 ; regiszterbank #1 használata ; PSW módosul clr RI ; flag törlése mov R0,#1 ; R0 módosul anl A, R0 ; A és PSW módosul mov P0,A ; pop PSW ; PSW és regiszterbank helyreállítása ; fordított sorrend! pop ACC ; ACC (A) helyreállítása reti ; visszatérés és ; megszakítások alapállapotba 46

47 Mikrovezérlők: valós idejű rendszerekben Fontos a precíz időzítés Mennyire pontos a megszakítások indulása? Az esemény detektálása 1 ciklus Az utasítások hossza 1-8 ciklus lehet A megszakítás meghívása 5 ciklus (LCALL) Ha RETI közben kérés jön, 1 művelet még végrehajtódik az újabb meghívásig 47

48 A leggyorsabb reagálás: 7 ciklus 1: detektálás 1: főprogram utasítása lefut 5: a rutin meghívása A leglassabb: 19 ciklus 1: detektálás 5: RETI közben aktíválódik a kérelem 8: DIV AB a leghosszabb utasítás 5: a rutin meghívása 48

49 Detect ( t) LCALL (5 t) Interrupt handler RETI (6 t) main program paused t t t t Instruction #1 Instruction #2 Instruction #3 latency: 7 t -19 t IRQ 49

50 Feladat: 100kHz-es logikai jel generálása (10us periódusidő) A processzor órajele: 25MHz (40ns ciklusidő) Egy időzítő megszakítást generál 5us időnként A megszakítás késleltetési bizonytalansága 19-7=12 ciklus, azaz 12x40ns=480ns Így a jelváltási idők bizonytalansága 480ns/5us = 480/5000 = 0,096 = 9,6%! 50

51 A késleltetés 7-19 ciklus között lehet Leggyakrabban 8-9 ciklus Elég véletlenszerű is lehet a reagálási idő A szoftveres időzítés így nem tökéletesen precíz A legtöbbször ez nem gond, de mérlegelni kell Ha nagyon precíz időzítésű jelek szükségesek: például adott frekvenciájú jelek, PWM jelek hardveres megoldás, nem szoftveres! PCA (programmable counter array) Több megszakítás esetén további késleltetés lehet 51

52 Csak rövid idejű feladatokra Felszabadítja a főprogramot az eseménykezeléstől Egyszerűbbé, megbízhatóbbá teszi a programot Gondosan kell tervezni: engedélyezés előtt az eseményforrás konfigurálása a főprogrammal ne ütközzön (mentés, visszaállítás) nem atomi műveletek a főprogramban (pl. 16-bit) a verem igénybevételének megfontolása túl gyakori kérések/a rutin futási ideje fontos elveszhetnek kérések flag-ek kezelése, törlése, több flag egy megszakítás több megszakítási forrás kezelése, extra késleltetés! a prioritás figyelembe vétele 52

53 Cím: 0x0003+8*megszakítási sorszám A RESET csak 3 byte LJMP a főprogramhoz A többi 8 byte, így a rutinhoz is LJMP kell 53

54 Source Address Number Flag Cleared by hardware Reset 0x yes /INT0 external 0x IE0 yes Timer 0 overflow 0x000B 1 TF0 yes /INT1 external 0x IE1 yes Timer 1 overflow 0x001B 3 TF1 no UART0 0x RI0, TI0 no Timer 2 overflow 0x002B 5 TF2H, TF2L no SPI0 0x SPIF, WCOL,MODF, RXOVRN no SMB0 0x003B 7 SI no 54

55 Source Address Number Flag Cleared by hardware smartclock 0x ALRM, OSCFAIL no ADC0 Window Comparator 0x004B 9 AD0WINT no ADC0 End of Conversion 0x AD0INT no Programmable Counter Array 0x005B 11 CF, CCFn no Comparator 0 0x CP0FIF, CP0RIF no Comparator 1 0x006B 13 CP1FIF, CP1RIF no Timer 3 overflow 0x TF3H, TF3L no Voltage regulator dropout 0x007B 15 - no PORT match 0x no 55

56 Gingl Zoltán, 2015, Szeged Mikrovezérlők Alkalmazástechnikája 56

57 a processzor, hardver alapos ismerete erőforrások pontos ismerete C kód ellenőrzése a fordító optimalizálása gondot okozhat a perifériáknál jobban kell figyelni, mint általános C programozásnál a C fordító által generált assembler megértése profiling, optimalizálás hatékonyabb hibakeresés a hardverismeret alapján assembler library rutinok megértése, felhasználása 57

58 teljes programozói szabadság, hatékonyság a hardverhez legközelebbi programozás C fordító limitációinak kikerülése optimalizálás, gyorsítás regiszterváltozók megszakítás-kezelő rutinok ciklusok C-ből hiányzó matematikai műveletek (példa: 24-bites aritmetika) inline-szerű C függvények írása (prolog, epilog optimalizálás) 58

59 Gingl Zoltán, 2015, Szeged Mikrovezérlők Alkalmazástechnikája 59

60 Nem a nyelv elemei A fordítónak adnak információkat Neveket adhatunk konstansoknak, memóriarészeknek Helyet foglalhatunk adatoknak Kezdőértéket adhatunk adatoknak A programrészek helyét megadhatjuk 60

61 Adatok és kód elhelyezésének definiálása Abszolút a programozó rögzíti a helyet Áthelyezhető a compiler/linker rögzíti Öt típus CODE programmemória DATA direkt címzésű adatmemória (RAM: 0-127, SFR ) IDATA indirekt címezhető adatmemória (0-255) XDATA külső RAM (XRAM, lehet on-chip is) BDATA vagy BIT bitmemória (20h-2Fh) 61

62 Egy szegmens definiálása VARIABLES SEGMENT DATA A szegmens használatba vétele RSEG VARIABLES egész addig érvényes, amíg nincs újabb RSEG direktíva 62

63 DSEG at 030h CSEG at 0100h XSEG at 0000h 63

64 DSEG ORG 030h X: DS 1 ; 030h Y: DS 1 ; 031h Z: DS 8 ; 032h-039h CSEG at 0000h ; reset cím LJMP Main ; ugrás a kezdőcímre ORG 0003h ; INT0 megszakítás címe RETI Main: MOV a,#10 END 64

65 Változók foglalása: DS (Define storage) nincs értékadás, csak helyfoglalás <változó neve>: DS <foglalandó byte-ok száma> x: DS 2 y: DS 1 Konstansok definiálása (értékadás): DB (Define byte), DW, DD (Define word, double word) csak CSEG lehet a helye, mivel konstans! 65

66 CSEG at 0000h mov dptr,#lookup_table ; a táblázat kezdőcíme mov a,#2 ; index movc a,@(a+dptr) ; a-ba mozgatás jmp $ ; infinite loop! MESSAGE: ; itt már nincs programkód ; az elejére nem tehetnénk! DB 'Number of samples', 0 LOOKUP_TABLE: DB 0,1,4,9,16 DB 25,36,49,64 ; egész számok négyzete END 66

67 Hasonló a C nyelv #define direktívájához $include (C8051F410.INC) LED EQU P0.5 COUNT EQU 5 CSEG at 0000h anl PCA0MD,#0BFh ; watchdog off mov PCA0MD,#000h mov XBR1,#040h ; crossbar on mov R7,#COUNT L1: cpl LED ; complemet LED djnz R7,L1 ; repeat COUNT times jmp $ ; infinite loop! END 67

68 jz L1 mov a,#10 L1: add a,#2 Mennyi a értéke? jz L1 mov a,#10 jmp L2 L1: add a,#2 L2: Mennyi a értéke? 68

69 L1: jnb P1.3,L1 Mi történik? cjne a,#3,l1 ; a=3 jmp L3 L1: jc L2 ; a>3 jmp L3 L2: ; a<3 L3: 69

70 Alprogramok meghívása: CALL <alprogram neve> Az alprogram neve egy memóriacímet jelent Bemeneti változók? Visszatérési érték? a programozóra van bízva lehet DPL, DPH, B, ACC az SDCC compiler is ezt követi baj lehet, ha a szubrutin hív egy másikat is lehet a verem (tipikus C megoldás) 70

71 int y=f(10,x); A programozó döntheti el az átadás módját mov dpl,#10 mov dph,_x call _f ; itt módosul dph és dpl ; y = (dph << 8) + dpl; 71

72 $include (C8051F410.INC) LED EQU P0.2 CSEG at 0000h jmp Main Main: anl PCA0MD, #0BFh ; watchdog off mov PCA0MD, #000h mov XBR1, #040h ; crossbar on Main1: cpl LED ; complement LED mov a,#5 ; wait a*10 ms call Wait jmp Main1 ; repeat forever 72

73 Wait: ; SYSCLK=191406Hz push acc ; 2 cycles Wait1: push acc ; 2 cycles mov a,#127 ; 2 cycles djnz acc,$ ; 127*5 cycles djnz acc,$ ; 256*5 cycles pop acc ; 2 cycles djnz acc,wait1 ; 5 cycles pop acc ; 2 cycles ret ; 6 cycles END 73

74 ; z=x+y ; 16-bit addition ; little endian data $include (C8051F410.inc) DSEG at 020h x: DS 2 y: DS 2 z: DS 2 CSEG at 0000h jmp main org 0100h Main: mov a,x add a,y mov z,a mov a,x+1 addc a,y+1 mov z+1,a jmp $ end 74

75 ; fill an array with ; ascending numbers $include (C8051F410.inc) DSEG at 020h x: DS 10 CSEG at 0000h jmp main org 0100h Main: mov R7,#10 mov R0,#x clr a Loop: inc a inc R0 djnz R7,Loop end 75

76 DSEG at 020h x: DS 10 sum: DS 2 CSEG at 0000h jmp main org 0100h Main: mov R7,#10 mov R0,#x clr a mov sum,a mov sum+1,a Loop: mov a,@r0 add a,sum mov sum,a clr a addc a,sum+1 mov sum+1,a inc R0 djnz R7,Loop end 76

77 65536 t TMR2RLH/TMR2RLL= t TMR2RLH/TMR2RLL=0 TMR2H/TMR2L TF2H interrupt 0 0 t Set TF2H (HW, interrupt) Clear TF2H (SW) 77

78 Detect ( t) LCALL (5 t) Interrupt handler t t t Instruction #1 Instruction #2 delay: TMR2 t TF2H TMR

79 $include (C8051F410.inc) DSEG at 30h x: DS 30 ; histogram array CSEG at 0000h ljmp Main ORG 002Bh mov a,tmr2l ; TMR2L = delay time/ t add a,#x ; x[tmr2l] mov r0,a ; address to index reg. ; x[tmr2l]++ inc r1 ; next sample anl TMR2CN,#07Fh ; clear TF2H IRQ flag reti ; no push/pop required? :04 A C8051Fxxx mikrovezérlők felépítése és programozása 79

80 Main: anl PCA0MD,#0BFh ; watchdog off mov PCA0MD,#000h mov TMR2CN,#0x04 ; enable timer 2 mov TMR2CF,#008h ; timer: sytem clock mov r1,#0 ; sample counter variable mov r0,#x ; move address of x to r0 L1: ; clear array element inc r0 ; next index cjne r0,#(x+30),l1 ; all elements? mov IE,#0A0h ; enable interrupt cjne r1,#255,$ ; wait here while not ready mov IE,#0 ; disable interrupt jmp $ ; infinite loop END 80

81 N= N=40000 N t TMR2RLH/TMR2RLL =25536=99* N t TMR2RLH/TMR2RLL TMR2H/TMR2L TF2H interrupt 0 0 t Set TF2H (HW, interrupt) Clear TF2H (SW) 81

82 $include (C8051F410.INC) LED EQU P0.2 CSEG at 0000h jmp Main ; reset, jump to the main ORG 002Bh ; Timer 2 IRQ vector anl TMR2CN,#07Fh ; clear interrupt flag cpl LED ; complement LED reti ; return from interrupt 82

83 Main: anl PCA0MD, #0BFh ; watchdog off mov PCA0MD, #000h mov XBR1, #040h ; crossbar on mov TMR2RLL, #0B2h ; Timer 2 reload register mov TMR2RLH, #0C1h ; mov TMR2L, #0B2h ; Timer 2 counter initial value mov TMR2H, #0C1h mov TMR2CN, #004h ; Start Timer 2 mov IE, #0A0h ; enable interrupts jmp $ ; repeat forever END fclk=1/ t=191406/12 Hz Hz (RESET utáni alapérték) 1 sec = t TMR2RL = = = 0xC1B2 83

84 Gingl Zoltán, 2015, Szeged Mikrovezérlők Alkalmazástechnikája 84

85 Speciális esetek Bitműveletek SFR elérés memóriatípusok assembler programrészek Az erőforrások korlátosak! változók pontosság tömbök mérete C és assembly keverése 85

86 type width bit default signed range unsigned range bit 1 unsigned - 0,1 char 8 signed short 16 signed int 16 signed long 32 signed float IEEE signed E-38, E+38 pointer 8-24 generic 86

87 Előjel 1 bit b31 Kitevő 8 bit b30..b23 mantissza 23 bit b22..b0 Előjel: 0:pozitív, 1:negatív Kitevő: Mantissza: előjel nélküli fixpontos bináris szám, bináris ponttal kezdve Pontosság: 23 bit, azaz 7 digit b 1 b b b b

88 Aritmetikai (signed) és logikai (unsigned) shift Példa: ADC adat 12-bites kettes komplemens adat short x; x = (ADC0H << 12) + (ADC0L << 4); // left justified x = ((signed short)(adc0h << 12) >> 4) + ADC0L; // right justified 88

89 Bit törlése x = x & ~(1 << 3); x &= ~(1 << 3); Bit beállítása x = x (1 << 3); x = (1 << 3); unsigned int, unsigned short x = -100; // , azaz Timer auto-reload módban hasznos 89

90 BELSŐ RAM (0-127, DIREKT) data unsigned char x; x=3; assembler: mov _x,#3 KÜLSŐ RAM (16-BITES CÍMZÉS) xdata unsigned char x; x=3; assembler: mov dptr,#_x mov a,#3 90

91 BELSŐ RAM (0..255, INDIREKT) idata unsigned char x; x=3; assembler: mov r0,#_x KÜLSŐ RAM (8-BITES CÍMZÉS) pdata unsigned char x; x=3; assembler: mov r0,#_x mov a,#3 91

92 CODE BIT code unsigned char x=3; y=x; assembler (read only): mov dptr,#_x clr a movc a,@a+dptr mov _y,a bit b; b=1; assembler: setb _b 92

93 SFR sfr at 0x80 P0; P0=3; assembler: mov 0x80,#3 SFR16 sfr16 at 0x8C8A TMR0; TMR0=100; assembler: mov 0x8A,#100 mov 0x8C,#0 vagy: mov 0x8C,#0 mov 0x8A,#100 A sorrend számíthat! (pl. PCA0L olvasás, PCA0CPLn írás) Ekkor inkább két 8-bites! 93

94 sbit at 0xD7 CARRY; CARRY=1; assembler: setb 0xD7 94

95 Declaration pointer type pointed xdata unsigned char * data p; data xdata data unsigned char * xdata p; xdata data xdata unsigned char * code p; code xdata code unsigned char * code p; code code unsigned char * xdata p; xdata * unsigned char * p; * * char (* data fp)(void); data function (code) *: depends on the memory model used 95

96 xdata at (0x4000) unsigned char x[16]; x[2]=7; assembler: mov a,#7 mov dptr,#0x

97 code at (0x7f00) char Msg[] = "Message"; putchar(msg[2]); assembler: mov dptr, #0x7F02 clr a movc mov dpl,a ; paraméterátadás lcall _putchar ; _ a név elé 97

98 bit at (0x80) GPIO_0; GPIO_0=1; assembler: setb 0x080 98

99 A változók alapértelmezett helyét szabja meg Célszerű választás: small leggyorsabb kód a programozó dönt A tárolási osztály választható Nem szabad keverni: más modellű object fájlok más modellű library fájlok Verem: idata opcionálisan: pdata Modell small medium large huge Variables data pdata xdata xdata 99

100 Gingl Zoltán, 2015, Szeged Mikrovezérlők Alkalmazástechnikája 100

101 C kódba assemblert illeszthetünk: asm clr a /* C stílusú komment */ mov R0,#0 // P0, C++ stílusú komment mov R1,#0x80 // C stílusú hexadecimális mov a,r2 jz L1 // címke használata mov R0,#0 L1: mov R1,#1 endasm; 101

102 A nevek elé a C fordító _-t generál: unsigned char c; c=5; asm mov _c,#5 endasm; lokális változók lehetnek regiszterekben: void f(void) { char c; /* regiszterbe kerül */ static char d; /* memóriába kerül */ 102

103 A függvények paraméterei: 1 byte: DPL 2 byte: DPL, DPH 3 byte: DPL, DPH, B 4 byte: DPL, DPH, B, ACC második paraméter: adatmemória Visszatérési értékek: 1 byte: DPL 2 byte: DPL, DPH 3 byte: DPL, DPH, B 4 byte: DPL, DPH, B, ACC reentrant függvények: verem 103

104 char add(char a, char b) { return a+b; } _add: mov r2,dpl mov a,_add_parm_2 ; direkt címzés add a,r2 mov dpl,a ret 104

105 char MaskP0(char a) { char c; } c=p0; c=c & a; return c; _MaskP0: mov r2,dpl mov r3,_p0 mov a,r2 anl ar3,a mov dpl,r3 ret ; r3 direkt címzése (erre van anl) 105

106 A függvény egyszerre több példányban futhat (például megszakításban) Nem használhat olyan változókat, amik statikusok pl. R0-R7 A verem a helye a paramétereknek, lokális változóknak Ritkán használatos Nagyteljesítményű processzorokon gyakran ez az alapértelmezett 106

107 char add(char a, char b) reentrant { return a+b; } _add: push _bp mov _bp,sp mov r2,dpl mov a,_bp add a,#0xfd mov r0,a mov a,@r0 add a,r2 mov dpl,a pop _bp ret 107

108 volatile unsigned char counter; /* Timer 2: megszakítás: 5 */ void IntHandler(void) interrupt 5 { TMR2CN&=~0x80; /* flag törlése */ counter++; } _IntHandler: anl _TMR2CN,#0x7F ; flag törlése inc _counter reti :09 A C8051Fxxx mikrovezérlők felépítése és programozása 108

109 volatile unsigned char counter; /* Timer 2: megszakítás: 5 */ void IntHandler(void) interrupt 5 using 1 { TMR2CN&=~0x80; /* flag törlése */ counter++; } _IntHandler: push psw mov psw,#0x08 ; R0..R7 helye 0x08-0x0F anl _TMR2CN,#0x7F inc _counter pop psw reti 109

110 /************************* EA kikapcsolása az elején, visszaállítás a végén **************************/ void f(void) critical { P0=0; P1=0xFF; } critical { P0=0; P1=0xFF; } 110

111 engedélyezés előtt az eseményforrás konfigurálása a főprogrammal ne ütközzön (mentés, visszaállítás) C: az Rn regisztereket nem menti a verem igénybevételének megfontolása túl gyakori kérések/a rutin futási ideje fontos elveszhetnek kérések flag-ek kezelése, törlése több flag egy megszakítás több megszakítási forrás kezelése, extra késleltetés! a prioritás figyelembe vétele 111

112 Volatile változók értékük bármikor változhat a megszakítás rutinban az optimalizálásból kimarad a változó Nem atomi műveletek atomi művelet: egyetlen utasítás pl: ne módosítsunk 16 bites változót a megszakítási rutinban critical használata a megszakítás késhet emiatt 112

113 unsigned char d; volatile unsigned char vd; d=5; mov _d,#0x05 P0=d+3; mov _P0,#0x08 vd=5; mov _vd,#0x05 P0=vd+3; mov a,#0x03 add a,_vd mov _P0,a 113

114 volatile int x; Megszakításban x változhat Főprogram: C Assembler if (x>10) clr c mov a,#0x0a subb a,_x clr a subb a,(_x + 1) jnc 114

115 volatile int x; Kimaradhat egy megszakításból x frissítése Main program protect_x=1; if (x>10) protect_x=0; Interrupt handler if (!protect_x) { x = (ADC0H << 8) ADC0L; } 115

116 buffer[0] buffer[1] ReadPtr AvailableSamples WritePtr buffer[readptr] buffer[writeptr] buffer[buffersize-2] buffer[buffersize-1] 116

117 volatile int buffer[buffersize]; volatile unsigned char WritePtr; volatile unsigned char AvailableSamples; unsigned char ReadPtr; void IRQ(void) interrupt ADC_VECTOR { AD0INT=0; buffer[writeptr] = (ADC0H << 8) ADC0L; WritePtr = (WritePtr + 1) % BUFFERSIZE; AvailableSamples++; // error, if > BUFFERSIZE } if (AvailableSamples) { Send(buffer[ReadPtr]); ReadPtr = (ReadPtr + 1) % BUFFERSIZE; AvailableSamples--; } Feladat: módosítsuk adatcsomagok esetére (PacketSize adja meg) 117

118 volatile bit UpdateAvailableSamples; volatile unsigned int AvailableSamples; // 16-bit! void IRQ(void) interrupt ADC_VECTOR { if (UpdateAvailableSamples) { AvailableSamples = (WritePtr-ReadPtr ) % BUFFERSIZE; UpdateAvailableSamples=0; } } UpdateAvailableSamples=1; while (UpdateAvailableSamples); for (i=0; i<availablesamples; i++) { Send(buffer[ReadPtr]); ReadPtr = (ReadPtr + 1) % BUFFERSIZE; } 118

119 A main() előtt a fordító generál egy kódot Változók kezdőértékének beállítása Tömböket is inicializál (0 értékkel) A watchdog miatt gond lehet! Saját kézbe vétel: unsigned char _sdcc_external_startup () { PCA0MD &= ~0x40; // watchdog off PCA0MD = 0x00; return 1; // 1: don t initialise variables } 119

120 120

121 Assemler (Keil) C fordító (SDCC, Keil, stb.) Silabs IDE intergált környezet debugger in-circuit emulation Config Wizard 121

122 USB Debug adapter, ICE Development kitek Toolstick kitek 122