Anfänger mit STK500 und Assembler

[robo_wolf]

Guteen Morgen mare_crisium,
werde ich gleich mal durcharbeiten.
Vielen Dank ersteinmal.

[robo_wolf]

Hallo mare_crisium,
Deine Kritiken den Programmabbruch habe ich verstanden.
Im fogenden Kommentar schreibst Du, das Nachteil sei, nur eine Tastennummer zu speichern.
??? Warum sollten mehrere Tastennummern abgelegt werden? Fuer die Menueauswahl brauche ich doch nur eine Nummern ,die die Aktion der Tasten bestimmt?
!!! Denken wir da in zwei Richtungen.. oder ueberseh ich wieder etwas..?
Das Thema mit der Warteschlange liest sich spannend.
- kommen garantiert noch mehr Fragen auf Dich zu
Auch der neue Handler "MNU8CTL_4HANDLER" gefaellt mir.

[mare_crisium]

Guten Abend, robo_wolf,

hier habe ich eine neue Version _04j, die aus _04i abgeleitet ist. Sie hat jetzt ein neues Modul "STACK8_V01.asm", das Software-Stacks bereitstellt. Man kann in seinem Hauptprogramm mehrere davon einbauen.

In _04j dient der "MENUSTACK" dazu, die Nummern der betätigten Menutasten zwischenzuspeichern. Die Gründe dafür sind folgende:

Man kann die Verarbeitung der Menutasten in die MAIN-Schleife verlagern und braucht nicht alles während des Timer-Interrupts zu erledigen. Ausserdem kommt es oft vor, dass jemand die Menutasten so schnell hintereinander betätigt, dass die erste noch nicht abgearbeitet ist, wenn die zweite gedrückt wird. Ohne Zwischenspeicherung ginge die zweite verloren. Noch ein anderer Grund ist, dass auf diese Weise die Verarbeitung der Menutasten von der Menusteuerung abgekoppelt wird. Das Modul "MENU8STRG_Vxx" braucht nichts über die Funktionen zu wissen, die die Tasten auslösen. Das Modul bleibt dadurch universell verwendbar .

Ciao,

mare_crisium

[mare_crisium]

robo_wolf,

nach der ganzen Testerei wird's mal wieder Zeit, das eigentliche Ziel ins Auge zu fassen . Deshalb habe ich hier eine Version (LernPrgrm_04k) angehängt, die eigentlich alles können sollte: Tasten entprellen, die Menuaktivierung steuern und die angewählten Menupunkte ausführen.

Dazu habe ich den Timer2-Interrupt wieder aktiviert. Die Zeitkonstante habe ich von Dir übernommen (0,1s). Die Zeitintervalle für die Menuaktivierung habe ich provisorisch auf
T0 = 0,1s, T1 = 3s und T2 (Totmannzeit) = 5,1s eingestellt.

Wenn wir beim Austesten alle Fehler bemerkt und beseitigt haben müsste das Ding funktionieren... Probier's doch mal!

Ciao,

mare_crisium

[robo_wolf]

Hallo mare_crisium,
langsam langsam
Bin gerade noch beim Durchsehen des vorherigen Postings... da kommt schon das Naechste.
Im vorigen hattest Du .include "Menu8Strg_V04.asm" eingebaut.
Das war sicher ein Tippfehler.
In der Endversion ist es dann wieder _V03.
Auf jeden Fall erst einmal wieder ein grosses Danke an Dich zurueck.
Habe nun einiges zum Aufarbeiten ..

[robo_wolf]

mare_crisium,
bin nun Dein Programm durchgegangen.
Eine Sache ist mir gleich zu Beginn aufgefallen.
Der Mega8515 hat keinen Timer2.
In irgendeiner Version der letzten Postings hast Du die Interrupttabelle vom Mega8 eingebaut.
Muss ehrlich gestehen, ich habe das in Deinem letzten Posting zwar gelesen(Dazu habe ich den Timer2-Interrupt wieder aktiviert.),
mehr ueberlesen, aber beim 1.TimerCompare ist es mir dann aufgefallen.
Wenn sich Stoplersteine immer so leicht finden lassen wuerden....
Eine kleine Aenderung habe ich dann noch hier vorgenommen. Bringt nicht wirklich viel.. ein paar Takte

STACK8_CREATE:
	push r25
	in r25,SREG
	push r16
	push r17
	push xl
	push xh

; reservierten Speicherbereich mit Nullen füllen
	mov xl,r16
	clr xh
	adiw xh:xl,STACK8CTL_LNG

    clr r17
STCK8_CRT00:
; 20100503 vor STCK8_CRT00 geschoben	clr r17
	st z+,r17
	sbiw xh:xl,0x0001	; Byte-Zähler abzählen
	brne STCK8_CRT00	; Sprung, wenn noch nicht fertig

; Zeiger wieder auf erstes Byte von STACK8CTL zurückstellen
	sbiw zh:zl,STACK8CTL_LNG ; Länge des Steuerblocks subtrahieren
	sub zl,r16
	clr r17
	sbc zh,r17		; Kapazität des Stacks subtrahieren

; Stackkapazität speichern
	std z+STACK8CTL_CAP,r16	; Kapazität speichern

	pop xh
	pop xl
	pop r17
	pop r16
	out SREG,r25
	pop r25
	ret

Der MenuStack ist ja ne schoene Sache. Aber waere es nicht einfacher die Tasterkennung in einem Register dezimal abzulegen?
Was wuerde dagegen sprechen? - Ich meine als Lernobjekt ist die Sache mit dem Stack ja suuuuper.
... kann es natuerlich sein, dass Du in Deinem Hinterkopf schon weiter geplant hast, als ich es bisher ueberschauen kann?

[mare_crisium]

robo_wolf,

huuch! Das mit dem Timer2 ist natürlich eine böse Falle. Ich hätte erwartet, dass der Assembler auf so einen groben Fehler hinweist. Wie machst Du's jetzt?

Deine Einsparmassnahme beim Stack ist berechtigt. Aber was meinst Du mit

in einem Register dezimal abzulegen

Man kann nie vohersagen, wann oder wie schnell hintereinander der Bediener die Tasten betätigt . Legt man die Nummer der betätigten Taste in einem Register ab, dann kann es vorkommen, dass ein ultrahibbeliger Bediener schon die nächste drückt, bevor die erste überhaupt ausgewertet ist. Dann wird der Inhalt des Registers mit der Nummer der zuletzt betätigten Taste überschrieben und die erste Eingabe war für die Katz. Sehr frustrierend für den Bediener ! Den Puffer betrachte ich hier als nützlich, weil es zu vermeiden gilt, dass nicht synchronisierbare Eingaben verloren gehen.

Freut mich, das der Software-Stack Dir so gut gefällt . Gedacht war er auch, um Dir auf solche Schmankerl Appetit zu machen. Denn mein Vorschlag ist nun, dass Du als Nächstes mal versuchst, einen FIFO-Speicher zu bauen. Speichern soll er einzelne Bytes; die Kapazität soll einstellbar sein und bis zu 255 gehen dürfen. Es sollen mehrere FIFOs in einem Programm einzurichten sein. Natürlich soll alles in einem wiederverwendbaren Modul verpackt werden. Es soll die Prozeduren

FIFO8_CREATE
Eingangsparameter: 
zh:zl enthalten Zeiger auf den Beginn des Steuerblocks
r16 enthält die gewünschte Kapazität in Byte
Ausgangsparameter:
zh:zl unverändert
r16 unverändert

FIFO8_WRITE
Eingangsparameter: 
zh:zl enthalten Zeiger auf den Beginn des Steuerblocks
r16 enthält das Datenbyte, das auf der FIFO abgelegt werden soll
Ausgangsparameter:
zh:zl unverändert
r16 unverändert
SREG (T-Flag): T = 0 Fehlschlag, FIFO war voll
T=1 Datenbyte erfolgreich auf der FIFO abgelegt

FIFO8_READ
Eingangsparameter: 
zh:zl enthalten Zeiger auf den Beginn des Steuerblocks
Ausgangsparameter:
zh:zl unverändert
r16 enthält das Datenbyte, das aus der FIFO ausgelesen wurde
SREG (T-Flag): T = 0 Fehlschlag, FIFO war leer
T=1 Datenbyte erfolgreich aus der FIFO ausgelesen

FIFO8_ISTLEER
Eingangsparameter: 
zh:zl enthalten Zeiger auf den Beginn des Steuerblocks
Ausgangsparameter:
zh:zl unverändert
SREG (T-Flag): T = 0 FIFO ist nicht leer
T=1 FIFO ist leer

FIFO8_ISTVOLL
Eingangsparameter: 
zh:zl enthalten Zeiger auf den Beginn des Steuerblocks
Ausgangsparameter:
zh:zl unverändert
SREG (T-Flag): T = 0 FIFO ist nicht voll
T=1 FIFO ist voll

exportieren. Als Muster, hatte dich mir gedacht, könntest Du den STACK8 verwenden; allerdings ist die FIFO etwas komplizierter, denn da es sind ein paar mehr Fälle zu berücksichtigen.

Mit so einem Ding in der Werkzeugkiste, könnten wir dann mal darangehen, eine RS232-Verbindung zwischen STK500 und PC einzurichten . Was hältst Du davon?

Ciao,

mare_crisium

[robo_wolf]

mare_crisium,
OK die Erlaeuterung mit dem hibbligen Bediener leuchtet mir ein.
An den FIFO moechte ich mich gern versuchen.
Eventuell kommt aber noch die eine oder andere Frage.

[mare_crisium]

robo_wolf,

nur zu mit Fragen !

Für die nächste Aufgabe, die FIFO, habe ich etwas zusammengeschrieben, das - wie ich hoffe - Dir den Einstieg erleichtert .

Ciao,

mare_crisium

[robo_wolf]

mare_crisium,
wo du gerade schreibst.
Hab da gleich ne Frage:
Den FIFO stell ich mir so vor, dass er je nach Anfrage geleert und befuellt werden kann, bis er eben voll oder leer ist.(kein Schieberegister)
Wenn ich keinen Lesezugriff mache, wird er sich bis zum max fuellen.
Aber es kann auch sein, es sind z.B. 10 Byte im FIFO und ich lese 2b raus, fuelle dann wieder 5b rein und lese 1b raus... usw. Oder..?
Wenn es so werden soll, dann ist es wirklich nicht so easy...