BMC - Mikrocomputertechnik 2017 Aufgaben & Beispiele

Transkript

1 Programme mit dem Simulator testen start: mov p1,# b mov p1,# b Google sim535 Hernando Vasquez Seite 1 / 35

2 Bitmuster auf Port 1 (LED-Zeile) ausgeben start: mov a, #55H ; Konstante Zahl 55Hex in Register A laden mov p1, a ; Register A nach Port 1 schreiben mov a, #0AAH ; Konstante Zahl AAHex in Register A laden mov p1, a ; siehe oben ; Sprung zu start * * * Seite 2 / 35

3 Tasten abfragen und Leuchtdioden schalten start: jnb p0.0, ziel mov p1,#055h ziel: mov p1,#0aah Aufgabe 1: Speichern Sie das Programm in einer Datei, übersetzen Sie es und testen Sie es. Welche Wirkung hat dieses Programm? Beobachten Sie dabei den Zustand der Leuchtdioden. Verändern Sie den Zustand von Port 0, indem Sie die Taste 1 drücken. start: jnb p0.0, ziel ;Taste gedrückt ziel mov p1,#055h ; = hell, 1 = dunkel ; Werte der einzelnen Stellen! ; 5 5 hexadezimal ziel: mov p1,#0aah ; = hell, 1 = dunkel ; ; A A hexadezimal unbetätigt betätigt * * * Seite 3 / 35

4 Aufgabe 2: Schreiben Sie ein Programm, das den Zustand der Taste 1 abfragt. Solange diese Taste gedrückt ist, sollen die Leuchtdioden 0 bis 3 aufleuchten. Wenn die Taste nicht gedrückt wird, sollen die Leuchtdioden 4 bis 7 leuchten. start: jnb p0.0, ziel ;Taste gedrückt -> ziel mov p1,# b ;LED Nr hell ziel: mov p1,# b ;LED Nr hell * * * Seite 4 / 35

5 Aufgabe 3: Schreiben Sie ein Programm, das den Zustand aller Tasten abfragt. Solange Taste 1 gedrückt ist, soll die Leuchtdiode 0 aufleuchten, wenn Taste 2 gedrückt ist, soll die Leuchtdiode 1 aufleuchten usw. Hinweis: inverse Logik beachten! Bit = 0 LED leuchtet Taste gedrückt Bit = 0 P1.0 LED 0 P0.0 Taste 1 P1.1 LED 1 P0.1 Taste 2 P1.2 LED 2 P0.2 Taste 3 P1.3 LED 3 P0.3 Taste 4 P1.4 LED 4 P1.5 LED 5 P1.6 LED 6 P1.7 LED 7 start: jnb p0.0, LED0 jnb p0.1, LED1 jnb p0.2, LED2 jnb p0.3, LED3 mov p1,# b ;setzt die Ausgabe dann wieder zurück! LED0: mov p1,# b LED1: mov p1,# b LED2: mov p1,# b LED3: mov p1,# b Seite 5 / 35

6 oder so : start: jnb p0.0, LED0 jnb p0.1, LED1 jnb p0.2, LED2 jnb p0.3, LED3 mov p1,# b ;setzt die Ausgabe dann wieder zurück! LED0: clr p1.0 LED1: clr p1.1 LED2: clr p1.2 LED3: clr p1.3 oder auch so : start: mov a,p0 ;Tastenport einlesen orl a,# b ;LED Nr dunkel mov p1,a ;Tastenstatus maskiert auf LEDs ausgeben Jetzt können mehrere Tasten gleichzeitig gedrückt und angezeigt werden! * * * Seite 6 / 35

7 Warteschleifen programmieren In diesem Versuch sollen Sie lernen Warteschleifen zu programmieren. Eine Anwung dieser Warteschleifen ist das Erzeugen von Blinksignalen und Lauflichtern. Aufgabe 1: Speichern Sie das Programm in einer Datei, übersetzen Sie es und testen Sie es (Taste 1 drücken) mov p1,#0ffh ; alle LEDs ausschalten start: jb p0.0,start ; Tastruck abwarten ; hier später eine Verzögerung einbauen jb p0.0,start ; Tastruck abwarten cpl p1.0 ; LED Zustand umschalten halten: jnb p0.0,halten ; Taste loslassen abwarten Was versteht man unter Tastenprellen und wodurch macht sich das hier bemerkbar? unsicheres Umschalten der LED. Problem: mechanische Kontakte prellen beim Schließen ab Gefahr: Programm erkennt fälschlicherweise mehrfaches Tastrücken Aufgabe 2: Bauen Sie eine Zeitverzögerung von ca. 10ms zur Entprellung in das Beispielprogramm ein. Seite 7 / 35

8 Debug-Session (Quarzfrequenz: 12MHz) mov p1,#0ffh ; alle LEDs ausschalten start: jb p0.0,start ; Tastruck abwarten call delay ; Verzögerung ca. 10ms jb p0.0,start ; Tastruck abwarten cpl p1.0 ; LED Zustand umschalten halten: jnb p0.0,halten ; Taste loslassen abwarten delay: mov r0,#20 w2: mov r1,#250 w1: djnz r1,w1 djnz r0,w2 ret ; Zeitverzögerung ca. 10ms Seite 8 / 35

9 Aufgabe 3: Schreiben Sie ein Programm, das einen 8-Bit-Binärzähler auf den Leuchtdioden erzeugt. Zunächst sollen alle LEDs ausgeschaltet sein. Bei jedem Tastruck auf Taste 1 soll der Zählerstand um 1 erhöht werden. Hinweis: Die Bits des Zählers müssen vor der Ausgabe invertiert werden, falls bei einer 1 in der Binärzahl eine LED leuchten soll. init: mov p1,#0feh ; alle LEDs ausschalten bis auf LED0 start: jb p0.0,start ; Tastruck abwarten call delay ; Verzögerung ca. 10ms jb p0.0,start ; Tastruck abwarten mov a,p1 ; Ausgabeport a cpl a ; invertieren inc a ; Wert = Wert + 1 cpl a ; invertieren mov p1,a ; a Ausgabeport halten: jnb p0.0,halten ; Taste loslassen abwarten delay: mov r0,#20 w2: mov r1,#250 w1: djnz r1,w1 djnz r0,w2 ret ; Zeitverzögerung ca. 10ms Seite 9 / 35

10 Warteschleifen & Lauflicht In diesem Versuch sollen Sie lernen Warteschleifen zu programmieren. Eine Anwung dieser Warteschleifen ist das Erzeugen von Blinksignalen und Lauflichtern. init: mov p1,#0ffh ; alle Leuchtdioden ausschalten ; Anfang der Programmschleife: zweifach verschachtelte Warteschleife start: mov r1,#064h ; äußere Schleife 100 mal abarbeiten warten2: mov r0,#0fah ; innere Schleife 250 mal abarbeiten warten1: nop nop djnz r0, warten1 djnz r1, warten2 ; Zustand der LEDs in Register a (Accu) laden und invertieren mov a,p1 ; Zustand des Port 1 lesen cpl a ; Wert invertieren (LEDs hell, dann dunkel...) mov p1,a ; neuen Zustand in das Port 1 schreiben Aufgabe 1: Testen Sie das Beispielprogramm. Berechnen Sie, wie lange es dauert, bis der Zustand der Leuchtdioden umgeschaltet wird? ( = Dauer der zweifach verschachtelten Warteschleife) Keil debugger 75ms Warteschleife start: mov r1,#100 ; 1us warten2: mov r0,#250 ; 1us warten1: nop ; 1us nop ; 1us djnz r0, warten1 ; 2us ; 250*4us + 1us = 1000us djnz r1, warten2 ; ca. 100ms Anm.: Überschlagsrechnung für eine Quarzfrequenz von 12MHz, 100ms * 12/16 = 75ms für eine Quarzfrequenz von 16MHz Seite 10 / 35

11 states s Seite 11 / 35

12 Aufgabe 2: Ändern Sie das Beispielprogramm so ab, dass die LEDs mit einer Frequenz von 0,5 Hz blinken, d.h. die Warteschleife eine Dauer von 1 Sekunde hat. start: mov r3,#10 ; 1us warten3: mov r1,#133 ; 1us anstelle von 100 für 16MHz 133 einsetzen warten2: mov r0,#250 ; 1us warten1: nop ; 1us nop ; 1us djnz r0, warten1 ; 2us ; 250*4us + 1us = 1000us djnz r1, warten2 ; ca. 100ms djnz r3, warten3 ; 10*100ms = 1s 100 * 16/12 = 133,3334 Seite 12 / 35

13 Aufgabe 3: Schreiben Sie ein Programm, das ein Lauflicht auf den 8 Leuchtdioden erzeugt. Es soll dabei immer nur eine Leuchtdiode eingeschaltet sein. Nach ca. einer Sekunde soll diese LED dann ausgeschaltet und die benachbarte Leuchtdiode eingeschaltet werden, usw. Das Umschalten der Leuchtdioden kann am einfachsten mit einem Schiebebefehl erreicht werden. Eine LED muss allerdings zu Beginn des Programms eingeschaltet werden. init: mov p1,# b ; LED 0 hell, alle anderen dunkel start: mov a,p1 ; p1 a cpl a ; invertieren rl a ; nach links rotieren cpl a ; invertieren mov p1,a ; a p1 call pause pause: mov r3,#10 ; 1us warten3: mov r1,#133 ; 1us anstelle von 100 für 16MHz 133 einsetzen warten2: mov r0,#250 ; 1us warten1: nop ; 1us nop ; 1us djnz r0, warten1 ; 2us ; 250*4us + 1us = 1000us djnz r1, warten2 ; ca. 100ms djnz r3, warten3 ; 10*100ms = 1s ret Seite 13 / 35

14 Timer-Programmierung Erzeugung von Rechtecksignalen T p = T 2 = 1 2 f Aufgabe 1: Testen Sie das Beispielprogramm. Berechnen Sie aus dem Zeitgeber-Anfangswert die Frequenz des ausgegebenen Tonsignals. Beachten Sie hierbei, daß der Zeitgeber einmal pro Maschinenzyklus inkrementiert wird. Das Zeitgeberflag TF0 wird gesetzt, sobald der Zeitgeberinhalt #0000H erreicht ist (Überlauf). NOMOD51 mov tmod,#11h ; Timer 0 und 1 als Zeitgeber konfigurieren clr tr0 ; Timer 0 anhalten (Run-Bit = 0) clr tf0 ; Timer Überlauf Bit rücksetzen start: jb p0.0, start ; warten bis Taste gedrückt mov th0,#0f8h ; Zeitgeber 0 laden mov tl0,#098h ; setb tr0 warten: jnb tf0, warten clr tr0 clr tf0 ; Timer 0 starten ; warten bis Timer 0 = 0000 (Overflow) ; Timer 0 anhalten ; Überlauf-Bit rücksetzen cpl p3.5 ; Lautsprecherausgang invertieren Pulsdauer Tp = 1910 µs (Timerlaufzeit + 14 µs) Frequenz f = 1 / (2 Tp) = 261,78Hz 16MHz Quarz 261,78Hz * 4 / 3 = 349,04Hz Seite 14 / 35

15 Mit einer Android-App ( datuner lite ) kann man die ausgesete Frequenz meßtechnisch ermitteln. Angezeigt werden Hz Seite 15 / 35

16 Aufgabe 2: Schreiben Sie ein Programm, das die Tasten abfragt und je nachdem welche der Tasten gedrückt ist, die Töne C (262Hz), D (294Hz), E (330Hz), und F (349Hz) der 4. Oktave ausgibt. init: mov tmod,#01h ; (2) Timer 0 als Zeitgeber benutzen setb tr0 ; (1) Timer 0 starten (Run-Bit = 1) taste: jnb p0.0,ton1 jnb p0.1,ton2 jnb p0.2,ton3 jnb p0.3,ton4 jmp taste ; (2) Sprung falls Taste gedrückt ; (2) Sprung falls Taste gedrückt ; (2) Sprung falls Taste gedrückt ; (2) Sprung falls Taste gedrückt ton1: mov th0,#0f6h ; (2) Zeitgeber 0 laden (14) 262 F61D mov tl0,#01dh ; (2) Ton C jmp ton ; (2) ton2: mov th0,#0f7h ; (2) Zeitgeber 0 laden (16) 294 F734 mov tl0,#034h ; (2) Ton D jmp ton ; (2) ton3: mov th0,#0f8h ; (2) Zeitgeber 0 laden (18) 330 F82D mov tl0,#02dh ; (2) Ton E jmp ton ; (2) ton4: mov th0,#0f8h ; (2) Zeitgeber 0 laden (20) 349 F89D mov tl0,#09dh ; (2) Ton F jmp ton ; (2) der Symmetrie wegen ton: clr tf0 ; (1) Timer Überlauf Bit rücksetzen warten: jnb tf0, warten ; (2) warten bis Timer 0 = 0000 (Overflow) cpl p3.5 ; (1) Lautsprecherausgang invertieren jmp taste ; (2) Ton f in Hz Startwert f gemessen C 262 F61D D 294 F E 330 F82D F 349 F89D Seite 16 / 35

17 Zusatzaufgabe (freiwillig): Schreiben Sie ein Programm, das den Zustand der Tasten als Binärcode interpretiert und somit 15 unterschiedliche Töne erzeugen kann (0001 = Ton C, 0010 = Ton D, 0011 = Ton E, usw.). Die weiteren Frequenzen erhalten Sie durch 12 Multiplikation mit 2 = 1,0595. Frequenzen der gleichschweb temperierten Stimmung mit a'=440 Hz. Ton Hertz Ton Hertz Ton Hertz Ton Hertz ''A 27,50 C 65,41 c' 261,63 c''' 1.046,50 ''B 29,14 Des 69,30 des' 277,18 des''' 1.108,73 ''H 30,87 D 73,42 d' 293,66 d''' 1.174,66 'C 32,70 Es 77,78 es' 311,13 es''' 1.244,51 'Des 34,65 E 82,41 e' 329,63 e''' 1.318,51 'D 36,71 F 87,31 f' 349,23 f''' 1.396,91 'Es 38,89 Ges 92,50 ges' 369,99 ges''' 1.479,98 'E 41,20 G 98,00 g' 392,00 g''' 1.567,98 'F 43,65 As 103,83 as' 415,30 as''' 1.661,22 'Ges 46,25 A 110,00 a' 440,00 a''' 1.760,00 'G 49,00 B 116,54 b' 466,16 b''' 1.864,66 'As 51,91 H 123,47 h' 493,88 h''' 1.975,53 'A 55,00 c 130,81 c'' 523,25 c'''' 2.093,00 'B 58,27 des 138,59 des'' 554,37 des'''' 2.217,46 'H 61,74 d 146,83 d'' 587,33 d'''' 2.349,32 es 155,56 es'' 622,25 es'''' 2.489,02 e 164,81 e'' 659,26 e'''' 2.637,02 f 174,61 f'' 698,46 f'''' 2.793,83 ges 185,00 ges'' 739,99 ges'''' 2.959,96 g 196,00 g'' 783,99 g'''' 3.135,96 as 207,65 as'' 830,61 as'''' 3.322,44 a 220,00 a'' 880,00 a'''' 3.520,00 b 233,08 b'' 932,33 b'''' 3.729,31 h 246,94 h'' 987,77 h'''' 3.951,07 Quelle: Vorladewerte berechnen timer preload value = (65536+additional cycles) 1 2 f [ Hz ] cycle time [μ s] timer preload value = (65536+additional cycles) cycle time f f = cycle time ( ( additional cycles) timer preload value ) Seite 17 / 35

18 timer_preload.c : #include <stdio.h> int main(void) { double crystal_frequ,audio_frequ,add_cycles=0; double frequ,machine_cycle,timer_preload_value; printf("\n-- calculate timer preload value for 8051 sound creation programs \n"); do{ printf("\n enter crystal_frequency [MHz] : "); if (!scanf("%lf", &crystal_frequ)){ printf(" bye...\n\n"); return(0); printf(" enter audio_frequency [Hz] : "); if (!scanf("%lf", &audio_frequ)){ printf(" bye...\n\n"); return(0); printf(" enter additional cycles : "); if (!scanf("%lf", &add_cycles)){ printf(" bye...\n\n"); return(0); frequ = crystal_frequ*1e6/12.; printf("\n frequ = %e Hz = %f MHz",frequ, frequ/1e6); machine_cycle = 1./frequ; printf("\n machine_cycle = %e us = %f us",machine_cycle,1e6*machine_cycle); timer_preload_value = add_cycles - 1./2./machine_cycle/audio_frequ; printf("\n timer_preload_value = %e = %d = 0x%X\n",\ timer_preload_value,(unsigned)timer_preload_value,(unsigned)timer_preload_value); while(1); /* Bildschirmausgaben: -- calculate timer preload value for 8051 sound creation programs enter crystal_frequency [MHz] : 16 enter audio_frequency [Hz] : 262 enter additional cycles : 14 frequ = e+006 Hz = MHz machine_cycle = e-007 us = us timer_preload_value = e+004 = = 0xF61D enter crystal_frequency [MHz] : */ * * * Seite 18 / 35

19 Zwei Timer gleichzeitig nutzen Beispiel: Jetzt geht es um die Verwung von mehreren Zeitgebern zur Überwachung mehrerer Zeitbedingungen. Dazu müssen mehrere Timer initialisiert und gestartet werden. In einer zentralen Wartesschleife werden alle relevanten Zustandsbits (Flags, Port-Pins etc.) abgefragt. mov tmod,#11h ; Timer 0 und 1 als Zeitgeber benutzen setb tr1 ; Timer 1 starten (Run-Bit = 1) warten: jb p0.0, warten jb tf0, timer0 jb tf1, timer1 jmp warten timer1: mov tl1,#0a0h mov th1,#015h clr tf1 cpl tr0 jmp warten timer0: mov tl0,#083h mov th0,#0ffh clr tf0 cpl p3.5 jmp warten ; warten bis Taste gedrückt ; Sprung, falls Timer 0 abgelaufen ; Sprung, falls Timer 1 abgelaufen ; Ende der zentralen Warteschleife ; Zeitgeber 1 laden ; >> Unterbrechung erzeugen (Signalpuls) ; Timer 1 Flag löschen ; Timer 0 starten oder anhalten ; zurück zur zentralen Warteschleife ; Zeitgeber 0 laden ; >> Tonsignal erzeugen ; Timer 0 Flag löschen ; Lautsprecherausgang invertieren ; zurück zur zentralen Warteschleife Aufgabe 1: Testen Sie das Beispielprogramm. Berechnen Sie aus dem Zeitgeber Anfangswert die Frequenz des ausgegebenen Tonsignals und die Wiederholrate des Tonsignals. Schätzen Sie die Genauigkeit der berechneten Werte ab, indem Sie berechnen, wie lange es im ungünstigsten Fall dauert, bis ein abgelaufener Timer mit einem neuen Startwert geladen werden kann. Berechnungen: Signalpuls Timer 1 15A0 HEX = = Timerzyklen 60000µs = 60ms bei Q=12MHz bzw /16 = ms bei Q=16MHz * * * Seite 19 / 35

20 Test der Tonerzeugungsroutine ( Timer 0 ) im Keil Debugger $nomod51 $include (reg51.inc) mov tmod,#11h ; (2) Timer 0 und 1 als Zeitgeber benutzen clr tr0 ; (1) Timer 0 anhalten, run bit =0 clr tf0 ; (1) Überlauf bit =0 start: ;jb p0.0, start ; (2) warten bis Taste S1 gedrückt mov th0,#0ffh ; (2) Zeitgeber 0 laden mov tl0,#083h ; (2) Ton setb tr0 ; (1) Timer 0 starten warten: jnb tf0,warten ; (2) warten bis Timer 0 = 0000H -> Überlauf ; -( ) = -125 clr tr0 ; (1) Timer 0 anhalten clr tf0 ; (1) Überlauf bit =0 cpl p3.5 ; (1) Lautsprecherausgang invertieren ; (2) ; (14) Zyklen nach Tastruck Berechnungen: Im Keil Debugger werden für einen Durchlauf 138 Zyklen (states) ermittelt. Für Q = 12MHz: T p = = 139[ s] ; f x = 1 2T p Für Q = 16MHz: f = /12 = 4796[ Hz ] (x) mit dem Windows Taschenrechner (wiss.) 2*139=278 1 x = 3597 Hz 3,6 khz 0, * =3597 Seite 20 / 35

21 Aufgabe 2: Schreiben Sie das Beispielprogramm so um, dass die Frequenz des ausgegebenen Tonsignals ca Hz (1KHz) beträgt. Für 12MHz mit 1µs Zyklusdauer: T p = 1 2 f = 500 Zyklen,insgesamt Zusätzlich sind etwa 10 bis 14 Befehlszyklen anzusetzen = 486 Timerzyklen Für 16MHz mit 0,75µs Zyklusdauer: /12 = 648 Timerzyklen Jetzt kann der erforderliche Preload-Wert für die Tonerzeugung berechnet werden: = = FD 78 Hex Auf einem Tablet-PC wird mit der DaTuner Lite App eine Frequenz von 1007Hz angezeigt. * * * Seite 21 / 35

22 Aufgabe 3: Hinweis: Schreiben Sie das Beispielprogramm so um, dass die Ton-Wiederholrate 1 Hz beträgt (d.h. der Ton soll für 0,5 s ertönen und dann soll eine Pause von 0,5 s folgen). Eine Dauer von 500 ms lässt sich nicht mit einem Timer erreichen. Sie können aber den Timer z.b. auf 50 ms einstellen und in einem Register (z.b. R0) die Überläufe des Timers zählen. Nach 10 Überläufen ist dann eine Zeit von ca. 500 ms erreicht. Laden Sie das Register R0 mit 10 (mov r0,#10) und zählen Sie dann auf 0 herunter (djnz r0,...). 50ms = = 3CB0 HEX bei Q=12MHz, 1µs Zykluszeit * 12/ 16 = = 2D84 HEX bei Q=16MHz, 0.75µs Zykluszeit $nomod51 $include (reg51.inc) mov tmod,#11h ; Timer 0 und 1 als Zeitgeber benutzen setb tr1 ; Timer 1 starten (Run-Bit = 1) mov r0, #10 ; Startwert des Überlaufzählers (10x) warten: jb p0.0, warten jb tf0, timer0 jnb tf1, warten ; warten bis Taste gedrückt ; Sprung, falls Timer 0 abgelaufen ; Sprung, falls Timer 1 nicht abgelaufen timer1: mov th1,#02dh ; Zeitgeber 1 laden mov tl1,#084h ; 50 ms, 12MHz > 3CB0, 16MHZ > 2D84 clr tf1 ; Timer 1 Flag löschen djnz r0, warten ; 10 Überläufe auf 0 heruntergezählt? mov r0, #10 ; Startwert des Überlaufzähler neu laden cpl tr0 ; Timer 0 starten oder anhalten jmp warten timer0: mov th0,#0fdh ; Zeitgeber 0 laden mov tl0,#078h ; clr tf0 ; Timer 0 Flag löschen cpl p3.5 ; Lautsprecherausgang invertieren jmp warten * * * Seite 22 / 35

23 Unterprogrammtechnik Aufgabe 1: Übersetzen Sie die zwei nachfolgen Programme. Laden Sie die erhaltenen LST-Files in den Simulator unf gehen Sie die Befehlszeilen im Einzelschrittverfahren durch. Protokollieren Sie dabei die Inhalte des SP und des zugehörigen Stacks tabellarisch. a) zwei aufeinander folge Unterprogrammaufrufe: start: call up1 ;(1) SP=07H call up2 ;(3) SP=07H FA ;(5) SP=07H up1: ret ;(2) SP=09H, Inhalt=0002H up2: ret ;(4) SP=09H, Inhalt=0004H b) ein Unterprogramm, in dem ein weiteres Unterprogram aufrufen wird: start: call up1 ;(1) SP=07H FC ;(5) SP=07H up1: call up2 ;(2) SP=09H, Inhalt=0002H ret ;(4) SP=09H, Inhalt=0002H up2: ret ;(3) SP=0BH, Inhalt=0006H * * * Aufgabe 2: Übersetzen Sie das nachstehe Programm und analysieren Sie es mit dem Simulator. mov p1,# b ; ein Bit von Port P1 setzen start: call schiebe schiebe: mov a, p1 rl a mov p1,a ret warte: mov r0,#3 zaehle: djnz r0, zaehle * * * Seite 23 / 35

24 Aufgabe 3: Ändern Sie das Programm so ab, daß die Ausgabe auf der LED-Zeile der Übungsplatine mit einer sichtbaren Verzögerung von 1s erfolgt ( Lauflicht! ). Zu Beginn soll LED 0 leuchten, alle anderen nicht. mov p1,# b ; LED 0 leuchtet zu Beginn, alle anderen nicht. start: call schiebe call pause schiebe: mov a, p1 rl a mov p1,a ret ; nach links schieben pause: mov r3,#10 ; 1us warten3: mov r1,#133 ; 1us? anstelle von 100 für 16MHz 133 einsetzen warten2: mov r0,#250 ; 1us warten1: nop ; 1us nop ; 1us djnz r0, warten1 ; 2us ; 250*4us + 1us = 1000us djnz r1, warten2 ; ca. 100ms djnz r3, warten3 ; 10*100ms = 1s ret * * * Seite 24 / 35

25 Aufgabe 4: Hinweis: Schreiben Sie das Programm so um, daß die Pause mit einer Timer-Routine erreicht wird. Eine Dauer von 1s lässt sich nicht mit einem Timer erreichen. Sie können aber den Timer z.b. auf 50 ms einstellen und in einem Register (z.b. R4) die Überläufe des Timers zählen. Nach 20 Überläufen ist dann eine Zeit von ca ms erreicht. Laden Sie das Register R4 mit 20 (mov r4,#20) und zählen Sie dann auf 0 herunter (djnz r4,...). 50ms = = 3CB0 HEX bei Q=12MHz, 1µs Zykluszeit * 12/ 16 = = 2D84 HEX bei Q=16MHz, 0.75µs Zykluszeit mov p1,# b ; LED 0 leuchtet zu Beginn, alle anderen nicht. start: call schiebe call pause schiebe: mov a, p1 rl a mov p1,a ret ; nach links schieben pause: mov tmod,#11h ; Timer 0 und 1 als Zeitgeber benutzen setb tr1 ; Timer 1 starten (Run-Bit = 1) mov r0, #20 ; Startwert des Überlaufzählers (10x) warten: jnb tf1, warten ; Sprung, falls Timer 1 nicht abgelaufen timer1: mov th1,#02dh ; Zeitgeber 1 laden mov tl1,#084h ; 50 ms, 12MHz > 3CB0, 16MHZ > 2D84 clr tf1 ; Timer 1 Flag löschen djnz r0, warten ; 20 Überläufe auf 0 heruntergezählt? mov r0, #20 ; Startwert des Überlaufzähler neu laden cpl tr0 ; Timer 0 starten oder anhalten ret * * * Seite 25 / 35

26 Sirenenton mit dem Timer 0 - Interrupt 000H 00BH jmp t0_int start: mov tmod,#11h setb tr0 mov r0,#0fah mov r1,#000h mov r2,#2 setb ET0 setb EAL warte: jmp warte ; Einsprungadresse bei Reset ; Einsprungadresse Interrupt ; 16 Bit Timer Modus ; Timer 0: Start ; Timer 0 High Byte (TH0) ; Timer 0 Low Byte (TL0) ; Steigung der Tonhöhe ; Interrupt Timer 0 freigeben ; generelle Interruptfreigabe t0_int: mov th0,r0 ; (2) Zeitgeber laden mov tl0,r1 ; (2) cpl p3.5 ; (1) Lautsprecher schalten djnz r2,e ; (2) inc r1 ; (1) Frequenz erhöhen mov r2,#2 ; (2) Zähler neu laden e: reti ; (2) (12) (9) + ca. 10 Befehlszyklen Überschlagsrechnung : FA = ca. 10 Befehlszyklen / (2*1546) = 323,4Hz * 4/3 ( für 16MHz ) 431,2Hz FAFF = ca. 10 Befehlszyklen / (2*1291) = 387,3Hz * 4/3 ( für 16MHz ) 516,4Hz Messung : Bei einer Quarzfrequenz von 16MHz 0FA00H 431,7Hz & 0FAFFH 516,6Hz ( gemessen mit der datuner lite app ). Seite 26 / 35

27 Aufgabe 1: Ändern Sie das Programm so ab, daß bei Druck auf Taste S1 der Ton ausgeschaltet und bei Druck auf Taste S2 der Ton wieder eingeschaltet wird. Sie können dazu den Interrupt ausbzw. einschalten (sperren bzw. freigeben). 000H 00BH jmp t0_int start: mov tmod,#11h setb tr0 mov r0,#0fah mov r1,#000h mov r2,#2 setb ET0 setb EAL ; Einsprungadresse bei Reset ; Einsprungadresse Interrupt ; 16 Bit Timer Modus ; Timer 0: Start ; Timer 0 High Byte (TH0) ; Timer 0 Low Byte (TL0) ; Steigung der Tonhöhe ; Interrupt Timer 0 freigeben ; generelle Interruptfreigabe warte: jb p0.0,s2 ; Sprung, falls Taste S1 nicht gedrückt clr ET0 ; Interrupt Timer 0 sperren S2: jb p0.1,warte ; Sprung, falls Taste S2 nicht gedrückt setb ET0 ; Interrupt Timer 0 freigeben jmp warte t0_int: mov th0,r0 ; (2) Zeitgeber laden mov tl0,r1 ; (2) cpl p3.5 ; (1) Lautsprecher schalten djnz r2,e ; (2) inc r1 ; (1) Frequenz erhöhen mov r2,#2 ; (2) Zähler neu laden e: reti ; (2)? (12) (9)? + ca. 10 Befehlszyklen * * * Seite 27 / 35

28 Aufgabe 2: Ändern Sie das Programm so ab, daß die Frequenz des Tons linear ansteigt. Sie benötigen dafür einen zweiten Timer. Betreiben Sie diesen ebenfalls im Interrupt-Modus. Stellen Sie ihn ausf 10ms ein und erhöhen Sie bei jedem Überlauf dieses Timers den Startwert des Tonerzeugen Timers. Timer 1 Einsprungadresse Freigabe-Bit 10ms 001BH ET = = D8F * 12/16 = = A2B4 $INCLUDE (reg51.inc) 000H 00BH jmp t0_int 01BH jmp t1_int start: mov tmod,#11h setb tr0 setb tr1 mov r0,#0fah mov r1,#000h setb ET0 setb ET1 setb EA ; Einsprungadresse bei Reset ; Einsprungadresse T0 Interrupt ; Einsprungadresse T1 Interrupt ; 16 Bit Timer Modus ; Timer 0: Start ; Timer 1: Start ; Timer 0 High Byte (TH0) ; Timer 0 Low Byte (TL0) ; Interrupt Timer 0 freigeben ; Interrupt Timer 1 freigeben ; enable all interrupts warte: jb p0.0,s2 ; Sprung, falls Taste S1 nicht gedrückt clr ET0 ; Interrupt Timer 0 sperren S2: jb p0.1,warte ; Sprung, falls Taste S2 nicht gedrückt setb ET0 ; Interrupt Timer 0 freigeben jmp warte t0_int: mov th0,r0 ; (2) Zeitgeber laden mov tl0,r1 ; (2) cpl p3.5 ; (1) Lautsprecher schalten djnz r2,e ; (2) inc r1 ; (1) Frequenz erhöhen mov r2,#2 ; (2) Zähler neu laden e: reti ; (2)? (12) (9)? + ca. 10 Befehlszyklen t1_int: mov th1,#0a2h mov tl1,#0b4h inc r1 reti ; Timer 1 wird auf 10ms eingestellt ; Ton erhöhen * * * Seite 28 / 35

29 Mikrocontroller-Programmierung in C Taste S1 einlesen und auf LED0 ausgeben /* Definition der symbolischen Namen des AT89C5131 einbinden */ #include <reg5131.h> /* Variablen-Deklaration (sbit = Bit im "special function register") */ sbit LED1 = P1^0; /* Bit 0 von Port P1 */ sbit Taste1 = P0^0; /* Bit 0 von Port P0 */ /* Hauptprogramm */ void main(void){ while (1) /* Endlosschleife */ { LED1 = Taste1; /* LED1 = 0, wenn Taste1 = 0 */ Aufgabe 1: Aufgabe 2: Übersetzen Sie das o.a. Beispielprogramm und testen Sie es auf der Übungsplatine. Schreiben Sie ein C-Programm, das fortwähr den Zustand der 4 Tasten einliest und auf der LED-Leiste entsprech ausgibt, auch wenn mehrere Tasten gleichzeitig betätigt werden. Die LEDs 4 bis 7 ( ohne Tastenzuordung ) sollen dabei nicht leuchten. #include <reg5131.h> sbit LED0 = P1^0; sbit LED1 = P1^1; sbit LED2 = P1^2; sbit LED3 = P1^3; sbit S1 sbit S2 sbit S3 sbit S4 = P0^0; = P0^1; = P0^2; = P0^3; main(){ while(1){ if (S1 == 0) LED0 = 0; else LED0 = 1; if (S2 == 0) LED1 = 0; else LED1 = 1; if (S3 == 0) LED2 = 0; else LED2 = 1; // negative Abfragelogik // LED leuchtet // LED dunkel if (S4 == 0) LED3 = 0; else LED3 = 1; // Endlosschleife, um Absturz zu verhindern. Seite 29 / 35

30 oder auch so : #include <reg5131.h> void main(void){ while (1){ P1 = ~(~P0 & 0x0F); * * * Blinklicht auf LED0, Pulsdauer = 1s #include <reg5131.h> sbit LED1 = P1^0; /* Bit 0 von Port P1 */ #define TH0_Startwert 0xfc /* (1 msec)*/ #define TL0_Startwert 0x18 /* ergibt fc18 als Startwert */ void main(void) { int zaehler; TMOD = 0x01; /* Timer 0 als 16 Bit Timer initialisieren */ TH0 = TH0_Startwert; TL0 = TL0_Startwert; zaehler = 0; /* Zähler für die Schleifurchläufe */ TF0 = 0; /* Timer 0 Überlauf-Flag löschen */ TR0 = 1; /* Timer 0 Run-Bit setzen (Timer starten) */ while (1) /* Endlosschleife */ { if (TF0 == 1) /* d.h.: Timer abgelaufen */ { TF0 = 0; TH0 = TH0_Startwert; TL0 = TL0_Startwert; zaehler++; if (zaehler > 1000) /* 1000 ms */ { LED1 = ~LED1; /* LED-Bit invertieren */ zaehler = 0; Aufgabe 1: Übersetzen Sie das Beispielprogramm und testen Sie es auf der Übungsplatine. Seite 30 / 35

31 Aufgabe 2: Schreiben Sie ein Programm in C, das ein Lauflicht erzeugt, das das Leuchten einer LED im Abstand von 1s um je eine Bitposition verschiebt ( Lauflicht ). #include <reg5131.h> #define TH0_Startwert 0xfc /* (1 msec)*/ #define TL0_Startwert 0x18 /* ergibt fc18 als Startwert */ void main(void) { int zaehler; TMOD = 0x01; /* Timer 0 als 16 Bit Timer initialisieren */ TH0 = TH0_Startwert; TL0 = TL0_Startwert; zaehler = 0; /* Zähler für die Schleifurchläufe */ TF0 = 0; /* Timer 0 Überlauf-Flag löschen */ TR0 = 1; /* Timer 0 Run-Bit setzen (Timer starten) */ while (1){ /* Endlosschleife */ if (TF0 == 1){ /* d.h.: Timer abgelaufen */ TF0 = 0; TH0 = TH0_Startwert; TL0 = TL0_Startwert; zaehler++; if (zaehler > 1000){ /* 1000 ms */ if (P1 == 0xFF) P1 = 0xFE; else P1 = ~(~P1 << 1); /* nach links schieben */ zaehler = 0; Seite 31 / 35

32 Aufgabe 3: Schreiben Sie ein Programm in C, das am Lautsprecher einen Ton mit einer Frequenz von 1kHz erzeugt. #include <reg5131.h> sbit SPEAKER = P3^5; /* Speaker-Port */ #define TH0_Startwert 0xfd /* Startwert für 1kHz bei*/ #define TL0_Startwert 0x73 /* 16MHz Quarzfrequenz */ void main(void) { TMOD = 0x11; /* Timer 0 als 16 Bit Timer initialisieren */ TH0 = TH0_Startwert; TL0 = TL0_Startwert; TF0 = 0; /* Timer 0 Überlauf-Flag löschen */ TR0 = 1; /* Timer 0 Run-Bit setzen (Timer starten) */ while(1){ /* (2) Endlosschleife */ if (TF0 == 1){ /* (2) d.h.: Timer abgelaufen */ TF0 = 0; /* (1) */ TH0 = TH0_Startwert; /* (2) */ TL0 = TL0_Startwert; /* (2) */ SPEAKER = ~SPEAKER; /* (1) Tonausgabe */ /* (10) geschätzte Befehlszyklen */ T p = 1 2f = 500 Zyklen,insgesamt Zusätzlich sind etwa 10 bis 14 Befehlszyklen anzusetzen = 490 Timerzyklen Für 16MHz mit 0,75µs Zyklusdauer: /12 = 653 Timerzyklen Jetzt kann der erforderliche Preload-Wert für die Tonerzeugung berechnet werden: = = FD 73 Hex Mit der DaTuner Lite App wird eine Frequenz von 1010Hz angezeigt. Zusatzaufgabe: - Aktivieren Sie in den Options for Target unter Listing die Option Assembly Code. - Compilieren Sie das Projekt neu und sehen Sie sich das zugehörige LST-file im Editor an.?c0001: JNB TF0,?C0001 ; (2) CLR TF0 ; (1) MOV TH0,#0FDH ; (2) MOV TL0,#073H ; (2) CPL SPEAKER ; (1) SJMP?C0001 ; (2) ; (10) Seite 32 / 35

33 Eine Melodie abspielen (C-Programm) #include <reg5131.h> sbit lautsprecher = P3^5; sbit taste1 = P0^0; #define NICHT_GEDRUECKT 1 #define HALBE 100 #define ACHTEL 25 #define ENDE 0 #define TON_D_4 0xf7a1 #define TON_DIS_4 0xf81a #define TON_F_4 0xf8f6 #define TON_G_4 0xf9bb #define PAUSE 0x0000 #define LOW_BYTE_5_MS 0xf5; #define HIGH_BYTE_5_MS 0xe5; struct ton { char dauer; int hoehe; ; char dauer; char tonhoehe_low_byte; char tonhoehe_high_byte; struct ton code melodie[] = {ACHTEL,PAUSE,ACHTEL,TON_G_4,ACHTEL,TON_G_4,ACHTEL,TON_G_4, HALBE,TON_DIS_4,ACHTEL,PAUSE,ACHTEL,TON_F_4,ACHTEL,TON_F_4, ACHTEL,TON_F_4,HALBE,TON_D_4, HALBE,TON_D_4,ENDE,PAUSE; void ton_laden(char index){ dauer = melodie[index].dauer; TL0 = LOW_BYTE_5_MS; TH0 = HIGH_BYTE_5_MS; TF0 = 0; if(melodie[index].hoehe == PAUSE) TR1 = 0; else { TR1 = 1; tonhoehe_low_byte = (char) melodie[index].hoehe; tonhoehe_high_byte = (char) (melodie[index].hoehe >> 8); TF1 = 1; Seite 33 / 35

34 void main(void){ char index; TMOD = 0x11; TR0 = 1; while (1){ while(taste1 == NICHT_GEDRUECKT); index = 0; ton_laden(0); while (dauer!= ENDE){ while (dauer > 0){ if(tf0 == 1){ TL0 = LOW_BYTE_5_MS; TH0 = HIGH_BYTE_5_MS; TF0 = 0; dauer--; if(tf1 == 1){ TL1 = tonhoehe_low_byte; TH1 = tonhoehe_high_byte; TF1 = 0; lautsprecher =!lautsprecher; index++; ton_laden(index); Seite 34 / 35

35 USB-Port Freigabe in Keil-C51 : Bisher war es so, daß nach jedem Programmstart ein vollständiger Reset nur möglich ist, indem man das Controller-Board mit dem zugehörigen Schalter kurzzeitig von der Stromversorgung trennt und danach abwartet, bis der Windows-Treiber wieder geladen ist (Signalton). Verwet man die nachfolge Initialisierungs-Sequenz. so kann man das vorherige Programm mit einem Druck auf den roten Reset-Taster been und die USB-Kommunikation erneut mit flip wiederherstellen, nachdem der Windows-Treiber wieder geladen ist (Signalton). Danach kann man ein neues Programm direkt wieder laden und damit den Controller neu flashen. #include <at89c5131.h> void main(void){ // USB-Port freigeben PLLCON = 0x02; USBCON = 0x80; USBCON = 0x10; while(1){ P1 = P0 0xF0; // Zustand der 4 Eingabtasten auf der LED-Zeile ausgeben oder in Assembler: $INCLUDE (reg51.inc) PLLCON DATA 0A3H USBCON DATA 0BCH mov PLLCON,#2 mov USBCON,#80H orl USBCON,#010H start: mov a,p0 orl a,#0f0h mov P1,a Seite 35 / 35