Frage zu ASSR bei PICs

[oderlachs]

Hallo ,
vieleicht findet ja wer mal etwas Zeit und "Tinte" für "ein, zwei" helfenden Sätzen.
Ich habe mich in RN-Wissen , etwas über PIC Assemblerprogrammierung eingelesen und auch ein funktionierendes LED- Blinkbeispiel zusammn bekommen.

Nur die Warte-Routine habe ich mal orginal übernommen, aber ich verstehe sie nicht ganz...und zwar die Dokumentation, das die Register 256mal durchlaufen werden.
Das sie dekrementiert werden ist mir verständlich , aber ein Register muss doch auch mit einem Wert( 256 ? ) geladen werden und das ist mein grosses Rätsel, das ich das nicht finde.
Hier die Warteschleife:

P0    equ    0x20                   ; Variablen definieren (Register benennen)
P1    equ    0x21
P2    equ    0x22

Warten   movlw   2               ; schreibe "2" für ca. 0,4 s
         movwf   P2                  ; ins Register P2
         clrf    P1                       ; lösche Register P1 ("0" für 256 Durchläufe) 
         clrf    P0                       ; lösche Register P0 ("0" für 256 Durchläufe)
         decfsz  P0,1                 ; dekrementiere P0 und überspringe "goto $-1" bei P0 = 0
         goto    $-1                    ; sonst gehe zur voherigen Adresse (Befehl "decfsz  P0") 
         decfsz  P1,1                 ; dekrementiere P1 und überspringe "goto $-4" bei P1 = 0 
         goto    $-4                    ; sonst gehe zur aktueller Adresse - 4 (Befehl "clrf P0")
         decfsz  P2,1                  ; dekrementiere P2 und überspringe  "goto $-7" bei P2 = 0
         goto    $-7                     ; sonst gehe zur aktueller Adresse - 7 (Befehl "clrf P1")
         return                           ; springe zurück zum Aufrufer

Das Codebeispiel habe ic h aus aus den Tutorial im obigen Link :Das erste Programm


Leider ist meine Assemblerzeit schon lange her C64er Ära und die des 8085..so das ich nicht mehr so Sattelfest bin .

Wenn mir wer die Güte erweisen würde , mich gedanklich aufzufrischen , warum da was von 256 Durchläufen steht, wäre ich dankbar.

Gruss und Dank

Gerhard

[Ceos]

ganz simpel, dein Register kann nur Werte von 0-255 annehmen

wenn ich jetzt eine fussgesteuerte Schleife habe, die im ersten Schritt von 0 aus 1 abzieht (clrf P1 und clrf P0) kippt das Register nach 255 um und beendet die Schleife erst wenn du auch wirklich 256 mal druchgelaufen bist

[oderlachs]

OK Ceos ..habe verstanden.....kannte das nur in umgedrehter Richtung bislang : 255 >> 0...

Danke Gerhard

[Ceos]

gerne Schleifen kann man ja in zig varianten aufziehen, solange der inhalt nicht für irgendwas zum indizieren genutzt wird ist die zählrichtung ja egal

[oderlachs]

Bestimmt, aber ich bin ja noch beim Lernen, möchte aber nicht ganz von C/Cpp auf ASSR umsteigen. Da aber mein PIC Lehrbuch: "PIC-Microcontroller" von Prof. Günter Schmitt , sehr viel mit "ASSR handelt", möchte ich doch einiges dort auch begreifen , vielleicht auch ausprobieren. Die ersten Fallen hatte ich mir schon beim Schreiben des Codes angelegt.. : Optocode in der ersten Spalte....u.a.m.

Da ich das Forum hier nicht mit blöden Listings vollmüllen möcht : HIER meine erste Creation mit MPLABX geschrieben.

Vielleicht muss ich noch lernen wie ich mit den zeitgenauen "Delays" hinkomme/berechne...vielleicht braucht man das ja mal, aber Rom wurde ja auch an mehreren Tagen erbaut.

Danke Gerhard

[Siro]

Hallo oderlachs,
is zwar schon rund 4 Wochen alt der Thread aber ich erlaube mir trotzdem noch etwas dazu zu schreiben:

Erstens: Ich finde das echt supi, dass jemand der C oder C++ programmiert dann doch mal in den Assembler reinschaut.

Dann hab ich mal deinen Link zu dem Programm aufgerufen.
Meiner Meinung nach ist da noch ein Fehler in deiner unteren Warteschleife, vermutlich durch das kopieren von der oberen Warteschleife:

MAIN_PROG CODE                  ; let linker place main program
214 
215 START
216 
217     ; TODO Step #5 - Insert Your Program Here
218         call INIT_IO  
219 ;LED einschalten        
220 blink   bsf  LED_0                      ; set LED_0
221 ;***********************************************************         
222 ;Warteschleife 1
223         clrf REG_1
224         clrf REG_2
225 loop1   decfsz REG_1
226         goto loop1
227         decfsz REG_2
228         goto loop1
229         clrf REG_1
230         clrf REG_2
231 ;LED ausschalten
232         bcf LED_0                       ;clear LED_0
233 ;Warteschleife 2
234         clrf REG_1
235         clrf REG_2
236 loop2   decfsz REG_1
237         goto loop1             <===== muss hier nicht goto loop2 hin ?
238         decfsz REG_2
239         goto loop2
240 ;***********************        
241         goto blink                      ; loop forever

Ein schönes Wochenende wünscht der
Siro

[oderlachs]

Hallo Siro !

Danke das Du Dich mit meinem Problem befasst hast. Ja ich habe mal mit ASSR beim C64 und 8085 angefangen. Den 8085 noch in der IT Ausbildung(anfang der 90er). Dann bin ich 2003 zu C/C++ übergewechselt(worden) und das habe ich nun als "Standart", aber wenn mir mal nach dem mir so ist, kram ich auch ASSR, Pascal, Delphi oder Java aus der Kiste und "spiel" damit umher.
Leider läuft mein Delphi5 nicht mehr unter den neuen OS besonders nicht bei 64Bit. und ein paar tausend Euronen ist mir meine Freizeitbeschäftigung doch nicht wert um die aktuellen EntwicklerStudios von ehemals Borland/Inprise zu kaufen.

Ich programmiere auch meist nur (In den anderen Sprachen),damit,das "Hirn" nicht verkalkt...sofern ich dieses besitze....

Gruss Gerhard

[Siro]

Hallo Gerhard,

[bischen Offtopic...]
dann habe ich eine ähnliche Karriere hinter mir.
VC20 Commodore war mein Erster und den habe ich auch in Assembler programmiert 6502
ebenso Assembler auf 8085 sowie 8086

und dann hab ich irgendwo mal für meinen ersten PC-XT ein Turbo Pascal bekommen. (DOS-Modus)
Später dann Delphi 3, Delphi 6, und dann war Ende.

ABER:
Irgendwann (ich glaub vor 2 Jahren) habe ich dann "Lazarus" entdeckt und ich dachte mir springt ein Ei aus der Hose,
denn das sieht genauso aus wie mein geliebtes Delphi und es funktioniert eigentlich auch genauso,
aber das Beste daran: es ist Open Source und kostet keinen Cent.
Läuft super und wird ständig gepflegt.

https://www.lazarus-ide.org

In der Firma "musste" ich auch auf "C" umsteigen.
Für die Microcontroller ist das anscheinend immer noch "die angesagte" Sprache.
Hier hatten wir eine abgespeckte, dennoch zig tausend Euro, Lizenz von IAR für ARM Controller.
Ich war echt am verzweifeln mit dem Zeug....... bin dann später umgestiegen, auf LPCXpresso und nun MCUXpresso von der Firma NXP
für die LPCxx Microcontroller. Kostet nix, funktioniert einwandfrei.
[ich hoffe,das war keine Schleichwerbung]

Zurück zum Assembler:
Die Microchip PIC's habe ich schon ewig verfolgt und benutze sie immer wieder.
Damals noch die JW Versionen, welche mit UV-Licht gelöscht werden mussten.
Bis heute programmiere ich die Dinger in Assembler, aber neuerdings auch gerne mal mit den C-Compilern.
Die freien Versionen der Compiler von Microchip sind wirklich brauchbar.
Für kleine Projekte braucht man da nix kaufen.

Man muss heutzutage für wirklich gute Entwicklungswerkzeuge kein Geld mehr ausgeben.

Zeitschleifen bei den PICs in Assembler sind nicht ganz einfach zu berechnen, hier braucht man schon die genauen Taktzyklen usw.
Ich hab das oft mit dem "Simulator" innerhalb der MPLAB-IDE gemacht. Da gibt es ein Fenster "Stopwatch" und hier kann man genau ermitteln wie lange der Code benötigt.
Dann kann man die Schleifenwerte verändern und erneut probieren.
Ich weis nicht, ob Du schon damit gearbeitet hast.



Siro