Probleme ATmega8

[Peter (Gast)]

.include "m8def.inc"  ;ACHTUNG in FUSES Frequenz auf 1MHZ stellen!    
 
         ldi r16, 0xFF      ;Port B sind Ausgänge
         out DDRB, r16         ;Port B Ausgänge
                             
         ldi r16, 0x00      ;Port D sind Eingänge
         out DDRD, r16         ;Port D Eingänge

     .cseg
     rjmp Power

     .org OVF0addr
         rjmp    timer0_overflow       ; Timer Overflow Handler

Power:   sbic PinD, 1
     sbi PortB, 2
     ldi r28, 1
     rjmp Ausw
Power1:  ldi r28,0
         
      ldi r27, 1
     rjmp timer
test:   ldi r27, 0
     cbi PortB, 2
     rjmp Start    ; Überspringen der TimerOVV

wait:   rjmp Timer
  

Start:   sbis PinD, 1      ; PinD1 (Aus) unbetätigt
     rjmp Ausw  ; Wenn Aus betätigt springe zu Aus
     sbis PinD, 5    ; PinD5 (Störung) unbetätigt
     rjmp stoerung    ; Wenn Störung betätigt springe zu stoerung
     sbic PinD, 0    ; Ein betätigt
     rjmp Start    ; Wenn ein betätigt dann gehts Weiter

Motor_AN:sbis PinD, 1      ; PinD1 (Aus) unbetätigt
     rjmp Ausw  ; Wenn Aus betätigt springe zu Aus
     sbis PinD, 5  ; PinD5 (Störung) unbetätigt
     rjmp stoerung  ; Wenn Störung betätigt springe zu stoerung
     sbic PinD, 0    ; Ein betätigt
     rjmp Start    ; Wenn ein betätigt dann gehts Weiter

     cbi PortB, 2    ; Störung löschen
     sbi PortB, 0  ; Setze PortB 0 (Motor geht an)
      
       ldi r25, 4    ; Lade r25 mit 4
     ldi r26, 1    ; Lade r26 mit 1
     rjmp Timer    ; Springe zu Wait

Flanke:   tst r25        ; Prüfe r25 auf null
       brne wait
     ldi r25, 0    ; Lade R25 mit 0
     ldi r26, 0    ; Lade R26 mit 0
     sbis PinD, 0    ; Ein losgelassen
     rjmp Flanke  ; Solange wie Ein gedrückt, Warten

Wahl:   ldi r23, 0      ; Lade r23 mit 0
     ldi r23, 77    ; Lade r23 mit 77
Wahl1:   cbi PortB, 1      ; Ventil Aus
     ldi r18,0    ; Lade r18 mit 0
     ldi r19,0    ; Lade r19 mit 0
     ldi r20,0    ; Lade r20 mit 0
     ldi r21,0    ; Lade r21 mit 0
     ldi r22,0    ; Lade r22 mit 0
     sbis PinD, 1    ; PinD1 (Aus) unbetätigt
     rjmp Aus    ; Wenn Aus betätigt springe zu Aus
     sbis PinD, 5  ; PinD5 (Störung) unbetätigt
     rjmp Aus    ; Wenn Aus betätigt springe zu Aus
     sbis PinD, 0      ; Ein betätigt
     rjmp Man    ; Wenn ein betätigt dann gehts Weiter
     sbis PinD, 2      ; Auto betätigt
     rjmp Auto1      ; Springe zu Auto 1
     tst r23      ; r23 auf null testen
     breq Aus5
     rjmp Timer      ; Springe zu Timer
     

Man:   sbis PinD, 1    ; PinD1 (Aus) unbetätigt
     rjmp Aus    ; Wenn Aus betätigt springe zu Aus
     sbis PinD, 5    ; PinD5 (Störung) unbetätigt
     rjmp Aus    ; Wenn Aus betätigt springe zu Aus
     sbic PinD, 0           ; Ein betätigt
     rjmp Wahl  ; Wenn ein betätigt dann gehts Weiter

     sbi PortB, 1    ; Setze PortB 1 (Ventil zieht an)

Man2:   sbis PinD, 1      ; PinD1 (Aus) unbetätigt
     rjmp Aus    ; Wenn Aus betätigt springe zu Aus
     sbis PinD, 5    ; PinD5 (Störung) unbetätigt
     rjmp Aus    ; Wenn Aus betätigt springe zu Aus
     sbis PinD, 0    ; Ein betätigt
     rjmp Man2    ; Wenn ein unbetätigt dann gehts Weiter

     cbi PortB, 1  ; Lösche PortB 1 (Ventil fällt ab)

     rjmp Wahl    ; Springe wieder zur Wahl 

Auto1:   sbis PinD, 1      ; PinD1 (Aus) unbetätigt
     rjmp Aus      ; Wenn Aus betätigt springe zu Aus
     sbis PinD, 5    ; PinD5 (Störung) unbetätigt
     rjmp Aus      ; Wenn Aus betätigt springe zu Aus
     sbic PinD, 2    ; Auto betätigt
     rjmp Wahl    ; Wenn nicht dann zu Wahl

     sbi PortB, 1    ; Setze PortB 1 (Ventil zieht an)

Auto2:   sbis PinD, 1      ; PinD1 (Aus) unbetätigt
     rjmp Aus      ; Wenn Aus betätigt springe zu Aus
     sbis PinD, 5    ; PinD5 (Störung) unbetätigt
     rjmp Aus      ; Wenn Aus betätigt springe zu Aus
     sbic PinD, 2    ; Auto betätigt
     rjmp Wahl    ; Wenn nicht dann zu Wahl
     ldi r18,1    ; Setze r18 auf 1
     ldi r19,4    ; Lader r19 mit 4
     rjmp Timer    ; Springe zum Timer

Weiter2: sbis PinD, 1      ; PinD1 (Aus) unbetätigt
     rjmp Aus    ; Wenn Aus betätigt springe zu Aus
     sbis PinD, 5    ; PinD5 (Störung) unbetätigt
     rjmp Aus    ; Wenn Aus betätigt springe zu Aus
     sbic PinD, 2    ; Auto betätigt
     rjmp Wahl    ; Wenn nicht dann zu Wahl
     tst r19      ; Teste r19 auf Null          
     brne Timer    ; Springe bei r19 ungleich 0
     sbic PinD, 3    ; 3bar erreicht?
     rjmp Weiter2    ; Warten bis 3bar
     dec r18      ; r18 - 1

     cbi PortB, 1  ; Lösche PortB 1 (Ventill fällt ab)

     rjmp Auto3
Aus5:   rjmp Aus
     rjmp Auto3
Power2:   rjmp Power1

Auto3:    sbis PinD, 1      ; PinD1 (Aus) unbetätigt
     rjmp Aus      ; Wenn Aus betätigt springe zu Aus
     sbis PinD, 5    ; PinD5 (Störung) unbetätigt
     rjmp Aus      ; Wenn Aus betätigt springe zu Aus
     sbic PinD, 2    ; Auto betätigt
     rjmp Wahl    ; Wenn nicht dann zu Wahl
     ldi r20,1    ; Setze r20 auf 1
     ldi r19,4    ; Lader r19 mit 4
     rjmp Timer    ; Springe zum Timer

Weiter3: sbis PinD, 1      ; PinD1 (Aus) unbetätigt
     rjmp Aus      ; Wenn Aus betätigt springe zu Aus
     sbis PinD, 5    ; PinD5 (Störung) unbetätigt
     rjmp Aus      ; Wenn Aus betätigt springe zu Aus
     sbic PinD, 2    ; Auto betätigt
     rjmp Wahl    ; Wenn nicht dann zu Wahl
     tst r19      ; Teste r19 auf Null          
     brne Timer    ; Springe bei r19 ungleich 0
     sbic PinD, 4    ; 90bar erreicht
     rjmp Weiter3    ; wenn nicht dann warte
     dec r20      ; r20 -1

     sbi PortB, 1    ; Setze PortB 1 (Ventil zieht an)

     rjmp Auto1    ; Wieder von vorne beginnen

Aus:   cbi PortB, 0       ; Lösche PortB 0 (Motor aus)
     cbi PortB, 1    ; Lösche PortB 1 (Ventil fällt ab)
Ausw:   ldi r21, 1      ; Lade r21 mit 1
     ldi r19,4    ; Lade r19 mit 4

     rjmp Timer

Kurz:   tst r19        ; Teste r19 auf Null          
     brne Timer    ; Springe bei r19 ungleich 0 
     dec r21      ; r21-1
     sbi PortB, 1    ; Setze PortB 1 (Ventil zieht an)
     ldi r22,1    ; Lade r22 mit 1
     ldi r19,4    ; Lade r19 mit 4

     rjmp Timer

Kurz1:   tst r19        ; Teste r19 auf Null        
     brne Timer    ; Springe bei r19 ungleich 0   
      dec r22      ; r22-1
     cbi PortB, 1     ; Lösche PortB 1 (Ventil fällt ab)

     sbis PinD, 1    ; Aus noch betätigt?
     rjmp Kurz1    ; Warte bis losgelassen
     sbis PinD, 5    ; Störung noch betätigt?
     rjmp stoerung
     tst r28
     brne Power2

     rjmp Start

Timer:   ldi     r17, HIGH(RAMEND)  ; Stackpointer initialisieren
         out     SPH, r17
         ldi     r17, LOW(RAMEND)     
         out     SPL, r17
    
         ldi     r17, (1<<CS02) | (1<<CS00)   ; Teiler 1024

         out     TCCR0, r17
 
         ldi     r17, (1<<TOIE0)      ; TOIE0: Interrupt bei Timer Overflow
         out     TIMSK, r17
 
         sei
 
loop:   rjmp loop
 
timer0_overflow:                 ; Timer 0 Overflow Handler
        
     nop  
     dec r19      ; r19 - 1
     dec r23      ; r23 - 1
     dec r25      ; r25 - 1

zum1:   tst r27        ; r27 auf null testen
     breq zum2    ; Wenn Null dann zu nächstem
     rjmp test    ; Springe zu Weiter 2

zum2:   tst r20        ; r20 auf null testen
     breq zum3    ; Wenn Null zum nächsten
     rjmp Weiter3    ; WSpringe zu Weiter 3

zum3:   tst r21        ; r21 auf null testen
     breq zum4    ; Wenn null dann zum nächsten
     rjmp Kurz    ; Springe zu Kurz

zum4:   tst r22        ; r22 auf null testen
     breq zum5    ; Wenn null dann zu nächsten
     rjmp Kurz1    ; Springe zu Kurz 1   

zum5:   tst r26        ; r26 auf null testen
     breq zum6    ; Wenn null dann zum nächsten    
     rjmp Flanke    ; Springe zu Flanke

zum6:   tst r18
     breq zum7
     rjmp Weiter2

zum7:    rjmp Wahl1      ; Springe zu Wahl 1

stoerung:sbi PortB, 2      ; Störungs LED an
     sbis PinD, 5    ; Störung noch betätigt
     rjmp stoerung    ; LED bleibt an
     cbi PortB, 2    ; LED aus
     rjmp Start    ; Springe zu Start
    
ende:    rjmp ende

Hallo Leute,

folgende Schaltung und Programm wie oben zusehen.
An sich ist auch alles toll und läuft, WENN das erste einschalten 
erfolgreich war. Was mein ich:
Ich stecke denn Stecker in die Steckdose. Nun Soll PortB 2 gesetzt 
werden, PortB 1 anziehen, 1 Sekunde warten abfallen, und PortB 2 
gelöscht werden.
Nur das passiert nicht, PortB2 wird gesetzt und nach ca. einer halben 
Sekunde wieder gelöscht. Wenn ich jedoch denn Stecker ziehe und sofort 
wieder in die Dose Stecke dann kann es sein, dass der Schritt 
erfolgreich ist.
Meine vermutung, die Timer werden beim ersten mal nicht bearbeitet oder 
so.
Bitte schaut euch mal mein Programm an. Wie gesagt wenn es mal läuft 
dann geht alles ohne Probleme, daher ist eigentlich ein 
Programmierungsfehler sowie Schaltungsfehler fast nicht möglich. Aber 
wieder ist dieser Fehler immer nur beim ersten mal Spannungzuschalten 
da?
Kennt jemand das Problem?

Grüße

[Holger P. (Gast)]

Nun so werde ich mal versuchen dir in ASM zu helfen :-)

Dein Program beschreibt die Interruptvektoren. Was da so alles passiert. 
Dafür bin ich noch zu neu.

Aber versuche es mal so:

.include "m8def.inc"
 
.org 0x000                    ; kommt ganz an den Anfang des Speichers
         rjmp reset           ; Interruptvektoren überspringen
                              ; und zum Hauptprogramm
         reti                 ; IRQ0 Handler
         reti                 ; IRQ1 Handler
         reti           
         reti           
         reti                 ; Timer1 Capture Handler
         reti                 ; Timer1 CompareA Handler
         reti                 ; Timer1 CompareB Handler
         reti                 ; Timer1 Overflow Handler
         rjmp timer0_overflow ; Timer0 Overflow Handler
         reti                 ; SPI Transfer Complete Handler
         reti                 ; USART RX Complete Handler
         reti                 ; UDR Empty Handler
         reti                 ; USART TX Complete Handler
         reti                 ; ADC Conversion Complete Interrupthandler
         reti                 ; EEPROM Ready Handler
         reti                 ; Analog Comparator Handler
         reti                 ; Two-wire Serial Interface Handler
         reti                 ; Store Program Memory Ready Handler
 
reset:                        ; hier beginnt das Hauptprogramm

         ldi r16, LOW(RAMEND)
         out SPL, r16
         ldi r16, HIGH(RAMEND)
         out SPH, r16



         ldi r16, 0xFF        ;Port B sind Ausgänge
         out DDRB, r16        ;Port B Ausgänge
                             
         ldi r16, 0x00        ;Port D sind Eingänge
         out DDRD, r16        ;Port D Eingänge

Power:

Du solltest auch immer den Stack initialisieren.

Nur so ein Tipp von einem unwissenden :-)

Ach ja

ldi r18,0    ; Lade r18 mit 0
     ldi r19,0    ; Lade r19 mit 0
     ldi r20,0    ; Lade r20 mit 0
     ldi r21,0    ; Lade r21 mit 0
     ldi r22,0    ; Lade r22 mit 0

warum schreibst du nicht

clr r19

ist übersichtlicher. So muss man erst schauen mit was du r19 
beschreibst. Anderst sieht man es sofort.

Sorry aber um so mehr ich in deinem Programm lese um soo schwindliger 
wird es mir. Ich mach das ja auch noch nicht so lange. Aber du solltest 
ein Interupt immer mit reti beenden.

Ei Ei Ei ich lese lieber nicht in dem Code weiter. Wer weiß was da noch 
alles kommt grins

[Wolfgang (Gast)]

Ähh, Du weißt schon, daß PC6 = Anschluß 1 der *Reset ist? Da gehört 
erstmal ein 100n gegen Masse dran und der R1 kann prinzipiell entfallen. 
War das erste, was mir aufgefallen ist, bevor ich Deinen Quellcode 
überflog. Ohne mich darüber auszulassen 8-) mach erstmal den 
*Reset-Kerko dran.

Gruß - Wolfgang

[Holger P. (Gast)]

Sorry Wolfgang.. Ich glaub da liegst Du falsch. Reset immer über ein 
Wiedrstand gegen Plus..

[Wolfgang (Gast)]

Wozu, Holger?

Der ATMega8 hat einen 60kR-Widerstand intern als Pull-up. Beweis: 
Datenblatt (Version 2486P-AVR-02/06), S. 242 ganz unten (30-80kR).

Gruß - Wolfgang

[Holger P. (Gast)]

Nun das kann sein, bin ja noch recht neu bei der Sache. Beim ATMega88 
mach ich das immer so. Falsch ist es aber nicht, bzw. führt zu keinem 
Fehler ODER?

[Wolfgang (Gast)]

Anschluß 1 = PC6 = *Reset. 30-60kR int. Pull-up. Beweis: Datenblatt 
(Version 2545K-AVR-04/07) S. 304.

Wer µC/µP ohne ordentlichen Rücksetzer betreibt, gehört mit Stacheldraht 
ausgepeitscht 8-P

Gruß - Wolfgang

[Holger P. (Gast)]

Kleiner Nachtrag an Peter:

Bitte so das nicht euren Kunden verkaufen. grins

Zitat: "Das bestens ausgebildete und erfahrene Servicepersonal sichert 
die Wartung, Instandhaltung,...."

Ei Ei Ei

[Peter (Gast)]

Danke bis hierher.
Die Sache mit dem Pullup an PC6 oder nicht ist ja nicht Grunde des 
Problems. Die Schaltung funktioniert ja wenn die erste Hürde 
übersprungen ist.
Um genau zu sein, drücke ich nach dem herstellen der Stromversorgung 
denn Aus-Taster PinD1, dann passiert nichts. Ich kann Tasten drücken wie 
ich lustig bin. Nach einer willkürlichen Zeit jedoch, schalten die 
Ausgänge wie sie müssen und alles Läuft super. Ich hoffe es ist 
verständlich.

Holger: Würde ich es so verkaufen wollen, wäre ich kaum hier?
        Ich möchte einfach denn letzten Bug ausmerzen, also aus dem 
Windows
        ein Linux machen ;-)

[Holger P. (Gast)]

Nun so wie dein Programm aussieht ist da mehr als ein Bug drinnen. Wie 
getippt schau mal was Du mit Deinen Interuptvektoren machst. Schau mal 
deine Stack inistlisierung an. Und kein reti aus dem Iterrupt macht die 
dein falsch instalierten Stack voll ohnen ende bis es knallt. Nur eine 
Frage der Zeit wie oft man da drücken kann.

Sorry wenn ich das so tippe aber so wie der Code da aussieht würde ich 
das schnell in die Tonne werfen mir mal grundlegent gedanken machen und 
ein Programmablauf schreiben und danach das Programm neu schreiben.

Bis jetzt ist es echte Glückssache das es überhaupt läuft.

[Stulle (Gast)]

moin

Stackoverflow :-)

du darfst nicht so wie du das machst aus der Interuptroutine einfach mit 
rjmp irgendwo im Prog. weitermachen . Bei jedem Interupt wird die 
Rücksprungadresse auf den stack gelegt , du sammelst also 
rücksprungadressen bis der stack überläuft (ram ist voll).Du müsstest 
dir anstatt direckt ins Prog. zu verzweigen einen Merker basteln und in 
der mainloop darauf reagieren .
siehe AVR-Tutorial - Interupts
http://www.mikrocontroller.net/articles/AVR-Tutorial

mfg

[Peter (Gast)]

@ Stulle
Danke klingt logisch, aber wieso tritt der Fehler nur beim ersten mal 
anstecken auf? Da ist doch an sich alles leer im Speicher?
Wie sollte das mit Merker - Mainloop usw aussehen?
Hast du da ein kurzes Beispiel?

[Holger P. (Gast)]

Du glaubst mir nicht oder?

Schau Dir erst mal deine Interruptvektoren an. Wie das aussehen sollte 
tippte ich Dir am Anfang.

Und überlege dir mal was du so alles in

Loop:
     rjmp Loop


machen könntest.

[Stulle (Gast)]

siehe
Einfache Tastenentprellung und Abfrage
http://www.mikrocontroller.net/articles/AVR-Tutorial:_Tasten

[Holger P. (Gast)]

Nehmen wir nur mal ein Gedankengang.

Du hast einen Sprung zu Power1:
Dieser wird nur von dem Sprung unter Power2 aufgerufen.
Power2 wird wiederum nur nach einem vergleich am ende von Kurz1: 
aufgerufen.

Na klasse

Power1:  ldi r28,0
         
        ldi r27, 1
        rjmp timer


Power2:   rjmp Power1




Kurz1:   
      ...
      ...
      ...
      ...
     tst r28
     brne Power2
     rjmp Start

Da frage ich mich warum nicht so?

Kurz1:   
      ...
      ...
      ...
      ...
     tst r28     
     breq Start
     ldi  r28,0
     ldi  r27,1
     rjmp timer

Was ich damit aufzeigen möchte ist das dein Code total verwirrt und 
verzweigt und und und. Mach einwenig struktur rein. Die Maschinen sollen 
doch von aussen auch fein aussehen und nicht zusammengewürfelt werden. 
Auch da wird systematisch gedacht. Wo hier. Wirkt mir einwenig nach hin 
und her flicken bis es eventuell passt.

Das war nur ein stück aus Deinem Code.

wait:     rjmp Timer


Flanke:   tst r25        ; Prüfe r25 auf null
          brne wait

warum nicht gleich

Flanke:   tst r25        ; Prüfe r25 auf null
          brne Timer

[Peter (Gast)]

Jip hast ja recht, es ist halt aus einer Grundidee entstanden und immer 
weiter gewachsen. Werde morgen nochmal neu ran gehen.

[Holger P. (Gast)]

Bevor Du neu ran gehst. Schau mal unter Interrupt nach und unter Stack.
Es ist immer hilfreich seine Programme zu kommentieren. eine Komentar 
wie

ldi r22,1    ; Lade r22 mit 1
ldi r19,4    ; Lade r19 mit 4

ist für die Katze. Das Du r22 mit 1 beschreibst steht doch in der Zeile. 
Warum machst Du das welch ein Gedankengang steckt dahinter.

FlussDiagramm zeichnen und danach Programmieren.

Was mir auch noch nicht klar ist. Warum deine Taster einmal gegen Masse 
und einmal gegen Plus schalten. Aber das ist etwas was die Schaltung 
angeht. Alles auf ein nenner da ist das Durchblicken nachher besser. 
Auch im Code sieht es besser aus das wen ein Tatser gedrückt wird immer 
das gleiche Passiert.. also immer High wenn gedrückt oder immer Low wenn 
gedrückt. Aber einaml so und einmal so.. Was steckt dahinter.

Wie getippt Ihr geht damit auf Menschen los un 9bar ist nicht wenig. So 
ein Ding sollte doch eigentlich sicher laufen und nicht zufällig und man 
weiß nicht warum.

Warum dafür einen Mega da tut es doch lange ein ATiny2313 ist billiger.. 
also mehr Gewinn für euch.

[oldmax (Gast)]

Hi
Ok, da ist noch eine Menge Holz, was aufgearbeitet werden muß. Mir fällt 
auf, den Stack setzt du unter Timer und den springst du aus allen 
möglichen Ecken deines Programmes an. Ok, es gibt so ich es gesehen 
habe, keinen Call, aber vermutlich eine ISR ( Interrupt Service Routine 
) Die braucht den Stack unbedingt. Wenn du ihn mehrfach wieder neu 
setzt, macht dein Programm sowieso was es will. Mal zur Struktur:
Du beginnst mit derVariablenvereinbarung im DSeg. Im Codesegment (CSeg:) 
kommt ein Sprung zu deinem Programm, um über die IVT ( Interrupt 
Vektortabelle hinwegzukommen und nicht dort hineinzulaufen.
Das ist dein
Start:
Hier erfolgt als erstes ! die zuweisung für den Stack. In Folge die 
initialisierung von Timer, IO's, serieller Schnitstelle und die 
Vorbesetzung von Variablen und Registern.
Dazu, damit es schön übersichtlich wird, schreibst du separate Routinen, 
die du mit RCALL aufrufst und mit Ret abschließt. Vorteil: Hast du in 
einer Routine etwas vergessen oder mußt etwas ändern, kannst du gezielt 
nachsehen und mußt nicht das gesamte Prrogramm durchblättern. Außerdem 
ist es schön einfach, wenn man schon im Kopf einer solchen Routine 
Kommentarzeilen mit der Funktionsbeschreibung hinterlegt.
Etwas so:

;------------- Initialisieren der IO-Pins  -----------------
;*                Port B 0 - 5 sind Ausgänge               *
;*                Port B 6 bleibt Reset                    *
;*                usw.                                     *
;***********************************************************
Init_IO:
  ....
  ....
RET

Wenn du alle deine Unterprogramme so  kommentierst, dann ist es ein 
leichtes, den Überblick zu behalten.
Sind alle deine Initialisierungen abgeschlossen, dann kommen wir zu der 
Programmschleife. Auch hier arbeite mit Unterprogrammen !

Loop:
   RCALL Read_IO      ; Einlesen der Eingänge
   RCALL Set_Flanken  ; Flanken erfassen (0 nach 1 oder 1 nach 0)
   RCALL Do_Job_a     ; bearbeite Informationen
   RCALL Do_Job_n     ; dto
   RCALL Write_IO     ; Ausgabe an Peripherie
RJMP Loop

Nun folgen die Unterprogramme.

;------------- Initialisieren der IO-Pins  -----------------
;*                Port B 0 - 5 sind Ausgänge               *
;*                Port B 6 bleibt Reset                    *
;*                usw.                                     *
;***********************************************************
INIT_IO:
   ....
RET

;------------- Einlesen der Eingänge-----------------
;*    Port D Bit 2 = Taster "+"                     *
;*           Bit 3  = Taster "-"                    *
;*                usw.                              *
;* Rückgabe in Variable New_In                      *
;*            Bit 0 = Taster "+"                    *
;*                usw.                              *
;****************************************************
Read_IO:
   ...
RET

usw.

Wenn du deine Routinen kurz fasst, kannst du sie auf eine DIN A 4 Seite 
drucken und hast schnell den Zugriff um einmal nachzusehen. Bedenke 
auch, das Kommentarzeilen deinen Code nicht größer machen und je mehr du 
kommentierst, um so leichter ist die Fehlersuche.
Gruß oldmax