PIC-Assembler - Pseudo Befehle

einige spezielle Schreibweisen/Befehle erleichtern die Arbeit mit Assembler

in Arbeit

zurück zu PIC-Prozessoren , Elektronik , Homepage

Pseudo Befehle?
Die Pseudo-Befehle

zurück

Pseudo-Befehlsübersicht

list , errorlevel , __config ,

#define , #include ,

ORG , END , EQU , RES ,

DA , DB , DW , DT , DE ,

banksel , pagesel , extern , global , code ,

Befehlsübersicht nach Gruppen

Daten Befehle
Befehle für das Arbeiten mit mehreren Programm-Modulen

Pseudo Befehle?

Der Begriff Pseudo-Befehle ist von mir vielleicht etwas unglücklich gewählt, aber jeder, der schon mal in ein Assemblerprogramm hineingeschaut hat, fand dort eine Reihe von Programmzeilen, die mit den vorher behandelten Assemblerbefehlen nicht s zu tun hat. Dabei handelt es sich im Wesentlichen um Steueranweisungen für den Assembler oder Linker.

nach oben

Die Pseudo-Befehle

Daten-Befehle
Befehle für das Arbeiten mit mehreren Programm-Modulen

#define	Festlegen eines Textbausteins
`Syntax:`	`#define <label> <text>`
`Beschreibung`	`Einem neuen Label wird als Bedeutung ein bestimmter Text zugewiesen.` `Wann immer dieses Label nun im Quelltext auftaucht, wird es vom Assembler durch den festgelegten Text ersetzt.`
`Beispiel:`	`#define Leuchtdiodenpin PORTA,1 ; das IO-Pin RA1 bekommt einen neuen Namen` . . `bsf Leuchtdiodenpin ; es wird der Code für "bsf PORTA,1" erzeugt . .#define led_an bsf Leuchtdiodenpin ; der Text "bsf Leuchtdiodenpin" bekommt den Namen "led_an" . . led_an ; auch hier wird der code für "bsf PORTA,1" erzeugt ; da "led_an" durch"bsf Leuchtdiodenpin" ersetzt wird ; und darin wiederum "Leuchtdiodenpin" durch "PORTA,1" ersetzt wird`

#include	Einfügen einer ganzen Quelltext-Datei
`Syntax:`	`#include <filename>`
`Beschreibung`	`An der Stelle des Befehls wird vom Assembler der gesamte Inhalt des Files <filename> eingefügt.` `Falls der filename Leerzeichen enthält, muss er in "Anführungszeichen" oder in <spitze Klammern> eingeschlossen werden.`
`Beispiel:`	`#include p16f876.inc ; ein Standard-Include-File` `#include "c:\meine Daten\pic codeschnipsel\mydefs.inc" ; eigene Definitionen`

ORG	Festlegen der Adresse für den nachfolgenden Code
`Syntax:`	`ORG <adresse>`
`Beschreibung`	`Der ORG-Befehl legt fest, ab welcher Adresse der nachfolgende Code im Programmspeicher bzw. EEPROM abgelegt werden soll. Damit lässt sich z.B. der Anfang der Interrupt-Behandlungsroutine genau auf die Adresse 4 legen.`
`Beispiel:`	`ORG 0x04 ; der nachfolgende Code wird ab Adresse 4 im Programmspeicher abgelegt` `ORG 0x2100 ; der nachfolgende Code wird ab Adresse 0 im EEPROM abgelegt`

END	kennzeichnet das Ende des Assemblerprogramms
`Syntax:`	`END`
`Beschreibung`	`Beim Erkennen dieses Befehls, beendet der Assembler die Arbeit. Alles danach ist ihm egal.`
`Beispiel:`	`END ; das war's`

EQU	Festlegen einer Konstante
`Syntax:`	`<label>` `EQU <ausdruck>`
`Beschreibung`	`Nach diesem Befehl kann das verwendete <label> anstelle des Wertes von <ausdruck> verwendet werden.` `Dieser Befehl eignet sich, um z.B. RAM-Zellen als Variablen zu definieren. Dabei wird mit dem EQU-Befehl einem <label> die Adresse dieser RAM-Zelle zugewiesen.`
`Beispiel:`	`Wert EQU 0x20 ; Wert bedeutet ab sofort 0x20` `MOVLW Wert ; W wird mit dem Zahlenwert 0x20 beschrieben` `MOVWF Wert ; nun wird der Inhalt von W in die Zelle mit der Adresse 0x20 kopiert`

RES	Reservieren von Speicherplatz
`Syntax:`	`<label>` `RES Speicherzellenanzahl`
`Beschreibung`	`Nach diesem Befehl steht <label> für den Anfang eines Reservierten Speicherblocks.` `Dieser Befehl eignet sich, um z.B. RAM-Zellen als Variablen zu definieren. Dabei wird mit dem RES-Befehl einem <label> die Adresse dieser RAM-Zelle zugewiesen. Im Gegensatz zur Variablemdefinition mittels EQU muss bei RES nicht die konkrete RAM-Adresse angegeben werden, die Variablen werden hintereinander angelegt. Ihre Größe wird in Bytes angegeben.`
`Beispiel:`	ORG 0x20 Wert RES 1 ; Wert bedeutet ab sofort 0x20, Wert ist eine 1 Byte große Variable Pointer RES 3 ; Wert bedeutet ab sofort 0x21, Pointer kann als 3 Byte große Variable dienen Temp RES 1 ; Wert bedeutet ab sofort 0x24 MOVLW Wert ; W wird mit dem Zahlenwert 0x20 beschrieben MOVWF Temp ; nun wird der Inhalt von W in die Zelle mit der Adresse 0x24 kopiert

Daten-Befehle (DA, ... DT, ...)

Diese Befehle dienen der Ablage von Daten (Zahlenwerte oder Text) im Programmspeicher oder im EEPROM des PIC

DA Ablage von 14-Bit-Zahlen/Text im Programmspeicher

Syntax: DA <string>
DA <zahlenwert>

Beschreibung Der DA-Befehl erzeugt 14-Bit Zahlen, und fügt sie an der aktuellen Stelle im Programmcode ein. Er ist vor allem zur Speicherung von Text gedacht. Wird der DA-Befehl von einem String gefolgt, so werden immer 2 Zeichen des Strings in den 7-Bit ASCII-Code gewandelt, und zu einer 14-Bit-Zahl zusammengefasst. Wird der DA-Befehl dagegen von einem Zahlenwert gefolgt, so wird dieser 14-bittig im Programmspeicher abgelegt. Was die Originalzahl größer als 14 Bit, so wird sie abgeschnitten.

Beispiel: DA "abcdef" ; erzeugter Code: 0x30E2 0x31E4 0x32E6 0x3380
DA   0xFFFF   ; erzeugter Code: 0x3FFF

DB Ablage von 8-Bit-Bytes im Programmspeicher

Syntax: DB <string>
DB <zahlenwert>

Beschreibung Der DB-Befehl erzeugt 8-Bit Zahlen, und fügt sie an der aktuellen Stelle im Programmcode ein.

Beispiel: DB "abcdef" ; erzeugter Code: 0x61 0x62 0x63 0x64 0x65 0x66
DB   0x1F     ; erzeugter Code: 0x1F

DT Ablage von 8-Bit-Bytes im Programmspeicher als RTLW-Befehl

Syntax: DT <string>
DT <zahlenwert>

Beschreibung Der DT-Befehl erzeugt 8-Bit Zahlen, und fügt sie als RTLW-Befehl an der aktuellen Stelle im Programmcode ein.

Beispiel: DT "ab"      ; erzeugter Code: retlw 'a'   retlw 'b'
DT   0x1F     ; erzeugter Code: retlw 0x1F

banksel Umschalten auf die Datenspeicherbank einer bestimmten Speicherzelle

Syntax: banksel <label>

Beschreibung Im Register STATUS werden die Bits RS0 und RS1 so gesetzt, dass die Speicherbank aktiviert wird, in der label liegt.
Der Datenspeicher (SFR und GPR) ist in 4 Bänke unterteilt,in denen jeweils die gleichen Adressen (0x00..0x7F)verwendet werden. Um auf eine bestimmte Speicherzelle zuzugreifen, muss vorab auf die richtige Bank umgeschaltet werden. Das erfolgt durch Setzen/Löschen der Bits RS0&RS1 im Register STATUS. Man kann diese Bits "von Hand" mit bsf & bcf-Befehlen setzen, oder befiehlt dem Assembler/Linker das selbsttätig zu tun. Dazu dient der banksel-Befehl. (Details siehe hier)

Beispiel: speicher      equ    0x20   ; die Speicherzelle mit der Adresse0x20 bekommt den Namen "speicher"
.
.
banksel       speicher      ; erzeugter Code: bcf STATUS,RS0 & bcf STATUS,RS1

Befehle für das Arbeiten mit mehreren Programm-Modulen

global macht einen lokalen Bezeichner (Marke, Adressenbezeichner) im ganzen Projekt bekannt

Syntax: global <label>

Beschreibung Besteht ein Projekt aus mehreren ASM-Files (die zunächst in Object-Files assembliert und dann verlinkt werden) so ist es natürlich nötig, dass zwischen den einzelnen ASM-Files (Module) ein Datenaustausch oder ein gegenseitiger Aufruf von Unterprogrammen möglich ist. Dazu muss anderen Modulen mitgeteilt werden, wie bestimmte Speicherzellen oder Einsprungstellen im Modul heißen.
Alle mit der global-Anweisung aufgelisteten Bezeichner sind automatisch im ganzen Project bekannt. Solche Bezeichner können dann von anderen Modulen benutzt werden. Eine global-Anweisung kann mehrere durch Komma getrennte Bezeichner enthalten.

Damit das andere Modul diese Bezeichner benutzen kann, muss der Bezeichner im anderen Modul mit der extern-Anweisung "definiert" werden

Beispiel:         global Marke1, Zaehler      ; diese Bezeichner können nun im ganzen Project benutzt werden
.
.
Marke
        incf   Zaehler
        return

extern macht einen mit global definierten Bezeichner (Marke, Adressenbezeichner) eines anderen Moduls im lokalen Modul bekannt

Syntax: extern <label>

Beschreibung Besteht ein Projekt aus mehreren ASM-Files (die zunächst in Object-Files assembliert und dann verlinkt werden) so ist es natürlich nötig, dass zwischen den einzelnen ASM-Files (Module) ein Datenaustausch oder ein gegenseitiger Aufruf von Unterprogrammen möglich ist. Dazu muss anderen Modulen mit der global-Anweisung mitgeteilt werden, wie bestimmte Speicherzellen oder Einsprungstellen im Modul heißen.
Im Modul, das diesen Bezeichner dann benutzen will, muss der Bezeichner dann mit der extern-Anweisung lokal definiert werden, bevor er verwendet werden kann.

Beispiel:         extern Marke1, Zaehler       ; Marke und Zaehler liegen in einem anderen Modul
.
.
        clrf   Zaehler               ; die im anderen Modul definierte Speicherzelle wird gelöscht
        call   Marke1                ; Aufruf der Unterroutine aus dem anderen Modul

nach oben

zurück zu PIC-Prozessoren , Elektronik , Homepage

erstellt am: 21.09.2004
letzte Änderung: 22.09.2004

DA	Ablage von 14-Bit-Zahlen/Text im Programmspeicher
`Syntax:`	`DA <string>` `DA <zahlenwert>`
`Beschreibung`	`Der DA-Befehl erzeugt 14-Bit Zahlen, und fügt sie an der aktuellen Stelle im Programmcode ein. Er ist vor allem zur Speicherung von Text gedacht. Wird der DA-Befehl von einem String gefolgt, so werden immer 2 Zeichen des Strings in den 7-Bit ASCII-Code gewandelt, und zu einer 14-Bit-Zahl zusammengefasst. Wird der DA-Befehl dagegen von einem Zahlenwert gefolgt, so wird dieser 14-bittig im Programmspeicher abgelegt. Was die Originalzahl größer als 14 Bit, so wird sie abgeschnitten.`
`Beispiel:`	`DA "abcdef" ; erzeugter Code: 0x30E2 0x31E4 0x32E6 0x3380` `DA 0xFFFF ; erzeugter Code: 0x3FFF`

DB	Ablage von 8-Bit-Bytes im Programmspeicher
`Syntax:`	`DB <string>` `DB <zahlenwert>`
`Beschreibung`	`Der DB-Befehl erzeugt 8-Bit Zahlen, und fügt sie an der aktuellen Stelle im Programmcode ein.`
`Beispiel:`	`DB "abcdef" ; erzeugter Code: 0x61 0x62 0x63 0x64 0x65 0x66` `DB 0x1F ; erzeugter Code: 0x1F`

DT	Ablage von 8-Bit-Bytes im Programmspeicher als RTLW-Befehl
`Syntax:`	`DT <string>` `DT <zahlenwert>`
`Beschreibung`	`Der DT-Befehl erzeugt 8-Bit Zahlen, und fügt sie als RTLW-Befehl an der aktuellen Stelle im Programmcode ein.`
`Beispiel:`	`DT "ab" ; erzeugter Code: retlw 'a' retlw 'b'` `DT 0x1F ; erzeugter Code: retlw 0x1F`

banksel	Umschalten auf die Datenspeicherbank einer bestimmten Speicherzelle
`Syntax:`	`banksel <label>`
`Beschreibung`	`Im Register STATUS werden die Bits RS0 und RS1 so gesetzt, dass die Speicherbank aktiviert wird, in der label liegt.` `Der Datenspeicher (SFR und GPR) ist in 4 Bänke unterteilt,in denen jeweils die gleichen Adressen (0x00..0x7F)verwendet werden. Um auf eine bestimmte Speicherzelle zuzugreifen, muss vorab auf die richtige Bank umgeschaltet werden. Das erfolgt durch Setzen/Löschen der Bits RS0&RS1 im Register STATUS. Man kann diese Bits "von Hand" mit bsf & bcf-Befehlen setzen, oder befiehlt dem Assembler/Linker das selbsttätig zu tun. Dazu dient der banksel-Befehl. (Details siehe hier)`
`Beispiel:`	`speicher equ 0x20 ; die Speicherzelle mit der Adresse0x20 bekommt den Namen "speicher"` `.` `.` `banksel speicher ; erzeugter Code: bcf STATUS,RS0 & bcf STATUS,RS1`

global	macht einen lokalen Bezeichner (Marke, Adressenbezeichner) im ganzen Projekt bekannt
`Syntax:`	`global <label>`
`Beschreibung`	`Besteht ein Projekt aus mehreren ASM-Files (die zunächst in Object-Files assembliert und dann verlinkt werden) so ist es natürlich nötig, dass zwischen den einzelnen ASM-Files (Module) ein Datenaustausch oder ein gegenseitiger Aufruf von Unterprogrammen möglich ist. Dazu muss anderen Modulen mitgeteilt werden, wie bestimmte Speicherzellen oder Einsprungstellen im Modul heißen.` `Alle mit der global-Anweisung aufgelisteten Bezeichner sind automatisch im ganzen Project bekannt. Solche Bezeichner können dann von anderen Modulen benutzt werden. Eine global-Anweisung kann mehrere durch Komma getrennte Bezeichner enthalten.` `Damit das andere Modul diese Bezeichner benutzen kann, muss der Bezeichner im anderen Modul mit der extern-Anweisung "definiert" werden`
`Beispiel:`	`global Marke1, Zaehler ; diese Bezeichner können nun im ganzen Project benutzt werden` `.` `.` `Marke` `incf Zaehler` `return`

extern	macht einen mit global definierten Bezeichner (Marke, Adressenbezeichner) eines anderen Moduls im lokalen Modul bekannt
`Syntax:`	`extern <label>`
`Beschreibung`	`Besteht ein Projekt aus mehreren ASM-Files (die zunächst in Object-Files assembliert und dann verlinkt werden) so ist es natürlich nötig, dass zwischen den einzelnen ASM-Files (Module) ein Datenaustausch oder ein gegenseitiger Aufruf von Unterprogrammen möglich ist. Dazu muss anderen Modulen mit der global-Anweisung mitgeteilt werden, wie bestimmte Speicherzellen oder Einsprungstellen im Modul heißen.` `Im Modul, das diesen Bezeichner dann benutzen will, muss der Bezeichner dann mit der extern-Anweisung lokal definiert werden, bevor er verwendet werden kann.`
`Beispiel:`	`extern Marke1, Zaehler ; Marke und Zaehler liegen in einem anderen Modul` `.` `.` `clrf Zaehler ; die im anderen Modul definierte Speicherzelle wird gelöscht` `call Marke1 ; Aufruf der Unterroutine aus dem anderen Modul`