Anfänger mit STK500 und Assembler

Hallo Leute,
beschäftige mich mit der Programmierung des STK500 mit Assembler.
Naja vielleicht sollte ich lieber schreiben, ein Newbi möchte sich mit der Assemblerprogrammierung des STK500 beschäftigen.
Als Software benutze ich die mitgelieferte AVR-Studio.
Habe im Vorfeld schon einiges in Foren und Büchern gelesen.
So als Einstieg und zum besseren Erlernen möchte ich mir kleine Aufgaben stellen und diese dann umsetzen.
Den Code werde ich hier posten und wäre sehr an euren Meinungen, Vorschlägen und Kritiken interessiert.
Zu den Code werde ich immer Kommentare anfügen, damit man versteht was ich damit bezwecke.
Anfangen möchte ich mit einer einfachen Tastenschaltung.
Bei dieser sollen die 8 LEDs des STK500 mit einer Taste entprellt an- bzw. ausgeschaltet werden.
Das STK500 habe ich mit einen ATMega8515 bestückt. PORTB ist mit den Tastern und PORTD mit den LEDs verbunden.

Code:

;***** STK500 Lernprogramm ;*** Aufgabe: alle LEDs mit einem Taster auf dem STK500 an bzw. ausschalten ;*** zum Entprellen soll ein Interrupt(Int0) benutzt werden ;*** .include "m8515def.inc" .def Temp = r16 ; Temporary register .def LED_STAT = r17 ; LED sind mit PortB verbunden ;***** ;Reset and Interrupt vector ;VNr. Beschreibung rjmp RESET ;1 POWER ON RESET rjmp INT0_ISR ;2 Int0-Interrupt reti ;3 Int1-Interrupt reti ;4 TC1 Capture reti ;5 TC1 Compare Match A TC2 Overflow reti ;6 TC1 Compare Match B TC1 Capture reti ;7 TC1 Overflow TC1 Compare Match A reti ;8 TC0 Overflow TC1 Compare Match B reti ;9 SPI, STC Serial Transfer Complete TC1 Overflow reti ;10 UART Rx Complete TC0 Overflow reti ;11 UART Data Register Empty SPI, STC Serial Transfer Complete reti ;12 UART Tx Complete UART Rx Complete reti ;13 Analog Comparator reti ;14 Int2-Interrupt reti ;15 Timer 0 Compare Match reti ;16 EEPROM Ready reti ;17 Store Program Memory Ready RESET: ldi r16, LOW(RAMEND) ;Stack initialisieren out SPL, r16 ldi r16, HIGH(RAMEND) out SPH, r16 ldi temp, 1 << INT0 ;Interrupt INT0 aktiviert out GICR, temp ldi temp, 1 << ISC00 ;Interrupt INT0 konfiguriert ori temp, 1 << ISC01 out MCUCR, temp clr Temp ;Temp mit 0b00000000 bzw. 0x00 laden out DDRD, Temp ;PORTD als Eingang ser Temp ;Temp mit 0b11111111 bzw. 0xFF laden out PORTD, temp ;PullUp an PortD einschalten out DDRB,Temp ;PORTB als Ausgang out PORTB, temp ;PORTB (LEDs) aus sei ;Interrupts zulassen MAIN: rjmp MAIN ;Die Schleife ruft mit dem Sprungbefehl ;rjmp sich ständig selbst auf.(endlos) INT0_ISR: cli ;Interrupts sperren in LED_STAT, PORTB ;PORTB auslesen in LED_STAT com LED_STAT ;Invertieren von LED_STAT out PORTB, LED_STAT ;Ausgabe von temp an PORTB -> LEDs aus reti

Das Programm habe ich zum STK500 übertragen und tut auch das was es soll.

robo_wolf,

da hast Du Dir einen sehr guten und erfolgsversprechenden Zugang ausgesucht :-) ! Ein paar Anmerkungen zu Deinem Programm:

Du musst bedenken, dass die Interrupt-Dienstprozedur INT0_ISR dieselben Register verwendet, wie das Hauptprogramm. Wenn also die Haupschleife MAIN mit bestimmten Registern etwas ausrechnen wollte, als der Interrupt sie unterbrach, dann erwartet sie, dass die Register bei der Rückkehr aus dem Interrupt wieder dieselben Werte haben wie vorher. Du musst also dafür sorgen, dass die Registerinhalte gleich zu Beginn von INT0_ISR auf den Stack gesichert (push rxx) und unmittelbar vor der Rückkehr (reti) wiederhergestellt (pop rxx) werden. Wichtig ist auch, den aktuellen Inhalt des SREG auf dem Stack zu sichern. Sonst gehen dem Hauptprogramm so wichtige Sachen wie der aktuelle Stand des Carry- oder Zero-Flags verloren. Also brauchst Du parallel zum Sichern der Register noch die Zeilen

Aus leidvoller (:-() Erfahrung habe ich mir angewöhnt, vor jedem Unterprogramm und jedem Interruptdienst aufzuschreiben, welche Register wie verwendet werden. Z.B. so:

Code:

/* Der Steuerblock und die Daten der FIFO werden im RAM angelegt. Die Offsets der Steuerdaten sind +0 : FIFO_FLAGS +1 : FIFO_WR zeigt auf nächste Schreibposition +2 : FIFO_RD zeigt auf nächste Leseposition +3 : FIFO_CAP FIFO-Kapazität, maximal 255 Byte Datenblock: +4 : <1. Datenbyte> Die Bedeutung der Bits in FIFO_FLAGS ist: XXXX XXXX || |+------ 0: FIFO ist nicht voll | 1: FIFO ist voll | +------- 0: FIFO ist nicht leer 1: FIFO ist leer */ ;------------------------------------------ ; ; FIFO-KONSTANTEN ; ; BYTE-OFFSETs .equ FIFO_FLAGS = 0 .equ FIFO_WR = 1 ; zeigt auf nächste freie Position .equ FIFO_RD = 2 ; zeigt auf nächste belegte Position .equ FIFO_CAP = 3 ; .equ FIFO_LNG = 4 ; Länge des Datenblocks ;BIT-OFFSETs .equ FIFO_VOLL = 0 .equ FIFO_LEER = 1 ; ; Der Platzbedarf im RAM ; berechnet sich als ; FIFO_SIZE = FIFO_LNG + FIFO_CAP /*------------------------------------------ PROCEDURE FIFO8_CREATE erzeugt die Struktur einer leeren FIFO für 1-Byte-Daten im RAM Eingangsvariablen zh:zl: enhält den Zeiger auf die RAM-Adresse, an der die FIFO angelegt werden soll r16: enthält die FIFO-Kapazität Ausgangsvariablen zh:zl : enthält den Zeiger auf die FIFO r16: enthält die FIFO-Kapazität geänderte Register keine geänderte Ports keine */ FIFO8_CREATE: push r17 in r17,SREG push r17 push r18 ; FIFO-Steuerblock mit Nullen füllen ldi r18,FIFO_LNG clr r17 FIFO_CREAT01: tst r18 breq FIFO_CREAT_00 st z+,r17 dec r18 rjmp FIFO_CREAT01 FIFO_CREAT_00: ; zh:zl wieder auf Anfang der FIFO stellen sbiw zh:zl,FIFO_LNG ; Anfangszustand der Flags einstellen ldi r17,(1<<FIFO_LEER); Flag "FIFO_LEER" setzen std z+FIFO_FLAGS,r17 dec r16 ; std z+FIFO_CAP,r16 ; FIFO-Kapazität speichern inc r16 ; pop r18 pop r17 out SREG,r17 pop r17 ret

Weiterhin viel Spass und viel Erfolg!

mare_crisium

verstehe ich das so richtig?

Hallo mare_crisium,
habe mein Listing angepasst.
Beim Testen im Simulator habe ich mir den Datenspeicher mit als Fenter anzeigen lassen und den Verlauf verglichen.
Das erste was nach Eintreten der ISR auf den Stack kommt ist der Programmcounter(zaehler). Dann werden die Registerinhalte, wie ich sie sichere, nach unten gestapelt und spaeter wieder ausgelesen.
Die Speicherinhalte vom Datenspeicher bleiben bestehen, bis sie von erneuten Aufrufen der ISR ggf. ueberschrieben werden.

Code:

;***** STK500 Lernprogramm ;*** Aufgabe: alle LEDs mit einem Taster auf dem STK500 an bzw. ausschalten ;*** zum Entprellen soll ein Interrupt(Int0) benutzt werden ;*** .include "m8515def.inc" .def Temp = r16 ; Temporary register .def LED_STAT = r17 ; LED sind mit PortB verbunden ;***** ;Reset and Interrupt vector ;VNr. Beschreibung rjmp RESET ;1 POWER ON RESET rjmp INT0_ISR ;2 Int0-Interrupt reti ;3 Int1-Interrupt reti ;4 TC1 Capture reti ;5 TC1 Compare Match A TC2 Overflow reti ;6 TC1 Compare Match B TC1 Capture reti ;7 TC1 Overflow TC1 Compare Match A reti ;8 TC0 Overflow TC1 Compare Match B reti ;9 SPI, STC Serial Transfer Complete TC1 Overflow reti ;10 UART Rx Complete TC0 Overflow reti ;11 UART Data Register Empty SPI, STC Serial Transfer Complete reti ;12 UART Tx Complete UART Rx Complete reti ;13 Analog Comparator reti ;14 Int2-Interrupt reti ;15 Timer 0 Compare Match reti ;16 EEPROM Ready reti ;17 Store Program Memory Ready RESET: ldi r16, LOW(RAMEND) ;Stack initialisieren out SPL, r16 ldi r16, HIGH(RAMEND) out SPH, r16 ldi temp, 1 << INT0 ;Interrupt INT0 aktiviert out GICR, temp ldi temp, 1 << ISC00 ;Interrupt INT0 konfiguriert ori temp, 1 << ISC01 out MCUCR, temp clr Temp ;Temp mit 0b00000000 bzw. 0x00 laden out DDRD, Temp ;PORTD als Eingang ser Temp ;Temp mit 0b11111111 bzw. 0xFF laden out PORTD, temp ;PullUp an PortD einschalten out DDRB,Temp ;PORTB als Ausgang out PORTB, temp ;PORTB (LEDs) aus sei ;Interrupts zulassen MAIN: rjmp MAIN ;Die Schleife ruft mit dem Sprungbefehl ;rjmp sich ständig selbst auf.(endlos) INT0_ISR: push R16 ;Inhalt von R16 auf Stack ablegen in R16, SREG ;Statusregister in R16 lesen push R16 ;Inhalt von R16(SREG) auf den Stack ablegen push R17 ;Inhalt von R17 auf den Stack ablegen cli ;Interrupts sperren in LED_STAT, PORTB ;PORTB auslesen in LED_STAT com LED_STAT ;Invertieren von LED_STAT out PORTB, LED_STAT ;Ausgabe von LED_STAT an PORTB -> LEDs an bzw. aus pop R17 ;Ruecksichern von R17 pop R16 ;Ruecksichern von R16(SREG) out SREG, R16 ;Ruecksichern von SREG pop R16 reti

So wie gezeigt ist das retten der Register schon richtig. In diesem Speziellen Fall, wo im Hauptprogramm nichts wirkliches passiert, kann man auch außnahmsweise mal auf das sichern des SREG verzichten.
Das erste Programm war also schon OK, aber man sollte sich das sichern der Register ruhig angewöhnen.

In ASM ist es ein gar nicht so seltener Trick einfach ein paar Register für die Benutzung im Interrupt zu reservieren, dass spart einem das sichern der Register. Oft nutzt man ja ASM gerade deshalb man das maximale an Geschwindigkeit haben will.

Es ist sonst recht hilfreich wenn man oben als Kommentar reinschreibt zu welcher Hardware das Programm gehört. Also wo hängen Taster oder LEDs dran. Für So einen kleinen Test gehts noch ohne, später sollte das aber dazu.

Ist nur eine Kleinigkeit, aber beim konfigurieren des Interrupts sollte man erst die Einstellungen (Flanke etc.) machen, dann ggf. das Interruptflag löschen, und erst dann den Interrupt einschalten. Sonst gibt es auch mal einen ungeplanten Interrupt vom Konfigurieren.

Interrupt Flag loeschen

Hallo Besserwessi,
erstmal vielen Dank fuer die Tipps...
Habe nun den Code wie folgt abgeaendert.

Code:

;***** STK500 Lernprogramm ;*** Aufgabe: alle LEDs mit einem Taster auf dem STK500 an bzw. ausschalten ;*** zum Entprellen soll ein Interrupt(Int0) benutzt werden ;*** .include "m8515def.inc" .def Temp = r16 ; Temporary register .def LED_STAT = r17 ; LED sind mit PortB verbunden ;***** ;Reset and Interrupt vector ;VNr. Beschreibung rjmp RESET ;1 POWER ON RESET rjmp INT0_ISR ;2 Int0-Interrupt reti ;3 Int1-Interrupt reti ;4 TC1 Capture reti ;5 TC1 Compare Match A TC2 Overflow reti ;6 TC1 Compare Match B TC1 Capture reti ;7 TC1 Overflow TC1 Compare Match A reti ;8 TC0 Overflow TC1 Compare Match B reti ;9 SPI, STC Serial Transfer Complete TC1 Overflow reti ;10 UART Rx Complete TC0 Overflow reti ;11 UART Data Register Empty SPI, STC Serial Transfer Complete reti ;12 UART Tx Complete UART Rx Complete reti ;13 Analog Comparator reti ;14 Int2-Interrupt reti ;15 Timer 0 Compare Match reti ;16 EEPROM Ready reti ;17 Store Program Memory Ready RESET: ldi r16, LOW(RAMEND) ;Stack initialisieren out SPL, r16 ldi r16, HIGH(RAMEND) out SPH, r16 ldi temp, 1 << ISC00 ;Interrupt INT0 konfiguriert ori temp, 1 << ISC01 out MCUCR, temp ldi temp, 0 << INTF0 ;InterruptFlagregister geloescht out GIFR, temp ldi temp, 1 << INT0 ;Interrupt INT0 aktiviert out GICR, temp clr Temp ;Temp mit 0b00000000 bzw. 0x00 laden out DDRD, Temp ;PORTD als Eingang ser Temp ;Temp mit 0b11111111 bzw. 0xFF laden out PORTD, temp ;PullUp an PortD einschalten out DDRB,Temp ;PORTB als Ausgang out PORTB, temp ;PORTB (LEDs) aus sei ;Interrupts zulassen MAIN: rjmp MAIN ;Die Schleife ruft mit dem Sprungbefehl ;rjmp sich ständig selbst auf.(endlos) INT0_ISR: push R16 ;Inhalt von R16 auf Stack ablegen in R16, SREG ;Statusregister in R16 lesen push R16 ;Inhalt von R16(SREG) auf den Stack ablegen push R17 ;Inhalt von R17 auf den Stack ablegen in LED_STAT, PORTB ;PORTB auslesen in LED_STAT com LED_STAT ;Invertieren von LED_STAT out PORTB, LED_STAT ;Ausgabe von LED_STAT an PORTB -> LEDs an bzw. aus pop R17 ;Ruecksichern von R17 pop R16 ;Ruecksichern von R16(SREG) out SREG, R16 ;Ruecksichern von SREG pop R16 reti

Reihenfolge Konfiguration und Aktivierung des INT0, sowie das Loeschen des INTF0 im GIFR.
Kannst Du mir naeheres zu den Flags sagen?
Ach ja das CLI in der ISR habe ich entfernt, da es automatisch geschieht.

werde ueber Weihnachten nicht zu Haus sein und somit auch nicht antworten koennen.

Die Reihenfolge bei der Konfiguration des Interrupts ist schon OK.

Allerdings haben die Register mit den Interruptflags eine komische Eigenschaft. Um da ein Bit zu löschen muß man eine 1 reinschreiben.
Das klingt erstmal widersinnig, erlaubt aber so ein direktes und atomares löschen einzelner Bits. Außerden kann man so oft den gleichen Wert zulöschen der Flags reinschreiben. Die Bits haben nämlich sinnigerweise die gleiche Reihenfolge.
kurz gesagt: 0 << INTF0 ist falsch.

Selbst wenn man ein normales Bit löschen wollte, ist das eine umständliche Schreibweise für 0. Man löscht also normal alle Bits, nur nicht grade bei den Interuptflags.

Die beiden Bits für die Interrupt-konfiguration kann man übrigens auch gleich zusammenfügen, das muß man nicht erst zur Laufzeit machen.
Also statt:
ldi temp, 1 << ISC00 ;Interrupt INT0 konfiguriert
ori temp, 1 << ISC01
kürzer
ldi temp, (1 << ISC00) |(1 << ISC01) ;Interrupt INT0 konfiguriert

Hallo Besserwessi,
bist ja noch spät bzw. schon frueh unterwegs.
Hier wieder eine angepasste Version des Codes:

Code:

;***** STK500 Lernprogramm ;*** Aufgabe: alle LEDs mit einem Taster auf dem STK500 an bzw. ausschalten ;*** zum Entprellen soll ein Interrupt(Int0) benutzt werden ;*** .include "m8515def.inc" .def Temp = r16 ; Temporary register .def LED_STAT = r17 ; LED sind mit PortB verbunden ;***** ;Reset and Interrupt vector ;VNr. Beschreibung rjmp RESET ;1 POWER ON RESET rjmp INT0_ISR ;2 Int0-Interrupt reti ;3 Int1-Interrupt reti ;4 TC1 Capture reti ;5 TC1 Compare Match A TC2 Overflow reti ;6 TC1 Compare Match B TC1 Capture reti ;7 TC1 Overflow TC1 Compare Match A reti ;8 TC0 Overflow TC1 Compare Match B reti ;9 SPI, STC Serial Transfer Complete TC1 Overflow reti ;10 UART Rx Complete TC0 Overflow reti ;11 UART Data Register Empty SPI, STC Serial Transfer Complete reti ;12 UART Tx Complete UART Rx Complete reti ;13 Analog Comparator reti ;14 Int2-Interrupt reti ;15 Timer 0 Compare Match reti ;16 EEPROM Ready reti ;17 Store Program Memory Ready RESET: ldi r16, LOW(RAMEND) ;Stack initialisieren out SPL, r16 ldi r16, HIGH(RAMEND) out SPH, r16 ldi temp, (1<<ISC00)|(1<<ISC01) ;Interrupt INT0 konfiguriert out MCUCR, temp ldi temp, 1 << INTF0 ;InterruptFlagregister geloescht out GIFR, temp ldi temp, 1 << INT0 ;Interrupt INT0 aktiviert out GICR, temp clr Temp ;Temp mit 0b00000000 bzw. 0x00 laden out DDRD, Temp ;PORTD als Eingang ser Temp ;Temp mit 0b11111111 bzw. 0xFF laden out PORTD, temp ;PullUp an PortD einschalten out DDRB,Temp ;PORTB als Ausgang out PORTB, temp ;PORTB (LEDs) aus sei ;Interrupts zulassen MAIN: rjmp MAIN ;Die Schleife ruft mit dem Sprungbefehl ;rjmp sich ständig selbst auf.(endlos) INT0_ISR: push R16 ;Inhalt von R16 auf Stack ablegen in R16, SREG ;Statusregister in R16 lesen push R16 ;Inhalt von R16(SREG) auf den Stack ablegen push R17 ;Inhalt von R17 auf den Stack ablegen in LED_STAT, PORTB ;PORTB auslesen in LED_STAT com LED_STAT ;Invertieren von LED_STAT out PORTB, LED_STAT ;Ausgabe von LED_STAT an PORTB -> LEDs an bzw. aus pop R17 ;Ruecksichern von R17 pop R16 ;Ruecksichern von R16(SREG) out SREG, R16 ;Ruecksichern von SREG pop R16 reti

--- werde ueber Weihnachten nicht zu Haus sein und somit auch nicht antworten koennen ---

Teil 2

so habe nun ein weiteres Miniprogramm.
diesmal mit Ein und Austaster

Code:

;***** STK500 Lernprogramm Nr.2 ;*** Aufgabe: alle LEDs mit einem Taster auf dem STK500 an ubd mit einem 2. Taster ausschalten ;*** zum Entprellen sollen Interrupts(INT0 und INT1) benutzt werden ;*** .include "m8515def.inc" .def Temp = r16 ; Temporary register ;***** ;Reset and Interrupt vector ;VNr. Beschreibung rjmp RESET ;1 POWER ON RESET rjmp INT0_ISR ;2 Int0-Interrupt rjmp INT1_ISR ;3 Int1-Interrupt reti ;4 TC1 Capture reti ;5 TC1 Compare Match A TC2 Overflow reti ;6 TC1 Compare Match B TC1 Capture reti ;7 TC1 Overflow TC1 Compare Match A reti ;8 TC0 Overflow TC1 Compare Match B reti ;9 SPI, STC Serial Transfer Complete TC1 Overflow reti ;10 UART Rx Complete TC0 Overflow reti ;11 UART Data Register Empty SPI, STC Serial Transfer Complete reti ;12 UART Tx Complete UART Rx Complete reti ;13 Analog Comparator reti ;14 Int2-Interrupt reti ;15 Timer 0 Compare Match reti ;16 EEPROM Ready reti ;17 Store Program Memory Ready RESET: ldi r16, LOW(RAMEND) ;Stack initialisieren out SPL, temp ldi r16, HIGH(RAMEND) out SPH, temp ldi temp, (1<<ISC00)|(1<<ISC01)|(1<<ISC10)|(1<<ISC11) out MCUCR, temp ;Interrupt INT0 und INT1 konfiguriert ldi temp, (1<<INTF0)|(1<<INTF1) out GIFR, temp ;InterruptFlagregister geloescht ldi temp, (1<<INT0)|(1<<INT1) out GICR, temp ;Interrupt INT0 und INT1 aktiviert clr Temp ;Temp mit 0b00000000 bzw. 0x00 laden out DDRD, Temp ;PORTD als Eingang ser Temp ;Temp mit 0b11111111 bzw. 0xFF laden out PORTD, temp ;PullUp an PortD einschalten out DDRB,Temp ;PORTB als Ausgang out PORTB, temp ;PORTB (LEDs) aus sei ;Interrupts zulassen MAIN: rjmp MAIN ;Die Schleife ruft mit dem Sprungbefehl ;rjmp sich ständig selbst auf.(endlos) INT0_ISR: push R16 ;Inhalt von R16 auf Stack ablegen in R16, SREG ;Statusregister in R16 lesen push R16 ;Inhalt von R16(SREG) auf den Stack ablegen ser Temp ;Temp mit 0b11111111 bzw. 0xFF laden out PORTB, temp ;Ausgabe an PORTB -> LEDs aus pop R16 ;Ruecksichern von R16(SREG) out SREG, R16 ;Ruecksichern von SREG pop R16 reti INT1_ISR: push R16 ;Inhalt von R16 auf Stack ablegen in R16, SREG ;Statusregister in R16 lesen push R16 ;Inhalt von R16(SREG) auf den Stack ablegen clr Temp ;Temp mit 0b00000000 bzw. 0x00 laden out PORTB, temp ;Ausgabe von LED_STAT an PORTB -> LEDs an pop R16 ;Ruecksichern von R16(SREG) out SREG, R16 ;Ruecksichern von SREG pop R16 reti

robo_wolf,

als Folgeaufgabe böte sich Folgendes an:
Ein allgemein anwendbares Entprellverfahren. So wie Du's jetzt machst, kannst Du immer nur maximal zwei Taster entprellen, die obendrein auch noch die beiden wertvollen externen Interrupts belegen. Deshalb ist ein Verfahren sehr nützlich, mit dem Taster entprellt werden, die einfach an einen Input-Port angeschlossen sind. Dabei kannst Du auch gleich die ersten Schritte mit Timer/Countern machen.

Code:

;***** STK500 Lernprogramm Nr.3 ;*** Aufgabe: alle LEDs mit einem Taster auf dem STK500 an und mit einem 2. Taster ausschalten ;*** zum Entprellen wird Timer/Counter0 genutzt. ; Die Interrupts INT0 und INT1 werden nicht benutzt. Der Overflow-Interrupt des TimerCounter0 ; wird aktiviert. ; Bei jedem TOV0-Interrupt wird der Zustand von Taster0 und Taster1 abgelesen. ; Für jeden Taster wird ein Zustandsregister eingerichtet. Wenn bei einer Ablesung Taster0 ; gedrückt ist, wird in das Zustandsregister von Taster0 von links eine 1 eingeschoben ; (z.B. <ror>-Anweisung, vorher CARRY-Flag setzen). Wenn bei einer Ablesung Taster0 nicht ; gedrückt ist, wird in das Register von rechts eine Null eingeschoben. Die Taste gilt nur dann als gedrückt, ; wenn der Inhalt des Registers grösser als 0x0F ist. ; Das Entprellen bei Taster1 wird analog gelöst. ; ; Mit dem Prescaler spielen, um verschiedene Reaktionsgeschwindigkeiten auzuprobieren ; Mit dem Schaltgrenzwert des Zustandsregisters spielen, um zeitlich symmetrisches und ; unsymmetrisches Verhalten zu erproben ;***

Wär' das was? Weiterhin viel Spass beim Assemblern :-) !

mare_crisium

hallo mare_crisium,
klar doch wollte eh das Programm abaendern, dass jeder Taster verwendet werden kann. Somit muss ich mich um ein anderes entprellen kuemmern.
Aber eine Schaltung habe ich noch zwischenzeitlich gemacht.
Angelehnt an das Hundegeschirr von unseren Berner.
hier dieser Code:

Code:

;***** STK500 Lernprogramm Nr.3 ;*** Aufgabe: alle LEDs mit einem Taster auf dem STK500 schalten ;*** 1. Tastendruck: LEDs einschalten ;*** 2. Tastendruck: LEDs blinken ;*** 3. Tastendruck: LEDs ausschalten ;*** zum Entprellen soll ein Interrupt(Int0) benutzt werden ;*** .include "m8515def.inc" .def Temp = r16 ; Temporary register .def Tast_Stat = r17 ; Zaehler fuer Taste .def Delay = R18 ; Wartezeit .def Delay2 = R19 ; Wartezeit ;***** ;Reset and Interrupt vector ;VNr. Beschreibung rjmp RESET ;1 POWER ON RESET rjmp INT0_ISR ;2 Int0-Interrupt reti ;3 Int1-Interrupt reti ;4 TC1 Capture reti ;5 TC1 Compare Match A TC2 Overflow reti ;6 TC1 Compare Match B TC1 Capture reti ;7 TC1 Overflow TC1 Compare Match A reti ;8 TC0 Overflow TC1 Compare Match B reti ;9 SPI, STC Serial Transfer Complete TC1 Overflow reti ;10 UART Rx Complete TC0 Overflow reti ;11 UART Data Register Empty SPI, STC Serial Transfer Complete reti ;12 UART Tx Complete UART Rx Complete reti ;13 Analog Comparator reti ;14 Int2-Interrupt reti ;15 Timer 0 Compare Match reti ;16 EEPROM Ready reti ;17 Store Program Memory Ready RESET: ldi r16, LOW(RAMEND) ;Stack initialisieren out SPL, r16 ldi r16, HIGH(RAMEND) out SPH, r16 ldi temp, (1<<ISC00)|(1<<ISC01)|(1<<SE) out MCUCR, temp ;Interrupt INT0 und Sleep enable konfiguriert ldi temp, 1 << INTF0 ;InterruptFlagregister geloescht out GIFR, temp ldi temp, 1 << INT0 ;Interrupt INT0 aktiviert out GICR, temp clr Temp ;Temp mit 0b00000000 bzw. 0x00 laden out DDRD, Temp ;PORTD als Eingang ser Temp ;Temp mit 0b11111111 bzw. 0xFF laden out PORTD, temp ;PullUp an PortD einschalten out DDRB,Temp ;PORTB als Ausgang out PORTB, temp ;PORTB (LEDs) aus sei ;Interrupts zulassen MAIN: rcall TESTE rjmp MAIN TESTE: clr temp ;loesche temp inc temp ;increment von temp - "1" cp Tast_Stat,temp ;ist TastStat = 1 dann Rufe Sub LED_AN auf, sonst ueberspringe naechsten Befehl breq LED_AN inc temp ;increment von temp - "2" cp Tast_Stat,temp ;ist TastStat = 2 dann Rufe Sub LED_BLINK auf, sonst ueberspringe naechsten Befehl breq LED_BLINK inc temp ;increment von temp - "3" cp Tast_Stat,temp ;ist TastStat = 3 dann Rufe Sub LED_AUS auf, sonst ueberspringe naechsten Befehl breq LED_AUS sleep ret LED_AN: ;loesche temp clr temp ;setze alle Bit in temp (0b00000000 bzw. 0x00) out PORTB, temp ;Ausgabe an PortB sleep ret LED_BLINK: in temp,PORTB ;lese PORTB in temp com temp ;Einercomplement von temp (ist 0b00000000 > 0b11111111 oder umgekehrt) out PORTB,temp ;Ausgabe an PortB Tot_Zeit: dec Delay ;zaehle ein Register R18 - 0b0000000 runter und springe danach aus der Schleife brne Tot_Zeit dec Delay2 ;zaehle ein Register R19 - 0b0000000 runter und springe danach aus der Schleife brne Tot_Zeit ret LED_AUS: ser temp ;setze alle Bits in temp (0b11111111 bzw. 0xFF) out PORTB,temp ;Ausgabe an PORTB clr Tast_Stat ;Loesche Tast_Stat sleep ret INT0_ISR: ldi Delay, 0b00000001 ;Ruecksprung aus LED_BLINK beschleunigen ldi Delay2, 0b00000001 ;Ruecksprung aus LED_BLINK beschleunigen push R16 ;Inhalt von R16 auf Stack ablegen in R16, SREG ;Statusregister in R16 lesen push R16 ;Inhalt von R16(SREG) auf den Stack ablegen inc Tast_Stat pop R16 ;Ruecksichern von R16(SREG) out SREG, R16 ;Ruecksichern von SREG pop R16 ;Ruecksichern von R16 reti

Als naechstes wird das generelle entprelle in Angriff genommen :-)

Liste der Anhänge anzeigen (Anzahl: 1)

robo_wolf,

meine Kommentare sind diesmal ein bisschen länglich ausgefallen ;-), deshalb hab' ich sie als .pdf angehängt.

Ciao,

mare_crisium

Hallo mare_crisium,
was soll ich sagen...
Als ich heute Deine Kommentare gelesen habe, war ich so richtig "baff" und andererseits wahnsinnig froh, dass Du Dir so viel Zeit genommen hast, mir Erklaerungen und Beispiele fuer mein kleines Programm zu schreiben. Dafuer erst einmal vielen vielen Dank.

Die "ret" Erklaerung sehe ich nun auch von anderen Blickpunkt aus. Habe beim Erstellen des Codes an der Art nach sich ziehende Probleme nicht gedacht.
Man lernt halt nur aus solchen "Fehlern", wenn man sie bewusst gemacht hat.

Die Delays auf 1 zusetzen kam eigentlich nur aus dem Studio-Simulator.
Dort hatte ich gesehen, dass beim Ruechsprung aus der ISR(wenn ISR waehrend LED_BLINK ausgefuehrt wurde) erst noch die Tot_Zeit abgearbeitet wurde, bevor es zu TESTE zurueck "ret" geht.
Naja ich gebe es zu, da hatte ich schon gemerkt, dass der Code nicht ganz so war, wie ich es eigentlich wollte.
Sah aber zu dem Zeitpunkt keinen anderen Weg, das Runterzaehlen der Register zu beschleuigen oder gar zu unterbinden.

Seit meinem letzten Posting hatte ich leider nicht so viel Zeit, wie ich gern wollte.
Hatte mich aber schon an das naechste Programm, wie von Dir vorgeschlagen, die Tasten ohne Interrupt zu entprellen gemacht und da ein wenig probiert.

Das muss ich nun auch noch einmal gruendlich ueberdenken bzw ueberarbeiten.
Zuvor moechte ich mir Deine Codeaenderungen im Simulator genau anschauen.

Habe da sicher noch einige Fragen.... :-)

Buona sera, Silvio,

freut mich, dass Du Dich trotz allem nicht vom Assembler-Programmieren abbringen lässt ;-). Nur weiter so.

Ciao,

mare_crisium

Hallo mare_crisium,
habe den Code zum Tasten_3 nach Deinen Vorschlaegen angepasst.

Teil 1war ja im Prinzip nur das Sichern der Register in den Unterprogrammen.
Das Register 17 kann ich nicht mit Sichern, da ich es als Zaehlvariable in der ISR benutze.
Mit R16 – temp kein Problem. Funktioniert:

Code:

;***** STK500 Lernprogramm Nr.3c ;*** Aufgabe: alle LEDs mit einem Taster auf dem STK500 schalten ;*** 1. Tastendruck: LEDs einschalten ;*** 2. Tastendruck: LEDs blinken ;*** 3. Tastendruck: LEDs ausschalten ;*** zum Entprellen soll ein Interrupt(Int0) benutzt werden ;*** .include "m8515def.inc" .def Temp = r16 ; Temporary register .def Tast_Stat = r17 ; Zaehler fuer Taste in ISR .def Delay = R18 ; Wartezeit .def Delay2 = R19 ; Wartezeit ;***** ;Reset and Interrupt vector ;VNr. Beschreibung rjmp RESET ;1 POWER ON RESET rjmp INT0_ISR ;2 Int0-Interrupt reti ;3 Int1-Interrupt reti ;4 TC1 Capture reti ;5 TC1 Compare Match A TC2 Overflow reti ;6 TC1 Compare Match B TC1 Capture reti ;7 TC1 Overflow TC1 Compare Match A reti ;8 TC0 Overflow TC1 Compare Match B reti ;9 SPI, STC Serial Transfer Complete TC1 Overflow reti ;10 UART Rx Complete TC0 Overflow reti ;11 UART Data Register Empty SPI, STC Serial Transfer Complete reti ;12 UART Tx Complete UART Rx Complete reti ;13 Analog Comparator reti ;14 Int2-Interrupt reti ;15 Timer 0 Compare Match reti ;16 EEPROM Ready reti ;17 Store Program Memory Ready RESET: ldi r16, LOW(RAMEND) ;Stack initialisieren out SPL, r16 ldi r16, HIGH(RAMEND) out SPH, r16 ldi temp, (1<<ISC00)|(1<<ISC01) out MCUCR, temp ;Interrupt INT0 konfiguriert ldi temp, 1 << INTF0 ;InterruptFlagregister geloescht out GIFR, temp ldi temp, 1 << INT0 ;Interrupt INT0 aktiviert out GICR, temp clr Temp ;Temp mit 0b00000000 bzw. 0x00 laden out DDRD, Temp ;PORTD als Eingang ser Temp ;Temp mit 0b11111111 bzw. 0xFF laden out PORTD, temp ;PullUp an PortD einschalten out DDRB,Temp ;PORTB als Ausgang out PORTB, temp ;PORTB (LEDs) aus sei ;Interrupts zulassen MAIN: rcall TESTE rjmp MAIN TESTE: push r16 in r16,SREG push r16 clr temp ;loesche temp inc temp ;increment von temp - "1" cp Tast_Stat,temp ;ist TastStat = 1 dann Rufe Sub LED_AN auf, sonst ueberspringe naechsten Befehl breq LED_AN inc temp ;increment von temp - "2" cp Tast_Stat,temp ;ist TastStat = 2 dann Rufe Sub LED_BLINK auf, sonst ueberspringe naechsten Befehl breq LED_BLINK inc temp ;increment von temp - "3" cp Tast_Stat,temp ;ist TastStat = 3 dann Rufe Sub LED_AUS auf, sonst ueberspringe naechsten Befehl breq LED_AUS rjmp TESTE_EXIT LED_AN: ;loesche temp clr temp ;setze alle Bit in temp (0b00000000 bzw. 0x00) out PORTB, temp ;Ausgabe an PortB rjmp TESTE_EXIT LED_BLINK: in temp,PORTB ;lese PORTB in temp com temp ;Einercomplement von temp (ist 0b00000000 > 0b11111111 oder umgekehrt) out PORTB,temp ;Ausgabe an PortB Tot_Zeit: dec Delay ;zaehle ein Register R18 - 0b0000000 runter und springe danach aus der Schleife brne Tot_Zeit ;dec Delay2 ;zaehle ein Register R19 - 0b0000000 runter und springe danach aus der Schleife ;brne Tot_Zeit rjmp TESTE_EXIT LED_AUS: ser temp ;setze alle Bits in temp (0b11111111 bzw. 0xFF) out PORTB,temp ;Ausgabe an PORTB clr Tast_Stat ;Loesche Tast_Stat sleep rjmp TESTE_EXIT TESTE_EXIT: pop r16 out SREG,r16 pop r16 ret INT0_ISR: push R16 ;Inhalt von R16 auf Stack ablegen in R16, SREG ;Statusregister in R16 lesen push R16 ;Inhalt von R16(SREG) auf den Stack ablegen inc Tast_Stat pop R16 ;Ruecksichern von R16(SREG) out SREG, R16 ;Ruecksichern von SREG pop R16 ;Ruecksichern von R16 reti

Der 2. Tipp macht mir jedoch Kopfzerbrechen(Seite 5- TESTE_02 bzw. TESTE_03)
Beim Simulieren im AVR-Studio bekomme ich Speicherfehler, da das Programm den STACK durcheinander bringt...?)

Code:

;***** STK500 Lernprogramm Nr.3b ;*** Aufgabe: alle LEDs mit einem Taster auf dem STK500 schalten ;*** 1. Tastendruck: LEDs einschalten ;*** 2. Tastendruck: LEDs blinken ;*** 3. Tastendruck: LEDs ausschalten ;*** zum Entprellen soll ein Interrupt(Int0) benutzt werden ;*** .include "m8515def.inc" .def Temp = r16 ; Temporary register .def Tast_Stat = r17 ; Zaehler fuer Taste .def Delay = R18 ; Wartezeit .def Delay2 = R19 ; Wartezeit ;***** ;Reset and Interrupt vector ;VNr. Beschreibung rjmp RESET ;1 POWER ON RESET rjmp INT0_ISR ;2 Int0-Interrupt reti ;3 Int1-Interrupt reti ;4 TC1 Capture reti ;5 TC1 Compare Match A TC2 Overflow reti ;6 TC1 Compare Match B TC1 Capture reti ;7 TC1 Overflow TC1 Compare Match A reti ;8 TC0 Overflow TC1 Compare Match B reti ;9 SPI, STC Serial Transfer Complete TC1 Overflow reti ;10 UART Rx Complete TC0 Overflow reti ;11 UART Data Register Empty SPI, STC Serial Transfer Complete reti ;12 UART Tx Complete UART Rx Complete reti ;13 Analog Comparator reti ;14 Int2-Interrupt reti ;15 Timer 0 Compare Match reti ;16 EEPROM Ready reti ;17 Store Program Memory Ready RESET: ldi r16, LOW(RAMEND) ;Stack initialisieren out SPL, r16 ldi r16, HIGH(RAMEND) out SPH, r16 ldi temp, (1<<ISC00)|(1<<ISC01) out MCUCR, temp ;Interrupt INT0 konfiguriert ldi temp, 1 << INTF0 ;InterruptFlagregister geloescht out GIFR, temp ldi temp, 1 << INT0 ;Interrupt INT0 aktiviert out GICR, temp clr Temp ;Temp mit 0b00000000 bzw. 0x00 laden out DDRD, Temp ;PORTD als Eingang ser Temp ;Temp mit 0b11111111 bzw. 0xFF laden out PORTD, temp ;PullUp an PortD einschalten out DDRB,Temp ;PORTB als Ausgang out PORTB, temp ;PORTB (LEDs) aus sei ;Interrupts zulassen MAIN: rcall TESTE rjmp MAIN TESTE: push r16 in r16,SREG push r16 ; In Abhängigkeit von Tast_Stat Aktivität auswählen clr temp ; inc temp ; temp := Vergleichszahl; Anfangswert Eins cp Tast_Stat,temp brne TESTE_02 ; Sprung, wenn TastStat <> 1 rcall LED_EIN rjmp TESTE_EXIT TESTE_02: ; Tast_Stat > 1 inc temp cp Tast_Stat,temp ; Vergleichszahl := 2 brne TESTE_03 ; Sprung, wenn TastStat <> 2 rcall LED_BLINK rjmp TESTE_EXIT TESTE_03: ; Tast_Stat > 3 inc temp ; Vergleichszahl := 3 cp Tast_Stat,temp brne TESTE_EXIT ; Sprung, wenn TastStat <> 3 rcall LED_AUS LED_EIN: ;loesche temp clr temp ;setze alle Bit in temp (0b00000000 bzw. 0x00) out PORTB, temp ;Ausgabe an PortB rjmp TESTE_EXIT LED_BLINK: in temp,PORTB ;lese PORTB in temp com temp ;Einercomplement von temp (ist 0b00000000 > 0b11111111 oder umgekehrt) out PORTB,temp ;Ausgabe an PortB ;Tot_Zeit: ;dec Delay ;zaehle ein Register R18 - 0b0000000 runter und springe danach aus der Schleife ;brne Tot_Zeit ;dec Delay2 ;zaehle ein Register R19 - 0b0000000 runter und springe danach aus der Schleife ;brne Tot_Zeit rjmp TESTE_EXIT LED_AUS: ser temp ;setze alle Bits in temp (0b11111111 bzw. 0xFF) out PORTB,temp ;Ausgabe an PORTB clr Tast_Stat ;Loesche Tast_Stat rjmp TESTE_EXIT TESTE_EXIT: pop r16 out SREG,r16 pop r16 ret INT0_ISR: push R16 ;Inhalt von R16 auf Stack ablegen in R16, SREG ;Statusregister in R16 lesen push R16 ;Inhalt von R16(SREG) auf den Stack ablegen inc Tast_Stat pop R16 ;Ruecksichern von R16(SREG) out SREG, R16 ;Ruecksichern von SREG pop R16 ;Ruecksichern von R16 reti

eventuell habe ich auch einen Bug mit eingebaut.
Nach dem 1. Abarbeiten der ISR kommt das LED_EIN.
Hier wird wieder durch das rjmp der Programmzaehler auf den Stack abgelegt.
Danach der Sprung zum TESTE_EXIT.
Dabei wird ins SREG 0X00 (ein Teil vom Programmzaehler - rjmp LED_EIN) rein geschrieben.
-muesste da nicht doch LED_EIN mit „ret“ beendet werden?

Das sichern des SREG und ggf, anderer register braucht man nur für ISRs.
Wenn man es trotzdem macht, verschwendet man erstmal Platz auf den Stack, und man kann leicht Fehler machen sodass es dann den Stack richtig durcheinander bringt.

Dann ist da noch ein Fehler dirn: Unterprogramme die man mir Rcall aufruft, bendet man mit RET, nicht mit einem RJMP nach teste_exit.

Silvio,

ich habe mir das Lernprogramm 3c ungeändert aus Deinem Posting in den Simulator des AVRStudio geladen und durch alle Zustände von "Tast_Stat" durchlaufen lassen. Es hat einwandfrei funktioniert :-) . Nur die "sleep"-Anweisung war wirkungslos, weil Du im MCUCR-Register das Bit SE nicht auf "1" gesetzt hast. Aber selbst, wenn ich im Simulator SE in MCUCR auf "1" setze, läuft das Programm völlig richtig weiter.

Lernprogramm 3b muss noch korrigiert werden. Zweck der Übung war ja, die einzelnen Funktionen "LED_EIN", "LED_AUS" und "LED_BLINK" in je eine selbstständige Prozedur auszulagern. Wenn man das tut, muss man jede dieser Prozeduren auch mit einer eigenen "ret"-Anweisung abschliessen, sonst kommt der Stack tatsächlich durcheinander.

So könnte das aussehen

Code:

;***** STK500 Lernprogramm Nr.3bb ;*** Aufgabe: alle LEDs mit einem Taster auf dem STK500 schalten ;*** 1. Tastendruck: LEDs einschalten ;*** 2. Tastendruck: LEDs blinken ;*** 3. Tastendruck: LEDs ausschalten ;*** zum Entprellen soll ein Interrupt(Int0) benutzt werden ;*** .include "m8515def.inc" .def Temp = r16 ; Temporary register .def Tast_Stat = r17 ; Zaehler fuer Taste .def Delay = R18 ; Wartezeit .def Delay2 = R19 ; Wartezeit ;***** ;Reset and Interrupt vector ;VNr. Beschreibung rjmp RESET ;1 POWER ON RESET rjmp INT0_ISR ;2 Int0-Interrupt reti ;3 Int1-Interrupt reti ;4 TC1 Capture reti ;5 TC1 Compare Match A TC2 Overflow reti ;6 TC1 Compare Match B TC1 Capture reti ;7 TC1 Overflow TC1 Compare Match A reti ;8 TC0 Overflow TC1 Compare Match B reti ;9 SPI, STC Serial Transfer Complete TC1 Overflow reti ;10 UART Rx Complete TC0 Overflow reti ;11 UART Data Register Empty SPI, STC Serial Transfer Complete reti ;12 UART Tx Complete UART Rx Complete reti ;13 Analog Comparator reti ;14 Int2-Interrupt reti ;15 Timer 0 Compare Match reti ;16 EEPROM Ready reti ;17 Store Program Memory Ready RESET: ldi r16, LOW(RAMEND) ;Stack initialisieren out SPL, r16 ldi r16, HIGH(RAMEND) out SPH, r16 ldi temp, (1<<ISC00)|(1<<ISC01) out MCUCR, temp ;Interrupt INT0 konfiguriert ldi temp, 1 << INTF0 ;InterruptFlagregister geloescht out GIFR, temp ldi temp, 1 << INT0 ;Interrupt INT0 aktiviert out GICR, temp clr Temp ;Temp mit 0b00000000 bzw. 0x00 laden out DDRD, Temp ;PORTD als Eingang ser Temp ;Temp mit 0b11111111 bzw. 0xFF laden out PORTD, temp ;PullUp an PortD einschalten out DDRB,Temp ;PORTB als Ausgang out PORTB, temp ;PORTB (LEDs) aus sei ;Interrupts zulassen MAIN: rcall TESTE rjmp MAIN TESTE: push r16 in r16,SREG push r16 ; In Abhängigkeit von Tast_Stat Aktivität auswählen clr temp ; inc temp ; temp := Vergleichszahl; Anfangswert Eins cp Tast_Stat,temp brne TESTE_02 ; Sprung, wenn TastStat <> 1 rcall LED_EIN rjmp TESTE_EXIT TESTE_02: ; Tast_Stat > 1 inc temp cp Tast_Stat,temp ; Vergleichszahl := 2 brne TESTE_03 ; Sprung, wenn TastStat <> 2 rcall LED_BLINK rjmp TESTE_EXIT TESTE_03: ; Tast_Stat > 3 inc temp ; Vergleichszahl := 3 cp Tast_Stat,temp brne TESTE_EXIT ; Sprung, wenn TastStat <> 3 rcall LED_AUS TESTE_EXIT: pop r16 out SREG,r16 pop r16 ret /*----------------------- PROZEDUR LED_EIN Die Prozedur LED_EIN setzt im Register "temp" alle Bits auf 0 und gibt "temp" an PORTB aus. Eingangsgrössen temp enthält den aktuellen LED-Zustand Ausgangsgrössen temp enthält den LED-Zustand 0x00 = alle LEDs eingeschaltet geänderte Register temp geänderte Ports PORTB */ LED_EIN: push r19 in r19,SREG clr temp ;setze alle Bit in temp (0b00000000 bzw. 0x00) out PORTB, temp ;Ausgabe an PortB out SREG,r19 pop r19 ret /*----------------------- PROZEDUR LED_AUS Die Prozedur LED_AUS setzt im Register "temp" alle Bits auf 1 und gibt "temp" an PORTB aus. Eingangsgrössen temp enthält den aktuellen LED-Zustand Ausgangsgrössen temp enthält den LED-Zustand 0xFF = alle LEDs ausgeschaltet geänderte Register temp geänderte Ports PORTB */ LED_AUS: push r19 in r19,SREG ser temp ;setze alle Bits in temp (0b11111111 bzw. 0xFF) out PORTB,temp ;Ausgabe an PORTB clr Tast_Stat ;Loesche Tast_Stat out SREG,r19 pop r19 ret /*----------------------- PROZEDUR LED_BLINK Die Prozedur LED_BLINK invertiert im Register "temp" alle Bits und gibt den neuen Inhalt von "temp" an PORTB aus. Eingangsgrössen temp enthält den aktuellen LED-Zustand Ausgangsgrössen temp enthält den invertierten LED-Zustand = alle LEDs umgeschaltet geänderte Register temp geänderte Ports PORTB */ LED_BLINK: push r19 in r19,SREG in temp,PORTB ;lese PORTB in temp com temp ;Einercomplement von temp (ist 0b00000000 > 0b11111111 oder umgekehrt) out PORTB,temp ;Ausgabe an PortB ;Tot_Zeit: ;dec Delay ;zaehle ein Register R18 - 0b0000000 runter und springe danach aus der Schleife ;brne Tot_Zeit ;dec Delay2 ;zaehle ein Register R19 - 0b0000000 runter und springe danach aus der Schleife ;brne Tot_Zeit out SREG,r19 pop r19 ret INT0_ISR: push R19 ;Inhalt von R19 auf Stack ablegen in R19, SREG ;Statusregister in R19 lesen inc Tast_Stat out SREG, R19 ;Ruecksichern von SREG pop R19 ;Ruecksichern von R19 reti

So müsste es jetzt funktionieren.

Ciao,

mare_crisium

Tasten_4

so mal wieder was von mir ....
Wie schon angekuendigt, wollte ich ohne Interrupt ein Programmcode schreiben.
Dabei sollen die LEDs mit dem jeweils auf dem STK500 befindlichen Taster geschaltet werden.
Also druecke Taste - jeweilige LED wird je nach vorherigen Zustand umgeschaltet.
LED an wird LED aus
LED aus wird LED an

Ablauf:
Im Programm selbst frage ich in der MAIN den TastenPort ab und lese den Inhalt in ein 1 Register,
invertiere dieses und schiebe den Inhalt in ein 2. Register.
Teste dann ob Taste gedrueckt ist, wenn ja springe in Warte und zaehle dort ein Register runter,
danach(RE_TEST) lese erneut den TastenPort in das 1. Register aus invertiere den Inhalt,
vergleiche dann mit Inhalt des 2. Registers(erstes Auslesen), wenn gleich springe zu LED_TOGGLE.
In LED_TOGGLE wird der LED_PORT in das LED_Stat-Register gelesen.
Nun wird mittels Exklusiv-ODER das LED_Stat-Register mit dem TAST_Stat-Register umgeschrieben.
LED=1 Tast=1 == LED=0
LED=0 Tast=0 == LED=0
LED=0 Tast=1 == LED=1
LED=1 Tast=0 == LED=1
Dann wird der Inhalt des LED_Stat an den LED_PORT ausgegeben.
Als naechstes wird nun ueberprueft, ob die gedrueckte Taste noch immer gedrueckt ist.
Falls das sein sollte kommt der Sprung in eine Schleife, die permanent die Tasten abfragt, bis die urspruenglich gedrueckte Taste losgelassen wurde.
Wenn das passiert kommt der Sprung zurueck in die MAIN, wo das Spiel wieder von vorn beginnen kann.
Hier nun der Code...

Code:

;***** STK500 Lernprogramm Nr.4 ;*** Aufgabe: die der jeweiligen Taste zugeordnete LED auf dem STK500 schalten ;*** 1. Tastendruck: LEDs einschalten ;*** 2. Tastendruck: LEDs ausschalten ;*** zum Entprellen soll kein Interrupt werden ;*** .include "m8515def.inc" .def Temp = r16 ; Temporary register .def Tast_Stat = r17 ; Tasten Status .def Tast_Stat1 = r18 .def LED_Stat = R19 ; LED Status ; .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 ; ;***** ;Reset and Interrupt vector ;VNr. Beschreibung rjmp RESET ;1 POWER ON RESET reti ;2 Int0-Interrupt reti ;3 Int1-Interrupt reti ;4 TC1 Capture reti ;5 TC1 Compare Match A TC2 Overflow reti ;6 TC1 Compare Match B TC1 Capture reti ;7 TC1 Overflow TC1 Compare Match A reti ;8 TC0 Overflow TC1 Compare Match B reti ;9 SPI, STC Serial Transfer Complete TC1 Overflow reti ;10 UART Rx Complete TC0 Overflow reti ;11 UART Data Register Empty SPI, STC Serial Transfer Complete reti ;12 UART Tx Complete UART Rx Complete reti ;13 Analog Comparator reti ;14 Int2-Interrupt reti ;15 Timer 0 Compare Match reti ;16 EEPROM Ready reti ;17 Store Program Memory Ready ;***** RESET: ldi r16, LOW(RAMEND) ;Stack initialisieren out SPL, r16 ldi r16, HIGH(RAMEND) out SPH, r16 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 MAIN: in Tast_Stat, TAST_PIN ; lese von PinD und speicher den Inhalt in Tast_Stat com Tast_Stat ; invertiert fuer spaetere EOR-Berechnung mov Tast_Stat1, Tast_Stat ; schiebe den Inhalt von Tast_Stat in Tast_Stat2 cpi Tast_Stat, 0b00000000 ; vergleiche Tast_Stat mit 0b00000000, wenn ungleich (Taste gedrueckt) springe zu WARTE brne WARTE rjmp MAIN WARTE: push r25 ; Register auf Stack sichern in r25, SREG push r25 WARTE_0: ; Wartezeit zum Entprellen dec r25 ; Schleife decrement Register 25 cpi r25, 0b00000000 breq WARTE_ZEIT_EXIT rjmp WARTE_0 WARTE_ZEIT_EXIT: ; Ausgang aus Warteschleife pop r25 ; Register vom Stack holen out SREG, r25 pop r25 RE_TEST: ; 2. Test - Vergleich ob Taste noch immer gedrueckt in Tast_Stat, TAST_PIN ; erneute Abfrage von Tasten und Vergleich mit erster Abfrage com Tast_Stat ; invertiert fuer spaetere EOR-Berechnung cp Tast_Stat, Tast_Stat1 ; wenn gleich, springe zu LED_TOGGLE breq LED_TOGGLE rjmp MAIN LED_TOGGLE: ; schaltet LED um in LED_Stat, LED_PORT ; lese LEDs aus und speichere in LED_Stat eor LED_Stat, Tast_Stat ; ExclusivODER - schalte die Ausgaenge , wo Tasten gedrueckt werden um ; LED=1 Tast=1 == LED=0 ; LED=0 Tast=0 == LED=0 ; LED=0 Tast=1 == LED=1 ; LED=1 Tast=0 == LED=1 out LED_PORT, LED_Stat cp Tast_Stat, Tast_Stat1 ; vergleiche ob Taste losgelassen breq WARTE2 ; wenn nicht losgelassen, springe in WARTE2 rjmp MAIN ; Abfrage von Tasten und Vergleich ob die urspruenglich gedrueckte Taste noch immer gedrueckt ist ; neu gedrueckte Taste wird waehrend die urspruenglich gedrueckte Taste noch gedrueckt ignoriert ; ist urspruenglich gedrueckte Taste gedrueckt wird die Schleife nicht verlassen WARTE2: RE_TEST_2: in Tast_Stat, TAST_PIN com Tast_Stat ; invertiert fuer spaetere EOR-Berechnung and Tast_Stat, Tast_Stat1 ; Bitmaske - urspruenglich gedrueckte Taste cp Tast_Stat, Tast_Stat1 breq WARTE2 rjmp MAIN

PS.
Einen Zustand habe ich nun noch nicht bedacht.
Es kann keine weitere Taste gedrueckt werden, solange die erste Taste nicht losgelassen wurde.
Das ist von mir in dem Programm zwar so gewollt, weil ich mir noch ueber die Ausfuehrung noch nicht Gedanken gemacht habe.
Haette ich das im jetzigen Code nicht verriegelt, wueder mir die weitere Taste, die erste LED wieder umschalten.

Eine Frage noch an die Experten:
Kann man im AVR-Studio die Zeilennummern aktivieren?
-> es macht die Fehlersuche leichter

Liste der Anhänge anzeigen (Anzahl: 1)

robo_wolf,

als erstes fiel mir am Lernprogramm Nr. 4 auf, dass Du nach dem Label 'WARTE' diese "push"-Anweisungen eingebaut hast. Die brauchst Du gar nicht. Auf die Gefahr hin, Dir nichts Neues zu erzählen, habe ich trotzdem 'mal ein paar Erklärungen zum Stack und zu den "call"-, "ret"-, "push"- und "pop"-Anweisungen aufgeschrieben. Es kann ja nicht schaden ... ;-).

Den Rest Deines Programms kommentiere ich später.

mare_crisium

P.S.: Ich hab's bisher noch nicht hingekriegt, die Zeilennummern anzeigen zu lassen. Ich habe mich bisher immer mit der kleinen Anzeige unten rechts beholfen, die die Zeilennummer beim Cursor angibt.

Hallo mare_crisium,
vielen Dank für doch sehr ausfuehrliche Erlaeuterung des Stacks.
Sicher war mir die Funktion und Arbeitsweise schon vertraut.Trotzdem fand ich die Erklaerungen noch vertiefend und leicht verstaendlich.
Aber auch andere User lesen unsere Zeilen und werden sicher ueber so manche verstaendlich geschriebene Erlaeuterung dankbar sein.

Jetzt wo Du mich darauf aufmerksam gemacht hast, sehe ich auch, dass keine Subs im Programm 4 vorhanden sind. Will das Programm eh noch erweitern und eventuell etwas umstellen... Da werde ich doch wieder Unterprogramme mit verwenden.

Danke für Deinen freundlichen Kommentar, robo_wolf. Leider interessieren sich nicht mehr sehr viele für Assemblerprogrammierung, wie man an der Anzahl downloads sieht. C und Konsorten führen halt viel schneller zu sichtbaren Erfolgen; Assembler erfordert Geduld und Übung. Beides ist hierzulande jüngst etwas aus der Mode gekommen ;-) .

Wenn Du sowieso noch einmal Hand an Dein Programm Nr. 4 legen willst, wie wär's, wenn Du versuchtest, die Tasten von einem Dienstprogramm ablesen zu lassen, dass in regelmässigen Abständen von einem Timer-Interrupt ausgelöst wird? Die Timer wirst Du noch sehr häufig brauchen. Je früher Du Dich mit denen anfreundest, desto besser ;-) !

Ciao,

mare_crisium

Hallo mare_crisium,
nehme deinen Rat mit den Timer gern an.
Zum Assembler bin ich gerade wegen der Hardwarenaehe gekommen.
Hatte mich auch erst an C und Bascom probiert.
Da blieben fuer mich aber einige Fragen offen. Es funktionierte zwar aber die Hintergruende bleiben da auf der Strecke.
Fuer einige vielleicht nicht wichtig, fuer mich aber schon.
Wenn mann die Hintergruende kennt, kann man besser aggieren. - ist meine Meinung - fuer mich ist das Ganze "nur" Hobby und das soll ja auch Spass machen.
Ausserdem finde ich, ist es aehnlich wie in der Schule Mathematik. Wenn man die Hintergruende kennt, braucht man nicht alles auswendig lernen(was eh keinen Sinn macht) - man kann sich seine Loesungen erarbeiten.

Eine Frage noch zum STK500. Es ist doch sicher sinnvoll auf externen Takt umzusteigen. Was fuer einen Quarz empfiehlst du mir? 4, 8, ??? MHz

Liste der Anhänge anzeigen (Anzahl: 1)

Guten Abend, robo_wolf,

genauso geht mir's auch: Ich will eben gern wissen, was der MC so treibt ;-). Dazu kommt, dass das Assemblerprogrammieren umso zügiger voran, je mehr sorgfältig ausgetestete Module man sich im Laufe der Zeit aufbaut. Das grösste Programm, das ich so geschrieben habe ist 13kB gross. Der Quelltext (alle Module zusammengerechnet und inkl. Kommentare) ist 13000 Zeilen lang.

Wegen des Quarzes? Na, wenn schon dann "the full monty"! Nimm ruhig die 16MHz, die Dein 8515 laut Datenblatt maximal vertägt. Meine ATmegas auf dem STK500 laufen auch so.

Ciao,

mare_crisium

P.S.: Zu Erleichterung der Parameterberechnung für den Timer hänge ich mal die Rechentabelle an, die ich mir dafür gebastelt habe. Nur die gelb unterlegten Felder sind für die Eingabe.

Hallo mare_crisium,
in die kleine Tabelle hast du ja ordentlich was reingepackt.
Danke
Hatte leider ein paar technische Probleme mit dem AVR-Studio.
Sind aber nun geloest. :-)
Welches Projekt hat denn 13000 Codezeilen gebraucht?

robo_wolf,

das ist ein Programm, das mit 16MHz auf einem ATmega16 läuft und zwei optische Maussensoren auswertet. Es berechnet alle 200ms aus den Maus-Messwerten eine komplette Koppelnavigation für das Fahrzeug, an dem die Sensoren montiert sind. Es hat ausserdem eine Schnittstelle zum TWI-Bus, über den andere Busteilnehmer die berechneten Daten (Ort, Orientierung, Linear- und Drehgeschwindigkeit) abfragen können. Leider sind die Messdaten der Maussensoren nicht so genau, wie ich's erhofft hatte :-(. Bin aber noch am Experimentieren.

Ciao,

mare_crisium

Liste der Anhänge anzeigen (Anzahl: 1)

robo_wolf,

hier die Kommentare zu Deinem Lernprogramm Nr. 4, diesmal in graphischer Form. Die graphische Darstellung ist manchmal ein gutes Mittel, um die Struktur des Programms zu durchschauen. Oft sieht man dann wieder den Wald und lässt sich von den vielen Bäumen nicht mehr so durcheinanderbringen ;-).

Es gibt verschiedene Normen bzgl. der Symbole, die für Abfrage, Anweisungen, Sprungmarken usw. verwendet werden sollten. Meine Darstellung ist "Freistil".

Ciao,

mare_crisium

13 000 :-b :-b :-b
und ich dachte immer, die 3000 oder mehr von meinem Dottie seien schon viel. Und davon sind vermutlich mehr als 60 % Kommentare. Alle Achtung!

Zitat:

Zitat von mare_crisium

... nicht ganz normenkonform ...

Ich mache das auch nicht korrekt. Bin halt die Nassi-Shneiderman gewöhnt . . . und versuche mich, etwas sehr selten, in UML.

Oberallgeier,

ja, ist schon ne ganze Menge! Ich wollte damit auch nur sagen, dass der Quelltext auch bei ganz harmlosen Projekten schon ziemlich lang ;-) werden kann. Um sowas fehlerfrei zum Laufen zu bringen, braucht man eben
1. eine übersichtliche, vorzugsweise modulare, Programmstruktur
2. einzeln, vorm Einbinden ins Gesamtprogramm, ausgetestete Programm-Module.
Bei diesem Austesten findet man Fehler sehr viel schneller, wenn man sich selbst bestimmte Regeln für das Programmieren vorgibt und sie dann sorgfältig einhält.

mare_crisium

so nach laengerer Zeit nun endlich das Programm mit Timer0

Code:

;***** STK500 Lernprogramm Nr.4c ;*** Aufgabe: die der jeweiligen Taste zugeordnete LED auf dem STK500 schalten ;*** 1. Tastendruck: LEDs einschalten ;*** 2. Tastendruck: LEDs ausschalten ;*** zum Entprellen soll kein Interrupt werden ;*** .include "m8515def.inc" .def Temp = r16 ; Temporary Register .def Tast_Stat0 = r17 ; Tasten Status .def Tast_Stat = r18 .def LED_Stat = r19 ; LED Status .def Tast_Sperre = r0 .def Aus = r20 ; ; TimerWerte(bei 1MHz - ca. 0,1sec/Takt) ;.equ Timerwert = -50 ; Timerschritte bis zum Überlauf(fuer Simulatortest) .equ Timerwert = 61 ; Timerschritte bis zum Überlauf .def tsw = r5 ; Timer Startwert (Reload) ; ; .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 ; ;***** ;Reset and Interrupt vector ;VNr. Beschreibung rjmp RESET ;1 POWER ON RESET reti ;2 Int0-Interrupt reti ;3 Int1-Interrupt reti ;4 TC1 Capture reti ;5 TC1 Compare Match A TC2 Overflow reti ;6 TC1 Compare Match B TC1 Capture reti ;7 TC1 Overflow TC1 Compare Match A rjmp TIMER0_OVF ;8 TC0 Overflow TC1 Compare Match B reti ;9 SPI, STC Serial Transfer Complete TC1 Overflow reti ;10 UART Rx Complete TC0 Overflow reti ;11 UART Data Register Empty SPI, STC Serial Transfer Complete reti ;12 UART Tx Complete UART Rx Complete reti ;13 Analog Comparator reti ;14 Int2-Interrupt reti ;15 Timer 0 Compare Match reti ;16 EEPROM Ready reti ;17 Store Program Memory Ready ;***** RESET: ldi temp,Timerwert mov tsw,temp out TCNT0,tsw ; ldi temp,(1<<CS00) ; Taktfrequenz ohne Vorteiler gewaehlt (fuer Simaulatortest) ldi temp,(1<<CS00)|(1<<CS02) ; Taktfrequenz mit Vorteiler 1024 gewaehlt out TCCR0,temp ldi temp,(1<<TOIE0) ; Timer0 Overflow aktivieren out TIMSK,temp ldi r16, LOW(RAMEND) ;Stack initialisieren out SPL, r16 ldi r16, HIGH(RAMEND) out SPH, r16 clr Temp ;Temp mit 0b00000000 bzw. 0x00 laden out TAST_DDR, Temp ;PORTD als Eingang mov Tast_Sperre, temp 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 clr Tast_Stat ;Tast_Stat auf def. Zustand clr Aus sei ; globale Interruptfreigabe MAIN: rcall TASTEN_TEST rjmp MAIN TIMER0_OVF: push TEMP ; TEMP auf Stack sichern in TEMP,SREG ; SREG auf Stack sichern push TEMP ; in Tast_Stat0, TAST_PIN com Tast_Stat0 ; invertiere out TCNT0,TSW ; Timer0-Startwert setzen pop TEMP ; out SREG,TEMP ; SREG zurueckschreiben pop TEMP ; TEMP zurueckschreiben reti TASTEN_TEST: mov Tast_Stat, Tast_Stat0 cp Tast_Stat, Aus ; Vergleich - (0b11111111->keine Taste) brne LED_TOGGLE ; bei != rufe LED_TOGGLE auf ret LED_TOGGLE: ; schaltet LED um in LED_Stat, LED_PORT ; lese LEDs aus und speichere in LED_Stat com LED_Stat ; invertiere eor Tast_Stat, Tast_Sperre ; gedrueckt gehaltene Taste sperren ; LED=1 Tast=1 == LED=0 ; LED=0 Tast=0 == LED=0 ; LED=0 Tast=1 == LED=1 ; LED=1 Tast=0 == LED=1 eor LED_Stat, Tast_Stat ; ExclusivODER - schalte die Ausgaenge , wo Tasten gedrueckt werden um com LED_Stat ; invertiere out LED_PORT, LED_Stat ; Ausgabe an LEDs in Tast_Stat0, TAST_PIN ; Wiedereinlesen fuer Tastensperre com Tast_Stat0 ; invertiere mov Tast_Sperre, Tast_Stat0 ret

Nur das Problem mit der 2.Tasten, wenn eine vorher "gedrueckte" noch gesetzt ist bzw. nicht losgelassen wurde.
Das will ich noch aendern. - Es soll auch eine 2. oder 3. Eingabe moeglich sein, wenn die 1. oder 2. nicht zurueck gesetzt wurde bzw. die Tasten noch immer gedrueckt sind.

Liste der Anhänge anzeigen (Anzahl: 1)

graphische Darstellung

Hallo mare_crisium,
habe mal eine graphische Darstellung gemacht, so wie ich es mir vorstelle.
Bitte verbessere mich, wenn Du Ungereimtheiten oder Fehler siehst.

robo_wolf,

werd's mir heute abend zu Gemüte führen. Versuche, morgen meine Rückmeldung zu posten.

Ciao,

mare_crisium

Liste der Anhänge anzeigen (Anzahl: 1)

robo_wolf,

an Deiner Grafik kann man gut die Struktur erkennen, die Dir vorschwebt - dafür sind diese grafischen Darstellungen sehr praktisch.

Ich lese Dein Bild so:
Du hast vor, zwei von einander unabhängige Programmteile aufzubauen:
1. einer liest den Tastenzustand aus
2. der andere wertet den Tastenzustand aus und führt abhängig davon eine Aktion aus
(LEDs ein und aus).

Der 1. Teil, der vom Timerinterrupt angestossen wird, ist für die Entprellung zuständig. Dazu gibt's im Anhang noch etwas Ausführlicheres ;-) . Der 2. Teil reagiert auf die Tastenzustände, wie er sie vom 1. Teil "vorgekaut" vorfindet. Diese Einteilung gefällt mir sehr gut, weil sie voneinander unabhängige Aufgaben getrennten Programmteilen zuordnet.

Zum 1. Teil fallen mir noch folgende Gesichtspunkte ein: Jeder Taster hat die beiden Zustände “betätigt“/“nicht betätigt“. Welche Pegel dabei am Portpin anstehen, hängt von der Art des Tasters („Öffner“ oder „Schliesser“) und von der Beschaltung ab. Ein Öffner zwischen Portpin (mit aktiviertem pull-up-Widerstand)und Masse liefert im betätigten Zustand eine logische Eins, ein Schliesser eine logische Null. Um aller möglichen Verwirrung vorzubeugen, ist es gute Praxis, wenn der 1. Programmteil immer denselben logischen Zustand liefert, wenn der Taster betätigt wird, z.B. den Zustand „hoch“ (= logisch Eins), ganz unabhängig davon, ob das jetzt 5V oder 0V am Pin entspricht.

Wenn man's nicht so macht, muss man sich später im 2. Programmteil immer wieder daran erinnern, wie die Hardware aussieht. Als ich noch mit sehr umfangreichen, mit Relais aufgebauten Steuerungen (naja, das war in den 1980ern ;-) ) zu tun hatte, habe ich mich mir mit sowas mehr als einmal fast das Gehirn verstaucht.

Der erste Programmteil ist ein „Treiber“, der die Hardware kapselt. D.h. alle Programmteile, die die Tasterzustände verarbeiten, die der Treiber liefert, brauchen nichts über die Hardware zu wissen. Wird irgendwann mal ein Taster von Öffner auf Schliesser getauscht, dann braucht man nur den 1. Programmteil anzupassen. Alle anderen Teile können so bleiben, wie sie sind.

Im 2. Teil hast Du die möglichen Tastenzustände, die er vorfindet, in den drei hellbraunen Kästchen aufgezählt. Da fehlt aber einer, nämlich der „Taste losgelassen“. Es ist sehr wichtig, sich immer eine vollständige Liste aller möglichen Zustände aufzuschreiben, damit man ja nicht vergisst, für alle Zustände die Reaktion festzulegen. Und wenn man einen Zustand ausser Acht lassen will, dann ist ganz besonders wichtig, genau dafür die Begründung aufzuschreiben. Man glaubt gar nicht, wie schnell man die Gründe für das Weglassen vergessen hat. Liest man dann später das Programm, hält man das Weglassen erstmal für einen Fehler. Es kostet erfahrungsgemäss sehr viel Zeit, bis man schliesslich wieder dahinterkommt, dass man schon damals so ein schlaues Kerlchen gewesen war...

In Deinem Fall hast Du festgelegt, dass nichts passieren soll, wenn der Taster gedrückt gehalten wird oder wenn er dauernd nicht gedrückt ist. Nur, wenn der Taster gerade gedrückt worden ist, soll das LED umgeschaltet werden. Für das Loslassen hast Du keine Reaktion vorgesehen. Das führt dazu, dass die LED bei jedem zweiten Tastendruck wieder ausgeht. Es gibt also keine ein-eindeutige Zuordnung von Taster- und LED-Zustand. Aber - vielleicht wolltest Du's ja so haben :-) .

Noch ein Vorschlag: Lass' uns diese Version erstmal für eine einzige Taste zum Laufen bringen, danach kümmern wir uns um die Behandlung von mehreren Tasten. Da können wir dann man gucken, wie man vorgeht, wenn man mehr Variablen als Register verfügbar hat...

Ciao,

mare_crisium

Edit: Im Anhang den Fehler korrigiert, auf den robo_wolf in seinem Posting vom 01.02.2010 hinweist.

Hallo mare_crisium,

herrlich - eine ZAK (ZustandsAutomatenKanone), made by mare_crisium. Einfach perfekt. Und ein schönes Lehrstück zur Tastenverwaltung. Ich muss mal sehen, was davon ich abkupfern kann (ich nehme mir einfach diese Freiheit *ggg* - und danke schon mal dafür).

Das Thema interessiert mich, weil ich derzeit seit vielen Tagen (wieder mal) an einem Pacer arbeite - das ist ein Blinker (vllt. mit Piepsmöglichkeit), der mit zwei LEDs und zwei Tastern ausgestattet ist und mir für Lauftraining eine Schrittfrequenz vorgibt. Also eine Art Metronom. Kein Display - ausser den beiden LEDs.

Die Tasten dienen zum Einschalten des aktiven Modus, zum Ausschalten, zum Ändern der Frequenz rauf und runter, zum Ein-/Ausschalten des Piepsers, zum Ändern eines Zeit-Mess-Taktes - weil das Dings ohne Quarz läuft und daher nicht wirklich stabil in der Frequenz ist. Dieses Gimmik ist auch ne Kanone - aber es soll halt alles den Anschein von Perfektion haben. Vielleicht noch mehr Gimmiks.

Nun habe ich meine Tasten nicht nur zu entprellen gehabt, sondern wollte auch in einem Horizont von etwa 2,5 sec wissen, wie lange die Taste schon gedrückt bzw. gelöst wurde. Damit kann/will ich im Menue herumtoben, je nachdem welche Taste in welcher Reihenfolge wie lange gedrückt wurde. Kennen wir von mancher alten Digital-Armbanduhr, von Fahrradcomputern etc. Also stelle ich den Tastenstatus der beiden Tasten TAB und TAU (Taste ABwärts und Taste AUfwärts) im 100 Hz Rhythmus in einer ISR fest - und zähle die jeweiligen Zeitabschnitte (in 10 ms-Schnitten) "gelöst" oder "gedrückt" ab dem letzen Wechsel. Damit kann ich dann recht gut spielen.

Das Ganze läuft dann so auf (m)einem tiny85:

Code:

/* >> Sicherung 22Jan10 0930 ...C2..\PCR_80\PCR_80_tmr_x51.c Es folgt ein Auszug aus einem funktionierenden Teilprogramm =================================================================================== Target MCU : ATtiny85 Target Hardware : Pacer ... Target cpu-frequ. : In der Quelle wählbar =================================================================================== Enthaltene Routinen: Nur Timer ... void TC1TMR_init(void) // Init Tmr/Cntr1, 8-Bit auf ca. 100 Hz = 0,01 s 50 ... ISR(TIM1_COMPA_vect) // Vektor 4 (1 ... 4 !!!) doc S 50 ... =================================================================================== *** Versionsgeschichte: ==================== x51 22Jan10 0930 Weiter in der Blink-organisation ... x00 07Dez09 2220 Übernahme vom Original, s.u., =================================================================================== *** Aufgabenstellung : Timer für pacer80 Original: ...C2..\pacer_61\pcr61_tmr_x21.c x21 11feb09 war: ...C2..\wallr_20\WR3_tmr_x03.c 30Nov08 ================================================================================ */ // ================================================================================ // ================================================================================ // === Initialisierung fuer Timer1 tiny85 ======================================== void TC1TMR_init(void) // Init Tmr/Cntr1, 8-Bit auf ca. 100 Hz = 10 ms { TCCR1 |= (1<<CTC1); // Timer im CTC-Mode, Top=OCRA doc S 92 TCCR1 |= (1<<CS12)|(1<<CS11)|(1<<CS10); // Prescaler Clock1/64 doc S 93 OCR1C = 152; // Preset/Preload = 152 => getestet ca. 0,010s @ 1,0Mhz TIMSK |= (1<<OCIE1A); // Tmr/Cntr1 CompareA interrupt enabled //SetBit (PB, rLED); // Testphase: Zeitanzeige durch rLED } // ================================================================================ // ================================================================================ // === Nicht unterbrechbare ISR für timer1 ======================================= // Interrupt mit ca. 100 Hz/10 ms. Diese ISR wird benutzt // A zum Auslesen der Tasten // Nach Ende der Routine sind die Tastenstati in den Statusbytes // B Zum Setzen der LEDs // Es werden beide LEDs durch das vorgegebene Bitmuster bedient ( 0 / 1 ) // AUSNAHME : Wenn // ISR(TIM1_COMPA_vect) // Vektor 4 (1 ... 4 !!!) doc S 50 { // Ab hier mal ähnlicher Aufbau wie bei Timer0 Izeit_1 ++; // if (Izeit_1 >= 100) //Interrupt-Timer = "Zeithorizont" begrenzen auf // 100 = Zeit für EINE Sekunde { Izeit_1 = 1; // Rückstellen auf Eins Isecflag = 55; // .. und Sekundenflag setzen } // - - Tastenstatistik - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - Es wird geprüft ob eine Taste gedrückt ist - - - - - - - - - - - - - - - - // WENN diese Taste gedrückt ist, wird einfach bis 254 hochgezählt // WENN diese Taste NICHT gedrückt ist, wird schnell (z.B.20) runtergezählt // Änderung 01Jan10 WENN Taste NICHT gedrückt ist, wird *cnt auf Null gesetzt // - - Zuerst für TAB - - - - - - - - - - - - - - - - - - - - - - - - - - - - - TABsts = (!(PINB & (1<<TAB))); // GENAU so *ggg* -- Status von Taste TAB holen if (TABsts) // Taste TAB gedrückt? { if (TABcnt < 254) // Wenn counter < 250 { TABcnt ++; // dann hochtackern nTABcnt = 0; // und Not-TABcount auf Null setzen } } else // Taste TAB ist nicht gedrückt { if (nTABcnt < 254) // Wenn not-counter < 250 { nTABcnt ++; // dann hochtackern TABcnt = 0; // und TABcount auf Null setzen } } // - - .. und auch für TAU - - - - - - - - - - - - - - - - - - - - - - - - - - - // . . . . // - - Die Tastenstati sind ausgelesen - - - - - - - - - - - - - - - - - - - - - // . . . . return; } // ================================================================================ // ================================================================================ // . . . . // ================================================================================ // ================================================================================ // ===== ENDE Subroutinen ==================================================== // ================================================================================ // ================================================================================ // ===== Sonstige Angaben ==================================================== // ================================================================================ #define TAU 1 // Taster "Aufwärts", PB1 #define TAB 2 // Taster "Abwärts", PB2 = "Start"Taste #define PB PORTB // Kurzwort für PORTB #define gLED 4 // Grüne LED PB4 // Typ LITEON-LTL1CHKGKNN = CSD-25-3020320 // 572 nm, 45°, IF 20 mA bei UF 2,4 V // Peak FW 60 mA, DC FW 30 mA #define rLED 3 // Rote LED auf PB3 #define IsBitSet(ADDR,BIT) (((ADDR)&(1<<BIT))?1:0) // Fragt Bit = 1? #define IsBitClr(ADDR,BIT) (!((ADDR) & (1<<BIT))) // Fragt Bit = 0? volatile uint16_t Izeit_1; // Timer1, ähnlich ~0 volatile uint8_t Isecflag; // Sekundenflag...55 = Sekunde in ISR erreicht // 0 = Sekunde in main übernommen volatile uint8_t TABsts; // Status derTaste TAB // = 0 <=> nicht gedrückt, =1 <=> gedrückt volatile uint8_t TABcnt; // Counter für Taste TAB, 0 ... 255 volatile uint8_t nTABcnt; // Counter für Taste notTAB, 0 ... 255

Dies vielleicht als Anhaltspunkt.

Hallo mare_crisium,
erst einmal vielen Dank fuer Deine Auswertung und den sehr ausfuehrlichen "endlichen Zustandsautomaten".
(kann es sein, dass sich ein kleiner Fehler eingeschlichen hat?

"Die Entscheidung, ob der aktuelle Tasterzustand „hoch“ oder „tief“ ist, kann als
Mehrheitsentscheidung betrachtet werden: Beim Z=3 war die Mehrheit der Messwerte „hoch“, bei Z=0 war
sie „tief“. Also werden dem Z-Wert 0 der Tasterzustand „hoch“ und dem Z-Wert 3 der „tief“
### muss es hier nicht umegkehrt lauten? ..oder ich habe es doch nicht begriffen..###
zugeordnet. In den Zuständen 1 und 2 herrscht Stimmengleichheit. Deshalb wird festgelegt, dass der
vorhergehende Tasterzustand unverändert bleibt, bis entweder Z=0 oder Z=3 erreicht wird."

Die Ausfuehrungen dazu habe ich in den Grundzuegen begriffen.
Wobei ich zugeben muss, manches mehrmals durchgelesen und durchdacht zuhaben, bis es so weit war. :-)

Meine Vorstellungen des Schaltens eines Tasters hat nicht so viele Zustaende umfasst.
Bei mir gab es nur die Zustaende und deren Aktionen:
1. Taste gedrueckt (Kein Zustandswechsel an den Tasten)
1a. Taste nicht gedrueckt bei LED-Zustand AUS -> LED AUS (keine Aktion)
1b. Taste nicht gedrueckt bei LED-Zustand AN -> LED AN (keine Aktion)

2. Taste nicht gedrueckt "Wechsel auf" Taste gedrueckt -> Umschalten der LED (Zustandswechsel an den Tasten)
2a. Taste nicht gedrueckt auf Taste gedrueckt bei LED-Zustand AUS -> LED AN (Aktion von AUS auf AN)
2b. Taste nicht gedrueckt auf Taste gedrueckt bei LED-Zustand AN -> LED AUS (Aktion von AN auf AUS)

3. Taste nicht gedrueckt "Wechsel auf" Taste gedrueckt und gehalten -> Umschalten der LED (Zustandswechsel an den Tasten)
3a. Taste gedrueckt gehalten bei LED-Zustand AUS -> LED AN (Aktion von AUS auf AN)
3b. Taste gedrueckt gehalten bei LED-Zustand AN -> LED AUS (Aktion von AN auf AUS)

Die abfallende Taste(gedrueckte Taste Wechsel auf Taste nicht gedrueckt) habe ich nicht betrachten und ihr auch keine Aktion angedacht.
Wenn ich meine Zeile aber nun so lese, stimmt das nicht wirklich... und ich muss Dir Recht geben.
" ..und ihr auch keine Aktion angedacht" - ist falsch, es sollte sich "nur" nichts am LED-Zustand aendern.
somit ergaenze ich hier:
4. Taste gedrueckt gehalten und Taste los gelassen (Zustandswechsel an den Tasten)
4a. bei LED-Zustand AUS -> LED AUS (keine Aktion)
4b. bei LED-Zustand AN -> LED AN (keine Aktion)

Beim Thema "Timer_Routine"- (Teil1) sprichst Du von einem Treiber bzw. Kapselung.
Die Idee bzw. den Hinweis, so an die Sache heran zu gehen, finde ich sehr gut.
In meinen Fall waere es eine Art "Eingangstreiber".
Wobei es sich dann foermlich aufdraengt gleiches an Ausgangsseite zu tun.
Zusammen gesagt einen IO-Treiber fuer das STK500...
Leicht gesagt bzw. geschrieben :-) ich weis.
Aber dieses Thema einmal komplett durchdacht und abgearbeiten - kann mann diesen Treiber immer wieder verwenden, in andere Projecte includen.
Der "IO-Treiber" braeuchte dann nur die Informatioen
-- Input oder Output
- Tastenzustaende in eine Inputvariable zu schreiben
- aus einer Outputvariable in den LED-Port zu schreiben.

Den Vorschlag "Lass' uns diese Version erstmal für eine einzige Taste zum Laufen bringen.." stimme ich,
nach dem was ich nun alles gelesen habe, vollkommen zu.

Nach dem Motto kleine Schritte machen, die aber richtig, soll erst einmal nur das Einlesen funktionieren.

-> Nehmen wir also die Taste, welche am PinD0 gekoppelt ist, als einzulesene Taste.
Als Ausgabe die LED an PortB0.
Ferner sind die Besonderheiten des STK500 bekannt.
Tasten sind mit PullUp-Winderstaende versehen:
Taste nicht betaetigt: liefert beim Einlesen eine log 1
Taste betaetigt: liefert beim Einlesen eine log 0
Der LED-Port schaltet LED AUS bei einer log 1
LED AN bei einer log 0.

Die Timer_Routine liest den Zustand von PinD0 und bereitet ihn so auf, dass
Taste nicht betaetigt eine log 0
Taste betaetigt eine log 1
in die Zustandsvariable schreibt.
??? (Bleibt erst einmal zu klaeren, in welcher Zeit die Timer_Routine aufgerufen werden soll? Was ist ein guter Wert?) ???

Die Zustandsvariable wird entsprechend Deiner Ausfuehrungen getestet:
Um eine gedrueckte Taste(log 1) zu erkennen, muss die Timer_Routine 3 mal nacheinander eine log 1 uebergeben.
Um eine nicht gedrueckte Taste(log 0) zu erkennen, muss die Timer_Routine 3 mal nacheinander eine log 0 uebergeben.

so erst einmal die Theorie. Die Praxis folgt....

Liste der Anhänge anzeigen (Anzahl: 1)

robo_wolf,

jau, danke für den Hinweis auf den Fehler - ist schon korrigiert!

Es macht richtig Spass, mitzulesen, wie Du Dich in das Thema hineinwühlst :-) ! Am Besten gefällt mir Deine Schlussfolgerung:

Zitat:

Zitat von robo_wolf

Aber dieses Thema einmal komplett durchdacht und abgearbeiten - kann mann diesen Treiber immer wieder verwenden, in andere Projecte includen.

Zu genau demselben Schluss bin ich nach ein paar Monaten auch gekommen und bin damit seither gut gefahren. Ein Programm-Modul deckt bei mir jeweils eine Funktion komplett ab (im Sinne von Kapselung, wie man sie von objektorientiertem Programmieren her kennt). Z.B. steckt die Handhabung des TWI-Busses und meines eigenen TWI-Protokolls in einem Modul. Wenn ich Daten über den Bus versenden will, schreibe ich sie byteweise in die Ausgangs-FIFO, rufe im TWI-Modul die Prozedur TWI_SEND auf und weiter geht's. Über die ganze interne Abwicklung im Modul brauche ich nie mehr ( ;-) ) Gedanken zu machen.

Die Module werden einfach per "include"-Anweisung eingebunden. Z.B. sieht der "include"-Block in meinem 13kB-Programm so aus:

Code:

.include "ASTWI16_V01.asm" ; Modul zur TWI-Abwicklung .include "ASTWIIF16_V04.asm" ; Interface zwischen Hauptprogramm und TWI-Modul, enthält die Dialogstruktur .include "FIFOk16_V01.asm" ; Ein- und Ausgangs-Datenpuffer für TWI-Bus .include "System16_V02.asm" ; div. Utilities, z.B. ASCII_to_hex u.ä. .include "MathLibSF24_16_V07.asm" ; 32-Bit Fliesskomma Bibliothek .include "M2KNavigation_16_V08.asm" ; Koppelnavigations-Algorithmus .include "ADNS2610SPI16_V05.asm" ; SPI-Kommunikation mit dem Maussensor .include "ASADNS2610IF16_V04.asm" ; Interface zwischen Hauptprogramm und Maussensoren .include "ZstAutomat16_V04.asm" ; der Zustandsautomat zum Hochfahren und Überwachen der Maussensoren usw.

Dieses Vorgehen führt zu etwas erhöhtem Zeitbedarf, weil man sich bestimmte Vorschriften setzen und sie einhalten muss. Z.B. werden bei mir alle verwendeten Register mit "push"- und "pop"-Anweisungen gesichert, damit ich nicht jedesmal nachgucken muss, welche Register verändert werden. Trotzdem hat das Verfahren sich sehr bewährt, weil es mir erlaubt, mit Assembler fast wie in einer Hochsprache Programme zu schreiben. -

Der Vollständigkeit halber habe ich im Anhang noch die Geschichte mit dem Zustandsautomaten zuendegeführt. Bin gespannt auf Dein nächstes "Lernprogramm". Als Takt für den Timer-Interrupt schlage ich vor, zunächst mit so 2 bis 5 Hz anzufangen; da kann man das Flackern noch sehen. Wenn dann alles fehlerfrei läuft, kannst Du's immer noch schneller machen.

Ciao,

mare_crisium

@oberallgeier,

ja, für diese Anwendung könnte ein endlicher Zustandsautomat ein gangbarer Weg sein. Natürlich nur, wenn er in Assembler programmiert ist, nicht in cäh ;-) !

mare_crisium

Habe den Code zum Einlesen und Auswerten des an PinD0 befindenlicher Taste.
Einige Zeilen sind stark an mare_crisium´s "endlichen Zustandsautomaten" angelehnt.
Das Schalten der LED habe ich vorerst weggelassen.

Code:

;***** STK500 Lernprogramm Nr.4d ;*** 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(log 1) bzw. 0x00(log 0) ;*** 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 TOGGLE_SPRR = r21 ; Sperrt die Ausfuehrung von TastenTest wenn, keine neuer TIMER1_OVL voran gegangen ; ; TimerWerte(bei 8MHz - ca. 0,2sec) .equ Timerwert = -60 ; Timerschritte bis zum Überlauf(fuer Simulatortest) ;.equ Timerwert = -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 ; ;***** ;Reset and Interrupt vector ;VNr. Beschreibung rjmp RESET ;1 POWER ON RESET reti ;2 Int0-Interrupt reti ;3 Int1-Interrupt reti ;4 TC1 Capture reti ;5 TC1 Compare Match A TC2 Overflow reti ;6 TC1 Compare Match B TC1 Capture rjmp TIMER1_OVF ;7 TC1 Overflow TC1 Compare Match A reti ;8 TC0 Overflow TC1 Compare Match B reti ;9 SPI, STC Serial Transfer Complete TC1 Overflow reti ;10 UART Rx Complete TC0 Overflow reti ;11 UART Data Register Empty SPI, STC Serial Transfer Complete reti ;12 UART Tx Complete UART Rx Complete reti ;13 Analog Comparator reti ;14 Int2-Interrupt reti ;15 Timer 0 Compare Match reti ;16 EEPROM Ready reti ;17 Store Program Memory Ready ;***** RESET: ldi temp,(1<<CS10) ; Taktfrequenz Vorteiler 1 gewaehlt (fuer Simaulatortest) ; ldi temp,(1<<CS10)|(1<<CS12) ; Taktfrequenz mit Vorteiler 1024 gewaehlt out TCCR1B,temp ; Timer1 vorladen ldi temp,HIGH(Timerwert) out TCNT1H,temp ldi temp,LOW(Timerwert) out TCNT1L,temp ldi temp,(1<<TOIE1) ; Timer1 Overflow aktivieren out TIMSK,temp ldi r16, LOW(RAMEND) ;Stack initialisieren out SPL, r16 ldi r16, HIGH(RAMEND) out SPH, r16 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 clr Tast_Stat ;Tast_Stat auf def. Zustand clr Zst_Var sei ; globale Interruptfreigabe MAIN: sbrc TOGGLE_SPRR,0 ; kein TOGGLE, wenn Bit0 ==0 rcall TOGGLE rjmp MAIN TIMER1_OVF: push TEMP ; TEMP auf Stack sichern in TEMP,SREG ; SREG auf Stack sichern push TEMP ; in Tast_Stat0, PIND ; Tasten werden komplett eingelesen com Tast_Stat0 ; invertiere clt ; loesche T-Flag SBRC Tast_Stat0,0 ; RegisterBit0 von TastStat ==0 ueberspringe / T-Flag wird nicht gesetzt set ; ==1 setze T-Flag ; ; default wird -1 in temp eingetragen | springt bei nicht gesetzten T-Flag zu TastZst0 ; bei gesetzten T-Flag wird +1 in temp eingetragen ; ldi temp, 0x03 ; temp == "-1" brtc TastZst0 ldi temp, 0x01 ; temp == "+1" ; ; TastZustand0 ; TastZst0: cpi Zst_Var,0x00 ; vergleiche ob Zst_Var ==0 brne TastZst1 ; springe wenn ungleich sbrs temp, 0x01 ; ueberspringe naechsten Befehl, wenn temp negativ(0x03) ist add Zst_Var, temp ; addieren temp in Zst_Var rjmp TastZst_Exit ; ; TastZustand1 ; TastZst1: cpi Zst_Var, 0x01 ; vergleiche ob Zst_Var ==1 brne TastZst2 add Zst_Var, temp rjmp TastZst_Exit ; ; TastZustand2 ; TastZst2: cpi Zst_Var, 0x02 ; vergleiche ob Zst_Var ==2 brne TastZst3 add Zst_Var, temp rjmp TastZst_Exit ; ; TastZustand3 ; Fehler abfangen Zst_Var darf nur Werte zwischen 0x00 und 0x03 haben ; TastZst3: cpi Zst_Var, 0x03 ; vergleiche ob Zst_Var ==3 brne TastZst_Error sbrc temp, 0x01 add Zst_Var, temp ; TastZst_Error: ; TastZst_Exit: andi Zst_Var, 0xFB ; eventuellen Uebertrag loeschen ; cpi Zst_Var, 0x00 ; ueberspringe naechsten Befehl brne Test2 cbr Tast_Stat,0x01 ; >>>>>Taste nicht gedrueckt ; Test2: cpi Zst_Var,0x03 ; ueberspringe naechsten Befehl brne T0_OVL_Exit sbr Tast_Stat,0x01 ; >>>>>Taste gedrueckt ; T0_OVL_Exit: ; Timer1 vorladen ldi temp,HIGH(Timerwert) out TCNT1H,temp ldi temp,LOW(Timerwert) out TCNT1L,temp ; sbr TOGGLE_SPRR,0 ; Status fuer TOGGLE 1 - TOGGLE / 0 - kein TOGGLE pop TEMP ; out SREG,TEMP ; SREG zurueckschreiben pop TEMP ; TEMP zurueckschreiben reti TOGGLE: cbr TOGGLE_SPRR,0 ; loesche Bit0, um TOGGLE bis zum naechsten TIMER1_OVF zu sperren nop ; kommt spaeter ret

Ganz zufrieden bin ich damit nicht.. :-(
Es tut zwar was es soll, ABER:
- es wurden 5 Register dafuer benoetigt (schaem)
- ich bin mir nicht sicher, ob alles in der TimerServiceRoutine drin sein sollte ???
(hatte mal gelesen, das die Programmunterbrechungen so kurz wie moeglich sein sollten) bei mir spielt sich da fast alles ab.
- gern haette ich die von mare_crisium aufgestellte Zustandstabelle benutzt, nur leider verstehe ich deren Funktion nicht richtig (wieder schaem)
(Da braeuchte ich noch mal ein bischen Starthilfe...generell das Benutzen von arrays und deren Auswertung)
- mit dem Konzentrieren auf eine Taste PinD0 in diesem Beispiel, seh ich momentan kein einfaches Einbinden der restlichen 7 Tasten
- vom eigendlichen Ziel "IO-Treiber" bin ich noch sehr weit weg

Solange man nur eine ISR hat, und sonst nichts zeitkritisches läuft, macht es nicht wenn die ISR etwas länger ist. Wenn man weiss was man macht, kann man da auch längere Sachen machen, wie einen String per UART verschicken. Meine längste ISR braucht etwa 2 Sekunden - das Hauptprogramm macht dafür nichts außer sleep.

So lang ist die ISR auch noch gar nicht. da ist schließlich keine Schleife drin. An einigen Stellen läßt sich noch was feilen, aber das lernt man auch noch. Ein Beispiel was mit sehr umständlich vorkommt ist die Art wie das Bit0 vonder Taste in T flag verschoben wird. Dafür gibt es direkt den Befehl BST, den ich allerdings auch noch nie richtig benutzt habe.

Es ist auch keine Schande die Register auch zu benutzen. Solange die Register da sind kann man das machen, und kommt so ohne RAM aus. geht schließlich schneller und wird kürzer.
Man kann sogar soweit gehen, für die Interrupts eigene Register zu reservieren, so daß man keine Register mehr auf den Stack retten muß.

Liste der Anhänge anzeigen (Anzahl: 1)

robo_wolf,

wenn sich einer zu schämen hat, dann wohl ich, weil ich's nicht gut genug erklärt habe :oops: . Wenn's Dir nichts ausmacht, dann lass' uns die Sache in kleineren Schritten angehen (siehe Anhang).

Ciao,

mare_crisium

Edit 1:
im .pdf haben sich folgende Fehler eingeschlichen:
1. "...mit der „ldi2-Anweisung setzen kann." Gemeint ist die "ldi"-Anweisung.
2. Im Programm-Ausschnitt "; LEDs von Tasten 1 und 2 steuern" müssen die Skip-Anweisungen nicht "sbrs r19,bFLANKE0" und "sbrs r19,bFLANKE1" sondern "sbrc r19,bFLANKE0" und "sbrc r19,bFLANKE1" heissen.

Hallo mare_crisium,
vielen Dank fuer die Erlaerungen.
Die fehlerhafte Vektortabelle hatte ich bisher nicht bemerkt.(Asche ueber mein Haupt)
Bis jetzt war bei Timer0 Schluss...und mit Timer1 ist es das erste Programm.
Aus diesem Grund sind mir die CTC-, Compare-Funktionen zwar bekannt, aber es fehlte die praktische Anwendung.
Du hast geschrieben, das die CTC-Funktion besser geignet sei.
Da habe ich nun einen praktischen Anwendungsfall :-)

CTC bedeutet also, dass er nach dem Erreichen des voreingestellten OCR1A und, oder OCR1B den Interrupt ausloest und die Serviceroutine durchlaeuft.
Es ist dann aber so, dass er beim Verlassen der Serviceroutine keinen definierten Zaehlerstand, je nach Verzweigung, hat? Oder liege ich da falsch?
Das spielt bei mir aber eine untergeordnete Rolle. Man kann auch sagen 100 Takte hin oder her sind bei der gewuenschten Funktion egal,
da keine Timings eingehalten werden muessen.
Es vereinfacht aber Programm an dieser Stelle, da das Nachladen entfaellt.

Die Funktionen des AVR-Studios hinsichtlich des Manipulieren(Setzen und Ruecksetzen von verschiedener PortBits oder Registerwerte)
sind mir schon bekannt und ich nutze sie.
Das zusaetzliche Anlegen der Daten fuer die Simulation hatte einen anderen Zweck.
Wenn ich bestimme wann die Programmunterbrechnung und Ausfuehrungen der ISR passieren, dann habe ich keine Willkuer vom Programm.
...will sagen, die Unterbrechungen passieren dann dort, wo ich sie nicht erwarte...
So hatte ich schon "kleine Anfaengerfehler" gefunden. War fuer mich eine zusaetzliche Ueberpruefung.
Trotzdem Danke fuer die Erlaeuterungen.

„BST“-Anweisung kannte ich bis jetzt nicht wirklich.
Du musst dir vorstellen, wenn ich ein programmtechnisches Problem loesen moechte,
dann nehme ich mir das Datasheet oder die AVR-Instuktionsliste zur Hand und probiere...
Auch muss ich wieder sagen, ... super habe nun eine praktische Anwendung dafuer

*/Ach, ich glaube, ich habe Dich auf zu komplizierte Gedanken gebracht. Tut mir leid, ich bin halt kein Pädagoge ;-) /*
Das ist schon OK so und bitte weiter so. Es schadet mir gewiss nicht, ueber das Geschriebene laenger nach zu denken.
Wenn es zu kompliziert wird, melde ich mich schon :-)

Nun habe ich leider nicht konkret geschrieben, was mir schwer faellt zu begreifen.. sorry
So kam es, wie es kommen musste.
Du hast genau, dass was mir klar war, noch einmal schoen beschrieben. - geschadet hat es mir ganz sicher nicht
- Du hattest nur Arbeit damit -

Den eigentlichen Ablauf habe ich schon verstanden und kann ihn nachvollziehen.
ABER ](*,)
>>> Die Sache mit den .dw-Anweisungen... da habert es ...
Die Werte die Du angegeben hast, sind von Dir (willkuerlich)festgelegt und beschreiben die Zustaende und belegen praktischer Weise 4Bit,
also ein Nibble eines Registers.
Da glaubte ich erst einen bestimmten Algoritmus, der dahinter steht, finden zu muessen.
- es sind leicht zu erkennende Zustaende, die nur irgendwie sinnvoll angeordnet sein muessen -

Dadurch lassen sich 2 Tasten in ein Register speichern.
Nun sind die Werte mit den .dw-Anweisungen festgelegt... und wo kommen die hin, sind sie abgelegt.?

>>> Danach hast Du Zeiger verwendet. ist ebenfalls Neuland fuer mich.(Hier liegt glaube ich mein groesstes Manko)
Wie der Name schon sagt, zeigen bzw. verweisen sie auf etwas. In dem Fall Speicher stellen.

>>> add und adc -Addieren mit und ohne Carry-Flag

>>> dann waere da noch "lpm" lesen aus dem Programmspeicher

Wahrscheinlich, dessen bin ich mir sicher, sind das ganz banale Dinge... die ich mir komplizierter denke, als sie in Wirklichkeit sind.

Das sind bei weitem nicht alle Fragen, die ich gern los werden moechte :-)
Aber mit den Antworten, kaeme ich erst einmal wieder ein Schritt weiter.

Ich hoffe, dass ich Dich nicht zu sehr damit quaele?
Du hast auf jeden Fall einen dankbaren Schueler... auch wenn Du kein Paedagoge bist.
Es ist eben nicht so einfach, etwas zu erklaeren, wenn man nicht genau weis, wie der andere(ich) es versteht.

robo_wolf,

nur immer zu mit Fragen :-). Dafür ist dieser Fred ja da.

".dw"-Anweisung:
Mit der „.dw“-Anweisung wird ein Wort, also ein 16-Bit-Wert, in den Programmspeicher geschrieben. Die Syntax des AVR-Assemblers erlaubt es, auch gleich mehrere Worte auf einmal zu schreiben. Z.B. ist

...
TABELLE:
.dw 0xABCD,0x1234,0x5678
...

ebenfalls erlaubt. Man kann die Einträge 0xABCD usw. wiederfinden, wenn man das Memory-Fenster des Simulator auf „Program“ einstellt und sich die Speicherinhalte ansieht, die auf die Adresse des Labels „TABELLE“ folgen (die Adresse von „TABELLE“ sieht man, wenn man im Simulator im Quelltext den Mauszeiger auf das Label stellt). Angenommen, die Adresse von „TABELLE“ sei 0x0046. Dann sieht es im Programmspeicher so aus

0046 CD AB 34 12
004A 78 56 ...

Das LSB wird also immer in der niedrigeren, geradzahligen Adresse abgelegt, danach erst das MSB. Man nennt diese Speichermethode auch „little endian“, im Gegensatz zum „big endian“, wo das MSB an der niedrigeren Adresse steht.

Die Daten, die auf die Adresse „TABELLE“ folgen, kann man mit der „lpm“-Anweisung auslesen. Die Einzelheiten des Befehls sind in der Assembler-Hilfe des AVR-Studios gut beschrieben.

Die Tastenzustände ändern sich laufend und müssen deshalb in den Registern oder im RAM-Speicher gehalten werden; der Programmspeicher soll zur Laufzeit des Entprellprogramms nicht mehr geändert werden. Deshalb dienen die „.dw“-Anweisungen ausschliesslich dazu, im Programmspeicher die Übergangstabelle zu erzeugen. Mit den aktuellen Tastenzuständen haben sie nichts zu tun.

Timer/Counter1:
In der Betriebsart CTC springt der Timer wieder auf Null zurück, nachdem er den Wert von OCR1A bzw. OCR1B erreicht hat, und zählt dann munter weiter. Dadurch bleibt das Zeitintervall zwischen zwei Interrupts immer dasselbe. Wo wie Du es gemacht hattest, beginnt die Zählung vom Rücksetzen des Zählerstandes neu. Er ist also von der Ausführungsdauer des Interrupt-Dienstprogramms abhängig.

Ich nehme an, Du hast das so gemacht, weil Du befürchtetest, der nächste Interrupt könnte eintreten, bevor das Dienstprogramm beendet ist. Probier' mal im Simulator, was passiert, wenn Du den CTC-Interrupt von TC1 manuell auslöst, während das Dienstprogramm noch läuft... Wenn Du solche Ereignisse partout vermeiden willst, dann hilft der Vergleich von PreScaler*OCR1A_Wert mit der maximalen Anzahl Taktzyklen im Dienstprogramm. Solange PreScaler*OCR1A > max.TaktZyklen ist, fällt der Interrupt immer in die Zeit nach dem Ende des Dienstprogramms.

Ciao,

mare_crisium

Hallo mare crisium,
schnelle und praezise Erklaerung.
Das bringt doch gleich etwas LICHT ins dunkel.
versteh ich das richtig?
von 0xABCD
LSB ist "CD"
und
MSB ist "AB"
Habe mal bei mir den Quellcode eingefuegt und mir den Programmspeicher angeschaut:

TABELLE:
.dw 0xABCD,0x1234,0x5678

Label Tabelle: zeigt auf die Speicherzelle 0x0019(16Bit breit) und
.dw 0xABCD,0x1234,0x5678 sind bei
0x0019 CD AB
0x001A 34 12
0x001B 78 56 abgelegt

also zuerst LSB und dann MSB in der Adresse

Nun hast Du geschrieben:
"Das LSB wird also immer in der niedrigeren, geradzahligen Adresse abgelegt, danach erst das MSB. "
??? 0x0019 und 0x001B sind doch keine geradzahligen Adressen ???

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