Kombination zwischen zwei Programmen

[Joachim J. (fhjgch)]

Hallo zusammen

Ich arbeite schon seit längerer Zeit an meinem Uhrenprojekt mit meinem 
ATmega8 und bis jetzt habe ich zwei Programme geschrieben. Einmal eine 
Uhr mit Wochentagsanzeige (und nicht funktionierendem Datum) und ein 
Programm mit einer Weltuhr (also vier verschiedene Städte in vier 
verschieden Zeitzonen).
Nun möchte ich die zwei Programme in eins integrieren. Dafür wollte ich 
einen Taster verwenden, doch nach ein paar Versuchen, dachte ich, dass 
es nur mit einem externen Interrupt funktioniert. Ich möchte nämlich 
zwischen der Weltuhr und der normalen Uhr durchswitchen, am besten immer 
nach Tasterdruck.
Brauche ich einen externen Int?
Ist meine Idee realisierbar?

P.S im Anhang findet ihr die zwei Programme (bei Anregungen gerne 
melden!)

[hufnala (Gast)]

Sollte ohne externen Interrupt gehen. Tastenabfrage mit Enprellung ist 
im AVR Tutorial.

//hufnala

[Joachim J. (fhjgch)]

ok, ja, ich weiß wie man Taster benutzt.
Ich habe es schon mal probiert, jedoch habe ich es nicht geschafft aus 
der Tasterabfrageschleife herauszukommen...
Hast du da einen Tip?

[?!? (Gast)]

Joachim Jakob schrieb:
> Brauche ich einen externen Int?
Für die Umschaltung: nein
> Ist meine Idee realisierbar?
Ja, einfach in regelmäßigen Zeitabständen einen Taster abfragen, den 
entprellen und im Program ein Flag setzen. Dieses Flag wechselt bei 
einem Tastendruck zwischen 1 und 0. Je nach Flag springst du zu "datum" 
oder "weltuhr". Diese beiden (bisher eigenständigen) Programme springst 
du je nach Flag-Zustand an.

[Joachim J. (fhjgch)]

?!? schrieb:
> Dieses Flag wechselt bei
> einem Tastendruck zwischen 1 und 0. Je nach Flag springst du zu "datum"
> oder "weltuhr". Diese beiden (bisher eigenständigen) Programme springst
> du je nach Flag-Zustand an.

Ja genau so wollte ich das machen!
aber ich wusste nicht wie ich die Taster Abfrage machen soll, deswegen 
dachte ich an den externen Interrupt...
Also wie soll ich die Abfrage machen?

[der alte Hanns (Gast)]

Im Datenblatt ist unter 'I/O Ports' die gewünschte Information zu 
finden; es empfiehlt sich, das ganze Kapitel zu lesen, in Ihrem Fall ist 
aber nur PINx wichtig, sowie die dazugehörenden Befehle sbic bzw. sbis.

[Joachim J. (fhjgch)]

ok danke, ich werds mir durchlesen!

[npn (Gast)]

Joachim Jakob schrieb:
> ?!? schrieb:
>> Dieses Flag wechselt bei
>> einem Tastendruck zwischen 1 und 0. Je nach Flag springst du zu "datum"
>> oder "weltuhr". Diese beiden (bisher eigenständigen) Programme springst
>> du je nach Flag-Zustand an.
>
> Ja genau so wollte ich das machen!
> aber ich wusste nicht wie ich die Taster Abfrage machen soll, deswegen
> dachte ich an den externen Interrupt...
> Also wie soll ich die Abfrage machen?

Einfach den µC-Pin, wo der Taster dran hängt, abfragen. Taster vom Pin 
gegen GND, internen Pullup aktivieren. Wenn der Taster gedrückt ist, 
liegt Low an, wenn er nicht gedrückt ist, liegt high an.
Und dann arbeitest du am besten diesen Beitrag durch:
http://www.mikrocontroller.net/articles/Entprellung

oder suchst im Forum den Suchbegriff "entprellung" ein, da findest du 
sehr viele Beiträge.

[Joachim J. (fhjgch)]

ja, danke für die hilfe!

[der alte Hanns (Gast)]

Ein Einfachstbeispiel für ein schnelles Erfolgserlebnis am Sonntagabend:

.equ PORT_Taster = PORTB
.equ PIN_Taster  = PINB
.equ Taster      = 5       ; gegen GND

  sbi  PORT_Taster,Taster  ; pullup einschalten

im Modul 'Datum' einbauen:
  sbis  PIN_Taster,Taster
   rjmp Weltuhr
; weiter mit Datum

im Modul 'Weltuhr' einbauen:
  sbic  PIN_Taster,Taster
   rjmp Datum
; weiter mit Weltuhr

Und sobald Sie sich dann ärgern, dass Sie für die Weltuhr den Taster 
gedrückt halten müssen, befassen Sie sich mit der schon erwähnten 
Entprellung und machen die Sache richtig.

[Joachim J. (fhjgch)]

Also ich habe das jetzt wie oben genannt ausgeführt, aber wie befürchtet 
wird nichts angezeigt, da das Programm in der Tasterabfrageschleife 
hängen bleibt und deshalb der LCD nicht aktualisiert wird...
Lösungen?

[Joachim J. (fhjgch)]

der alte Hanns schrieb:
> sbi  PORT_Taster,Taster  ; pullup einschalten
>
> im Modul 'Datum' einbauen:
>   sbis  PIN_Taster,Taster
>    rjmp Weltuhr
> ; weiter mit Datum
>
> im Modul 'Weltuhr' einbauen:
>   sbic  PIN_Taster,Taster
>    rjmp Datum
> ; weiter mit Weltuhr


kannst du mir das bitte genauer erläutern?

[Karl H. (kbuchegg)]

Ich wuerde mir an deiner Stelle ein 3. Programm schreiben.

Knackpunkt an der ganzen Sache ist, dass beide Aufgabenstellungen ja im 
Grunde auf der gleichen Grundlage beruhen - prinzipiell hast du es mit 
einer Uhr zu tun. Und zwar nur mit EINER Uhr. Langer Rede kurzer Sinn: 
die Ausgabe muss aus dem Timer Interrupt raus. Im Timer Interrupt machst 
du nur die Weiterzaehlung der Register, die deine Uhrzeit bzw. das Datum 
darstellen. Nicht mehr!
Die Ausgabe der Uhrzeit bzw. Datum, bzw. des Wochentags kommt in die 
Hauptschleife. Dort und nur dort wird aufs Display ausgegeben. Und bei 
Bedarf wird dann dort, zum Beispiel wenn eine Taste gedrueckt ist, auf 
eine andere Anzeige umgeschaltet, indem ganz einfach eine andere 
Ausgaberoutine angesprungen wird. Zum Beispiel eine, die zur Zeit noch 
ein paar Stunden dazu zaehlt oder weg zaehlt und dabei, wieder nur fuer 
sich lokal, dann auch das Datum und den Wochentag korrigiert.

Aber der erste Schritt besteht darin, dass die innerste Uhr erst mal nur 
fuer sich zaehlt - ganz ohne Ausgabe. Dieser innerste Kern, der Timer 
Interrupt, ist nur dafuer zustaendig, die Zeit zu zaehlen und zu 
registrieren. Wie, wann, wo und auf welche Art die Zeit dann ausgegeben 
wird, soll nicht das Bier dieses inneren Uhrenkerns sein. Das regelt das 
Hauptprogramm in der Hauptschleife.

Daher das 3. Programm, in dem du dir erst mal eine Uhr machst, die genau 
so funktioniert.

[Joachim J. (fhjgch)]

ich habe zwei posts weiter oben noch einen code gepostet, der meiner 
Meinung nach deinen Anforderungen entspricht.
Ich verstehe auch was du meinst, aber meiner meinung nach ist das nur 
mit einem ext Interrupt zu realisieren, denn die Ausgabe muss doch jede 
Sekunde stattfinden, um die Sekunden zu aktualisieren und wenn das 
Programm immer mit dem Abfragen des Tasters beschäftigt ist, kann keine 
Aktualisierung stattfinden.
So sehe ich das..

[Karl H. (kbuchegg)]

Joachim Jakob schrieb:
> ich habe zwei posts weiter oben noch einen code gepostet, der meiner
> Meinung nach deinen Anforderungen entspricht.

Seh ich gleich mal rein

> Ich verstehe auch was du meinst, aber meiner meinung nach ist das nur
> mit einem ext Interrupt zu realisieren,

nicht nur, keinesewgs

> denn die Ausgabe muss doch jede
> Sekunde stattfinden, um die Sekunden zu aktualisieren und wenn das
> Programm immer mit dem Abfragen des Tasters beschäftigt ist, kann keine
> Aktualisierung stattfinden.

Der Interrupt kann zb in ein Register eine 1 reinschreiben, wenn 1 
Sekunde gezaehlt wurde.


Das Hauptprogramm geht nach dem Muster vor, dass es nicht nur den Taster 
abfragt, sondern auch dieses Register. Steht es auf 1, dann wird das 
Display auf den neuesten Stand gebracht und in dieses Register eine 0 
hineingeschrieben. Diese 0 steht dann so lange im Register, bis sie vom 
Timer Interrupt wieder durch eine 1 ersetzt wird um anzuzeigen, dass 1 
Sekunde vergangen ist, woraufhin in der Hauptschleife die Uhrenanzeige 
wieder auf den neuesten Stand gebracht wird.

Lass die Idee mit Taster und externem Interrupt wieder fallen. Als reine 
Softwareloesung gibt das eine Menge Aerger.

[Joachim J. (fhjgch)]

Karl Heinz schrieb:
> Das Hauptprogramm geht nach dem Muster vor, dass es nicht nur den Taster
> abfragt, sondern auch dieses Register. Steht es auf 1, dann wird das
> Display auf den neuesten Stand gebracht und in dieses Register eine 0
> hineingeschrieben. Diese 0 steht dann so lange im Register, bis sie vom
> Timer Interrupt wieder durch eine 1 ersetzt wird um anzuzeigen, dass 1
> Sekunde vergangen ist, woraufhin in der Hauptschleife die Uhrenanzeige
> wieder auf den neuesten Stand gebracht wird.

Diese Vorgehensweise hatte ich bei den zwei einzelnen Modulen auch, 
jedoch muss ich bei dem Programm mit dem Taster immer zurück zur 
Tasterabfrage springen, weshalb ich dieses Aktualisierungsregister 
weggenommen habe...

Karl Heinz schrieb:
> Lass die Idee mit Taster und externem Interrupt wieder fallen. Als reine
> Softwareloesung gibt das eine Menge Aerger.

Hast du vielleicht eine andere Idee, wie ich die zwei Module verbinden 
kann?

[Karl H. (kbuchegg)]

Joachim Jakob schrieb:

> Hast du vielleicht eine andere Idee, wie ich die zwei Module verbinden
> kann?

Das was du hast, sieht doch gar nicht so schlecht aus.

Du musst das nur ein wenig anders organisieren.

Das Hauptprogramm sieht im Prinzip so aus:

    ....
    Initialisierung
    Timer aufsetzen, etc.
    ...

    sei

main:

    Tasterabfrage, ist ein Taster gedrückt worden?
    wenn ja, dann Modus von 1 auf 0 umstellen, bzw. umgekehrt


    wenn Modus steht auf 0, dann normale
    Uhrenanzeige

    wenn Modus steht auf 1, dann Weltuhranzeige

    rjmp main


normale Anzeige:
    mache einen Durchlauf durch die normale Anzeige
    aktuelle Uhrzeit auswerten und einmalig auf die Anzeige schreiben

    rjmp main


Weltuhranzeige:
    mache einen Durchlauf durch die Weltuhranzeige

    rjmp main

du bist noch zusehr davon behaftet, dass der jeweilige Anzeigemodus erst 
bei Tastendruck verlassen wird.
Du kanst die Sache genau umgekehrt aufziehen. Jeder Anzeigemodus wird, 
nachdem er seine Anzeige gemacht hat, verlassen und kehrt wieder zu main 
zurück. Dort wird dann wieder die Tastenauswertung gemacht und je nach 
Modus gehts wieder zurück in den jewiligen Anzeigemodus, der die 
aktuelle Uhrzeit EINMALIG wieder auf die Anzeige klatscht. Ist er damit 
fertig, gehts wieder zurück zu main, Tastenauswertung und Entscheidung 
anhand des Modus, welche Anzeige zu machen ist.

[Karl H. (kbuchegg)]

Ganz wichtig:
die lcd_clear solltest du dir (ausser vielleicht beim Moduswechsel) 
abschminken.
Das flackert sonst wie Sau!

Statt dessen willst du deine Anzeige in jedem Modus so organisieren, 
dass immer nur die jewieligen Stellen überschrieben werden. Also einfach 
über das, was bereits an der Anzeige steht drüber schreiben. Dann 
flackert da auch nichts.

[Karl H. (kbuchegg)]

AUch solltest du dir mal darüber Gedanken machen, dir eine Funktion zu 
schreiben, mit der du fixe Texte ausgeben kannst. Die jedesmal händisch 
in Einzelzeichen aufzudröseln und für jedes Zeichen selbst einzeln 
lcd_data aufzurufen, ist dann schon sehr mühsam. Das kann Programmcode 
genausogut für dich erledigen.

Hier zb ist eine für die UART geschrieben worden:
http://www.mikrocontroller.net/articles/AVR-Tutorial:_Speicher#Flash-ROM_2
(Scroll ein wenig runter bis zu "Fallbeispiel Zeichenketten"

Das lässt sich leicht auf die Verwendung von lcd_data anstelle der UART 
Ausgabe umbauen.

Edit:
Wie du für meinen Geschmack überhaupt noch ein bischen zu sehr 
Copy&Paste programmierst. Wenn ein Teilbereich in deinem Programm 
funktioniert, dann hast du den sehr oft einfach kopiert und 
Registerbezeichnungen angepasst anstatt dir zu überlegen, wie du das so 
formulieren kannst, dass du eine gemeinsame Routine hast, der du in 
vereinbarten Registern die relevanten Kennwerte hinterlässt und die dann 
mehrmals benutzt werden kann, in dem man zb für verschiedene Städte die 
jeweiligen Kennwerte in diese vereinbarten Register kopiert und die 
Routine aufruft.
Mit so einer Textausgabefunktion vereinfacht sich zb in letzter 
Konsequenz die Ausgabe des Wochentags enorm, weil sich der Start des 
Wochentags-Textes ja aus der Wochentagsnummer berechnen lässt.
Da ist noch viel Potential, wie man das Programm gleichzeitig einfacher 
und kürzer machen kann und damit dann auch änderungsfreundlicher 
hinkriegt.

So wie du das

[Joachim J. (fhjgch)]

Karl Heinz schrieb:
> Das flackert sonst wie Sau!

so schlimm ist es auch nicht :P
Spaß bei Seite, danke für den Tipp!


Karl Heinz schrieb:
> Jeder Anzeigemodus wird,
> nachdem er seine Anzeige gemacht hat, verlassen und kehrt wieder zu main
> zurück. Dort wird dann wieder die Tastenauswertung gemacht und je nach
> Modus gehts wieder zurück in den jewiligen Anzeigemodus, der die
> aktuelle Uhrzeit EINMALIG wieder auf die Anzeige klatscht. Ist er damit
> fertig, gehts wieder zurück zu main, Tastenauswertung und Entscheidung
> anhand des Modus, welche Anzeige zu machen ist.

So habe ich mir das ja auch gedacht und da kam mir sofort der ext 
Interrupt in den Sinn, denn die normale Tasterabfrage ist eine Schleife, 
die DANN ERST weiterspringt, wenn die Taste gedrückt wurde...
Also wie schaffe ich es den Taster abzufragen ohne dass er immer rjmp 
warte_auf_taste ausführt?
Da liegt das Problem

Karl Heinz schrieb:
> AUch solltest du dir mal darüber Gedanken machen, dir eine Funktion zu
> schreiben, mit der du fixe Texte ausgeben kannst.

Meinst du ich könnte das für die Wochentagsanzeige gebrauchen?


Und vielen Dank übrigens, du hilfst mir echt weiter!

[Karl H. (kbuchegg)]

Joachim Jakob schrieb:

> So habe ich mir das ja auch gedacht und da kam mir sofort der ext
> Interrupt in den Sinn, denn die normale Tasterabfrage ist eine Schleife,
> die DANN ERST weiterspringt, wenn die Taste gedrückt wurde...

Genau das darf natürlich nicht sein!

> Also wie schaffe ich es den Taster abzufragen ohne dass er immer rjmp
> warte_auf_taste ausführt?
> Da liegt das Problem

Die Lösung besteht darin, dass man Veränderungen im Tastenzustand 
feststellt.

D.h. du wartest NICHT darauf, dass die Taste eine 0 liefert (oder eine 
1). Sondern du vergleichst den Tastenzustand JETZT mit dem Tastenzustand 
ein paar Mykrosekunden zuvor. Sind die beiden gleich, dann hat niemand 
am Taster gefummelt. Sind sie aber NICHT gleich, dann ist die Taste 
gedrückt oder losgelassen worden!

http://www.mikrocontroller.net/articles/AVR-Tutorial:_Tasten

[Karl H. (kbuchegg)]

Karl Heinz schrieb:

>
> http://www.mikrocontroller.net/articles/AVR-Tutorial:_Tasten


Beim ersten Beispiel (das im Tut nicht zuverlässig funktioniert) änderst 
du die Routine tv wie folgt ab

....
      mov  key_old, temp1         ; bisher war kein Taster gedrückt
 
loop:
      in   key_now, key_pin       ; den jetzigen Zustand der Taster holen
      mov  temp1, key_now         ; und in temp1 sichern
      eor  key_now, key_old       ; mit dem vorhergehenden Zustand XOR
      mov  key_old, temp1         ; und den jetzigen Zustand für den nächsten
                                  ; Schleifendurchlauf als alten Zustand merken
 
      breq do_work                ; Das Ergebnis des XOR auswerten:
                                  ; wenn keine Taste gedrückt war -> normale weitere Bearbeitung
 
      and  temp1, key_now         ; War das ein 1->0 Übergang, wurde der Taster also
                                  ; gedrückt (in key_now steht das Ergebnis vom XOR)
      brne do_work                ;
 
.... 
Tastendruck erkannt. Modus umschalten. Modus, das ist eine 1 oder eine 0 in einem Register
....

do_work:

    mache die Anzeige einmalig, je nach Modus

    ....
 
    rjmp  loop                   ; und wieder nachsehen, ob jemand
                                 ; an der Taste gefummelt hat

Bei dir könnte diese einfache Tastenabfrage sogar ganz gut 
funktionieren, weil die Anzeige relativ lange dauert.
Das Problem bei dieser Abfrage besteht ja im Grunde darin, dass der µC 
(im Tutorialsbeispiel) zu schnell ist. Wodurch das Tastenprellen 
durchschlägt (und genau das ist auch das Problem bei einer Lösung mit 
externem Interrupt)

[Karl H. (kbuchegg)]

Joachim Jakob schrieb:

>> schreiben, mit der du fixe Texte ausgeben kannst.
>
> Meinst du ich könnte das für die Wochentagsanzeige gebrauchen?

Logo.
Oder auch die Städtenamen.
Oder auch ein Text, wenn du mal eine Weckfunktion einbaust.

Oder .....

Einen fixen Text ausgeben braucht man immer wieder mal. Sowas auf Vorrat 
zu haben kann nie schaden.

[Joachim J. (fhjgch)]

wow, danke für die Hilfe!

Ich werde die genannten Sachen in mein Programm einbauen und 
anschließend wieder hier posten.

Der Hinweis mit dem Tastenzustand ist genau das, was ich brauche!

Und das mit dem Kürzen und Vereinfachen versuche ich dann auch 
umzusetzen.

Also Danke nochmal und hoffentlich begutachtest du bald mein 
funktionierendes Programm! :D

[Karl H. (kbuchegg)]

Joachim Jakob schrieb:
> ich habe zwei posts weiter oben noch einen code gepostet, der meiner
> Meinung nach deinen Anforderungen entspricht.

Das sieht doch schon nicht schlecht aus.

Nur kann deine
> Ich verstehe auch was du meinst, aber meiner meinung nach ist das nur
> mit einem ext Interrupt zu realisieren, denn die Ausgabe muss doch jede
> Sekunde stattfinden, um die Sekunden zu aktualisieren und wenn das
> Programm immer mit dem Abfragen des Tasters beschäftigt ist, kann keine
> Aktualisierung stattfinden.
> So sehe ich das..

[oldmax (Gast)]

Hi
Wie viele Anfänger machst du den Fehler, ein Programm nicht aufzuteilen, 
sondern in große Blöcke alles reinzupacken. Assembler ist zwar geduldig 
und läßt vieles zu, aber irgendwann verlierst du den Überblick. Versuch 
mal, deine Main mit einer Event-Steuerung auszustatten. Wie bereits 
erwähnt, benötigst du dazu das Ereignis "Signal kommt" oder "Signal 
geht". Wenn du in der Main immer eine Routine aufrufst, die einfach den 
Status der Eingänge sammelt und in ein Byte ablegt, wird es schon 
einfacher. Nennen wir sie mal "read_IO" und getreu nach dem Muster EVA 
(Einlesen Verarbeiten Ausgeben) steht der Aufruf RCALL "Read_IO" am 
Anfang der Programmschleife. Dort samelst du alle Eingänge ein, drehst 
eventuell den Logikpegel ( es läßt sich einfacher denken "Taster 
gedrückt = 1 als Taster gedrückt = 0 bei Tasteranbindung an GND) und 
legst in einer Variablen "Akt_In" den Status ab.
In der nächsten Subroutine prüfst du mit EOR den aktuellen und den 
letzten Status. So bekommst du die Ereignisse bei einer Änderung mit 
einer 1 geliefert. Diese 1 verundest du mit ddem neuen Status ( Wechsel 
von 0 nach 1)  oder mit dem alten Status (Wechsel von 1 nach 0). Dieses 
Ergebnis legst du in einem Eventbyte ab ( Event_To_1 oder Event_To_0). 
Anschließend wird noch der neue Status in die Ablage kopiert. Ein 
weiteres Unterprogramm kümmert sich nun um die gesetzten Bits in der 
Eventvariable. Ist ein Bit gesetzt, so wird der zugehörige Job 
angestoßen und das Bit gelöscht.
Für deine Ausgabe nimmst du einen Puffer, den du entsprechend füllst. 
Deine Ausgabe greift nun abhängig von Timer auf diesen Puffer zurück. Da 
ist es egal, ob da die Zeit von Alaska oder dem Äquator drinsteht. Das 
weist du in den Tasterereignissen zu. Vielleicht hilft dir zusätzlich 
zum Tutorial dieser Seite ein Beitrag im Forum AVR-Praxis unter der 
Rubrik FAQ mit dem Thema "keine Angst vor Assember" weitere Lücken 
schließen.
Gruß oldmax

[Joachim J. (fhjgch)]

So, habe es jetzt hingekriegt :)

Ich würde mich über Tipps freuen!

[LostInMusic (Gast)]

Wochentagsteil ('Mo', 'Di', 'Mi'...) eindampfen über .DB und indirektem 
Zugriff via Z-Pointer.

[der alte Hanns (Gast)]

Erstmal Glückwunsch! - Ein weiterer Assembler-Programmierer.

>Ich würde mich über Tipps freuen!

Na denn:

Peter Dannegger schrieb:
> Kommentare sind für einen selber da, um auch später noch zu verstehen,
> was man mal hingeschrieben hat.
>
> Sie können aber auch sofort aufzeigen, daß man sich vorher keine
> Gedanken über die Funktion gemacht hat. Sie sind sozusagen eine erste
> Gütekontrolle.

Bei einem Anfänger darf man das natürlich nicht ganz so streng nehmen, 
aber ...

[der alte Hanns (Gast)]

sprechende Registernamen, wie bei
> .def temp1=r16
also z.B.
.def Sekunden = r20
.def Minuten  = r24

Das Programm liest sich leichter, und Tippfehler werden ausgesprochen 
selten (wenn man sich bei r24 vertippt, sucht man u.U. lange).

[Joachim J. (fhjgch)]

LostInMusic schrieb:
> Wochentagsteil ('Mo', 'Di', 'Mi'...) eindampfen über .DB und
> indirektem Zugriff via Z-Pointer.

Ja, das ist dann der nächwte Schritt

der alte Hanns schrieb:
> sprechende Registernamen, wie bei
> .def temp1=r16
>
> also z.B.
> .def Sekunden = r20
> .def Minuten  = r24
>
> Das Programm liest sich leichter, und Tippfehler werden ausgesprochen
> selten (wenn man sich bei r24 vertippt, sucht man u.U. lange).

Ja, ich bin nunmal schlampig..
Das werde ich auch noch ändern.
Es ist so entstanden, weil ich mich immer Schritt für Schritt gesteigert 
habe und am Anfang habe ich einfach irgendwelche Register ausgewählt^^

der alte Hanns schrieb:
> Erstmal Glückwunsch! - Ein weiterer Assembler-Programmierer.
>
> Ich würde mich über Tipps freuen!
>
> Na denn:
>
> Peter Dannegger schrieb:
> Kommentare sind für einen selber da, um auch später noch zu verstehen,
> was man mal hingeschrieben hat.
> Sie können aber auch sofort aufzeigen, daß man sich vorher keine
> Gedanken über die Funktion gemacht hat. Sie sind sozusagen eine erste
> Gütekontrolle.
>
> Bei einem Anfänger darf man das natürlich nicht ganz so streng nehmen,
> aber ...

Ja, auch das werde ich noch einbinden :)


Also Danke für die Tipps!

Wollt ihr die verbesserte Version dann auch sehen?

[Falk B. (falk)]

@ Joachim Jakob (fhjgch)

>Wollt ihr die verbesserte Version dann auch sehen?

Nur wenn sie WIRKLICH verbessert ist.

[oldmax (Gast)]

Hi
Ich hab wirklich ein Problem, mich in deinem Konstrukt zurecht zu 
finden. Sicher, solange das Programm noch frisch ist, kennst du dich 
damit aus, aber... laß mal ein paar Tage verstreichen. Hier mal mein 
Tip, mit dem ich mich bei Assembler auch nach Monaten zurecht finde.
Zuerst Kopf.

;*****************************************
;*  hier steht die Programmbeschreibung  *
;*  in einem Kommentarfeld               *
;*****************************************
Reset: RJMP Init         ; Sprung über die IVT
;*****************************************
;*   Abbild der Interrupt Vektor Tabelle *
;*****************************************
             ;IVT
:-----------------------------------------
Init:            ;Initialisierung
   ; Stack initialisieren
   RCALL   Init_IO            ; IO initialisieren
   RCALL   Init_Timer         ; Timer initialisieren
   RCALL   Init_Usart         ; Usart initialisieren
   RCALL   Set_Default_Reg    ; Registerwerte vorbesetzen
   RCALL   Set_Default_VAr    ; Variablen vorbesetzen
   ; etc

;******************************************
;*        Schleife  Hauptprogramm         *
;******************************************

Main:         
   RCALL   Read_IO
   RCALL   Debounce
   RCALL   Set_Io_Event
   RCALL   Read_Usart
   RCALL   Chk_IO_Event
   RCALL   Chk_Rec
   RCALL   set_Anz
   RCALL   Write_IO
   RCALL   Send_Data
   RJMP    Main

;*****************************************
;*     Bereich der Unterprogramme,       *
;*    beginnend mit Initialisierung      *
;*    gefolgt von Leseroutinen           *
;*    Verarbeitung und Ausgabe           *
;*   Am Schluss die Interruptroutinen    *
;*****************************************

Init_IO:
   ....
RET

USW...

Beachte dabei, das du richtig einrückst. Sprungmarken und RET stehen am 
Anfang der Zeile, alles andere rückst du ca. 2-3 zeichen ein. Das ergibt 
ein sauberes Bild und eine gute Übersicht. Und ja, noch etwas: gewöhn 
dir an, die Kommentarzeilen gleich zu schreiben. Du wirst uns für diesen 
Hinweis irgendwann dankbar sein.
Gruß oldmax