Inhaltsverzeichnis
Einführung
Die Maschinensprache, auch Assembler oder kurz ASM genannt, ist eine Sprache die nur bestimmter Prozessor versteht. Für einen Menschen ist sie unverständlich, da sie nur aus hexadezimalen (kurz: hex) Zahlen besteht.
Um sich die Sprache verständlicher zu machen wurden den hex Zahlen s.g. Mnemonics aus Buchstaben zugewiesen. Jeder Befehl für ein Prozessor hat somit einen "Namen", der meistens aus einer Abkürzung des Namens in englischer Sprache stammt.
Obwohl sie 200 bis 1000 mal schneller als die meisten Hochsprachen ist, wird sie wegen dem grossen Aufwand bei Erstellung umfangreichen Programmen, selten benutzt. Man findet sie aber oft in fast allen Hochsprachen, in eigebundenen Funktionen, überall dort wo die Hochsprachen zu langsam sind.
ASM eignet sich aber sehr gut für kleine Anwendungen (meistens Steuerungen) mit Mikrokontrollern (kurz: µC).
Die Aufgabe eines ASM-Programmierers ist, ein Programm zu schreiben, das der bestimmte Prozessor versteht und nach den Wünschen des Programmierers realisiert.
Weil ASM Programme nicht besonders durchschaubar sind, wurde als Hilfsmittel ein Programmablaufdiagramm (kurz: PAD) erfunden. Beim Programmerstellung fängt man damit an ein PAD zu erstellen, das die wichtigsten Programmschritte enthält.
Weiter werden alle Befehle nach dem PAD mit einem üblichen Texteditor in eine Textdatei mit Erweiterung .asm (Quellcode) geschrieben, durch ein Assemblerprogramm (für PICs: MPASM oder GPASM) von dem für Menschen noch verständlichen Code in die Maschinensprache "übersetzt" und als Texdatei mit Erweiterung .hex gespeichert. Diese Datei wird danach in den Programmspeicher des µC übertragen ("gebrannt"). Das Assemblerprogramm MPASM kann kostenlos von der Haupseite des Herstellers von PICs [htpp://www.microchip.com] runtergeladen werden.
Das PDA ist sehr behilflich um sogar nach langer Zeit im Programm ewentuelle Fehler zu finden oder Änderungen vorzunehmen.
Nach dem Eischalten der Betriebspannung des µC, fängt der Prozessor an, das sich im Programmspeicher befindliches Programm von der Adresse 0 auszuführen.
Vor dem erstellen eines Programms müssen mehrere seine Parameter festgelegt und demensprechend ein PIC Typ gewählt werden. Bei der Auswahl des PICs am wichtigsten sind: - Anzahl den nützlichen I/O Pins (meistens gesamte Pinanzahl -3) - Max. Taktfrequenz des Prozessors - Grösse des Datenspeichers für Variablen - Grösse des Programmspeichers - Grösse des EEPROMs - Integrierte Hardware (Komparatoren, A/D Wadler, Timer, USART, I²C, SPI, PWM u.s.w) - Benötigte externe Hardware, die an I/O Pins angeschlossen werden muss (Diplay, Tasten, u.s.w.) - Vorhandene Betriebspannung. In der Praxis wird meistens für die Programmentwicklung (wenn möglich) ein grösseren pinkompatiblen PIC genommen (z.B. PIC16F628 für PIC16F84) und erst nach der Optimierung des lauffägiges Programms, der tatsächlich nötiger, da die Parameter am Anfang nur geschätzt werden können. Diese Lösung hat auch den Vorteil, das kurze Hilfsprogramme in den Programmspeicher kopiert und benutzt werden können. Diese benutzen auch eigene Variablen und brauchen 2 I/O Pins fürs Terminal.
Programm
Allgemeines
Jedes Program kann man auf klenere Fragmente unterteilen die auf bestimmter Weise miteinander verknüpft sind und gemeinsam die Aufgabe des Programms erfüllen. Das wichtigste Teil eines Programms ist s.g. Hautprogram (kurz:HP), das eine führende Rolle spielt. Dem HP sind alle andere Programmteile untergeordnet (weiter als Unterprogramm (kurz:UP) genannt) und werden nach Bedarf von ihm aufgerufen um eine bestimmte Aufgabe zu erledigen.
Die Struktur eines Programs ist aber kompliezierter, da ein UP kann auch ein oder mehrere UPs nacheinander aufrufen. Deswegen wird ein Programm von "unten" aufgebaut. Zuerst werden die UP1s erstellt, die ganz einfache Sachen erledigen. Danach kommt das nächste Ebene mit UP2s die schon mehr komplizierten Aufgaben durch ein Aufruf der UP1s erledigen können, u.s.w. Bei Mid-Range PICs (12FXXX und 16FXXX) können maximal bis zu 8 Ebenen benutzt werden.
.-------------------------------------------.
| |
| HP |
| |
'-------------------------------------------'
| | | |
| | | |
V V V V
.-------. .-------. .-------. .-------.
| UP2 | | UP2 | | UP2 | | UP2 |
'-------' '-------' '-------' '-------'
| | | |
| +-----|-+-----------|-+-------+
| | | | | |
| +-|-----|-|-----------+-|-----------+
| | | | | | | |
| +-|-|-----+-|---------+-|-|---------+ |
| | | | | | | | | |
+-|-|-|-----+-|---------|-|-|-------+ | |
V V V V V V V V V V V V
.-------. .-------. .-------. .-------.
| UP1 | | UP1 | | UP1 | | UP1 |
'-------' '-------' '-------' '-------'
Jedes UP kann jederzeit aufgerufen werden, je nach dem was gerade eledigt werden muss. Weil das nicht egal ist, welches UP augerufen wird, da jedes nur eine bestimmte Funktion im Programm hat, muss der Programmierer dafür sorgen, dass alles richtig nach PDA, und nicht chaotisch, abläuft.
Einfaches Beispiel für UPs:
Cmd bcf RS ;setze RS=0 für Befehl
goto Send ;gehe zu Send
Dat bsf RS ;setze RS=1 für Daten
Send .......... ;schicke ein Byte ans Display
return ;gehe zurück zum Aufrufer
Das UP "Send" ist den UPs "Cmd" und "Dat" untergeordnet, weil von beiden benutzt wird, kann aber selber weder "Cmd" noch "Dat" benutzen.
Der PDA ist sehr eifach zu erstellen, weil dafür nur drei Symbole benötigt sind:
Das "Start/Stopp" Symbol bedeutet, dass das Programm sich im stabilem Zustand befindet und nicht "läuft". Enstatt "Stopp" kann auch "Sleep" agewendet werden, da das Programm in dem Fall auch nicht aktiv ist. Das "Tun" Symbol stellt meistens ein UP mit Reihenfolge von Befehlen dar. Das "Prüfen" bedeutet eine Prüfung bestimmter Bedingung und abhängig davon einen weiteren Lauf des Programs, endweder in der "ja" oder "nein" Richtung.
Das Erstellen von PDA bei ASM Programmen ist sehr wichtig und darf nicht unterschätzt werden. Je stärker ein Programmierer glaubt, dass er das ohne PDA schaft, um so mehr Zeit wird er danach bei Fehlersuche oder Änderunen im Programm verlieren. Für einfache Programme, die gut kommentiert sind, reicht es meistens aus, ein PDA nur "im Kopf" zu erstellen, aber ganz ohne PDA geht es sicher nicht.
Die Programmierung in ASM ist änlich wie bei Hochsprachen, wenn man sich Bibliotheken mit Prozessorspezifischen UPs erstellt. Um ein lauffähiges Programm zu erstellen, braucht man nur benötigte UPs ins Program kopieren und ein geignetes HP, das sie aufruft, schreiben.
Midrange
Kurzübersicht Assembler Befehle
|
|
|
Ausführliche Beschreibung zu den Befehlen
Erklärungen zu den Verwendeten Platzhaltern:
- k stellt einen fest definierten Wert da. z.B. 0x20, d'42' oder b'00101010'
- W steht für das W-Register.
- d steht für destination. Im code wird d durch ein w bzw. 0 (der Wert wird in das W-Register gespeichert ) oder f bzw. 1 (der Wert wird in das davor definierte Register gespeichert)
- R steht für ein Register
- fett geschrieben Bedeutet, dass es ein Platzhalter ist und im Quellcode durch eine Registeradresse oder einen Wert ersetzt werden muss
- Schreibmaschinenstil bedeutet, dass es so im Quellcode geschrieben werden kann.
- Vom Wert des Registers R wird 1 subtrahiert und das Ergebniss entweder in das W-Register (d=W=0) oder in R gespeichert (d=F=1).
- Vom Wert des Registers R wird 1 subtrahiert und das Ergebniss entweder in das W-Register (d=W=0) oder in R gespeichert (d=F=1). Der Zusatz SZ steht für skip if zero, d.h. wenn das Ergebnis der Rechnung Null ist, wird der nächste Befehl übersprungen.
- Nach dem GOTO Befehl wird das Programm bei der Adresse weiter ausgeführt, die nach dem GOTO-Befehl steht. Diese Adresse wird durch so genannte Sprungmarken definiert, welche, im Gegensatz zu den Befehlen nicht eingerückt in der asm-Datei stehen.
- Zum Wert des Registers R wird 1 addiert und das Ergebniss entweder in das W-Register (d=W=0) oder in R gespeichert (d=F=1).
- Zum Wert des Registers R wird 1 addiert und das Ergebniss entweder in das W-Register (d=W=0) oder in R gespeichert (d=F=1). Der Zusatz SZ steht für skip if zero, d.h. wenn das Ergebnis der Rechnung Null ist, wird der nächste Befehl übersprungen.
- Es wird die logische Funktion [math]W\ ior\ k[/math] ausgeführt und das Ergebniss in das W-Register gespeichert. Dieser Befehl setzt das Z bit des STATUS-Register, falls W=k und das Ergebnis 0 ist.
- Zur Verdeutlichung der Rechenoperation:
- 1100 1010 ---- ior 1110
- Es wird die logische Funktion [math]W\ ior\ R[/math] ausgeführt und das Ergebniss entweder in das W-Register (d=W=0) oder in R gespeichert (d=F=1). Vergleiche IORLW
- Das Register R wird in das W-Register (d=W=0) oder wieder in R geschoben (d=F=1). Letzteres mag sinnlos scheinen, ist aber nützlich, da durch den Befehl das Z-Bit im STATUS-Regsiter gesetzt wird, falls R Null ist.
- Der festgelegte Wert k wird in das W-Register geschoben.
- Das W-Register wird in das Register R kopiert.
- Dieser Befehl macht nichts. Er verbraucht nur Zeit, welche sich einfach mit folgender Formel berechnen lässt. [math]t=\frac{4}{f}[/math],wobei [math]f[/math] für die Frequenz des Oszillators steht.
- Mit diesem Befehl wird der Interrupthandler (ISR) beendet und das Programm wird an der Zeile weiter ausgeführt, vor der es durch den Interrupt angehalten wurde. Es werden auch alle Interrupts wieder erlaubt (das GIE bit wird gesetzt). Siehe hierzu auch Interrupt
- Wurde ein Programmteil mit dem Befehl CALL aufgerufen, dann springt man mit dem Befehl RETLW zurück in die nächste Zeile nach der Zeile aus der das CALL Befehl ausgeführt wurde. Der in k angegebene Wert wird dabei in das W-Register geschrieben. Dieser Befehl wird vor allem für s.g Sprungtabellen (eng: lookup tables) und Computed-Gotos verwendet.
- Wurde ein Programmteil mit dem Befehl CALL aufgerufen, dann springt man mit dem Befehl RETURN zurück zu der nächsten Zeile nach der Zeile aus der das CALL Befehl ausgeführt wurde.
- Die Bits im Register R werden nach links verschoben. Dabei wird das Carry bit (STATUS,C) in das Bit 0 des Registers R geschoben. Bit 7 aus dem Register R wird in das Carry bit "geschoben". Das Ergebnis wird entweder in das W-Register (d=W=0) oder in R gespeichert (d=F=1).
- Zur Verdeutlichung:
- |C| |-Register R-| ;C steht für das Carry-bit, STATUS,C c 7 6 5 4 3 2 1 0 ;vor dem Verschieben 7 6 5 4 3 2 1 0 c ;nach dem Verschieben
- Die Bits im Register R werden nach rechts verschoben. Dabei wird das Carry bit (STATUS,C) in das 7.Bit des Registers R geschoben. Bit 0 aus dem Register R wird in das Carry bit "geschoben". Das Ergebnis wird entweder in das W-Register (d=W=0) oder in R gespeichert (d=F=1).
- Zur Verdeutlichung:
- |C| |-Register R-| ;C steht für das Carry-bit, STATUS,C C 7 6 5 4 3 2 1 0 ;vor dem Verschieben 0 C 7 6 5 4 3 2 1 ;nach dem Verschieben
- Der µC wird in den Sleep-Mode versetzt, in dem er weniger Strom verbraucht. Er kann durch einen Reset, einem Watchdog-Timer-Reset oder durch einen Interrupt wieder aufgeweckt werden.
- Es wird die Rechenoperation [math]k-W[/math] ausgeführt und das Ergebniss in das W-Register gespeichert. Dieser Befehl beeinflusst das STATUS-Register. Siehe hierzu Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register
- Es wird die Rechenoperation [math]R-W[/math] ausgeführt und das Ergebniss entweder in das W-Register (d=W=0) oder in R gespeichert (d=F=1). Dieser Befehl beeinflusst das STATUS-Register. Siehe hierzu Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register
- Beispiel:
- movlw d'20' ;schreibe 20 in das W-Register movwf Register1 ;bewegt das W-Register in das Register1 movlw d'10' ;schreibt 10 in das W-Register SUBWF Register1,F ;schreibt Register1(20)-W(10) in Register1
- Es es werden die ersten 4 bit mit den letzten 4 bit eines Registers vertauscht und entweder in das W-Register (d=W=0) oder in R gespeichert (d=F=1).
- Beispiel:
- movlw b'00001111' ;schreibe b'00001111' in das W-Register movwf Register1 ;bewegt das W-Register in das Register1 SWAPF Register1,W ;vertauscht die ersten 4 bit mit den letzen ;4 bit in Register 1 und schreibt es in das W-Register ;im W-Register steht nun b'11110000'
- Es wird die logische Funktion [math]W\ xor\ k[/math] ausgeführt und das Ergebniss in das W-Register gespeichert. Dieser Befehl setzt das Z bit des STATUS-Register, falls W=k und das Ergebnis 0 ist.
- Zur Verdeutlichung der Rechenoperation:
- 1100 1010 ---- xor 0110
- Es wird die logische Funktion [math]W\ xor\ R[/math] ausgeführt und das Ergebniss entweder in das W-Register (d=W=0) oder in R gespeichert (d=F=1). Vergleiche XORLW
Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register
|
|
