Anfänger mit STK500 und Assembler

Guten Abend, robo_wolf!

Zitat:

Zitat von robo_wolf

Ich glaub, ich steh hier schon wieder auf der Leitung.

:-) nee, stehst Du nicht: Du bist nur über die Gemeinheiten der Speicherorganisation bei ATMELs MCs gestolpert.

Guck' mal:

Zitat:

Zitat von robo_wolf

0x0019 CD AB

Offenbar ist im Flash-Speicher unter jeder Adresse je ein 2-Byte-Wort gespeichert.
Deshalb ist der Programmzähler (PC) so aufgebaut, dass PC+1 auf das nächste 2-Byte-Wort nach PC zeigt. Beim Inkrementieren springt der PC um zwei Bytes weiter. So sind auch die Adresse 0x0019 aus Deinem Beispiel zu verstehen: Es ist die Adresse eines 2-Byte-Wortes.

Im Gegensatz dazu ist im RAM unter jeder Adresse je ein 1-Byte-Wort gespeichert.
Deshalb sind die Zeigerregister zh:zl, yh:yl und xh:xl so aufgebaut, dass sie beim Inkrementieren um ein 1-Byte-Wort weiterspringen.

Beim Auslesen des Flash-Speichers mit der „lpm“-Anweisung muss man zh:zl als Zeigerregister verwenden. Das führt zu Schwierigkeiten: zh:zl kann nur auf einzelne Bytes zeigen, die Flashspeicher-Adressen beziehen sich aber immer auf ein 2-Byte-Wort. Also muss man die Flashadresse in zh:zl verdoppeln, dann zeigt zh:zl auf das LSB des gespeicherten Doppelbytes.

Beispiel: Das MSB des unter 0x0019 im Flash gespeicherten Wortes soll ausgelesen werden

Code:

ldi zh,HIGH(0x0019) ldi zl,LOW(0x0019) add zl,zl ; Zeiger verdoppeln adc zh,zh ; jetzt zeigt er auf das LSB ; lpm r16,z ; diese Anweisung würde jetzt das LSB (0xCD) nach r16 befördern adiw zh:zl,0x0001 ; wir wollen ans MSB kommen, also noch eins draufaddieren lpm r16,z ; so, jetzt landet das MSB (0xAB) in r16.

Du hast also recht: Der PC zeigt auf gerade wie ungerade Adressen im Flashspeicher. Ich bezog mich auf die Verwendung von zh:zl im Flashspeicher. Da steht das LSB immer unter der geraden Adresse und das MSB unter der ungeraden.

Am Besten, Du probierst's direkt im Simulator und mit einem Glas Wein gleich 'mal aus ;-) .

Ciao,

mare_crisium

Liste der Anhänge anzeigen (Anzahl: 1)

noch immer Verstaendnisprobleme

Hallo mare_crisium,
leider habe ich noch immer Verstaendnisprobleme.
- Das Lesen der Tabellenwerte mit Zeigern und deren Verarbeitung -
:-k
Ich habe Deinen Code mit einfliessen lassen und habe ihn nun so einge Male durch den Simulator getickert.
Aber es hat leider bei mir noch immer nicht klick gemacht... :-s
Selbst mit den Wein nicht.
Den Code dokumentierten Zeile haenge ich diesmal an.
Dokumentiert sind 3 Durchlaeufe.
Vielleicht kannst Du mir noch ein paar Erlaeuterungen ergaenzen ?

robo_wolf,

nicht locker lassen! Das mit der Tabelle konnte nicht klappen, weil Du zh:zl nicht mit dem Zeiger auf den Tabellenanfang geladen hattest ;-) .

Versuch' mal das hier:

Code:

;***** STK500 Lernprogramm Nr.4e ;*** Aufgabe: die Taste an PinD0 schaltet die zugeordnete LED auf dem STK500 ;*** 1. Tastendruck: LEDs einschalten ;*** 2. Tastendruck: LEDs ausschalten ;*** eine Timerroutine liest den TastenStatus ein ;*** zum Entprellen - muss die TimerRoutine 3mal hintereinander den gleichen Wert, ;*** einlesen um einen Tastzustand zu erkennen, Zst_Var 0x03 bzw. 0x00 ;*** Taste nicht gedrueckt >>> log 0 in Tast_Stat(r17) ;*** Taste gedrueckt >>> log 1 in Tast_Stat(r17) ; ; .include "m8515def.inc" .def Temp = r16 ; Temporary Register .def Tast_Stat = r17 ; Tasten Status .def Tast_Stat0 = r18 .def LED_Stat = r19 ; LED Status .def Zst_Var = r20 ; Zustandsvariable - beinhaltet eine 2Bit-Zahl zur Tastzustandserkennung .def LED_Update_SPRR = r21 ; Sperrt die Ausfuehrung von TastenTest wenn, keine neuer TIMER1_OVL voran gegangen ; .equ Timerwert = 255 ;-1562 ; Timerschritte bis zum Überlauf .equ LED_PORT = PORTB ; LEDs .equ LED_DDR = PORTB-1 ; DataDirectory fuer LEDs .equ TAST_PORT= PORTD ; Tasten .equ TAST_DDR = PORTD-1 ; DataDirectory fuer TastenEingang .equ TAST_PIN = PORTD-2 ; TastenEingang ; Bit-Definitionen für Z-Wert .equ bZWERT_FLANKE = 3 ; Bit3 speichert das "Flankenbit" ; 0 = "keine Flanke" ; 1 = "Flanke steht an" .equ bZWERT_BETAETIGT = 0 ; Bit0 speichert den Tastenzustand ; 0 = "nicht betätigt" ; 1 = "betätigt" ; Pinzuordnung für div. Tasten .equ TASTE0_PIN = 0 .equ TASTE1_PIN = 1 .equ TASTE2_PIN = 3 ; die Zuordnung der PINs muss ja nicht mit der TastenNr übereinstimmen! .equ TASTE3_PIN = 2 ; jetzt kommen die Register, die die Z-Werte der Tasten enthalten. Im Prinzip ; braucht man nur jeweils nur ein Nibble pro Taste. Um die Sache erstmal einfach ; zu halten wird für jede Taste ein ganzes Byte verbraucht. .def rTASTE0_ZST = r15 ; enthält Zustand Taste0 .def rTASTE1_ZST = r14 ; enthält Zustand Taste1 .def rTASTE2_ZST = r13 ; enthält Zustand Taste2 .def rTASTE3_ZST = r12 ; enthält Zustand Taste3 ; ; Vektortabelle ; rjmp RESET ; 1 - $000 RESET External Pin, Power-on Reset, Brown-out, Reset and Watchdog Reset reti ; 2 - $001 INT0 External Interrupt Request 0 reti ; 3 - $002 INT1 External Interrupt Request 1 reti ; 4 - $003 TIMER1 CAPT Timer/Counter1 Capture Event rjmp TIMER1_COMPA_ISR ; 5 - $004 TIMER1 COMPA Timer/Counter1 Compare Match A reti ; 6 - $005 TIMER1 COMPB Timer/Counter1 Compare Match B reti ; 7 - $006 TIMER1 OVF Timer/Counter1 Overflow reti ; 8 - $007 TIMER0 OVF Timer/Counter0 Overflow reti ; 9 - $008 SPI, STC Serial Transfer Complete reti ; 10 - $009 USART, RXC USART, Rx Complete reti ; 11 - $00A USART, UDRE USART Data Register Empty reti ; 12 - $00B USART, TXC USART, Tx Complete reti ; 13 - $00C ANA_COMP Analog Comparator reti ; 14 - $00D INT2 External Interrupt Request 2 reti ; 15 - $00E TIMER0 COMP Timer/Counter0 Compare Match reti ; 16 - $00F EE_RDY EEPROM Ready reti ; 17 - $010 SPM_RDY Store Program memory Ready ; TBL_UEBERGANG_01: .dw 0x0008 ; Tabellenlänge ; T = 0 T = 1 .dw 0x0200 ; Z=0 -> Z=0,Flanke=0 / Z=2,Flanke=0 .dw 0x0308 ; Z=1 -> Z=0,Flanke=1 / Z=3,Flanke=0 .dw 0x0400 ; Z=2 -> Z=0,Flanke=0 / Z=4,Flanke=0 .dw 0x0501 ; Z=3 -> Z=1,Flanke=0 / Z=5,Flanke=0 .dw 0x0602 ; Z=4 -> Z=2,Flanke=0 / Z=6,Flanke=0 .dw 0x0703 ; Z=5 -> Z=3,Flanke=0 / Z=7,Flanke=0 .dw 0x0F04 ; Z=6 -> Z=4,Flanke=0 / Z=7,Flanke=1 .dw 0x0705 ; Z=7 -> Z=5,Flanke=0 / Z=7,Flanke=0 ; verweist auf den Programmspeicher und zeigt dort im ersten Wort auf den ersten ; definierten Wert(Tabellenlaenge), ; anschliessende Worte beinhalten die festgelegten Werte fortlaufend ; bedeutet in meinem Fall Verweis auf 0x0011 mit 08 00 (.dw 0x0008) ; 0x0012 mit 02 00 (.dw 0x0200) ; 0x0013 mit 00 00 (.dw 0x0000) ; 0x0014 mit 04 00 (.dw 0x0400) ; 0x0015 mit 08 50 (.dw 0x0580) ; 0x0016 mit 02 87 (.dw 0x8702) ; 0x0017 mit 03 07 (.dw 0x0703) ; 0x0018 mit 00 00 (.dw 0x0000) ; 0x0019 mit 05 07 (.dw 0x0705) ; ->>> ; Der Wert(Tabellenlaenge) ist auch nur ein festgelegter Wert und fuer Programmoperationen wichtig. ; RESET: ; ldi r16, LOW(RAMEND) ;Stack initialisieren out SPL, r16 ldi r16, HIGH(RAMEND) out SPH, r16 ; ldi temp,(1<<CS10)|(1<<WGM12) ; Taktfrequenz Vorteiler 1 gewaehlt (fuer Simaulatortest) ; ldi temp,(1<<CS10)|(1<<CS12)|(1<<WGM12) ; Taktfrequenz mit Vorteiler 1024 gewaehlt out TCCR1B,temp ; ldi temp,HIGH(Timerwert) out OCR1AH,temp ldi temp,LOW(Timerwert) out OCR1AL,temp ; ldi temp,(1<<COM1A1)|(0<<COM1A0) out TCCR1A,temp ldi temp,(1<<OCIE1A) ; Timer1 Overflow aktivieren out TIMSK,temp ; clr Temp ;Temp mit 0b00000000 bzw. 0x00 laden out TAST_DDR, Temp ;PORTD als Eingang ser Temp ;Temp mit 0b11111111 bzw. 0xFF laden out TAST_PIN, temp ;STK500 schaltet gegen GND - Taste gedreuckt (Pin==0) out TAST_PORT, temp ;PullUp an PortD einschalten out LED_DDR,Temp ;PORTB als Ausgang out LED_PORT, temp ;PORTB (LEDs) aus ; Tastenzustände aller Tasten auf Null setzen clr r16 ; mov rTASTE0_ZST,r16 ; Taste0 und Taste1 zurücksetzen mov rTASTE2_ZST,r16 ; Taste2 und Taste3 zurücksetzen clr Zst_Var ; sei ; ; MAIN: sbrc LED_Update_SPRR,0 ; kein LED_Update, wenn Bit0 ==0 rcall LED_Update rjmp MAIN ; LED_Update: cbr LED_Update_SPRR,0 ; loesche Bit0, um LED_Update bis zur naechsten TIMER1_ISR zu sperren ret ; /*------------------------------------- INTERRUPTDIENST TIMER1_COMPA_ISR Die Interruptdienstprogramm TIMER1_COMPA_ISR wird vom Output-Match-Interrupt von Timer1 ausgelöst. Es liest die aktuellen Messwerte der Tasten vom TAST_PIN ab und berechnet für jede Taste den neuen Zustand (Z-Wert). Eingansgrössen: keine Ausgangsgrössen: keine geänderte Register keine Anzahl Zyklen */ TIMER1_COMPA_ISR: push r25 in r25,SREG push r16 push r17 push r18 push zl push zh /* Das hier hattest Du übersehen: Der Zeiger auf die Übergangstabelle muss VOR (!!) dem Aufruf von NEXT0_TAST_ZST in die Register zh:zl geladen werden !! */ ldi zl,LOW(TBL_UEBERGANG_01) ; zh:zl := Zeiger auf Übergangstabelle ... ldi zh,HIGH(TBL_UEBERGANG_01) ; ...wird für NEXT0_TAST_ZST gebraucht ; Betätigungszustand der Tasten einlesen und der Reihe nach verarbeiten in r18,TAST_PIN ; r18 := Messwerte aller Pins ; Taste0 verarbeiten bst r18,TASTE0_PIN ; überträgt den Messwert von TASTE0_PIN ins T-Flag von SREG mov r16,rTASTE0_ZST ; r16 := Z-Wert Taste0 andi r16,0x07 ; "Flankenbit" löschen rcall NEXT0_TAST_ZST ; Folgezustand für Taste0 in r16 berechnen mov rTASTE0_ZST,r16 ; neuen Z-Wert in TASTE0_ZST speichern ; Taste1 verarbeiten bst r18,TASTE1_PIN ; überträgt den Messwert von TASTE1_PIN ins T-Flag von SREG mov r16,rTASTE1_ZST ; r16 := Z-Wert Taste1 andi r16,0x07 ; "Flankenbit" löschen rcall NEXT0_TAST_ZST ; Folgezustand für Taste1 in r16 berechnen mov rTASTE1_ZST,r16 ; neuen Z-Wert in TASTE1_ZST speichern ; usw... sbr LED_Update_SPRR,0 ; Status fuer LED_Update 1 - LED_Update / 0 - kein LED_Update pop zh pop zl pop r18 pop r17 pop r16 out SREG,r25 pop r25 reti ; /*------------------------------------- PROZEDUR NEXT0_TAST_ZST Die Prozedur NEXT0_TAST_ZST liest den Folgezustand der Tastenentprellung aus einer Übergangstabelle aus. Die Adresse der Tabelle wird in zh:zl übergeben. Der aktuelle Zustand (Z-Wert) wird in r16 übergeben. Der aktuelle Tastenzustand (betätigt/nicht betätigt) ist im T-Flag von SREG gespeichert. Das Ergebnis wird in r16 zurückgegeben. Die Tabelle, darf maximal 127 Einträge enthalten. Der erste Eintrag der Tabelle ist die Länge der Tabelle und dient der Bereichsüberprüfung. D.h. der Zeiger auf die Übergangstabelle muss zh:zl geladen werden BEVOR diese Prozedur aufgerufen wird!! In diesem Beispiel, bei dem nur eine einzige Übergangstabelle im Spiel ist, könnte man zh:zl auch innerhalb von NEXT0_TAST_ZST laden. Um die Prozedur auch in Programmen verwenden zu können, in denen mehrere Zustandsautomaten nebeneinanderherlaufen, ist es sinnvoll, den Zeiger vorher zu laden. Dann kann je nach Aufgabe eine andere Tabelle verwendet werden. Kommt in meinen Programmen öfters vor ;-). Eingansgrössen: r16 : enthält aktuellen Z-Wert der Taste zh:zl : enthält Zeiger auf die Übergangstabelle SREG (T-Flag) : enthält den aktuellen Messwert der Taste T = 0 : Taste nicht betätigt T = 1 : Taste betätigt Ausgangsgrössen: r16 : enthält den neuen Z-Wert für die Taste zh:zl unverändert SREG unverändert geänderte Register r16 Anzahl Zyklen */ NEXT0_TAST_ZST: push r17 in r17,SREG push r17 push r18 push zl push zh ; Zeiger auf Anfang der Übergangstabelle berechnen add zl,zl ; zh:zl verdoppeln, weil einer Adresse im... adc zh,zh ; .. Programmspeicher immer zwei Bytes entsprechen ; FRAGE: Wo wird die Information abgelegt -> im Flashspeicher ; ; ; Information in Bit7 löschen; Tabelle darf nicht länger als 127 Einträge sein andi r16,0x7F ; ; Tabellenlänge einlesen (0-ter Eintrag in der Tabelle) lpm r17,z+ ; r17 := TBL_LNG einlesen ; 1.Durchgang ; es wird in R16 der Wert 0x19 eingetragen - ??? Die letzte Stelle in der Tabelle (0x0019) ; und in R30(ZL) die 0x01 ; ; 2.Durchgang ; es wird in R16 der Wert 0x19 eingetragen - ??? Die letzte Stelle in der Tabelle (0x0019) ; und in R30(ZL) die 0x01 ; ; KLAR; Du hattest den Zeiger nicht gesetzt! ; ; lpm r18,z+ ; zweites Byte überlesen, wird nicht gebraucht ; Bereichsprüfung ( r17 < TBL_LNG ) cp r16,r17 ; Tabellenindex mit TBL_LNG vergleichen brlt NXT0ZST_00 ; Sprung, wenn Tabellenindex iO ; Fehler: Tabellenindex ist zu gross clr r16 ; Zustand auf Null setzen rjmp NXT0ZST_EXIT ; fertig NXT0ZST_00: ; Tabellenindex im zulässigen Bereich clr r17 ; add zl,r16 ; Index zweimal zum Zeiger addieren, weil... adc zh,r17 ; ... in der Tabelle... add zl,r16 ; ... 2-Byte-Worte gespeichert sind. adc zh,r17 ; zh:zl := Zeiger auf Tabelleneintrag lpm r16,z+ ; r16 := Folgezustand für T=0 lpm r17,z ; r17 := Folgezustand für T=1 brtc NXT0ZST_EXIT ; fertig, wenn T = 0 ; T = 1, d.h. Taste betätigt mov r16,r17 ; zweiten Eintrag als Folgezustand verwenden NXT0ZST_EXIT: ; sbr LED_Update_SPRR,0 ; Status fuer LED_Update 1 - LED_Update / 0 - kein LED_Update ; diese Zeile gehört in den Interruptdienst! pop zh pop zl pop r18 pop r17 out SREG,r17 pop r17 ret ;

Diese Version hat eine etwas geänderte Übergangstabelle. Sie macht es möglich, anhand der Bits "bZWERT_FLANKE" und "bZWERT_BETAETIGT" auf einfache Weise den aktuellen Zustand der Taste abzufragen.

Macht Spass mit Dir durch die Geschichte durchzukriechen :-) !

Ciao,

mare_crisium

Edit: P.S.: Könnte es sein, dass Dir meine Art der Parameterübergabe an die Prozedur NEXT0_TAST_ZST fremd ist? Die Register zh:zl, r16 und das T-Flag werwende ich wie die Parameter bei einem Prozeduraufruf in einer Hochsprache, z.B. Pascal:

Code:

procedure NEXT0_TAST_ZST( var Taste_Zst : byte; Tabelle : Pointer; betaetigt : boolean ); Hier ist zugeordnet Taste_Zst -> r16, Tabelle -> zh:zl, betaetigt -> T-Flag in SREG

Hallo mare_crisium,
Daaaanke und schon die naechste Frage, die ich mir hoffentlich selbst beantwortet habe.
Meine Anmerkungen bzw. Gedanken dazu sind im Codesegment.

Code:

NEXT0_TAST_ZST: push r17 in r17,SREG push r17 push r18 push zl push zh // Bis hier hin kann ich es nachvollziehen. Aber nun wird der Eintrag der 0.Stelle von 0x0011 auf 0x0022 berechnet. // ...und was das schlimmste ist, hinterher auch noch richtig ausgelesen... :-() // Bei 0x0022 sind doch ganz andere Daten abgelegt, keine aus der Tabelle. Die enden bei 0x0019. // >>>Glaube, Du hast es mir schon einmal versucht in "Breiform" zu servieren? :-) ; Zeiger auf Anfang der Übergangstabelle berechnen add zl,zl ; zh:zl verdoppeln, weil einer Adresse im... adc zh,zh ; .. Programmspeicher immer zwei Bytes entsprechen // Wenn ich den Kommentar von Dir nun richtig interpretiere, wird auf den Speicher 0x0011 - 0x0019 verwiesen und dort stehen die Daten zu je 16Bit. // Zumindest sehe ich sie so im Simulator. Dort kann ich sie aber nicht wirklich ansprechen, da der ATmega8515 ein 8Bit-Prozessor ist und somit auch nur // 8Bit mit einmal verarbeiten kann. // Bedeutet das die 0. Stelle der Tabelle zwar bei 0x0011 abgelegt, ist aber fuer die CPU bei 0x0022 und 0x0023 // 1. Stelle der Tabelle zwar bei 0x0012 abgelegt, ist aber fuer die CPU bei 0x0024 und 0x0025 // 8. Stelle der Tabelle zwar bei 0x0019 abgelegt, ist aber fuer die CPU bei 0x0032 und 0x0033 // "gerade" und "ungerade" // Ist es so??? Wenn ja, dann habe ich es doch verstanden. ...jedoch nicht warum Atmel keine 8Bit Speicherstruktur verwendet. ; ; ; Information in Bit7 löschen; Tabelle darf nicht länger als 127 Einträge sein andi r16,0x7F ; ; Tabellenlänge einlesen (0-ter Eintrag in der Tabelle) lpm r17,z+ ; r17 := TBL_LNG einlesen // Hier wird der Tabellenwert eingelesen und der Zeiger von 0x0022 auf die 2. "ungerade" Stelle 0x0023 addiert lpm r18,z+ ; r18 := TBL_LNG einlesen // Hier wird der Tabellenwert eingelesen und der Zeiger von 0x0023 auf die 2. "gerade" Stelle 0x0024 addiert - den naechsten Tabelleneintrag // // >>>Habe ich den "Brei" nun mit dem Laeufel oder mit der Gabel gegessen? //

Zitat:

Edit: P.S.: Könnte es sein, dass Dir meine Art der Parameterübergabe an die Prozedur NEXT0_TAST_ZST fremd ist?
Die Register zh:zl, r16 und das T-Flag werwende ich wie die Parameter bei einem Prozeduraufruf in einer Hochsprache, z.B. Pascal:

Fremd? ganz klar... ;-) darueber musst Du aber nicht nachdenken. Wenn ich sie dann einmal verstanden habe.. ist sie nicht mehr fremd.
Ich versuche an die Sache mit gesunden Menschenverstand ran zu gehen.
Manchmal brauche ich vielleicht etwas laenger, um komplett hinter jedes Problem zukommen.
Moechte aber auf keinen Fall Dinge, die ich beim ersten mal nicht gleich verstanden habe, ignorieren bzw. hinnehmen.
Das waere Selbstbetrug und holt mich nur all zu schnell wieder ein.

- Es ist ein Hobby und es macht Spass mit nur "1" und "0" zu spielen -

Was ich damit sagen will:
Es ist voll OK so. und bin wirklich froh, dass Du mich beim Lernen so tatkraeftig unterstuetzt.

robo_wolf,

genau das

Zitat:

... da der ATmega8515 ein 8Bit-Prozessor ist und somit auch nur 8 Bit mit einmal verarbeiten kann.

ist der springende Punkt ;-). Und das kommt so: Es gibt zwei gängige Arten von Computer-Architektur, die von-Neumann- und die Harvard-Architektur (In Wikipedia sind die beiden Architekturen ganz gut erläutert).

Bei der v-Neumann-Variante werden Programm- und Datenspeicher über denselben Bus angesprochen. Klar, dass dann die Maschinenbefehle und die Daten im einfachsten Fall dieselbe Anzahl Bits haben. Beispiel: Die alten 8048 bis 8085, 6502, 6800 und Z80 usw. hatten alle eine von-Neumann-Struktur und einen Daten- und Programmbus mit 8Bit Breite. Wenn längere Maschinenbefehle nötig waren, mussten eben zwei Bytes eingelesen werden. Die 8086- und die 68000-Reihe waren auch vom von-Neumann Typ, aber mit 16 Bit-Bus.

Bei der Harvard-Architektur sind Daten- und Programmspeicher voneinander getrennt, und es gibt separate Busse für Daten und Programm. Der Vorteil ist, dass man Programmbefehle und Daten gleichzeitig einlesen kann. Auch können die Maschinenbefehle mehr Bits haben als ein Datenwort - dadurch kann man auch längere Maschinenbefehle in nur einem Speicherzugriff einlesen. Beispiel: Die ATmega-Prozessoren.

Also: Der Programmspeicher bei den ATmega-MCs ist in 16-Bit-Worten organisiert. Die Adresse, die einem Label zugeordnet wird, zeigt immer auf den Anfang eines Doppelbytes. Die "lpm"-Anweisung behandelt den Programmspeicher aber so, als wäre er in 8-Bit-Worten organisiert. Deshalb muss man die Labeladressen in zh:zl verdoppeln, um an die richtigen Daten zu kommen. Na? ;-) !

Ciao,

mare_crisium

Hallo mare_crisium,
dann werde ich das Programm mal komplettieren, 2 Zustaende in ein Register unterbringen und in mein naechsten Post setzen.

Hallo mare_crisium,
wollte eigentlich mit diesem Post das fertige Programm praesentieren.
Leider bin ich da noch auf ein seltsames Problem gestossen:
Ich habe deshalb den Code von Dir, ohne meine Erweiterungen, im Simulator laufen lassen.(Nur Deine Kommentare asm-konform veraendert)
Beim 2. Anspringen der ISR(Simulator steht in Zeile 62 "rjmp TIMER1_COMPA_ISR") wird der Eingang PinD5 von High auf Low umgeschaltet.

edit: Stimmt nicht ganz, das Umschalten passiert schon vorher bei Counter 269 - bevor die ISR angsprungen wird. Genau bei Ueberlauf des Timers auf 1.

Leider kann ich mir nicht erklaeren, wie es dazu kommt...
Koenntest Du den Code versuchsweise in Deinem Simulator laufen lassen?

Code:

;***** STK500 Lernprogramm Nr.4e ;*** Aufgabe: die Taste an PinD0 schaltet die zugeordnete LED auf dem STK500 ;*** 1. Tastendruck: LEDs einschalten ;*** 2. Tastendruck: LEDs ausschalten ;*** eine Timerroutine liest den TastenStatus ein ;*** zum Entprellen - muss die TimerRoutine 3mal hintereinander den gleichen Wert, ;*** einlesen um einen Tastzustand zu erkennen, Zst_Var 0x03 bzw. 0x00 ;*** Taste nicht gedrueckt >>> log 0 in Tast_Stat(r17) ;*** Taste gedrueckt >>> log 1 in Tast_Stat(r17) ; ; .include "m8515def.inc" .def Temp = r16 ; Temporary Register .def Tast_Stat = r17 ; Tasten Status .def Tast_Stat0 = r18 .def LED_Stat = r19 ; LED Status .def Zst_Var = r20 ; Zustandsvariable - beinhaltet eine 2Bit-Zahl zur Tastzustandserkennung .def LED_Update_SPRR = r21 ; Sperrt die Ausfuehrung von TastenTest wenn, keine neuer TIMER1_OVL voran gegangen ; .equ Timerwert = 255 ;-1562 ; Timerschritte bis zum Überlauf .equ LED_PORT = PORTB ; LEDs .equ LED_DDR = PORTB-1 ; DataDirectory fuer LEDs .equ TAST_PORT= PORTD ; Tasten .equ TAST_DDR = PORTD-1 ; DataDirectory fuer TastenEingang .equ TAST_PIN = PORTD-2 ; TastenEingang ; Bit-Definitionen für Z-Wert .equ bZWERT_FLANKE = 3 ; Bit3 speichert das "Flankenbit" ; 0 = "keine Flanke" ; 1 = "Flanke steht an" .equ bZWERT_BETAETIGT = 0 ; Bit0 speichert den Tastenzustand ; 0 = "nicht betätigt" ; 1 = "betätigt" ; Pinzuordnung für div. Tasten .equ TASTE0_PIN = 0 .equ TASTE1_PIN = 1 .equ TASTE2_PIN = 3 ; die Zuordnung der PINs muss ja nicht mit der TastenNr übereinstimmen! .equ TASTE3_PIN = 2 ; jetzt kommen die Register, die die Z-Werte der Tasten enthalten. Im Prinzip ; braucht man nur jeweils nur ein Nibble pro Taste. Um die Sache erstmal einfach ; zu halten wird für jede Taste ein ganzes Byte verbraucht. .def rTASTE0_ZST = r15 ; enthält Zustand Taste0 .def rTASTE1_ZST = r14 ; enthält Zustand Taste1 .def rTASTE2_ZST = r13 ; enthält Zustand Taste2 .def rTASTE3_ZST = r12 ; enthält Zustand Taste3 ; ; Vektortabelle ; rjmp RESET ; 1 - $000 RESET External Pin, Power-on Reset, Brown-out, Reset and Watchdog Reset reti ; 2 - $001 INT0 External Interrupt Request 0 reti ; 3 - $002 INT1 External Interrupt Request 1 reti ; 4 - $003 TIMER1 CAPT Timer/Counter1 Capture Event rjmp TIMER1_COMPA_ISR ; 5 - $004 TIMER1 COMPA Timer/Counter1 Compare Match A reti ; 6 - $005 TIMER1 COMPB Timer/Counter1 Compare Match B reti ; 7 - $006 TIMER1 OVF Timer/Counter1 Overflow reti ; 8 - $007 TIMER0 OVF Timer/Counter0 Overflow reti ; 9 - $008 SPI, STC Serial Transfer Complete reti ; 10 - $009 USART, RXC USART, Rx Complete reti ; 11 - $00A USART, UDRE USART Data Register Empty reti ; 12 - $00B USART, TXC USART, Tx Complete reti ; 13 - $00C ANA_COMP Analog Comparator reti ; 14 - $00D INT2 External Interrupt Request 2 reti ; 15 - $00E TIMER0 COMP Timer/Counter0 Compare Match reti ; 16 - $00F EE_RDY EEPROM Ready reti ; 17 - $010 SPM_RDY Store Program memory Ready ; TBL_UEBERGANG_01: .dw 0x0008 ; Tabellenlänge ; T = 0 T = 1 .dw 0x0200 ; Z=0 -> Z=0,Flanke=0 / Z=2,Flanke=0 .dw 0x0308 ; Z=1 -> Z=0,Flanke=1 / Z=3,Flanke=0 .dw 0x0400 ; Z=2 -> Z=0,Flanke=0 / Z=4,Flanke=0 .dw 0x0501 ; Z=3 -> Z=1,Flanke=0 / Z=5,Flanke=0 .dw 0x0602 ; Z=4 -> Z=2,Flanke=0 / Z=6,Flanke=0 .dw 0x0703 ; Z=5 -> Z=3,Flanke=0 / Z=7,Flanke=0 .dw 0x0F04 ; Z=6 -> Z=4,Flanke=0 / Z=7,Flanke=1 .dw 0x0705 ; Z=7 -> Z=5,Flanke=0 / Z=7,Flanke=0 ; verweist auf den Programmspeicher und zeigt dort im ersten Wort auf den ersten ; definierten Wert(Tabellenlaenge), ; anschliessende Worte beinhalten die festgelegten Werte fortlaufend ; bedeutet in meinem Fall Verweis auf 0x0011 mit 08 00 (.dw 0x0008) ; 0x0012 mit 02 00 (.dw 0x0200) ; 0x0013 mit 00 00 (.dw 0x0000) ; 0x0014 mit 04 00 (.dw 0x0400) ; 0x0015 mit 08 50 (.dw 0x0580) ; 0x0016 mit 02 87 (.dw 0x8702) ; 0x0017 mit 03 07 (.dw 0x0703) ; 0x0018 mit 00 00 (.dw 0x0000) ; 0x0019 mit 05 07 (.dw 0x0705) ; ->>> ; Der Wert(Tabellenlaenge) ist auch nur ein festgelegter Wert und fuer Programmoperationen wichtig. ; RESET: ; ldi r16, LOW(RAMEND) ;Stack initialisieren out SPL, r16 ldi r16, HIGH(RAMEND) out SPH, r16 ; ldi temp,(1<<CS10)|(1<<WGM12) ; Taktfrequenz Vorteiler 1 gewaehlt (fuer Simaulatortest) ; ldi temp,(1<<CS10)|(1<<CS12)|(1<<WGM12) ; Taktfrequenz mit Vorteiler 1024 gewaehlt out TCCR1B,temp ; ldi temp,HIGH(Timerwert) out OCR1AH,temp ldi temp,LOW(Timerwert) out OCR1AL,temp ; ldi temp,(1<<COM1A1)|(0<<COM1A0) out TCCR1A,temp ldi temp,(1<<OCIE1A) ; Timer1 Overflow aktivieren out TIMSK,temp ; clr Temp ;Temp mit 0b00000000 bzw. 0x00 laden out TAST_DDR, Temp ;PORTD als Eingang ser Temp ;Temp mit 0b11111111 bzw. 0xFF laden out TAST_PIN, temp ;STK500 schaltet gegen GND - Taste gedreuckt (Pin==0) out TAST_PORT, temp ;PullUp an PortD einschalten out LED_DDR,Temp ;PORTB als Ausgang out LED_PORT, temp ;PORTB (LEDs) aus ; Tastenzustände aller Tasten auf Null setzen clr r16 ; mov rTASTE0_ZST,r16 ; Taste0 und Taste1 zurücksetzen mov rTASTE2_ZST,r16 ; Taste2 und Taste3 zurücksetzen clr Zst_Var ; sei ; ; MAIN: sbrc LED_Update_SPRR,0 ; kein LED_Update, wenn Bit0 ==0 rcall LED_Update rjmp MAIN ; LED_Update: cbr LED_Update_SPRR,0 ; loesche Bit0, um LED_Update bis zur naechsten TIMER1_ISR zu sperren ret ; ;/*------------------------------------- ; ;INTERRUPTDIENST TIMER1_COMPA_ISR ; ;Die Interruptdienstprogramm TIMER1_COMPA_ISR wird vom Output-Match-Interrupt von ;Timer1 ausgelöst. Es liest die aktuellen Messwerte der Tasten vom TAST_PIN ab und ;berechnet für jede Taste den neuen Zustand (Z-Wert). ; ;Eingansgrössen: ; keine ; ;Ausgangsgrössen: ; keine ; ;geänderte Register ; keine ; ;Anzahl Zyklen ; ;*/ TIMER1_COMPA_ISR: push r25 in r25,SREG push r16 push r17 push r18 push zl push zh ;/* ;Das hier hattest Du übersehen: ;Der Zeiger auf die Übergangstabelle muss VOR (!!) dem Aufruf von NEXT0_TAST_ZST ;in die Register zh:zl geladen werden !! ;*/ ldi zl,LOW(TBL_UEBERGANG_01) ; zh:zl := Zeiger auf Übergangstabelle ... ldi zh,HIGH(TBL_UEBERGANG_01) ; ...wird für NEXT0_TAST_ZST gebraucht ; Betätigungszustand der Tasten einlesen und der Reihe nach verarbeiten in r18,TAST_PIN ; r18 := Messwerte aller Pins ; Taste0 verarbeiten bst r18,TASTE0_PIN ; überträgt den Messwert von TASTE0_PIN ins T-Flag von SREG mov r16,rTASTE0_ZST ; r16 := Z-Wert Taste0 andi r16,0x07 ; "Flankenbit" löschen rcall NEXT0_TAST_ZST ; Folgezustand für Taste0 in r16 berechnen mov rTASTE0_ZST,r16 ; neuen Z-Wert in TASTE0_ZST speichern ; Taste1 verarbeiten bst r18,TASTE1_PIN ; überträgt den Messwert von TASTE1_PIN ins T-Flag von SREG mov r16,rTASTE1_ZST ; r16 := Z-Wert Taste1 andi r16,0x07 ; "Flankenbit" löschen rcall NEXT0_TAST_ZST ; Folgezustand für Taste1 in r16 berechnen mov rTASTE1_ZST,r16 ; neuen Z-Wert in TASTE1_ZST speichern ; usw... sbr LED_Update_SPRR,0 ; Status fuer LED_Update 1 - LED_Update / 0 - kein LED_Update pop zh pop zl pop r18 pop r17 pop r16 out SREG,r25 pop r25 reti ; ;/*------------------------------------- ;PROZEDUR NEXT0_TAST_ZST ; ;Die Prozedur NEXT0_TAST_ZST liest den Folgezustand der Tastenentprellung aus einer ;Übergangstabelle aus. Die Adresse der Tabelle wird in zh:zl übergeben. Der aktuelle ;Zustand (Z-Wert) wird in r16 übergeben. Der aktuelle Tastenzustand (betätigt/nicht ;betätigt) ist im T-Flag von SREG gespeichert. Das Ergebnis wird in r16 zurückgegeben. ;Die Tabelle, darf maximal 127 Einträge enthalten. Der erste Eintrag der Tabelle ist ;die Länge der Tabelle und dient der Bereichsüberprüfung. ; ;D.h. der Zeiger auf die Übergangstabelle muss zh:zl geladen werden BEVOR diese ;Prozedur aufgerufen wird!! In diesem Beispiel, bei dem nur eine einzige Übergangstabelle ;im Spiel ist, könnte man zh:zl auch innerhalb von NEXT0_TAST_ZST laden. Um die ;Prozedur auch in Programmen verwenden zu können, in denen mehrere Zustandsautomaten ;nebeneinanderherlaufen, ist es sinnvoll, den Zeiger vorher zu laden. Dann kann je ;nach Aufgabe eine andere Tabelle verwendet werden. Kommt in meinen Programmen öfters ;vor ;-). ; ; ;Eingansgrössen: ; r16 : enthält aktuellen Z-Wert der Taste ; zh:zl : enthält Zeiger auf die Übergangstabelle ; SREG (T-Flag) : enthält den aktuellen Messwert der Taste ; T = 0 : Taste nicht betätigt ; T = 1 : Taste betätigt ; ;Ausgangsgrössen: ; r16 : enthält den neuen Z-Wert für die Taste ; zh:zl unverändert ; SREG unverändert ; ;geänderte Register ; r16 ; ;Anzahl Zyklen ; ;*/ NEXT0_TAST_ZST: push r17 in r17,SREG push r17 push r18 push zl push zh ; Zeiger auf Anfang der Übergangstabelle berechnen add zl,zl ; zh:zl verdoppeln, weil einer Adresse im... adc zh,zh ; .. Programmspeicher immer zwei Bytes entsprechen ; FRAGE: Wo wird die Information abgelegt -> im Flashspeicher ; ; ; Information in Bit7 löschen; Tabelle darf nicht länger als 127 Einträge sein andi r16,0x7F ; ; Tabellenlänge einlesen (0-ter Eintrag in der Tabelle) lpm r17,z+ ; r17 := TBL_LNG einlesen ; 1.Durchgang ; es wird in R16 der Wert 0x19 eingetragen - ??? Die letzte Stelle in der Tabelle (0x0019) ; und in R30(ZL) die 0x01 ; ; 2.Durchgang ; es wird in R16 der Wert 0x19 eingetragen - ??? Die letzte Stelle in der Tabelle (0x0019) ; und in R30(ZL) die 0x01 ; ; KLAR; Du hattest den Zeiger nicht gesetzt! ; ; lpm r18,z+ ; zweites Byte überlesen, wird nicht gebraucht ; Bereichsprüfung ( r17 < TBL_LNG ) cp r16,r17 ; Tabellenindex mit TBL_LNG vergleichen brlt NXT0ZST_00 ; Sprung, wenn Tabellenindex iO ; Fehler: Tabellenindex ist zu gross clr r16 ; Zustand auf Null setzen rjmp NXT0ZST_EXIT ; fertig NXT0ZST_00: ; Tabellenindex im zulässigen Bereich clr r17 ; add zl,r16 ; Index zweimal zum Zeiger addieren, weil... adc zh,r17 ; ... in der Tabelle... add zl,r16 ; ... 2-Byte-Worte gespeichert sind. adc zh,r17 ; zh:zl := Zeiger auf Tabelleneintrag lpm r16,z+ ; r16 := Folgezustand für T=0 lpm r17,z ; r17 := Folgezustand für T=1 brtc NXT0ZST_EXIT ; fertig, wenn T = 0 ; T = 1, d.h. Taste betätigt mov r16,r17 ; zweiten Eintrag als Folgezustand verwenden NXT0ZST_EXIT: ; sbr LED_Update_SPRR,0 ; Status fuer LED_Update 1 - LED_Update / 0 - kein LED_Update ; diese Zeile gehört in den Interruptdienst! pop zh pop zl pop r18 pop r17 out SREG,r17 pop r17 ret ;

robo_wolf,

das liegt an diesen Zeilen

Code:

ldi temp,(1<<COM1A1)|(0<<COM1A0) out TCCR1A,temp

Laut Tabelle 50 auf Seite 119 des Datenblatts sagst Du Deinem 8515 damit, dass er beim Erreichen des Vergleichswortes den Pin OC1A auf "low" setzen soll ("Clear OC1A/OC1B on Compare Match (Set output to low level)").

Der Pin OC1A ist identisch mit Pin PD5. Du kannst das Umschalten aber nur erkennen, wenn der Pin vorher auf "high" gesetzt war. Ich nehme an, das ist der Grund, weshalb Du die Funktion erst beim dritten Interrupt sehen kannst. - Diese Doppelbelegungen der Pins können manchmal ziemlich tückisch sein ;-)!

Du kannst die Funktion abschalten, indem Du die Bits COM1A1 und COM1A0 beide auf Null stellst.

Ciao,

mare_crisium

Hallo mare_crisium,
super...
Das wars. Mit den Timerfunktionen muss ich mich genauer auseinander setzen.

Hallo mare_crisium,
hatte heute mal wieder genuegend Zeit um mich den schoenen Dingen im Leben zu widmen... ;-)
Hier nun das Ergebnis:

Code:

;***** STK500 Lernprogramm Nr.4e ;*** Aufgabe: die Taste an PinD0 schaltet die zugeordnete LED auf dem STK500 ;*** 1. Tastendruck: LEDs einschalten ;*** 2. Tastendruck: LEDs ausschalten ;*** eine Timerroutine liest den TastenStatus ein ;*** zum Entprellen - muss die TimerRoutine 3mal hintereinander den gleichen Wert, ;*** einlesen um einen Tastzustand zu erkennen ;*** die Flanken der Tastzustaende werden in rTastFlanken gesammelt und schalten die LEDs um ;*** Taste nicht gedrueckt >>> log 0 ;*** Taste gedrueckt >>> log 1 ; ; .include "m8515def.inc" .def Temp = r16 ; Temporary Register .def rTastFlanken = r20 ; Zustandsvariable - beinhaltet eine 2Bit-Zahl zur Tastzustandserkennung .def rLED_Update_SPRR = r21 ; Sperrt die Ausfuehrung von TastenTest wenn, keine neuer TIMER1_OVL voran gegangen ; .equ Timerwert = 155 ;-24999 ; Timerschritte bis zum Überlauf 0,2 sec ; .equ LED_PORT = PORTB ; LEDs .equ LED_DDR = PORTB-1 ; DataDirectory fuer LEDs ; .equ TAST_PORT= PORTD ; Tasten .equ TAST_DDR = PORTD-1 ; DataDirectory fuer TastenEingang .equ TAST_PIN = PORTD-2 ; TastenEingang ; ; Pinzuordnung für div. Tasten .equ TASTE0_PIN = 0 .equ TASTE1_PIN = 1 .equ TASTE2_PIN = 2 ; die Zuordnung der PINs muss ja nicht mit der TastenNr übereinstimmen! .equ TASTE3_PIN = 3 .equ TASTE4_PIN = 4 .equ TASTE5_PIN = 5 .equ TASTE6_PIN = 6 .equ TASTE7_PIN = 7 ; ; jetzt kommen die Register, die die Z-Werte der Tasten enthalten.. .def rTASTE1_0_ZST = r15 ; enthält Zustand Taste1 im oberen Nibble und 0 im unteren Nibble .def rTASTE3_2_ZST = r14 ; enthält Zustand Taste3 im oberen Nibble und 2 im unteren Nibble .def rTASTE5_4_ZST = r13 ; enthält Zustand Taste5 im oberen Nibble und 4 im unteren Nibble .def rTASTE7_6_ZST = r12 ; enthält Zustand Taste7 im oberen Nibble und 6 im unteren Nibble ; ; Vektortabelle ; rjmp RESET ; 1 - $000 RESET External Pin, Power-on Reset, Brown-out, Reset and Watchdog Reset reti ; 2 - $001 INT0 External Interrupt Request 0 reti ; 3 - $002 INT1 External Interrupt Request 1 reti ; 4 - $003 TIMER1 CAPT Timer/Counter1 Capture Event rjmp TIMER1_COMPA_ISR ; 5 - $004 TIMER1 COMPA Timer/Counter1 Compare Match A reti ; 6 - $005 TIMER1 COMPB Timer/Counter1 Compare Match B reti ; 7 - $006 TIMER1 OVF Timer/Counter1 Overflow reti ; 8 - $007 TIMER0 OVF Timer/Counter0 Overflow reti ; 9 - $008 SPI, STC Serial Transfer Complete reti ; 10 - $009 USART, RXC USART, Rx Complete reti ; 11 - $00A USART, UDRE USART Data Register Empty reti ; 12 - $00B USART, TXC USART, Tx Complete reti ; 13 - $00C ANA_COMP Analog Comparator reti ; 14 - $00D INT2 External Interrupt Request 2 reti ; 15 - $00E TIMER0 COMP Timer/Counter0 Compare Match reti ; 16 - $00F EE_RDY EEPROM Ready reti ; 17 - $010 SPM_RDY Store Program memory Ready ; TBL_UEBERGANG_01: .dw 0x0008 ; Tabellenlänge ; T = 0 T = 1 .dw 0x0200 ; Z=0 -> Z=0,Flanke=0 / Z=2,Flanke=0 .dw 0x0308 ; Z=1 -> Z=0,Flanke=1 / Z=3,Flanke=0 .dw 0x0400 ; Z=2 -> Z=0,Flanke=0 / Z=4,Flanke=0 .dw 0x0501 ; Z=3 -> Z=1,Flanke=0 / Z=5,Flanke=0 .dw 0x0602 ; Z=4 -> Z=2,Flanke=0 / Z=6,Flanke=0 .dw 0x0703 ; Z=5 -> Z=3,Flanke=0 / Z=7,Flanke=0 .dw 0x0F04 ; Z=6 -> Z=4,Flanke=0 / Z=F,Flanke=1 .dw 0x0705 ; Z=7 -> Z=5,Flanke=0 / Z=7,Flanke=0 ; RESET: ; ldi r16, LOW(RAMEND) ;Stack initialisieren out SPL, r16 ldi r16, HIGH(RAMEND) out SPH, r16 ; ldi temp,(1<<CS10)|(1<<WGM12) ; Taktfrequenz Vorteiler 1 gewaehlt (fuer Simaulatortest) ; ldi temp,(1<<CS10)|(1<<CS11)|(1<<WGM12) ; Taktfrequenz mit Vorteiler 64 gewaehlt out TCCR1B,temp ; ldi temp,HIGH(Timerwert) out OCR1AH,temp ldi temp,LOW(Timerwert) out OCR1AL,temp ; ldi temp,(0<<COM1A1)|(0<<COM1A0) out TCCR1A,temp ldi temp,(1<<OCIE1A) ; Timer1 Overflow aktivieren out TIMSK,temp ; clr Temp ;Temp mit 0b00000000 bzw. 0x00 laden out TAST_DDR, Temp ;PORTD als Eingang ser Temp ;Temp mit 0b11111111 bzw. 0xFF laden out TAST_PIN, temp ;STK500 schaltet gegen GND - Taste gedreuckt (Pin==0) out TAST_PORT, temp ;PullUp an PortD einschalten out LED_DDR,Temp ;PORTB als Ausgang out LED_PORT, temp ;PORTB (LEDs) aus ; ; Tastenzustände aller Tasten auf Null setzen clr r16 ; mov rTASTE1_0_ZST,r16 ; Taste0 und Taste1 zurücksetzen mov rTASTE5_4_ZST,r16 ; Taste2 und Taste3 zurücksetzen ; sei ; MAIN: sbrc rLED_Update_SPRR,0 ; kein LED_Update, wenn Bit0 ==0 rcall LED_Update rjmp MAIN ; LED_Update: ; ; LED_PORT auslesen - mit TastenZustand verarbeiten - LED_PORT ausgeben push temp in temp, LED_PORT ; LED_PORT einlesen eor temp, rTastFlanken ; toggle das Bit im LED_PORT fuer das eine Flanke in rTastFlanken ansteht out LED_PORT,temp ; LED_PORT augeben cbr rLED_Update_SPRR,1 ; loesche Bit0, um LED_Update bis zur naechsten TIMER1_ISR zu sperren clr rTastFlanken ; setze rTastFlanken zum erneuten Beschreiben auf 0x00 pop temp ret ; /*------------------------------------- INTERRUPTDIENST TIMER1_COMPA_ISR Die Interruptdienstprogramm TIMER1_COMPA_ISR wird vom Output-Match-Interrupt von Timer1 ausgelöst. Es liest die aktuellen Messwerte der Tasten vom TAST_PIN ab und berechnet für jede Taste den neuen Zustand (Z-Wert). Eingansgrössen: keine Ausgangsgrössen: keine geänderte Register keine Anzahl Zyklen */ TIMER1_COMPA_ISR: push r25 in r25,SREG push r16 push r17 push r18 push zl push zh /* Das hier hattest Du übersehen: Der Zeiger auf die Übergangstabelle muss VOR (!!) dem Aufruf von NEXT0_TAST_ZST in die Register zh:zl geladen werden !! */ ldi zl,LOW(TBL_UEBERGANG_01) ; zh:zl := Zeiger auf Übergangstabelle ... ldi zh,HIGH(TBL_UEBERGANG_01) ; ...wird für NEXT0_TAST_ZST gebraucht ; Betätigungszustand der Tasten einlesen und der Reihe nach verarbeiten in r18,TAST_PIN ; r18 := Messwerte aller Pins com r18 ; invertier r18 ; ; Taste0 und Taste1 verarbeiten und in Register TASTE1_0_ZST ; ; Taste0 verarbeiten (!!! Achtung unteres Nibble von rTASTE1_0_ZST 0bxxxx????) clr r19 ; Register r19 fuer temporaeres Register fuer swap bst r18,TASTE0_PIN ; überträgt den Messwert von TASTE0_PIN ins T-Flag von SREG ; lade TASTE1_0_ZST in R19 und loesche MSB (oberes Nibble) mov r16,rTASTE1_0_ZST ; r16 := Z-Wert Taste0 sbrc r16,3 ; wenn Flankenbit gesetzt setze Bit1 in rTastFlanken sbr rTastFlanken,0b00000001 ; andi r16,0x07 ; "Flankenbit" und MSB löschen rcall NEXT0_TAST_ZST ; Folgezustand für Taste0 in r16 berechnen andi r16,0x0F ; loesche MSB fuer or ; schiebe rTASTE1_0_ZST in R19 und loesche LSB fuer neues Z von Taste0 mov r19, rTASTE1_0_ZST andi r19,0xF0 ; loesche altes Z (LSB) or r16, r19 ; vereine MSB und LSB in rTASTE1_0_ZST mov rTASTE1_0_ZST,r16 ; neuen Z-Wert von Taste0 in TASTE1_0_ZST speichern ; ; Taste1 verarbeiten (!!! Achtung oberes Nibble von rTASTE1_0_ZST 0b????xxxx) clr r19 ; Register r19 fuer temporaeres Register fuer swap bst r18,TASTE1_PIN ; überträgt den Messwert von TASTE1_PIN ins T-Flag von SREG ; lade TASTE1_0_ZST in R19 und loesche MSB (oberes Nibble) mov r19, rTASTE1_0_ZST swap r19 ; tausche MSB mit LSB sbrc r19,3 ; wenn Flankenbit gesetzt setze Bit2 in rTastFlanken sbr rTastFlanken,0b00000010 ; andi r19,0x07 ; loesche MSB (eigentlichliches LSB) und "Flankenbit" mov r16,r19 ; r16 := Z-Wert Taste1 rcall NEXT0_TAST_ZST ; Folgezustand für Taste1 in r16 berechnen swap r16 ; tausche MSB mit LSB ; schiebe rTASTE1_0_ZST in R19 und loesche MSB fuer neues Z von Taste1 mov r19, rTASTE1_0_ZST andi r19,0x0F ; loesche altes Z (MSB) or r16, r19 ; vereine MSB und LSB in rTASTE1_0_ZST mov rTASTE1_0_ZST,r16 ; neuen Z-Wert von Taste1 in TASTE1_0_ZST speichern ; ; Taste2 und Taste3 verarbeiten und in Register TASTE3_2_ZST ; ; Taste2 verarbeiten (!!! Achtung unteres Nibble von rTASTE3_2_ZST 0bxxxx????) clr r19 ; Register r19 fuer temporaeres Register fuer swap bst r18,TASTE2_PIN ; überträgt den Messwert von TASTE2_PIN ins T-Flag von SREG ; lade TASTE3_2_ZST in R19 und loesche MSB (oberes Nibble) mov r16,rTASTE3_2_ZST ; r16 := Z-Wert Taste0 sbrc r16,3 ; wenn Flankenbit gesetzt setze Bit3 in rTastFlanken sbr rTastFlanken,0b00000100 ; andi r16,0x07 ; "Flankenbit" und MSB löschen rcall NEXT0_TAST_ZST ; Folgezustand für Taste2 in r16 berechnen andi r16,0x0F ; loesche MSB fuer or ; schiebe rTASTE3_2_ZST in R19 und loesche LSB fuer neues Z von Taste2 mov r19, rTASTE3_2_ZST andi r19,0xF0 ; loesche altes Z (LSB) or r16, r19 ; vereine MSB und LSB in rTASTE3_2_ZST mov rTASTE3_2_ZST,r16 ; neuen Z-Wert von Taste2 in TASTE3_2_ZST speichern ; ; Taste3 verarbeiten (!!! Achtung oberes Nibble von rTASTE3_2_ZST 0b????xxxx) clr r19 ; Register r19 fuer temporaeres Register fuer swap bst r18,TASTE3_PIN ; überträgt den Messwert von TASTE3_PIN ins T-Flag von SREG ; lade TASTE3_2_ZST in R19 und loesche MSB (oberes Nibble) mov r19, rTASTE3_2_ZST swap r19 ; tausche MSB mit LSB sbrc r19,3 ; wenn Flankenbit gesetzt setze Bit4 in rTastFlanken sbr rTastFlanken,0b00001000 ; andi r19,0x07 ; loesche MSB (eigentlichliches LSB) und "Flankenbit" mov r16,r19 ; r16 := Z-Wert Taste1 rcall NEXT0_TAST_ZST ; Folgezustand für Taste3 in r16 berechnen swap r16 ; tausche MSB mit LSB ; schiebe rTASTE3_2_ZST in R19 und loesche MSB fuer neues Z von Taste1 mov r19, rTASTE3_2_ZST andi r19,0x0F ; loesche altes Z (MSB) or r16, r19 ; vereine MSB und LSB in rTASTE3_2_ZST mov rTASTE3_2_ZST,r16 ; neuen Z-Wert von Taste3 in TASTE3_2_ZST speichern ; ; Taste5 und Taste4 verarbeiten und in Register TASTE5_4_ZST ; ; Taste4 verarbeiten (!!! Achtung unteres Nibble von rTASTE5_4_ZST 0bxxxx????) clr r19 ; Register r19 fuer temporaeres Register fuer swap bst r18,TASTE4_PIN ; überträgt den Messwert von TASTE4_PIN ins T-Flag von SREG ; lade TASTE5_4_ZST in R19 und loesche MSB (oberes Nibble) mov r16,rTASTE5_4_ZST ; r16 := Z-Wert Taste0 sbrc r16,3 ; wenn Flankenbit gesetzt setze Bit5 in rTastFlanken sbr rTastFlanken,0b00010000 ; andi r16,0x07 ; "Flankenbit" und MSB löschen rcall NEXT0_TAST_ZST ; Folgezustand für Taste4 in r16 berechnen andi r16,0x0F ; loesche MSB fuer or ; schiebe rTASTE5_4_ZST in R19 und loesche LSB fuer neues Z von Taste4 mov r19, rTASTE5_4_ZST andi r19,0xF0 ; loesche altes Z (LSB) or r16, r19 ; vereine MSB und LSB in rTASTE1_0_ZST mov rTASTE5_4_ZST,r16 ; neuen Z-Wert von Taste4 in TASTE5_4_ZST speichern ; ; Taste5 verarbeiten (!!! Achtung oberes Nibble von rTASTE5_4_ZST 0b????xxxx) clr r19 ; Register r19 fuer temporaeres Register fuer swap bst r18,TASTE5_PIN ; überträgt den Messwert von TASTE5_PIN ins T-Flag von SREG ; lade TASTE5_4_ZST in R19 und loesche MSB (oberes Nibble) mov r19, rTASTE5_4_ZST swap r19 ; tausche MSB mit LSB sbrc r19,3 ; wenn Flankenbit gesetzt setze Bit6 in rTastFlanken sbr rTastFlanken,0b00100000 ; andi r19,0x07 ; loesche MSB (eigentlichliches LSB) und "Flankenbit" mov r16,r19 ; r16 := Z-Wert Taste1 rcall NEXT0_TAST_ZST ; Folgezustand für Taste1 in r16 berechnen swap r16 ; tausche MSB mit LSB ; schiebe rTASTE5_4_ZST in R19 und loesche MSB fuer neues Z von Taste5 mov r19, rTASTE5_4_ZST andi r19,0x0F ; loesche altes Z (MSB) or r16, r19 ; vereine MSB und LSB in rTASTE5_4_ZST mov rTASTE5_4_ZST,r16 ; neuen Z-Wert von Taste5 in TASTE5_4_ZST speichern ; ; Taste6 und Taste7 verarbeiten und in Register TASTE7_6_ZST ; ; Taste6 verarbeiten (!!! Achtung unteres Nibble von rTASTE7_6_ZST 0bxxxx????) clr r19 ; Register r19 fuer temporaeres Register fuer swap bst r18,TASTE6_PIN ; überträgt den Messwert von TASTE6_PIN ins T-Flag von SREG ; lade TASTE7_6_ZST in R19 und loesche MSB (oberes Nibble) mov r16,rTASTE7_6_ZST ; r16 := Z-Wert Taste0 sbrc r16,3 ; wenn Flankenbit gesetzt setze Bit7 in rTastFlanken sbr rTastFlanken,0b01000000 ; andi r16,0x07 ; "Flankenbit" und MSB löschen rcall NEXT0_TAST_ZST ; Folgezustand für Taste6 in r16 berechnen andi r16,0x0F ; loesche MSB fuer or ; schiebe rTASTE7_6_ZST in R19 und loesche LSB fuer neues Z von Taste6 mov r19, rTASTE7_6_ZST andi r19,0xF0 ; loesche altes Z (LSB) or r16, r19 ; vereine MSB und LSB in rTASTE7_6_ZST mov rTASTE7_6_ZST,r16 ; neuen Z-Wert in TASTE6_ZST speichern ; ; Taste7 verarbeiten (!!! Achtung oberes Nibble von rTASTE7_6_ZST 0b????xxxx) clr r19 ; Register r19 fuer temporaeres Register fuer swap bst r18,TASTE7_PIN ; überträgt den Messwert von TASTE7_PIN ins T-Flag von SREG ; lade TASTE7_6_ZST in R19 und loesche MSB (oberes Nibble) mov r19, rTASTE7_6_ZST swap r19 ; tausche MSB mit LSB sbrc r19,3 ; wenn Flankenbit gesetzt setze Bit8 in rTastFlanken sbr rTastFlanken,0b10000000 ; andi r19,0x07 ; loesche MSB (eigentlichliches LSB) und "Flankenbit" mov r16,r19 ; r16 := Z-Wert Taste1 rcall NEXT0_TAST_ZST ; Folgezustand für Taste7 in r16 berechnen swap r16 ; tausche MSB mit LSB ; schiebe rTASTE7_6_ZST in R19 und loesche MSB fuer neues Z von Taste7 mov r19, rTASTE7_6_ZST andi r19,0x0F ; loesche altes Z (MSB) or r16, r19 ; vereine MSB und LSB in rTASTE7_6_ZST mov rTASTE7_6_ZST,r16 ; neuen Z-Wert von Taste7 rTASTE7_6_ZST speichern ; ; ; sbr rLED_Update_SPRR,1 ; Status fuer LED_Update pop zh pop zl pop r18 pop r17 pop r16 out SREG,r25 pop r25 reti ; /*------------------------------------- PROZEDUR NEXT0_TAST_ZST Die Prozedur NEXT0_TAST_ZST liest den Folgezustand der Tastenentprellung aus einer Übergangstabelle aus. Die Adresse der Tabelle wird in zh:zl übergeben. Der aktuelle Zustand (Z-Wert) wird in r16 übergeben. Der aktuelle Tastenzustand (betätigt/nicht betätigt) ist im T-Flag von SREG gespeichert. Das Ergebnis wird in r16 zurückgegeben. Die Tabelle, darf maximal 127 Einträge enthalten. Der erste Eintrag der Tabelle ist die Länge der Tabelle und dient der Bereichsüberprüfung. D.h. der Zeiger auf die Übergangstabelle muss zh:zl geladen werden BEVOR diese Prozedur aufgerufen wird!! In diesem Beispiel, bei dem nur eine einzige Übergangstabelle im Spiel ist, könnte man zh:zl auch innerhalb von NEXT0_TAST_ZST laden. Um die Prozedur auch in Programmen verwenden zu können, in denen mehrere Zustandsautomaten nebeneinanderherlaufen, ist es sinnvoll, den Zeiger vorher zu laden. Dann kann je nach Aufgabe eine andere Tabelle verwendet werden. Kommt in meinen Programmen öfters vor ;-). Eingansgrössen: r16 : enthält aktuellen Z-Wert der Taste zh:zl : enthält Zeiger auf die Übergangstabelle SREG (T-Flag) : enthält den aktuellen Messwert der Taste T = 0 : Taste nicht betätigt T = 1 : Taste betätigt Ausgangsgrössen: r16 : enthält den neuen Z-Wert für die Taste zh:zl unverändert SREG unverändert geänderte Register r16 Anzahl Zyklen */ NEXT0_TAST_ZST: push r17 in r17,SREG push r17 push r18 push zl push zh ; Zeiger auf Anfang der Übergangstabelle berechnen add zl,zl ; zh:zl verdoppeln, weil einer Adresse im... adc zh,zh ; .. Programmspeicher immer zwei Bytes entsprechen ; ; ; Information in Bit7 löschen; Tabelle darf nicht länger als 127 Einträge sein andi r16,0x7F ; ; Tabellenlänge einlesen (0-ter Eintrag in der Tabelle) lpm r17,z+ ; r17 := TBL_LNG einlesen ; lpm r18,z+ ; zweites Byte überlesen, wird nicht gebraucht ; Bereichsprüfung ( r17 < TBL_LNG ) cp r16,r17 ; Tabellenindex mit TBL_LNG vergleichen brlt NXT0ZST_00 ; Sprung, wenn Tabellenindex iO (wenn r16 kleiner r17) ; Fehler: Tabellenindex ist zu gross clr r16 ; Zustand auf Null setzen rjmp NXT0ZST_EXIT ; fertig NXT0ZST_00: ; Tabellenindex im zulässigen Bereich clr r17 ; add zl,r16 ; Index zweimal zum Zeiger addieren, weil... adc zh,r17 ; ... in der Tabelle... add zl,r16 ; ... 2-Byte-Worte gespeichert sind. adc zh,r17 ; zh:zl := Zeiger auf Tabelleneintrag lpm r16,z+ ; r16 := Folgezustand für T=0 lpm r17,z ; r17 := Folgezustand für T=1 brtc NXT0ZST_EXIT ; fertig, wenn T = 0 ; T = 1, d.h. Taste betätigt mov r16,r17 ; zweiten Eintrag als Folgezustand verwenden NXT0ZST_EXIT: pop zh pop zl pop r18 pop r17 out SREG,r17 pop r17 ret ;

Im Simulator schaut es eigentlich so aus, ich es erwartet habe.
Aber als ich das Programm zum finalen Test in den µC uebertragen hatte, ging erst einaml gar nichts.. :-(
Nach ein paar Veraenderungen am Timer, stellte sich dann aber doch ein wenig Freude ein.
Leider konnte ich meinen Fehler bis jetzt noch nicht lokalisieren.
Mit meinen 8MHz Quarz wollte ich alle 0,2 sec eine ISR ausloesen.
Entweder meine Timerberechnung sind falsch, oder meine Timereinstellungen, oder mein STK500 betreibt den µC doch nicht mit dem Quarz..ODER?
Den Vorteiler habe ich mit 64 fuer den Timer1 gewaehlt. und vorladen wollte ich ihn mit -24999 dmit ich ca. auf 0,2 sec komme.
die Einstellungen habe ic hso gewaehlt:

Code:

ldi temp,(1<<CS10)|(1<<CS11)|(1<<WGM12) ; Taktfrequenz mit Vorteiler 64 gewaehlt out TCCR1B,temp ; ldi temp,HIGH(Timerwert) out OCR1AH,temp ldi temp,LOW(Timerwert) out OCR1AL,temp

Desweiteren wollte ich noch eine "Gedaechtnisfunktion" mit einbauen - den letzten LED-Stand ins EEPROM uebertragen. So soll der letzte Status nach dem
Aus- und wieder Einschalten erhalten und geschalten werden.
????
Wie spreche ich das EEPROM genau an?

Liste der Anhänge anzeigen (Anzahl: 1)

robo_wolf,

das sieht doch schon gut aus :-) ! Meine Kommentare habe ich in den Quelltext geschrieben. Deine Fragen zum Timer habe ich auch dort beantwortet (siehe Anhang).

Das EEPROM ist ein sehr praktischer Bestandteil der ATmegas. Ich benutze zum Lesen und Schreiben ziemlich genau die Prozeduren die im Datenblatt auf Seite 22 und 23 vorgestellt werden. Die funktionieren sehr zuverlässig.

Ciao,

mare_crisium

Hallo mare_crisium,
erst einmal wieder ein grosses DANKE.

Den Fehler mit den nichtbeachteten Comparemodus habe ich gestern morgen auch endeckt.
Der im Code stehende Wert von "155" kam durch das Probieren bzw. Fehlersuchen.
Der eigentliche Wert von "-24999" ist aber, wie Du schon angemerkt hast, auch falsch und haette "24999" fuer den Comparemodus heissen muessen.
Bei der Fehlersuche habe ich erst die Hardware ausgeschlossen, in dem ich ein reines Timerprogramm geschrieben hatte.
Dabei ist mir dann der Fehler aufgefallen.

Mit den veralteten Kommentaren hast Du vollkommen Recht. >>>Kopieren, >>>verbessern und dann doch >>>anders realisiert - dabei die Kommentare vergessen.

Hierzu braeuchte ich noch ein wenig Hilfe:
#####
"Gute Idee, die Flankenbits gleich mundgerecht fürs Togglen auszulagern :-)! Du kannst das
noch eleganter hinkriegen, indem Du die Tasten in umgekehrter Reihenfolge auswertest und
das Flankenbit immer von rechts in rTastFlanken einschiebst (mit „lsl“-Anweisung). Ich würde
den ganzen Vorgang direkt nach dem Aufruf von „NEXT0_TAST_ZST“ verschieben, dann erwischst
Du die Flanke sofort nachdem sie erkannt wurde."
#####
meinst Du es so?:
clc
sbrc r16,3
sec
lsl rTastFlanken
clc - loesche das CaryFlag "0"
sbrc r16,3 - ist das Bit3 von r16(FlankenBit) nicht gesetzt Ueberspringe das >>>
sec - setzen des CaryFlag "1"
lsl rTastFlanken - schiebt dann, in Abhaengigkeit vom FlankenBit, das gesetzte bzw. nicht gesetzte CaryFlag ins Register rTastFlanken.
xxxx xxxx ; xxxx xxx0 ; xxxx xx01 ; xxxx x011 ; xxxx 0111 ; xxx0 1111 ; xx01 1110 ; x011 1100 ; 0111 1001
// Frage: Warum nicht "lsr"? - Dann kann die bisherige Reihenfolge bestehen bleiben.
xxxx xxxx ; 0xxx xxxx ; 10xx xxxx ; 110x xxxx ; 1110 xxxx ; 1111 0xxx ; 0111 10xx ; 0011 110x ; 1001 1110

Das mit den macro ist ne tolle Sache.
Hatte ich auch noch nie verwendet. Und hier nun ein sinnvolles, praktisches Bsp.
>>> wiederkehrende Prozesse sollte man ausgliedern <<< :-)

Habe noch einen weiteren Fehler gefunden. Auch der hat sich mir erst in der Praxis geboten.
Nachdem ich ja das Problem mit dem Timer nicht gleich gefunden hatte, probierte ich unterschiedliche Einstellungen aus ( der Wert "155") z.B.
Meine Programm hat nur sehr schlecht, das gemacht was es sollte.
Das Druecken der Taste bewirkte zwar ein Einschalten und Ausschalten der LED ... aber nur wenn der ISR Abstand gross gewaehlt war
und auch nicht immer...
Mein Fehler ist, dass eine Flanke nur das FlankenBit auswerte. Dabei ausser Betracht lasse, wo diese herkommt.
Bit 3 von "F" oder von "8"... boeser Denkfehler
Eine Moeglichkeit ware nun zwei Register r0TastFlanken und r1TastFlanken mit der Auswertung von "F" und "8" anstatt von Bit 3 zu befuellen.
Ueber eine weitere Moeglichkeit denke ich noch nach.... :-)

robo_wolf,

Zitat:

Zitat von robo_wolf

meinst Du es so?:

Jup, genau so - bis auf den Fehler, den diesmal ich eingebaut habe :oops: : Mit der "lsl"-Anweisung wird immer eine Null von rechts in das Register eingeschoben. Wenn man das Carry-Flag von rechts einschieben will, muss man die "rol"-Anweisung nehmen! Sorry. Es muss also so heissen:

Code:

clc sbrc r16,3 sec rol rTastFlanken

Natürlich kannst Du die Flankenbits auch von links her einschieben ("ror"-Anweisung); nur ist das Flankenbyte dann nicht automatisch rechtsbündig, d.h. bis Bit0 besetzt. Es sei denn, Du hättest genau 8 Tasten verarbeitet.

Zitat:

Zitat von robo_wolf

Bit 3 von "F" oder von "8"... boeser Denkfehler

Ich wollte Dir sowieso vorschlagen, einfach das Bit0 des Z-Wertes zum Steuern der LED zu verwenden. Das zeigt direkt den aktuellen Tastenzustand an. Das Flankenbit könntest Du verwenden, um zu entscheiden, ob die LED ihren Leuchtzustand ändern muss oder nicht. Sich nur auf die Flanke zu verlassen ist riskant. Wie Du ja festgestellt hast, kommt man da leicht aus dem Tritt.

Ciao,

mare_crisium

Hallo mare_crisium,

habe den Code umgeschrieben und einige Probleme damit gehabt.
Thema macro:
eigendlich hatte ich mir ein macro fuer das Sichern der Flanke nach Deinen Tipps gemacht...
Aber bin dabei auf folgende Probleme gestossen:
Zum Einen hatte ich das macro unter die ISR gesetzt und mich dann beim assemblieren gewundert, warum 2 Fehlermeldungen kamen.
"unbekannte instruction oder macro.."
->>> macro muss vor dem Aufruf bekannt sein - habe es dann unter RESET abgelegt. -> Fehlermeldungen waren dann weg.
Mein 2. Problem tauchte dann auf als das macro ins Unterprogramm verzweigen sollte -
das Unterprogramm kam mit ret nicht mehr ins macro zurueck - dafuer aber leider zum RESET.

Code:

.macro _FLANKE_SICHERN clc cpi r16, 0x0F brne SET_CARY_FLAG rol rTastFlanken .endmacro ; ; SET_CARY_FLAG: sec ret

So habe ich dann doch sub´s verwendet.
FRAGE??? Das macro muss also vor dem Aufruf bekannt sein?
FRAGE??? Man kann im macro nicht verzweigen?
Habe mal wieder ein Gang zurueck geschaltet und nur Taste0 und Taste1 behandelt.
Ausserdem die ISR-Zeit deutlich eingekuerzt von 0,25 auf 0,05sec
0,25 war sehr traege - da ja erst nach dem 4. Durchlauf die Flanken gestetzt werden, sind es in Summe ja 1sec.
Das Auswerten der LOW_Flanke habe ich auch heraus gelassen - es soll ja nur bei HIGH eine Aenderung am LED_PORT geben.

Code:

;***** STK500 Lernprogramm Nr.4e1 ;*** Aufgabe: die Taste an PinD0 schaltet die zugeordnete LED auf dem STK500 ;*** 1. Tastendruck: LEDs einschalten ;*** 2. Tastendruck: LEDs ausschalten ;*** eine Timerroutine liest den TastenStatus ein ;*** zum Entprellen - muss die TimerRoutine 3mal hintereinander den gleichen Wert, ;*** einlesen um einen Tastzustand zu erkennen ;*** die Flanken der Tastzustaende werden in rTastFlanken gesammelt und schalten die LEDs um ;*** Taste nicht gedrueckt >>> log 0 ;*** Taste gedrueckt >>> log 1 ; ; .include "m8515def.inc" .def Temp = r16 ; Temporary Register .def rTastFlanken = r0 ; Zustandsvariable - beinhaltet eine 2Bit-Zahl zur Tastzustandserkennung .def rLED_Update_SPRR = r21 ; Sperrt die Ausfuehrung von TastenTest wenn, keine neuer TIMER1_OVL voran gegangen ; .equ Timerwert = 6249 ; Timerschritte bis zum Überlauf 0,05 sec ; .equ LED_PORT = PORTB ; LEDs .equ LED_DDR = PORTB-1 ; DataDirectory fuer LEDs ; .equ TAST_PORT= PORTD ; Tasten .equ TAST_DDR = PORTD-1 ; DataDirectory fuer TastenEingang .equ TAST_PIN = PORTD-2 ; TastenEingang ; ; Pinzuordnung für div. Tasten .equ TASTE0_PIN = 0 .equ TASTE1_PIN = 1 .equ TASTE2_PIN = 2 ; die Zuordnung der PINs muss ja nicht mit der TastenNr übereinstimmen! .equ TASTE3_PIN = 3 .equ TASTE4_PIN = 4 .equ TASTE5_PIN = 5 .equ TASTE6_PIN = 6 .equ TASTE7_PIN = 7 ; ; jetzt kommen die Register, die die Z-Werte der Tasten enthalten.. .def rTASTE1_0_ZST = r15 ; enthält Zustand Taste1 im oberen Nibble und 0 im unteren Nibble .def rTASTE3_2_ZST = r14 ; enthält Zustand Taste3 im oberen Nibble und 2 im unteren Nibble .def rTASTE5_4_ZST = r13 ; enthält Zustand Taste5 im oberen Nibble und 4 im unteren Nibble .def rTASTE7_6_ZST = r12 ; enthält Zustand Taste7 im oberen Nibble und 6 im unteren Nibble ; ; Vektortabelle ; rjmp RESET ; 1 - $000 RESET External Pin, Power-on Reset, Brown-out, Reset and Watchdog Reset reti ; 2 - $001 INT0 External Interrupt Request 0 reti ; 3 - $002 INT1 External Interrupt Request 1 reti ; 4 - $003 TIMER1 CAPT Timer/Counter1 Capture Event rjmp TIMER1_COMPA_ISR ; 5 - $004 TIMER1 COMPA Timer/Counter1 Compare Match A reti ; 6 - $005 TIMER1 COMPB Timer/Counter1 Compare Match B reti ; 7 - $006 TIMER1 OVF Timer/Counter1 Overflow reti ; 8 - $007 TIMER0 OVF Timer/Counter0 Overflow reti ; 9 - $008 SPI, STC Serial Transfer Complete reti ; 10 - $009 USART, RXC USART, Rx Complete reti ; 11 - $00A USART, UDRE USART Data Register Empty reti ; 12 - $00B USART, TXC USART, Tx Complete reti ; 13 - $00C ANA_COMP Analog Comparator reti ; 14 - $00D INT2 External Interrupt Request 2 reti ; 15 - $00E TIMER0 COMP Timer/Counter0 Compare Match reti ; 16 - $00F EE_RDY EEPROM Ready reti ; 17 - $010 SPM_RDY Store Program memory Ready ; TBL_UEBERGANG_01: .dw 0x0008 ; Tabellenlänge ; T = 0 T = 1 .dw 0x0200 ; Z=0 -> Z=0,Flanke=0 / Z=2,Flanke=0 .dw 0x0308 ; Z=1 -> Z=0,Flanke=1 / Z=3,Flanke=0 .dw 0x0400 ; Z=2 -> Z=0,Flanke=0 / Z=4,Flanke=0 .dw 0x0501 ; Z=3 -> Z=1,Flanke=0 / Z=5,Flanke=0 .dw 0x0602 ; Z=4 -> Z=2,Flanke=0 / Z=6,Flanke=0 .dw 0x0703 ; Z=5 -> Z=3,Flanke=0 / Z=7,Flanke=0 .dw 0x0F04 ; Z=6 -> Z=4,Flanke=0 / Z=F,Flanke=1 .dw 0x0705 ; Z=7 -> Z=5,Flanke=0 / Z=7,Flanke=0 ; RESET: ; ldi r16, LOW(RAMEND) ;Stack initialisieren out SPL, r16 ldi r16, HIGH(RAMEND) out SPH, r16 ; ; ldi temp,(1<<CS10)|(1<<WGM12) ; Taktfrequenz Vorteiler 1 gewaehlt (fuer Simaulatortest) ldi temp,(1<<CS10)|(1<<CS11)|(1<<WGM12) ; Taktfrequenz mit Vorteiler 64 gewaehlt out TCCR1B,temp ; ldi temp,HIGH(Timerwert) out OCR1AH,temp ldi temp,LOW(Timerwert) out OCR1AL,temp ; ldi temp,(0<<COM1A1)|(0<<COM1A0) out TCCR1A,temp ldi temp,(1<<OCIE1A) ; Timer1 Overflow aktivieren out TIMSK,temp ; clr Temp ;Temp mit 0b00000000 bzw. 0x00 laden out TAST_DDR, Temp ;PORTD als Eingang ser Temp ;Temp mit 0b11111111 bzw. 0xFF laden out TAST_PIN, temp ;STK500 schaltet gegen GND - Taste gedreuckt (Pin==0) out TAST_PORT, temp ;PullUp an PortD einschalten out LED_DDR,Temp ;PORTB als Ausgang out LED_PORT, temp ;PORTB (LEDs) aus ; ; Tastenzustände aller Tasten auf Null setzen clr r16 ; mov rTASTE1_0_ZST,r16 ; Taste0 und Taste1 zurücksetzen mov rTASTE5_4_ZST,r16 ; Taste2 und Taste3 zurücksetzen ; sei ;???? ; hier soll das Ruecksichern aus dem EEPROM erfolgen - ; lds temp, ???? ; und ; out LED_PORT, temp ;!!!! MAIN: sbrc rLED_Update_SPRR,0 ; kein LED_Update, wenn Bit0 ==0 rcall LED_Update rjmp MAIN ; LED_Update: ; ; LED_PORT auslesen - mit TastenZustand verarbeiten - LED_PORT ausgeben push temp in temp, LED_PORT ; LED_PORT einlesen eor temp, rTastFlanken ; toggle das Bit im LED_PORT fuer das eine Flanke in rTastFlanken ansteht out LED_PORT,temp ; LED_PORT augeben ;???? ; hier soll noch ins EEPROM gesichert werden ; sts ????, temp ; LED_PORT sichern ;!!!! cbr rLED_Update_SPRR,1 ; loesche Bit0, um LED_Update bis zur naechsten TIMER1_ISR zu sperren clr rTastFlanken ; setze rTastFlanken zum erneuten Beschreiben auf 0x00 pop temp ret ; /*------------------------------------- INTERRUPTDIENST TIMER1_COMPA_ISR Die Interruptdienstprogramm TIMER1_COMPA_ISR wird vom Output-Match-Interrupt von Timer1 ausgelöst. Es liest die aktuellen Messwerte der Tasten vom TAST_PIN ab und berechnet für jede Taste den neuen Zustand (Z-Wert). Eingansgrössen: keine Ausgangsgrössen: keine geänderte Register keine Anzahl Zyklen */ TIMER1_COMPA_ISR: push r25 in r25,SREG push r1 ; Register r1 - temporaeres Register fuer Unterprogramme push r20 ; Register r20 - temp. Bit fuer rTastFlanken(uebergibt Unterprogramm den Tastursprung) push r16 push r17 push r18 push r19 ; Register r19 - temporaeres Register fuer swap push zl push zh ; ldi zl,LOW(TBL_UEBERGANG_01) ; zh:zl := Zeiger auf Übergangstabelle ... ldi zh,HIGH(TBL_UEBERGANG_01) ; ...wird für NEXT0_TAST_ZST gebraucht ; ; Betätigungszustand der Tasten einlesen und der Reihe nach verarbeiten in r18,TAST_PIN ; r18 := Messwerte aller Pins com r18 ; invertier r18 ; ; Taste1 und Taste0 verarbeiten und in Register TASTE1_0_ZST ; ; Taste1 verarbeiten (!!! Achtung oberes Nibble von rTASTE1_0_ZST 0b????xxxx) rcall CLEAR_REGISTER ldi r20, 2 ; tmp. Tastenursprung - fuer Bitbestimmung in rTastFlanken bst r18,TASTE1_PIN ; überträgt den Messwert von TASTE1_PIN ins T-Flag von SREG ; lade TASTE1_0_ZST in R1 und loesche MSB (oberes Nibble) mov r1, rTASTE1_0_ZST ; temp Register fuer SET_XXX_NIBBLE - uebernimmt rTastx_y_ZST rcall GET_HIGH_NIBBLE ; hole HIGH_NIBBLE nach r16 rcall FLANKE_SICHERN ; andi r16,0x07 ; loesche MSB (eigentlichliches LSB) und "Flankenbit" mov r19,r16 ; r16 := Z-Wert Taste1 rcall NEXT0_TAST_ZST ; Folgezustand für Taste1 in r16 berechnen rcall SET_HIGH_NIBBLE ; bereite HIGH_NIBBLE fuer Ruecksichern vor mov rTASTE1_0_ZST,r16 ; neuen Z-Wert von Taste1 in TASTE1_0_ZST speichern ; ; Taste0 verarbeiten (!!! Achtung unteres Nibble von rTASTE1_0_ZST 0bxxxx????) rcall CLEAR_REGISTER ldi r20, 1 ; tmp. Tastenursprung bst r18,TASTE0_PIN ; überträgt den Messwert von TASTE0_PIN ins T-Flag von SREG ; lade TASTE1_0_ZST in R1 und loesche MSB (oberes Nibble) mov r1, rTASTE1_0_ZST ; temp Register fuer SET_XXX_NIBBLE rcall GET_LOW_NIBBLE ; hole LOW_NIBBLE nach r16 rcall FLANKE_SICHERN ; andi r16,0x07 ; "Flankenbit" und MSB löschen rcall NEXT0_TAST_ZST ; Folgezustand für Taste0 in r16 berechnen rcall SET_LOW_NIBBLE ; bereite LOW_NIBBLE fuer Ruecksichern vor mov rTASTE1_0_ZST,r16 ; neuen Z-Wert von Taste0 in TASTE1_0_ZST speichern ; sbr rLED_Update_SPRR,1 ; setze Status fuer LED_Update ; pop zh pop zl pop r20 pop r19 pop r18 pop r17 pop r16 pop r1 out SREG,r25 pop r25 reti ; ; Vergleich ob im Flanke fuer gedrueckte Taste(0xF) erreicht wurde - ; bei Erreichen wird eine 1 ; bei nicht Erreichen eine 0 in rTASTFLANKEN mit Hilfe des CARY_FLAGs von links nach rechts rotiert ; CLEAR_REGISTER: clr r1 ; Register r1 - temporaeres Register fuer Unterprogramme clr r16 ; Register r16 clr r19 ; Register r19 - temporaeres Register fuer swap clr r20 ; Register r20 - temporaeres Register fuer Unterprogramme ret ; GET_HIGH_NIBBLE: mov r16, r1 swap r16 ; tausche MSB mit LSB ret ; GET_LOW_NIBBLE: mov r16,r1 ; r16 := Z-Wert Taste0 ret ; ; Flanke sichern ; hatte es mit dem links schieben versucht, aber mit der zusaetzlichen Variablen r20 bin ich flexibler in der Tastenwahl ; FRAGE??? ; meine Loesung funktioniert zwar - aber scheint umstaendlich ; wie kann ich es in einem Unterprogramm realisieren? ; ; setze Tast_FLAG wenn rTastx.. oder ..y_ZST 0b00001111 erreicht FLANKE_SICHERN: cpi r16, 0x0F breq SET_TAST_FLAG ret ; SET_TAST_FLAG: or rTastFlanken, r20 ret ; SET_HIGH_NIBBLE: swap r16 ; tausche MSB mit LSB ; schiebe rTASTE1_0_ZST in R19 und loesche MSB fuer neues Z von Taste1 mov r19, r1 ; hole rTASTx_y_ZST in r19 andi r19,0x0F ; loesche altes Z (MSB) or r16, r19 ; vereine MSB und LSB in rTASTE1_0_ZST ret ; SET_LOW_NIBBLE: ; schiebe rTASTEx_y_ZST in R19 und loesche LSB fuer neues Z von jeweiligen Taste andi r16,0x0F ; loesche MSB fuer or mov r19, r1 ; hole rTASTx_y_ZST in r19 andi r19,0xF0 ; loesche altes Z (LSB) or r16, r19 ; vereine MSB und LSB in rTASTE1_0_ZST ret ; /*------------------------------------- PROZEDUR NEXT0_TAST_ZST Die Prozedur NEXT0_TAST_ZST liest den Folgezustand der Tastenentprellung aus einer Übergangstabelle aus. Die Adresse der Tabelle wird in zh:zl übergeben. Der aktuelle Zustand (Z-Wert) wird in r16 übergeben. Der aktuelle Tastenzustand (betätigt/nicht betätigt) ist im T-Flag von SREG gespeichert. Das Ergebnis wird in r16 zurückgegeben. Die Tabelle, darf maximal 127 Einträge enthalten. Der erste Eintrag der Tabelle ist die Länge der Tabelle und dient der Bereichsüberprüfung. D.h. der Zeiger auf die Übergangstabelle muss zh:zl geladen werden BEVOR diese Prozedur aufgerufen wird!! In diesem Beispiel, bei dem nur eine einzige Übergangstabelle im Spiel ist, könnte man zh:zl auch innerhalb von NEXT0_TAST_ZST laden. Um die Prozedur auch in Programmen verwenden zu können, in denen mehrere Zustandsautomaten nebeneinanderherlaufen, ist es sinnvoll, den Zeiger vorher zu laden. Dann kann je nach Aufgabe eine andere Tabelle verwendet werden. Kommt in meinen Programmen öfters vor ;-). Eingansgrössen: r16 : enthält aktuellen Z-Wert der Taste zh:zl : enthält Zeiger auf die Übergangstabelle SREG (T-Flag) : enthält den aktuellen Messwert der Taste T = 0 : Taste nicht betätigt T = 1 : Taste betätigt Ausgangsgrössen: r16 : enthält den neuen Z-Wert für die Taste zh:zl unverändert SREG unverändert geänderte Register r16 Anzahl Zyklen */ NEXT0_TAST_ZST: push r17 in r17,SREG push r17 push r18 push zl push zh ; Zeiger auf Anfang der Übergangstabelle berechnen add zl,zl ; zh:zl verdoppeln, weil einer Adresse im... adc zh,zh ; .. Programmspeicher immer zwei Bytes entsprechen ; ; ; Information in Bit7 löschen; Tabelle darf nicht länger als 127 Einträge sein andi r16,0x7F ; ; Tabellenlänge einlesen (0-ter Eintrag in der Tabelle) lpm r17,z+ ; r17 := TBL_LNG einlesen ; lpm r18,z+ ; zweites Byte überlesen, wird nicht gebraucht ; Bereichsprüfung ( r17 < TBL_LNG ) cp r16,r17 ; Tabellenindex mit TBL_LNG vergleichen brlt NXT0ZST_00 ; Sprung, wenn Tabellenindex iO (wenn r16 kleiner r17) ; Fehler: Tabellenindex ist zu gross clr r16 ; Zustand auf Null setzen rjmp NXT0ZST_EXIT ; fertig NXT0ZST_00: ; Tabellenindex im zulässigen Bereich clr r17 ; add zl,r16 ; Index zweimal zum Zeiger addieren, weil... adc zh,r17 ; ... in der Tabelle... add zl,r16 ; ... 2-Byte-Worte gespeichert sind. adc zh,r17 ; zh:zl := Zeiger auf Tabelleneintrag lpm r16,z+ ; r16 := Folgezustand für T=0 lpm r17,z ; r17 := Folgezustand für T=1 brtc NXT0ZST_EXIT ; fertig, wenn T = 0 ; T = 1, d.h. Taste betätigt mov r16,r17 ; zweiten Eintrag als Folgezustand verwenden NXT0ZST_EXIT: pop zh pop zl pop r18 pop r17 out SREG,r17 pop r17 ret ;

robo_wolf,

ja, beim Definieren und Benutzen der Macros gibt's Einiges zu beachten; das hätte ich ausführlicher erklären sollen. Alle Macros müssen vor der ersten Verwendung definiert sein. Die Definition darf sogar vor der CSEG- bzw. der ORG-Anweisung stehen. Ist eigentlich auch logisch, bei der Definition ist es ja noch nicht Teil des Quelltextes.

Noch wichtiger ist, mit den Sprüngen und "ret"-Anweisung innerhalb Macros sehr vorsichtig umzugehen. Ich rate davon ab, Sprunganweisgungen zu verwenden, die aus dem Macro herausführen. Da verliert man zu schnell den Überblick. Reine "ret"-Anweisung in einem Macro führen im Allgemeinen direkt ins Nirwana, weil meist der Stack nicht richtig wiederhergestellt wird, oder gar keine Rückkehradresse auf dem Stack liegt.

Vorschlag: Am Übersichtlichsten ist es, alle Macros ganz am Anfang des Quelltextes, noch vor der CSEG- oder ORG-Anweisung zu definieren. Dann weiss man immer, wo man nachgucken kann, wenn man mal wieder vergessen hat, was sie eigentlich bewirkten. Keine "ret"-Anweisungen in einem Macro ohne vorherige "call"- oder "rcall"-Anweisung in demselben Macro. Sprünge nur innerhalb des Macros zulassen.

Damit sähe Dein Macro dann so aus:

Code:

.macro _FLANKE_SICHERN clc cpi r16, 0x0F brne PC+2 sec rol rTastFlanken .endmacro ;

Dabei verwende ich einen relativen Sprung: Die Anweisung "brne PC+1" bewirkt Folgendes: Wenn Gleichheit festgestellt wird, dann wird die Anweisung an der Adresse ausgeführt, auf die der PC (Program counter) gerade zeigt. Das ist die Anweisung direkt nach der "brne"-Anwesiung, also "sec". Wenn Ungleichheit festgestellt wird, dann springt das Programm zur Adresse PC+2, d.h. zur "rol"-Anweisung. Praktisch, gell :-) ? Das geht übrigens auch rückwärts, also PC-X. Die Sprungdistanz ist begrenzt (-128 bis +127).

Die "ret"-Anwweisung brauchst Du gar nicht. Das Macro verhält sich ja so, als ob Du ihren Quelltext mit "copy" und "paste" in den laufenden Quelltext eingefügt hättest.

Probier's mal, damit solltes klappen. Die Kommentare zu Nr. 4e1 kommen später :-) .

Ciao,

mare_crisium

EDIT: Den Fehler (Sprungweite) im Macro korrigiert.

Liste der Anhänge anzeigen (Anzahl: 1)

robo_wolf,

na, es doch geht voran ;-). Bevor wir neue "Features" in Angriff nehmen, ist es an der Zeit, sich noch einmal Überblick zu verschaffen, Überflüssiges bzw. Vermeidbares abzuschrauben und fertige Module in eine Bibliothek auszulagern (siehe Kommentare in angehängter pdf-Datei).

Als Quelltext darf ich's nicht einfügen, weil's angeblich mehr als 20000 Zeichen hat :-(. Leider musst Du den Text jetzt aus dem pdf herausfummeln.

Ciao,

mare_crisium

EDIT: Die Fehler verbessert (hoffentlich alle ;-) !), die robo_wolf entdeckt hat.

Hallo mare_crisium,
vielen Dank fuer den neuen Lehrstoff. :-))
Habe gleich ein paar Fragen dazu.
Im MACRO _FLANKEN_SICHERN hast Du "@0" verwendet und als Parameter beschrieben.

Code:

.macro _FLANKEN_SICHERN bst r16,3 bld rTAST_FLANKEN,(@0) .endmacro

..muss das "@0" in Klammern()?
oder muss nur der zu uebergebene Parameter "LED_TASTE_x" beim macro-Aufruf
_FLANKEN_SICHERN(LED_TASTE_x) in Klammern?
Eins muss ich aber noch gleich loswerden:
"Es ist schon eine sehr galante und uebersichtliche Loesung."

Im Uebergang von Seite 4 auf 5 ist mir eine Ungereimtheit aufgefallen.

Code:

SET_LOW_NIBBLE: push r25 in r25,SREG andi r16,0x0F ; oberes Nibble des Wertes in r16 (Quelle) löschen andi r19,0x0F ; unteres Nibble in r19 (Ziel) ebenfalls löschen or r19, r16 ; neuens oberes Nibble in r19 einfügen out SREG,r25 pop r25 ret

muss es hier nicht so heissen?(eventuell ein Tippfehler?)

Code:

SET_LOW_NIBBLE: push r25 in r25,SREG andi r16,0x0F ; oberes Nibble des Wertes in r16 (Quelle) löschen andi r19,0xF0 ; unteres Nibble in r19 (Ziel) ebenfalls löschen or r19, r16 ; neuens oberes Nibble in r19 einfügen out SREG,r25 pop r25 ret

An meinen Kommentaren muss ich auf jeden Fall noch arbeiten.
Im Nachhinein liest sich vieles nicht unbedingt verstaendlich - meine Kommentare beschreiben oft nur den eigentlichen Programmschritt.
Das ist fuer mich momentan natuerlich relevant, da mir viele Befehle neu und nicht gelaeufig sind.
Der Sinn der Befehlsfolge bleibt dann oft auf der Strecke... :-( >>> Verbesserungspotential

robo_wolf,

jup, hast recht mit Deinen Vermutungen: Die Prozedur SET_LOW_NIBBLE habe ich korrigiert, wie Du vorgeschlagen hast. Im Macro "FLANKEN_SICHERN" habe ich die Klammern gelöscht. Die korrigierte Version ist an meinem vorangehenden Posting angehängt.

Wo hast Du denn die "galante Lösung" her? Was ein Buchstabe doch für einen hübschen Unterschied machen kann :-) !

An den Kommentaren zu arbeiten lohnt sich immer. Der Aufwand für's Kommentieren wird aber mit der Zeit geringer, weil Du Deinen persönlichen Programmierstil entwickeln wirst. Das führt dann dazu, dass Du für typische Aufgaben bestimmte Befehlsfolgen verwenden wirst, deren Funktion Du auf Anhieb wiedererkennst. Dadurch erübrigen sich manche Kommentare von selbst.

Ciao,

mare_crisium

Hallo mare_crisium,
in Deinem Posting vom 01.03. hast Du die Loesung mit dem Manipulieren des PC beim macro beschrieben.
Beim Testen im Simulator bin ich leider nicht zum gewuenschten Erfolg gekommen.

Code:

.macro _FLANKE_SICHERN clc cpi r16, 0x0F brne PC+1 sec rol rTastFlanken .endmacro ;

PC+1 bewirkt doch nur einen Schritt weiter. In dem Fall des macro waere es "sec" bei Ungleichheit und bei Gleichheit ist es auch nur "sec". PC+2 waere dann "rol"-Anweisung und damit funktioniert es auch im Simulator.

Du wolltest mich testen? ;-)

Zitat:

Zitat von robo_wolf

Du wolltest mich testen? ;-)

wenn ich's gewollt hätte, hättest Du mit 100 Punkten bestanden :-) !

Der Grund für meinen Fehler ist erstens, dass ich's nicht ausprobiert habe und zweitens meine Gewohnheit, PC immer so zu behandeln, als sei der aktuelle Befehl schon ausgeführt. Unter anderem deshalb benutze ich relative Sprünge nur noch in Macros. Mein Lieblingsfehler ist, zwischen Sprunganweisung und -ziel noch ein paar Anweisungen einzuflicken und nicht daran zu denken, die Sprungweite zu vergrösern. :oops: Diese Dinger sind nur mit allergrösster Vorsicht zu geniessen.

Ciao,

mare_crisium

Liste der Anhänge anzeigen (Anzahl: 2)

das ist er wieder...

Hallo mare_crisium,
lang hats gedauert... (hatte leider nicht so viel Zeit - Sorry)
Aber nun moechte ich mein Werk wieder einmal vorstellen.
Vieles von Deinem Posting habe ich uebernommen, aber auch manches abgeaendert.
Aenderungen:
- Habe nun fuer High und Low-Flanken je ein Register rTAST_High_FLANKEN und rTAST_Low_FLANKEN(wird aber noch nicht ausgewertet)
- das marco _FLANKEN_SICHERN habe ich mit Abfragen auf HIGH und LOW erweitert
!!! wobei mir das noch nicht ganz gefaellt !!!
??? in der ISR wollte ich abfragen, ob eine Flanke anliegt und nur dann diese sichern

Code:

sbrc r16,3 ; Abfrage ob Flanke ansteht _FLANKEN_SICHERN(LED_TASTE_0) ;

Das funktioniert nur leider nicht, musste ich feststellen.
Ist aber klar, wenn man sich anstelle des Aufrufs die Instruktionen vorstellt.
-> springe ich ja nur eine Instruktion weiter und nicht ueber das komplette macro
??? Kann ich bei rcall-Aufrufen auch ein Parameter mit uebergeben aehnlich wie beim _macro(@0) ???

- Register rLED_Update-Sprr ist ersetzt durch rIO_config
rIO_config soll mehr Infos aufnehmen als nur die Sperrung der Prozedur LED_Update
z.B. angedacht Lesen und Schreiben des EEPROM als Bit 1 und 2 usw...
- GET_HIGH_NIBBLE habe ich auch ein wenig veraendert
anstelle von
andi r16,0x0F ; unteres Nibble freistellen
kam:
andi r16,0x07 ; unteres Nibble freistellen und Flankenbit loeschen
die Zeile "andi r16,0x07" kam in der ISR im naechsten Schritt und wird somit ueberfluessig.
- den Kommentar habe ich auch angepasst und hoffe das es nun lesbarer ist - lese es am Besten in 3 Tagen noch einmal, um zu sehen ob es nun passt ;-)
// im grossen und ganzen muss ich sagen, wurde der Code durch das Auslagern der Unterprogramme wesentlich ueberschaubarer

so nun aber hier der Code:
diesmal angehaengt - wegen der 20.000er

robo_wolf,

Zitat:

Zitat von robo_wolf

Ist aber klar, wenn man sich anstelle des Aufrufs die Instruktionen vorstellt.
-> springe ich ja nur eine Instruktion weiter und nicht ueber das komplette macro

esatto, so ist es. Wenn Du wüsstest, wie oft und wie lang ich schon nach Fehlern diesen Typs gesucht habe ;-) ! Das ist einer der Gründe, derentwegen ich möglichst nur Sprünge zu Labels verwende und keine relativen.

Ja, durch die Auslagerung ist Dein Quelltext jetzt schön übersichtlich und kompakt. Gefällt mir schon richtig gut :-) . Jetzt können wir noch versuchen, Programmplatz sparen, indem wir die Tastenabfrage im Interruptdienst auf eine Schleife umstellen.

Ja, prinzipiell kann man sich ein Macro schreiben, mit dem man die Parameterübergabe z.B. in die Form "_rcall(ProzedurName,Param1Byte,Param2Byte)" bringt; z.B.:

Code:

.macro _rcall ldi r16,@1 ; ldi zl,low(@2) ; ldi zh,high(@2) ; rcall @0 ; .endmacro

Im laufenden Quelltext veranlasst die Anweisung

Code:

_rcall PROZEDURA, 0xFE, 0xABCD _rcall PROZEDURB, 0xEF, 0xDCBA

dass Register r16 mit 0xFE, zl mit 0xCD und zh mit 0xAB geladen werden und anschliessend die Prozedur PROZEDURA aufgerufen wird. Anschliessend wird PROZEDURB mit 0xEF in r16 und 0xDCBA in zh:zl aufgerufen. Man muss nur aufpassen und die Veränderungen in r16, zl und zh nicht vergessen. Sehr gern passiert einem sowas

Code:

ldi r16,0x01 ldi zl,0x00 ldi zh 0x00 _rcall PROZEDURA, 0xFE, 0xABCD or zl,zh brne Nirwana

und man wundert sich, warum das Programm nach der "brne"-Anweisung nie nach "Nirwana" springt, obwohl es das ja tun müsste ;-) ... Das kommt davon, dass das Macro die Benutzung der Register r16, zl und zh versteckt. Umgehen liesse sich diese Gefahr, indem man die Sicherung der Register ebenfalls in das macro übernimmt, z.B. durch

Code:

.macro _rcall push r16 push zl push zh ldi r16,@1 ; ldi zl,low(@2) ; ldi zh,high(@2) ; rcall @0 ; pop zh pop zl pop r16 .endmacro

Wenn man solche Vorsichtsmassnahmen trifft, kann man sich eine Macrosammlung aufbauen, mit der man Assemblerprogramme schreiben kann, die schon sehr einer Hochsprache ähneln.

Ausführlicherer Kommentar zu LernProgram_4g_V02 kommt später.

Ciao,

mare_crisium

Hallo are_crisium,
mit der rcall-Aufrufen hatte ich nicht gemeint ein macro mit dem Namen rcall und Parameteruebergabe sondern ein Sprung zu einem Unterprogramm.
rcall FLANKEN_SICHERN
...
FLANKEN_SICHERN:
...
ret
Die Idee dahinter war, dass ich ebenfalls wie im macro _FLANKEN_SICHERN den Parameter(LED_TASTE_0) anhaengen wollte...
Trotzdem Danke fuer diese Erklaerung.
Wollte eh schon fragen:
Wenn man ein Paramter uebergibt, dann geht es auch mit mehr...?

Liste der Anhänge anzeigen (Anzahl: 1)

robo_wolf,

Zitat:

Zitat von robo_wolf

Hallo are_crisium,
Wenn man ein Paramter uebergibt, dann geht es auch mit mehr...?

ja, natürlich. Nur ist die Parameterübergabe immer implizit - damit meine ich: Der Benutzer muss vorher wissen, welcher Parameter in welchem Register steht. Solche praktischen Aufrufe, wie z.B. FLANKEN_SICHERN( LED_TASTE0), gibt's meines Wissens nur in Hochsprachen wie Pascal, aber in keinem Assemblerdialekt. - Deshalb muss man ein Macro gebasteln, um die Pascal-ähnliche Schreibweise zu simulieren.

Wenn man der Prozedur die Parameter in Registern übergeben muss, ist es hilfreich, eine Beschreibung der Prozedur zu haben, die angibt, welche Parameter in welchen Registern stehen müssen. Deshalb hat in meinen Programmen jede Prozedur so einen ausführlichen Vorspann. Andernfalls muss man erst den ganzen Quelltext der Prozedur wieder durchlesen und verstehen (;-)!) , bevor man sie benutzen kann.

Alternativ kann man der Prozedur auch Parameter übergeben, die im RAM stehen: Entweder auf dem Stack (so macht das Pascal) oder in einem Datenblock. Diese letzte Methode verwende ich auch in der angehängten Version Deines Lernprogramms. Da geht es nämlich um das Auslagern von Daten ins RAM :-) .

Dann man viel Spass!

Ciao,

mare_crisium

Hallo mare_crisium,
wie sagte das Spitzohr bei StarTrek "fazinierend".... ;-)
Hast Dir wieder extrem viel Muehe gemacht. Danke
Auf den ersten Blick, gar nicht so leichte Kost fuer mich.
Da kommen garantiert noch ein paar Fragen auf Dich zu.
Da ist schon eine banale:
Was bedeutet die Abkuerzung TASTCLT? TAST ist klar..aber CLT
Banal, ich weis aber ich verstehe es sich leichter, wenn ich es weis.
LNG - laenge so was erklaert sich von selbst.

PS. bin leider 2 Tage auf Reisen und kann mich erst am Sonntag wieder melden.

robo_wolf,

TASTCLT ist ein Dreckfuhler :-). Gemeint war TASTCTL (Tastensteuerung).

Ciao,

mare_crisium

P.S.: Wieso leider auf Reisen? Ach so: Dienstreise...

so da is er wieder...
ah TAST en C on T ro L l

.db "...LernPrgm4g1_K01.asm..."
Den Gedanken finde ich gut.
aber wo finde ich den String im Simulator wieder? oder ist es nur nach dem Deassemblieren gemeint? Wenn man de nCode warten muss?
(TBL_UEBERGANG_01: - ist klar gehe mit dem Mauszeiger ueber den Eintrag und sehe die Speicherstelle
Nun kann ich mir gut vorstellen das der String davor steht, aber wenn er das tut, kann ich ihn nicht lesen...?)

Die RAM-Einteilung noch einmal zusammenfassend:
3 Bytes pro Tasten im RAM - Die Inistialisiereung mit "0" kann man im Simulator schoen erkennen.
??? Die Belegung ist so gemeint:
TASTCTLx Byte0 TASTCTLx Byte1 TASTCTLx Byte2
xxxx xxxx xxxx xxxx xxxx xxxx
TASTCTL_FLAGS TASTCTL_MASKE

----------------------
??? kann man den Code mit den Tasten0 - 7 nicht noch etwas schrumpfen in den man

Code:

; Taste0 einrichten ldi yl,low(TASTCTL0) ; yh:yl := Zeiger auf ersten Datenblock ldi yh,high(TASTCTL0) ldi r17,(1<<TASTE0_PIN) ; Anschluss-Pin einstellen std y+TASTCTL_MASKE,r17 ;

ihn eine weitere Schleife packt und darin alle Tasten durchlaeuft?

Code:

ldi TASTCTL_X, TASTCTL0 ; vorladen mit TASTCTL0 :=0 ldi TASTE_X_PIN, LED_TASTE_0 ; vorladen mit LED_TASTE_0 :=0 ; TasteX einrichten TasteX_Einrichten: ldi yl,low(TASTCTL_X) ; yh:yl := Zeiger auf ersten Datenblock ldi yh,high(TASTCTL_X) ldi r17,(1<<TASTE_X_PIN) ; Anschluss-Pin einstellen std y+TASTCTL_MASKE,r17 ; ldi TASTCTL_X, TASTCTL_X + TASTCTL_LNG, ; Datenbereich um eine Tastenlaenge verschieben ldi TASTE_X_PIN,TASTE_X_PIN + 1 ; TASTE_X_PIN um 1 erhoehen cpi TASTE_X_PIN, TASTEN_ANZAHL ; TASTEN_ANZAHL erreicht dann fertig breq TasteX_Einrichten ; Schleife solang durchlaufen, bis TASTEN_ANZAHL erreicht ret

Das ist jetzt nur sinngemaess dahin geschrieben und kann man sicher noch viel eleganter loesen.(War eben so ein Gedanke)

Aber im nochmal zu Deinen geposteten LernPrgm4g1K01:
Bei den ersten Zeilen habe ich mich noch etwas schwer getan, aber nachdem ich alles durchgearbeitet hatte,
finde ich es doch sehr gelungen und sehr uebersichtlich.

robo_wolf,

macht Spass, Dir beim Lernen zuzugucken :-) ! - Den Versionstext „......LernPrgm4g1_K01.asm... „ findest Du wieder, wenn Du Dir den Inhalt des Flashspeichers ansiehst. Das geht entweder im Simulator (über das Menu: „View“->“Memory“ im Memory-Fenster in der Combobox „Program“ anwählen. Den String erkennst Du in der rechten Fensterhälfte; dort wird der Speicherinhalt als ASCII angezeigt) oder, wenn das Programm in einen ATmega geflasht wurde, indem Du den Inhalt des Flashspeichers in den Disassembler hochlädst.

Dieser letzte Fall tritt auf, wenn Du mal anfängst, Dir eigene Schaltungen mit ATmegas drin zu bauen und zu programmieren. Mein erstes selbstgebautes Teil war ein RS232-TWI-Umsetzer (sehr nützliches Teil ;-) ). Die Schaltung hat einen Anschluss, über den ich das Program sowohl in den ATmega8 hinunter- als auch aus dem ATmega in den PC heraufladen kann. Natürlich kann man den Käfer auch sockeln, so dass man ihn herausziehen und zum Programmieren auf das STK500 umsetzen kann. Nur kann man dann keine SMD-Bauteile verwenden. Jedenfalls habe ich das Programm schon mehrfach hochgeladen und war froh, anhand des Versionstextes die Programmversion feststellen zu können. Früher hatte ich immer kleine Zettelchen mit der Versionsnummer auf die Chips geklebt. Aber heutzutage sind die SMD-Teile dafür zu winzig ... ;-) .

Die Speicherbelegung hast Du richtig verstanden. Eigentlich werden nur 2 Bytes pro Taste benutzt. Versuch' doch mal, was passiert, wenn folgende Änderungen machst

Code:

.equ TASTCTL_MASKE = 1 ; enthält die Nummer des Pins, an den die Taste ; angeschlossen ist .equ TASTCTL_LNG = 2 ; Pro Taste 2 Bytes reserviert

(Nur um die Flexibilität dieser Art der Speicheraufteilung auszuprobieren ;-) ).

Die Schleife beim Einrichten der TASTCTL-Blöcke lässt sich machen; bringt aber einen Nachteil: Die Nummern der Tastenpins müssten in der Schleife berechnet werden, d.h. es muss einen festgelegten Zusammenhang zwischen Schleifenzähler und PinNummer geben (z.B. Tastennummer = Pin-Nummer). Das engt aber die Flexibilität bei der Zuordnung der Tasten ein.

Den Zeiger auf den Beginn des TASTCTL-Blocks der Taste mit der Nummer X kann man leider nicht so berechnen, wie Du es vorschlägst. Der ATMEL-Assembler erlaubt meines Wissens nicht, die Labels als Variablen zu benutzen. Er besteht darauf, dass Dein Label TASTCTL_X immer denselben Wert hat. Deine Anweisung

Code:

ldi TASTCTL_X, TASTCTL_X + TASTCTL_LNG, ; Datenbereich um eine Tastenlaenge verschieben

wird er strikt ablehnen.

Versuch' doch mal, einen Programmabschnitt in die Hauptschleife einzufügen, (vorzugsweise mithilfe einer Prozedur), die Dir zurückmeldet, ob eine Flanke ansteht (z.B. im Carry- oder im T-Flag) und welche Tastenzustände gerade anstehen (z.B. im Register r16). In diesem Zusammenhang könntest Du auch in TASTCTL ein Byte TASTCTL_LED einzuführen, das die Position des LED-Pins angibt, der die Taste darstellen soll. Dann kannst Du das Byte aus r16 direkt an die LEDs ausgeben, wenn eine Flanke ansteht. - Es ist besser, die Tastenzustände aus Bit0 des Z-Wertes abzuleiten, als bei jeder Flanke umzuschalten. - Du hast ja selbst schon gemerkt, wie man da aus dem Tritt kommen kann, wenn einmal eine Flanke unbemerkt durchwitscht.

Ciao,

mare_crisium

Hallo mare_crisium,
bin leider noch nicht all soweit gekommen.
Zum Einen war ich auf Fehlersuche zum Anderen mach ich mir noch Gedanken, wie man die Tasten-Auswertung am Besten realisiert.
Der Fehler:
Bei gedrueckter Taste ist mir aufgefallen, dass ein Tabellenindexfehler erzeugt wurde.
Der Z-Wert sprang von 0x0F auf 0x00 anstatt auf 0x07(wo er dann ohne Pegelaenderung verharren sollte).
Bei losgelassener Taste natuerlich dann auch.
Ursache:
Das Flankenbit wurde in der vorhergehenden Programmversion in TAST_UTILS_V01.asm bei "GET_HIGH_NIBBLE:" geloescht.
..und das ist in der neuen Version nicht mehr eingebunden. Aus diesem Grund gibt es nun eine TAST_UTILS_V02.asm.
Dort wird es jetzt in "NEXT_TAST_ZST:" bei der Beschraenkung der Tabelleneintraegen von ehemals 127(0x7F) auf 119(0x77) geloescht.
Nun ja, da haette ich es auch gleich ablegen koennen.. ;-)

Gedanken zur Auswertung der Tasten und Flanken:

-----------------------------------------------
Daten im R A M

Code:

Bsp Taste0 bei gedrueckter Taste.: ----------------------------------------------- TASTCTL0 Byte0 TASTCTL0 Byte1 TASTCTL0 Byte2 ----------------------------------------------- TASTCTL_FLAGS TASTCTL_MASKE ----------------------------------------------- 0000 0010 0000 0000 0000 0001 0x02 0x00 0x01 ----------------------------------------------- 0000 0100 0000 0000 0000 0001 0x04 0x00 0x01 ----------------------------------------------- 0000 0110 0000 0000 0000 0001 0x06 0x00 0x01 ----------------------------------------------- 0000 1111 0000 0000 0000 0001 0x0F 0x00 0x01 ----------------------------------------------- 0000 0111 0000 0000 0000 0001 0x07 0x00 0x01 ----------------------------------------------- || || || ---------------------------- Bsp Taste0 losgelassen(high bzw. gedrueckt voraus gegangen).: ----------------------------------------------- 0000 0111 0000 0000 0000 0001 0x07 0x00 0x01 ----------------------------------------------- 0000 0101 0000 0000 0000 0001 0x05 0x00 0x01 ----------------------------------------------- 0000 0011 0000 0000 0000 0001 0x03 0x00 0x01 ----------------------------------------------- 0000 0001 0000 0000 0000 0001 0x01 0x00 0x01 ----------------------------------------------- 0000 1000 0000 0000 0000 0001 0x08 0x00 0x01 ----------------------------------------------- 0000 0000 0000 0000 0000 0001 0x00 0x00 0x01 -----------------------------------------------

Flankenbit - Bit3
Taste gedrueckt: Bit0 :=0 bis Flanke eintritt dann 1
Taste losgelassen: Bit0 :=1 bis Flanke eintritt dann 0

-> Taste gedrueckt Bit0 :=0 -> dann Flankenbit -> Bit0 :=1 == Taste als High(geschaltet) erkannt
-> Taste nicht gedrueckt Bit0 :=1 -> dann Flankenbit -> Bit0 :=0 == Taste als Low( nicht geschaltet) erkannt

===> Auswertung mit Flankenbit auf Bit0
liegt FlankenBit an und ist Bit0 :=0 dann Tasten nicht gedrueckt
liegt FlankenBit an und ist Bit0 :=1 dann Tasten gedrueckt

------------------------------------------------
im Programm "Tasten_4g_V02" wurden die Flanken mit einem macro in der ISR in ein Register gesichert.
neu soll:
in Main-Schleife - vorangegngene ISR setzt Bit(1) - in rIO_Config fuer Erlaubnis zum FlankenBit testen - Flanke (gesetzt) - Ausgang(LED)Update - Rueckehr in Main-Schleife
in Main-Schleife - vorangegngene ISR setzt Bit(1) - in rIO_Config fuer Erlaubnis zum FlankenBit testen - Flanke (n.gesetzt)- Rueckehr in Main-Schleife
in Main-Schleife - vorangegngene ISR setzt Bit(0) - Rueckehr in Main-Schleife
// bin noch an der richtigen Ausarbeitung und hoffe es bis zum WE noch verneunftig umzusetzen
// habe dann noch weitere Plaene mit der Schaltung :-) - mir schwebt eine Menuefunktion vor, mit der das LED-Update veraendert wird

PS. irgendwie verschwinden meine Leerzeichen im Posting :-( - deswegen das RAM im Code-Schnipsel.

robo_wolf,

Du bewegst Dich schon sehr souverän in unserem Programm :-) .

Am Beispiel des Flankenbit-Fehlers kann man gut sehen, wie wichtig es war, von vornherein die Tabellen-Indexprüfung einzubauen. Nur dadurch konntest Du die Fehlerursache sofort erkennen. Hätten wir die Prüfung weggelassen, hätte das Programm plötzlich komische Z-Werte geliefert und Du hättest sehr viel mehr Zeit gebraucht, um den Fehler ausfindig zu machen. Also: Die Programmiermethode "diesen Fall brauche ich nicht zu berücksichtigen, er kann ja gar nicht vorkommen" führt zu labilen Programmen. Was passieren kann, wird früher oder später auch passieren (noch ein Korollar zu Murphy's law ;-) ).

Die andere Lösung für das Flankenbit-Problem ist eine modifizierte Übergangstabelle

Code:

TBL_UEBERGANG_01: .dw 0x0010 ; Tabellenlänge ; T = 1 T = 0 .dw 0x0200 ; Z=0 -> Z=2,Flanke=0 / Z=0,Flanke=0 / .dw 0x0308 ; Z=1 -> Z=3,Flanke=0 / Z=0,Flanke=1 / .dw 0x0400 ; Z=2 -> Z=4,Flanke=0 / Z=0,Flanke=0 / .dw 0x0501 ; Z=3 -> Z=5,Flanke=0 / Z=1,Flanke=0 / .dw 0x0602 ; Z=4 -> Z=6,Flanke=0 / Z=2,Flanke=0 / .dw 0x0703 ; Z=5 -> Z=7,Flanke=0 / Z=3,Flanke=0 / .dw 0x0F04 ; Z=6 -> Z=F,Flanke=1 / Z=4,Flanke=0 / .dw 0x0705 ; Z=7 -> Z=7,Flanke=0 / Z=5,Flanke=0 / .dw 0x0200 ; Z=8 -> Z=2,Flanke=0 / Z=0,Flanke=0 / .dw 0x0000 ; Z=9 -> Z=0,Flanke=0 / Z=0,Flanke=0 / .dw 0x0000 ; Z=A -> Z=0,Flanke=0 / Z=0,Flanke=0 / .dw 0x0000 ; Z=B -> Z=0,Flanke=0 / Z=0,Flanke=0 / .dw 0x0000 ; Z=C -> Z=0,Flanke=0 / Z=0,Flanke=0 / .dw 0x0000 ; Z=D -> Z=0,Flanke=0 / Z=0,Flanke=0 / .dw 0x0000 ; Z=E -> Z=0,Flanke=0 / Z=0,Flanke=0 / .dw 0x0705 ; Z=F -> Z=7,Flanke=0 / Z=5,Flanke=0 / ;

Du siehst, ich habe sie um 8 zusätzliche Zustände erweitert. Dadurch kann man jetzt festlegen, welcher Z-Wert bei gesetztem Flankenbit angenommen werden soll - man braucht es also nicht mehr per Programm zu löschen.

Das sieht zuerst ziemlich banal aus, es steckt aber mehr dahinter: Beim Programmieren gibt's immer den Dualismus zwischen Algorithmus und Datenstruktur; so ähnlich wie der Teilchen-Welle-Dualismus in der Quantenphysik. Der erste, der auf diesen Sachverhalt hingewiesen hat, war, meines Wissens, Prof. Niklaus Wirth von der ETH in Zürich. Er hat darüber ein bis heute sehr lesenswertes Buch verfasst (Niklaus Wirth, "Algorithmen und Datenstrukturen", B.G. Teubner 1983, ISBN 3-519-02250-8. ). Er zeigt, dass man beim Programmieren immer die Wahl hat, einen bestimmten Ablauf entweder in der Datenstruktur (z.B. in Tabellen) oder als Algorithmus (z.B. einer "case"-Abfrage) abzubilden. Eigentlich habe ich die Übergangstabelle in unserem Beispiel nur eingeführt, damit Du 'mal beide Seiten kennenlernst. Welchen der beiden Wege man wählt, hängt immer von der Anwendung und vom persönlichen Geschmack ab. Ich nehme öfters den Weg über die Datenstruktur, weil komplizierte Abläufe so oft übersichtlicher und wartungsfreundlicher darzustellen sind.

Im übrigen ist das Beispiel von Prof. Wirth auch ein lehrreiches Kapitel Technikgeschichte: Er entwickelte die Programmiersprachen Lillith, Pascal, Modula und Oberon. Unter seiner Leitung genoss die Informatikforschung der ETH Zürich einen weltweit führenden Ruf. - Aber es war die Zeit, als in Deutschland allen Ernstes eine Diskussion über die Einführung einer "Computersteuer" geführt wurde und die Mittel für die Informatikforschung (auch in Deutschland) stark eingeschränkt, wenn nicht gar zusammengestrichen wurden. - Na, schlussendlich war spätestens nach seiner Emeritierung die Informatikforschung in der Schweiz so gut wie nicht mehr existent. Genau wie in Deutschland zog man es vor, einmalige Gelegenheiten gemütlich zu verschlafen 8), mit den bekannten Folgen.

Bin gespannt auf Deine nächste Version!

Ciao,

mare_crisium

Liste der Anhänge anzeigen (Anzahl: 2)

Hallo mare_crisium,
nach dem der gestrige Tag im Zeichen des Gartens stand, melde ich mich erst heute... 8-[

Habe nun den Code wieder so angepasst, dass die gewuenschte Funktion "Ein- und Ausschalten" der LED mittels der jeweiligen Taste geschieht.
so 100%ig gefaellt es mir aber noch nicht...
eventuell liegt es an dem was mir so noch im Hinterkopf spukt:
>>>>
... eine Menueabfrage einfuegen.
Diese soll aufgerufen werden, wenn Tasten0 und Taste7 3 sec lang gedrueckt wurde.
--- denkbar ware hier das reservierte DatenByte (bzw. noch ein Zweites) im RAM zu nutzen - Timer ist bei 0,1 sec -> also 300 mal hoch zaehlen... ---
--- oder kann ich das TIMER1 COMPB eventuell dafuer nutzen? ---
--- sind die Werte beider Tasten > 300 dann Einstieg ins Menue ---
Im Menue stehen dann die einzelnen Tasten mit unterschiedlichen Funktionen zur Verfuegung. Signalisierung fuer Menue koennte ein Blinken der LEDs sein...
Nach Erkennen einer Taste wird das Menue verlassen und das Programm arbeitet mit der ausgewaehlten Funktion,
die hinter der Taste steht.
Wurde 5 sec lang, keine Eingabe gemacht, wird das Menue wieder verlassen.
--- denkbar auch hier ein Datenbyte auf 500 zaehlen ---
Als default soll das Programm mit SWITCH_LED nach dem Starten/Einschalten laufen bzw. zu einem spaeteren Zeitpunkt
soll das Programm nach dem Starten/Einschalten mit der zuletzt ausgewaehlten Funktion arbeiten.
<<<<
Das sind erst einmal nur Ueberlegungen... eventuell loese ich die Aufgabe dann doch etwas anders.
Auf Deine Kommentare und event. Vorschlaege bin ich wieder sehr gespannt.
PS. "Computersteuer" - so etwas Aehnliches hat man doch endlich geschafft :-k - in Form der GEZ-Gebuehren

Hallo mare_crisium,
fuer mein Vorhaben mit dem Menue muss SWITCH_LED aus der TAST_ANA rausgenommen werden.
Dazu wiederum sollten die aus dem Z-Werten erkannten, betaetigten Tasten gesichert werden.
Entweder in ein Register oder im RAM.
Dann muss TAST_ANA noch eine Abfrage auf das Menue erhalten, damit der Code dorthin verzweigen kann.
ABER:
laut meinen Vorhaben gibt es nun 4 Timings
1 - fuer das Tastenentprellen 0,1sec
2 - fuer den MenueEinstieg 3,0sec
3 - fuer die MenueSignalisierung(Blinken) 0,2sec
4 - fuer den Menueausstieg 5sec
(wobei -2- =30 mal -1-, -3- =2 mal -1- ist und -4- direkt an -3- gebunden werden kann -4- =25 mal -3-)
- sicher hast Du da noch eine bessere Idee :-k

robo_wolf,

klar, habe ich einen Vorschlag in der Mache :-) ! Ob er besser sein wird, weiss ich noch nicht. Dauert aber noch was...

Ciao,

mare_crisium

Hallo mare_crisium,
"Ob er besser sein wird" - da bin ich mir ziemlich sicher ;-)
..naja, mein Vorschlag hat natuerlich den Nachteil, wenn ich den Timer1 veraendere, aendern sich alle anderen gleich mit.

Liste der Anhänge anzeigen (Anzahl: 3)

robo_wolf,

hier ist noch ein Zwischenschritt auf dem Weg zur Menusteuerung. In der .pdf-Datei habe ich versucht zu erklären, warum ich den für nötig halte. So gut ich's konnte, halt :-).

Morgen kommt der nächste Schritt mit einem Testprogramm für die Komponenten der Menusteuerung.

Ciao,

mare_crisium

Liste der Anhänge anzeigen (Anzahl: 1)

Hallo mare_crisium,
vielen Dank fuer die tolle Ausarbeitung.
Die IDEE eines gekapselten "IO-Treibers" kann man nun sehr schoen erkannen.
Habe mal einen sehr einfach gehaltenen Signalfluss aufgezeichnet.

Liste der Anhänge anzeigen (Anzahl: 2)

Hallo mare_crisium,
habe im Simulator 2 Problemchen bemerkt.
Beim Initialisieren der Ports
LED_PORT habe ich noch ser r16 eingefuegt, da sonst r16 noch den Wert von "ldi r16,(1<<OCIE1A) ; Timer1 Overflow aktivieren" hatte.
Beim TASTCTL_PORT habe ich noch "out TASTCTL_PINS, r16" eingefuegt, da die Tasten gegen GND geschaltet werden.(Besonderheit beim STK500).
-- sehr schoene Loesung --
...wenn ich das mal so sagen darf
Auf Deine Menueloesung bin ich schon sehr gespannt.

Liste der Anhänge anzeigen (Anzahl: 1)

Fuer den weiteren Aufbau des Programm und mit Hinsicht auf Kapselung habe ich nun Nachfolgendes:

Modul Menuesteuerung:
Das Menue wird aufgerufen durch das gleichzeitige Druecken der Tasten T0 und T7 fuer 3sec(Menue-Abfrage).

1 - nach dem Aufruf des "Menue-Auswahl" bleibt dies ohne weiteren Eingriff(Tastendruck)
5sec aktiv und beendet sich nach abgelaufender Zeit mit dem Ruecksprung zu MainSchleife.

2 - wird waehrend des Aufrufs von "Menue-Auswahl"ein Taste gedrueckt,
so schreibt der Inhalt von R18 in R15 geschoben
T0 := Bit0.... T7 :=Bit7 von rTastMenue und bendet "Menue-Steuerung" mit dem Ruecksprung zu Main-Schleife.

3 - Register r18 enthaelt die gedrueckten Tasten(High-Flanken)
-> r18 wird fuer die "Menuesteuerung" eingelesen und verarbeitet.

4 - fuer die Ausarbeitung und Erstellung des Testprogramms wird folgendes festgelegt:
Der Zeitgeber wird durch ein RegisterZaehler simuliert.

Code:

.equ MenueInTime = 3 .equ MenueTimeOut = 5 def r15 = rTastMenue ; wird default mit 0x01 geladen def r20 = rMenueTC ; (MenueTimer-Counter)

F U N K T I O N:
Menue-Abfrage:
r18 wird in einer Schleife mit 0x81 (0b1000 0001) verglichen.
bei Uebereinstimmung incrementiert rMenueTC.

rMenueTC wird mit MenueInTime verglichen.
bei Uebereinstimmung wird das Untermenue "Menue-Auswahl" aufgerufen
und rMenueTC wird mit MenueTimeOut geladen.

Menue-Auswahl:
Menue-Auswahl durchlaeuft eine Schleife, in der rMenueTC decrementiert.
Bei "tst rMenueTC" wird rTastMenue mit 0x01 geldaen und die Funktion mit dem Ruecksprung in Main beendet.
oder die naechste erkannte Taste in R18 wird in R15 verschoben und das Menue-Auswahl damit beendet.
Innerhalb von Menue-Auswahl sollen die LEDs zur Signalisierung blinken.
Dazu wird rTastMenue geloescht := 0x00.

rTastMenue wird mit der naechsten in der Main-Schleife befindlichen Prozedur "SWITCH_OUT_PORT" bislang "SWITCH_LED" verarbeitet.
rTastMenue := 0x00 liefert das Blinken aller LEDs

Liste der Anhänge anzeigen (Anzahl: 3)

robo_wolf,

Du weisst ja, ich bin momentan zeitlich ziemlich eingeschränkt. Deshalb zeigen die Dateien im Anhang noch einen nicht komplett ausgetesten Zwischenstand. - Interessant, wie sich unsere Ansätze unterscheiden :-) . Das Ausknobeln hat richtig Spass gemacht und war eine gute Ablenkung.

Ciao,

mare_crisium

EDIT_1: Verbesserte Versionen der drei Anhänge hochgeladen
EDIT_2: Fehler (siehe Post von robo_wolf 02.04.2010) in _V03 korrigiert. Neue Version "TestPrgrm_04i_V03.asm"
EDIT_3: Neue Version _V09 mit Korrektur/Ergän
zung des Übergangskriteriums von A.0 nach A.1.
EDIT_4: Fehler (siehe Post von robo_wolf 10.04.2010) in "MENU8STRG_V02.asm" korrigiert, korrigierte Version hochgeladen

robo_wolf,

bitte, lade die korrigierten Versionen herunter, die jetzt an meinem Posting von heute morgen angefügt sind. Bei den alten Versionen war ich doch zu sehr in Eile. Mit den neuen klappt's :-).

Ciao,

mare_crisium