RN-Wissen.de - Benutzerbeiträge [de]

AVR-Einstieg leicht gemacht

2007-05-08T20:28:58Z

Andy: /* Wie bekommt man das Programm in den Controller? */

[[Bild:avr8.jpg|thumb|300px|Einen Controller zum Leben zu erwecken ist nicht schwer, manchmal reichen ein paar Teile! Beispiel mit Mega8]]
==Wir starten mit einem ATMega32==
Immer wieder gibt es in Foren, wie dem Roboternetz, Einsteiger, die das erstemal mit einem [[Microcontroller]] in Berührung kommen. Trotz zahlreicher Einstiegsbeiträge im Forum wiederholen sich doch bestimmte Anfängerfragen immer wieder, daher soll dieser Artikel noch einmal aufzeigen, wie man den ersten Schritt tut und einen Controller zum Leben erweckt. Es werden verschiedene Grundschaltungen aufgezeigt und erläutert, welche Bauteile welche Funktion besitzen.
Als Controller verwenden wir einen [[AVR]] [[ATMega32]], der derzeit größte [[AVR]]-Controller, welcher noch im bastlerfreundlichen DIP-Gehäuse verfügbar ist. Für kleine bis mittlere Projekte ein sehr empfehlenswerter Controller, zumal er preislich mit ca. 6-7 Euro noch sehr günstig ist und zudem mit seinem 40-Pin-Gehäuse reichlich Anschlussmöglichkeiten besitzt.

[[Bild:Mega1632.gif|center]]

Wie auf dem Bild zu sehen, verfügt auch der etwas günstigere ATMega16 über die gleiche Pinbelegung, daher könnten wir in diesem Tutorial auch diesen Typ verwenden. Der ATMega32 hat aber doppelt soviel Speicherplatz für Programmdaten (Flash), daher hat man für eine geringe Preisdifferenz doch mehr Möglichkeiten.
Wer noch 3 bis 4 Euro sparen will, dem sei der [[ATMega8]] oder [[ATMega168]] empfohlen, diese Typen sind sehr ähnlich, so dass das Tutorial weitgehend auch auf diese Typen bezogen werden kann. Allerdings haben diese Typen deutlich weniger Anschlussmöglichkeiten (28 Pin DIP Gehäuse).

Die Frage, ob man mit einem fertigen Controllerboard, einer Experimentierplatine oder einem Steckbrett beginnen sollte, wurde ja in dem RN-Wissen Wiki Beitrag "[[Mit welchem Controllerboard fang ich an]]" angesprochen. In den meisten Fällen favorisiert der Autor dieses Artikels ein fertiges Controllerboard. Warum das so ist, dazu am Ende noch ein paar Anmerkungen. Dennoch soll diese Einführung schrittweise anhand eines Steckbrettes erläutert werden.

==Start mit handelsüblichem Steckbrett==
Ein Steckbrett hat den Vorteil, dass man theoretisch ohne Löten alle Bauteile relativ zügig zusammenstecken kann. Bestimmte Steckkontakte innerhalb einer Reihe sind im Steckbrett miteinander verbunden, so dass man nachher pro Bauteilbeinchen noch einige Steckkontakte zum Verdrahten mit Schaltdraht oder speziell konfektionierter Litze verwenden kann.

'''Die Vorteile eines Steckbretts:'''

*Bauteile können ohne Löten eingesetzt und verdrahtet werden
*recht zügiger Schaltungsaufbau
*eine Schaltung kann leicht geändert oder korrigiert werden, defekte Teile sind leicht tauschbar
*ein Steckbrett kann auch für ganz andere Schaltungen verwendet werden
'''Die Nachteile eines Steckbretts gegenüber gedruckten Schaltungen und Experimentierplatinen sind:'''

*nicht alle Bauteile passen, so dass wir doch noch etwas löten müssen
*nur geringer Schaltungsumfang möglich, da es schnell unübersichtlich wird
*sehr störanfällig wegen grosser Kabellängen, dadurch oft Funktionsstörungen
*Bauteile müssen zum Teil verbogen werden, damit sie passen

Man beginnt, indem man den Controller AVR [[ATMega32]] auf das Board aufsetzt:

[[Bild:avrtutorial_steckbrettmega32.jpg|center]]

==Die Grundschaltung==
Damit ein Controller erst mal zum Laufen kommt, benötigt man zumindest einen 10-k-Widerstand, einen 100-nF-Kondensator und eine 5V-Spannungsquelle. Das Ganze muss entsprechend dem unteren Schaltplan verschaltet werden, man spricht von einer sogenannten Grundschaltung. In dem Schaltplan wurde der Controller im Übrigen pinkompatibel als Schaltzeichen verwendet, die Pinreihenfolge ist also im Schaltplan identisch mit der echten Bauteilpin-Reihenfolge. Diese Darstellung erleichtert den Nachbau der Schaltung auf einem Steckbrett aber auch einer Experimentierplatine ungemein. Gewöhnlich verwendet man in Schaltplänen eine etwas andere Darstellung, bei der die Pins nach Funktionsgruppen geordnet sind. Bei solchen Schaltplänen muss man sich dann anhand der Pin-Nummern orientieren, man wird dies am Ende des Artikels noch bei dem IC MAX232 sehen.

[[Bild:avrtutorial_grundschaltung_mega32.gif|center|500px]]

Wenn man schon einige Grundschaltungen in anderen Tutorials gesehen hat, dann wird man bemerken, dass unsere doch noch etwas einfacher ist und weniger Bauteile benötigt. Hier wird beispielsweise kein Quarz verwendet, da der ATMega32 auch intern einen Takt generieren kann. Wer mit dem ADC genau messen will, sollte statt der Beschaltung im Bild, zwischen Vcc und AVcc eine Spule von 10uH und einen Kondensator von 100nF zwischen AVcc und GND schalten. Will man AVcc als Referenzspannung verwenden, muss noch ein 100nF Kondensator von ARef nach GND.

Auf dem Steckbrett sieht die obere Schaltung wie folgt aus:

[[Bild:avrtutorial_steckbrett1.jpg|center]]

Um den Controller in Betrieb zu nehmen, benötigt man bei dieser Schaltung ein Netzteil, das eine stabilisierte Spannung von 4 bis 5V liefert. Wir gehen erst einmal davon aus, dass man über dieses verfügt.
Erwähnenswert ist noch, dass der Kondensator als [[Abblockkondensator]] zur Unterdrückung von Störungen dient. Er muss so nah wie möglich an die Spannungszuführung am Controller selbst gesetzt werden. Ohne Kondensator enstehen erhebliche Störungen in der Versorgungsspannung, das Bild verdeutlicht es:

[[Bild:Abblockkondensator OhneC amAVR.jpg|center]]

Der Widerstand in der Grundschaltung dient dazu, die Reset-Leitung konstant auf definiertem High-Pegel zu halten. Verbindet man diesen RESET-Pin später kurz mit GND (Masse), dann wird das Programm im Controller neu gestartet.

==Woran merkt man, dass der Controller funktioniert?==
Gute Frage! Man merkt es garnicht. Genau genommen funktioniert ja auch trotz korrekter Schaltung noch immer nix, denn es muss zuerst ein Programm in den Controller geladen werden, damit er überhaupt weiss, was zu tun ist. Ohne Programm ist der Controller quasi tot.

==Wie bekommt man das Programm in den Controller?==
Der Controller verfügt über eine sogenannte [[ISP]]-Schnittstelle. Das bedeutet, über bestimmte Pins ([[SPI]]) kann der Controller mit einer geeigneten PC-Software (zum Beispiel Bascom) programmiert werden. Zum Anschluss an den PC benötigt man jedoch einen sogenannten ISP-Dongle, auch Programmieradapter genannt. Hier gibt es verschiedene Lösungen, serielle und parallele Adapter. Original von Atmel oder kompatible Lösungen. Der am meisten verwendete ISP-Dongle wird am Druckerport betrieben. Diese gibt es inzwischen recht preiswert, sodass sich das Selbstbauen eigentlich nicht lohnt. Da man auch gern auf ein paar Fehlerquellen verzichten sollte, würde ich eine Fertiglösung empfehlen. Wer ihn selbst bauen möchte, findet ([[AVR-ISP_Programmierkabel|hier]] eine ISP-Dongle-Bauanleitung und sogar eine fertige Platine dafür ([[AVR-ISP_Programmierkabel]]).

Sowas sieht dann so aus:

[[Bild:Avrtutorial_ispkabel.jpeg|center]]

Der Schaltplan eines solchen Programmierkabels:

[[Bild:ispschaltplan.gif|center|thumb|400px|Schaltplan des ISP-Dongels nach unserem Wiki-Bauplan, mit SUB-D Buchse. Bitte beachten, dass das IC1 hier im Plan als verschiedene Blöcke (IC1A/IC1B) dargestellt wird. Dies dient nur zur Übersicht, es handelt sich nur um ein IC, einfach auf die Pinnummern achten. Zum vergrößern anklicken.]]

Das Problem ist nun, wie schließe ich einen handelsüblichen ISP-Programmieradapter an den Controller auf dem Steckbrett an. Der normale 10-polige Wannenstecker (nach [[RN-Definitionen]]) passt nicht in ein Steckbrett. Das ist wieder so ein typischer Nachteil bei Steckbrettern! In unserem Beispiel haben wir dazu auf einem kleinen Stück Experimentierplatine einen steckbaren Adapter für das Steckboard gelötet.
Somit kann man die Schaltung um einen üblichen 10-poligen ISP-Programmieranschluss ergänzen:

[[Bild:avrtutorial_grundschaltung_mitisp.gif|center|500px]]

Auf dem Steckbrett sieht das gleiche so aus:

[[Bild:avrtutorial_steckbrett_mitisp.jpg|center]]

Jetzt endlich ist es soweit, jetzt kann man den Controller über einen ISP-Programmieradapter mit dem PC verbinden. Aber unbedingt darauf achten, dass auch alles korrekt nach Schaltplan gesteckt wurde und dass die Betriebsspannung 5V nicht übersteigt. Ansonsten könnte man sich Dongle oder sogar die PC-Schnittstelle beschädigen.
Als Entwicklungsumgebung nutzen wir hier im Tutorial [[Bascom]]. [[Bascom]] ist ein sehr beliebter Basic-[[Compiler]], der zahlreiche [[AVR]] Controllertypen programmieren kann. Da auch ein [[Terminalprogramm]] und ein Programmer integriert ist, enthält diese PC-Software alles, was man braucht, das erleichtert den Einstieg zusätzlich. Die Software gibts kostenlos als Demo bis 4K Code, für unsere Beispiele und den Einstieg reicht das allemal, siehe dazu Artikel Bascom.
Wie man ein Programm schreibt, kompiliert und überträgt, wurde schon in diesem Beitrag [[Bascom - Erstes Programm in den AVR Controller übertragen]] ausführlich behandelt, wir ersparen uns deshalb diese Details.

Als erstes kompilieren und übertragen wir folgendes Programm:

<pre>
'###################################################
'step1.bas.BAS
'für
'RoboterNetz.de AVR Tutorial in RN-Wissen
'
'Autor: Frank Brall
'Weitere Beispiele und Beschreibung der Hardware
'unter
' http://www.Roboternetz.de oder
' http://www.Roboternetz.de/wissen
'#######################################################

$regfile = "m32def.dat"
$framesize = 32
$swstack = 32
$hwstack = 32
$crystal = 1000000

Do
Loop

End
</pre>

Das Programm macht eigentlich nichts, außer dass es eine Endlosschleife ausführt. Aber da wir noch überhaupt nix am Controller angeschlossen haben, können wir eh noch nicht sehen, ob ein Programm nun richtig ausgeführt wird oder nicht.
Allerdings können wir schonmal üben, das Programm mit Bascom zu übertragen. Wenn wir alles richtig aufgebaut haben und Spannung anliegt, dann sollte automatisch der Controller in Bascom erkannt werden. Die Übertragung sollte dann ohne Fehlermeldung erfolgen können. Wenn wir das geschafft haben, geht’s weiter.

==Läuft die Schaltung und das Programm?==
Damit wir nun endlich sehen, ob sich bei unserer Schaltung auch was tut, schließen wir eine LED über einen 1K-Vorwiderstand an einen Port an. Da wir die Kathode an den Controllerpin und die Anode an Plus legen, leuchtet die LED immer dann, wenn dieser Pin auf Low geschaltet wird.

[[Bild:avrtutorial_grundschaltung_mitled.gif|center|500px]]

Auf dem Steckbrett sieht's nun so aus:

[[Bild:avrtutorial_steckbrett_mitled.jpg|center]]

Damit man nun auch wirklich sieht, ob das Programm läuft, schreiben wir ein kleines Basic-Programm, welches eine LED abwechselnd ein– und ausschaltet. Wir kompilieren und übertragen also folgendes Programm:

<pre>
'###################################################
'step2.bas.BAS
'für
'RoboterNetz.de AVR Tutorial in RN-Wissen
'
'Autor: Frank Brall
'Weitere Beispiele und Beschreibung der Hardware
'unter
' http://www.Roboternetz.de oder
' http://www.Roboternetz.de/wissen
'#######################################################

$regfile = "m32def.dat"
$framesize = 32
$swstack = 32
$hwstack = 32
$crystal = 1000000

Config Portc.0 = Output 'Ein Pin wird aus Ausgang konfiguriert PC0 (also Pin0 von Port C)

Do
Portc.0 = 1 'Pin wird auf High, also 5V geschaltet
Waitms 100
Portc.0 = 0 'Pin wird auf Low, also 0V geschaltet
Waitms 100
Loop

End
</pre>

Wenn die LED nun schnell blinkt, dann funktioniert die aufgebaute Schaltung perfekt. Wir haben gleichzeitig gelernt, wie man einen Ausgangsport, also Controllerpin, ein- und ausschalten kann. Nahezu alle Pins beim ATMega32 können auf diese Weise als Ausgangsport betrieben werden. Somit lassen sich nicht nur viele Leds, sondern unter Zuhilfenahme eines Treibers (z.B. Transistors) auch Relais und andere Aktoren schalten.

==Eingangsport fragt Taster ab==
Nun erweitern wir die Schaltung noch um einen Taster. Nahezu jedes Port kann bei einem ATMega32 auch per Software als Eingangsport konfiguriert werden. Wir schließen z.B. einen Taster an Port-Pin PA7 an.

[[Bild:avrtutorial_grundschaltung_mittaster.gif|center|500px]]

Das Port wird in der Software so konfiguriert, dass es als Eingang arbeitet und intern über einen hohen Widerstand (Pullup-Widerstand) ständig auf High-Pegel gelegt wird. Wird nun eine Taste gedrückt, so wird der Pegel auf Low gezogen.
Das Beispielprogramm ist nun so gestaltet, dass bei gedrückter Taste die LED leuchtet und beim Loslassen wieder ausgeht.

<pre>
'###################################################
'step3.bas.BAS
'für
'RoboterNetz.de AVR Tutorial in RN-Wissen
'
'Autor: Frank Brall
'Weitere Beispiele und Beschreibung der Hardware
'unter
' http://www.Roboternetz.de oder
' http://www.Roboternetz.de/wissen
'#######################################################

$regfile = "m32def.dat"
$framesize = 32
$swstack = 32
$hwstack = 32
$crystal = 1000000

Config Portc.0 = Output 'Ein Pin wird aus Ausgang konfiguriert PC0 (also Pin0 von Port C)

Config Pina.7 = Input 'Ein Pin (PA0) wird als Eingang definiert
Porta.7 = 1 'Interner Pullup Widerstand ein

Do
If Pina.7 = 1 Then
Portc.0 = 1 'Pin wird auf High, also 5V geschaltet
Else
Portc.0 = 0 'Pin wird auf Low, also 0V geschaltet
End If
Loop

End
</pre>

==Grundschaltung mit Quarz==
Obwohl wir ab der letzten Schaltung schon einiges mit dem Controller anfangen können, so fehlt doch noch etwas Wichtiges. Oft ist es nämlich notwendig, dass ein Controller sehr genaue Frequenzen mißt oder ganz genaue Taktraten ausgeben kann. Leider ist der interne Taktgenerator nicht 100% exakt, was bei manchen Anwendungen störend ist. Zum Beispiel können über die RS232-Schnittstelle Daten nicht immer ganz fehlerfrei übertragen werden, wenn die Taktfrequenz nicht genau stimmt. Daher wird in den meisten Anwendungsfällen ein Quarz zur Takterzeugung genutzt, Sie kennen das sicher aus anderen Grundschaltungen. Also erweitern wir unsere Schaltung gleich noch um einen Quarz mit den zugehörigen 22pF-Kondensatoren.

[[Bild:avrtutorial_grundschaltung_mitquarz.gif|center|500px]]

Auf unserem Steckbrett wird's langsam voller, hier sieht's also inzwischen so aus:

[[Bild:avrtutorial_steckbrett_mitquarz.jpg|center|500px]]

Normalerweise sollte der Quarz genauso wie die beiden 22pF-Kondensatoren, die zum Anschwingen des Quarzes dienen, möglichst nahe am Controller platziert werden. Auf dem Steckbrett ist das manchmal gar nicht so einfach, insbesondere wenn man wie in diesem Fall den Quarz erst später hinzufügt. Wichtig ist nämlich, dass die Leitungen vom Quarz zum Controller möglichst kurz sind, bei gedruckten Schaltungen oft nur 1 bis 2 cm! Auch die einzelnen Bauteilbeinchen, z.B. der Kondensatoren, sollten normalerweise so kurz wie möglich sein.
Ist dies nicht der Fall, wie auch in unserem Bild, dann fungieren diese Leitungen fast wie eine Funkantenne. Dies führt in der Regel zu starken Hochfrequenzsignalen, die nicht nur unsere Schaltung, sondern auch andere Schaltungen in der Nähe stören könnten. Man merkt dies auch oft daran, dass sich ein Board bei höherer Quarzfrequenz immer seltener fehlerfrei ohne Übertragungsfehler programmieren läßt.
Grundsätzlich sind daher Schaltungen mit Quarz auf einem Steckbrett nicht sonderlich zu empfehlen, die Betriebssicherheit ist nicht immer gegeben.

Auch wenn nun ein Quarz angeschlossen ist, so wird er noch immer nicht genutzt. Noch immer arbeitet der [[ATMega32]] mit seiner intern voreingestellten 1 Mhz Taktfrequenz. Um dies umzustellen, muss man ein sogenanntes [[Fusebits|Fusebit]] im Controller umprogrammieren. Auch dies wurde schon im Beitrag [[Bascom - Erstes Programm in den AVR_Controller übertragen]] näher beschrieben. Hier sei daher nur nochmals gesagt, dass dies auch sehr bequem in [[Bascom]] erfolgt:

[[Bild:avrtutorial_bascomfusebitquarz.gif|center]]

Sobald wir das umgestellt haben, müssen wir auch in dem Programm die Anweisung

$crystal = 1000000

durch

$crystal = 16000000

ersetzen, denn unser Quarz taktet nun mit 16 MHz.

==Spannung stabilisieren==
Auch wenn unsere Basis-Schaltung für Experimente inzwischen schon ganz nett ist, so ist es doch etwas ungünstig, dass wir stets 5V zur Verfügung haben müssen. Nicht immer steht ein geeignetes Netzteil zur Verfügung, zudem soll ein Controller auch oft mit Batterien versorgt werden. Aus diesem Grund verfügen fast alle Entwicklungsboards wie ([[RN-Control]], STK500 etc.) über einen [[Spannungsregler]].
[[Bild:78s05.jpg|thumb|Spannungsregler 78S05]] Dieser wandelt eine höhere Eingangsspannung (ca. 7 bis 20 V) immer genau in 5V um. Sowas erhöht die Betriebssicherheit einer Schaltung nochmals immens. Als [[Spannungsregler]] (IC2) wird oft der 7805 genutzt, empfehlenswert ist der Typ 78S05, welcher 2A verträgt sowie über einen Kurzschluss- und Überlastungsschutz verfügt.
Die beiden 100nF-Kondensatoren sind wichtig, sie sollen HF-Störungen und Schwingungen vermeiden. Der Elko vor dem Spannungsregler ist vor allem dann wichtig, wenn die Spannung von einem Netzgerät kommt und noch etwas geglättet werden muss. Je höher der Strombedarf der Schaltung, desto größer kann man die Kapazität wählen. Es schadet nicht, wenn man den Elko einige Nummern größer wählt, man ist dann quasi für alle Fälle gerüstet. So sind Werte zwischen 100 uF und 2200 uF durchaus denkbar.

Wir erweitern unsere Schaltung somit wie folgt:

[[Bild:avrtutorial_grundschaltung_spannung.gif|center|500px]]

Auf dem Steckbrett sieht's wie folgt aus:

[[Bild:avrtutorial_steckbrett_spannung.jpg|center]]

==Daten und Texte zum PC übertragen==
In vielen Programmen müssen Daten oder Texte vom Controller an den PC oder umgekehrt gesendet werden. Insbesondere bei komplexen Programmen kann man auf diese Weise Variableninhalte ausgeben und somit auch Fehler im Programmcode schneller finden und korrigieren. In der Regel ist das ganz einfach, denn der [[Microcontroller]] [[ATMega32]] verfügt über einen internen [[UART]], also ein Modul, das Daten über die [[RS232]]-Schnittstelle zum PC senden bzw. auch von ihm empfangen kann. Leider arbeitet jedoch die Controllerschnittstelle mit 5V und die PC-Schnittstelle der Norm entsprechend mit +-12V. Daher muss unbedingt ein Schaltkreis dazwischen, welcher die Pegel anpasst. Gewöhnlich nimmt man hier das IC MAX232(CPE), welches inzwischen sehr preiswert erhältlich ist.

Wir müssen also die Schaltung nochmals erweitern.

[[Bild:avrtutorial_grundschaltung_max232.gif|center|500px]]

Das IC Max232 ist im Schaltplan in der üblichen funktionsorientierten Darstellung gezeichnet. Zur besseren Übersichtlichkeit wurden die immer benötigten Anschlüsse für VCC (Pin 16) und GND (Pin 15) getrennt oben rechts im Schaltplan dargestellt. Also nicht vergessen !!

Auf dem Steckbrett sieht's so aus:

[[Bild:avrtutorial_steckbrett_max232.jpg|center|500px]]

Über eine dreipolige Stiftleiste ([[RN-Definitionen]]) wird nun das Steckboard mit der [[RS232]]-Schnittstelle des PC verbunden. Es ist nun ein Leichtes, mit einem Programm Daten zum PC zu senden. Das nachfolgende Programm gibt Hinweise mit der Anweisung '''PRINT''' aus:

<pre>
'###################################################
'step5.bas.BAS
'für
'RoboterNetz.de AVR Tutorial in RN-Wissen
'
'Autor: Frank Brall
'Weitere Beispiele und Beschreibung der Hardware
'unter
' http://www.Roboternetz.de oder
' http://www.Roboternetz.de/wissen
'#######################################################

$regfile = "m32def.dat"
$framesize = 32
$swstack = 32
$hwstack = 32
$crystal = 16000000
$baud = 9600

Config Portc.0 = Output 'Ein Pin wird aus Ausgang konfiguriert PC0 (also Pin0 von Port C)

Config Pina.7 = Input 'Ein Pin (PA0) wird als Eingang definiert
Porta.7 = 1 'Interner Pullup Widerstand ein

Do
If Pina.7 = 1 Then
Portc.0 = 1 'Pin wird auf High, also 5V geschaltet
Print "Schalter nicht gedrückt"
Else
Portc.0 = 0 'Pin wird auf Low, also 0V geschaltet
Print "Schalter gedrückt"
End If
Wait 1
Loop

End
</pre>

==Möglichkeiten des Steckbrettes erreicht==
Inzwischen füllt der Schaltplan fast ein DIN-A4-Blatt und auf dem Steckbrett sieht's auch schon recht wirr aus, dabei haben wir nur die wichtigsten Grundelemente auf dem Steckbrett. Für eine Roboter-Steuerung oder andere Anwendung fehlt doch noch einiges. Zum Beispiel weitere Taster, weitere LEDs, Motortreiber, damit der Controller auch Motoren ansteuern kann und ein [[I2C]]-Bus-Anschluss.
Dies alles noch auf einem Steckbrett zu realisieren macht wenig Sinn, zumal bereits jetzt schon durch die doch recht langen Leitungen/Verkabelungen erhebliche Störungen auftreten. In der letzten Phase ist es immer öfters zu Übertragungsfehlern beim Programmieren gekommen, oft musste dies 20mal wiederholt werden. Dies zeigt, dass ein Steckbrett bestenfalls für ganz kleine Controller-Experimente herhalten kann. Für größere Dinge sollte man dann doch zu einer Lösung auf einer gedruckten Platine greifen. Spezielle Experimentierboards bieten mehr Sicherheit und haben neben den Grundelementen, die hier beschrieben wurden, noch eine ganze Menge mehr drauf. Bei [[RN-Control]] zum Beispiel 5 Tasten, 8 Leds, Motortreiber, Lautsprecher, diverse Anschlüsse etc.
Der Größenunterschied wird im Bild deutlich:

[[Bild:avrtutorial_steckbrett_rncontrol.jpg|center|500px]]

Auch wenn das Steckbrett also kein Controllerboard ersetzen kann, so hat das kleine Tutorial doch gezeigt, wie eine [[Avr]]-Schaltung aufzubauen ist. Dieses Wissen sollte man auch besitzen, wenn man ein Controllerboard nutzt.

==Was braucht man, wenn man mit einem Controllerboard den Einstieg startet?==

[[Bild:avrtutorial_ispkabel.jpg|thumb|ISP-Programmierkabel]]Neben dem eigentlichen Board braucht man, wie schon zuvor angesprochen, ein [[AVR-ISP Programmierkabel]]. Da das Selbstbauen kaum billiger ist, ist zu empfehlen, ein solches fertig mitzubestellen. Am preiswertesten und zugleich vielseitigsten sind die ISP-Adapter, die man an das Druckerport anschließt (siehe Bild). Es gibt aber auch USB-Lösungen, wobei diese jedoch oft teuer sind und auch oft weniger Controller programmieren können. Hat man jedoch einen PC oder Notebook ohne parellelen Druckeranschluss, so muss man wohl oder übel in den meisten Fällen zu einem seriellen oder USB-Programmieradapter greifen. Neben den erwähnten Nachteilen hat der USB Dongle aber oft auch den Vorteil, dass er etwas schneller ist. Dieser Unterschied macht sich aber nur bei sehr großen Programmen und Controllern wirklich bemerkbar.

Als zweites braucht man natürlich eine Stromversorgung. Ideal sind Gleichspannungsnetzgeräte, die zwischen 9 und 12V liefern, vorausgesetzt, das Board hat einen Spannungsregler wie in der Regel die RN-Boards. Man kann hier ein normales Steckernetzteil oder ein komfortables Labornetzteil nehmen. Um etwas Reserve zu haben, wäre es gut, wenn das Netzteil mindestens 1 A liefern kann. Alternativ kann man auch Akkupacks oder Batterien nutzen, allerdings mindestens 7,2V sollten die schon liefern können, sicherer sind 8,4-, 9,6- oder 12V-Akkus.
Das wäre eigentlich schon das Wichtigste, um ein Board in Betrieb zu nehmen und Experimente zu machen.

Allerdings, ein RS232-Kabel ist ebenfalls noch sehr empfehlenswert. Dieses erlaubt die Ausgabe von Texten und Variablen auf den PC, wir haben es ja oben im Steckbrettbeispiel schon gesehen. Dazu wird auf dem PC ein [[Terminalprogramm]] gestartet und über die [[RS232]] Schnittstelle mit dem PC verbunden. Bei manchen Boards ist sowieso ein RS232 Kabel unerläßlich, wie z.B. RN-Motor, RN-Speak etc. Nützlich ist es aber überall. Man kann ein solches Kabel selbst bauen oder gleich beim Kauf eines Boardes mitbestellen.

Also nochmal die Zusammenfassung für den Einstieg:

* Controllerboard
* [[AVR-ISP Programmierkabel]] mit 10-poligem Wannenstecker
* RS-232-Kabel (mit 3-poligem Adapter, wenn Board [[RN-Definitionen]] erfüllt)
* Netzgerät oder Akku (ideal 9 bis 12V, notfalls auch 7,2 bis 20V)
* [[Bascom]]-Compiler-Vollversion ist nur nötig, wenn man gleich größere Sachen anstrebt, ansonsten reicht das Demo, genauso wie ein [[Avr-gcc]]-Compiler. Bei RN-Boards sind diese Programme beim Board- oder Platinenkauf sowieso dabei, ansonsten kann man diese im Internet downloaden.
* Ein gutes Buch ist immer gut, siehe [[Buchvorstellungen]]

==Autor==
*[[Benutzer:Frank|Frank]]

===Quellen===
* [[Abblockkondensator]] Artikel von Uwegw
* RN-Board Dokumentationen aus [[:Kategorie:Projekte]]
* diverse Datenblätter

==Siehe auch==
*[[AVR-ISP Programmierkabel]]
*[[Mit welchem Controllerboard fang ich an]]
*[[Abblockkondensator]]
*[[Bascom]]
*[[Bascom - Erstes Programm in den AVR_Controller übertragen]]
*[[Avr]]
*[[Atmel Controller Mega16 und Mega32]]
*[[Spannungsregler]]

[[Kategorie:Robotikeinstieg]]
[[Kategorie:Praxis]]
[[Kategorie:Elektronik]]
[[Kategorie:Microcontroller]]
[[Kategorie:Projekte]]

RN-Control

2007-05-08T19:15:30Z

Andy: /* Programmierung per Druckerport, USB oder RS232 */

Ein bewährtes Microcontrollerboard, das wie das RNBFRA-Board in der Roboternetz-Community infolge einer Diskussion entstand. Es sollte ein Board werden, das ein gutes Preis-Leistungs-Verhältnis bietet und für vielfältige Aufgaben geeignet ist.
Das Vorhaben ist dank der zahlreichen Anregungen gut gelungen, das Board gibt es inzwischen nicht nur als Bauanleitung mit Platine, sondern auch als Bausatz und sogar Fertigmodul.
Es hat sich als preiswertes Universalboard für Roboter, Steuerungsaufgaben etc. als auch als ideales Einsteigerboard einen guten Namen im Roboternetz gemacht, daher gibt es für dieses Board auch ein eigenes Unterforum im Roboternetz.
Es gibt inzwischen unzählige Anwendungen, die mit RN-Control umgesetzt wurden.
Trotz günstigem Preis ist ein sehr flexibles Board für unzählige Anwendungsmöglichkeiten entstanden. Über den I2C-Bus stehen zahlreiche Erweiterungsboards zur Verfügung, so können beispielsweise die gleichen I2C-Erweiterungen wie beim großen RNBFRA-Board kombiniert werden (Relaiskarte, Sprachausgabe usw.) Roboternetz

[[Bild:rncontrol1.4diagramm.jpg|thumb|Funktionen des Boards]]

[[Bild:rncontrol1.4schaltplan.gif|thumb|Schaltplan zum Board]]

[[Bild:rncontrol1.4bestückungsplan.gif|thumb|Bestückungsplan zum Board]]

Besonders viel Wert wurde auch auf den einfachen Aufbau und viele Experimentier- und Einsatzmöglichkeiten gelegt. Mit diesem Board läßt sich u.a. schon ein recht ausgereifter Roboter konstruieren. Ultraschallsensoren, Infrarot-Entfernungssensoren, Motoren u.v.m. können direkt angeschlossen werden. Da das Board auch in der Community Roboternetz recht beliebt ist, findet man dort auch viele Tips und Programme.

[[http://www.robotikhardware.de/bilder/rncontrol14diagrammmittel.jpg Diagramm hier]]

==Hier die Leistungsmerkmale auf einen Blick:==

*Wahlweise 8 oder 16 Mhz Taktfrequenz (beide Quarze werden mitgeliefert, 16 Mhz bereits eingesteckt)
*Schneller AVR Mega 32 Mikrocontroller,32K Speicher, 2K Ram und 1K EEPROM), 32 programmierbare I/O Pins,8 AD Ports u.v.m.
*8 Leuchtdioden per DIP-Schalter deaktivierbar und anderen Ports per Steckbrücke beliebig zuzuordnen
*alle Portleitungen sind über Stecker nach außen geführt. Die Steckernorm entspricht der Roboternetz-Definition als auch der des Atmel Entwicklungsboards STK500
*alle Ports sowie +5V und GND sind zusätzlich über Steckbuchsen erreichbar. Ideal zum Experimentieren, da einfach Drähte (ca. 0,5mm) eingesteckt werden (kein Löten oder Schrauben). So können einfach andere LEDs zugeordnet werden oder ein Steckbrett verbunden werden
*Der wichtige Port A (wahlweise 8 digitale oder analoge Ein- o. Ausgänge) ist zusätzlich noch über eine Qualitätssteckklemme mit Hebel herausgeführt
*Motortreiber ca. 1 A belastbar - für zwei Getriebemotoren oder 1 Schrittmotor. Dieser kann auch für andere Zwecke (Relaisansteuerung, Lämpchen etc.) genutzt oder einfach entfernt werden
*Integrierter programmierbarer Mini-Lautsprecher, um Töne auszugeben
*1 Reset-Taster
*5 Taster für beliebige Verwendung. Sie belegen nur einen analogen Port!
*5 V Spannungsstabilisierung mit 2 A Belastbarkeit, auch herausgeführt für Erweiterungen; Eingangsspannung gegen Verpolung geschützt
*RS232 mit normgerechtem Pegelwandler (MAX232) - PC direkt anschließbar
*Batteriespannung kann im Programm abgefragt werden
*ISP-Programmierschnittstelle für übliche AVR-Programmieradapter (10polig)
*Betriebsspannung wahlweise zwischen 7 und 18V (empfohlen 7 bis 14 V) - wahlweise auch höhere Motorspannung bis 24 V möglich)
*Sehr kompakt, nur halbes Europaformat nach Roboternetz-Norm (ca. 100x75mm)
*I2C-Bus, über den zahlreiche Erweiterungsplatinen anschließbar sind (z.B. Sprachausgabe RN-Speak, Relaisboard RN-Relais, Servoboards, LCDs uvm.)
*Programmierbar in zahlreichen Sprachen, z.B. Basic (BASCOM Compiler, eingeschränkt bis 4K wird mitgeliefert), C (C-Compiler GCC wird mitgeliefert), Assembler, Pascal
*Deutsche Doku mit Basic-Programmbeispiel
*Preiswerter Bausatz erhältlich - einfacher Aufbau
*Kein Starter- oder Applikationsboard notwendig - bereits alles integriert!
*alle wichtigen Bauteile gesockelt, somit auch bei falscher Beschaltung durch Einsteiger immer kostengünstig reparierbar (einfach neues IC einstecken)

http://www.robotikhardware.de/bilder/rncontro4.jpg

==Belegung der RN-Control Steckklemmen==
Um auch schnell und praktisch mit RN-Control experimentieren zu können, verfügt dieses Board über Steckklemmen die alle Ports herausführen. 0,5mm Drähte lassen sich dort direkt einstecken, so das Sensoren und dergleichen schnell und einfach verdrahtet werden können. Die genaue Belegung lässt sich in nachfolgendem Ausschnitt aus dem Bestückungsplan gut entnehmen.

[[Bild:rncontrolsteckklemmen.gif|center]]

==Steckerbelegung und Jumper-Funktionen==
Erläuterung der Anschlüsse, Regler und Kurzschlussbrücken

{|{{Blauetabelle}}
|'''Anschluss-Bezeichnung'''
|'''Erläuterung'''
|-
|'''Port A'''
|Digitaler I/O und analoger Port (PA 0 bis PA7 und ADC0 bis ADC7)
Über eine Steckklemme werden hier die 8 Portleitungen PA0 bis PA 7 zur Verfügung gestellt. PA7 befindet sich dabei ganz links und PA0 ganz rechts. Anschlußdrähte können einfach eingesteckt werden, indem man mit einem Kugelschreiber oder Schraubenziehen den oberen weißen Hebel etwas nach unten drückt.
Die Ports PA7 bis PA0 können sowohl als normaler I/O-Port (Ein- und Ausgabeport) oder als AD-Port´s programmiert werden. Somit könnten also auch bis zu 8 Spannungen quasi gleichzeitig gemessen werden.

Ist der Kurzschlusstecker UREF eingesteckt, dann können Spannungen bis zu 5V gemessen werden. Ist UREF offen, dann können Spannungen nur bis 2,5V gemessen werden. Durch geeignete Spannungsteiler kann der Meßbereich natürlich beliebig erhöht werden.

Achtung: Die zulässige Höchstspannung 2,5V oder 5V darf am Port nicht überschritten werden, dieses würde den Port zerstören!

Vorbelegung:
Port PA7 wird auch für die Tastenabfrage genutzt. indem über einen Spannungsteiler verschiedene Spannungen per Tastendruck angelegt werden (siehe Schaltplan).
Solange keine Taste gedrückt ist, ist dieser jedoch frei Verfügbar.
Port PA6 wird über einen Spannungsteiler (22k und 5,1K) zur Batteriespannungsmessung benutzt (siehe Schaltplan und Demoprogramm) wenn der Kurzschlusstecker UMESS eingesteckt ist. Durch entfernen dieses Steckers steht der Port zur freien Verfügung.

Der komplette Port steht auch nochmals über die Buchsenleiste JP2 zur Verfügung. Auch dort können Drähte zum experimentieren eingesteckt werden (möglichst 0,6mm²).
|-
|'''Port B'''
|Digitale I/O Port B (PB0 bis PB 7)
Über einen Wannenstecker werden gemäß der Roboternetz-Definition 8 I/O Portleitungen mit Sonderfunktionen als auch GND und +5V bereitgestellt.

Die genaue Belegung sieht wie folgt aus:
<pre>
Pin 1 PB0 / T0 / XCL / wird vom Motortreiber für Motor 2 Kanal 1 genutzt
Pin 2 PB1 / T1 / wird vom Motortreiber für Motor 2 Kanal 2 genutzt
Pin 3 PB2 / AIN0 / INT2 / wird auch vom I2C-Bus genutzt
Pin 4 PB3 / AIN1 / OC0
Pin 5 PB4 / SS
Pin 6 PB5 / MOSI / wird auch vom ISP Anschluss genutzt
Pin 7 PB6 / MISO / wird auch vom ISP Anschluss genutzt
Pin 8 PB7 / SCK / wird auch vom ISP Anschluss genutzt
Pin 9 GND
Pin 10 +5V
</pre>
Durch entfernen des Motortreiber IC´s aus der Fassung, steht PB0 und PB1 zur freien Verfügung.

Der komplette Port steht auch nochmals über die Buchsenleiste JP3 zur Verfügung. Auch dort können Drähte zum experimentieren eingesteckt werden (möglichst 0,6mm²).
|-
|'''Port C'''
|Digitale I/O Port C (PC0 bis PC 7)
Über einen Wannenstecker werden gemäß der Roboternetz-Definition 8 I/O Portleitungen mit Sonderfunktionen als auch GND und +5V bereitgestellt.

Die genaue Belegung sieht wie folgt aus:
<pre>
Pin 1 PC0 / SCL wird vom I2C-Bus genutzt
Pin 2 PC1 / SDA wird vom I2C-Bus genutzt
Pin 3 PC2 / TCK
Pin 4 PC3 / TMS
Pin 5 PC4 / TDO
Pin 6 PC5 / TDI
Pin 7 PC6 / TOSC1 / wird vom Motortreiber für Motor 1 Kanal 1 genutzt
Pin 8 PC7 / TOSC2 / wird vom Motortreiber für Motor 1 Kanal 2 genutzt
Pin 9 GND
Pin 10 +5V
</pre>
Über den 8 fachen DIP Schalter können den Ports auch LED´s zugeschaltet werden! Die LED´s leuchten wenn Port LOW-Zustand annimmt!

Durch entfernen des Motortreiber IC´s aus der Fassung, steht PC6 und PC7 zur freien Verfügung.
Der komplette Port steht auch nochmals über die Buchsenleiste JP4 zur Verfügung. Auch dort können Drähte zum experimentieren eingesteckt werden (möglichst 0,6mm²).
|-
|'''Port D'''
|Digitale I/O Port D (PD0 bis PD 7)
Über einen Wannenstecker werden gemäß der Roboternetz-Definition 8 I/O Portleitungen mit Sonderfunktionen als auch GND und +5V bereitgestellt.

Die genaue Belegung sieht wie folgt aus:
<pre>
Pin 1 PD0 / RXD / wird für RS232 Schnittstelle genutzt
Pin 2 PD1 / TXD / wird für RS232 Schnittstelle genutzt
Pin 3 PD2 / INT0
Pin 4 PD3 / INT1
Pin 5 PD4 / OC1B / wird für PWM Motor 1 benutzt (Geschwindigkeitsregelung)
Pin 6 PD5 / OC1A / wird für PWM Motor 2 benutzt (Geschwindigkeitsregelung)
Pin 7 PD6 / ICP
Pin 8 PD7 / OC2
Pin 9 GND
Pin 10 +5V
</pre>
Durch entfernen des Motortreiber IC´s aus der Fassung, steht PD4 und PD5 zur freien Verfügung.
Der komplette Port steht auch nochmal über die Buchsenleiste JP5 zur Verfügung. Auch dort können Drähte zum experimentieren eingesteckt werden (möglichst 0,6mm²).
|-
|'''I2C-Bus'''
|I2C-Bus
Über diesen Bus lassen sich zahlreiche Erweiterungen an dieses Board anschließen. Zum Beispiel werden auf der Seite robotikhardware.de passende Boards mit Sprachausgabe, Relais, Schrittmotorsteuerung etc. angeboten.
Aber auch dieses Board kann selbst als Slave-Board, also als Erweiterung an ein anderes Hauptboard angeschlossen werden.
Der I2C-Bus benötig nur 2 Leitungen für alle Funktionen. Entsprechend der Roboternetz-Norm wird hier ein 2x5 poliger Stecker angeschlossen. Die Belegung entspricht exakt der anderer Roboternetz Boards.
<pre>
Pin 1 SCL (Taktleitung)
Pin 3 SDA (Datenleitung)
Pin 5 +5V
Pin 7 +5V
Pin 9 Batteriespannung
Pin 2,4,6,8 GND
Pin 10 INT
</pre>

INT - Diese Leitung kann von allen I2C-Bus Erweiterungen genutzt
werden um den Hauptcontroller darüber zu informieren das sich Daten (z.B. von Sensoren) verändert haben. In diesem Fall wird die Leitung solange auf Masse gelegt bis der entsprechende I2C-Baustein ausgelesen wird.
Die Controller muß also immer alle I2C-Bausteine auslesen solange diese Leitung auf Masse liegt. Diese Leitung ist mit Port PD2 verbunden

Die PIN´s 5,7,9 und 10 können über herausnehmbare Kurzschlussbrücken (Jumper JP6) vom Board getrennt werden. Dies ist zum Beispiel dann notwendig, wenn bereits ein anderes Masterboard die Spannungen auf den Bus legt. Es darf immer nur ein Board die Spannungen bereitstellen.
|-
|'''ISP'''
|ISP – IN SYSTEM PROGRAMMING
Über diesen Anschluß kann der Controller auf dem Sprachboard mit einem Standard ISP-Kabel direkt an einen Parallelport des PC´s angeschlossen und programmiert werden.
Die Belegung des ISP-Anschlusses ist zu dem weit verbreitetet STK200 Programmier Dongle kompatibel. Ein entsprechender Dongle kann man sich entweder selber basteln (siehe Artikel „ARV Einstieg leicht gemacht“ unter www.roboternetz.de) oder fertig bestellen (z.B. www.robotikhardware.de).
<pre>
Pin 1 MOSI
Pin 2 VCC
Pin 3 Nicht belegt
Pin 4 GND
Pin 5 RESET
Pin 6 GND
Pin 7 SCK
Pin 8 GND
Pin 9 MISO
Pin 10 GND
</pre>
|-
|'''Power'''
|Spannungsversorgung
Über diese Schraubklemme wird das Board mit Spannung versorgt. Es reicht eine unstabilisierte Gleichspannung von 7 bis 14V aus (max. 18V wenn Kühlkörper verwendet wird)
+ und – sind auf der Platine markiert. Das Board ist jedoch auch gegen ein verpolen geschützt, so das nichts kaputt geht!
|-
|'''Motoren'''
|Motoren
Über diese 4 polige Schraubklemme können zwei Getriebemotoren (jeweils die beiden linken oder rechten Kontakte) oder ein Schrittmotor angeschlossen werden.
Der Motortreiber kann jedoch auch für andere Dinge genutzt werden, z.B zum Ansteuern von Relais, Lämpchen etc. verwendet werden. Die Belastbarkeit liegt bei 1A. Sollen größere Motoren angeschlossen werden, so kann z.B. über den I2C-Port eine andere Endstufe angeschlossen werden.
|-
|'''JP6'''
|I2C-Bus Belegung
Über drei Kurzschlussstecker können wahlweise die Bateriespannung (UB), +5V sowie INT mit dem I2C-Bus verbunden werden. Wenn INT nicht benötigt wird, kann man diesen Jumper offen lassen. Somit hat man einen Port zusätzlich frei zur Verfügung
Möchte man das Board über den I2C-Bus mit Spannung versorgen, dann kann man UB oder +5V Jumper einstecken. In diesem Fall braucht/darf keine Spannung an dem Power Schraubklemen angelegt werden. Möchte man umgekehrt andere Boards über den I2C-Bus mit Spannung versorgen, dann müssen die Jumper UB und/oder +5V eingesteckt werden.
Durch diesen Jumper ist man für alle Fälle gerüstet. Bei älteren RN-Control Versionen mußte man dazu noch das Kabel ändern.
|-
|'''JP8'''
|Über diesen Stecker kann die stabilisierte 5V Logikspannung für Erweiterungen oder Experimente entnommen werden. Wird mehr als 500mA entnommen, so sollte der Spannungsregler mit einem kleinen Kühlkörper versehen werden.
|-
|'''UREF'''
|Referenzspannung
Über eine Kurzschlussstecker kann hier die Referenzspannung von 5V eingestellt werden. Wird der Stecker entfernt, so kann an den analogen Ports nur bis 2,5V gemessen werden (jedoch mit höherer Genauigkeit).
Sicherheitshalber sollten Sie den Stecker anfangs eingesteckt lassen! Wird er entfernt, so sollte man daran denken das auch die Batteriespannung über einen analogen Port gemessen wird. Diese darf dann nicht viel höher als 13V sein!
|-
|'''UMOT'''
|Motorspannung
Wenn dieser Kurzschlussstecker eingesteckt wird, dann wird die volle Batteriespannung auch für die Motoren benutzt. Ansonsten könnte man über einen PIN dieses Jumpers auch eine höhere Versorgungsspannung für die Motoren nutzen. Dazu sollte sie aber nochmals in den Schaltplan schaun.
In der Regel sollte hier ein Jumper eingesteckt sein!
|-
|'''UMESS'''
|Batteriespannungsmessung
Wenn diese Kurzschlussbrücke gesteckt ist, dann wird über Port PA6 die Batteriespannung überwacht. Ansonsten ist der Port frei!
|-
|'''S1'''
|DIP Schalter
Mit einem kleinen Schraubenzieher kann über diesen 8 poligen Schalter den Portleitungen PC0 bis PC7 eine LED zugeschaltet werden. Die LED´s leuchten immer dann wenn der Port LOW (0 Pegel) führt.
Wenn die LED auf Off geschaltet wird, so kann die LED über eine Drahtbrücke von JP7 mit einem anderen Port verbunden werden.
|-
|'''RS232'''
|PC kompatible RS232 Schnittstelle
Über ein Adapterkabel kann die serielle Schnittstelle des PC direkt mit dem Board verbunden werden. Dies ist dann sinnvoll, wenn Fehler in Programmen gesucht . Einfache PRINT Anweisungen werden von einem Terminalprogramm angezeigt.
Hier kann Hyperterminal von Windows oder das eingebaute terminalprogramm von Bascom empfohlen werden.

Die Belegung ist kompatibel zum Conrad Roboter CCRP5:
<pre>
Pin 1 RX
Pin 2 GND
Pin 3 TX
</pre>
Ein geeignetes Anschlußkabel kann schnell selbst angefertigt werden oder gibt es bei robotikhardware.de bereits fertig
|-
|'''JP7'''
|Über diese Buchse sind alle LED´s ganz einfach durch Einstecken eines Drahtes beschaltbar.
Bedenken muß man dabei das die Anode über einen Vorwiderstand immer mit 5V verbunden ist. Die LED leuchtet also nur wenn sie mit der Drahtbrücke auf GND bzw. einen Port mit 0 Pegel gelegt wird.
|-
|'''JP1'''
|Buchsenleiste die dreimal +5V und drei mal GND für Experimente bereitstellt
|-
|'''JP2'''
|Buchsenleiste die den gesamten Port A für steckbare Drähte bereitstellt
|-
|'''JP3'''
|Buchsenleiste die den gesamten Port B für steckbare Drähte bereitstellt
|-
|'''JP4'''
|Buchsenleiste die den gesamten Port C für steckbare Drähte bereitstellt
|-
|'''JP5'''
|Buchsenleiste die den gesamten Port D für steckbare Drähte bereitstellt
|-
|'''TASTER T1 bis T5'''
|Stehen zur freien Verfügung
Die Abfrage ist im Demoprogramm beschrieben
|}

==Stückliste==
Bauteil Wert Beschreibung Reichelt Best.Nr.
C1 100n Keramik Kondensator KERKO100N
C2 100n Keramik Kondensator KERKO100N
C3 22pf Keramik Kondensator KERKO-500 22p
C4 22pf Keramik Kondensator KERKO-500 22p
C5 4,7uF Elko SM 4,7/50RAD
C6 4,7uF Elko SM 4,7/50RAD
C7 4,7uF Elko SM 4,7/50RAD
C8 4,7uF Elko SM 4,7/50RAD
C9 1uF Elko SM 1,0/63RAD
C10 100n Keramik Kondensator KERKO100N
C11 100n Keramik Kondensator KERKO100N
C12 100n Keramik Kondensator KERKO100N
C13 1000uF Elko RAD 1000/35
C14 100n Keramik Kondensator KERKO100N
C15 100n Keramik Kondensator KERKO100N
C16 100n Keramik Kondensator KERKO100N
C17 220uF Elko RAD 220/35
C18 100n Keramik Kondensator KERKO100N
D1 1N4148 Diode 1n 4148
D2 BYV27 Diode BYV 27/200
I2C-BUS I2C Wannenbuchse WSL 10G
IC1 MAX232 RS232 Treiber MAX 232 CPE
IC2 7805 Spannungsregler 78S05
IC3 L293D Motortreiber L 293 D
IC4 MEGA16-P Atmel Mega 16 oder 32 ATMEGA 16-16
ISP AVR-ISP Wannenbuchse WSL 10G
JP1 Kontaktbuchse (manuell kürzen) SPL20
JP2 Kontaktbuchse (manuell kürzen) SPL 20
JP3 Kontaktbuchse (manuell kürzen) SPL 20
JP4 Kontaktbuchse (manuell kürzen) SPL 20
JP5 Kontaktbuchse (manuell kürzen) SPL 20
JP6 Stiftleiste Stiftl. 2x50g (teilen)
JP7 Kontaktbuchse (manuell kürzen) SPL 20
JP8 Stiftleiste LU 2,5 MS2
LED1 Leuchtdiode Low LED 3MM 2MA GN
LED2 Leuchtdiode Low LED 3MM 2MA GN
LED3 Leuchtdiode Low LED 3MM 2MA GN
LED4 Leuchtdiode Low LED 3MM 2MA GN
LED5 Leuchtdiode Low LED 3MM 2MA GN
LED6 Leuchtdiode Low LED 3MM 2MA GN
LED7 Leuchtdiode Low LED 3MM 2MA GN
LED8 Leuchtdiode Low LED 3MM 2MA GN
MOTOREN Schraubklemme 4 polig AKL 101-04
PORTA Steckklemme 8 polig WAGO 233-508
PORTB Wannenbuchse WSL 10G
PORTC Wannenbuchse WSL 10G
PORTD Wannenbuchse WSL 10G
POWER Schraubklemme 2 polig AKL 101-02
Q1 Quarz 16 Mhz 16-HC18
R1 100k Widerstand 100k 1/4W 100k
R2 1k Widerstand 1k 1/4W 1k
R3 10k Widerstand 10k 1/4W 10k
R4 1k Widerstand 1k 1/4W 1k
R5 1k Widerstand 1k 1/4W 1k
R6 1k Widerstand 1k 1/4W 1k
R7 1k Widerstand 1k 1/4W 1k
R8 1k Widerstand 1k 1/4W 1k
R9 22k Widerstand 22k 1/4W 22k
R10 5,1k Widerstand 5,1k 1/4W 5,1k
R11 10k Widerstand 10k 1/4W 10k
R12 10k Widerstand 10k 1/4W 10k
R13 10k Widerstand 10k 1/4W 10k
R14 10k Widerstand 10k 1/4W 10k
RESET TASTER3301 Minitaster liegend TASTER 3301
RN1 Widerstandsnetzwerk SIL 9-8 1,0k
RS232 Stiftleiste 3 polig LU 2,5 MS3
S1 DIP Schalter 8 polig NT08
SPEAKER F/CM12P Mini Piezo Lautsprecher SUMMER EPM 121
T1 TASTER3301 Minitaster liegend TASTER 3301
T2 TASTER3301 Minitaster liegend TASTER 3301
T3 TASTER3301 Minitaster liegend TASTER 3301
T4 TASTER3301 Minitaster liegend TASTER 3301
T5 TASTER3301 Minitaster liegend TASTER 3301
UMESS Stiftleiste LU 2,5 MS2
UMOT Stiftleiste LU 2,5 MS2
UREF Stiftleiste LU 2,5 MS2

==Basic Beispieltestprogramm==
<pre>
'###################################################
'rncontroltest.BAS
'für
'RoboterNetz Board RN-CONTROL ab Version 1.1
'Das neue preiswerte Controllerboard zum Experimentieren

' Achtung:
' Diese Demo ist mit Bascom Compiler 1.11.7.7 getestet

'
'Aufgabe:
' Dieses Testprogramm testet gleich mehrere Eigenschaften auf dem Board
' Den verschiedenen Tasten sind bestimmte Funktionen zugeordnet
' Taste 1: Zeigt Batteriespannung über RS232 an
' Taste 2: Angeschlossene Motoren beschleunigen und abbremsen
' Taste 3: Einige Male Lauflicht über LEDs anzeigen. Am I2C-Bus
' darf in diesem Moment nichts angeschlossen sein
' Taste 4: Zeigt analoge Messwerte an allen Port A PINs über RS232 an
''Taste 5: Zeigt digitalen I/O Zustand von PA0 bis PA5 an

' Sehr gut kann man aus dem Demo auch entnehmen wie Sound ausgegeben wird,
' wie Tasten abgefragt werden und wie Subroutinen und Funktionen angelegt werden

'Autor: Frank
'#######################################################

Declare Sub Batteriespannung()
Declare Sub Motortest()
Declare Sub Lauflicht()
Declare Sub Showporta()
Declare Sub Showdigitalporta()
Declare Function Tastenabfrage() As Byte

$regfile = "m32def.dat"
' bei Mega 16 $regfile = "m16def.dat"
$framesize = 32
$swstack = 32
$hwstack = 32

Dim I As Integer
Dim N As Integer
Dim Ton As Integer

$crystal = 16000000 'Quarzfrequenz
$baud = 9600

Config Adc = Single , Prescaler = Auto 'Für Tastenabfrage und Spannungsmessung

Config Pina.7 = Input 'Für Tastenabfrage
Porta.7 = 1 'Pullup Widerstand ein

Const Ref = 5 / 1023 'Für Batteriespannungsberechnung

Dim Taste As Byte
Dim Volt As Single

' Für Motorentest
'Ports für linken Motor
Config Pinc.6 = Output 'Linker Motor Kanal 1
Config Pinc.7 = Output 'Linker Motor Kanal 2
Config Pind.4 = Output 'Linker Motor PWM
'Ports für rechten Motor
Config Pinb.0 = Output 'Rechter Motor Kanal 1
Config Pinb.1 = Output 'Rechter Motor Kanal 2
Config Pind.5 = Output 'Rechter Motor PWM
Config Timer1 = Pwm , Pwm = 10 , Compare A Pwm = Clear Down , Compare B Pwm = Clear Down
Pwm1a = 0
Pwm1b = 0
Tccr1b = Tccr1b Or &H02 'Prescaler = 8

I = 0
Sound Portd.7 , 400 , 450 'BEEP
Sound Portd.7 , 400 , 250 'BEEP
Sound Portd.7 , 400 , 450 'BEEP
Print
Print "**** RN-CONTROL 1.4 *****"
Print "Das neue Experimentier- und Roboterboard"
Print "Weitere passende Zusatzboards bei www.robotikhardware.de"
Print
Do

Taste = Tastenabfrage()
If Taste <> 0 Then

Select Case Taste
Case 1
Call Batteriespannung 'Taste 1 Zeigt Bateriespannung über RS232 an
Case 2
Call Motortest 'Taste 2 Motoren beschleunigen und abbremsen
Case 3
Call Lauflicht 'Einige Male Lauflicht über LEDs anzeigen.
'Am I2C-Port darf in diesem Moment nichts angeschlossen sein
Case 4
Call Showporta 'Zeigt Messwerte an allen Port A PINs
Case 5
Call Showdigitalporta 'Zeigt digitalen I/O Zustand von PA0 bis PA5 an

End Select
Sound Portd.7 , 400 , 500 'BEEP
End If

Waitms 100
Loop

End

'Diese Unterfunktion fragt die Tastatur am analogen Port ab
Function Tastenabfrage() As Byte
Local Ws As Word

Tastenabfrage = 0
Ton = 600
Start Adc
Ws = Getadc(7)
' Print "Tastenabfrage anpassen!ADC Wert ws=" ; Ws
If Ws < 500 Then
Select Case Ws
Case 400 To 450
Tastenabfrage = 1
Ton = 550
Case 330 To 380
Tastenabfrage = 2
Ton = 500
Case 260 To 305
Tastenabfrage = 3
Ton = 450
Case 180 To 220
Tastenabfrage = 4
Ton = 400
Case 90 To 130
Tastenabfrage = 5
Ton = 350
' Case Else
' Print "Tastenabfrage anpassen!ADC Wert ws=" ; Ws
End Select
Sound Portd.7 , 400 , Ton 'BEEP

End If

End Function

'Diese Unterfunktion zeigt Batteriespannung an
Sub Batteriespannung()
Local W As Word
Start Adc
W = Getadc(6)
Volt = W * Ref
Volt = Volt * 5.2941
Print "Die aktuelle Spannung beträgt: " ; Volt ; " Volt"

End Sub

'Testet Motoren und Geschwindigkeitsreglung
Sub Motortest()
'Linker Motor ein
Portc.6 = 1 'bestimmt Richtung
Portc.7 = 0 'bestimmt Richtung
Portd.4 = 1 'Linker Motor EIN

'Rechter Motor ein
Portb.0 = 1 'bestimmt Richtung rechter Motor
Portb.1 = 0 'bestimmt Richtung rechter Motor
Portd.5 = 1 'rechter Motor EIN

I = 0
Do
Pwm1a = I
Pwm1b = I
Waitms 40
I = I + 5
Loop Until I > 1023

Wait 1
Do
Pwm1a = I
Pwm1b = I
Waitms 40
I = I - 5
Loop Until I < 1
Pwm1a = 0 'Linker Motor aus
Pwm1b = 0 'rechter Motor aus
End Sub

' Einige Male Lauflicht über LEDs anzeigen. Am I2C-Port darf in diesem
' Moment nichts angeschlossen sein
Sub Lauflicht()

Config Portc = Output
Portd = 0
For N = 1 To 10
For I = 0 To 7
Portc.i = 0
Waitms 100
Portc.i = 1
Next I
Next N
Config Portc = Input
End Sub

'Zeigt die analogen Messwerte an Port A an
Sub Showporta()
Local Ws As Word

Config Porta = Input
For I = 0 To 5 ' Alle internen Pullup Widerstände ein, bis auf Batteriespannungsmessungsport
Porta.i = 1
Next I

Print
Print "Ermittelte Messwerte an Port A:"
For I = 0 To 7 ' Alle Eingänge inkl. messen
Start Adc
Ws = Getadc(i)
Volt = Ws * Ref
Print "Pin " ; I ; " ADC-Wert= " ; Ws ; " bei 5V REF waeren das " ; Volt ; " Volt"
Next I
End Sub

'Zeigt den Zustand einiger freier I/O von Die Analogen Messwerte An Port A An
Sub Showdigitalporta()
Local Zustand As String * 6
Config Porta = Input
For I = 0 To 5 ' Alle internen Pullup Widerstände ein, bis auf Batteriespannungsmessungsport
Porta.i = 1
Next I

Print
Print "Ermittelter I/O Zustand Port A:"
For I = 0 To 5 ' Alle Eingänge inkl. messen
If Pina.i = 1 Then
Zustand = "High"
Else
Zustand = "Low"
End If
Print "Pin " ; I ; " I/O Zustand= " ; Pina.i ; " " ; Zustand
Next I
End Sub
</pre>

==Programmierung per Druckerport, [[USB]] oder [[RS232]]==
RN-Control wird üblicherweise mit einem sogenannten [[ISP]]-Dongel programmiert. Die günstigste Ausführung gibt es für einen parallelen Druckerport, siehe auch unter [[AVR-ISP Programmierkabel]]. Etwas teurer aber auch schneller ist ein USBISP-Dongel. Wie genau der Ablauf vonstatten geht wird in der Anleitung (PDF-Dokument siehe Links) genau beschrieben.
Seit März 2007 wird RN-Control aber auch mit installiertem Bootloader ausgeliefert. Dies hat den Vorteil, dass das Board nun auch ohne ISP-Dongel per RS232 Kabel mit dem Bascom Compiler programmiert werden kann. Dies ist recht angenehm für Notebook Besitzer, die keinen parallelen Druckerport haben und denen der USBISP-Dongel am Anfang etwas zu teuer erscheint. Nähere Hinweise dazu sind ebenfalls in der überarbeiteten PDF-Anleitung (siehe Weblinks unten auf der Seite) zu finden.

==Anschlussbeispiele==
Da sich Einsteiger mit dem Anschluss von Sensoren oder Verbrauchern manchmal etwas schwer tun, hier eine Skizze, wie man zum Beispiel bestimmte Dinge wie Entfernungssensoren, Servos, Lämpchen oder Helligkeits- bzw. Temperatursensoren anschließen könnte. Bei den Lämpchen sollte man beachten, dass sie zusammen weniger als 1A Strom benötigen, da ansonsten der zuständige Treiber (Motortreiber L293D) überhitzt würde. Natürlich könnte man auch größere Lasten schalten, indem man z.B. statt den Lämpchen Relais anschließt. Auch viele weitere Sensoren könnten natürlich an die noch freien Ports angeschlossen werden, beachten muss man nur, ob der Sensor einen Digital- oder Analogport benötigt.
Das Servo wird in der Skizze mit 5V versorgt, daher sollte man den Spannungsregler mit einem Kühlkörper versehen.

[[Bild:rncontrolanschlussbeispiel.png|center]]

[[Bild:srf10anrncontrol.gif|framed|center|Ultraschallmodul am I2C-Bus (mehrere möglich)]]

[[Bild:kompassmodul_an_rncontrol.jpg|framed|center|Auch ein elektronischer Kompass läßt sich leicht am I2C Bus anschließen]]

[[Bild:drehgeber_an_rncontrol.gif|center|framed|Beispielschaltung wenn man lediglich die Drehzahl ohne Drehrichtung auswerten möchte. Als Widerstand hat sich 330 Ohm als gut erwiesen. Als Sensor wurde hier ein GP1A30 verwendet]]

[[Bild:rnjoycontrolanrncontrol.jpg|center|framed|Auch passende Joysticks/Joypads lassen sich einfach an RN-Control anschließen]]

[[Bild:rn_adapter_mit_rncontrol.jpg|center|framed|Über Adapter lassen sich die Wannenstecker auch durch Steckklemmen mit Portüberwachung ersetzen. Dadurch wird die Verdrahtung noch flexibler]]

[[Bild:rndigicontrol.jpg|thumb|center|Digitalanzeige an RN-Control]]

[[Bild:srf02_i2c_rncontrol.jpg|framed|center|Der neue Ultraschallsensor SRF02 im I2C Mode über Adapter an RN-Control]]

[[Bild:srf02_an_rncontrol_rs232mode.jpg|framed|center|Der neue Ultraschallsensor SRF02 im RS232 Mode an RN-Control]]

[[Bild:rn_lcd_adapter_rncontrol.gif|framed|center|Ein LCD mittels RN-LCDAdapter angeschlossen.]]

==Projektbeispiel mit RN-Control==

[[Bild:allwetterbot.jpg|center]]

==Siehe auch==
*[[Beispiel Drehzahlmessung mit RN-Control]]
* [[Ultraschall SRF10 an RN-Control]]
* [[Ultraschallsensor SRF02 am RN-Board]]
* [[Bascom und Kompass CMPS03]]
* [[RN-Digi|4 stellige Digitalanzeige an RN-Control]]
* [[LCD an RN-Control]]
*[[Bascom]]
*[[Bascom - Erstes Programm in den AVR Controller übertragen]]
*[[RN-Definitionen]]
*[[RN-Board FAQ-Seite]]
* [[Avr]]
* [[RN-Mega8]]
* [[RNBFRA-Board]]

==Weblinks==
* [http://www.roboternetz.de/phpBB2/dload.php?action=file&file_id=138 Ausführliche Anleitung und Bauplan als PDF-Datei]

{{Platinenservice|http://www.robotikhardware.de}}
{{Bausatzservice|http://www.robotikhardware.de}}
{{Fertigservice|http://www.robotikhardware.de}}

[[Category:Robotikeinstieg]]
[[Category:Praxis]]
[[Category:Elektronik]]
[[Category:Projekte]]
[[Category:Microcontroller]]
[[Kategorie:Quellcode Bascom]]

PIC Assembler

2007-05-06T19:48:22Z

Andy: /* Variablen */

= Einladung zur Diskussion... =

Es wird hier versucht die ASM Programmierung von PIC Mikrocontrollern möglichst kurz zu beschreiben.

Damit der enstehende Artikel wirklich nützlich wird, ist Ihre Mitwirkung nötig. Bitte schreiben Sie uns Ihre Meinung, was eventuell noch geändert (z.B. ergänzt) werden soll in diesem Thread:

http://www.roboternetz.de/phpBB2/viewtopic.php?p=271211#271211

Die Autoren bedanken sich im voraus für jeden Beitrag mit Vorschlägen !

= Einführung =

== Bit, Byte, Nibble, Bin und Hex ==

Ein Mikrocontroller (kurz: µC) kann eigentlich nur durch ein Portpin eine Spannung einlesen bzw. ausgeben. Er kann aber nur erkennen, ob eine Spannung vorhanden ist oder nicht. Wenn fast keine Spannung vorhanden ist erkennt er das als 0 und wenn eine Spannung fast so gross, wie seine Versorgungsspannung anliegt, als 1.

Genauso bei der Ausgabe, wenn er 0 ausgibt ist auf dem Portpin fast keine Spannung, wenn 1, eine Spannung fast gleich gross seiner Versorgungsspannung. Und das ist ein Bit, die kleinste Menge einer Information. Das Bit ist binär, d.h. es kann nur zwei unterschiedliche Werte haben: 0 oder 1.

Wenn wir gleichzeitig (parallel) 8 Bits haben, dann ist es ein Byte, das 256 Bitkombinationen von 00000000b bis 11111111b enhält, weil ein Bit (X) auf jeder Stelle 0 bzw. 1 sein kann.

<table border=0 cellpadding=3 cellspacing=2>

<tr>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
</tr>

<tr>
<td colspan=4 align=middle bgcolor=#007fff>High Nibble </td>
<td colspan=4 align=middle bgcolor=#ff8305>Low Nibble </td>
</tr>
<tr>
<td colspan=8 align=middle bgcolor=#810f40> Byte </td>
</tr>
</table>

Das "b" bedeutet, dass es sich um binäre (kurz: bin) Darstellung (auch Zahl genannt) handelt. Binäre Zahlen sind aber lang, weil jedes Bit eine Stelle benötigt.

Um die Schreibweise zu verkürzen, wurden hexadezimale (kurz: hex) Zahlen eingeführt. Zuerst wurde ein Byte auf zwei 4-Bit Halbbytes (Nibbles) verteilt und danach ein Nibble als Ziffer genommen. Weil 4 Bits 16 Kombinationen ergeben, haben die Ziffer 0 bis 9 aus dem Dezimalsystem (d) nicht ausgereicht und wurden um Buchstaben A bis F erweitert. Die hexadezimalen Zahlen haben ein "h" Zeichen am Ende. Für die Zahlen 0 bis 9 sind die (h) und
(d) Zeichen nicht nötig, da sie beide gleich den entsprechenden bin Zahlen sind.

Die Umwandlung zwischen bin, hex und dec Zahlen für ein Nibble zeigt folgende Tabelle:

0b = 0h = 0d 100b = 4h = 4d 1000b = 8h = 8d 1100b = Ch = 12d
1b = 1h = 1d 101b = 5h = 5d 1001b = 9h = 9d 1101b = Dh = 13d
10b = 2h = 2d 110b = 6h = 6d 1010b = Ah = 10d 1110b = Eh = 14d
11b = 3h = 3d 111b = 7h = 7d 1011b = Bh = 11d 1111b = Fh = 15d

Damit kann ein Byte mit zwei hex Ziffern definiert werden z.B. 1100 0011b = C3h. Für zwei Bytes braucht man 4 hex Ziffern z.B.

101 0111 1010 1001b = 57A9h, u.s.w. Für MPASM wird sehr oft die Schreibweise für hex Zahlen 0x57A9 oder 0xC3 benutzt.

So wie im Dezimalsystem werden führende Nullen nicht geschrieben. Bei einer Wandlung bin->hex fängt man immer von der rechten Seite der bin Zahl an, da die Anzahl führender Nullen unbekannt ist.

== Speicher und Register ==

Als Speicher bezeichnet man das Teil der Hardware, in das eine Information geschrieben, gespeichert und von dort wieder ausgelesen werden kann.

Es gibt eigentlich nur zwei Arten von elektronischen Speichern: flüchtige und nichtflüchtige. Die Information die sich im flüchtigen Speicher befindet, geht verloren, wenn die Versorgungsspannung des Speichers unterbrochen oder abgeschaltet wird. Bei PICs ist es Datenspeicher (RAM).

Wenn die Versorgungsspannung vom nichtflüchtigen Speicher abgeschaltet wird, ist die gespeicherte Information zwar momentan nicht lesbar, bleibt aber erhalten und sobald der Speicher wieder mit Spannung versorgt wird, kann sie ausgelesen werden. Ein PIC hat zwei solche Speicher: Programmspeicher (Flash) und EEPROM.

Der wichtigste Unterschied zwischen den Speicherarten ist, dass die flüchtigen direkt (sehr schnell) beschreibbar sind, dagegen das Beschreiben des nichtflüchtigen Speichers spezielle Algorithmen benötigt, die im Vergleich zu direkten Zugriffen langsamer sind. Beim Auslesen gibt es praktisch keinen Unterschied.

Speicher besitzen eine bestimmte Menge von s.g. Speicherstellen. Jede Speicherstelle hat eine individuelle Adresse und kann eine binäre Information mit bestimmter Anzahl von Bits abspeichern.

PIC Prozessoren haben drei Arten von Speicher, wegen verschiedener Anwendung, auch unterschiedliche Struktur. Die beiden Speicher für Daten (RAM und EEPROM) haben jeweils 8 Bit Breite und Programmspeicher (Flasch) bei Mid-Range hat 14-bitige Speicherstellen. Die Anzahl den Speicherstellen im bestimmten Speicher ist vom PIC-Typ abhängig.

Eine 8-bitige Speicherstelle im RAM wird bei PICs Register genannt und kann so skizziert werden:

<table border=0 cellpadding=3 cellspacing=2>

<tr>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
</tr>

<tr>
<td> MSB </td>
<td colspan=6></td>
<td> LSB </td>
</tr>

<tr>
<td bgcolor="#007fff">bit 7</td>
<td bgcolor="#007fff">bit 6</td>
<td bgcolor="#007fff">bit 5</td>
<td bgcolor="#007fff">bit 4</td>
<td bgcolor="#007fff">bit 3</td>
<td bgcolor="#007fff">bit 2</td>
<td bgcolor="#007fff">bit 1</td>
<td bgcolor="#007fff">bit 0</td>
</tr>

<tr>
<td colspan=4 align=middle bgcolor=#ff8305>High Nibble </td>
<td colspan=4 align=middle bgcolor=#ff8305>Low Nibble </td>
</tr>
<tr>
<td colspan=8 align=middle bgcolor=#810f40> Byte </td>
</tr>
</table>

Bit 7 wird als hochwertigstes (MSB = Most Significant Bit) und bit 0 als niederwertigstes (LSB = Least Significant Bit) bezeichnet. Jedes Bit im Register (X) kann gleich 0 bzw. 1 sein. In einem Register existieren immer 8 Bits also auch führende Nullen. Zum Beispiel die hex Zahl 3 sieht im PIC Register so aus: 00000011.

Um ein Datenbyte in ein Register zu schreiben oder aus einem Register zu lesen, muss zuerst das Register durch seine Adresse gewählt werden. Dafür gibt es beim PIC folgende Möglichkeiten:

Direkte Adressierung per absolute Adresse: movwf 0x20

Direkte Adressierung per vorher definiertem Namen des Registers (z.B. Temp equ 0x20): movwf Temp

Indirekte Adressierung durch "FSR" Register, in das die absolute Adresse des Registers "Temp" eingeschrieben wird. Durch Zugriff mittels "INDF" Register wird auf die Speicherstelle zugegriffen, die durch das Register "FSR" adressiert wird. (INDF ist dabei kein real in Hardware implementiertes Register.) Wie vorher wurde "Temp equ 0x20" definiert und weiter:

movlw Temp ;ins W-Register wird die absolute Adresse des Registers "Temp" geladen
movwf FSR ;diese Adresse wird ins "FSR" Register kopiert
movf INDF,0 ;der Wert aus dem indirekt adressierten Register "Temp"
;wird ins W-Register geladen.

Weil in jedem 14-bittigen Befehl, der mit Datenspeicher verbunden ist, für die Adresse des ansprechenden Registers nur 7 Bits existieren, die bis zur Adresse 7Fh (128d) Register direkt ansprechen können, ist bei PICs der Datenspeicher (RAM) in s.g. Bänke verteilt.

Für Auswahl einer Bank sind zwei Bits "RP0" und "RP1" im "STATUS" Register zuständig. Die Anzahl der Bänke und ihre Verwendung ist von der gesamten Größe des RAMs abhängig und kann dem Datenblatt des PICs entnommen werden. Siehe: [[#Speicherbankorganisation|Speicherbankorganisation]]

== Prozessor ==

Der Prozessor von Mid-Range PICs gehört zu den RISC (Reduced Instruction Set Computer) Prozessoren und man hat nur 35 Befehle zu erlernen, was seine Programmierung im Vergleich zu anderen µCs deutlich vereinfacht. Jeder Befehl benötigt im Programmspeicher nur eine Speicherstelle und im Quellcode nur eine Zeile. Die Ausführung des Befehls dauert, abhängig vom Befehl, 1 bis 2 Prozessortakte.

Die Prozessoren der Mid-Range Serie von Microchip sind alle in der "Harvard"-Architektur gefertigt. Das bedeutet, dass Datenspeicher und Programmspeicher einen eigenen Bus zur CPU (Central Processing Unit) besitzen. Der Vorteil zur "von Neumann"-Architektur ist, dass sich die Busgrößen damit unterscheiden können. Das ermöglicht eine größere Bandbreite.

Der Befehl (beim PIC 14 bit) kann in nur einem Takt verarbeitet werden. Daher kommt auch das Aufteilen der Ausführung des Befehls in 4 verschiedene Vorgänge. Wärend der neue Befehl eingelesen ("fetch") wird, wird der vorige gerade gelesen ("read") und der vorvorige verarbeitet ("execute") und der vorvorvorige schreibt gerade in den Datenspeicher ("write"). Das heißt, 4 Befehle werden jeweils um einen Oszillatortaktzyklus verschoben gleichzeitig verarbeitet.

Das geschieht in vier Perioden des Oszillators. Deswegen entspricht die Taktfrequenz der CPU der durch 4 geteilten Frequenz des Oszillators.

CPU Vorgang Richtung Speicher
------------------------------------------------- -
1.Befehl lesen (fatch) <------- Flash |
2.Daten lesen (read) <------- RAM | 1 Prozessortakt =
3.Daten verarbeiten (execute) | 4 Oszillatortakte
4.Daten schreiben (write) -------> RAM |
-

Nur o.g. CPU Vorgänge sind direkt möglich. Es können deswegen keine Befehle aus dem RAM oder EEPROM ausgeführt werden. Um ein Databyte aus einem RAM Register in ein anderes zu kopieren, muss er zuerst aus dem ersten RAM Register in das W-Register (eigenen s.g. Arbeitsregister des CPU) und erst davon in das zweite RAM Register kopiert werden.

Der Prozessor hat kleinen eigenen Speicher, der weder zum Programmspeicher noch zum Datenspeicher gehört. Er besteht aus dem Programmzähler PC (programm counter) und dem Stapel (stack).

In dem PC befindet sich die 13-Bittige Adresse des momentan ausfürbaren Befehls. Nach der Ausführung jedes Befehls wird der PC um 1 erhöht und "zeigt" somit auf den nächsten Befehl im Programmspeicher, der zum Ausführen wäre. Wenn der nächste Befehl aber ein Sprung ("call") ist, wird die Adresse aus dem Befehl genommen. Nach dem Sprung wird das Programm bis zum Befehl "return" ausgeführt und danach muss der Prozessor zurückspringen, und zwar, genau zur nächsten Adresse im Programmspeicher nach dem "call" Befehl. Damit es möglich wäre, wird vor dem Sprung die Adresse aus dem PC "auf dem Stapel gelegt" (gespeichert). Für den Rücksprung wird die abgelegte Adresse "aus dem Stapel genommen" (vom Stapel in den PC geladen).

Der Stapel kann aber nur 8 Adressen speichern, deswegen dürfen nur 8 nacheinander folgende "call" Befehle benutzt werden. Sonst findet der Prozessor nicht mehr zurück und in die "Nirvana" springt, was einen Absturz des Programms bedeutet.

Das Lesen/Schreiben aus/in den EEPROM Speicher ist mit Hilfe speziellen Register und Unterprogrammen bei allen Mid-Range PICs möglich. Der Lese und Schreibzugriff auf den Programmspeicher ist aber nur bei wenigen PIC-Typen (z.B. PIC16F87X) möglich. Dies ermöglicht ein "sich selbst Programmieren", was bei Bootloadern genutzt wird.

== Assembler ==

Die Maschinensprache, auch Assembler oder kurz ASM genannt, ist eine Sprache die nur eine bestimmte CPU versteht. Für einen Menschen ist sie unverständlich, da sie nur aus 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 einen CPU hat somit ein "Namen", der aus der englischen Sprache stammt. Siehe: [[#Kurzübersicht Assembler Befehle|Kurzübersicht Assembler Befehle]]

Obwohl sie 200 bis 1000 mal schneller als die meisten Hochsprachen ist, wird sie, wegen des grossen Aufwands bei der Erstellung von umfangreichen Programmen, selten benutzt. Man findet sie aber oft in fast allen Hochsprachen, in eigebundenen Funktionen, überall dort wo die Hochsprachen zu langsam sind oder die nötigen Aufgaben nicht unterstützen (z.B. Maus in Q-Basic).

ASM eignet sich sehr gut für kleine Anwendungen (meistens Steuerungen) mit µC, weil nur bei dieser Programmiersprache ein direkter Zusammenhang zwischen einem Bit im Programm und einer Spannung am I/O Pin besteht.

Dank der integrierten oder an Portpins angeschlosenen Hardware und dem entsprechenden Program kann ein µC umfangreiche Aufgaben realisieren, die fast unbegrenzt und schwer vorstellbar sind.

Die Aufgabe eines ASM-Programmierers ist, ein Programm zu schreiben, das das Assemblerprogramm (z.B. MPASM) fehlerfrei in die Machinensprache assembliert ("übersetzt"), die dann eine bestimmte CPU "versteht". Sie endet eigentlich erst dann, wenn das geschriebene Programm so wie geplant funktioniert.

Die beste Methode um ASM Programmierung zu lernen ist einfach mit den Befehlen, wie mit "LEGO" Bausteinen, zu spielen. Der PIC kann durch ein Programmfehler nicht kaputtgehen. Vorsicht ist nur bei der angeschlossener Hardware nötig, da ein Fehler den PIC oder die Hardware sogar "töten" kann.

Weil ASM Programme nicht besonders durchschaubar sind, wurde als Hilfsmittel ein Programmablaufdiagramm (kurz: PAD) erfunden. Bei der 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 [http://gputils.sourceforge.net/ GPASM]) von dem für Menschen noch verständlichen Code in die Maschinensprache assembliert 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 Homepage des Herstellers von PICs [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en019469&part=SW007002] runtergeladen werden. Es muss zuerst vom Downloads die "MPLAB IDE v7.50 Full Zipped Installation" runtergeladen und erst danach können gewählte Programme (z.B. nur MPASM) intalliert werden. Für MPASM benutzer werden auch folgende ".pdf" Dateien empfohlen:

MPASM/MPLINK User's Guide (2628 KB) [Benutzerhandbuch]

MPASM™/MPLINK™ PICmicro® Quick Chart (81 KB) [Kurzübersicht]

Nach dem Eischalten der Betriebsspannung des µC, fängt der CPU an, sich im Programmspeicher befindliches Programm mit dem Befehl, der an der Adresse 0 steht, auszuführen.

Aber wann das Programm endet? Natürlich wenn die Versorgungsspannung abgeschaltet wird. Nein! Das ist die einfachste Lösung um ein laufendes Programm an zufälliger Stelle zu unterbrechen,
aber keine, um es an einer definierten Stelle zu beenden.

Wenn an den µC angeschlossene externe Hardware (z.B. Grafikdisplay), eine bestimmte Befehlsfolge vor dem Abschalten benötigt oder wichtige Daten (in EEPROM oder Flash) abgespeichert werden sollen, darf die Spannung erst dann abgeschaltet werden, wenn die CPU eine Meldung ausgibt, dass sie sich schon auf der "STOP" Stelle des Programms befindet. Es muss auch
definiert werden (z.B. durch eine Tastenkombination), wann die CPU zum letzten Fragment des ASM Programms vor dem "STOP" gehen soll.

== Grundbeschaltung ==

Der Prozessor von einem PIC kann sofort nach dem Einschalten der Versorgungsspannung (z.B. + 5V DC) arbeiten. Allerdings nur, wenn er den Takt, in dem er die Befehle ausführen soll, vorgegeben hat. Manche PICs besitzen einen internen RC-Oszillator, (z.B. PIC12F629, PIC16F630, PIC16F628, u.s.w.). Bei diesen reicht es bereits Spannung anzulegen und sie laufen bereits.
Die meisten haben ihn aber nicht (z.B. PIC16F84, PIC16F870, u.s.w.) und brauchen fürs Funktionieren zusätzliche Bauteile. Grundsätzlich gibt es mehrere Möglichkeiten:

* Quarz oder Keramik-Resonator + 2 Kondensatoren (LP,HS oder XT)
* Keramik-Resonator mit integrierten Kondensatoren (HS oder XT)
* Quarzoszillator (EC); genau und stabil
* Widerstand + Kondensator (RC); keine hohe Frequenzstabilität

Die entsprechenden Bauteile werden an die Pins OSC1/OSC2 angeschlossen, um den notwendigen Prozessortakt zu erzeugen. Im Konfiguration-Word "__config" muss noch angegeben werden, welcher Oszillator verwendet wird.

Desweiteren existiert ein MCLR-Pin, der beim PIC einen Neustart (=Reset) auslösen kann (Low-Pegel). Diesen Pin sollte man, wenn er in "__config" aktiviert ist, über einen Widerstand (pull-up) an Versorgungsspannung legen, damit der PIC anfängt, sein Programm abzuarbeiten. Der Anschluss wird auch für die Programmierung benötigt. Beim sog. High-Voltage-Programming wird MCLR auf ca. 12-14 Volt gelegt, um den PIC in den Programmiermodus zu schalten. Bei manchen PICs kann dieser Anschluss auch als normalen I/O Pin eingestellt werden. In dem Fall, bei ICSP Benutzung, soll noch eine Diode zwischen den pull-up und Versorgungsspannung angeschlossen werden, um die an MCLR Pin angeschlossene Hardware während der Programmierung zu schützen.

Bei externen Oszillatoren bleibt der Pin OSC2 nicht angeschlossen und kann als I/O benutzt werden. Falls ein interner Oszillator benutzt wird, können beide OSC Pins als I/O dienen.

Damit ein Programm zuverlässig ausgeführt werden kann, muss die Versorgungspannung störungsfrei sein. Dafür wird ein Keramik-Vielschicht-Kondensator 100 nF möglichts am kürzesten direkt zwischen VDD und VSS Pins geschaltet.

Folgende Skizzen zeigen die Grundbeschaltung eines PICs:

{|
|-
|
[[Bild:Pic-entstoer.png|thumb|160px|Entstörkondensator beim PIC]]
|
[[Bild:Qz-os.png|thumb|160px|Quarz ]]
|
[[Bild:Qos-os.png|thumb|160px|externer Quarzoszillator]]
|
[[Bild:Rc-os.png|thumb|160px|externer RC-Oszillator]]
|}

== Konfiguration ==

Die Konfiguration eines PICs wird beim "brennen" fest programmiert. Sie ist eigentlich für fast jeden PIC-Typ anders. Um Probleme zu vermeinden, muss sie für bestimmten PIC aus einer im MPASM Verzeichnis enthaltenen Datei "PXXFXX.INC" entnommen werden. Die Erklärung der Optionen befindet sich im entsprechenden Datenblatt unter "Special Features of the CPU"

Als Beispiel für PIC16F84 haben wir in der Datei "P16F84.INC":

;==========================================================================
;
; Configuration Bits
;
;==========================================================================

_CP_ON EQU H'000F'
_CP_OFF EQU H'3FFF'
_PWRTE_ON EQU H'3FF7'
_PWRTE_OFF EQU H'3FFF'
_WDT_ON EQU H'3FFF'
_WDT_OFF EQU H'3FFB'
_LP_OSC EQU H'3FFC'
_XT_OSC EQU H'3FFD'
_HS_OSC EQU H'3FFE'
_RC_OSC EQU H'3FFF'

Wobei:

_CP_ON - Programmspeicher ist vorm Auslesen geschützt
_CP_OFF - Programmspeicher kann ausgelesen werden (ist nicht geschützt)
_PWRTE_ON - Das Programm wird mit Verzögerung von ca. 72 ms nach dem Einschalten gestartet
_PWRTE_OFF - Das Program wird sofort nach dem Einschalten gestartet
_WDT_ON - Watchdog Timer ist aktiv
_WDT_OFF - Watchdog Timer ist unaktiv

Die alle folgende Optionen beziehen sich an den Oszillatortyp:

_LP_OSC - Oszillator bis ca. 200 kHz (z.B. Uhrenquarz 32768 Hz)
_XT_OSC - Oszillator bis ca. 3,5 MHz
_HS_OSC - Oszillator über 3,5 MHz (z.B. 4 MHz)
_RC_OSC - Externer RC Oszillator

Die Konfiguration wird im Quellcode (*.asm Datei) mit Direktive "__config" definiert, z.B. so:

__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _XT_OSC

Alle Optionen müssen groß geschrieben sein, genauso wie in der "*.inc" Datei.

== Wahl des PICs ==

Es gibt PIC µC die in der Typenbezeichnung den Buchstaben "C" oder "F" haben.

Die älteren mit "C" haben EPROM Programmspeicher und die gibt es in zwei Versionen: ohne und mit Fenster (aus Quarz-Glass) fürs Löschen des EPROMs mit UV Strahlung. Bei denen ohne Fenster kann der Programmspeicher nur einmal beschrieben und nicht mehr gelöscht werden.

Die neuen mit "F" besitzen einen Flash-Programmspeicher, der bis zu 100 000 mal mit angelegter Spannung gelöscht und danach neu beschrieben werden kann.

Für die Wahl eines PICs für bestimmte Anwendung wichtig sind:

- Max. Taktfrequenz des Prozessors.

- Grösse des Datenspeichers (für Variablen).

- Grösse des Programmspeichers (für Programm).

- Integrierte Hardware (Komparatoren, A/D Wandler, Timer, USART, I²C, SPI, PWM, u.s.w.).

- Freie I/O Pins für externe Hardware (Display, Tasten, u.s.w.).

- Vorhandene Betriebspannung (Netzteil, Akku, Batterie).

In der Praxis wird meistens für die Programmerstellung ein grösserer PIC genommen (wenn möglich pinkompatibler z.B. PIC16F628 für PIC16F84 oder PIC16F630 für PIC12F629) und erst nach der Optimierung des lauffägiges Programms, der tatsächlich nötige, da seine Parameter am Anfang nur geschätzt werden können. Wenn man viele Programme für verschiedene PICs entwickelt, wäre der größte PIC16F877 mit 20 MHz max. Taktfrequenz optimal.

Diese Lösung hat auch den Vorteil, dass während der Programmerstellung kurze Hilfsprogramme (z.B. PIC Trainer) in den Programmspeicher kopiert und benutzt werden können, da sie sowohl ein bischen Programmspeicher und RAM als auch 2 freie I/O Pins fürs PIC Miniterminal brauchen.

= Programm =

== Allgemeines ==

Jedes Program kann man in kleinere Fragmente unterteilen, die auf bestimmte Weise miteinander verknüpft sind und gemeinsam die Aufgabe des Programms erfüllen. Das wichtigste Teil eines Programms ist das s.g. Hautprogram (kurz:HP), das eine führende Rolle spielt. Dem HP sind fast 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 komplizierter, da ein UP auch ein oder mehrere UPs nacheinander aufrufen kann. Ganz unten sind die UP1s, die ganz einfache Sachen erledigen. Höher ist 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 ohne Tricks maximal bis zu 8 Ebenen benutzt werden, da auf dem Stapel (stack) nur max. 8 Rücksprungadressen abgespeichert werden können. Siehe hierzu: [[#Prozessor|Prozessor]] und [[#Programmspeicher|Programmspeicher]]

<center>
[[Bild:HP-UP.png|Hauptprogramm - Unterprogramm]]
</center>

Jedes UP kann jederzeit aufgerufen werden, je nach dem was gerade eledigt werden muss. Weil das nicht egal ist, welches UP aufgerufen wird, da jedes nur eine bestimmte Funktion im Programm hat, muss der Programmierer dafür sorgen, dass alles richtig nach Programablaufdiagramm, und nicht chaotisch, abläuft.

Die Programmierung in ASM ist ähnlich 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 Programm kopieren oder einbinden und ein geeignetes HP, das sie aufruft, schreiben.

Ein ASM Programm (Quellcode) muss in einer Texdatei mit der Endung ".asm" in der vom Assemblerprogramm erwarteten Form verfasst werden, um die fehlerfreie Konvertierung in die Maschinensprache (Assemblierung) zu gewährleisten. Dieser Prozess verläuft in der Form eines Dialoges.

Der Programmierer schreibt und gibt es dem Assemblerprogramm zum Übersetzen. Alles was der Assembler nicht versteht oder nicht richtig ist, erscheint als Fehlermeldungen, die der Programmierer kennen muss, um die Fehler korrigieren zu können. Eine ".hex" Datei wird erst dannn erstellt, wenn das Assemblerprogramm keine Fehler mehr im Quellcode findet. Deswegen ist es sehr wichtig, sich mit dem Assemblerprogramm vertraut zu machen, um die Dialogzeit zu minimieren.

== Programmdurchlaufdiagramm ==

Der Programdurchlaufdiagram (kurz: PAD) ist eine vorläufige und laufend änderbare Stufe zwischen einer Idee und ihrer Verwirklichung. Die Kreativität des Programmierers ist nur für die Erstellung des PADs nötig. Jedes sein Symbol (ausser "Start/Stop") muss als Befehlsreihenfolge für einen bestimmten Prozessor in den Quellcode übertragen werden. Das ist aber nur reine "Übersetzung". Der Quellcode ist nur eine andere Form des PADs und hoffentlich wird es zukünftig Komputerprogramme geben, die ein PAD direkt in eine "*.hex" Datei für bestimmten Prozessor wandeln werden. Zur Zeit muss die "Übersetzung" leider vom Programmierer gemacht werden. Der PAD wird erst dann fertig, wenn nach ihm erstelltes ASM Program auf einem µC so wie gewünscht funktioniert.

Die Anschriften "Ein" und "Aus" gehören nicht zu Symbolen des PADs und wurden nur zur Erklärung benutzt.

[[Bild:PAD_beispiel.png|thumb|80px|Beispiel für ein PAD]]

Der PAD ist sehr eifach zu erstellen, weil dafür nur drei Symbole benötigt sind:
<center>
[[Bild:PAD_kurz.png|Symbole des PAD]]
</center>
Das "Start/Stopp" Symbol bedeutet, dass das gesamte Programm sich im stabilen Zustand befindet und nicht "läuft". Anstatt "Stopp" kann auch "Schlaf" (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 eines Programms, endweder in der "ja" (J) oder "nein" (N) Richtung.

Als allgemeinnutziges Standard für µCs kann man folgender PAD bezeichnen:

PAD _____
/ \
Spannung ein (Ein) ----->( Start )
\_____/
| -
V |
.---------------. |
|Initialisierung| |
'---------------' |
| |
.--------->V |
| .---------------. |
| | Hauptprogramm | |
| '---------------' |
| | |
| V |
| A |
| / \ > Gesamtes Programm
| / \ |
| /Ende \____ |
| \ ? / J | |
| \ / | |
| \ / | |
| V | |
| N| | |
`----------´ | |
V |
.---------------. |
| Beenden | |
'---------------' |
| |
V -
_____
/ \
Spannung aus (Aus) <-------------( Stopp )
\_____/

Das Hauptprogram wird in einer endlosen Schleife ausgeführt, die durch die Prüfung "Ende?" unterbrochen werden kann. In dem Fall wird vor dem Beenden des gesammten Programms noch ein UP "Beenden" ausgeführt, das z.B. Daten im EEPROM speichert.

Es ist nicht nötig, immer die Symbole zu zeichnen, man kann sie sich vorstellen und nur den Text schreiben. Die Prüfungen werden mit "?" gekenzeichnet und die Zeichen "V", "A", "<" und ">" zeigen die Richtung des weiteren Verlaufs. Dann sieht der PAD so aus:

Ein > Start
V -
Initialisierung |
.------->V |
| Hauptprogramm > Gesamtes Programm
| V |
| Ende? J > Beenden |
| N V -
| V Stopp > Aus
`--------´

Man kann auch die unbedeutenden Richtungspfeilen weg lassen:

PAD1 Ein > Start _
Initialisierung |
.------->V | Gesamtes
| Hauptprogramm | Programm
| Ende? J > Beenden _|
| N Stopp
| V V
`--------´ Aus

In der Praxis werden aus Platzgründen meistens die vereinfachten PADs benutzt. Als "movxx" wird oft ein Zeichen "->" benutzt. Zum Beispiel "A->W" bedeutet, dass der Inhalt des A Registers ins W-Register geladen (kopiert) wird. Ausserdem werden Zeichen ("+", "-", "*", "/", "^", u.s.w.) für arithmetische und ("&", "or", "xor", u.s.w.) für logische Operationen angewendet. In den Quellcode werden für diese Zeichen entsprechende Befehle geschrieben. Beispiel:

V
10h->W
W+B->B
V

wird im Quelcode so aussehen:

...........
movlw 10h
addwf B,1
...........

Siehe auch: [[#Das erste...|Das erste...]] und [[#Mausrad|Mausrad]]

Der PAD1 kann aber für Hauptprogramme, die in beliebigem Moment unterbrochen werden dürfen, deutlich vereinfacht werden, da die Prüfung "Ende?" ob das Hauptprogram beendet werden soll, und das UP "Beenden", entfallen.

Die meisten ASM Programme für µC sind deswegen nach solchem PAD erstellt:

PAD2 Ein > Start _
Initialisierung |
.------->V |
| Hauptprogramm > Gesamtes Programm
| V |
`--------´ _|

Für Testprogramme wird meistens fogender PAD angewendet, weil es ziemlich einfach festzustellen
ist (z.B. durch Stromverbrauchmessung des µCs), wann sich die CPU schon im Schlaf befindet. Erst dann, darf die Betriebspannung des µCs ausgeschaltet werden.

PAD3 Ein > Start _
Initialisierung | Gesamtes
Hauptprogramm _| Programm
Schlaf > Aus

Und eine batteriebetriebene Uhr wird überwiegend so gestaltet:

PAD4 Ein > Start _
Interrupt Initialisierung |
Timer------------------------->V > Gesamtes Programm
Hauptprogramm _|
Schlaf

In dem Fall reicht es aus, wenn der CPU jede Minute vom Timer aufgeweckt wird, um die Zeit zu aktualisieren. Eine Uhr ist immer (ausser Batteriewechsel) ununterbrochen mit Spannung versorgt.

Für komplizierte Programme ist es praktisch unmöglich ein PAD zu erstellen, in dem jeder CPU Befehl sein eigenes Symbol hat. Man beschränkt sich nur auf alle Prüfungen, die über den Lauf des Programms entscheiden, und ganze UPs (z.B. "Initialisierung") nur als ein Symbol verwendet. Für jedes UP wird dann ein eigener PAD erstellt.

Das Erstellen von PAD bei ASM Programmen ist sehr wichtig und darf nicht unterschätzt werden. Je stärker ein Programmierer glaubt, dass er das ohne PAD schafft, um so mehr Zeit wird er danach bei Fehlersuche oder Änderungen im ASM Programm verlieren.

Beispiel aus dem Alltag:

"Das programm hat anfangs auf Anhieb funktioniert. Doch leider habe ich dann was geändert was ich nicht mehr weiß. Das Programm macht nun komische Sachen...... Ich kann mir nicht erklären warum, kann mir jemand helfen???"

Für einfache ASM Programme, die gut kommentiert sind, reicht es meistens aus, ein PAD nur "im Kopf" zu erstellen, aber ganz ohne PAD geht es sicher nicht.

Der PAD kann auch benutzt werden, um einen "fremden" Code verständlich zu machen. In dem Fall werden alle Befehle (Zeilen) aus der Quellcode nacheinander in PAD Symbole umgewandelt und daraus ein PAD erstellt.

== Hauptprogramm ==

Wie sein Namen schon vermuten lässt, ist das Hauptprogram das wichtigste Teil des gesamten Programms. Meistens ist es auch das kleinste Teil, vor allem, wenn die UPs sehr komplex sind. Seine Aufgabe ist die benötigte UPs in bestimmter Reihenfolge nacheinander aufzurufen, um die alle Funktionen des gesamten Programms zu realisieren.

Das HP ist meistens als endlose Schleife, wie im PAD2, aufgebaut. Weil die endlose Schleife sehr schnell läuft, werden alle durch die UPS realisierten Aufgaben quasi gleichzeitig ausgeführt. Wenn es unerwünscht ist, müssen einige UPs als Verzögerungen realisiert werden.

Typischer PAD für ein HP sieht so aus:

Haupt .--->V
| UP1
| UP2
| ...
| UPn
| V
`----´

In den Quellcode wird es so eigeschrieben:

Haupt call UP1
call UP2
...........
call UPn
goto Haupt

In der Praxis wird das HP schrittweise erstellt. Am Anfang wird sich nur ein Aufruf vom UP im HP befinden und die folgenden kommen nach Erstellung und Prüfen weiteren UPs dazu, bis das HP fertig wird.

== Unterprogramm ==

Unterprogramm wird durch übergeordnetes Programmteil (Aufrufer) aufgerufen und nach seinem Ausführen, wird zurück zum Aufrufer gesprungen. Der Rückkehr zum Aufrufer wird durch "return" Befehl, der sich am Ende jedes UPs befinden muss, erreicht. Und das ist der einzige Unterschied zwischen einem HP und einem UP.

Jedes UP hat folgender PAD:

vom Aufrufer ------------>V
Tun
V
zurück zum Aufrufer <----------return

Ein HP von einem ASM Programm kann in anderem, mehr umfangreichem ASM Program als UP benutzt werden, wenn der sich am Ende des HPs befindlicher Befehl "goto" durch "return" ersetzt wird. Ein Beispiel dazu:

Haupt1 call UP11 Haupt1 call UP11
call UP21 call UP21
........... -------> ...........
call UPn1 call UPn1
goto Haupt1 return

Jetzt können wir im mehr komplexen HP (Haupt) das Haupt1 als Unterprogramm aufrufen:

Haupt call UP1
call Haupt1
...........
call UPn
goto Haupt

Jedes UP kann auch von einem anderen übergeordneten UP aufgerufen werden, wenn das was es realisiert, benötigt wird.

In der Praxis wird oft ein UP von mehreren anderen UPs benutzt. Zum Beispiel um LCD Display zu steuern, brauchen wir entweder ein Befehl (Cmd) oder ein Zeichen (Data) an Display zu schicken. In beiden Fällen wird ein Byte geschickt, einmal mit RS=0 (Befehl) und einmal mit RS=1 (Zeichen) laut folgendem PAD:

"Cmd" "Data"
RS=0 RS=1
V V
`-->V<--´
"Send" Byte schicken
V
return

Das wird in den Quellcode z.B. so eingeschrieben:

Cmd bcf RS
goto Send
Data bsf RS
Send ............
return

Das UP "Send" ist den UPs "Cmd" und "Data" untergeordnet, da es von beiden benutzt wird, kann aber weder "Cmd" noch "Data" benutzen.

=== Initialisierung ===

Damit der PIC ein Programm asführen kann, muss er vollständig und richtig initialisiert werden. Deswegen als erstes UP, das von dem gesamten Programm noch vor dem HP aufgerufen wird , ist "Initialisierung" (kurz: Init)

==== Variablen ====

Weil sich nach dem Einschalten der Spannung im RAM zufällige Werte befinden, wird meistens als erstes der benutzte Bereich des RAMs (z.B. 20h bis 7Fh) gelöscht. Es wird einfach und sparsam mit einer Schleife erledigt, die indirekte Adressierung verwendet:

V
Adresse des ersten Registers in FSR laden (20h)
.-------------------->V
RAMClr |Indirekt adressierter Register löschen (INDF)
| Adresse erhöhen
| Letzte Adresse + 1 (80h) J > Return
| N
| V
`---------------------´

Es wird wie folgt in Quellcode eingeschrieben:

movlw 0x20
movwf FSR
RAMClr ,->clrf INDF
| incf FSR,1
| btfss FSR,7
`-<goto RAMClr
return

Um Anzahl den Marken (label) zu verringern, wird oft ein Symbol "$" benutzt. Es bedeutet die Adresse der aktuellen Befehlszeile. Es kann also auch so geschrieben werden:

movlw 0x20
movwf FSR
,->clrf INDF
| incf FSR,1
| btfss FSR,7
`-<goto $-3 ; springe zu aktueller Adresse -3
return

Danach können den benötigten Variablen die gewünschten Werte zugewiesen werden:

movlw 0x3C
movwf LimH
movlw 0x5A
movwf LimL
u.s.w.

Somit sind die Variablen initialisiert.

==== I/O Ports ====

Nach dem Einschalten der Spannung sind die für Komparatoren oder A/D Wandler benutzte Pins als analoge Eingänge initialisiert. Wenn sie alle als digitale I/Os verwendet werden sollen, müssen sie als solche definiert werden. Das geschieht durch Schreiben des Wertes 7 in das entsprechende Register (CMCON bzw. ADCON1):

movlw 7 b.z.w. movlw 7
movwf CMCON movwf ADCON1

Wenn einige als analoge Eingänge benutzt werden sollen, müssen die entsprechende Werte dem Datenblatt des jeweiligen PICs entnommen werden.

Danach werden alle Ports nacheinander gelöscht und die gewünschte Werte die an den Pins vor dem Start des Hauptprogramms ausgegeben werden sollen, geschrieben:

clrf PORTA
movlw 0x37
movwf PORTA
usw.

Anchliessend werden für jeden Port die Werte in TRIS Register eingeschrieben, wobei ein Bit einem Pin entspricht. Ein Pin wird in TRIS Register durch 1 als Eingang und durch 0 als Ausgang definiert. Beispielweise beim PORTB sollen B7,B5 und B3 als Eingänge und restliche Pins als Ausgänge definiert werden. Das ergibt den Wert 10101000b = A8h, der in den TRISB Register geschrieben werden muss. Weil die alle TRIS Register sich in der höheren Bank befinden, muss im STATUS-Register auf entsprechende Bank und danach zurück auf Bank 0 umgeschaltet werden. Zum Beispiel für die TRASB in der Bank1:

bsf STATUS,RP0
movlw 0xA8
movwf TRISB
bcf STATUS,RP0

Bei einem Umschalten der Bank können selbstverständlich alle TRIS Register, die in der gleichen Bank liegen, nacheinander beschrieben werden. Siehe : [[#PORTx|PORTx]] und [[#TRISx|TRISx]]

Bei dem PORTA gibt es Pins, die nur "open drain" Ausgang haben (können nur auf GND schalten) b.z.w. nur als Eingang benutzt werden können. Bei Plannung der Verwendung von PORTA muss immer im Datenblatt geprüft werden, ob sich ein bestimmter Pin für die geplannte Anwendung eignet.

==== Hardware ====

Die für ASM Programm benutzte Hardware kann auf integrierte und externe geteilt werden. Für eine Initialisierung der integrierten Hardware (Komparatoren, A/D Wandler, Timer, USART, I²C, SPI, PWM, u.s.w.), müssen entsprechende SFRs (Spezial Function Registers) laut Datenblatt des PICs definiert werden.

Die externe Hardware muss nach Datenblättern der Herstellern initialisiert werden.

=== Einlesen ===

Um ein Bit von einem Portpin einzulesen und in ein bestimmtes Register zu Kopieren wird folgender PAD benutzt, weil ein PIC kein Befehl dafür hat:

V
Bit im Zielregister löschen
Quellbit = 0 ? J >------.
N |
V |
Bit im Zielregister setzen |
V<-------------´

Wenn wir z.B. ein bit3 von PortA als bit1 in den Register Tasten kopieren wollen, dann wird es in Quellcode so geschrieben:

bcf Tasten,1
btfsc PORTA,3
bsf Tasten,1

Wenn ein ganzes Byte vom Port in das W-Register eingelesen wird, kann man den Wert gleich komplett in das Zielregister schreiben:

movf PORTA,0
movwf Tasten

=== Ausgeben ===

Um ein Bit an einem Portpin auszugeben wird ein bestimmtes Bit mit "bcf" gelöscht oder mit "bsf" gesetzt. Zum Beispiel bit4 im PORTA:

bcf PORTA,4.

Um ein Byte auszugeben wird es zuerst in das W-Register geladen und danach an den Port übergeben, z.B.:

movlw 0x12
movwf PORTA

=== Schleifen ===

Ein in ASM Programmen meist verbreitetes Codefragment ist eine Schleife.

Es kann eine endlose Schleife, die durch Prüfung einer bestimmten Bedingung (z.B. Taste) unterbrochen wird, sein:

V<-----.
Tun |
? N >--´
J
V
weiter

Es kann eine Schleife mit Schleifenzähler (z.B. Temp), die bestimmte Anzahl Durchläufe hat, sein:

V
Anzahl ins Temp laden
V<---------.
Tun |
Temp decrementieren |
Temp = 0 ? N >--´
J
V
weiter

Solche Schleifen können als UPs verwendet werden, wenn "weiter" mit "return" ersetzt wird.

Das waren Beispiele für Schleifen, die bewusst programmiert sind. Es gibt leider auch endlose Schleifen, die durch einen Fehler im Programm enstanden sind und zum "hängen" des Programms führen. Solche Schleifen sind im Programm nicht einfach zu finden, da ihre Parameter unbekannt sind. In dem Fall sehr behilflich ist der [[#PIC RAM Monitor|PIC RAM Monitor]].

=== Pause ===

Um eine Pause (Warten, Verzögerung) im Programm anzulegen wird der "nop" Befehl benutzt, während dessen Ausführung der CPU nichts macht. Mit einem "nop" kann eine Zeit gleich 4 Takten (Perioden) des Oszillators realisiert werden.

Für sehr kurze Wartezeiten benutzt man eine Reihe von nachfolgenden "nop"s. Beim einem Oszillator 4 MHz, die Ausführungszeit des Prozessors beträgt 1 µs pro "nop". Wenn z.B. 4 µs benötigt werden, werden dafür 4 "nop"s gebraucht:

...
nop
nop
nop
nop
...

Das gleiche bewirken 2 "goto"s, brauchen aber im Vergleich zu "nop"s nur die Hälfte der Bytes im Programmspeicher:

...
goto $+1
goto $+1
...

Der Befehl goto $+1 bedeutet "springe zur aktuellen Adresse + 1" (also nächster Adresse) und seine Ausführungszeit ist gleich 2 Prozessortakten.

Für kurze Zeiten werden s.g. Warteschleifen, wie im folgendem PAD benutzt:

V
n * nop
P0 laden
V<---------.
P0 decrementieren |
P0 = 0 ? N >--´
J
V

In Quellcode wird es als UP so eigeschrieben:

Warte nop Warte nop
... ...
nop nop
movlw 0xXX movlw 0xXX
movwf P0 movwf P0
Warte0 decfsz P0,1 decfsz P0,1
goto Warte0 goto $-1
return return

Der Sprung zur Marke "Warte0" ("goto Warte0") wurde in rechtem Beispiel durch "goto $-1" ersetzt.

Die gesammte Anzahl den CPU Takten (N) lässt sich aus folgender Formel berechnen:

N = 3 * P0 + 6 + n

und die Wartezeit (T) in Sekunden:

T = N * ( 4 / Fosc ), für Schätzungen T ~ 3 * P0 * ( 4 / Fosc )

Wobei:

P0 = Zahl im Register P0, 6 = Ausführungszeit von "call" (2) + "movlw" (1) + "movwf" (1) + "return" (2), n = Anzahl "nop"s, Fosc = Frequenz des Oszillators (z.B. Quartz)

Wenn in ein Register PX eine 0 eingeschrieben wird, bedeutet es, dass die decrementierung des Registers 100h = 256d Takten dauern wird, da dekrementierte 0 eine FFh = 255d ergibt. Deshalb in Warteschleifen ist die Zahl 0 die grösste (256 Dürchläufe) und 1 die kleinste. Für solche einfache Schleifen (als UP) die Wartezeit beträgt min. 9 und max. ca. 800 Prozessortakten (ohne "nop"s).

Für mittlere Wartezeiten z.B. 0,1 Sekunde werden doppelte Warteschleifen verwendet:

Warte V
n * nop
P1 laden
Warte1 V<-------------.
P0 laden |
Warte0 V<---------. |
P0 decrementieren | |
P0 = 0 ? N >--´ |
J |
V |
P1 dekrementieren |
P1 = 0 ? N >------´
J
V

Das wird in Quellcode als UP so aussehen:

Warte nop Warte nop
... ...
nop nop
movlw 0xXX movlw 0xXX
movwf P1 movwf P1
Warte1 movlw 0xXX movlw 0xXX
movwf P0 movwf P0
Warte0 decfsz P0,1 decfsz P0,1
goto Warte0 goto $-1
decfsz P1,1 decfsz P1,1
goto Warte1 goto $-5
return return

Wie vorher wurden rechts die Marken durch "$-n" ersetzt.

Die gesammte Anzahl den CPU Takten (N) lässt sich aus folgender Formel berechnen:

N = P1 * (3 * P0 + 5) + 8 + n

und die Wartezeit (T) in Sekunden:

T = N * ( 4 / Fosc ), für Schätzungen T ~ 3 * P1 * P0 * ( 4 / Fosc )

Wobei:

P0 = Zahl im Register P0, P1 = Zahl im Register P1, 8 = Ausführungszeit von "call" + "return" + 2 * ("movlw" + "movwf"), n = Anzahl "nop"s, Fosc = Frequenz des Oszillators (z.B. Quartz)

Für solche doppelte Schleifen (als UP) die Wartezeit beträgt min. 16 und max. ca. 200 000 Prozessortakten (ohne "nop"s).

Für lange Wartezeiten z.B. 1 Sekunde werden 3-fache Warteschleifen angewendet.

Solche Warteschleife ist im folgenden PAD abgebildet:

Warte V
n * nop
P2 laden
Warte2 V<-----------------.
P1 laden |
Warte1 V<-------------. |
P0 laden | |
Warte0 V<---------. | |
P0 decrementieren | | |
P0 = 0 ? N >--´ | |
J | |
V | |
P1 decrementieren | |
P1 = 0 ? N >------´ |
J |
V |
P2 dekrementieren |
P2 = 0 ? N >----------´
J
V

Das wird in Quellcode als UP so aussehen:

Warte nop Warte nop
... ...
nop nop
movlw 0xXX movlw 0xXX
movwf P2 movwf P2
Warte2 movlw 0xXX movlw 0xXX
movwf P1 movwf P1
Warte1 movlw 0xXX movlw 0xXX
movwf P0 movwf P0
Warte0 decfsz P0,1 decfsz P0,1
goto Warte0 goto $-1
decfsz P1,1 decfsz P1,1
goto Warte1 goto $-5
decfsz P2,1 decfsz P2,1
goto Warte2 goto $-9
return return

Auch hier wurden rechts die Marken durch "$-n" ersetzt.

Die gesammte Anzahl den CPU Takten (N) lässt sich aus folgender Formel berechnen:

N = P2 * [ P1 * (3 * P0 + 5) + 9 ] + 10 + n

und die Wartezeit (T) in Sekunden:

T = N * ( 4 / Fosc ), für Schätzungen T ~ 3 * P2 * P1 * P0 * ( 4 / Fosc )

Wobei:

P0 = Zahl im Register P0, P1 = Zahl im Register P1, P2 = Zahl im Register P2, 10 = Ausführungszeit von "call" + "return" + 3 * ("movlw" + "movwf"), n = Anzahl "nop"s, Fosc = Frequenz des Oszillators (z.B. Quartz)

Für solche 3-fache Schleifen (als UP) die Wartezeit beträgt min. 27 und max. ca. 50 000 000 Prozessortakten (ohne "nop"s).

Die "nop"s vor allen Warteschleifen sind nur notwendig um genaue Wartezeit einzustellen zu können. Sie können auch mit "goto $+1"s ersetzt, oder weg gelassen werden. Sie können auch innerhalb jeder Schleife eingesetzt werden, um sie deutlich zu verlängern.

Ein Beispiel:

V
n * nop
P0 laden
V<---------.
n0 * nop
P0 decrementieren |
P0 = 0 ? N >--´
J
V

Bei nur einem "nop" (n0=1) ist die max. Wartezeit ca. T ~ 4 * P0 * ( 4 / Fosc ), bei zwei (n0=2) ca. T ~ 5 * P0 * ( 4 / Fosc ) u.s.w.

Anstatt "movlw 0xXX" kann auch "movf PauseX,0" angewendet werden, wenn die Schleife mehrmals mit verschiedenen Werten P0, P1 und P2 aus den Register Pause0, Pause1 und Pause2 benutzt wird.

Für sehr lange Wartezeiten können, nach gleichem Prinzip, Warteschleifen erstellt werden, die mehr als 3 Schleifen enthalten.

=== Tabellen ===

Es gibt zwei Arten von Tabellen: Sprungtabellen (computed goto) die "goto" Befehle enthalten und Wertetabellen (lookup table) in denen feste Werte in "retlw" gespeichert sind. Der wichtigste Unterschied zwischen dennen ist, dass die Sprungtabellen steuern den Programlauf abhängig vom Inhalt des W-Registers und die Wertetabellen liefern abhängig von Inhalt des W-Registers ein Wert an den Aufrufer zurück.

Beide werden in Programmspeicher erstellt. Sie können nur bis zu 256 Speicherstellen belegen, da in den W-Register auch nur so viel veschiedenen Zahlen "passen". Sie Fangen also (fast) immer bei einer Adresse XX00h an und enden bei XXFFh. Der Hochwertige Byte "XX" der Adresse an der sich der Anfang einer Tabelle befindet, muss vor dem Einsprung in die Tabelle ins PCLATH Register eingeschrieben werden, wenn die Tabelle weit vom Aufrufer liegt. In der Praxis werden solche Tabellen am oberen Ende des Programmspeichers angelegt, damit sie den ASM Code nicht unterbrechen.

Eine Sprungtabelle wird so aufgebaut:

org (XX-1)FF <--- eine Direktive für Assemblerprogramm, wo es
die Tabelle im Programmspeicher plazieren soll
Adresse Inhalt
-------------------------
Tab1 (XX-1)FF addwf PCL,1
XX00 goto Marke0
XX01 goto Marke1
.......................
XXFE goto Marke254
XXFF goto Marke255

Und so aufgerufen:

movlw 0xXX
movwf PCLATH
movf TWert,0
call Tab1

Wobei:

0xXX = Hochwertiger Byte der Adresse von Tab1, TWert = ein Wert, der die Wahl wohin gesprungen wird bestimmt.

Nach ausführen der obiger Befehlsfolge, wird das ASM Programm z.B. für Twert=0x01 weiter ab Marke1 "laufen" bis es an "return" kommt. Dann springt es zurüch zum Aufrufer der Tabelle.

Eine Wertetabelle wird so aufgebaut:

org (XX-1)FF <--- eine Direktive für Assemblerprogramm, wo es
die Tabelle im Programmspeicher plazieren soll
Adresse Inhalt
-------------------------
Tab1 (XX-1)FF addwf PCL,1
XX00 retlw Wert0
XX01 retlw Wert1
.......................
XXFE retlw Wert254
XXFF retlw Wert255

Und so aufgerufen:

movlw 0xXX
movwf PCLATH
movf TWert,0
call Tab1

wobei:

0xXX = Hochwertiger Byte der Adresse von Tab1, TWert = ein Wert, für welchen, an den Aufrufer bestimmter Wert aus der Tabelle im W-Register zurückgeliefert wird

Wertetabelle kann auch mit Hilfe der MPASM Direktive "dt" erstellt werden. So kann man sich mehrfaches Schreiben von "retlw" Befehlen ersparen:

org 0x(XX-1)FF
Tabelle addwf PCL,1
; nachfolgend der benötigte Wert im W- Register
; vor dem Aufruf der Tabelle
dt 0x03, 0xE8 ; 0x00
dt 0x03, 0xE8 ; 0x02
dt 'M','H','z',0x00 ; 0x04
dt ' ',' ','W','A','I','T',0x00 ; 0x08
dt 'C','o','n','s','t',' ','X',0x00 ; 0x0F
dt 'C','=',0x00 ; 0x17
dt 'L','=',0x00 ; 0x1A
dt 'F','=',0x00 ; 0x1D
dt 'O','K',0x00 ; 0x20
u.s.w.

Das Lesen eines Strings muss ab entsprechendem Wert im W-Register (z.B. für "MHz" -> 0x04) anfangen und auf dem Wert 0x00 enden, der hier als Stringende dient. Einfacher ist, wenn alle Strings gleich lang sind (wie z.B. in einem Zeichengenerator fur Grafikdisplay).

=== Interrupt ===

==== Prinzip ====

Ein Interrupt (Unterbrechung) unterbricht ein laufendes Programms, wenn ein bestimmtes Ereigniss, auf das reagiert werden soll, statt gefunden hat. Die Reaktion wird in s.g. Interrupt Service Routine (kurz: ISR) definiert.

Einfach gesagt, ein Interrupt stoppt ein laufendes Programm, ruft die ISR auf und nach deren Ausführung startet das Programm wieder, ab der Zeile, vor der es durch Interrupt angehalten wurde.

.--->V
| Tun
| V
Interrupt ------>Tun-------->V
| V ISR
| Tun<--------´
| V
| Tun
| V
`----´

Damit das unterbrochene Programm nach dem Rückkehr aus der ISR weiter fehlerfrei ausgeführt werden kann, darf die ISR keine Änderungen im Programm verursachen.

Um ein Interrupt auslösen zu können, muss er in UP "Init", durch beschreiben nötigen Register (INTCON, PIR, u.s.w.) vorbereitet werden. Siehe hierzu: [[#INTCON|INTCON]] und [[#Interrupts|Interrupts]]

==== Quellen ====

Es gibt folgende Interrupt-Quellen:

- interne Hardware (z.B. ein Timer)

- externe Hardware (z.B. eine Taste)

Die alle PICs der Mid-Range Familie haben im Programmspeicher nur eine Adresse (s.g. Interrupt Vektor 0x0004), wohin im Falle eines Interrupts, gesprungen wird. Um ermöglichen den Verursacher des Interrupts zu finden, hat jede Quelle ein eigenes Interrupt Flag (IF), das gesetzt wird, wenn das Interrupt ausgelöst wird. Somit kann in der ISR nach der Prüfung der IFs auf jeden Interrupt gezielt reagiert werden.

==== Interrupt Service Routine ====

Die Interrupt Service Routine ist ein besonderes UP das immer an der Adresse 0x0004 beginnt und immer mit dem Befehl "retfie" endet. Ihr Umfang ist von der Menge der Quellen und der Reaktionen auf ihre Interrupts abhängig. Folgender PAD zeigt ein allgemeiner Aufbau der ISR:

Adresse 0x0004 Interrupts sperren ; bcf INTCON,GIE
Beeinflüsste Register sichern
Interrupt-Quelle ermitteln
Interrupt-Flag löschen
und entsprechend reagieren
Beeinflüsste Register restaurieren
zurück ins Programm springen ; retfie

Je nach Bedürfnissen, wird eine ISR nur nötige Elemente davon enthalten. Um auf alle Interrupts reagieren zu können muss die ISR vor dem nächsten Interrupt beendet werden. Da das Programm nur in den Pausen zwischen Ausführungen der ISR laufen kann, sollte die Ausführungszeit der ISR möglichst kurz sein.

Die kürzeste ISR setzt nur ein Flag ("_Fint"), das dem Programm zeigt, dass ein Interrupt statt gefunden hat. Sie eignet sich für den Fall, wenn nur eine Interrupt-Quelle erlaubt ist. Das Programm wird nur für 5 Prozessortakten unterbrochen.

0x0004 bcf INTCON,GIE ; Interrupts sperren
bcf IF ; Interrupt Flag löschen
bsf _Fint ; Flag setzen
retfie ; zurück ins Programm

Das Programm prüft das Flag "_Fint", löscht es und reagiert entsprechend. Somit kann ein Interrupt immer auf gleichen Stelle des Hauptprogramms bearbeitet werden.

Die ISR kann aber auch ein HP darstellen. Siehe hierzu: [[#Interrupts|Interrupts]]

=== Schnittstellen und Treiber ===

Als Schnittstelle wird externe Hadware, die zum Steuern eines an sie angeschlossenes "Gerätes" dient, genannt. Das ASM Programm, das die Steuerung ermöglicht ist ein Treiber. Als Beispiele siehe: [[http://www.roboternetz.de/phpBB2/viewtopic.php?t=13685]] und [http://www.roboternetz.de/phpBB2/viewtopic.php?t=22749]

== Vorlage für MPASM ==

Diese Vorlage ist nur für ASM Programme ohne Interrupts geeignet:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration
#define _DTT1 GPIO,0 ; Portpins benennen
#define _CKT2 GPIO,1
#define _T3 GPIO,2
#define _RNG GPIO,3
#define _INT GPIO,4
#define _RL GPIO,5
u.s.w.
SecondL equ 0x20 ; Variablen definieren (Register benennen)
SecondH equ 0x21
MinuteL equ 0x22
MinuteH equ 0x23
StundeL equ 0x24
StundeH equ 0x25
u.s.w
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
Haupt ............ ; hier fängt das Hauptprogramm als endlose Schleife an
Eigener Code
............
goto Haupt ; hier endet das HP, gehe zum Anfang des HPs (zurück)
UP1 ............ ; Unterprogramme
Eigener Code
............
return
############
UPn ............
Eigener Code
............
return
Init clrf GPIO ; lösche Port
bsf STATUS,RP0 ; auf Bank1 umschalten
call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; kalibriere internen RC oscillator
bcf OPTION_REG,7 ; aktiviere pull-ups
movlw 0x38 ; definiere Portpins GPIO, (z.B. 0-2 Aus- und 3-5 Eingänge)
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
movlw 7 ; schalte Komparator aus
movwf CMCON ; und definiere GPIO 0-2 als digitale I/Os
............
eigener Code
............
return ; springe zurück (zum Haupt)
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

Die Variablen können auch kürzer mit s.g. cblock definiert werden:

cblock 0x20
SecondL
SecondH
MinuteL
MinuteH
StundeL
StundeH
endc

Bei sehr vielen Variablen sind aber die Registeradressen nicht so übersichtlich.

Für Programme mit Interrupts ist diese Vorlage geeignet:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration
#define _DTT1 GPIO,0 ; Portpins benennen
#define _CKT2 GPIO,1
#define _T3 GPIO,2
#define _RNG GPIO,3
#define _INT GPIO,4
#define _RL GPIO,5
u.s.w.
SecondL equ 0x20 ; Variablen definieren (Register benennen)
SecondH equ 0x21
MinuteL equ 0x22
MinuteH equ 0x23
StundeL equ 0x24
StundeH equ 0x25
u.s.w
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
goto Haupt ; gehe zum Hauptprogramm "Haupt"
org 0x004 ; hier fängt die ISR (interrupt service routine) an
bcf INTCON,GIE ; interrupts sperren
.............
Eigener Code
.............
retfie ; hier endet die ISR, interrupts wieder erlauben
Haupt ............ ; hier fängt das Hauptprogramm als endlose Schleife an
Eigener Code
............
goto Haupt ; hier endet das HP, gehe zum Anfang des HPs (zurück)
UP1 ............ ; Unterprogramme
Eigener Code
............
return
############
UPn ............
Eigener Code
............
return
Init clrf GPIO ; lösche Port
bsf STATUS,RP0 ; auf Bank1 umschalten
call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; kalibriere internen RC oscillator
bcf OPTION_REG,7 ; aktiviere pull-ups
movlw 0x38 ; definiere Portpins GPIO, (z.B. 0-2 Aus- und 3-5 Eingänge)
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
movlw 7 ; schalte Komparator aus
movwf CMCON ; und definiere GPIO 0-2 als digitale I/Os
............
eigener Code
............
return ; springe zurück (zum Haupt)
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

== Das erste... ==

Hier wird detailiert das ganze Prozess der Erstellung eines ASM Programms beschrieben. Die Idee:

Es gibt 4 LEDs (_L1, _L2, _L3 und _L4), die mit 2 Tastern gesteuert werden sollen. Nach dem Einschalten soll keine LED leuchten. Solange der linke Taster (_T1) gedrückt ist, sollte eine leuchtende LED von links nach rechts "wandern" und von der letzten rechten Position wieder nach ganz linke "springen". Solange der rechte Taster (_T2) gedrückt ist, sollte eine leuchtende LED von rechts nach links "wandern" und von der letzten linken Position wieder nach ganz rechte "springen". Solange beide Taster gedrückt sind soll die leuchtende LED von links nach rechts und zurück "wandern".

Dafür nötige Hardware zeigt folgende Skizze:

.-----------------------------------------------.
| |
| PIC12F629 |
| |
| GPIO,3 GPIO,4 GPIO,5 GPIO,2 GPIO,1 GPIO,0|
'-----------------------------------------------'
4| 3| 2| 5| 6| 7|
| | .-. .-. .-. .-.
| | R | | R | | R | | R | |
| | 470| | 470| | 470| | 470| |
| | '-' '-' '-' '-'
\ o \ o | | | |
\ \ V -> V -> V -> V ->
\. \. - - - -
_T1 o _T2 o _L1 | _L2 | _L3 | _L4 |
| | | | | |
+-------+-------+---+---+-------+-------+
|
===
GND

Weil der Pin 4 (GPIO,3) nur einen "open drain" Ausgang hat (kann nur an GND schalten), wird er hier als Eingang benutzt.

Jetzt muss die Idee vom Programmierer in ein PAD verfasst werden, z.B. solcher:

Start
Initialisierung
.-------------->V
| _T1=0 gedrückt ? N >----.
| J |
| V |
| links->rechts "wandern" |
| V<------------´
| _T2=0 gedrückt ? N >----.
| J |
| V |
| rechts->links "wandern" |
| V<------------´
`---------------´

danach detailierter:

Start
Initialisierung
V<-------------------------------------------.
_T1=0 gedrückt ? N >---+--->_T2=0 gedrückt ? N >---+---´
J A J A
V | V |
_L1 an | _L4 an |
Warten | Warten |
_L1 aus | _L4 aus |
_L2 an | _L3 an |
Warten | Warten |
_L2 aus | _L3 aus |
_L3 an | _L2 an |
Warten | Warten |
_L3 aus | _L2 aus |
_L4 an | _L1 an |
Warten | Warten |
_L4 aus | _L1 aus |
V | V |
`------------´ `------------´

Weil der Prozessor die Befehle nacheinander liest, ist jeder Quelcode einspaltig. Um sich die "Übersetzung" des PADs in den Quelcode zu erleichtern wird er noch z.B. so umgestaltet:

Start
Initialisierung
V<-----------------+<----.
Haupt _T1=0 gedrückt ? N >---. A |
J | | |
V | | |
_L1 an | | |
Warten | | |
_L1 aus | | |
_L2 an | | |
Warten | | |
_L2 aus | | |
_L3 an | | |
Warten | | |
_L3 aus | | |
_L4 an | | |
Warten | | |
_L4 aus | | |
V<-----------´ | |
T2Test _T2=0 gedrückt ? N >---------´ |
J |
V |
_L4 an |
Warten |
_L4 aus |
_L3 an |
Warten |
_L3 aus |
_L2 an |
Warten |
_L2 aus |
_L1 an |
Warten |
_L1 aus |
V |
`------------------------´

Alle Pfeilen aus diesem PAD werden als "goto" in den Quelcode eingetragen.

Zuerst wird im MPASM Verzeichnis ein neuer Verzeichniss (z,B. "PIC Programme") angelegt und in dem Verzeichniss neue Textdatei (z.B. "Erstes.txt") erstellt. Als nächstes wird die "Vorlage für MPASM" dorthin kopiert.

Danach müssen, die im Programm benutzte Portpins und Register mit "#define" und "equ" definiert werden.

Als Initialisierung wird das UP "Init" aus der Vorlage für MPASM mit geändertem "TRISIO" Wert (0x18) übernommen. Siehe: [[#Vorlage für MPASM|Vorlage für MPASM]]

Fürs "Warten" wird eine dreifache Warteschleife verwendet. Siehe: [[#Pause|Pause]]

Die Taster werden mit "btfsc" Befehl geprüft und zum LEDs An- und Ausschalten werden Befehle "bsf" und "bcf" für ensprechenden Portpin von GPIO angewendet. Siehe: [[#Ausgeben|Ausgeben]]

Anschlessend wird alles laut PAD in die Vorlage für MPASM eingeschrieben und der Quellcode ist fertig:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration
#define _T1 GPIO,3 ; Portpins benennen
#define _T2 GPIO,4
#define _L1 GPIO,5
#define _L2 GPIO,2
#define _L3 GPIO,1
#define _L4 GPIO,0
P0 equ 0x20 ; Variablen definieren (Register benennen)
P1 equ 0x21
P2 equ 0x22
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
Haupt btfsc _T1 ; Taster _T1=0 gedrückt ?, wenn ja, überspringe "goto T2Test"
goto T2Test ; wenn nicht, springe zu "T2Test"
bsf _L1 ; schalte _L1 an (setze den Pin 2 auf "1")
call Warten ; warte ca. 0,4 s (ca. 400 000 Prozessortakten)
bcf _L1 ; schalte _L1 aus (setze den Pin 2 auf "0")
bsf _L2 ; schalte _L2 an (setze den Pin 5 auf "1")
call Warten ; warte
bcf _L2 ; schalte _L2 aus (setze den Pin 5 auf "0")
bsf _L3 ; schalte _L3 an (setze den Pin 6 auf "1")
call Warten ; warte
bcf _L3 ; schalte _L3 aus (setze den Pin 6 auf "0")
bsf _L4 ; schalte _L4 an (setze den Pin 7 auf "1")
call Warten ; warte
bcf _L4 ; schalte _L4 aus (setze den Pin 7 auf "0")
T2Test btfsc _T2 ; Taster _T2=0 gedrückt ?, wenn ja, überspringe "goto Haupt"
goto Haupt ; wenn nicht, springe zu "Haupt"
bsf _L4 ; schalte _L4 an (setze den Pin 7 auf "1")
call Warten ; warte
bcf _L4 ; schalte _L4 aus (setze den Pin 7 auf "0")
bsf _L3 ; schalte _L3 an (setze den Pin 6 auf "1")
call Warten ; warte
bcf _L3 ; schalte _L3 aus (setze den Pin 6 auf "0")
bsf _L2 ; schalte _L2 an (setze den Pin 5 auf "1")
call Warten ; warte
bcf _L2 ; schalte _L2 aus (setze den Pin 5 auf "0")
bsf _L1 ; schalte _L1 an (setze den Pin 2 auf "1")
call Warten ; warte
bcf _L1 ; schalte _L1 aus (setze den Pin 2 auf "0")
goto Haupt ; springe zu "Haupt"
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 ("Haupt"),
Init clrf GPIO ; lösche Port (setze alle werdende Ausgänge auf "0")
bsf STATUS,RP0 ; auf Bank1 umschalten
call 0x3FF ; hole Kalibrationswert (als "retlw" unter Adresse 0x3FF)
movwf OSCCAL ; und kalibriere internen RC oscillator (4 MHz)
bcf OPTION_ REG,7 ; aktiviere pull-ups für die Portpins
movlw 0x18 ; definiere Portpins GPIO,3 und 4 als Eingänge
; und restlichen als Ausgänge (00011000b)
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
movlw 7 ; schalte Komparator aus
movwf CMCON ; und definiere GPIO 0-2 als digitale I/Os
return ; springe zurück (zum Haupt)
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

Jetzt wird der Quellcode in "Erstes.asm" umbenannt. Diese "*.asm" Datei können wir dem MPASM zum "Übersetzten" geben. Nach der Assemblierung sehen wir 3 Meldungen (Messages) vom MPASM. Diese befinden sich in der vom MPASM erstellter Datei "Erstes.lst" und lauten:

Message[302]: Register in operand not in bank 0. Ensure that bank bits are correct.

Diese Meldung kann man übersetzen als:

Meldung[302]: Register im Befehl nicht in Bank 0. Vergewisse Dich, dass die Bank-Bits korrekt sind.

Wir sind sicher, dass die Register "OSCCAL", "OPTION_REG" und "TRISIO" in der Bank 1 sich befinden. Wenn man aber nicht sicher ist, soll man in Datenblatt nachschauen. Die Meldungen kommen immer für alle SFRs (Special Function Register) die sich nicht in der Bank 0 befinden und können ignoriert werden.

Am Ende der Datei "Erstes.lst" befinden sich noch einige Informationen über Programmspeicher:

Program Memory Words Used: 52 ; benutzte Speicherstellen
Program Memory Words Free: 972 ; freie Speicherstellen

und die Anzahl den eventuellen Fehlern (Errors), Warnungen (Warnings) und Meldungen (Messages):

Errors : 0
Warnings : 0 reported, 0 suppressed
Messages : 3 reported, 0 suppressed

Insgesamt werden durch MPASM 4 Dateien erstellt: "*.cod", "*.err", "*.hex" und "*.lst".

Wichtigste davon, falls wegen Fehler keine "*.hex" Datei erstellt wird, ist die "*.err" Datei, wo alles was dem MPASM nicht "passt" aufgelistet ist. In der "*.lst" Datei kann man sich ein Programm mit genauen Adressen für jeden Befehl anschauen.

Die während der Assemblierung vom MPASM generierte Datei "Erstes.hex" kann jetzt durch ein Brenner mit geeignetem Programm in den PIC Programmspeicher eingeschrieben werden.

== Für anderen PIC umschreiben ==

Die wichtigste Vorraussetzung ist, das der andere PIC2, auf dem das vorhandene ASM Programm für PIC1 laufen soll, zumindest für das ASM Programm nötige interne Hardware hat. Die Frequenz des Oszillators sollte gleich sein. Der Code benötigt ausser UP "Init" keine Änderungen.

Wenn der Port vom PIC2 anderen Namen hat, muss man das im Quellcode umdefinieren, z.B.:

#define PORTC PORTB
#define TRISC TRISB

Dann wird das Assemblerprogramm, wenn es PORTC findet, immer PORTB nehmen. Das gleiche Betrifft die "__config" Ausdrücke, die entsprechend der "*.ini" Datei für den PIC2, geändert werden müssen.

Das Assemblerprogramm findet sicher alles, was ihm nicht "passt" und bringt Fehlermeldungen, auf die man entsprechend reagieren muss.

Als Beispiel, schreiben wir "Erstes.asm" für den PIC16F84A um.

Zum Ändern sind die ersten 3 Zeilen:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration

Sie werden für den PIC16F84A so aussehen:

list P=16F84A ; Prozessor definieren
include "P16F84A.inc" ; 4.000 MHz
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _HS_OSC

Dazu muss noch "GPIO" Port umdefiniert werden, da der PIC16F84A solchen nicht hat, z.B wegen internen pull-ups auf "B":

#define GPIO PORTB
#define TRISIO TRISB

Die Hardware muss natürlich an entsprechende Pins angeschlossen werden:

_T1 auf 12 (B3), _T2 auf 13 (B4), _L1 auf 14 (B5), _L2 auf 11 (B2), _L3 auf 10 (B1) und _L4 auf 9 (B0)

Jetzt assemblieren wir die Qelldatei und der MPASM bringt in der Datei "Erstes.err" folgende Fehler:

Error[113] C:\MPASM\PICPROG\PIC16F84\ERSTES.ASM 61 : Symbol not previously defined (OSCCAL)
Error[113] C:\MPASM\PICPROG\PIC16F84\ERSTES.ASM 67 : Symbol not previously defined (CMCON)

In dem UP "Init" müssen also noch die Befehle mit "OSCCAL" und "CMCON" Register entfernt werden, da der PIC16F84A sie nicht hat:

call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; kalibriere internen RC oscillator (4 MHz)

und:

movlw 7 ; schalte Komparator aus
movwf CMCON ; und mache GPIO 0-2 als digital I/O

Weiter kann schon alles übernommen werden und die Datei "Erstes.asm" für den PIC16F84A ist fertig:

list P=16F84A ; Prozessor definieren
include "P16F84A.inc" ; 4.000 MHz
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _HS_OSC
#define GPIO PORTB ; Ports umbenennen
#define TRISIO TRISB
#define _T1 GPIO,3 ; Portpins benennen
#define _T2 GPIO,4
#define _L1 GPIO,5
#define _L2 GPIO,2
#define _L3 GPIO,1
#define _L4 GPIO,0
P0 equ 0x20 ; Variablen definieren (Register benennen)
P1 equ 0x21
P2 equ 0x22
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
Haupt btfsc _T1 ; Taster _T1=0 gedrückt ?, wenn ja, überspringe "goto T2Test"
goto T2Test ; wenn nicht, springe zu "T2Test"
bsf _L1 ; schalte _L1 an
call Warten ; warte ca. 0,4 s (ca. 400 000 Prozessortakten)
bcf _L1 ; schalte _L1 aus
bsf _L2 ; schalte _L2 an
call Warten ; warte
bcf _L2 ; schalte _L2 aus
bsf _L3 ; schalte _L3 an
call Warten ; warte
bcf _L3 ; schalte _L3 aus
bsf _L4 ; schalte _L4 an
call Warten ; warte
bcf _L4 ; schalte _L4 aus
T2Test btfsc _T2 ; Taster _T2=0 gedrückt ?, wenn ja, überspringe "goto Haupt"
goto Haupt ; wenn nicht, springe zu "Haupt"
bsf _L4 ; schalte _L4 an
call Warten ; warte
bcf _L4 ; schalte _L4 aus
bsf _L3 ; schalte _L3 an
call Warten ; warte
bcf _L3 ; schalte _L3 aus
bsf _L2 ; schalte _L2 an
call Warten ; warte
bcf _L2 ; schalte _L2 aus
bsf _L1 ; schalte _L1 an
call Warten ; warte
bcf _L1 ; schalte _L1 aus
goto Haupt ; springe zu "Haupt"
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 ("Haupt"),
Init clrf GPIO ; lösche Port (setze alle werdende Ausgänge auf "0")
bsf STATUS,RP0 ; auf Bank1 umschalten
bcf OPTION_REG,7 ; aktiviere pull-ups
movlw 0x18 ; definiere Portpins GPIO,3 und 4 als Eingänge
; und die restlichen als Ausgänge (00011000b)
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
return ; springe zurück (zum Haupt), nach der Zeile
; aus der du afgerufen wurdest
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

Man kann auch die PORTs neu definieren und das UP "Warten" für z.B. 20 MHz Quarz anpassen:

list P=16F84A ; Prozessor definieren
include "P16F84A.inc" ; 20.000 MHz
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _HS_OSC
#define _T1 PORTB,5 ; Portpins benennen
#define _T2 PORTB,4
#define _L1 PORTB,3
#define _L2 PORTB,2
#define _L3 PORTB,1
#define _L4 PORTB,0
P0 equ 0x20 ; Variablen definieren (Register benennen)
P1 equ 0x21
P2 equ 0x22
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP Init (Initialisierung) auf
Haupt btfsc _T1 ; prüfe, ob Taster T1 gedrückt ist, wenn ja, überspringe "goto T2Test"
goto T2Test ; wenn nicht, springe zu T2Test
bsf _L1 ; schalte LED1 an (setze den Pin 2 auf "1")
call Warten ; warte ca. 0,4 s (400 000 Prozessortakten)
bcf _L1 ; schalte LED1 aus (setze den Pin2 auf "0")
bsf _L2 ; schalte LED2 an (setze den Pin 5 auf "1")
call Warten ; warte
bcf _L2 ; schalte LED2 aus (setze den Pin 5 auf "0")
bsf _L3 ; schalte LED3 ein (setze den Pin 6 auf "1")
call Warten ; warte
bcf _L3 ; schalte LED3 aus (setze den Pin 6 auf "0")
bsf _L4 ; schalte LED4 ein (setze den Pin 7 auf "1")
call Warten ; warte
bcf _L4 ; schalte LED4 aus (setze den Pin 7 auf "0")
T2Test btfsc _T2 ; prüfe, ob Taster T2 gedrückt ist, wenn ja, überspringe "goto Haupt"
goto Haupt ; Wenn nicht, springe zu Haupt
bsf _L4 ; schalte LED4 ein (setze den Pin 7 auf "1")
call Warten ; warte
bcf _L4 ; schalte LED4 aus (setze den Pin 7 auf "0")
bsf _L3 ; schalte LED3 ein (setze den Pin 6 auf "1")
call Warten ; warte
bcf _L3 ; schalte LED3 aus (setze den Pin 6 auf "0")
bsf _L2 ; schalte LED2 an (setze den Pin 5 auf "1")
call Warten ; warte
bcf _L2 ; schalte LED2 aus (setze den Pin 5 auf "0")
bsf _L1 ; schalte LED1 an (setze den Pin 2 auf "1")
call Warten ; warte
bcf _L1 ; schalte LED1 aus (setze den Pin2 auf "0")
goto Haupt ; springe zu Haupt
Warten movlw 0x0A ; schreibe "0x0A" für ca. 0,4 s
movwf P2 ; ins Register P2
clrf P1 ; lösche Register P1 (schreibe "0" für 256 Durchläufe)
clrf P0 ; lösche Register P0 (schreibe "0" für 256 Durchläufe)
decfsz P0,1 ; dekrementiere P0 und überspringe nächsten Befehl bei P0 = 0
goto $-1 ; gehe zur voherigen Adresse (Befehl "decfsz P0")
decfsz P1,1 ; dekrementiere P1 und überspringe nächsten Befehl bei P1 = 0
goto $-4 ; gehe zur aktueller Adresse - 4 (Befehl "clrf P0")
decfsz P2,1 ; dekrementiere P2 und überspringe nächsten Befehl bei P2 = 0
goto $-7 ; gehe zur aktueller Adresse - 7 (Befehl "clrf P1")
return ; springe zurück zum Aufrufer ("Haupt"),
Init clrf PORTB ; lösche Port (setze alle werdende Ausgänge auf "0")
bsf STATUS,RP0 ; auf Bank1 umschalten
bcf OPTION_REG,7 ; aktiviere pull-ups
movlw 0x30 ; definiere PortB: Pins 5 und 4 als Eingänge
; und die restlichen als Ausgänge
movwf TRISB ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
return ; springe zurück (zum Haupt), nach der Zeile aus der du afgerufen wurdest
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

== Einbinden ==

Die einfachste Möglichkeit die gewünschte Programme in ein neues Programm einzubinden ist, die alle Programme in das neue Programm zu kopieren. Dafür müssen die ersten 3 Zeilen, die den Prozessor und die Konfiguration des PICs festlegen aus den eigebundenen Programmen entfernt werden. Danach müssen alle "#define", "equ" und "org" Direktiven, verglichen und wenn nötig geändert werden. Dabei hilft der MPASM mit seinen Fehlermeldungen in der Datei "*.err".

Die zweite Möglichkeit ist die gewünschte Programme als "*.asm" Dateien mit der Direktive "include *.asm" am Ende des neuen Programms vor der Direktive "end" einzubinden.

include "1.asm"
include "2.asm"
...............
include "n.asm"
end

In dem Fall gelten die gleichen o.g. Regeln wie beim direkten Kopieren. Wenn es in den eingebindenen Programmen keine "org" Direktiven gibt, dann werden die weitere Programme im Programmspeicher ab Ende des ersten Programms nacheinander plaziert.

== Fehlersuche ==

Als erstes wird an den PIC angeschlossene externe Hardware geprüft. Das sollte noch vor dem Einstecken oder Einlöten des PICs gemacht werden, da die gravierende Fehler (z.B. Kurzschlüsse, Umpolung von VCC und GND, u.s.w.) für den PIC schädlich werden können. Für einige Teile der Hardware kann entsprechende Spannung (VCC oder GND) an bestimmten Pin gelegt werden und die richtige Reaktion der Hardware optisch (z.B. für LEDs) oder akustisch (z.B. für Relais) festgestellt werden. Sonst müssen die elektrischen Verbindungen mit einem Messgerät überprüft werden.

Die Fehlersuche in der Software fängt mit der ersten und endet mit der letzten Zeile des ASM Programms. Sie läuft die ganze Zeit parallel zur Programmierung. Jedes UP soll vor dem Übertragen in den Quellcode geprüft und eventuelle Fehler beseitigt werden. Dazu arbeitet man gleichzeitig mit zwei "*.asm" Dateien, einer für die UPs und einer für das gesamte Programm. Es wird empfohlen, nach der "Initialisierung", als erstes UP, das für Ausgabegerät (z.B. Display) zu erstellen, um das funktionieren des Programms, vom Anfang an beobachten zu können.

Für die Fehlersuche in "hängenden" Programmen ist der [[#PIC RAM Monitor|PIC RAM Monitor]] unersetzlich. Weil er durch Interrupt das Programm unterbricht und auf einem Display Registerinhalte während der Unterbrechung zeigt, können alle in der endlosen Schleife sich befindliche Register schnell festgestellt werden, da nur dessen Inhalte sich ständig ändern.

Wenn aus geprüften Unterprogrammen erstelltes Programm nicht richtig funktioniert, müsste ein Fehler im PAD des Hauptprogramms sein.

== Optimierung ==
Work in Progress...
Wer sonst noch Beispiele hat, bitte hier vervollständigen...
BMS ...
=== Speicherbedarf ===
==== Programmspeicher ====
Die ersten Programme für den PIC sind natürlich einfach und kurz. Doch nach und nach werden die Codes länger und unübersichtlicher, das Brennen dauert auch umso länger. Das Programm ist zu umfangreich. Doch wo soll man etwas kürzen?

Es gibt unzählige Möglichkeiten - hier ein paar Beispiele:

===== Unterprogramme =====

Bestimmt wird man im Code immer die selben Abschnitte brauchen, zum Beispiel Warteschleifen oder ADC-Routinen, etc. Wieso sollte man diese also mehrfach (doppelt, dreifach, u.s.w.) schreiben?

Die Lösung: Der Programmteil wird als Unterprogramm benutzt. Man erstellt eine Sprungmarke (ab hier beginnt das Unterprogramm) und endet wieder mit einem "return"- oder "retlw"-Befehl.
Aufgerufen werden die Unterprogramme meistens mit dem "call"-Befehl. Es "lohnt sich" ein Codefragment als UP zu definieren erst wenn es min. 2 mal aufgerufen wird.

Ein "goto"-Befehl ist zu diesem Zweck geeignet nur, wenn der Prozessor zum letzten Aufrufer von "call" zurück springen soll, da die Rücksprungadresse vom letzten "call" auf dem Stapel (stack) abgelegt wurde. Somit kann man mehr als 8 Ebenen von UPs nutzen.

Den Unterprogrammen kann man natürlich auch Werte übergeben. Möchte man z.B. mehrere unterschiedliche Zeiten für Warteschleifen benutzen, so kann man die Parameter vor dem Aufruf des UPs in benötigte Anzahl von Register einschreben und dann das Unterprogramm mit "call" aufrufen. Das Unterprogramm verwendet dann die Zahlen von den Register. Siehe: [[#Pause|Pause]]

Um gleiche Vorgänge in mehreren Register durchzuführen (z.B. löschen) geeignet ist Anwendung von Schleifen mit bestimmter Anzahl der Abläufe und indirekter Adressierung. Siehe: [[#Variablen|Variablen]]

===== bsf und bcf =====

Bestimmt gibt es Situationen, in denen der PIC mehrere Bits an einem Port/Register setzen oder löschen muss. Z.B. wenn mehrere LEDs an einem Port ein- oder ausgeschaltet werden sollen.
Werden mehr als 2 Bits verändert, so kann man hier die "bsf"- und "bcf"-Befehle umgehen und einen kürzeren Code erstellen.

bsf PORTB,0 ;An PORTB sind 8 LEDs angeschlossen.
bsf PORTB,1 ;Es sollen die ersten 4 LEDs angeschaltet werden,
bsf PORTB,2 ;die anderen sollen ausgeschaltet werden.
bsf PORTB,3 ;links steht es mit bcf/bsf
bcf PORTB,4 ;ziemlich lang
bcf PORTB,5
bcf PORTB,6
bcf PORTB,7

movlw b'00001111' ;Das geht auch kürzer und übersichtlicher:
movwf PORTB

Man sieht - der Codeabschnitt umfasst nur noch 2 Zeilen anstatt 8. Somit braucht es weniger Speicher und wird von PIC schneller verarbeitet. Allerdings muss man aufpassen, da durch diese Routine der Inhalt des W-Registers und der Inhalt des gesamten Zielregisters verändert wird. Sollen die anderen Bits unangetastet bleiben, muss man es entweder bei den "bcf"/"bsf"-Befehlen belassen oder logische Funktionen (and bzw. or) durchführen.

===== Bit kopieren =====

;An den PIC ist ein Taster(RB0) und eine LED(RB1) angeschlossen.
;Taster: High=gedrückt Low=nicht gedrückt
;LED: High=Ein Low=Aus
;Wenn der Taster gedrückt ist, soll die LED leuchten
;wenn er nicht gedrückt ist, soll die LED nicht leuchten.
;1.Vorschlag:
btfss PORTB,0 ;ist der taster gedrückt?
goto no ;nein
bsf PORTB,1 ;ja - LED ein
goto endif ;fertig abgefragt - unten weitermachen...
no bcf PORTB,1 ;LED aus
endif

Der oben aufgeführte Code hat viele Nachteile: er ist relativ lang, braucht zwei Gotos und entspr. Sprungmarken. Ok, das ist vielleicht Erbsenzählerei, aber aus diesen 5 Zeilen kann man 3 machen.

bcf PORTB,1 ;Das Bit wird erst gelöscht
btfss PORTB,0 ;Taster gedrückt?
bsf PORTB,1 ;JA-LED an

Man geht davon aus, dass der Taster nicht gedrückt ist. Somit wird die LED erst einmal ausgeschaltet. Ist der Taster aber doch gedrückt, dann wird die LED angeschaltet.

Achtung möglicher Nebeneffekt: Wird dies in einer Schleife sehr schnell und oft ausgeführt, kann die LED flimmern oder nicht in ihrer vollen Helligkeit leuchten. Das passiert, weil ja angenommen wird, dass der Taster nicht gedrückt wird und die LED somit aus sein muss. Dann wird sie aber bei Tastendruck eingeschaltet. Somit entsteht ein schnelles ein-/ausschalten (PWM) und die LED leuchtet nicht mehr so hell.
Meist ist das aber nicht tragisch oder wird nicht unbedingt in einer Schleife sehr schnell abefragt. Siehe hierzu: [[#Einlesen|Einlesen]]

==== RAM ====

Um Anzahl benötigten Register zu sparen werden vorläufige Register (temporary) definiert, die von mehreren UPs benutzt werden. Als Beispiel, das Register "ATmp" in [[#Hex Dec Wandlung|Hex Dec Wandlung]]. Die Benutzung muss aber sehr genau nach PAD zugeteilt werden. Bei gleichzeitiger Benutzung des gleichen Registers durch mehrere UPS werden falsche Daten verarbeitet und im schlimmsten Fall können endlose Schleifen entstehen, die in Folge haben, dass das Programm nicht weiter ausgeführt wird ("hängt").

Viele im ASM Programm ungebrauchte SFRs können als "normale" Register (GPR) verwendet werden. Wenn zum Beispiel Timer1 nicht benutzt wird, können seine Register TMR1H und TMR1L für Speicherung von Daten benutzt werden. Es könnte aber gefährlich werden, wenn mehrere Programme gebindet sind. Deswegen muss es immer am Ende, beim volständigen Programm, geprüft werden, welche SFRs tatsächlich benutzt werden dürfen.

Für Konstanten (z.B. pi, ln2, Meldungen, u.s.w.), die sich im Laufe des Programms nicht ändern, kann EEPROM (mit MPASM Direktive "de") oder Programmspeicher (mit MPASM Direktive "dt") als Ablage benutzt werden. Siehe auch: [[#EEPROM|EEPROM]] und [[#Tabellen|Tabellen]]

=== Ausführungszeit ===

Alles was schnellmöglichst ablaufen soll, widersetzt sich der Optimierung des Programmspeichers.

Es können keine Schleifen und keine indirekte Adressierung benutzt werden, alles muss direkt programmiert werden.

Als Beispiel zur Verdeutlichung: Es sollen 16 Werte vom PORTA ins RAM ab Adresse 0x20 eingelesen werden.

Als Schleife mit indirekter Adressierung:

................
movlw 0x10 ;Anzahl Durchläufe
movwf Temp ;in den Schleifenzähler
movlw 0x20 ;erste Adresse
movwf FSR ;ins FSR Register
Einlesen movf PORTA,0 ;PortA ins W-Register
movwf INDF ;und ins aktuellen RAM Register
incf FSR,1 ;nächste Adresse
decfsz Temp,1 ;Temp = 0 ?
goto Einlesen ;nein, zum Einlesen
................ ;ja, weiter
Gesamtdauer: 100 Takten
Pause zwischen Einlesungen: 6 Takten
Programmspeicher Bedarf: 9 Speicherstellen
Direkt:

...............
movf PORTA,0
movwf 0x20
movf PORTA,0
movwf 0x21
movf PORTA,0
movwf 0x22
movf PORTA,0
movwf 0x23
movf PORTA,0
movwf 0x24
movf PORTA,0
movwf 0x25
movf PORTA,0
movwf 0x26
movf PORTA,0
movwf 0x27
movf PORTA,0
movwf 0x28
movf PORTA,0
movwf 0x29
movf PORTA,0
movwf 0x2A
movf PORTA,0
movwf 0x2B
movf PORTA,0
movwf 0x2C
movf PORTA,0
movwf 0x2D
movf PORTA,0
movwf 0x2E
movf PORTA,0
movwf 0x2F
...............
Gesamtdauer: 32 Takten
Pause zwischen Einlesungen: 2 Takten
Programmspeicher Bedarf: 32 Speicherstellen

Anstatt Warteschleifen (z.B. für Tastenentprellung) sollten Programmfragmente mit entsprechender Ausführungszeit benutzt werden (z.B. Ausgabe auf einem Display). Die nötige Zeit lässt sich aus mehreren UPs zusammensetzen.

Es sollte kein Prozessortakt ungenutzt bleiben.

= Mid-Range =

Zu Mid-Range gehören alle PICs mit 14-bit langen Befehlen aus den Familien 12FXXX und 16FXXX.

== Kurzübersicht Assembler Befehle ==

{|
|-
| valign=top |

{| {{Blauetabelle}}
|ADDLW||Add literal and W
|-
|ADDWF||Add W and f
|-
|ANDLW||AND literal with W
|-
|ANDWF||AND W with f
|-
|BCF||Bit Clear f
|-
|BSF||Bit Set f
|-
|BTFSC||Bit Test f, Skip if Clear
|-
|BTFSS||Bit Test f, Skip if Set
|-
|CALL||Call subroutine
|-
|CLRF||Clear f
|-
|CLRW||Clear W
|-
|CLRWDT||Clear Watchdog Timer
|}

| valign=top |

{| {{Blauetabelle}}
|-
|COMF||Complement f
|-
|DECF||Decrement f
|-
|DECFSZ||Decrement f, Skip if 0
|-
|GOTO||Go to address or label
|-
|INCF||Increment f
|-
|INCFSZ||Increment f, Skip if 0
|-
|IORLW||Inclusive OR literal with W
|-
|IORWF||Inclusive OR W with f
|-
|MOVF||Move f
|-
|MOVLW||Move literal to W
|-
|MOVWF||Move W to f
|-
|NOP||No Operation
|}

| valign=top |

{| {{Blauetabelle}}
|-
|RETFIE||Return from interrupt
|-
|RETLW||Return with literal in W
|-
|RETURN||Return from Subroutine
|-
|RLF||Rotate Left f through Carry
|-
|RRF||Rotate Right f through Carry
|-
|SLEEP||Go into standby mode
|-
|SUBLW||Subtract W from literal
|-
|SUBWF||Subtract W from f
|-
|SWAPF||Swap nibbles in f
|-
|XORLW||Exclusive OR literal with W
|-
|XORWF||Exclusive OR W with f
|}
[[:bild:pic_asm_short.jpg|Kurzübersicht zum Ausdrucken]]
|}


==Ausführliche Beschreibung zu den Befehlen==

Fast alle Befehle werden in einem Takt = 4 Oszillatortakten ausgeführt.

Aussnahmen:

"goto", "call", "return" und "retfie" benötigen wegen Zugriff auf den Programmzähler (PC) immer 2 Takten.

"btfsc", "btfss", "decfsz" und "incfsz" brauchen 1 Takt wenn der nächste Befehl ausgeführt wird b.z.w. 2 Takten wenn er überspringen wird, weil es immer anstatt des überspringenden Befehls ein "nop" ausgeführt wird.

Eine ausgegliederte Beschreibung der Befehle findet sich unter [[PIC Assemblerbefehle]]

Erklärungen zu den Verwendeten Platzhaltern:
*'''k''' stellt einen fest definierten Wert da. z.B. <tt>0x20</tt>, <tt>d'42'</tt> oder <tt>b'00101010'</tt>
*'''W''' steht für das W-Register.
*'''d''' steht für ''destination'' (Ziel). Im code wird d durch ein <tt>w</tt> bzw. <tt>0</tt> (der Wert wird in das W-Register gespeichert ) oder <tt>f</tt> bzw. <tt>1</tt> (der Wert wird in das davor definierte Register gespeichert)
*'''b''' steht für Bitnummer im Register (eine Zahl zwischen 0 und 7)
*'''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
*<tt>Schreibmaschinenstil</tt> bedeutet, dass es so im Quellcode geschrieben werden kann.

 ADDLW k ADD Literal and W - Addiere Zahl (k) und W<hr>
:Es wird die Rechenoperation <math>W+k</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|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

 ADDWF R,d ADD W and F - Addiere W und f <hr>
:Es wird die Rechenoperation <math>W+R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Dieser Befehl beeinflusst das STATUS-Register. Siehe hierzu [[#Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

 ANDLW k AND Literal with W<hr>
:Es wird bitweise die logische Funktion <math>k\ and\ W</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 Operation:
<dl><dd>
11001010 ;k
10101100 ;W-Register
-------- and
10001000 ;W-Register
</dd></dl>

 ANDWF R,d AND W with F<hr>
:Es wird bitweise die logische Funktion <math>W\ and\ R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Vergleiche ANDLW. Dieser Befehl wird benutzt zum Löschen bestimmten Bits im Register ohne restlichen Bits zu beeinflüssen.

BCF R,b Bit Clear F - Bit b im R wird gelöscht<hr>
:Mit dem Befehl <tt>BCF</tt> wird das Bit '''b''' im Register '''R''' gelöscht. Ein Beispiel:
<dl><dd>
movlw b'11111111' ;es wird b'11111111' in das W-Register geschrieben
BCF W,2 ;es wird bit 2 im W-Register gelöscht.
;das Ergebnis ist: b'11111011'
</dl></dd>

BSF R,b Bit Set F - Bit b im R wird gesetzt<hr>
:Mit dem Befehl <tt>BSF</tt> wird das Bit '''b''' im Register '''R''' gesetzt. Ein Beispiel:
<dl><dd>
clrw ;es wird b'00000000' in das W-Register geschrieben
BSF W,2 ;es wird bit 2 im W-Register gesetzt.
;das Ergebnis ist: b'00000100'
</dl></dd>

BTFSC R,b Bit Test F, Skip if Clear - Wenn das Bit b im Register R 0 ist, überspringe den nächsten Befehl<hr>
:Mit dem Befehl <tt>BTFSC</tt> kann eine Verzweigung im Programmablauf bewirkt werden. Wenn das Bit '''b''' im Register '''R''' 0 ist, wird der nächste Befehl übersprungen. Ein Beispiel:
<dl><dd>
movlw b'00000001' ;es wird die Zahl 1 in das W-Register kopiert.
BTFSC W,0 ;es wird bit 0 geprüft.
;wenn es 0 ist, wird der nächste Befehl übersprungen
goto IST_EINS ;springt zur Marke "IST_EINS" <- in diesem Fall wird dieser
;Sprungbefehl ausgeführt.
goto IST_NULL ;springt zur Marke "IST_NULL"
</dl></dd>

BTFSS R,b Bit Test F, Skip if Set - Wenn das Bit b im Register R 1 ist, überspringe den nächsten Befehl<hr>
:Mit dem Befehl <tt>BTFSS</tt> kann eine Verzweigung im Programmablauf bewirkt werden. Wenn das Bit '''b''' im Register '''R''' 1 ist, wird der nächste Befehl übersprungen. Ein Beispiel:
<dl><dd>
movlw b'00000001' ;es wird die Zahl 1 in das W-Register kopiert.
BTFSS W,0 ;es wird bit 0 geprüft.
;wenn es 1 ist, wird der nächste Befehl übersprungen
goto IST_NULL ;springt zur Marke "IST_NULL"
goto IST_EINS ;springt zur Marke "IST_EINS" <- in diesem Fall wird dieser
;Sprungbefehl ausgeführt, da der Befehl
;darüber übersprungen wurde.
</dl></dd>

CALL CALL Subroutine - Rufe Unterprogramm auf<hr>
:Mit dem <tt>CALL</tt> Befehl wird ein Unterprogramm aufgerufen. Mit dem <tt>RETURN</tt>-Befehl wird das Unterprogramm beendet und man kehrt zum Befehl nach dem <tt>CALL</tt>-Befehl zurück. Das Unterprogramm wird so definiert, dass im Quellcode der Name des Unterprogramms nicht eingerückt steht. Ein Beispiel:

<dl><dd>
movlw d'13' ;in das W-Register wird 13d geladen
CALL UP1 ;es wird das Unterprogramm "UP1" aufgerufen
movwf ergebnis ;das W-Register wird in das Register "ergebnis" kopiert.
;im Register "ergebnis" steht nun 23d

UP1 addlw d'10' ;es wird 10d zum W-Register addiert
return ;kehre zurück zum Aufrufer
</dl></dd>

CLRF R CLeaR F- Schreibe 0 in das Register R<hr>
:Das Register '''R''' wird mit Nullen gefüllt (gelöscht).

CLRW CLeaR W - Schreibe 0 in W<hr>
:Das W-Register (<tt>W</tt>) wird mit Nullen gefüllt (gelöscht).
:Der Befehl bewirkt das gleiche wie MOVLW 0 und darf im Programmen, die fur zukünftige Anwendung bei den PICs der serie 18F vorgesehen sind, nicht benutzt werden, da sie ihn nicht kennen.

CLRWDT CLeaR WatchDog Timer - Setzt den Watchdog-Timer zurück<hr>
:Es wird der WDT (Watchdog-Timer) zurückgesetzt und der Zähler des WDT auf 0 gesetzt, zusätzlich werden die STATUS-bits TO und PD gesetzt.

COMF R,d COMplement F - negiere alle bits im Register R<hr>
:Von der Binärzahl im Register '''R''' werden alle 0 mit 1 und alle 1 mit 0 ersetzt. Das Ergebnis wird entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Ein kleines Beispiel: aus <tt>AAh</tt> (<tt>10101010b</tt>) wird <tt>55h</tt> (<tt>01010101b</tt>).

DECF R,d DECrement F - Subtrahiert 1 vom Regiser f<hr>
:Vom Wert des Registers '''R''' wird 1 subtrahiert und das Ergebnis entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
:Weil es keine "echte" Substraktion ist, beeinflusst dieser Befehl das C-Flag im STATUS-Register nicht.

DECFSZ R,d DECrement F, Skip if Zero - Subtrahiert 1 vom Regiser f, überspringe wenn 0<hr>
:Vom Wert des Registers '''R''' wird 1 subtrahiert und das Ergebnis entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Der Zusatz SZ steht für ''skip if zero'', d.h. wenn das Ergebnis der Rechnung Null ist, wird der nächste Befehl übersprungen. Dieser Befehl wird für Schleifen mit bestimmter Anzahl der Durchläufe benutzt.

GOTO GO TO address - Gehe zu Adresse/Sprungmarke<hr>
:Nach dem GOTO Befehl wird das Programm ab der Adresse weiter ausgeführt, die nach dem GOTO-Befehl steht. Diese Adresse wird durch so genannte Sprungmarke definiert, welche, im Gegensatz zu den Befehlen nicht eingerückt im Quellcode stehen.

INCF R,d INCrement F - Addiere 1 zum Register f<hr>
:Zum Wert des Registers '''R''' wird 1 addiert und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
:Weil es keine "echte" Addition ist, beeinflusst dieser Befehl das C-Flag im STATUS-Register nicht.

INCFSZ R,d INCrement F, Skip if Zero - Addiere 1 zum Regiser f, überspringe wenn 0<hr>
:Zum Wert des Registers '''R''' wird 1 addiert und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Der Zusatz SZ steht für ''skip if zero'', d.h. wenn das Ergebnis der Rechnung Null ist, wird der nächste Befehl übersprungen. Dieser Befehl wird für Schleifen mit bestimmter Anzahl der Durchläufe benutzt.

 IORLW k Inclusive OR Literal with W<hr>
:Es wird bitweise die logische Funktion <math>k\ or\ W</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 Operation:
<dl><dd>
11001010 ;k
10101100 ;W-Register
-------- or
11101110 ;W-Register
</dd></dl>

 IORWF R,d Inclusive OR W with F<hr>
:Es wird bitweise die logische Funktion <math>W\ or\ R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Vergleiche IORLW. Dieser Befehl wird oft benutzt zum Setzen bestimmten Bits im Register ohne restlichen Bits zu beeinflüssen.

MOVF R,d MOVe F - Bewege f<hr>
:Das Register R wird in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder wieder in R kopiert ('''d'''=<tt>F</tt>=<tt>1</tt>). Letzteres mag sinnlos scheinen, ist aber nützlich, da durch den Befehl das Z-Bit im STATUS-Register gesetzt wird, falls R Null ist.

MOVLW k MOVe Literal to W - Bewege Zahl (k) in W-Register<hr>
:Der festgelegte Wert k wird in das W-Register kopiert.

:Dieser Befehl wird auch bei indirekter Adressierung zum laden der absoluter Adresse ins "FSR" Register benutzt. Beispiel:
:Der Register "Temp" wurde mit "Temp equ 0x20" definiert.
<dl><dd>
MOVLW Temp ;ins W-Register wird die absolute Adresse 0x20 vom "Temp" geladen
movwf FSR ;diese Adresse wird jetzt ins Register "FSR" kopiert
</dd></dl>
MOVWF R MOVe W to F- Bewege W-Register in das Register F<hr>
:Das W-Register wird in das Register '''R''' kopiert.

NOP No OPeration - Kein Befehl zum Ausführen (warte)<hr>
: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. Siehe hierzu: [[#Pause|Pause]]

RETFIE RETurn From Interrupt Enable - Kehre zurück aus der Unterbrechung, erlaube Unterbrechungen<hr>
:Mit diesem Befehl wird die Interrupt Service Routine (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 | Interrupt]]

RETLW k RETurn with Literal in W - Kehre zurück mit Zahl k im W-Register<hr>
:Wurde ein Programmteil mit dem Befehl <tt>CALL</tt> aufgerufen, dann springt man mit dem Befehl <tt>RETLW</tt> zurück in die nächste Zeile nach der Zeile aus der das <tt>CALL</tt> 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 Wertetabellen (eng: lookup tables) verwendet.

RETURN RETURN from Subroutine - Kehre zurück zum Aufrufer<hr>
:Wurde ein Programmteil mit dem Befehl <tt>CALL</tt> aufgerufen, dann springt man mit dem Befehl <tt>RETURN</tt> zurück zu der nächsten Zeile nach der Zeile aus der das <tt>CALL</tt> Befehl ausgeführt wurde.

RLF R,d Rotate Left F through carry - Rotiere das Register f mithilfe des Carry-bits nach links<hr>
:Alle Bits im Register '''R''' werden um eine Position nach links verschoben. Dabei wird das Carry bit (<tt>STATUS,C</tt>) 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'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
<dl><dd>
|<--- Register R --->|
|c|<-7<-6<-5<-4<-3<-2<-1<-0
V A
|________________________|
</dd></dl>
:Zur Verdeutlichung:
<dl><dd>
|C| |-Register R-| ;C steht für das Carry-bit, STATUS,C ; 0-7 stehen für Bitnummer im Register.
c 7 6 5 4 3 2 1 0 ;vor der Rotation
7 6 5 4 3 2 1 0 c ;nach der Rotation
</dd></dl>

RRF R,d Rotate Right F through carry - Rotiere das Register f mithilfe des Carry-bits nach rechts<hr>
:Alle Bits im Register '''R''' werden um eine Position nach rechts verschoben. Dabei wird das Carry bit (<tt>STATUS,C</tt>) 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'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
<dl><dd>
|<--- Register R --->|
|c|->7->6->5->4->3->2->1->0
A V
|________________________|
</dd></dl>
:Zur Verdeutlichung:
<dl><dd>
|C| |-Register R-| ;C steht für das Carry-bit, STATUS,C ; 0-7 stehen für Bitnummer im Register.
C 7 6 5 4 3 2 1 0 ;vor der Rotation
0 C 7 6 5 4 3 2 1 ;nach der Rotation
</dd></dl>

SLEEP Go into standby mode - Versetze den Mirokontroller in Bereitschaftsmodus (Schlaf)<hr>
: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.

 SUBLW k SUBtract W from Literal - Ziehe W von Zahl (k) ab<hr>
: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|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

 SUBWF R,d SUBtract W from F - Ziehe W von f ab<hr>
:Es wird die Rechenoperation <math>R-W</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Dieser Befehl beeinflusst das STATUS-Register. Siehe hierzu [[#Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

:Beispiel:
<dl><dd>
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
</dd></dl>

SWAPF R,d SWAP nibbles in F - Vertausche die Halbbytes (Nibbles)<hr>
:Es werden die höheren 4 bit (bit7-bit4) mit den niedrigeren 4 bit (bit3-bit0) eines Registers vertauscht und entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
:Beispiel:
<dl><dd>
movlw b'00001111' ;schreibe b'00001111' in das W-Register
movwf Register1 ;kopiert 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'
</dd></dl>

 XORLW k EXclusive OR Literal with W<hr>
:Es wird bitweise die logische Funktion <math>k\ xor\ W</math> ausgeführt und das Ergebniss in das W-Register gespeichert. Dieser Befehl setzt das Z bit des STATUS-Registers, falls W=k und das Ergebnis 0 ist.
:Zur Verdeutlichung der Operation:
<dl><dd>
11001010 ;k
10101100 ;W-Register
-------- xor
01100110 ;W-Register
</dd></dl>

 XORWF R,d EXclusive OR W with F<hr>
:Es wird bitweise die logische Funktion <math>W\ xor\ R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Vergleiche XORLW. Dieser Befehl setzt das Z bit des STATUS-Registers, falls W=k und das Ergebnis 0 ist und wird zum Vergleichen zwei Register benutzt.

==Besondere, oft gebrauchte Register==

=== STATUS ===
Der Statusregister beinhaltet den Status der Recheneinheit ALU (Arithmetic-Logic Unit), Resetinformationen und die beiden Bits zur Wahl der Speicherbank

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''STATUS''' (ADDRESSE 03h, 83h, 103h, 183h)</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R-1</td>
<td style="width:60px;">R-1</td>
<td style="width:60px;">R/W-x</td>
<td style="width:60px;">R/W-x</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''IRP'''</td>
<td style="background:#f5f7ff;">'''RP1'''</td>
<td style="background:#f5f7ff;">'''RP0'''</td>
<td style="background:#f5f7ff;">'''TO'''</td>
<td style="background:#f5f7ff;">'''PD'''</td>
<td style="background:#f5f7ff;">'''Z'''</td>
<td style="background:#f5f7ff;">'''DC'''</td>
<td style="background:#f5f7ff;">'''C'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

*Bit 7 '''IRP''': Register Bank Select Bit (für indirekte Adressierung)
:: 1 = Bank 2, 3 (100h-1FFh)
:: 0 = Bank 0, 1 (00h-FFh)
*Bit 6-5 '''RP<1:0>''': Register Bank Select Bits (für direkte Adressierung)
:: 11 = Bank 3 (180h-1FFh)
:: 10 = Bank 2 (100h-17Fh)
:: 01 = Bank 1 (80h-FFh)
:: 00 = Bank 0 (00h-7Fh)
*Bit 4 '''TO''': Time-out Bit
:: 1 = Nach Power-up, CLRWDT Befehl oder SLEEP Befehl
:: 0 = A Watchdogtimer time-out ist eingetreten
*Bit 3 '''PD''': Power-Down Bit
:: 1 = Nach Power-up oder durch den CLRWDT
:: 0 = Nach einem SLEEP befehl
*Bit 2 '''Z''': Zero bit
:: 1 = Das Ergebnis einer arithmetischen oder logischen Operation ist 0
:: 0 = Das Ergebnis einer arithmetischen oder logischen Operation ist NICHT 0
*Bit 1 '''DC''': Digit carry/borrow bit (ADDWF, ADDLW, SUBLW und SUBWF Befehle)
:: 1 = Ein Carry-out des 4.Niedrigsten Bits (Low Nibble) eines Rechenergebnisses existiert
:: 0 = Kein Carry-out des 4.Niedrigsten Bits eines Rechenergebnisses existiert
*Bit 0 '''C''': Carry/borrow Bit (ADDWF, ADDLW, SUBLW und SUBWF Befehle)
:: 1 = Ein Carry-out des MSB eines Rechenergebnisses existiert
:: 0 = Kein Carry-out des MSB eines Rechenergebnisses existiert

Das "Carry/Borrow Bit" (to carry = etwas übertragen, to borrow = etwas borgen) dient zum erkennen, wenn ein Übertrag einer Rechenoperation exisitiert. 250d+10d ergibt zum Beispiel 4, und setzt dabei das "Carry/Borrow Bit" auf 1. Damit kann das Programm erkennen, wenn wieder einmal ein Ergebnis größer als 255d herauskam.
Bei Subtraktionen (SUBLW und SUBWF) verhält sich das "Carry/Borrow Bit" umgekehrt als bei Additionen (ADDWF und ADDLW)!! Zum Beispiel 55d-6=49d setzt "Carry/Borrow Bit" auf 1 aber 10d-25d=241d löscht das "Carry/Borrow Bit".

====Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Registers====

{|
|-
|
{| {{Blauetabelle}}
|+ Auswirkungen auf das STATUS-Register bei Subtraktionen
|-
| Ergebnis
|| STATUS,C
|| STATUS,Z
|-
| positiv
|align="center"|1
|align="center"|0
|-
| negativ
|align="center"|0
|align="center"|0
|-
| Null
|align="center"|1
|align="center"|1
|}

||

{| {{Blauetabelle}}
|+ Auswirkungen auf das STATUS-Register bei Additionen
|-
| Ergebnis
|| STATUS,C
|| STATUS,Z
|-
| positiv
|align="center"|0
|align="center"|0
|-
| Überlauf
|align="center"|1
|align="center"|0
|-
| Null
|align="center"|1
|align="center"|1
|}
|}

=== PORTx ===

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''PORTx'''</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''Rx7'''</td>
<td style="background:#f5f7ff;">'''Rx6'''</td>
<td style="background:#f5f7ff;">'''Rx5'''</td>
<td style="background:#f5f7ff;">'''Rx4'''</td>
<td style="background:#f5f7ff;">'''Rx3'''</td>
<td style="background:#f5f7ff;">'''Rx2'''</td>
<td style="background:#f5f7ff;">'''Rx1'''</td>
<td style="background:#f5f7ff;">'''Rx0'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

!Das "x" steht in allen Fällen für den Buchstaben des Ports!
BSP: "PORTB" oder "RA1"

Diese Special Funktion Register liegen ALLE in Bank0 und Bank2(Falls vorhanden).

Jedes Bit eines PORT-Registers steht für einen Pin (Ein/Ausgang) des jeweiligen Ports. Je nachdem Ob ein Pin als Ausgang oder als Eingang definiert ist, kann man dort entweder den Wert schreiben oder auslesen. Es hat nicht Jeder PIC gleich viele Ports und es sind auch nicht immer 8 Pins pro Port, es können auch weniger sein. Alle PICs der Midrange-Serie besitzen nur bidirektionale Ports, d.h. sie können sowohl Eingang als auch Ausgang sein. Bei Port B kann man bei allen Pins einen internen PULL-UP Widerstand mit dem Bit OPTION_REG<RBPU> hinzuschalten (Standardmäßig auf nicht aktiviert, Bit muss gelöscht werden um die Funktion zu aktivieren). Weiters ist zu beachten, dass einzelne Pins nach dem Reset mit anderen Funktionen belegt sein können. Das gilt im Speziellen für PORTA, wo sich die Komperatoren, AD's (falls vorhanden) und die Oszillatoreingänge befinden. Siehe [[PIC Assembler#I/O Ports|I/O Ports]]. Bei den "kleinsten" PICs der 12F Serie die nur einen I/O Port (6 Pins) haben, heisst der PORT-Register GPIO.
{|{{Blauetabelle}}
|+ Beispiel PICs und ihre Ports (Zahlen in der Klammer sind die Anzahl der Pins des Ports)
|
|'''PIC16F628A'''
|'''PIC16F876'''
|'''PIC16F877'''
|-
|'''PORTA'''
|Ja
|Ja(5)
|Ja(6)
|-
|'''PORTB'''
|ja
|ja
|ja
|-
|'''PORTC'''
|/
|ja
|ja
|-
|'''PORTD'''
|/
|/
|ja
|-
|'''PORTE'''
|/
|/
|ja (3)
|-
|}

=== TRISx ===

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''TRISx'''</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''TRISx7'''</td>
<td style="background:#f5f7ff;">'''TRISx6'''</td>
<td style="background:#f5f7ff;">'''TRISx5'''</td>
<td style="background:#f5f7ff;">'''TRISx4'''</td>
<td style="background:#f5f7ff;">'''TRISx3'''</td>
<td style="background:#f5f7ff;">'''TRISx2'''</td>
<td style="background:#f5f7ff;">'''TRISx1'''</td>
<td style="background:#f5f7ff;">'''TRISx0'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

!Das "x" steht in allen Fällen für den Buchstaben des Ports!
BSP: "TRISB" oder "TRISA"

Bei den "kleinsten" PICs der 12F Serie die nur einen I/O Port (6 Pins) haben, heisst der TRIS-Register TRISIO.

Die TRIS-Bytes dienen dazu, einzelne I/O Pins als Eingang oder Ausgang zu definieren. Sie liegen immer genau eine Bank über den jeweiligen PORT-Bytes, d.h. sie liegen alle in Bank1 und Bank3 (falls vorhanden.) Besonders zu beachten ist, dass manche Eingebaute Features wie die Serielle Schnittstelle, I2C, SPI usw nicht funktionieren, wenn die Jeweiligen Sende und Empfangspins nicht manuell umgestellt werden, ja es ''muss'' sogar manchmal umgestellt werden (bei I2C z.B.) Egal ist dies jedoch für Komperatoren und AD-Wandler.

Merke:
* Eine 1 (als "I" für "Input" zu lesen) eines TRISxx-Bits definiert den zugehörigen PIN am PIC als Eingang.
* Eine 0 (als "O" für "Output" zu lesen) eines TRISxx-Bits definiert den zugehörigen PIN am PIC als Ausgang.

Siehe [[PIC Assembler#I/O Ports|I/O Ports]].

=== INTCON ===

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''INTCON''' (ADDRESSE 0Bh, 8Bh, 10Bh, 18Bh)</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''GIE'''</td>
<td style="background:#f5f7ff;">'''PEIE'''</td>
<td style="background:#f5f7ff;">'''TMR0IE'''</td>
<td style="background:#f5f7ff;">'''INT0IE'''</td>
<td style="background:#f5f7ff;">'''RBIE'''</td>
<td style="background:#f5f7ff;">'''TMR0IF'''</td>
<td style="background:#f5f7ff;">'''INT0IF'''</td>
<td style="background:#f5f7ff;">'''RBIF'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

*Bit 7 '''GIE''': Global Interrupt Enable Bit
::1 = Aktiviert alle Interrupts
::0 = Deaktiviert alle Interrupts
*Bit 6 '''PEIE''': Peripheral Interrupt Enable Bit
::1 = Aktiviert alle peripheren Interrupts
::0 = Deaktiviert alle peripheren Interrupts
*Bit 5 '''TMR0IE''': TMR0 Overflow Interrupt Enable Bit (Overflow von Timer0 löst Interrupt aus)
::1 = Aktiviert den TMR0 Interrupt
::0 = Deaktiviert den TMR0 Interrupt
*Bit 4 '''INT0IE''': RB0/INT External Interrupt Enable Bit (Änderung an RB0 Pin löst Interrupt aus) *)
::1 = Aktiviert den RB0/INT Interrupt (Extern ausgelöst)
::0 = Deaktiviert den RB0/INT Interrupt (Extern ausgelöst)
*Bit 3 '''RBIE''': RB Port On-Change-Interrupt Enable Bit (Änderung an PortB löst Interrupt aus) **)
::1 = Aktiviert den RB port on-change-interrupt
::0 = Deaktiviert den RB port on-change-interrupt
*Bit 2 '''TMR0IF''': TMR0 Overflow Interrupt Flag Bit
::1 = TMR0 Register ist Übergelaufen (muss per Software gelöscht werden)
::0 = TMR0 register ist nicht Übergelaufen
*Bit 1 '''INT0IF''': RB0/INT External Interrupt Flag Bit
::1 = Eine Änderung an RB0/INT Pin hat stattgefunden (muss per Software gelöscht werden)
::0 = Eine Änderung an RB0/INT Pin hat nicht stattgefunden
*Bit 0 '''RBIF''': RB Port On-Change-Interrupt Flag bit
::1 = Mind. einer der Pins von RB7:RB4 hat sich geändert (muss per Software gelöscht werden)
::0 = Keiner der Pins von RB7:RB4 hat sich geändert

* *) Die Flanke auf die reagiert werden soll, wird mit dem Bit OPTION_REG.INTEDG definiert. (steigende = 1 oder fallende = 0)
* **) Der Interrupt klingt verführerischer Weise so, als ob er den gesamten Port überwacht. Dabei reagiert er nur auf RB7:RB4!!!! Er kann aber den Prozessor vom "Schlaf" aufwecken (z.B. durch einen Tastendruck).

==Speicherbankorganisation==
===Programmspeicher===
Die Mid-Range MCUs haben einen 2-8k großen Programmspeicher. Dieser hat aber in jeder Speicherzelle nicht 8, sondern 14 Bit - also genau die Länge eines Befehls. Die aktuelle Stelle im Programm wird im PC (Program Counter) verwaltet. Er speichert immer die aktuelle Adresse im Programmspeicher (wird im Code oft als "$" bezeichnet). Bei einem PIC mit 8k Adressen muss er also die Adressen 0000-1FFF speichern können. Daraus folgt die Größe von 13 Bit für den PC. Der Programmspeicher ist in mehrere Bänke geteilt, die alle 2k groß sind. Das Programm springt ohne zutun des Benutzers von einer in die Nächste. Wenn man aber selber springen will, muss man die Register PCLATH (Program Counter Latch High) oder PCL (Program Counter Least Significant Byte) mit der Sprungadresse beschreiben.

===Datenspeicher===
Der Datenspeicher besteht aus den Special Function Registern (SFR) und den General Purpose
Registern (GPR). Die SFRs sind für die Funktionen des PICs zuständig (Interrupts, Timer, ADCs, CCPM...) und die GPRs für die Speicherung von Variablen und Daten.

Da immer nur 7 Bit der (Ziel)Adresse in einem Befehl gespeichert werden können, sind nur 7Fh (128d) Adressen im Datenbereich möglich. Deswegen wurde das "Banking" eingeführt. 2 Bit im Statusregister (welcher in allen Bänken der selbe ist und auch an der gleichen Stelle sitzt) geben die akutelle "Bank" an und sind nichts anderes als die 2 höchstwertigsten (MSB) Bits der Adresse. Damit lassen sich max. 4 Bänke ansprechen. Je nach PIC gibt es 2-4 Bänke. Die beiden Bits im Register STATUS heißen RP0 (STATUS<5>) und RP1 (STATUS<6>).

{| {{Blauetabelle}}
|+ Wechseln der Bänke mit RP0 und RP1
|-
|
|| RP1
|| RP0
|-
| Bank0
|align="center"|0
|align="center"|0
|-
| Bank1
|align="center"|0
|align="center"|1
|-
| Bank2
|align="center"|1
|align="center"|0
|-
| Bank3
|align="center"|1
|align="center"|1
|}

[[Bild:PIC midrange register.JPG]]
# '''FETTE Register''' sind in allen PICs vorhanden
# können je nach PIC unimplementierte Bereiche beinhalten - diese werden immer als 0 gelesen. (DATENBLATT!!)
# siehe 2
# Könnten je nach PIC auch nicht in Bank0 gemapped werden, sind dann eigenständige Register.
# je nach PIC kann es diese Bänke geben oder nicht geben.

== Codeschnipsel ==

=== Analog-Digital-Wandler (ADC) ===

Viele PICs besitzen einen Analog-Digital-Wandler, der eine angelegte Spannung messen kann und diese als Zahl speichert.

Es gibt AD-Wandler mit 8Bit bzw. 10Bit Auflösung, d.h. die Spannung an einem analogen Eingang wird linear 2^8=256 bzw. 2^10=1024 Werten zugeordnet.
Der höchste Wert, auch Referenzspannung genannt, (255 bzw. 1023; der Controller rechnet die Null auch mit) entspricht der Betriebsspannung des PICs oder wahlweise einer wählbaren Spannung, die an RA3 angelegt werden muss. Der niedrigste Wert entspricht 0 Volt.

Mit dem Analog-Digital-Wandler kann man somit z.B. Sensoren auswerten, die mehr als zwei Zustände ausgeben (Beispiele: Temperatursensor, Helligkeitssensor, Entfernungssensoren usw.) oder Akkuspannungen messen.

Bevor überhaupt gemessen werden kann, muss einiges eingestellt werden:

* Eingangsverteilung Analog/Digital bzw.Referenzspannung (Betriebsspannung oder RA3)
die genauen Einstellungsmöglichkeiten entnehmen sie bitte dem Datenblatt ihres Controllers (Register ADCON1 Bank 1).

* Wählen des Taktes für den ADC und Einschalten des ADCs

Das Register ADCON0 besitzt 8 Bits, die folgendes bestimmen:
Bit0 ADON - schaltet AD-Wandler ein oder aus (Strom sparen)
Bit1 - nicht vorhanden
Bit2 GO/Done - startet Wandlung / signalisiert, wann Umwandlung beendet ist.
Bit3 CHS0 - Channel Select 0 wählt Eingang aus
Bit4 CHS1 - Channel Select 1 wählt Eingang aus
Bit5 CHS2 - Channel Select 2 wählt Eingang aus
Bit6 ADCS0 - AD-Clock-Select wählt Takt
Bit7 ADCS1 - AD-Clock-Select wählt Takt

Kümmern wir uns zunächst um den Takt. Mit den zwei Bits ADCS0 und ADCS1 bestimmt man den Takt - hierbei gibt es vier Möglichkeiten:

ADCS1=0, ADCS0=0 -> Taktfrequenz des PICs :2
ADCS1=0, ADCS0=1 -> Taktfrequenz des PICs :8
ADCS1=1, ADCS0=0 -> Taktfrequenz des PICs :32
ADCS1=1, ADCS0=1 -> interner RC-Oszillator des ADCs verwenden

Die Taktfrequenz des ADCs darf 625kHz nicht überschreiten, dementsprechend ist ADCS0 und ADCS1 zu wählen.

Ist dies vollbracht, so kann man den AD-Wandler einschalten und das Go/Done-Bit löschen.
Codebeispiel:

bcf ADCON0,6 ;Takt für
bsf ADCON0,7 ;ADC (OSC/32)
bsf ADCON0,0 ;ADC einschalten, ADON=1
bcf ADCON0,2 ;Go/Done-Bit zurücksetzen

Nun ist der AD-Wandler bereit, Spannungen in Zahlen umzuwandeln.
Für eine Wandlung muss erst der entsprechende Eingang gewählt werden. Dafür sind die CHS0..CHS2-Bits zuständig:

CHS2 CHS1 CHS0 gewählter Eingang(falls vorhanden)
0 0 0 RA0
0 0 1 RA1
0 1 0 RA2
0 1 1 RA3
1 0 0 RA5
1 0 1 RE0
1 1 0 RE1
1 1 1 RE2

Achtung! RA4 ist kein analoger Eingang, folglich ist er oben nicht aufgelistet !!

Codebeispiel:

bcf ADCON0,3 ;RA2 auswählen
bsf ADCON0,4
bcf ADCON0,5

Als letztes muss die AD-Routine nur noch gestartet werden. Ist der AD-Wandler fertig, so löscht er das Bit wieder. Das Bit wird nun solange abgefragt, bis der AD-Wandler fertig ist. Den zugeordneten Wert findet man im Register 'ADRES'.
Code:

bsf ADCON0,2 ;start
wa btfsz ADCON0,2 ;warten,bis es wieder low ist
goto wa ;noch nicht fertig
;jetzt ist er fertig
movf ADRES,W ;ADRES in W verschieben, um damit gleich weiter zu arbeiten

Die AD-Wandlung ist somit fertig. Liest man mehrere Werte von unterschiedlichen Eingängen ein und möchte diese miteinander vergleichen o.ä., sollte man die Zahlen von ADRES in anderen Registern zwischenspeichern.

Desweiteren ist zu beachten, dass der Analog-Digital-Wandler eine gewisse Pause zwischen den Wandlungen benötigt, die sog. 'Aquisition Time'. Diese Zeitangabe entnehmen sie bitte ihrem Datenblatt.

mögliche Probleme:

;Der PIC liefert stark schwankende Werte
:-> Mögliche Ursachen dafür sind z.B. nicht stabile Betriebsspannung, falsche Zeiteinstellungen. Abhilfe schafft auch das mehrmalige Einlesen eines Eingangs. Auch können z.B. 8 Werte eingelesen werden und dann der Durchschnitt gebildet werden.
Evtl. kann ein Kondensator gegen Masse (z.B. 1nF) helfen; Wichtig ist auch eine kleine Verzögerung zwischen Kanalauswahl und Start der Wandlung. In dieser Zeit kann sich der interne Kondensator des ADC's aufladen.

;Die Spannung an einem Eingang wird erhöht, die Werte der anderen Eingänge werden aber auch beeinflusst.
:-> Dann sind Sie Opfer des sog. 'Ghostings' geworden (Werte 'scheinen durch', verschleißen). Die Werte der anderen Eingänge gehen mit, weil der interne Kondensator noch auf die Spannung des Vorgängers aufgeladen ist. Maßnahme: Aquisition Time erhöhen, Werte öfters abfragen, Pause zwischen Kanalauswahl und Start

;Der PIC liefert immer die gleichen Werte an einem Eingang, obwohl sich die angelegte Spannung ändert
:-> möglicherweise falsche Eingangsverteilung (ADCON1) eingestellt oder falschen Pin gewählt

=== Hex Dec Wandlung ===

Das ist ein Unterprogramm das mit "call Hex_Dec" aufgerufen wird. Es gibt 4 Register (A, B, C und D) mit jeweils 32 Bits, die aus jeweils 4 Register mit 8 Bits (z.B. fur A: A3, A2, A1 und A0) bestehen.

A3 A2 A1 A0
.--------.--------.--------.--------.
|76543210|76543210|76543210|76543210|
'--------'--------'--------'--------'
| |
|<----------- A Register ---------->|

Sie müssen (wegen FSR) so wie im Code nacheinander liegen (die absoluten Adressen sind nicht wichtig). In das Register "A" wird die hex Zahl eingeschrieben und aus dem "D" die umgewandelte dec Zahl ausgelesen. A3,7 und D3,7 sind MSB und A0,0 und D0,0 sind LSB. Die "B" und "C" sind Hifsregister. Das UP kann für kleinere als 32-bittige hex Zahlen modifiziert werden. Zum Beispiel für 16-bittige hex Zahlen bleiben nur Register A1,A0,B1,B0,C1,C0,D1,D0 und in den UPs werden in die Register und als X, folgende Zahlen eingeschrieben: HTmp->0x10 (Anzahl Bits der hex Zahl),ATmp->2=X (Anzahl Bytes der hex Zahl). Es müssen auch die UPs "CClr", "DClr" und "CopyCB" entsprechend der Registerlänge angepasst werden. Genauso kann natürlich das UP auch für längere hex Zahlen modifiziert werden.

Das UP "AddCB" addiert dezimal die 32- bittige Register C und B, das Ergebniss befindet sich in C.
Das UP "AddDC" addiert dezimal die 32-bittige Register D und C, das Ergebniss befindet sich in D.

Die 32-bit Additionen werden in 4 Schritten wie folgt realisiert:

C0+B0->C0, C1+B1->C1, C2+B2->C2 und C3+B3->C3

D0+C0->D0, D1+C1->D1, D2+C2->D2 und D3+C3->D3

Die Flags "_Fcra", "_Fcrp" und "_Fdca" steuern die alle nötigen Korrekturen.

Die Wandlung wird in 32 Schritten laut folgender Formel durchgeführt:

Zahl(d)=B0*2^0+B1*2^1+B2*2^2+B3*2^3+B4*2^4+B5*2^5+B6*2^6+B7*2^7+B8*2^8+B9*2^9+B10*2^10+B11*2^11+

B12*2^12+B13*2^13+B14*2^14+B15*2^15+B16*2^16+B17*2^17+B18*2^18+B19*2^19+B20*2^20+B21*2^21+

B22*2^22+B23*2^23+B24*2^24+B25*2^25+B26*2^26+B27*2^27+B28*2^28+B29*2^29+B30*2^30+B31*2^31

Wobei B0 bedeutet den LSB und B31 den MSB der hex Zahl.

Die dec Zahl wird im D Register durch "AddDC" gebildet. In dem C Register befindet sich immer die laufende 2^X. Am Anfang wird dort 1=2^0 geladen. Da die nächste zu addierende dec Zahl immer gleich 2* vorherige ist, wird sie einfach so berechnet, dass die aktuelle aus C Register ins B Register kopiert ("CopyCB") und zu C addiert ("AddCB") wird. Diese dec Zahl wird zum D Register addiert nur wenn das entsprechende Bit der hex Zahl gleich 1 ist. Weil im UP "Hex_Dec" immer das bit A0,0 dafür geprüft wird, wird das gesamte 32-bittige A Register nach jeder Addition "AddDC" um ein Bit mit "ARotRb" nach rechts rotiert. Die Flags "_Fcra" und "_Fcrp" übertragen die Bits zwischen den 8 Bit Registern A0, A1, A2 und A3. Es würde zwar reichen, wenn das A Register nur verschoben würde, aber hier wurde Rotation gewählt, damit nach der Wandlung die hex Zahl im A Register unverändert steht. Weil die dec Zahl nur 8-stellig ist, darf die max. hex Zahl 99999999d = 5F5E0FFh sein.

#define _C STATUS,C
#define _Z STATUS,Z
#define _DC STATUS,DC
#define _Fcra Flags,0
#define _Fcrp Flags,1
#define _Fdca Flags,2
#define _Ferr Flags,3 ;Überlauf (Fehler)
;..................................................................................
A3 EQU 0x20 ;Register fürs Rechnen
A2 EQU 0x21
A1 EQU 0x22
A0 EQU 0x23
B3 EQU 0x24
B2 EQU 0x25
B1 EQU 0x26
B0 EQU 0x27
C3 EQU 0x28
C2 EQU 0x29
C1 EQU 0x2A
C0 EQU 0x2B
D3 EQU 0x2C
D2 EQU 0x2D
D1 EQU 0x2E
D0 EQU 0x2F
Flags EQU 0x30
ATmp EQU 0x31 ;Schleifenzähler
HTmp EQU 0x32 ;Schleifenzähler
RTmp EQU 0x33 ;Zwischenspeicher
;..................................................................................
Hex_Dec call CClr ;Hex>A, D>Dec
call DClr
movlw 1
movwf C0
movlw 0x20 ;32 bit Hex > 32 bit Dec (8 Stellen)
movwf HTmp
HexDecL btfsc A0,0
call AddDC
call CopyCB
call AddCB
call ARotRb
decfsz HTmp,1
goto HexDecL
return
CClr clrf C0
clrf C1
clrf C2
clrf C3
return
DClr clrf D0
clrf D1
clrf D2
clrf D3
return
CopyCB movf C0,0
movwf B0
movf C1,0
movwf B1
movf C2,0
movwf B2
movf C3,0
movwf B3
return
AddCB movlw B0 ;C+B>C
movwf FSR
goto AddR
AddDC movlw C0 ;D+C>D
movwf FSR
AddR bcf _Ferr ;Addiere zwei Register
bcf _Fcrp
movlw 4 ;X=4 Bytes lang
movwf ATmp
AddRL bcf _Fdca
bcf _Fcra
movf INDF,0
movwf RTmp
movlw 4 ;X=4
addwf FSR,1
btfss _Fcrp
goto AddRN
movlw 1
addwf INDF,1
call DecCor
AddRN movf RTmp,0
addwf INDF,1
call DecCor
btfss _Fdca
goto AddCor1
movlw 6
addwf INDF,1
AddCor1 btfss _Fcra
goto AddCor2
movlw 0x60
addwf INDF,1
btfsc _C
bsf _Fcra
AddCor2 movf INDF,0
andlw 0xF0
sublw 0xA0
btfss _Z
goto AddCor3
movf INDF,0
andlw 0x0F
clrf INDF
addwf INDF,1
bsf _Fcra
AddCor3 bcf _Fcrp
btfsc _Fcra
bsf _Fcrp
movlw 5 ;X+1=5
subwf FSR,1
decfsz ATmp,1
goto AddRL
btfsc _Fcra
bsf _Ferr
return
DecCor btfsc _DC ;dezimale Korrektur (equ DAW)
bsf _Fdca
btfsc _C
bsf _Fcra
movf INDF,0
andlw 0x0F
sublw 9
btfss _C
bsf _Fdca
movf INDF,0
andlw 0xF0
sublw 0x90
btfss _C
bsf _Fcra
return
ARotRb movlw A3 ;rotiere A register 1 Bit rechts
movwf FSR
RRotRb movlw 4 ;rotiere X=4 Bytes
movwf ATmp
bcf _Fcrp
btfsc A0,0
bsf _Fcrp
RRotRbL bcf _Fcra
btfsc INDF,0
bsf _Fcra
bcf _C
btfsc _Fcrp
bsf _C
rrf INDF,1
bcf _Fcrp
btfsc _Fcra
bsf _Fcrp
incf FSR,1
decfsz ATmp,1
goto RRotRbL
return

=== EEPROM ===

Alle PICs besitzen EEPROM in dem je nach Typ können 64 bis 256 Databytes abgespeichert werden. Die Adressierung des EEPROMs fängt immer mit 0x00 an. Hier werden nur geprüfte UPs kurz erklärt. Die ersten zwei brauchen nur ein Register "Temp" für Schleifenzähler, dessen Name, falls im Programm schon existiert, geändert werden muss. Die Adresse im EEPROM ist gleich der Adresse im RAM.

EEPROM beschreiben:

EEWrite movlw 0x20 ; ab der RAM Adresse wird in EEPROM abgespeichert
movwf FSR
movlw 4 ; soviel Bytes
movwf Temp ; Schleifenzähler
EEWLoop call EEWrite1
incf FSR,1 ; nächste Adresse
decfsz Temp,1
goto EEWLoop
return

EEWrite1 bcf INTCON,GIE ; Interrupts sperren
movf FSR,0
bsf STATUS,RP0 ; auf Bank1 umschalten
movwf EEADR ; EEPROM Adresse
movf INDF,0
movwf EEDATA ; EEPROM Data
bsf EECON1,WREN
movlw 0x55
movwf EECON2
movlw 0xAA
movwf EECON2
bsf EECON1,WR
bcf EECON1,WREN
btfsc EECON1,WR
goto $-1 ; warten bis WR=0
bcf STATUS,RP0 ; zurück auf Bank 0 umschalten
bsf INTCON,GIE ; Interrupts erlauben
return

EEPROM lesen und zurück in RAM schreiben:

EERead movlw 0x20 ; ab der Adressse wird aus EEPROM in RAM abgelegt
movwf FSR
movlw 4 ; soviel Bytes
movwf Temp ; Schleifenzähler
EERLoop call EERead1
incf FSR,1 ; nächste Adresse
decfsz Temp,1
goto EERLoop
return

EERead1 movf FSR,0
bsf STATUS,RP0 ; auf Bank1 umschalten
movwf EEADR ; EEPROM Adresse
bsf EECON1,RD
movf EEDATA,0 ; EEPROM Data
bcf STATUS,RP0 ; zurück auf Bank 0 umschalten
movwf INDF
return

Tabelle im EEPROM mit MPASM Direktive "de" erstellen:

org 0x2100 ; EEPROM initialisieren
; nachfolgend als Kommentar die EEPROM Adressen
de 0x03, 0xE8 ; 0x00
de 0x03, 0xE8 ; 0x02
de 'M','H','z',0x00 ; 0x04
de ' ',' ','W','A','I','T',0x00 ; 0x08
de 'C','o','n','s','t',' ','X',0x00 ; 0x0F
de 'C','=',0x00 ; 0x17
de 'L','=',0x00 ; 0x1A
de 'F','=',0x00 ; 0x1D
de 'O','K',0x00 ; 0x20
u.s.w.

Wenn die Tabelle sich im Quellcode befindet, wird sie beim brennen des PICs in EEPROM eigeschrieben.

Das Lesen eines Strings muss ab entsprechender EEPROM Adresse (z.B. für "MHz" -> 0x04) anfangen und auf dem Wert 0x00, der hier als Stringende dient, enden. Einfacher ist, wenn alle Strings gleich lang sind (wie z.B. in einem Zeichengenerator fur Grafikdisplay).

Die Adreesse "0x2100" in der "org" Direktive hat mit der Adresse im Programmspeicher nichts zu tun.

=== Interrupts ===

Das Programmteil misst eine Frequenz an TOCKI Pin und wurde für PIC16F870 geschrieben.

Benötigte Hardware: Widerstand 470 Ohm zwischen der Frequenzquelle und TOCKI Pin (A4).

Es fehlen UPs "Hex_Dec" [[#Hex Dec Wandlung|Hex Dec Wandlung]] und Ausgabe auf ein Display "DispFrq". Das HP ("Main") als leere endlose Schleife macht nichts ausser warten auf ein Interrupt von Timer0 bzw. Timer1. Man kann die Marke "Main" weglassen und das HP als "goto $" formulieren.

Da der Timer0 nicht, wie der Timer1 durch ein Flag gestartet und gestoppt werden kann, wird es durch setzen und löschen des Bits für TOCKI (A4) Pin im TRISA Register, genauso wie in der AN592 vom Microchip, gemacht.

Der Zähler der Frequenz wurde um ein Zähler aus zwei zusätzlichen Register A2 und A3 erweitert und bei jedem Timer0 Überlauf erhöht. Der Prescaler wird ins Register A0 und der TIMER0 ins A1 kopiert. Somit ergibt sich 32-bittiges Ergebniss, der als hex Zahl in den Register A3 (MSB),A2, A1, und A0 (LSB) steht. Nach der "Hex_Dec" Wandlung kann die Frequenz aus den Register D3 (MSB), D2, D1 und D0 (LSB) an einem biliebigen Display angezeigt werden.

Es wird kein zusätzliches Register benötigt, da das "ATmp" und das "RTmp" die gleichen wie im UP "Hex_Dec" sind. Die Quarzfrequenz wurde gewählt, weil sie am nächsten der Temperaturstabiltesten Frequenz für AT Quarzen 7,2 MHz ist. Der PIC16F870 wurde nur wegen nötigen 19 I/O Pins für 6-stelligen 7-segment LCD Display LPH2673-1[[http://www.roboternetz.de/phpBB2/viewtopic.php?t=26005]] (ohne Kontroller) vom Pollin angewendet. Mit einem üblichen 1x16 Zeichen LCD Matrixdisplay und anderen PICs wurde das Programm für Frequenzen bis zum 80 MHz mit einer Genauigkeit
+/- 4 Hz positiv getestet.

Um die Frequenz mit Genauigkeit +/- 1Hz zu messen, muss die Messzeit 1 s von Timer1 erzeugt werden, das nur für Quarz bis 2,048 MHz möglich ist. Für sehr genaue Messungen wird empfohlen als Taktfrequenz für den Timer1, die Trägerfrequenz eines nächsten LW Senders (z.B. DLF 153 bzw. 207 kHz) zu nutzen. Die Genauigkeit der Frequenz ist ca. 1E-11 und geprüfter Empfänger kann laut der Skizze in [[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=13706&highlight=frequenzz%E4hler]] nachgebaut werden. In dem Fall müssen die Register vom Timer1 (TMR1H und TMR1L) vor seinem Start entsprechend geladen werden.

Mit dem Quarz 7,3728 MHz wird hier die Messzeit 0,25 s genutzt und die gemessene Frequenz durch 4 multipliziert (mittels 2 Additionen), was die Auflösung von +/- 4 Hz ergibt.

Das UP "Init" muss selbstverständlich für ein Matrixdisplay um Initialisierung des Displaykontrollers ergänzt werden.

; Programm zum Messen der Frequenz an T0CKI Pin mit 7,3728 MHz Quarz
LIST P=16F870
include "P16F870.inc"
__CONFIG _CP_OFF & _DEBUG_OFF & _WRT_ENABLE_ON & _CPD_OFF & _LVP_OFF & _BODEN_OFF &
_PWRTE_ON & _WDT_OFF & _HS_OSC
ORG 0x0000
call Init
Main goto Main
ORG 0x0004 ;ISR (interrupt service routine)
bcf INTCON,GIE ;interrupts sperren
btfss INTCON,T0IF ;ist Timer0 übelaufen ?
goto CheckTMR1 ;nein, dann prüfe Timer1
bcf INTCON,T0IF ;Timer0 interrupt flag löschen
movlw 1
addwf A2,1 ;erhöhe A2
btfsc STATUS,C
incf A3,1 ;increment A3, wenn A2 überlaufen ist
CheckTMR1 btfss PIR1,TMR1IF ;ist Timer1 überlaufen ?
retfie ;wenn nicht, springe zurück zu Main
bsf STATUS,RP0 ;stopp Timer0
movf TRISA,0
andlw 0xEF
movwf TRISA ;TOCKI Pin (A4) als Ausgang
bcf STATUS,RP0
bcf T1CON,TMR1ON ;stopp Timer1
bcf PIR1,TMR1IF ;Timer1 interrupt flag löschen
GetFreq movf TMR0,0 ;Prescaler ins Register A0 kopieren
movwf A1
movwf RTmp
clrf ATmp
FToggle incf ATmp,1
bsf STATUS,RP0
bsf OPTION_REG,T0SE
bcf OPTION_REG,T0SE
bcf STATUS,RP0
movf TMR0,0
subwf RTmp,0
btfsc STATUS,Z
goto FToggle
comf ATmp,1
incf ATmp,0
movwf A0
call Hex_Dec
clrf A3 ;Register A löschen
clrf A2
clrf A1
clrf A0
call CopyDC
call AddDC ;gemessene Frequenz * 2
call CopyDC
call AddDC ;gemessene Frequenz * 4 = tatsächliche Frequenz
call DispFrq ;eigenes UP für benutztes Display
clrf TMR0 ;Timer0 löschen
movlw 0x34 ;Timer1
movwf T1CON ;konfigurieren
movlw 0x1F ;Timer1 laden (für 0,25 s)
movwf TMR1H
clrf TMR1L
bsf STATUS,RP0 ;start Timer0
movf TRISA,0
iorlw 0x10
movwf TRISA ;TOCKI Pin (A4)als Eingang
bcf STATUS,RP0
bsf T1CON,TMR1ON ;start Timer1
retfie ;erlaube interrupts und springe zurück zu Main
CopyDC movf D0,0
movwf C0
movf D1,0
movwf C1
movf D2,0
movwf C2
movf D3,0
movwf C3
return
Init clrf PORTA ;Ports löschen
clrf PORTB
clrf PORTC
movlw 0x20 ;RAM (20-7Fh) löschen
movwf FSR
clrf INDF
incf FSR,1
btfss FSR,7
goto $-3
clrf ADCON0 ;schalte ADC off
movlw 7 ;sperre ADC
movwf ADCON1 ;und definiere RA0-7 als digitale I/Os
movlw 0xE0 ;GIE, PEIE & TMR0IE erlauben
movwf INTCON
bsf STATUS,RP0 ;bank 1
clrf TRISA ;alle PORTA,
clrf TRISB ;alle PORTB,
clrf TRISC ;und alle PORTC Pins als Ausgänge
movlw 0xE7 ;Takt für Timer0 vom T0CKI Pin
movwf OPTION_REG ;Timer0 konfigurieren
bsf PIE1,TMR1IE ;TMR1 interrupt erlauben
bcf STATUS,RP0 ;Bank 0
clrf TMR0 ;Timer0 löschen
movlw 0x34 ;Timer1 konfigurieren
movwf T1CON ;(prescaler 8)
movlw 0x1F ;Timer1 laden (für 0,25 s)
movwf TMR1H
clrf TMR1L
bsf STATUS,RP0 ;start Timer0
iorlw 0x10
movwf TRISA ;TOCKI Pin (A4) als Eingang
bcf STATUS,RP0
bsf T1CON,TMR1ON ;start Timer1
return
end

=== Mausrad ===

Das UP wertet ein Mausrad aus und setzt, je nach Drehrichtug und sein Anschluss an PORT (PORTB,0 und PORTB,1), ein Flag "_Finc" bzw. "_Fdec", das vor der nächsten Abfrage, gelöscht werden muss. Diese Flags können z.B. für Inkrementierung und Dekrementierung von Zählern dienen.

Die Hardware:

Mausrad
.-------.
| o---> PORTB,0
+----o---- |
| | o---> PORTB,1
=== '-------'
GND

Es müssen die internen pull-ups vom PORTB aktiviert werden. Wenn das Mausrad an anderen PORT angeschlossen wird, werden externe pull-ups (z.B. 10 kOhm) benötigt. Als "_Z" wurde "STATUS,Z" definiert. Zum Auswerten werden 4 Register "MausA", "MausB", "MausC" und "Flags" gebraucht, die im gesamten Programm definiert werden müssen. Die Warteschleife "Delay" soll ca. 10ms sein.

In dem UP "Mouse" wird PORTB eigelesen, die alle Bits ausser 0 und 1 durch "and" Funktion gelöscht und in den Register "MausB" und "MausC" gespeichert. Nach ca. 10ms wird das gleiche gemacht und im Register "MausA" gespeichert. Der Wert aus "MausA" wird mit dem vorherigen aus "MouseC" durch "xor" verglichen. Sind sie nicht identisch, wird je nach dem Wert "X" (0, 1, 2, b.z.w. 3) im "MausB" in das entsprechende UP "MouseX" gesprungen. Sonst, wenn "MausA"="MausC", wird zum Aufrufer zurückgekehrt.

In einem UP "MouseX" wird der letzte Wert im "MausA" ermittelt und nach der Kombination der Werte im "MausB" und "MausA" (01 b.z.w. 02, 10 b.z.w. 13, 20 b.z.w. 23 oder 31 b.z.w. 32) entsprechendes der Drehrichtung Flag "_Finc" b.z.w. "_Fdec" gesetzt. Anschliessend wird zum Aufrufer zurückgesprungen.

Detailierter PAD:

Mouse V
PORTB->W
3 and W->W
W->MausB
W->MausC
Warten 10ms
PORTB->W
3 and W->W
W->MausA
W xor MausC->MausC
_Z=1 ? J > return
N
V
MausB->MausB
.--------------------------< J _Z=1 ?
| N
| V
| MausB->W
| 1-W->W
| .----< J _Z=1 ?
| | N
| | V
| | MausB->W
| | 2-W->W
| | _Z=1 ? J >---------------------------.
| | N |
| | V |
| | MausB->W |
| | 3-W->W |
| | _Z=1 ? J >-----. |
| | N | |
| | V | |
| | return | |
| | | |
| | | |
Mouse0 V Mouse1 V Mouse3 V Mouse2 V
MausA->W MausA->MausA MausA->W MausA->MausA
1-W->W V 1-W->W V
_Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--.
J | J | J | J |
V | V | V | V |
setze _Fdec | setze _Finc | setze _Finc | setze _Fdec |
V<-----´ V<-----´ V<-----´ V<-----´
MausA->W MausA->W MausA->W MausA->W
2-W->W 3-W->W 2-W->W 3-W->W
_Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--.
J | J | J | J |
V | V | V | V |
setze _Finc | setze _Fdec | setze _Fdec | setze _Finc |
V<-----´ V<-----´ V<-----´ V<-----´
return return return return

und Quellcode:

Mouse movf PORTB,0
andlw 3
movwf MausB
movwf MausC
call Delay ; ca. 10 ms
movf PORTB,0
andlw 3
movwf MausA
xorwf MausC,1
btfsc _Z
return
movf MausB,1
btfsc _Z
goto Mouse0
movf MausB,0
sublw 1
btfsc _Z
goto Mouse1
movf MausB,0
sublw 2
btfsc _Z
goto Mouse2
movf MausB,0
sublw 3
btfsc _Z
goto Mouse3
return
Mouse0 movf MausA,0
sublw 1
btfsc _Z
bsf _Fdec
movf MausA,0
sublw 2
btfsc _Z
bsf _Finc
return
Mouse1 movf MausA,1
btfsc _Z
bsf _Finc
movf MausA,0
sublw 3
btfsc _Z
bsf _Fdec
return
Mouse2 movf MausA,1
btfsc _Z
bsf _Fdec
movf MausA,0
sublw 3
btfsc _Z
bsf _Finc
return
Mouse3 movf MausA,1
sublw 1
btfsc _Z
bsf _Finc
movf MausA,0
sublw 2
btfsc _Z
bsf _Fdec
return

=== Handy Display ===

Als Beispiel die Hardware und Testprogram für Nokia 3310/3330 Display: [[http://www.roboternetz.de/phpBB2/viewtopic.php?p=124669#124669]]

= Hilfsmittel =

Hier werden einige Programme presentiert, die das ASM Programmieren erleichtern.
Damit sie möglichst wenig Data- und Programmspeicher benötigen, sind alle Zahlen auf dem Display in der hex Darstellung.
Für alle, die es in Dezimalsystem haben wollen, ist ein Taschenrechner mit hex<->dec Wandlung nötig.

== PIC Miniterminal ==

Das ist eine Schnittstelle, die nur 2 Leitungen zum Anschluss an PIC braucht. Sie ermöglicht das Steuern von diversen LCD Displays mit üblichem Anschluss ("RS", "Enable" und 8 Databits) und Abfragen von 3 Tasten.

Sie wird mit einem 2x16 Zeichen Matrixdisplay und 3 Tasten für weiter beschriebene Hilfsprogramme verwendet.

Hardware und Testprogramm: [[http://www.roboternetz.de/phpBB2/viewtopic.php?t=13685]]

== PIC RAM Monitor ==

Er wurde entwickelt um 16 Register (0x20 bis 0x2F) im RAM eines PICs auf dem Display von PIC Miniterminal, wie skizziert, beobachten zu können:

Register Adressen (hex) 20 21 22 23 24 25 26 27
.-----------------------.
Zweistelligen Werte (hex) |XX XX XX XX XX XX XX XX|
| |
|XX XX XX XX XX XX XX XX|
'-----------------------'
28 29 2A 2B 2C 2D 2E 2F

Um das zu ermöglichen, wenn wegen Fehler das ASM Programm in einer endloser Schleife "hängt", wurde Interrupt vom Timer0 angewendet. Dieser Timer wurde gewählt, weil er in allen PICs vorhanden ist. Das Programm zeigt die Registerinhalte auf dem Display ca. 1 mal pro Sekunde, wenn der PIC mit einem 20 MHz Quarz arbeitet. Für 4 MHz Quarz b.z.w. internen RC Oszillator muss die Interrupts-Anzahl in der ISR ( gezählt im "Int" Register) von 0x40 auf 0x10 reduziert werden, also "Int,4" anstatt "Int,6" prüfen.

PIC RAM Monitor wird so konzipiert, das er in jedes ASM Programm eingebunden werden kann. Er braucht insgesamt 93 Speicherstellen im Programmspeicher, 9 Register im RAM und 2 I/O Portpins des PICs für den er benutzt wird.

Der beobachtete ASM Programm darf, wegen ISR vom PIC RAM Monitor, erst ab der Adresse 0x0018 beginnen und nur bis zur Adresse 0x03AF gehen, da ab 0x03B0 im Programmspeicher der PIC RAM Monitor ist. Wenn ein benutzter PIC mehr Programmspeicher hat, kann der PIC RAM Monitor mit der "org" Direktive höher plaziert werden. Er belegt die 9 obersten Register im RAM (0x47 bis 0x4F), kann aber auch anderswo im RAM (z.B. in andere Bank) verlegt werden

Um "Kollisionen" mit dem Programm, in das er eingebunden wird, zu vermeinden, fangen alle seine Marken mit "@" an.

In dem beobachteten Programm müssen lediglich zwei Portpins, an die PIC Miniterminal angeschlossen wird, definiert und als Ausgang initialisiert werden. Ausserdem muss in die Initialisierung "@Init" eingefügt werden.

Hier der Quellcode:

; PIC RAM Monitor
@Tmp equ 0x4F
@Tmp1 equ 0x4E
@Tmp2 equ 0x4D
@Tmp3 equ 0x4C
@Tmp4 equ 0x4B
@Int equ 0x4A
@FSR equ 0x49
@SSR equ 0x48
@SWR equ 0x47
ORG 0x0004 ; ISR
bcf INTCON,GIE ; interrupts sperren
movwf @SWR ; W-Register sichern
movf STATUS,0 ; STATUS Register
movwf @SSR ; sichern
movf FSR,0 ; FSR Register
movwf @FSR ; sichern
btfss INTCON,T0IF ; Timer0 interrupt Flag prüfen
goto IntTest ; wenn nicht gesetzt, eventuell andere prüfen
bcf INTCON,T0IF ; Timer0 interrupt Flag löschen
incf @Int,1 ; Zähler erhöhen
btfss @Int,6 ; prüfen, ob schon 64d. Timer0 interrupt
goto $+3 ; wenn nicht, Anzeigen der Registerinhalte überspringen
clrf @Int ; Zähler löschen
call @ ; Anzeigen der Registerinhalte aufrufen
IntTest ;**************;
; eigener Code ;
;**************;
movf @FSR,0 ; FSR Register
movwf FSR ; wiederherstellen
movf @SSR,0 ; STATUS Register
movwf STATUS ; wiederherstellen
movf @SWR,0 ; W-Register wiederherstellen
retfie ; zurück ins Programm springen, interrupts erlauben
ORG 0x03B0
@ movlw 0x20 ; Anzeigen der Regisrerinhalte
movwf FSR
call @1st
call @Line
call @2nd
call @Line
return
@Line movlw 8
movwf @Tmp
movf INDF,0
call @Val
incf FSR,1
decfsz @Tmp,1
goto $-4
return
@1st movlw 0x80 ; schicke Adresse der 1. Zeile
goto @Cmd
@2nd movlw 0xC0 ; schicke Adresse der 2. Zeile
@Cmd movwf @Tmp2 ; schicke Befehl
bcf STATUS,C
goto @SendR
@Val movwf @Tmp1 ; schicke Zahl (0-FF)
swapf @Tmp1,0
movwf @Tmp4
call @Num
movf @Tmp1,0
movwf @Tmp4
@Num movf @Tmp4,0
andlw 0x0F ; schicke Ziffer (0-F)
movwf @Tmp2
movlw 0x0A
subwf @Tmp2,0
btfsc STATUS,C
addlw 7
addlw 0x3A
bsf STATUS,C
@Send movwf @Tmp2
@SendR movlw 9 ; schicke ein Byte aus @Tmp2 + RS (9 Bits)
movwf @Tmp3
@SerSend bcf @CK
bcf @DT
btfsc @Tmp2,7
bsf @DT
bsf @CK
rlf @Tmp2,1
decfsz @Tmp3,1
goto @SerSend
bcf @DT ; setze Display
bsf @DT ; Enable
movlw 0x30 ; warte
movwf @Tmp3
decfsz @Tmp3,1
goto $-1
bcf @CK ; lösche
bcf @DT ; Display
bsf @DT ; Enable
return
@Init bsf INTCON,GIE ; alle interrupts erlauben
bsf INTCON,T0IE ; Timer0 interrupt erlauben
bcf INTCON,T0IF ; Timer0 interrupt Flag löschen
bsf STATUS,RP0 ; auf Bank 1 umschalten
movf OPTION_REG,0 ; OPTION_REG in W-Register laden
andlw 0xC0 ; Timer0 konfigurieren
iorlw 7 ; Prescaler 256:1
movwf OPTION_REG ; ins OPTION_REG schreiben
bcf STATUS,RP0 ; zurück auf Bank 0 umschalten
movlw 0x38 ; Display vom PIC Miniterminal initialisieren
call @Cmd
movlw 0x0C
call @Cmd
movlw 6
call @Cmd
return
end

Und hier ein Beispiel für eine Anwendung mit dem Programm "Erstes.asm" für PIC16F84A:

list P=16F84A ; Prozessor definieren
include "P16F84A.inc" ; 20.000 MHz
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _HS_OSC
#define @DT PORTB,7 ; * definiere Anschlüsse @DT und @CK
#define @CK PORTB,6 ; * für "PIC RAM Monitor"
#define _T1 PORTB,5 ; Portpins benennen
#define _T2 PORTB,4
#define _L1 PORTB,3
#define _L2 PORTB,2
#define _L3 PORTB,1
#define _L4 PORTB,0
P0 equ 0x20 ; Variablen definieren (Register benennen)
P1 equ 0x21
P2 equ 0x22
org 0x0000 ; hier fängt das gesamte ASM Programm an
call Init ; rufe UP Init (Initialisierung) auf
goto Haupt
org 0x0018
Haupt btfsc _T1 ; prüfe, ob Taster T1 gedrückt ist, wenn ja,
; überspringe "goto T2Test"
goto T2Test ; wenn nicht, springe zu T2Test
bsf _L1 ; schalte LED1 an (setze den Pin 2 auf "1")
call Warten ; warte ca. 0,4 s (400 000 Prozessortakten)
bcf _L1 ; schalte LED1 aus (setze den Pin2 auf "0")
bsf _L2 ; schalte LED2 an (setze den Pin 5 auf "1")
call Warten ; warte
bcf _L2 ; schalte LED2 aus (setze den Pin 5 auf "0")
bsf _L3 ; schalte LED3 ein (setze den Pin 6 auf "1")
call Warten ; warte
bcf _L3 ; schalte LED3 aus (setze den Pin 6 auf "0")
bsf _L4 ; schalte LED4 ein (setze den Pin 7 auf "1")
call Warten ; warte
bcf _L4 ; schalte LED4 aus (setze den Pin 7 auf "0")
T2Test btfsc _T2 ; prüfe, ob Taster T2 gedrückt ist, wenn ja,
; überspringe "goto Haupt"
goto Haupt ; Wenn nicht, springe zu Haupt
bsf _L4 ; schalte LED4 ein (setze den Pin 7 auf "1")
call Warten ; warte
bcf _L4 ; schalte LED4 aus (setze den Pin 7 auf "0")
bsf _L3 ; schalte LED3 ein (setze den Pin 6 auf "1")
call Warten ; warte
bcf _L3 ; schalte LED3 aus (setze den Pin 6 auf "0")
bsf _L2 ; schalte LED2 an (setze den Pin 5 auf "1")
call Warten ; warte
bcf _L2 ; schalte LED2 aus (setze den Pin 5 auf "0")
bsf _L1 ; schalte LED1 an (setze den Pin 2 auf "1")
call Warten ; warte
bcf _L1 ; schalte LED1 aus (setze den Pin2 auf "0")
goto Haupt ; springe zu Haupt
Warten movlw 0x0A ; schreibe "0x0A" (10d) für ca. 0,4 s
movwf P2 ; ins Register P2
clrf P1 ; lösche Register P1 (schreibe "0" für 256 Durchläufe)
clrf P0 ; lösche Register P0 (schreibe "0" für 256 Durchläufe)
decfsz P0,1 ; dekrementiere P0 und überspringe nächsten Befehl bei P0 = 0
goto $-1 ; gehe zur voherigen Adresse (Befehl "decfsz P0")
decfsz P1,1 ; dekrementiere P1 und überspringe nächsten Befehl bei P1 = 0
goto $-4 ; gehe zur aktueller Adresse - 4 (Befehl "clrf P0")
decfsz P2,1 ; dekrementiere P2 und überspringe nächsten Befehl bei P2 = 0
goto $-7 ; gehe zur aktueller Adresse - 7 (Befehl "clrf P1")
return ; springe zurück zum Aufrufer ("Haupt"),
Init clrf PORTB ; lösche Port (setze alle werdende Ausgänge auf "0")
bsf STATUS,RP0 ; auf Bank1 umschalten
bcf OPTION_REG,7 ; aktiviere pull-ups
movlw 0x30 ; definiere PortB: Pins 5 und 4 als Eingänge
; und die restlichen als Ausgänge
movwf TRISB ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
goto @Init ; * initialisiere "PIC RAM Monitor"
; hier endet das gesamte ASM Programm
include "PIC RAM Monitor.asm"
end

Mit dem "*" wurden 3 Zeilen gekenzeichnet, die, in das mit PIC RAM Monitor beobachtetes ASM Programm, eingefügt werden müssen.

Falls im beobachteten ASM Programm Interrupts benutzt werden, muss die ISR um die Prüfungen anderen Interrupt Flags ergänzt werden, was in der ISR als "eigener Code" eingetragen ist. Der PIC RAM Monitor reagiert nur auf Timer0 Interrupt Flag.

[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Category:PIC]]

PIC Assembler

2007-05-05T07:02:22Z

Andy: /* PIC Miniterminal */

= Einladung zur Diskussion... =

Es wird hier versucht die ASM Programmierung von PIC Mikrocontrollern möglichst kurz zu beschreiben.

Damit der enstehende Artikel wirklich nützlich wird, ist Ihre Mitwirkung nötig. Bitte schreiben Sie uns Ihre Meinung, was eventuell noch geändert (z.B. ergänzt) werden soll in diesem Thread:

http://www.roboternetz.de/phpBB2/viewtopic.php?p=271211#271211

Die Autoren bedanken sich im voraus für jeden Beitrag mit Vorschlägen !

= Einführung =

== Bit, Byte, Nibble, Bin und Hex ==

Ein Mikrocontroller (kurz: µC) kann eigentlich nur durch ein Portpin eine Spannung einlesen bzw. ausgeben. Er kann aber nur erkennen, ob eine Spannung vorhanden ist oder nicht. Wenn fast keine Spannung vorhanden ist erkennt er das als 0 und wenn eine Spannung fast so gross, wie seine Versorgungsspannung anliegt, als 1.

Genauso bei der Ausgabe, wenn er 0 ausgibt ist auf dem Portpin fast keine Spannung, wenn 1, eine Spannung fast gleich gross seiner Versorgungsspannung. Und das ist ein Bit, die kleinste Menge einer Information. Das Bit ist binär, d.h. es kann nur zwei unterschiedliche Werte haben: 0 oder 1.

Wenn wir gleichzeitig (parallel) 8 Bits haben, dann ist es ein Byte, das 256 Bitkombinationen von 00000000b bis 11111111b enhält, weil ein Bit (X) auf jeder Stelle 0 bzw. 1 sein kann.

<table border=0 cellpadding=3 cellspacing=2>

<tr>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
</tr>

<tr>
<td colspan=4 align=middle bgcolor=#007fff>High Nibble </td>
<td colspan=4 align=middle bgcolor=#ff8305>Low Nibble </td>
</tr>
<tr>
<td colspan=8 align=middle bgcolor=#810f40> Byte </td>
</tr>
</table>

Das "b" bedeutet, dass es sich um binäre (kurz: bin) Darstellung (auch Zahl genannt) handelt. Binäre Zahlen sind aber lang, weil jedes Bit eine Stelle benötigt.

Um die Schreibweise zu verkürzen, wurden hexadezimale (kurz: hex) Zahlen eingeführt. Zuerst wurde ein Byte auf zwei 4-Bit Halbbytes (Nibbles) verteilt und danach ein Nibble als Ziffer genommen. Weil 4 Bits 16 Kombinationen ergeben, haben die Ziffer 0 bis 9 aus dem Dezimalsystem (d) nicht ausgereicht und wurden um Buchstaben A bis F erweitert. Die hexadezimalen Zahlen haben ein "h" Zeichen am Ende. Für die Zahlen 0 bis 9 sind die (h) und
(d) Zeichen nicht nötig, da sie beide gleich den entsprechenden bin Zahlen sind.

Die Umwandlung zwischen bin, hex und dec Zahlen für ein Nibble zeigt folgende Tabelle:

0b = 0h = 0d 100b = 4h = 4d 1000b = 8h = 8d 1100b = Ch = 12d
1b = 1h = 1d 101b = 5h = 5d 1001b = 9h = 9d 1101b = Dh = 13d
10b = 2h = 2d 110b = 6h = 6d 1010b = Ah = 10d 1110b = Eh = 14d
11b = 3h = 3d 111b = 7h = 7d 1011b = Bh = 11d 1111b = Fh = 15d

Damit kann ein Byte mit zwei hex Ziffern definiert werden z.B. 1100 0011b = C3h. Für zwei Bytes braucht man 4 hex Ziffern z.B.

101 0111 1010 1001b = 57A9h, u.s.w. Für MPASM wird sehr oft die Schreibweise für hex Zahlen 0x57A9 oder 0xC3 benutzt.

So wie im Dezimalsystem werden führende Nullen nicht geschrieben. Bei einer Wandlung bin->hex fängt man immer von der rechten Seite der bin Zahl an, da die Anzahl führender Nullen unbekannt ist.

== Speicher und Register ==

Als Speicher bezeichnet man das Teil der Hardware, in das eine Information geschrieben, gespeichert und von dort wieder ausgelesen werden kann.

Es gibt eigentlich nur zwei Arten von elektronischen Speichern: flüchtige und nichtflüchtige. Die Information die sich im flüchtigen Speicher befindet, geht verloren, wenn die Versorgungsspannung des Speichers unterbrochen oder abgeschaltet wird. Bei PICs ist es Datenspeicher (RAM).

Wenn die Versorgungsspannung vom nichtflüchtigen Speicher abgeschaltet wird, ist die gespeicherte Information zwar momentan nicht lesbar, bleibt aber erhalten und sobald der Speicher wieder mit Spannung versorgt wird, kann sie ausgelesen werden. Ein PIC hat zwei solche Speicher: Programmspeicher (Flash) und EEPROM.

Der wichtigste Unterschied zwischen den Speicherarten ist, dass die flüchtigen direkt (sehr schnell) beschreibbar sind, dagegen das Beschreiben des nichtflüchtigen Speichers spezielle Algorithmen benötigt, die im Vergleich zu direkten Zugriffen langsamer sind. Beim Auslesen gibt es praktisch keinen Unterschied.

Speicher besitzen eine bestimmte Menge von s.g. Speicherstellen. Jede Speicherstelle hat eine individuelle Adresse und kann eine binäre Information mit bestimmter Anzahl von Bits abspeichern.

PIC Prozessoren haben drei Arten von Speicher, wegen verschiedener Anwendung, auch unterschiedliche Struktur. Die beiden Speicher für Daten (RAM und EEPROM) haben jeweils 8 Bit Breite und Programmspeicher (Flasch) bei Mid-Range hat 14-bitige Speicherstellen. Die Anzahl den Speicherstellen im bestimmten Speicher ist vom PIC-Typ abhängig.

Eine 8-bitige Speicherstelle im RAM wird bei PICs Register genannt und kann so skizziert werden:

<table border=0 cellpadding=3 cellspacing=2>

<tr>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
</tr>

<tr>
<td> MSB </td>
<td colspan=6></td>
<td> LSB </td>
</tr>

<tr>
<td bgcolor="#007fff">bit 7</td>
<td bgcolor="#007fff">bit 6</td>
<td bgcolor="#007fff">bit 5</td>
<td bgcolor="#007fff">bit 4</td>
<td bgcolor="#007fff">bit 3</td>
<td bgcolor="#007fff">bit 2</td>
<td bgcolor="#007fff">bit 1</td>
<td bgcolor="#007fff">bit 0</td>
</tr>

<tr>
<td colspan=4 align=middle bgcolor=#ff8305>High Nibble </td>
<td colspan=4 align=middle bgcolor=#ff8305>Low Nibble </td>
</tr>
<tr>
<td colspan=8 align=middle bgcolor=#810f40> Byte </td>
</tr>
</table>

Bit 7 wird als hochwertigstes (MSB = Most Significant Bit) und bit 0 als niederwertigstes (LSB = Least Significant Bit) bezeichnet. Jedes Bit im Register (X) kann gleich 0 bzw. 1 sein. In einem Register existieren immer 8 Bits also auch führende Nullen. Zum Beispiel die hex Zahl 3 sieht im PIC Register so aus: 00000011.

Um ein Datenbyte in ein Register zu schreiben oder aus einem Register zu lesen, muss zuerst das Register durch seine Adresse gewählt werden. Dafür gibt es beim PIC folgende Möglichkeiten:

Direkte Adressierung per absolute Adresse: movwf 0x20

Direkte Adressierung per vorher definiertem Namen des Registers (z.B. Temp equ 0x20): movwf Temp

Indirekte Adressierung durch "FSR" Register, in das die absolute Adresse des Registers "Temp" eingeschrieben wird. Durch Zugriff mittels "INDF" Register wird auf die Speicherstelle zugegriffen, die durch das Register "FSR" adressiert wird. (INDF ist dabei kein real in Hardware implementiertes Register.) Wie vorher wurde "Temp equ 0x20" definiert und weiter:

movlw Temp ;ins W-Register wird die absolute Adresse des Registers "Temp" geladen
movwf FSR ;diese Adresse wird ins "FSR" Register kopiert
movf INDF,0 ;der Wert aus dem indirekt adressierten Register "Temp"
;wird ins W-Register geladen.

Weil in jedem 14-bittigen Befehl, der mit Datenspeicher verbunden ist, für die Adresse des ansprechenden Registers nur 7 Bits existieren, die bis zur Adresse 7Fh (128d) Register direkt ansprechen können, ist bei PICs der Datenspeicher (RAM) in s.g. Bänke verteilt.

Für Auswahl einer Bank sind zwei Bits "RP0" und "RP1" im "STATUS" Register zuständig. Die Anzahl der Bänke und ihre Verwendung ist von der gesamten Größe des RAMs abhängig und kann dem Datenblatt des PICs entnommen werden. Siehe: [[#Speicherbankorganisation|Speicherbankorganisation]]

== Prozessor ==

Der Prozessor von Mid-Range PICs gehört zu den RISC (Reduced Instruction Set Computer) Prozessoren und man hat nur 35 Befehle zu erlernen, was seine Programmierung im Vergleich zu anderen µCs deutlich vereinfacht. Jeder Befehl benötigt im Programmspeicher nur eine Speicherstelle und im Quellcode nur eine Zeile. Die Ausführung des Befehls dauert, abhängig vom Befehl, 1 bis 2 Prozessortakte.

Die Prozessoren der Mid-Range Serie von Microchip sind alle in der "Harvard"-Architektur gefertigt. Das bedeutet, dass Datenspeicher und Programmspeicher einen eigenen Bus zur CPU (Central Processing Unit) besitzen. Der Vorteil zur "von Neumann"-Architektur ist, dass sich die Busgrößen damit unterscheiden können. Das ermöglicht eine größere Bandbreite.

Der Befehl (beim PIC 14 bit) kann in nur einem Takt verarbeitet werden. Daher kommt auch das Aufteilen der Ausführung des Befehls in 4 verschiedene Vorgänge. Wärend der neue Befehl eingelesen ("fetch") wird, wird der vorige gerade gelesen ("read") und der vorvorige verarbeitet ("execute") und der vorvorvorige schreibt gerade in den Datenspeicher ("write"). Das heißt, 4 Befehle werden jeweils um einen Oszillatortaktzyklus verschoben gleichzeitig verarbeitet.

Das geschieht in vier Perioden des Oszillators. Deswegen entspricht die Taktfrequenz der CPU der durch 4 geteilten Frequenz des Oszillators.

CPU Vorgang Richtung Speicher
------------------------------------------------- -
1.Befehl lesen (fatch) <------- Flash |
2.Daten lesen (read) <------- RAM | 1 Prozessortakt =
3.Daten verarbeiten (execute) | 4 Oszillatortakte
4.Daten schreiben (write) -------> RAM |
-

Nur o.g. CPU Vorgänge sind direkt möglich. Es können deswegen keine Befehle aus dem RAM oder EEPROM ausgeführt werden. Um ein Databyte aus einem RAM Register in ein anderes zu kopieren, muss er zuerst aus dem ersten RAM Register in das W-Register (eigenen s.g. Arbeitsregister des CPU) und erst davon in das zweite RAM Register kopiert werden.

Der Prozessor hat kleinen eigenen Speicher, der weder zum Programmspeicher noch zum Datenspeicher gehört. Er besteht aus dem Programmzähler PC (programm counter) und dem Stapel (stack).

In dem PC befindet sich die 13-Bittige Adresse des momentan ausfürbaren Befehls. Nach der Ausführung jedes Befehls wird der PC um 1 erhöht und "zeigt" somit auf den nächsten Befehl im Programmspeicher, der zum Ausführen wäre. Wenn der nächste Befehl aber ein Sprung ("call") ist, wird die Adresse aus dem Befehl genommen. Nach dem Sprung wird das Programm bis zum Befehl "return" ausgeführt und danach muss der Prozessor zurückspringen, und zwar, genau zur nächsten Adresse im Programmspeicher nach dem "call" Befehl. Damit es möglich wäre, wird vor dem Sprung die Adresse aus dem PC "auf dem Stapel gelegt" (gespeichert). Für den Rücksprung wird die abgelegte Adresse "aus dem Stapel genommen" (vom Stapel in den PC geladen).

Der Stapel kann aber nur 8 Adressen speichern, deswegen dürfen nur 8 nacheinander folgende "call" Befehle benutzt werden. Sonst findet der Prozessor nicht mehr zurück und in die "Nirvana" springt, was einen Absturz des Programms bedeutet.

Das Lesen/Schreiben aus/in den EEPROM Speicher ist mit Hilfe speziellen Register und Unterprogrammen bei allen Mid-Range PICs möglich. Der Lese und Schreibzugriff auf den Programmspeicher ist aber nur bei wenigen PIC-Typen (z.B. PIC16F87X) möglich. Dies ermöglicht ein "sich selbst Programmieren", was bei Bootloadern genutzt wird.

== Assembler ==

Die Maschinensprache, auch Assembler oder kurz ASM genannt, ist eine Sprache die nur eine bestimmte CPU versteht. Für einen Menschen ist sie unverständlich, da sie nur aus 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 einen CPU hat somit ein "Namen", der aus der englischen Sprache stammt. Siehe: [[#Kurzübersicht Assembler Befehle|Kurzübersicht Assembler Befehle]]

Obwohl sie 200 bis 1000 mal schneller als die meisten Hochsprachen ist, wird sie, wegen des grossen Aufwands bei der Erstellung von umfangreichen Programmen, selten benutzt. Man findet sie aber oft in fast allen Hochsprachen, in eigebundenen Funktionen, überall dort wo die Hochsprachen zu langsam sind oder die nötigen Aufgaben nicht unterstützen (z.B. Maus in Q-Basic).

ASM eignet sich sehr gut für kleine Anwendungen (meistens Steuerungen) mit µC, weil nur bei dieser Programmiersprache ein direkter Zusammenhang zwischen einem Bit im Programm und einer Spannung am I/O Pin besteht.

Dank der integrierten oder an Portpins angeschlosenen Hardware und dem entsprechenden Program kann ein µC umfangreiche Aufgaben realisieren, die fast unbegrenzt und schwer vorstellbar sind.

Die Aufgabe eines ASM-Programmierers ist, ein Programm zu schreiben, das das Assemblerprogramm (z.B. MPASM) fehlerfrei in die Machinensprache assembliert ("übersetzt"), die dann eine bestimmte CPU "versteht". Sie endet eigentlich erst dann, wenn das geschriebene Programm so wie geplant funktioniert.

Die beste Methode um ASM Programmierung zu lernen ist einfach mit den Befehlen, wie mit "LEGO" Bausteinen, zu spielen. Der PIC kann durch ein Programmfehler nicht kaputtgehen. Vorsicht ist nur bei der angeschlossener Hardware nötig, da ein Fehler den PIC oder die Hardware sogar "töten" kann.

Weil ASM Programme nicht besonders durchschaubar sind, wurde als Hilfsmittel ein Programmablaufdiagramm (kurz: PAD) erfunden. Bei der 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 [http://gputils.sourceforge.net/ GPASM]) von dem für Menschen noch verständlichen Code in die Maschinensprache assembliert 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 Homepage des Herstellers von PICs [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en019469&part=SW007002] runtergeladen werden. Es muss zuerst vom Downloads die "MPLAB IDE v7.50 Full Zipped Installation" runtergeladen und erst danach können gewählte Programme (z.B. nur MPASM) intalliert werden. Für MPASM benutzer werden auch folgende ".pdf" Dateien empfohlen:

MPASM/MPLINK User's Guide (2628 KB) [Benutzerhandbuch]

MPASM™/MPLINK™ PICmicro® Quick Chart (81 KB) [Kurzübersicht]

Nach dem Eischalten der Betriebsspannung des µC, fängt der CPU an, sich im Programmspeicher befindliches Programm mit dem Befehl, der an der Adresse 0 steht, auszuführen.

Aber wann das Programm endet? Natürlich wenn die Versorgungsspannung abgeschaltet wird. Nein! Das ist die einfachste Lösung um ein laufendes Programm an zufälliger Stelle zu unterbrechen,
aber keine, um es an einer definierten Stelle zu beenden.

Wenn an den µC angeschlossene externe Hardware (z.B. Grafikdisplay), eine bestimmte Befehlsfolge vor dem Abschalten benötigt oder wichtige Daten (in EEPROM oder Flash) abgespeichert werden sollen, darf die Spannung erst dann abgeschaltet werden, wenn die CPU eine Meldung ausgibt, dass sie sich schon auf der "STOP" Stelle des Programms befindet. Es muss auch
definiert werden (z.B. durch eine Tastenkombination), wann die CPU zum letzten Fragment des ASM Programms vor dem "STOP" gehen soll.

== Grundbeschaltung ==

Der Prozessor von einem PIC kann sofort nach dem Einschalten der Versorgungsspannung (z.B. + 5V DC) arbeiten. Allerdings nur, wenn er den Takt, in dem er die Befehle ausführen soll, vorgegeben hat. Manche PICs besitzen einen internen RC-Oszillator, (z.B. PIC12F629, PIC16F630, PIC16F628, u.s.w.). Bei diesen reicht es bereits Spannung anzulegen und sie laufen bereits.
Die meisten haben ihn aber nicht (z.B. PIC16F84, PIC16F870, u.s.w.) und brauchen fürs Funktionieren zusätzliche Bauteile. Grundsätzlich gibt es mehrere Möglichkeiten:

* Quarz oder Keramik-Resonator + 2 Kondensatoren (LP,HS oder XT)
* Keramik-Resonator mit integrierten Kondensatoren (HS oder XT)
* Quarzoszillator (EC); genau und stabil
* Widerstand + Kondensator (RC); keine hohe Frequenzstabilität

Die entsprechenden Bauteile werden an die Pins OSC1/OSC2 angeschlossen, um den notwendigen Prozessortakt zu erzeugen. Im Konfiguration-Word "__config" muss noch angegeben werden, welcher Oszillator verwendet wird.

Desweiteren existiert ein MCLR-Pin, der beim PIC einen Neustart (=Reset) auslösen kann (Low-Pegel). Diesen Pin sollte man, wenn er in "__config" aktiviert ist, über einen Widerstand (pull-up) an Versorgungsspannung legen, damit der PIC anfängt, sein Programm abzuarbeiten. Der Anschluss wird auch für die Programmierung benötigt. Beim sog. High-Voltage-Programming wird MCLR auf ca. 12-14 Volt gelegt, um den PIC in den Programmiermodus zu schalten. Bei manchen PICs kann dieser Anschluss auch als normalen I/O Pin eingestellt werden. In dem Fall, bei ICSP Benutzung, soll noch eine Diode zwischen den pull-up und Versorgungsspannung angeschlossen werden, um die an MCLR Pin angeschlossene Hardware während der Programmierung zu schützen.

Bei externen Oszillatoren bleibt der Pin OSC2 nicht angeschlossen und kann als I/O benutzt werden. Falls ein interner Oszillator benutzt wird, können beide OSC Pins als I/O dienen.

Damit ein Programm zuverlässig ausgeführt werden kann, muss die Versorgungspannung störungsfrei sein. Dafür wird ein Keramik-Vielschicht-Kondensator 100 nF möglichts am kürzesten direkt zwischen VDD und VSS Pins geschaltet.

Folgende Skizzen zeigen die Grundbeschaltung eines PICs:

{|
|-
|
[[Bild:Pic-entstoer.png|thumb|160px|Entstörkondensator beim PIC]]
|
[[Bild:Qz-os.png|thumb|160px|Quarz ]]
|
[[Bild:Qos-os.png|thumb|160px|externer Quarzoszillator]]
|
[[Bild:Rc-os.png|thumb|160px|externer RC-Oszillator]]
|}

== Konfiguration ==

Die Konfiguration eines PICs wird beim "brennen" fest programmiert. Sie ist eigentlich für fast jeden PIC-Typ anders. Um Probleme zu vermeinden, muss sie für bestimmten PIC aus einer im MPASM Verzeichnis enthaltenen Datei "PXXFXX.INC" entnommen werden. Die Erklärung der Optionen befindet sich im entsprechenden Datenblatt unter "Special Features of the CPU"

Als Beispiel für PIC16F84 haben wir in der Datei "P16F84.INC":

;==========================================================================
;
; Configuration Bits
;
;==========================================================================

_CP_ON EQU H'000F'
_CP_OFF EQU H'3FFF'
_PWRTE_ON EQU H'3FF7'
_PWRTE_OFF EQU H'3FFF'
_WDT_ON EQU H'3FFF'
_WDT_OFF EQU H'3FFB'
_LP_OSC EQU H'3FFC'
_XT_OSC EQU H'3FFD'
_HS_OSC EQU H'3FFE'
_RC_OSC EQU H'3FFF'

Wobei:

_CP_ON - Programmspeicher ist vorm Auslesen geschützt
_CP_OFF - Programmspeicher kann ausgelesen werden (ist nicht geschützt)
_PWRTE_ON - Das Programm wird mit Verzögerung von ca. 72 ms nach dem Einschalten gestartet
_PWRTE_OFF - Das Program wird sofort nach dem Einschalten gestartet
_WDT_ON - Watchdog Timer ist aktiv
_WDT_OFF - Watchdog Timer ist unaktiv

Die alle folgende Optionen beziehen sich an den Oszillatortyp:

_LP_OSC - Oszillator bis ca. 200 kHz (z.B. Uhrenquarz 32768 Hz)
_XT_OSC - Oszillator bis ca. 3,5 MHz
_HS_OSC - Oszillator über 3,5 MHz (z.B. 4 MHz)
_RC_OSC - Externer RC Oszillator

Die Konfiguration wird im Quellcode (*.asm Datei) mit Direktive "__config" definiert, z.B. so:

__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _XT_OSC

Alle Optionen müssen groß geschrieben sein, genauso wie in der "*.inc" Datei.

== Wahl des PICs ==

Es gibt PIC µC die in der Typenbezeichnung den Buchstaben "C" oder "F" haben.

Die älteren mit "C" haben EPROM Programmspeicher und die gibt es in zwei Versionen: ohne und mit Fenster (aus Quarz-Glass) fürs Löschen des EPROMs mit UV Strahlung. Bei denen ohne Fenster kann der Programmspeicher nur einmal beschrieben und nicht mehr gelöscht werden.

Die neuen mit "F" besitzen einen Flash-Programmspeicher, der bis zu 100 000 mal mit angelegter Spannung gelöscht und danach neu beschrieben werden kann.

Für die Wahl eines PICs für bestimmte Anwendung wichtig sind:

- Max. Taktfrequenz des Prozessors.

- Grösse des Datenspeichers (für Variablen).

- Grösse des Programmspeichers (für Programm).

- Integrierte Hardware (Komparatoren, A/D Wandler, Timer, USART, I²C, SPI, PWM, u.s.w.).

- Freie I/O Pins für externe Hardware (Display, Tasten, u.s.w.).

- Vorhandene Betriebspannung (Netzteil, Akku, Batterie).

In der Praxis wird meistens für die Programmerstellung ein grösserer PIC genommen (wenn möglich pinkompatibler z.B. PIC16F628 für PIC16F84 oder PIC16F630 für PIC12F629) und erst nach der Optimierung des lauffägiges Programms, der tatsächlich nötige, da seine Parameter am Anfang nur geschätzt werden können. Wenn man viele Programme für verschiedene PICs entwickelt, wäre der größte PIC16F877 mit 20 MHz max. Taktfrequenz optimal.

Diese Lösung hat auch den Vorteil, dass während der Programmerstellung kurze Hilfsprogramme (z.B. PIC Trainer) in den Programmspeicher kopiert und benutzt werden können, da sie sowohl ein bischen Programmspeicher und RAM als auch 2 freie I/O Pins fürs PIC Miniterminal brauchen.

= Programm =

== Allgemeines ==

Jedes Program kann man in kleinere Fragmente unterteilen, die auf bestimmte Weise miteinander verknüpft sind und gemeinsam die Aufgabe des Programms erfüllen. Das wichtigste Teil eines Programms ist das s.g. Hautprogram (kurz:HP), das eine führende Rolle spielt. Dem HP sind fast 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 komplizierter, da ein UP auch ein oder mehrere UPs nacheinander aufrufen kann. Ganz unten sind die UP1s, die ganz einfache Sachen erledigen. Höher ist 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 ohne Tricks maximal bis zu 8 Ebenen benutzt werden, da auf dem Stapel (stack) nur max. 8 Rücksprungadressen abgespeichert werden können. Siehe hierzu: [[#Prozessor|Prozessor]] und [[#Programmspeicher|Programmspeicher]]

<center>
[[Bild:HP-UP.png|Hauptprogramm - Unterprogramm]]
</center>

Jedes UP kann jederzeit aufgerufen werden, je nach dem was gerade eledigt werden muss. Weil das nicht egal ist, welches UP aufgerufen wird, da jedes nur eine bestimmte Funktion im Programm hat, muss der Programmierer dafür sorgen, dass alles richtig nach Programablaufdiagramm, und nicht chaotisch, abläuft.

Die Programmierung in ASM ist ähnlich 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 Programm kopieren oder einbinden und ein geeignetes HP, das sie aufruft, schreiben.

Ein ASM Programm (Quellcode) muss in einer Texdatei mit der Endung ".asm" in der vom Assemblerprogramm erwarteten Form verfasst werden, um die fehlerfreie Konvertierung in die Maschinensprache (Assemblierung) zu gewährleisten. Dieser Prozess verläuft in der Form eines Dialoges.

Der Programmierer schreibt und gibt es dem Assemblerprogramm zum Übersetzen. Alles was der Assembler nicht versteht oder nicht richtig ist, erscheint als Fehlermeldungen, die der Programmierer kennen muss, um die Fehler korrigieren zu können. Eine ".hex" Datei wird erst dannn erstellt, wenn das Assemblerprogramm keine Fehler mehr im Quellcode findet. Deswegen ist es sehr wichtig, sich mit dem Assemblerprogramm vertraut zu machen, um die Dialogzeit zu minimieren.

== Programmdurchlaufdiagramm ==

Der Programdurchlaufdiagram (kurz: PAD) ist eine vorläufige und laufend änderbare Stufe zwischen einer Idee und ihrer Verwirklichung. Die Kreativität des Programmierers ist nur für die Erstellung des PADs nötig. Jedes sein Symbol (ausser "Start/Stop") muss als Befehlsreihenfolge für einen bestimmten Prozessor in den Quellcode übertragen werden. Das ist aber nur reine "Übersetzung". Der Quellcode ist nur eine andere Form des PADs und hoffentlich wird es zukünftig Komputerprogramme geben, die ein PAD direkt in eine "*.hex" Datei für bestimmten Prozessor wandeln werden. Zur Zeit muss die "Übersetzung" leider vom Programmierer gemacht werden. Der PAD wird erst dann fertig, wenn nach ihm erstelltes ASM Program auf einem µC so wie gewünscht funktioniert.

Die Anschriften "Ein" und "Aus" gehören nicht zu Symbolen des PADs und wurden nur zur Erklärung benutzt.

[[Bild:PAD_beispiel.png|thumb|80px|Beispiel für ein PAD]]

Der PAD ist sehr eifach zu erstellen, weil dafür nur drei Symbole benötigt sind:
<center>
[[Bild:PAD_kurz.png|Symbole des PAD]]
</center>
Das "Start/Stopp" Symbol bedeutet, dass das gesamte Programm sich im stabilen Zustand befindet und nicht "läuft". Anstatt "Stopp" kann auch "Schlaf" (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 eines Programms, endweder in der "ja" (J) oder "nein" (N) Richtung.

Als allgemeinnutziges Standard für µCs kann man folgender PAD bezeichnen:

PAD _____
/ \
Spannung ein (Ein) ----->( Start )
\_____/
| -
V |
.---------------. |
|Initialisierung| |
'---------------' |
| |
.--------->V |
| .---------------. |
| | Hauptprogramm | |
| '---------------' |
| | |
| V |
| A |
| / \ > Gesamtes Programm
| / \ |
| /Ende \____ |
| \ ? / J | |
| \ / | |
| \ / | |
| V | |
| N| | |
`----------´ | |
V |
.---------------. |
| Beenden | |
'---------------' |
| |
V -
_____
/ \
Spannung aus (Aus) <-------------( Stopp )
\_____/

Das Hauptprogram wird in einer endlosen Schleife ausgeführt, die durch die Prüfung "Ende?" unterbrochen werden kann. In dem Fall wird vor dem Beenden des gesammten Programms noch ein UP "Beenden" ausgeführt, das z.B. Daten im EEPROM speichert.

Es ist nicht nötig, immer die Symbole zu zeichnen, man kann sie sich vorstellen und nur den Text schreiben. Die Prüfungen werden mit "?" gekenzeichnet und die Zeichen "V", "A", "<" und ">" zeigen die Richtung des weiteren Verlaufs. Dann sieht der PAD so aus:

Ein > Start
V -
Initialisierung |
.------->V |
| Hauptprogramm > Gesamtes Programm
| V |
| Ende? J > Beenden |
| N V -
| V Stopp > Aus
`--------´

Man kann auch die unbedeutenden Richtungspfeilen weg lassen:

PAD1 Ein > Start _
Initialisierung |
.------->V | Gesamtes
| Hauptprogramm | Programm
| Ende? J > Beenden _|
| N Stopp
| V V
`--------´ Aus

In der Praxis werden aus Platzgründen meistens die vereinfachten PADs benutzt. Als "movxx" wird oft ein Zeichen "->" benutzt. Zum Beispiel "A->W" bedeutet, dass der Inhalt des A Registers ins W-Register geladen (kopiert) wird. Ausserdem werden Zeichen ("+", "-", "*", "/", "^", u.s.w.) für arithmetische und ("&", "or", "xor", u.s.w.) für logische Operationen angewendet. In den Quellcode werden für diese Zeichen entsprechende Befehle geschrieben. Beispiel:

V
10h->W
W+B->B
V

wird im Quelcode so aussehen:

...........
movlw 10h
addwf B,1
...........

Siehe auch: [[#Das erste...|Das erste...]] und [[#Mausrad|Mausrad]]

Der PAD1 kann aber für Hauptprogramme, die in beliebigem Moment unterbrochen werden dürfen, deutlich vereinfacht werden, da die Prüfung "Ende?" ob das Hauptprogram beendet werden soll, und das UP "Beenden", entfallen.

Die meisten ASM Programme für µC sind deswegen nach solchem PAD erstellt:

PAD2 Ein > Start _
Initialisierung |
.------->V |
| Hauptprogramm > Gesamtes Programm
| V |
`--------´ _|

Für Testprogramme wird meistens fogender PAD angewendet, weil es ziemlich einfach festzustellen
ist (z.B. durch Stromverbrauchmessung des µCs), wann sich die CPU schon im Schlaf befindet. Erst dann, darf die Betriebspannung des µCs ausgeschaltet werden.

PAD3 Ein > Start _
Initialisierung | Gesamtes
Hauptprogramm _| Programm
Schlaf > Aus

Und eine batteriebetriebene Uhr wird überwiegend so gestaltet:

PAD4 Ein > Start _
Interrupt Initialisierung |
Timer------------------------->V > Gesamtes Programm
Hauptprogramm _|
Schlaf

In dem Fall reicht es aus, wenn der CPU jede Minute vom Timer aufgeweckt wird, um die Zeit zu aktualisieren. Eine Uhr ist immer (ausser Batteriewechsel) ununterbrochen mit Spannung versorgt.

Für komplizierte Programme ist es praktisch unmöglich ein PAD zu erstellen, in dem jeder CPU Befehl sein eigenes Symbol hat. Man beschränkt sich nur auf alle Prüfungen, die über den Lauf des Programms entscheiden, und ganze UPs (z.B. "Initialisierung") nur als ein Symbol verwendet. Für jedes UP wird dann ein eigener PAD erstellt.

Das Erstellen von PAD bei ASM Programmen ist sehr wichtig und darf nicht unterschätzt werden. Je stärker ein Programmierer glaubt, dass er das ohne PAD schafft, um so mehr Zeit wird er danach bei Fehlersuche oder Änderungen im ASM Programm verlieren.

Beispiel aus dem Alltag:

"Das programm hat anfangs auf Anhieb funktioniert. Doch leider habe ich dann was geändert was ich nicht mehr weiß. Das Programm macht nun komische Sachen...... Ich kann mir nicht erklären warum, kann mir jemand helfen???"

Für einfache ASM Programme, die gut kommentiert sind, reicht es meistens aus, ein PAD nur "im Kopf" zu erstellen, aber ganz ohne PAD geht es sicher nicht.

Der PAD kann auch benutzt werden, um einen "fremden" Code verständlich zu machen. In dem Fall werden alle Befehle (Zeilen) aus der Quellcode nacheinander in PAD Symbole umgewandelt und daraus ein PAD erstellt.

== Hauptprogramm ==

Wie sein Namen schon vermuten lässt, ist das Hauptprogram das wichtigste Teil des gesamten Programms. Meistens ist es auch das kleinste Teil, vor allem, wenn die UPs sehr komplex sind. Seine Aufgabe ist die benötigte UPs in bestimmter Reihenfolge nacheinander aufzurufen, um die alle Funktionen des gesamten Programms zu realisieren.

Das HP ist meistens als endlose Schleife, wie im PAD2, aufgebaut. Weil die endlose Schleife sehr schnell läuft, werden alle durch die UPS realisierten Aufgaben quasi gleichzeitig ausgeführt. Wenn es unerwünscht ist, müssen einige UPs als Verzögerungen realisiert werden.

Typischer PAD für ein HP sieht so aus:

Haupt .--->V
| UP1
| UP2
| ...
| UPn
| V
`----´

In den Quellcode wird es so eigeschrieben:

Haupt call UP1
call UP2
...........
call UPn
goto Haupt

In der Praxis wird das HP schrittweise erstellt. Am Anfang wird sich nur ein Aufruf vom UP im HP befinden und die folgenden kommen nach Erstellung und Prüfen weiteren UPs dazu, bis das HP fertig wird.

== Unterprogramm ==

Unterprogramm wird durch übergeordnetes Programmteil (Aufrufer) aufgerufen und nach seinem Ausführen, wird zurück zum Aufrufer gesprungen. Der Rückkehr zum Aufrufer wird durch "return" Befehl, der sich am Ende jedes UPs befinden muss, erreicht. Und das ist der einzige Unterschied zwischen einem HP und einem UP.

Jedes UP hat folgender PAD:

vom Aufrufer ------------>V
Tun
V
zurück zum Aufrufer <----------return

Ein HP von einem ASM Programm kann in anderem, mehr umfangreichem ASM Program als UP benutzt werden, wenn der sich am Ende des HPs befindlicher Befehl "goto" durch "return" ersetzt wird. Ein Beispiel dazu:

Haupt1 call UP11 Haupt1 call UP11
call UP21 call UP21
........... -------> ...........
call UPn1 call UPn1
goto Haupt1 return

Jetzt können wir im mehr komplexen HP (Haupt) das Haupt1 als Unterprogramm aufrufen:

Haupt call UP1
call Haupt1
...........
call UPn
goto Haupt

Jedes UP kann auch von einem anderen übergeordneten UP aufgerufen werden, wenn das was es realisiert, benötigt wird.

In der Praxis wird oft ein UP von mehreren anderen UPs benutzt. Zum Beispiel um LCD Display zu steuern, brauchen wir entweder ein Befehl (Cmd) oder ein Zeichen (Data) an Display zu schicken. In beiden Fällen wird ein Byte geschickt, einmal mit RS=0 (Befehl) und einmal mit RS=1 (Zeichen) laut folgendem PAD:

"Cmd" "Data"
RS=0 RS=1
V V
`-->V<--´
"Send" Byte schicken
V
return

Das wird in den Quellcode z.B. so eingeschrieben:

Cmd bcf RS
goto Send
Data bsf RS
Send ............
return

Das UP "Send" ist den UPs "Cmd" und "Data" untergeordnet, da es von beiden benutzt wird, kann aber weder "Cmd" noch "Data" benutzen.

=== Initialisierung ===

Damit der PIC ein Programm asführen kann, muss er vollständig und richtig initialisiert werden. Deswegen als erstes UP, das von dem gesamten Programm noch vor dem HP aufgerufen wird , ist "Initialisierung" (kurz: Init)

==== Variablen ====

Weil sich nach dem Einschalten der Spannung im RAM zufällige Werte befinden, wird meistens als erstes der benutzte Bereich des RAMs (z.B. 20h bis 7Fh) gelöscht. Es wird einfach und sparsam mit einer Schleife erledigt, die indirekte Adressierung verwendet:

V
Adresse des ersten Registers in FSR laden (20h)
.-------------------->V
RAMClr |Indirekt adressierter Register löschen (INDF)
| Adresse erhöhen
| Letzte Adresse + 1 (80h) J > Return
| N
| V
`---------------------´

Es wird wie folgt in Quellcode eingeschrieben:

movlw 0x20
movwf FSR
RAMClr ,->clrf INDF
| incf FSR,1
| btfss FSR,7
`-<goto RAMClr
return

Um Anzahl den Marken (label) zu verringern, wird oft ein Symbol "$" benutzt. Es bedeutet die Adresse der aktuellen Befehlszeile. Es kann also auch so eingeschrieben werden:

movlw 0x20
movwf FSR
,->clrf INDF
| incf FSR,1
| btfss FSR,7
`-<goto $-3 ; springe zu aktueller Adresse -3
return

Danach können den benötigtenen Variablen die gewünschte Werte zugewiesen werden:

movlw 0x3C
movwf LimH
movlw 0x5A
movwf LimL
u.s.w.

Somit sind die Variablen initialisiert.

==== I/O Ports ====

Nach dem Einschalten der Spannung sind die für Komparatoren oder A/D Wandler benutzte Pins als analoge Eingänge initialisiert. Wenn sie alle als digitale I/Os verwendet werden sollen, müssen sie als solche definiert werden. Das geschieht durch Schreiben des Wertes 7 in das entsprechende Register (CMCON bzw. ADCON1):

movlw 7 b.z.w. movlw 7
movwf CMCON movwf ADCON1

Wenn einige als analoge Eingänge benutzt werden sollen, müssen die entsprechende Werte dem Datenblatt des jeweiligen PICs entnommen werden.

Danach werden alle Ports nacheinander gelöscht und die gewünschte Werte die an den Pins vor dem Start des Hauptprogramms ausgegeben werden sollen, geschrieben:

clrf PORTA
movlw 0x37
movwf PORTA
usw.

Anchliessend werden für jeden Port die Werte in TRIS Register eingeschrieben, wobei ein Bit einem Pin entspricht. Ein Pin wird in TRIS Register durch 1 als Eingang und durch 0 als Ausgang definiert. Beispielweise beim PORTB sollen B7,B5 und B3 als Eingänge und restliche Pins als Ausgänge definiert werden. Das ergibt den Wert 10101000b = A8h, der in den TRISB Register geschrieben werden muss. Weil die alle TRIS Register sich in der höheren Bank befinden, muss im STATUS-Register auf entsprechende Bank und danach zurück auf Bank 0 umgeschaltet werden. Zum Beispiel für die TRASB in der Bank1:

bsf STATUS,RP0
movlw 0xA8
movwf TRISB
bcf STATUS,RP0

Bei einem Umschalten der Bank können selbstverständlich alle TRIS Register, die in der gleichen Bank liegen, nacheinander beschrieben werden. Siehe : [[#PORTx|PORTx]] und [[#TRISx|TRISx]]

Bei dem PORTA gibt es Pins, die nur "open drain" Ausgang haben (können nur auf GND schalten) b.z.w. nur als Eingang benutzt werden können. Bei Plannung der Verwendung von PORTA muss immer im Datenblatt geprüft werden, ob sich ein bestimmter Pin für die geplannte Anwendung eignet.

==== Hardware ====

Die für ASM Programm benutzte Hardware kann auf integrierte und externe geteilt werden. Für eine Initialisierung der integrierten Hardware (Komparatoren, A/D Wandler, Timer, USART, I²C, SPI, PWM, u.s.w.), müssen entsprechende SFRs (Spezial Function Registers) laut Datenblatt des PICs definiert werden.

Die externe Hardware muss nach Datenblättern der Herstellern initialisiert werden.

=== Einlesen ===

Um ein Bit von einem Portpin einzulesen und in ein bestimmtes Register zu Kopieren wird folgender PAD benutzt, weil ein PIC kein Befehl dafür hat:

V
Bit im Zielregister löschen
Quellbit = 0 ? J >------.
N |
V |
Bit im Zielregister setzen |
V<-------------´

Wenn wir z.B. ein bit3 von PortA als bit1 in den Register Tasten kopieren wollen, dann wird es in Quellcode so geschrieben:

bcf Tasten,1
btfsc PORTA,3
bsf Tasten,1

Wenn ein ganzes Byte vom Port in das W-Register eingelesen wird, kann man den Wert gleich komplett in das Zielregister schreiben:

movf PORTA,0
movwf Tasten

=== Ausgeben ===

Um ein Bit an einem Portpin auszugeben wird ein bestimmtes Bit mit "bcf" gelöscht oder mit "bsf" gesetzt. Zum Beispiel bit4 im PORTA:

bcf PORTA,4.

Um ein Byte auszugeben wird es zuerst in das W-Register geladen und danach an den Port übergeben, z.B.:

movlw 0x12
movwf PORTA

=== Schleifen ===

Ein in ASM Programmen meist verbreitetes Codefragment ist eine Schleife.

Es kann eine endlose Schleife, die durch Prüfung einer bestimmten Bedingung (z.B. Taste) unterbrochen wird, sein:

V<-----.
Tun |
? N >--´
J
V
weiter

Es kann eine Schleife mit Schleifenzähler (z.B. Temp), die bestimmte Anzahl Durchläufe hat, sein:

V
Anzahl ins Temp laden
V<---------.
Tun |
Temp decrementieren |
Temp = 0 ? N >--´
J
V
weiter

Solche Schleifen können als UPs verwendet werden, wenn "weiter" mit "return" ersetzt wird.

Das waren Beispiele für Schleifen, die bewusst programmiert sind. Es gibt leider auch endlose Schleifen, die durch einen Fehler im Programm enstanden sind und zum "hängen" des Programms führen. Solche Schleifen sind im Programm nicht einfach zu finden, da ihre Parameter unbekannt sind.

=== Pause ===

Um eine Pause (Warten, Verzögerung) im Programm anzulegen wird der "nop" Befehl benutzt, während dessen Ausführung der CPU nichts macht. Mit einem "nop" kann eine Zeit gleich 4 Takten (Perioden) des Oszillators realisiert werden.

Für sehr kurze Wartezeiten benutzt man eine Reihe von nachfolgenden "nop"s. Beim einem Oszillator 4 MHz, die Ausführungszeit des Prozessors beträgt 1 µs pro "nop". Wenn z.B. 4 µs benötigt werden, werden dafür 4 "nop"s gebraucht:

...
nop
nop
nop
nop
...

Das gleiche bewirken 2 "goto"s, brauchen aber im Vergleich zu "nop"s nur die Hälfte der Bytes im Programmspeicher:

...
goto $+1
goto $+1
...

Der Befehl goto $+1 bedeutet "springe zur aktuellen Adresse + 1" (also nächster Adresse) und seine Ausführungszeit ist gleich 2 Prozessortakten.

Für kurze Zeiten werden s.g. Warteschleifen, wie im folgendem PAD benutzt:

V
n * nop
P0 laden
V<---------.
P0 decrementieren |
P0 = 0 ? N >--´
J
V

In Quellcode wird es als UP so eigeschrieben:

Warte nop Warte nop
... ...
nop nop
movlw 0xXX movlw 0xXX
movwf P0 movwf P0
Warte0 decfsz P0,1 decfsz P0,1
goto Warte0 goto $-1
return return

Der Sprung zur Marke "Warte0" ("goto Warte0") wurde in rechtem Beispiel durch "goto $-1" ersetzt.

Die gesammte Anzahl den CPU Takten (N) lässt sich aus folgender Formel berechnen:

N = 3 * P0 + 6 + n

und die Wartezeit (T) in Sekunden:

T = N * ( 4 / Fosc ), für Schätzungen T ~ 3 * P0 * ( 4 / Fosc )

Wobei:

P0 = Zahl im Register P0, 6 = Ausführungszeit von "call" (2) + "movlw" (1) + "movwf" (1) + "return" (2), n = Anzahl "nop"s, Fosc = Frequenz des Oszillators (z.B. Quartz)

Wenn in ein Register PX eine 0 eingeschrieben wird, bedeutet es, dass die decrementierung des Registers 100h = 256d Takten dauern wird, da dekrementierte 0 eine FFh = 255d ergibt. Deshalb in Warteschleifen ist die Zahl 0 die grösste (256 Dürchläufe) und 1 die kleinste. Für solche einfache Schleifen (als UP) die Wartezeit beträgt min. 9 und max. ca. 800 Prozessortakten (ohne "nop"s).

Für mittlere Wartezeiten z.B. 0,1 Sekunde werden doppelte Warteschleifen verwendet:

Warte V
n * nop
P1 laden
Warte1 V<-------------.
P0 laden |
Warte0 V<---------. |
P0 decrementieren | |
P0 = 0 ? N >--´ |
J |
V |
P1 dekrementieren |
P1 = 0 ? N >------´
J
V

Das wird in Quellcode als UP so aussehen:

Warte nop Warte nop
... ...
nop nop
movlw 0xXX movlw 0xXX
movwf P1 movwf P1
Warte1 movlw 0xXX movlw 0xXX
movwf P0 movwf P0
Warte0 decfsz P0,1 decfsz P0,1
goto Warte0 goto $-1
decfsz P1,1 decfsz P1,1
goto Warte1 goto $-5
return return

Wie vorher wurden rechts die Marken durch "$-n" ersetzt.

Die gesammte Anzahl den CPU Takten (N) lässt sich aus folgender Formel berechnen:

N = P1 * (3 * P0 + 5) + 8 + n

und die Wartezeit (T) in Sekunden:

T = N * ( 4 / Fosc ), für Schätzungen T ~ 3 * P1 * P0 * ( 4 / Fosc )

Wobei:

P0 = Zahl im Register P0, P1 = Zahl im Register P1, 8 = Ausführungszeit von "call" + "return" + 2 * ("movlw" + "movwf"), n = Anzahl "nop"s, Fosc = Frequenz des Oszillators (z.B. Quartz)

Für solche doppelte Schleifen (als UP) die Wartezeit beträgt min. 16 und max. ca. 200 000 Prozessortakten (ohne "nop"s).

Für lange Wartezeiten z.B. 1 Sekunde werden 3-fache Warteschleifen angewendet.

Solche Warteschleife ist im folgenden PAD abgebildet:

Warte V
n * nop
P2 laden
Warte2 V<-----------------.
P1 laden |
Warte1 V<-------------. |
P0 laden | |
Warte0 V<---------. | |
P0 decrementieren | | |
P0 = 0 ? N >--´ | |
J | |
V | |
P1 decrementieren | |
P1 = 0 ? N >------´ |
J |
V |
P2 dekrementieren |
P2 = 0 ? N >----------´
J
V

Das wird in Quellcode als UP so aussehen:

Warte nop Warte nop
... ...
nop nop
movlw 0xXX movlw 0xXX
movwf P2 movwf P2
Warte2 movlw 0xXX movlw 0xXX
movwf P1 movwf P1
Warte1 movlw 0xXX movlw 0xXX
movwf P0 movwf P0
Warte0 decfsz P0,1 decfsz P0,1
goto Warte0 goto $-1
decfsz P1,1 decfsz P1,1
goto Warte1 goto $-5
decfsz P2,1 decfsz P2,1
goto Warte2 goto $-9
return return

Auch hier wurden rechts die Marken durch "$-n" ersetzt.

Die gesammte Anzahl den CPU Takten (N) lässt sich aus folgender Formel berechnen:

N = P2 * [ P1 * (3 * P0 + 5) + 9 ] + 10 + n

und die Wartezeit (T) in Sekunden:

T = N * ( 4 / Fosc ), für Schätzungen T ~ 3 * P2 * P1 * P0 * ( 4 / Fosc )

Wobei:

P0 = Zahl im Register P0, P1 = Zahl im Register P1, P2 = Zahl im Register P2, 10 = Ausführungszeit von "call" + "return" + 3 * ("movlw" + "movwf"), n = Anzahl "nop"s, Fosc = Frequenz des Oszillators (z.B. Quartz)

Für solche 3-fache Schleifen (als UP) die Wartezeit beträgt min. 27 und max. ca. 50 000 000 Prozessortakten (ohne "nop"s).

Die "nop"s vor allen Warteschleifen sind nur notwendig um genaue Wartezeit einzustellen zu können. Sie können auch mit "goto $+1"s ersetzt, oder weg gelassen werden. Sie können auch innerhalb jeder Schleife eingesetzt werden, um sie deutlich zu verlängern.

Ein Beispiel:

V
n * nop
P0 laden
V<---------.
n0 * nop
P0 decrementieren |
P0 = 0 ? N >--´
J
V

Bei nur einem "nop" (n0=1) ist die max. Wartezeit ca. T ~ 4 * P0 * ( 4 / Fosc ), bei zwei (n0=2) ca. T ~ 5 * P0 * ( 4 / Fosc ) u.s.w.

Anstatt "movlw 0xXX" kann auch "movf PauseX,0" angewendet werden, wenn die Schleife mehrmals mit verschiedenen Werten P0, P1 und P2 aus den Register Pause0, Pause1 und Pause2 benutzt wird.

Für sehr lange Wartezeiten können, nach gleichem Prinzip, Warteschleifen erstellt werden, die mehr als 3 Schleifen enthalten.

=== Tabellen ===

Es gibt zwei Arten von Tabellen: Sprungtabellen (computed goto) die "goto" Befehle enthalten und Wertetabellen (lookup table) in denen feste Werte in "retlw" gespeichert sind. Der wichtigste Unterschied zwischen dennen ist, dass die Sprungtabellen steuern den Programlauf abhängig vom Inhalt des W-Registers und die Wertetabellen liefern abhängig von Inhalt des W-Registers ein Wert an den Aufrufer zurück.

Beide werden in Programmspeicher erstellt. Sie können nur bis zu 256 Speicherstellen belegen, da in den W-Register auch nur so viel veschiedenen Zahlen "passen". Sie Fangen also (fast) immer bei einer Adresse XX00h an und enden bei XXFFh. Der Hochwertige Byte "XX" der Adresse an der sich der Anfang einer Tabelle befindet, muss vor dem Einsprung in die Tabelle ins PCLATH Register eingeschrieben werden, wenn die Tabelle weit vom Aufrufer liegt. In der Praxis werden solche Tabellen am oberen Ende des Programmspeichers angelegt, damit sie den ASM Code nicht unterbrechen.

Eine Sprungtabelle wird so aufgebaut:

org (XX-1)FF <--- eine Direktive für Assemblerprogramm, wo es
die Tabelle im Programmspeicher plazieren soll
Adresse Inhalt
-------------------------
Tab1 (XX-1)FF addwf PCL,1
XX00 goto Marke0
XX01 goto Marke1
.......................
XXFE goto Marke254
XXFF goto Marke255

Und so aufgerufen:

movlw 0xXX
movwf PCLATH
movf TWert,0
call Tab1

Wobei:

0xXX = Hochwertiger Byte der Adresse von Tab1, TWert = ein Wert, der die Wahl wohin gesprungen wird bestimmt.

Nach ausführen der obiger Befehlsfolge, wird das ASM Programm z.B. für Twert=0x01 weiter ab Marke1 "laufen" bis es an "return" kommt. Dann springt es zurüch zum Aufrufer der Tabelle.

Eine Wertetabelle wird so aufgebaut:

org (XX-1)FF <--- eine Direktive für Assemblerprogramm, wo es
die Tabelle im Programmspeicher plazieren soll
Adresse Inhalt
-------------------------
Tab1 (XX-1)FF addwf PCL,1
XX00 retlw Wert0
XX01 retlw Wert1
.......................
XXFE retlw Wert254
XXFF retlw Wert255

Und so aufgerufen:

movlw 0xXX
movwf PCLATH
movf TWert,0
call Tab1

wobei:

0xXX = Hochwertiger Byte der Adresse von Tab1, TWert = ein Wert, für welchen, an den Aufrufer bestimmter Wert aus der Tabelle im W-Register zurückgeliefert wird

Wertetabelle kann auch mit Hilfe der MPASM Direktive "dt" erstellt werden. So kann man sich mehrfaches Schreiben von "retlw" Befehlen ersparen:

org 0x(XX-1)FF
Tabelle addwf PCL,1
; nachfolgend der benötigte Wert im W- Register
; vor dem Aufruf der Tabelle
dt 0x03, 0xE8 ; 0x00
dt 0x03, 0xE8 ; 0x02
dt 'M','H','z',0x00 ; 0x04
dt ' ',' ','W','A','I','T',0x00 ; 0x08
dt 'C','o','n','s','t',' ','X',0x00 ; 0x0F
dt 'C','=',0x00 ; 0x17
dt 'L','=',0x00 ; 0x1A
dt 'F','=',0x00 ; 0x1D
dt 'O','K',0x00 ; 0x20
u.s.w.

Das Lesen eines Strings muss ab entsprechendem Wert im W-Register (z.B. für "MHz" -> 0x04) anfangen und auf dem Wert 0x00 enden, der hier als Stringende dient. Einfacher ist, wenn alle Strings gleich lang sind (wie z.B. in einem Zeichengenerator fur Grafikdisplay).

=== Interrupt ===

==== Prinzip ====

Ein Interrupt (Unterbrechung) unterbricht ein laufendes Programms, wenn ein bestimmtes Ereigniss, auf das reagiert werden soll, statt gefunden hat. Die Reaktion wird in s.g. Interrupt Service Routine (kurz: ISR) definiert.

Einfach gesagt, ein Interrupt stoppt ein laufendes Programm, ruft die ISR auf und nach deren Ausführung startet das Programm wieder, ab der Zeile, vor der es durch Interrupt angehalten wurde.

.--->V
| Tun
| V
Interrupt ------>Tun-------->V
| V ISR
| Tun<--------´
| V
| Tun
| V
`----´

Damit das unterbrochene Programm nach dem Rückkehr aus der ISR weiter fehlerfrei ausgeführt werden kann, darf die ISR keine Änderungen im Programm verursachen.

Um ein Interrupt auslösen zu können, muss er in UP "Init", durch beschreiben nötigen Register (INTCON, PIR, u.s.w.) vorbereitet werden. Siehe hierzu: [[#INTCON|INTCON]] und [[#Interrupts|Interrupts]]

==== Quellen ====

Es gibt folgende Interrupt-Quellen:

- interne Hardware (z.B. ein Timer)

- externe Hardware (z.B. eine Taste)

Die alle PICs der Mid-Range Familie haben im Programmspeicher nur eine Adresse (s.g. Interrupt Vektor 0x0004), wohin im Falle eines Interrupts, gesprungen wird. Um ermöglichen den Verursacher des Interrupts zu finden, hat jede Quelle ein eigenes Interrupt Flag (IF), das gesetzt wird, wenn das Interrupt ausgelöst wird. Somit kann in der ISR nach der Prüfung der IFs auf jeden Interrupt gezielt reagiert werden.

==== Interrupt Service Routine ====

Die Interrupt Service Routine ist ein besonderes UP das immer an der Adresse 0x0004 beginnt und immer mit dem Befehl "retfie" endet. Ihr Umfang ist von der Menge der Quellen und der Reaktionen auf ihre Interrupts abhängig. Folgender PAD zeigt ein allgemeiner Aufbau der ISR:

Adresse 0x0004 Interrupts sperren ; bcf INTCON,GIE
Beeinflüsste Register sichern
Interrupt-Quelle ermitteln
Interrupt-Flag löschen
und entsprechend reagieren
Beeinflüsste Register restaurieren
zurück ins Programm springen ; retfie

Je nach Bedürfnissen, wird eine ISR nur nötige Elemente davon enthalten. Um auf alle Interrupts reagieren zu können muss die ISR vor dem nächsten Interrupt beendet werden. Da das Programm nur in den Pausen zwischen Ausführungen der ISR laufen kann, sollte die Ausführungszeit der ISR möglichst kurz sein.

Die kürzeste ISR setzt nur ein Flag ("_Fint"), das dem Programm zeigt, dass ein Interrupt statt gefunden hat. Sie eignet sich für den Fall, wenn nur eine Interrupt-Quelle erlaubt ist. Das Programm wird nur für 5 Prozessortakten unterbrochen.

0x0004 bcf INTCON,GIE ; Interrupts sperren
bcf IF ; Interrupt Flag löschen
bsf _Fint ; Flag setzen
retfie ; zurück ins Programm

Das Programm prüft das Flag "_Fint", löscht es und reagiert entsprechend. Somit kann ein Interrupt immer auf gleichen Stelle des Hauptprogramms bearbeitet werden.

Die ISR kann aber auch ein HP darstellen. Siehe hierzu: [[#Interrupts|Interrupts]]

=== Schnittstellen und Treiber ===

Als Schnittstelle wird externe Hadware, die zum Steuern eines an sie angeschlossenes "Gerätes" dient, genannt. Das ASM Programm, das die Steuerung ermöglicht ist ein Treiber. Als Beispiele siehe: [[http://www.roboternetz.de/phpBB2/viewtopic.php?t=13685]] und [http://www.roboternetz.de/phpBB2/viewtopic.php?t=22749]

== Vorlage für MPASM ==

Diese Vorlage ist nur für ASM Programme ohne Interrupts geeignet:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration
#define _DTT1 GPIO,0 ; Portpins benennen
#define _CKT2 GPIO,1
#define _T3 GPIO,2
#define _RNG GPIO,3
#define _INT GPIO,4
#define _RL GPIO,5
u.s.w.
SecondL equ 0x20 ; Variablen definieren (Register benennen)
SecondH equ 0x21
MinuteL equ 0x22
MinuteH equ 0x23
StundeL equ 0x24
StundeH equ 0x25
u.s.w
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
Haupt ............ ; hier fängt das Hauptprogramm als endlose Schleife an
Eigener Code
............
goto Haupt ; hier endet das HP, gehe zum Anfang des HPs (zurück)
UP1 ............ ; Unterprogramme
Eigener Code
............
return
############
UPn ............
Eigener Code
............
return
Init clrf GPIO ; lösche Port
bsf STATUS,RP0 ; auf Bank1 umschalten
call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; kalibriere internen RC oscillator
bcf OPTION_REG,7 ; aktiviere pull-ups
movlw 0x38 ; definiere Portpins GPIO, (z.B. 0-2 Aus- und 3-5 Eingänge)
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
movlw 7 ; schalte Komparator aus
movwf CMCON ; und definiere GPIO 0-2 als digitale I/Os
............
eigener Code
............
return ; springe zurück (zum Haupt)
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

Die Variablen können auch kürzer mit s.g. cblock definiert werden:

cblock 0x20
SecondL
SecondH
MinuteL
MinuteH
StundeL
StundeH
endc

Bei sehr vielen Variablen sind aber die Registeradressen nicht so übersichtlich.

Für Programme mit Interrupts ist diese Vorlage geeignet:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration
#define _DTT1 GPIO,0 ; Portpins benennen
#define _CKT2 GPIO,1
#define _T3 GPIO,2
#define _RNG GPIO,3
#define _INT GPIO,4
#define _RL GPIO,5
u.s.w.
SecondL equ 0x20 ; Variablen definieren (Register benennen)
SecondH equ 0x21
MinuteL equ 0x22
MinuteH equ 0x23
StundeL equ 0x24
StundeH equ 0x25
u.s.w
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
goto Haupt ; gehe zum Hauptprogramm "Haupt"
org 0x004 ; hier fängt die ISR (interrupt service routine) an
bcf INTCON,GIE ; interrupts sperren
.............
Eigener Code
.............
retfie ; hier endet die ISR, interrupts wieder erlauben
Haupt ............ ; hier fängt das Hauptprogramm als endlose Schleife an
Eigener Code
............
goto Haupt ; hier endet das HP, gehe zum Anfang des HPs (zurück)
UP1 ............ ; Unterprogramme
Eigener Code
............
return
############
UPn ............
Eigener Code
............
return
Init clrf GPIO ; lösche Port
bsf STATUS,RP0 ; auf Bank1 umschalten
call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; kalibriere internen RC oscillator
bcf OPTION_REG,7 ; aktiviere pull-ups
movlw 0x38 ; definiere Portpins GPIO, (z.B. 0-2 Aus- und 3-5 Eingänge)
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
movlw 7 ; schalte Komparator aus
movwf CMCON ; und definiere GPIO 0-2 als digitale I/Os
............
eigener Code
............
return ; springe zurück (zum Haupt)
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

== Das erste... ==

Hier wird detailiert das ganze Prozess der Erstellung eines ASM Programms beschrieben. Die Idee:

Es gibt 4 LEDs (_L1, _L2, _L3 und _L4), die mit 2 Tastern gesteuert werden sollen. Nach dem Einschalten soll keine LED leuchten. Solange der linke Taster (_T1) gedrückt ist, sollte eine leuchtende LED von links nach rechts "wandern" und von der letzten rechten Position wieder nach ganz linke "springen". Solange der rechte Taster (_T2) gedrückt ist, sollte eine leuchtende LED von rechts nach links "wandern" und von der letzten linken Position wieder nach ganz rechte "springen". Solange beide Taster gedrückt sind soll die leuchtende LED von links nach rechts und zurück "wandern".

Dafür nötige Hardware zeigt folgende Skizze:

.-----------------------------------------------.
| |
| PIC12F629 |
| |
| GPIO,3 GPIO,4 GPIO,5 GPIO,2 GPIO,1 GPIO,0|
'-----------------------------------------------'
4| 3| 2| 5| 6| 7|
| | .-. .-. .-. .-.
| | R | | R | | R | | R | |
| | 470| | 470| | 470| | 470| |
| | '-' '-' '-' '-'
\ o \ o | | | |
\ \ V -> V -> V -> V ->
\. \. - - - -
_T1 o _T2 o _L1 | _L2 | _L3 | _L4 |
| | | | | |
+-------+-------+---+---+-------+-------+
|
===
GND

Weil der Pin 4 (GPIO,3) nur einen "open drain" Ausgang hat (kann nur an GND schalten), wird er hier als Eingang benutzt.

Jetzt muss die Idee vom Programmierer in ein PAD verfasst werden, z.B. solcher:

Start
Initialisierung
.-------------->V
| _T1=0 gedrückt ? N >----.
| J |
| V |
| links->rechts "wandern" |
| V<------------´
| _T2=0 gedrückt ? N >----.
| J |
| V |
| rechts->links "wandern" |
| V<------------´
`---------------´

danach detailierter:

Start
Initialisierung
V<-------------------------------------------.
_T1=0 gedrückt ? N >---+--->_T2=0 gedrückt ? N >---+---´
J A J A
V | V |
_L1 an | _L4 an |
Warten | Warten |
_L1 aus | _L4 aus |
_L2 an | _L3 an |
Warten | Warten |
_L2 aus | _L3 aus |
_L3 an | _L2 an |
Warten | Warten |
_L3 aus | _L2 aus |
_L4 an | _L1 an |
Warten | Warten |
_L4 aus | _L1 aus |
V | V |
`------------´ `------------´

Weil der Prozessor die Befehle nacheinander liest, ist jeder Quelcode einspaltig. Um sich die "Übersetzung" des PADs in den Quelcode zu erleichtern wird er noch z.B. so umgestaltet:

Start
Initialisierung
V<-----------------+<----.
Haupt _T1=0 gedrückt ? N >---. A |
J | | |
V | | |
_L1 an | | |
Warten | | |
_L1 aus | | |
_L2 an | | |
Warten | | |
_L2 aus | | |
_L3 an | | |
Warten | | |
_L3 aus | | |
_L4 an | | |
Warten | | |
_L4 aus | | |
V<-----------´ | |
T2Test _T2=0 gedrückt ? N >---------´ |
J |
V |
_L4 an |
Warten |
_L4 aus |
_L3 an |
Warten |
_L3 aus |
_L2 an |
Warten |
_L2 aus |
_L1 an |
Warten |
_L1 aus |
V |
`------------------------´

Alle Pfeilen aus diesem PAD werden als "goto" in den Quelcode eingetragen.

Zuerst wird im MPASM Verzeichnis ein neuer Verzeichniss (z,B. "PIC Programme") angelegt und in dem Verzeichniss neue Textdatei (z.B. "Erstes.txt") erstellt. Als nächstes wird die "Vorlage für MPASM" dorthin kopiert.

Danach müssen, die im Programm benutzte Portpins und Register mit "#define" und "equ" definiert werden.

Als Initialisierung wird das UP "Init" aus der Vorlage für MPASM mit geändertem "TRISIO" Wert (0x18) übernommen. Siehe: [[#Vorlage für MPASM|Vorlage für MPASM]]

Fürs "Warten" wird eine dreifache Warteschleife verwendet. Siehe: [[#Pause|Pause]]

Die Taster werden mit "btfsc" Befehl geprüft und zum LEDs An- und Ausschalten werden Befehle "bsf" und "bcf" für ensprechenden Portpin von GPIO angewendet. Siehe: [[#Ausgeben|Ausgeben]]

Anschlessend wird alles laut PAD in die Vorlage für MPASM eingeschrieben und der Quellcode ist fertig:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration
#define _T1 GPIO,3 ; Portpins benennen
#define _T2 GPIO,4
#define _L1 GPIO,5
#define _L2 GPIO,2
#define _L3 GPIO,1
#define _L4 GPIO,0
P0 equ 0x20 ; Variablen definieren (Register benennen)
P1 equ 0x21
P2 equ 0x22
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
Haupt btfsc _T1 ; Taster _T1=0 gedrückt ?, wenn ja, überspringe "goto T2Test"
goto T2Test ; wenn nicht, springe zu "T2Test"
bsf _L1 ; schalte _L1 an (setze den Pin 2 auf "1")
call Warten ; warte ca. 0,4 s (ca. 400 000 Prozessortakten)
bcf _L1 ; schalte _L1 aus (setze den Pin 2 auf "0")
bsf _L2 ; schalte _L2 an (setze den Pin 5 auf "1")
call Warten ; warte
bcf _L2 ; schalte _L2 aus (setze den Pin 5 auf "0")
bsf _L3 ; schalte _L3 an (setze den Pin 6 auf "1")
call Warten ; warte
bcf _L3 ; schalte _L3 aus (setze den Pin 6 auf "0")
bsf _L4 ; schalte _L4 an (setze den Pin 7 auf "1")
call Warten ; warte
bcf _L4 ; schalte _L4 aus (setze den Pin 7 auf "0")
T2Test btfsc _T2 ; Taster _T2=0 gedrückt ?, wenn ja, überspringe "goto Haupt"
goto Haupt ; wenn nicht, springe zu "Haupt"
bsf _L4 ; schalte _L4 an (setze den Pin 7 auf "1")
call Warten ; warte
bcf _L4 ; schalte _L4 aus (setze den Pin 7 auf "0")
bsf _L3 ; schalte _L3 an (setze den Pin 6 auf "1")
call Warten ; warte
bcf _L3 ; schalte _L3 aus (setze den Pin 6 auf "0")
bsf _L2 ; schalte _L2 an (setze den Pin 5 auf "1")
call Warten ; warte
bcf _L2 ; schalte _L2 aus (setze den Pin 5 auf "0")
bsf _L1 ; schalte _L1 an (setze den Pin 2 auf "1")
call Warten ; warte
bcf _L1 ; schalte _L1 aus (setze den Pin 2 auf "0")
goto Haupt ; springe zu "Haupt"
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 ("Haupt"),
Init clrf GPIO ; lösche Port (setze alle werdende Ausgänge auf "0")
bsf STATUS,RP0 ; auf Bank1 umschalten
call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; und kalibriere internen RC oscillator (4 MHz)
bcf OPTION_ REG,7 ; aktiviere pull-ups für die Portpins
movlw 0x18 ; definiere Portpins GPIO,3 und 4 als Eingänge
; und restlichen als Ausgänge (00011000b)
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
movlw 7 ; schalte Komparator aus
movwf CMCON ; und definiere GPIO 0-2 als digitale I/Os
return ; springe zurück (zum Haupt)
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

Jetzt wird der Quellcode in "Erstes.asm" umbenannt. Diese "*.asm" Datei können wir dem MPASM zum "Übersetzten" geben. Nach der Assemblierung sehen wir 3 Meldungen (Messages) vom MPASM. Diese befinden sich in der vom MPASM erstellter Datei "Erstes.lst" und lauten:

Message[302]: Register in operand not in bank 0. Ensure that bank bits are correct.

Diese Meldung kann man übersetzen als:

Meldung[302]: Register im Befehl nicht in Bank 0. Vergewisse Dich, dass die Bank-Bits korrekt sind.

Wir sind sicher, dass die Register "OSCCAL", "OPTION_REG" und "TRISIO" in der Bank 1 sich befinden. Wenn man aber nicht sicher ist, soll man in Datenblatt nachschauen. Die Meldungen kommen immer für alle SFRs (Special Function Register) die sich nicht in der Bank 0 befinden und können ignoriert werden.

Am Ende der Datei "Erstes.lst" befinden sich noch einige Informationen über Programmspeicher:

Program Memory Words Used: 52 ; benutzte Speicherstellen
Program Memory Words Free: 972 ; freie Speicherstellen

und die Anzahl den eventuellen Fehlern (Errors), Warnungen (Warnings) und Meldungen (Messages):

Errors : 0
Warnings : 0 reported, 0 suppressed
Messages : 3 reported, 0 suppressed

Insgesamt werden durch MPASM 4 Dateien erstellt: "*.cod", "*.err", "*.hex" und "*.lst".

Wichtigste davon, falls wegen Fehler keine "*.hex" Datei erstellt wird, ist die "*.err" Datei, wo alles was dem MPASM nicht "passt" aufgelistet ist. In der "*.lst" Datei kann man sich ein Programm mit genauen Adressen für jeden Befehl anschauen.

Die während der Assemblierung vom MPASM generierte Datei "Erstes.hex" kann jetzt durch ein Brenner mit geeignetem Programm in den PIC Programmspeicher eingeschrieben werden.

== Für anderen PIC umschreiben ==

Die wichtigste Vorraussetzung ist, das der andere PIC2, auf dem das vorhandene ASM Programm für PIC1 laufen soll, zumindest für das ASM Programm nötige interne Hardware hat. Die Frequenz des Oszillators sollte gleich sein. Der Code benötigt ausser UP "Init" keine Änderungen.

Wenn der Port vom PIC2 anderen Namen hat, muss man das im Quellcode umdefinieren, z.B.:

#define PORTC PORTB
#define TRISC TRISB

Dann wird das Assemblerprogramm, wenn es PORTC findet, immer PORTB nehmen. Das gleiche Betrifft die "__config" Ausdrücke, die entsprechend der "*.ini" Datei für den PIC2, geändert werden müssen.

Das Assemblerprogramm findet sicher alles, was ihm nicht "passt" und bringt Fehlermeldungen, auf die man entsprechend reagieren muss.

Als Beispiel, schreiben wir "Erstes.asm" für den PIC16F84A um.

Zum Ändern sind die ersten 3 Zeilen:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration

Sie werden für den PIC16F84A so aussehen:

list P=16F84A ; Prozessor definieren
include "P16F84A.inc" ; 4.000 MHz
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _HS_OSC

Dazu muss noch "GPIO" Port umdefiniert werden, da der PIC16F84A solchen nicht hat, z.B wegen internen pull-ups auf "B":

#define GPIO PORTB
#define TRISIO TRISB

Die Hardware muss natürlich an entsprechende Pins angeschlossen werden:

_T1 auf 12 (B3), _T2 auf 13 (B4), _L1 auf 14 (B5), _L2 auf 11 (B2), _L3 auf 10 (B1) und _L4 auf 9 (B0)

Jetzt assemblieren wir die Qelldatei und der MPASM bringt in der Datei "Erstes.err" folgende Fehler:

Error[113] C:\MPASM\PICPROG\PIC16F84\ERSTES.ASM 61 : Symbol not previously defined (OSCCAL)
Error[113] C:\MPASM\PICPROG\PIC16F84\ERSTES.ASM 67 : Symbol not previously defined (CMCON)

In dem UP "Init" müssen also noch die Befehle mit "OSCCAL" und "CMCON" Register entfernt werden, da der PIC16F84A sie nicht hat:

call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; kalibriere internen RC oscillator (4 MHz)

und:

movlw 7 ; schalte Komparator aus
movwf CMCON ; und mache GPIO 0-2 als digital I/O

Weiter kann schon alles übernommen werden und die Datei "Erstes.asm" für den PIC16F84A ist fertig:

list P=16F84A ; Prozessor definieren
include "P16F84A.inc" ; 4.000 MHz
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _HS_OSC
#define GPIO PORTB ; Ports umbenennen
#define TRISIO TRISB
#define _T1 GPIO,3 ; Portpins benennen
#define _T2 GPIO,4
#define _L1 GPIO,5
#define _L2 GPIO,2
#define _L3 GPIO,1
#define _L4 GPIO,0
P0 equ 0x20 ; Variablen definieren (Register benennen)
P1 equ 0x21
P2 equ 0x22
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
Haupt btfsc _T1 ; Taster _T1=0 gedrückt ?, wenn ja, überspringe "goto T2Test"
goto T2Test ; wenn nicht, springe zu "T2Test"
bsf _L1 ; schalte _L1 an
call Warten ; warte ca. 0,4 s (ca. 400 000 Prozessortakten)
bcf _L1 ; schalte _L1 aus
bsf _L2 ; schalte _L2 an
call Warten ; warte
bcf _L2 ; schalte _L2 aus
bsf _L3 ; schalte _L3 an
call Warten ; warte
bcf _L3 ; schalte _L3 aus
bsf _L4 ; schalte _L4 an
call Warten ; warte
bcf _L4 ; schalte _L4 aus
T2Test btfsc _T2 ; Taster _T2=0 gedrückt ?, wenn ja, überspringe "goto Haupt"
goto Haupt ; wenn nicht, springe zu "Haupt"
bsf _L4 ; schalte _L4 an
call Warten ; warte
bcf _L4 ; schalte _L4 aus
bsf _L3 ; schalte _L3 an
call Warten ; warte
bcf _L3 ; schalte _L3 aus
bsf _L2 ; schalte _L2 an
call Warten ; warte
bcf _L2 ; schalte _L2 aus
bsf _L1 ; schalte _L1 an
call Warten ; warte
bcf _L1 ; schalte _L1 aus
goto Haupt ; springe zu "Haupt"
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 ("Haupt"),
Init clrf GPIO ; lösche Port (setze alle werdende Ausgänge auf "0")
bsf STATUS,RP0 ; auf Bank1 umschalten
bcf OPTION_REG,7 ; aktiviere pull-ups
movlw 0x18 ; definiere Portpins GPIO,3 und 4 als Eingänge
; und die restlichen als Ausgänge (00011000b)
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
return ; springe zurück (zum Haupt), nach der Zeile
; aus der du afgerufen wurdest
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

== Einbinden ==

Die einfachste Möglichkeit die gewünschte Programme in ein neues Programm einzubinden ist, die alle Programme in das neue Programm zu kopieren. Dafür müssen die ersten 3 Zeilen, die den Prozessor und die Konfiguration des PICs festlegen aus den eigebundenen Programmen entfernt werden. Danach müssen alle "#define", "equ" und "org" Direktiven, verglichen und wenn nötig geändert werden. Dabei hilft der MPASM mit seinen Fehlermeldungen in der Datei "*.err".

Die zweite Möglichkeit ist die gewünschte Programme als "*.asm" Dateien mit der Direktive "include *.asm" am Ende des neuen Programms vor der Direktive "end" einzubinden.

include "1.asm"
include "2.asm"
...............
include "n.asm"
end

In dem Fall gelten die gleichen o.g. Regeln wie beim direkten Kopieren. Wenn es in den eingebindenen Programmen keine "org" Direktiven gibt, dann werden die weitere Programme im Programmspeicher ab Ende des ersten Programms nacheinander plaziert.

== Fehlersuche ==

Als erstes wird an den PIC angeschlossene externe Hardware geprüft. Das sollte noch vor dem Einstecken oder Einlöten des PICs gemacht werden, da die gravierende Fehler (z.B. Kurzschlüsse, Umpolung von VCC und GND, u.s.w.) für den PIC schädlich werden können. Für einige Teile der Hardware kann entsprechende Spannung (VCC oder GND) an bestimmten Pin gelegt werden und die richtige Reaktion der Hardware optisch (z.B. für LEDs) oder akustisch (z.B. für Relais) festgestellt werden. Sonst müssen die elektrischen Verbindungen mit einem Messgerät überprüft werden.

Die Fehlersuche in der Software fängt mit der ersten und endet mit der letzten Zeile des ASM Programms. Sie läuft die ganze Zeit parallel zur Programmierung. Jedes UP soll vor dem Übertragen in den Quellcode geprüft und eventuelle Fehler beseitigt werden. Dazu arbeitet man gleichzeitig mit zwei "*.asm" Dateien, einer für die UPs und einer für das gesamte Programm. Es wird empfohlen, nach der "Initialisierung", als erstes UP, das für Ausgabegerät (z.B. Display) zu erstellen, um das funktionieren des Programms, vom Anfang an beobachten zu können.

Wenn aus geprüften UPs erstelltes Programm nicht richtig funktioniert, müsste ein Fehler im PAD sein.

== Optimierung ==
Work in Progress...
Wer sonst noch Beispiele hat, bitte hier vervollständigen...
BMS ...
=== Speicherbedarf ===
==== Programmspeicher ====
Die ersten Programme für den PIC sind natürlich einfach und kurz. Doch nach und nach werden die Codes länger und unübersichtlicher, das Brennen dauert auch umso länger. Das Programm ist zu umfangreich. Doch wo soll man etwas kürzen?

Es gibt unzählige Möglichkeiten - hier ein paar Beispiele:

===== Unterprogramme =====

Bestimmt wird man im Code immer die selben Abschnitte brauchen, zum Beispiel Warteschleifen oder ADC-Routinen, etc. Wieso sollte man diese also mehrfach (doppelt, dreifach, u.s.w.) schreiben?

Die Lösung: Der Programmteil wird als Unterprogramm benutzt. Man erstellt eine Sprungmarke (ab hier beginnt das Unterprogramm) und endet wieder mit einem "return"- oder "retlw"-Befehl.
Aufgerufen werden die Unterprogramme meistens mit dem "call"-Befehl. Es "lohnt sich" ein Codefragment als UP zu definieren erst wenn es min. 2 mal aufgerufen wird.

Ein "goto"-Befehl ist zu diesem Zweck geeignet nur, wenn der Prozessor zum letzten Aufrufer von "call" zurück springen soll, da die Rücksprungadresse vom letzten "call" auf dem Stapel (stack) abgelegt wurde. Somit kann man mehr als 8 Ebenen von UPs nutzen.

Den Unterprogrammen kann man natürlich auch Werte übergeben. Möchte man z.B. mehrere unterschiedliche Zeiten für Warteschleifen benutzen, so kann man die Parameter vor dem Aufruf des UPs in benötigte Anzahl von Register einschreben und dann das Unterprogramm mit "call" aufrufen. Das Unterprogramm verwendet dann die Zahlen von den Register. Siehe: [[#Pause|Pause]]

Um gleiche Vorgänge in mehreren Register durchzuführen (z.B. löschen) geeignet ist Anwendung von Schleifen mit bestimmter Anzahl der Abläufe und indirekter Adressierung. Siehe: [[#Variablen|Variablen]]

===== bsf und bcf =====

Bestimmt gibt es Situationen, in denen der PIC mehrere Bits an einem Port/Register setzen oder löschen muss. Z.B. wenn mehrere LEDs an einem Port ein- oder ausgeschaltet werden sollen.
Werden mehr als 2 Bits verändert, so kann man hier die "bsf"- und "bcf"-Befehle umgehen und einen kürzeren Code erstellen.

bsf PORTB,0 ;An PORTB sind 8 LEDs angeschlossen.
bsf PORTB,1 ;Es sollen die ersten 4 LEDs angeschaltet werden,
bsf PORTB,2 ;die anderen sollen ausgeschaltet werden.
bsf PORTB,3 ;links steht es mit bcf/bsf
bcf PORTB,4 ;ziemlich lang
bcf PORTB,5
bcf PORTB,6
bcf PORTB,7

movlw b'00001111' ;Das geht auch kürzer und übersichtlicher:
movwf PORTB

Man sieht - der Codeabschnitt umfasst nur noch 2 Zeilen anstatt 8. Somit braucht es weniger Speicher und wird von PIC schneller verarbeitet. Allerdings muss man aufpassen, da durch diese Routine der Inhalt des W-Registers und der Inhalt des gesamten Zielregisters verändert wird. Sollen die anderen Bits unangetastet bleiben, muss man es entweder bei den "bcf"/"bsf"-Befehlen belassen oder logische Funktionen (and bzw. or) durchführen.

===== Bit kopieren =====

;An den PIC ist ein Taster(RB0) und eine LED(RB1) angeschlossen.
;Taster: High=gedrückt Low=nicht gedrückt
;LED: High=Ein Low=Aus
;Wenn der Taster gedrückt ist, soll die LED leuchten
;wenn er nicht gedrückt ist, soll die LED nicht leuchten.
;1.Vorschlag:
btfss PORTB,0 ;ist der taster gedrückt?
goto no ;nein
bsf PORTB,1 ;ja - LED ein
goto endif ;fertig abgefragt - unten weitermachen...
no bcf PORTB,1 ;LED aus
endif

Der oben aufgeführte Code hat viele Nachteile: er ist relativ lang, braucht zwei Gotos und entspr. Sprungmarken. Ok, das ist vielleicht Erbsenzählerei, aber aus diesen 5 Zeilen kann man 3 machen.

bcf PORTB,1 ;Das Bit wird erst gelöscht
btfss PORTB,0 ;Taster gedrückt?
bsf PORTB,1 ;JA-LED an

Man geht davon aus, dass der Taster nicht gedrückt ist. Somit wird die LED erst einmal ausgeschaltet. Ist der Taster aber doch gedrückt, dann wird die LED angeschaltet.

Achtung möglicher Nebeneffekt: Wird dies in einer Schleife sehr schnell und oft ausgeführt, kann die LED flimmern oder nicht in ihrer vollen Helligkeit leuchten. Das passiert, weil ja angenommen wird, dass der Taster nicht gedrückt wird und die LED somit aus sein muss. Dann wird sie aber bei Tastendruck eingeschaltet. Somit entsteht ein schnelles ein-/ausschalten (PWM) und die LED leuchtet nicht mehr so hell.
Meist ist das aber nicht tragisch oder wird nicht unbedingt in einer Schleife sehr schnell abefragt. Siehe hierzu: [[#Einlesen|Einlesen]]

==== RAM ====

Um Anzahl benötigten Register zu sparen werden vorläufige Register (temporary) definiert, die von mehreren UPs benutzt werden. Als Beispiel, das Register "ATmp" in [[#Hex Dec Wandlung|Hex Dec Wandlung]]. Die Benutzung muss aber sehr genau nach PAD zugeteilt werden. Bei gleichzeitiger Benutzung des gleichen Registers durch mehrere UPS werden falsche Daten verarbeitet und im schlimmsten Fall können endlose Schleifen entstehen, die in Folge haben, dass das Programm nicht weiter ausgeführt wird ("hängt").

Viele im ASM Programm ungebrauchte SFRs können als "normale" Register (GPR) verwendet werden. Wenn zum Beispiel Timer1 nicht benutzt wird, können seine Register TMR1H und TMR1L für Speicherung von Daten benutzt werden. Es könnte aber gefährlich werden, wenn mehrere Programme gebindet sind. Deswegen muss es immer am Ende, beim volständigen Programm, geprüft werden, welche SFRs tatsächlich benutzt werden dürfen.

Für Konstanten (z.B. pi, ln2, Meldungen, u.s.w.), die sich im Laufe des Programms nicht ändern, kann EEPROM (mit MPASM Direktive "de") oder Programmspeicher (mit MPASM Direktive "dt") als Ablage benutzt werden. Siehe auch: [[#EEPROM|EEPROM]] und [[#Tabellen|Tabellen]]

=== Ausführungszeit ===

Alles was schnellmöglichst ablaufen soll, widersetzt sich der Optimierung des Programmspeichers.

Es können keine Schleifen und keine indirekte Adressierung benutzt werden, alles muss direkt programmiert werden.

Als Beispiel zur Verdeutlichung: Es sollen 16 Werte vom PORTA ins RAM ab Adresse 0x20 eingelesen werden.

Als Schleife mit indirekter Adressierung:

................
movlw 0x10 ;Anzahl Durchläufe
movwf Temp ;in den Schleifenzähler
movlw 0x20 ;erste Adresse
movwf FSR ;ins FSR Register
Einlesen movf PORTA,0 ;PortA ins W-Register
movwf INDF ;und ins aktuellen RAM Register
incf FSR,1 ;nächste Adresse
decfsz Temp,1 ;Temp = 0 ?
goto Einlesen ;nein, zum Einlesen
................ ;ja, weiter
Gesamtdauer: 100 Takten
Pause zwischen Einlesungen: 6 Takten
Programmspeicher Bedarf: 9 Speicherstellen
Direkt:

...............
movf PORTA,0
movwf 0x20
movf PORTA,0
movwf 0x21
movf PORTA,0
movwf 0x22
movf PORTA,0
movwf 0x23
movf PORTA,0
movwf 0x24
movf PORTA,0
movwf 0x25
movf PORTA,0
movwf 0x26
movf PORTA,0
movwf 0x27
movf PORTA,0
movwf 0x28
movf PORTA,0
movwf 0x29
movf PORTA,0
movwf 0x2A
movf PORTA,0
movwf 0x2B
movf PORTA,0
movwf 0x2C
movf PORTA,0
movwf 0x2D
movf PORTA,0
movwf 0x2E
movf PORTA,0
movwf 0x2F
...............
Gesamtdauer: 32 Takten
Pause zwischen Einlesungen: 2 Takten
Programmspeicher Bedarf: 32 Speicherstellen

Anstatt Warteschleifen (z.B. für Tastenentprellung) sollten Programmfragmente mit entsprechender Ausführungszeit benutzt werden (z.B. Ausgabe auf einem Display). Die nötige Zeit lässt sich aus mehreren UPs zusammensetzen.

Es sollte kein Prozessortakt ungenutzt bleiben.

= Mid-Range =

Zu Mid-Range gehören alle PICs mit 14-bit langen Befehlen aus den Familien 12FXXX und 16FXXX.

== Kurzübersicht Assembler Befehle ==

{|
|-
| valign=top |

{| {{Blauetabelle}}
|ADDLW||Add literal and W
|-
|ADDWF||Add W and f
|-
|ANDLW||AND literal with W
|-
|ANDWF||AND W with f
|-
|BCF||Bit Clear f
|-
|BSF||Bit Set f
|-
|BTFSC||Bit Test f, Skip if Clear
|-
|BTFSS||Bit Test f, Skip if Set
|-
|CALL||Call subroutine
|-
|CLRF||Clear f
|-
|CLRW||Clear W
|-
|CLRWDT||Clear Watchdog Timer
|}

| valign=top |

{| {{Blauetabelle}}
|-
|COMF||Complement f
|-
|DECF||Decrement f
|-
|DECFSZ||Decrement f, Skip if 0
|-
|GOTO||Go to address or label
|-
|INCF||Increment f
|-
|INCFSZ||Increment f, Skip if 0
|-
|IORLW||Inclusive OR literal with W
|-
|IORWF||Inclusive OR W with f
|-
|MOVF||Move f
|-
|MOVLW||Move literal to W
|-
|MOVWF||Move W to f
|-
|NOP||No Operation
|}

| valign=top |

{| {{Blauetabelle}}
|-
|RETFIE||Return from interrupt
|-
|RETLW||Return with literal in W
|-
|RETURN||Return from Subroutine
|-
|RLF||Rotate Left f through Carry
|-
|RRF||Rotate Right f through Carry
|-
|SLEEP||Go into standby mode
|-
|SUBLW||Subtract W from literal
|-
|SUBWF||Subtract W from f
|-
|SWAPF||Swap nibbles in f
|-
|XORLW||Exclusive OR literal with W
|-
|XORWF||Exclusive OR W with f
|}
[[:bild:pic_asm_short.jpg|Kurzübersicht zum Ausdrucken]]
|}


==Ausführliche Beschreibung zu den Befehlen==

Fast alle Befehle werden in einem Takt = 4 Oszillatortakten ausgeführt.

Aussnahmen:

"goto", "call", "return" und "retfie" benötigen wegen Zugriff auf den Programmzähler (PC) immer 2 Takten.

"btfsc", "btfss", "decfsz" und "incfsz" brauchen 1 Takt wenn der nächste Befehl ausgeführt wird b.z.w. 2 Takten wenn er überspringen wird, weil es immer anstatt des überspringenden Befehls ein "nop" ausgeführt wird.

Eine ausgegliederte Beschreibung der Befehle findet sich unter [[PIC Assemblerbefehle]]

Erklärungen zu den Verwendeten Platzhaltern:
*'''k''' stellt einen fest definierten Wert da. z.B. <tt>0x20</tt>, <tt>d'42'</tt> oder <tt>b'00101010'</tt>
*'''W''' steht für das W-Register.
*'''d''' steht für ''destination'' (Ziel). Im code wird d durch ein <tt>w</tt> bzw. <tt>0</tt> (der Wert wird in das W-Register gespeichert ) oder <tt>f</tt> bzw. <tt>1</tt> (der Wert wird in das davor definierte Register gespeichert)
*'''b''' steht für Bitnummer im Register (eine Zahl zwischen 0 und 7)
*'''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
*<tt>Schreibmaschinenstil</tt> bedeutet, dass es so im Quellcode geschrieben werden kann.

 ADDLW k ADD Literal and W - Addiere Zahl (k) und W<hr>
:Es wird die Rechenoperation <math>W+k</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|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

 ADDWF R,d ADD W and F - Addiere W und f <hr>
:Es wird die Rechenoperation <math>W+R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Dieser Befehl beeinflusst das STATUS-Register. Siehe hierzu [[#Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

 ANDLW k AND Literal with W<hr>
:Es wird bitweise die logische Funktion <math>k\ and\ W</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 Operation:
<dl><dd>
11001010 ;k
10101100 ;W-Register
-------- and
10001000 ;W-Register
</dd></dl>

 ANDWF R,d AND W with F<hr>
:Es wird bitweise die logische Funktion <math>W\ and\ R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Vergleiche ANDLW. Dieser Befehl wird benutzt zum Löschen bestimmten Bits im Register ohne restlichen Bits zu beeinflüssen.

BCF R,b Bit Clear F - Bit b im R wird gelöscht<hr>
:Mit dem Befehl <tt>BCF</tt> wird das Bit '''b''' im Register '''R''' gelöscht. Ein Beispiel:
<dl><dd>
movlw b'11111111' ;es wird b'11111111' in das W-Register geschrieben
BCF W,2 ;es wird bit 2 im W-Register gelöscht.
;das Ergebnis ist: b'11111011'
</dl></dd>

BSF R,b Bit Set F - Bit b im R wird gesetzt<hr>
:Mit dem Befehl <tt>BSF</tt> wird das Bit '''b''' im Register '''R''' gesetzt. Ein Beispiel:
<dl><dd>
clrw ;es wird b'00000000' in das W-Register geschrieben
BSF W,2 ;es wird bit 2 im W-Register gesetzt.
;das Ergebnis ist: b'00000100'
</dl></dd>

BTFSC R,b Bit Test F, Skip if Clear - Wenn das Bit b im Register R 0 ist, überspringe den nächsten Befehl<hr>
:Mit dem Befehl <tt>BTFSC</tt> kann eine Verzweigung im Programmablauf bewirkt werden. Wenn das Bit '''b''' im Register '''R''' 0 ist, wird der nächste Befehl übersprungen. Ein Beispiel:
<dl><dd>
movlw b'00000001' ;es wird die Zahl 1 in das W-Register kopiert.
BTFSC W,0 ;es wird bit 0 geprüft.
;wenn es 0 ist, wird der nächste Befehl übersprungen
goto IST_EINS ;springt zur Marke "IST_EINS" <- in diesem Fall wird dieser
;Sprungbefehl ausgeführt.
goto IST_NULL ;springt zur Marke "IST_NULL"
</dl></dd>

BTFSS R,b Bit Test F, Skip if Set - Wenn das Bit b im Register R 1 ist, überspringe den nächsten Befehl<hr>
:Mit dem Befehl <tt>BTFSS</tt> kann eine Verzweigung im Programmablauf bewirkt werden. Wenn das Bit '''b''' im Register '''R''' 1 ist, wird der nächste Befehl übersprungen. Ein Beispiel:
<dl><dd>
movlw b'00000001' ;es wird die Zahl 1 in das W-Register kopiert.
BTFSS W,0 ;es wird bit 0 geprüft.
;wenn es 1 ist, wird der nächste Befehl übersprungen
goto IST_NULL ;springt zur Marke "IST_NULL"
goto IST_EINS ;springt zur Marke "IST_EINS" <- in diesem Fall wird dieser
;Sprungbefehl ausgeführt, da der Befehl
;darüber übersprungen wurde.
</dl></dd>

CALL CALL Subroutine - Rufe Unterprogramm auf<hr>
:Mit dem <tt>CALL</tt> Befehl wird ein Unterprogramm aufgerufen. Mit dem <tt>RETURN</tt>-Befehl wird das Unterprogramm beendet und man kehrt zum Befehl nach dem <tt>CALL</tt>-Befehl zurück. Das Unterprogramm wird so definiert, dass im Quellcode der Name des Unterprogramms nicht eingerückt steht. Ein Beispiel:

<dl><dd>
movlw d'13' ;in das W-Register wird 13d geladen
CALL UP1 ;es wird das Unterprogramm "UP1" aufgerufen
movwf ergebnis ;das W-Register wird in das Register "ergebnis" kopiert.
;im Register "ergebnis" steht nun 23d

UP1 addlw d'10' ;es wird 10d zum W-Register addiert
return ;kehre zurück zum Aufrufer
</dl></dd>

CLRF R CLeaR F- Schreibe 0 in das Register R<hr>
:Das Register '''R''' wird mit Nullen gefüllt (gelöscht).

CLRW CLeaR W - Schreibe 0 in W<hr>
:Das W-Register (<tt>W</tt>) wird mit Nullen gefüllt (gelöscht).
:Der Befehl bewirkt das gleiche wie MOVLW 0 und darf im Programmen, die fur zukünftige Anwendung bei den PICs der serie 18F vorgesehen sind, nicht benutzt werden, da sie ihn nicht kennen.

CLRWDT CLeaR WatchDog Timer - Setzt den Watchdog-Timer zurück<hr>
:Es wird der WDT (Watchdog-Timer) zurückgesetzt und der Zähler des WDT auf 0 gesetzt, zusätzlich werden die STATUS-bits TO und PD gesetzt.

COMF R,d COMplement F - negiere alle bits im Register R<hr>
:Von der Binärzahl im Register '''R''' werden alle 0 mit 1 und alle 1 mit 0 ersetzt. Das Ergebnis wird entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Ein kleines Beispiel: aus <tt>AAh</tt> (<tt>10101010b</tt>) wird <tt>55h</tt> (<tt>01010101b</tt>).

DECF R,d DECrement F - Subtrahiert 1 vom Regiser f<hr>
:Vom Wert des Registers '''R''' wird 1 subtrahiert und das Ergebnis entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
:Weil es keine "echte" Substraktion ist, beeinflusst dieser Befehl das C-Flag im STATUS-Register nicht.

DECFSZ R,d DECrement F, Skip if Zero - Subtrahiert 1 vom Regiser f, überspringe wenn 0<hr>
:Vom Wert des Registers '''R''' wird 1 subtrahiert und das Ergebnis entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Der Zusatz SZ steht für ''skip if zero'', d.h. wenn das Ergebnis der Rechnung Null ist, wird der nächste Befehl übersprungen. Dieser Befehl wird für Schleifen mit bestimmter Anzahl der Durchläufe benutzt.

GOTO GO TO address - Gehe zu Adresse/Sprungmarke<hr>
:Nach dem GOTO Befehl wird das Programm ab der Adresse weiter ausgeführt, die nach dem GOTO-Befehl steht. Diese Adresse wird durch so genannte Sprungmarke definiert, welche, im Gegensatz zu den Befehlen nicht eingerückt im Quellcode stehen.

INCF R,d INCrement F - Addiere 1 zum Register f<hr>
:Zum Wert des Registers '''R''' wird 1 addiert und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
:Weil es keine "echte" Addition ist, beeinflusst dieser Befehl das C-Flag im STATUS-Register nicht.

INCFSZ R,d INCrement F, Skip if Zero - Addiere 1 zum Regiser f, überspringe wenn 0<hr>
:Zum Wert des Registers '''R''' wird 1 addiert und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Der Zusatz SZ steht für ''skip if zero'', d.h. wenn das Ergebnis der Rechnung Null ist, wird der nächste Befehl übersprungen. Dieser Befehl wird für Schleifen mit bestimmter Anzahl der Durchläufe benutzt.

 IORLW k Inclusive OR Literal with W<hr>
:Es wird bitweise die logische Funktion <math>k\ or\ W</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 Operation:
<dl><dd>
11001010 ;k
10101100 ;W-Register
-------- or
11101110 ;W-Register
</dd></dl>

 IORWF R,d Inclusive OR W with F<hr>
:Es wird bitweise die logische Funktion <math>W\ or\ R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Vergleiche IORLW. Dieser Befehl wird oft benutzt zum Setzen bestimmten Bits im Register ohne restlichen Bits zu beeinflüssen.

MOVF R,d MOVe F - Bewege f<hr>
:Das Register R wird in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder wieder in R kopiert ('''d'''=<tt>F</tt>=<tt>1</tt>). Letzteres mag sinnlos scheinen, ist aber nützlich, da durch den Befehl das Z-Bit im STATUS-Register gesetzt wird, falls R Null ist.

MOVLW k MOVe Literal to W - Bewege Zahl (k) in W-Register<hr>
:Der festgelegte Wert k wird in das W-Register kopiert.

:Dieser Befehl wird auch bei indirekter Adressierung zum laden der absoluter Adresse ins "FSR" Register benutzt. Beispiel:
:Der Register "Temp" wurde mit "Temp equ 0x20" definiert.
<dl><dd>
MOVLW Temp ;ins W-Register wird die absolute Adresse 0x20 vom "Temp" geladen
movwf FSR ;diese Adresse wird jetzt ins Register "FSR" kopiert
</dd></dl>
MOVWF R MOVe W to F- Bewege W-Register in das Register F<hr>
:Das W-Register wird in das Register '''R''' kopiert.

NOP No OPeration - Kein Befehl zum Ausführen (warte)<hr>
: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. Siehe hierzu: [[#Pause|Pause]]

RETFIE RETurn From Interrupt Enable - Kehre zurück aus der Unterbrechung, erlaube Unterbrechungen<hr>
:Mit diesem Befehl wird die Interrupt Service Routine (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 | Interrupt]]

RETLW k RETurn with Literal in W - Kehre zurück mit Zahl k im W-Register<hr>
:Wurde ein Programmteil mit dem Befehl <tt>CALL</tt> aufgerufen, dann springt man mit dem Befehl <tt>RETLW</tt> zurück in die nächste Zeile nach der Zeile aus der das <tt>CALL</tt> 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 Wertetabellen (eng: lookup tables) verwendet.

RETURN RETURN from Subroutine - Kehre zurück zum Aufrufer<hr>
:Wurde ein Programmteil mit dem Befehl <tt>CALL</tt> aufgerufen, dann springt man mit dem Befehl <tt>RETURN</tt> zurück zu der nächsten Zeile nach der Zeile aus der das <tt>CALL</tt> Befehl ausgeführt wurde.

RLF R,d Rotate Left F through carry - Rotiere das Register f mithilfe des Carry-bits nach links<hr>
:Alle Bits im Register '''R''' werden um eine Position nach links verschoben. Dabei wird das Carry bit (<tt>STATUS,C</tt>) 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'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
<dl><dd>
|<--- Register R --->|
|c|<-7<-6<-5<-4<-3<-2<-1<-0
V A
|________________________|
</dd></dl>
:Zur Verdeutlichung:
<dl><dd>
|C| |-Register R-| ;C steht für das Carry-bit, STATUS,C ; 0-7 stehen für Bitnummer im Register.
c 7 6 5 4 3 2 1 0 ;vor der Rotation
7 6 5 4 3 2 1 0 c ;nach der Rotation
</dd></dl>

RRF R,d Rotate Right F through carry - Rotiere das Register f mithilfe des Carry-bits nach rechts<hr>
:Alle Bits im Register '''R''' werden um eine Position nach rechts verschoben. Dabei wird das Carry bit (<tt>STATUS,C</tt>) 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'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
<dl><dd>
|<--- Register R --->|
|c|->7->6->5->4->3->2->1->0
A V
|________________________|
</dd></dl>
:Zur Verdeutlichung:
<dl><dd>
|C| |-Register R-| ;C steht für das Carry-bit, STATUS,C ; 0-7 stehen für Bitnummer im Register.
C 7 6 5 4 3 2 1 0 ;vor der Rotation
0 C 7 6 5 4 3 2 1 ;nach der Rotation
</dd></dl>

SLEEP Go into standby mode - Versetze den Mirokontroller in Bereitschaftsmodus (Schlaf)<hr>
: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.

 SUBLW k SUBtract W from Literal - Ziehe W von Zahl (k) ab<hr>
: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|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

 SUBWF R,d SUBtract W from F - Ziehe W von f ab<hr>
:Es wird die Rechenoperation <math>R-W</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Dieser Befehl beeinflusst das STATUS-Register. Siehe hierzu [[#Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

:Beispiel:
<dl><dd>
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
</dd></dl>

SWAPF R,d SWAP nibbles in F - Vertausche die Halbbytes (Nibbles)<hr>
:Es werden die höheren 4 bit (bit7-bit4) mit den niedrigeren 4 bit (bit3-bit0) eines Registers vertauscht und entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
:Beispiel:
<dl><dd>
movlw b'00001111' ;schreibe b'00001111' in das W-Register
movwf Register1 ;kopiert 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'
</dd></dl>

 XORLW k EXclusive OR Literal with W<hr>
:Es wird bitweise die logische Funktion <math>k\ xor\ W</math> ausgeführt und das Ergebniss in das W-Register gespeichert. Dieser Befehl setzt das Z bit des STATUS-Registers, falls W=k und das Ergebnis 0 ist.
:Zur Verdeutlichung der Operation:
<dl><dd>
11001010 ;k
10101100 ;W-Register
-------- xor
01100110 ;W-Register
</dd></dl>

 XORWF R,d EXclusive OR W with F<hr>
:Es wird bitweise die logische Funktion <math>W\ xor\ R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Vergleiche XORLW. Dieser Befehl setzt das Z bit des STATUS-Registers, falls W=k und das Ergebnis 0 ist und wird zum Vergleichen zwei Register benutzt.

==Besondere, oft gebrauchte Register==

=== STATUS ===
Der Statusregister beinhaltet den Status der Recheneinheit ALU (Arithmetic-Logic Unit), Resetinformationen und die beiden Bits zur Wahl der Speicherbank

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''STATUS''' (ADDRESSE 03h, 83h, 103h, 183h)</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R-1</td>
<td style="width:60px;">R-1</td>
<td style="width:60px;">R/W-x</td>
<td style="width:60px;">R/W-x</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''IRP'''</td>
<td style="background:#f5f7ff;">'''RP1'''</td>
<td style="background:#f5f7ff;">'''RP0'''</td>
<td style="background:#f5f7ff;">'''TO'''</td>
<td style="background:#f5f7ff;">'''PD'''</td>
<td style="background:#f5f7ff;">'''Z'''</td>
<td style="background:#f5f7ff;">'''DC'''</td>
<td style="background:#f5f7ff;">'''C'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

*Bit 7 '''IRP''': Register Bank Select Bit (für indirekte Adressierung)
:: 1 = Bank 2, 3 (100h-1FFh)
:: 0 = Bank 0, 1 (00h-FFh)
*Bit 6-5 '''RP<1:0>''': Register Bank Select Bits (für direkte Adressierung)
:: 11 = Bank 3 (180h-1FFh)
:: 10 = Bank 2 (100h-17Fh)
:: 01 = Bank 1 (80h-FFh)
:: 00 = Bank 0 (00h-7Fh)
*Bit 4 '''TO''': Time-out Bit
:: 1 = Nach Power-up, CLRWDT Befehl oder SLEEP Befehl
:: 0 = A Watchdogtimer time-out ist eingetreten
*Bit 3 '''PD''': Power-Down Bit
:: 1 = Nach Power-up oder durch den CLRWDT
:: 0 = Nach einem SLEEP befehl
*Bit 2 '''Z''': Zero bit
:: 1 = Das Ergebnis einer arithmetischen oder logischen Operation ist 0
:: 0 = Das Ergebnis einer arithmetischen oder logischen Operation ist NICHT 0
*Bit 1 '''DC''': Digit carry/borrow bit (ADDWF, ADDLW, SUBLW und SUBWF Befehle)
:: 1 = Ein Carry-out des 4.Niedrigsten Bits (Low Nibble) eines Rechenergebnisses existiert
:: 0 = Kein Carry-out des 4.Niedrigsten Bits eines Rechenergebnisses existiert
*Bit 0 '''C''': Carry/borrow Bit (ADDWF, ADDLW, SUBLW und SUBWF Befehle)
:: 1 = Ein Carry-out des MSB eines Rechenergebnisses existiert
:: 0 = Kein Carry-out des MSB eines Rechenergebnisses existiert

Das "Carry/Borrow Bit" (to carry = etwas übertragen, to borrow = etwas borgen) dient zum erkennen, wenn ein Übertrag einer Rechenoperation exisitiert. 250d+10d ergibt zum Beispiel 4, und setzt dabei das "Carry/Borrow Bit" auf 1. Damit kann das Programm erkennen, wenn wieder einmal ein Ergebnis größer als 255d herauskam.
Bei Subtraktionen (SUBLW und SUBWF) verhält sich das "Carry/Borrow Bit" umgekehrt als bei Additionen (ADDWF und ADDLW)!! Zum Beispiel 55d-6=49d setzt "Carry/Borrow Bit" auf 1 aber 10d-25d=241d löscht das "Carry/Borrow Bit".

====Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Registers====

{|
|-
|
{| {{Blauetabelle}}
|+ Auswirkungen auf das STATUS-Register bei Subtraktionen
|-
| Ergebnis
|| STATUS,C
|| STATUS,Z
|-
| positiv
|align="center"|1
|align="center"|0
|-
| negativ
|align="center"|0
|align="center"|0
|-
| Null
|align="center"|1
|align="center"|1
|}

||

{| {{Blauetabelle}}
|+ Auswirkungen auf das STATUS-Register bei Additionen
|-
| Ergebnis
|| STATUS,C
|| STATUS,Z
|-
| positiv
|align="center"|0
|align="center"|0
|-
| Überlauf
|align="center"|1
|align="center"|0
|-
| Null
|align="center"|1
|align="center"|1
|}
|}

=== PORTx ===

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''PORTx'''</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''Rx7'''</td>
<td style="background:#f5f7ff;">'''Rx6'''</td>
<td style="background:#f5f7ff;">'''Rx5'''</td>
<td style="background:#f5f7ff;">'''Rx4'''</td>
<td style="background:#f5f7ff;">'''Rx3'''</td>
<td style="background:#f5f7ff;">'''Rx2'''</td>
<td style="background:#f5f7ff;">'''Rx1'''</td>
<td style="background:#f5f7ff;">'''Rx0'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

!Das "x" steht in allen Fällen für den Buchstaben des Ports!
BSP: "PORTB" oder "RA1"

Diese Special Funktion Register liegen ALLE in Bank0 und Bank2(Falls vorhanden).

Jedes Bit eines PORT-Registers steht für einen Pin (Ein/Ausgang) des jeweiligen Ports. Je nachdem Ob ein Pin als Ausgang oder als Eingang definiert ist, kann man dort entweder den Wert schreiben oder auslesen. Es hat nicht Jeder PIC gleich viele Ports und es sind auch nicht immer 8 Pins pro Port, es können auch weniger sein. Alle PICs der Midrange-Serie besitzen nur bidirektionale Ports, d.h. sie können sowohl Eingang als auch Ausgang sein. Bei Port B kann man bei allen Pins einen internen PULL-UP Widerstand mit dem Bit OPTION_REG<RBPU> hinzuschalten (Standardmäßig auf nicht aktiviert, Bit muss gelöscht werden um die Funktion zu aktivieren). Weiters ist zu beachten, dass einzelne Pins nach dem Reset mit anderen Funktionen belegt sein können. Das gilt im Speziellen für PORTA, wo sich die Komperatoren, AD's (falls vorhanden) und die Oszillatoreingänge befinden. Siehe [[PIC Assembler#I/O Ports|I/O Ports]]. Bei den "kleinsten" PICs der 12F Serie die nur einen I/O Port (6 Pins) haben, heisst der PORT-Register GPIO.
{|{{Blauetabelle}}
|+ Beispiel PICs und ihre Ports (Zahlen in der Klammer sind die Anzahl der Pins des Ports)
|
|'''PIC16F628A'''
|'''PIC16F876'''
|'''PIC16F877'''
|-
|'''PORTA'''
|Ja
|Ja(5)
|Ja(6)
|-
|'''PORTB'''
|ja
|ja
|ja
|-
|'''PORTC'''
|/
|ja
|ja
|-
|'''PORTD'''
|/
|/
|ja
|-
|'''PORTE'''
|/
|/
|ja (3)
|-
|}

=== TRISx ===

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''TRISx'''</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''TRISx7'''</td>
<td style="background:#f5f7ff;">'''TRISx6'''</td>
<td style="background:#f5f7ff;">'''TRISx5'''</td>
<td style="background:#f5f7ff;">'''TRISx4'''</td>
<td style="background:#f5f7ff;">'''TRISx3'''</td>
<td style="background:#f5f7ff;">'''TRISx2'''</td>
<td style="background:#f5f7ff;">'''TRISx1'''</td>
<td style="background:#f5f7ff;">'''TRISx0'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

!Das "x" steht in allen Fällen für den Buchstaben des Ports!
BSP: "TRISB" oder "TRISA"

Bei den "kleinsten" PICs der 12F Serie die nur einen I/O Port (6 Pins) haben, heisst der TRIS-Register TRISIO.

Die TRIS-Bytes dienen dazu, einzelne I/O Pins als Eingang oder Ausgang zu definieren. Sie liegen immer genau eine Bank über den jeweiligen PORT-Bytes, d.h. sie liegen alle in Bank1 und Bank3 (falls vorhanden.) Besonders zu beachten ist, dass manche Eingebaute Features wie die Serielle Schnittstelle, I2C, SPI usw nicht funktionieren, wenn die Jeweiligen Sende und Empfangspins nicht manuell umgestellt werden, ja es ''muss'' sogar manchmal umgestellt werden (bei I2C z.B.) Egal ist dies jedoch für Komperatoren und AD-Wandler.

Merke:
* Eine 1 (als "I" für "Input" zu lesen) eines TRISxx-Bits definiert den zugehörigen PIN am PIC als Eingang.
* Eine 0 (als "O" für "Output" zu lesen) eines TRISxx-Bits definiert den zugehörigen PIN am PIC als Ausgang.

Siehe [[PIC Assembler#I/O Ports|I/O Ports]].

=== INTCON ===

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''INTCON''' (ADDRESSE 0Bh, 8Bh, 10Bh, 18Bh)</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''GIE'''</td>
<td style="background:#f5f7ff;">'''PEIE'''</td>
<td style="background:#f5f7ff;">'''TMR0IE'''</td>
<td style="background:#f5f7ff;">'''INT0IE'''</td>
<td style="background:#f5f7ff;">'''RBIE'''</td>
<td style="background:#f5f7ff;">'''TMR0IF'''</td>
<td style="background:#f5f7ff;">'''INT0IF'''</td>
<td style="background:#f5f7ff;">'''RBIF'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

*Bit 7 '''GIE''': Global Interrupt Enable Bit
::1 = Aktiviert alle Interrupts
::0 = Deaktiviert alle Interrupts
*Bit 6 '''PEIE''': Peripheral Interrupt Enable Bit
::1 = Aktiviert alle peripheren Interrupts
::0 = Deaktiviert alle peripheren Interrupts
*Bit 5 '''TMR0IE''': TMR0 Overflow Interrupt Enable Bit (Overflow von Timer0 löst Interrupt aus)
::1 = Aktiviert den TMR0 Interrupt
::0 = Deaktiviert den TMR0 Interrupt
*Bit 4 '''INT0IE''': RB0/INT External Interrupt Enable Bit (Änderung an RB0 Pin löst Interrupt aus) *)
::1 = Aktiviert den RB0/INT Interrupt (Extern ausgelöst)
::0 = Deaktiviert den RB0/INT Interrupt (Extern ausgelöst)
*Bit 3 '''RBIE''': RB Port On-Change-Interrupt Enable Bit (Änderung an PortB löst Interrupt aus) **)
::1 = Aktiviert den RB port on-change-interrupt
::0 = Deaktiviert den RB port on-change-interrupt
*Bit 2 '''TMR0IF''': TMR0 Overflow Interrupt Flag Bit
::1 = TMR0 Register ist Übergelaufen (muss per Software gelöscht werden)
::0 = TMR0 register ist nicht Übergelaufen
*Bit 1 '''INT0IF''': RB0/INT External Interrupt Flag Bit
::1 = Eine Änderung an RB0/INT Pin hat stattgefunden (muss per Software gelöscht werden)
::0 = Eine Änderung an RB0/INT Pin hat nicht stattgefunden
*Bit 0 '''RBIF''': RB Port On-Change-Interrupt Flag bit
::1 = Mind. einer der Pins von RB7:RB4 hat sich geändert (muss per Software gelöscht werden)
::0 = Keiner der Pins von RB7:RB4 hat sich geändert

* *) Die Flanke auf die reagiert werden soll, wird mit dem Bit OPTION_REG.INTEDG definiert. (steigende = 1 oder fallende = 0)
* **) Der Interrupt klingt verführerischer Weise so, als ob er den gesamten Port überwacht. Dabei reagiert er nur auf RB7:RB4!!!! Er kann aber den Prozessor vom "Schlaf" aufwecken (z.B. durch einen Tastendruck).

==Speicherbankorganisation==
===Programmspeicher===
Die Mid-Range MCUs haben einen 2-8k großen Programmspeicher. Dieser hat aber in jeder Speicherzelle nicht 8, sondern 14 Bit - also genau die Länge eines Befehls. Die aktuelle Stelle im Programm wird im PC (Program Counter) verwaltet. Er speichert immer die aktuelle Adresse im Programmspeicher (wird im Code oft als "$" bezeichnet). Bei einem PIC mit 8k Adressen muss er also die Adressen 0000-1FFF speichern können. Daraus folgt die Größe von 13 Bit für den PC. Der Programmspeicher ist in mehrere Bänke geteilt, die alle 2k groß sind. Das Programm springt ohne zutun des Benutzers von einer in die Nächste. Wenn man aber selber springen will, muss man die Register PCLATH (Program Counter Latch High) oder PCL (Program Counter Least Significant Byte) mit der Sprungadresse beschreiben.

===Datenspeicher===
Der Datenspeicher besteht aus den Special Function Registern (SFR) und den General Purpose
Registern (GPR). Die SFRs sind für die Funktionen des PICs zuständig (Interrupts, Timer, ADCs, CCPM...) und die GPRs für die Speicherung von Variablen und Daten.

Da immer nur 7 Bit der (Ziel)Adresse in einem Befehl gespeichert werden können, sind nur 7Fh (128d) Adressen im Datenbereich möglich. Deswegen wurde das "Banking" eingeführt. 2 Bit im Statusregister (welcher in allen Bänken der selbe ist und auch an der gleichen Stelle sitzt) geben die akutelle "Bank" an und sind nichts anderes als die 2 höchstwertigsten (MSB) Bits der Adresse. Damit lassen sich max. 4 Bänke ansprechen. Je nach PIC gibt es 2-4 Bänke. Die beiden Bits im Register STATUS heißen RP0 (STATUS<5>) und RP1 (STATUS<6>).

{| {{Blauetabelle}}
|+ Wechseln der Bänke mit RP0 und RP1
|-
|
|| RP1
|| RP0
|-
| Bank0
|align="center"|0
|align="center"|0
|-
| Bank1
|align="center"|0
|align="center"|1
|-
| Bank2
|align="center"|1
|align="center"|0
|-
| Bank3
|align="center"|1
|align="center"|1
|}

[[Bild:PIC midrange register.JPG]]
# '''FETTE Register''' sind in allen PICs vorhanden
# können je nach PIC unimplementierte Bereiche beinhalten - diese werden immer als 0 gelesen. (DATENBLATT!!)
# siehe 2
# Könnten je nach PIC auch nicht in Bank0 gemapped werden, sind dann eigenständige Register.
# je nach PIC kann es diese Bänke geben oder nicht geben.

== Codeschnipsel ==

=== Analog-Digital-Wandler (ADC) ===

Viele PICs besitzen einen Analog-Digital-Wandler, der eine angelegte Spannung messen kann und diese als Zahl speichert.

Es gibt AD-Wandler mit 8Bit bzw. 10Bit Auflösung, d.h. die Spannung an einem analogen Eingang wird linear 2^8=256 bzw. 2^10=1024 Werten zugeordnet.
Der höchste Wert, auch Referenzspannung genannt, (255 bzw. 1023; der Controller rechnet die Null auch mit) entspricht der Betriebsspannung des PICs oder wahlweise einer wählbaren Spannung, die an RA3 angelegt werden muss. Der niedrigste Wert entspricht 0 Volt.

Mit dem Analog-Digital-Wandler kann man somit z.B. Sensoren auswerten, die mehr als zwei Zustände ausgeben (Beispiele: Temperatursensor, Helligkeitssensor, Entfernungssensoren usw.) oder Akkuspannungen messen.

Bevor überhaupt gemessen werden kann, muss einiges eingestellt werden:

* Eingangsverteilung Analog/Digital bzw.Referenzspannung (Betriebsspannung oder RA3)
die genauen Einstellungsmöglichkeiten entnehmen sie bitte dem Datenblatt ihres Controllers (Register ADCON1 Bank 1).

* Wählen des Taktes für den ADC und Einschalten des ADCs

Das Register ADCON0 besitzt 8 Bits, die folgendes bestimmen:
Bit0 ADON - schaltet AD-Wandler ein oder aus (Strom sparen)
Bit1 - nicht vorhanden
Bit2 GO/Done - startet Wandlung / signalisiert, wann Umwandlung beendet ist.
Bit3 CHS0 - Channel Select 0 wählt Eingang aus
Bit4 CHS1 - Channel Select 1 wählt Eingang aus
Bit5 CHS2 - Channel Select 2 wählt Eingang aus
Bit6 ADCS0 - AD-Clock-Select wählt Takt
Bit7 ADCS1 - AD-Clock-Select wählt Takt

Kümmern wir uns zunächst um den Takt. Mit den zwei Bits ADCS0 und ADCS1 bestimmt man den Takt - hierbei gibt es vier Möglichkeiten:

ADCS1=0, ADCS0=0 -> Taktfrequenz des PICs :2
ADCS1=0, ADCS0=1 -> Taktfrequenz des PICs :8
ADCS1=1, ADCS0=0 -> Taktfrequenz des PICs :32
ADCS1=1, ADCS0=1 -> interner RC-Oszillator des ADCs verwenden

Die Taktfrequenz des ADCs darf 625kHz nicht überschreiten, dementsprechend ist ADCS0 und ADCS1 zu wählen.

Ist dies vollbracht, so kann man den AD-Wandler einschalten und das Go/Done-Bit löschen.
Codebeispiel:

bcf ADCON0,6 ;Takt für
bsf ADCON0,7 ;ADC (OSC/32)
bsf ADCON0,0 ;ADC einschalten, ADON=1
bcf ADCON0,2 ;Go/Done-Bit zurücksetzen

Nun ist der AD-Wandler bereit, Spannungen in Zahlen umzuwandeln.
Für eine Wandlung muss erst der entsprechende Eingang gewählt werden. Dafür sind die CHS0..CHS2-Bits zuständig:

CHS2 CHS1 CHS0 gewählter Eingang(falls vorhanden)
0 0 0 RA0
0 0 1 RA1
0 1 0 RA2
0 1 1 RA3
1 0 0 RA5
1 0 1 RE0
1 1 0 RE1
1 1 1 RE2

Achtung! RA4 ist kein analoger Eingang, folglich ist er oben nicht aufgelistet !!

Codebeispiel:

bcf ADCON0,3 ;RA2 auswählen
bsf ADCON0,4
bcf ADCON0,5

Als letztes muss die AD-Routine nur noch gestartet werden. Ist der AD-Wandler fertig, so löscht er das Bit wieder. Das Bit wird nun solange abgefragt, bis der AD-Wandler fertig ist. Den zugeordneten Wert findet man im Register 'ADRES'.
Code:

bsf ADCON0,2 ;start
wa btfsz ADCON0,2 ;warten,bis es wieder low ist
goto wa ;noch nicht fertig
;jetzt ist er fertig
movf ADRES,W ;ADRES in W verschieben, um damit gleich weiter zu arbeiten

Die AD-Wandlung ist somit fertig. Liest man mehrere Werte von unterschiedlichen Eingängen ein und möchte diese miteinander vergleichen o.ä., sollte man die Zahlen von ADRES in anderen Registern zwischenspeichern.

Desweiteren ist zu beachten, dass der Analog-Digital-Wandler eine gewisse Pause zwischen den Wandlungen benötigt, die sog. 'Aquisition Time'. Diese Zeitangabe entnehmen sie bitte ihrem Datenblatt.

mögliche Probleme:

;Der PIC liefert stark schwankende Werte
:-> Mögliche Ursachen dafür sind z.B. nicht stabile Betriebsspannung, falsche Zeiteinstellungen. Abhilfe schafft auch das mehrmalige Einlesen eines Eingangs. Auch können z.B. 8 Werte eingelesen werden und dann der Durchschnitt gebildet werden.
Evtl. kann ein Kondensator gegen Masse (z.B. 1nF) helfen; Wichtig ist auch eine kleine Verzögerung zwischen Kanalauswahl und Start der Wandlung. In dieser Zeit kann sich der interne Kondensator des ADC's aufladen.

;Die Spannung an einem Eingang wird erhöht, die Werte der anderen Eingänge werden aber auch beeinflusst.
:-> Dann sind Sie Opfer des sog. 'Ghostings' geworden (Werte 'scheinen durch', verschleißen). Die Werte der anderen Eingänge gehen mit, weil der interne Kondensator noch auf die Spannung des Vorgängers aufgeladen ist. Maßnahme: Aquisition Time erhöhen, Werte öfters abfragen, Pause zwischen Kanalauswahl und Start

;Der PIC liefert immer die gleichen Werte an einem Eingang, obwohl sich die angelegte Spannung ändert
:-> möglicherweise falsche Eingangsverteilung (ADCON1) eingestellt oder falschen Pin gewählt

=== Hex Dec Wandlung ===

Das ist ein Unterprogramm das mit "call Hex_Dec" aufgerufen wird. Es gibt 4 Register (A, B, C und D) mit jeweils 32 Bits, die aus jeweils 4 Register mit 8 Bits (z.B. fur A: A3, A2, A1 und A0) bestehen.

A3 A2 A1 A0
.--------.--------.--------.--------.
|76543210|76543210|76543210|76543210|
'--------'--------'--------'--------'
| |
|<----------- A Register ---------->|

Sie müssen (wegen FSR) so wie im Code nacheinander liegen (die absoluten Adressen sind nicht wichtig). In das Register "A" wird die hex Zahl eingeschrieben und aus dem "D" die umgewandelte dec Zahl ausgelesen. A3,7 und D3,7 sind MSB und A0,0 und D0,0 sind LSB. Die "B" und "C" sind Hifsregister. Das UP kann für kleinere als 32-bittige hex Zahlen modifiziert werden. Zum Beispiel für 16-bittige hex Zahlen bleiben nur Register A1,A0,B1,B0,C1,C0,D1,D0 und in den UPs werden in die Register und als X, folgende Zahlen eingeschrieben: HTmp->0x10 (Anzahl Bits der hex Zahl),ATmp->2=X (Anzahl Bytes der hex Zahl). Es müssen auch die UPs "CClr", "DClr" und "CopyCB" entsprechend der Registerlänge angepasst werden. Genauso kann natürlich das UP auch für längere hex Zahlen modifiziert werden.

Das UP "AddCB" addiert dezimal die 32- bittige Register C und B, das Ergebniss befindet sich in C.
Das UP "AddDC" addiert dezimal die 32-bittige Register D und C, das Ergebniss befindet sich in D.

Die 32-bit Additionen werden in 4 Schritten wie folgt realisiert:

C0+B0->C0, C1+B1->C1, C2+B2->C2 und C3+B3->C3

D0+C0->D0, D1+C1->D1, D2+C2->D2 und D3+C3->D3

Die Flags "_Fcra", "_Fcrp" und "_Fdca" steuern die alle nötigen Korrekturen.

Die Wandlung wird in 32 Schritten laut folgender Formel durchgeführt:

Zahl(d)=B0*2^0+B1*2^1+B2*2^2+B3*2^3+B4*2^4+B5*2^5+B6*2^6+B7*2^7+B8*2^8+B9*2^9+B10*2^10+B11*2^11+

B12*2^12+B13*2^13+B14*2^14+B15*2^15+B16*2^16+B17*2^17+B18*2^18+B19*2^19+B20*2^20+B21*2^21+

B22*2^22+B23*2^23+B24*2^24+B25*2^25+B26*2^26+B27*2^27+B28*2^28+B29*2^29+B30*2^30+B31*2^31

Wobei B0 bedeutet den LSB und B31 den MSB der hex Zahl.

Die dec Zahl wird im D Register durch "AddDC" gebildet. In dem C Register befindet sich immer die laufende 2^X. Am Anfang wird dort 1=2^0 geladen. Da die nächste zu addierende dec Zahl immer gleich 2* vorherige ist, wird sie einfach so berechnet, dass die aktuelle aus C Register ins B Register kopiert ("CopyCB") und zu C addiert ("AddCB") wird. Diese dec Zahl wird zum D Register addiert nur wenn das entsprechende Bit der hex Zahl gleich 1 ist. Weil im UP "Hex_Dec" immer das bit A0,0 dafür geprüft wird, wird das gesamte 32-bittige A Register nach jeder Addition "AddDC" um ein Bit mit "ARotRb" nach rechts rotiert. Die Flags "_Fcra" und "_Fcrp" übertragen die Bits zwischen den 8 Bit Registern A0, A1, A2 und A3. Es würde zwar reichen, wenn das A Register nur verschoben würde, aber hier wurde Rotation gewählt, damit nach der Wandlung die hex Zahl im A Register unverändert steht. Weil die dec Zahl nur 8-stellig ist, darf die max. hex Zahl 99999999d = 5F5E0FFh sein.

#define _C STATUS,C
#define _Z STATUS,Z
#define _DC STATUS,DC
#define _Fcra Flags,0
#define _Fcrp Flags,1
#define _Fdca Flags,2
#define _Ferr Flags,3 ;Überlauf (Fehler)
;..................................................................................
A3 EQU 0x20 ;Register fürs Rechnen
A2 EQU 0x21
A1 EQU 0x22
A0 EQU 0x23
B3 EQU 0x24
B2 EQU 0x25
B1 EQU 0x26
B0 EQU 0x27
C3 EQU 0x28
C2 EQU 0x29
C1 EQU 0x2A
C0 EQU 0x2B
D3 EQU 0x2C
D2 EQU 0x2D
D1 EQU 0x2E
D0 EQU 0x2F
Flags EQU 0x30
ATmp EQU 0x31 ;Schleifenzähler
HTmp EQU 0x32 ;Schleifenzähler
RTmp EQU 0x33 ;Zwischenspeicher
;..................................................................................
Hex_Dec call CClr ;Hex>A, D>Dec
call DClr
movlw 1
movwf C0
movlw 0x20 ;32 bit Hex > 32 bit Dec (8 Stellen)
movwf HTmp
HexDecL btfsc A0,0
call AddDC
call CopyCB
call AddCB
call ARotRb
decfsz HTmp,1
goto HexDecL
return
CClr clrf C0
clrf C1
clrf C2
clrf C3
return
DClr clrf D0
clrf D1
clrf D2
clrf D3
return
CopyCB movf C0,0
movwf B0
movf C1,0
movwf B1
movf C2,0
movwf B2
movf C3,0
movwf B3
return
AddCB movlw B0 ;C+B>C
movwf FSR
goto AddR
AddDC movlw C0 ;D+C>D
movwf FSR
AddR bcf _Ferr ;Addiere zwei Register
bcf _Fcrp
movlw 4 ;X=4 Bytes lang
movwf ATmp
AddRL bcf _Fdca
bcf _Fcra
movf INDF,0
movwf RTmp
movlw 4 ;X=4
addwf FSR,1
btfss _Fcrp
goto AddRN
movlw 1
addwf INDF,1
call DecCor
AddRN movf RTmp,0
addwf INDF,1
call DecCor
btfss _Fdca
goto AddCor1
movlw 6
addwf INDF,1
AddCor1 btfss _Fcra
goto AddCor2
movlw 0x60
addwf INDF,1
btfsc _C
bsf _Fcra
AddCor2 movf INDF,0
andlw 0xF0
sublw 0xA0
btfss _Z
goto AddCor3
movf INDF,0
andlw 0x0F
clrf INDF
addwf INDF,1
bsf _Fcra
AddCor3 bcf _Fcrp
btfsc _Fcra
bsf _Fcrp
movlw 5 ;X+1=5
subwf FSR,1
decfsz ATmp,1
goto AddRL
btfsc _Fcra
bsf _Ferr
return
DecCor btfsc _DC ;dezimale Korrektur (equ DAW)
bsf _Fdca
btfsc _C
bsf _Fcra
movf INDF,0
andlw 0x0F
sublw 9
btfss _C
bsf _Fdca
movf INDF,0
andlw 0xF0
sublw 0x90
btfss _C
bsf _Fcra
return
ARotRb movlw A3 ;rotiere A register 1 Bit rechts
movwf FSR
RRotRb movlw 4 ;rotiere X=4 Bytes
movwf ATmp
bcf _Fcrp
btfsc A0,0
bsf _Fcrp
RRotRbL bcf _Fcra
btfsc INDF,0
bsf _Fcra
bcf _C
btfsc _Fcrp
bsf _C
rrf INDF,1
bcf _Fcrp
btfsc _Fcra
bsf _Fcrp
incf FSR,1
decfsz ATmp,1
goto RRotRbL
return

=== EEPROM ===

Alle PICs besitzen EEPROM in dem je nach Typ können 64 bis 256 Databytes abgespeichert werden. Die Adressierung des EEPROMs fängt immer mit 0x00 an. Hier werden nur geprüfte UPs kurz erklärt. Die ersten zwei brauchen nur ein Register "Temp" für Schleifenzähler, dessen Name, falls im Programm schon existiert, geändert werden muss. Die Adresse im EEPROM ist gleich der Adresse im RAM.

EEPROM beschreiben:

EEWrite movlw 0x20 ; ab der RAM Adresse wird in EEPROM abgespeichert
movwf FSR
movlw 4 ; soviel Bytes
movwf Temp ; Schleifenzähler
EEWLoop call EEWrite1
incf FSR,1 ; nächste Adresse
decfsz Temp,1
goto EEWLoop
return

EEWrite1 bcf INTCON,GIE ; Interrupts sperren
movf FSR,0
bsf STATUS,RP0 ; auf Bank1 umschalten
movwf EEADR ; EEPROM Adresse
movf INDF,0
movwf EEDATA ; EEPROM Data
bsf EECON1,WREN
movlw 0x55
movwf EECON2
movlw 0xAA
movwf EECON2
bsf EECON1,WR
bcf EECON1,WREN
btfsc EECON1,WR
goto $-1 ; warten bis WR=0
bcf STATUS,RP0 ; zurück auf Bank 0 umschalten
bsf INTCON,GIE ; Interrupts erlauben
return

EEPROM lesen und zurück in RAM schreiben:

EERead movlw 0x20 ; ab der Adressse wird aus EEPROM in RAM abgelegt
movwf FSR
movlw 4 ; soviel Bytes
movwf Temp ; Schleifenzähler
EERLoop call EERead1
incf FSR,1 ; nächste Adresse
decfsz Temp,1
goto EERLoop
return

EERead1 movf FSR,0
bsf STATUS,RP0 ; auf Bank1 umschalten
movwf EEADR ; EEPROM Adresse
bsf EECON1,RD
movf EEDATA,0 ; EEPROM Data
bcf STATUS,RP0 ; zurück auf Bank 0 umschalten
movwf INDF
return

Tabelle im EEPROM mit MPASM Direktive "de" erstellen:

org 0x2100 ; EEPROM initialisieren
; nachfolgend als Kommentar die EEPROM Adressen
de 0x03, 0xE8 ; 0x00
de 0x03, 0xE8 ; 0x02
de 'M','H','z',0x00 ; 0x04
de ' ',' ','W','A','I','T',0x00 ; 0x08
de 'C','o','n','s','t',' ','X',0x00 ; 0x0F
de 'C','=',0x00 ; 0x17
de 'L','=',0x00 ; 0x1A
de 'F','=',0x00 ; 0x1D
de 'O','K',0x00 ; 0x20
u.s.w.

Wenn die Tabelle sich im Quellcode befindet, wird sie beim brennen des PICs in EEPROM eigeschrieben.

Das Lesen eines Strings muss ab entsprechender EEPROM Adresse (z.B. für "MHz" -> 0x04) anfangen und auf dem Wert 0x00, der hier als Stringende dient, enden. Einfacher ist, wenn alle Strings gleich lang sind (wie z.B. in einem Zeichengenerator fur Grafikdisplay).

Die Adreesse "0x2100" in der "org" Direktive hat mit der Adresse im Programmspeicher nichts zu tun.

=== Interrupts ===

Das Programmteil misst eine Frequenz an TOCKI Pin und wurde für PIC16F870 geschrieben.

Benötigte Hardware: Widerstand 470 Ohm zwischen der Frequenzquelle und TOCKI Pin (A4).

Es fehlen UPs "Hex_Dec" [[#Hex Dec Wandlung|Hex Dec Wandlung]] und Ausgabe auf ein Display "DispFrq". Das HP ("Main") als leere endlose Schleife macht nichts ausser warten auf ein Interrupt von Timer0 bzw. Timer1. Man kann die Marke "Main" weglassen und das HP als "goto $" formulieren.

Da der Timer0 nicht, wie der Timer1 durch ein Flag gestartet und gestoppt werden kann, wird es durch setzen und löschen des Bits für TOCKI (A4) Pin im TRISA Register, genauso wie in der AN592 vom Microchip, gemacht.

Der Zähler der Frequenz wurde um ein Zähler aus zwei zusätzlichen Register A2 und A3 erweitert und bei jedem Timer0 Überlauf erhöht. Der Prescaler wird ins Register A0 und der TIMER0 ins A1 kopiert. Somit ergibt sich 32-bittiges Ergebniss, der als hex Zahl in den Register A3 (MSB),A2, A1, und A0 (LSB) steht. Nach der "Hex_Dec" Wandlung kann die Frequenz aus den Register D3 (MSB), D2, D1 und D0 (LSB) an einem biliebigen Display angezeigt werden.

Es wird kein zusätzliches Register benötigt, da das "ATmp" und das "RTmp" die gleichen wie im UP "Hex_Dec" sind. Die Quarzfrequenz wurde gewählt, weil sie am nächsten der Temperaturstabiltesten Frequenz für AT Quarzen 7,2 MHz ist. Der PIC16F870 wurde nur wegen nötigen 19 I/O Pins für 6-stelligen 7-segment LCD Display LPH2673-1[[http://www.roboternetz.de/phpBB2/viewtopic.php?t=26005]] (ohne Kontroller) vom Pollin angewendet. Mit einem üblichen 1x16 Zeichen LCD Matrixdisplay und anderen PICs wurde das Programm für Frequenzen bis zum 80 MHz mit einer Genauigkeit
+/- 4 Hz positiv getestet.

Um die Frequenz mit Genauigkeit +/- 1Hz zu messen, muss die Messzeit 1 s von Timer1 erzeugt werden, das nur für Quarz bis 2,048 MHz möglich ist. Für sehr genaue Messungen wird empfohlen als Taktfrequenz für den Timer1, die Trägerfrequenz eines nächsten LW Senders (z.B. DLF 153 bzw. 207 kHz) zu nutzen. Die Genauigkeit der Frequenz ist ca. 1E-11 und geprüfter Empfänger kann laut der Skizze in [[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=13706&highlight=frequenzz%E4hler]] nachgebaut werden. In dem Fall müssen die Register vom Timer1 (TMR1H und TMR1L) vor seinem Start entsprechend geladen werden.

Mit dem Quarz 7,3728 MHz wird hier die Messzeit 0,25 s genutzt und die gemessene Frequenz durch 4 multipliziert (mittels 2 Additionen), was die Auflösung von +/- 4 Hz ergibt.

Das UP "Init" muss selbstverständlich für ein Matrixdisplay um Initialisierung des Displaykontrollers ergänzt werden.

; Programm zum Messen der Frequenz an T0CKI Pin mit 7,3728 MHz Quarz
LIST P=16F870
include "P16F870.inc"
__CONFIG _CP_OFF & _DEBUG_OFF & _WRT_ENABLE_ON & _CPD_OFF & _LVP_OFF & _BODEN_OFF &
_PWRTE_ON & _WDT_OFF & _HS_OSC
ORG 0x0000
call Init
Main goto Main
ORG 0x0004 ;ISR (interrupt service routine)
bcf INTCON,GIE ;interrupts sperren
btfss INTCON,T0IF ;ist Timer0 übelaufen ?
goto CheckTMR1 ;nein, dann prüfe Timer1
bcf INTCON,T0IF ;Timer0 interrupt flag löschen
movlw 1
addwf A2,1 ;erhöhe A2
btfsc STATUS,C
incf A3,1 ;increment A3, wenn A2 überlaufen ist
CheckTMR1 btfss PIR1,TMR1IF ;ist Timer1 überlaufen ?
retfie ;wenn nicht, springe zurück zu Main
bsf STATUS,RP0 ;stopp Timer0
movf TRISA,0
andlw 0xEF
movwf TRISA ;TOCKI Pin (A4) als Ausgang
bcf STATUS,RP0
bcf T1CON,TMR1ON ;stopp Timer1
bcf PIR1,TMR1IF ;Timer1 interrupt flag löschen
GetFreq movf TMR0,0 ;Prescaler ins Register A0 kopieren
movwf A1
movwf RTmp
clrf ATmp
FToggle incf ATmp,1
bsf STATUS,RP0
bsf OPTION_REG,T0SE
bcf OPTION_REG,T0SE
bcf STATUS,RP0
movf TMR0,0
subwf RTmp,0
btfsc STATUS,Z
goto FToggle
comf ATmp,1
incf ATmp,0
movwf A0
call Hex_Dec
clrf A3 ;Register A löschen
clrf A2
clrf A1
clrf A0
call CopyDC
call AddDC ;gemessene Frequenz * 2
call CopyDC
call AddDC ;gemessene Frequenz * 4 = tatsächliche Frequenz
call DispFrq ;eigenes UP für benutztes Display
clrf TMR0 ;Timer0 löschen
movlw 0x34 ;Timer1
movwf T1CON ;konfigurieren
movlw 0x1F ;Timer1 laden (für 0,25 s)
movwf TMR1H
clrf TMR1L
bsf STATUS,RP0 ;start Timer0
movf TRISA,0
iorlw 0x10
movwf TRISA ;TOCKI Pin (A4)als Eingang
bcf STATUS,RP0
bsf T1CON,TMR1ON ;start Timer1
retfie ;erlaube interrupts und springe zurück zu Main
CopyDC movf D0,0
movwf C0
movf D1,0
movwf C1
movf D2,0
movwf C2
movf D3,0
movwf C3
return
Init clrf PORTA ;Ports löschen
clrf PORTB
clrf PORTC
movlw 0x20 ;RAM (20-7Fh) löschen
movwf FSR
clrf INDF
incf FSR,1
btfss FSR,7
goto $-3
clrf ADCON0 ;schalte ADC off
movlw 7 ;sperre ADC
movwf ADCON1 ;und definiere RA0-7 als digitale I/Os
movlw 0xE0 ;GIE, PEIE & TMR0IE erlauben
movwf INTCON
bsf STATUS,RP0 ;bank 1
clrf TRISA ;alle PORTA,
clrf TRISB ;alle PORTB,
clrf TRISC ;und alle PORTC Pins als Ausgänge
movlw 0xE7 ;Takt für Timer0 vom T0CKI Pin
movwf OPTION_REG ;Timer0 konfigurieren
bsf PIE1,TMR1IE ;TMR1 interrupt erlauben
bcf STATUS,RP0 ;Bank 0
clrf TMR0 ;Timer0 löschen
movlw 0x34 ;Timer1 konfigurieren
movwf T1CON ;(prescaler 8)
movlw 0x1F ;Timer1 laden (für 0,25 s)
movwf TMR1H
clrf TMR1L
bsf STATUS,RP0 ;start Timer0
iorlw 0x10
movwf TRISA ;TOCKI Pin (A4) als Eingang
bcf STATUS,RP0
bsf T1CON,TMR1ON ;start Timer1
return
end

=== Mausrad ===

Das UP wertet ein Mausrad aus und setzt, je nach Drehrichtug und sein Anschluss an PORT (PORTB,0 und PORTB,1), ein Flag "_Finc" bzw. "_Fdec", das vor der nächsten Abfrage, gelöscht werden muss. Diese Flags können z.B. für Inkrementierung und Dekrementierung von Zählern dienen.

Die Hardware:

Mausrad
.-------.
| o---> PORTB,0
+----o---- |
| | o---> PORTB,1
=== '-------'
GND

Es müssen die internen pull-ups vom PORTB aktiviert werden. Wenn das Mausrad an anderen PORT angeschlossen wird, werden externe pull-ups (z.B. 10 kOhm) benötigt. Als "_Z" wurde "STATUS,Z" definiert. Zum Auswerten werden 4 Register "MausA", "MausB", "MausC" und "Flags" gebraucht, die im gesamten Programm definiert werden müssen. Die Warteschleife "Delay" soll ca. 10ms sein.

In dem UP "Mouse" wird PORTB eigelesen, die alle Bits ausser 0 und 1 durch "and" Funktion gelöscht und in den Register "MausB" und "MausC" gespeichert. Nach ca. 10ms wird das gleiche gemacht und im Register "MausA" gespeichert. Der Wert aus "MausA" wird mit dem vorherigen aus "MouseC" durch "xor" verglichen. Sind sie nicht identisch, wird je nach dem Wert "X" (0, 1, 2, b.z.w. 3) im "MausB" in das entsprechende UP "MouseX" gesprungen. Sonst, wenn "MausA"="MausC", wird zum Aufrufer zurückgekehrt.

In einem UP "MouseX" wird der letzte Wert im "MausA" ermittelt und nach der Kombination der Werte im "MausB" und "MausA" (01 b.z.w. 02, 10 b.z.w. 13, 20 b.z.w. 23 oder 31 b.z.w. 32) entsprechendes der Drehrichtung Flag "_Finc" b.z.w. "_Fdec" gesetzt. Anschliessend wird zum Aufrufer zurückgesprungen.

Detailierter PAD:

Mouse V
PORTB->W
3 and W->W
W->MausB
W->MausC
Warten 10ms
PORTB->W
3 and W->W
W->MausA
W xor MausC->MausC
_Z=1 ? J > return
N
V
MausB->MausB
.--------------------------< J _Z=1 ?
| N
| V
| MausB->W
| 1-W->W
| .----< J _Z=1 ?
| | N
| | V
| | MausB->W
| | 2-W->W
| | _Z=1 ? J >---------------------------.
| | N |
| | V |
| | MausB->W |
| | 3-W->W |
| | _Z=1 ? J >-----. |
| | N | |
| | V | |
| | return | |
| | | |
| | | |
Mouse0 V Mouse1 V Mouse3 V Mouse2 V
MausA->W MausA->MausA MausA->W MausA->MausA
1-W->W V 1-W->W V
_Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--.
J | J | J | J |
V | V | V | V |
setze _Fdec | setze _Finc | setze _Finc | setze _Fdec |
V<-----´ V<-----´ V<-----´ V<-----´
MausA->W MausA->W MausA->W MausA->W
2-W->W 3-W->W 2-W->W 3-W->W
_Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--.
J | J | J | J |
V | V | V | V |
setze _Finc | setze _Fdec | setze _Fdec | setze _Finc |
V<-----´ V<-----´ V<-----´ V<-----´
return return return return

und Quellcode:

Mouse movf PORTB,0
andlw 3
movwf MausB
movwf MausC
call Delay ; ca. 10 ms
movf PORTB,0
andlw 3
movwf MausA
xorwf MausC,1
btfsc _Z
return
movf MausB,1
btfsc _Z
goto Mouse0
movf MausB,0
sublw 1
btfsc _Z
goto Mouse1
movf MausB,0
sublw 2
btfsc _Z
goto Mouse2
movf MausB,0
sublw 3
btfsc _Z
goto Mouse3
return
Mouse0 movf MausA,0
sublw 1
btfsc _Z
bsf _Fdec
movf MausA,0
sublw 2
btfsc _Z
bsf _Finc
return
Mouse1 movf MausA,1
btfsc _Z
bsf _Finc
movf MausA,0
sublw 3
btfsc _Z
bsf _Fdec
return
Mouse2 movf MausA,1
btfsc _Z
bsf _Fdec
movf MausA,0
sublw 3
btfsc _Z
bsf _Finc
return
Mouse3 movf MausA,1
sublw 1
btfsc _Z
bsf _Finc
movf MausA,0
sublw 2
btfsc _Z
bsf _Fdec
return

=== Handy Display ===

Als Beispiel die Hardware und Testprogram für Nokia 3310/3330 Display: [[http://www.roboternetz.de/phpBB2/viewtopic.php?p=124669#124669]]

= Hilfsmittel =

Hier werden einige Programme presentiert, die das ASM Programmieren erleichtern.
Damit sie möglichst wenig Data- und Programmspeicher benötigen, sind alle Zahlen auf dem Display in der hex Darstellung.
Für alle, die es in Dezimalsystem haben wollen, ist ein Taschenrechner mit hex<->dec Wandlung nötig.

== PIC Miniterminal ==

Das ist eine Schnittstelle, die nur 2 Leitungen zum Anschluss an PIC braucht. Sie ermöglicht das Steuern von diversen LCD Displays mit üblichem Anschluss ("RS", "Enable" und 8 Databits) und Abfragen von 3 Tasten.

Sie wird mit einem 2x16 Zeichen Matrixdisplay und 3 Tasten für weiter beschriebene Hilfsprogramme verwendet.

Hardware und Testprogramm: [[http://www.roboternetz.de/phpBB2/viewtopic.php?t=13685]]

[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Category:PIC]]

PIC Assembler

2007-05-05T07:00:14Z

Andy: /* Hex Dec Wandlung */

= Einladung zur Diskussion... =

Es wird hier versucht die ASM Programmierung von PIC Mikrocontrollern möglichst kurz zu beschreiben.

Damit der enstehende Artikel wirklich nützlich wird, ist Ihre Mitwirkung nötig. Bitte schreiben Sie uns Ihre Meinung, was eventuell noch geändert (z.B. ergänzt) werden soll in diesem Thread:

http://www.roboternetz.de/phpBB2/viewtopic.php?p=271211#271211

Die Autoren bedanken sich im voraus für jeden Beitrag mit Vorschlägen !

= Einführung =

== Bit, Byte, Nibble, Bin und Hex ==

Ein Mikrocontroller (kurz: µC) kann eigentlich nur durch ein Portpin eine Spannung einlesen bzw. ausgeben. Er kann aber nur erkennen, ob eine Spannung vorhanden ist oder nicht. Wenn fast keine Spannung vorhanden ist erkennt er das als 0 und wenn eine Spannung fast so gross, wie seine Versorgungsspannung anliegt, als 1.

Genauso bei der Ausgabe, wenn er 0 ausgibt ist auf dem Portpin fast keine Spannung, wenn 1, eine Spannung fast gleich gross seiner Versorgungsspannung. Und das ist ein Bit, die kleinste Menge einer Information. Das Bit ist binär, d.h. es kann nur zwei unterschiedliche Werte haben: 0 oder 1.

Wenn wir gleichzeitig (parallel) 8 Bits haben, dann ist es ein Byte, das 256 Bitkombinationen von 00000000b bis 11111111b enhält, weil ein Bit (X) auf jeder Stelle 0 bzw. 1 sein kann.

<table border=0 cellpadding=3 cellspacing=2>

<tr>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
</tr>

<tr>
<td colspan=4 align=middle bgcolor=#007fff>High Nibble </td>
<td colspan=4 align=middle bgcolor=#ff8305>Low Nibble </td>
</tr>
<tr>
<td colspan=8 align=middle bgcolor=#810f40> Byte </td>
</tr>
</table>

Das "b" bedeutet, dass es sich um binäre (kurz: bin) Darstellung (auch Zahl genannt) handelt. Binäre Zahlen sind aber lang, weil jedes Bit eine Stelle benötigt.

Um die Schreibweise zu verkürzen, wurden hexadezimale (kurz: hex) Zahlen eingeführt. Zuerst wurde ein Byte auf zwei 4-Bit Halbbytes (Nibbles) verteilt und danach ein Nibble als Ziffer genommen. Weil 4 Bits 16 Kombinationen ergeben, haben die Ziffer 0 bis 9 aus dem Dezimalsystem (d) nicht ausgereicht und wurden um Buchstaben A bis F erweitert. Die hexadezimalen Zahlen haben ein "h" Zeichen am Ende. Für die Zahlen 0 bis 9 sind die (h) und
(d) Zeichen nicht nötig, da sie beide gleich den entsprechenden bin Zahlen sind.

Die Umwandlung zwischen bin, hex und dec Zahlen für ein Nibble zeigt folgende Tabelle:

0b = 0h = 0d 100b = 4h = 4d 1000b = 8h = 8d 1100b = Ch = 12d
1b = 1h = 1d 101b = 5h = 5d 1001b = 9h = 9d 1101b = Dh = 13d
10b = 2h = 2d 110b = 6h = 6d 1010b = Ah = 10d 1110b = Eh = 14d
11b = 3h = 3d 111b = 7h = 7d 1011b = Bh = 11d 1111b = Fh = 15d

Damit kann ein Byte mit zwei hex Ziffern definiert werden z.B. 1100 0011b = C3h. Für zwei Bytes braucht man 4 hex Ziffern z.B.

101 0111 1010 1001b = 57A9h, u.s.w. Für MPASM wird sehr oft die Schreibweise für hex Zahlen 0x57A9 oder 0xC3 benutzt.

So wie im Dezimalsystem werden führende Nullen nicht geschrieben. Bei einer Wandlung bin->hex fängt man immer von der rechten Seite der bin Zahl an, da die Anzahl führender Nullen unbekannt ist.

== Speicher und Register ==

Als Speicher bezeichnet man das Teil der Hardware, in das eine Information geschrieben, gespeichert und von dort wieder ausgelesen werden kann.

Es gibt eigentlich nur zwei Arten von elektronischen Speichern: flüchtige und nichtflüchtige. Die Information die sich im flüchtigen Speicher befindet, geht verloren, wenn die Versorgungsspannung des Speichers unterbrochen oder abgeschaltet wird. Bei PICs ist es Datenspeicher (RAM).

Wenn die Versorgungsspannung vom nichtflüchtigen Speicher abgeschaltet wird, ist die gespeicherte Information zwar momentan nicht lesbar, bleibt aber erhalten und sobald der Speicher wieder mit Spannung versorgt wird, kann sie ausgelesen werden. Ein PIC hat zwei solche Speicher: Programmspeicher (Flash) und EEPROM.

Der wichtigste Unterschied zwischen den Speicherarten ist, dass die flüchtigen direkt (sehr schnell) beschreibbar sind, dagegen das Beschreiben des nichtflüchtigen Speichers spezielle Algorithmen benötigt, die im Vergleich zu direkten Zugriffen langsamer sind. Beim Auslesen gibt es praktisch keinen Unterschied.

Speicher besitzen eine bestimmte Menge von s.g. Speicherstellen. Jede Speicherstelle hat eine individuelle Adresse und kann eine binäre Information mit bestimmter Anzahl von Bits abspeichern.

PIC Prozessoren haben drei Arten von Speicher, wegen verschiedener Anwendung, auch unterschiedliche Struktur. Die beiden Speicher für Daten (RAM und EEPROM) haben jeweils 8 Bit Breite und Programmspeicher (Flasch) bei Mid-Range hat 14-bitige Speicherstellen. Die Anzahl den Speicherstellen im bestimmten Speicher ist vom PIC-Typ abhängig.

Eine 8-bitige Speicherstelle im RAM wird bei PICs Register genannt und kann so skizziert werden:

<table border=0 cellpadding=3 cellspacing=2>

<tr>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
</tr>

<tr>
<td> MSB </td>
<td colspan=6></td>
<td> LSB </td>
</tr>

<tr>
<td bgcolor="#007fff">bit 7</td>
<td bgcolor="#007fff">bit 6</td>
<td bgcolor="#007fff">bit 5</td>
<td bgcolor="#007fff">bit 4</td>
<td bgcolor="#007fff">bit 3</td>
<td bgcolor="#007fff">bit 2</td>
<td bgcolor="#007fff">bit 1</td>
<td bgcolor="#007fff">bit 0</td>
</tr>

<tr>
<td colspan=4 align=middle bgcolor=#ff8305>High Nibble </td>
<td colspan=4 align=middle bgcolor=#ff8305>Low Nibble </td>
</tr>
<tr>
<td colspan=8 align=middle bgcolor=#810f40> Byte </td>
</tr>
</table>

Bit 7 wird als hochwertigstes (MSB = Most Significant Bit) und bit 0 als niederwertigstes (LSB = Least Significant Bit) bezeichnet. Jedes Bit im Register (X) kann gleich 0 bzw. 1 sein. In einem Register existieren immer 8 Bits also auch führende Nullen. Zum Beispiel die hex Zahl 3 sieht im PIC Register so aus: 00000011.

Um ein Datenbyte in ein Register zu schreiben oder aus einem Register zu lesen, muss zuerst das Register durch seine Adresse gewählt werden. Dafür gibt es beim PIC folgende Möglichkeiten:

Direkte Adressierung per absolute Adresse: movwf 0x20

Direkte Adressierung per vorher definiertem Namen des Registers (z.B. Temp equ 0x20): movwf Temp

Indirekte Adressierung durch "FSR" Register, in das die absolute Adresse des Registers "Temp" eingeschrieben wird. Durch Zugriff mittels "INDF" Register wird auf die Speicherstelle zugegriffen, die durch das Register "FSR" adressiert wird. (INDF ist dabei kein real in Hardware implementiertes Register.) Wie vorher wurde "Temp equ 0x20" definiert und weiter:

movlw Temp ;ins W-Register wird die absolute Adresse des Registers "Temp" geladen
movwf FSR ;diese Adresse wird ins "FSR" Register kopiert
movf INDF,0 ;der Wert aus dem indirekt adressierten Register "Temp"
;wird ins W-Register geladen.

Weil in jedem 14-bittigen Befehl, der mit Datenspeicher verbunden ist, für die Adresse des ansprechenden Registers nur 7 Bits existieren, die bis zur Adresse 7Fh (128d) Register direkt ansprechen können, ist bei PICs der Datenspeicher (RAM) in s.g. Bänke verteilt.

Für Auswahl einer Bank sind zwei Bits "RP0" und "RP1" im "STATUS" Register zuständig. Die Anzahl der Bänke und ihre Verwendung ist von der gesamten Größe des RAMs abhängig und kann dem Datenblatt des PICs entnommen werden. Siehe: [[#Speicherbankorganisation|Speicherbankorganisation]]

== Prozessor ==

Der Prozessor von Mid-Range PICs gehört zu den RISC (Reduced Instruction Set Computer) Prozessoren und man hat nur 35 Befehle zu erlernen, was seine Programmierung im Vergleich zu anderen µCs deutlich vereinfacht. Jeder Befehl benötigt im Programmspeicher nur eine Speicherstelle und im Quellcode nur eine Zeile. Die Ausführung des Befehls dauert, abhängig vom Befehl, 1 bis 2 Prozessortakte.

Die Prozessoren der Mid-Range Serie von Microchip sind alle in der "Harvard"-Architektur gefertigt. Das bedeutet, dass Datenspeicher und Programmspeicher einen eigenen Bus zur CPU (Central Processing Unit) besitzen. Der Vorteil zur "von Neumann"-Architektur ist, dass sich die Busgrößen damit unterscheiden können. Das ermöglicht eine größere Bandbreite.

Der Befehl (beim PIC 14 bit) kann in nur einem Takt verarbeitet werden. Daher kommt auch das Aufteilen der Ausführung des Befehls in 4 verschiedene Vorgänge. Wärend der neue Befehl eingelesen ("fetch") wird, wird der vorige gerade gelesen ("read") und der vorvorige verarbeitet ("execute") und der vorvorvorige schreibt gerade in den Datenspeicher ("write"). Das heißt, 4 Befehle werden jeweils um einen Oszillatortaktzyklus verschoben gleichzeitig verarbeitet.

Das geschieht in vier Perioden des Oszillators. Deswegen entspricht die Taktfrequenz der CPU der durch 4 geteilten Frequenz des Oszillators.

CPU Vorgang Richtung Speicher
------------------------------------------------- -
1.Befehl lesen (fatch) <------- Flash |
2.Daten lesen (read) <------- RAM | 1 Prozessortakt =
3.Daten verarbeiten (execute) | 4 Oszillatortakte
4.Daten schreiben (write) -------> RAM |
-

Nur o.g. CPU Vorgänge sind direkt möglich. Es können deswegen keine Befehle aus dem RAM oder EEPROM ausgeführt werden. Um ein Databyte aus einem RAM Register in ein anderes zu kopieren, muss er zuerst aus dem ersten RAM Register in das W-Register (eigenen s.g. Arbeitsregister des CPU) und erst davon in das zweite RAM Register kopiert werden.

Der Prozessor hat kleinen eigenen Speicher, der weder zum Programmspeicher noch zum Datenspeicher gehört. Er besteht aus dem Programmzähler PC (programm counter) und dem Stapel (stack).

In dem PC befindet sich die 13-Bittige Adresse des momentan ausfürbaren Befehls. Nach der Ausführung jedes Befehls wird der PC um 1 erhöht und "zeigt" somit auf den nächsten Befehl im Programmspeicher, der zum Ausführen wäre. Wenn der nächste Befehl aber ein Sprung ("call") ist, wird die Adresse aus dem Befehl genommen. Nach dem Sprung wird das Programm bis zum Befehl "return" ausgeführt und danach muss der Prozessor zurückspringen, und zwar, genau zur nächsten Adresse im Programmspeicher nach dem "call" Befehl. Damit es möglich wäre, wird vor dem Sprung die Adresse aus dem PC "auf dem Stapel gelegt" (gespeichert). Für den Rücksprung wird die abgelegte Adresse "aus dem Stapel genommen" (vom Stapel in den PC geladen).

Der Stapel kann aber nur 8 Adressen speichern, deswegen dürfen nur 8 nacheinander folgende "call" Befehle benutzt werden. Sonst findet der Prozessor nicht mehr zurück und in die "Nirvana" springt, was einen Absturz des Programms bedeutet.

Das Lesen/Schreiben aus/in den EEPROM Speicher ist mit Hilfe speziellen Register und Unterprogrammen bei allen Mid-Range PICs möglich. Der Lese und Schreibzugriff auf den Programmspeicher ist aber nur bei wenigen PIC-Typen (z.B. PIC16F87X) möglich. Dies ermöglicht ein "sich selbst Programmieren", was bei Bootloadern genutzt wird.

== Assembler ==

Die Maschinensprache, auch Assembler oder kurz ASM genannt, ist eine Sprache die nur eine bestimmte CPU versteht. Für einen Menschen ist sie unverständlich, da sie nur aus 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 einen CPU hat somit ein "Namen", der aus der englischen Sprache stammt. Siehe: [[#Kurzübersicht Assembler Befehle|Kurzübersicht Assembler Befehle]]

Obwohl sie 200 bis 1000 mal schneller als die meisten Hochsprachen ist, wird sie, wegen des grossen Aufwands bei der Erstellung von umfangreichen Programmen, selten benutzt. Man findet sie aber oft in fast allen Hochsprachen, in eigebundenen Funktionen, überall dort wo die Hochsprachen zu langsam sind oder die nötigen Aufgaben nicht unterstützen (z.B. Maus in Q-Basic).

ASM eignet sich sehr gut für kleine Anwendungen (meistens Steuerungen) mit µC, weil nur bei dieser Programmiersprache ein direkter Zusammenhang zwischen einem Bit im Programm und einer Spannung am I/O Pin besteht.

Dank der integrierten oder an Portpins angeschlosenen Hardware und dem entsprechenden Program kann ein µC umfangreiche Aufgaben realisieren, die fast unbegrenzt und schwer vorstellbar sind.

Die Aufgabe eines ASM-Programmierers ist, ein Programm zu schreiben, das das Assemblerprogramm (z.B. MPASM) fehlerfrei in die Machinensprache assembliert ("übersetzt"), die dann eine bestimmte CPU "versteht". Sie endet eigentlich erst dann, wenn das geschriebene Programm so wie geplant funktioniert.

Die beste Methode um ASM Programmierung zu lernen ist einfach mit den Befehlen, wie mit "LEGO" Bausteinen, zu spielen. Der PIC kann durch ein Programmfehler nicht kaputtgehen. Vorsicht ist nur bei der angeschlossener Hardware nötig, da ein Fehler den PIC oder die Hardware sogar "töten" kann.

Weil ASM Programme nicht besonders durchschaubar sind, wurde als Hilfsmittel ein Programmablaufdiagramm (kurz: PAD) erfunden. Bei der 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 [http://gputils.sourceforge.net/ GPASM]) von dem für Menschen noch verständlichen Code in die Maschinensprache assembliert 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 Homepage des Herstellers von PICs [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en019469&part=SW007002] runtergeladen werden. Es muss zuerst vom Downloads die "MPLAB IDE v7.50 Full Zipped Installation" runtergeladen und erst danach können gewählte Programme (z.B. nur MPASM) intalliert werden. Für MPASM benutzer werden auch folgende ".pdf" Dateien empfohlen:

MPASM/MPLINK User's Guide (2628 KB) [Benutzerhandbuch]

MPASM™/MPLINK™ PICmicro® Quick Chart (81 KB) [Kurzübersicht]

Nach dem Eischalten der Betriebsspannung des µC, fängt der CPU an, sich im Programmspeicher befindliches Programm mit dem Befehl, der an der Adresse 0 steht, auszuführen.

Aber wann das Programm endet? Natürlich wenn die Versorgungsspannung abgeschaltet wird. Nein! Das ist die einfachste Lösung um ein laufendes Programm an zufälliger Stelle zu unterbrechen,
aber keine, um es an einer definierten Stelle zu beenden.

Wenn an den µC angeschlossene externe Hardware (z.B. Grafikdisplay), eine bestimmte Befehlsfolge vor dem Abschalten benötigt oder wichtige Daten (in EEPROM oder Flash) abgespeichert werden sollen, darf die Spannung erst dann abgeschaltet werden, wenn die CPU eine Meldung ausgibt, dass sie sich schon auf der "STOP" Stelle des Programms befindet. Es muss auch
definiert werden (z.B. durch eine Tastenkombination), wann die CPU zum letzten Fragment des ASM Programms vor dem "STOP" gehen soll.

== Grundbeschaltung ==

Der Prozessor von einem PIC kann sofort nach dem Einschalten der Versorgungsspannung (z.B. + 5V DC) arbeiten. Allerdings nur, wenn er den Takt, in dem er die Befehle ausführen soll, vorgegeben hat. Manche PICs besitzen einen internen RC-Oszillator, (z.B. PIC12F629, PIC16F630, PIC16F628, u.s.w.). Bei diesen reicht es bereits Spannung anzulegen und sie laufen bereits.
Die meisten haben ihn aber nicht (z.B. PIC16F84, PIC16F870, u.s.w.) und brauchen fürs Funktionieren zusätzliche Bauteile. Grundsätzlich gibt es mehrere Möglichkeiten:

* Quarz oder Keramik-Resonator + 2 Kondensatoren (LP,HS oder XT)
* Keramik-Resonator mit integrierten Kondensatoren (HS oder XT)
* Quarzoszillator (EC); genau und stabil
* Widerstand + Kondensator (RC); keine hohe Frequenzstabilität

Die entsprechenden Bauteile werden an die Pins OSC1/OSC2 angeschlossen, um den notwendigen Prozessortakt zu erzeugen. Im Konfiguration-Word "__config" muss noch angegeben werden, welcher Oszillator verwendet wird.

Desweiteren existiert ein MCLR-Pin, der beim PIC einen Neustart (=Reset) auslösen kann (Low-Pegel). Diesen Pin sollte man, wenn er in "__config" aktiviert ist, über einen Widerstand (pull-up) an Versorgungsspannung legen, damit der PIC anfängt, sein Programm abzuarbeiten. Der Anschluss wird auch für die Programmierung benötigt. Beim sog. High-Voltage-Programming wird MCLR auf ca. 12-14 Volt gelegt, um den PIC in den Programmiermodus zu schalten. Bei manchen PICs kann dieser Anschluss auch als normalen I/O Pin eingestellt werden. In dem Fall, bei ICSP Benutzung, soll noch eine Diode zwischen den pull-up und Versorgungsspannung angeschlossen werden, um die an MCLR Pin angeschlossene Hardware während der Programmierung zu schützen.

Bei externen Oszillatoren bleibt der Pin OSC2 nicht angeschlossen und kann als I/O benutzt werden. Falls ein interner Oszillator benutzt wird, können beide OSC Pins als I/O dienen.

Damit ein Programm zuverlässig ausgeführt werden kann, muss die Versorgungspannung störungsfrei sein. Dafür wird ein Keramik-Vielschicht-Kondensator 100 nF möglichts am kürzesten direkt zwischen VDD und VSS Pins geschaltet.

Folgende Skizzen zeigen die Grundbeschaltung eines PICs:

{|
|-
|
[[Bild:Pic-entstoer.png|thumb|160px|Entstörkondensator beim PIC]]
|
[[Bild:Qz-os.png|thumb|160px|Quarz ]]
|
[[Bild:Qos-os.png|thumb|160px|externer Quarzoszillator]]
|
[[Bild:Rc-os.png|thumb|160px|externer RC-Oszillator]]
|}

== Konfiguration ==

Die Konfiguration eines PICs wird beim "brennen" fest programmiert. Sie ist eigentlich für fast jeden PIC-Typ anders. Um Probleme zu vermeinden, muss sie für bestimmten PIC aus einer im MPASM Verzeichnis enthaltenen Datei "PXXFXX.INC" entnommen werden. Die Erklärung der Optionen befindet sich im entsprechenden Datenblatt unter "Special Features of the CPU"

Als Beispiel für PIC16F84 haben wir in der Datei "P16F84.INC":

;==========================================================================
;
; Configuration Bits
;
;==========================================================================

_CP_ON EQU H'000F'
_CP_OFF EQU H'3FFF'
_PWRTE_ON EQU H'3FF7'
_PWRTE_OFF EQU H'3FFF'
_WDT_ON EQU H'3FFF'
_WDT_OFF EQU H'3FFB'
_LP_OSC EQU H'3FFC'
_XT_OSC EQU H'3FFD'
_HS_OSC EQU H'3FFE'
_RC_OSC EQU H'3FFF'

Wobei:

_CP_ON - Programmspeicher ist vorm Auslesen geschützt
_CP_OFF - Programmspeicher kann ausgelesen werden (ist nicht geschützt)
_PWRTE_ON - Das Programm wird mit Verzögerung von ca. 72 ms nach dem Einschalten gestartet
_PWRTE_OFF - Das Program wird sofort nach dem Einschalten gestartet
_WDT_ON - Watchdog Timer ist aktiv
_WDT_OFF - Watchdog Timer ist unaktiv

Die alle folgende Optionen beziehen sich an den Oszillatortyp:

_LP_OSC - Oszillator bis ca. 200 kHz (z.B. Uhrenquarz 32768 Hz)
_XT_OSC - Oszillator bis ca. 3,5 MHz
_HS_OSC - Oszillator über 3,5 MHz (z.B. 4 MHz)
_RC_OSC - Externer RC Oszillator

Die Konfiguration wird im Quellcode (*.asm Datei) mit Direktive "__config" definiert, z.B. so:

__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _XT_OSC

Alle Optionen müssen groß geschrieben sein, genauso wie in der "*.inc" Datei.

== Wahl des PICs ==

Es gibt PIC µC die in der Typenbezeichnung den Buchstaben "C" oder "F" haben.

Die älteren mit "C" haben EPROM Programmspeicher und die gibt es in zwei Versionen: ohne und mit Fenster (aus Quarz-Glass) fürs Löschen des EPROMs mit UV Strahlung. Bei denen ohne Fenster kann der Programmspeicher nur einmal beschrieben und nicht mehr gelöscht werden.

Die neuen mit "F" besitzen einen Flash-Programmspeicher, der bis zu 100 000 mal mit angelegter Spannung gelöscht und danach neu beschrieben werden kann.

Für die Wahl eines PICs für bestimmte Anwendung wichtig sind:

- Max. Taktfrequenz des Prozessors.

- Grösse des Datenspeichers (für Variablen).

- Grösse des Programmspeichers (für Programm).

- Integrierte Hardware (Komparatoren, A/D Wandler, Timer, USART, I²C, SPI, PWM, u.s.w.).

- Freie I/O Pins für externe Hardware (Display, Tasten, u.s.w.).

- Vorhandene Betriebspannung (Netzteil, Akku, Batterie).

In der Praxis wird meistens für die Programmerstellung ein grösserer PIC genommen (wenn möglich pinkompatibler z.B. PIC16F628 für PIC16F84 oder PIC16F630 für PIC12F629) und erst nach der Optimierung des lauffägiges Programms, der tatsächlich nötige, da seine Parameter am Anfang nur geschätzt werden können. Wenn man viele Programme für verschiedene PICs entwickelt, wäre der größte PIC16F877 mit 20 MHz max. Taktfrequenz optimal.

Diese Lösung hat auch den Vorteil, dass während der Programmerstellung kurze Hilfsprogramme (z.B. PIC Trainer) in den Programmspeicher kopiert und benutzt werden können, da sie sowohl ein bischen Programmspeicher und RAM als auch 2 freie I/O Pins fürs PIC Miniterminal brauchen.

= Programm =

== Allgemeines ==

Jedes Program kann man in kleinere Fragmente unterteilen, die auf bestimmte Weise miteinander verknüpft sind und gemeinsam die Aufgabe des Programms erfüllen. Das wichtigste Teil eines Programms ist das s.g. Hautprogram (kurz:HP), das eine führende Rolle spielt. Dem HP sind fast 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 komplizierter, da ein UP auch ein oder mehrere UPs nacheinander aufrufen kann. Ganz unten sind die UP1s, die ganz einfache Sachen erledigen. Höher ist 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 ohne Tricks maximal bis zu 8 Ebenen benutzt werden, da auf dem Stapel (stack) nur max. 8 Rücksprungadressen abgespeichert werden können. Siehe hierzu: [[#Prozessor|Prozessor]] und [[#Programmspeicher|Programmspeicher]]

<center>
[[Bild:HP-UP.png|Hauptprogramm - Unterprogramm]]
</center>

Jedes UP kann jederzeit aufgerufen werden, je nach dem was gerade eledigt werden muss. Weil das nicht egal ist, welches UP aufgerufen wird, da jedes nur eine bestimmte Funktion im Programm hat, muss der Programmierer dafür sorgen, dass alles richtig nach Programablaufdiagramm, und nicht chaotisch, abläuft.

Die Programmierung in ASM ist ähnlich 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 Programm kopieren oder einbinden und ein geeignetes HP, das sie aufruft, schreiben.

Ein ASM Programm (Quellcode) muss in einer Texdatei mit der Endung ".asm" in der vom Assemblerprogramm erwarteten Form verfasst werden, um die fehlerfreie Konvertierung in die Maschinensprache (Assemblierung) zu gewährleisten. Dieser Prozess verläuft in der Form eines Dialoges.

Der Programmierer schreibt und gibt es dem Assemblerprogramm zum Übersetzen. Alles was der Assembler nicht versteht oder nicht richtig ist, erscheint als Fehlermeldungen, die der Programmierer kennen muss, um die Fehler korrigieren zu können. Eine ".hex" Datei wird erst dannn erstellt, wenn das Assemblerprogramm keine Fehler mehr im Quellcode findet. Deswegen ist es sehr wichtig, sich mit dem Assemblerprogramm vertraut zu machen, um die Dialogzeit zu minimieren.

== Programmdurchlaufdiagramm ==

Der Programdurchlaufdiagram (kurz: PAD) ist eine vorläufige und laufend änderbare Stufe zwischen einer Idee und ihrer Verwirklichung. Die Kreativität des Programmierers ist nur für die Erstellung des PADs nötig. Jedes sein Symbol (ausser "Start/Stop") muss als Befehlsreihenfolge für einen bestimmten Prozessor in den Quellcode übertragen werden. Das ist aber nur reine "Übersetzung". Der Quellcode ist nur eine andere Form des PADs und hoffentlich wird es zukünftig Komputerprogramme geben, die ein PAD direkt in eine "*.hex" Datei für bestimmten Prozessor wandeln werden. Zur Zeit muss die "Übersetzung" leider vom Programmierer gemacht werden. Der PAD wird erst dann fertig, wenn nach ihm erstelltes ASM Program auf einem µC so wie gewünscht funktioniert.

Die Anschriften "Ein" und "Aus" gehören nicht zu Symbolen des PADs und wurden nur zur Erklärung benutzt.

[[Bild:PAD_beispiel.png|thumb|80px|Beispiel für ein PAD]]

Der PAD ist sehr eifach zu erstellen, weil dafür nur drei Symbole benötigt sind:
<center>
[[Bild:PAD_kurz.png|Symbole des PAD]]
</center>
Das "Start/Stopp" Symbol bedeutet, dass das gesamte Programm sich im stabilen Zustand befindet und nicht "läuft". Anstatt "Stopp" kann auch "Schlaf" (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 eines Programms, endweder in der "ja" (J) oder "nein" (N) Richtung.

Als allgemeinnutziges Standard für µCs kann man folgender PAD bezeichnen:

PAD _____
/ \
Spannung ein (Ein) ----->( Start )
\_____/
| -
V |
.---------------. |
|Initialisierung| |
'---------------' |
| |
.--------->V |
| .---------------. |
| | Hauptprogramm | |
| '---------------' |
| | |
| V |
| A |
| / \ > Gesamtes Programm
| / \ |
| /Ende \____ |
| \ ? / J | |
| \ / | |
| \ / | |
| V | |
| N| | |
`----------´ | |
V |
.---------------. |
| Beenden | |
'---------------' |
| |
V -
_____
/ \
Spannung aus (Aus) <-------------( Stopp )
\_____/

Das Hauptprogram wird in einer endlosen Schleife ausgeführt, die durch die Prüfung "Ende?" unterbrochen werden kann. In dem Fall wird vor dem Beenden des gesammten Programms noch ein UP "Beenden" ausgeführt, das z.B. Daten im EEPROM speichert.

Es ist nicht nötig, immer die Symbole zu zeichnen, man kann sie sich vorstellen und nur den Text schreiben. Die Prüfungen werden mit "?" gekenzeichnet und die Zeichen "V", "A", "<" und ">" zeigen die Richtung des weiteren Verlaufs. Dann sieht der PAD so aus:

Ein > Start
V -
Initialisierung |
.------->V |
| Hauptprogramm > Gesamtes Programm
| V |
| Ende? J > Beenden |
| N V -
| V Stopp > Aus
`--------´

Man kann auch die unbedeutenden Richtungspfeilen weg lassen:

PAD1 Ein > Start _
Initialisierung |
.------->V | Gesamtes
| Hauptprogramm | Programm
| Ende? J > Beenden _|
| N Stopp
| V V
`--------´ Aus

In der Praxis werden aus Platzgründen meistens die vereinfachten PADs benutzt. Als "movxx" wird oft ein Zeichen "->" benutzt. Zum Beispiel "A->W" bedeutet, dass der Inhalt des A Registers ins W-Register geladen (kopiert) wird. Ausserdem werden Zeichen ("+", "-", "*", "/", "^", u.s.w.) für arithmetische und ("&", "or", "xor", u.s.w.) für logische Operationen angewendet. In den Quellcode werden für diese Zeichen entsprechende Befehle geschrieben. Beispiel:

V
10h->W
W+B->B
V

wird im Quelcode so aussehen:

...........
movlw 10h
addwf B,1
...........

Siehe auch: [[#Das erste...|Das erste...]] und [[#Mausrad|Mausrad]]

Der PAD1 kann aber für Hauptprogramme, die in beliebigem Moment unterbrochen werden dürfen, deutlich vereinfacht werden, da die Prüfung "Ende?" ob das Hauptprogram beendet werden soll, und das UP "Beenden", entfallen.

Die meisten ASM Programme für µC sind deswegen nach solchem PAD erstellt:

PAD2 Ein > Start _
Initialisierung |
.------->V |
| Hauptprogramm > Gesamtes Programm
| V |
`--------´ _|

Für Testprogramme wird meistens fogender PAD angewendet, weil es ziemlich einfach festzustellen
ist (z.B. durch Stromverbrauchmessung des µCs), wann sich die CPU schon im Schlaf befindet. Erst dann, darf die Betriebspannung des µCs ausgeschaltet werden.

PAD3 Ein > Start _
Initialisierung | Gesamtes
Hauptprogramm _| Programm
Schlaf > Aus

Und eine batteriebetriebene Uhr wird überwiegend so gestaltet:

PAD4 Ein > Start _
Interrupt Initialisierung |
Timer------------------------->V > Gesamtes Programm
Hauptprogramm _|
Schlaf

In dem Fall reicht es aus, wenn der CPU jede Minute vom Timer aufgeweckt wird, um die Zeit zu aktualisieren. Eine Uhr ist immer (ausser Batteriewechsel) ununterbrochen mit Spannung versorgt.

Für komplizierte Programme ist es praktisch unmöglich ein PAD zu erstellen, in dem jeder CPU Befehl sein eigenes Symbol hat. Man beschränkt sich nur auf alle Prüfungen, die über den Lauf des Programms entscheiden, und ganze UPs (z.B. "Initialisierung") nur als ein Symbol verwendet. Für jedes UP wird dann ein eigener PAD erstellt.

Das Erstellen von PAD bei ASM Programmen ist sehr wichtig und darf nicht unterschätzt werden. Je stärker ein Programmierer glaubt, dass er das ohne PAD schafft, um so mehr Zeit wird er danach bei Fehlersuche oder Änderungen im ASM Programm verlieren.

Beispiel aus dem Alltag:

"Das programm hat anfangs auf Anhieb funktioniert. Doch leider habe ich dann was geändert was ich nicht mehr weiß. Das Programm macht nun komische Sachen...... Ich kann mir nicht erklären warum, kann mir jemand helfen???"

Für einfache ASM Programme, die gut kommentiert sind, reicht es meistens aus, ein PAD nur "im Kopf" zu erstellen, aber ganz ohne PAD geht es sicher nicht.

Der PAD kann auch benutzt werden, um einen "fremden" Code verständlich zu machen. In dem Fall werden alle Befehle (Zeilen) aus der Quellcode nacheinander in PAD Symbole umgewandelt und daraus ein PAD erstellt.

== Hauptprogramm ==

Wie sein Namen schon vermuten lässt, ist das Hauptprogram das wichtigste Teil des gesamten Programms. Meistens ist es auch das kleinste Teil, vor allem, wenn die UPs sehr komplex sind. Seine Aufgabe ist die benötigte UPs in bestimmter Reihenfolge nacheinander aufzurufen, um die alle Funktionen des gesamten Programms zu realisieren.

Das HP ist meistens als endlose Schleife, wie im PAD2, aufgebaut. Weil die endlose Schleife sehr schnell läuft, werden alle durch die UPS realisierten Aufgaben quasi gleichzeitig ausgeführt. Wenn es unerwünscht ist, müssen einige UPs als Verzögerungen realisiert werden.

Typischer PAD für ein HP sieht so aus:

Haupt .--->V
| UP1
| UP2
| ...
| UPn
| V
`----´

In den Quellcode wird es so eigeschrieben:

Haupt call UP1
call UP2
...........
call UPn
goto Haupt

In der Praxis wird das HP schrittweise erstellt. Am Anfang wird sich nur ein Aufruf vom UP im HP befinden und die folgenden kommen nach Erstellung und Prüfen weiteren UPs dazu, bis das HP fertig wird.

== Unterprogramm ==

Unterprogramm wird durch übergeordnetes Programmteil (Aufrufer) aufgerufen und nach seinem Ausführen, wird zurück zum Aufrufer gesprungen. Der Rückkehr zum Aufrufer wird durch "return" Befehl, der sich am Ende jedes UPs befinden muss, erreicht. Und das ist der einzige Unterschied zwischen einem HP und einem UP.

Jedes UP hat folgender PAD:

vom Aufrufer ------------>V
Tun
V
zurück zum Aufrufer <----------return

Ein HP von einem ASM Programm kann in anderem, mehr umfangreichem ASM Program als UP benutzt werden, wenn der sich am Ende des HPs befindlicher Befehl "goto" durch "return" ersetzt wird. Ein Beispiel dazu:

Haupt1 call UP11 Haupt1 call UP11
call UP21 call UP21
........... -------> ...........
call UPn1 call UPn1
goto Haupt1 return

Jetzt können wir im mehr komplexen HP (Haupt) das Haupt1 als Unterprogramm aufrufen:

Haupt call UP1
call Haupt1
...........
call UPn
goto Haupt

Jedes UP kann auch von einem anderen übergeordneten UP aufgerufen werden, wenn das was es realisiert, benötigt wird.

In der Praxis wird oft ein UP von mehreren anderen UPs benutzt. Zum Beispiel um LCD Display zu steuern, brauchen wir entweder ein Befehl (Cmd) oder ein Zeichen (Data) an Display zu schicken. In beiden Fällen wird ein Byte geschickt, einmal mit RS=0 (Befehl) und einmal mit RS=1 (Zeichen) laut folgendem PAD:

"Cmd" "Data"
RS=0 RS=1
V V
`-->V<--´
"Send" Byte schicken
V
return

Das wird in den Quellcode z.B. so eingeschrieben:

Cmd bcf RS
goto Send
Data bsf RS
Send ............
return

Das UP "Send" ist den UPs "Cmd" und "Data" untergeordnet, da es von beiden benutzt wird, kann aber weder "Cmd" noch "Data" benutzen.

=== Initialisierung ===

Damit der PIC ein Programm asführen kann, muss er vollständig und richtig initialisiert werden. Deswegen als erstes UP, das von dem gesamten Programm noch vor dem HP aufgerufen wird , ist "Initialisierung" (kurz: Init)

==== Variablen ====

Weil sich nach dem Einschalten der Spannung im RAM zufällige Werte befinden, wird meistens als erstes der benutzte Bereich des RAMs (z.B. 20h bis 7Fh) gelöscht. Es wird einfach und sparsam mit einer Schleife erledigt, die indirekte Adressierung verwendet:

V
Adresse des ersten Registers in FSR laden (20h)
.-------------------->V
RAMClr |Indirekt adressierter Register löschen (INDF)
| Adresse erhöhen
| Letzte Adresse + 1 (80h) J > Return
| N
| V
`---------------------´

Es wird wie folgt in Quellcode eingeschrieben:

movlw 0x20
movwf FSR
RAMClr ,->clrf INDF
| incf FSR,1
| btfss FSR,7
`-<goto RAMClr
return

Um Anzahl den Marken (label) zu verringern, wird oft ein Symbol "$" benutzt. Es bedeutet die Adresse der aktuellen Befehlszeile. Es kann also auch so eingeschrieben werden:

movlw 0x20
movwf FSR
,->clrf INDF
| incf FSR,1
| btfss FSR,7
`-<goto $-3 ; springe zu aktueller Adresse -3
return

Danach können den benötigtenen Variablen die gewünschte Werte zugewiesen werden:

movlw 0x3C
movwf LimH
movlw 0x5A
movwf LimL
u.s.w.

Somit sind die Variablen initialisiert.

==== I/O Ports ====

Nach dem Einschalten der Spannung sind die für Komparatoren oder A/D Wandler benutzte Pins als analoge Eingänge initialisiert. Wenn sie alle als digitale I/Os verwendet werden sollen, müssen sie als solche definiert werden. Das geschieht durch Schreiben des Wertes 7 in das entsprechende Register (CMCON bzw. ADCON1):

movlw 7 b.z.w. movlw 7
movwf CMCON movwf ADCON1

Wenn einige als analoge Eingänge benutzt werden sollen, müssen die entsprechende Werte dem Datenblatt des jeweiligen PICs entnommen werden.

Danach werden alle Ports nacheinander gelöscht und die gewünschte Werte die an den Pins vor dem Start des Hauptprogramms ausgegeben werden sollen, geschrieben:

clrf PORTA
movlw 0x37
movwf PORTA
usw.

Anchliessend werden für jeden Port die Werte in TRIS Register eingeschrieben, wobei ein Bit einem Pin entspricht. Ein Pin wird in TRIS Register durch 1 als Eingang und durch 0 als Ausgang definiert. Beispielweise beim PORTB sollen B7,B5 und B3 als Eingänge und restliche Pins als Ausgänge definiert werden. Das ergibt den Wert 10101000b = A8h, der in den TRISB Register geschrieben werden muss. Weil die alle TRIS Register sich in der höheren Bank befinden, muss im STATUS-Register auf entsprechende Bank und danach zurück auf Bank 0 umgeschaltet werden. Zum Beispiel für die TRASB in der Bank1:

bsf STATUS,RP0
movlw 0xA8
movwf TRISB
bcf STATUS,RP0

Bei einem Umschalten der Bank können selbstverständlich alle TRIS Register, die in der gleichen Bank liegen, nacheinander beschrieben werden. Siehe : [[#PORTx|PORTx]] und [[#TRISx|TRISx]]

Bei dem PORTA gibt es Pins, die nur "open drain" Ausgang haben (können nur auf GND schalten) b.z.w. nur als Eingang benutzt werden können. Bei Plannung der Verwendung von PORTA muss immer im Datenblatt geprüft werden, ob sich ein bestimmter Pin für die geplannte Anwendung eignet.

==== Hardware ====

Die für ASM Programm benutzte Hardware kann auf integrierte und externe geteilt werden. Für eine Initialisierung der integrierten Hardware (Komparatoren, A/D Wandler, Timer, USART, I²C, SPI, PWM, u.s.w.), müssen entsprechende SFRs (Spezial Function Registers) laut Datenblatt des PICs definiert werden.

Die externe Hardware muss nach Datenblättern der Herstellern initialisiert werden.

=== Einlesen ===

Um ein Bit von einem Portpin einzulesen und in ein bestimmtes Register zu Kopieren wird folgender PAD benutzt, weil ein PIC kein Befehl dafür hat:

V
Bit im Zielregister löschen
Quellbit = 0 ? J >------.
N |
V |
Bit im Zielregister setzen |
V<-------------´

Wenn wir z.B. ein bit3 von PortA als bit1 in den Register Tasten kopieren wollen, dann wird es in Quellcode so geschrieben:

bcf Tasten,1
btfsc PORTA,3
bsf Tasten,1

Wenn ein ganzes Byte vom Port in das W-Register eingelesen wird, kann man den Wert gleich komplett in das Zielregister schreiben:

movf PORTA,0
movwf Tasten

=== Ausgeben ===

Um ein Bit an einem Portpin auszugeben wird ein bestimmtes Bit mit "bcf" gelöscht oder mit "bsf" gesetzt. Zum Beispiel bit4 im PORTA:

bcf PORTA,4.

Um ein Byte auszugeben wird es zuerst in das W-Register geladen und danach an den Port übergeben, z.B.:

movlw 0x12
movwf PORTA

=== Schleifen ===

Ein in ASM Programmen meist verbreitetes Codefragment ist eine Schleife.

Es kann eine endlose Schleife, die durch Prüfung einer bestimmten Bedingung (z.B. Taste) unterbrochen wird, sein:

V<-----.
Tun |
? N >--´
J
V
weiter

Es kann eine Schleife mit Schleifenzähler (z.B. Temp), die bestimmte Anzahl Durchläufe hat, sein:

V
Anzahl ins Temp laden
V<---------.
Tun |
Temp decrementieren |
Temp = 0 ? N >--´
J
V
weiter

Solche Schleifen können als UPs verwendet werden, wenn "weiter" mit "return" ersetzt wird.

Das waren Beispiele für Schleifen, die bewusst programmiert sind. Es gibt leider auch endlose Schleifen, die durch einen Fehler im Programm enstanden sind und zum "hängen" des Programms führen. Solche Schleifen sind im Programm nicht einfach zu finden, da ihre Parameter unbekannt sind.

=== Pause ===

Um eine Pause (Warten, Verzögerung) im Programm anzulegen wird der "nop" Befehl benutzt, während dessen Ausführung der CPU nichts macht. Mit einem "nop" kann eine Zeit gleich 4 Takten (Perioden) des Oszillators realisiert werden.

Für sehr kurze Wartezeiten benutzt man eine Reihe von nachfolgenden "nop"s. Beim einem Oszillator 4 MHz, die Ausführungszeit des Prozessors beträgt 1 µs pro "nop". Wenn z.B. 4 µs benötigt werden, werden dafür 4 "nop"s gebraucht:

...
nop
nop
nop
nop
...

Das gleiche bewirken 2 "goto"s, brauchen aber im Vergleich zu "nop"s nur die Hälfte der Bytes im Programmspeicher:

...
goto $+1
goto $+1
...

Der Befehl goto $+1 bedeutet "springe zur aktuellen Adresse + 1" (also nächster Adresse) und seine Ausführungszeit ist gleich 2 Prozessortakten.

Für kurze Zeiten werden s.g. Warteschleifen, wie im folgendem PAD benutzt:

V
n * nop
P0 laden
V<---------.
P0 decrementieren |
P0 = 0 ? N >--´
J
V

In Quellcode wird es als UP so eigeschrieben:

Warte nop Warte nop
... ...
nop nop
movlw 0xXX movlw 0xXX
movwf P0 movwf P0
Warte0 decfsz P0,1 decfsz P0,1
goto Warte0 goto $-1
return return

Der Sprung zur Marke "Warte0" ("goto Warte0") wurde in rechtem Beispiel durch "goto $-1" ersetzt.

Die gesammte Anzahl den CPU Takten (N) lässt sich aus folgender Formel berechnen:

N = 3 * P0 + 6 + n

und die Wartezeit (T) in Sekunden:

T = N * ( 4 / Fosc ), für Schätzungen T ~ 3 * P0 * ( 4 / Fosc )

Wobei:

P0 = Zahl im Register P0, 6 = Ausführungszeit von "call" (2) + "movlw" (1) + "movwf" (1) + "return" (2), n = Anzahl "nop"s, Fosc = Frequenz des Oszillators (z.B. Quartz)

Wenn in ein Register PX eine 0 eingeschrieben wird, bedeutet es, dass die decrementierung des Registers 100h = 256d Takten dauern wird, da dekrementierte 0 eine FFh = 255d ergibt. Deshalb in Warteschleifen ist die Zahl 0 die grösste (256 Dürchläufe) und 1 die kleinste. Für solche einfache Schleifen (als UP) die Wartezeit beträgt min. 9 und max. ca. 800 Prozessortakten (ohne "nop"s).

Für mittlere Wartezeiten z.B. 0,1 Sekunde werden doppelte Warteschleifen verwendet:

Warte V
n * nop
P1 laden
Warte1 V<-------------.
P0 laden |
Warte0 V<---------. |
P0 decrementieren | |
P0 = 0 ? N >--´ |
J |
V |
P1 dekrementieren |
P1 = 0 ? N >------´
J
V

Das wird in Quellcode als UP so aussehen:

Warte nop Warte nop
... ...
nop nop
movlw 0xXX movlw 0xXX
movwf P1 movwf P1
Warte1 movlw 0xXX movlw 0xXX
movwf P0 movwf P0
Warte0 decfsz P0,1 decfsz P0,1
goto Warte0 goto $-1
decfsz P1,1 decfsz P1,1
goto Warte1 goto $-5
return return

Wie vorher wurden rechts die Marken durch "$-n" ersetzt.

Die gesammte Anzahl den CPU Takten (N) lässt sich aus folgender Formel berechnen:

N = P1 * (3 * P0 + 5) + 8 + n

und die Wartezeit (T) in Sekunden:

T = N * ( 4 / Fosc ), für Schätzungen T ~ 3 * P1 * P0 * ( 4 / Fosc )

Wobei:

P0 = Zahl im Register P0, P1 = Zahl im Register P1, 8 = Ausführungszeit von "call" + "return" + 2 * ("movlw" + "movwf"), n = Anzahl "nop"s, Fosc = Frequenz des Oszillators (z.B. Quartz)

Für solche doppelte Schleifen (als UP) die Wartezeit beträgt min. 16 und max. ca. 200 000 Prozessortakten (ohne "nop"s).

Für lange Wartezeiten z.B. 1 Sekunde werden 3-fache Warteschleifen angewendet.

Solche Warteschleife ist im folgenden PAD abgebildet:

Warte V
n * nop
P2 laden
Warte2 V<-----------------.
P1 laden |
Warte1 V<-------------. |
P0 laden | |
Warte0 V<---------. | |
P0 decrementieren | | |
P0 = 0 ? N >--´ | |
J | |
V | |
P1 decrementieren | |
P1 = 0 ? N >------´ |
J |
V |
P2 dekrementieren |
P2 = 0 ? N >----------´
J
V

Das wird in Quellcode als UP so aussehen:

Warte nop Warte nop
... ...
nop nop
movlw 0xXX movlw 0xXX
movwf P2 movwf P2
Warte2 movlw 0xXX movlw 0xXX
movwf P1 movwf P1
Warte1 movlw 0xXX movlw 0xXX
movwf P0 movwf P0
Warte0 decfsz P0,1 decfsz P0,1
goto Warte0 goto $-1
decfsz P1,1 decfsz P1,1
goto Warte1 goto $-5
decfsz P2,1 decfsz P2,1
goto Warte2 goto $-9
return return

Auch hier wurden rechts die Marken durch "$-n" ersetzt.

Die gesammte Anzahl den CPU Takten (N) lässt sich aus folgender Formel berechnen:

N = P2 * [ P1 * (3 * P0 + 5) + 9 ] + 10 + n

und die Wartezeit (T) in Sekunden:

T = N * ( 4 / Fosc ), für Schätzungen T ~ 3 * P2 * P1 * P0 * ( 4 / Fosc )

Wobei:

P0 = Zahl im Register P0, P1 = Zahl im Register P1, P2 = Zahl im Register P2, 10 = Ausführungszeit von "call" + "return" + 3 * ("movlw" + "movwf"), n = Anzahl "nop"s, Fosc = Frequenz des Oszillators (z.B. Quartz)

Für solche 3-fache Schleifen (als UP) die Wartezeit beträgt min. 27 und max. ca. 50 000 000 Prozessortakten (ohne "nop"s).

Die "nop"s vor allen Warteschleifen sind nur notwendig um genaue Wartezeit einzustellen zu können. Sie können auch mit "goto $+1"s ersetzt, oder weg gelassen werden. Sie können auch innerhalb jeder Schleife eingesetzt werden, um sie deutlich zu verlängern.

Ein Beispiel:

V
n * nop
P0 laden
V<---------.
n0 * nop
P0 decrementieren |
P0 = 0 ? N >--´
J
V

Bei nur einem "nop" (n0=1) ist die max. Wartezeit ca. T ~ 4 * P0 * ( 4 / Fosc ), bei zwei (n0=2) ca. T ~ 5 * P0 * ( 4 / Fosc ) u.s.w.

Anstatt "movlw 0xXX" kann auch "movf PauseX,0" angewendet werden, wenn die Schleife mehrmals mit verschiedenen Werten P0, P1 und P2 aus den Register Pause0, Pause1 und Pause2 benutzt wird.

Für sehr lange Wartezeiten können, nach gleichem Prinzip, Warteschleifen erstellt werden, die mehr als 3 Schleifen enthalten.

=== Tabellen ===

Es gibt zwei Arten von Tabellen: Sprungtabellen (computed goto) die "goto" Befehle enthalten und Wertetabellen (lookup table) in denen feste Werte in "retlw" gespeichert sind. Der wichtigste Unterschied zwischen dennen ist, dass die Sprungtabellen steuern den Programlauf abhängig vom Inhalt des W-Registers und die Wertetabellen liefern abhängig von Inhalt des W-Registers ein Wert an den Aufrufer zurück.

Beide werden in Programmspeicher erstellt. Sie können nur bis zu 256 Speicherstellen belegen, da in den W-Register auch nur so viel veschiedenen Zahlen "passen". Sie Fangen also (fast) immer bei einer Adresse XX00h an und enden bei XXFFh. Der Hochwertige Byte "XX" der Adresse an der sich der Anfang einer Tabelle befindet, muss vor dem Einsprung in die Tabelle ins PCLATH Register eingeschrieben werden, wenn die Tabelle weit vom Aufrufer liegt. In der Praxis werden solche Tabellen am oberen Ende des Programmspeichers angelegt, damit sie den ASM Code nicht unterbrechen.

Eine Sprungtabelle wird so aufgebaut:

org (XX-1)FF <--- eine Direktive für Assemblerprogramm, wo es
die Tabelle im Programmspeicher plazieren soll
Adresse Inhalt
-------------------------
Tab1 (XX-1)FF addwf PCL,1
XX00 goto Marke0
XX01 goto Marke1
.......................
XXFE goto Marke254
XXFF goto Marke255

Und so aufgerufen:

movlw 0xXX
movwf PCLATH
movf TWert,0
call Tab1

Wobei:

0xXX = Hochwertiger Byte der Adresse von Tab1, TWert = ein Wert, der die Wahl wohin gesprungen wird bestimmt.

Nach ausführen der obiger Befehlsfolge, wird das ASM Programm z.B. für Twert=0x01 weiter ab Marke1 "laufen" bis es an "return" kommt. Dann springt es zurüch zum Aufrufer der Tabelle.

Eine Wertetabelle wird so aufgebaut:

org (XX-1)FF <--- eine Direktive für Assemblerprogramm, wo es
die Tabelle im Programmspeicher plazieren soll
Adresse Inhalt
-------------------------
Tab1 (XX-1)FF addwf PCL,1
XX00 retlw Wert0
XX01 retlw Wert1
.......................
XXFE retlw Wert254
XXFF retlw Wert255

Und so aufgerufen:

movlw 0xXX
movwf PCLATH
movf TWert,0
call Tab1

wobei:

0xXX = Hochwertiger Byte der Adresse von Tab1, TWert = ein Wert, für welchen, an den Aufrufer bestimmter Wert aus der Tabelle im W-Register zurückgeliefert wird

Wertetabelle kann auch mit Hilfe der MPASM Direktive "dt" erstellt werden. So kann man sich mehrfaches Schreiben von "retlw" Befehlen ersparen:

org 0x(XX-1)FF
Tabelle addwf PCL,1
; nachfolgend der benötigte Wert im W- Register
; vor dem Aufruf der Tabelle
dt 0x03, 0xE8 ; 0x00
dt 0x03, 0xE8 ; 0x02
dt 'M','H','z',0x00 ; 0x04
dt ' ',' ','W','A','I','T',0x00 ; 0x08
dt 'C','o','n','s','t',' ','X',0x00 ; 0x0F
dt 'C','=',0x00 ; 0x17
dt 'L','=',0x00 ; 0x1A
dt 'F','=',0x00 ; 0x1D
dt 'O','K',0x00 ; 0x20
u.s.w.

Das Lesen eines Strings muss ab entsprechendem Wert im W-Register (z.B. für "MHz" -> 0x04) anfangen und auf dem Wert 0x00 enden, der hier als Stringende dient. Einfacher ist, wenn alle Strings gleich lang sind (wie z.B. in einem Zeichengenerator fur Grafikdisplay).

=== Interrupt ===

==== Prinzip ====

Ein Interrupt (Unterbrechung) unterbricht ein laufendes Programms, wenn ein bestimmtes Ereigniss, auf das reagiert werden soll, statt gefunden hat. Die Reaktion wird in s.g. Interrupt Service Routine (kurz: ISR) definiert.

Einfach gesagt, ein Interrupt stoppt ein laufendes Programm, ruft die ISR auf und nach deren Ausführung startet das Programm wieder, ab der Zeile, vor der es durch Interrupt angehalten wurde.

.--->V
| Tun
| V
Interrupt ------>Tun-------->V
| V ISR
| Tun<--------´
| V
| Tun
| V
`----´

Damit das unterbrochene Programm nach dem Rückkehr aus der ISR weiter fehlerfrei ausgeführt werden kann, darf die ISR keine Änderungen im Programm verursachen.

Um ein Interrupt auslösen zu können, muss er in UP "Init", durch beschreiben nötigen Register (INTCON, PIR, u.s.w.) vorbereitet werden. Siehe hierzu: [[#INTCON|INTCON]] und [[#Interrupts|Interrupts]]

==== Quellen ====

Es gibt folgende Interrupt-Quellen:

- interne Hardware (z.B. ein Timer)

- externe Hardware (z.B. eine Taste)

Die alle PICs der Mid-Range Familie haben im Programmspeicher nur eine Adresse (s.g. Interrupt Vektor 0x0004), wohin im Falle eines Interrupts, gesprungen wird. Um ermöglichen den Verursacher des Interrupts zu finden, hat jede Quelle ein eigenes Interrupt Flag (IF), das gesetzt wird, wenn das Interrupt ausgelöst wird. Somit kann in der ISR nach der Prüfung der IFs auf jeden Interrupt gezielt reagiert werden.

==== Interrupt Service Routine ====

Die Interrupt Service Routine ist ein besonderes UP das immer an der Adresse 0x0004 beginnt und immer mit dem Befehl "retfie" endet. Ihr Umfang ist von der Menge der Quellen und der Reaktionen auf ihre Interrupts abhängig. Folgender PAD zeigt ein allgemeiner Aufbau der ISR:

Adresse 0x0004 Interrupts sperren ; bcf INTCON,GIE
Beeinflüsste Register sichern
Interrupt-Quelle ermitteln
Interrupt-Flag löschen
und entsprechend reagieren
Beeinflüsste Register restaurieren
zurück ins Programm springen ; retfie

Je nach Bedürfnissen, wird eine ISR nur nötige Elemente davon enthalten. Um auf alle Interrupts reagieren zu können muss die ISR vor dem nächsten Interrupt beendet werden. Da das Programm nur in den Pausen zwischen Ausführungen der ISR laufen kann, sollte die Ausführungszeit der ISR möglichst kurz sein.

Die kürzeste ISR setzt nur ein Flag ("_Fint"), das dem Programm zeigt, dass ein Interrupt statt gefunden hat. Sie eignet sich für den Fall, wenn nur eine Interrupt-Quelle erlaubt ist. Das Programm wird nur für 5 Prozessortakten unterbrochen.

0x0004 bcf INTCON,GIE ; Interrupts sperren
bcf IF ; Interrupt Flag löschen
bsf _Fint ; Flag setzen
retfie ; zurück ins Programm

Das Programm prüft das Flag "_Fint", löscht es und reagiert entsprechend. Somit kann ein Interrupt immer auf gleichen Stelle des Hauptprogramms bearbeitet werden.

Die ISR kann aber auch ein HP darstellen. Siehe hierzu: [[#Interrupts|Interrupts]]

=== Schnittstellen und Treiber ===

Als Schnittstelle wird externe Hadware, die zum Steuern eines an sie angeschlossenes "Gerätes" dient, genannt. Das ASM Programm, das die Steuerung ermöglicht ist ein Treiber. Als Beispiele siehe: [[http://www.roboternetz.de/phpBB2/viewtopic.php?t=13685]] und [http://www.roboternetz.de/phpBB2/viewtopic.php?t=22749]

== Vorlage für MPASM ==

Diese Vorlage ist nur für ASM Programme ohne Interrupts geeignet:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration
#define _DTT1 GPIO,0 ; Portpins benennen
#define _CKT2 GPIO,1
#define _T3 GPIO,2
#define _RNG GPIO,3
#define _INT GPIO,4
#define _RL GPIO,5
u.s.w.
SecondL equ 0x20 ; Variablen definieren (Register benennen)
SecondH equ 0x21
MinuteL equ 0x22
MinuteH equ 0x23
StundeL equ 0x24
StundeH equ 0x25
u.s.w
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
Haupt ............ ; hier fängt das Hauptprogramm als endlose Schleife an
Eigener Code
............
goto Haupt ; hier endet das HP, gehe zum Anfang des HPs (zurück)
UP1 ............ ; Unterprogramme
Eigener Code
............
return
############
UPn ............
Eigener Code
............
return
Init clrf GPIO ; lösche Port
bsf STATUS,RP0 ; auf Bank1 umschalten
call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; kalibriere internen RC oscillator
bcf OPTION_REG,7 ; aktiviere pull-ups
movlw 0x38 ; definiere Portpins GPIO, (z.B. 0-2 Aus- und 3-5 Eingänge)
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
movlw 7 ; schalte Komparator aus
movwf CMCON ; und definiere GPIO 0-2 als digitale I/Os
............
eigener Code
............
return ; springe zurück (zum Haupt)
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

Die Variablen können auch kürzer mit s.g. cblock definiert werden:

cblock 0x20
SecondL
SecondH
MinuteL
MinuteH
StundeL
StundeH
endc

Bei sehr vielen Variablen sind aber die Registeradressen nicht so übersichtlich.

Für Programme mit Interrupts ist diese Vorlage geeignet:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration
#define _DTT1 GPIO,0 ; Portpins benennen
#define _CKT2 GPIO,1
#define _T3 GPIO,2
#define _RNG GPIO,3
#define _INT GPIO,4
#define _RL GPIO,5
u.s.w.
SecondL equ 0x20 ; Variablen definieren (Register benennen)
SecondH equ 0x21
MinuteL equ 0x22
MinuteH equ 0x23
StundeL equ 0x24
StundeH equ 0x25
u.s.w
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
goto Haupt ; gehe zum Hauptprogramm "Haupt"
org 0x004 ; hier fängt die ISR (interrupt service routine) an
bcf INTCON,GIE ; interrupts sperren
.............
Eigener Code
.............
retfie ; hier endet die ISR, interrupts wieder erlauben
Haupt ............ ; hier fängt das Hauptprogramm als endlose Schleife an
Eigener Code
............
goto Haupt ; hier endet das HP, gehe zum Anfang des HPs (zurück)
UP1 ............ ; Unterprogramme
Eigener Code
............
return
############
UPn ............
Eigener Code
............
return
Init clrf GPIO ; lösche Port
bsf STATUS,RP0 ; auf Bank1 umschalten
call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; kalibriere internen RC oscillator
bcf OPTION_REG,7 ; aktiviere pull-ups
movlw 0x38 ; definiere Portpins GPIO, (z.B. 0-2 Aus- und 3-5 Eingänge)
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
movlw 7 ; schalte Komparator aus
movwf CMCON ; und definiere GPIO 0-2 als digitale I/Os
............
eigener Code
............
return ; springe zurück (zum Haupt)
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

== Das erste... ==

Hier wird detailiert das ganze Prozess der Erstellung eines ASM Programms beschrieben. Die Idee:

Es gibt 4 LEDs (_L1, _L2, _L3 und _L4), die mit 2 Tastern gesteuert werden sollen. Nach dem Einschalten soll keine LED leuchten. Solange der linke Taster (_T1) gedrückt ist, sollte eine leuchtende LED von links nach rechts "wandern" und von der letzten rechten Position wieder nach ganz linke "springen". Solange der rechte Taster (_T2) gedrückt ist, sollte eine leuchtende LED von rechts nach links "wandern" und von der letzten linken Position wieder nach ganz rechte "springen". Solange beide Taster gedrückt sind soll die leuchtende LED von links nach rechts und zurück "wandern".

Dafür nötige Hardware zeigt folgende Skizze:

.-----------------------------------------------.
| |
| PIC12F629 |
| |
| GPIO,3 GPIO,4 GPIO,5 GPIO,2 GPIO,1 GPIO,0|
'-----------------------------------------------'
4| 3| 2| 5| 6| 7|
| | .-. .-. .-. .-.
| | R | | R | | R | | R | |
| | 470| | 470| | 470| | 470| |
| | '-' '-' '-' '-'
\ o \ o | | | |
\ \ V -> V -> V -> V ->
\. \. - - - -
_T1 o _T2 o _L1 | _L2 | _L3 | _L4 |
| | | | | |
+-------+-------+---+---+-------+-------+
|
===
GND

Weil der Pin 4 (GPIO,3) nur einen "open drain" Ausgang hat (kann nur an GND schalten), wird er hier als Eingang benutzt.

Jetzt muss die Idee vom Programmierer in ein PAD verfasst werden, z.B. solcher:

Start
Initialisierung
.-------------->V
| _T1=0 gedrückt ? N >----.
| J |
| V |
| links->rechts "wandern" |
| V<------------´
| _T2=0 gedrückt ? N >----.
| J |
| V |
| rechts->links "wandern" |
| V<------------´
`---------------´

danach detailierter:

Start
Initialisierung
V<-------------------------------------------.
_T1=0 gedrückt ? N >---+--->_T2=0 gedrückt ? N >---+---´
J A J A
V | V |
_L1 an | _L4 an |
Warten | Warten |
_L1 aus | _L4 aus |
_L2 an | _L3 an |
Warten | Warten |
_L2 aus | _L3 aus |
_L3 an | _L2 an |
Warten | Warten |
_L3 aus | _L2 aus |
_L4 an | _L1 an |
Warten | Warten |
_L4 aus | _L1 aus |
V | V |
`------------´ `------------´

Weil der Prozessor die Befehle nacheinander liest, ist jeder Quelcode einspaltig. Um sich die "Übersetzung" des PADs in den Quelcode zu erleichtern wird er noch z.B. so umgestaltet:

Start
Initialisierung
V<-----------------+<----.
Haupt _T1=0 gedrückt ? N >---. A |
J | | |
V | | |
_L1 an | | |
Warten | | |
_L1 aus | | |
_L2 an | | |
Warten | | |
_L2 aus | | |
_L3 an | | |
Warten | | |
_L3 aus | | |
_L4 an | | |
Warten | | |
_L4 aus | | |
V<-----------´ | |
T2Test _T2=0 gedrückt ? N >---------´ |
J |
V |
_L4 an |
Warten |
_L4 aus |
_L3 an |
Warten |
_L3 aus |
_L2 an |
Warten |
_L2 aus |
_L1 an |
Warten |
_L1 aus |
V |
`------------------------´

Alle Pfeilen aus diesem PAD werden als "goto" in den Quelcode eingetragen.

Zuerst wird im MPASM Verzeichnis ein neuer Verzeichniss (z,B. "PIC Programme") angelegt und in dem Verzeichniss neue Textdatei (z.B. "Erstes.txt") erstellt. Als nächstes wird die "Vorlage für MPASM" dorthin kopiert.

Danach müssen, die im Programm benutzte Portpins und Register mit "#define" und "equ" definiert werden.

Als Initialisierung wird das UP "Init" aus der Vorlage für MPASM mit geändertem "TRISIO" Wert (0x18) übernommen. Siehe: [[#Vorlage für MPASM|Vorlage für MPASM]]

Fürs "Warten" wird eine dreifache Warteschleife verwendet. Siehe: [[#Pause|Pause]]

Die Taster werden mit "btfsc" Befehl geprüft und zum LEDs An- und Ausschalten werden Befehle "bsf" und "bcf" für ensprechenden Portpin von GPIO angewendet. Siehe: [[#Ausgeben|Ausgeben]]

Anschlessend wird alles laut PAD in die Vorlage für MPASM eingeschrieben und der Quellcode ist fertig:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration
#define _T1 GPIO,3 ; Portpins benennen
#define _T2 GPIO,4
#define _L1 GPIO,5
#define _L2 GPIO,2
#define _L3 GPIO,1
#define _L4 GPIO,0
P0 equ 0x20 ; Variablen definieren (Register benennen)
P1 equ 0x21
P2 equ 0x22
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
Haupt btfsc _T1 ; Taster _T1=0 gedrückt ?, wenn ja, überspringe "goto T2Test"
goto T2Test ; wenn nicht, springe zu "T2Test"
bsf _L1 ; schalte _L1 an (setze den Pin 2 auf "1")
call Warten ; warte ca. 0,4 s (ca. 400 000 Prozessortakten)
bcf _L1 ; schalte _L1 aus (setze den Pin 2 auf "0")
bsf _L2 ; schalte _L2 an (setze den Pin 5 auf "1")
call Warten ; warte
bcf _L2 ; schalte _L2 aus (setze den Pin 5 auf "0")
bsf _L3 ; schalte _L3 an (setze den Pin 6 auf "1")
call Warten ; warte
bcf _L3 ; schalte _L3 aus (setze den Pin 6 auf "0")
bsf _L4 ; schalte _L4 an (setze den Pin 7 auf "1")
call Warten ; warte
bcf _L4 ; schalte _L4 aus (setze den Pin 7 auf "0")
T2Test btfsc _T2 ; Taster _T2=0 gedrückt ?, wenn ja, überspringe "goto Haupt"
goto Haupt ; wenn nicht, springe zu "Haupt"
bsf _L4 ; schalte _L4 an (setze den Pin 7 auf "1")
call Warten ; warte
bcf _L4 ; schalte _L4 aus (setze den Pin 7 auf "0")
bsf _L3 ; schalte _L3 an (setze den Pin 6 auf "1")
call Warten ; warte
bcf _L3 ; schalte _L3 aus (setze den Pin 6 auf "0")
bsf _L2 ; schalte _L2 an (setze den Pin 5 auf "1")
call Warten ; warte
bcf _L2 ; schalte _L2 aus (setze den Pin 5 auf "0")
bsf _L1 ; schalte _L1 an (setze den Pin 2 auf "1")
call Warten ; warte
bcf _L1 ; schalte _L1 aus (setze den Pin 2 auf "0")
goto Haupt ; springe zu "Haupt"
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 ("Haupt"),
Init clrf GPIO ; lösche Port (setze alle werdende Ausgänge auf "0")
bsf STATUS,RP0 ; auf Bank1 umschalten
call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; und kalibriere internen RC oscillator (4 MHz)
bcf OPTION_ REG,7 ; aktiviere pull-ups für die Portpins
movlw 0x18 ; definiere Portpins GPIO,3 und 4 als Eingänge
; und restlichen als Ausgänge (00011000b)
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
movlw 7 ; schalte Komparator aus
movwf CMCON ; und definiere GPIO 0-2 als digitale I/Os
return ; springe zurück (zum Haupt)
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

Jetzt wird der Quellcode in "Erstes.asm" umbenannt. Diese "*.asm" Datei können wir dem MPASM zum "Übersetzten" geben. Nach der Assemblierung sehen wir 3 Meldungen (Messages) vom MPASM. Diese befinden sich in der vom MPASM erstellter Datei "Erstes.lst" und lauten:

Message[302]: Register in operand not in bank 0. Ensure that bank bits are correct.

Diese Meldung kann man übersetzen als:

Meldung[302]: Register im Befehl nicht in Bank 0. Vergewisse Dich, dass die Bank-Bits korrekt sind.

Wir sind sicher, dass die Register "OSCCAL", "OPTION_REG" und "TRISIO" in der Bank 1 sich befinden. Wenn man aber nicht sicher ist, soll man in Datenblatt nachschauen. Die Meldungen kommen immer für alle SFRs (Special Function Register) die sich nicht in der Bank 0 befinden und können ignoriert werden.

Am Ende der Datei "Erstes.lst" befinden sich noch einige Informationen über Programmspeicher:

Program Memory Words Used: 52 ; benutzte Speicherstellen
Program Memory Words Free: 972 ; freie Speicherstellen

und die Anzahl den eventuellen Fehlern (Errors), Warnungen (Warnings) und Meldungen (Messages):

Errors : 0
Warnings : 0 reported, 0 suppressed
Messages : 3 reported, 0 suppressed

Insgesamt werden durch MPASM 4 Dateien erstellt: "*.cod", "*.err", "*.hex" und "*.lst".

Wichtigste davon, falls wegen Fehler keine "*.hex" Datei erstellt wird, ist die "*.err" Datei, wo alles was dem MPASM nicht "passt" aufgelistet ist. In der "*.lst" Datei kann man sich ein Programm mit genauen Adressen für jeden Befehl anschauen.

Die während der Assemblierung vom MPASM generierte Datei "Erstes.hex" kann jetzt durch ein Brenner mit geeignetem Programm in den PIC Programmspeicher eingeschrieben werden.

== Für anderen PIC umschreiben ==

Die wichtigste Vorraussetzung ist, das der andere PIC2, auf dem das vorhandene ASM Programm für PIC1 laufen soll, zumindest für das ASM Programm nötige interne Hardware hat. Die Frequenz des Oszillators sollte gleich sein. Der Code benötigt ausser UP "Init" keine Änderungen.

Wenn der Port vom PIC2 anderen Namen hat, muss man das im Quellcode umdefinieren, z.B.:

#define PORTC PORTB
#define TRISC TRISB

Dann wird das Assemblerprogramm, wenn es PORTC findet, immer PORTB nehmen. Das gleiche Betrifft die "__config" Ausdrücke, die entsprechend der "*.ini" Datei für den PIC2, geändert werden müssen.

Das Assemblerprogramm findet sicher alles, was ihm nicht "passt" und bringt Fehlermeldungen, auf die man entsprechend reagieren muss.

Als Beispiel, schreiben wir "Erstes.asm" für den PIC16F84A um.

Zum Ändern sind die ersten 3 Zeilen:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration

Sie werden für den PIC16F84A so aussehen:

list P=16F84A ; Prozessor definieren
include "P16F84A.inc" ; 4.000 MHz
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _HS_OSC

Dazu muss noch "GPIO" Port umdefiniert werden, da der PIC16F84A solchen nicht hat, z.B wegen internen pull-ups auf "B":

#define GPIO PORTB
#define TRISIO TRISB

Die Hardware muss natürlich an entsprechende Pins angeschlossen werden:

_T1 auf 12 (B3), _T2 auf 13 (B4), _L1 auf 14 (B5), _L2 auf 11 (B2), _L3 auf 10 (B1) und _L4 auf 9 (B0)

Jetzt assemblieren wir die Qelldatei und der MPASM bringt in der Datei "Erstes.err" folgende Fehler:

Error[113] C:\MPASM\PICPROG\PIC16F84\ERSTES.ASM 61 : Symbol not previously defined (OSCCAL)
Error[113] C:\MPASM\PICPROG\PIC16F84\ERSTES.ASM 67 : Symbol not previously defined (CMCON)

In dem UP "Init" müssen also noch die Befehle mit "OSCCAL" und "CMCON" Register entfernt werden, da der PIC16F84A sie nicht hat:

call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; kalibriere internen RC oscillator (4 MHz)

und:

movlw 7 ; schalte Komparator aus
movwf CMCON ; und mache GPIO 0-2 als digital I/O

Weiter kann schon alles übernommen werden und die Datei "Erstes.asm" für den PIC16F84A ist fertig:

list P=16F84A ; Prozessor definieren
include "P16F84A.inc" ; 4.000 MHz
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _HS_OSC
#define GPIO PORTB ; Ports umbenennen
#define TRISIO TRISB
#define _T1 GPIO,3 ; Portpins benennen
#define _T2 GPIO,4
#define _L1 GPIO,5
#define _L2 GPIO,2
#define _L3 GPIO,1
#define _L4 GPIO,0
P0 equ 0x20 ; Variablen definieren (Register benennen)
P1 equ 0x21
P2 equ 0x22
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
Haupt btfsc _T1 ; Taster _T1=0 gedrückt ?, wenn ja, überspringe "goto T2Test"
goto T2Test ; wenn nicht, springe zu "T2Test"
bsf _L1 ; schalte _L1 an
call Warten ; warte ca. 0,4 s (ca. 400 000 Prozessortakten)
bcf _L1 ; schalte _L1 aus
bsf _L2 ; schalte _L2 an
call Warten ; warte
bcf _L2 ; schalte _L2 aus
bsf _L3 ; schalte _L3 an
call Warten ; warte
bcf _L3 ; schalte _L3 aus
bsf _L4 ; schalte _L4 an
call Warten ; warte
bcf _L4 ; schalte _L4 aus
T2Test btfsc _T2 ; Taster _T2=0 gedrückt ?, wenn ja, überspringe "goto Haupt"
goto Haupt ; wenn nicht, springe zu "Haupt"
bsf _L4 ; schalte _L4 an
call Warten ; warte
bcf _L4 ; schalte _L4 aus
bsf _L3 ; schalte _L3 an
call Warten ; warte
bcf _L3 ; schalte _L3 aus
bsf _L2 ; schalte _L2 an
call Warten ; warte
bcf _L2 ; schalte _L2 aus
bsf _L1 ; schalte _L1 an
call Warten ; warte
bcf _L1 ; schalte _L1 aus
goto Haupt ; springe zu "Haupt"
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 ("Haupt"),
Init clrf GPIO ; lösche Port (setze alle werdende Ausgänge auf "0")
bsf STATUS,RP0 ; auf Bank1 umschalten
bcf OPTION_REG,7 ; aktiviere pull-ups
movlw 0x18 ; definiere Portpins GPIO,3 und 4 als Eingänge
; und die restlichen als Ausgänge (00011000b)
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
return ; springe zurück (zum Haupt), nach der Zeile
; aus der du afgerufen wurdest
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

== Einbinden ==

Die einfachste Möglichkeit die gewünschte Programme in ein neues Programm einzubinden ist, die alle Programme in das neue Programm zu kopieren. Dafür müssen die ersten 3 Zeilen, die den Prozessor und die Konfiguration des PICs festlegen aus den eigebundenen Programmen entfernt werden. Danach müssen alle "#define", "equ" und "org" Direktiven, verglichen und wenn nötig geändert werden. Dabei hilft der MPASM mit seinen Fehlermeldungen in der Datei "*.err".

Die zweite Möglichkeit ist die gewünschte Programme als "*.asm" Dateien mit der Direktive "include *.asm" am Ende des neuen Programms vor der Direktive "end" einzubinden.

include "1.asm"
include "2.asm"
...............
include "n.asm"
end

In dem Fall gelten die gleichen o.g. Regeln wie beim direkten Kopieren. Wenn es in den eingebindenen Programmen keine "org" Direktiven gibt, dann werden die weitere Programme im Programmspeicher ab Ende des ersten Programms nacheinander plaziert.

== Fehlersuche ==

Als erstes wird an den PIC angeschlossene externe Hardware geprüft. Das sollte noch vor dem Einstecken oder Einlöten des PICs gemacht werden, da die gravierende Fehler (z.B. Kurzschlüsse, Umpolung von VCC und GND, u.s.w.) für den PIC schädlich werden können. Für einige Teile der Hardware kann entsprechende Spannung (VCC oder GND) an bestimmten Pin gelegt werden und die richtige Reaktion der Hardware optisch (z.B. für LEDs) oder akustisch (z.B. für Relais) festgestellt werden. Sonst müssen die elektrischen Verbindungen mit einem Messgerät überprüft werden.

Die Fehlersuche in der Software fängt mit der ersten und endet mit der letzten Zeile des ASM Programms. Sie läuft die ganze Zeit parallel zur Programmierung. Jedes UP soll vor dem Übertragen in den Quellcode geprüft und eventuelle Fehler beseitigt werden. Dazu arbeitet man gleichzeitig mit zwei "*.asm" Dateien, einer für die UPs und einer für das gesamte Programm. Es wird empfohlen, nach der "Initialisierung", als erstes UP, das für Ausgabegerät (z.B. Display) zu erstellen, um das funktionieren des Programms, vom Anfang an beobachten zu können.

Wenn aus geprüften UPs erstelltes Programm nicht richtig funktioniert, müsste ein Fehler im PAD sein.

== Optimierung ==
Work in Progress...
Wer sonst noch Beispiele hat, bitte hier vervollständigen...
BMS ...
=== Speicherbedarf ===
==== Programmspeicher ====
Die ersten Programme für den PIC sind natürlich einfach und kurz. Doch nach und nach werden die Codes länger und unübersichtlicher, das Brennen dauert auch umso länger. Das Programm ist zu umfangreich. Doch wo soll man etwas kürzen?

Es gibt unzählige Möglichkeiten - hier ein paar Beispiele:

===== Unterprogramme =====

Bestimmt wird man im Code immer die selben Abschnitte brauchen, zum Beispiel Warteschleifen oder ADC-Routinen, etc. Wieso sollte man diese also mehrfach (doppelt, dreifach, u.s.w.) schreiben?

Die Lösung: Der Programmteil wird als Unterprogramm benutzt. Man erstellt eine Sprungmarke (ab hier beginnt das Unterprogramm) und endet wieder mit einem "return"- oder "retlw"-Befehl.
Aufgerufen werden die Unterprogramme meistens mit dem "call"-Befehl. Es "lohnt sich" ein Codefragment als UP zu definieren erst wenn es min. 2 mal aufgerufen wird.

Ein "goto"-Befehl ist zu diesem Zweck geeignet nur, wenn der Prozessor zum letzten Aufrufer von "call" zurück springen soll, da die Rücksprungadresse vom letzten "call" auf dem Stapel (stack) abgelegt wurde. Somit kann man mehr als 8 Ebenen von UPs nutzen.

Den Unterprogrammen kann man natürlich auch Werte übergeben. Möchte man z.B. mehrere unterschiedliche Zeiten für Warteschleifen benutzen, so kann man die Parameter vor dem Aufruf des UPs in benötigte Anzahl von Register einschreben und dann das Unterprogramm mit "call" aufrufen. Das Unterprogramm verwendet dann die Zahlen von den Register. Siehe: [[#Pause|Pause]]

Um gleiche Vorgänge in mehreren Register durchzuführen (z.B. löschen) geeignet ist Anwendung von Schleifen mit bestimmter Anzahl der Abläufe und indirekter Adressierung. Siehe: [[#Variablen|Variablen]]

===== bsf und bcf =====

Bestimmt gibt es Situationen, in denen der PIC mehrere Bits an einem Port/Register setzen oder löschen muss. Z.B. wenn mehrere LEDs an einem Port ein- oder ausgeschaltet werden sollen.
Werden mehr als 2 Bits verändert, so kann man hier die "bsf"- und "bcf"-Befehle umgehen und einen kürzeren Code erstellen.

bsf PORTB,0 ;An PORTB sind 8 LEDs angeschlossen.
bsf PORTB,1 ;Es sollen die ersten 4 LEDs angeschaltet werden,
bsf PORTB,2 ;die anderen sollen ausgeschaltet werden.
bsf PORTB,3 ;links steht es mit bcf/bsf
bcf PORTB,4 ;ziemlich lang
bcf PORTB,5
bcf PORTB,6
bcf PORTB,7

movlw b'00001111' ;Das geht auch kürzer und übersichtlicher:
movwf PORTB

Man sieht - der Codeabschnitt umfasst nur noch 2 Zeilen anstatt 8. Somit braucht es weniger Speicher und wird von PIC schneller verarbeitet. Allerdings muss man aufpassen, da durch diese Routine der Inhalt des W-Registers und der Inhalt des gesamten Zielregisters verändert wird. Sollen die anderen Bits unangetastet bleiben, muss man es entweder bei den "bcf"/"bsf"-Befehlen belassen oder logische Funktionen (and bzw. or) durchführen.

===== Bit kopieren =====

;An den PIC ist ein Taster(RB0) und eine LED(RB1) angeschlossen.
;Taster: High=gedrückt Low=nicht gedrückt
;LED: High=Ein Low=Aus
;Wenn der Taster gedrückt ist, soll die LED leuchten
;wenn er nicht gedrückt ist, soll die LED nicht leuchten.
;1.Vorschlag:
btfss PORTB,0 ;ist der taster gedrückt?
goto no ;nein
bsf PORTB,1 ;ja - LED ein
goto endif ;fertig abgefragt - unten weitermachen...
no bcf PORTB,1 ;LED aus
endif

Der oben aufgeführte Code hat viele Nachteile: er ist relativ lang, braucht zwei Gotos und entspr. Sprungmarken. Ok, das ist vielleicht Erbsenzählerei, aber aus diesen 5 Zeilen kann man 3 machen.

bcf PORTB,1 ;Das Bit wird erst gelöscht
btfss PORTB,0 ;Taster gedrückt?
bsf PORTB,1 ;JA-LED an

Man geht davon aus, dass der Taster nicht gedrückt ist. Somit wird die LED erst einmal ausgeschaltet. Ist der Taster aber doch gedrückt, dann wird die LED angeschaltet.

Achtung möglicher Nebeneffekt: Wird dies in einer Schleife sehr schnell und oft ausgeführt, kann die LED flimmern oder nicht in ihrer vollen Helligkeit leuchten. Das passiert, weil ja angenommen wird, dass der Taster nicht gedrückt wird und die LED somit aus sein muss. Dann wird sie aber bei Tastendruck eingeschaltet. Somit entsteht ein schnelles ein-/ausschalten (PWM) und die LED leuchtet nicht mehr so hell.
Meist ist das aber nicht tragisch oder wird nicht unbedingt in einer Schleife sehr schnell abefragt. Siehe hierzu: [[#Einlesen|Einlesen]]

==== RAM ====

Um Anzahl benötigten Register zu sparen werden vorläufige Register (temporary) definiert, die von mehreren UPs benutzt werden. Als Beispiel, das Register "ATmp" in [[#Hex Dec Wandlung|Hex Dec Wandlung]]. Die Benutzung muss aber sehr genau nach PAD zugeteilt werden. Bei gleichzeitiger Benutzung des gleichen Registers durch mehrere UPS werden falsche Daten verarbeitet und im schlimmsten Fall können endlose Schleifen entstehen, die in Folge haben, dass das Programm nicht weiter ausgeführt wird ("hängt").

Viele im ASM Programm ungebrauchte SFRs können als "normale" Register (GPR) verwendet werden. Wenn zum Beispiel Timer1 nicht benutzt wird, können seine Register TMR1H und TMR1L für Speicherung von Daten benutzt werden. Es könnte aber gefährlich werden, wenn mehrere Programme gebindet sind. Deswegen muss es immer am Ende, beim volständigen Programm, geprüft werden, welche SFRs tatsächlich benutzt werden dürfen.

Für Konstanten (z.B. pi, ln2, Meldungen, u.s.w.), die sich im Laufe des Programms nicht ändern, kann EEPROM (mit MPASM Direktive "de") oder Programmspeicher (mit MPASM Direktive "dt") als Ablage benutzt werden. Siehe auch: [[#EEPROM|EEPROM]] und [[#Tabellen|Tabellen]]

=== Ausführungszeit ===

Alles was schnellmöglichst ablaufen soll, widersetzt sich der Optimierung des Programmspeichers.

Es können keine Schleifen und keine indirekte Adressierung benutzt werden, alles muss direkt programmiert werden.

Als Beispiel zur Verdeutlichung: Es sollen 16 Werte vom PORTA ins RAM ab Adresse 0x20 eingelesen werden.

Als Schleife mit indirekter Adressierung:

................
movlw 0x10 ;Anzahl Durchläufe
movwf Temp ;in den Schleifenzähler
movlw 0x20 ;erste Adresse
movwf FSR ;ins FSR Register
Einlesen movf PORTA,0 ;PortA ins W-Register
movwf INDF ;und ins aktuellen RAM Register
incf FSR,1 ;nächste Adresse
decfsz Temp,1 ;Temp = 0 ?
goto Einlesen ;nein, zum Einlesen
................ ;ja, weiter
Gesamtdauer: 100 Takten
Pause zwischen Einlesungen: 6 Takten
Programmspeicher Bedarf: 9 Speicherstellen
Direkt:

...............
movf PORTA,0
movwf 0x20
movf PORTA,0
movwf 0x21
movf PORTA,0
movwf 0x22
movf PORTA,0
movwf 0x23
movf PORTA,0
movwf 0x24
movf PORTA,0
movwf 0x25
movf PORTA,0
movwf 0x26
movf PORTA,0
movwf 0x27
movf PORTA,0
movwf 0x28
movf PORTA,0
movwf 0x29
movf PORTA,0
movwf 0x2A
movf PORTA,0
movwf 0x2B
movf PORTA,0
movwf 0x2C
movf PORTA,0
movwf 0x2D
movf PORTA,0
movwf 0x2E
movf PORTA,0
movwf 0x2F
...............
Gesamtdauer: 32 Takten
Pause zwischen Einlesungen: 2 Takten
Programmspeicher Bedarf: 32 Speicherstellen

Anstatt Warteschleifen (z.B. für Tastenentprellung) sollten Programmfragmente mit entsprechender Ausführungszeit benutzt werden (z.B. Ausgabe auf einem Display). Die nötige Zeit lässt sich aus mehreren UPs zusammensetzen.

Es sollte kein Prozessortakt ungenutzt bleiben.

= Mid-Range =

Zu Mid-Range gehören alle PICs mit 14-bit langen Befehlen aus den Familien 12FXXX und 16FXXX.

== Kurzübersicht Assembler Befehle ==

{|
|-
| valign=top |

{| {{Blauetabelle}}
|ADDLW||Add literal and W
|-
|ADDWF||Add W and f
|-
|ANDLW||AND literal with W
|-
|ANDWF||AND W with f
|-
|BCF||Bit Clear f
|-
|BSF||Bit Set f
|-
|BTFSC||Bit Test f, Skip if Clear
|-
|BTFSS||Bit Test f, Skip if Set
|-
|CALL||Call subroutine
|-
|CLRF||Clear f
|-
|CLRW||Clear W
|-
|CLRWDT||Clear Watchdog Timer
|}

| valign=top |

{| {{Blauetabelle}}
|-
|COMF||Complement f
|-
|DECF||Decrement f
|-
|DECFSZ||Decrement f, Skip if 0
|-
|GOTO||Go to address or label
|-
|INCF||Increment f
|-
|INCFSZ||Increment f, Skip if 0
|-
|IORLW||Inclusive OR literal with W
|-
|IORWF||Inclusive OR W with f
|-
|MOVF||Move f
|-
|MOVLW||Move literal to W
|-
|MOVWF||Move W to f
|-
|NOP||No Operation
|}

| valign=top |

{| {{Blauetabelle}}
|-
|RETFIE||Return from interrupt
|-
|RETLW||Return with literal in W
|-
|RETURN||Return from Subroutine
|-
|RLF||Rotate Left f through Carry
|-
|RRF||Rotate Right f through Carry
|-
|SLEEP||Go into standby mode
|-
|SUBLW||Subtract W from literal
|-
|SUBWF||Subtract W from f
|-
|SWAPF||Swap nibbles in f
|-
|XORLW||Exclusive OR literal with W
|-
|XORWF||Exclusive OR W with f
|}
[[:bild:pic_asm_short.jpg|Kurzübersicht zum Ausdrucken]]
|}


==Ausführliche Beschreibung zu den Befehlen==

Fast alle Befehle werden in einem Takt = 4 Oszillatortakten ausgeführt.

Aussnahmen:

"goto", "call", "return" und "retfie" benötigen wegen Zugriff auf den Programmzähler (PC) immer 2 Takten.

"btfsc", "btfss", "decfsz" und "incfsz" brauchen 1 Takt wenn der nächste Befehl ausgeführt wird b.z.w. 2 Takten wenn er überspringen wird, weil es immer anstatt des überspringenden Befehls ein "nop" ausgeführt wird.

Eine ausgegliederte Beschreibung der Befehle findet sich unter [[PIC Assemblerbefehle]]

Erklärungen zu den Verwendeten Platzhaltern:
*'''k''' stellt einen fest definierten Wert da. z.B. <tt>0x20</tt>, <tt>d'42'</tt> oder <tt>b'00101010'</tt>
*'''W''' steht für das W-Register.
*'''d''' steht für ''destination'' (Ziel). Im code wird d durch ein <tt>w</tt> bzw. <tt>0</tt> (der Wert wird in das W-Register gespeichert ) oder <tt>f</tt> bzw. <tt>1</tt> (der Wert wird in das davor definierte Register gespeichert)
*'''b''' steht für Bitnummer im Register (eine Zahl zwischen 0 und 7)
*'''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
*<tt>Schreibmaschinenstil</tt> bedeutet, dass es so im Quellcode geschrieben werden kann.

 ADDLW k ADD Literal and W - Addiere Zahl (k) und W<hr>
:Es wird die Rechenoperation <math>W+k</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|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

 ADDWF R,d ADD W and F - Addiere W und f <hr>
:Es wird die Rechenoperation <math>W+R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Dieser Befehl beeinflusst das STATUS-Register. Siehe hierzu [[#Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

 ANDLW k AND Literal with W<hr>
:Es wird bitweise die logische Funktion <math>k\ and\ W</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 Operation:
<dl><dd>
11001010 ;k
10101100 ;W-Register
-------- and
10001000 ;W-Register
</dd></dl>

 ANDWF R,d AND W with F<hr>
:Es wird bitweise die logische Funktion <math>W\ and\ R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Vergleiche ANDLW. Dieser Befehl wird benutzt zum Löschen bestimmten Bits im Register ohne restlichen Bits zu beeinflüssen.

BCF R,b Bit Clear F - Bit b im R wird gelöscht<hr>
:Mit dem Befehl <tt>BCF</tt> wird das Bit '''b''' im Register '''R''' gelöscht. Ein Beispiel:
<dl><dd>
movlw b'11111111' ;es wird b'11111111' in das W-Register geschrieben
BCF W,2 ;es wird bit 2 im W-Register gelöscht.
;das Ergebnis ist: b'11111011'
</dl></dd>

BSF R,b Bit Set F - Bit b im R wird gesetzt<hr>
:Mit dem Befehl <tt>BSF</tt> wird das Bit '''b''' im Register '''R''' gesetzt. Ein Beispiel:
<dl><dd>
clrw ;es wird b'00000000' in das W-Register geschrieben
BSF W,2 ;es wird bit 2 im W-Register gesetzt.
;das Ergebnis ist: b'00000100'
</dl></dd>

BTFSC R,b Bit Test F, Skip if Clear - Wenn das Bit b im Register R 0 ist, überspringe den nächsten Befehl<hr>
:Mit dem Befehl <tt>BTFSC</tt> kann eine Verzweigung im Programmablauf bewirkt werden. Wenn das Bit '''b''' im Register '''R''' 0 ist, wird der nächste Befehl übersprungen. Ein Beispiel:
<dl><dd>
movlw b'00000001' ;es wird die Zahl 1 in das W-Register kopiert.
BTFSC W,0 ;es wird bit 0 geprüft.
;wenn es 0 ist, wird der nächste Befehl übersprungen
goto IST_EINS ;springt zur Marke "IST_EINS" <- in diesem Fall wird dieser
;Sprungbefehl ausgeführt.
goto IST_NULL ;springt zur Marke "IST_NULL"
</dl></dd>

BTFSS R,b Bit Test F, Skip if Set - Wenn das Bit b im Register R 1 ist, überspringe den nächsten Befehl<hr>
:Mit dem Befehl <tt>BTFSS</tt> kann eine Verzweigung im Programmablauf bewirkt werden. Wenn das Bit '''b''' im Register '''R''' 1 ist, wird der nächste Befehl übersprungen. Ein Beispiel:
<dl><dd>
movlw b'00000001' ;es wird die Zahl 1 in das W-Register kopiert.
BTFSS W,0 ;es wird bit 0 geprüft.
;wenn es 1 ist, wird der nächste Befehl übersprungen
goto IST_NULL ;springt zur Marke "IST_NULL"
goto IST_EINS ;springt zur Marke "IST_EINS" <- in diesem Fall wird dieser
;Sprungbefehl ausgeführt, da der Befehl
;darüber übersprungen wurde.
</dl></dd>

CALL CALL Subroutine - Rufe Unterprogramm auf<hr>
:Mit dem <tt>CALL</tt> Befehl wird ein Unterprogramm aufgerufen. Mit dem <tt>RETURN</tt>-Befehl wird das Unterprogramm beendet und man kehrt zum Befehl nach dem <tt>CALL</tt>-Befehl zurück. Das Unterprogramm wird so definiert, dass im Quellcode der Name des Unterprogramms nicht eingerückt steht. Ein Beispiel:

<dl><dd>
movlw d'13' ;in das W-Register wird 13d geladen
CALL UP1 ;es wird das Unterprogramm "UP1" aufgerufen
movwf ergebnis ;das W-Register wird in das Register "ergebnis" kopiert.
;im Register "ergebnis" steht nun 23d

UP1 addlw d'10' ;es wird 10d zum W-Register addiert
return ;kehre zurück zum Aufrufer
</dl></dd>

CLRF R CLeaR F- Schreibe 0 in das Register R<hr>
:Das Register '''R''' wird mit Nullen gefüllt (gelöscht).

CLRW CLeaR W - Schreibe 0 in W<hr>
:Das W-Register (<tt>W</tt>) wird mit Nullen gefüllt (gelöscht).
:Der Befehl bewirkt das gleiche wie MOVLW 0 und darf im Programmen, die fur zukünftige Anwendung bei den PICs der serie 18F vorgesehen sind, nicht benutzt werden, da sie ihn nicht kennen.

CLRWDT CLeaR WatchDog Timer - Setzt den Watchdog-Timer zurück<hr>
:Es wird der WDT (Watchdog-Timer) zurückgesetzt und der Zähler des WDT auf 0 gesetzt, zusätzlich werden die STATUS-bits TO und PD gesetzt.

COMF R,d COMplement F - negiere alle bits im Register R<hr>
:Von der Binärzahl im Register '''R''' werden alle 0 mit 1 und alle 1 mit 0 ersetzt. Das Ergebnis wird entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Ein kleines Beispiel: aus <tt>AAh</tt> (<tt>10101010b</tt>) wird <tt>55h</tt> (<tt>01010101b</tt>).

DECF R,d DECrement F - Subtrahiert 1 vom Regiser f<hr>
:Vom Wert des Registers '''R''' wird 1 subtrahiert und das Ergebnis entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
:Weil es keine "echte" Substraktion ist, beeinflusst dieser Befehl das C-Flag im STATUS-Register nicht.

DECFSZ R,d DECrement F, Skip if Zero - Subtrahiert 1 vom Regiser f, überspringe wenn 0<hr>
:Vom Wert des Registers '''R''' wird 1 subtrahiert und das Ergebnis entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Der Zusatz SZ steht für ''skip if zero'', d.h. wenn das Ergebnis der Rechnung Null ist, wird der nächste Befehl übersprungen. Dieser Befehl wird für Schleifen mit bestimmter Anzahl der Durchläufe benutzt.

GOTO GO TO address - Gehe zu Adresse/Sprungmarke<hr>
:Nach dem GOTO Befehl wird das Programm ab der Adresse weiter ausgeführt, die nach dem GOTO-Befehl steht. Diese Adresse wird durch so genannte Sprungmarke definiert, welche, im Gegensatz zu den Befehlen nicht eingerückt im Quellcode stehen.

INCF R,d INCrement F - Addiere 1 zum Register f<hr>
:Zum Wert des Registers '''R''' wird 1 addiert und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
:Weil es keine "echte" Addition ist, beeinflusst dieser Befehl das C-Flag im STATUS-Register nicht.

INCFSZ R,d INCrement F, Skip if Zero - Addiere 1 zum Regiser f, überspringe wenn 0<hr>
:Zum Wert des Registers '''R''' wird 1 addiert und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Der Zusatz SZ steht für ''skip if zero'', d.h. wenn das Ergebnis der Rechnung Null ist, wird der nächste Befehl übersprungen. Dieser Befehl wird für Schleifen mit bestimmter Anzahl der Durchläufe benutzt.

 IORLW k Inclusive OR Literal with W<hr>
:Es wird bitweise die logische Funktion <math>k\ or\ W</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 Operation:
<dl><dd>
11001010 ;k
10101100 ;W-Register
-------- or
11101110 ;W-Register
</dd></dl>

 IORWF R,d Inclusive OR W with F<hr>
:Es wird bitweise die logische Funktion <math>W\ or\ R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Vergleiche IORLW. Dieser Befehl wird oft benutzt zum Setzen bestimmten Bits im Register ohne restlichen Bits zu beeinflüssen.

MOVF R,d MOVe F - Bewege f<hr>
:Das Register R wird in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder wieder in R kopiert ('''d'''=<tt>F</tt>=<tt>1</tt>). Letzteres mag sinnlos scheinen, ist aber nützlich, da durch den Befehl das Z-Bit im STATUS-Register gesetzt wird, falls R Null ist.

MOVLW k MOVe Literal to W - Bewege Zahl (k) in W-Register<hr>
:Der festgelegte Wert k wird in das W-Register kopiert.

:Dieser Befehl wird auch bei indirekter Adressierung zum laden der absoluter Adresse ins "FSR" Register benutzt. Beispiel:
:Der Register "Temp" wurde mit "Temp equ 0x20" definiert.
<dl><dd>
MOVLW Temp ;ins W-Register wird die absolute Adresse 0x20 vom "Temp" geladen
movwf FSR ;diese Adresse wird jetzt ins Register "FSR" kopiert
</dd></dl>
MOVWF R MOVe W to F- Bewege W-Register in das Register F<hr>
:Das W-Register wird in das Register '''R''' kopiert.

NOP No OPeration - Kein Befehl zum Ausführen (warte)<hr>
: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. Siehe hierzu: [[#Pause|Pause]]

RETFIE RETurn From Interrupt Enable - Kehre zurück aus der Unterbrechung, erlaube Unterbrechungen<hr>
:Mit diesem Befehl wird die Interrupt Service Routine (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 | Interrupt]]

RETLW k RETurn with Literal in W - Kehre zurück mit Zahl k im W-Register<hr>
:Wurde ein Programmteil mit dem Befehl <tt>CALL</tt> aufgerufen, dann springt man mit dem Befehl <tt>RETLW</tt> zurück in die nächste Zeile nach der Zeile aus der das <tt>CALL</tt> 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 Wertetabellen (eng: lookup tables) verwendet.

RETURN RETURN from Subroutine - Kehre zurück zum Aufrufer<hr>
:Wurde ein Programmteil mit dem Befehl <tt>CALL</tt> aufgerufen, dann springt man mit dem Befehl <tt>RETURN</tt> zurück zu der nächsten Zeile nach der Zeile aus der das <tt>CALL</tt> Befehl ausgeführt wurde.

RLF R,d Rotate Left F through carry - Rotiere das Register f mithilfe des Carry-bits nach links<hr>
:Alle Bits im Register '''R''' werden um eine Position nach links verschoben. Dabei wird das Carry bit (<tt>STATUS,C</tt>) 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'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
<dl><dd>
|<--- Register R --->|
|c|<-7<-6<-5<-4<-3<-2<-1<-0
V A
|________________________|
</dd></dl>
:Zur Verdeutlichung:
<dl><dd>
|C| |-Register R-| ;C steht für das Carry-bit, STATUS,C ; 0-7 stehen für Bitnummer im Register.
c 7 6 5 4 3 2 1 0 ;vor der Rotation
7 6 5 4 3 2 1 0 c ;nach der Rotation
</dd></dl>

RRF R,d Rotate Right F through carry - Rotiere das Register f mithilfe des Carry-bits nach rechts<hr>
:Alle Bits im Register '''R''' werden um eine Position nach rechts verschoben. Dabei wird das Carry bit (<tt>STATUS,C</tt>) 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'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
<dl><dd>
|<--- Register R --->|
|c|->7->6->5->4->3->2->1->0
A V
|________________________|
</dd></dl>
:Zur Verdeutlichung:
<dl><dd>
|C| |-Register R-| ;C steht für das Carry-bit, STATUS,C ; 0-7 stehen für Bitnummer im Register.
C 7 6 5 4 3 2 1 0 ;vor der Rotation
0 C 7 6 5 4 3 2 1 ;nach der Rotation
</dd></dl>

SLEEP Go into standby mode - Versetze den Mirokontroller in Bereitschaftsmodus (Schlaf)<hr>
: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.

 SUBLW k SUBtract W from Literal - Ziehe W von Zahl (k) ab<hr>
: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|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

 SUBWF R,d SUBtract W from F - Ziehe W von f ab<hr>
:Es wird die Rechenoperation <math>R-W</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Dieser Befehl beeinflusst das STATUS-Register. Siehe hierzu [[#Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

:Beispiel:
<dl><dd>
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
</dd></dl>

SWAPF R,d SWAP nibbles in F - Vertausche die Halbbytes (Nibbles)<hr>
:Es werden die höheren 4 bit (bit7-bit4) mit den niedrigeren 4 bit (bit3-bit0) eines Registers vertauscht und entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
:Beispiel:
<dl><dd>
movlw b'00001111' ;schreibe b'00001111' in das W-Register
movwf Register1 ;kopiert 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'
</dd></dl>

 XORLW k EXclusive OR Literal with W<hr>
:Es wird bitweise die logische Funktion <math>k\ xor\ W</math> ausgeführt und das Ergebniss in das W-Register gespeichert. Dieser Befehl setzt das Z bit des STATUS-Registers, falls W=k und das Ergebnis 0 ist.
:Zur Verdeutlichung der Operation:
<dl><dd>
11001010 ;k
10101100 ;W-Register
-------- xor
01100110 ;W-Register
</dd></dl>

 XORWF R,d EXclusive OR W with F<hr>
:Es wird bitweise die logische Funktion <math>W\ xor\ R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Vergleiche XORLW. Dieser Befehl setzt das Z bit des STATUS-Registers, falls W=k und das Ergebnis 0 ist und wird zum Vergleichen zwei Register benutzt.

==Besondere, oft gebrauchte Register==

=== STATUS ===
Der Statusregister beinhaltet den Status der Recheneinheit ALU (Arithmetic-Logic Unit), Resetinformationen und die beiden Bits zur Wahl der Speicherbank

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''STATUS''' (ADDRESSE 03h, 83h, 103h, 183h)</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R-1</td>
<td style="width:60px;">R-1</td>
<td style="width:60px;">R/W-x</td>
<td style="width:60px;">R/W-x</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''IRP'''</td>
<td style="background:#f5f7ff;">'''RP1'''</td>
<td style="background:#f5f7ff;">'''RP0'''</td>
<td style="background:#f5f7ff;">'''TO'''</td>
<td style="background:#f5f7ff;">'''PD'''</td>
<td style="background:#f5f7ff;">'''Z'''</td>
<td style="background:#f5f7ff;">'''DC'''</td>
<td style="background:#f5f7ff;">'''C'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

*Bit 7 '''IRP''': Register Bank Select Bit (für indirekte Adressierung)
:: 1 = Bank 2, 3 (100h-1FFh)
:: 0 = Bank 0, 1 (00h-FFh)
*Bit 6-5 '''RP<1:0>''': Register Bank Select Bits (für direkte Adressierung)
:: 11 = Bank 3 (180h-1FFh)
:: 10 = Bank 2 (100h-17Fh)
:: 01 = Bank 1 (80h-FFh)
:: 00 = Bank 0 (00h-7Fh)
*Bit 4 '''TO''': Time-out Bit
:: 1 = Nach Power-up, CLRWDT Befehl oder SLEEP Befehl
:: 0 = A Watchdogtimer time-out ist eingetreten
*Bit 3 '''PD''': Power-Down Bit
:: 1 = Nach Power-up oder durch den CLRWDT
:: 0 = Nach einem SLEEP befehl
*Bit 2 '''Z''': Zero bit
:: 1 = Das Ergebnis einer arithmetischen oder logischen Operation ist 0
:: 0 = Das Ergebnis einer arithmetischen oder logischen Operation ist NICHT 0
*Bit 1 '''DC''': Digit carry/borrow bit (ADDWF, ADDLW, SUBLW und SUBWF Befehle)
:: 1 = Ein Carry-out des 4.Niedrigsten Bits (Low Nibble) eines Rechenergebnisses existiert
:: 0 = Kein Carry-out des 4.Niedrigsten Bits eines Rechenergebnisses existiert
*Bit 0 '''C''': Carry/borrow Bit (ADDWF, ADDLW, SUBLW und SUBWF Befehle)
:: 1 = Ein Carry-out des MSB eines Rechenergebnisses existiert
:: 0 = Kein Carry-out des MSB eines Rechenergebnisses existiert

Das "Carry/Borrow Bit" (to carry = etwas übertragen, to borrow = etwas borgen) dient zum erkennen, wenn ein Übertrag einer Rechenoperation exisitiert. 250d+10d ergibt zum Beispiel 4, und setzt dabei das "Carry/Borrow Bit" auf 1. Damit kann das Programm erkennen, wenn wieder einmal ein Ergebnis größer als 255d herauskam.
Bei Subtraktionen (SUBLW und SUBWF) verhält sich das "Carry/Borrow Bit" umgekehrt als bei Additionen (ADDWF und ADDLW)!! Zum Beispiel 55d-6=49d setzt "Carry/Borrow Bit" auf 1 aber 10d-25d=241d löscht das "Carry/Borrow Bit".

====Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Registers====

{|
|-
|
{| {{Blauetabelle}}
|+ Auswirkungen auf das STATUS-Register bei Subtraktionen
|-
| Ergebnis
|| STATUS,C
|| STATUS,Z
|-
| positiv
|align="center"|1
|align="center"|0
|-
| negativ
|align="center"|0
|align="center"|0
|-
| Null
|align="center"|1
|align="center"|1
|}

||

{| {{Blauetabelle}}
|+ Auswirkungen auf das STATUS-Register bei Additionen
|-
| Ergebnis
|| STATUS,C
|| STATUS,Z
|-
| positiv
|align="center"|0
|align="center"|0
|-
| Überlauf
|align="center"|1
|align="center"|0
|-
| Null
|align="center"|1
|align="center"|1
|}
|}

=== PORTx ===

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''PORTx'''</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''Rx7'''</td>
<td style="background:#f5f7ff;">'''Rx6'''</td>
<td style="background:#f5f7ff;">'''Rx5'''</td>
<td style="background:#f5f7ff;">'''Rx4'''</td>
<td style="background:#f5f7ff;">'''Rx3'''</td>
<td style="background:#f5f7ff;">'''Rx2'''</td>
<td style="background:#f5f7ff;">'''Rx1'''</td>
<td style="background:#f5f7ff;">'''Rx0'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

!Das "x" steht in allen Fällen für den Buchstaben des Ports!
BSP: "PORTB" oder "RA1"

Diese Special Funktion Register liegen ALLE in Bank0 und Bank2(Falls vorhanden).

Jedes Bit eines PORT-Registers steht für einen Pin (Ein/Ausgang) des jeweiligen Ports. Je nachdem Ob ein Pin als Ausgang oder als Eingang definiert ist, kann man dort entweder den Wert schreiben oder auslesen. Es hat nicht Jeder PIC gleich viele Ports und es sind auch nicht immer 8 Pins pro Port, es können auch weniger sein. Alle PICs der Midrange-Serie besitzen nur bidirektionale Ports, d.h. sie können sowohl Eingang als auch Ausgang sein. Bei Port B kann man bei allen Pins einen internen PULL-UP Widerstand mit dem Bit OPTION_REG<RBPU> hinzuschalten (Standardmäßig auf nicht aktiviert, Bit muss gelöscht werden um die Funktion zu aktivieren). Weiters ist zu beachten, dass einzelne Pins nach dem Reset mit anderen Funktionen belegt sein können. Das gilt im Speziellen für PORTA, wo sich die Komperatoren, AD's (falls vorhanden) und die Oszillatoreingänge befinden. Siehe [[PIC Assembler#I/O Ports|I/O Ports]]. Bei den "kleinsten" PICs der 12F Serie die nur einen I/O Port (6 Pins) haben, heisst der PORT-Register GPIO.
{|{{Blauetabelle}}
|+ Beispiel PICs und ihre Ports (Zahlen in der Klammer sind die Anzahl der Pins des Ports)
|
|'''PIC16F628A'''
|'''PIC16F876'''
|'''PIC16F877'''
|-
|'''PORTA'''
|Ja
|Ja(5)
|Ja(6)
|-
|'''PORTB'''
|ja
|ja
|ja
|-
|'''PORTC'''
|/
|ja
|ja
|-
|'''PORTD'''
|/
|/
|ja
|-
|'''PORTE'''
|/
|/
|ja (3)
|-
|}

=== TRISx ===

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''TRISx'''</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''TRISx7'''</td>
<td style="background:#f5f7ff;">'''TRISx6'''</td>
<td style="background:#f5f7ff;">'''TRISx5'''</td>
<td style="background:#f5f7ff;">'''TRISx4'''</td>
<td style="background:#f5f7ff;">'''TRISx3'''</td>
<td style="background:#f5f7ff;">'''TRISx2'''</td>
<td style="background:#f5f7ff;">'''TRISx1'''</td>
<td style="background:#f5f7ff;">'''TRISx0'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

!Das "x" steht in allen Fällen für den Buchstaben des Ports!
BSP: "TRISB" oder "TRISA"

Bei den "kleinsten" PICs der 12F Serie die nur einen I/O Port (6 Pins) haben, heisst der TRIS-Register TRISIO.

Die TRIS-Bytes dienen dazu, einzelne I/O Pins als Eingang oder Ausgang zu definieren. Sie liegen immer genau eine Bank über den jeweiligen PORT-Bytes, d.h. sie liegen alle in Bank1 und Bank3 (falls vorhanden.) Besonders zu beachten ist, dass manche Eingebaute Features wie die Serielle Schnittstelle, I2C, SPI usw nicht funktionieren, wenn die Jeweiligen Sende und Empfangspins nicht manuell umgestellt werden, ja es ''muss'' sogar manchmal umgestellt werden (bei I2C z.B.) Egal ist dies jedoch für Komperatoren und AD-Wandler.

Merke:
* Eine 1 (als "I" für "Input" zu lesen) eines TRISxx-Bits definiert den zugehörigen PIN am PIC als Eingang.
* Eine 0 (als "O" für "Output" zu lesen) eines TRISxx-Bits definiert den zugehörigen PIN am PIC als Ausgang.

Siehe [[PIC Assembler#I/O Ports|I/O Ports]].

=== INTCON ===

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''INTCON''' (ADDRESSE 0Bh, 8Bh, 10Bh, 18Bh)</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''GIE'''</td>
<td style="background:#f5f7ff;">'''PEIE'''</td>
<td style="background:#f5f7ff;">'''TMR0IE'''</td>
<td style="background:#f5f7ff;">'''INT0IE'''</td>
<td style="background:#f5f7ff;">'''RBIE'''</td>
<td style="background:#f5f7ff;">'''TMR0IF'''</td>
<td style="background:#f5f7ff;">'''INT0IF'''</td>
<td style="background:#f5f7ff;">'''RBIF'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

*Bit 7 '''GIE''': Global Interrupt Enable Bit
::1 = Aktiviert alle Interrupts
::0 = Deaktiviert alle Interrupts
*Bit 6 '''PEIE''': Peripheral Interrupt Enable Bit
::1 = Aktiviert alle peripheren Interrupts
::0 = Deaktiviert alle peripheren Interrupts
*Bit 5 '''TMR0IE''': TMR0 Overflow Interrupt Enable Bit (Overflow von Timer0 löst Interrupt aus)
::1 = Aktiviert den TMR0 Interrupt
::0 = Deaktiviert den TMR0 Interrupt
*Bit 4 '''INT0IE''': RB0/INT External Interrupt Enable Bit (Änderung an RB0 Pin löst Interrupt aus) *)
::1 = Aktiviert den RB0/INT Interrupt (Extern ausgelöst)
::0 = Deaktiviert den RB0/INT Interrupt (Extern ausgelöst)
*Bit 3 '''RBIE''': RB Port On-Change-Interrupt Enable Bit (Änderung an PortB löst Interrupt aus) **)
::1 = Aktiviert den RB port on-change-interrupt
::0 = Deaktiviert den RB port on-change-interrupt
*Bit 2 '''TMR0IF''': TMR0 Overflow Interrupt Flag Bit
::1 = TMR0 Register ist Übergelaufen (muss per Software gelöscht werden)
::0 = TMR0 register ist nicht Übergelaufen
*Bit 1 '''INT0IF''': RB0/INT External Interrupt Flag Bit
::1 = Eine Änderung an RB0/INT Pin hat stattgefunden (muss per Software gelöscht werden)
::0 = Eine Änderung an RB0/INT Pin hat nicht stattgefunden
*Bit 0 '''RBIF''': RB Port On-Change-Interrupt Flag bit
::1 = Mind. einer der Pins von RB7:RB4 hat sich geändert (muss per Software gelöscht werden)
::0 = Keiner der Pins von RB7:RB4 hat sich geändert

* *) Die Flanke auf die reagiert werden soll, wird mit dem Bit OPTION_REG.INTEDG definiert. (steigende = 1 oder fallende = 0)
* **) Der Interrupt klingt verführerischer Weise so, als ob er den gesamten Port überwacht. Dabei reagiert er nur auf RB7:RB4!!!! Er kann aber den Prozessor vom "Schlaf" aufwecken (z.B. durch einen Tastendruck).

==Speicherbankorganisation==
===Programmspeicher===
Die Mid-Range MCUs haben einen 2-8k großen Programmspeicher. Dieser hat aber in jeder Speicherzelle nicht 8, sondern 14 Bit - also genau die Länge eines Befehls. Die aktuelle Stelle im Programm wird im PC (Program Counter) verwaltet. Er speichert immer die aktuelle Adresse im Programmspeicher (wird im Code oft als "$" bezeichnet). Bei einem PIC mit 8k Adressen muss er also die Adressen 0000-1FFF speichern können. Daraus folgt die Größe von 13 Bit für den PC. Der Programmspeicher ist in mehrere Bänke geteilt, die alle 2k groß sind. Das Programm springt ohne zutun des Benutzers von einer in die Nächste. Wenn man aber selber springen will, muss man die Register PCLATH (Program Counter Latch High) oder PCL (Program Counter Least Significant Byte) mit der Sprungadresse beschreiben.

===Datenspeicher===
Der Datenspeicher besteht aus den Special Function Registern (SFR) und den General Purpose
Registern (GPR). Die SFRs sind für die Funktionen des PICs zuständig (Interrupts, Timer, ADCs, CCPM...) und die GPRs für die Speicherung von Variablen und Daten.

Da immer nur 7 Bit der (Ziel)Adresse in einem Befehl gespeichert werden können, sind nur 7Fh (128d) Adressen im Datenbereich möglich. Deswegen wurde das "Banking" eingeführt. 2 Bit im Statusregister (welcher in allen Bänken der selbe ist und auch an der gleichen Stelle sitzt) geben die akutelle "Bank" an und sind nichts anderes als die 2 höchstwertigsten (MSB) Bits der Adresse. Damit lassen sich max. 4 Bänke ansprechen. Je nach PIC gibt es 2-4 Bänke. Die beiden Bits im Register STATUS heißen RP0 (STATUS<5>) und RP1 (STATUS<6>).

{| {{Blauetabelle}}
|+ Wechseln der Bänke mit RP0 und RP1
|-
|
|| RP1
|| RP0
|-
| Bank0
|align="center"|0
|align="center"|0
|-
| Bank1
|align="center"|0
|align="center"|1
|-
| Bank2
|align="center"|1
|align="center"|0
|-
| Bank3
|align="center"|1
|align="center"|1
|}

[[Bild:PIC midrange register.JPG]]
# '''FETTE Register''' sind in allen PICs vorhanden
# können je nach PIC unimplementierte Bereiche beinhalten - diese werden immer als 0 gelesen. (DATENBLATT!!)
# siehe 2
# Könnten je nach PIC auch nicht in Bank0 gemapped werden, sind dann eigenständige Register.
# je nach PIC kann es diese Bänke geben oder nicht geben.

== Codeschnipsel ==

=== Analog-Digital-Wandler (ADC) ===

Viele PICs besitzen einen Analog-Digital-Wandler, der eine angelegte Spannung messen kann und diese als Zahl speichert.

Es gibt AD-Wandler mit 8Bit bzw. 10Bit Auflösung, d.h. die Spannung an einem analogen Eingang wird linear 2^8=256 bzw. 2^10=1024 Werten zugeordnet.
Der höchste Wert, auch Referenzspannung genannt, (255 bzw. 1023; der Controller rechnet die Null auch mit) entspricht der Betriebsspannung des PICs oder wahlweise einer wählbaren Spannung, die an RA3 angelegt werden muss. Der niedrigste Wert entspricht 0 Volt.

Mit dem Analog-Digital-Wandler kann man somit z.B. Sensoren auswerten, die mehr als zwei Zustände ausgeben (Beispiele: Temperatursensor, Helligkeitssensor, Entfernungssensoren usw.) oder Akkuspannungen messen.

Bevor überhaupt gemessen werden kann, muss einiges eingestellt werden:

* Eingangsverteilung Analog/Digital bzw.Referenzspannung (Betriebsspannung oder RA3)
die genauen Einstellungsmöglichkeiten entnehmen sie bitte dem Datenblatt ihres Controllers (Register ADCON1 Bank 1).

* Wählen des Taktes für den ADC und Einschalten des ADCs

Das Register ADCON0 besitzt 8 Bits, die folgendes bestimmen:
Bit0 ADON - schaltet AD-Wandler ein oder aus (Strom sparen)
Bit1 - nicht vorhanden
Bit2 GO/Done - startet Wandlung / signalisiert, wann Umwandlung beendet ist.
Bit3 CHS0 - Channel Select 0 wählt Eingang aus
Bit4 CHS1 - Channel Select 1 wählt Eingang aus
Bit5 CHS2 - Channel Select 2 wählt Eingang aus
Bit6 ADCS0 - AD-Clock-Select wählt Takt
Bit7 ADCS1 - AD-Clock-Select wählt Takt

Kümmern wir uns zunächst um den Takt. Mit den zwei Bits ADCS0 und ADCS1 bestimmt man den Takt - hierbei gibt es vier Möglichkeiten:

ADCS1=0, ADCS0=0 -> Taktfrequenz des PICs :2
ADCS1=0, ADCS0=1 -> Taktfrequenz des PICs :8
ADCS1=1, ADCS0=0 -> Taktfrequenz des PICs :32
ADCS1=1, ADCS0=1 -> interner RC-Oszillator des ADCs verwenden

Die Taktfrequenz des ADCs darf 625kHz nicht überschreiten, dementsprechend ist ADCS0 und ADCS1 zu wählen.

Ist dies vollbracht, so kann man den AD-Wandler einschalten und das Go/Done-Bit löschen.
Codebeispiel:

bcf ADCON0,6 ;Takt für
bsf ADCON0,7 ;ADC (OSC/32)
bsf ADCON0,0 ;ADC einschalten, ADON=1
bcf ADCON0,2 ;Go/Done-Bit zurücksetzen

Nun ist der AD-Wandler bereit, Spannungen in Zahlen umzuwandeln.
Für eine Wandlung muss erst der entsprechende Eingang gewählt werden. Dafür sind die CHS0..CHS2-Bits zuständig:

CHS2 CHS1 CHS0 gewählter Eingang(falls vorhanden)
0 0 0 RA0
0 0 1 RA1
0 1 0 RA2
0 1 1 RA3
1 0 0 RA5
1 0 1 RE0
1 1 0 RE1
1 1 1 RE2

Achtung! RA4 ist kein analoger Eingang, folglich ist er oben nicht aufgelistet !!

Codebeispiel:

bcf ADCON0,3 ;RA2 auswählen
bsf ADCON0,4
bcf ADCON0,5

Als letztes muss die AD-Routine nur noch gestartet werden. Ist der AD-Wandler fertig, so löscht er das Bit wieder. Das Bit wird nun solange abgefragt, bis der AD-Wandler fertig ist. Den zugeordneten Wert findet man im Register 'ADRES'.
Code:

bsf ADCON0,2 ;start
wa btfsz ADCON0,2 ;warten,bis es wieder low ist
goto wa ;noch nicht fertig
;jetzt ist er fertig
movf ADRES,W ;ADRES in W verschieben, um damit gleich weiter zu arbeiten

Die AD-Wandlung ist somit fertig. Liest man mehrere Werte von unterschiedlichen Eingängen ein und möchte diese miteinander vergleichen o.ä., sollte man die Zahlen von ADRES in anderen Registern zwischenspeichern.

Desweiteren ist zu beachten, dass der Analog-Digital-Wandler eine gewisse Pause zwischen den Wandlungen benötigt, die sog. 'Aquisition Time'. Diese Zeitangabe entnehmen sie bitte ihrem Datenblatt.

mögliche Probleme:

;Der PIC liefert stark schwankende Werte
:-> Mögliche Ursachen dafür sind z.B. nicht stabile Betriebsspannung, falsche Zeiteinstellungen. Abhilfe schafft auch das mehrmalige Einlesen eines Eingangs. Auch können z.B. 8 Werte eingelesen werden und dann der Durchschnitt gebildet werden.
Evtl. kann ein Kondensator gegen Masse (z.B. 1nF) helfen; Wichtig ist auch eine kleine Verzögerung zwischen Kanalauswahl und Start der Wandlung. In dieser Zeit kann sich der interne Kondensator des ADC's aufladen.

;Die Spannung an einem Eingang wird erhöht, die Werte der anderen Eingänge werden aber auch beeinflusst.
:-> Dann sind Sie Opfer des sog. 'Ghostings' geworden (Werte 'scheinen durch', verschleißen). Die Werte der anderen Eingänge gehen mit, weil der interne Kondensator noch auf die Spannung des Vorgängers aufgeladen ist. Maßnahme: Aquisition Time erhöhen, Werte öfters abfragen, Pause zwischen Kanalauswahl und Start

;Der PIC liefert immer die gleichen Werte an einem Eingang, obwohl sich die angelegte Spannung ändert
:-> möglicherweise falsche Eingangsverteilung (ADCON1) eingestellt oder falschen Pin gewählt

=== Hex Dec Wandlung ===

Das ist ein Unterprogramm das mit "call Hex_Dec" aufgerufen wird. Es gibt 4 Register (A, B, C und D) mit jeweils 32 Bits, die aus jeweils 4 Register mit 8 Bits (z.B. fur A: A3, A2, A1 und A0) bestehen.

A3 A2 A1 A0
.--------.--------.--------.--------.
|76543210|76543210|76543210|76543210|
'--------'--------'--------'--------'
| |
|<----------- A Register ---------->|

Sie müssen (wegen FSR) so wie im Code nacheinander liegen (die absoluten Adressen sind nicht wichtig). In das Register "A" wird die hex Zahl eingeschrieben und aus dem "D" die umgewandelte dec Zahl ausgelesen. A3,7 und D3,7 sind MSB und A0,0 und D0,0 sind LSB. Die "B" und "C" sind Hifsregister. Das UP kann für kleinere als 32-bittige hex Zahlen modifiziert werden. Zum Beispiel für 16-bittige hex Zahlen bleiben nur Register A1,A0,B1,B0,C1,C0,D1,D0 und in den UPs werden in die Register und als X, folgende Zahlen eingeschrieben: HTmp->0x10 (Anzahl Bits der hex Zahl),ATmp->2=X (Anzahl Bytes der hex Zahl). Es müssen auch die UPs "CClr", "DClr" und "CopyCB" entsprechend der Registerlänge angepasst werden. Genauso kann natürlich das UP auch für längere hex Zahlen modifiziert werden.

Das UP "AddCB" addiert dezimal die 32- bittige Register C und B, das Ergebniss befindet sich in C.
Das UP "AddDC" addiert dezimal die 32-bittige Register D und C, das Ergebniss befindet sich in D.

Die 32-bit Additionen werden in 4 Schritten wie folgt realisiert:

C0+B0->C0, C1+B1->C1, C2+B2->C2 und C3+B3->C3

D0+C0->D0, D1+C1->D1, D2+C2->D2 und D3+C3->D3

Die Flags "_Fcra", "_Fcrp" und "_Fdca" steuern die alle nötigen Korrekturen.

Die Wandlung wird in 32 Schritten laut folgender Formel durchgeführt:

Zahl(d)=B0*2^0+B1*2^1+B2*2^2+B3*2^3+B4*2^4+B5*2^5+B6*2^6+B7*2^7+B8*2^8+B9*2^9+B10*2^10+B11*2^11+

B12*2^12+B13*2^13+B14*2^14+B15*2^15+B16*2^16+B17*2^17+B18*2^18+B19*2^19+B20*2^20+B21*2^21+

B22*2^22+B23*2^23+B24*2^24+B25*2^25+B26*2^26+B27*2^27+B28*2^28+B29*2^29+B30*2^30+B31*2^31

Wobei B0 bedeutet den LSB und B31 den MSB der hex Zahl.

Die dec Zahl wird im D Register durch "AddDC" gebildet. In dem C Register befindet sich immer die laufende 2^X. Am Anfang wird dort 1=2^0 geladen. Da die nächste zu addierende dec Zahl immer gleich 2* vorherige ist, wird sie einfach so berechnet, dass die aktuelle aus C Register ins B Register kopiert ("CopyCB") und zu C addiert ("AddCB") wird. Diese dec Zahl wird zum D Register addiert nur wenn das entsprechende Bit der hex Zahl gleich 1 ist. Weil im UP "Hex_Dec" immer das bit A0,0 dafür geprüft wird, wird das gesamte 32-bittige A Register nach jeder Addition "AddDC" um ein Bit mit "ARotRb" nach rechts rotiert. Die Flags "_Fcra" und "_Fcrp" übertragen die Bits zwischen den 8 Bit Registern A0, A1, A2 und A3. Es würde zwar reichen, wenn das A Register nur verschoben würde, aber hier wurde Rotation gewählt, damit nach der Wandlung die hex Zahl im A Register unverändert steht. Weil die dec Zahl nur 8-stellig ist, darf die max. hex Zahl 99999999d = 5F5E0FFh sein.

#define _C STATUS,C
#define _Z STATUS,Z
#define _DC STATUS,DC
#define _Fcra Flags,0
#define _Fcrp Flags,1
#define _Fdca Flags,2
#define _Ferr Flags,3 ;Überlauf (Fehler)
;..................................................................................
A3 EQU 0x20 ;Register fürs Rechnen
A2 EQU 0x21
A1 EQU 0x22
A0 EQU 0x23
B3 EQU 0x24
B2 EQU 0x25
B1 EQU 0x26
B0 EQU 0x27
C3 EQU 0x28
C2 EQU 0x29
C1 EQU 0x2A
C0 EQU 0x2B
D3 EQU 0x2C
D2 EQU 0x2D
D1 EQU 0x2E
D0 EQU 0x2F
Flags EQU 0x30
ATmp EQU 0x31 ;Schleifenzähler
HTmp EQU 0x32 ;Schleifenzähler
RTmp EQU 0x33 ;Zwischenspeicher
;..................................................................................
Hex_Dec call CClr ;Hex>A, D>Dec
call DClr
movlw 1
movwf C0
movlw 0x20 ;32 bit Hex > 32 bit Dec (8 Stellen)
movwf HTmp
HexDecL btfsc A0,0
call AddDC
call CopyCB
call AddCB
call ARotRb
decfsz HTmp,1
goto HexDecL
return
CClr clrf C0
clrf C1
clrf C2
clrf C3
return
DClr clrf D0
clrf D1
clrf D2
clrf D3
return
CopyCB movf C0,0
movwf B0
movf C1,0
movwf B1
movf C2,0
movwf B2
movf C3,0
movwf B3
return
AddCB movlw B0 ;C+B>C
movwf FSR
goto AddR
AddDC movlw C0 ;D+C>D
movwf FSR
AddR bcf _Ferr ;Addiere zwei Register
bcf _Fcrp
movlw 4 ;X=4 Bytes lang
movwf ATmp
AddRL bcf _Fdca
bcf _Fcra
movf INDF,0
movwf RTmp
movlw 4 ;X=4
addwf FSR,1
btfss _Fcrp
goto AddRN
movlw 1
addwf INDF,1
call DecCor
AddRN movf RTmp,0
addwf INDF,1
call DecCor
btfss _Fdca
goto AddCor1
movlw 6
addwf INDF,1
AddCor1 btfss _Fcra
goto AddCor2
movlw 0x60
addwf INDF,1
btfsc _C
bsf _Fcra
AddCor2 movf INDF,0
andlw 0xF0
sublw 0xA0
btfss _Z
goto AddCor3
movf INDF,0
andlw 0x0F
clrf INDF
addwf INDF,1
bsf _Fcra
AddCor3 bcf _Fcrp
btfsc _Fcra
bsf _Fcrp
movlw 5 ;X+1=5
subwf FSR,1
decfsz ATmp,1
goto AddRL
btfsc _Fcra
bsf _Ferr
return
DecCor btfsc _DC ;dezimale Korrektur (equ DAW)
bsf _Fdca
btfsc _C
bsf _Fcra
movf INDF,0
andlw 0x0F
sublw 9
btfss _C
bsf _Fdca
movf INDF,0
andlw 0xF0
sublw 0x90
btfss _C
bsf _Fcra
return
ARotRb movlw A3 ;rotiere A register 1 Bit rechts
movwf FSR
RRotRb movlw 4 ;rotiere X=4 Bytes
movwf ATmp
bcf _Fcrp
btfsc A0,0
bsf _Fcrp
RRotRbL bcf _Fcra
btfsc INDF,0
bsf _Fcra
bcf _C
btfsc _Fcrp
bsf _C
rrf INDF,1
bcf _Fcrp
btfsc _Fcra
bsf _Fcrp
incf FSR,1
decfsz ATmp,1
goto RRotRbL
return

=== EEPROM ===

Alle PICs besitzen EEPROM in dem je nach Typ können 64 bis 256 Databytes abgespeichert werden. Die Adressierung des EEPROMs fängt immer mit 0x00 an. Hier werden nur geprüfte UPs kurz erklärt. Die ersten zwei brauchen nur ein Register "Temp" für Schleifenzähler, dessen Name, falls im Programm schon existiert, geändert werden muss. Die Adresse im EEPROM ist gleich der Adresse im RAM.

EEPROM beschreiben:

EEWrite movlw 0x20 ; ab der RAM Adresse wird in EEPROM abgespeichert
movwf FSR
movlw 4 ; soviel Bytes
movwf Temp ; Schleifenzähler
EEWLoop call EEWrite1
incf FSR,1 ; nächste Adresse
decfsz Temp,1
goto EEWLoop
return

EEWrite1 bcf INTCON,GIE ; Interrupts sperren
movf FSR,0
bsf STATUS,RP0 ; auf Bank1 umschalten
movwf EEADR ; EEPROM Adresse
movf INDF,0
movwf EEDATA ; EEPROM Data
bsf EECON1,WREN
movlw 0x55
movwf EECON2
movlw 0xAA
movwf EECON2
bsf EECON1,WR
bcf EECON1,WREN
btfsc EECON1,WR
goto $-1 ; warten bis WR=0
bcf STATUS,RP0 ; zurück auf Bank 0 umschalten
bsf INTCON,GIE ; Interrupts erlauben
return

EEPROM lesen und zurück in RAM schreiben:

EERead movlw 0x20 ; ab der Adressse wird aus EEPROM in RAM abgelegt
movwf FSR
movlw 4 ; soviel Bytes
movwf Temp ; Schleifenzähler
EERLoop call EERead1
incf FSR,1 ; nächste Adresse
decfsz Temp,1
goto EERLoop
return

EERead1 movf FSR,0
bsf STATUS,RP0 ; auf Bank1 umschalten
movwf EEADR ; EEPROM Adresse
bsf EECON1,RD
movf EEDATA,0 ; EEPROM Data
bcf STATUS,RP0 ; zurück auf Bank 0 umschalten
movwf INDF
return

Tabelle im EEPROM mit MPASM Direktive "de" erstellen:

org 0x2100 ; EEPROM initialisieren
; nachfolgend als Kommentar die EEPROM Adressen
de 0x03, 0xE8 ; 0x00
de 0x03, 0xE8 ; 0x02
de 'M','H','z',0x00 ; 0x04
de ' ',' ','W','A','I','T',0x00 ; 0x08
de 'C','o','n','s','t',' ','X',0x00 ; 0x0F
de 'C','=',0x00 ; 0x17
de 'L','=',0x00 ; 0x1A
de 'F','=',0x00 ; 0x1D
de 'O','K',0x00 ; 0x20
u.s.w.

Wenn die Tabelle sich im Quellcode befindet, wird sie beim brennen des PICs in EEPROM eigeschrieben.

Das Lesen eines Strings muss ab entsprechender EEPROM Adresse (z.B. für "MHz" -> 0x04) anfangen und auf dem Wert 0x00, der hier als Stringende dient, enden. Einfacher ist, wenn alle Strings gleich lang sind (wie z.B. in einem Zeichengenerator fur Grafikdisplay).

Die Adreesse "0x2100" in der "org" Direktive hat mit der Adresse im Programmspeicher nichts zu tun.

=== Interrupts ===

Das Programmteil misst eine Frequenz an TOCKI Pin und wurde für PIC16F870 geschrieben.

Benötigte Hardware: Widerstand 470 Ohm zwischen der Frequenzquelle und TOCKI Pin (A4).

Es fehlen UPs "Hex_Dec" [[#Hex Dec Wandlung|Hex Dec Wandlung]] und Ausgabe auf ein Display "DispFrq". Das HP ("Main") als leere endlose Schleife macht nichts ausser warten auf ein Interrupt von Timer0 bzw. Timer1. Man kann die Marke "Main" weglassen und das HP als "goto $" formulieren.

Da der Timer0 nicht, wie der Timer1 durch ein Flag gestartet und gestoppt werden kann, wird es durch setzen und löschen des Bits für TOCKI (A4) Pin im TRISA Register, genauso wie in der AN592 vom Microchip, gemacht.

Der Zähler der Frequenz wurde um ein Zähler aus zwei zusätzlichen Register A2 und A3 erweitert und bei jedem Timer0 Überlauf erhöht. Der Prescaler wird ins Register A0 und der TIMER0 ins A1 kopiert. Somit ergibt sich 32-bittiges Ergebniss, der als hex Zahl in den Register A3 (MSB),A2, A1, und A0 (LSB) steht. Nach der "Hex_Dec" Wandlung kann die Frequenz aus den Register D3 (MSB), D2, D1 und D0 (LSB) an einem biliebigen Display angezeigt werden.

Es wird kein zusätzliches Register benötigt, da das "ATmp" und das "RTmp" die gleichen wie im UP "Hex_Dec" sind. Die Quarzfrequenz wurde gewählt, weil sie am nächsten der Temperaturstabiltesten Frequenz für AT Quarzen 7,2 MHz ist. Der PIC16F870 wurde nur wegen nötigen 19 I/O Pins für 6-stelligen 7-segment LCD Display LPH2673-1[[http://www.roboternetz.de/phpBB2/viewtopic.php?t=26005]] (ohne Kontroller) vom Pollin angewendet. Mit einem üblichen 1x16 Zeichen LCD Matrixdisplay und anderen PICs wurde das Programm für Frequenzen bis zum 80 MHz mit einer Genauigkeit
+/- 4 Hz positiv getestet.

Um die Frequenz mit Genauigkeit +/- 1Hz zu messen, muss die Messzeit 1 s von Timer1 erzeugt werden, das nur für Quarz bis 2,048 MHz möglich ist. Für sehr genaue Messungen wird empfohlen als Taktfrequenz für den Timer1, die Trägerfrequenz eines nächsten LW Senders (z.B. DLF 153 bzw. 207 kHz) zu nutzen. Die Genauigkeit der Frequenz ist ca. 1E-11 und geprüfter Empfänger kann laut der Skizze in [[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=13706&highlight=frequenzz%E4hler]] nachgebaut werden. In dem Fall müssen die Register vom Timer1 (TMR1H und TMR1L) vor seinem Start entsprechend geladen werden.

Mit dem Quarz 7,3728 MHz wird hier die Messzeit 0,25 s genutzt und die gemessene Frequenz durch 4 multipliziert (mittels 2 Additionen), was die Auflösung von +/- 4 Hz ergibt.

Das UP "Init" muss selbstverständlich für ein Matrixdisplay um Initialisierung des Displaykontrollers ergänzt werden.

; Programm zum Messen der Frequenz an T0CKI Pin mit 7,3728 MHz Quarz
LIST P=16F870
include "P16F870.inc"
__CONFIG _CP_OFF & _DEBUG_OFF & _WRT_ENABLE_ON & _CPD_OFF & _LVP_OFF & _BODEN_OFF &
_PWRTE_ON & _WDT_OFF & _HS_OSC
ORG 0x0000
call Init
Main goto Main
ORG 0x0004 ;ISR (interrupt service routine)
bcf INTCON,GIE ;interrupts sperren
btfss INTCON,T0IF ;ist Timer0 übelaufen ?
goto CheckTMR1 ;nein, dann prüfe Timer1
bcf INTCON,T0IF ;Timer0 interrupt flag löschen
movlw 1
addwf A2,1 ;erhöhe A2
btfsc STATUS,C
incf A3,1 ;increment A3, wenn A2 überlaufen ist
CheckTMR1 btfss PIR1,TMR1IF ;ist Timer1 überlaufen ?
retfie ;wenn nicht, springe zurück zu Main
bsf STATUS,RP0 ;stopp Timer0
movf TRISA,0
andlw 0xEF
movwf TRISA ;TOCKI Pin (A4) als Ausgang
bcf STATUS,RP0
bcf T1CON,TMR1ON ;stopp Timer1
bcf PIR1,TMR1IF ;Timer1 interrupt flag löschen
GetFreq movf TMR0,0 ;Prescaler ins Register A0 kopieren
movwf A1
movwf RTmp
clrf ATmp
FToggle incf ATmp,1
bsf STATUS,RP0
bsf OPTION_REG,T0SE
bcf OPTION_REG,T0SE
bcf STATUS,RP0
movf TMR0,0
subwf RTmp,0
btfsc STATUS,Z
goto FToggle
comf ATmp,1
incf ATmp,0
movwf A0
call Hex_Dec
clrf A3 ;Register A löschen
clrf A2
clrf A1
clrf A0
call CopyDC
call AddDC ;gemessene Frequenz * 2
call CopyDC
call AddDC ;gemessene Frequenz * 4 = tatsächliche Frequenz
call DispFrq ;eigenes UP für benutztes Display
clrf TMR0 ;Timer0 löschen
movlw 0x34 ;Timer1
movwf T1CON ;konfigurieren
movlw 0x1F ;Timer1 laden (für 0,25 s)
movwf TMR1H
clrf TMR1L
bsf STATUS,RP0 ;start Timer0
movf TRISA,0
iorlw 0x10
movwf TRISA ;TOCKI Pin (A4)als Eingang
bcf STATUS,RP0
bsf T1CON,TMR1ON ;start Timer1
retfie ;erlaube interrupts und springe zurück zu Main
CopyDC movf D0,0
movwf C0
movf D1,0
movwf C1
movf D2,0
movwf C2
movf D3,0
movwf C3
return
Init clrf PORTA ;Ports löschen
clrf PORTB
clrf PORTC
movlw 0x20 ;RAM (20-7Fh) löschen
movwf FSR
clrf INDF
incf FSR,1
btfss FSR,7
goto $-3
clrf ADCON0 ;schalte ADC off
movlw 7 ;sperre ADC
movwf ADCON1 ;und definiere RA0-7 als digitale I/Os
movlw 0xE0 ;GIE, PEIE & TMR0IE erlauben
movwf INTCON
bsf STATUS,RP0 ;bank 1
clrf TRISA ;alle PORTA,
clrf TRISB ;alle PORTB,
clrf TRISC ;und alle PORTC Pins als Ausgänge
movlw 0xE7 ;Takt für Timer0 vom T0CKI Pin
movwf OPTION_REG ;Timer0 konfigurieren
bsf PIE1,TMR1IE ;TMR1 interrupt erlauben
bcf STATUS,RP0 ;Bank 0
clrf TMR0 ;Timer0 löschen
movlw 0x34 ;Timer1 konfigurieren
movwf T1CON ;(prescaler 8)
movlw 0x1F ;Timer1 laden (für 0,25 s)
movwf TMR1H
clrf TMR1L
bsf STATUS,RP0 ;start Timer0
iorlw 0x10
movwf TRISA ;TOCKI Pin (A4) als Eingang
bcf STATUS,RP0
bsf T1CON,TMR1ON ;start Timer1
return
end

=== Mausrad ===

Das UP wertet ein Mausrad aus und setzt, je nach Drehrichtug und sein Anschluss an PORT (PORTB,0 und PORTB,1), ein Flag "_Finc" bzw. "_Fdec", das vor der nächsten Abfrage, gelöscht werden muss. Diese Flags können z.B. für Inkrementierung und Dekrementierung von Zählern dienen.

Die Hardware:

Mausrad
.-------.
| o---> PORTB,0
+----o---- |
| | o---> PORTB,1
=== '-------'
GND

Es müssen die internen pull-ups vom PORTB aktiviert werden. Wenn das Mausrad an anderen PORT angeschlossen wird, werden externe pull-ups (z.B. 10 kOhm) benötigt. Als "_Z" wurde "STATUS,Z" definiert. Zum Auswerten werden 4 Register "MausA", "MausB", "MausC" und "Flags" gebraucht, die im gesamten Programm definiert werden müssen. Die Warteschleife "Delay" soll ca. 10ms sein.

In dem UP "Mouse" wird PORTB eigelesen, die alle Bits ausser 0 und 1 durch "and" Funktion gelöscht und in den Register "MausB" und "MausC" gespeichert. Nach ca. 10ms wird das gleiche gemacht und im Register "MausA" gespeichert. Der Wert aus "MausA" wird mit dem vorherigen aus "MouseC" durch "xor" verglichen. Sind sie nicht identisch, wird je nach dem Wert "X" (0, 1, 2, b.z.w. 3) im "MausB" in das entsprechende UP "MouseX" gesprungen. Sonst, wenn "MausA"="MausC", wird zum Aufrufer zurückgekehrt.

In einem UP "MouseX" wird der letzte Wert im "MausA" ermittelt und nach der Kombination der Werte im "MausB" und "MausA" (01 b.z.w. 02, 10 b.z.w. 13, 20 b.z.w. 23 oder 31 b.z.w. 32) entsprechendes der Drehrichtung Flag "_Finc" b.z.w. "_Fdec" gesetzt. Anschliessend wird zum Aufrufer zurückgesprungen.

Detailierter PAD:

Mouse V
PORTB->W
3 and W->W
W->MausB
W->MausC
Warten 10ms
PORTB->W
3 and W->W
W->MausA
W xor MausC->MausC
_Z=1 ? J > return
N
V
MausB->MausB
.--------------------------< J _Z=1 ?
| N
| V
| MausB->W
| 1-W->W
| .----< J _Z=1 ?
| | N
| | V
| | MausB->W
| | 2-W->W
| | _Z=1 ? J >---------------------------.
| | N |
| | V |
| | MausB->W |
| | 3-W->W |
| | _Z=1 ? J >-----. |
| | N | |
| | V | |
| | return | |
| | | |
| | | |
Mouse0 V Mouse1 V Mouse3 V Mouse2 V
MausA->W MausA->MausA MausA->W MausA->MausA
1-W->W V 1-W->W V
_Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--.
J | J | J | J |
V | V | V | V |
setze _Fdec | setze _Finc | setze _Finc | setze _Fdec |
V<-----´ V<-----´ V<-----´ V<-----´
MausA->W MausA->W MausA->W MausA->W
2-W->W 3-W->W 2-W->W 3-W->W
_Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--.
J | J | J | J |
V | V | V | V |
setze _Finc | setze _Fdec | setze _Fdec | setze _Finc |
V<-----´ V<-----´ V<-----´ V<-----´
return return return return

und Quellcode:

Mouse movf PORTB,0
andlw 3
movwf MausB
movwf MausC
call Delay ; ca. 10 ms
movf PORTB,0
andlw 3
movwf MausA
xorwf MausC,1
btfsc _Z
return
movf MausB,1
btfsc _Z
goto Mouse0
movf MausB,0
sublw 1
btfsc _Z
goto Mouse1
movf MausB,0
sublw 2
btfsc _Z
goto Mouse2
movf MausB,0
sublw 3
btfsc _Z
goto Mouse3
return
Mouse0 movf MausA,0
sublw 1
btfsc _Z
bsf _Fdec
movf MausA,0
sublw 2
btfsc _Z
bsf _Finc
return
Mouse1 movf MausA,1
btfsc _Z
bsf _Finc
movf MausA,0
sublw 3
btfsc _Z
bsf _Fdec
return
Mouse2 movf MausA,1
btfsc _Z
bsf _Fdec
movf MausA,0
sublw 3
btfsc _Z
bsf _Finc
return
Mouse3 movf MausA,1
sublw 1
btfsc _Z
bsf _Finc
movf MausA,0
sublw 2
btfsc _Z
bsf _Fdec
return

=== Handy Display ===

Als Beispiel die Hardware und Testprogram für Nokia 3310/3330 Display: [[http://www.roboternetz.de/phpBB2/viewtopic.php?p=124669#124669]]

= Hilfsmittel =

Hier werden einige Programme presentiert, die das ASM Programmieren erleichtern.
Damit sie möglichst wenig Data- und Programmspeicher benötigen, sind alle Zahlen auf dem Display in der hex Darstellung.
Für alle, die es in Dezimalsystem haben wollen, ist ein Taschenrechner mit hex<->dec Wandlung nötig.

== PIC Miniterminal ==

Das ist eine Schnittstelle, die nur 2 Leitungen zum Anschluss an PIC braucht. Sie ermöglicht Steuern von diversen LCD Displays mit üblichem Anschluss ("RS", "Enable" und 8 Databits) und Abfragen von 3 Tasten.

Sie wird mit einem 2x16 Zeichen Matrixdisplay und 3 Tasten für weiter beschriebene Hilfsprogramme verwendet.

Hardware und Testprogramm: [[http://www.roboternetz.de/phpBB2/viewtopic.php?t=13685]]

[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Category:PIC]]

PIC Assembler

2007-05-05T06:39:13Z

Andy: /* Speicher und Register */

= Einladung zur Diskussion... =

Es wird hier versucht die ASM Programmierung von PIC Mikrocontrollern möglichst kurz zu beschreiben.

Damit der enstehende Artikel wirklich nützlich wird, ist Ihre Mitwirkung nötig. Bitte schreiben Sie uns Ihre Meinung, was eventuell noch geändert (z.B. ergänzt) werden soll in diesem Thread:

http://www.roboternetz.de/phpBB2/viewtopic.php?p=271211#271211

Die Autoren bedanken sich im voraus für jeden Beitrag mit Vorschlägen !

= Einführung =

== Bit, Byte, Nibble, Bin und Hex ==

Ein Mikrocontroller (kurz: µC) kann eigentlich nur durch ein Portpin eine Spannung einlesen bzw. ausgeben. Er kann aber nur erkennen, ob eine Spannung vorhanden ist oder nicht. Wenn fast keine Spannung vorhanden ist erkennt er das als 0 und wenn eine Spannung fast so gross, wie seine Versorgungsspannung anliegt, als 1.

Genauso bei der Ausgabe, wenn er 0 ausgibt ist auf dem Portpin fast keine Spannung, wenn 1, eine Spannung fast gleich gross seiner Versorgungsspannung. Und das ist ein Bit, die kleinste Menge einer Information. Das Bit ist binär, d.h. es kann nur zwei unterschiedliche Werte haben: 0 oder 1.

Wenn wir gleichzeitig (parallel) 8 Bits haben, dann ist es ein Byte, das 256 Bitkombinationen von 00000000b bis 11111111b enhält, weil ein Bit (X) auf jeder Stelle 0 bzw. 1 sein kann.

<table border=0 cellpadding=3 cellspacing=2>

<tr>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
</tr>

<tr>
<td colspan=4 align=middle bgcolor=#007fff>High Nibble </td>
<td colspan=4 align=middle bgcolor=#ff8305>Low Nibble </td>
</tr>
<tr>
<td colspan=8 align=middle bgcolor=#810f40> Byte </td>
</tr>
</table>

Das "b" bedeutet, dass es sich um binäre (kurz: bin) Darstellung (auch Zahl genannt) handelt. Binäre Zahlen sind aber lang, weil jedes Bit eine Stelle benötigt.

Um die Schreibweise zu verkürzen, wurden hexadezimale (kurz: hex) Zahlen eingeführt. Zuerst wurde ein Byte auf zwei 4-Bit Halbbytes (Nibbles) verteilt und danach ein Nibble als Ziffer genommen. Weil 4 Bits 16 Kombinationen ergeben, haben die Ziffer 0 bis 9 aus dem Dezimalsystem (d) nicht ausgereicht und wurden um Buchstaben A bis F erweitert. Die hexadezimalen Zahlen haben ein "h" Zeichen am Ende. Für die Zahlen 0 bis 9 sind die (h) und
(d) Zeichen nicht nötig, da sie beide gleich den entsprechenden bin Zahlen sind.

Die Umwandlung zwischen bin, hex und dec Zahlen für ein Nibble zeigt folgende Tabelle:

0b = 0h = 0d 100b = 4h = 4d 1000b = 8h = 8d 1100b = Ch = 12d
1b = 1h = 1d 101b = 5h = 5d 1001b = 9h = 9d 1101b = Dh = 13d
10b = 2h = 2d 110b = 6h = 6d 1010b = Ah = 10d 1110b = Eh = 14d
11b = 3h = 3d 111b = 7h = 7d 1011b = Bh = 11d 1111b = Fh = 15d

Damit kann ein Byte mit zwei hex Ziffern definiert werden z.B. 1100 0011b = C3h. Für zwei Bytes braucht man 4 hex Ziffern z.B.

101 0111 1010 1001b = 57A9h, u.s.w. Für MPASM wird sehr oft die Schreibweise für hex Zahlen 0x57A9 oder 0xC3 benutzt.

So wie im Dezimalsystem werden führende Nullen nicht geschrieben. Bei einer Wandlung bin->hex fängt man immer von der rechten Seite der bin Zahl an, da die Anzahl führender Nullen unbekannt ist.

== Speicher und Register ==

Als Speicher bezeichnet man das Teil der Hardware, in das eine Information geschrieben, gespeichert und von dort wieder ausgelesen werden kann.

Es gibt eigentlich nur zwei Arten von elektronischen Speichern: flüchtige und nichtflüchtige. Die Information die sich im flüchtigen Speicher befindet, geht verloren, wenn die Versorgungsspannung des Speichers unterbrochen oder abgeschaltet wird. Bei PICs ist es Datenspeicher (RAM).

Wenn die Versorgungsspannung vom nichtflüchtigen Speicher abgeschaltet wird, ist die gespeicherte Information zwar momentan nicht lesbar, bleibt aber erhalten und sobald der Speicher wieder mit Spannung versorgt wird, kann sie ausgelesen werden. Ein PIC hat zwei solche Speicher: Programmspeicher (Flash) und EEPROM.

Der wichtigste Unterschied zwischen den Speicherarten ist, dass die flüchtigen direkt (sehr schnell) beschreibbar sind, dagegen das Beschreiben des nichtflüchtigen Speichers spezielle Algorithmen benötigt, die im Vergleich zu direkten Zugriffen langsamer sind. Beim Auslesen gibt es praktisch keinen Unterschied.

Speicher besitzen eine bestimmte Menge von s.g. Speicherstellen. Jede Speicherstelle hat eine individuelle Adresse und kann eine binäre Information mit bestimmter Anzahl von Bits abspeichern.

PIC Prozessoren haben drei Arten von Speicher, wegen verschiedener Anwendung, auch unterschiedliche Struktur. Die beiden Speicher für Daten (RAM und EEPROM) haben jeweils 8 Bit Breite und Programmspeicher (Flasch) bei Mid-Range hat 14-bitige Speicherstellen. Die Anzahl den Speicherstellen im bestimmten Speicher ist vom PIC-Typ abhängig.

Eine 8-bitige Speicherstelle im RAM wird bei PICs Register genannt und kann so skizziert werden:

<table border=0 cellpadding=3 cellspacing=2>

<tr>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
</tr>

<tr>
<td> MSB </td>
<td colspan=6></td>
<td> LSB </td>
</tr>

<tr>
<td bgcolor="#007fff">bit 7</td>
<td bgcolor="#007fff">bit 6</td>
<td bgcolor="#007fff">bit 5</td>
<td bgcolor="#007fff">bit 4</td>
<td bgcolor="#007fff">bit 3</td>
<td bgcolor="#007fff">bit 2</td>
<td bgcolor="#007fff">bit 1</td>
<td bgcolor="#007fff">bit 0</td>
</tr>

<tr>
<td colspan=4 align=middle bgcolor=#ff8305>High Nibble </td>
<td colspan=4 align=middle bgcolor=#ff8305>Low Nibble </td>
</tr>
<tr>
<td colspan=8 align=middle bgcolor=#810f40> Byte </td>
</tr>
</table>

Bit 7 wird als hochwertigstes (MSB = Most Significant Bit) und bit 0 als niederwertigstes (LSB = Least Significant Bit) bezeichnet. Jedes Bit im Register (X) kann gleich 0 bzw. 1 sein. In einem Register existieren immer 8 Bits also auch führende Nullen. Zum Beispiel die hex Zahl 3 sieht im PIC Register so aus: 00000011.

Um ein Datenbyte in ein Register zu schreiben oder aus einem Register zu lesen, muss zuerst das Register durch seine Adresse gewählt werden. Dafür gibt es beim PIC folgende Möglichkeiten:

Direkte Adressierung per absolute Adresse: movwf 0x20

Direkte Adressierung per vorher definiertem Namen des Registers (z.B. Temp equ 0x20): movwf Temp

Indirekte Adressierung durch "FSR" Register, in das die absolute Adresse des Registers "Temp" eingeschrieben wird. Durch Zugriff mittels "INDF" Register wird auf die Speicherstelle zugegriffen, die durch das Register "FSR" adressiert wird. (INDF ist dabei kein real in Hardware implementiertes Register.) Wie vorher wurde "Temp equ 0x20" definiert und weiter:

movlw Temp ;ins W-Register wird die absolute Adresse des Registers "Temp" geladen
movwf FSR ;diese Adresse wird ins "FSR" Register kopiert
movf INDF,0 ;der Wert aus dem indirekt adressierten Register "Temp"
;wird ins W-Register geladen.

Weil in jedem 14-bittigen Befehl, der mit Datenspeicher verbunden ist, für die Adresse des ansprechenden Registers nur 7 Bits existieren, die bis zur Adresse 7Fh (128d) Register direkt ansprechen können, ist bei PICs der Datenspeicher (RAM) in s.g. Bänke verteilt.

Für Auswahl einer Bank sind zwei Bits "RP0" und "RP1" im "STATUS" Register zuständig. Die Anzahl der Bänke und ihre Verwendung ist von der gesamten Größe des RAMs abhängig und kann dem Datenblatt des PICs entnommen werden. Siehe: [[#Speicherbankorganisation|Speicherbankorganisation]]

== Prozessor ==

Der Prozessor von Mid-Range PICs gehört zu den RISC (Reduced Instruction Set Computer) Prozessoren und man hat nur 35 Befehle zu erlernen, was seine Programmierung im Vergleich zu anderen µCs deutlich vereinfacht. Jeder Befehl benötigt im Programmspeicher nur eine Speicherstelle und im Quellcode nur eine Zeile. Die Ausführung des Befehls dauert, abhängig vom Befehl, 1 bis 2 Prozessortakte.

Die Prozessoren der Mid-Range Serie von Microchip sind alle in der "Harvard"-Architektur gefertigt. Das bedeutet, dass Datenspeicher und Programmspeicher einen eigenen Bus zur CPU (Central Processing Unit) besitzen. Der Vorteil zur "von Neumann"-Architektur ist, dass sich die Busgrößen damit unterscheiden können. Das ermöglicht eine größere Bandbreite.

Der Befehl (beim PIC 14 bit) kann in nur einem Takt verarbeitet werden. Daher kommt auch das Aufteilen der Ausführung des Befehls in 4 verschiedene Vorgänge. Wärend der neue Befehl eingelesen ("fetch") wird, wird der vorige gerade gelesen ("read") und der vorvorige verarbeitet ("execute") und der vorvorvorige schreibt gerade in den Datenspeicher ("write"). Das heißt, 4 Befehle werden jeweils um einen Oszillatortaktzyklus verschoben gleichzeitig verarbeitet.

Das geschieht in vier Perioden des Oszillators. Deswegen entspricht die Taktfrequenz der CPU der durch 4 geteilten Frequenz des Oszillators.

CPU Vorgang Richtung Speicher
------------------------------------------------- -
1.Befehl lesen (fatch) <------- Flash |
2.Daten lesen (read) <------- RAM | 1 Prozessortakt =
3.Daten verarbeiten (execute) | 4 Oszillatortakte
4.Daten schreiben (write) -------> RAM |
-

Nur o.g. CPU Vorgänge sind direkt möglich. Es können deswegen keine Befehle aus dem RAM oder EEPROM ausgeführt werden. Um ein Databyte aus einem RAM Register in ein anderes zu kopieren, muss er zuerst aus dem ersten RAM Register in das W-Register (eigenen s.g. Arbeitsregister des CPU) und erst davon in das zweite RAM Register kopiert werden.

Der Prozessor hat kleinen eigenen Speicher, der weder zum Programmspeicher noch zum Datenspeicher gehört. Er besteht aus dem Programmzähler PC (programm counter) und dem Stapel (stack).

In dem PC befindet sich die 13-Bittige Adresse des momentan ausfürbaren Befehls. Nach der Ausführung jedes Befehls wird der PC um 1 erhöht und "zeigt" somit auf den nächsten Befehl im Programmspeicher, der zum Ausführen wäre. Wenn der nächste Befehl aber ein Sprung ("call") ist, wird die Adresse aus dem Befehl genommen. Nach dem Sprung wird das Programm bis zum Befehl "return" ausgeführt und danach muss der Prozessor zurückspringen, und zwar, genau zur nächsten Adresse im Programmspeicher nach dem "call" Befehl. Damit es möglich wäre, wird vor dem Sprung die Adresse aus dem PC "auf dem Stapel gelegt" (gespeichert). Für den Rücksprung wird die abgelegte Adresse "aus dem Stapel genommen" (vom Stapel in den PC geladen).

Der Stapel kann aber nur 8 Adressen speichern, deswegen dürfen nur 8 nacheinander folgende "call" Befehle benutzt werden. Sonst findet der Prozessor nicht mehr zurück und in die "Nirvana" springt, was einen Absturz des Programms bedeutet.

Das Lesen/Schreiben aus/in den EEPROM Speicher ist mit Hilfe speziellen Register und Unterprogrammen bei allen Mid-Range PICs möglich. Der Lese und Schreibzugriff auf den Programmspeicher ist aber nur bei wenigen PIC-Typen (z.B. PIC16F87X) möglich. Dies ermöglicht ein "sich selbst Programmieren", was bei Bootloadern genutzt wird.

== Assembler ==

Die Maschinensprache, auch Assembler oder kurz ASM genannt, ist eine Sprache die nur eine bestimmte CPU versteht. Für einen Menschen ist sie unverständlich, da sie nur aus 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 einen CPU hat somit ein "Namen", der aus der englischen Sprache stammt. Siehe: [[#Kurzübersicht Assembler Befehle|Kurzübersicht Assembler Befehle]]

Obwohl sie 200 bis 1000 mal schneller als die meisten Hochsprachen ist, wird sie, wegen des grossen Aufwands bei der Erstellung von umfangreichen Programmen, selten benutzt. Man findet sie aber oft in fast allen Hochsprachen, in eigebundenen Funktionen, überall dort wo die Hochsprachen zu langsam sind oder die nötigen Aufgaben nicht unterstützen (z.B. Maus in Q-Basic).

ASM eignet sich sehr gut für kleine Anwendungen (meistens Steuerungen) mit µC, weil nur bei dieser Programmiersprache ein direkter Zusammenhang zwischen einem Bit im Programm und einer Spannung am I/O Pin besteht.

Dank der integrierten oder an Portpins angeschlosenen Hardware und dem entsprechenden Program kann ein µC umfangreiche Aufgaben realisieren, die fast unbegrenzt und schwer vorstellbar sind.

Die Aufgabe eines ASM-Programmierers ist, ein Programm zu schreiben, das das Assemblerprogramm (z.B. MPASM) fehlerfrei in die Machinensprache assembliert ("übersetzt"), die dann eine bestimmte CPU "versteht". Sie endet eigentlich erst dann, wenn das geschriebene Programm so wie geplant funktioniert.

Die beste Methode um ASM Programmierung zu lernen ist einfach mit den Befehlen, wie mit "LEGO" Bausteinen, zu spielen. Der PIC kann durch ein Programmfehler nicht kaputtgehen. Vorsicht ist nur bei der angeschlossener Hardware nötig, da ein Fehler den PIC oder die Hardware sogar "töten" kann.

Weil ASM Programme nicht besonders durchschaubar sind, wurde als Hilfsmittel ein Programmablaufdiagramm (kurz: PAD) erfunden. Bei der 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 [http://gputils.sourceforge.net/ GPASM]) von dem für Menschen noch verständlichen Code in die Maschinensprache assembliert 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 Homepage des Herstellers von PICs [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en019469&part=SW007002] runtergeladen werden. Es muss zuerst vom Downloads die "MPLAB IDE v7.50 Full Zipped Installation" runtergeladen und erst danach können gewählte Programme (z.B. nur MPASM) intalliert werden. Für MPASM benutzer werden auch folgende ".pdf" Dateien empfohlen:

MPASM/MPLINK User's Guide (2628 KB) [Benutzerhandbuch]

MPASM™/MPLINK™ PICmicro® Quick Chart (81 KB) [Kurzübersicht]

Nach dem Eischalten der Betriebsspannung des µC, fängt der CPU an, sich im Programmspeicher befindliches Programm mit dem Befehl, der an der Adresse 0 steht, auszuführen.

Aber wann das Programm endet? Natürlich wenn die Versorgungsspannung abgeschaltet wird. Nein! Das ist die einfachste Lösung um ein laufendes Programm an zufälliger Stelle zu unterbrechen,
aber keine, um es an einer definierten Stelle zu beenden.

Wenn an den µC angeschlossene externe Hardware (z.B. Grafikdisplay), eine bestimmte Befehlsfolge vor dem Abschalten benötigt oder wichtige Daten (in EEPROM oder Flash) abgespeichert werden sollen, darf die Spannung erst dann abgeschaltet werden, wenn die CPU eine Meldung ausgibt, dass sie sich schon auf der "STOP" Stelle des Programms befindet. Es muss auch
definiert werden (z.B. durch eine Tastenkombination), wann die CPU zum letzten Fragment des ASM Programms vor dem "STOP" gehen soll.

== Grundbeschaltung ==

Der Prozessor von einem PIC kann sofort nach dem Einschalten der Versorgungsspannung (z.B. + 5V DC) arbeiten. Allerdings nur, wenn er den Takt, in dem er die Befehle ausführen soll, vorgegeben hat. Manche PICs besitzen einen internen RC-Oszillator, (z.B. PIC12F629, PIC16F630, PIC16F628, u.s.w.). Bei diesen reicht es bereits Spannung anzulegen und sie laufen bereits.
Die meisten haben ihn aber nicht (z.B. PIC16F84, PIC16F870, u.s.w.) und brauchen fürs Funktionieren zusätzliche Bauteile. Grundsätzlich gibt es mehrere Möglichkeiten:

* Quarz oder Keramik-Resonator + 2 Kondensatoren (LP,HS oder XT)
* Keramik-Resonator mit integrierten Kondensatoren (HS oder XT)
* Quarzoszillator (EC); genau und stabil
* Widerstand + Kondensator (RC); keine hohe Frequenzstabilität

Die entsprechenden Bauteile werden an die Pins OSC1/OSC2 angeschlossen, um den notwendigen Prozessortakt zu erzeugen. Im Konfiguration-Word "__config" muss noch angegeben werden, welcher Oszillator verwendet wird.

Desweiteren existiert ein MCLR-Pin, der beim PIC einen Neustart (=Reset) auslösen kann (Low-Pegel). Diesen Pin sollte man, wenn er in "__config" aktiviert ist, über einen Widerstand (pull-up) an Versorgungsspannung legen, damit der PIC anfängt, sein Programm abzuarbeiten. Der Anschluss wird auch für die Programmierung benötigt. Beim sog. High-Voltage-Programming wird MCLR auf ca. 12-14 Volt gelegt, um den PIC in den Programmiermodus zu schalten. Bei manchen PICs kann dieser Anschluss auch als normalen I/O Pin eingestellt werden. In dem Fall, bei ICSP Benutzung, soll noch eine Diode zwischen den pull-up und Versorgungsspannung angeschlossen werden, um die an MCLR Pin angeschlossene Hardware während der Programmierung zu schützen.

Bei externen Oszillatoren bleibt der Pin OSC2 nicht angeschlossen und kann als I/O benutzt werden. Falls ein interner Oszillator benutzt wird, können beide OSC Pins als I/O dienen.

Damit ein Programm zuverlässig ausgeführt werden kann, muss die Versorgungspannung störungsfrei sein. Dafür wird ein Keramik-Vielschicht-Kondensator 100 nF möglichts am kürzesten direkt zwischen VDD und VSS Pins geschaltet.

Folgende Skizzen zeigen die Grundbeschaltung eines PICs:

{|
|-
|
[[Bild:Pic-entstoer.png|thumb|160px|Entstörkondensator beim PIC]]
|
[[Bild:Qz-os.png|thumb|160px|Quarz ]]
|
[[Bild:Qos-os.png|thumb|160px|externer Quarzoszillator]]
|
[[Bild:Rc-os.png|thumb|160px|externer RC-Oszillator]]
|}

== Konfiguration ==

Die Konfiguration eines PICs wird beim "brennen" fest programmiert. Sie ist eigentlich für fast jeden PIC-Typ anders. Um Probleme zu vermeinden, muss sie für bestimmten PIC aus einer im MPASM Verzeichnis enthaltenen Datei "PXXFXX.INC" entnommen werden. Die Erklärung der Optionen befindet sich im entsprechenden Datenblatt unter "Special Features of the CPU"

Als Beispiel für PIC16F84 haben wir in der Datei "P16F84.INC":

;==========================================================================
;
; Configuration Bits
;
;==========================================================================

_CP_ON EQU H'000F'
_CP_OFF EQU H'3FFF'
_PWRTE_ON EQU H'3FF7'
_PWRTE_OFF EQU H'3FFF'
_WDT_ON EQU H'3FFF'
_WDT_OFF EQU H'3FFB'
_LP_OSC EQU H'3FFC'
_XT_OSC EQU H'3FFD'
_HS_OSC EQU H'3FFE'
_RC_OSC EQU H'3FFF'

Wobei:

_CP_ON - Programmspeicher ist vorm Auslesen geschützt
_CP_OFF - Programmspeicher kann ausgelesen werden (ist nicht geschützt)
_PWRTE_ON - Das Programm wird mit Verzögerung von ca. 72 ms nach dem Einschalten gestartet
_PWRTE_OFF - Das Program wird sofort nach dem Einschalten gestartet
_WDT_ON - Watchdog Timer ist aktiv
_WDT_OFF - Watchdog Timer ist unaktiv

Die alle folgende Optionen beziehen sich an den Oszillatortyp:

_LP_OSC - Oszillator bis ca. 200 kHz (z.B. Uhrenquarz 32768 Hz)
_XT_OSC - Oszillator bis ca. 3,5 MHz
_HS_OSC - Oszillator über 3,5 MHz (z.B. 4 MHz)
_RC_OSC - Externer RC Oszillator

Die Konfiguration wird im Quellcode (*.asm Datei) mit Direktive "__config" definiert, z.B. so:

__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _XT_OSC

Alle Optionen müssen groß geschrieben sein, genauso wie in der "*.inc" Datei.

== Wahl des PICs ==

Es gibt PIC µC die in der Typenbezeichnung den Buchstaben "C" oder "F" haben.

Die älteren mit "C" haben EPROM Programmspeicher und die gibt es in zwei Versionen: ohne und mit Fenster (aus Quarz-Glass) fürs Löschen des EPROMs mit UV Strahlung. Bei denen ohne Fenster kann der Programmspeicher nur einmal beschrieben und nicht mehr gelöscht werden.

Die neuen mit "F" besitzen einen Flash-Programmspeicher, der bis zu 100 000 mal mit angelegter Spannung gelöscht und danach neu beschrieben werden kann.

Für die Wahl eines PICs für bestimmte Anwendung wichtig sind:

- Max. Taktfrequenz des Prozessors.

- Grösse des Datenspeichers (für Variablen).

- Grösse des Programmspeichers (für Programm).

- Integrierte Hardware (Komparatoren, A/D Wandler, Timer, USART, I²C, SPI, PWM, u.s.w.).

- Freie I/O Pins für externe Hardware (Display, Tasten, u.s.w.).

- Vorhandene Betriebspannung (Netzteil, Akku, Batterie).

In der Praxis wird meistens für die Programmerstellung ein grösserer PIC genommen (wenn möglich pinkompatibler z.B. PIC16F628 für PIC16F84 oder PIC16F630 für PIC12F629) und erst nach der Optimierung des lauffägiges Programms, der tatsächlich nötige, da seine Parameter am Anfang nur geschätzt werden können. Wenn man viele Programme für verschiedene PICs entwickelt, wäre der größte PIC16F877 mit 20 MHz max. Taktfrequenz optimal.

Diese Lösung hat auch den Vorteil, dass während der Programmerstellung kurze Hilfsprogramme (z.B. PIC Trainer) in den Programmspeicher kopiert und benutzt werden können, da sie sowohl ein bischen Programmspeicher und RAM als auch 2 freie I/O Pins fürs PIC Miniterminal brauchen.

= Programm =

== Allgemeines ==

Jedes Program kann man in kleinere Fragmente unterteilen, die auf bestimmte Weise miteinander verknüpft sind und gemeinsam die Aufgabe des Programms erfüllen. Das wichtigste Teil eines Programms ist das s.g. Hautprogram (kurz:HP), das eine führende Rolle spielt. Dem HP sind fast 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 komplizierter, da ein UP auch ein oder mehrere UPs nacheinander aufrufen kann. Ganz unten sind die UP1s, die ganz einfache Sachen erledigen. Höher ist 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 ohne Tricks maximal bis zu 8 Ebenen benutzt werden, da auf dem Stapel (stack) nur max. 8 Rücksprungadressen abgespeichert werden können. Siehe hierzu: [[#Prozessor|Prozessor]] und [[#Programmspeicher|Programmspeicher]]

<center>
[[Bild:HP-UP.png|Hauptprogramm - Unterprogramm]]
</center>

Jedes UP kann jederzeit aufgerufen werden, je nach dem was gerade eledigt werden muss. Weil das nicht egal ist, welches UP aufgerufen wird, da jedes nur eine bestimmte Funktion im Programm hat, muss der Programmierer dafür sorgen, dass alles richtig nach Programablaufdiagramm, und nicht chaotisch, abläuft.

Die Programmierung in ASM ist ähnlich 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 Programm kopieren oder einbinden und ein geeignetes HP, das sie aufruft, schreiben.

Ein ASM Programm (Quellcode) muss in einer Texdatei mit der Endung ".asm" in der vom Assemblerprogramm erwarteten Form verfasst werden, um die fehlerfreie Konvertierung in die Maschinensprache (Assemblierung) zu gewährleisten. Dieser Prozess verläuft in der Form eines Dialoges.

Der Programmierer schreibt und gibt es dem Assemblerprogramm zum Übersetzen. Alles was der Assembler nicht versteht oder nicht richtig ist, erscheint als Fehlermeldungen, die der Programmierer kennen muss, um die Fehler korrigieren zu können. Eine ".hex" Datei wird erst dannn erstellt, wenn das Assemblerprogramm keine Fehler mehr im Quellcode findet. Deswegen ist es sehr wichtig, sich mit dem Assemblerprogramm vertraut zu machen, um die Dialogzeit zu minimieren.

== Programmdurchlaufdiagramm ==

Der Programdurchlaufdiagram (kurz: PAD) ist eine vorläufige und laufend änderbare Stufe zwischen einer Idee und ihrer Verwirklichung. Die Kreativität des Programmierers ist nur für die Erstellung des PADs nötig. Jedes sein Symbol (ausser "Start/Stop") muss als Befehlsreihenfolge für einen bestimmten Prozessor in den Quellcode übertragen werden. Das ist aber nur reine "Übersetzung". Der Quellcode ist nur eine andere Form des PADs und hoffentlich wird es zukünftig Komputerprogramme geben, die ein PAD direkt in eine "*.hex" Datei für bestimmten Prozessor wandeln werden. Zur Zeit muss die "Übersetzung" leider vom Programmierer gemacht werden. Der PAD wird erst dann fertig, wenn nach ihm erstelltes ASM Program auf einem µC so wie gewünscht funktioniert.

Die Anschriften "Ein" und "Aus" gehören nicht zu Symbolen des PADs und wurden nur zur Erklärung benutzt.

[[Bild:PAD_beispiel.png|thumb|80px|Beispiel für ein PAD]]

Der PAD ist sehr eifach zu erstellen, weil dafür nur drei Symbole benötigt sind:
<center>
[[Bild:PAD_kurz.png|Symbole des PAD]]
</center>
Das "Start/Stopp" Symbol bedeutet, dass das gesamte Programm sich im stabilen Zustand befindet und nicht "läuft". Anstatt "Stopp" kann auch "Schlaf" (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 eines Programms, endweder in der "ja" (J) oder "nein" (N) Richtung.

Als allgemeinnutziges Standard für µCs kann man folgender PAD bezeichnen:

PAD _____
/ \
Spannung ein (Ein) ----->( Start )
\_____/
| -
V |
.---------------. |
|Initialisierung| |
'---------------' |
| |
.--------->V |
| .---------------. |
| | Hauptprogramm | |
| '---------------' |
| | |
| V |
| A |
| / \ > Gesamtes Programm
| / \ |
| /Ende \____ |
| \ ? / J | |
| \ / | |
| \ / | |
| V | |
| N| | |
`----------´ | |
V |
.---------------. |
| Beenden | |
'---------------' |
| |
V -
_____
/ \
Spannung aus (Aus) <-------------( Stopp )
\_____/

Das Hauptprogram wird in einer endlosen Schleife ausgeführt, die durch die Prüfung "Ende?" unterbrochen werden kann. In dem Fall wird vor dem Beenden des gesammten Programms noch ein UP "Beenden" ausgeführt, das z.B. Daten im EEPROM speichert.

Es ist nicht nötig, immer die Symbole zu zeichnen, man kann sie sich vorstellen und nur den Text schreiben. Die Prüfungen werden mit "?" gekenzeichnet und die Zeichen "V", "A", "<" und ">" zeigen die Richtung des weiteren Verlaufs. Dann sieht der PAD so aus:

Ein > Start
V -
Initialisierung |
.------->V |
| Hauptprogramm > Gesamtes Programm
| V |
| Ende? J > Beenden |
| N V -
| V Stopp > Aus
`--------´

Man kann auch die unbedeutenden Richtungspfeilen weg lassen:

PAD1 Ein > Start _
Initialisierung |
.------->V | Gesamtes
| Hauptprogramm | Programm
| Ende? J > Beenden _|
| N Stopp
| V V
`--------´ Aus

In der Praxis werden aus Platzgründen meistens die vereinfachten PADs benutzt. Als "movxx" wird oft ein Zeichen "->" benutzt. Zum Beispiel "A->W" bedeutet, dass der Inhalt des A Registers ins W-Register geladen (kopiert) wird. Ausserdem werden Zeichen ("+", "-", "*", "/", "^", u.s.w.) für arithmetische und ("&", "or", "xor", u.s.w.) für logische Operationen angewendet. In den Quellcode werden für diese Zeichen entsprechende Befehle geschrieben. Beispiel:

V
10h->W
W+B->B
V

wird im Quelcode so aussehen:

...........
movlw 10h
addwf B,1
...........

Siehe auch: [[#Das erste...|Das erste...]] und [[#Mausrad|Mausrad]]

Der PAD1 kann aber für Hauptprogramme, die in beliebigem Moment unterbrochen werden dürfen, deutlich vereinfacht werden, da die Prüfung "Ende?" ob das Hauptprogram beendet werden soll, und das UP "Beenden", entfallen.

Die meisten ASM Programme für µC sind deswegen nach solchem PAD erstellt:

PAD2 Ein > Start _
Initialisierung |
.------->V |
| Hauptprogramm > Gesamtes Programm
| V |
`--------´ _|

Für Testprogramme wird meistens fogender PAD angewendet, weil es ziemlich einfach festzustellen
ist (z.B. durch Stromverbrauchmessung des µCs), wann sich die CPU schon im Schlaf befindet. Erst dann, darf die Betriebspannung des µCs ausgeschaltet werden.

PAD3 Ein > Start _
Initialisierung | Gesamtes
Hauptprogramm _| Programm
Schlaf > Aus

Und eine batteriebetriebene Uhr wird überwiegend so gestaltet:

PAD4 Ein > Start _
Interrupt Initialisierung |
Timer------------------------->V > Gesamtes Programm
Hauptprogramm _|
Schlaf

In dem Fall reicht es aus, wenn der CPU jede Minute vom Timer aufgeweckt wird, um die Zeit zu aktualisieren. Eine Uhr ist immer (ausser Batteriewechsel) ununterbrochen mit Spannung versorgt.

Für komplizierte Programme ist es praktisch unmöglich ein PAD zu erstellen, in dem jeder CPU Befehl sein eigenes Symbol hat. Man beschränkt sich nur auf alle Prüfungen, die über den Lauf des Programms entscheiden, und ganze UPs (z.B. "Initialisierung") nur als ein Symbol verwendet. Für jedes UP wird dann ein eigener PAD erstellt.

Das Erstellen von PAD bei ASM Programmen ist sehr wichtig und darf nicht unterschätzt werden. Je stärker ein Programmierer glaubt, dass er das ohne PAD schafft, um so mehr Zeit wird er danach bei Fehlersuche oder Änderungen im ASM Programm verlieren.

Beispiel aus dem Alltag:

"Das programm hat anfangs auf Anhieb funktioniert. Doch leider habe ich dann was geändert was ich nicht mehr weiß. Das Programm macht nun komische Sachen...... Ich kann mir nicht erklären warum, kann mir jemand helfen???"

Für einfache ASM Programme, die gut kommentiert sind, reicht es meistens aus, ein PAD nur "im Kopf" zu erstellen, aber ganz ohne PAD geht es sicher nicht.

Der PAD kann auch benutzt werden, um einen "fremden" Code verständlich zu machen. In dem Fall werden alle Befehle (Zeilen) aus der Quellcode nacheinander in PAD Symbole umgewandelt und daraus ein PAD erstellt.

== Hauptprogramm ==

Wie sein Namen schon vermuten lässt, ist das Hauptprogram das wichtigste Teil des gesamten Programms. Meistens ist es auch das kleinste Teil, vor allem, wenn die UPs sehr komplex sind. Seine Aufgabe ist die benötigte UPs in bestimmter Reihenfolge nacheinander aufzurufen, um die alle Funktionen des gesamten Programms zu realisieren.

Das HP ist meistens als endlose Schleife, wie im PAD2, aufgebaut. Weil die endlose Schleife sehr schnell läuft, werden alle durch die UPS realisierten Aufgaben quasi gleichzeitig ausgeführt. Wenn es unerwünscht ist, müssen einige UPs als Verzögerungen realisiert werden.

Typischer PAD für ein HP sieht so aus:

Haupt .--->V
| UP1
| UP2
| ...
| UPn
| V
`----´

In den Quellcode wird es so eigeschrieben:

Haupt call UP1
call UP2
...........
call UPn
goto Haupt

In der Praxis wird das HP schrittweise erstellt. Am Anfang wird sich nur ein Aufruf vom UP im HP befinden und die folgenden kommen nach Erstellung und Prüfen weiteren UPs dazu, bis das HP fertig wird.

== Unterprogramm ==

Unterprogramm wird durch übergeordnetes Programmteil (Aufrufer) aufgerufen und nach seinem Ausführen, wird zurück zum Aufrufer gesprungen. Der Rückkehr zum Aufrufer wird durch "return" Befehl, der sich am Ende jedes UPs befinden muss, erreicht. Und das ist der einzige Unterschied zwischen einem HP und einem UP.

Jedes UP hat folgender PAD:

vom Aufrufer ------------>V
Tun
V
zurück zum Aufrufer <----------return

Ein HP von einem ASM Programm kann in anderem, mehr umfangreichem ASM Program als UP benutzt werden, wenn der sich am Ende des HPs befindlicher Befehl "goto" durch "return" ersetzt wird. Ein Beispiel dazu:

Haupt1 call UP11 Haupt1 call UP11
call UP21 call UP21
........... -------> ...........
call UPn1 call UPn1
goto Haupt1 return

Jetzt können wir im mehr komplexen HP (Haupt) das Haupt1 als Unterprogramm aufrufen:

Haupt call UP1
call Haupt1
...........
call UPn
goto Haupt

Jedes UP kann auch von einem anderen übergeordneten UP aufgerufen werden, wenn das was es realisiert, benötigt wird.

In der Praxis wird oft ein UP von mehreren anderen UPs benutzt. Zum Beispiel um LCD Display zu steuern, brauchen wir entweder ein Befehl (Cmd) oder ein Zeichen (Data) an Display zu schicken. In beiden Fällen wird ein Byte geschickt, einmal mit RS=0 (Befehl) und einmal mit RS=1 (Zeichen) laut folgendem PAD:

"Cmd" "Data"
RS=0 RS=1
V V
`-->V<--´
"Send" Byte schicken
V
return

Das wird in den Quellcode z.B. so eingeschrieben:

Cmd bcf RS
goto Send
Data bsf RS
Send ............
return

Das UP "Send" ist den UPs "Cmd" und "Data" untergeordnet, da es von beiden benutzt wird, kann aber weder "Cmd" noch "Data" benutzen.

=== Initialisierung ===

Damit der PIC ein Programm asführen kann, muss er vollständig und richtig initialisiert werden. Deswegen als erstes UP, das von dem gesamten Programm noch vor dem HP aufgerufen wird , ist "Initialisierung" (kurz: Init)

==== Variablen ====

Weil sich nach dem Einschalten der Spannung im RAM zufällige Werte befinden, wird meistens als erstes der benutzte Bereich des RAMs (z.B. 20h bis 7Fh) gelöscht. Es wird einfach und sparsam mit einer Schleife erledigt, die indirekte Adressierung verwendet:

V
Adresse des ersten Registers in FSR laden (20h)
.-------------------->V
RAMClr |Indirekt adressierter Register löschen (INDF)
| Adresse erhöhen
| Letzte Adresse + 1 (80h) J > Return
| N
| V
`---------------------´

Es wird wie folgt in Quellcode eingeschrieben:

movlw 0x20
movwf FSR
RAMClr ,->clrf INDF
| incf FSR,1
| btfss FSR,7
`-<goto RAMClr
return

Um Anzahl den Marken (label) zu verringern, wird oft ein Symbol "$" benutzt. Es bedeutet die Adresse der aktuellen Befehlszeile. Es kann also auch so eingeschrieben werden:

movlw 0x20
movwf FSR
,->clrf INDF
| incf FSR,1
| btfss FSR,7
`-<goto $-3 ; springe zu aktueller Adresse -3
return

Danach können den benötigtenen Variablen die gewünschte Werte zugewiesen werden:

movlw 0x3C
movwf LimH
movlw 0x5A
movwf LimL
u.s.w.

Somit sind die Variablen initialisiert.

==== I/O Ports ====

Nach dem Einschalten der Spannung sind die für Komparatoren oder A/D Wandler benutzte Pins als analoge Eingänge initialisiert. Wenn sie alle als digitale I/Os verwendet werden sollen, müssen sie als solche definiert werden. Das geschieht durch Schreiben des Wertes 7 in das entsprechende Register (CMCON bzw. ADCON1):

movlw 7 b.z.w. movlw 7
movwf CMCON movwf ADCON1

Wenn einige als analoge Eingänge benutzt werden sollen, müssen die entsprechende Werte dem Datenblatt des jeweiligen PICs entnommen werden.

Danach werden alle Ports nacheinander gelöscht und die gewünschte Werte die an den Pins vor dem Start des Hauptprogramms ausgegeben werden sollen, geschrieben:

clrf PORTA
movlw 0x37
movwf PORTA
usw.

Anchliessend werden für jeden Port die Werte in TRIS Register eingeschrieben, wobei ein Bit einem Pin entspricht. Ein Pin wird in TRIS Register durch 1 als Eingang und durch 0 als Ausgang definiert. Beispielweise beim PORTB sollen B7,B5 und B3 als Eingänge und restliche Pins als Ausgänge definiert werden. Das ergibt den Wert 10101000b = A8h, der in den TRISB Register geschrieben werden muss. Weil die alle TRIS Register sich in der höheren Bank befinden, muss im STATUS-Register auf entsprechende Bank und danach zurück auf Bank 0 umgeschaltet werden. Zum Beispiel für die TRASB in der Bank1:

bsf STATUS,RP0
movlw 0xA8
movwf TRISB
bcf STATUS,RP0

Bei einem Umschalten der Bank können selbstverständlich alle TRIS Register, die in der gleichen Bank liegen, nacheinander beschrieben werden. Siehe : [[#PORTx|PORTx]] und [[#TRISx|TRISx]]

Bei dem PORTA gibt es Pins, die nur "open drain" Ausgang haben (können nur auf GND schalten) b.z.w. nur als Eingang benutzt werden können. Bei Plannung der Verwendung von PORTA muss immer im Datenblatt geprüft werden, ob sich ein bestimmter Pin für die geplannte Anwendung eignet.

==== Hardware ====

Die für ASM Programm benutzte Hardware kann auf integrierte und externe geteilt werden. Für eine Initialisierung der integrierten Hardware (Komparatoren, A/D Wandler, Timer, USART, I²C, SPI, PWM, u.s.w.), müssen entsprechende SFRs (Spezial Function Registers) laut Datenblatt des PICs definiert werden.

Die externe Hardware muss nach Datenblättern der Herstellern initialisiert werden.

=== Einlesen ===

Um ein Bit von einem Portpin einzulesen und in ein bestimmtes Register zu Kopieren wird folgender PAD benutzt, weil ein PIC kein Befehl dafür hat:

V
Bit im Zielregister löschen
Quellbit = 0 ? J >------.
N |
V |
Bit im Zielregister setzen |
V<-------------´

Wenn wir z.B. ein bit3 von PortA als bit1 in den Register Tasten kopieren wollen, dann wird es in Quellcode so geschrieben:

bcf Tasten,1
btfsc PORTA,3
bsf Tasten,1

Wenn ein ganzes Byte vom Port in das W-Register eingelesen wird, kann man den Wert gleich komplett in das Zielregister schreiben:

movf PORTA,0
movwf Tasten

=== Ausgeben ===

Um ein Bit an einem Portpin auszugeben wird ein bestimmtes Bit mit "bcf" gelöscht oder mit "bsf" gesetzt. Zum Beispiel bit4 im PORTA:

bcf PORTA,4.

Um ein Byte auszugeben wird es zuerst in das W-Register geladen und danach an den Port übergeben, z.B.:

movlw 0x12
movwf PORTA

=== Schleifen ===

Ein in ASM Programmen meist verbreitetes Codefragment ist eine Schleife.

Es kann eine endlose Schleife, die durch Prüfung einer bestimmten Bedingung (z.B. Taste) unterbrochen wird, sein:

V<-----.
Tun |
? N >--´
J
V
weiter

Es kann eine Schleife mit Schleifenzähler (z.B. Temp), die bestimmte Anzahl Durchläufe hat, sein:

V
Anzahl ins Temp laden
V<---------.
Tun |
Temp decrementieren |
Temp = 0 ? N >--´
J
V
weiter

Solche Schleifen können als UPs verwendet werden, wenn "weiter" mit "return" ersetzt wird.

Das waren Beispiele für Schleifen, die bewusst programmiert sind. Es gibt leider auch endlose Schleifen, die durch einen Fehler im Programm enstanden sind und zum "hängen" des Programms führen. Solche Schleifen sind im Programm nicht einfach zu finden, da ihre Parameter unbekannt sind.

=== Pause ===

Um eine Pause (Warten, Verzögerung) im Programm anzulegen wird der "nop" Befehl benutzt, während dessen Ausführung der CPU nichts macht. Mit einem "nop" kann eine Zeit gleich 4 Takten (Perioden) des Oszillators realisiert werden.

Für sehr kurze Wartezeiten benutzt man eine Reihe von nachfolgenden "nop"s. Beim einem Oszillator 4 MHz, die Ausführungszeit des Prozessors beträgt 1 µs pro "nop". Wenn z.B. 4 µs benötigt werden, werden dafür 4 "nop"s gebraucht:

...
nop
nop
nop
nop
...

Das gleiche bewirken 2 "goto"s, brauchen aber im Vergleich zu "nop"s nur die Hälfte der Bytes im Programmspeicher:

...
goto $+1
goto $+1
...

Der Befehl goto $+1 bedeutet "springe zur aktuellen Adresse + 1" (also nächster Adresse) und seine Ausführungszeit ist gleich 2 Prozessortakten.

Für kurze Zeiten werden s.g. Warteschleifen, wie im folgendem PAD benutzt:

V
n * nop
P0 laden
V<---------.
P0 decrementieren |
P0 = 0 ? N >--´
J
V

In Quellcode wird es als UP so eigeschrieben:

Warte nop Warte nop
... ...
nop nop
movlw 0xXX movlw 0xXX
movwf P0 movwf P0
Warte0 decfsz P0,1 decfsz P0,1
goto Warte0 goto $-1
return return

Der Sprung zur Marke "Warte0" ("goto Warte0") wurde in rechtem Beispiel durch "goto $-1" ersetzt.

Die gesammte Anzahl den CPU Takten (N) lässt sich aus folgender Formel berechnen:

N = 3 * P0 + 6 + n

und die Wartezeit (T) in Sekunden:

T = N * ( 4 / Fosc ), für Schätzungen T ~ 3 * P0 * ( 4 / Fosc )

Wobei:

P0 = Zahl im Register P0, 6 = Ausführungszeit von "call" (2) + "movlw" (1) + "movwf" (1) + "return" (2), n = Anzahl "nop"s, Fosc = Frequenz des Oszillators (z.B. Quartz)

Wenn in ein Register PX eine 0 eingeschrieben wird, bedeutet es, dass die decrementierung des Registers 100h = 256d Takten dauern wird, da dekrementierte 0 eine FFh = 255d ergibt. Deshalb in Warteschleifen ist die Zahl 0 die grösste (256 Dürchläufe) und 1 die kleinste. Für solche einfache Schleifen (als UP) die Wartezeit beträgt min. 9 und max. ca. 800 Prozessortakten (ohne "nop"s).

Für mittlere Wartezeiten z.B. 0,1 Sekunde werden doppelte Warteschleifen verwendet:

Warte V
n * nop
P1 laden
Warte1 V<-------------.
P0 laden |
Warte0 V<---------. |
P0 decrementieren | |
P0 = 0 ? N >--´ |
J |
V |
P1 dekrementieren |
P1 = 0 ? N >------´
J
V

Das wird in Quellcode als UP so aussehen:

Warte nop Warte nop
... ...
nop nop
movlw 0xXX movlw 0xXX
movwf P1 movwf P1
Warte1 movlw 0xXX movlw 0xXX
movwf P0 movwf P0
Warte0 decfsz P0,1 decfsz P0,1
goto Warte0 goto $-1
decfsz P1,1 decfsz P1,1
goto Warte1 goto $-5
return return

Wie vorher wurden rechts die Marken durch "$-n" ersetzt.

Die gesammte Anzahl den CPU Takten (N) lässt sich aus folgender Formel berechnen:

N = P1 * (3 * P0 + 5) + 8 + n

und die Wartezeit (T) in Sekunden:

T = N * ( 4 / Fosc ), für Schätzungen T ~ 3 * P1 * P0 * ( 4 / Fosc )

Wobei:

P0 = Zahl im Register P0, P1 = Zahl im Register P1, 8 = Ausführungszeit von "call" + "return" + 2 * ("movlw" + "movwf"), n = Anzahl "nop"s, Fosc = Frequenz des Oszillators (z.B. Quartz)

Für solche doppelte Schleifen (als UP) die Wartezeit beträgt min. 16 und max. ca. 200 000 Prozessortakten (ohne "nop"s).

Für lange Wartezeiten z.B. 1 Sekunde werden 3-fache Warteschleifen angewendet.

Solche Warteschleife ist im folgenden PAD abgebildet:

Warte V
n * nop
P2 laden
Warte2 V<-----------------.
P1 laden |
Warte1 V<-------------. |
P0 laden | |
Warte0 V<---------. | |
P0 decrementieren | | |
P0 = 0 ? N >--´ | |
J | |
V | |
P1 decrementieren | |
P1 = 0 ? N >------´ |
J |
V |
P2 dekrementieren |
P2 = 0 ? N >----------´
J
V

Das wird in Quellcode als UP so aussehen:

Warte nop Warte nop
... ...
nop nop
movlw 0xXX movlw 0xXX
movwf P2 movwf P2
Warte2 movlw 0xXX movlw 0xXX
movwf P1 movwf P1
Warte1 movlw 0xXX movlw 0xXX
movwf P0 movwf P0
Warte0 decfsz P0,1 decfsz P0,1
goto Warte0 goto $-1
decfsz P1,1 decfsz P1,1
goto Warte1 goto $-5
decfsz P2,1 decfsz P2,1
goto Warte2 goto $-9
return return

Auch hier wurden rechts die Marken durch "$-n" ersetzt.

Die gesammte Anzahl den CPU Takten (N) lässt sich aus folgender Formel berechnen:

N = P2 * [ P1 * (3 * P0 + 5) + 9 ] + 10 + n

und die Wartezeit (T) in Sekunden:

T = N * ( 4 / Fosc ), für Schätzungen T ~ 3 * P2 * P1 * P0 * ( 4 / Fosc )

Wobei:

P0 = Zahl im Register P0, P1 = Zahl im Register P1, P2 = Zahl im Register P2, 10 = Ausführungszeit von "call" + "return" + 3 * ("movlw" + "movwf"), n = Anzahl "nop"s, Fosc = Frequenz des Oszillators (z.B. Quartz)

Für solche 3-fache Schleifen (als UP) die Wartezeit beträgt min. 27 und max. ca. 50 000 000 Prozessortakten (ohne "nop"s).

Die "nop"s vor allen Warteschleifen sind nur notwendig um genaue Wartezeit einzustellen zu können. Sie können auch mit "goto $+1"s ersetzt, oder weg gelassen werden. Sie können auch innerhalb jeder Schleife eingesetzt werden, um sie deutlich zu verlängern.

Ein Beispiel:

V
n * nop
P0 laden
V<---------.
n0 * nop
P0 decrementieren |
P0 = 0 ? N >--´
J
V

Bei nur einem "nop" (n0=1) ist die max. Wartezeit ca. T ~ 4 * P0 * ( 4 / Fosc ), bei zwei (n0=2) ca. T ~ 5 * P0 * ( 4 / Fosc ) u.s.w.

Anstatt "movlw 0xXX" kann auch "movf PauseX,0" angewendet werden, wenn die Schleife mehrmals mit verschiedenen Werten P0, P1 und P2 aus den Register Pause0, Pause1 und Pause2 benutzt wird.

Für sehr lange Wartezeiten können, nach gleichem Prinzip, Warteschleifen erstellt werden, die mehr als 3 Schleifen enthalten.

=== Tabellen ===

Es gibt zwei Arten von Tabellen: Sprungtabellen (computed goto) die "goto" Befehle enthalten und Wertetabellen (lookup table) in denen feste Werte in "retlw" gespeichert sind. Der wichtigste Unterschied zwischen dennen ist, dass die Sprungtabellen steuern den Programlauf abhängig vom Inhalt des W-Registers und die Wertetabellen liefern abhängig von Inhalt des W-Registers ein Wert an den Aufrufer zurück.

Beide werden in Programmspeicher erstellt. Sie können nur bis zu 256 Speicherstellen belegen, da in den W-Register auch nur so viel veschiedenen Zahlen "passen". Sie Fangen also (fast) immer bei einer Adresse XX00h an und enden bei XXFFh. Der Hochwertige Byte "XX" der Adresse an der sich der Anfang einer Tabelle befindet, muss vor dem Einsprung in die Tabelle ins PCLATH Register eingeschrieben werden, wenn die Tabelle weit vom Aufrufer liegt. In der Praxis werden solche Tabellen am oberen Ende des Programmspeichers angelegt, damit sie den ASM Code nicht unterbrechen.

Eine Sprungtabelle wird so aufgebaut:

org (XX-1)FF <--- eine Direktive für Assemblerprogramm, wo es
die Tabelle im Programmspeicher plazieren soll
Adresse Inhalt
-------------------------
Tab1 (XX-1)FF addwf PCL,1
XX00 goto Marke0
XX01 goto Marke1
.......................
XXFE goto Marke254
XXFF goto Marke255

Und so aufgerufen:

movlw 0xXX
movwf PCLATH
movf TWert,0
call Tab1

Wobei:

0xXX = Hochwertiger Byte der Adresse von Tab1, TWert = ein Wert, der die Wahl wohin gesprungen wird bestimmt.

Nach ausführen der obiger Befehlsfolge, wird das ASM Programm z.B. für Twert=0x01 weiter ab Marke1 "laufen" bis es an "return" kommt. Dann springt es zurüch zum Aufrufer der Tabelle.

Eine Wertetabelle wird so aufgebaut:

org (XX-1)FF <--- eine Direktive für Assemblerprogramm, wo es
die Tabelle im Programmspeicher plazieren soll
Adresse Inhalt
-------------------------
Tab1 (XX-1)FF addwf PCL,1
XX00 retlw Wert0
XX01 retlw Wert1
.......................
XXFE retlw Wert254
XXFF retlw Wert255

Und so aufgerufen:

movlw 0xXX
movwf PCLATH
movf TWert,0
call Tab1

wobei:

0xXX = Hochwertiger Byte der Adresse von Tab1, TWert = ein Wert, für welchen, an den Aufrufer bestimmter Wert aus der Tabelle im W-Register zurückgeliefert wird

Wertetabelle kann auch mit Hilfe der MPASM Direktive "dt" erstellt werden. So kann man sich mehrfaches Schreiben von "retlw" Befehlen ersparen:

org 0x(XX-1)FF
Tabelle addwf PCL,1
; nachfolgend der benötigte Wert im W- Register
; vor dem Aufruf der Tabelle
dt 0x03, 0xE8 ; 0x00
dt 0x03, 0xE8 ; 0x02
dt 'M','H','z',0x00 ; 0x04
dt ' ',' ','W','A','I','T',0x00 ; 0x08
dt 'C','o','n','s','t',' ','X',0x00 ; 0x0F
dt 'C','=',0x00 ; 0x17
dt 'L','=',0x00 ; 0x1A
dt 'F','=',0x00 ; 0x1D
dt 'O','K',0x00 ; 0x20
u.s.w.

Das Lesen eines Strings muss ab entsprechendem Wert im W-Register (z.B. für "MHz" -> 0x04) anfangen und auf dem Wert 0x00 enden, der hier als Stringende dient. Einfacher ist, wenn alle Strings gleich lang sind (wie z.B. in einem Zeichengenerator fur Grafikdisplay).

=== Interrupt ===

==== Prinzip ====

Ein Interrupt (Unterbrechung) unterbricht ein laufendes Programms, wenn ein bestimmtes Ereigniss, auf das reagiert werden soll, statt gefunden hat. Die Reaktion wird in s.g. Interrupt Service Routine (kurz: ISR) definiert.

Einfach gesagt, ein Interrupt stoppt ein laufendes Programm, ruft die ISR auf und nach deren Ausführung startet das Programm wieder, ab der Zeile, vor der es durch Interrupt angehalten wurde.

.--->V
| Tun
| V
Interrupt ------>Tun-------->V
| V ISR
| Tun<--------´
| V
| Tun
| V
`----´

Damit das unterbrochene Programm nach dem Rückkehr aus der ISR weiter fehlerfrei ausgeführt werden kann, darf die ISR keine Änderungen im Programm verursachen.

Um ein Interrupt auslösen zu können, muss er in UP "Init", durch beschreiben nötigen Register (INTCON, PIR, u.s.w.) vorbereitet werden. Siehe hierzu: [[#INTCON|INTCON]] und [[#Interrupts|Interrupts]]

==== Quellen ====

Es gibt folgende Interrupt-Quellen:

- interne Hardware (z.B. ein Timer)

- externe Hardware (z.B. eine Taste)

Die alle PICs der Mid-Range Familie haben im Programmspeicher nur eine Adresse (s.g. Interrupt Vektor 0x0004), wohin im Falle eines Interrupts, gesprungen wird. Um ermöglichen den Verursacher des Interrupts zu finden, hat jede Quelle ein eigenes Interrupt Flag (IF), das gesetzt wird, wenn das Interrupt ausgelöst wird. Somit kann in der ISR nach der Prüfung der IFs auf jeden Interrupt gezielt reagiert werden.

==== Interrupt Service Routine ====

Die Interrupt Service Routine ist ein besonderes UP das immer an der Adresse 0x0004 beginnt und immer mit dem Befehl "retfie" endet. Ihr Umfang ist von der Menge der Quellen und der Reaktionen auf ihre Interrupts abhängig. Folgender PAD zeigt ein allgemeiner Aufbau der ISR:

Adresse 0x0004 Interrupts sperren ; bcf INTCON,GIE
Beeinflüsste Register sichern
Interrupt-Quelle ermitteln
Interrupt-Flag löschen
und entsprechend reagieren
Beeinflüsste Register restaurieren
zurück ins Programm springen ; retfie

Je nach Bedürfnissen, wird eine ISR nur nötige Elemente davon enthalten. Um auf alle Interrupts reagieren zu können muss die ISR vor dem nächsten Interrupt beendet werden. Da das Programm nur in den Pausen zwischen Ausführungen der ISR laufen kann, sollte die Ausführungszeit der ISR möglichst kurz sein.

Die einfachste ISR setzt nur ein Flag ("_Fint"), das dem Programm zeigt, dass ein Interrupt statt gefunden hat. Sie eignet sich für den Fall, wenn nur eine Interrupt-Quelle erlaubt ist.

0x0004 bcf INTCON,GIE ; Interrupts sperren
bsf IF ; Interrupt Flag löschen
bsf _Fint ; Flag setzen
retfie ; zurück ins Programm

Das Programm prüft das Flag "_Fint", löscht es und reagiert entsprechend.

Die ISR kann aber auch ein HP darstellen. Siehe hierzu: [[#Interrupts|Interrupts]]

=== Schnittstellen und Treiber ===

Als Schnittstelle wird externe Hadware, die zum Steuern eines an sie angeschlossenes "Gerätes" dient, genannt. Das ASM Programm, das die Steuerung ermöglicht ist ein Treiber. Als Beispiele siehe: [[http://www.roboternetz.de/phpBB2/viewtopic.php?t=13685]] und [http://www.roboternetz.de/phpBB2/viewtopic.php?t=22749]

== Vorlage für MPASM ==

Diese Vorlage ist nur für ASM Programme ohne Interrupts geeignet:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration
#define _DTT1 GPIO,0 ; Portpins benennen
#define _CKT2 GPIO,1
#define _T3 GPIO,2
#define _RNG GPIO,3
#define _INT GPIO,4
#define _RL GPIO,5
u.s.w.
SecondL equ 0x20 ; Variablen definieren (Register benennen)
SecondH equ 0x21
MinuteL equ 0x22
MinuteH equ 0x23
StundeL equ 0x24
StundeH equ 0x25
u.s.w
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
Haupt ............ ; hier fängt das Hauptprogramm als endlose Schleife an
Eigener Code
............
goto Haupt ; hier endet das HP, gehe zum Anfang des HPs (zurück)
UP1 ............ ; Unterprogramme
Eigener Code
............
return
############
UPn ............
Eigener Code
............
return
Init clrf GPIO ; lösche Port
bsf STATUS,RP0 ; auf Bank1 umschalten
call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; kalibriere internen RC oscillator
bcf OPTION_REG,7 ; aktiviere pull-ups
movlw 0x38 ; definiere Portpins GPIO, (z.B. 0-2 Aus- und 3-5 Eingänge)
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
movlw 7 ; schalte Komparator aus
movwf CMCON ; und definiere GPIO 0-2 als digitale I/Os
............
eigener Code
............
return ; springe zurück (zum Haupt)
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

Die Variablen können auch kürzer mit s.g. cblock definiert werden:

cblock 0x20
SecondL
SecondH
MinuteL
MinuteH
StundeL
StundeH
endc

Bei sehr vielen Variablen sind aber die Registeradressen nicht so übersichtlich.

Für Programme mit Interrupts ist diese Vorlage geeignet:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration
#define _DTT1 GPIO,0 ; Portpins benennen
#define _CKT2 GPIO,1
#define _T3 GPIO,2
#define _RNG GPIO,3
#define _INT GPIO,4
#define _RL GPIO,5
u.s.w.
SecondL equ 0x20 ; Variablen definieren (Register benennen)
SecondH equ 0x21
MinuteL equ 0x22
MinuteH equ 0x23
StundeL equ 0x24
StundeH equ 0x25
u.s.w
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
goto Haupt ; gehe zum Hauptprogramm "Haupt"
org 0x004 ; hier fängt die ISR (interrupt service routine) an
bcf INTCON,GIE ; interrupts sperren
.............
Eigener Code
.............
retfie ; hier endet die ISR, interrupts wieder erlauben
Haupt ............ ; hier fängt das Hauptprogramm als endlose Schleife an
Eigener Code
............
goto Haupt ; hier endet das HP, gehe zum Anfang des HPs (zurück)
UP1 ............ ; Unterprogramme
Eigener Code
............
return
############
UPn ............
Eigener Code
............
return
Init clrf GPIO ; lösche Port
bsf STATUS,RP0 ; auf Bank1 umschalten
call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; kalibriere internen RC oscillator
bcf OPTION_REG,7 ; aktiviere pull-ups
movlw 0x38 ; definiere Portpins GPIO, (z.B. 0-2 Aus- und 3-5 Eingänge)
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
movlw 7 ; schalte Komparator aus
movwf CMCON ; und definiere GPIO 0-2 als digitale I/Os
............
eigener Code
............
return ; springe zurück (zum Haupt)
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

== Das erste... ==

Hier wird detailiert das ganze Prozess der Erstellung eines ASM Programms beschrieben. Die Idee:

Es gibt 4 LEDs (_L1, _L2, _L3 und _L4), die mit 2 Tastern gesteuert werden sollen. Nach dem Einschalten soll keine LED leuchten. Solange der linke Taster (_T1) gedrückt ist, sollte eine leuchtende LED von links nach rechts "wandern" und von der letzten rechten Position wieder nach ganz linke "springen". Solange der rechte Taster (_T2) gedrückt ist, sollte eine leuchtende LED von rechts nach links "wandern" und von der letzten linken Position wieder nach ganz rechte "springen". Solange beide Taster gedrückt sind soll die leuchtende LED von links nach rechts und zurück "wandern".

Dafür nötige Hardware zeigt folgende Skizze:

.-----------------------------------------------.
| |
| PIC12F629 |
| |
| GPIO,3 GPIO,4 GPIO,5 GPIO,2 GPIO,1 GPIO,0|
'-----------------------------------------------'
4| 3| 2| 5| 6| 7|
| | .-. .-. .-. .-.
| | R | | R | | R | | R | |
| | 470| | 470| | 470| | 470| |
| | '-' '-' '-' '-'
\ o \ o | | | |
\ \ V -> V -> V -> V ->
\. \. - - - -
_T1 o _T2 o _L1 | _L2 | _L3 | _L4 |
| | | | | |
+-------+-------+---+---+-------+-------+
|
===
GND

Weil der Pin 4 (GPIO,3) nur einen "open drain" Ausgang hat (kann nur an GND schalten), wird er hier als Eingang benutzt.

Jetzt muss die Idee vom Programmierer in ein PAD verfasst werden, z.B. solcher:

Start
Initialisierung
.-------------->V
| _T1=0 gedrückt ? N >----.
| J |
| V |
| links->rechts "wandern" |
| V<------------´
| _T2=0 gedrückt ? N >----.
| J |
| V |
| rechts->links "wandern" |
| V<------------´
`---------------´

danach detailierter:

Start
Initialisierung
V<-------------------------------------------.
_T1=0 gedrückt ? N >---+--->_T2=0 gedrückt ? N >---+---´
J A J A
V | V |
_L1 an | _L4 an |
Warten | Warten |
_L1 aus | _L4 aus |
_L2 an | _L3 an |
Warten | Warten |
_L2 aus | _L3 aus |
_L3 an | _L2 an |
Warten | Warten |
_L3 aus | _L2 aus |
_L4 an | _L1 an |
Warten | Warten |
_L4 aus | _L1 aus |
V | V |
`------------´ `------------´

Weil der Prozessor die Befehle nacheinander liest, ist jeder Quelcode einspaltig. Um sich die "Übersetzung" des PADs in den Quelcode zu erleichtern wird er noch z.B. so umgestaltet:

Start
Initialisierung
V<-----------------+<----.
Haupt _T1=0 gedrückt ? N >---. A |
J | | |
V | | |
_L1 an | | |
Warten | | |
_L1 aus | | |
_L2 an | | |
Warten | | |
_L2 aus | | |
_L3 an | | |
Warten | | |
_L3 aus | | |
_L4 an | | |
Warten | | |
_L4 aus | | |
V<-----------´ | |
T2Test _T2=0 gedrückt ? N >---------´ |
J |
V |
_L4 an |
Warten |
_L4 aus |
_L3 an |
Warten |
_L3 aus |
_L2 an |
Warten |
_L2 aus |
_L1 an |
Warten |
_L1 aus |
V |
`------------------------´

Alle Pfeilen aus diesem PAD werden als "goto" in den Quelcode eingetragen.

Zuerst wird im MPASM Verzeichnis ein neuer Verzeichniss (z,B. "PIC Programme") angelegt und in dem Verzeichniss neue Textdatei (z.B. "Erstes.txt") erstellt. Als nächstes wird die "Vorlage für MPASM" dorthin kopiert.

Danach müssen, die im Programm benutzte Portpins und Register mit "#define" und "equ" definiert werden.

Als Initialisierung wird das UP "Init" aus der Vorlage für MPASM mit geändertem "TRISIO" Wert (0x18) übernommen. Siehe: [[#Vorlage für MPASM|Vorlage für MPASM]]

Fürs "Warten" wird eine dreifache Warteschleife verwendet. Siehe: [[#Pause|Pause]]

Die Taster werden mit "btfsc" Befehl geprüft und zum LEDs An- und Ausschalten werden Befehle "bsf" und "bcf" für ensprechenden Portpin von GPIO angewendet. Siehe: [[#Ausgeben|Ausgeben]]

Anschlessend wird alles laut PAD in die Vorlage für MPASM eingeschrieben und der Quellcode ist fertig:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration
#define _T1 GPIO,3 ; Portpins benennen
#define _T2 GPIO,4
#define _L1 GPIO,5
#define _L2 GPIO,2
#define _L3 GPIO,1
#define _L4 GPIO,0
P0 equ 0x20 ; Variablen definieren (Register benennen)
P1 equ 0x21
P2 equ 0x22
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
Haupt btfsc _T1 ; Taster _T1=0 gedrückt ?, wenn ja, überspringe "goto T2Test"
goto T2Test ; wenn nicht, springe zu "T2Test"
bsf _L1 ; schalte _L1 an (setze den Pin 2 auf "1")
call Warten ; warte ca. 0,4 s (ca. 400 000 Prozessortakten)
bcf _L1 ; schalte _L1 aus (setze den Pin 2 auf "0")
bsf _L2 ; schalte _L2 an (setze den Pin 5 auf "1")
call Warten ; warte
bcf _L2 ; schalte _L2 aus (setze den Pin 5 auf "0")
bsf _L3 ; schalte _L3 an (setze den Pin 6 auf "1")
call Warten ; warte
bcf _L3 ; schalte _L3 aus (setze den Pin 6 auf "0")
bsf _L4 ; schalte _L4 an (setze den Pin 7 auf "1")
call Warten ; warte
bcf _L4 ; schalte _L4 aus (setze den Pin 7 auf "0")
T2Test btfsc _T2 ; Taster _T2=0 gedrückt ?, wenn ja, überspringe "goto Haupt"
goto Haupt ; wenn nicht, springe zu "Haupt"
bsf _L4 ; schalte _L4 an (setze den Pin 7 auf "1")
call Warten ; warte
bcf _L4 ; schalte _L4 aus (setze den Pin 7 auf "0")
bsf _L3 ; schalte _L3 an (setze den Pin 6 auf "1")
call Warten ; warte
bcf _L3 ; schalte _L3 aus (setze den Pin 6 auf "0")
bsf _L2 ; schalte _L2 an (setze den Pin 5 auf "1")
call Warten ; warte
bcf _L2 ; schalte _L2 aus (setze den Pin 5 auf "0")
bsf _L1 ; schalte _L1 an (setze den Pin 2 auf "1")
call Warten ; warte
bcf _L1 ; schalte _L1 aus (setze den Pin 2 auf "0")
goto Haupt ; springe zu "Haupt"
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 ("Haupt"),
Init clrf GPIO ; lösche Port (setze alle werdende Ausgänge auf "0")
bsf STATUS,RP0 ; auf Bank1 umschalten
call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; und kalibriere internen RC oscillator (4 MHz)
bcf OPTION_ REG,7 ; aktiviere pull-ups für die Portpins
movlw 0x18 ; definiere Portpins GPIO,3 und 4 als Eingänge
; und restlichen als Ausgänge (00011000b)
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
movlw 7 ; schalte Komparator aus
movwf CMCON ; und definiere GPIO 0-2 als digitale I/Os
return ; springe zurück (zum Haupt)
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

Jetzt wird der Quellcode in "Erstes.asm" umbenannt. Diese "*.asm" Datei können wir dem MPASM zum "Übersetzten" geben. Nach der Assemblierung sehen wir 3 Meldungen (Messages) vom MPASM. Diese befinden sich in der vom MPASM erstellter Datei "Erstes.lst" und lauten:

Message[302]: Register in operand not in bank 0. Ensure that bank bits are correct.

Diese Meldung kann man übersetzen als:

Meldung[302]: Register im Befehl nicht in Bank 0. Vergewisse Dich, dass die Bank-Bits korrekt sind.

Wir sind sicher, dass die Register "OSCCAL", "OPTION_REG" und "TRISIO" in der Bank 1 sich befinden. Wenn man aber nicht sicher ist, soll man in Datenblatt nachschauen. Die Meldungen kommen immer für alle SFRs (Special Function Register) die sich nicht in der Bank 0 befinden und können ignoriert werden.

Am Ende der Datei "Erstes.lst" befinden sich noch einige Informationen über Programmspeicher:

Program Memory Words Used: 52 ; benutzte Speicherstellen
Program Memory Words Free: 972 ; freie Speicherstellen

und die Anzahl den eventuellen Fehlern (Errors), Warnungen (Warnings) und Meldungen (Messages):

Errors : 0
Warnings : 0 reported, 0 suppressed
Messages : 3 reported, 0 suppressed

Insgesamt werden durch MPASM 4 Dateien erstellt: "*.cod", "*.err", "*.hex" und "*.lst".

Wichtigste davon, falls wegen Fehler keine "*.hex" Datei erstellt wird, ist die "*.err" Datei, wo alles was dem MPASM nicht "passt" aufgelistet ist. In der "*.lst" Datei kann man sich ein Programm mit genauen Adressen für jeden Befehl anschauen.

Die während der Assemblierung vom MPASM generierte Datei "Erstes.hex" kann jetzt durch ein Brenner mit geeignetem Programm in den PIC Programmspeicher eingeschrieben werden.

== Für anderen PIC umschreiben ==

Die wichtigste Vorraussetzung ist, das der andere PIC2, auf dem das vorhandene ASM Programm für PIC1 laufen soll, zumindest für das ASM Programm nötige interne Hardware hat. Die Frequenz des Oszillators sollte gleich sein. Der Code benötigt ausser UP "Init" keine Änderungen.

Wenn der Port vom PIC2 anderen Namen hat, muss man das im Quellcode umdefinieren, z.B.:

#define PORTC PORTB
#define TRISC TRISB

Dann wird das Assemblerprogramm, wenn es PORTC findet, immer PORTB nehmen. Das gleiche Betrifft die "__config" Ausdrücke, die entsprechend der "*.ini" Datei für den PIC2, geändert werden müssen.

Das Assemblerprogramm findet sicher alles, was ihm nicht "passt" und bringt Fehlermeldungen, auf die man entsprechend reagieren muss.

Als Beispiel, schreiben wir "Erstes.asm" für den PIC16F84A um.

Zum Ändern sind die ersten 3 Zeilen:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration

Sie werden für den PIC16F84A so aussehen:

list P=16F84A ; Prozessor definieren
include "P16F84A.inc" ; 4.000 MHz
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _HS_OSC

Dazu muss noch "GPIO" Port umdefiniert werden, da der PIC16F84A solchen nicht hat, z.B wegen internen pull-ups auf "B":

#define GPIO PORTB
#define TRISIO TRISB

Die Hardware muss natürlich an entsprechende Pins angeschlossen werden:

_T1 auf 12 (B3), _T2 auf 13 (B4), _L1 auf 14 (B5), _L2 auf 11 (B2), _L3 auf 10 (B1) und _L4 auf 9 (B0)

Jetzt assemblieren wir die Qelldatei und der MPASM bringt in der Datei "Erstes.err" folgende Fehler:

Error[113] C:\MPASM\PICPROG\PIC16F84\ERSTES.ASM 61 : Symbol not previously defined (OSCCAL)
Error[113] C:\MPASM\PICPROG\PIC16F84\ERSTES.ASM 67 : Symbol not previously defined (CMCON)

In dem UP "Init" müssen also noch die Befehle mit "OSCCAL" und "CMCON" Register entfernt werden, da der PIC16F84A sie nicht hat:

call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; kalibriere internen RC oscillator (4 MHz)

und:

movlw 7 ; schalte Komparator aus
movwf CMCON ; und mache GPIO 0-2 als digital I/O

Weiter kann schon alles übernommen werden und die Datei "Erstes.asm" für den PIC16F84A ist fertig:

list P=16F84A ; Prozessor definieren
include "P16F84A.inc" ; 4.000 MHz
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _HS_OSC
#define GPIO PORTB ; Ports umbenennen
#define TRISIO TRISB
#define _T1 GPIO,3 ; Portpins benennen
#define _T2 GPIO,4
#define _L1 GPIO,5
#define _L2 GPIO,2
#define _L3 GPIO,1
#define _L4 GPIO,0
P0 equ 0x20 ; Variablen definieren (Register benennen)
P1 equ 0x21
P2 equ 0x22
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
Haupt btfsc _T1 ; Taster _T1=0 gedrückt ?, wenn ja, überspringe "goto T2Test"
goto T2Test ; wenn nicht, springe zu "T2Test"
bsf _L1 ; schalte _L1 an
call Warten ; warte ca. 0,4 s (ca. 400 000 Prozessortakten)
bcf _L1 ; schalte _L1 aus
bsf _L2 ; schalte _L2 an
call Warten ; warte
bcf _L2 ; schalte _L2 aus
bsf _L3 ; schalte _L3 an
call Warten ; warte
bcf _L3 ; schalte _L3 aus
bsf _L4 ; schalte _L4 an
call Warten ; warte
bcf _L4 ; schalte _L4 aus
T2Test btfsc _T2 ; Taster _T2=0 gedrückt ?, wenn ja, überspringe "goto Haupt"
goto Haupt ; wenn nicht, springe zu "Haupt"
bsf _L4 ; schalte _L4 an
call Warten ; warte
bcf _L4 ; schalte _L4 aus
bsf _L3 ; schalte _L3 an
call Warten ; warte
bcf _L3 ; schalte _L3 aus
bsf _L2 ; schalte _L2 an
call Warten ; warte
bcf _L2 ; schalte _L2 aus
bsf _L1 ; schalte _L1 an
call Warten ; warte
bcf _L1 ; schalte _L1 aus
goto Haupt ; springe zu "Haupt"
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 ("Haupt"),
Init clrf GPIO ; lösche Port (setze alle werdende Ausgänge auf "0")
bsf STATUS,RP0 ; auf Bank1 umschalten
bcf OPTION_REG,7 ; aktiviere pull-ups
movlw 0x18 ; definiere Portpins GPIO,3 und 4 als Eingänge
; und die restlichen als Ausgänge (00011000b)
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
return ; springe zurück (zum Haupt), nach der Zeile
; aus der du afgerufen wurdest
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

== Einbinden ==

Die einfachste Möglichkeit die gewünschte Programme in ein neues Programm einzubinden ist, die alle Programme in das neue Programm zu kopieren. Dafür müssen die ersten 3 Zeilen, die den Prozessor und die Konfiguration des PICs festlegen aus den eigebundenen Programmen entfernt werden. Danach müssen alle "#define", "equ" und "org" Direktiven, verglichen und wenn nötig geändert werden. Dabei hilft der MPASM mit seinen Fehlermeldungen in der Datei "*.err".

Die zweite Möglichkeit ist die gewünschte Programme als "*.asm" Dateien mit der Direktive "include *.asm" am Ende des neuen Programms vor der Direktive "end" einzubinden.

include "1.asm"
include "2.asm"
...............
include "n.asm"
end

In dem Fall gelten die gleichen o.g. Regeln wie beim direkten Kopieren. Wenn es in den eingebindenen Programmen keine "org" Direktiven gibt, dann werden die weitere Programme im Programmspeicher ab Ende des ersten Programms nacheinander plaziert.

== Fehlersuche ==

Als erstes wird an den PIC angeschlossene externe Hardware geprüft. Das sollte noch vor dem Einstecken oder Einlöten des PICs gemacht werden, da die gravierende Fehler (z.B. Kurzschlüsse, Umpolung von VCC und GND, u.s.w.) für den PIC schädlich werden können. Für einige Teile der Hardware kann entsprechende Spannung (VCC oder GND) an bestimmten Pin gelegt werden und die richtige Reaktion der Hardware optisch (z.B. für LEDs) oder akustisch (z.B. für Relais) festgestellt werden. Sonst müssen die elektrischen Verbindungen mit einem Messgerät überprüft werden.

Die Fehlersuche in der Software fängt mit der ersten und endet mit der letzten Zeile des ASM Programms. Sie läuft die ganze Zeit parallel zur Programmierung. Jedes UP soll vor dem Übertragen in den Quellcode geprüft und eventuelle Fehler beseitigt werden. Dazu arbeitet man gleichzeitig mit zwei "*.asm" Dateien, einer für die UPs und einer für das gesamte Programm. Es wird empfohlen, nach der "Initialisierung", als erstes UP, das für Ausgabegerät (z.B. Display) zu erstellen, um das funktionieren des Programms, vom Anfang an beobachten zu können.

Wenn aus geprüften UPs erstelltes Programm nicht richtig funktioniert, müsste ein Fehler im PAD sein.

== Optimierung ==
Work in Progress...
Wer sonst noch Beispiele hat, bitte hier vervollständigen...
BMS ...
=== Speicherbedarf ===
==== Programmspeicher ====
Die ersten Programme für den PIC sind natürlich einfach und kurz. Doch nach und nach werden die Codes länger und unübersichtlicher, das Brennen dauert auch umso länger. Das Programm ist zu umfangreich. Doch wo soll man etwas kürzen?

Es gibt unzählige Möglichkeiten - hier ein paar Beispiele:

===== Unterprogramme =====

Bestimmt wird man im Code immer die selben Abschnitte brauchen, zum Beispiel Warteschleifen oder ADC-Routinen, etc. Wieso sollte man diese also mehrfach (doppelt, dreifach, u.s.w.) schreiben?

Die Lösung: Der Programmteil wird als Unterprogramm benutzt. Man erstellt eine Sprungmarke (ab hier beginnt das Unterprogramm) und endet wieder mit einem "return"- oder "retlw"-Befehl.
Aufgerufen werden die Unterprogramme meistens mit dem "call"-Befehl. Es "lohnt sich" ein Codefragment als UP zu definieren erst wenn es min. 2 mal aufgerufen wird.

Ein "goto"-Befehl ist zu diesem Zweck geeignet nur, wenn der Prozessor zum letzten Aufrufer von "call" zurück springen soll, da die Rücksprungadresse vom letzten "call" auf dem Stapel (stack) abgelegt wurde. Somit kann man mehr als 8 Ebenen von UPs nutzen.

Den Unterprogrammen kann man natürlich auch Werte übergeben. Möchte man z.B. mehrere unterschiedliche Zeiten für Warteschleifen benutzen, so kann man die Parameter vor dem Aufruf des UPs in benötigte Anzahl von Register einschreben und dann das Unterprogramm mit "call" aufrufen. Das Unterprogramm verwendet dann die Zahlen von den Register. Siehe: [[#Pause|Pause]]

Um gleiche Vorgänge in mehreren Register durchzuführen (z.B. löschen) geeignet ist Anwendung von Schleifen mit bestimmter Anzahl der Abläufe und indirekter Adressierung. Siehe: [[#Variablen|Variablen]]

===== bsf und bcf =====

Bestimmt gibt es Situationen, in denen der PIC mehrere Bits an einem Port/Register setzen oder löschen muss. Z.B. wenn mehrere LEDs an einem Port ein- oder ausgeschaltet werden sollen.
Werden mehr als 2 Bits verändert, so kann man hier die "bsf"- und "bcf"-Befehle umgehen und einen kürzeren Code erstellen.

bsf PORTB,0 ;An PORTB sind 8 LEDs angeschlossen.
bsf PORTB,1 ;Es sollen die ersten 4 LEDs angeschaltet werden,
bsf PORTB,2 ;die anderen sollen ausgeschaltet werden.
bsf PORTB,3 ;links steht es mit bcf/bsf
bcf PORTB,4 ;ziemlich lang
bcf PORTB,5
bcf PORTB,6
bcf PORTB,7

movlw b'00001111' ;Das geht auch kürzer und übersichtlicher:
movwf PORTB

Man sieht - der Codeabschnitt umfasst nur noch 2 Zeilen anstatt 8. Somit braucht es weniger Speicher und wird von PIC schneller verarbeitet. Allerdings muss man aufpassen, da durch diese Routine der Inhalt des W-Registers und der Inhalt des gesamten Zielregisters verändert wird. Sollen die anderen Bits unangetastet bleiben, muss man es entweder bei den "bcf"/"bsf"-Befehlen belassen oder logische Funktionen (and bzw. or) durchführen.

===== Bit kopieren =====

;An den PIC ist ein Taster(RB0) und eine LED(RB1) angeschlossen.
;Taster: High=gedrückt Low=nicht gedrückt
;LED: High=Ein Low=Aus
;Wenn der Taster gedrückt ist, soll die LED leuchten
;wenn er nicht gedrückt ist, soll die LED nicht leuchten.
;1.Vorschlag:
btfss PORTB,0 ;ist der taster gedrückt?
goto no ;nein
bsf PORTB,1 ;ja - LED ein
goto endif ;fertig abgefragt - unten weitermachen...
no bcf PORTB,1 ;LED aus
endif

Der oben aufgeführte Code hat viele Nachteile: er ist relativ lang, braucht zwei Gotos und entspr. Sprungmarken. Ok, das ist vielleicht Erbsenzählerei, aber aus diesen 5 Zeilen kann man 3 machen.

bcf PORTB,1 ;Das Bit wird erst gelöscht
btfss PORTB,0 ;Taster gedrückt?
bsf PORTB,1 ;JA-LED an

Man geht davon aus, dass der Taster nicht gedrückt ist. Somit wird die LED erst einmal ausgeschaltet. Ist der Taster aber doch gedrückt, dann wird die LED angeschaltet.

Achtung möglicher Nebeneffekt: Wird dies in einer Schleife sehr schnell und oft ausgeführt, kann die LED flimmern oder nicht in ihrer vollen Helligkeit leuchten. Das passiert, weil ja angenommen wird, dass der Taster nicht gedrückt wird und die LED somit aus sein muss. Dann wird sie aber bei Tastendruck eingeschaltet. Somit entsteht ein schnelles ein-/ausschalten (PWM) und die LED leuchtet nicht mehr so hell.
Meist ist das aber nicht tragisch oder wird nicht unbedingt in einer Schleife sehr schnell abefragt. Siehe hierzu: [[#Einlesen|Einlesen]]

==== RAM ====

Um Anzahl benötigten Register zu sparen werden vorläufige Register (temporary) definiert, die von mehreren UPs benutzt werden. Als Beispiel, das Register "ATmp" in [[#Hex Dec Wandlung|Hex Dec Wandlung]]. Die Benutzung muss aber sehr genau nach PAD zugeteilt werden. Bei gleichzeitiger Benutzung des gleichen Registers durch mehrere UPS werden falsche Daten verarbeitet und im schlimmsten Fall können endlose Schleifen entstehen, die in Folge haben, dass das Programm nicht weiter ausgeführt wird ("hängt").

Viele im ASM Programm ungebrauchte SFRs können als "normale" Register (GPR) verwendet werden. Wenn zum Beispiel Timer1 nicht benutzt wird, können seine Register TMR1H und TMR1L für Speicherung von Daten benutzt werden. Es könnte aber gefährlich werden, wenn mehrere Programme gebindet sind. Deswegen muss es immer am Ende, beim volständigen Programm, geprüft werden, welche SFRs tatsächlich benutzt werden dürfen.

Für Konstanten (z.B. pi, ln2, Meldungen, u.s.w.), die sich im Laufe des Programms nicht ändern, kann EEPROM (mit MPASM Direktive "de") oder Programmspeicher (mit MPASM Direktive "dt") als Ablage benutzt werden. Siehe auch: [[#EEPROM|EEPROM]] und [[#Tabellen|Tabellen]]

=== Ausführungszeit ===

Alles was schnellmöglichst ablaufen soll, widersetzt sich der Optimierung des Programmspeichers.

Es können keine Schleifen und keine indirekte Adressierung benutzt werden, alles muss direkt programmiert werden.

Als Beispiel zur Verdeutlichung: Es sollen 16 Werte vom PORTA ins RAM ab Adresse 0x20 eingelesen werden.

Als Schleife mit indirekter Adressierung:

................
movlw 0x10 ;Anzahl Durchläufe
movwf Temp ;in den Schleifenzähler
movlw 0x20 ;erste Adresse
movwf FSR ;ins FSR Register
Einlesen movf PORTA,0 ;PortA ins W-Register
movwf INDF ;und ins aktuellen RAM Register
incf FSR,1 ;nächste Adresse
decfsz Temp,1 ;Temp = 0 ?
goto Einlesen ;nein, zum Einlesen
................ ;ja, weiter
Gesamtdauer: 100 Takten
Pause zwischen Einlesungen: 6 Takten
Programmspeicher Bedarf: 9 Speicherstellen
Direkt:

...............
movf PORTA,0
movwf 0x20
movf PORTA,0
movwf 0x21
movf PORTA,0
movwf 0x22
movf PORTA,0
movwf 0x23
movf PORTA,0
movwf 0x24
movf PORTA,0
movwf 0x25
movf PORTA,0
movwf 0x26
movf PORTA,0
movwf 0x27
movf PORTA,0
movwf 0x28
movf PORTA,0
movwf 0x29
movf PORTA,0
movwf 0x2A
movf PORTA,0
movwf 0x2B
movf PORTA,0
movwf 0x2C
movf PORTA,0
movwf 0x2D
movf PORTA,0
movwf 0x2E
movf PORTA,0
movwf 0x2F
...............
Gesamtdauer: 32 Takten
Pause zwischen Einlesungen: 2 Takten
Programmspeicher Bedarf: 32 Speicherstellen

Anstatt Warteschleifen (z.B. für Tastenentprellung) sollten Programmfragmente mit entsprechender Ausführungszeit benutzt werden (z.B. Ausgabe auf einem Display). Die nötige Zeit lässt sich aus mehreren UPs zusammensetzen.

Es sollte kein Prozessortakt ungenutzt bleiben.

= Mid-Range =

Zu Mid-Range gehören alle PICs mit 14-bit langen Befehlen aus den Familien 12FXXX und 16FXXX.

== Kurzübersicht Assembler Befehle ==

{|
|-
| valign=top |

{| {{Blauetabelle}}
|ADDLW||Add literal and W
|-
|ADDWF||Add W and f
|-
|ANDLW||AND literal with W
|-
|ANDWF||AND W with f
|-
|BCF||Bit Clear f
|-
|BSF||Bit Set f
|-
|BTFSC||Bit Test f, Skip if Clear
|-
|BTFSS||Bit Test f, Skip if Set
|-
|CALL||Call subroutine
|-
|CLRF||Clear f
|-
|CLRW||Clear W
|-
|CLRWDT||Clear Watchdog Timer
|}

| valign=top |

{| {{Blauetabelle}}
|-
|COMF||Complement f
|-
|DECF||Decrement f
|-
|DECFSZ||Decrement f, Skip if 0
|-
|GOTO||Go to address or label
|-
|INCF||Increment f
|-
|INCFSZ||Increment f, Skip if 0
|-
|IORLW||Inclusive OR literal with W
|-
|IORWF||Inclusive OR W with f
|-
|MOVF||Move f
|-
|MOVLW||Move literal to W
|-
|MOVWF||Move W to f
|-
|NOP||No Operation
|}

| valign=top |

{| {{Blauetabelle}}
|-
|RETFIE||Return from interrupt
|-
|RETLW||Return with literal in W
|-
|RETURN||Return from Subroutine
|-
|RLF||Rotate Left f through Carry
|-
|RRF||Rotate Right f through Carry
|-
|SLEEP||Go into standby mode
|-
|SUBLW||Subtract W from literal
|-
|SUBWF||Subtract W from f
|-
|SWAPF||Swap nibbles in f
|-
|XORLW||Exclusive OR literal with W
|-
|XORWF||Exclusive OR W with f
|}
[[:bild:pic_asm_short.jpg|Kurzübersicht zum Ausdrucken]]
|}


==Ausführliche Beschreibung zu den Befehlen==

Fast alle Befehle werden in einem Takt = 4 Oszillatortakten ausgeführt.

Aussnahmen:

"goto", "call", "return" und "retfie" benötigen wegen Zugriff auf den Programmzähler (PC) immer 2 Takten.

"btfsc", "btfss", "decfsz" und "incfsz" brauchen 1 Takt wenn der nächste Befehl ausgeführt wird b.z.w. 2 Takten wenn er überspringen wird, weil es immer anstatt des überspringenden Befehls ein "nop" ausgeführt wird.

Eine ausgegliederte Beschreibung der Befehle findet sich unter [[PIC Assemblerbefehle]]

Erklärungen zu den Verwendeten Platzhaltern:
*'''k''' stellt einen fest definierten Wert da. z.B. <tt>0x20</tt>, <tt>d'42'</tt> oder <tt>b'00101010'</tt>
*'''W''' steht für das W-Register.
*'''d''' steht für ''destination'' (Ziel). Im code wird d durch ein <tt>w</tt> bzw. <tt>0</tt> (der Wert wird in das W-Register gespeichert ) oder <tt>f</tt> bzw. <tt>1</tt> (der Wert wird in das davor definierte Register gespeichert)
*'''b''' steht für Bitnummer im Register (eine Zahl zwischen 0 und 7)
*'''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
*<tt>Schreibmaschinenstil</tt> bedeutet, dass es so im Quellcode geschrieben werden kann.

 ADDLW k ADD Literal and W - Addiere Zahl (k) und W<hr>
:Es wird die Rechenoperation <math>W+k</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|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

 ADDWF R,d ADD W and F - Addiere W und f <hr>
:Es wird die Rechenoperation <math>W+R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Dieser Befehl beeinflusst das STATUS-Register. Siehe hierzu [[#Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

 ANDLW k AND Literal with W<hr>
:Es wird bitweise die logische Funktion <math>k\ and\ W</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 Operation:
<dl><dd>
11001010 ;k
10101100 ;W-Register
-------- and
10001000 ;W-Register
</dd></dl>

 ANDWF R,d AND W with F<hr>
:Es wird bitweise die logische Funktion <math>W\ and\ R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Vergleiche ANDLW. Dieser Befehl wird benutzt zum Löschen bestimmten Bits im Register ohne restlichen Bits zu beeinflüssen.

BCF R,b Bit Clear F - Bit b im R wird gelöscht<hr>
:Mit dem Befehl <tt>BCF</tt> wird das Bit '''b''' im Register '''R''' gelöscht. Ein Beispiel:
<dl><dd>
movlw b'11111111' ;es wird b'11111111' in das W-Register geschrieben
BCF W,2 ;es wird bit 2 im W-Register gelöscht.
;das Ergebnis ist: b'11111011'
</dl></dd>

BSF R,b Bit Set F - Bit b im R wird gesetzt<hr>
:Mit dem Befehl <tt>BSF</tt> wird das Bit '''b''' im Register '''R''' gesetzt. Ein Beispiel:
<dl><dd>
clrw ;es wird b'00000000' in das W-Register geschrieben
BSF W,2 ;es wird bit 2 im W-Register gesetzt.
;das Ergebnis ist: b'00000100'
</dl></dd>

BTFSC R,b Bit Test F, Skip if Clear - Wenn das Bit b im Register R 0 ist, überspringe den nächsten Befehl<hr>
:Mit dem Befehl <tt>BTFSC</tt> kann eine Verzweigung im Programmablauf bewirkt werden. Wenn das Bit '''b''' im Register '''R''' 0 ist, wird der nächste Befehl übersprungen. Ein Beispiel:
<dl><dd>
movlw b'00000001' ;es wird die Zahl 1 in das W-Register kopiert.
BTFSC W,0 ;es wird bit 0 geprüft.
;wenn es 0 ist, wird der nächste Befehl übersprungen
goto IST_EINS ;springt zur Marke "IST_EINS" <- in diesem Fall wird dieser
;Sprungbefehl ausgeführt.
goto IST_NULL ;springt zur Marke "IST_NULL"
</dl></dd>

BTFSS R,b Bit Test F, Skip if Set - Wenn das Bit b im Register R 1 ist, überspringe den nächsten Befehl<hr>
:Mit dem Befehl <tt>BTFSS</tt> kann eine Verzweigung im Programmablauf bewirkt werden. Wenn das Bit '''b''' im Register '''R''' 1 ist, wird der nächste Befehl übersprungen. Ein Beispiel:
<dl><dd>
movlw b'00000001' ;es wird die Zahl 1 in das W-Register kopiert.
BTFSS W,0 ;es wird bit 0 geprüft.
;wenn es 1 ist, wird der nächste Befehl übersprungen
goto IST_NULL ;springt zur Marke "IST_NULL"
goto IST_EINS ;springt zur Marke "IST_EINS" <- in diesem Fall wird dieser
;Sprungbefehl ausgeführt, da der Befehl
;darüber übersprungen wurde.
</dl></dd>

CALL CALL Subroutine - Rufe Unterprogramm auf<hr>
:Mit dem <tt>CALL</tt> Befehl wird ein Unterprogramm aufgerufen. Mit dem <tt>RETURN</tt>-Befehl wird das Unterprogramm beendet und man kehrt zum Befehl nach dem <tt>CALL</tt>-Befehl zurück. Das Unterprogramm wird so definiert, dass im Quellcode der Name des Unterprogramms nicht eingerückt steht. Ein Beispiel:

<dl><dd>
movlw d'13' ;in das W-Register wird 13d geladen
CALL UP1 ;es wird das Unterprogramm "UP1" aufgerufen
movwf ergebnis ;das W-Register wird in das Register "ergebnis" kopiert.
;im Register "ergebnis" steht nun 23d

UP1 addlw d'10' ;es wird 10d zum W-Register addiert
return ;kehre zurück zum Aufrufer
</dl></dd>

CLRF R CLeaR F- Schreibe 0 in das Register R<hr>
:Das Register '''R''' wird mit Nullen gefüllt (gelöscht).

CLRW CLeaR W - Schreibe 0 in W<hr>
:Das W-Register (<tt>W</tt>) wird mit Nullen gefüllt (gelöscht).
:Der Befehl bewirkt das gleiche wie MOVLW 0 und darf im Programmen, die fur zukünftige Anwendung bei den PICs der serie 18F vorgesehen sind, nicht benutzt werden, da sie ihn nicht kennen.

CLRWDT CLeaR WatchDog Timer - Setzt den Watchdog-Timer zurück<hr>
:Es wird der WDT (Watchdog-Timer) zurückgesetzt und der Zähler des WDT auf 0 gesetzt, zusätzlich werden die STATUS-bits TO und PD gesetzt.

COMF R,d COMplement F - negiere alle bits im Register R<hr>
:Von der Binärzahl im Register '''R''' werden alle 0 mit 1 und alle 1 mit 0 ersetzt. Das Ergebnis wird entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Ein kleines Beispiel: aus <tt>AAh</tt> (<tt>10101010b</tt>) wird <tt>55h</tt> (<tt>01010101b</tt>).

DECF R,d DECrement F - Subtrahiert 1 vom Regiser f<hr>
:Vom Wert des Registers '''R''' wird 1 subtrahiert und das Ergebnis entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
:Weil es keine "echte" Substraktion ist, beeinflusst dieser Befehl das C-Flag im STATUS-Register nicht.

DECFSZ R,d DECrement F, Skip if Zero - Subtrahiert 1 vom Regiser f, überspringe wenn 0<hr>
:Vom Wert des Registers '''R''' wird 1 subtrahiert und das Ergebnis entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Der Zusatz SZ steht für ''skip if zero'', d.h. wenn das Ergebnis der Rechnung Null ist, wird der nächste Befehl übersprungen. Dieser Befehl wird für Schleifen mit bestimmter Anzahl der Durchläufe benutzt.

GOTO GO TO address - Gehe zu Adresse/Sprungmarke<hr>
:Nach dem GOTO Befehl wird das Programm ab der Adresse weiter ausgeführt, die nach dem GOTO-Befehl steht. Diese Adresse wird durch so genannte Sprungmarke definiert, welche, im Gegensatz zu den Befehlen nicht eingerückt im Quellcode stehen.

INCF R,d INCrement F - Addiere 1 zum Register f<hr>
:Zum Wert des Registers '''R''' wird 1 addiert und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
:Weil es keine "echte" Addition ist, beeinflusst dieser Befehl das C-Flag im STATUS-Register nicht.

INCFSZ R,d INCrement F, Skip if Zero - Addiere 1 zum Regiser f, überspringe wenn 0<hr>
:Zum Wert des Registers '''R''' wird 1 addiert und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Der Zusatz SZ steht für ''skip if zero'', d.h. wenn das Ergebnis der Rechnung Null ist, wird der nächste Befehl übersprungen. Dieser Befehl wird für Schleifen mit bestimmter Anzahl der Durchläufe benutzt.

 IORLW k Inclusive OR Literal with W<hr>
:Es wird bitweise die logische Funktion <math>k\ or\ W</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 Operation:
<dl><dd>
11001010 ;k
10101100 ;W-Register
-------- or
11101110 ;W-Register
</dd></dl>

 IORWF R,d Inclusive OR W with F<hr>
:Es wird bitweise die logische Funktion <math>W\ or\ R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Vergleiche IORLW. Dieser Befehl wird oft benutzt zum Setzen bestimmten Bits im Register ohne restlichen Bits zu beeinflüssen.

MOVF R,d MOVe F - Bewege f<hr>
:Das Register R wird in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder wieder in R kopiert ('''d'''=<tt>F</tt>=<tt>1</tt>). Letzteres mag sinnlos scheinen, ist aber nützlich, da durch den Befehl das Z-Bit im STATUS-Register gesetzt wird, falls R Null ist.

MOVLW k MOVe Literal to W - Bewege Zahl (k) in W-Register<hr>
:Der festgelegte Wert k wird in das W-Register kopiert.

:Dieser Befehl wird auch bei indirekter Adressierung zum laden der absoluter Adresse ins "FSR" Register benutzt. Beispiel:
:Der Register "Temp" wurde mit "Temp equ 0x20" definiert.
<dl><dd>
MOVLW Temp ;ins W-Register wird die absolute Adresse 0x20 vom "Temp" geladen
movwf FSR ;diese Adresse wird jetzt ins Register "FSR" kopiert
</dd></dl>
MOVWF R MOVe W to F- Bewege W-Register in das Register F<hr>
:Das W-Register wird in das Register '''R''' kopiert.

NOP No OPeration - Kein Befehl zum Ausführen (warte)<hr>
: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. Siehe hierzu: [[#Pause|Pause]]

RETFIE RETurn From Interrupt Enable - Kehre zurück aus der Unterbrechung, erlaube Unterbrechungen<hr>
:Mit diesem Befehl wird die Interrupt Service Routine (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 | Interrupt]]

RETLW k RETurn with Literal in W - Kehre zurück mit Zahl k im W-Register<hr>
:Wurde ein Programmteil mit dem Befehl <tt>CALL</tt> aufgerufen, dann springt man mit dem Befehl <tt>RETLW</tt> zurück in die nächste Zeile nach der Zeile aus der das <tt>CALL</tt> 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 Wertetabellen (eng: lookup tables) verwendet.

RETURN RETURN from Subroutine - Kehre zurück zum Aufrufer<hr>
:Wurde ein Programmteil mit dem Befehl <tt>CALL</tt> aufgerufen, dann springt man mit dem Befehl <tt>RETURN</tt> zurück zu der nächsten Zeile nach der Zeile aus der das <tt>CALL</tt> Befehl ausgeführt wurde.

RLF R,d Rotate Left F through carry - Rotiere das Register f mithilfe des Carry-bits nach links<hr>
:Alle Bits im Register '''R''' werden um eine Position nach links verschoben. Dabei wird das Carry bit (<tt>STATUS,C</tt>) 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'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
<dl><dd>
|<--- Register R --->|
|c|<-7<-6<-5<-4<-3<-2<-1<-0
V A
|________________________|
</dd></dl>
:Zur Verdeutlichung:
<dl><dd>
|C| |-Register R-| ;C steht für das Carry-bit, STATUS,C ; 0-7 stehen für Bitnummer im Register.
c 7 6 5 4 3 2 1 0 ;vor der Rotation
7 6 5 4 3 2 1 0 c ;nach der Rotation
</dd></dl>

RRF R,d Rotate Right F through carry - Rotiere das Register f mithilfe des Carry-bits nach rechts<hr>
:Alle Bits im Register '''R''' werden um eine Position nach rechts verschoben. Dabei wird das Carry bit (<tt>STATUS,C</tt>) 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'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
<dl><dd>
|<--- Register R --->|
|c|->7->6->5->4->3->2->1->0
A V
|________________________|
</dd></dl>
:Zur Verdeutlichung:
<dl><dd>
|C| |-Register R-| ;C steht für das Carry-bit, STATUS,C ; 0-7 stehen für Bitnummer im Register.
C 7 6 5 4 3 2 1 0 ;vor der Rotation
0 C 7 6 5 4 3 2 1 ;nach der Rotation
</dd></dl>

SLEEP Go into standby mode - Versetze den Mirokontroller in Bereitschaftsmodus (Schlaf)<hr>
: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.

 SUBLW k SUBtract W from Literal - Ziehe W von Zahl (k) ab<hr>
: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|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

 SUBWF R,d SUBtract W from F - Ziehe W von f ab<hr>
:Es wird die Rechenoperation <math>R-W</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Dieser Befehl beeinflusst das STATUS-Register. Siehe hierzu [[#Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

:Beispiel:
<dl><dd>
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
</dd></dl>

SWAPF R,d SWAP nibbles in F - Vertausche die Halbbytes (Nibbles)<hr>
:Es werden die höheren 4 bit (bit7-bit4) mit den niedrigeren 4 bit (bit3-bit0) eines Registers vertauscht und entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
:Beispiel:
<dl><dd>
movlw b'00001111' ;schreibe b'00001111' in das W-Register
movwf Register1 ;kopiert 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'
</dd></dl>

 XORLW k EXclusive OR Literal with W<hr>
:Es wird bitweise die logische Funktion <math>k\ xor\ W</math> ausgeführt und das Ergebniss in das W-Register gespeichert. Dieser Befehl setzt das Z bit des STATUS-Registers, falls W=k und das Ergebnis 0 ist.
:Zur Verdeutlichung der Operation:
<dl><dd>
11001010 ;k
10101100 ;W-Register
-------- xor
01100110 ;W-Register
</dd></dl>

 XORWF R,d EXclusive OR W with F<hr>
:Es wird bitweise die logische Funktion <math>W\ xor\ R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Vergleiche XORLW. Dieser Befehl setzt das Z bit des STATUS-Registers, falls W=k und das Ergebnis 0 ist und wird zum Vergleichen zwei Register benutzt.

==Besondere, oft gebrauchte Register==

=== STATUS ===
Der Statusregister beinhaltet den Status der Recheneinheit ALU (Arithmetic-Logic Unit), Resetinformationen und die beiden Bits zur Wahl der Speicherbank

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''STATUS''' (ADDRESSE 03h, 83h, 103h, 183h)</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R-1</td>
<td style="width:60px;">R-1</td>
<td style="width:60px;">R/W-x</td>
<td style="width:60px;">R/W-x</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''IRP'''</td>
<td style="background:#f5f7ff;">'''RP1'''</td>
<td style="background:#f5f7ff;">'''RP0'''</td>
<td style="background:#f5f7ff;">'''TO'''</td>
<td style="background:#f5f7ff;">'''PD'''</td>
<td style="background:#f5f7ff;">'''Z'''</td>
<td style="background:#f5f7ff;">'''DC'''</td>
<td style="background:#f5f7ff;">'''C'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

*Bit 7 '''IRP''': Register Bank Select Bit (für indirekte Adressierung)
:: 1 = Bank 2, 3 (100h-1FFh)
:: 0 = Bank 0, 1 (00h-FFh)
*Bit 6-5 '''RP<1:0>''': Register Bank Select Bits (für direkte Adressierung)
:: 11 = Bank 3 (180h-1FFh)
:: 10 = Bank 2 (100h-17Fh)
:: 01 = Bank 1 (80h-FFh)
:: 00 = Bank 0 (00h-7Fh)
*Bit 4 '''TO''': Time-out Bit
:: 1 = Nach Power-up, CLRWDT Befehl oder SLEEP Befehl
:: 0 = A Watchdogtimer time-out ist eingetreten
*Bit 3 '''PD''': Power-Down Bit
:: 1 = Nach Power-up oder durch den CLRWDT
:: 0 = Nach einem SLEEP befehl
*Bit 2 '''Z''': Zero bit
:: 1 = Das Ergebnis einer arithmetischen oder logischen Operation ist 0
:: 0 = Das Ergebnis einer arithmetischen oder logischen Operation ist NICHT 0
*Bit 1 '''DC''': Digit carry/borrow bit (ADDWF, ADDLW, SUBLW und SUBWF Befehle)
:: 1 = Ein Carry-out des 4.Niedrigsten Bits (Low Nibble) eines Rechenergebnisses existiert
:: 0 = Kein Carry-out des 4.Niedrigsten Bits eines Rechenergebnisses existiert
*Bit 0 '''C''': Carry/borrow Bit (ADDWF, ADDLW, SUBLW und SUBWF Befehle)
:: 1 = Ein Carry-out des MSB eines Rechenergebnisses existiert
:: 0 = Kein Carry-out des MSB eines Rechenergebnisses existiert

Das "Carry/Borrow Bit" (to carry = etwas übertragen, to borrow = etwas borgen) dient zum erkennen, wenn ein Übertrag einer Rechenoperation exisitiert. 250d+10d ergibt zum Beispiel 4, und setzt dabei das "Carry/Borrow Bit" auf 1. Damit kann das Programm erkennen, wenn wieder einmal ein Ergebnis größer als 255d herauskam.
Bei Subtraktionen (SUBLW und SUBWF) verhält sich das "Carry/Borrow Bit" umgekehrt als bei Additionen (ADDWF und ADDLW)!! Zum Beispiel 55d-6=49d setzt "Carry/Borrow Bit" auf 1 aber 10d-25d=241d löscht das "Carry/Borrow Bit".

====Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Registers====

{|
|-
|
{| {{Blauetabelle}}
|+ Auswirkungen auf das STATUS-Register bei Subtraktionen
|-
| Ergebnis
|| STATUS,C
|| STATUS,Z
|-
| positiv
|align="center"|1
|align="center"|0
|-
| negativ
|align="center"|0
|align="center"|0
|-
| Null
|align="center"|1
|align="center"|1
|}

||

{| {{Blauetabelle}}
|+ Auswirkungen auf das STATUS-Register bei Additionen
|-
| Ergebnis
|| STATUS,C
|| STATUS,Z
|-
| positiv
|align="center"|0
|align="center"|0
|-
| Überlauf
|align="center"|1
|align="center"|0
|-
| Null
|align="center"|1
|align="center"|1
|}
|}

=== PORTx ===

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''PORTx'''</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''Rx7'''</td>
<td style="background:#f5f7ff;">'''Rx6'''</td>
<td style="background:#f5f7ff;">'''Rx5'''</td>
<td style="background:#f5f7ff;">'''Rx4'''</td>
<td style="background:#f5f7ff;">'''Rx3'''</td>
<td style="background:#f5f7ff;">'''Rx2'''</td>
<td style="background:#f5f7ff;">'''Rx1'''</td>
<td style="background:#f5f7ff;">'''Rx0'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

!Das "x" steht in allen Fällen für den Buchstaben des Ports!
BSP: "PORTB" oder "RA1"

Diese Special Funktion Register liegen ALLE in Bank0 und Bank2(Falls vorhanden).

Jedes Bit eines PORT-Registers steht für einen Pin (Ein/Ausgang) des jeweiligen Ports. Je nachdem Ob ein Pin als Ausgang oder als Eingang definiert ist, kann man dort entweder den Wert schreiben oder auslesen. Es hat nicht Jeder PIC gleich viele Ports und es sind auch nicht immer 8 Pins pro Port, es können auch weniger sein. Alle PICs der Midrange-Serie besitzen nur bidirektionale Ports, d.h. sie können sowohl Eingang als auch Ausgang sein. Bei Port B kann man bei allen Pins einen internen PULL-UP Widerstand mit dem Bit OPTION_REG<RBPU> hinzuschalten (Standardmäßig auf nicht aktiviert, Bit muss gelöscht werden um die Funktion zu aktivieren). Weiters ist zu beachten, dass einzelne Pins nach dem Reset mit anderen Funktionen belegt sein können. Das gilt im Speziellen für PORTA, wo sich die Komperatoren, AD's (falls vorhanden) und die Oszillatoreingänge befinden. Siehe [[PIC Assembler#I/O Ports|I/O Ports]]. Bei den "kleinsten" PICs der 12F Serie die nur einen I/O Port (6 Pins) haben, heisst der PORT-Register GPIO.
{|{{Blauetabelle}}
|+ Beispiel PICs und ihre Ports (Zahlen in der Klammer sind die Anzahl der Pins des Ports)
|
|'''PIC16F628A'''
|'''PIC16F876'''
|'''PIC16F877'''
|-
|'''PORTA'''
|Ja
|Ja(5)
|Ja(6)
|-
|'''PORTB'''
|ja
|ja
|ja
|-
|'''PORTC'''
|/
|ja
|ja
|-
|'''PORTD'''
|/
|/
|ja
|-
|'''PORTE'''
|/
|/
|ja (3)
|-
|}

=== TRISx ===

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''TRISx'''</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''TRISx7'''</td>
<td style="background:#f5f7ff;">'''TRISx6'''</td>
<td style="background:#f5f7ff;">'''TRISx5'''</td>
<td style="background:#f5f7ff;">'''TRISx4'''</td>
<td style="background:#f5f7ff;">'''TRISx3'''</td>
<td style="background:#f5f7ff;">'''TRISx2'''</td>
<td style="background:#f5f7ff;">'''TRISx1'''</td>
<td style="background:#f5f7ff;">'''TRISx0'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

!Das "x" steht in allen Fällen für den Buchstaben des Ports!
BSP: "TRISB" oder "TRISA"

Bei den "kleinsten" PICs der 12F Serie die nur einen I/O Port (6 Pins) haben, heisst der TRIS-Register TRISIO.

Die TRIS-Bytes dienen dazu, einzelne I/O Pins als Eingang oder Ausgang zu definieren. Sie liegen immer genau eine Bank über den jeweiligen PORT-Bytes, d.h. sie liegen alle in Bank1 und Bank3 (falls vorhanden.) Besonders zu beachten ist, dass manche Eingebaute Features wie die Serielle Schnittstelle, I2C, SPI usw nicht funktionieren, wenn die Jeweiligen Sende und Empfangspins nicht manuell umgestellt werden, ja es ''muss'' sogar manchmal umgestellt werden (bei I2C z.B.) Egal ist dies jedoch für Komperatoren und AD-Wandler.

Merke:
* Eine 1 (als "I" für "Input" zu lesen) eines TRISxx-Bits definiert den zugehörigen PIN am PIC als Eingang.
* Eine 0 (als "O" für "Output" zu lesen) eines TRISxx-Bits definiert den zugehörigen PIN am PIC als Ausgang.

Siehe [[PIC Assembler#I/O Ports|I/O Ports]].

=== INTCON ===

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''INTCON''' (ADDRESSE 0Bh, 8Bh, 10Bh, 18Bh)</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''GIE'''</td>
<td style="background:#f5f7ff;">'''PEIE'''</td>
<td style="background:#f5f7ff;">'''TMR0IE'''</td>
<td style="background:#f5f7ff;">'''INT0IE'''</td>
<td style="background:#f5f7ff;">'''RBIE'''</td>
<td style="background:#f5f7ff;">'''TMR0IF'''</td>
<td style="background:#f5f7ff;">'''INT0IF'''</td>
<td style="background:#f5f7ff;">'''RBIF'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

*Bit 7 '''GIE''': Global Interrupt Enable Bit
::1 = Aktiviert alle Interrupts
::0 = Deaktiviert alle Interrupts
*Bit 6 '''PEIE''': Peripheral Interrupt Enable Bit
::1 = Aktiviert alle peripheren Interrupts
::0 = Deaktiviert alle peripheren Interrupts
*Bit 5 '''TMR0IE''': TMR0 Overflow Interrupt Enable Bit (Overflow von Timer0 löst Interrupt aus)
::1 = Aktiviert den TMR0 Interrupt
::0 = Deaktiviert den TMR0 Interrupt
*Bit 4 '''INT0IE''': RB0/INT External Interrupt Enable Bit (Änderung an RB0 Pin löst Interrupt aus) *)
::1 = Aktiviert den RB0/INT Interrupt (Extern ausgelöst)
::0 = Deaktiviert den RB0/INT Interrupt (Extern ausgelöst)
*Bit 3 '''RBIE''': RB Port On-Change-Interrupt Enable Bit (Änderung an PortB löst Interrupt aus) **)
::1 = Aktiviert den RB port on-change-interrupt
::0 = Deaktiviert den RB port on-change-interrupt
*Bit 2 '''TMR0IF''': TMR0 Overflow Interrupt Flag Bit
::1 = TMR0 Register ist Übergelaufen (muss per Software gelöscht werden)
::0 = TMR0 register ist nicht Übergelaufen
*Bit 1 '''INT0IF''': RB0/INT External Interrupt Flag Bit
::1 = Eine Änderung an RB0/INT Pin hat stattgefunden (muss per Software gelöscht werden)
::0 = Eine Änderung an RB0/INT Pin hat nicht stattgefunden
*Bit 0 '''RBIF''': RB Port On-Change-Interrupt Flag bit
::1 = Mind. einer der Pins von RB7:RB4 hat sich geändert (muss per Software gelöscht werden)
::0 = Keiner der Pins von RB7:RB4 hat sich geändert

* *) Die Flanke auf die reagiert werden soll, wird mit dem Bit OPTION_REG.INTEDG definiert. (steigende = 1 oder fallende = 0)
* **) Der Interrupt klingt verführerischer Weise so, als ob er den gesamten Port überwacht. Dabei reagiert er nur auf RB7:RB4!!!! Er kann aber den Prozessor vom "Schlaf" aufwecken (z.B. durch einen Tastendruck).

==Speicherbankorganisation==
===Programmspeicher===
Die Mid-Range MCUs haben einen 2-8k großen Programmspeicher. Dieser hat aber in jeder Speicherzelle nicht 8, sondern 14 Bit - also genau die Länge eines Befehls. Die aktuelle Stelle im Programm wird im PC (Program Counter) verwaltet. Er speichert immer die aktuelle Adresse im Programmspeicher (wird im Code oft als "$" bezeichnet). Bei einem PIC mit 8k Adressen muss er also die Adressen 0000-1FFF speichern können. Daraus folgt die Größe von 13 Bit für den PC. Der Programmspeicher ist in mehrere Bänke geteilt, die alle 2k groß sind. Das Programm springt ohne zutun des Benutzers von einer in die Nächste. Wenn man aber selber springen will, muss man die Register PCLATH (Program Counter Latch High) oder PCL (Program Counter Least Significant Byte) mit der Sprungadresse beschreiben.

===Datenspeicher===
Der Datenspeicher besteht aus den Special Function Registern (SFR) und den General Purpose
Registern (GPR). Die SFRs sind für die Funktionen des PICs zuständig (Interrupts, Timer, ADCs, CCPM...) und die GPRs für die Speicherung von Variablen und Daten.

Da immer nur 7 Bit der (Ziel)Adresse in einem Befehl gespeichert werden können, sind nur 7Fh (128d) Adressen im Datenbereich möglich. Deswegen wurde das "Banking" eingeführt. 2 Bit im Statusregister (welcher in allen Bänken der selbe ist und auch an der gleichen Stelle sitzt) geben die akutelle "Bank" an und sind nichts anderes als die 2 höchstwertigsten (MSB) Bits der Adresse. Damit lassen sich max. 4 Bänke ansprechen. Je nach PIC gibt es 2-4 Bänke. Die beiden Bits im Register STATUS heißen RP0 (STATUS<5>) und RP1 (STATUS<6>).

{| {{Blauetabelle}}
|+ Wechseln der Bänke mit RP0 und RP1
|-
|
|| RP1
|| RP0
|-
| Bank0
|align="center"|0
|align="center"|0
|-
| Bank1
|align="center"|0
|align="center"|1
|-
| Bank2
|align="center"|1
|align="center"|0
|-
| Bank3
|align="center"|1
|align="center"|1
|}

[[Bild:PIC midrange register.JPG]]
# '''FETTE Register''' sind in allen PICs vorhanden
# können je nach PIC unimplementierte Bereiche beinhalten - diese werden immer als 0 gelesen. (DATENBLATT!!)
# siehe 2
# Könnten je nach PIC auch nicht in Bank0 gemapped werden, sind dann eigenständige Register.
# je nach PIC kann es diese Bänke geben oder nicht geben.

== Codeschnipsel ==

=== Analog-Digital-Wandler (ADC) ===

Viele PICs besitzen einen Analog-Digital-Wandler, der eine angelegte Spannung messen kann und diese als Zahl speichert.

Es gibt AD-Wandler mit 8Bit bzw. 10Bit Auflösung, d.h. die Spannung an einem analogen Eingang wird linear 2^8=256 bzw. 2^10=1024 Werten zugeordnet.
Der höchste Wert, auch Referenzspannung genannt, (255 bzw. 1023; der Controller rechnet die Null auch mit) entspricht der Betriebsspannung des PICs oder wahlweise einer wählbaren Spannung, die an RA3 angelegt werden muss. Der niedrigste Wert entspricht 0 Volt.

Mit dem Analog-Digital-Wandler kann man somit z.B. Sensoren auswerten, die mehr als zwei Zustände ausgeben (Beispiele: Temperatursensor, Helligkeitssensor, Entfernungssensoren usw.) oder Akkuspannungen messen.

Bevor überhaupt gemessen werden kann, muss einiges eingestellt werden:

* Eingangsverteilung Analog/Digital bzw.Referenzspannung (Betriebsspannung oder RA3)
die genauen Einstellungsmöglichkeiten entnehmen sie bitte dem Datenblatt ihres Controllers (Register ADCON1 Bank 1).

* Wählen des Taktes für den ADC und Einschalten des ADCs

Das Register ADCON0 besitzt 8 Bits, die folgendes bestimmen:
Bit0 ADON - schaltet AD-Wandler ein oder aus (Strom sparen)
Bit1 - nicht vorhanden
Bit2 GO/Done - startet Wandlung / signalisiert, wann Umwandlung beendet ist.
Bit3 CHS0 - Channel Select 0 wählt Eingang aus
Bit4 CHS1 - Channel Select 1 wählt Eingang aus
Bit5 CHS2 - Channel Select 2 wählt Eingang aus
Bit6 ADCS0 - AD-Clock-Select wählt Takt
Bit7 ADCS1 - AD-Clock-Select wählt Takt

Kümmern wir uns zunächst um den Takt. Mit den zwei Bits ADCS0 und ADCS1 bestimmt man den Takt - hierbei gibt es vier Möglichkeiten:

ADCS1=0, ADCS0=0 -> Taktfrequenz des PICs :2
ADCS1=0, ADCS0=1 -> Taktfrequenz des PICs :8
ADCS1=1, ADCS0=0 -> Taktfrequenz des PICs :32
ADCS1=1, ADCS0=1 -> interner RC-Oszillator des ADCs verwenden

Die Taktfrequenz des ADCs darf 625kHz nicht überschreiten, dementsprechend ist ADCS0 und ADCS1 zu wählen.

Ist dies vollbracht, so kann man den AD-Wandler einschalten und das Go/Done-Bit löschen.
Codebeispiel:

bcf ADCON0,6 ;Takt für
bsf ADCON0,7 ;ADC (OSC/32)
bsf ADCON0,0 ;ADC einschalten, ADON=1
bcf ADCON0,2 ;Go/Done-Bit zurücksetzen

Nun ist der AD-Wandler bereit, Spannungen in Zahlen umzuwandeln.
Für eine Wandlung muss erst der entsprechende Eingang gewählt werden. Dafür sind die CHS0..CHS2-Bits zuständig:

CHS2 CHS1 CHS0 gewählter Eingang(falls vorhanden)
0 0 0 RA0
0 0 1 RA1
0 1 0 RA2
0 1 1 RA3
1 0 0 RA5
1 0 1 RE0
1 1 0 RE1
1 1 1 RE2

Achtung! RA4 ist kein analoger Eingang, folglich ist er oben nicht aufgelistet !!

Codebeispiel:

bcf ADCON0,3 ;RA2 auswählen
bsf ADCON0,4
bcf ADCON0,5

Als letztes muss die AD-Routine nur noch gestartet werden. Ist der AD-Wandler fertig, so löscht er das Bit wieder. Das Bit wird nun solange abgefragt, bis der AD-Wandler fertig ist. Den zugeordneten Wert findet man im Register 'ADRES'.
Code:

bsf ADCON0,2 ;start
wa btfsz ADCON0,2 ;warten,bis es wieder low ist
goto wa ;noch nicht fertig
;jetzt ist er fertig
movf ADRES,W ;ADRES in W verschieben, um damit gleich weiter zu arbeiten

Die AD-Wandlung ist somit fertig. Liest man mehrere Werte von unterschiedlichen Eingängen ein und möchte diese miteinander vergleichen o.ä., sollte man die Zahlen von ADRES in anderen Registern zwischenspeichern.

Desweiteren ist zu beachten, dass der Analog-Digital-Wandler eine gewisse Pause zwischen den Wandlungen benötigt, die sog. 'Aquisition Time'. Diese Zeitangabe entnehmen sie bitte ihrem Datenblatt.

mögliche Probleme:

;Der PIC liefert stark schwankende Werte
:-> Mögliche Ursachen dafür sind z.B. nicht stabile Betriebsspannung, falsche Zeiteinstellungen. Abhilfe schafft auch das mehrmalige Einlesen eines Eingangs. Auch können z.B. 8 Werte eingelesen werden und dann der Durchschnitt gebildet werden.
Evtl. kann ein Kondensator gegen Masse (z.B. 1nF) helfen; Wichtig ist auch eine kleine Verzögerung zwischen Kanalauswahl und Start der Wandlung. In dieser Zeit kann sich der interne Kondensator des ADC's aufladen.

;Die Spannung an einem Eingang wird erhöht, die Werte der anderen Eingänge werden aber auch beeinflusst.
:-> Dann sind Sie Opfer des sog. 'Ghostings' geworden (Werte 'scheinen durch', verschleißen). Die Werte der anderen Eingänge gehen mit, weil der interne Kondensator noch auf die Spannung des Vorgängers aufgeladen ist. Maßnahme: Aquisition Time erhöhen, Werte öfters abfragen, Pause zwischen Kanalauswahl und Start

;Der PIC liefert immer die gleichen Werte an einem Eingang, obwohl sich die angelegte Spannung ändert
:-> möglicherweise falsche Eingangsverteilung (ADCON1) eingestellt oder falschen Pin gewählt

=== Hex Dec Wandlung ===

Das ist ein Unterprogramm das mit "call Hex_Dec" aufgerufen wird. Es gibt 4 Register (A, B, C und D) mit jeweils 32 Bits, die aus jeweils 4 Register mit 8 Bits (z.B. fur A: A3, A2, A1 und A0) bestehen.

A3 A2 A1 A0
.--------.--------.--------.--------.
|76543210|76543210|76543210|76543210|
'--------'--------'--------'--------'
| |
|<----------- A Register ---------->|

Sie müssen (wegen FSR) so wie im Code nacheinander liegen (die absoluten Adressen sind nicht wichtig). In das Register "A" wird die hex Zahl eingeschrieben und aus dem "D" die umgewandelte dec Zahl ausgelesen. A3,7 und D3,7 sind MSB und A0,0 und D0,0 sind LSB. Die "B" und "C" sind Hifsregister. Das UP kann für kleinere als 32-bittige hex Zahlen modifiziert werden. Zum Beispiel für 16-bittige hex Zahlen bleiben nur Register A1,A0,B1,B0,C1,C0,D1,D0 und in den UPs werden in die Register und als X, folgende Zahlen eingeschrieben: HTmp->0x10 (Anzahl Bits der hex Zahl),ATmp->2=X (Anzahl Bytes der hex Zahl). Es müssen auch die UPs "CClr", "DClr" und "CopyCB" entschprechend der Registerlänge angepasst werden. Genauso kann natürlich das UP auch für längere hex Zahlen modifiziert werden.

Das UP "AddCB" addiert dezimal die 32- bittige Register C und B, das Ergebniss befindet sich in C.
Das UP "AddDC" addiert dezimal die 32-bittige Register D und C, das Ergebniss befindet sich in D.

Die 32-bit Additionen werden in 4 Schritten wie folgt realisiert:

C0+B0->C0, C1+B1->C1, C2+B2->C2 und C3+B3->C3

D0+C0->D0, D1+C1->D1, D2+C2->D2 und D3+C3->D3

Die Flags "_Fcra", "_Fcrp" und "_Fdca" steuern die alle nötigen Korrekturen.

Die Wandlung wird in 32 Schritten laut folgender Formel durchgeführt:

Zahl(d)=B0*2^0+B1*2^1+B2*2^2+B3*2^3+B4*2^4+B5*2^5+B6*2^6+B7*2^7+B8*2^8+B9*2^9+B10*2^10+B11*2^11+

B12*2^12+B13*2^13+B14*2^14+B15*2^15+B16*2^16+B17*2^17+B18*2^18+B19*2^19+B20*2^20+B21*2^21+

B22*2^22+B23*2^23+B24*2^24+B25*2^25+B26*2^26+B27*2^27+B28*2^28+B29*2^29+B30*2^30+B31*2^31

Wobei B0 bedeutet den LSB und B31 den MSB der hex Zahl.

Die dec Zahl wird im D Register durch "AddDC" gebildet. In dem C Register befindet sich immer die laufende 2^X. Am Anfang wird dort 1=2^0 geladen. Da die nächste zu addierende dec Zahl immer gleich 2* vorherige ist, wird sie einfach so berechnet, dass die aktuelle aus C Register ins B Register kopiert ("CopyCB") und zum C addiert ("AddCB") wird. Diese dec Zahl wird zum D Register addiert nur wenn entsprechender Bit der hex Zahl gleich 1 ist. Weil im UP "Hex_Dec" immer das bit A0,0 dafür geprüft wird, wird das gesamte 32-bittige A Register nach jeder Addition "AddDC" um ein Bit mit "ARotRb" nach rechts rotiert. Die Flags "_Fcra" und "_Fcrp" übertragen die Bits zwischen den 8 Bit Register A0, A1, A2 und A3. Es würde zwar reichen, wenn das A Register nur verschoben würde, aber hier wurde Rotation gewählt, damit nach der Wandlung die hex Zahl im A Register unverändert steht. Weil die dec Zahl nur 8-stellig ist, die max. hex Zahl darf 99999999d = 5F5E0FFh sein.

#define _C STATUS,C
#define _Z STATUS,Z
#define _DC STATUS,DC
#define _Fcra Flags,0
#define _Fcrp Flags,1
#define _Fdca Flags,2
#define _Ferr Flags,3 ;Überlauf (Fehler)
;..................................................................................
A3 EQU 0x20 ;Register fürs Rechnen
A2 EQU 0x21
A1 EQU 0x22
A0 EQU 0x23
B3 EQU 0x24
B2 EQU 0x25
B1 EQU 0x26
B0 EQU 0x27
C3 EQU 0x28
C2 EQU 0x29
C1 EQU 0x2A
C0 EQU 0x2B
D3 EQU 0x2C
D2 EQU 0x2D
D1 EQU 0x2E
D0 EQU 0x2F
Flags EQU 0x30
ATmp EQU 0x31 ;Schleifenzähler
HTmp EQU 0x32 ;Schleifenzähler
RTmp EQU 0x33 ;Zwischenspeicher
;..................................................................................
Hex_Dec call CClr ;Hex>A, D>Dec
call DClr
movlw 1
movwf C0
movlw 0x20 ;32 bit Hex > 32 bit Dec (8 Stellen)
movwf HTmp
HexDecL btfsc A0,0
call AddDC
call CopyCB
call AddCB
call ARotRb
decfsz HTmp,1
goto HexDecL
return
CClr clrf C0
clrf C1
clrf C2
clrf C3
return
DClr clrf D0
clrf D1
clrf D2
clrf D3
return
CopyCB movf C0,0
movwf B0
movf C1,0
movwf B1
movf C2,0
movwf B2
movf C3,0
movwf B3
return
AddCB movlw B0 ;C+B>C
movwf FSR
goto AddR
AddDC movlw C0 ;D+C>D
movwf FSR
AddR bcf _Ferr ;Addiere zwei Register
bcf _Fcrp
movlw 4 ;X=4 Bytes lang
movwf ATmp
AddRL bcf _Fdca
bcf _Fcra
movf INDF,0
movwf RTmp
movlw 4 ;X=4
addwf FSR,1
btfss _Fcrp
goto AddRN
movlw 1
addwf INDF,1
call DecCor
AddRN movf RTmp,0
addwf INDF,1
call DecCor
btfss _Fdca
goto AddCor1
movlw 6
addwf INDF,1
AddCor1 btfss _Fcra
goto AddCor2
movlw 0x60
addwf INDF,1
btfsc _C
bsf _Fcra
AddCor2 movf INDF,0
andlw 0xF0
sublw 0xA0
btfss _Z
goto AddCor3
movf INDF,0
andlw 0x0F
clrf INDF
addwf INDF,1
bsf _Fcra
AddCor3 bcf _Fcrp
btfsc _Fcra
bsf _Fcrp
movlw 5 ;X+1=5
subwf FSR,1
decfsz ATmp,1
goto AddRL
btfsc _Fcra
bsf _Ferr
return
DecCor btfsc _DC ;dezimale Korrektur (equ DAW)
bsf _Fdca
btfsc _C
bsf _Fcra
movf INDF,0
andlw 0x0F
sublw 9
btfss _C
bsf _Fdca
movf INDF,0
andlw 0xF0
sublw 0x90
btfss _C
bsf _Fcra
return
ARotRb movlw A3 ;rotiere A register 1 Bit rechts
movwf FSR
RRotRb movlw 4 ;rotiere X=4 Bytes
movwf ATmp
bcf _Fcrp
btfsc A0,0
bsf _Fcrp
RRotRbL bcf _Fcra
btfsc INDF,0
bsf _Fcra
bcf _C
btfsc _Fcrp
bsf _C
rrf INDF,1
bcf _Fcrp
btfsc _Fcra
bsf _Fcrp
incf FSR,1
decfsz ATmp,1
goto RRotRbL
return

=== EEPROM ===

Alle PICs besitzen EEPROM in dem je nach Typ können 64 bis 256 Databytes abgespeichert werden. Die Adressierung des EEPROMs fängt immer mit 0x00 an. Hier werden nur geprüfte UPs kurz erklärt. Die ersten zwei brauchen nur ein Register "Temp" für Schleifenzähler, dessen Name, falls im Programm schon existiert, geändert werden muss. Die Adresse im EEPROM ist gleich der Adresse im RAM.

EEPROM beschreiben:

EEWrite movlw 0x20 ; ab der RAM Adresse wird in EEPROM abgespeichert
movwf FSR
movlw 4 ; soviel Bytes
movwf Temp ; Schleifenzähler
EEWLoop call EEWrite1
incf FSR,1 ; nächste Adresse
decfsz Temp,1
goto EEWLoop
return

EEWrite1 bcf INTCON,GIE ; Interrupts sperren
movf FSR,0
bsf STATUS,RP0 ; auf Bank1 umschalten
movwf EEADR ; EEPROM Adresse
movf INDF,0
movwf EEDATA ; EEPROM Data
bsf EECON1,WREN
movlw 0x55
movwf EECON2
movlw 0xAA
movwf EECON2
bsf EECON1,WR
bcf EECON1,WREN
btfsc EECON1,WR
goto $-1 ; warten bis WR=0
bcf STATUS,RP0 ; zurück auf Bank 0 umschalten
bsf INTCON,GIE ; Interrupts erlauben
return

EEPROM lesen und zurück in RAM schreiben:

EERead movlw 0x20 ; ab der Adressse wird aus EEPROM in RAM abgelegt
movwf FSR
movlw 4 ; soviel Bytes
movwf Temp ; Schleifenzähler
EERLoop call EERead1
incf FSR,1 ; nächste Adresse
decfsz Temp,1
goto EERLoop
return

EERead1 movf FSR,0
bsf STATUS,RP0 ; auf Bank1 umschalten
movwf EEADR ; EEPROM Adresse
bsf EECON1,RD
movf EEDATA,0 ; EEPROM Data
bcf STATUS,RP0 ; zurück auf Bank 0 umschalten
movwf INDF
return

Tabelle im EEPROM mit MPASM Direktive "de" erstellen:

org 0x2100 ; EEPROM initialisieren
; nachfolgend als Kommentar die EEPROM Adressen
de 0x03, 0xE8 ; 0x00
de 0x03, 0xE8 ; 0x02
de 'M','H','z',0x00 ; 0x04
de ' ',' ','W','A','I','T',0x00 ; 0x08
de 'C','o','n','s','t',' ','X',0x00 ; 0x0F
de 'C','=',0x00 ; 0x17
de 'L','=',0x00 ; 0x1A
de 'F','=',0x00 ; 0x1D
de 'O','K',0x00 ; 0x20
u.s.w.

Wenn die Tabelle sich im Quellcode befindet, wird sie beim brennen des PICs in EEPROM eigeschrieben.

Das Lesen eines Strings muss ab entsprechender EEPROM Adresse (z.B. für "MHz" -> 0x04) anfangen und auf dem Wert 0x00, der hier als Stringende dient, enden. Einfacher ist, wenn alle Strings gleich lang sind (wie z.B. in einem Zeichengenerator fur Grafikdisplay).

Die Adreesse "0x2100" in der "org" Direktive hat mit der Adresse im Programmspeicher nichts zu tun.

=== Interrupts ===

Das Programmteil misst eine Frequenz an TOCKI Pin und wurde für PIC16F870 geschrieben.

Benötigte Hardware: Widerstand 470 Ohm zwischen der Frequenzquelle und TOCKI Pin (A4).

Es fehlen UPs "Hex_Dec" [[#Hex Dec Wandlung|Hex Dec Wandlung]] und Ausgabe auf ein Display "DispFrq". Das HP ("Main") als leere endlose Schleife macht nichts ausser warten auf ein Interrupt von Timer0 bzw. Timer1. Man kann die Marke "Main" weglassen und das HP als "goto $" formulieren.

Da der Timer0 nicht, wie der Timer1 durch ein Flag gestartet und gestoppt werden kann, wird es durch setzen und löschen des Bits für TOCKI (A4) Pin im TRISA Register, genauso wie in der AN592 vom Microchip, gemacht.

Der Zähler der Frequenz wurde um ein Zähler aus zwei zusätzlichen Register A2 und A3 erweitert und bei jedem Timer0 Überlauf erhöht. Der Prescaler wird ins Register A0 und der TIMER0 ins A1 kopiert. Somit ergibt sich 32-bittiges Ergebniss, der als hex Zahl in den Register A3 (MSB),A2, A1, und A0 (LSB) steht. Nach der "Hex_Dec" Wandlung kann die Frequenz aus den Register D3 (MSB), D2, D1 und D0 (LSB) an einem biliebigen Display angezeigt werden.

Es wird kein zusätzliches Register benötigt, da das "ATmp" und das "RTmp" die gleichen wie im UP "Hex_Dec" sind. Die Quarzfrequenz wurde gewählt, weil sie am nächsten der Temperaturstabiltesten Frequenz für AT Quarzen 7,2 MHz ist. Der PIC16F870 wurde nur wegen nötigen 19 I/O Pins für 6-stelligen 7-segment LCD Display LPH2673-1[[http://www.roboternetz.de/phpBB2/viewtopic.php?t=26005]] (ohne Kontroller) vom Pollin angewendet. Mit einem üblichen 1x16 Zeichen LCD Matrixdisplay und anderen PICs wurde das Programm für Frequenzen bis zum 80 MHz mit einer Genauigkeit
+/- 4 Hz positiv getestet.

Um die Frequenz mit Genauigkeit +/- 1Hz zu messen, muss die Messzeit 1 s von Timer1 erzeugt werden, das nur für Quarz bis 2,048 MHz möglich ist. Für sehr genaue Messungen wird empfohlen als Taktfrequenz für den Timer1, die Trägerfrequenz eines nächsten LW Senders (z.B. DLF 153 bzw. 207 kHz) zu nutzen. Die Genauigkeit der Frequenz ist ca. 1E-11 und geprüfter Empfänger kann laut der Skizze in [[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=13706&highlight=frequenzz%E4hler]] nachgebaut werden. In dem Fall müssen die Register vom Timer1 (TMR1H und TMR1L) vor seinem Start entsprechend geladen werden.

Mit dem Quarz 7,3728 MHz wird hier die Messzeit 0,25 s genutzt und die gemessene Frequenz durch 4 multipliziert (mittels 2 Additionen), was die Auflösung von +/- 4 Hz ergibt.

Das UP "Init" muss selbstverständlich für ein Matrixdisplay um Initialisierung des Displaykontrollers ergänzt werden.

; Programm zum Messen der Frequenz an T0CKI Pin mit 7,3728 MHz Quarz
LIST P=16F870
include "P16F870.inc"
__CONFIG _CP_OFF & _DEBUG_OFF & _WRT_ENABLE_ON & _CPD_OFF & _LVP_OFF & _BODEN_OFF &
_PWRTE_ON & _WDT_OFF & _HS_OSC
ORG 0x0000
call Init
Main goto Main
ORG 0x0004 ;ISR (interrupt service routine)
bcf INTCON,GIE ;interrupts sperren
btfss INTCON,T0IF ;ist Timer0 übelaufen ?
goto CheckTMR1 ;nein, dann prüfe Timer1
bcf INTCON,T0IF ;Timer0 interrupt flag löschen
movlw 1
addwf A2,1 ;erhöhe A2
btfsc STATUS,C
incf A3,1 ;increment A3, wenn A2 überlaufen ist
CheckTMR1 btfss PIR1,TMR1IF ;ist Timer1 überlaufen ?
retfie ;wenn nicht, springe zurück zu Main
bsf STATUS,RP0 ;stopp Timer0
movf TRISA,0
andlw 0xEF
movwf TRISA ;TOCKI Pin (A4) als Ausgang
bcf STATUS,RP0
bcf T1CON,TMR1ON ;stopp Timer1
bcf PIR1,TMR1IF ;Timer1 interrupt flag löschen
GetFreq movf TMR0,0 ;Prescaler ins Register A0 kopieren
movwf A1
movwf RTmp
clrf ATmp
FToggle incf ATmp,1
bsf STATUS,RP0
bsf OPTION_REG,T0SE
bcf OPTION_REG,T0SE
bcf STATUS,RP0
movf TMR0,0
subwf RTmp,0
btfsc STATUS,Z
goto FToggle
comf ATmp,1
incf ATmp,0
movwf A0
call Hex_Dec
clrf A3 ;Register A löschen
clrf A2
clrf A1
clrf A0
call CopyDC
call AddDC ;gemessene Frequenz * 2
call CopyDC
call AddDC ;gemessene Frequenz * 4 = tatsächliche Frequenz
call DispFrq ;eigenes UP für benutztes Display
clrf TMR0 ;Timer0 löschen
movlw 0x34 ;Timer1
movwf T1CON ;konfigurieren
movlw 0x1F ;Timer1 laden (für 0,25 s)
movwf TMR1H
clrf TMR1L
bsf STATUS,RP0 ;start Timer0
movf TRISA,0
iorlw 0x10
movwf TRISA ;TOCKI Pin (A4)als Eingang
bcf STATUS,RP0
bsf T1CON,TMR1ON ;start Timer1
retfie ;erlaube interrupts und springe zurück zu Main
CopyDC movf D0,0
movwf C0
movf D1,0
movwf C1
movf D2,0
movwf C2
movf D3,0
movwf C3
return
Init clrf PORTA ;Ports löschen
clrf PORTB
clrf PORTC
movlw 0x20 ;RAM (20-7Fh) löschen
movwf FSR
clrf INDF
incf FSR,1
btfss FSR,7
goto $-3
clrf ADCON0 ;schalte ADC off
movlw 7 ;sperre ADC
movwf ADCON1 ;und definiere RA0-7 als digitale I/Os
movlw 0xE0 ;GIE, PEIE & TMR0IE erlauben
movwf INTCON
bsf STATUS,RP0 ;bank 1
clrf TRISA ;alle PORTA,
clrf TRISB ;alle PORTB,
clrf TRISC ;und alle PORTC Pins als Ausgänge
movlw 0xE7 ;Takt für Timer0 vom T0CKI Pin
movwf OPTION_REG ;Timer0 konfigurieren
bsf PIE1,TMR1IE ;TMR1 interrupt erlauben
bcf STATUS,RP0 ;Bank 0
clrf TMR0 ;Timer0 löschen
movlw 0x34 ;Timer1 konfigurieren
movwf T1CON ;(prescaler 8)
movlw 0x1F ;Timer1 laden (für 0,25 s)
movwf TMR1H
clrf TMR1L
bsf STATUS,RP0 ;start Timer0
iorlw 0x10
movwf TRISA ;TOCKI Pin (A4) als Eingang
bcf STATUS,RP0
bsf T1CON,TMR1ON ;start Timer1
return
end

=== Mausrad ===

Das UP wertet ein Mausrad aus und setzt, je nach Drehrichtug und sein Anschluss an PORT (PORTB,0 und PORTB,1), ein Flag "_Finc" bzw. "_Fdec", das vor der nächsten Abfrage, gelöscht werden muss. Diese Flags können z.B. für Inkrementierung und Dekrementierung von Zählern dienen.

Die Hardware:

Mausrad
.-------.
| o---> PORTB,0
+----o---- |
| | o---> PORTB,1
=== '-------'
GND

Es müssen die internen pull-ups vom PORTB aktiviert werden. Wenn das Mausrad an anderen PORT angeschlossen wird, werden externe pull-ups (z.B. 10 kOhm) benötigt. Als "_Z" wurde "STATUS,Z" definiert. Zum Auswerten werden 4 Register "MausA", "MausB", "MausC" und "Flags" gebraucht, die im gesamten Programm definiert werden müssen. Die Warteschleife "Delay" soll ca. 10ms sein.

In dem UP "Mouse" wird PORTB eigelesen, die alle Bits ausser 0 und 1 durch "and" Funktion gelöscht und in den Register "MausB" und "MausC" gespeichert. Nach ca. 10ms wird das gleiche gemacht und im Register "MausA" gespeichert. Der Wert aus "MausA" wird mit dem vorherigen aus "MouseC" durch "xor" verglichen. Sind sie nicht identisch, wird je nach dem Wert "X" (0, 1, 2, b.z.w. 3) im "MausB" in das entsprechende UP "MouseX" gesprungen. Sonst, wenn "MausA"="MausC", wird zum Aufrufer zurückgekehrt.

In einem UP "MouseX" wird der letzte Wert im "MausA" ermittelt und nach der Kombination der Werte im "MausB" und "MausA" (01 b.z.w. 02, 10 b.z.w. 13, 20 b.z.w. 23 oder 31 b.z.w. 32) entsprechendes der Drehrichtung Flag "_Finc" b.z.w. "_Fdec" gesetzt. Anschliessend wird zum Aufrufer zurückgesprungen.

Detailierter PAD:

Mouse V
PORTB->W
3 and W->W
W->MausB
W->MausC
Warten 10ms
PORTB->W
3 and W->W
W->MausA
W xor MausC->MausC
_Z=1 ? J > return
N
V
MausB->MausB
.--------------------------< J _Z=1 ?
| N
| V
| MausB->W
| 1-W->W
| .----< J _Z=1 ?
| | N
| | V
| | MausB->W
| | 2-W->W
| | _Z=1 ? J >---------------------------.
| | N |
| | V |
| | MausB->W |
| | 3-W->W |
| | _Z=1 ? J >-----. |
| | N | |
| | V | |
| | return | |
| | | |
| | | |
Mouse0 V Mouse1 V Mouse3 V Mouse2 V
MausA->W MausA->MausA MausA->W MausA->MausA
1-W->W V 1-W->W V
_Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--.
J | J | J | J |
V | V | V | V |
setze _Fdec | setze _Finc | setze _Finc | setze _Fdec |
V<-----´ V<-----´ V<-----´ V<-----´
MausA->W MausA->W MausA->W MausA->W
2-W->W 3-W->W 2-W->W 3-W->W
_Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--.
J | J | J | J |
V | V | V | V |
setze _Finc | setze _Fdec | setze _Fdec | setze _Finc |
V<-----´ V<-----´ V<-----´ V<-----´
return return return return

und Quellcode:

Mouse movf PORTB,0
andlw 3
movwf MausB
movwf MausC
call Delay ; ca. 10 ms
movf PORTB,0
andlw 3
movwf MausA
xorwf MausC,1
btfsc _Z
return
movf MausB,1
btfsc _Z
goto Mouse0
movf MausB,0
sublw 1
btfsc _Z
goto Mouse1
movf MausB,0
sublw 2
btfsc _Z
goto Mouse2
movf MausB,0
sublw 3
btfsc _Z
goto Mouse3
return
Mouse0 movf MausA,0
sublw 1
btfsc _Z
bsf _Fdec
movf MausA,0
sublw 2
btfsc _Z
bsf _Finc
return
Mouse1 movf MausA,1
btfsc _Z
bsf _Finc
movf MausA,0
sublw 3
btfsc _Z
bsf _Fdec
return
Mouse2 movf MausA,1
btfsc _Z
bsf _Fdec
movf MausA,0
sublw 3
btfsc _Z
bsf _Finc
return
Mouse3 movf MausA,1
sublw 1
btfsc _Z
bsf _Finc
movf MausA,0
sublw 2
btfsc _Z
bsf _Fdec
return

=== Handy Display ===

Als Beispiel die Hardware und Testprogram für Nokia 3310/3330 Display: [[http://www.roboternetz.de/phpBB2/viewtopic.php?p=124669#124669]]

= Hilfsmittel =

Hier werden einige Programme presentiert, die das ASM Programmieren erleichtern.
Damit sie möglichst wenig Data- und Programmspeicher benötigen, sind alle Zahlen auf dem Display in der hex Darstellung.
Für alle, die es in Dezimalsystem haben wollen, ist ein Taschenrechner mit hex<->dec Wandlung nötig.

== PIC Miniterminal ==

Das ist eine Schnittstelle, die nur 2 Leitungen zum Anschluss an PIC braucht. Sie ermöglicht Steuern von diversen LCD Displays mit üblichem Anschluss ("RS", "Enable" und 8 Databits) und Abfragen von 3 Tasten.

Sie wird mit einem 2x16 Zeichen Matrixdisplay und 3 Tasten für weiter beschriebene Hilfsprogramme verwendet.

Hardware und Testprogramm: [[http://www.roboternetz.de/phpBB2/viewtopic.php?t=13685]]

[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Category:PIC]]

PIC Assembler

2007-05-05T06:25:19Z

Andy: /* Bit, Byte, Nibble, Bin und Hex */

= Einladung zur Diskussion... =

Es wird hier versucht die ASM Programmierung von PIC Mikrocontrollern möglichst kurz zu beschreiben.

Damit der enstehende Artikel wirklich nützlich wird, ist Ihre Mitwirkung nötig. Bitte schreiben Sie uns Ihre Meinung, was eventuell noch geändert (z.B. ergänzt) werden soll in diesem Thread:

http://www.roboternetz.de/phpBB2/viewtopic.php?p=271211#271211

Die Autoren bedanken sich im voraus für jeden Beitrag mit Vorschlägen !

= Einführung =

== Bit, Byte, Nibble, Bin und Hex ==

Ein Mikrocontroller (kurz: µC) kann eigentlich nur durch ein Portpin eine Spannung einlesen bzw. ausgeben. Er kann aber nur erkennen, ob eine Spannung vorhanden ist oder nicht. Wenn fast keine Spannung vorhanden ist erkennt er das als 0 und wenn eine Spannung fast so gross, wie seine Versorgungsspannung anliegt, als 1.

Genauso bei der Ausgabe, wenn er 0 ausgibt ist auf dem Portpin fast keine Spannung, wenn 1, eine Spannung fast gleich gross seiner Versorgungsspannung. Und das ist ein Bit, die kleinste Menge einer Information. Das Bit ist binär, d.h. es kann nur zwei unterschiedliche Werte haben: 0 oder 1.

Wenn wir gleichzeitig (parallel) 8 Bits haben, dann ist es ein Byte, das 256 Bitkombinationen von 00000000b bis 11111111b enhält, weil ein Bit (X) auf jeder Stelle 0 bzw. 1 sein kann.

<table border=0 cellpadding=3 cellspacing=2>

<tr>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
</tr>

<tr>
<td colspan=4 align=middle bgcolor=#007fff>High Nibble </td>
<td colspan=4 align=middle bgcolor=#ff8305>Low Nibble </td>
</tr>
<tr>
<td colspan=8 align=middle bgcolor=#810f40> Byte </td>
</tr>
</table>

Das "b" bedeutet, dass es sich um binäre (kurz: bin) Darstellung (auch Zahl genannt) handelt. Binäre Zahlen sind aber lang, weil jedes Bit eine Stelle benötigt.

Um die Schreibweise zu verkürzen, wurden hexadezimale (kurz: hex) Zahlen eingeführt. Zuerst wurde ein Byte auf zwei 4-Bit Halbbytes (Nibbles) verteilt und danach ein Nibble als Ziffer genommen. Weil 4 Bits 16 Kombinationen ergeben, haben die Ziffer 0 bis 9 aus dem Dezimalsystem (d) nicht ausgereicht und wurden um Buchstaben A bis F erweitert. Die hexadezimalen Zahlen haben ein "h" Zeichen am Ende. Für die Zahlen 0 bis 9 sind die (h) und
(d) Zeichen nicht nötig, da sie beide gleich den entsprechenden bin Zahlen sind.

Die Umwandlung zwischen bin, hex und dec Zahlen für ein Nibble zeigt folgende Tabelle:

0b = 0h = 0d 100b = 4h = 4d 1000b = 8h = 8d 1100b = Ch = 12d
1b = 1h = 1d 101b = 5h = 5d 1001b = 9h = 9d 1101b = Dh = 13d
10b = 2h = 2d 110b = 6h = 6d 1010b = Ah = 10d 1110b = Eh = 14d
11b = 3h = 3d 111b = 7h = 7d 1011b = Bh = 11d 1111b = Fh = 15d

Damit kann ein Byte mit zwei hex Ziffern definiert werden z.B. 1100 0011b = C3h. Für zwei Bytes braucht man 4 hex Ziffern z.B.

101 0111 1010 1001b = 57A9h, u.s.w. Für MPASM wird sehr oft die Schreibweise für hex Zahlen 0x57A9 oder 0xC3 benutzt.

So wie im Dezimalsystem werden führende Nullen nicht geschrieben. Bei einer Wandlung bin->hex fängt man immer von der rechten Seite der bin Zahl an, da die Anzahl führender Nullen unbekannt ist.

== Speicher und Register ==

Als Speicher bezeichnet man das Teil der Hardware, in das eine Information geschrieben, gespeichert und von dort wieder ausgelesen werden kann.

Es gibt eigentlich nur zwei Arten von elektronischen Speichern: flüchtige und nichtflüchtige. Die Information die sich im flüchtigen Speicher befindet, geht verloren, wenn die Versorgungsspannung des Speichers unterbrochen oder abgeschaltet wird. Bei PICs ist es Datenspeicher (RAM).

Wenn die Versorgungsspannung vom nichtflüchtigen Speicher abgeschaltet wird, ist die gespeicherte Information zwar momentan nicht lesbar, bleibt aber erhalten und sobald der Speicher wieder mit Spannung versorgt wird, kann sie ausgelesen werden. Ein PIC hat zwei solche Speicher: Programmspeicher (Flash) und EEPROM.

Der wichtigste Unterschied zwischen den Speicherarten ist, dass die flüchtigen direkt (sehr schnell) beschreibbar sind, dagegen das Beschreiben des nichtflüchtigen Speichers spezielle Algorithmen benötigt, die im Vergleich zu direkten Zugriffen langsamer sind. Beim Auslesen gibt es praktisch keinen Unterschied.

Speicher besitzen eine bestimmte Menge von s.g. Speicherstellen. Jede Speicherstelle hat eine individuelle Adresse und kann eine binäre Information mit bestimmter Anzahl von Bits abspeichern.

PIC Prozessoren haben drei Arten von Speicher, wegen verschiedener Anwendung, auch unterschiedliche Struktur. Die beiden Speicher für Daten (RAM und EEPROM) haben jeweils 8 Bit Breite und Programmspeicher (Flasch) bei Mid-Range hat 14-bitige Speicherstellen. Die Anzahl den Speicherstellen im bestimmten Speicher ist vom PIC-Typ abhängig.

Eine 8-bitige Speicherstelle im RAM wird bei PICs Register genannt und kann so skizziert werden:

<table border=0 cellpadding=3 cellspacing=2>

<tr>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
</tr>

<tr>
<td> MSB </td>
<td colspan=6></td>
<td> LSB </td>
</tr>

<tr>
<td bgcolor="#007fff">bit 7</td>
<td bgcolor="#007fff">bit 6</td>
<td bgcolor="#007fff">bit 5</td>
<td bgcolor="#007fff">bit 4</td>
<td bgcolor="#007fff">bit 3</td>
<td bgcolor="#007fff">bit 2</td>
<td bgcolor="#007fff">bit 1</td>
<td bgcolor="#007fff">bit 0</td>
</tr>

<tr>
<td colspan=4 align=middle bgcolor=#ff8305>High Nibble </td>
<td colspan=4 align=middle bgcolor=#ff8305>Low Nibble </td>
</tr>
<tr>
<td colspan=8 align=middle bgcolor=#810f40> Byte </td>
</tr>
</table>

Bit 7 wird als hochwertigstes (MSB = Most Significant Bit) und bit 0 als niederwertigstes (LSB = Least Significant Bit) bezeichnet. Jeder Bit im Register (X) kann gleich 0 bzw. 1 sein. In einem Register existieren immer 8 Bits also auch führende Nullen. Zum Beispiel die hex Zahl 3 sieht im PIC Register so aus: 00000011.

Um ein Databyte in ein Register zu schreiben oder aus einem Register zu lesen, muss zuerst das Register durch seine Adresse gewählt werden. Dafür gibt es beim PIC folgende Möglichkeiten:

Direkte Adressierung per absolute Adresse: movwf 0x20

Direkte Adressierung per vorher definierten Namen des Registers (z.B. Temp equ 0x20): movwf Temp

Indirekte Adressierung durch "FSR" Register, in das die absolute Adresse des Registers "Temp" eingeschrieben wird und der Wert aus "Temp" sich im "INDF" Register befindet. Wie vorher wurde "Temp equ 0x20" definiert und weiter:

movlw Temp ;ins W-Register wird die absolute Adresse des Registers "Temp" geladen
movwf FSR ;diese Adresse wird ins "FSR" Register kopiert
movf INDF,0 ;der Wert aus dem indirekt adressierten Register "Temp", der sich jetzt
;im "INDF" befindet, wird ins W-Register geladen.

Weil in jedem 14-bittigen Befehl, der mit Datenspeicher verbunden ist, für die Adresse des ansprechenden Registers nur 7 Bits existieren, die bis zur Adresse 7Fh (128d) Register direkt ansprechen können, ist bei PICs der Datenspeicher (RAM) in s.g. Bänke verteilt.

Für Auswahl einer Bank sind zwei Bits "RP0" und "RP1" im "STATUS" Register zuständig. Die Anzahl der Bänke und ihre Verwendung ist von der gesamten Größe des RAMs abhängig und kann dem Datenblatt des PICs entnommen werden. Siehe: [[#Speicherbankorganisation|Speicherbankorganisation]]

== Prozessor ==

Der Prozessor von Mid-Range PICs gehört zu den RISC (Reduced Instruction Set Computer) Prozessoren und man hat nur 35 Befehle zu erlernen, was seine Programmierung im Vergleich zu anderen µCs deutlich vereinfacht. Jeder Befehl benötigt im Programmspeicher nur eine Speicherstelle und im Quellcode nur eine Zeile. Die Ausführung des Befehls dauert, abhängig vom Befehl, 1 bis 2 Prozessortakte.

Die Prozessoren der Mid-Range Serie von Microchip sind alle in der "Harvard"-Architektur gefertigt. Das bedeutet, dass Datenspeicher und Programmspeicher einen eigenen Bus zur CPU (Central Processing Unit) besitzen. Der Vorteil zur "von Neumann"-Architektur ist, dass sich die Busgrößen damit unterscheiden können. Das ermöglicht eine größere Bandbreite.

Der Befehl (beim PIC 14 bit) kann in nur einem Takt verarbeitet werden. Daher kommt auch das Aufteilen der Ausführung des Befehls in 4 verschiedene Vorgänge. Wärend der neue Befehl eingelesen ("fetch") wird, wird der vorige gerade gelesen ("read") und der vorvorige verarbeitet ("execute") und der vorvorvorige schreibt gerade in den Datenspeicher ("write"). Das heißt, 4 Befehle werden jeweils um einen Oszillatortaktzyklus verschoben gleichzeitig verarbeitet.

Das geschieht in vier Perioden des Oszillators. Deswegen entspricht die Taktfrequenz der CPU der durch 4 geteilten Frequenz des Oszillators.

CPU Vorgang Richtung Speicher
------------------------------------------------- -
1.Befehl lesen (fatch) <------- Flash |
2.Daten lesen (read) <------- RAM | 1 Prozessortakt =
3.Daten verarbeiten (execute) | 4 Oszillatortakte
4.Daten schreiben (write) -------> RAM |
-

Nur o.g. CPU Vorgänge sind direkt möglich. Es können deswegen keine Befehle aus dem RAM oder EEPROM ausgeführt werden. Um ein Databyte aus einem RAM Register in ein anderes zu kopieren, muss er zuerst aus dem ersten RAM Register in das W-Register (eigenen s.g. Arbeitsregister des CPU) und erst davon in das zweite RAM Register kopiert werden.

Der Prozessor hat kleinen eigenen Speicher, der weder zum Programmspeicher noch zum Datenspeicher gehört. Er besteht aus dem Programmzähler PC (programm counter) und dem Stapel (stack).

In dem PC befindet sich die 13-Bittige Adresse des momentan ausfürbaren Befehls. Nach der Ausführung jedes Befehls wird der PC um 1 erhöht und "zeigt" somit auf den nächsten Befehl im Programmspeicher, der zum Ausführen wäre. Wenn der nächste Befehl aber ein Sprung ("call") ist, wird die Adresse aus dem Befehl genommen. Nach dem Sprung wird das Programm bis zum Befehl "return" ausgeführt und danach muss der Prozessor zurückspringen, und zwar, genau zur nächsten Adresse im Programmspeicher nach dem "call" Befehl. Damit es möglich wäre, wird vor dem Sprung die Adresse aus dem PC "auf dem Stapel gelegt" (gespeichert). Für den Rücksprung wird die abgelegte Adresse "aus dem Stapel genommen" (vom Stapel in den PC geladen).

Der Stapel kann aber nur 8 Adressen speichern, deswegen dürfen nur 8 nacheinander folgende "call" Befehle benutzt werden. Sonst findet der Prozessor nicht mehr zurück und in die "Nirvana" springt, was einen Absturz des Programms bedeutet.

Das Lesen/Schreiben aus/in den EEPROM Speicher ist mit Hilfe speziellen Register und Unterprogrammen bei allen Mid-Range PICs möglich. Der Lese und Schreibzugriff auf den Programmspeicher ist aber nur bei wenigen PIC-Typen (z.B. PIC16F87X) möglich. Dies ermöglicht ein "sich selbst Programmieren", was bei Bootloadern genutzt wird.

== Assembler ==

Die Maschinensprache, auch Assembler oder kurz ASM genannt, ist eine Sprache die nur eine bestimmte CPU versteht. Für einen Menschen ist sie unverständlich, da sie nur aus 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 einen CPU hat somit ein "Namen", der aus der englischen Sprache stammt. Siehe: [[#Kurzübersicht Assembler Befehle|Kurzübersicht Assembler Befehle]]

Obwohl sie 200 bis 1000 mal schneller als die meisten Hochsprachen ist, wird sie, wegen des grossen Aufwands bei der Erstellung von umfangreichen Programmen, selten benutzt. Man findet sie aber oft in fast allen Hochsprachen, in eigebundenen Funktionen, überall dort wo die Hochsprachen zu langsam sind oder die nötigen Aufgaben nicht unterstützen (z.B. Maus in Q-Basic).

ASM eignet sich sehr gut für kleine Anwendungen (meistens Steuerungen) mit µC, weil nur bei dieser Programmiersprache ein direkter Zusammenhang zwischen einem Bit im Programm und einer Spannung am I/O Pin besteht.

Dank der integrierten oder an Portpins angeschlosenen Hardware und dem entsprechenden Program kann ein µC umfangreiche Aufgaben realisieren, die fast unbegrenzt und schwer vorstellbar sind.

Die Aufgabe eines ASM-Programmierers ist, ein Programm zu schreiben, das das Assemblerprogramm (z.B. MPASM) fehlerfrei in die Machinensprache assembliert ("übersetzt"), die dann eine bestimmte CPU "versteht". Sie endet eigentlich erst dann, wenn das geschriebene Programm so wie geplant funktioniert.

Die beste Methode um ASM Programmierung zu lernen ist einfach mit den Befehlen, wie mit "LEGO" Bausteinen, zu spielen. Der PIC kann durch ein Programmfehler nicht kaputtgehen. Vorsicht ist nur bei der angeschlossener Hardware nötig, da ein Fehler den PIC oder die Hardware sogar "töten" kann.

Weil ASM Programme nicht besonders durchschaubar sind, wurde als Hilfsmittel ein Programmablaufdiagramm (kurz: PAD) erfunden. Bei der 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 [http://gputils.sourceforge.net/ GPASM]) von dem für Menschen noch verständlichen Code in die Maschinensprache assembliert 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 Homepage des Herstellers von PICs [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en019469&part=SW007002] runtergeladen werden. Es muss zuerst vom Downloads die "MPLAB IDE v7.50 Full Zipped Installation" runtergeladen und erst danach können gewählte Programme (z.B. nur MPASM) intalliert werden. Für MPASM benutzer werden auch folgende ".pdf" Dateien empfohlen:

MPASM/MPLINK User's Guide (2628 KB) [Benutzerhandbuch]

MPASM™/MPLINK™ PICmicro® Quick Chart (81 KB) [Kurzübersicht]

Nach dem Eischalten der Betriebsspannung des µC, fängt der CPU an, sich im Programmspeicher befindliches Programm mit dem Befehl, der an der Adresse 0 steht, auszuführen.

Aber wann das Programm endet? Natürlich wenn die Versorgungsspannung abgeschaltet wird. Nein! Das ist die einfachste Lösung um ein laufendes Programm an zufälliger Stelle zu unterbrechen,
aber keine, um es an einer definierten Stelle zu beenden.

Wenn an den µC angeschlossene externe Hardware (z.B. Grafikdisplay), eine bestimmte Befehlsfolge vor dem Abschalten benötigt oder wichtige Daten (in EEPROM oder Flash) abgespeichert werden sollen, darf die Spannung erst dann abgeschaltet werden, wenn die CPU eine Meldung ausgibt, dass sie sich schon auf der "STOP" Stelle des Programms befindet. Es muss auch
definiert werden (z.B. durch eine Tastenkombination), wann die CPU zum letzten Fragment des ASM Programms vor dem "STOP" gehen soll.

== Grundbeschaltung ==

Der Prozessor von einem PIC kann sofort nach dem Einschalten der Versorgungsspannung (z.B. + 5V DC) arbeiten. Allerdings nur, wenn er den Takt, in dem er die Befehle ausführen soll, vorgegeben hat. Manche PICs besitzen einen internen RC-Oszillator, (z.B. PIC12F629, PIC16F630, PIC16F628, u.s.w.). Bei diesen reicht es bereits Spannung anzulegen und sie laufen bereits.
Die meisten haben ihn aber nicht (z.B. PIC16F84, PIC16F870, u.s.w.) und brauchen fürs Funktionieren zusätzliche Bauteile. Grundsätzlich gibt es mehrere Möglichkeiten:

* Quarz oder Keramik-Resonator + 2 Kondensatoren (LP,HS oder XT)
* Keramik-Resonator mit integrierten Kondensatoren (HS oder XT)
* Quarzoszillator (EC); genau und stabil
* Widerstand + Kondensator (RC); keine hohe Frequenzstabilität

Die entsprechenden Bauteile werden an die Pins OSC1/OSC2 angeschlossen, um den notwendigen Prozessortakt zu erzeugen. Im Konfiguration-Word "__config" muss noch angegeben werden, welcher Oszillator verwendet wird.

Desweiteren existiert ein MCLR-Pin, der beim PIC einen Neustart (=Reset) auslösen kann (Low-Pegel). Diesen Pin sollte man, wenn er in "__config" aktiviert ist, über einen Widerstand (pull-up) an Versorgungsspannung legen, damit der PIC anfängt, sein Programm abzuarbeiten. Der Anschluss wird auch für die Programmierung benötigt. Beim sog. High-Voltage-Programming wird MCLR auf ca. 12-14 Volt gelegt, um den PIC in den Programmiermodus zu schalten. Bei manchen PICs kann dieser Anschluss auch als normalen I/O Pin eingestellt werden. In dem Fall, bei ICSP Benutzung, soll noch eine Diode zwischen den pull-up und Versorgungsspannung angeschlossen werden, um die an MCLR Pin angeschlossene Hardware während der Programmierung zu schützen.

Bei externen Oszillatoren bleibt der Pin OSC2 nicht angeschlossen und kann als I/O benutzt werden. Falls ein interner Oszillator benutzt wird, können beide OSC Pins als I/O dienen.

Damit ein Programm zuverlässig ausgeführt werden kann, muss die Versorgungspannung störungsfrei sein. Dafür wird ein Keramik-Vielschicht-Kondensator 100 nF möglichts am kürzesten direkt zwischen VDD und VSS Pins geschaltet.

Folgende Skizzen zeigen die Grundbeschaltung eines PICs:

{|
|-
|
[[Bild:Pic-entstoer.png|thumb|160px|Entstörkondensator beim PIC]]
|
[[Bild:Qz-os.png|thumb|160px|Quarz ]]
|
[[Bild:Qos-os.png|thumb|160px|externer Quarzoszillator]]
|
[[Bild:Rc-os.png|thumb|160px|externer RC-Oszillator]]
|}

== Konfiguration ==

Die Konfiguration eines PICs wird beim "brennen" fest programmiert. Sie ist eigentlich für fast jeden PIC-Typ anders. Um Probleme zu vermeinden, muss sie für bestimmten PIC aus einer im MPASM Verzeichnis enthaltenen Datei "PXXFXX.INC" entnommen werden. Die Erklärung der Optionen befindet sich im entsprechenden Datenblatt unter "Special Features of the CPU"

Als Beispiel für PIC16F84 haben wir in der Datei "P16F84.INC":

;==========================================================================
;
; Configuration Bits
;
;==========================================================================

_CP_ON EQU H'000F'
_CP_OFF EQU H'3FFF'
_PWRTE_ON EQU H'3FF7'
_PWRTE_OFF EQU H'3FFF'
_WDT_ON EQU H'3FFF'
_WDT_OFF EQU H'3FFB'
_LP_OSC EQU H'3FFC'
_XT_OSC EQU H'3FFD'
_HS_OSC EQU H'3FFE'
_RC_OSC EQU H'3FFF'

Wobei:

_CP_ON - Programmspeicher ist vorm Auslesen geschützt
_CP_OFF - Programmspeicher kann ausgelesen werden (ist nicht geschützt)
_PWRTE_ON - Das Programm wird mit Verzögerung von ca. 72 ms nach dem Einschalten gestartet
_PWRTE_OFF - Das Program wird sofort nach dem Einschalten gestartet
_WDT_ON - Watchdog Timer ist aktiv
_WDT_OFF - Watchdog Timer ist unaktiv

Die alle folgende Optionen beziehen sich an den Oszillatortyp:

_LP_OSC - Oszillator bis ca. 200 kHz (z.B. Uhrenquarz 32768 Hz)
_XT_OSC - Oszillator bis ca. 3,5 MHz
_HS_OSC - Oszillator über 3,5 MHz (z.B. 4 MHz)
_RC_OSC - Externer RC Oszillator

Die Konfiguration wird im Quellcode (*.asm Datei) mit Direktive "__config" definiert, z.B. so:

__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _XT_OSC

Alle Optionen müssen groß geschrieben sein, genauso wie in der "*.inc" Datei.

== Wahl des PICs ==

Es gibt PIC µC die in der Typenbezeichnung den Buchstaben "C" oder "F" haben.

Die älteren mit "C" haben EPROM Programmspeicher und die gibt es in zwei Versionen: ohne und mit Fenster (aus Quarz-Glass) fürs Löschen des EPROMs mit UV Strahlung. Bei denen ohne Fenster kann der Programmspeicher nur einmal beschrieben und nicht mehr gelöscht werden.

Die neuen mit "F" besitzen einen Flash-Programmspeicher, der bis zu 100 000 mal mit angelegter Spannung gelöscht und danach neu beschrieben werden kann.

Für die Wahl eines PICs für bestimmte Anwendung wichtig sind:

- Max. Taktfrequenz des Prozessors.

- Grösse des Datenspeichers (für Variablen).

- Grösse des Programmspeichers (für Programm).

- Integrierte Hardware (Komparatoren, A/D Wandler, Timer, USART, I²C, SPI, PWM, u.s.w.).

- Freie I/O Pins für externe Hardware (Display, Tasten, u.s.w.).

- Vorhandene Betriebspannung (Netzteil, Akku, Batterie).

In der Praxis wird meistens für die Programmerstellung ein grösserer PIC genommen (wenn möglich pinkompatibler z.B. PIC16F628 für PIC16F84 oder PIC16F630 für PIC12F629) und erst nach der Optimierung des lauffägiges Programms, der tatsächlich nötige, da seine Parameter am Anfang nur geschätzt werden können. Wenn man viele Programme für verschiedene PICs entwickelt, wäre der größte PIC16F877 mit 20 MHz max. Taktfrequenz optimal.

Diese Lösung hat auch den Vorteil, dass während der Programmerstellung kurze Hilfsprogramme (z.B. PIC Trainer) in den Programmspeicher kopiert und benutzt werden können, da sie sowohl ein bischen Programmspeicher und RAM als auch 2 freie I/O Pins fürs PIC Miniterminal brauchen.

= Programm =

== Allgemeines ==

Jedes Program kann man in kleinere Fragmente unterteilen, die auf bestimmte Weise miteinander verknüpft sind und gemeinsam die Aufgabe des Programms erfüllen. Das wichtigste Teil eines Programms ist das s.g. Hautprogram (kurz:HP), das eine führende Rolle spielt. Dem HP sind fast 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 komplizierter, da ein UP auch ein oder mehrere UPs nacheinander aufrufen kann. Ganz unten sind die UP1s, die ganz einfache Sachen erledigen. Höher ist 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 ohne Tricks maximal bis zu 8 Ebenen benutzt werden, da auf dem Stapel (stack) nur max. 8 Rücksprungadressen abgespeichert werden können. Siehe hierzu: [[#Prozessor|Prozessor]] und [[#Programmspeicher|Programmspeicher]]

<center>
[[Bild:HP-UP.png|Hauptprogramm - Unterprogramm]]
</center>

Jedes UP kann jederzeit aufgerufen werden, je nach dem was gerade eledigt werden muss. Weil das nicht egal ist, welches UP aufgerufen wird, da jedes nur eine bestimmte Funktion im Programm hat, muss der Programmierer dafür sorgen, dass alles richtig nach Programablaufdiagramm, und nicht chaotisch, abläuft.

Die Programmierung in ASM ist ähnlich 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 Programm kopieren oder einbinden und ein geeignetes HP, das sie aufruft, schreiben.

Ein ASM Programm (Quellcode) muss in einer Texdatei mit der Endung ".asm" in der vom Assemblerprogramm erwarteten Form verfasst werden, um die fehlerfreie Konvertierung in die Maschinensprache (Assemblierung) zu gewährleisten. Dieser Prozess verläuft in der Form eines Dialoges.

Der Programmierer schreibt und gibt es dem Assemblerprogramm zum Übersetzen. Alles was der Assembler nicht versteht oder nicht richtig ist, erscheint als Fehlermeldungen, die der Programmierer kennen muss, um die Fehler korrigieren zu können. Eine ".hex" Datei wird erst dannn erstellt, wenn das Assemblerprogramm keine Fehler mehr im Quellcode findet. Deswegen ist es sehr wichtig, sich mit dem Assemblerprogramm vertraut zu machen, um die Dialogzeit zu minimieren.

== Programmdurchlaufdiagramm ==

Der Programdurchlaufdiagram (kurz: PAD) ist eine vorläufige und laufend änderbare Stufe zwischen einer Idee und ihrer Verwirklichung. Die Kreativität des Programmierers ist nur für die Erstellung des PADs nötig. Jedes sein Symbol (ausser "Start/Stop") muss als Befehlsreihenfolge für einen bestimmten Prozessor in den Quellcode übertragen werden. Das ist aber nur reine "Übersetzung". Der Quellcode ist nur eine andere Form des PADs und hoffentlich wird es zukünftig Komputerprogramme geben, die ein PAD direkt in eine "*.hex" Datei für bestimmten Prozessor wandeln werden. Zur Zeit muss die "Übersetzung" leider vom Programmierer gemacht werden. Der PAD wird erst dann fertig, wenn nach ihm erstelltes ASM Program auf einem µC so wie gewünscht funktioniert.

Die Anschriften "Ein" und "Aus" gehören nicht zu Symbolen des PADs und wurden nur zur Erklärung benutzt.

[[Bild:PAD_beispiel.png|thumb|80px|Beispiel für ein PAD]]

Der PAD ist sehr eifach zu erstellen, weil dafür nur drei Symbole benötigt sind:
<center>
[[Bild:PAD_kurz.png|Symbole des PAD]]
</center>
Das "Start/Stopp" Symbol bedeutet, dass das gesamte Programm sich im stabilen Zustand befindet und nicht "läuft". Anstatt "Stopp" kann auch "Schlaf" (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 eines Programms, endweder in der "ja" (J) oder "nein" (N) Richtung.

Als allgemeinnutziges Standard für µCs kann man folgender PAD bezeichnen:

PAD _____
/ \
Spannung ein (Ein) ----->( Start )
\_____/
| -
V |
.---------------. |
|Initialisierung| |
'---------------' |
| |
.--------->V |
| .---------------. |
| | Hauptprogramm | |
| '---------------' |
| | |
| V |
| A |
| / \ > Gesamtes Programm
| / \ |
| /Ende \____ |
| \ ? / J | |
| \ / | |
| \ / | |
| V | |
| N| | |
`----------´ | |
V |
.---------------. |
| Beenden | |
'---------------' |
| |
V -
_____
/ \
Spannung aus (Aus) <-------------( Stopp )
\_____/

Das Hauptprogram wird in einer endlosen Schleife ausgeführt, die durch die Prüfung "Ende?" unterbrochen werden kann. In dem Fall wird vor dem Beenden des gesammten Programms noch ein UP "Beenden" ausgeführt, das z.B. Daten im EEPROM speichert.

Es ist nicht nötig, immer die Symbole zu zeichnen, man kann sie sich vorstellen und nur den Text schreiben. Die Prüfungen werden mit "?" gekenzeichnet und die Zeichen "V", "A", "<" und ">" zeigen die Richtung des weiteren Verlaufs. Dann sieht der PAD so aus:

Ein > Start
V -
Initialisierung |
.------->V |
| Hauptprogramm > Gesamtes Programm
| V |
| Ende? J > Beenden |
| N V -
| V Stopp > Aus
`--------´

Man kann auch die unbedeutenden Richtungspfeilen weg lassen:

PAD1 Ein > Start _
Initialisierung |
.------->V | Gesamtes
| Hauptprogramm | Programm
| Ende? J > Beenden _|
| N Stopp
| V V
`--------´ Aus

In der Praxis werden aus Platzgründen meistens die vereinfachten PADs benutzt. Als "movxx" wird oft ein Zeichen "->" benutzt. Zum Beispiel "A->W" bedeutet, dass der Inhalt des A Registers ins W-Register geladen (kopiert) wird. Ausserdem werden Zeichen ("+", "-", "*", "/", "^", u.s.w.) für arithmetische und ("&", "or", "xor", u.s.w.) für logische Operationen angewendet. In den Quellcode werden für diese Zeichen entsprechende Befehle geschrieben. Beispiel:

V
10h->W
W+B->B
V

wird im Quelcode so aussehen:

...........
movlw 10h
addwf B,1
...........

Siehe auch: [[#Das erste...|Das erste...]] und [[#Mausrad|Mausrad]]

Der PAD1 kann aber für Hauptprogramme, die in beliebigem Moment unterbrochen werden dürfen, deutlich vereinfacht werden, da die Prüfung "Ende?" ob das Hauptprogram beendet werden soll, und das UP "Beenden", entfallen.

Die meisten ASM Programme für µC sind deswegen nach solchem PAD erstellt:

PAD2 Ein > Start _
Initialisierung |
.------->V |
| Hauptprogramm > Gesamtes Programm
| V |
`--------´ _|

Für Testprogramme wird meistens fogender PAD angewendet, weil es ziemlich einfach festzustellen
ist (z.B. durch Stromverbrauchmessung des µCs), wann sich die CPU schon im Schlaf befindet. Erst dann, darf die Betriebspannung des µCs ausgeschaltet werden.

PAD3 Ein > Start _
Initialisierung | Gesamtes
Hauptprogramm _| Programm
Schlaf > Aus

Und eine batteriebetriebene Uhr wird überwiegend so gestaltet:

PAD4 Ein > Start _
Interrupt Initialisierung |
Timer------------------------->V > Gesamtes Programm
Hauptprogramm _|
Schlaf

In dem Fall reicht es aus, wenn der CPU jede Minute vom Timer aufgeweckt wird, um die Zeit zu aktualisieren. Eine Uhr ist immer (ausser Batteriewechsel) ununterbrochen mit Spannung versorgt.

Für komplizierte Programme ist es praktisch unmöglich ein PAD zu erstellen, in dem jeder CPU Befehl sein eigenes Symbol hat. Man beschränkt sich nur auf alle Prüfungen, die über den Lauf des Programms entscheiden, und ganze UPs (z.B. "Initialisierung") nur als ein Symbol verwendet. Für jedes UP wird dann ein eigener PAD erstellt.

Das Erstellen von PAD bei ASM Programmen ist sehr wichtig und darf nicht unterschätzt werden. Je stärker ein Programmierer glaubt, dass er das ohne PAD schafft, um so mehr Zeit wird er danach bei Fehlersuche oder Änderungen im ASM Programm verlieren.

Beispiel aus dem Alltag:

"Das programm hat anfangs auf Anhieb funktioniert. Doch leider habe ich dann was geändert was ich nicht mehr weiß. Das Programm macht nun komische Sachen...... Ich kann mir nicht erklären warum, kann mir jemand helfen???"

Für einfache ASM Programme, die gut kommentiert sind, reicht es meistens aus, ein PAD nur "im Kopf" zu erstellen, aber ganz ohne PAD geht es sicher nicht.

Der PAD kann auch benutzt werden, um einen "fremden" Code verständlich zu machen. In dem Fall werden alle Befehle (Zeilen) aus der Quellcode nacheinander in PAD Symbole umgewandelt und daraus ein PAD erstellt.

== Hauptprogramm ==

Wie sein Namen schon vermuten lässt, ist das Hauptprogram das wichtigste Teil des gesamten Programms. Meistens ist es auch das kleinste Teil, vor allem, wenn die UPs sehr komplex sind. Seine Aufgabe ist die benötigte UPs in bestimmter Reihenfolge nacheinander aufzurufen, um die alle Funktionen des gesamten Programms zu realisieren.

Das HP ist meistens als endlose Schleife, wie im PAD2, aufgebaut. Weil die endlose Schleife sehr schnell läuft, werden alle durch die UPS realisierten Aufgaben quasi gleichzeitig ausgeführt. Wenn es unerwünscht ist, müssen einige UPs als Verzögerungen realisiert werden.

Typischer PAD für ein HP sieht so aus:

Haupt .--->V
| UP1
| UP2
| ...
| UPn
| V
`----´

In den Quellcode wird es so eigeschrieben:

Haupt call UP1
call UP2
...........
call UPn
goto Haupt

In der Praxis wird das HP schrittweise erstellt. Am Anfang wird sich nur ein Aufruf vom UP im HP befinden und die folgenden kommen nach Erstellung und Prüfen weiteren UPs dazu, bis das HP fertig wird.

== Unterprogramm ==

Unterprogramm wird durch übergeordnetes Programmteil (Aufrufer) aufgerufen und nach seinem Ausführen, wird zurück zum Aufrufer gesprungen. Der Rückkehr zum Aufrufer wird durch "return" Befehl, der sich am Ende jedes UPs befinden muss, erreicht. Und das ist der einzige Unterschied zwischen einem HP und einem UP.

Jedes UP hat folgender PAD:

vom Aufrufer ------------>V
Tun
V
zurück zum Aufrufer <----------return

Ein HP von einem ASM Programm kann in anderem, mehr umfangreichem ASM Program als UP benutzt werden, wenn der sich am Ende des HPs befindlicher Befehl "goto" durch "return" ersetzt wird. Ein Beispiel dazu:

Haupt1 call UP11 Haupt1 call UP11
call UP21 call UP21
........... -------> ...........
call UPn1 call UPn1
goto Haupt1 return

Jetzt können wir im mehr komplexen HP (Haupt) das Haupt1 als Unterprogramm aufrufen:

Haupt call UP1
call Haupt1
...........
call UPn
goto Haupt

Jedes UP kann auch von einem anderen übergeordneten UP aufgerufen werden, wenn das was es realisiert, benötigt wird.

In der Praxis wird oft ein UP von mehreren anderen UPs benutzt. Zum Beispiel um LCD Display zu steuern, brauchen wir entweder ein Befehl (Cmd) oder ein Zeichen (Data) an Display zu schicken. In beiden Fällen wird ein Byte geschickt, einmal mit RS=0 (Befehl) und einmal mit RS=1 (Zeichen) laut folgendem PAD:

"Cmd" "Data"
RS=0 RS=1
V V
`-->V<--´
"Send" Byte schicken
V
return

Das wird in den Quellcode z.B. so eingeschrieben:

Cmd bcf RS
goto Send
Data bsf RS
Send ............
return

Das UP "Send" ist den UPs "Cmd" und "Data" untergeordnet, da es von beiden benutzt wird, kann aber weder "Cmd" noch "Data" benutzen.

=== Initialisierung ===

Damit der PIC ein Programm asführen kann, muss er vollständig und richtig initialisiert werden. Deswegen als erstes UP, das von dem gesamten Programm noch vor dem HP aufgerufen wird , ist "Initialisierung" (kurz: Init)

==== Variablen ====

Weil sich nach dem Einschalten der Spannung im RAM zufällige Werte befinden, wird meistens als erstes der benutzte Bereich des RAMs (z.B. 20h bis 7Fh) gelöscht. Es wird einfach und sparsam mit einer Schleife erledigt, die indirekte Adressierung verwendet:

V
Adresse des ersten Registers in FSR laden (20h)
.-------------------->V
RAMClr |Indirekt adressierter Register löschen (INDF)
| Adresse erhöhen
| Letzte Adresse + 1 (80h) J > Return
| N
| V
`---------------------´

Es wird wie folgt in Quellcode eingeschrieben:

movlw 0x20
movwf FSR
RAMClr ,->clrf INDF
| incf FSR,1
| btfss FSR,7
`-<goto RAMClr
return

Um Anzahl den Marken (label) zu verringern, wird oft ein Symbol "$" benutzt. Es bedeutet die Adresse der aktuellen Befehlszeile. Es kann also auch so eingeschrieben werden:

movlw 0x20
movwf FSR
,->clrf INDF
| incf FSR,1
| btfss FSR,7
`-<goto $-3 ; springe zu aktueller Adresse -3
return

Danach können den benötigtenen Variablen die gewünschte Werte zugewiesen werden:

movlw 0x3C
movwf LimH
movlw 0x5A
movwf LimL
u.s.w.

Somit sind die Variablen initialisiert.

==== I/O Ports ====

Nach dem Einschalten der Spannung sind die für Komparatoren oder A/D Wandler benutzte Pins als analoge Eingänge initialisiert. Wenn sie alle als digitale I/Os verwendet werden sollen, müssen sie als solche definiert werden. Das geschieht durch Schreiben des Wertes 7 in das entsprechende Register (CMCON bzw. ADCON1):

movlw 7 b.z.w. movlw 7
movwf CMCON movwf ADCON1

Wenn einige als analoge Eingänge benutzt werden sollen, müssen die entsprechende Werte dem Datenblatt des jeweiligen PICs entnommen werden.

Danach werden alle Ports nacheinander gelöscht und die gewünschte Werte die an den Pins vor dem Start des Hauptprogramms ausgegeben werden sollen, geschrieben:

clrf PORTA
movlw 0x37
movwf PORTA
usw.

Anchliessend werden für jeden Port die Werte in TRIS Register eingeschrieben, wobei ein Bit einem Pin entspricht. Ein Pin wird in TRIS Register durch 1 als Eingang und durch 0 als Ausgang definiert. Beispielweise beim PORTB sollen B7,B5 und B3 als Eingänge und restliche Pins als Ausgänge definiert werden. Das ergibt den Wert 10101000b = A8h, der in den TRISB Register geschrieben werden muss. Weil die alle TRIS Register sich in der höheren Bank befinden, muss im STATUS-Register auf entsprechende Bank und danach zurück auf Bank 0 umgeschaltet werden. Zum Beispiel für die TRASB in der Bank1:

bsf STATUS,RP0
movlw 0xA8
movwf TRISB
bcf STATUS,RP0

Bei einem Umschalten der Bank können selbstverständlich alle TRIS Register, die in der gleichen Bank liegen, nacheinander beschrieben werden. Siehe : [[#PORTx|PORTx]] und [[#TRISx|TRISx]]

Bei dem PORTA gibt es Pins, die nur "open drain" Ausgang haben (können nur auf GND schalten) b.z.w. nur als Eingang benutzt werden können. Bei Plannung der Verwendung von PORTA muss immer im Datenblatt geprüft werden, ob sich ein bestimmter Pin für die geplannte Anwendung eignet.

==== Hardware ====

Die für ASM Programm benutzte Hardware kann auf integrierte und externe geteilt werden. Für eine Initialisierung der integrierten Hardware (Komparatoren, A/D Wandler, Timer, USART, I²C, SPI, PWM, u.s.w.), müssen entsprechende SFRs (Spezial Function Registers) laut Datenblatt des PICs definiert werden.

Die externe Hardware muss nach Datenblättern der Herstellern initialisiert werden.

=== Einlesen ===

Um ein Bit von einem Portpin einzulesen und in ein bestimmtes Register zu Kopieren wird folgender PAD benutzt, weil ein PIC kein Befehl dafür hat:

V
Bit im Zielregister löschen
Quellbit = 0 ? J >------.
N |
V |
Bit im Zielregister setzen |
V<-------------´

Wenn wir z.B. ein bit3 von PortA als bit1 in den Register Tasten kopieren wollen, dann wird es in Quellcode so geschrieben:

bcf Tasten,1
btfsc PORTA,3
bsf Tasten,1

Wenn ein ganzes Byte vom Port in das W-Register eingelesen wird, kann man den Wert gleich komplett in das Zielregister schreiben:

movf PORTA,0
movwf Tasten

=== Ausgeben ===

Um ein Bit an einem Portpin auszugeben wird ein bestimmtes Bit mit "bcf" gelöscht oder mit "bsf" gesetzt. Zum Beispiel bit4 im PORTA:

bcf PORTA,4.

Um ein Byte auszugeben wird es zuerst in das W-Register geladen und danach an den Port übergeben, z.B.:

movlw 0x12
movwf PORTA

=== Schleifen ===

Ein in ASM Programmen meist verbreitetes Codefragment ist eine Schleife.

Es kann eine endlose Schleife, die durch Prüfung einer bestimmten Bedingung (z.B. Taste) unterbrochen wird, sein:

V<-----.
Tun |
? N >--´
J
V
weiter

Es kann eine Schleife mit Schleifenzähler (z.B. Temp), die bestimmte Anzahl Durchläufe hat, sein:

V
Anzahl ins Temp laden
V<---------.
Tun |
Temp decrementieren |
Temp = 0 ? N >--´
J
V
weiter

Solche Schleifen können als UPs verwendet werden, wenn "weiter" mit "return" ersetzt wird.

Das waren Beispiele für Schleifen, die bewusst programmiert sind. Es gibt leider auch endlose Schleifen, die durch einen Fehler im Programm enstanden sind und zum "hängen" des Programms führen. Solche Schleifen sind im Programm nicht einfach zu finden, da ihre Parameter unbekannt sind.

=== Pause ===

Um eine Pause (Warten, Verzögerung) im Programm anzulegen wird der "nop" Befehl benutzt, während dessen Ausführung der CPU nichts macht. Mit einem "nop" kann eine Zeit gleich 4 Takten (Perioden) des Oszillators realisiert werden.

Für sehr kurze Wartezeiten benutzt man eine Reihe von nachfolgenden "nop"s. Beim einem Oszillator 4 MHz, die Ausführungszeit des Prozessors beträgt 1 µs pro "nop". Wenn z.B. 4 µs benötigt werden, werden dafür 4 "nop"s gebraucht:

...
nop
nop
nop
nop
...

Das gleiche bewirken 2 "goto"s, brauchen aber im Vergleich zu "nop"s nur die Hälfte der Bytes im Programmspeicher:

...
goto $+1
goto $+1
...

Der Befehl goto $+1 bedeutet "springe zur aktuellen Adresse + 1" (also nächster Adresse) und seine Ausführungszeit ist gleich 2 Prozessortakten.

Für kurze Zeiten werden s.g. Warteschleifen, wie im folgendem PAD benutzt:

V
n * nop
P0 laden
V<---------.
P0 decrementieren |
P0 = 0 ? N >--´
J
V

In Quellcode wird es als UP so eigeschrieben:

Warte nop Warte nop
... ...
nop nop
movlw 0xXX movlw 0xXX
movwf P0 movwf P0
Warte0 decfsz P0,1 decfsz P0,1
goto Warte0 goto $-1
return return

Der Sprung zur Marke "Warte0" ("goto Warte0") wurde in rechtem Beispiel durch "goto $-1" ersetzt.

Die gesammte Anzahl den CPU Takten (N) lässt sich aus folgender Formel berechnen:

N = 3 * P0 + 6 + n

und die Wartezeit (T) in Sekunden:

T = N * ( 4 / Fosc ), für Schätzungen T ~ 3 * P0 * ( 4 / Fosc )

Wobei:

P0 = Zahl im Register P0, 6 = Ausführungszeit von "call" (2) + "movlw" (1) + "movwf" (1) + "return" (2), n = Anzahl "nop"s, Fosc = Frequenz des Oszillators (z.B. Quartz)

Wenn in ein Register PX eine 0 eingeschrieben wird, bedeutet es, dass die decrementierung des Registers 100h = 256d Takten dauern wird, da dekrementierte 0 eine FFh = 255d ergibt. Deshalb in Warteschleifen ist die Zahl 0 die grösste (256 Dürchläufe) und 1 die kleinste. Für solche einfache Schleifen (als UP) die Wartezeit beträgt min. 9 und max. ca. 800 Prozessortakten (ohne "nop"s).

Für mittlere Wartezeiten z.B. 0,1 Sekunde werden doppelte Warteschleifen verwendet:

Warte V
n * nop
P1 laden
Warte1 V<-------------.
P0 laden |
Warte0 V<---------. |
P0 decrementieren | |
P0 = 0 ? N >--´ |
J |
V |
P1 dekrementieren |
P1 = 0 ? N >------´
J
V

Das wird in Quellcode als UP so aussehen:

Warte nop Warte nop
... ...
nop nop
movlw 0xXX movlw 0xXX
movwf P1 movwf P1
Warte1 movlw 0xXX movlw 0xXX
movwf P0 movwf P0
Warte0 decfsz P0,1 decfsz P0,1
goto Warte0 goto $-1
decfsz P1,1 decfsz P1,1
goto Warte1 goto $-5
return return

Wie vorher wurden rechts die Marken durch "$-n" ersetzt.

Die gesammte Anzahl den CPU Takten (N) lässt sich aus folgender Formel berechnen:

N = P1 * (3 * P0 + 5) + 8 + n

und die Wartezeit (T) in Sekunden:

T = N * ( 4 / Fosc ), für Schätzungen T ~ 3 * P1 * P0 * ( 4 / Fosc )

Wobei:

P0 = Zahl im Register P0, P1 = Zahl im Register P1, 8 = Ausführungszeit von "call" + "return" + 2 * ("movlw" + "movwf"), n = Anzahl "nop"s, Fosc = Frequenz des Oszillators (z.B. Quartz)

Für solche doppelte Schleifen (als UP) die Wartezeit beträgt min. 16 und max. ca. 200 000 Prozessortakten (ohne "nop"s).

Für lange Wartezeiten z.B. 1 Sekunde werden 3-fache Warteschleifen angewendet.

Solche Warteschleife ist im folgenden PAD abgebildet:

Warte V
n * nop
P2 laden
Warte2 V<-----------------.
P1 laden |
Warte1 V<-------------. |
P0 laden | |
Warte0 V<---------. | |
P0 decrementieren | | |
P0 = 0 ? N >--´ | |
J | |
V | |
P1 decrementieren | |
P1 = 0 ? N >------´ |
J |
V |
P2 dekrementieren |
P2 = 0 ? N >----------´
J
V

Das wird in Quellcode als UP so aussehen:

Warte nop Warte nop
... ...
nop nop
movlw 0xXX movlw 0xXX
movwf P2 movwf P2
Warte2 movlw 0xXX movlw 0xXX
movwf P1 movwf P1
Warte1 movlw 0xXX movlw 0xXX
movwf P0 movwf P0
Warte0 decfsz P0,1 decfsz P0,1
goto Warte0 goto $-1
decfsz P1,1 decfsz P1,1
goto Warte1 goto $-5
decfsz P2,1 decfsz P2,1
goto Warte2 goto $-9
return return

Auch hier wurden rechts die Marken durch "$-n" ersetzt.

Die gesammte Anzahl den CPU Takten (N) lässt sich aus folgender Formel berechnen:

N = P2 * [ P1 * (3 * P0 + 5) + 9 ] + 10 + n

und die Wartezeit (T) in Sekunden:

T = N * ( 4 / Fosc ), für Schätzungen T ~ 3 * P2 * P1 * P0 * ( 4 / Fosc )

Wobei:

P0 = Zahl im Register P0, P1 = Zahl im Register P1, P2 = Zahl im Register P2, 10 = Ausführungszeit von "call" + "return" + 3 * ("movlw" + "movwf"), n = Anzahl "nop"s, Fosc = Frequenz des Oszillators (z.B. Quartz)

Für solche 3-fache Schleifen (als UP) die Wartezeit beträgt min. 27 und max. ca. 50 000 000 Prozessortakten (ohne "nop"s).

Die "nop"s vor allen Warteschleifen sind nur notwendig um genaue Wartezeit einzustellen zu können. Sie können auch mit "goto $+1"s ersetzt, oder weg gelassen werden. Sie können auch innerhalb jeder Schleife eingesetzt werden, um sie deutlich zu verlängern.

Ein Beispiel:

V
n * nop
P0 laden
V<---------.
n0 * nop
P0 decrementieren |
P0 = 0 ? N >--´
J
V

Bei nur einem "nop" (n0=1) ist die max. Wartezeit ca. T ~ 4 * P0 * ( 4 / Fosc ), bei zwei (n0=2) ca. T ~ 5 * P0 * ( 4 / Fosc ) u.s.w.

Anstatt "movlw 0xXX" kann auch "movf PauseX,0" angewendet werden, wenn die Schleife mehrmals mit verschiedenen Werten P0, P1 und P2 aus den Register Pause0, Pause1 und Pause2 benutzt wird.

Für sehr lange Wartezeiten können, nach gleichem Prinzip, Warteschleifen erstellt werden, die mehr als 3 Schleifen enthalten.

=== Tabellen ===

Es gibt zwei Arten von Tabellen: Sprungtabellen (computed goto) die "goto" Befehle enthalten und Wertetabellen (lookup table) in denen feste Werte in "retlw" gespeichert sind. Der wichtigste Unterschied zwischen dennen ist, dass die Sprungtabellen steuern den Programlauf abhängig vom Inhalt des W-Registers und die Wertetabellen liefern abhängig von Inhalt des W-Registers ein Wert an den Aufrufer zurück.

Beide werden in Programmspeicher erstellt. Sie können nur bis zu 256 Speicherstellen belegen, da in den W-Register auch nur so viel veschiedenen Zahlen "passen". Sie Fangen also (fast) immer bei einer Adresse XX00h an und enden bei XXFFh. Der Hochwertige Byte "XX" der Adresse an der sich der Anfang einer Tabelle befindet, muss vor dem Einsprung in die Tabelle ins PCLATH Register eingeschrieben werden, wenn die Tabelle weit vom Aufrufer liegt. In der Praxis werden solche Tabellen am oberen Ende des Programmspeichers angelegt, damit sie den ASM Code nicht unterbrechen.

Eine Sprungtabelle wird so aufgebaut:

org (XX-1)FF <--- eine Direktive für Assemblerprogramm, wo es
die Tabelle im Programmspeicher plazieren soll
Adresse Inhalt
-------------------------
Tab1 (XX-1)FF addwf PCL,1
XX00 goto Marke0
XX01 goto Marke1
.......................
XXFE goto Marke254
XXFF goto Marke255

Und so aufgerufen:

movlw 0xXX
movwf PCLATH
movf TWert,0
call Tab1

Wobei:

0xXX = Hochwertiger Byte der Adresse von Tab1, TWert = ein Wert, der die Wahl wohin gesprungen wird bestimmt.

Nach ausführen der obiger Befehlsfolge, wird das ASM Programm z.B. für Twert=0x01 weiter ab Marke1 "laufen" bis es an "return" kommt. Dann springt es zurüch zum Aufrufer der Tabelle.

Eine Wertetabelle wird so aufgebaut:

org (XX-1)FF <--- eine Direktive für Assemblerprogramm, wo es
die Tabelle im Programmspeicher plazieren soll
Adresse Inhalt
-------------------------
Tab1 (XX-1)FF addwf PCL,1
XX00 retlw Wert0
XX01 retlw Wert1
.......................
XXFE retlw Wert254
XXFF retlw Wert255

Und so aufgerufen:

movlw 0xXX
movwf PCLATH
movf TWert,0
call Tab1

wobei:

0xXX = Hochwertiger Byte der Adresse von Tab1, TWert = ein Wert, für welchen, an den Aufrufer bestimmter Wert aus der Tabelle im W-Register zurückgeliefert wird

Wertetabelle kann auch mit Hilfe der MPASM Direktive "dt" erstellt werden. So kann man sich mehrfaches Schreiben von "retlw" Befehlen ersparen:

org 0x(XX-1)FF
Tabelle addwf PCL,1
; nachfolgend der benötigte Wert im W- Register
; vor dem Aufruf der Tabelle
dt 0x03, 0xE8 ; 0x00
dt 0x03, 0xE8 ; 0x02
dt 'M','H','z',0x00 ; 0x04
dt ' ',' ','W','A','I','T',0x00 ; 0x08
dt 'C','o','n','s','t',' ','X',0x00 ; 0x0F
dt 'C','=',0x00 ; 0x17
dt 'L','=',0x00 ; 0x1A
dt 'F','=',0x00 ; 0x1D
dt 'O','K',0x00 ; 0x20
u.s.w.

Das Lesen eines Strings muss ab entsprechendem Wert im W-Register (z.B. für "MHz" -> 0x04) anfangen und auf dem Wert 0x00 enden, der hier als Stringende dient. Einfacher ist, wenn alle Strings gleich lang sind (wie z.B. in einem Zeichengenerator fur Grafikdisplay).

=== Interrupt ===

==== Prinzip ====

Ein Interrupt (Unterbrechung) unterbricht ein laufendes Programms, wenn ein bestimmtes Ereigniss, auf das reagiert werden soll, statt gefunden hat. Die Reaktion wird in s.g. Interrupt Service Routine (kurz: ISR) definiert.

Einfach gesagt, ein Interrupt stoppt ein laufendes Programm, ruft die ISR auf und nach deren Ausführung startet das Programm wieder, ab der Zeile, vor der es durch Interrupt angehalten wurde.

.--->V
| Tun
| V
Interrupt ------>Tun-------->V
| V ISR
| Tun<--------´
| V
| Tun
| V
`----´

Damit das unterbrochene Programm nach dem Rückkehr aus der ISR weiter fehlerfrei ausgeführt werden kann, darf die ISR keine Änderungen im Programm verursachen.

Um ein Interrupt auslösen zu können, muss er in UP "Init", durch beschreiben nötigen Register (INTCON, PIR, u.s.w.) vorbereitet werden. Siehe hierzu: [[#INTCON|INTCON]] und [[#Interrupts|Interrupts]]

==== Quellen ====

Es gibt folgende Interrupt-Quellen:

- interne Hardware (z.B. ein Timer)

- externe Hardware (z.B. eine Taste)

Die alle PICs der Mid-Range Familie haben im Programmspeicher nur eine Adresse (s.g. Interrupt Vektor 0x0004), wohin im Falle eines Interrupts, gesprungen wird. Um ermöglichen den Verursacher des Interrupts zu finden, hat jede Quelle ein eigenes Interrupt Flag (IF), das gesetzt wird, wenn das Interrupt ausgelöst wird. Somit kann in der ISR nach der Prüfung der IFs auf jeden Interrupt gezielt reagiert werden.

==== Interrupt Service Routine ====

Die Interrupt Service Routine ist ein besonderes UP das immer an der Adresse 0x0004 beginnt und immer mit dem Befehl "retfie" endet. Ihr Umfang ist von der Menge der Quellen und der Reaktionen auf ihre Interrupts abhängig. Folgender PAD zeigt ein allgemeiner Aufbau der ISR:

Adresse 0x0004 Interrupts sperren ; bcf INTCON,GIE
Beeinflüsste Register sichern
Interrupt-Quelle ermitteln
Interrupt-Flag löschen
und entsprechend reagieren
Beeinflüsste Register restaurieren
zurück ins Programm springen ; retfie

Je nach Bedürfnissen, wird eine ISR nur nötige Elemente davon enthalten. Um auf alle Interrupts reagieren zu können muss die ISR vor dem nächsten Interrupt beendet werden. Da das Programm nur in den Pausen zwischen Ausführungen der ISR laufen kann, sollte die Ausführungszeit der ISR möglichst kurz sein.

Die einfachste ISR setzt nur ein Flag ("_Fint"), das dem Programm zeigt, dass ein Interrupt statt gefunden hat. Sie eignet sich für den Fall, wenn nur eine Interrupt-Quelle erlaubt ist.

0x0004 bcf INTCON,GIE ; Interrupts sperren
bsf IF ; Interrupt Flag löschen
bsf _Fint ; Flag setzen
retfie ; zurück ins Programm

Das Programm prüft das Flag "_Fint", löscht es und reagiert entsprechend.

Die ISR kann aber auch ein HP darstellen. Siehe hierzu: [[#Interrupts|Interrupts]]

=== Schnittstellen und Treiber ===

Als Schnittstelle wird externe Hadware, die zum Steuern eines an sie angeschlossenes "Gerätes" dient, genannt. Das ASM Programm, das die Steuerung ermöglicht ist ein Treiber. Als Beispiele siehe: [[http://www.roboternetz.de/phpBB2/viewtopic.php?t=13685]] und [http://www.roboternetz.de/phpBB2/viewtopic.php?t=22749]

== Vorlage für MPASM ==

Diese Vorlage ist nur für ASM Programme ohne Interrupts geeignet:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration
#define _DTT1 GPIO,0 ; Portpins benennen
#define _CKT2 GPIO,1
#define _T3 GPIO,2
#define _RNG GPIO,3
#define _INT GPIO,4
#define _RL GPIO,5
u.s.w.
SecondL equ 0x20 ; Variablen definieren (Register benennen)
SecondH equ 0x21
MinuteL equ 0x22
MinuteH equ 0x23
StundeL equ 0x24
StundeH equ 0x25
u.s.w
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
Haupt ............ ; hier fängt das Hauptprogramm als endlose Schleife an
Eigener Code
............
goto Haupt ; hier endet das HP, gehe zum Anfang des HPs (zurück)
UP1 ............ ; Unterprogramme
Eigener Code
............
return
############
UPn ............
Eigener Code
............
return
Init clrf GPIO ; lösche Port
bsf STATUS,RP0 ; auf Bank1 umschalten
call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; kalibriere internen RC oscillator
bcf OPTION_REG,7 ; aktiviere pull-ups
movlw 0x38 ; definiere Portpins GPIO, (z.B. 0-2 Aus- und 3-5 Eingänge)
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
movlw 7 ; schalte Komparator aus
movwf CMCON ; und definiere GPIO 0-2 als digitale I/Os
............
eigener Code
............
return ; springe zurück (zum Haupt)
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

Die Variablen können auch kürzer mit s.g. cblock definiert werden:

cblock 0x20
SecondL
SecondH
MinuteL
MinuteH
StundeL
StundeH
endc

Bei sehr vielen Variablen sind aber die Registeradressen nicht so übersichtlich.

Für Programme mit Interrupts ist diese Vorlage geeignet:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration
#define _DTT1 GPIO,0 ; Portpins benennen
#define _CKT2 GPIO,1
#define _T3 GPIO,2
#define _RNG GPIO,3
#define _INT GPIO,4
#define _RL GPIO,5
u.s.w.
SecondL equ 0x20 ; Variablen definieren (Register benennen)
SecondH equ 0x21
MinuteL equ 0x22
MinuteH equ 0x23
StundeL equ 0x24
StundeH equ 0x25
u.s.w
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
goto Haupt ; gehe zum Hauptprogramm "Haupt"
org 0x004 ; hier fängt die ISR (interrupt service routine) an
bcf INTCON,GIE ; interrupts sperren
.............
Eigener Code
.............
retfie ; hier endet die ISR, interrupts wieder erlauben
Haupt ............ ; hier fängt das Hauptprogramm als endlose Schleife an
Eigener Code
............
goto Haupt ; hier endet das HP, gehe zum Anfang des HPs (zurück)
UP1 ............ ; Unterprogramme
Eigener Code
............
return
############
UPn ............
Eigener Code
............
return
Init clrf GPIO ; lösche Port
bsf STATUS,RP0 ; auf Bank1 umschalten
call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; kalibriere internen RC oscillator
bcf OPTION_REG,7 ; aktiviere pull-ups
movlw 0x38 ; definiere Portpins GPIO, (z.B. 0-2 Aus- und 3-5 Eingänge)
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
movlw 7 ; schalte Komparator aus
movwf CMCON ; und definiere GPIO 0-2 als digitale I/Os
............
eigener Code
............
return ; springe zurück (zum Haupt)
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

== Das erste... ==

Hier wird detailiert das ganze Prozess der Erstellung eines ASM Programms beschrieben. Die Idee:

Es gibt 4 LEDs (_L1, _L2, _L3 und _L4), die mit 2 Tastern gesteuert werden sollen. Nach dem Einschalten soll keine LED leuchten. Solange der linke Taster (_T1) gedrückt ist, sollte eine leuchtende LED von links nach rechts "wandern" und von der letzten rechten Position wieder nach ganz linke "springen". Solange der rechte Taster (_T2) gedrückt ist, sollte eine leuchtende LED von rechts nach links "wandern" und von der letzten linken Position wieder nach ganz rechte "springen". Solange beide Taster gedrückt sind soll die leuchtende LED von links nach rechts und zurück "wandern".

Dafür nötige Hardware zeigt folgende Skizze:

.-----------------------------------------------.
| |
| PIC12F629 |
| |
| GPIO,3 GPIO,4 GPIO,5 GPIO,2 GPIO,1 GPIO,0|
'-----------------------------------------------'
4| 3| 2| 5| 6| 7|
| | .-. .-. .-. .-.
| | R | | R | | R | | R | |
| | 470| | 470| | 470| | 470| |
| | '-' '-' '-' '-'
\ o \ o | | | |
\ \ V -> V -> V -> V ->
\. \. - - - -
_T1 o _T2 o _L1 | _L2 | _L3 | _L4 |
| | | | | |
+-------+-------+---+---+-------+-------+
|
===
GND

Weil der Pin 4 (GPIO,3) nur einen "open drain" Ausgang hat (kann nur an GND schalten), wird er hier als Eingang benutzt.

Jetzt muss die Idee vom Programmierer in ein PAD verfasst werden, z.B. solcher:

Start
Initialisierung
.-------------->V
| _T1=0 gedrückt ? N >----.
| J |
| V |
| links->rechts "wandern" |
| V<------------´
| _T2=0 gedrückt ? N >----.
| J |
| V |
| rechts->links "wandern" |
| V<------------´
`---------------´

danach detailierter:

Start
Initialisierung
V<-------------------------------------------.
_T1=0 gedrückt ? N >---+--->_T2=0 gedrückt ? N >---+---´
J A J A
V | V |
_L1 an | _L4 an |
Warten | Warten |
_L1 aus | _L4 aus |
_L2 an | _L3 an |
Warten | Warten |
_L2 aus | _L3 aus |
_L3 an | _L2 an |
Warten | Warten |
_L3 aus | _L2 aus |
_L4 an | _L1 an |
Warten | Warten |
_L4 aus | _L1 aus |
V | V |
`------------´ `------------´

Weil der Prozessor die Befehle nacheinander liest, ist jeder Quelcode einspaltig. Um sich die "Übersetzung" des PADs in den Quelcode zu erleichtern wird er noch z.B. so umgestaltet:

Start
Initialisierung
V<-----------------+<----.
Haupt _T1=0 gedrückt ? N >---. A |
J | | |
V | | |
_L1 an | | |
Warten | | |
_L1 aus | | |
_L2 an | | |
Warten | | |
_L2 aus | | |
_L3 an | | |
Warten | | |
_L3 aus | | |
_L4 an | | |
Warten | | |
_L4 aus | | |
V<-----------´ | |
T2Test _T2=0 gedrückt ? N >---------´ |
J |
V |
_L4 an |
Warten |
_L4 aus |
_L3 an |
Warten |
_L3 aus |
_L2 an |
Warten |
_L2 aus |
_L1 an |
Warten |
_L1 aus |
V |
`------------------------´

Alle Pfeilen aus diesem PAD werden als "goto" in den Quelcode eingetragen.

Zuerst wird im MPASM Verzeichnis ein neuer Verzeichniss (z,B. "PIC Programme") angelegt und in dem Verzeichniss neue Textdatei (z.B. "Erstes.txt") erstellt. Als nächstes wird die "Vorlage für MPASM" dorthin kopiert.

Danach müssen, die im Programm benutzte Portpins und Register mit "#define" und "equ" definiert werden.

Als Initialisierung wird das UP "Init" aus der Vorlage für MPASM mit geändertem "TRISIO" Wert (0x18) übernommen. Siehe: [[#Vorlage für MPASM|Vorlage für MPASM]]

Fürs "Warten" wird eine dreifache Warteschleife verwendet. Siehe: [[#Pause|Pause]]

Die Taster werden mit "btfsc" Befehl geprüft und zum LEDs An- und Ausschalten werden Befehle "bsf" und "bcf" für ensprechenden Portpin von GPIO angewendet. Siehe: [[#Ausgeben|Ausgeben]]

Anschlessend wird alles laut PAD in die Vorlage für MPASM eingeschrieben und der Quellcode ist fertig:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration
#define _T1 GPIO,3 ; Portpins benennen
#define _T2 GPIO,4
#define _L1 GPIO,5
#define _L2 GPIO,2
#define _L3 GPIO,1
#define _L4 GPIO,0
P0 equ 0x20 ; Variablen definieren (Register benennen)
P1 equ 0x21
P2 equ 0x22
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
Haupt btfsc _T1 ; Taster _T1=0 gedrückt ?, wenn ja, überspringe "goto T2Test"
goto T2Test ; wenn nicht, springe zu "T2Test"
bsf _L1 ; schalte _L1 an (setze den Pin 2 auf "1")
call Warten ; warte ca. 0,4 s (ca. 400 000 Prozessortakten)
bcf _L1 ; schalte _L1 aus (setze den Pin 2 auf "0")
bsf _L2 ; schalte _L2 an (setze den Pin 5 auf "1")
call Warten ; warte
bcf _L2 ; schalte _L2 aus (setze den Pin 5 auf "0")
bsf _L3 ; schalte _L3 an (setze den Pin 6 auf "1")
call Warten ; warte
bcf _L3 ; schalte _L3 aus (setze den Pin 6 auf "0")
bsf _L4 ; schalte _L4 an (setze den Pin 7 auf "1")
call Warten ; warte
bcf _L4 ; schalte _L4 aus (setze den Pin 7 auf "0")
T2Test btfsc _T2 ; Taster _T2=0 gedrückt ?, wenn ja, überspringe "goto Haupt"
goto Haupt ; wenn nicht, springe zu "Haupt"
bsf _L4 ; schalte _L4 an (setze den Pin 7 auf "1")
call Warten ; warte
bcf _L4 ; schalte _L4 aus (setze den Pin 7 auf "0")
bsf _L3 ; schalte _L3 an (setze den Pin 6 auf "1")
call Warten ; warte
bcf _L3 ; schalte _L3 aus (setze den Pin 6 auf "0")
bsf _L2 ; schalte _L2 an (setze den Pin 5 auf "1")
call Warten ; warte
bcf _L2 ; schalte _L2 aus (setze den Pin 5 auf "0")
bsf _L1 ; schalte _L1 an (setze den Pin 2 auf "1")
call Warten ; warte
bcf _L1 ; schalte _L1 aus (setze den Pin 2 auf "0")
goto Haupt ; springe zu "Haupt"
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 ("Haupt"),
Init clrf GPIO ; lösche Port (setze alle werdende Ausgänge auf "0")
bsf STATUS,RP0 ; auf Bank1 umschalten
call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; und kalibriere internen RC oscillator (4 MHz)
bcf OPTION_ REG,7 ; aktiviere pull-ups für die Portpins
movlw 0x18 ; definiere Portpins GPIO,3 und 4 als Eingänge
; und restlichen als Ausgänge (00011000b)
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
movlw 7 ; schalte Komparator aus
movwf CMCON ; und definiere GPIO 0-2 als digitale I/Os
return ; springe zurück (zum Haupt)
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

Jetzt wird der Quellcode in "Erstes.asm" umbenannt. Diese "*.asm" Datei können wir dem MPASM zum "Übersetzten" geben. Nach der Assemblierung sehen wir 3 Meldungen (Messages) vom MPASM. Diese befinden sich in der vom MPASM erstellter Datei "Erstes.lst" und lauten:

Message[302]: Register in operand not in bank 0. Ensure that bank bits are correct.

Diese Meldung kann man übersetzen als:

Meldung[302]: Register im Befehl nicht in Bank 0. Vergewisse Dich, dass die Bank-Bits korrekt sind.

Wir sind sicher, dass die Register "OSCCAL", "OPTION_REG" und "TRISIO" in der Bank 1 sich befinden. Wenn man aber nicht sicher ist, soll man in Datenblatt nachschauen. Die Meldungen kommen immer für alle SFRs (Special Function Register) die sich nicht in der Bank 0 befinden und können ignoriert werden.

Am Ende der Datei "Erstes.lst" befinden sich noch einige Informationen über Programmspeicher:

Program Memory Words Used: 52 ; benutzte Speicherstellen
Program Memory Words Free: 972 ; freie Speicherstellen

und die Anzahl den eventuellen Fehlern (Errors), Warnungen (Warnings) und Meldungen (Messages):

Errors : 0
Warnings : 0 reported, 0 suppressed
Messages : 3 reported, 0 suppressed

Insgesamt werden durch MPASM 4 Dateien erstellt: "*.cod", "*.err", "*.hex" und "*.lst".

Wichtigste davon, falls wegen Fehler keine "*.hex" Datei erstellt wird, ist die "*.err" Datei, wo alles was dem MPASM nicht "passt" aufgelistet ist. In der "*.lst" Datei kann man sich ein Programm mit genauen Adressen für jeden Befehl anschauen.

Die während der Assemblierung vom MPASM generierte Datei "Erstes.hex" kann jetzt durch ein Brenner mit geeignetem Programm in den PIC Programmspeicher eingeschrieben werden.

== Für anderen PIC umschreiben ==

Die wichtigste Vorraussetzung ist, das der andere PIC2, auf dem das vorhandene ASM Programm für PIC1 laufen soll, zumindest für das ASM Programm nötige interne Hardware hat. Die Frequenz des Oszillators sollte gleich sein. Der Code benötigt ausser UP "Init" keine Änderungen.

Wenn der Port vom PIC2 anderen Namen hat, muss man das im Quellcode umdefinieren, z.B.:

#define PORTC PORTB
#define TRISC TRISB

Dann wird das Assemblerprogramm, wenn es PORTC findet, immer PORTB nehmen. Das gleiche Betrifft die "__config" Ausdrücke, die entsprechend der "*.ini" Datei für den PIC2, geändert werden müssen.

Das Assemblerprogramm findet sicher alles, was ihm nicht "passt" und bringt Fehlermeldungen, auf die man entsprechend reagieren muss.

Als Beispiel, schreiben wir "Erstes.asm" für den PIC16F84A um.

Zum Ändern sind die ersten 3 Zeilen:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration

Sie werden für den PIC16F84A so aussehen:

list P=16F84A ; Prozessor definieren
include "P16F84A.inc" ; 4.000 MHz
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _HS_OSC

Dazu muss noch "GPIO" Port umdefiniert werden, da der PIC16F84A solchen nicht hat, z.B wegen internen pull-ups auf "B":

#define GPIO PORTB
#define TRISIO TRISB

Die Hardware muss natürlich an entsprechende Pins angeschlossen werden:

_T1 auf 12 (B3), _T2 auf 13 (B4), _L1 auf 14 (B5), _L2 auf 11 (B2), _L3 auf 10 (B1) und _L4 auf 9 (B0)

Jetzt assemblieren wir die Qelldatei und der MPASM bringt in der Datei "Erstes.err" folgende Fehler:

Error[113] C:\MPASM\PICPROG\PIC16F84\ERSTES.ASM 61 : Symbol not previously defined (OSCCAL)
Error[113] C:\MPASM\PICPROG\PIC16F84\ERSTES.ASM 67 : Symbol not previously defined (CMCON)

In dem UP "Init" müssen also noch die Befehle mit "OSCCAL" und "CMCON" Register entfernt werden, da der PIC16F84A sie nicht hat:

call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; kalibriere internen RC oscillator (4 MHz)

und:

movlw 7 ; schalte Komparator aus
movwf CMCON ; und mache GPIO 0-2 als digital I/O

Weiter kann schon alles übernommen werden und die Datei "Erstes.asm" für den PIC16F84A ist fertig:

list P=16F84A ; Prozessor definieren
include "P16F84A.inc" ; 4.000 MHz
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _HS_OSC
#define GPIO PORTB ; Ports umbenennen
#define TRISIO TRISB
#define _T1 GPIO,3 ; Portpins benennen
#define _T2 GPIO,4
#define _L1 GPIO,5
#define _L2 GPIO,2
#define _L3 GPIO,1
#define _L4 GPIO,0
P0 equ 0x20 ; Variablen definieren (Register benennen)
P1 equ 0x21
P2 equ 0x22
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
Haupt btfsc _T1 ; Taster _T1=0 gedrückt ?, wenn ja, überspringe "goto T2Test"
goto T2Test ; wenn nicht, springe zu "T2Test"
bsf _L1 ; schalte _L1 an
call Warten ; warte ca. 0,4 s (ca. 400 000 Prozessortakten)
bcf _L1 ; schalte _L1 aus
bsf _L2 ; schalte _L2 an
call Warten ; warte
bcf _L2 ; schalte _L2 aus
bsf _L3 ; schalte _L3 an
call Warten ; warte
bcf _L3 ; schalte _L3 aus
bsf _L4 ; schalte _L4 an
call Warten ; warte
bcf _L4 ; schalte _L4 aus
T2Test btfsc _T2 ; Taster _T2=0 gedrückt ?, wenn ja, überspringe "goto Haupt"
goto Haupt ; wenn nicht, springe zu "Haupt"
bsf _L4 ; schalte _L4 an
call Warten ; warte
bcf _L4 ; schalte _L4 aus
bsf _L3 ; schalte _L3 an
call Warten ; warte
bcf _L3 ; schalte _L3 aus
bsf _L2 ; schalte _L2 an
call Warten ; warte
bcf _L2 ; schalte _L2 aus
bsf _L1 ; schalte _L1 an
call Warten ; warte
bcf _L1 ; schalte _L1 aus
goto Haupt ; springe zu "Haupt"
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 ("Haupt"),
Init clrf GPIO ; lösche Port (setze alle werdende Ausgänge auf "0")
bsf STATUS,RP0 ; auf Bank1 umschalten
bcf OPTION_REG,7 ; aktiviere pull-ups
movlw 0x18 ; definiere Portpins GPIO,3 und 4 als Eingänge
; und die restlichen als Ausgänge (00011000b)
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
return ; springe zurück (zum Haupt), nach der Zeile
; aus der du afgerufen wurdest
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

== Einbinden ==

Die einfachste Möglichkeit die gewünschte Programme in ein neues Programm einzubinden ist, die alle Programme in das neue Programm zu kopieren. Dafür müssen die ersten 3 Zeilen, die den Prozessor und die Konfiguration des PICs festlegen aus den eigebundenen Programmen entfernt werden. Danach müssen alle "#define", "equ" und "org" Direktiven, verglichen und wenn nötig geändert werden. Dabei hilft der MPASM mit seinen Fehlermeldungen in der Datei "*.err".

Die zweite Möglichkeit ist die gewünschte Programme als "*.asm" Dateien mit der Direktive "include *.asm" am Ende des neuen Programms vor der Direktive "end" einzubinden.

include "1.asm"
include "2.asm"
...............
include "n.asm"
end

In dem Fall gelten die gleichen o.g. Regeln wie beim direkten Kopieren. Wenn es in den eingebindenen Programmen keine "org" Direktiven gibt, dann werden die weitere Programme im Programmspeicher ab Ende des ersten Programms nacheinander plaziert.

== Fehlersuche ==

Als erstes wird an den PIC angeschlossene externe Hardware geprüft. Das sollte noch vor dem Einstecken oder Einlöten des PICs gemacht werden, da die gravierende Fehler (z.B. Kurzschlüsse, Umpolung von VCC und GND, u.s.w.) für den PIC schädlich werden können. Für einige Teile der Hardware kann entsprechende Spannung (VCC oder GND) an bestimmten Pin gelegt werden und die richtige Reaktion der Hardware optisch (z.B. für LEDs) oder akustisch (z.B. für Relais) festgestellt werden. Sonst müssen die elektrischen Verbindungen mit einem Messgerät überprüft werden.

Die Fehlersuche in der Software fängt mit der ersten und endet mit der letzten Zeile des ASM Programms. Sie läuft die ganze Zeit parallel zur Programmierung. Jedes UP soll vor dem Übertragen in den Quellcode geprüft und eventuelle Fehler beseitigt werden. Dazu arbeitet man gleichzeitig mit zwei "*.asm" Dateien, einer für die UPs und einer für das gesamte Programm. Es wird empfohlen, nach der "Initialisierung", als erstes UP, das für Ausgabegerät (z.B. Display) zu erstellen, um das funktionieren des Programms, vom Anfang an beobachten zu können.

Wenn aus geprüften UPs erstelltes Programm nicht richtig funktioniert, müsste ein Fehler im PAD sein.

== Optimierung ==
Work in Progress...
Wer sonst noch Beispiele hat, bitte hier vervollständigen...
BMS ...
=== Speicherbedarf ===
==== Programmspeicher ====
Die ersten Programme für den PIC sind natürlich einfach und kurz. Doch nach und nach werden die Codes länger und unübersichtlicher, das Brennen dauert auch umso länger. Das Programm ist zu umfangreich. Doch wo soll man etwas kürzen?

Es gibt unzählige Möglichkeiten - hier ein paar Beispiele:

===== Unterprogramme =====

Bestimmt wird man im Code immer die selben Abschnitte brauchen, zum Beispiel Warteschleifen oder ADC-Routinen, etc. Wieso sollte man diese also mehrfach (doppelt, dreifach, u.s.w.) schreiben?

Die Lösung: Der Programmteil wird als Unterprogramm benutzt. Man erstellt eine Sprungmarke (ab hier beginnt das Unterprogramm) und endet wieder mit einem "return"- oder "retlw"-Befehl.
Aufgerufen werden die Unterprogramme meistens mit dem "call"-Befehl. Es "lohnt sich" ein Codefragment als UP zu definieren erst wenn es min. 2 mal aufgerufen wird.

Ein "goto"-Befehl ist zu diesem Zweck geeignet nur, wenn der Prozessor zum letzten Aufrufer von "call" zurück springen soll, da die Rücksprungadresse vom letzten "call" auf dem Stapel (stack) abgelegt wurde. Somit kann man mehr als 8 Ebenen von UPs nutzen.

Den Unterprogrammen kann man natürlich auch Werte übergeben. Möchte man z.B. mehrere unterschiedliche Zeiten für Warteschleifen benutzen, so kann man die Parameter vor dem Aufruf des UPs in benötigte Anzahl von Register einschreben und dann das Unterprogramm mit "call" aufrufen. Das Unterprogramm verwendet dann die Zahlen von den Register. Siehe: [[#Pause|Pause]]

Um gleiche Vorgänge in mehreren Register durchzuführen (z.B. löschen) geeignet ist Anwendung von Schleifen mit bestimmter Anzahl der Abläufe und indirekter Adressierung. Siehe: [[#Variablen|Variablen]]

===== bsf und bcf =====

Bestimmt gibt es Situationen, in denen der PIC mehrere Bits an einem Port/Register setzen oder löschen muss. Z.B. wenn mehrere LEDs an einem Port ein- oder ausgeschaltet werden sollen.
Werden mehr als 2 Bits verändert, so kann man hier die "bsf"- und "bcf"-Befehle umgehen und einen kürzeren Code erstellen.

bsf PORTB,0 ;An PORTB sind 8 LEDs angeschlossen.
bsf PORTB,1 ;Es sollen die ersten 4 LEDs angeschaltet werden,
bsf PORTB,2 ;die anderen sollen ausgeschaltet werden.
bsf PORTB,3 ;links steht es mit bcf/bsf
bcf PORTB,4 ;ziemlich lang
bcf PORTB,5
bcf PORTB,6
bcf PORTB,7

movlw b'00001111' ;Das geht auch kürzer und übersichtlicher:
movwf PORTB

Man sieht - der Codeabschnitt umfasst nur noch 2 Zeilen anstatt 8. Somit braucht es weniger Speicher und wird von PIC schneller verarbeitet. Allerdings muss man aufpassen, da durch diese Routine der Inhalt des W-Registers und der Inhalt des gesamten Zielregisters verändert wird. Sollen die anderen Bits unangetastet bleiben, muss man es entweder bei den "bcf"/"bsf"-Befehlen belassen oder logische Funktionen (and bzw. or) durchführen.

===== Bit kopieren =====

;An den PIC ist ein Taster(RB0) und eine LED(RB1) angeschlossen.
;Taster: High=gedrückt Low=nicht gedrückt
;LED: High=Ein Low=Aus
;Wenn der Taster gedrückt ist, soll die LED leuchten
;wenn er nicht gedrückt ist, soll die LED nicht leuchten.
;1.Vorschlag:
btfss PORTB,0 ;ist der taster gedrückt?
goto no ;nein
bsf PORTB,1 ;ja - LED ein
goto endif ;fertig abgefragt - unten weitermachen...
no bcf PORTB,1 ;LED aus
endif

Der oben aufgeführte Code hat viele Nachteile: er ist relativ lang, braucht zwei Gotos und entspr. Sprungmarken. Ok, das ist vielleicht Erbsenzählerei, aber aus diesen 5 Zeilen kann man 3 machen.

bcf PORTB,1 ;Das Bit wird erst gelöscht
btfss PORTB,0 ;Taster gedrückt?
bsf PORTB,1 ;JA-LED an

Man geht davon aus, dass der Taster nicht gedrückt ist. Somit wird die LED erst einmal ausgeschaltet. Ist der Taster aber doch gedrückt, dann wird die LED angeschaltet.

Achtung möglicher Nebeneffekt: Wird dies in einer Schleife sehr schnell und oft ausgeführt, kann die LED flimmern oder nicht in ihrer vollen Helligkeit leuchten. Das passiert, weil ja angenommen wird, dass der Taster nicht gedrückt wird und die LED somit aus sein muss. Dann wird sie aber bei Tastendruck eingeschaltet. Somit entsteht ein schnelles ein-/ausschalten (PWM) und die LED leuchtet nicht mehr so hell.
Meist ist das aber nicht tragisch oder wird nicht unbedingt in einer Schleife sehr schnell abefragt. Siehe hierzu: [[#Einlesen|Einlesen]]

==== RAM ====

Um Anzahl benötigten Register zu sparen werden vorläufige Register (temporary) definiert, die von mehreren UPs benutzt werden. Als Beispiel, das Register "ATmp" in [[#Hex Dec Wandlung|Hex Dec Wandlung]]. Die Benutzung muss aber sehr genau nach PAD zugeteilt werden. Bei gleichzeitiger Benutzung des gleichen Registers durch mehrere UPS werden falsche Daten verarbeitet und im schlimmsten Fall können endlose Schleifen entstehen, die in Folge haben, dass das Programm nicht weiter ausgeführt wird ("hängt").

Viele im ASM Programm ungebrauchte SFRs können als "normale" Register (GPR) verwendet werden. Wenn zum Beispiel Timer1 nicht benutzt wird, können seine Register TMR1H und TMR1L für Speicherung von Daten benutzt werden. Es könnte aber gefährlich werden, wenn mehrere Programme gebindet sind. Deswegen muss es immer am Ende, beim volständigen Programm, geprüft werden, welche SFRs tatsächlich benutzt werden dürfen.

Für Konstanten (z.B. pi, ln2, Meldungen, u.s.w.), die sich im Laufe des Programms nicht ändern, kann EEPROM (mit MPASM Direktive "de") oder Programmspeicher (mit MPASM Direktive "dt") als Ablage benutzt werden. Siehe auch: [[#EEPROM|EEPROM]] und [[#Tabellen|Tabellen]]

=== Ausführungszeit ===

Alles was schnellmöglichst ablaufen soll, widersetzt sich der Optimierung des Programmspeichers.

Es können keine Schleifen und keine indirekte Adressierung benutzt werden, alles muss direkt programmiert werden.

Als Beispiel zur Verdeutlichung: Es sollen 16 Werte vom PORTA ins RAM ab Adresse 0x20 eingelesen werden.

Als Schleife mit indirekter Adressierung:

................
movlw 0x10 ;Anzahl Durchläufe
movwf Temp ;in den Schleifenzähler
movlw 0x20 ;erste Adresse
movwf FSR ;ins FSR Register
Einlesen movf PORTA,0 ;PortA ins W-Register
movwf INDF ;und ins aktuellen RAM Register
incf FSR,1 ;nächste Adresse
decfsz Temp,1 ;Temp = 0 ?
goto Einlesen ;nein, zum Einlesen
................ ;ja, weiter
Gesamtdauer: 100 Takten
Pause zwischen Einlesungen: 6 Takten
Programmspeicher Bedarf: 9 Speicherstellen
Direkt:

...............
movf PORTA,0
movwf 0x20
movf PORTA,0
movwf 0x21
movf PORTA,0
movwf 0x22
movf PORTA,0
movwf 0x23
movf PORTA,0
movwf 0x24
movf PORTA,0
movwf 0x25
movf PORTA,0
movwf 0x26
movf PORTA,0
movwf 0x27
movf PORTA,0
movwf 0x28
movf PORTA,0
movwf 0x29
movf PORTA,0
movwf 0x2A
movf PORTA,0
movwf 0x2B
movf PORTA,0
movwf 0x2C
movf PORTA,0
movwf 0x2D
movf PORTA,0
movwf 0x2E
movf PORTA,0
movwf 0x2F
...............
Gesamtdauer: 32 Takten
Pause zwischen Einlesungen: 2 Takten
Programmspeicher Bedarf: 32 Speicherstellen

Anstatt Warteschleifen (z.B. für Tastenentprellung) sollten Programmfragmente mit entsprechender Ausführungszeit benutzt werden (z.B. Ausgabe auf einem Display). Die nötige Zeit lässt sich aus mehreren UPs zusammensetzen.

Es sollte kein Prozessortakt ungenutzt bleiben.

= Mid-Range =

Zu Mid-Range gehören alle PICs mit 14-bit langen Befehlen aus den Familien 12FXXX und 16FXXX.

== Kurzübersicht Assembler Befehle ==

{|
|-
| valign=top |

{| {{Blauetabelle}}
|ADDLW||Add literal and W
|-
|ADDWF||Add W and f
|-
|ANDLW||AND literal with W
|-
|ANDWF||AND W with f
|-
|BCF||Bit Clear f
|-
|BSF||Bit Set f
|-
|BTFSC||Bit Test f, Skip if Clear
|-
|BTFSS||Bit Test f, Skip if Set
|-
|CALL||Call subroutine
|-
|CLRF||Clear f
|-
|CLRW||Clear W
|-
|CLRWDT||Clear Watchdog Timer
|}

| valign=top |

{| {{Blauetabelle}}
|-
|COMF||Complement f
|-
|DECF||Decrement f
|-
|DECFSZ||Decrement f, Skip if 0
|-
|GOTO||Go to address or label
|-
|INCF||Increment f
|-
|INCFSZ||Increment f, Skip if 0
|-
|IORLW||Inclusive OR literal with W
|-
|IORWF||Inclusive OR W with f
|-
|MOVF||Move f
|-
|MOVLW||Move literal to W
|-
|MOVWF||Move W to f
|-
|NOP||No Operation
|}

| valign=top |

{| {{Blauetabelle}}
|-
|RETFIE||Return from interrupt
|-
|RETLW||Return with literal in W
|-
|RETURN||Return from Subroutine
|-
|RLF||Rotate Left f through Carry
|-
|RRF||Rotate Right f through Carry
|-
|SLEEP||Go into standby mode
|-
|SUBLW||Subtract W from literal
|-
|SUBWF||Subtract W from f
|-
|SWAPF||Swap nibbles in f
|-
|XORLW||Exclusive OR literal with W
|-
|XORWF||Exclusive OR W with f
|}
[[:bild:pic_asm_short.jpg|Kurzübersicht zum Ausdrucken]]
|}


==Ausführliche Beschreibung zu den Befehlen==

Fast alle Befehle werden in einem Takt = 4 Oszillatortakten ausgeführt.

Aussnahmen:

"goto", "call", "return" und "retfie" benötigen wegen Zugriff auf den Programmzähler (PC) immer 2 Takten.

"btfsc", "btfss", "decfsz" und "incfsz" brauchen 1 Takt wenn der nächste Befehl ausgeführt wird b.z.w. 2 Takten wenn er überspringen wird, weil es immer anstatt des überspringenden Befehls ein "nop" ausgeführt wird.

Eine ausgegliederte Beschreibung der Befehle findet sich unter [[PIC Assemblerbefehle]]

Erklärungen zu den Verwendeten Platzhaltern:
*'''k''' stellt einen fest definierten Wert da. z.B. <tt>0x20</tt>, <tt>d'42'</tt> oder <tt>b'00101010'</tt>
*'''W''' steht für das W-Register.
*'''d''' steht für ''destination'' (Ziel). Im code wird d durch ein <tt>w</tt> bzw. <tt>0</tt> (der Wert wird in das W-Register gespeichert ) oder <tt>f</tt> bzw. <tt>1</tt> (der Wert wird in das davor definierte Register gespeichert)
*'''b''' steht für Bitnummer im Register (eine Zahl zwischen 0 und 7)
*'''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
*<tt>Schreibmaschinenstil</tt> bedeutet, dass es so im Quellcode geschrieben werden kann.

 ADDLW k ADD Literal and W - Addiere Zahl (k) und W<hr>
:Es wird die Rechenoperation <math>W+k</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|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

 ADDWF R,d ADD W and F - Addiere W und f <hr>
:Es wird die Rechenoperation <math>W+R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Dieser Befehl beeinflusst das STATUS-Register. Siehe hierzu [[#Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

 ANDLW k AND Literal with W<hr>
:Es wird bitweise die logische Funktion <math>k\ and\ W</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 Operation:
<dl><dd>
11001010 ;k
10101100 ;W-Register
-------- and
10001000 ;W-Register
</dd></dl>

 ANDWF R,d AND W with F<hr>
:Es wird bitweise die logische Funktion <math>W\ and\ R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Vergleiche ANDLW. Dieser Befehl wird benutzt zum Löschen bestimmten Bits im Register ohne restlichen Bits zu beeinflüssen.

BCF R,b Bit Clear F - Bit b im R wird gelöscht<hr>
:Mit dem Befehl <tt>BCF</tt> wird das Bit '''b''' im Register '''R''' gelöscht. Ein Beispiel:
<dl><dd>
movlw b'11111111' ;es wird b'11111111' in das W-Register geschrieben
BCF W,2 ;es wird bit 2 im W-Register gelöscht.
;das Ergebnis ist: b'11111011'
</dl></dd>

BSF R,b Bit Set F - Bit b im R wird gesetzt<hr>
:Mit dem Befehl <tt>BSF</tt> wird das Bit '''b''' im Register '''R''' gesetzt. Ein Beispiel:
<dl><dd>
clrw ;es wird b'00000000' in das W-Register geschrieben
BSF W,2 ;es wird bit 2 im W-Register gesetzt.
;das Ergebnis ist: b'00000100'
</dl></dd>

BTFSC R,b Bit Test F, Skip if Clear - Wenn das Bit b im Register R 0 ist, überspringe den nächsten Befehl<hr>
:Mit dem Befehl <tt>BTFSC</tt> kann eine Verzweigung im Programmablauf bewirkt werden. Wenn das Bit '''b''' im Register '''R''' 0 ist, wird der nächste Befehl übersprungen. Ein Beispiel:
<dl><dd>
movlw b'00000001' ;es wird die Zahl 1 in das W-Register kopiert.
BTFSC W,0 ;es wird bit 0 geprüft.
;wenn es 0 ist, wird der nächste Befehl übersprungen
goto IST_EINS ;springt zur Marke "IST_EINS" <- in diesem Fall wird dieser
;Sprungbefehl ausgeführt.
goto IST_NULL ;springt zur Marke "IST_NULL"
</dl></dd>

BTFSS R,b Bit Test F, Skip if Set - Wenn das Bit b im Register R 1 ist, überspringe den nächsten Befehl<hr>
:Mit dem Befehl <tt>BTFSS</tt> kann eine Verzweigung im Programmablauf bewirkt werden. Wenn das Bit '''b''' im Register '''R''' 1 ist, wird der nächste Befehl übersprungen. Ein Beispiel:
<dl><dd>
movlw b'00000001' ;es wird die Zahl 1 in das W-Register kopiert.
BTFSS W,0 ;es wird bit 0 geprüft.
;wenn es 1 ist, wird der nächste Befehl übersprungen
goto IST_NULL ;springt zur Marke "IST_NULL"
goto IST_EINS ;springt zur Marke "IST_EINS" <- in diesem Fall wird dieser
;Sprungbefehl ausgeführt, da der Befehl
;darüber übersprungen wurde.
</dl></dd>

CALL CALL Subroutine - Rufe Unterprogramm auf<hr>
:Mit dem <tt>CALL</tt> Befehl wird ein Unterprogramm aufgerufen. Mit dem <tt>RETURN</tt>-Befehl wird das Unterprogramm beendet und man kehrt zum Befehl nach dem <tt>CALL</tt>-Befehl zurück. Das Unterprogramm wird so definiert, dass im Quellcode der Name des Unterprogramms nicht eingerückt steht. Ein Beispiel:

<dl><dd>
movlw d'13' ;in das W-Register wird 13d geladen
CALL UP1 ;es wird das Unterprogramm "UP1" aufgerufen
movwf ergebnis ;das W-Register wird in das Register "ergebnis" kopiert.
;im Register "ergebnis" steht nun 23d

UP1 addlw d'10' ;es wird 10d zum W-Register addiert
return ;kehre zurück zum Aufrufer
</dl></dd>

CLRF R CLeaR F- Schreibe 0 in das Register R<hr>
:Das Register '''R''' wird mit Nullen gefüllt (gelöscht).

CLRW CLeaR W - Schreibe 0 in W<hr>
:Das W-Register (<tt>W</tt>) wird mit Nullen gefüllt (gelöscht).
:Der Befehl bewirkt das gleiche wie MOVLW 0 und darf im Programmen, die fur zukünftige Anwendung bei den PICs der serie 18F vorgesehen sind, nicht benutzt werden, da sie ihn nicht kennen.

CLRWDT CLeaR WatchDog Timer - Setzt den Watchdog-Timer zurück<hr>
:Es wird der WDT (Watchdog-Timer) zurückgesetzt und der Zähler des WDT auf 0 gesetzt, zusätzlich werden die STATUS-bits TO und PD gesetzt.

COMF R,d COMplement F - negiere alle bits im Register R<hr>
:Von der Binärzahl im Register '''R''' werden alle 0 mit 1 und alle 1 mit 0 ersetzt. Das Ergebnis wird entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Ein kleines Beispiel: aus <tt>AAh</tt> (<tt>10101010b</tt>) wird <tt>55h</tt> (<tt>01010101b</tt>).

DECF R,d DECrement F - Subtrahiert 1 vom Regiser f<hr>
:Vom Wert des Registers '''R''' wird 1 subtrahiert und das Ergebnis entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
:Weil es keine "echte" Substraktion ist, beeinflusst dieser Befehl das C-Flag im STATUS-Register nicht.

DECFSZ R,d DECrement F, Skip if Zero - Subtrahiert 1 vom Regiser f, überspringe wenn 0<hr>
:Vom Wert des Registers '''R''' wird 1 subtrahiert und das Ergebnis entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Der Zusatz SZ steht für ''skip if zero'', d.h. wenn das Ergebnis der Rechnung Null ist, wird der nächste Befehl übersprungen. Dieser Befehl wird für Schleifen mit bestimmter Anzahl der Durchläufe benutzt.

GOTO GO TO address - Gehe zu Adresse/Sprungmarke<hr>
:Nach dem GOTO Befehl wird das Programm ab der Adresse weiter ausgeführt, die nach dem GOTO-Befehl steht. Diese Adresse wird durch so genannte Sprungmarke definiert, welche, im Gegensatz zu den Befehlen nicht eingerückt im Quellcode stehen.

INCF R,d INCrement F - Addiere 1 zum Register f<hr>
:Zum Wert des Registers '''R''' wird 1 addiert und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
:Weil es keine "echte" Addition ist, beeinflusst dieser Befehl das C-Flag im STATUS-Register nicht.

INCFSZ R,d INCrement F, Skip if Zero - Addiere 1 zum Regiser f, überspringe wenn 0<hr>
:Zum Wert des Registers '''R''' wird 1 addiert und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Der Zusatz SZ steht für ''skip if zero'', d.h. wenn das Ergebnis der Rechnung Null ist, wird der nächste Befehl übersprungen. Dieser Befehl wird für Schleifen mit bestimmter Anzahl der Durchläufe benutzt.

 IORLW k Inclusive OR Literal with W<hr>
:Es wird bitweise die logische Funktion <math>k\ or\ W</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 Operation:
<dl><dd>
11001010 ;k
10101100 ;W-Register
-------- or
11101110 ;W-Register
</dd></dl>

 IORWF R,d Inclusive OR W with F<hr>
:Es wird bitweise die logische Funktion <math>W\ or\ R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Vergleiche IORLW. Dieser Befehl wird oft benutzt zum Setzen bestimmten Bits im Register ohne restlichen Bits zu beeinflüssen.

MOVF R,d MOVe F - Bewege f<hr>
:Das Register R wird in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder wieder in R kopiert ('''d'''=<tt>F</tt>=<tt>1</tt>). Letzteres mag sinnlos scheinen, ist aber nützlich, da durch den Befehl das Z-Bit im STATUS-Register gesetzt wird, falls R Null ist.

MOVLW k MOVe Literal to W - Bewege Zahl (k) in W-Register<hr>
:Der festgelegte Wert k wird in das W-Register kopiert.

:Dieser Befehl wird auch bei indirekter Adressierung zum laden der absoluter Adresse ins "FSR" Register benutzt. Beispiel:
:Der Register "Temp" wurde mit "Temp equ 0x20" definiert.
<dl><dd>
MOVLW Temp ;ins W-Register wird die absolute Adresse 0x20 vom "Temp" geladen
movwf FSR ;diese Adresse wird jetzt ins Register "FSR" kopiert
</dd></dl>
MOVWF R MOVe W to F- Bewege W-Register in das Register F<hr>
:Das W-Register wird in das Register '''R''' kopiert.

NOP No OPeration - Kein Befehl zum Ausführen (warte)<hr>
: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. Siehe hierzu: [[#Pause|Pause]]

RETFIE RETurn From Interrupt Enable - Kehre zurück aus der Unterbrechung, erlaube Unterbrechungen<hr>
:Mit diesem Befehl wird die Interrupt Service Routine (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 | Interrupt]]

RETLW k RETurn with Literal in W - Kehre zurück mit Zahl k im W-Register<hr>
:Wurde ein Programmteil mit dem Befehl <tt>CALL</tt> aufgerufen, dann springt man mit dem Befehl <tt>RETLW</tt> zurück in die nächste Zeile nach der Zeile aus der das <tt>CALL</tt> 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 Wertetabellen (eng: lookup tables) verwendet.

RETURN RETURN from Subroutine - Kehre zurück zum Aufrufer<hr>
:Wurde ein Programmteil mit dem Befehl <tt>CALL</tt> aufgerufen, dann springt man mit dem Befehl <tt>RETURN</tt> zurück zu der nächsten Zeile nach der Zeile aus der das <tt>CALL</tt> Befehl ausgeführt wurde.

RLF R,d Rotate Left F through carry - Rotiere das Register f mithilfe des Carry-bits nach links<hr>
:Alle Bits im Register '''R''' werden um eine Position nach links verschoben. Dabei wird das Carry bit (<tt>STATUS,C</tt>) 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'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
<dl><dd>
|<--- Register R --->|
|c|<-7<-6<-5<-4<-3<-2<-1<-0
V A
|________________________|
</dd></dl>
:Zur Verdeutlichung:
<dl><dd>
|C| |-Register R-| ;C steht für das Carry-bit, STATUS,C ; 0-7 stehen für Bitnummer im Register.
c 7 6 5 4 3 2 1 0 ;vor der Rotation
7 6 5 4 3 2 1 0 c ;nach der Rotation
</dd></dl>

RRF R,d Rotate Right F through carry - Rotiere das Register f mithilfe des Carry-bits nach rechts<hr>
:Alle Bits im Register '''R''' werden um eine Position nach rechts verschoben. Dabei wird das Carry bit (<tt>STATUS,C</tt>) 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'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
<dl><dd>
|<--- Register R --->|
|c|->7->6->5->4->3->2->1->0
A V
|________________________|
</dd></dl>
:Zur Verdeutlichung:
<dl><dd>
|C| |-Register R-| ;C steht für das Carry-bit, STATUS,C ; 0-7 stehen für Bitnummer im Register.
C 7 6 5 4 3 2 1 0 ;vor der Rotation
0 C 7 6 5 4 3 2 1 ;nach der Rotation
</dd></dl>

SLEEP Go into standby mode - Versetze den Mirokontroller in Bereitschaftsmodus (Schlaf)<hr>
: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.

 SUBLW k SUBtract W from Literal - Ziehe W von Zahl (k) ab<hr>
: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|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

 SUBWF R,d SUBtract W from F - Ziehe W von f ab<hr>
:Es wird die Rechenoperation <math>R-W</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Dieser Befehl beeinflusst das STATUS-Register. Siehe hierzu [[#Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

:Beispiel:
<dl><dd>
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
</dd></dl>

SWAPF R,d SWAP nibbles in F - Vertausche die Halbbytes (Nibbles)<hr>
:Es werden die höheren 4 bit (bit7-bit4) mit den niedrigeren 4 bit (bit3-bit0) eines Registers vertauscht und entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
:Beispiel:
<dl><dd>
movlw b'00001111' ;schreibe b'00001111' in das W-Register
movwf Register1 ;kopiert 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'
</dd></dl>

 XORLW k EXclusive OR Literal with W<hr>
:Es wird bitweise die logische Funktion <math>k\ xor\ W</math> ausgeführt und das Ergebniss in das W-Register gespeichert. Dieser Befehl setzt das Z bit des STATUS-Registers, falls W=k und das Ergebnis 0 ist.
:Zur Verdeutlichung der Operation:
<dl><dd>
11001010 ;k
10101100 ;W-Register
-------- xor
01100110 ;W-Register
</dd></dl>

 XORWF R,d EXclusive OR W with F<hr>
:Es wird bitweise die logische Funktion <math>W\ xor\ R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Vergleiche XORLW. Dieser Befehl setzt das Z bit des STATUS-Registers, falls W=k und das Ergebnis 0 ist und wird zum Vergleichen zwei Register benutzt.

==Besondere, oft gebrauchte Register==

=== STATUS ===
Der Statusregister beinhaltet den Status der Recheneinheit ALU (Arithmetic-Logic Unit), Resetinformationen und die beiden Bits zur Wahl der Speicherbank

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''STATUS''' (ADDRESSE 03h, 83h, 103h, 183h)</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R-1</td>
<td style="width:60px;">R-1</td>
<td style="width:60px;">R/W-x</td>
<td style="width:60px;">R/W-x</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''IRP'''</td>
<td style="background:#f5f7ff;">'''RP1'''</td>
<td style="background:#f5f7ff;">'''RP0'''</td>
<td style="background:#f5f7ff;">'''TO'''</td>
<td style="background:#f5f7ff;">'''PD'''</td>
<td style="background:#f5f7ff;">'''Z'''</td>
<td style="background:#f5f7ff;">'''DC'''</td>
<td style="background:#f5f7ff;">'''C'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

*Bit 7 '''IRP''': Register Bank Select Bit (für indirekte Adressierung)
:: 1 = Bank 2, 3 (100h-1FFh)
:: 0 = Bank 0, 1 (00h-FFh)
*Bit 6-5 '''RP<1:0>''': Register Bank Select Bits (für direkte Adressierung)
:: 11 = Bank 3 (180h-1FFh)
:: 10 = Bank 2 (100h-17Fh)
:: 01 = Bank 1 (80h-FFh)
:: 00 = Bank 0 (00h-7Fh)
*Bit 4 '''TO''': Time-out Bit
:: 1 = Nach Power-up, CLRWDT Befehl oder SLEEP Befehl
:: 0 = A Watchdogtimer time-out ist eingetreten
*Bit 3 '''PD''': Power-Down Bit
:: 1 = Nach Power-up oder durch den CLRWDT
:: 0 = Nach einem SLEEP befehl
*Bit 2 '''Z''': Zero bit
:: 1 = Das Ergebnis einer arithmetischen oder logischen Operation ist 0
:: 0 = Das Ergebnis einer arithmetischen oder logischen Operation ist NICHT 0
*Bit 1 '''DC''': Digit carry/borrow bit (ADDWF, ADDLW, SUBLW und SUBWF Befehle)
:: 1 = Ein Carry-out des 4.Niedrigsten Bits (Low Nibble) eines Rechenergebnisses existiert
:: 0 = Kein Carry-out des 4.Niedrigsten Bits eines Rechenergebnisses existiert
*Bit 0 '''C''': Carry/borrow Bit (ADDWF, ADDLW, SUBLW und SUBWF Befehle)
:: 1 = Ein Carry-out des MSB eines Rechenergebnisses existiert
:: 0 = Kein Carry-out des MSB eines Rechenergebnisses existiert

Das "Carry/Borrow Bit" (to carry = etwas übertragen, to borrow = etwas borgen) dient zum erkennen, wenn ein Übertrag einer Rechenoperation exisitiert. 250d+10d ergibt zum Beispiel 4, und setzt dabei das "Carry/Borrow Bit" auf 1. Damit kann das Programm erkennen, wenn wieder einmal ein Ergebnis größer als 255d herauskam.
Bei Subtraktionen (SUBLW und SUBWF) verhält sich das "Carry/Borrow Bit" umgekehrt als bei Additionen (ADDWF und ADDLW)!! Zum Beispiel 55d-6=49d setzt "Carry/Borrow Bit" auf 1 aber 10d-25d=241d löscht das "Carry/Borrow Bit".

====Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Registers====

{|
|-
|
{| {{Blauetabelle}}
|+ Auswirkungen auf das STATUS-Register bei Subtraktionen
|-
| Ergebnis
|| STATUS,C
|| STATUS,Z
|-
| positiv
|align="center"|1
|align="center"|0
|-
| negativ
|align="center"|0
|align="center"|0
|-
| Null
|align="center"|1
|align="center"|1
|}

||

{| {{Blauetabelle}}
|+ Auswirkungen auf das STATUS-Register bei Additionen
|-
| Ergebnis
|| STATUS,C
|| STATUS,Z
|-
| positiv
|align="center"|0
|align="center"|0
|-
| Überlauf
|align="center"|1
|align="center"|0
|-
| Null
|align="center"|1
|align="center"|1
|}
|}

=== PORTx ===

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''PORTx'''</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''Rx7'''</td>
<td style="background:#f5f7ff;">'''Rx6'''</td>
<td style="background:#f5f7ff;">'''Rx5'''</td>
<td style="background:#f5f7ff;">'''Rx4'''</td>
<td style="background:#f5f7ff;">'''Rx3'''</td>
<td style="background:#f5f7ff;">'''Rx2'''</td>
<td style="background:#f5f7ff;">'''Rx1'''</td>
<td style="background:#f5f7ff;">'''Rx0'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

!Das "x" steht in allen Fällen für den Buchstaben des Ports!
BSP: "PORTB" oder "RA1"

Diese Special Funktion Register liegen ALLE in Bank0 und Bank2(Falls vorhanden).

Jedes Bit eines PORT-Registers steht für einen Pin (Ein/Ausgang) des jeweiligen Ports. Je nachdem Ob ein Pin als Ausgang oder als Eingang definiert ist, kann man dort entweder den Wert schreiben oder auslesen. Es hat nicht Jeder PIC gleich viele Ports und es sind auch nicht immer 8 Pins pro Port, es können auch weniger sein. Alle PICs der Midrange-Serie besitzen nur bidirektionale Ports, d.h. sie können sowohl Eingang als auch Ausgang sein. Bei Port B kann man bei allen Pins einen internen PULL-UP Widerstand mit dem Bit OPTION_REG<RBPU> hinzuschalten (Standardmäßig auf nicht aktiviert, Bit muss gelöscht werden um die Funktion zu aktivieren). Weiters ist zu beachten, dass einzelne Pins nach dem Reset mit anderen Funktionen belegt sein können. Das gilt im Speziellen für PORTA, wo sich die Komperatoren, AD's (falls vorhanden) und die Oszillatoreingänge befinden. Siehe [[PIC Assembler#I/O Ports|I/O Ports]]. Bei den "kleinsten" PICs der 12F Serie die nur einen I/O Port (6 Pins) haben, heisst der PORT-Register GPIO.
{|{{Blauetabelle}}
|+ Beispiel PICs und ihre Ports (Zahlen in der Klammer sind die Anzahl der Pins des Ports)
|
|'''PIC16F628A'''
|'''PIC16F876'''
|'''PIC16F877'''
|-
|'''PORTA'''
|Ja
|Ja(5)
|Ja(6)
|-
|'''PORTB'''
|ja
|ja
|ja
|-
|'''PORTC'''
|/
|ja
|ja
|-
|'''PORTD'''
|/
|/
|ja
|-
|'''PORTE'''
|/
|/
|ja (3)
|-
|}

=== TRISx ===

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''TRISx'''</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''TRISx7'''</td>
<td style="background:#f5f7ff;">'''TRISx6'''</td>
<td style="background:#f5f7ff;">'''TRISx5'''</td>
<td style="background:#f5f7ff;">'''TRISx4'''</td>
<td style="background:#f5f7ff;">'''TRISx3'''</td>
<td style="background:#f5f7ff;">'''TRISx2'''</td>
<td style="background:#f5f7ff;">'''TRISx1'''</td>
<td style="background:#f5f7ff;">'''TRISx0'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

!Das "x" steht in allen Fällen für den Buchstaben des Ports!
BSP: "TRISB" oder "TRISA"

Bei den "kleinsten" PICs der 12F Serie die nur einen I/O Port (6 Pins) haben, heisst der TRIS-Register TRISIO.

Die TRIS-Bytes dienen dazu, einzelne I/O Pins als Eingang oder Ausgang zu definieren. Sie liegen immer genau eine Bank über den jeweiligen PORT-Bytes, d.h. sie liegen alle in Bank1 und Bank3 (falls vorhanden.) Besonders zu beachten ist, dass manche Eingebaute Features wie die Serielle Schnittstelle, I2C, SPI usw nicht funktionieren, wenn die Jeweiligen Sende und Empfangspins nicht manuell umgestellt werden, ja es ''muss'' sogar manchmal umgestellt werden (bei I2C z.B.) Egal ist dies jedoch für Komperatoren und AD-Wandler.

Merke:
* Eine 1 (als "I" für "Input" zu lesen) eines TRISxx-Bits definiert den zugehörigen PIN am PIC als Eingang.
* Eine 0 (als "O" für "Output" zu lesen) eines TRISxx-Bits definiert den zugehörigen PIN am PIC als Ausgang.

Siehe [[PIC Assembler#I/O Ports|I/O Ports]].

=== INTCON ===

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''INTCON''' (ADDRESSE 0Bh, 8Bh, 10Bh, 18Bh)</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''GIE'''</td>
<td style="background:#f5f7ff;">'''PEIE'''</td>
<td style="background:#f5f7ff;">'''TMR0IE'''</td>
<td style="background:#f5f7ff;">'''INT0IE'''</td>
<td style="background:#f5f7ff;">'''RBIE'''</td>
<td style="background:#f5f7ff;">'''TMR0IF'''</td>
<td style="background:#f5f7ff;">'''INT0IF'''</td>
<td style="background:#f5f7ff;">'''RBIF'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

*Bit 7 '''GIE''': Global Interrupt Enable Bit
::1 = Aktiviert alle Interrupts
::0 = Deaktiviert alle Interrupts
*Bit 6 '''PEIE''': Peripheral Interrupt Enable Bit
::1 = Aktiviert alle peripheren Interrupts
::0 = Deaktiviert alle peripheren Interrupts
*Bit 5 '''TMR0IE''': TMR0 Overflow Interrupt Enable Bit (Overflow von Timer0 löst Interrupt aus)
::1 = Aktiviert den TMR0 Interrupt
::0 = Deaktiviert den TMR0 Interrupt
*Bit 4 '''INT0IE''': RB0/INT External Interrupt Enable Bit (Änderung an RB0 Pin löst Interrupt aus) *)
::1 = Aktiviert den RB0/INT Interrupt (Extern ausgelöst)
::0 = Deaktiviert den RB0/INT Interrupt (Extern ausgelöst)
*Bit 3 '''RBIE''': RB Port On-Change-Interrupt Enable Bit (Änderung an PortB löst Interrupt aus) **)
::1 = Aktiviert den RB port on-change-interrupt
::0 = Deaktiviert den RB port on-change-interrupt
*Bit 2 '''TMR0IF''': TMR0 Overflow Interrupt Flag Bit
::1 = TMR0 Register ist Übergelaufen (muss per Software gelöscht werden)
::0 = TMR0 register ist nicht Übergelaufen
*Bit 1 '''INT0IF''': RB0/INT External Interrupt Flag Bit
::1 = Eine Änderung an RB0/INT Pin hat stattgefunden (muss per Software gelöscht werden)
::0 = Eine Änderung an RB0/INT Pin hat nicht stattgefunden
*Bit 0 '''RBIF''': RB Port On-Change-Interrupt Flag bit
::1 = Mind. einer der Pins von RB7:RB4 hat sich geändert (muss per Software gelöscht werden)
::0 = Keiner der Pins von RB7:RB4 hat sich geändert

* *) Die Flanke auf die reagiert werden soll, wird mit dem Bit OPTION_REG.INTEDG definiert. (steigende = 1 oder fallende = 0)
* **) Der Interrupt klingt verführerischer Weise so, als ob er den gesamten Port überwacht. Dabei reagiert er nur auf RB7:RB4!!!! Er kann aber den Prozessor vom "Schlaf" aufwecken (z.B. durch einen Tastendruck).

==Speicherbankorganisation==
===Programmspeicher===
Die Mid-Range MCUs haben einen 2-8k großen Programmspeicher. Dieser hat aber in jeder Speicherzelle nicht 8, sondern 14 Bit - also genau die Länge eines Befehls. Die aktuelle Stelle im Programm wird im PC (Program Counter) verwaltet. Er speichert immer die aktuelle Adresse im Programmspeicher (wird im Code oft als "$" bezeichnet). Bei einem PIC mit 8k Adressen muss er also die Adressen 0000-1FFF speichern können. Daraus folgt die Größe von 13 Bit für den PC. Der Programmspeicher ist in mehrere Bänke geteilt, die alle 2k groß sind. Das Programm springt ohne zutun des Benutzers von einer in die Nächste. Wenn man aber selber springen will, muss man die Register PCLATH (Program Counter Latch High) oder PCL (Program Counter Least Significant Byte) mit der Sprungadresse beschreiben.

===Datenspeicher===
Der Datenspeicher besteht aus den Special Function Registern (SFR) und den General Purpose
Registern (GPR). Die SFRs sind für die Funktionen des PICs zuständig (Interrupts, Timer, ADCs, CCPM...) und die GPRs für die Speicherung von Variablen und Daten.

Da immer nur 7 Bit der (Ziel)Adresse in einem Befehl gespeichert werden können, sind nur 7Fh (128d) Adressen im Datenbereich möglich. Deswegen wurde das "Banking" eingeführt. 2 Bit im Statusregister (welcher in allen Bänken der selbe ist und auch an der gleichen Stelle sitzt) geben die akutelle "Bank" an und sind nichts anderes als die 2 höchstwertigsten (MSB) Bits der Adresse. Damit lassen sich max. 4 Bänke ansprechen. Je nach PIC gibt es 2-4 Bänke. Die beiden Bits im Register STATUS heißen RP0 (STATUS<5>) und RP1 (STATUS<6>).

{| {{Blauetabelle}}
|+ Wechseln der Bänke mit RP0 und RP1
|-
|
|| RP1
|| RP0
|-
| Bank0
|align="center"|0
|align="center"|0
|-
| Bank1
|align="center"|0
|align="center"|1
|-
| Bank2
|align="center"|1
|align="center"|0
|-
| Bank3
|align="center"|1
|align="center"|1
|}

[[Bild:PIC midrange register.JPG]]
# '''FETTE Register''' sind in allen PICs vorhanden
# können je nach PIC unimplementierte Bereiche beinhalten - diese werden immer als 0 gelesen. (DATENBLATT!!)
# siehe 2
# Könnten je nach PIC auch nicht in Bank0 gemapped werden, sind dann eigenständige Register.
# je nach PIC kann es diese Bänke geben oder nicht geben.

== Codeschnipsel ==

=== Analog-Digital-Wandler (ADC) ===

Viele PICs besitzen einen Analog-Digital-Wandler, der eine angelegte Spannung messen kann und diese als Zahl speichert.

Es gibt AD-Wandler mit 8Bit bzw. 10Bit Auflösung, d.h. die Spannung an einem analogen Eingang wird linear 2^8=256 bzw. 2^10=1024 Werten zugeordnet.
Der höchste Wert, auch Referenzspannung genannt, (255 bzw. 1023; der Controller rechnet die Null auch mit) entspricht der Betriebsspannung des PICs oder wahlweise einer wählbaren Spannung, die an RA3 angelegt werden muss. Der niedrigste Wert entspricht 0 Volt.

Mit dem Analog-Digital-Wandler kann man somit z.B. Sensoren auswerten, die mehr als zwei Zustände ausgeben (Beispiele: Temperatursensor, Helligkeitssensor, Entfernungssensoren usw.) oder Akkuspannungen messen.

Bevor überhaupt gemessen werden kann, muss einiges eingestellt werden:

* Eingangsverteilung Analog/Digital bzw.Referenzspannung (Betriebsspannung oder RA3)
die genauen Einstellungsmöglichkeiten entnehmen sie bitte dem Datenblatt ihres Controllers (Register ADCON1 Bank 1).

* Wählen des Taktes für den ADC und Einschalten des ADCs

Das Register ADCON0 besitzt 8 Bits, die folgendes bestimmen:
Bit0 ADON - schaltet AD-Wandler ein oder aus (Strom sparen)
Bit1 - nicht vorhanden
Bit2 GO/Done - startet Wandlung / signalisiert, wann Umwandlung beendet ist.
Bit3 CHS0 - Channel Select 0 wählt Eingang aus
Bit4 CHS1 - Channel Select 1 wählt Eingang aus
Bit5 CHS2 - Channel Select 2 wählt Eingang aus
Bit6 ADCS0 - AD-Clock-Select wählt Takt
Bit7 ADCS1 - AD-Clock-Select wählt Takt

Kümmern wir uns zunächst um den Takt. Mit den zwei Bits ADCS0 und ADCS1 bestimmt man den Takt - hierbei gibt es vier Möglichkeiten:

ADCS1=0, ADCS0=0 -> Taktfrequenz des PICs :2
ADCS1=0, ADCS0=1 -> Taktfrequenz des PICs :8
ADCS1=1, ADCS0=0 -> Taktfrequenz des PICs :32
ADCS1=1, ADCS0=1 -> interner RC-Oszillator des ADCs verwenden

Die Taktfrequenz des ADCs darf 625kHz nicht überschreiten, dementsprechend ist ADCS0 und ADCS1 zu wählen.

Ist dies vollbracht, so kann man den AD-Wandler einschalten und das Go/Done-Bit löschen.
Codebeispiel:

bcf ADCON0,6 ;Takt für
bsf ADCON0,7 ;ADC (OSC/32)
bsf ADCON0,0 ;ADC einschalten, ADON=1
bcf ADCON0,2 ;Go/Done-Bit zurücksetzen

Nun ist der AD-Wandler bereit, Spannungen in Zahlen umzuwandeln.
Für eine Wandlung muss erst der entsprechende Eingang gewählt werden. Dafür sind die CHS0..CHS2-Bits zuständig:

CHS2 CHS1 CHS0 gewählter Eingang(falls vorhanden)
0 0 0 RA0
0 0 1 RA1
0 1 0 RA2
0 1 1 RA3
1 0 0 RA5
1 0 1 RE0
1 1 0 RE1
1 1 1 RE2

Achtung! RA4 ist kein analoger Eingang, folglich ist er oben nicht aufgelistet !!

Codebeispiel:

bcf ADCON0,3 ;RA2 auswählen
bsf ADCON0,4
bcf ADCON0,5

Als letztes muss die AD-Routine nur noch gestartet werden. Ist der AD-Wandler fertig, so löscht er das Bit wieder. Das Bit wird nun solange abgefragt, bis der AD-Wandler fertig ist. Den zugeordneten Wert findet man im Register 'ADRES'.
Code:

bsf ADCON0,2 ;start
wa btfsz ADCON0,2 ;warten,bis es wieder low ist
goto wa ;noch nicht fertig
;jetzt ist er fertig
movf ADRES,W ;ADRES in W verschieben, um damit gleich weiter zu arbeiten

Die AD-Wandlung ist somit fertig. Liest man mehrere Werte von unterschiedlichen Eingängen ein und möchte diese miteinander vergleichen o.ä., sollte man die Zahlen von ADRES in anderen Registern zwischenspeichern.

Desweiteren ist zu beachten, dass der Analog-Digital-Wandler eine gewisse Pause zwischen den Wandlungen benötigt, die sog. 'Aquisition Time'. Diese Zeitangabe entnehmen sie bitte ihrem Datenblatt.

mögliche Probleme:

;Der PIC liefert stark schwankende Werte
:-> Mögliche Ursachen dafür sind z.B. nicht stabile Betriebsspannung, falsche Zeiteinstellungen. Abhilfe schafft auch das mehrmalige Einlesen eines Eingangs. Auch können z.B. 8 Werte eingelesen werden und dann der Durchschnitt gebildet werden.
Evtl. kann ein Kondensator gegen Masse (z.B. 1nF) helfen; Wichtig ist auch eine kleine Verzögerung zwischen Kanalauswahl und Start der Wandlung. In dieser Zeit kann sich der interne Kondensator des ADC's aufladen.

;Die Spannung an einem Eingang wird erhöht, die Werte der anderen Eingänge werden aber auch beeinflusst.
:-> Dann sind Sie Opfer des sog. 'Ghostings' geworden (Werte 'scheinen durch', verschleißen). Die Werte der anderen Eingänge gehen mit, weil der interne Kondensator noch auf die Spannung des Vorgängers aufgeladen ist. Maßnahme: Aquisition Time erhöhen, Werte öfters abfragen, Pause zwischen Kanalauswahl und Start

;Der PIC liefert immer die gleichen Werte an einem Eingang, obwohl sich die angelegte Spannung ändert
:-> möglicherweise falsche Eingangsverteilung (ADCON1) eingestellt oder falschen Pin gewählt

=== Hex Dec Wandlung ===

Das ist ein Unterprogramm das mit "call Hex_Dec" aufgerufen wird. Es gibt 4 Register (A, B, C und D) mit jeweils 32 Bits, die aus jeweils 4 Register mit 8 Bits (z.B. fur A: A3, A2, A1 und A0) bestehen.

A3 A2 A1 A0
.--------.--------.--------.--------.
|76543210|76543210|76543210|76543210|
'--------'--------'--------'--------'
| |
|<----------- A Register ---------->|

Sie müssen (wegen FSR) so wie im Code nacheinander liegen (die absoluten Adressen sind nicht wichtig). In das Register "A" wird die hex Zahl eingeschrieben und aus dem "D" die umgewandelte dec Zahl ausgelesen. A3,7 und D3,7 sind MSB und A0,0 und D0,0 sind LSB. Die "B" und "C" sind Hifsregister. Das UP kann für kleinere als 32-bittige hex Zahlen modifiziert werden. Zum Beispiel für 16-bittige hex Zahlen bleiben nur Register A1,A0,B1,B0,C1,C0,D1,D0 und in den UPs werden in die Register und als X, folgende Zahlen eingeschrieben: HTmp->0x10 (Anzahl Bits der hex Zahl),ATmp->2=X (Anzahl Bytes der hex Zahl). Es müssen auch die UPs "CClr", "DClr" und "CopyCB" entschprechend der Registerlänge angepasst werden. Genauso kann natürlich das UP auch für längere hex Zahlen modifiziert werden.

Das UP "AddCB" addiert dezimal die 32- bittige Register C und B, das Ergebniss befindet sich in C.
Das UP "AddDC" addiert dezimal die 32-bittige Register D und C, das Ergebniss befindet sich in D.

Die 32-bit Additionen werden in 4 Schritten wie folgt realisiert:

C0+B0->C0, C1+B1->C1, C2+B2->C2 und C3+B3->C3

D0+C0->D0, D1+C1->D1, D2+C2->D2 und D3+C3->D3

Die Flags "_Fcra", "_Fcrp" und "_Fdca" steuern die alle nötigen Korrekturen.

Die Wandlung wird in 32 Schritten laut folgender Formel durchgeführt:

Zahl(d)=B0*2^0+B1*2^1+B2*2^2+B3*2^3+B4*2^4+B5*2^5+B6*2^6+B7*2^7+B8*2^8+B9*2^9+B10*2^10+B11*2^11+

B12*2^12+B13*2^13+B14*2^14+B15*2^15+B16*2^16+B17*2^17+B18*2^18+B19*2^19+B20*2^20+B21*2^21+

B22*2^22+B23*2^23+B24*2^24+B25*2^25+B26*2^26+B27*2^27+B28*2^28+B29*2^29+B30*2^30+B31*2^31

Wobei B0 bedeutet den LSB und B31 den MSB der hex Zahl.

Die dec Zahl wird im D Register durch "AddDC" gebildet. In dem C Register befindet sich immer die laufende 2^X. Am Anfang wird dort 1=2^0 geladen. Da die nächste zu addierende dec Zahl immer gleich 2* vorherige ist, wird sie einfach so berechnet, dass die aktuelle aus C Register ins B Register kopiert ("CopyCB") und zum C addiert ("AddCB") wird. Diese dec Zahl wird zum D Register addiert nur wenn entsprechender Bit der hex Zahl gleich 1 ist. Weil im UP "Hex_Dec" immer das bit A0,0 dafür geprüft wird, wird das gesamte 32-bittige A Register nach jeder Addition "AddDC" um ein Bit mit "ARotRb" nach rechts rotiert. Die Flags "_Fcra" und "_Fcrp" übertragen die Bits zwischen den 8 Bit Register A0, A1, A2 und A3. Es würde zwar reichen, wenn das A Register nur verschoben würde, aber hier wurde Rotation gewählt, damit nach der Wandlung die hex Zahl im A Register unverändert steht. Weil die dec Zahl nur 8-stellig ist, die max. hex Zahl darf 99999999d = 5F5E0FFh sein.

#define _C STATUS,C
#define _Z STATUS,Z
#define _DC STATUS,DC
#define _Fcra Flags,0
#define _Fcrp Flags,1
#define _Fdca Flags,2
#define _Ferr Flags,3 ;Überlauf (Fehler)
;..................................................................................
A3 EQU 0x20 ;Register fürs Rechnen
A2 EQU 0x21
A1 EQU 0x22
A0 EQU 0x23
B3 EQU 0x24
B2 EQU 0x25
B1 EQU 0x26
B0 EQU 0x27
C3 EQU 0x28
C2 EQU 0x29
C1 EQU 0x2A
C0 EQU 0x2B
D3 EQU 0x2C
D2 EQU 0x2D
D1 EQU 0x2E
D0 EQU 0x2F
Flags EQU 0x30
ATmp EQU 0x31 ;Schleifenzähler
HTmp EQU 0x32 ;Schleifenzähler
RTmp EQU 0x33 ;Zwischenspeicher
;..................................................................................
Hex_Dec call CClr ;Hex>A, D>Dec
call DClr
movlw 1
movwf C0
movlw 0x20 ;32 bit Hex > 32 bit Dec (8 Stellen)
movwf HTmp
HexDecL btfsc A0,0
call AddDC
call CopyCB
call AddCB
call ARotRb
decfsz HTmp,1
goto HexDecL
return
CClr clrf C0
clrf C1
clrf C2
clrf C3
return
DClr clrf D0
clrf D1
clrf D2
clrf D3
return
CopyCB movf C0,0
movwf B0
movf C1,0
movwf B1
movf C2,0
movwf B2
movf C3,0
movwf B3
return
AddCB movlw B0 ;C+B>C
movwf FSR
goto AddR
AddDC movlw C0 ;D+C>D
movwf FSR
AddR bcf _Ferr ;Addiere zwei Register
bcf _Fcrp
movlw 4 ;X=4 Bytes lang
movwf ATmp
AddRL bcf _Fdca
bcf _Fcra
movf INDF,0
movwf RTmp
movlw 4 ;X=4
addwf FSR,1
btfss _Fcrp
goto AddRN
movlw 1
addwf INDF,1
call DecCor
AddRN movf RTmp,0
addwf INDF,1
call DecCor
btfss _Fdca
goto AddCor1
movlw 6
addwf INDF,1
AddCor1 btfss _Fcra
goto AddCor2
movlw 0x60
addwf INDF,1
btfsc _C
bsf _Fcra
AddCor2 movf INDF,0
andlw 0xF0
sublw 0xA0
btfss _Z
goto AddCor3
movf INDF,0
andlw 0x0F
clrf INDF
addwf INDF,1
bsf _Fcra
AddCor3 bcf _Fcrp
btfsc _Fcra
bsf _Fcrp
movlw 5 ;X+1=5
subwf FSR,1
decfsz ATmp,1
goto AddRL
btfsc _Fcra
bsf _Ferr
return
DecCor btfsc _DC ;dezimale Korrektur (equ DAW)
bsf _Fdca
btfsc _C
bsf _Fcra
movf INDF,0
andlw 0x0F
sublw 9
btfss _C
bsf _Fdca
movf INDF,0
andlw 0xF0
sublw 0x90
btfss _C
bsf _Fcra
return
ARotRb movlw A3 ;rotiere A register 1 Bit rechts
movwf FSR
RRotRb movlw 4 ;rotiere X=4 Bytes
movwf ATmp
bcf _Fcrp
btfsc A0,0
bsf _Fcrp
RRotRbL bcf _Fcra
btfsc INDF,0
bsf _Fcra
bcf _C
btfsc _Fcrp
bsf _C
rrf INDF,1
bcf _Fcrp
btfsc _Fcra
bsf _Fcrp
incf FSR,1
decfsz ATmp,1
goto RRotRbL
return

=== EEPROM ===

Alle PICs besitzen EEPROM in dem je nach Typ können 64 bis 256 Databytes abgespeichert werden. Die Adressierung des EEPROMs fängt immer mit 0x00 an. Hier werden nur geprüfte UPs kurz erklärt. Die ersten zwei brauchen nur ein Register "Temp" für Schleifenzähler, dessen Name, falls im Programm schon existiert, geändert werden muss. Die Adresse im EEPROM ist gleich der Adresse im RAM.

EEPROM beschreiben:

EEWrite movlw 0x20 ; ab der RAM Adresse wird in EEPROM abgespeichert
movwf FSR
movlw 4 ; soviel Bytes
movwf Temp ; Schleifenzähler
EEWLoop call EEWrite1
incf FSR,1 ; nächste Adresse
decfsz Temp,1
goto EEWLoop
return

EEWrite1 bcf INTCON,GIE ; Interrupts sperren
movf FSR,0
bsf STATUS,RP0 ; auf Bank1 umschalten
movwf EEADR ; EEPROM Adresse
movf INDF,0
movwf EEDATA ; EEPROM Data
bsf EECON1,WREN
movlw 0x55
movwf EECON2
movlw 0xAA
movwf EECON2
bsf EECON1,WR
bcf EECON1,WREN
btfsc EECON1,WR
goto $-1 ; warten bis WR=0
bcf STATUS,RP0 ; zurück auf Bank 0 umschalten
bsf INTCON,GIE ; Interrupts erlauben
return

EEPROM lesen und zurück in RAM schreiben:

EERead movlw 0x20 ; ab der Adressse wird aus EEPROM in RAM abgelegt
movwf FSR
movlw 4 ; soviel Bytes
movwf Temp ; Schleifenzähler
EERLoop call EERead1
incf FSR,1 ; nächste Adresse
decfsz Temp,1
goto EERLoop
return

EERead1 movf FSR,0
bsf STATUS,RP0 ; auf Bank1 umschalten
movwf EEADR ; EEPROM Adresse
bsf EECON1,RD
movf EEDATA,0 ; EEPROM Data
bcf STATUS,RP0 ; zurück auf Bank 0 umschalten
movwf INDF
return

Tabelle im EEPROM mit MPASM Direktive "de" erstellen:

org 0x2100 ; EEPROM initialisieren
; nachfolgend als Kommentar die EEPROM Adressen
de 0x03, 0xE8 ; 0x00
de 0x03, 0xE8 ; 0x02
de 'M','H','z',0x00 ; 0x04
de ' ',' ','W','A','I','T',0x00 ; 0x08
de 'C','o','n','s','t',' ','X',0x00 ; 0x0F
de 'C','=',0x00 ; 0x17
de 'L','=',0x00 ; 0x1A
de 'F','=',0x00 ; 0x1D
de 'O','K',0x00 ; 0x20
u.s.w.

Wenn die Tabelle sich im Quellcode befindet, wird sie beim brennen des PICs in EEPROM eigeschrieben.

Das Lesen eines Strings muss ab entsprechender EEPROM Adresse (z.B. für "MHz" -> 0x04) anfangen und auf dem Wert 0x00, der hier als Stringende dient, enden. Einfacher ist, wenn alle Strings gleich lang sind (wie z.B. in einem Zeichengenerator fur Grafikdisplay).

Die Adreesse "0x2100" in der "org" Direktive hat mit der Adresse im Programmspeicher nichts zu tun.

=== Interrupts ===

Das Programmteil misst eine Frequenz an TOCKI Pin und wurde für PIC16F870 geschrieben.

Benötigte Hardware: Widerstand 470 Ohm zwischen der Frequenzquelle und TOCKI Pin (A4).

Es fehlen UPs "Hex_Dec" [[#Hex Dec Wandlung|Hex Dec Wandlung]] und Ausgabe auf ein Display "DispFrq". Das HP ("Main") als leere endlose Schleife macht nichts ausser warten auf ein Interrupt von Timer0 bzw. Timer1. Man kann die Marke "Main" weglassen und das HP als "goto $" formulieren.

Da der Timer0 nicht, wie der Timer1 durch ein Flag gestartet und gestoppt werden kann, wird es durch setzen und löschen des Bits für TOCKI (A4) Pin im TRISA Register, genauso wie in der AN592 vom Microchip, gemacht.

Der Zähler der Frequenz wurde um ein Zähler aus zwei zusätzlichen Register A2 und A3 erweitert und bei jedem Timer0 Überlauf erhöht. Der Prescaler wird ins Register A0 und der TIMER0 ins A1 kopiert. Somit ergibt sich 32-bittiges Ergebniss, der als hex Zahl in den Register A3 (MSB),A2, A1, und A0 (LSB) steht. Nach der "Hex_Dec" Wandlung kann die Frequenz aus den Register D3 (MSB), D2, D1 und D0 (LSB) an einem biliebigen Display angezeigt werden.

Es wird kein zusätzliches Register benötigt, da das "ATmp" und das "RTmp" die gleichen wie im UP "Hex_Dec" sind. Die Quarzfrequenz wurde gewählt, weil sie am nächsten der Temperaturstabiltesten Frequenz für AT Quarzen 7,2 MHz ist. Der PIC16F870 wurde nur wegen nötigen 19 I/O Pins für 6-stelligen 7-segment LCD Display LPH2673-1[[http://www.roboternetz.de/phpBB2/viewtopic.php?t=26005]] (ohne Kontroller) vom Pollin angewendet. Mit einem üblichen 1x16 Zeichen LCD Matrixdisplay und anderen PICs wurde das Programm für Frequenzen bis zum 80 MHz mit einer Genauigkeit
+/- 4 Hz positiv getestet.

Um die Frequenz mit Genauigkeit +/- 1Hz zu messen, muss die Messzeit 1 s von Timer1 erzeugt werden, das nur für Quarz bis 2,048 MHz möglich ist. Für sehr genaue Messungen wird empfohlen als Taktfrequenz für den Timer1, die Trägerfrequenz eines nächsten LW Senders (z.B. DLF 153 bzw. 207 kHz) zu nutzen. Die Genauigkeit der Frequenz ist ca. 1E-11 und geprüfter Empfänger kann laut der Skizze in [[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=13706&highlight=frequenzz%E4hler]] nachgebaut werden. In dem Fall müssen die Register vom Timer1 (TMR1H und TMR1L) vor seinem Start entsprechend geladen werden.

Mit dem Quarz 7,3728 MHz wird hier die Messzeit 0,25 s genutzt und die gemessene Frequenz durch 4 multipliziert (mittels 2 Additionen), was die Auflösung von +/- 4 Hz ergibt.

Das UP "Init" muss selbstverständlich für ein Matrixdisplay um Initialisierung des Displaykontrollers ergänzt werden.

; Programm zum Messen der Frequenz an T0CKI Pin mit 7,3728 MHz Quarz
LIST P=16F870
include "P16F870.inc"
__CONFIG _CP_OFF & _DEBUG_OFF & _WRT_ENABLE_ON & _CPD_OFF & _LVP_OFF & _BODEN_OFF &
_PWRTE_ON & _WDT_OFF & _HS_OSC
ORG 0x0000
call Init
Main goto Main
ORG 0x0004 ;ISR (interrupt service routine)
bcf INTCON,GIE ;interrupts sperren
btfss INTCON,T0IF ;ist Timer0 übelaufen ?
goto CheckTMR1 ;nein, dann prüfe Timer1
bcf INTCON,T0IF ;Timer0 interrupt flag löschen
movlw 1
addwf A2,1 ;erhöhe A2
btfsc STATUS,C
incf A3,1 ;increment A3, wenn A2 überlaufen ist
CheckTMR1 btfss PIR1,TMR1IF ;ist Timer1 überlaufen ?
retfie ;wenn nicht, springe zurück zu Main
bsf STATUS,RP0 ;stopp Timer0
movf TRISA,0
andlw 0xEF
movwf TRISA ;TOCKI Pin (A4) als Ausgang
bcf STATUS,RP0
bcf T1CON,TMR1ON ;stopp Timer1
bcf PIR1,TMR1IF ;Timer1 interrupt flag löschen
GetFreq movf TMR0,0 ;Prescaler ins Register A0 kopieren
movwf A1
movwf RTmp
clrf ATmp
FToggle incf ATmp,1
bsf STATUS,RP0
bsf OPTION_REG,T0SE
bcf OPTION_REG,T0SE
bcf STATUS,RP0
movf TMR0,0
subwf RTmp,0
btfsc STATUS,Z
goto FToggle
comf ATmp,1
incf ATmp,0
movwf A0
call Hex_Dec
clrf A3 ;Register A löschen
clrf A2
clrf A1
clrf A0
call CopyDC
call AddDC ;gemessene Frequenz * 2
call CopyDC
call AddDC ;gemessene Frequenz * 4 = tatsächliche Frequenz
call DispFrq ;eigenes UP für benutztes Display
clrf TMR0 ;Timer0 löschen
movlw 0x34 ;Timer1
movwf T1CON ;konfigurieren
movlw 0x1F ;Timer1 laden (für 0,25 s)
movwf TMR1H
clrf TMR1L
bsf STATUS,RP0 ;start Timer0
movf TRISA,0
iorlw 0x10
movwf TRISA ;TOCKI Pin (A4)als Eingang
bcf STATUS,RP0
bsf T1CON,TMR1ON ;start Timer1
retfie ;erlaube interrupts und springe zurück zu Main
CopyDC movf D0,0
movwf C0
movf D1,0
movwf C1
movf D2,0
movwf C2
movf D3,0
movwf C3
return
Init clrf PORTA ;Ports löschen
clrf PORTB
clrf PORTC
movlw 0x20 ;RAM (20-7Fh) löschen
movwf FSR
clrf INDF
incf FSR,1
btfss FSR,7
goto $-3
clrf ADCON0 ;schalte ADC off
movlw 7 ;sperre ADC
movwf ADCON1 ;und definiere RA0-7 als digitale I/Os
movlw 0xE0 ;GIE, PEIE & TMR0IE erlauben
movwf INTCON
bsf STATUS,RP0 ;bank 1
clrf TRISA ;alle PORTA,
clrf TRISB ;alle PORTB,
clrf TRISC ;und alle PORTC Pins als Ausgänge
movlw 0xE7 ;Takt für Timer0 vom T0CKI Pin
movwf OPTION_REG ;Timer0 konfigurieren
bsf PIE1,TMR1IE ;TMR1 interrupt erlauben
bcf STATUS,RP0 ;Bank 0
clrf TMR0 ;Timer0 löschen
movlw 0x34 ;Timer1 konfigurieren
movwf T1CON ;(prescaler 8)
movlw 0x1F ;Timer1 laden (für 0,25 s)
movwf TMR1H
clrf TMR1L
bsf STATUS,RP0 ;start Timer0
iorlw 0x10
movwf TRISA ;TOCKI Pin (A4) als Eingang
bcf STATUS,RP0
bsf T1CON,TMR1ON ;start Timer1
return
end

=== Mausrad ===

Das UP wertet ein Mausrad aus und setzt, je nach Drehrichtug und sein Anschluss an PORT (PORTB,0 und PORTB,1), ein Flag "_Finc" bzw. "_Fdec", das vor der nächsten Abfrage, gelöscht werden muss. Diese Flags können z.B. für Inkrementierung und Dekrementierung von Zählern dienen.

Die Hardware:

Mausrad
.-------.
| o---> PORTB,0
+----o---- |
| | o---> PORTB,1
=== '-------'
GND

Es müssen die internen pull-ups vom PORTB aktiviert werden. Wenn das Mausrad an anderen PORT angeschlossen wird, werden externe pull-ups (z.B. 10 kOhm) benötigt. Als "_Z" wurde "STATUS,Z" definiert. Zum Auswerten werden 4 Register "MausA", "MausB", "MausC" und "Flags" gebraucht, die im gesamten Programm definiert werden müssen. Die Warteschleife "Delay" soll ca. 10ms sein.

In dem UP "Mouse" wird PORTB eigelesen, die alle Bits ausser 0 und 1 durch "and" Funktion gelöscht und in den Register "MausB" und "MausC" gespeichert. Nach ca. 10ms wird das gleiche gemacht und im Register "MausA" gespeichert. Der Wert aus "MausA" wird mit dem vorherigen aus "MouseC" durch "xor" verglichen. Sind sie nicht identisch, wird je nach dem Wert "X" (0, 1, 2, b.z.w. 3) im "MausB" in das entsprechende UP "MouseX" gesprungen. Sonst, wenn "MausA"="MausC", wird zum Aufrufer zurückgekehrt.

In einem UP "MouseX" wird der letzte Wert im "MausA" ermittelt und nach der Kombination der Werte im "MausB" und "MausA" (01 b.z.w. 02, 10 b.z.w. 13, 20 b.z.w. 23 oder 31 b.z.w. 32) entsprechendes der Drehrichtung Flag "_Finc" b.z.w. "_Fdec" gesetzt. Anschliessend wird zum Aufrufer zurückgesprungen.

Detailierter PAD:

Mouse V
PORTB->W
3 and W->W
W->MausB
W->MausC
Warten 10ms
PORTB->W
3 and W->W
W->MausA
W xor MausC->MausC
_Z=1 ? J > return
N
V
MausB->MausB
.--------------------------< J _Z=1 ?
| N
| V
| MausB->W
| 1-W->W
| .----< J _Z=1 ?
| | N
| | V
| | MausB->W
| | 2-W->W
| | _Z=1 ? J >---------------------------.
| | N |
| | V |
| | MausB->W |
| | 3-W->W |
| | _Z=1 ? J >-----. |
| | N | |
| | V | |
| | return | |
| | | |
| | | |
Mouse0 V Mouse1 V Mouse3 V Mouse2 V
MausA->W MausA->MausA MausA->W MausA->MausA
1-W->W V 1-W->W V
_Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--.
J | J | J | J |
V | V | V | V |
setze _Fdec | setze _Finc | setze _Finc | setze _Fdec |
V<-----´ V<-----´ V<-----´ V<-----´
MausA->W MausA->W MausA->W MausA->W
2-W->W 3-W->W 2-W->W 3-W->W
_Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--.
J | J | J | J |
V | V | V | V |
setze _Finc | setze _Fdec | setze _Fdec | setze _Finc |
V<-----´ V<-----´ V<-----´ V<-----´
return return return return

und Quellcode:

Mouse movf PORTB,0
andlw 3
movwf MausB
movwf MausC
call Delay ; ca. 10 ms
movf PORTB,0
andlw 3
movwf MausA
xorwf MausC,1
btfsc _Z
return
movf MausB,1
btfsc _Z
goto Mouse0
movf MausB,0
sublw 1
btfsc _Z
goto Mouse1
movf MausB,0
sublw 2
btfsc _Z
goto Mouse2
movf MausB,0
sublw 3
btfsc _Z
goto Mouse3
return
Mouse0 movf MausA,0
sublw 1
btfsc _Z
bsf _Fdec
movf MausA,0
sublw 2
btfsc _Z
bsf _Finc
return
Mouse1 movf MausA,1
btfsc _Z
bsf _Finc
movf MausA,0
sublw 3
btfsc _Z
bsf _Fdec
return
Mouse2 movf MausA,1
btfsc _Z
bsf _Fdec
movf MausA,0
sublw 3
btfsc _Z
bsf _Finc
return
Mouse3 movf MausA,1
sublw 1
btfsc _Z
bsf _Finc
movf MausA,0
sublw 2
btfsc _Z
bsf _Fdec
return

=== Handy Display ===

Als Beispiel die Hardware und Testprogram für Nokia 3310/3330 Display: [[http://www.roboternetz.de/phpBB2/viewtopic.php?p=124669#124669]]

= Hilfsmittel =

Hier werden einige Programme presentiert, die das ASM Programmieren erleichtern.
Damit sie möglichst wenig Data- und Programmspeicher benötigen, sind alle Zahlen auf dem Display in der hex Darstellung.
Für alle, die es in Dezimalsystem haben wollen, ist ein Taschenrechner mit hex<->dec Wandlung nötig.

== PIC Miniterminal ==

Das ist eine Schnittstelle, die nur 2 Leitungen zum Anschluss an PIC braucht. Sie ermöglicht Steuern von diversen LCD Displays mit üblichem Anschluss ("RS", "Enable" und 8 Databits) und Abfragen von 3 Tasten.

Sie wird mit einem 2x16 Zeichen Matrixdisplay und 3 Tasten für weiter beschriebene Hilfsprogramme verwendet.

Hardware und Testprogramm: [[http://www.roboternetz.de/phpBB2/viewtopic.php?t=13685]]

[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Category:PIC]]

PIC Assembler

2007-05-05T06:24:23Z

Andy: /* Bit, Byte, Nibble, Bin und Hex */

= Einladung zur Diskussion... =

Es wird hier versucht die ASM Programmierung von PIC Mikrocontrollern möglichst kurz zu beschreiben.

Damit der enstehende Artikel wirklich nützlich wird, ist Ihre Mitwirkung nötig. Bitte schreiben Sie uns Ihre Meinung, was eventuell noch geändert (z.B. ergänzt) werden soll in diesem Thread:

http://www.roboternetz.de/phpBB2/viewtopic.php?p=271211#271211

Die Autoren bedanken sich im voraus für jeden Beitrag mit Vorschlägen !

= Einführung =

== Bit, Byte, Nibble, Bin und Hex ==

Ein Mikrocontroller (kurz: µC) kann eigentlich nur durch ein Portpin eine Spannung einlesen bzw. ausgeben. Er kann aber nur erkennen, ob eine Spannung vorhanden ist oder nicht. Wenn fast keine Spannung vorhanden ist erkennt er das als 0 und wenn eine Spannung fast so gross, wie seine Versorgungsspannung anliegt, als 1.

Genauso bei der Ausgabe, wenn er 0 ausgibt ist auf dem Portpin fast keine Spannung, wenn 1, eine Spannung fast gleich gross seiner Versorgungsspannung. Und das ist ein Bit, die kleinste Menge einer Information. Das Bit ist binär, d.h. es kann nur zwei unterschiedliche Werte haben: 0 oder 1.

Wenn wir gleichzeitig (parallel) 8 Bits haben, dann ist es ein Byte, das 256 Bitkombinationen von 00000000b bis 11111111b enhält, weil ein Bit (X) auf jeder Stelle 0 bzw. 1 sein kann.

<table border=0 cellpadding=3 cellspacing=2>

<tr>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
</tr>

<tr>
<td colspan=4 align=middle bgcolor=#007fff>High Nibble </td>
<td colspan=4 align=middle bgcolor=#ff8305>Low Nibble </td>
</tr>
<tr>
<td colspan=8 align=middle bgcolor=#810f40> Byte </td>
</tr>
</table>

Das "b" bedeutet, dass es sich um binäre (kurz: bin) Darstellung (auch Zahl genannt) handelt. Binäre Zahlen sind aber lang, weil jeder Bit eine Stelle benötigt.

Um die Schreibweise zu verkürzen, wurden hexadezimale (kurz: hex) Zahlen eingeführt. Zuerst wurde ein Byte auf zwei 4-Bit Halbbytes (Nibbles) verteilt und danach ein Nibble als Ziffer genommen. Weil 4 Bits 16 Kombinationen ergeben, haben die Ziffer 0 bis 9 aus dem Dezimalsystem (d) nicht ausgereicht und wurden um Buchstaben A bis F erweitert. Die hexadezimalen Zahlen haben ein "h" Zeichen am Ende. Für die Zahlen 0 bis 9 sind die (h) und
(d) Zeichen nicht nötig, da sie beide gleich den entsprechenden bin Zahlen sind.

Die Umwandlung zwischen bin, hex und dec Zahlen für ein Nibble zeigt folgende Tabelle:

0b = 0h = 0d 100b = 4h = 4d 1000b = 8h = 8d 1100b = Ch = 12d
1b = 1h = 1d 101b = 5h = 5d 1001b = 9h = 9d 1101b = Dh = 13d
10b = 2h = 2d 110b = 6h = 6d 1010b = Ah = 10d 1110b = Eh = 14d
11b = 3h = 3d 111b = 7h = 7d 1011b = Bh = 11d 1111b = Fh = 15d

Damit kann ein Byte mit zwei hex Ziffern definiert werden z.B. 1100 0011b = C3h. Für zwei Bytes braucht man 4 hex Ziffern z.B.

101 0111 1010 1001b = 57A9h, u.s.w. Für MPASM wird sehr oft die Schreibweise für hex Zahlen 0x57A9 oder 0xC3 benutzt.

So wie im Dezimalsystem werden führende Nullen nicht geschrieben. Bei einer Wandlung bin->hex fängt man immer von der rechten Seite der bin Zahl an, da die Anzahl führender Nullen unbekannt ist.

== Speicher und Register ==

Als Speicher bezeichnet man das Teil der Hardware, in das eine Information geschrieben, gespeichert und von dort wieder ausgelesen werden kann.

Es gibt eigentlich nur zwei Arten von elektronischen Speichern: flüchtige und nichtflüchtige. Die Information die sich im flüchtigen Speicher befindet, geht verloren, wenn die Versorgungsspannung des Speichers unterbrochen oder abgeschaltet wird. Bei PICs ist es Datenspeicher (RAM).

Wenn die Versorgungsspannung vom nichtflüchtigen Speicher abgeschaltet wird, ist die gespeicherte Information zwar momentan nicht lesbar, bleibt aber erhalten und sobald der Speicher wieder mit Spannung versorgt wird, kann sie ausgelesen werden. Ein PIC hat zwei solche Speicher: Programmspeicher (Flash) und EEPROM.

Der wichtigste Unterschied zwischen den Speicherarten ist, dass die flüchtigen direkt (sehr schnell) beschreibbar sind, dagegen das Beschreiben des nichtflüchtigen Speichers spezielle Algorithmen benötigt, die im Vergleich zu direkten Zugriffen langsamer sind. Beim Auslesen gibt es praktisch keinen Unterschied.

Speicher besitzen eine bestimmte Menge von s.g. Speicherstellen. Jede Speicherstelle hat eine individuelle Adresse und kann eine binäre Information mit bestimmter Anzahl von Bits abspeichern.

PIC Prozessoren haben drei Arten von Speicher, wegen verschiedener Anwendung, auch unterschiedliche Struktur. Die beiden Speicher für Daten (RAM und EEPROM) haben jeweils 8 Bit Breite und Programmspeicher (Flasch) bei Mid-Range hat 14-bitige Speicherstellen. Die Anzahl den Speicherstellen im bestimmten Speicher ist vom PIC-Typ abhängig.

Eine 8-bitige Speicherstelle im RAM wird bei PICs Register genannt und kann so skizziert werden:

<table border=0 cellpadding=3 cellspacing=2>

<tr>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
</tr>

<tr>
<td> MSB </td>
<td colspan=6></td>
<td> LSB </td>
</tr>

<tr>
<td bgcolor="#007fff">bit 7</td>
<td bgcolor="#007fff">bit 6</td>
<td bgcolor="#007fff">bit 5</td>
<td bgcolor="#007fff">bit 4</td>
<td bgcolor="#007fff">bit 3</td>
<td bgcolor="#007fff">bit 2</td>
<td bgcolor="#007fff">bit 1</td>
<td bgcolor="#007fff">bit 0</td>
</tr>

<tr>
<td colspan=4 align=middle bgcolor=#ff8305>High Nibble </td>
<td colspan=4 align=middle bgcolor=#ff8305>Low Nibble </td>
</tr>
<tr>
<td colspan=8 align=middle bgcolor=#810f40> Byte </td>
</tr>
</table>

Bit 7 wird als hochwertigstes (MSB = Most Significant Bit) und bit 0 als niederwertigstes (LSB = Least Significant Bit) bezeichnet. Jeder Bit im Register (X) kann gleich 0 bzw. 1 sein. In einem Register existieren immer 8 Bits also auch führende Nullen. Zum Beispiel die hex Zahl 3 sieht im PIC Register so aus: 00000011.

Um ein Databyte in ein Register zu schreiben oder aus einem Register zu lesen, muss zuerst das Register durch seine Adresse gewählt werden. Dafür gibt es beim PIC folgende Möglichkeiten:

Direkte Adressierung per absolute Adresse: movwf 0x20

Direkte Adressierung per vorher definierten Namen des Registers (z.B. Temp equ 0x20): movwf Temp

Indirekte Adressierung durch "FSR" Register, in das die absolute Adresse des Registers "Temp" eingeschrieben wird und der Wert aus "Temp" sich im "INDF" Register befindet. Wie vorher wurde "Temp equ 0x20" definiert und weiter:

movlw Temp ;ins W-Register wird die absolute Adresse des Registers "Temp" geladen
movwf FSR ;diese Adresse wird ins "FSR" Register kopiert
movf INDF,0 ;der Wert aus dem indirekt adressierten Register "Temp", der sich jetzt
;im "INDF" befindet, wird ins W-Register geladen.

Weil in jedem 14-bittigen Befehl, der mit Datenspeicher verbunden ist, für die Adresse des ansprechenden Registers nur 7 Bits existieren, die bis zur Adresse 7Fh (128d) Register direkt ansprechen können, ist bei PICs der Datenspeicher (RAM) in s.g. Bänke verteilt.

Für Auswahl einer Bank sind zwei Bits "RP0" und "RP1" im "STATUS" Register zuständig. Die Anzahl der Bänke und ihre Verwendung ist von der gesamten Größe des RAMs abhängig und kann dem Datenblatt des PICs entnommen werden. Siehe: [[#Speicherbankorganisation|Speicherbankorganisation]]

== Prozessor ==

Der Prozessor von Mid-Range PICs gehört zu den RISC (Reduced Instruction Set Computer) Prozessoren und man hat nur 35 Befehle zu erlernen, was seine Programmierung im Vergleich zu anderen µCs deutlich vereinfacht. Jeder Befehl benötigt im Programmspeicher nur eine Speicherstelle und im Quellcode nur eine Zeile. Die Ausführung des Befehls dauert, abhängig vom Befehl, 1 bis 2 Prozessortakte.

Die Prozessoren der Mid-Range Serie von Microchip sind alle in der "Harvard"-Architektur gefertigt. Das bedeutet, dass Datenspeicher und Programmspeicher einen eigenen Bus zur CPU (Central Processing Unit) besitzen. Der Vorteil zur "von Neumann"-Architektur ist, dass sich die Busgrößen damit unterscheiden können. Das ermöglicht eine größere Bandbreite.

Der Befehl (beim PIC 14 bit) kann in nur einem Takt verarbeitet werden. Daher kommt auch das Aufteilen der Ausführung des Befehls in 4 verschiedene Vorgänge. Wärend der neue Befehl eingelesen ("fetch") wird, wird der vorige gerade gelesen ("read") und der vorvorige verarbeitet ("execute") und der vorvorvorige schreibt gerade in den Datenspeicher ("write"). Das heißt, 4 Befehle werden jeweils um einen Oszillatortaktzyklus verschoben gleichzeitig verarbeitet.

Das geschieht in vier Perioden des Oszillators. Deswegen entspricht die Taktfrequenz der CPU der durch 4 geteilten Frequenz des Oszillators.

CPU Vorgang Richtung Speicher
------------------------------------------------- -
1.Befehl lesen (fatch) <------- Flash |
2.Daten lesen (read) <------- RAM | 1 Prozessortakt =
3.Daten verarbeiten (execute) | 4 Oszillatortakte
4.Daten schreiben (write) -------> RAM |
-

Nur o.g. CPU Vorgänge sind direkt möglich. Es können deswegen keine Befehle aus dem RAM oder EEPROM ausgeführt werden. Um ein Databyte aus einem RAM Register in ein anderes zu kopieren, muss er zuerst aus dem ersten RAM Register in das W-Register (eigenen s.g. Arbeitsregister des CPU) und erst davon in das zweite RAM Register kopiert werden.

Der Prozessor hat kleinen eigenen Speicher, der weder zum Programmspeicher noch zum Datenspeicher gehört. Er besteht aus dem Programmzähler PC (programm counter) und dem Stapel (stack).

In dem PC befindet sich die 13-Bittige Adresse des momentan ausfürbaren Befehls. Nach der Ausführung jedes Befehls wird der PC um 1 erhöht und "zeigt" somit auf den nächsten Befehl im Programmspeicher, der zum Ausführen wäre. Wenn der nächste Befehl aber ein Sprung ("call") ist, wird die Adresse aus dem Befehl genommen. Nach dem Sprung wird das Programm bis zum Befehl "return" ausgeführt und danach muss der Prozessor zurückspringen, und zwar, genau zur nächsten Adresse im Programmspeicher nach dem "call" Befehl. Damit es möglich wäre, wird vor dem Sprung die Adresse aus dem PC "auf dem Stapel gelegt" (gespeichert). Für den Rücksprung wird die abgelegte Adresse "aus dem Stapel genommen" (vom Stapel in den PC geladen).

Der Stapel kann aber nur 8 Adressen speichern, deswegen dürfen nur 8 nacheinander folgende "call" Befehle benutzt werden. Sonst findet der Prozessor nicht mehr zurück und in die "Nirvana" springt, was einen Absturz des Programms bedeutet.

Das Lesen/Schreiben aus/in den EEPROM Speicher ist mit Hilfe speziellen Register und Unterprogrammen bei allen Mid-Range PICs möglich. Der Lese und Schreibzugriff auf den Programmspeicher ist aber nur bei wenigen PIC-Typen (z.B. PIC16F87X) möglich. Dies ermöglicht ein "sich selbst Programmieren", was bei Bootloadern genutzt wird.

== Assembler ==

Die Maschinensprache, auch Assembler oder kurz ASM genannt, ist eine Sprache die nur eine bestimmte CPU versteht. Für einen Menschen ist sie unverständlich, da sie nur aus 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 einen CPU hat somit ein "Namen", der aus der englischen Sprache stammt. Siehe: [[#Kurzübersicht Assembler Befehle|Kurzübersicht Assembler Befehle]]

Obwohl sie 200 bis 1000 mal schneller als die meisten Hochsprachen ist, wird sie, wegen des grossen Aufwands bei der Erstellung von umfangreichen Programmen, selten benutzt. Man findet sie aber oft in fast allen Hochsprachen, in eigebundenen Funktionen, überall dort wo die Hochsprachen zu langsam sind oder die nötigen Aufgaben nicht unterstützen (z.B. Maus in Q-Basic).

ASM eignet sich sehr gut für kleine Anwendungen (meistens Steuerungen) mit µC, weil nur bei dieser Programmiersprache ein direkter Zusammenhang zwischen einem Bit im Programm und einer Spannung am I/O Pin besteht.

Dank der integrierten oder an Portpins angeschlosenen Hardware und dem entsprechenden Program kann ein µC umfangreiche Aufgaben realisieren, die fast unbegrenzt und schwer vorstellbar sind.

Die Aufgabe eines ASM-Programmierers ist, ein Programm zu schreiben, das das Assemblerprogramm (z.B. MPASM) fehlerfrei in die Machinensprache assembliert ("übersetzt"), die dann eine bestimmte CPU "versteht". Sie endet eigentlich erst dann, wenn das geschriebene Programm so wie geplant funktioniert.

Die beste Methode um ASM Programmierung zu lernen ist einfach mit den Befehlen, wie mit "LEGO" Bausteinen, zu spielen. Der PIC kann durch ein Programmfehler nicht kaputtgehen. Vorsicht ist nur bei der angeschlossener Hardware nötig, da ein Fehler den PIC oder die Hardware sogar "töten" kann.

Weil ASM Programme nicht besonders durchschaubar sind, wurde als Hilfsmittel ein Programmablaufdiagramm (kurz: PAD) erfunden. Bei der 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 [http://gputils.sourceforge.net/ GPASM]) von dem für Menschen noch verständlichen Code in die Maschinensprache assembliert 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 Homepage des Herstellers von PICs [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en019469&part=SW007002] runtergeladen werden. Es muss zuerst vom Downloads die "MPLAB IDE v7.50 Full Zipped Installation" runtergeladen und erst danach können gewählte Programme (z.B. nur MPASM) intalliert werden. Für MPASM benutzer werden auch folgende ".pdf" Dateien empfohlen:

MPASM/MPLINK User's Guide (2628 KB) [Benutzerhandbuch]

MPASM™/MPLINK™ PICmicro® Quick Chart (81 KB) [Kurzübersicht]

Nach dem Eischalten der Betriebsspannung des µC, fängt der CPU an, sich im Programmspeicher befindliches Programm mit dem Befehl, der an der Adresse 0 steht, auszuführen.

Aber wann das Programm endet? Natürlich wenn die Versorgungsspannung abgeschaltet wird. Nein! Das ist die einfachste Lösung um ein laufendes Programm an zufälliger Stelle zu unterbrechen,
aber keine, um es an einer definierten Stelle zu beenden.

Wenn an den µC angeschlossene externe Hardware (z.B. Grafikdisplay), eine bestimmte Befehlsfolge vor dem Abschalten benötigt oder wichtige Daten (in EEPROM oder Flash) abgespeichert werden sollen, darf die Spannung erst dann abgeschaltet werden, wenn die CPU eine Meldung ausgibt, dass sie sich schon auf der "STOP" Stelle des Programms befindet. Es muss auch
definiert werden (z.B. durch eine Tastenkombination), wann die CPU zum letzten Fragment des ASM Programms vor dem "STOP" gehen soll.

== Grundbeschaltung ==

Der Prozessor von einem PIC kann sofort nach dem Einschalten der Versorgungsspannung (z.B. + 5V DC) arbeiten. Allerdings nur, wenn er den Takt, in dem er die Befehle ausführen soll, vorgegeben hat. Manche PICs besitzen einen internen RC-Oszillator, (z.B. PIC12F629, PIC16F630, PIC16F628, u.s.w.). Bei diesen reicht es bereits Spannung anzulegen und sie laufen bereits.
Die meisten haben ihn aber nicht (z.B. PIC16F84, PIC16F870, u.s.w.) und brauchen fürs Funktionieren zusätzliche Bauteile. Grundsätzlich gibt es mehrere Möglichkeiten:

* Quarz oder Keramik-Resonator + 2 Kondensatoren (LP,HS oder XT)
* Keramik-Resonator mit integrierten Kondensatoren (HS oder XT)
* Quarzoszillator (EC); genau und stabil
* Widerstand + Kondensator (RC); keine hohe Frequenzstabilität

Die entsprechenden Bauteile werden an die Pins OSC1/OSC2 angeschlossen, um den notwendigen Prozessortakt zu erzeugen. Im Konfiguration-Word "__config" muss noch angegeben werden, welcher Oszillator verwendet wird.

Desweiteren existiert ein MCLR-Pin, der beim PIC einen Neustart (=Reset) auslösen kann (Low-Pegel). Diesen Pin sollte man, wenn er in "__config" aktiviert ist, über einen Widerstand (pull-up) an Versorgungsspannung legen, damit der PIC anfängt, sein Programm abzuarbeiten. Der Anschluss wird auch für die Programmierung benötigt. Beim sog. High-Voltage-Programming wird MCLR auf ca. 12-14 Volt gelegt, um den PIC in den Programmiermodus zu schalten. Bei manchen PICs kann dieser Anschluss auch als normalen I/O Pin eingestellt werden. In dem Fall, bei ICSP Benutzung, soll noch eine Diode zwischen den pull-up und Versorgungsspannung angeschlossen werden, um die an MCLR Pin angeschlossene Hardware während der Programmierung zu schützen.

Bei externen Oszillatoren bleibt der Pin OSC2 nicht angeschlossen und kann als I/O benutzt werden. Falls ein interner Oszillator benutzt wird, können beide OSC Pins als I/O dienen.

Damit ein Programm zuverlässig ausgeführt werden kann, muss die Versorgungspannung störungsfrei sein. Dafür wird ein Keramik-Vielschicht-Kondensator 100 nF möglichts am kürzesten direkt zwischen VDD und VSS Pins geschaltet.

Folgende Skizzen zeigen die Grundbeschaltung eines PICs:

{|
|-
|
[[Bild:Pic-entstoer.png|thumb|160px|Entstörkondensator beim PIC]]
|
[[Bild:Qz-os.png|thumb|160px|Quarz ]]
|
[[Bild:Qos-os.png|thumb|160px|externer Quarzoszillator]]
|
[[Bild:Rc-os.png|thumb|160px|externer RC-Oszillator]]
|}

== Konfiguration ==

Die Konfiguration eines PICs wird beim "brennen" fest programmiert. Sie ist eigentlich für fast jeden PIC-Typ anders. Um Probleme zu vermeinden, muss sie für bestimmten PIC aus einer im MPASM Verzeichnis enthaltenen Datei "PXXFXX.INC" entnommen werden. Die Erklärung der Optionen befindet sich im entsprechenden Datenblatt unter "Special Features of the CPU"

Als Beispiel für PIC16F84 haben wir in der Datei "P16F84.INC":

;==========================================================================
;
; Configuration Bits
;
;==========================================================================

_CP_ON EQU H'000F'
_CP_OFF EQU H'3FFF'
_PWRTE_ON EQU H'3FF7'
_PWRTE_OFF EQU H'3FFF'
_WDT_ON EQU H'3FFF'
_WDT_OFF EQU H'3FFB'
_LP_OSC EQU H'3FFC'
_XT_OSC EQU H'3FFD'
_HS_OSC EQU H'3FFE'
_RC_OSC EQU H'3FFF'

Wobei:

_CP_ON - Programmspeicher ist vorm Auslesen geschützt
_CP_OFF - Programmspeicher kann ausgelesen werden (ist nicht geschützt)
_PWRTE_ON - Das Programm wird mit Verzögerung von ca. 72 ms nach dem Einschalten gestartet
_PWRTE_OFF - Das Program wird sofort nach dem Einschalten gestartet
_WDT_ON - Watchdog Timer ist aktiv
_WDT_OFF - Watchdog Timer ist unaktiv

Die alle folgende Optionen beziehen sich an den Oszillatortyp:

_LP_OSC - Oszillator bis ca. 200 kHz (z.B. Uhrenquarz 32768 Hz)
_XT_OSC - Oszillator bis ca. 3,5 MHz
_HS_OSC - Oszillator über 3,5 MHz (z.B. 4 MHz)
_RC_OSC - Externer RC Oszillator

Die Konfiguration wird im Quellcode (*.asm Datei) mit Direktive "__config" definiert, z.B. so:

__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _XT_OSC

Alle Optionen müssen groß geschrieben sein, genauso wie in der "*.inc" Datei.

== Wahl des PICs ==

Es gibt PIC µC die in der Typenbezeichnung den Buchstaben "C" oder "F" haben.

Die älteren mit "C" haben EPROM Programmspeicher und die gibt es in zwei Versionen: ohne und mit Fenster (aus Quarz-Glass) fürs Löschen des EPROMs mit UV Strahlung. Bei denen ohne Fenster kann der Programmspeicher nur einmal beschrieben und nicht mehr gelöscht werden.

Die neuen mit "F" besitzen einen Flash-Programmspeicher, der bis zu 100 000 mal mit angelegter Spannung gelöscht und danach neu beschrieben werden kann.

Für die Wahl eines PICs für bestimmte Anwendung wichtig sind:

- Max. Taktfrequenz des Prozessors.

- Grösse des Datenspeichers (für Variablen).

- Grösse des Programmspeichers (für Programm).

- Integrierte Hardware (Komparatoren, A/D Wandler, Timer, USART, I²C, SPI, PWM, u.s.w.).

- Freie I/O Pins für externe Hardware (Display, Tasten, u.s.w.).

- Vorhandene Betriebspannung (Netzteil, Akku, Batterie).

In der Praxis wird meistens für die Programmerstellung ein grösserer PIC genommen (wenn möglich pinkompatibler z.B. PIC16F628 für PIC16F84 oder PIC16F630 für PIC12F629) und erst nach der Optimierung des lauffägiges Programms, der tatsächlich nötige, da seine Parameter am Anfang nur geschätzt werden können. Wenn man viele Programme für verschiedene PICs entwickelt, wäre der größte PIC16F877 mit 20 MHz max. Taktfrequenz optimal.

Diese Lösung hat auch den Vorteil, dass während der Programmerstellung kurze Hilfsprogramme (z.B. PIC Trainer) in den Programmspeicher kopiert und benutzt werden können, da sie sowohl ein bischen Programmspeicher und RAM als auch 2 freie I/O Pins fürs PIC Miniterminal brauchen.

= Programm =

== Allgemeines ==

Jedes Program kann man in kleinere Fragmente unterteilen, die auf bestimmte Weise miteinander verknüpft sind und gemeinsam die Aufgabe des Programms erfüllen. Das wichtigste Teil eines Programms ist das s.g. Hautprogram (kurz:HP), das eine führende Rolle spielt. Dem HP sind fast 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 komplizierter, da ein UP auch ein oder mehrere UPs nacheinander aufrufen kann. Ganz unten sind die UP1s, die ganz einfache Sachen erledigen. Höher ist 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 ohne Tricks maximal bis zu 8 Ebenen benutzt werden, da auf dem Stapel (stack) nur max. 8 Rücksprungadressen abgespeichert werden können. Siehe hierzu: [[#Prozessor|Prozessor]] und [[#Programmspeicher|Programmspeicher]]

<center>
[[Bild:HP-UP.png|Hauptprogramm - Unterprogramm]]
</center>

Jedes UP kann jederzeit aufgerufen werden, je nach dem was gerade eledigt werden muss. Weil das nicht egal ist, welches UP aufgerufen wird, da jedes nur eine bestimmte Funktion im Programm hat, muss der Programmierer dafür sorgen, dass alles richtig nach Programablaufdiagramm, und nicht chaotisch, abläuft.

Die Programmierung in ASM ist ähnlich 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 Programm kopieren oder einbinden und ein geeignetes HP, das sie aufruft, schreiben.

Ein ASM Programm (Quellcode) muss in einer Texdatei mit der Endung ".asm" in der vom Assemblerprogramm erwarteten Form verfasst werden, um die fehlerfreie Konvertierung in die Maschinensprache (Assemblierung) zu gewährleisten. Dieser Prozess verläuft in der Form eines Dialoges.

Der Programmierer schreibt und gibt es dem Assemblerprogramm zum Übersetzen. Alles was der Assembler nicht versteht oder nicht richtig ist, erscheint als Fehlermeldungen, die der Programmierer kennen muss, um die Fehler korrigieren zu können. Eine ".hex" Datei wird erst dannn erstellt, wenn das Assemblerprogramm keine Fehler mehr im Quellcode findet. Deswegen ist es sehr wichtig, sich mit dem Assemblerprogramm vertraut zu machen, um die Dialogzeit zu minimieren.

== Programmdurchlaufdiagramm ==

Der Programdurchlaufdiagram (kurz: PAD) ist eine vorläufige und laufend änderbare Stufe zwischen einer Idee und ihrer Verwirklichung. Die Kreativität des Programmierers ist nur für die Erstellung des PADs nötig. Jedes sein Symbol (ausser "Start/Stop") muss als Befehlsreihenfolge für einen bestimmten Prozessor in den Quellcode übertragen werden. Das ist aber nur reine "Übersetzung". Der Quellcode ist nur eine andere Form des PADs und hoffentlich wird es zukünftig Komputerprogramme geben, die ein PAD direkt in eine "*.hex" Datei für bestimmten Prozessor wandeln werden. Zur Zeit muss die "Übersetzung" leider vom Programmierer gemacht werden. Der PAD wird erst dann fertig, wenn nach ihm erstelltes ASM Program auf einem µC so wie gewünscht funktioniert.

Die Anschriften "Ein" und "Aus" gehören nicht zu Symbolen des PADs und wurden nur zur Erklärung benutzt.

[[Bild:PAD_beispiel.png|thumb|80px|Beispiel für ein PAD]]

Der PAD ist sehr eifach zu erstellen, weil dafür nur drei Symbole benötigt sind:
<center>
[[Bild:PAD_kurz.png|Symbole des PAD]]
</center>
Das "Start/Stopp" Symbol bedeutet, dass das gesamte Programm sich im stabilen Zustand befindet und nicht "läuft". Anstatt "Stopp" kann auch "Schlaf" (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 eines Programms, endweder in der "ja" (J) oder "nein" (N) Richtung.

Als allgemeinnutziges Standard für µCs kann man folgender PAD bezeichnen:

PAD _____
/ \
Spannung ein (Ein) ----->( Start )
\_____/
| -
V |
.---------------. |
|Initialisierung| |
'---------------' |
| |
.--------->V |
| .---------------. |
| | Hauptprogramm | |
| '---------------' |
| | |
| V |
| A |
| / \ > Gesamtes Programm
| / \ |
| /Ende \____ |
| \ ? / J | |
| \ / | |
| \ / | |
| V | |
| N| | |
`----------´ | |
V |
.---------------. |
| Beenden | |
'---------------' |
| |
V -
_____
/ \
Spannung aus (Aus) <-------------( Stopp )
\_____/

Das Hauptprogram wird in einer endlosen Schleife ausgeführt, die durch die Prüfung "Ende?" unterbrochen werden kann. In dem Fall wird vor dem Beenden des gesammten Programms noch ein UP "Beenden" ausgeführt, das z.B. Daten im EEPROM speichert.

Es ist nicht nötig, immer die Symbole zu zeichnen, man kann sie sich vorstellen und nur den Text schreiben. Die Prüfungen werden mit "?" gekenzeichnet und die Zeichen "V", "A", "<" und ">" zeigen die Richtung des weiteren Verlaufs. Dann sieht der PAD so aus:

Ein > Start
V -
Initialisierung |
.------->V |
| Hauptprogramm > Gesamtes Programm
| V |
| Ende? J > Beenden |
| N V -
| V Stopp > Aus
`--------´

Man kann auch die unbedeutenden Richtungspfeilen weg lassen:

PAD1 Ein > Start _
Initialisierung |
.------->V | Gesamtes
| Hauptprogramm | Programm
| Ende? J > Beenden _|
| N Stopp
| V V
`--------´ Aus

In der Praxis werden aus Platzgründen meistens die vereinfachten PADs benutzt. Als "movxx" wird oft ein Zeichen "->" benutzt. Zum Beispiel "A->W" bedeutet, dass der Inhalt des A Registers ins W-Register geladen (kopiert) wird. Ausserdem werden Zeichen ("+", "-", "*", "/", "^", u.s.w.) für arithmetische und ("&", "or", "xor", u.s.w.) für logische Operationen angewendet. In den Quellcode werden für diese Zeichen entsprechende Befehle geschrieben. Beispiel:

V
10h->W
W+B->B
V

wird im Quelcode so aussehen:

...........
movlw 10h
addwf B,1
...........

Siehe auch: [[#Das erste...|Das erste...]] und [[#Mausrad|Mausrad]]

Der PAD1 kann aber für Hauptprogramme, die in beliebigem Moment unterbrochen werden dürfen, deutlich vereinfacht werden, da die Prüfung "Ende?" ob das Hauptprogram beendet werden soll, und das UP "Beenden", entfallen.

Die meisten ASM Programme für µC sind deswegen nach solchem PAD erstellt:

PAD2 Ein > Start _
Initialisierung |
.------->V |
| Hauptprogramm > Gesamtes Programm
| V |
`--------´ _|

Für Testprogramme wird meistens fogender PAD angewendet, weil es ziemlich einfach festzustellen
ist (z.B. durch Stromverbrauchmessung des µCs), wann sich die CPU schon im Schlaf befindet. Erst dann, darf die Betriebspannung des µCs ausgeschaltet werden.

PAD3 Ein > Start _
Initialisierung | Gesamtes
Hauptprogramm _| Programm
Schlaf > Aus

Und eine batteriebetriebene Uhr wird überwiegend so gestaltet:

PAD4 Ein > Start _
Interrupt Initialisierung |
Timer------------------------->V > Gesamtes Programm
Hauptprogramm _|
Schlaf

In dem Fall reicht es aus, wenn der CPU jede Minute vom Timer aufgeweckt wird, um die Zeit zu aktualisieren. Eine Uhr ist immer (ausser Batteriewechsel) ununterbrochen mit Spannung versorgt.

Für komplizierte Programme ist es praktisch unmöglich ein PAD zu erstellen, in dem jeder CPU Befehl sein eigenes Symbol hat. Man beschränkt sich nur auf alle Prüfungen, die über den Lauf des Programms entscheiden, und ganze UPs (z.B. "Initialisierung") nur als ein Symbol verwendet. Für jedes UP wird dann ein eigener PAD erstellt.

Das Erstellen von PAD bei ASM Programmen ist sehr wichtig und darf nicht unterschätzt werden. Je stärker ein Programmierer glaubt, dass er das ohne PAD schafft, um so mehr Zeit wird er danach bei Fehlersuche oder Änderungen im ASM Programm verlieren.

Beispiel aus dem Alltag:

"Das programm hat anfangs auf Anhieb funktioniert. Doch leider habe ich dann was geändert was ich nicht mehr weiß. Das Programm macht nun komische Sachen...... Ich kann mir nicht erklären warum, kann mir jemand helfen???"

Für einfache ASM Programme, die gut kommentiert sind, reicht es meistens aus, ein PAD nur "im Kopf" zu erstellen, aber ganz ohne PAD geht es sicher nicht.

Der PAD kann auch benutzt werden, um einen "fremden" Code verständlich zu machen. In dem Fall werden alle Befehle (Zeilen) aus der Quellcode nacheinander in PAD Symbole umgewandelt und daraus ein PAD erstellt.

== Hauptprogramm ==

Wie sein Namen schon vermuten lässt, ist das Hauptprogram das wichtigste Teil des gesamten Programms. Meistens ist es auch das kleinste Teil, vor allem, wenn die UPs sehr komplex sind. Seine Aufgabe ist die benötigte UPs in bestimmter Reihenfolge nacheinander aufzurufen, um die alle Funktionen des gesamten Programms zu realisieren.

Das HP ist meistens als endlose Schleife, wie im PAD2, aufgebaut. Weil die endlose Schleife sehr schnell läuft, werden alle durch die UPS realisierten Aufgaben quasi gleichzeitig ausgeführt. Wenn es unerwünscht ist, müssen einige UPs als Verzögerungen realisiert werden.

Typischer PAD für ein HP sieht so aus:

Haupt .--->V
| UP1
| UP2
| ...
| UPn
| V
`----´

In den Quellcode wird es so eigeschrieben:

Haupt call UP1
call UP2
...........
call UPn
goto Haupt

In der Praxis wird das HP schrittweise erstellt. Am Anfang wird sich nur ein Aufruf vom UP im HP befinden und die folgenden kommen nach Erstellung und Prüfen weiteren UPs dazu, bis das HP fertig wird.

== Unterprogramm ==

Unterprogramm wird durch übergeordnetes Programmteil (Aufrufer) aufgerufen und nach seinem Ausführen, wird zurück zum Aufrufer gesprungen. Der Rückkehr zum Aufrufer wird durch "return" Befehl, der sich am Ende jedes UPs befinden muss, erreicht. Und das ist der einzige Unterschied zwischen einem HP und einem UP.

Jedes UP hat folgender PAD:

vom Aufrufer ------------>V
Tun
V
zurück zum Aufrufer <----------return

Ein HP von einem ASM Programm kann in anderem, mehr umfangreichem ASM Program als UP benutzt werden, wenn der sich am Ende des HPs befindlicher Befehl "goto" durch "return" ersetzt wird. Ein Beispiel dazu:

Haupt1 call UP11 Haupt1 call UP11
call UP21 call UP21
........... -------> ...........
call UPn1 call UPn1
goto Haupt1 return

Jetzt können wir im mehr komplexen HP (Haupt) das Haupt1 als Unterprogramm aufrufen:

Haupt call UP1
call Haupt1
...........
call UPn
goto Haupt

Jedes UP kann auch von einem anderen übergeordneten UP aufgerufen werden, wenn das was es realisiert, benötigt wird.

In der Praxis wird oft ein UP von mehreren anderen UPs benutzt. Zum Beispiel um LCD Display zu steuern, brauchen wir entweder ein Befehl (Cmd) oder ein Zeichen (Data) an Display zu schicken. In beiden Fällen wird ein Byte geschickt, einmal mit RS=0 (Befehl) und einmal mit RS=1 (Zeichen) laut folgendem PAD:

"Cmd" "Data"
RS=0 RS=1
V V
`-->V<--´
"Send" Byte schicken
V
return

Das wird in den Quellcode z.B. so eingeschrieben:

Cmd bcf RS
goto Send
Data bsf RS
Send ............
return

Das UP "Send" ist den UPs "Cmd" und "Data" untergeordnet, da es von beiden benutzt wird, kann aber weder "Cmd" noch "Data" benutzen.

=== Initialisierung ===

Damit der PIC ein Programm asführen kann, muss er vollständig und richtig initialisiert werden. Deswegen als erstes UP, das von dem gesamten Programm noch vor dem HP aufgerufen wird , ist "Initialisierung" (kurz: Init)

==== Variablen ====

Weil sich nach dem Einschalten der Spannung im RAM zufällige Werte befinden, wird meistens als erstes der benutzte Bereich des RAMs (z.B. 20h bis 7Fh) gelöscht. Es wird einfach und sparsam mit einer Schleife erledigt, die indirekte Adressierung verwendet:

V
Adresse des ersten Registers in FSR laden (20h)
.-------------------->V
RAMClr |Indirekt adressierter Register löschen (INDF)
| Adresse erhöhen
| Letzte Adresse + 1 (80h) J > Return
| N
| V
`---------------------´

Es wird wie folgt in Quellcode eingeschrieben:

movlw 0x20
movwf FSR
RAMClr ,->clrf INDF
| incf FSR,1
| btfss FSR,7
`-<goto RAMClr
return

Um Anzahl den Marken (label) zu verringern, wird oft ein Symbol "$" benutzt. Es bedeutet die Adresse der aktuellen Befehlszeile. Es kann also auch so eingeschrieben werden:

movlw 0x20
movwf FSR
,->clrf INDF
| incf FSR,1
| btfss FSR,7
`-<goto $-3 ; springe zu aktueller Adresse -3
return

Danach können den benötigtenen Variablen die gewünschte Werte zugewiesen werden:

movlw 0x3C
movwf LimH
movlw 0x5A
movwf LimL
u.s.w.

Somit sind die Variablen initialisiert.

==== I/O Ports ====

Nach dem Einschalten der Spannung sind die für Komparatoren oder A/D Wandler benutzte Pins als analoge Eingänge initialisiert. Wenn sie alle als digitale I/Os verwendet werden sollen, müssen sie als solche definiert werden. Das geschieht durch Schreiben des Wertes 7 in das entsprechende Register (CMCON bzw. ADCON1):

movlw 7 b.z.w. movlw 7
movwf CMCON movwf ADCON1

Wenn einige als analoge Eingänge benutzt werden sollen, müssen die entsprechende Werte dem Datenblatt des jeweiligen PICs entnommen werden.

Danach werden alle Ports nacheinander gelöscht und die gewünschte Werte die an den Pins vor dem Start des Hauptprogramms ausgegeben werden sollen, geschrieben:

clrf PORTA
movlw 0x37
movwf PORTA
usw.

Anchliessend werden für jeden Port die Werte in TRIS Register eingeschrieben, wobei ein Bit einem Pin entspricht. Ein Pin wird in TRIS Register durch 1 als Eingang und durch 0 als Ausgang definiert. Beispielweise beim PORTB sollen B7,B5 und B3 als Eingänge und restliche Pins als Ausgänge definiert werden. Das ergibt den Wert 10101000b = A8h, der in den TRISB Register geschrieben werden muss. Weil die alle TRIS Register sich in der höheren Bank befinden, muss im STATUS-Register auf entsprechende Bank und danach zurück auf Bank 0 umgeschaltet werden. Zum Beispiel für die TRASB in der Bank1:

bsf STATUS,RP0
movlw 0xA8
movwf TRISB
bcf STATUS,RP0

Bei einem Umschalten der Bank können selbstverständlich alle TRIS Register, die in der gleichen Bank liegen, nacheinander beschrieben werden. Siehe : [[#PORTx|PORTx]] und [[#TRISx|TRISx]]

Bei dem PORTA gibt es Pins, die nur "open drain" Ausgang haben (können nur auf GND schalten) b.z.w. nur als Eingang benutzt werden können. Bei Plannung der Verwendung von PORTA muss immer im Datenblatt geprüft werden, ob sich ein bestimmter Pin für die geplannte Anwendung eignet.

==== Hardware ====

Die für ASM Programm benutzte Hardware kann auf integrierte und externe geteilt werden. Für eine Initialisierung der integrierten Hardware (Komparatoren, A/D Wandler, Timer, USART, I²C, SPI, PWM, u.s.w.), müssen entsprechende SFRs (Spezial Function Registers) laut Datenblatt des PICs definiert werden.

Die externe Hardware muss nach Datenblättern der Herstellern initialisiert werden.

=== Einlesen ===

Um ein Bit von einem Portpin einzulesen und in ein bestimmtes Register zu Kopieren wird folgender PAD benutzt, weil ein PIC kein Befehl dafür hat:

V
Bit im Zielregister löschen
Quellbit = 0 ? J >------.
N |
V |
Bit im Zielregister setzen |
V<-------------´

Wenn wir z.B. ein bit3 von PortA als bit1 in den Register Tasten kopieren wollen, dann wird es in Quellcode so geschrieben:

bcf Tasten,1
btfsc PORTA,3
bsf Tasten,1

Wenn ein ganzes Byte vom Port in das W-Register eingelesen wird, kann man den Wert gleich komplett in das Zielregister schreiben:

movf PORTA,0
movwf Tasten

=== Ausgeben ===

Um ein Bit an einem Portpin auszugeben wird ein bestimmtes Bit mit "bcf" gelöscht oder mit "bsf" gesetzt. Zum Beispiel bit4 im PORTA:

bcf PORTA,4.

Um ein Byte auszugeben wird es zuerst in das W-Register geladen und danach an den Port übergeben, z.B.:

movlw 0x12
movwf PORTA

=== Schleifen ===

Ein in ASM Programmen meist verbreitetes Codefragment ist eine Schleife.

Es kann eine endlose Schleife, die durch Prüfung einer bestimmten Bedingung (z.B. Taste) unterbrochen wird, sein:

V<-----.
Tun |
? N >--´
J
V
weiter

Es kann eine Schleife mit Schleifenzähler (z.B. Temp), die bestimmte Anzahl Durchläufe hat, sein:

V
Anzahl ins Temp laden
V<---------.
Tun |
Temp decrementieren |
Temp = 0 ? N >--´
J
V
weiter

Solche Schleifen können als UPs verwendet werden, wenn "weiter" mit "return" ersetzt wird.

Das waren Beispiele für Schleifen, die bewusst programmiert sind. Es gibt leider auch endlose Schleifen, die durch einen Fehler im Programm enstanden sind und zum "hängen" des Programms führen. Solche Schleifen sind im Programm nicht einfach zu finden, da ihre Parameter unbekannt sind.

=== Pause ===

Um eine Pause (Warten, Verzögerung) im Programm anzulegen wird der "nop" Befehl benutzt, während dessen Ausführung der CPU nichts macht. Mit einem "nop" kann eine Zeit gleich 4 Takten (Perioden) des Oszillators realisiert werden.

Für sehr kurze Wartezeiten benutzt man eine Reihe von nachfolgenden "nop"s. Beim einem Oszillator 4 MHz, die Ausführungszeit des Prozessors beträgt 1 µs pro "nop". Wenn z.B. 4 µs benötigt werden, werden dafür 4 "nop"s gebraucht:

...
nop
nop
nop
nop
...

Das gleiche bewirken 2 "goto"s, brauchen aber im Vergleich zu "nop"s nur die Hälfte der Bytes im Programmspeicher:

...
goto $+1
goto $+1
...

Der Befehl goto $+1 bedeutet "springe zur aktuellen Adresse + 1" (also nächster Adresse) und seine Ausführungszeit ist gleich 2 Prozessortakten.

Für kurze Zeiten werden s.g. Warteschleifen, wie im folgendem PAD benutzt:

V
n * nop
P0 laden
V<---------.
P0 decrementieren |
P0 = 0 ? N >--´
J
V

In Quellcode wird es als UP so eigeschrieben:

Warte nop Warte nop
... ...
nop nop
movlw 0xXX movlw 0xXX
movwf P0 movwf P0
Warte0 decfsz P0,1 decfsz P0,1
goto Warte0 goto $-1
return return

Der Sprung zur Marke "Warte0" ("goto Warte0") wurde in rechtem Beispiel durch "goto $-1" ersetzt.

Die gesammte Anzahl den CPU Takten (N) lässt sich aus folgender Formel berechnen:

N = 3 * P0 + 6 + n

und die Wartezeit (T) in Sekunden:

T = N * ( 4 / Fosc ), für Schätzungen T ~ 3 * P0 * ( 4 / Fosc )

Wobei:

P0 = Zahl im Register P0, 6 = Ausführungszeit von "call" (2) + "movlw" (1) + "movwf" (1) + "return" (2), n = Anzahl "nop"s, Fosc = Frequenz des Oszillators (z.B. Quartz)

Wenn in ein Register PX eine 0 eingeschrieben wird, bedeutet es, dass die decrementierung des Registers 100h = 256d Takten dauern wird, da dekrementierte 0 eine FFh = 255d ergibt. Deshalb in Warteschleifen ist die Zahl 0 die grösste (256 Dürchläufe) und 1 die kleinste. Für solche einfache Schleifen (als UP) die Wartezeit beträgt min. 9 und max. ca. 800 Prozessortakten (ohne "nop"s).

Für mittlere Wartezeiten z.B. 0,1 Sekunde werden doppelte Warteschleifen verwendet:

Warte V
n * nop
P1 laden
Warte1 V<-------------.
P0 laden |
Warte0 V<---------. |
P0 decrementieren | |
P0 = 0 ? N >--´ |
J |
V |
P1 dekrementieren |
P1 = 0 ? N >------´
J
V

Das wird in Quellcode als UP so aussehen:

Warte nop Warte nop
... ...
nop nop
movlw 0xXX movlw 0xXX
movwf P1 movwf P1
Warte1 movlw 0xXX movlw 0xXX
movwf P0 movwf P0
Warte0 decfsz P0,1 decfsz P0,1
goto Warte0 goto $-1
decfsz P1,1 decfsz P1,1
goto Warte1 goto $-5
return return

Wie vorher wurden rechts die Marken durch "$-n" ersetzt.

Die gesammte Anzahl den CPU Takten (N) lässt sich aus folgender Formel berechnen:

N = P1 * (3 * P0 + 5) + 8 + n

und die Wartezeit (T) in Sekunden:

T = N * ( 4 / Fosc ), für Schätzungen T ~ 3 * P1 * P0 * ( 4 / Fosc )

Wobei:

P0 = Zahl im Register P0, P1 = Zahl im Register P1, 8 = Ausführungszeit von "call" + "return" + 2 * ("movlw" + "movwf"), n = Anzahl "nop"s, Fosc = Frequenz des Oszillators (z.B. Quartz)

Für solche doppelte Schleifen (als UP) die Wartezeit beträgt min. 16 und max. ca. 200 000 Prozessortakten (ohne "nop"s).

Für lange Wartezeiten z.B. 1 Sekunde werden 3-fache Warteschleifen angewendet.

Solche Warteschleife ist im folgenden PAD abgebildet:

Warte V
n * nop
P2 laden
Warte2 V<-----------------.
P1 laden |
Warte1 V<-------------. |
P0 laden | |
Warte0 V<---------. | |
P0 decrementieren | | |
P0 = 0 ? N >--´ | |
J | |
V | |
P1 decrementieren | |
P1 = 0 ? N >------´ |
J |
V |
P2 dekrementieren |
P2 = 0 ? N >----------´
J
V

Das wird in Quellcode als UP so aussehen:

Warte nop Warte nop
... ...
nop nop
movlw 0xXX movlw 0xXX
movwf P2 movwf P2
Warte2 movlw 0xXX movlw 0xXX
movwf P1 movwf P1
Warte1 movlw 0xXX movlw 0xXX
movwf P0 movwf P0
Warte0 decfsz P0,1 decfsz P0,1
goto Warte0 goto $-1
decfsz P1,1 decfsz P1,1
goto Warte1 goto $-5
decfsz P2,1 decfsz P2,1
goto Warte2 goto $-9
return return

Auch hier wurden rechts die Marken durch "$-n" ersetzt.

Die gesammte Anzahl den CPU Takten (N) lässt sich aus folgender Formel berechnen:

N = P2 * [ P1 * (3 * P0 + 5) + 9 ] + 10 + n

und die Wartezeit (T) in Sekunden:

T = N * ( 4 / Fosc ), für Schätzungen T ~ 3 * P2 * P1 * P0 * ( 4 / Fosc )

Wobei:

P0 = Zahl im Register P0, P1 = Zahl im Register P1, P2 = Zahl im Register P2, 10 = Ausführungszeit von "call" + "return" + 3 * ("movlw" + "movwf"), n = Anzahl "nop"s, Fosc = Frequenz des Oszillators (z.B. Quartz)

Für solche 3-fache Schleifen (als UP) die Wartezeit beträgt min. 27 und max. ca. 50 000 000 Prozessortakten (ohne "nop"s).

Die "nop"s vor allen Warteschleifen sind nur notwendig um genaue Wartezeit einzustellen zu können. Sie können auch mit "goto $+1"s ersetzt, oder weg gelassen werden. Sie können auch innerhalb jeder Schleife eingesetzt werden, um sie deutlich zu verlängern.

Ein Beispiel:

V
n * nop
P0 laden
V<---------.
n0 * nop
P0 decrementieren |
P0 = 0 ? N >--´
J
V

Bei nur einem "nop" (n0=1) ist die max. Wartezeit ca. T ~ 4 * P0 * ( 4 / Fosc ), bei zwei (n0=2) ca. T ~ 5 * P0 * ( 4 / Fosc ) u.s.w.

Anstatt "movlw 0xXX" kann auch "movf PauseX,0" angewendet werden, wenn die Schleife mehrmals mit verschiedenen Werten P0, P1 und P2 aus den Register Pause0, Pause1 und Pause2 benutzt wird.

Für sehr lange Wartezeiten können, nach gleichem Prinzip, Warteschleifen erstellt werden, die mehr als 3 Schleifen enthalten.

=== Tabellen ===

Es gibt zwei Arten von Tabellen: Sprungtabellen (computed goto) die "goto" Befehle enthalten und Wertetabellen (lookup table) in denen feste Werte in "retlw" gespeichert sind. Der wichtigste Unterschied zwischen dennen ist, dass die Sprungtabellen steuern den Programlauf abhängig vom Inhalt des W-Registers und die Wertetabellen liefern abhängig von Inhalt des W-Registers ein Wert an den Aufrufer zurück.

Beide werden in Programmspeicher erstellt. Sie können nur bis zu 256 Speicherstellen belegen, da in den W-Register auch nur so viel veschiedenen Zahlen "passen". Sie Fangen also (fast) immer bei einer Adresse XX00h an und enden bei XXFFh. Der Hochwertige Byte "XX" der Adresse an der sich der Anfang einer Tabelle befindet, muss vor dem Einsprung in die Tabelle ins PCLATH Register eingeschrieben werden, wenn die Tabelle weit vom Aufrufer liegt. In der Praxis werden solche Tabellen am oberen Ende des Programmspeichers angelegt, damit sie den ASM Code nicht unterbrechen.

Eine Sprungtabelle wird so aufgebaut:

org (XX-1)FF <--- eine Direktive für Assemblerprogramm, wo es
die Tabelle im Programmspeicher plazieren soll
Adresse Inhalt
-------------------------
Tab1 (XX-1)FF addwf PCL,1
XX00 goto Marke0
XX01 goto Marke1
.......................
XXFE goto Marke254
XXFF goto Marke255

Und so aufgerufen:

movlw 0xXX
movwf PCLATH
movf TWert,0
call Tab1

Wobei:

0xXX = Hochwertiger Byte der Adresse von Tab1, TWert = ein Wert, der die Wahl wohin gesprungen wird bestimmt.

Nach ausführen der obiger Befehlsfolge, wird das ASM Programm z.B. für Twert=0x01 weiter ab Marke1 "laufen" bis es an "return" kommt. Dann springt es zurüch zum Aufrufer der Tabelle.

Eine Wertetabelle wird so aufgebaut:

org (XX-1)FF <--- eine Direktive für Assemblerprogramm, wo es
die Tabelle im Programmspeicher plazieren soll
Adresse Inhalt
-------------------------
Tab1 (XX-1)FF addwf PCL,1
XX00 retlw Wert0
XX01 retlw Wert1
.......................
XXFE retlw Wert254
XXFF retlw Wert255

Und so aufgerufen:

movlw 0xXX
movwf PCLATH
movf TWert,0
call Tab1

wobei:

0xXX = Hochwertiger Byte der Adresse von Tab1, TWert = ein Wert, für welchen, an den Aufrufer bestimmter Wert aus der Tabelle im W-Register zurückgeliefert wird

Wertetabelle kann auch mit Hilfe der MPASM Direktive "dt" erstellt werden. So kann man sich mehrfaches Schreiben von "retlw" Befehlen ersparen:

org 0x(XX-1)FF
Tabelle addwf PCL,1
; nachfolgend der benötigte Wert im W- Register
; vor dem Aufruf der Tabelle
dt 0x03, 0xE8 ; 0x00
dt 0x03, 0xE8 ; 0x02
dt 'M','H','z',0x00 ; 0x04
dt ' ',' ','W','A','I','T',0x00 ; 0x08
dt 'C','o','n','s','t',' ','X',0x00 ; 0x0F
dt 'C','=',0x00 ; 0x17
dt 'L','=',0x00 ; 0x1A
dt 'F','=',0x00 ; 0x1D
dt 'O','K',0x00 ; 0x20
u.s.w.

Das Lesen eines Strings muss ab entsprechendem Wert im W-Register (z.B. für "MHz" -> 0x04) anfangen und auf dem Wert 0x00 enden, der hier als Stringende dient. Einfacher ist, wenn alle Strings gleich lang sind (wie z.B. in einem Zeichengenerator fur Grafikdisplay).

=== Interrupt ===

==== Prinzip ====

Ein Interrupt (Unterbrechung) unterbricht ein laufendes Programms, wenn ein bestimmtes Ereigniss, auf das reagiert werden soll, statt gefunden hat. Die Reaktion wird in s.g. Interrupt Service Routine (kurz: ISR) definiert.

Einfach gesagt, ein Interrupt stoppt ein laufendes Programm, ruft die ISR auf und nach deren Ausführung startet das Programm wieder, ab der Zeile, vor der es durch Interrupt angehalten wurde.

.--->V
| Tun
| V
Interrupt ------>Tun-------->V
| V ISR
| Tun<--------´
| V
| Tun
| V
`----´

Damit das unterbrochene Programm nach dem Rückkehr aus der ISR weiter fehlerfrei ausgeführt werden kann, darf die ISR keine Änderungen im Programm verursachen.

Um ein Interrupt auslösen zu können, muss er in UP "Init", durch beschreiben nötigen Register (INTCON, PIR, u.s.w.) vorbereitet werden. Siehe hierzu: [[#INTCON|INTCON]] und [[#Interrupts|Interrupts]]

==== Quellen ====

Es gibt folgende Interrupt-Quellen:

- interne Hardware (z.B. ein Timer)

- externe Hardware (z.B. eine Taste)

Die alle PICs der Mid-Range Familie haben im Programmspeicher nur eine Adresse (s.g. Interrupt Vektor 0x0004), wohin im Falle eines Interrupts, gesprungen wird. Um ermöglichen den Verursacher des Interrupts zu finden, hat jede Quelle ein eigenes Interrupt Flag (IF), das gesetzt wird, wenn das Interrupt ausgelöst wird. Somit kann in der ISR nach der Prüfung der IFs auf jeden Interrupt gezielt reagiert werden.

==== Interrupt Service Routine ====

Die Interrupt Service Routine ist ein besonderes UP das immer an der Adresse 0x0004 beginnt und immer mit dem Befehl "retfie" endet. Ihr Umfang ist von der Menge der Quellen und der Reaktionen auf ihre Interrupts abhängig. Folgender PAD zeigt ein allgemeiner Aufbau der ISR:

Adresse 0x0004 Interrupts sperren ; bcf INTCON,GIE
Beeinflüsste Register sichern
Interrupt-Quelle ermitteln
Interrupt-Flag löschen
und entsprechend reagieren
Beeinflüsste Register restaurieren
zurück ins Programm springen ; retfie

Je nach Bedürfnissen, wird eine ISR nur nötige Elemente davon enthalten. Um auf alle Interrupts reagieren zu können muss die ISR vor dem nächsten Interrupt beendet werden. Da das Programm nur in den Pausen zwischen Ausführungen der ISR laufen kann, sollte die Ausführungszeit der ISR möglichst kurz sein.

Die einfachste ISR setzt nur ein Flag ("_Fint"), das dem Programm zeigt, dass ein Interrupt statt gefunden hat. Sie eignet sich für den Fall, wenn nur eine Interrupt-Quelle erlaubt ist.

0x0004 bcf INTCON,GIE ; Interrupts sperren
bsf IF ; Interrupt Flag löschen
bsf _Fint ; Flag setzen
retfie ; zurück ins Programm

Das Programm prüft das Flag "_Fint", löscht es und reagiert entsprechend.

Die ISR kann aber auch ein HP darstellen. Siehe hierzu: [[#Interrupts|Interrupts]]

=== Schnittstellen und Treiber ===

Als Schnittstelle wird externe Hadware, die zum Steuern eines an sie angeschlossenes "Gerätes" dient, genannt. Das ASM Programm, das die Steuerung ermöglicht ist ein Treiber. Als Beispiele siehe: [[http://www.roboternetz.de/phpBB2/viewtopic.php?t=13685]] und [http://www.roboternetz.de/phpBB2/viewtopic.php?t=22749]

== Vorlage für MPASM ==

Diese Vorlage ist nur für ASM Programme ohne Interrupts geeignet:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration
#define _DTT1 GPIO,0 ; Portpins benennen
#define _CKT2 GPIO,1
#define _T3 GPIO,2
#define _RNG GPIO,3
#define _INT GPIO,4
#define _RL GPIO,5
u.s.w.
SecondL equ 0x20 ; Variablen definieren (Register benennen)
SecondH equ 0x21
MinuteL equ 0x22
MinuteH equ 0x23
StundeL equ 0x24
StundeH equ 0x25
u.s.w
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
Haupt ............ ; hier fängt das Hauptprogramm als endlose Schleife an
Eigener Code
............
goto Haupt ; hier endet das HP, gehe zum Anfang des HPs (zurück)
UP1 ............ ; Unterprogramme
Eigener Code
............
return
############
UPn ............
Eigener Code
............
return
Init clrf GPIO ; lösche Port
bsf STATUS,RP0 ; auf Bank1 umschalten
call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; kalibriere internen RC oscillator
bcf OPTION_REG,7 ; aktiviere pull-ups
movlw 0x38 ; definiere Portpins GPIO, (z.B. 0-2 Aus- und 3-5 Eingänge)
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
movlw 7 ; schalte Komparator aus
movwf CMCON ; und definiere GPIO 0-2 als digitale I/Os
............
eigener Code
............
return ; springe zurück (zum Haupt)
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

Die Variablen können auch kürzer mit s.g. cblock definiert werden:

cblock 0x20
SecondL
SecondH
MinuteL
MinuteH
StundeL
StundeH
endc

Bei sehr vielen Variablen sind aber die Registeradressen nicht so übersichtlich.

Für Programme mit Interrupts ist diese Vorlage geeignet:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration
#define _DTT1 GPIO,0 ; Portpins benennen
#define _CKT2 GPIO,1
#define _T3 GPIO,2
#define _RNG GPIO,3
#define _INT GPIO,4
#define _RL GPIO,5
u.s.w.
SecondL equ 0x20 ; Variablen definieren (Register benennen)
SecondH equ 0x21
MinuteL equ 0x22
MinuteH equ 0x23
StundeL equ 0x24
StundeH equ 0x25
u.s.w
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
goto Haupt ; gehe zum Hauptprogramm "Haupt"
org 0x004 ; hier fängt die ISR (interrupt service routine) an
bcf INTCON,GIE ; interrupts sperren
.............
Eigener Code
.............
retfie ; hier endet die ISR, interrupts wieder erlauben
Haupt ............ ; hier fängt das Hauptprogramm als endlose Schleife an
Eigener Code
............
goto Haupt ; hier endet das HP, gehe zum Anfang des HPs (zurück)
UP1 ............ ; Unterprogramme
Eigener Code
............
return
############
UPn ............
Eigener Code
............
return
Init clrf GPIO ; lösche Port
bsf STATUS,RP0 ; auf Bank1 umschalten
call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; kalibriere internen RC oscillator
bcf OPTION_REG,7 ; aktiviere pull-ups
movlw 0x38 ; definiere Portpins GPIO, (z.B. 0-2 Aus- und 3-5 Eingänge)
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
movlw 7 ; schalte Komparator aus
movwf CMCON ; und definiere GPIO 0-2 als digitale I/Os
............
eigener Code
............
return ; springe zurück (zum Haupt)
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

== Das erste... ==

Hier wird detailiert das ganze Prozess der Erstellung eines ASM Programms beschrieben. Die Idee:

Es gibt 4 LEDs (_L1, _L2, _L3 und _L4), die mit 2 Tastern gesteuert werden sollen. Nach dem Einschalten soll keine LED leuchten. Solange der linke Taster (_T1) gedrückt ist, sollte eine leuchtende LED von links nach rechts "wandern" und von der letzten rechten Position wieder nach ganz linke "springen". Solange der rechte Taster (_T2) gedrückt ist, sollte eine leuchtende LED von rechts nach links "wandern" und von der letzten linken Position wieder nach ganz rechte "springen". Solange beide Taster gedrückt sind soll die leuchtende LED von links nach rechts und zurück "wandern".

Dafür nötige Hardware zeigt folgende Skizze:

.-----------------------------------------------.
| |
| PIC12F629 |
| |
| GPIO,3 GPIO,4 GPIO,5 GPIO,2 GPIO,1 GPIO,0|
'-----------------------------------------------'
4| 3| 2| 5| 6| 7|
| | .-. .-. .-. .-.
| | R | | R | | R | | R | |
| | 470| | 470| | 470| | 470| |
| | '-' '-' '-' '-'
\ o \ o | | | |
\ \ V -> V -> V -> V ->
\. \. - - - -
_T1 o _T2 o _L1 | _L2 | _L3 | _L4 |
| | | | | |
+-------+-------+---+---+-------+-------+
|
===
GND

Weil der Pin 4 (GPIO,3) nur einen "open drain" Ausgang hat (kann nur an GND schalten), wird er hier als Eingang benutzt.

Jetzt muss die Idee vom Programmierer in ein PAD verfasst werden, z.B. solcher:

Start
Initialisierung
.-------------->V
| _T1=0 gedrückt ? N >----.
| J |
| V |
| links->rechts "wandern" |
| V<------------´
| _T2=0 gedrückt ? N >----.
| J |
| V |
| rechts->links "wandern" |
| V<------------´
`---------------´

danach detailierter:

Start
Initialisierung
V<-------------------------------------------.
_T1=0 gedrückt ? N >---+--->_T2=0 gedrückt ? N >---+---´
J A J A
V | V |
_L1 an | _L4 an |
Warten | Warten |
_L1 aus | _L4 aus |
_L2 an | _L3 an |
Warten | Warten |
_L2 aus | _L3 aus |
_L3 an | _L2 an |
Warten | Warten |
_L3 aus | _L2 aus |
_L4 an | _L1 an |
Warten | Warten |
_L4 aus | _L1 aus |
V | V |
`------------´ `------------´

Weil der Prozessor die Befehle nacheinander liest, ist jeder Quelcode einspaltig. Um sich die "Übersetzung" des PADs in den Quelcode zu erleichtern wird er noch z.B. so umgestaltet:

Start
Initialisierung
V<-----------------+<----.
Haupt _T1=0 gedrückt ? N >---. A |
J | | |
V | | |
_L1 an | | |
Warten | | |
_L1 aus | | |
_L2 an | | |
Warten | | |
_L2 aus | | |
_L3 an | | |
Warten | | |
_L3 aus | | |
_L4 an | | |
Warten | | |
_L4 aus | | |
V<-----------´ | |
T2Test _T2=0 gedrückt ? N >---------´ |
J |
V |
_L4 an |
Warten |
_L4 aus |
_L3 an |
Warten |
_L3 aus |
_L2 an |
Warten |
_L2 aus |
_L1 an |
Warten |
_L1 aus |
V |
`------------------------´

Alle Pfeilen aus diesem PAD werden als "goto" in den Quelcode eingetragen.

Zuerst wird im MPASM Verzeichnis ein neuer Verzeichniss (z,B. "PIC Programme") angelegt und in dem Verzeichniss neue Textdatei (z.B. "Erstes.txt") erstellt. Als nächstes wird die "Vorlage für MPASM" dorthin kopiert.

Danach müssen, die im Programm benutzte Portpins und Register mit "#define" und "equ" definiert werden.

Als Initialisierung wird das UP "Init" aus der Vorlage für MPASM mit geändertem "TRISIO" Wert (0x18) übernommen. Siehe: [[#Vorlage für MPASM|Vorlage für MPASM]]

Fürs "Warten" wird eine dreifache Warteschleife verwendet. Siehe: [[#Pause|Pause]]

Die Taster werden mit "btfsc" Befehl geprüft und zum LEDs An- und Ausschalten werden Befehle "bsf" und "bcf" für ensprechenden Portpin von GPIO angewendet. Siehe: [[#Ausgeben|Ausgeben]]

Anschlessend wird alles laut PAD in die Vorlage für MPASM eingeschrieben und der Quellcode ist fertig:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration
#define _T1 GPIO,3 ; Portpins benennen
#define _T2 GPIO,4
#define _L1 GPIO,5
#define _L2 GPIO,2
#define _L3 GPIO,1
#define _L4 GPIO,0
P0 equ 0x20 ; Variablen definieren (Register benennen)
P1 equ 0x21
P2 equ 0x22
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
Haupt btfsc _T1 ; Taster _T1=0 gedrückt ?, wenn ja, überspringe "goto T2Test"
goto T2Test ; wenn nicht, springe zu "T2Test"
bsf _L1 ; schalte _L1 an (setze den Pin 2 auf "1")
call Warten ; warte ca. 0,4 s (ca. 400 000 Prozessortakten)
bcf _L1 ; schalte _L1 aus (setze den Pin 2 auf "0")
bsf _L2 ; schalte _L2 an (setze den Pin 5 auf "1")
call Warten ; warte
bcf _L2 ; schalte _L2 aus (setze den Pin 5 auf "0")
bsf _L3 ; schalte _L3 an (setze den Pin 6 auf "1")
call Warten ; warte
bcf _L3 ; schalte _L3 aus (setze den Pin 6 auf "0")
bsf _L4 ; schalte _L4 an (setze den Pin 7 auf "1")
call Warten ; warte
bcf _L4 ; schalte _L4 aus (setze den Pin 7 auf "0")
T2Test btfsc _T2 ; Taster _T2=0 gedrückt ?, wenn ja, überspringe "goto Haupt"
goto Haupt ; wenn nicht, springe zu "Haupt"
bsf _L4 ; schalte _L4 an (setze den Pin 7 auf "1")
call Warten ; warte
bcf _L4 ; schalte _L4 aus (setze den Pin 7 auf "0")
bsf _L3 ; schalte _L3 an (setze den Pin 6 auf "1")
call Warten ; warte
bcf _L3 ; schalte _L3 aus (setze den Pin 6 auf "0")
bsf _L2 ; schalte _L2 an (setze den Pin 5 auf "1")
call Warten ; warte
bcf _L2 ; schalte _L2 aus (setze den Pin 5 auf "0")
bsf _L1 ; schalte _L1 an (setze den Pin 2 auf "1")
call Warten ; warte
bcf _L1 ; schalte _L1 aus (setze den Pin 2 auf "0")
goto Haupt ; springe zu "Haupt"
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 ("Haupt"),
Init clrf GPIO ; lösche Port (setze alle werdende Ausgänge auf "0")
bsf STATUS,RP0 ; auf Bank1 umschalten
call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; und kalibriere internen RC oscillator (4 MHz)
bcf OPTION_ REG,7 ; aktiviere pull-ups für die Portpins
movlw 0x18 ; definiere Portpins GPIO,3 und 4 als Eingänge
; und restlichen als Ausgänge (00011000b)
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
movlw 7 ; schalte Komparator aus
movwf CMCON ; und definiere GPIO 0-2 als digitale I/Os
return ; springe zurück (zum Haupt)
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

Jetzt wird der Quellcode in "Erstes.asm" umbenannt. Diese "*.asm" Datei können wir dem MPASM zum "Übersetzten" geben. Nach der Assemblierung sehen wir 3 Meldungen (Messages) vom MPASM. Diese befinden sich in der vom MPASM erstellter Datei "Erstes.lst" und lauten:

Message[302]: Register in operand not in bank 0. Ensure that bank bits are correct.

Diese Meldung kann man übersetzen als:

Meldung[302]: Register im Befehl nicht in Bank 0. Vergewisse Dich, dass die Bank-Bits korrekt sind.

Wir sind sicher, dass die Register "OSCCAL", "OPTION_REG" und "TRISIO" in der Bank 1 sich befinden. Wenn man aber nicht sicher ist, soll man in Datenblatt nachschauen. Die Meldungen kommen immer für alle SFRs (Special Function Register) die sich nicht in der Bank 0 befinden und können ignoriert werden.

Am Ende der Datei "Erstes.lst" befinden sich noch einige Informationen über Programmspeicher:

Program Memory Words Used: 52 ; benutzte Speicherstellen
Program Memory Words Free: 972 ; freie Speicherstellen

und die Anzahl den eventuellen Fehlern (Errors), Warnungen (Warnings) und Meldungen (Messages):

Errors : 0
Warnings : 0 reported, 0 suppressed
Messages : 3 reported, 0 suppressed

Insgesamt werden durch MPASM 4 Dateien erstellt: "*.cod", "*.err", "*.hex" und "*.lst".

Wichtigste davon, falls wegen Fehler keine "*.hex" Datei erstellt wird, ist die "*.err" Datei, wo alles was dem MPASM nicht "passt" aufgelistet ist. In der "*.lst" Datei kann man sich ein Programm mit genauen Adressen für jeden Befehl anschauen.

Die während der Assemblierung vom MPASM generierte Datei "Erstes.hex" kann jetzt durch ein Brenner mit geeignetem Programm in den PIC Programmspeicher eingeschrieben werden.

== Für anderen PIC umschreiben ==

Die wichtigste Vorraussetzung ist, das der andere PIC2, auf dem das vorhandene ASM Programm für PIC1 laufen soll, zumindest für das ASM Programm nötige interne Hardware hat. Die Frequenz des Oszillators sollte gleich sein. Der Code benötigt ausser UP "Init" keine Änderungen.

Wenn der Port vom PIC2 anderen Namen hat, muss man das im Quellcode umdefinieren, z.B.:

#define PORTC PORTB
#define TRISC TRISB

Dann wird das Assemblerprogramm, wenn es PORTC findet, immer PORTB nehmen. Das gleiche Betrifft die "__config" Ausdrücke, die entsprechend der "*.ini" Datei für den PIC2, geändert werden müssen.

Das Assemblerprogramm findet sicher alles, was ihm nicht "passt" und bringt Fehlermeldungen, auf die man entsprechend reagieren muss.

Als Beispiel, schreiben wir "Erstes.asm" für den PIC16F84A um.

Zum Ändern sind die ersten 3 Zeilen:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration

Sie werden für den PIC16F84A so aussehen:

list P=16F84A ; Prozessor definieren
include "P16F84A.inc" ; 4.000 MHz
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _HS_OSC

Dazu muss noch "GPIO" Port umdefiniert werden, da der PIC16F84A solchen nicht hat, z.B wegen internen pull-ups auf "B":

#define GPIO PORTB
#define TRISIO TRISB

Die Hardware muss natürlich an entsprechende Pins angeschlossen werden:

_T1 auf 12 (B3), _T2 auf 13 (B4), _L1 auf 14 (B5), _L2 auf 11 (B2), _L3 auf 10 (B1) und _L4 auf 9 (B0)

Jetzt assemblieren wir die Qelldatei und der MPASM bringt in der Datei "Erstes.err" folgende Fehler:

Error[113] C:\MPASM\PICPROG\PIC16F84\ERSTES.ASM 61 : Symbol not previously defined (OSCCAL)
Error[113] C:\MPASM\PICPROG\PIC16F84\ERSTES.ASM 67 : Symbol not previously defined (CMCON)

In dem UP "Init" müssen also noch die Befehle mit "OSCCAL" und "CMCON" Register entfernt werden, da der PIC16F84A sie nicht hat:

call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; kalibriere internen RC oscillator (4 MHz)

und:

movlw 7 ; schalte Komparator aus
movwf CMCON ; und mache GPIO 0-2 als digital I/O

Weiter kann schon alles übernommen werden und die Datei "Erstes.asm" für den PIC16F84A ist fertig:

list P=16F84A ; Prozessor definieren
include "P16F84A.inc" ; 4.000 MHz
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _HS_OSC
#define GPIO PORTB ; Ports umbenennen
#define TRISIO TRISB
#define _T1 GPIO,3 ; Portpins benennen
#define _T2 GPIO,4
#define _L1 GPIO,5
#define _L2 GPIO,2
#define _L3 GPIO,1
#define _L4 GPIO,0
P0 equ 0x20 ; Variablen definieren (Register benennen)
P1 equ 0x21
P2 equ 0x22
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
Haupt btfsc _T1 ; Taster _T1=0 gedrückt ?, wenn ja, überspringe "goto T2Test"
goto T2Test ; wenn nicht, springe zu "T2Test"
bsf _L1 ; schalte _L1 an
call Warten ; warte ca. 0,4 s (ca. 400 000 Prozessortakten)
bcf _L1 ; schalte _L1 aus
bsf _L2 ; schalte _L2 an
call Warten ; warte
bcf _L2 ; schalte _L2 aus
bsf _L3 ; schalte _L3 an
call Warten ; warte
bcf _L3 ; schalte _L3 aus
bsf _L4 ; schalte _L4 an
call Warten ; warte
bcf _L4 ; schalte _L4 aus
T2Test btfsc _T2 ; Taster _T2=0 gedrückt ?, wenn ja, überspringe "goto Haupt"
goto Haupt ; wenn nicht, springe zu "Haupt"
bsf _L4 ; schalte _L4 an
call Warten ; warte
bcf _L4 ; schalte _L4 aus
bsf _L3 ; schalte _L3 an
call Warten ; warte
bcf _L3 ; schalte _L3 aus
bsf _L2 ; schalte _L2 an
call Warten ; warte
bcf _L2 ; schalte _L2 aus
bsf _L1 ; schalte _L1 an
call Warten ; warte
bcf _L1 ; schalte _L1 aus
goto Haupt ; springe zu "Haupt"
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 ("Haupt"),
Init clrf GPIO ; lösche Port (setze alle werdende Ausgänge auf "0")
bsf STATUS,RP0 ; auf Bank1 umschalten
bcf OPTION_REG,7 ; aktiviere pull-ups
movlw 0x18 ; definiere Portpins GPIO,3 und 4 als Eingänge
; und die restlichen als Ausgänge (00011000b)
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
return ; springe zurück (zum Haupt), nach der Zeile
; aus der du afgerufen wurdest
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

== Einbinden ==

Die einfachste Möglichkeit die gewünschte Programme in ein neues Programm einzubinden ist, die alle Programme in das neue Programm zu kopieren. Dafür müssen die ersten 3 Zeilen, die den Prozessor und die Konfiguration des PICs festlegen aus den eigebundenen Programmen entfernt werden. Danach müssen alle "#define", "equ" und "org" Direktiven, verglichen und wenn nötig geändert werden. Dabei hilft der MPASM mit seinen Fehlermeldungen in der Datei "*.err".

Die zweite Möglichkeit ist die gewünschte Programme als "*.asm" Dateien mit der Direktive "include *.asm" am Ende des neuen Programms vor der Direktive "end" einzubinden.

include "1.asm"
include "2.asm"
...............
include "n.asm"
end

In dem Fall gelten die gleichen o.g. Regeln wie beim direkten Kopieren. Wenn es in den eingebindenen Programmen keine "org" Direktiven gibt, dann werden die weitere Programme im Programmspeicher ab Ende des ersten Programms nacheinander plaziert.

== Fehlersuche ==

Als erstes wird an den PIC angeschlossene externe Hardware geprüft. Das sollte noch vor dem Einstecken oder Einlöten des PICs gemacht werden, da die gravierende Fehler (z.B. Kurzschlüsse, Umpolung von VCC und GND, u.s.w.) für den PIC schädlich werden können. Für einige Teile der Hardware kann entsprechende Spannung (VCC oder GND) an bestimmten Pin gelegt werden und die richtige Reaktion der Hardware optisch (z.B. für LEDs) oder akustisch (z.B. für Relais) festgestellt werden. Sonst müssen die elektrischen Verbindungen mit einem Messgerät überprüft werden.

Die Fehlersuche in der Software fängt mit der ersten und endet mit der letzten Zeile des ASM Programms. Sie läuft die ganze Zeit parallel zur Programmierung. Jedes UP soll vor dem Übertragen in den Quellcode geprüft und eventuelle Fehler beseitigt werden. Dazu arbeitet man gleichzeitig mit zwei "*.asm" Dateien, einer für die UPs und einer für das gesamte Programm. Es wird empfohlen, nach der "Initialisierung", als erstes UP, das für Ausgabegerät (z.B. Display) zu erstellen, um das funktionieren des Programms, vom Anfang an beobachten zu können.

Wenn aus geprüften UPs erstelltes Programm nicht richtig funktioniert, müsste ein Fehler im PAD sein.

== Optimierung ==
Work in Progress...
Wer sonst noch Beispiele hat, bitte hier vervollständigen...
BMS ...
=== Speicherbedarf ===
==== Programmspeicher ====
Die ersten Programme für den PIC sind natürlich einfach und kurz. Doch nach und nach werden die Codes länger und unübersichtlicher, das Brennen dauert auch umso länger. Das Programm ist zu umfangreich. Doch wo soll man etwas kürzen?

Es gibt unzählige Möglichkeiten - hier ein paar Beispiele:

===== Unterprogramme =====

Bestimmt wird man im Code immer die selben Abschnitte brauchen, zum Beispiel Warteschleifen oder ADC-Routinen, etc. Wieso sollte man diese also mehrfach (doppelt, dreifach, u.s.w.) schreiben?

Die Lösung: Der Programmteil wird als Unterprogramm benutzt. Man erstellt eine Sprungmarke (ab hier beginnt das Unterprogramm) und endet wieder mit einem "return"- oder "retlw"-Befehl.
Aufgerufen werden die Unterprogramme meistens mit dem "call"-Befehl. Es "lohnt sich" ein Codefragment als UP zu definieren erst wenn es min. 2 mal aufgerufen wird.

Ein "goto"-Befehl ist zu diesem Zweck geeignet nur, wenn der Prozessor zum letzten Aufrufer von "call" zurück springen soll, da die Rücksprungadresse vom letzten "call" auf dem Stapel (stack) abgelegt wurde. Somit kann man mehr als 8 Ebenen von UPs nutzen.

Den Unterprogrammen kann man natürlich auch Werte übergeben. Möchte man z.B. mehrere unterschiedliche Zeiten für Warteschleifen benutzen, so kann man die Parameter vor dem Aufruf des UPs in benötigte Anzahl von Register einschreben und dann das Unterprogramm mit "call" aufrufen. Das Unterprogramm verwendet dann die Zahlen von den Register. Siehe: [[#Pause|Pause]]

Um gleiche Vorgänge in mehreren Register durchzuführen (z.B. löschen) geeignet ist Anwendung von Schleifen mit bestimmter Anzahl der Abläufe und indirekter Adressierung. Siehe: [[#Variablen|Variablen]]

===== bsf und bcf =====

Bestimmt gibt es Situationen, in denen der PIC mehrere Bits an einem Port/Register setzen oder löschen muss. Z.B. wenn mehrere LEDs an einem Port ein- oder ausgeschaltet werden sollen.
Werden mehr als 2 Bits verändert, so kann man hier die "bsf"- und "bcf"-Befehle umgehen und einen kürzeren Code erstellen.

bsf PORTB,0 ;An PORTB sind 8 LEDs angeschlossen.
bsf PORTB,1 ;Es sollen die ersten 4 LEDs angeschaltet werden,
bsf PORTB,2 ;die anderen sollen ausgeschaltet werden.
bsf PORTB,3 ;links steht es mit bcf/bsf
bcf PORTB,4 ;ziemlich lang
bcf PORTB,5
bcf PORTB,6
bcf PORTB,7

movlw b'00001111' ;Das geht auch kürzer und übersichtlicher:
movwf PORTB

Man sieht - der Codeabschnitt umfasst nur noch 2 Zeilen anstatt 8. Somit braucht es weniger Speicher und wird von PIC schneller verarbeitet. Allerdings muss man aufpassen, da durch diese Routine der Inhalt des W-Registers und der Inhalt des gesamten Zielregisters verändert wird. Sollen die anderen Bits unangetastet bleiben, muss man es entweder bei den "bcf"/"bsf"-Befehlen belassen oder logische Funktionen (and bzw. or) durchführen.

===== Bit kopieren =====

;An den PIC ist ein Taster(RB0) und eine LED(RB1) angeschlossen.
;Taster: High=gedrückt Low=nicht gedrückt
;LED: High=Ein Low=Aus
;Wenn der Taster gedrückt ist, soll die LED leuchten
;wenn er nicht gedrückt ist, soll die LED nicht leuchten.
;1.Vorschlag:
btfss PORTB,0 ;ist der taster gedrückt?
goto no ;nein
bsf PORTB,1 ;ja - LED ein
goto endif ;fertig abgefragt - unten weitermachen...
no bcf PORTB,1 ;LED aus
endif

Der oben aufgeführte Code hat viele Nachteile: er ist relativ lang, braucht zwei Gotos und entspr. Sprungmarken. Ok, das ist vielleicht Erbsenzählerei, aber aus diesen 5 Zeilen kann man 3 machen.

bcf PORTB,1 ;Das Bit wird erst gelöscht
btfss PORTB,0 ;Taster gedrückt?
bsf PORTB,1 ;JA-LED an

Man geht davon aus, dass der Taster nicht gedrückt ist. Somit wird die LED erst einmal ausgeschaltet. Ist der Taster aber doch gedrückt, dann wird die LED angeschaltet.

Achtung möglicher Nebeneffekt: Wird dies in einer Schleife sehr schnell und oft ausgeführt, kann die LED flimmern oder nicht in ihrer vollen Helligkeit leuchten. Das passiert, weil ja angenommen wird, dass der Taster nicht gedrückt wird und die LED somit aus sein muss. Dann wird sie aber bei Tastendruck eingeschaltet. Somit entsteht ein schnelles ein-/ausschalten (PWM) und die LED leuchtet nicht mehr so hell.
Meist ist das aber nicht tragisch oder wird nicht unbedingt in einer Schleife sehr schnell abefragt. Siehe hierzu: [[#Einlesen|Einlesen]]

==== RAM ====

Um Anzahl benötigten Register zu sparen werden vorläufige Register (temporary) definiert, die von mehreren UPs benutzt werden. Als Beispiel, das Register "ATmp" in [[#Hex Dec Wandlung|Hex Dec Wandlung]]. Die Benutzung muss aber sehr genau nach PAD zugeteilt werden. Bei gleichzeitiger Benutzung des gleichen Registers durch mehrere UPS werden falsche Daten verarbeitet und im schlimmsten Fall können endlose Schleifen entstehen, die in Folge haben, dass das Programm nicht weiter ausgeführt wird ("hängt").

Viele im ASM Programm ungebrauchte SFRs können als "normale" Register (GPR) verwendet werden. Wenn zum Beispiel Timer1 nicht benutzt wird, können seine Register TMR1H und TMR1L für Speicherung von Daten benutzt werden. Es könnte aber gefährlich werden, wenn mehrere Programme gebindet sind. Deswegen muss es immer am Ende, beim volständigen Programm, geprüft werden, welche SFRs tatsächlich benutzt werden dürfen.

Für Konstanten (z.B. pi, ln2, Meldungen, u.s.w.), die sich im Laufe des Programms nicht ändern, kann EEPROM (mit MPASM Direktive "de") oder Programmspeicher (mit MPASM Direktive "dt") als Ablage benutzt werden. Siehe auch: [[#EEPROM|EEPROM]] und [[#Tabellen|Tabellen]]

=== Ausführungszeit ===

Alles was schnellmöglichst ablaufen soll, widersetzt sich der Optimierung des Programmspeichers.

Es können keine Schleifen und keine indirekte Adressierung benutzt werden, alles muss direkt programmiert werden.

Als Beispiel zur Verdeutlichung: Es sollen 16 Werte vom PORTA ins RAM ab Adresse 0x20 eingelesen werden.

Als Schleife mit indirekter Adressierung:

................
movlw 0x10 ;Anzahl Durchläufe
movwf Temp ;in den Schleifenzähler
movlw 0x20 ;erste Adresse
movwf FSR ;ins FSR Register
Einlesen movf PORTA,0 ;PortA ins W-Register
movwf INDF ;und ins aktuellen RAM Register
incf FSR,1 ;nächste Adresse
decfsz Temp,1 ;Temp = 0 ?
goto Einlesen ;nein, zum Einlesen
................ ;ja, weiter
Gesamtdauer: 100 Takten
Pause zwischen Einlesungen: 6 Takten
Programmspeicher Bedarf: 9 Speicherstellen
Direkt:

...............
movf PORTA,0
movwf 0x20
movf PORTA,0
movwf 0x21
movf PORTA,0
movwf 0x22
movf PORTA,0
movwf 0x23
movf PORTA,0
movwf 0x24
movf PORTA,0
movwf 0x25
movf PORTA,0
movwf 0x26
movf PORTA,0
movwf 0x27
movf PORTA,0
movwf 0x28
movf PORTA,0
movwf 0x29
movf PORTA,0
movwf 0x2A
movf PORTA,0
movwf 0x2B
movf PORTA,0
movwf 0x2C
movf PORTA,0
movwf 0x2D
movf PORTA,0
movwf 0x2E
movf PORTA,0
movwf 0x2F
...............
Gesamtdauer: 32 Takten
Pause zwischen Einlesungen: 2 Takten
Programmspeicher Bedarf: 32 Speicherstellen

Anstatt Warteschleifen (z.B. für Tastenentprellung) sollten Programmfragmente mit entsprechender Ausführungszeit benutzt werden (z.B. Ausgabe auf einem Display). Die nötige Zeit lässt sich aus mehreren UPs zusammensetzen.

Es sollte kein Prozessortakt ungenutzt bleiben.

= Mid-Range =

Zu Mid-Range gehören alle PICs mit 14-bit langen Befehlen aus den Familien 12FXXX und 16FXXX.

== Kurzübersicht Assembler Befehle ==

{|
|-
| valign=top |

{| {{Blauetabelle}}
|ADDLW||Add literal and W
|-
|ADDWF||Add W and f
|-
|ANDLW||AND literal with W
|-
|ANDWF||AND W with f
|-
|BCF||Bit Clear f
|-
|BSF||Bit Set f
|-
|BTFSC||Bit Test f, Skip if Clear
|-
|BTFSS||Bit Test f, Skip if Set
|-
|CALL||Call subroutine
|-
|CLRF||Clear f
|-
|CLRW||Clear W
|-
|CLRWDT||Clear Watchdog Timer
|}

| valign=top |

{| {{Blauetabelle}}
|-
|COMF||Complement f
|-
|DECF||Decrement f
|-
|DECFSZ||Decrement f, Skip if 0
|-
|GOTO||Go to address or label
|-
|INCF||Increment f
|-
|INCFSZ||Increment f, Skip if 0
|-
|IORLW||Inclusive OR literal with W
|-
|IORWF||Inclusive OR W with f
|-
|MOVF||Move f
|-
|MOVLW||Move literal to W
|-
|MOVWF||Move W to f
|-
|NOP||No Operation
|}

| valign=top |

{| {{Blauetabelle}}
|-
|RETFIE||Return from interrupt
|-
|RETLW||Return with literal in W
|-
|RETURN||Return from Subroutine
|-
|RLF||Rotate Left f through Carry
|-
|RRF||Rotate Right f through Carry
|-
|SLEEP||Go into standby mode
|-
|SUBLW||Subtract W from literal
|-
|SUBWF||Subtract W from f
|-
|SWAPF||Swap nibbles in f
|-
|XORLW||Exclusive OR literal with W
|-
|XORWF||Exclusive OR W with f
|}
[[:bild:pic_asm_short.jpg|Kurzübersicht zum Ausdrucken]]
|}


==Ausführliche Beschreibung zu den Befehlen==

Fast alle Befehle werden in einem Takt = 4 Oszillatortakten ausgeführt.

Aussnahmen:

"goto", "call", "return" und "retfie" benötigen wegen Zugriff auf den Programmzähler (PC) immer 2 Takten.

"btfsc", "btfss", "decfsz" und "incfsz" brauchen 1 Takt wenn der nächste Befehl ausgeführt wird b.z.w. 2 Takten wenn er überspringen wird, weil es immer anstatt des überspringenden Befehls ein "nop" ausgeführt wird.

Eine ausgegliederte Beschreibung der Befehle findet sich unter [[PIC Assemblerbefehle]]

Erklärungen zu den Verwendeten Platzhaltern:
*'''k''' stellt einen fest definierten Wert da. z.B. <tt>0x20</tt>, <tt>d'42'</tt> oder <tt>b'00101010'</tt>
*'''W''' steht für das W-Register.
*'''d''' steht für ''destination'' (Ziel). Im code wird d durch ein <tt>w</tt> bzw. <tt>0</tt> (der Wert wird in das W-Register gespeichert ) oder <tt>f</tt> bzw. <tt>1</tt> (der Wert wird in das davor definierte Register gespeichert)
*'''b''' steht für Bitnummer im Register (eine Zahl zwischen 0 und 7)
*'''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
*<tt>Schreibmaschinenstil</tt> bedeutet, dass es so im Quellcode geschrieben werden kann.

 ADDLW k ADD Literal and W - Addiere Zahl (k) und W<hr>
:Es wird die Rechenoperation <math>W+k</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|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

 ADDWF R,d ADD W and F - Addiere W und f <hr>
:Es wird die Rechenoperation <math>W+R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Dieser Befehl beeinflusst das STATUS-Register. Siehe hierzu [[#Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

 ANDLW k AND Literal with W<hr>
:Es wird bitweise die logische Funktion <math>k\ and\ W</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 Operation:
<dl><dd>
11001010 ;k
10101100 ;W-Register
-------- and
10001000 ;W-Register
</dd></dl>

 ANDWF R,d AND W with F<hr>
:Es wird bitweise die logische Funktion <math>W\ and\ R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Vergleiche ANDLW. Dieser Befehl wird benutzt zum Löschen bestimmten Bits im Register ohne restlichen Bits zu beeinflüssen.

BCF R,b Bit Clear F - Bit b im R wird gelöscht<hr>
:Mit dem Befehl <tt>BCF</tt> wird das Bit '''b''' im Register '''R''' gelöscht. Ein Beispiel:
<dl><dd>
movlw b'11111111' ;es wird b'11111111' in das W-Register geschrieben
BCF W,2 ;es wird bit 2 im W-Register gelöscht.
;das Ergebnis ist: b'11111011'
</dl></dd>

BSF R,b Bit Set F - Bit b im R wird gesetzt<hr>
:Mit dem Befehl <tt>BSF</tt> wird das Bit '''b''' im Register '''R''' gesetzt. Ein Beispiel:
<dl><dd>
clrw ;es wird b'00000000' in das W-Register geschrieben
BSF W,2 ;es wird bit 2 im W-Register gesetzt.
;das Ergebnis ist: b'00000100'
</dl></dd>

BTFSC R,b Bit Test F, Skip if Clear - Wenn das Bit b im Register R 0 ist, überspringe den nächsten Befehl<hr>
:Mit dem Befehl <tt>BTFSC</tt> kann eine Verzweigung im Programmablauf bewirkt werden. Wenn das Bit '''b''' im Register '''R''' 0 ist, wird der nächste Befehl übersprungen. Ein Beispiel:
<dl><dd>
movlw b'00000001' ;es wird die Zahl 1 in das W-Register kopiert.
BTFSC W,0 ;es wird bit 0 geprüft.
;wenn es 0 ist, wird der nächste Befehl übersprungen
goto IST_EINS ;springt zur Marke "IST_EINS" <- in diesem Fall wird dieser
;Sprungbefehl ausgeführt.
goto IST_NULL ;springt zur Marke "IST_NULL"
</dl></dd>

BTFSS R,b Bit Test F, Skip if Set - Wenn das Bit b im Register R 1 ist, überspringe den nächsten Befehl<hr>
:Mit dem Befehl <tt>BTFSS</tt> kann eine Verzweigung im Programmablauf bewirkt werden. Wenn das Bit '''b''' im Register '''R''' 1 ist, wird der nächste Befehl übersprungen. Ein Beispiel:
<dl><dd>
movlw b'00000001' ;es wird die Zahl 1 in das W-Register kopiert.
BTFSS W,0 ;es wird bit 0 geprüft.
;wenn es 1 ist, wird der nächste Befehl übersprungen
goto IST_NULL ;springt zur Marke "IST_NULL"
goto IST_EINS ;springt zur Marke "IST_EINS" <- in diesem Fall wird dieser
;Sprungbefehl ausgeführt, da der Befehl
;darüber übersprungen wurde.
</dl></dd>

CALL CALL Subroutine - Rufe Unterprogramm auf<hr>
:Mit dem <tt>CALL</tt> Befehl wird ein Unterprogramm aufgerufen. Mit dem <tt>RETURN</tt>-Befehl wird das Unterprogramm beendet und man kehrt zum Befehl nach dem <tt>CALL</tt>-Befehl zurück. Das Unterprogramm wird so definiert, dass im Quellcode der Name des Unterprogramms nicht eingerückt steht. Ein Beispiel:

<dl><dd>
movlw d'13' ;in das W-Register wird 13d geladen
CALL UP1 ;es wird das Unterprogramm "UP1" aufgerufen
movwf ergebnis ;das W-Register wird in das Register "ergebnis" kopiert.
;im Register "ergebnis" steht nun 23d

UP1 addlw d'10' ;es wird 10d zum W-Register addiert
return ;kehre zurück zum Aufrufer
</dl></dd>

CLRF R CLeaR F- Schreibe 0 in das Register R<hr>
:Das Register '''R''' wird mit Nullen gefüllt (gelöscht).

CLRW CLeaR W - Schreibe 0 in W<hr>
:Das W-Register (<tt>W</tt>) wird mit Nullen gefüllt (gelöscht).
:Der Befehl bewirkt das gleiche wie MOVLW 0 und darf im Programmen, die fur zukünftige Anwendung bei den PICs der serie 18F vorgesehen sind, nicht benutzt werden, da sie ihn nicht kennen.

CLRWDT CLeaR WatchDog Timer - Setzt den Watchdog-Timer zurück<hr>
:Es wird der WDT (Watchdog-Timer) zurückgesetzt und der Zähler des WDT auf 0 gesetzt, zusätzlich werden die STATUS-bits TO und PD gesetzt.

COMF R,d COMplement F - negiere alle bits im Register R<hr>
:Von der Binärzahl im Register '''R''' werden alle 0 mit 1 und alle 1 mit 0 ersetzt. Das Ergebnis wird entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Ein kleines Beispiel: aus <tt>AAh</tt> (<tt>10101010b</tt>) wird <tt>55h</tt> (<tt>01010101b</tt>).

DECF R,d DECrement F - Subtrahiert 1 vom Regiser f<hr>
:Vom Wert des Registers '''R''' wird 1 subtrahiert und das Ergebnis entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
:Weil es keine "echte" Substraktion ist, beeinflusst dieser Befehl das C-Flag im STATUS-Register nicht.

DECFSZ R,d DECrement F, Skip if Zero - Subtrahiert 1 vom Regiser f, überspringe wenn 0<hr>
:Vom Wert des Registers '''R''' wird 1 subtrahiert und das Ergebnis entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Der Zusatz SZ steht für ''skip if zero'', d.h. wenn das Ergebnis der Rechnung Null ist, wird der nächste Befehl übersprungen. Dieser Befehl wird für Schleifen mit bestimmter Anzahl der Durchläufe benutzt.

GOTO GO TO address - Gehe zu Adresse/Sprungmarke<hr>
:Nach dem GOTO Befehl wird das Programm ab der Adresse weiter ausgeführt, die nach dem GOTO-Befehl steht. Diese Adresse wird durch so genannte Sprungmarke definiert, welche, im Gegensatz zu den Befehlen nicht eingerückt im Quellcode stehen.

INCF R,d INCrement F - Addiere 1 zum Register f<hr>
:Zum Wert des Registers '''R''' wird 1 addiert und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
:Weil es keine "echte" Addition ist, beeinflusst dieser Befehl das C-Flag im STATUS-Register nicht.

INCFSZ R,d INCrement F, Skip if Zero - Addiere 1 zum Regiser f, überspringe wenn 0<hr>
:Zum Wert des Registers '''R''' wird 1 addiert und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Der Zusatz SZ steht für ''skip if zero'', d.h. wenn das Ergebnis der Rechnung Null ist, wird der nächste Befehl übersprungen. Dieser Befehl wird für Schleifen mit bestimmter Anzahl der Durchläufe benutzt.

 IORLW k Inclusive OR Literal with W<hr>
:Es wird bitweise die logische Funktion <math>k\ or\ W</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 Operation:
<dl><dd>
11001010 ;k
10101100 ;W-Register
-------- or
11101110 ;W-Register
</dd></dl>

 IORWF R,d Inclusive OR W with F<hr>
:Es wird bitweise die logische Funktion <math>W\ or\ R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Vergleiche IORLW. Dieser Befehl wird oft benutzt zum Setzen bestimmten Bits im Register ohne restlichen Bits zu beeinflüssen.

MOVF R,d MOVe F - Bewege f<hr>
:Das Register R wird in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder wieder in R kopiert ('''d'''=<tt>F</tt>=<tt>1</tt>). Letzteres mag sinnlos scheinen, ist aber nützlich, da durch den Befehl das Z-Bit im STATUS-Register gesetzt wird, falls R Null ist.

MOVLW k MOVe Literal to W - Bewege Zahl (k) in W-Register<hr>
:Der festgelegte Wert k wird in das W-Register kopiert.

:Dieser Befehl wird auch bei indirekter Adressierung zum laden der absoluter Adresse ins "FSR" Register benutzt. Beispiel:
:Der Register "Temp" wurde mit "Temp equ 0x20" definiert.
<dl><dd>
MOVLW Temp ;ins W-Register wird die absolute Adresse 0x20 vom "Temp" geladen
movwf FSR ;diese Adresse wird jetzt ins Register "FSR" kopiert
</dd></dl>
MOVWF R MOVe W to F- Bewege W-Register in das Register F<hr>
:Das W-Register wird in das Register '''R''' kopiert.

NOP No OPeration - Kein Befehl zum Ausführen (warte)<hr>
: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. Siehe hierzu: [[#Pause|Pause]]

RETFIE RETurn From Interrupt Enable - Kehre zurück aus der Unterbrechung, erlaube Unterbrechungen<hr>
:Mit diesem Befehl wird die Interrupt Service Routine (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 | Interrupt]]

RETLW k RETurn with Literal in W - Kehre zurück mit Zahl k im W-Register<hr>
:Wurde ein Programmteil mit dem Befehl <tt>CALL</tt> aufgerufen, dann springt man mit dem Befehl <tt>RETLW</tt> zurück in die nächste Zeile nach der Zeile aus der das <tt>CALL</tt> 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 Wertetabellen (eng: lookup tables) verwendet.

RETURN RETURN from Subroutine - Kehre zurück zum Aufrufer<hr>
:Wurde ein Programmteil mit dem Befehl <tt>CALL</tt> aufgerufen, dann springt man mit dem Befehl <tt>RETURN</tt> zurück zu der nächsten Zeile nach der Zeile aus der das <tt>CALL</tt> Befehl ausgeführt wurde.

RLF R,d Rotate Left F through carry - Rotiere das Register f mithilfe des Carry-bits nach links<hr>
:Alle Bits im Register '''R''' werden um eine Position nach links verschoben. Dabei wird das Carry bit (<tt>STATUS,C</tt>) 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'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
<dl><dd>
|<--- Register R --->|
|c|<-7<-6<-5<-4<-3<-2<-1<-0
V A
|________________________|
</dd></dl>
:Zur Verdeutlichung:
<dl><dd>
|C| |-Register R-| ;C steht für das Carry-bit, STATUS,C ; 0-7 stehen für Bitnummer im Register.
c 7 6 5 4 3 2 1 0 ;vor der Rotation
7 6 5 4 3 2 1 0 c ;nach der Rotation
</dd></dl>

RRF R,d Rotate Right F through carry - Rotiere das Register f mithilfe des Carry-bits nach rechts<hr>
:Alle Bits im Register '''R''' werden um eine Position nach rechts verschoben. Dabei wird das Carry bit (<tt>STATUS,C</tt>) 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'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
<dl><dd>
|<--- Register R --->|
|c|->7->6->5->4->3->2->1->0
A V
|________________________|
</dd></dl>
:Zur Verdeutlichung:
<dl><dd>
|C| |-Register R-| ;C steht für das Carry-bit, STATUS,C ; 0-7 stehen für Bitnummer im Register.
C 7 6 5 4 3 2 1 0 ;vor der Rotation
0 C 7 6 5 4 3 2 1 ;nach der Rotation
</dd></dl>

SLEEP Go into standby mode - Versetze den Mirokontroller in Bereitschaftsmodus (Schlaf)<hr>
: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.

 SUBLW k SUBtract W from Literal - Ziehe W von Zahl (k) ab<hr>
: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|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

 SUBWF R,d SUBtract W from F - Ziehe W von f ab<hr>
:Es wird die Rechenoperation <math>R-W</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Dieser Befehl beeinflusst das STATUS-Register. Siehe hierzu [[#Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

:Beispiel:
<dl><dd>
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
</dd></dl>

SWAPF R,d SWAP nibbles in F - Vertausche die Halbbytes (Nibbles)<hr>
:Es werden die höheren 4 bit (bit7-bit4) mit den niedrigeren 4 bit (bit3-bit0) eines Registers vertauscht und entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
:Beispiel:
<dl><dd>
movlw b'00001111' ;schreibe b'00001111' in das W-Register
movwf Register1 ;kopiert 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'
</dd></dl>

 XORLW k EXclusive OR Literal with W<hr>
:Es wird bitweise die logische Funktion <math>k\ xor\ W</math> ausgeführt und das Ergebniss in das W-Register gespeichert. Dieser Befehl setzt das Z bit des STATUS-Registers, falls W=k und das Ergebnis 0 ist.
:Zur Verdeutlichung der Operation:
<dl><dd>
11001010 ;k
10101100 ;W-Register
-------- xor
01100110 ;W-Register
</dd></dl>

 XORWF R,d EXclusive OR W with F<hr>
:Es wird bitweise die logische Funktion <math>W\ xor\ R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Vergleiche XORLW. Dieser Befehl setzt das Z bit des STATUS-Registers, falls W=k und das Ergebnis 0 ist und wird zum Vergleichen zwei Register benutzt.

==Besondere, oft gebrauchte Register==

=== STATUS ===
Der Statusregister beinhaltet den Status der Recheneinheit ALU (Arithmetic-Logic Unit), Resetinformationen und die beiden Bits zur Wahl der Speicherbank

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''STATUS''' (ADDRESSE 03h, 83h, 103h, 183h)</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R-1</td>
<td style="width:60px;">R-1</td>
<td style="width:60px;">R/W-x</td>
<td style="width:60px;">R/W-x</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''IRP'''</td>
<td style="background:#f5f7ff;">'''RP1'''</td>
<td style="background:#f5f7ff;">'''RP0'''</td>
<td style="background:#f5f7ff;">'''TO'''</td>
<td style="background:#f5f7ff;">'''PD'''</td>
<td style="background:#f5f7ff;">'''Z'''</td>
<td style="background:#f5f7ff;">'''DC'''</td>
<td style="background:#f5f7ff;">'''C'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

*Bit 7 '''IRP''': Register Bank Select Bit (für indirekte Adressierung)
:: 1 = Bank 2, 3 (100h-1FFh)
:: 0 = Bank 0, 1 (00h-FFh)
*Bit 6-5 '''RP<1:0>''': Register Bank Select Bits (für direkte Adressierung)
:: 11 = Bank 3 (180h-1FFh)
:: 10 = Bank 2 (100h-17Fh)
:: 01 = Bank 1 (80h-FFh)
:: 00 = Bank 0 (00h-7Fh)
*Bit 4 '''TO''': Time-out Bit
:: 1 = Nach Power-up, CLRWDT Befehl oder SLEEP Befehl
:: 0 = A Watchdogtimer time-out ist eingetreten
*Bit 3 '''PD''': Power-Down Bit
:: 1 = Nach Power-up oder durch den CLRWDT
:: 0 = Nach einem SLEEP befehl
*Bit 2 '''Z''': Zero bit
:: 1 = Das Ergebnis einer arithmetischen oder logischen Operation ist 0
:: 0 = Das Ergebnis einer arithmetischen oder logischen Operation ist NICHT 0
*Bit 1 '''DC''': Digit carry/borrow bit (ADDWF, ADDLW, SUBLW und SUBWF Befehle)
:: 1 = Ein Carry-out des 4.Niedrigsten Bits (Low Nibble) eines Rechenergebnisses existiert
:: 0 = Kein Carry-out des 4.Niedrigsten Bits eines Rechenergebnisses existiert
*Bit 0 '''C''': Carry/borrow Bit (ADDWF, ADDLW, SUBLW und SUBWF Befehle)
:: 1 = Ein Carry-out des MSB eines Rechenergebnisses existiert
:: 0 = Kein Carry-out des MSB eines Rechenergebnisses existiert

Das "Carry/Borrow Bit" (to carry = etwas übertragen, to borrow = etwas borgen) dient zum erkennen, wenn ein Übertrag einer Rechenoperation exisitiert. 250d+10d ergibt zum Beispiel 4, und setzt dabei das "Carry/Borrow Bit" auf 1. Damit kann das Programm erkennen, wenn wieder einmal ein Ergebnis größer als 255d herauskam.
Bei Subtraktionen (SUBLW und SUBWF) verhält sich das "Carry/Borrow Bit" umgekehrt als bei Additionen (ADDWF und ADDLW)!! Zum Beispiel 55d-6=49d setzt "Carry/Borrow Bit" auf 1 aber 10d-25d=241d löscht das "Carry/Borrow Bit".

====Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Registers====

{|
|-
|
{| {{Blauetabelle}}
|+ Auswirkungen auf das STATUS-Register bei Subtraktionen
|-
| Ergebnis
|| STATUS,C
|| STATUS,Z
|-
| positiv
|align="center"|1
|align="center"|0
|-
| negativ
|align="center"|0
|align="center"|0
|-
| Null
|align="center"|1
|align="center"|1
|}

||

{| {{Blauetabelle}}
|+ Auswirkungen auf das STATUS-Register bei Additionen
|-
| Ergebnis
|| STATUS,C
|| STATUS,Z
|-
| positiv
|align="center"|0
|align="center"|0
|-
| Überlauf
|align="center"|1
|align="center"|0
|-
| Null
|align="center"|1
|align="center"|1
|}
|}

=== PORTx ===

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''PORTx'''</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''Rx7'''</td>
<td style="background:#f5f7ff;">'''Rx6'''</td>
<td style="background:#f5f7ff;">'''Rx5'''</td>
<td style="background:#f5f7ff;">'''Rx4'''</td>
<td style="background:#f5f7ff;">'''Rx3'''</td>
<td style="background:#f5f7ff;">'''Rx2'''</td>
<td style="background:#f5f7ff;">'''Rx1'''</td>
<td style="background:#f5f7ff;">'''Rx0'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

!Das "x" steht in allen Fällen für den Buchstaben des Ports!
BSP: "PORTB" oder "RA1"

Diese Special Funktion Register liegen ALLE in Bank0 und Bank2(Falls vorhanden).

Jedes Bit eines PORT-Registers steht für einen Pin (Ein/Ausgang) des jeweiligen Ports. Je nachdem Ob ein Pin als Ausgang oder als Eingang definiert ist, kann man dort entweder den Wert schreiben oder auslesen. Es hat nicht Jeder PIC gleich viele Ports und es sind auch nicht immer 8 Pins pro Port, es können auch weniger sein. Alle PICs der Midrange-Serie besitzen nur bidirektionale Ports, d.h. sie können sowohl Eingang als auch Ausgang sein. Bei Port B kann man bei allen Pins einen internen PULL-UP Widerstand mit dem Bit OPTION_REG<RBPU> hinzuschalten (Standardmäßig auf nicht aktiviert, Bit muss gelöscht werden um die Funktion zu aktivieren). Weiters ist zu beachten, dass einzelne Pins nach dem Reset mit anderen Funktionen belegt sein können. Das gilt im Speziellen für PORTA, wo sich die Komperatoren, AD's (falls vorhanden) und die Oszillatoreingänge befinden. Siehe [[PIC Assembler#I/O Ports|I/O Ports]]. Bei den "kleinsten" PICs der 12F Serie die nur einen I/O Port (6 Pins) haben, heisst der PORT-Register GPIO.
{|{{Blauetabelle}}
|+ Beispiel PICs und ihre Ports (Zahlen in der Klammer sind die Anzahl der Pins des Ports)
|
|'''PIC16F628A'''
|'''PIC16F876'''
|'''PIC16F877'''
|-
|'''PORTA'''
|Ja
|Ja(5)
|Ja(6)
|-
|'''PORTB'''
|ja
|ja
|ja
|-
|'''PORTC'''
|/
|ja
|ja
|-
|'''PORTD'''
|/
|/
|ja
|-
|'''PORTE'''
|/
|/
|ja (3)
|-
|}

=== TRISx ===

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''TRISx'''</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''TRISx7'''</td>
<td style="background:#f5f7ff;">'''TRISx6'''</td>
<td style="background:#f5f7ff;">'''TRISx5'''</td>
<td style="background:#f5f7ff;">'''TRISx4'''</td>
<td style="background:#f5f7ff;">'''TRISx3'''</td>
<td style="background:#f5f7ff;">'''TRISx2'''</td>
<td style="background:#f5f7ff;">'''TRISx1'''</td>
<td style="background:#f5f7ff;">'''TRISx0'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

!Das "x" steht in allen Fällen für den Buchstaben des Ports!
BSP: "TRISB" oder "TRISA"

Bei den "kleinsten" PICs der 12F Serie die nur einen I/O Port (6 Pins) haben, heisst der TRIS-Register TRISIO.

Die TRIS-Bytes dienen dazu, einzelne I/O Pins als Eingang oder Ausgang zu definieren. Sie liegen immer genau eine Bank über den jeweiligen PORT-Bytes, d.h. sie liegen alle in Bank1 und Bank3 (falls vorhanden.) Besonders zu beachten ist, dass manche Eingebaute Features wie die Serielle Schnittstelle, I2C, SPI usw nicht funktionieren, wenn die Jeweiligen Sende und Empfangspins nicht manuell umgestellt werden, ja es ''muss'' sogar manchmal umgestellt werden (bei I2C z.B.) Egal ist dies jedoch für Komperatoren und AD-Wandler.

Merke:
* Eine 1 (als "I" für "Input" zu lesen) eines TRISxx-Bits definiert den zugehörigen PIN am PIC als Eingang.
* Eine 0 (als "O" für "Output" zu lesen) eines TRISxx-Bits definiert den zugehörigen PIN am PIC als Ausgang.

Siehe [[PIC Assembler#I/O Ports|I/O Ports]].

=== INTCON ===

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''INTCON''' (ADDRESSE 0Bh, 8Bh, 10Bh, 18Bh)</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''GIE'''</td>
<td style="background:#f5f7ff;">'''PEIE'''</td>
<td style="background:#f5f7ff;">'''TMR0IE'''</td>
<td style="background:#f5f7ff;">'''INT0IE'''</td>
<td style="background:#f5f7ff;">'''RBIE'''</td>
<td style="background:#f5f7ff;">'''TMR0IF'''</td>
<td style="background:#f5f7ff;">'''INT0IF'''</td>
<td style="background:#f5f7ff;">'''RBIF'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

*Bit 7 '''GIE''': Global Interrupt Enable Bit
::1 = Aktiviert alle Interrupts
::0 = Deaktiviert alle Interrupts
*Bit 6 '''PEIE''': Peripheral Interrupt Enable Bit
::1 = Aktiviert alle peripheren Interrupts
::0 = Deaktiviert alle peripheren Interrupts
*Bit 5 '''TMR0IE''': TMR0 Overflow Interrupt Enable Bit (Overflow von Timer0 löst Interrupt aus)
::1 = Aktiviert den TMR0 Interrupt
::0 = Deaktiviert den TMR0 Interrupt
*Bit 4 '''INT0IE''': RB0/INT External Interrupt Enable Bit (Änderung an RB0 Pin löst Interrupt aus) *)
::1 = Aktiviert den RB0/INT Interrupt (Extern ausgelöst)
::0 = Deaktiviert den RB0/INT Interrupt (Extern ausgelöst)
*Bit 3 '''RBIE''': RB Port On-Change-Interrupt Enable Bit (Änderung an PortB löst Interrupt aus) **)
::1 = Aktiviert den RB port on-change-interrupt
::0 = Deaktiviert den RB port on-change-interrupt
*Bit 2 '''TMR0IF''': TMR0 Overflow Interrupt Flag Bit
::1 = TMR0 Register ist Übergelaufen (muss per Software gelöscht werden)
::0 = TMR0 register ist nicht Übergelaufen
*Bit 1 '''INT0IF''': RB0/INT External Interrupt Flag Bit
::1 = Eine Änderung an RB0/INT Pin hat stattgefunden (muss per Software gelöscht werden)
::0 = Eine Änderung an RB0/INT Pin hat nicht stattgefunden
*Bit 0 '''RBIF''': RB Port On-Change-Interrupt Flag bit
::1 = Mind. einer der Pins von RB7:RB4 hat sich geändert (muss per Software gelöscht werden)
::0 = Keiner der Pins von RB7:RB4 hat sich geändert

* *) Die Flanke auf die reagiert werden soll, wird mit dem Bit OPTION_REG.INTEDG definiert. (steigende = 1 oder fallende = 0)
* **) Der Interrupt klingt verführerischer Weise so, als ob er den gesamten Port überwacht. Dabei reagiert er nur auf RB7:RB4!!!! Er kann aber den Prozessor vom "Schlaf" aufwecken (z.B. durch einen Tastendruck).

==Speicherbankorganisation==
===Programmspeicher===
Die Mid-Range MCUs haben einen 2-8k großen Programmspeicher. Dieser hat aber in jeder Speicherzelle nicht 8, sondern 14 Bit - also genau die Länge eines Befehls. Die aktuelle Stelle im Programm wird im PC (Program Counter) verwaltet. Er speichert immer die aktuelle Adresse im Programmspeicher (wird im Code oft als "$" bezeichnet). Bei einem PIC mit 8k Adressen muss er also die Adressen 0000-1FFF speichern können. Daraus folgt die Größe von 13 Bit für den PC. Der Programmspeicher ist in mehrere Bänke geteilt, die alle 2k groß sind. Das Programm springt ohne zutun des Benutzers von einer in die Nächste. Wenn man aber selber springen will, muss man die Register PCLATH (Program Counter Latch High) oder PCL (Program Counter Least Significant Byte) mit der Sprungadresse beschreiben.

===Datenspeicher===
Der Datenspeicher besteht aus den Special Function Registern (SFR) und den General Purpose
Registern (GPR). Die SFRs sind für die Funktionen des PICs zuständig (Interrupts, Timer, ADCs, CCPM...) und die GPRs für die Speicherung von Variablen und Daten.

Da immer nur 7 Bit der (Ziel)Adresse in einem Befehl gespeichert werden können, sind nur 7Fh (128d) Adressen im Datenbereich möglich. Deswegen wurde das "Banking" eingeführt. 2 Bit im Statusregister (welcher in allen Bänken der selbe ist und auch an der gleichen Stelle sitzt) geben die akutelle "Bank" an und sind nichts anderes als die 2 höchstwertigsten (MSB) Bits der Adresse. Damit lassen sich max. 4 Bänke ansprechen. Je nach PIC gibt es 2-4 Bänke. Die beiden Bits im Register STATUS heißen RP0 (STATUS<5>) und RP1 (STATUS<6>).

{| {{Blauetabelle}}
|+ Wechseln der Bänke mit RP0 und RP1
|-
|
|| RP1
|| RP0
|-
| Bank0
|align="center"|0
|align="center"|0
|-
| Bank1
|align="center"|0
|align="center"|1
|-
| Bank2
|align="center"|1
|align="center"|0
|-
| Bank3
|align="center"|1
|align="center"|1
|}

[[Bild:PIC midrange register.JPG]]
# '''FETTE Register''' sind in allen PICs vorhanden
# können je nach PIC unimplementierte Bereiche beinhalten - diese werden immer als 0 gelesen. (DATENBLATT!!)
# siehe 2
# Könnten je nach PIC auch nicht in Bank0 gemapped werden, sind dann eigenständige Register.
# je nach PIC kann es diese Bänke geben oder nicht geben.

== Codeschnipsel ==

=== Analog-Digital-Wandler (ADC) ===

Viele PICs besitzen einen Analog-Digital-Wandler, der eine angelegte Spannung messen kann und diese als Zahl speichert.

Es gibt AD-Wandler mit 8Bit bzw. 10Bit Auflösung, d.h. die Spannung an einem analogen Eingang wird linear 2^8=256 bzw. 2^10=1024 Werten zugeordnet.
Der höchste Wert, auch Referenzspannung genannt, (255 bzw. 1023; der Controller rechnet die Null auch mit) entspricht der Betriebsspannung des PICs oder wahlweise einer wählbaren Spannung, die an RA3 angelegt werden muss. Der niedrigste Wert entspricht 0 Volt.

Mit dem Analog-Digital-Wandler kann man somit z.B. Sensoren auswerten, die mehr als zwei Zustände ausgeben (Beispiele: Temperatursensor, Helligkeitssensor, Entfernungssensoren usw.) oder Akkuspannungen messen.

Bevor überhaupt gemessen werden kann, muss einiges eingestellt werden:

* Eingangsverteilung Analog/Digital bzw.Referenzspannung (Betriebsspannung oder RA3)
die genauen Einstellungsmöglichkeiten entnehmen sie bitte dem Datenblatt ihres Controllers (Register ADCON1 Bank 1).

* Wählen des Taktes für den ADC und Einschalten des ADCs

Das Register ADCON0 besitzt 8 Bits, die folgendes bestimmen:
Bit0 ADON - schaltet AD-Wandler ein oder aus (Strom sparen)
Bit1 - nicht vorhanden
Bit2 GO/Done - startet Wandlung / signalisiert, wann Umwandlung beendet ist.
Bit3 CHS0 - Channel Select 0 wählt Eingang aus
Bit4 CHS1 - Channel Select 1 wählt Eingang aus
Bit5 CHS2 - Channel Select 2 wählt Eingang aus
Bit6 ADCS0 - AD-Clock-Select wählt Takt
Bit7 ADCS1 - AD-Clock-Select wählt Takt

Kümmern wir uns zunächst um den Takt. Mit den zwei Bits ADCS0 und ADCS1 bestimmt man den Takt - hierbei gibt es vier Möglichkeiten:

ADCS1=0, ADCS0=0 -> Taktfrequenz des PICs :2
ADCS1=0, ADCS0=1 -> Taktfrequenz des PICs :8
ADCS1=1, ADCS0=0 -> Taktfrequenz des PICs :32
ADCS1=1, ADCS0=1 -> interner RC-Oszillator des ADCs verwenden

Die Taktfrequenz des ADCs darf 625kHz nicht überschreiten, dementsprechend ist ADCS0 und ADCS1 zu wählen.

Ist dies vollbracht, so kann man den AD-Wandler einschalten und das Go/Done-Bit löschen.
Codebeispiel:

bcf ADCON0,6 ;Takt für
bsf ADCON0,7 ;ADC (OSC/32)
bsf ADCON0,0 ;ADC einschalten, ADON=1
bcf ADCON0,2 ;Go/Done-Bit zurücksetzen

Nun ist der AD-Wandler bereit, Spannungen in Zahlen umzuwandeln.
Für eine Wandlung muss erst der entsprechende Eingang gewählt werden. Dafür sind die CHS0..CHS2-Bits zuständig:

CHS2 CHS1 CHS0 gewählter Eingang(falls vorhanden)
0 0 0 RA0
0 0 1 RA1
0 1 0 RA2
0 1 1 RA3
1 0 0 RA5
1 0 1 RE0
1 1 0 RE1
1 1 1 RE2

Achtung! RA4 ist kein analoger Eingang, folglich ist er oben nicht aufgelistet !!

Codebeispiel:

bcf ADCON0,3 ;RA2 auswählen
bsf ADCON0,4
bcf ADCON0,5

Als letztes muss die AD-Routine nur noch gestartet werden. Ist der AD-Wandler fertig, so löscht er das Bit wieder. Das Bit wird nun solange abgefragt, bis der AD-Wandler fertig ist. Den zugeordneten Wert findet man im Register 'ADRES'.
Code:

bsf ADCON0,2 ;start
wa btfsz ADCON0,2 ;warten,bis es wieder low ist
goto wa ;noch nicht fertig
;jetzt ist er fertig
movf ADRES,W ;ADRES in W verschieben, um damit gleich weiter zu arbeiten

Die AD-Wandlung ist somit fertig. Liest man mehrere Werte von unterschiedlichen Eingängen ein und möchte diese miteinander vergleichen o.ä., sollte man die Zahlen von ADRES in anderen Registern zwischenspeichern.

Desweiteren ist zu beachten, dass der Analog-Digital-Wandler eine gewisse Pause zwischen den Wandlungen benötigt, die sog. 'Aquisition Time'. Diese Zeitangabe entnehmen sie bitte ihrem Datenblatt.

mögliche Probleme:

;Der PIC liefert stark schwankende Werte
:-> Mögliche Ursachen dafür sind z.B. nicht stabile Betriebsspannung, falsche Zeiteinstellungen. Abhilfe schafft auch das mehrmalige Einlesen eines Eingangs. Auch können z.B. 8 Werte eingelesen werden und dann der Durchschnitt gebildet werden.
Evtl. kann ein Kondensator gegen Masse (z.B. 1nF) helfen; Wichtig ist auch eine kleine Verzögerung zwischen Kanalauswahl und Start der Wandlung. In dieser Zeit kann sich der interne Kondensator des ADC's aufladen.

;Die Spannung an einem Eingang wird erhöht, die Werte der anderen Eingänge werden aber auch beeinflusst.
:-> Dann sind Sie Opfer des sog. 'Ghostings' geworden (Werte 'scheinen durch', verschleißen). Die Werte der anderen Eingänge gehen mit, weil der interne Kondensator noch auf die Spannung des Vorgängers aufgeladen ist. Maßnahme: Aquisition Time erhöhen, Werte öfters abfragen, Pause zwischen Kanalauswahl und Start

;Der PIC liefert immer die gleichen Werte an einem Eingang, obwohl sich die angelegte Spannung ändert
:-> möglicherweise falsche Eingangsverteilung (ADCON1) eingestellt oder falschen Pin gewählt

=== Hex Dec Wandlung ===

Das ist ein Unterprogramm das mit "call Hex_Dec" aufgerufen wird. Es gibt 4 Register (A, B, C und D) mit jeweils 32 Bits, die aus jeweils 4 Register mit 8 Bits (z.B. fur A: A3, A2, A1 und A0) bestehen.

A3 A2 A1 A0
.--------.--------.--------.--------.
|76543210|76543210|76543210|76543210|
'--------'--------'--------'--------'
| |
|<----------- A Register ---------->|

Sie müssen (wegen FSR) so wie im Code nacheinander liegen (die absoluten Adressen sind nicht wichtig). In das Register "A" wird die hex Zahl eingeschrieben und aus dem "D" die umgewandelte dec Zahl ausgelesen. A3,7 und D3,7 sind MSB und A0,0 und D0,0 sind LSB. Die "B" und "C" sind Hifsregister. Das UP kann für kleinere als 32-bittige hex Zahlen modifiziert werden. Zum Beispiel für 16-bittige hex Zahlen bleiben nur Register A1,A0,B1,B0,C1,C0,D1,D0 und in den UPs werden in die Register und als X, folgende Zahlen eingeschrieben: HTmp->0x10 (Anzahl Bits der hex Zahl),ATmp->2=X (Anzahl Bytes der hex Zahl). Es müssen auch die UPs "CClr", "DClr" und "CopyCB" entschprechend der Registerlänge angepasst werden. Genauso kann natürlich das UP auch für längere hex Zahlen modifiziert werden.

Das UP "AddCB" addiert dezimal die 32- bittige Register C und B, das Ergebniss befindet sich in C.
Das UP "AddDC" addiert dezimal die 32-bittige Register D und C, das Ergebniss befindet sich in D.

Die 32-bit Additionen werden in 4 Schritten wie folgt realisiert:

C0+B0->C0, C1+B1->C1, C2+B2->C2 und C3+B3->C3

D0+C0->D0, D1+C1->D1, D2+C2->D2 und D3+C3->D3

Die Flags "_Fcra", "_Fcrp" und "_Fdca" steuern die alle nötigen Korrekturen.

Die Wandlung wird in 32 Schritten laut folgender Formel durchgeführt:

Zahl(d)=B0*2^0+B1*2^1+B2*2^2+B3*2^3+B4*2^4+B5*2^5+B6*2^6+B7*2^7+B8*2^8+B9*2^9+B10*2^10+B11*2^11+

B12*2^12+B13*2^13+B14*2^14+B15*2^15+B16*2^16+B17*2^17+B18*2^18+B19*2^19+B20*2^20+B21*2^21+

B22*2^22+B23*2^23+B24*2^24+B25*2^25+B26*2^26+B27*2^27+B28*2^28+B29*2^29+B30*2^30+B31*2^31

Wobei B0 bedeutet den LSB und B31 den MSB der hex Zahl.

Die dec Zahl wird im D Register durch "AddDC" gebildet. In dem C Register befindet sich immer die laufende 2^X. Am Anfang wird dort 1=2^0 geladen. Da die nächste zu addierende dec Zahl immer gleich 2* vorherige ist, wird sie einfach so berechnet, dass die aktuelle aus C Register ins B Register kopiert ("CopyCB") und zum C addiert ("AddCB") wird. Diese dec Zahl wird zum D Register addiert nur wenn entsprechender Bit der hex Zahl gleich 1 ist. Weil im UP "Hex_Dec" immer das bit A0,0 dafür geprüft wird, wird das gesamte 32-bittige A Register nach jeder Addition "AddDC" um ein Bit mit "ARotRb" nach rechts rotiert. Die Flags "_Fcra" und "_Fcrp" übertragen die Bits zwischen den 8 Bit Register A0, A1, A2 und A3. Es würde zwar reichen, wenn das A Register nur verschoben würde, aber hier wurde Rotation gewählt, damit nach der Wandlung die hex Zahl im A Register unverändert steht. Weil die dec Zahl nur 8-stellig ist, die max. hex Zahl darf 99999999d = 5F5E0FFh sein.

#define _C STATUS,C
#define _Z STATUS,Z
#define _DC STATUS,DC
#define _Fcra Flags,0
#define _Fcrp Flags,1
#define _Fdca Flags,2
#define _Ferr Flags,3 ;Überlauf (Fehler)
;..................................................................................
A3 EQU 0x20 ;Register fürs Rechnen
A2 EQU 0x21
A1 EQU 0x22
A0 EQU 0x23
B3 EQU 0x24
B2 EQU 0x25
B1 EQU 0x26
B0 EQU 0x27
C3 EQU 0x28
C2 EQU 0x29
C1 EQU 0x2A
C0 EQU 0x2B
D3 EQU 0x2C
D2 EQU 0x2D
D1 EQU 0x2E
D0 EQU 0x2F
Flags EQU 0x30
ATmp EQU 0x31 ;Schleifenzähler
HTmp EQU 0x32 ;Schleifenzähler
RTmp EQU 0x33 ;Zwischenspeicher
;..................................................................................
Hex_Dec call CClr ;Hex>A, D>Dec
call DClr
movlw 1
movwf C0
movlw 0x20 ;32 bit Hex > 32 bit Dec (8 Stellen)
movwf HTmp
HexDecL btfsc A0,0
call AddDC
call CopyCB
call AddCB
call ARotRb
decfsz HTmp,1
goto HexDecL
return
CClr clrf C0
clrf C1
clrf C2
clrf C3
return
DClr clrf D0
clrf D1
clrf D2
clrf D3
return
CopyCB movf C0,0
movwf B0
movf C1,0
movwf B1
movf C2,0
movwf B2
movf C3,0
movwf B3
return
AddCB movlw B0 ;C+B>C
movwf FSR
goto AddR
AddDC movlw C0 ;D+C>D
movwf FSR
AddR bcf _Ferr ;Addiere zwei Register
bcf _Fcrp
movlw 4 ;X=4 Bytes lang
movwf ATmp
AddRL bcf _Fdca
bcf _Fcra
movf INDF,0
movwf RTmp
movlw 4 ;X=4
addwf FSR,1
btfss _Fcrp
goto AddRN
movlw 1
addwf INDF,1
call DecCor
AddRN movf RTmp,0
addwf INDF,1
call DecCor
btfss _Fdca
goto AddCor1
movlw 6
addwf INDF,1
AddCor1 btfss _Fcra
goto AddCor2
movlw 0x60
addwf INDF,1
btfsc _C
bsf _Fcra
AddCor2 movf INDF,0
andlw 0xF0
sublw 0xA0
btfss _Z
goto AddCor3
movf INDF,0
andlw 0x0F
clrf INDF
addwf INDF,1
bsf _Fcra
AddCor3 bcf _Fcrp
btfsc _Fcra
bsf _Fcrp
movlw 5 ;X+1=5
subwf FSR,1
decfsz ATmp,1
goto AddRL
btfsc _Fcra
bsf _Ferr
return
DecCor btfsc _DC ;dezimale Korrektur (equ DAW)
bsf _Fdca
btfsc _C
bsf _Fcra
movf INDF,0
andlw 0x0F
sublw 9
btfss _C
bsf _Fdca
movf INDF,0
andlw 0xF0
sublw 0x90
btfss _C
bsf _Fcra
return
ARotRb movlw A3 ;rotiere A register 1 Bit rechts
movwf FSR
RRotRb movlw 4 ;rotiere X=4 Bytes
movwf ATmp
bcf _Fcrp
btfsc A0,0
bsf _Fcrp
RRotRbL bcf _Fcra
btfsc INDF,0
bsf _Fcra
bcf _C
btfsc _Fcrp
bsf _C
rrf INDF,1
bcf _Fcrp
btfsc _Fcra
bsf _Fcrp
incf FSR,1
decfsz ATmp,1
goto RRotRbL
return

=== EEPROM ===

Alle PICs besitzen EEPROM in dem je nach Typ können 64 bis 256 Databytes abgespeichert werden. Die Adressierung des EEPROMs fängt immer mit 0x00 an. Hier werden nur geprüfte UPs kurz erklärt. Die ersten zwei brauchen nur ein Register "Temp" für Schleifenzähler, dessen Name, falls im Programm schon existiert, geändert werden muss. Die Adresse im EEPROM ist gleich der Adresse im RAM.

EEPROM beschreiben:

EEWrite movlw 0x20 ; ab der RAM Adresse wird in EEPROM abgespeichert
movwf FSR
movlw 4 ; soviel Bytes
movwf Temp ; Schleifenzähler
EEWLoop call EEWrite1
incf FSR,1 ; nächste Adresse
decfsz Temp,1
goto EEWLoop
return

EEWrite1 bcf INTCON,GIE ; Interrupts sperren
movf FSR,0
bsf STATUS,RP0 ; auf Bank1 umschalten
movwf EEADR ; EEPROM Adresse
movf INDF,0
movwf EEDATA ; EEPROM Data
bsf EECON1,WREN
movlw 0x55
movwf EECON2
movlw 0xAA
movwf EECON2
bsf EECON1,WR
bcf EECON1,WREN
btfsc EECON1,WR
goto $-1 ; warten bis WR=0
bcf STATUS,RP0 ; zurück auf Bank 0 umschalten
bsf INTCON,GIE ; Interrupts erlauben
return

EEPROM lesen und zurück in RAM schreiben:

EERead movlw 0x20 ; ab der Adressse wird aus EEPROM in RAM abgelegt
movwf FSR
movlw 4 ; soviel Bytes
movwf Temp ; Schleifenzähler
EERLoop call EERead1
incf FSR,1 ; nächste Adresse
decfsz Temp,1
goto EERLoop
return

EERead1 movf FSR,0
bsf STATUS,RP0 ; auf Bank1 umschalten
movwf EEADR ; EEPROM Adresse
bsf EECON1,RD
movf EEDATA,0 ; EEPROM Data
bcf STATUS,RP0 ; zurück auf Bank 0 umschalten
movwf INDF
return

Tabelle im EEPROM mit MPASM Direktive "de" erstellen:

org 0x2100 ; EEPROM initialisieren
; nachfolgend als Kommentar die EEPROM Adressen
de 0x03, 0xE8 ; 0x00
de 0x03, 0xE8 ; 0x02
de 'M','H','z',0x00 ; 0x04
de ' ',' ','W','A','I','T',0x00 ; 0x08
de 'C','o','n','s','t',' ','X',0x00 ; 0x0F
de 'C','=',0x00 ; 0x17
de 'L','=',0x00 ; 0x1A
de 'F','=',0x00 ; 0x1D
de 'O','K',0x00 ; 0x20
u.s.w.

Wenn die Tabelle sich im Quellcode befindet, wird sie beim brennen des PICs in EEPROM eigeschrieben.

Das Lesen eines Strings muss ab entsprechender EEPROM Adresse (z.B. für "MHz" -> 0x04) anfangen und auf dem Wert 0x00, der hier als Stringende dient, enden. Einfacher ist, wenn alle Strings gleich lang sind (wie z.B. in einem Zeichengenerator fur Grafikdisplay).

Die Adreesse "0x2100" in der "org" Direktive hat mit der Adresse im Programmspeicher nichts zu tun.

=== Interrupts ===

Das Programmteil misst eine Frequenz an TOCKI Pin und wurde für PIC16F870 geschrieben.

Benötigte Hardware: Widerstand 470 Ohm zwischen der Frequenzquelle und TOCKI Pin (A4).

Es fehlen UPs "Hex_Dec" [[#Hex Dec Wandlung|Hex Dec Wandlung]] und Ausgabe auf ein Display "DispFrq". Das HP ("Main") als leere endlose Schleife macht nichts ausser warten auf ein Interrupt von Timer0 bzw. Timer1. Man kann die Marke "Main" weglassen und das HP als "goto $" formulieren.

Da der Timer0 nicht, wie der Timer1 durch ein Flag gestartet und gestoppt werden kann, wird es durch setzen und löschen des Bits für TOCKI (A4) Pin im TRISA Register, genauso wie in der AN592 vom Microchip, gemacht.

Der Zähler der Frequenz wurde um ein Zähler aus zwei zusätzlichen Register A2 und A3 erweitert und bei jedem Timer0 Überlauf erhöht. Der Prescaler wird ins Register A0 und der TIMER0 ins A1 kopiert. Somit ergibt sich 32-bittiges Ergebniss, der als hex Zahl in den Register A3 (MSB),A2, A1, und A0 (LSB) steht. Nach der "Hex_Dec" Wandlung kann die Frequenz aus den Register D3 (MSB), D2, D1 und D0 (LSB) an einem biliebigen Display angezeigt werden.

Es wird kein zusätzliches Register benötigt, da das "ATmp" und das "RTmp" die gleichen wie im UP "Hex_Dec" sind. Die Quarzfrequenz wurde gewählt, weil sie am nächsten der Temperaturstabiltesten Frequenz für AT Quarzen 7,2 MHz ist. Der PIC16F870 wurde nur wegen nötigen 19 I/O Pins für 6-stelligen 7-segment LCD Display LPH2673-1[[http://www.roboternetz.de/phpBB2/viewtopic.php?t=26005]] (ohne Kontroller) vom Pollin angewendet. Mit einem üblichen 1x16 Zeichen LCD Matrixdisplay und anderen PICs wurde das Programm für Frequenzen bis zum 80 MHz mit einer Genauigkeit
+/- 4 Hz positiv getestet.

Um die Frequenz mit Genauigkeit +/- 1Hz zu messen, muss die Messzeit 1 s von Timer1 erzeugt werden, das nur für Quarz bis 2,048 MHz möglich ist. Für sehr genaue Messungen wird empfohlen als Taktfrequenz für den Timer1, die Trägerfrequenz eines nächsten LW Senders (z.B. DLF 153 bzw. 207 kHz) zu nutzen. Die Genauigkeit der Frequenz ist ca. 1E-11 und geprüfter Empfänger kann laut der Skizze in [[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=13706&highlight=frequenzz%E4hler]] nachgebaut werden. In dem Fall müssen die Register vom Timer1 (TMR1H und TMR1L) vor seinem Start entsprechend geladen werden.

Mit dem Quarz 7,3728 MHz wird hier die Messzeit 0,25 s genutzt und die gemessene Frequenz durch 4 multipliziert (mittels 2 Additionen), was die Auflösung von +/- 4 Hz ergibt.

Das UP "Init" muss selbstverständlich für ein Matrixdisplay um Initialisierung des Displaykontrollers ergänzt werden.

; Programm zum Messen der Frequenz an T0CKI Pin mit 7,3728 MHz Quarz
LIST P=16F870
include "P16F870.inc"
__CONFIG _CP_OFF & _DEBUG_OFF & _WRT_ENABLE_ON & _CPD_OFF & _LVP_OFF & _BODEN_OFF &
_PWRTE_ON & _WDT_OFF & _HS_OSC
ORG 0x0000
call Init
Main goto Main
ORG 0x0004 ;ISR (interrupt service routine)
bcf INTCON,GIE ;interrupts sperren
btfss INTCON,T0IF ;ist Timer0 übelaufen ?
goto CheckTMR1 ;nein, dann prüfe Timer1
bcf INTCON,T0IF ;Timer0 interrupt flag löschen
movlw 1
addwf A2,1 ;erhöhe A2
btfsc STATUS,C
incf A3,1 ;increment A3, wenn A2 überlaufen ist
CheckTMR1 btfss PIR1,TMR1IF ;ist Timer1 überlaufen ?
retfie ;wenn nicht, springe zurück zu Main
bsf STATUS,RP0 ;stopp Timer0
movf TRISA,0
andlw 0xEF
movwf TRISA ;TOCKI Pin (A4) als Ausgang
bcf STATUS,RP0
bcf T1CON,TMR1ON ;stopp Timer1
bcf PIR1,TMR1IF ;Timer1 interrupt flag löschen
GetFreq movf TMR0,0 ;Prescaler ins Register A0 kopieren
movwf A1
movwf RTmp
clrf ATmp
FToggle incf ATmp,1
bsf STATUS,RP0
bsf OPTION_REG,T0SE
bcf OPTION_REG,T0SE
bcf STATUS,RP0
movf TMR0,0
subwf RTmp,0
btfsc STATUS,Z
goto FToggle
comf ATmp,1
incf ATmp,0
movwf A0
call Hex_Dec
clrf A3 ;Register A löschen
clrf A2
clrf A1
clrf A0
call CopyDC
call AddDC ;gemessene Frequenz * 2
call CopyDC
call AddDC ;gemessene Frequenz * 4 = tatsächliche Frequenz
call DispFrq ;eigenes UP für benutztes Display
clrf TMR0 ;Timer0 löschen
movlw 0x34 ;Timer1
movwf T1CON ;konfigurieren
movlw 0x1F ;Timer1 laden (für 0,25 s)
movwf TMR1H
clrf TMR1L
bsf STATUS,RP0 ;start Timer0
movf TRISA,0
iorlw 0x10
movwf TRISA ;TOCKI Pin (A4)als Eingang
bcf STATUS,RP0
bsf T1CON,TMR1ON ;start Timer1
retfie ;erlaube interrupts und springe zurück zu Main
CopyDC movf D0,0
movwf C0
movf D1,0
movwf C1
movf D2,0
movwf C2
movf D3,0
movwf C3
return
Init clrf PORTA ;Ports löschen
clrf PORTB
clrf PORTC
movlw 0x20 ;RAM (20-7Fh) löschen
movwf FSR
clrf INDF
incf FSR,1
btfss FSR,7
goto $-3
clrf ADCON0 ;schalte ADC off
movlw 7 ;sperre ADC
movwf ADCON1 ;und definiere RA0-7 als digitale I/Os
movlw 0xE0 ;GIE, PEIE & TMR0IE erlauben
movwf INTCON
bsf STATUS,RP0 ;bank 1
clrf TRISA ;alle PORTA,
clrf TRISB ;alle PORTB,
clrf TRISC ;und alle PORTC Pins als Ausgänge
movlw 0xE7 ;Takt für Timer0 vom T0CKI Pin
movwf OPTION_REG ;Timer0 konfigurieren
bsf PIE1,TMR1IE ;TMR1 interrupt erlauben
bcf STATUS,RP0 ;Bank 0
clrf TMR0 ;Timer0 löschen
movlw 0x34 ;Timer1 konfigurieren
movwf T1CON ;(prescaler 8)
movlw 0x1F ;Timer1 laden (für 0,25 s)
movwf TMR1H
clrf TMR1L
bsf STATUS,RP0 ;start Timer0
iorlw 0x10
movwf TRISA ;TOCKI Pin (A4) als Eingang
bcf STATUS,RP0
bsf T1CON,TMR1ON ;start Timer1
return
end

=== Mausrad ===

Das UP wertet ein Mausrad aus und setzt, je nach Drehrichtug und sein Anschluss an PORT (PORTB,0 und PORTB,1), ein Flag "_Finc" bzw. "_Fdec", das vor der nächsten Abfrage, gelöscht werden muss. Diese Flags können z.B. für Inkrementierung und Dekrementierung von Zählern dienen.

Die Hardware:

Mausrad
.-------.
| o---> PORTB,0
+----o---- |
| | o---> PORTB,1
=== '-------'
GND

Es müssen die internen pull-ups vom PORTB aktiviert werden. Wenn das Mausrad an anderen PORT angeschlossen wird, werden externe pull-ups (z.B. 10 kOhm) benötigt. Als "_Z" wurde "STATUS,Z" definiert. Zum Auswerten werden 4 Register "MausA", "MausB", "MausC" und "Flags" gebraucht, die im gesamten Programm definiert werden müssen. Die Warteschleife "Delay" soll ca. 10ms sein.

In dem UP "Mouse" wird PORTB eigelesen, die alle Bits ausser 0 und 1 durch "and" Funktion gelöscht und in den Register "MausB" und "MausC" gespeichert. Nach ca. 10ms wird das gleiche gemacht und im Register "MausA" gespeichert. Der Wert aus "MausA" wird mit dem vorherigen aus "MouseC" durch "xor" verglichen. Sind sie nicht identisch, wird je nach dem Wert "X" (0, 1, 2, b.z.w. 3) im "MausB" in das entsprechende UP "MouseX" gesprungen. Sonst, wenn "MausA"="MausC", wird zum Aufrufer zurückgekehrt.

In einem UP "MouseX" wird der letzte Wert im "MausA" ermittelt und nach der Kombination der Werte im "MausB" und "MausA" (01 b.z.w. 02, 10 b.z.w. 13, 20 b.z.w. 23 oder 31 b.z.w. 32) entsprechendes der Drehrichtung Flag "_Finc" b.z.w. "_Fdec" gesetzt. Anschliessend wird zum Aufrufer zurückgesprungen.

Detailierter PAD:

Mouse V
PORTB->W
3 and W->W
W->MausB
W->MausC
Warten 10ms
PORTB->W
3 and W->W
W->MausA
W xor MausC->MausC
_Z=1 ? J > return
N
V
MausB->MausB
.--------------------------< J _Z=1 ?
| N
| V
| MausB->W
| 1-W->W
| .----< J _Z=1 ?
| | N
| | V
| | MausB->W
| | 2-W->W
| | _Z=1 ? J >---------------------------.
| | N |
| | V |
| | MausB->W |
| | 3-W->W |
| | _Z=1 ? J >-----. |
| | N | |
| | V | |
| | return | |
| | | |
| | | |
Mouse0 V Mouse1 V Mouse3 V Mouse2 V
MausA->W MausA->MausA MausA->W MausA->MausA
1-W->W V 1-W->W V
_Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--.
J | J | J | J |
V | V | V | V |
setze _Fdec | setze _Finc | setze _Finc | setze _Fdec |
V<-----´ V<-----´ V<-----´ V<-----´
MausA->W MausA->W MausA->W MausA->W
2-W->W 3-W->W 2-W->W 3-W->W
_Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--.
J | J | J | J |
V | V | V | V |
setze _Finc | setze _Fdec | setze _Fdec | setze _Finc |
V<-----´ V<-----´ V<-----´ V<-----´
return return return return

und Quellcode:

Mouse movf PORTB,0
andlw 3
movwf MausB
movwf MausC
call Delay ; ca. 10 ms
movf PORTB,0
andlw 3
movwf MausA
xorwf MausC,1
btfsc _Z
return
movf MausB,1
btfsc _Z
goto Mouse0
movf MausB,0
sublw 1
btfsc _Z
goto Mouse1
movf MausB,0
sublw 2
btfsc _Z
goto Mouse2
movf MausB,0
sublw 3
btfsc _Z
goto Mouse3
return
Mouse0 movf MausA,0
sublw 1
btfsc _Z
bsf _Fdec
movf MausA,0
sublw 2
btfsc _Z
bsf _Finc
return
Mouse1 movf MausA,1
btfsc _Z
bsf _Finc
movf MausA,0
sublw 3
btfsc _Z
bsf _Fdec
return
Mouse2 movf MausA,1
btfsc _Z
bsf _Fdec
movf MausA,0
sublw 3
btfsc _Z
bsf _Finc
return
Mouse3 movf MausA,1
sublw 1
btfsc _Z
bsf _Finc
movf MausA,0
sublw 2
btfsc _Z
bsf _Fdec
return

=== Handy Display ===

Als Beispiel die Hardware und Testprogram für Nokia 3310/3330 Display: [[http://www.roboternetz.de/phpBB2/viewtopic.php?p=124669#124669]]

= Hilfsmittel =

Hier werden einige Programme presentiert, die das ASM Programmieren erleichtern.
Damit sie möglichst wenig Data- und Programmspeicher benötigen, sind alle Zahlen auf dem Display in der hex Darstellung.
Für alle, die es in Dezimalsystem haben wollen, ist ein Taschenrechner mit hex<->dec Wandlung nötig.

== PIC Miniterminal ==

Das ist eine Schnittstelle, die nur 2 Leitungen zum Anschluss an PIC braucht. Sie ermöglicht Steuern von diversen LCD Displays mit üblichem Anschluss ("RS", "Enable" und 8 Databits) und Abfragen von 3 Tasten.

Sie wird mit einem 2x16 Zeichen Matrixdisplay und 3 Tasten für weiter beschriebene Hilfsprogramme verwendet.

Hardware und Testprogramm: [[http://www.roboternetz.de/phpBB2/viewtopic.php?t=13685]]

[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Category:PIC]]

PIC Assembler

2007-04-25T20:52:41Z

Andy:

= Einladung zur Diskussion... =

Es wird hier versucht die ASM Programmierung von PIC Mikrocontrollern zu beschreiben.

Damit der enstehende Artikel wirklich nützlich wird, ist Ihre Mitwirkung nötig. Bitte schreiben Sie uns Ihre Meinung, was eventuell noch geändert (z.B. ergänzt) werden soll in diesem Thread:

http://www.roboternetz.de/phpBB2/viewtopic.php?p=271211#271211

Die Autoren bedanken sich im voraus für jeden Beitrag mit Vorschlägen !

= Einführung =

== Bit, Byte, Nibble, Bin und Hex ==

Ein Mikrocontroller (kurz: µC) kann eigentlich nur durch ein Portpin eine Spannung einlesen bzw. ausgeben. Er kann aber nur erkennen, ob eine Spannung vorhanden ist oder nicht. Wenn fast keine Spannung vorhanden ist erkennt er das als 0 und wenn eine Spannung fast so gross, wie seine Versorgungsspannung anliegt, als 1.

Genauso bei der Ausgabe, wenn er 0 ausgibt ist auf dem Portpin fast keine Spannung, wenn 1, eine Spannung fast gleich gross seiner Versorgungsspannung. Und das ist ein Bit, die kleinste Menge einer Information. Das Bit ist binär, d.h. es nur zwei unterschiedliche Werte haben: 0 oder 1.

Wenn wir gleichzeitig (parallel) 8 Bits haben, dann ist es ein Byte, das 256 Bitkombinationen von 00000000b bis 11111111b enhält, weil ein Bit (X) auf jeder Stelle 0 bzw. 1 sein kann.

<table border=0 cellpadding=3 cellspacing=2>

<tr>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
</tr>

<tr>
<td colspan=4 align=middle bgcolor=#007fff>High Nibble </td>
<td colspan=4 align=middle bgcolor=#ff8305>Low Nibble </td>
</tr>
<tr>
<td colspan=8 align=middle bgcolor=#810f40> Byte </td>
</tr>
</table>

Das "b" bedeutet, dass es sich um binäre (kurz: bin) Darstellung (auch Zahl genannt) handelt. Binäre Zahlen sind aber lang, weil jedes Bit eine Stelle benötigt.

Um die Schreibweise zu verkürzen, wurden hexadezimale (kurz: hex) Zahlen eingeführt. Zuerst wurde ein Byte auf zwei 4-Bit Halbbytes (Nibbles) verteilt und danach ein Nibble als Ziffer genommen. Weil 4 Bit mehr als 10 Kombinationen ergeben, haben die Ziffer 0 bis 9 aus dem Dezimalsystem (d) nicht ausgereicht und wurden um Buchstaben A bis F erweitert. Die hexadezimalen Zahlen haben ein "h" Zeichen am Ende. Für die Zahlen 0 bis 9 sind die (h) und
(d) Zeichen nicht nötig, da sie beide gleich den entsprechenden bin Zahlen sind.

Die Umwandlung zwischen bin, hex und dec Zahlen für ein Nibble zeigt folgende Tabelle:

0b = 0h = 0d 100b = 4h = 4d 1000b = 8h = 8d 1100b = Ch = 12d
1b = 1h = 1d 101b = 5h = 5d 1001b = 9h = 9d 1101b = Dh = 13d
10b = 2h = 2d 110b = 6h = 6d 1010b = Ah = 10d 1110b = Eh = 14d
11b = 3h = 3d 111b = 7h = 8d 1011b = Bh = 11d 1111b = Fh = 15d

Damit kann ein Byte mit zwei hex Ziffern definiert werden z.B. 1100 0011b = C3h. Für zwei Bytes braucht man 4 hex Ziffern z.B.

101 0111 1010 1001b = 57A9h, u.s.w. So wie im Dezimalsystem werden führende Nullen nicht geschrieben, aber in einem PIC Register existieren immer 8 Bits also auch führende Nullen. Zum Beispiel die hex Zahl 3h sieht im Register so aus: 00000011b. Bei einer Wandlung bin->hex fängt man immer von der rechten Seite der bin Zahl an, da die Anzahl führenden Nullen unbekannt ist.

== Speicher und Register ==

Als Speicher bezeichnet man den Teil der Hardware, in den eine Information geschrieben, gespeichert und von dort wieder ausgelesen werden kann.

Es gibt eigentlich nur zwei Arten von elektronischen Speichern: flüchtige und nichtflüchtige. Die Information die sich im flüchtigen Speicher befindet, geht verloren, wenn die Versorgungsspannung des Speichers unterbrochen oder abgeschaltet wird. Bei PICs ist es Dataspeicher (RAM).

Wenn die Versorgungsspannung vom nichtflüchtigen Speicher abgeschaltet wird, ist die gespeicherte Information zwar momentan nicht lesbar, bleibt aber erhalten und sobald der Speicher wieder mit Spannung versorgt wird, kann sie ausgelesen werden. Ein PIC hat zwei solche Speicher: Programmspeicher (Flash) und EEPROM.

Der wichtigste Unterschied zwischen den Speicherarten ist, dass die flüchtigen direkt (sehr schnell) beschreibbar sind, dagegen das Beschreiben des nichtflüchtigen Speichers spezielle Algorithmen benötigt, die im Vergleich zu direkten Zugriffen langsamer sind. Beim Auslesen gibt es praktisch keinen Unterschied.

Speicher besitzen eine bestimmte Menge von s.g. Speicherstellen. Jede Speicherstelle hat eine individuelle Adresse und kann eine binäre Information mit bestimmter Anzahl von Bits abspeichern.

PIC Prozessoren haben drei Arten von Speicher, wegen verschiedener Anwendung, auch unterschiedliche Struktur. Die beiden Speicher für Daten (RAM und EEPROM) haben jeweils 8 Bit Breite und Programmspeicher (Flasch) bei Mid-Range hat 14-bitige Speicherstellen. Die Anzahl den Speicherstellen im bestimmten Speicher ist vom PIC-Typ abhängig.

Eine 8-bitige Speicherstelle im RAM wird bei PICs Register genannt und kann so skizziert werden:

<table border=0 cellpadding=3 cellspacing=2>

<tr>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
</tr>

<tr>
<td> MSB </td>
<td colspan=6></td>
<td> LSB </td>
</tr>

<tr>
<td bgcolor="#007fff">bit 7</td>
<td bgcolor="#007fff">bit 6</td>
<td bgcolor="#007fff">bit 5</td>
<td bgcolor="#007fff">bit 4</td>
<td bgcolor="#007fff">bit 3</td>
<td bgcolor="#007fff">bit 2</td>
<td bgcolor="#007fff">bit 1</td>
<td bgcolor="#007fff">bit 0</td>
</tr>

<tr>
<td colspan=4 align=middle bgcolor=#ff8305>High Nibble </td>
<td colspan=4 align=middle bgcolor=#ff8305>Low Nibble </td>
</tr>
<tr>
<td colspan=8 align=middle bgcolor=#810f40> Byte </td>
</tr>
</table>

Bit 7 wird als hochwertigstes (MSB = Most Significant Bit) und bit 0 als niederwertigstes (LSB = Least Significant Bit) bezeichnet. Jedes Bit im Register (X) kann gleich 0 bzw. 1 sein.

Um ein Databyte in ein Register zu schreiben oder aus einem Register zu lesen, muss zuerst das Register durch seine Adresse gewählt werden. Dafür gibt es beim PIC folgende Möglichkeiten:

Direkte Adressierung per absoluter Adresse: movwf 0x20

Direkte Adressierung per vorher definiertem Namen des Registers (z.B. Temp equ 0x20): movwf Temp

Indirekte Adressierung durch "FSR" Register, in das die absolute Adresse des Registers "Temp" eingeschrieben wird und der Wert aus "Temp" sich im "INDF" Register befindet. Wie vorher wurde "Temp equ 0x20" definiert und weiter:

movlw Temp ;ins W-Register wird die absolute Adresse des Registers "Temp" geladen
movwf FSR ;diese Adresse wird ins "FSR" Register kopiert
movf INDF,0 ;der Wert aus dem indirekt adressierten Register "Temp", der sich jetzt
;im "INDF" befindet, wird ins W-Register geladen.

Weil in jedem 14-bittigen Befehl, der mit Datenspeicher verbunden ist, für die Adresse des ansprechenden Registers nur 7 Bits existieren, die bis zur Adresse 7Fh (128d) Register direkt ansprechen können, ist bei PICs der Datenspeicher (RAM) in s.g. Bänke verteilt.

Für Auswahl einer Bank sind zwei Bits "RP0" und "RP1" im "STATUS" Register zuständig. Die Anzahl der Bänke und ihre Verwendung ist von der gesamten Größe des RAMs abhängig und kann dem Datenblatt des PICs entnommen werden. Siehe: [[#Speicherbankorganisation|Speicherbankorganisation]]

== Prozessor ==

Der Prozessor von Mid-Range PICs gehört zu den RISC (Reduced Instruction Set Computer) Prozessoren und man hat nur 35 Befehle zu erlernen, was seine Programmierung im Vergleich zu anderen µCs deutlich vereinfacht. Jeder Befehl benötigt im Programmspeicher nur eine Speicherstelle und im Quellcode nur eine Zeile. Die Ausführung des Befehls dauert, abhängig vom Befehl, 1 bis 2 Prozessortakte.

Die Prozessoren der Mid-Range Serie von Microchip sind alle in der "Harvard"-Architektur gefertigt. Das bedeutet, dass Datenspeicher und Programmspeicher einen eigenen Bus zur CPU besitzen. Der Vorteil zur "von Neumann"-Architektur ist, dass sich die Busgrößen damit unterscheiden können. Das ermöglicht eine größere Bandbreite.

Der Befehl (beim PIC 14 bit) kann in nur einem Takt verarbeitet werden. Daher kommt auch das Aufteilen der Ausführung des Befehls in 4 verschiedene Vorgänge. Wärend der neue Befehl eingelesen ("fetch") wird, wird der vorige gerade gelesen ("read") und der vorvorige verarbeitet ("execute") und der vorvorvorige schreibt gerade in den Datenspeicher ("write"). Das heißt, 4 Befehle werden jeweils um einen Oszillatortaktzyklus verschoben gleichzeitig verarbeitet.

Das geschieht in vier Perioden des Oszillators. Deswegen entspricht die Taktfrequenz der CPU der durch 4 geteilten Frequenz des Oszillators.

CPU Vorgang Richtung Speicher
------------------------------------------------- -
1.Befehl lesen (fatch) <------- Flash |
2.Daten lesen (read) <------- RAM | 1 Prozessortakt =
3.Daten verarbeiten (execute) | 4 Oszillatortakte
4.Daten schreiben (write) -------> RAM |
-

Nur o.g. CPU Vorgänge sind direkt möglich. Es können deswegen keine Befehle aus dem RAM oder EEPROM ausgeführt werden. Um ein Databyte aus einem RAM Register in ein anderes zu kopieren, muss er zuerst aus dem ersten RAM Register in das W-Register (eigenen s.g. Arbeitsregister des CPU) und erst davon in das zweite RAM Register kopiert werden.

Das Lesen/Schreiben aus/in den EEPROM Speicher ist mit Hilfe speziellen Register und Unterprogrammen bei allen Mid-Range PICs möglich. Der Lese und Schreibzugriff auf den Programmspeicher ist aber nur bei wenigen PIC-Typen (z.B. PIC16F87X) möglich. Dies ermöglicht ein "sich selbst Programmieren", was bei Bootloadern genutzt wird.

== Assembler ==

Die Maschinensprache, auch Assembler oder kurz ASM genannt, ist eine Sprache die nur eine bestimmte CPU versteht. Für einen Menschen ist sie unverständlich, da sie nur aus 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 einen CPU hat somit ein "Namen", der aus der englischen Sprache stammt. Siehe: [[#Kurzübersicht Assembler Befehle|Kurzübersicht Assembler Befehle]]

Obwohl sie 200 bis 1000 mal schneller als die meisten Hochsprachen ist, wird sie, wegen des grossen Aufwands bei der Erstellung von umfangreichen Programmen, selten benutzt. Man findet sie aber oft in fast allen Hochsprachen, in eigebundenen Funktionen, überall dort wo die Hochsprachen zu langsam sind oder die nötigen Aufgaben nicht unterstützen (z.B. Maus in Q-Basic).

ASM eignet sich sehr gut für kleine Anwendungen (meistens Steuerungen) mit µC, weil nur bei dieser Programmiersprache ein direkter Zusammenhang zwischen einem Bit im Programm und einer Spannung am I/O Pin besteht.

Dank der integrierten oder an Portpins angeschlosenen Hardware und dem entsprechenden Program kann ein µC umfangreiche Aufgaben realisieren, die fast unbegrenzt und schwer vorstellbar sind.

Die Aufgabe eines ASM-Programmierers ist, ein Programm zu schreiben, das das Assemblerprogramm (z.B. MPASM) fehlerfrei in die Machinensprache assembliert ("übersetzt"), die dann eine bestimmte CPU "versteht". Sie endet eigentlich erst dann, wenn das geschriebene Programm so wie geplant funktioniert.

[[Bild:PAD_beispiel.png|thumb|80px|Beispiel für ein PAD]]

Weil ASM Programme nicht besonders durchschaubar sind, wurde als Hilfsmittel ein Programmablaufdiagramm (kurz: PAD) erfunden. Bei der 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 [http://gputils.sourceforge.net/ GPASM]) von dem für Menschen noch verständlichen Code in die Maschinensprache assembliert 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 Homepage des Herstellers von PICs [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en019469&part=SW007002] runtergeladen werden. Es muss zuerst vom Downloads die "MPLAB IDE v7.50 Full Zipped Installation" runtergeladen und erst danach können gewählte Programme (z.B. nur MPASM) intalliert werden. Für MPASM benutzer werden auch folgende .pdf Dateien empfohlen:

MPASM/MPLINK User's Guide (2628 KB) [Benutzerhandbuch]

MPASM™/MPLINK™ PICmicro® Quick Chart (81 KB) [Kurzübersicht]

Nach dem Eischalten der Betriebsspannung des µC, fängt der CPU an, sich im Programmspeicher befindliches Programm mit dem Befehl, der an der Adresse 0 steht, auszuführen.

Aber wann das Programm endet? Natürlich wenn die Versorgungsspannung abgeschaltet wird. Nein! Das ist die einfachste Lösung um ein laufendes Programm an zufälliger Stelle zu unterbrechen,
aber keine, um es an einer definierten Stelle zu beenden.

Wenn an den µC angeschlossene externe Hardware (z.B. Grafikdisplay), eine bestimmte Befehlsfolge vor dem Abschalten benötigt oder wichtige Daten (in EEPROM oder Flash) abgespeichert werden sollen, darf die Spannung erst dann abgeschaltet werden, wenn die CPU eine Meldung ausgibt, dass sie sich schon auf der "STOP" Stelle des Programms befindet. Es muss auch
definiert werden (z.B. durch eine Tastenkombination), wann die CPU zum letzten Fragment des ASM Programms vor dem "STOP" gehen soll.

== Grundbeschaltung ==

Der Prozessor von einem PIC kann sofort nach dem Einschalten der Versorgungsspannung (z.B. + 5V DC) arbeiten. Allerdings nur, wenn er den Takt, in dem er die Befehle ausführen soll, vorgegeben hat. Manche PICs besitzen einen internen RC-Oszillator, (z.B. PIC12F629, PIC16F630, PIC16F628, u.s.w.). Bei diesen reicht es bereits Spannung anzulegen und sie laufen bereits.
Die meisten haben ihn aber nicht (z.B. PIC16F84, PIC16F870, u.s.w.) und brauchen fürs Funktionieren zusätzliche Bauteile. Grundsätzlich gibt es mehrere Möglichkeiten:

* Quarz oder Keramik-Resonator + 2 Kondensatoren (LP,HS oder XT)
* Keramik-Resonator mit integrierten Kondensatoren (HS oder XT)
* Quarzoszillator (EC); genau und stabil
* Widerstand + Kondensator (RC); keine hohe Frequenzstabilität

Die entsprechenden Bauteile werden an die Pins OSC1/OSC2 angeschlossen, um den notwendigen Prozessortakt zu erzeugen. Im Konfiguration-Word "__config" muss noch angegeben werden, welcher Oszillator verwendet wird.

Desweiteren existiert ein MCLR-Pin, der beim PIC einen Neustart (=Reset) auslösen kann (Low-Pegel). Diesen Pin sollte man, wenn er in "__config" aktiviert ist, über einen Widerstand (pull-up) an Versorgungsspannung legen, damit der PIC anfängt, sein Programm abzuarbeiten. Der Anschluss wird auch für die Programmierung benötigt. Beim sog. High-Voltage-Programming wird MCLR auf ca. 12-14 Volt gelegt, um den PIC in den Programmiermodus zu schalten. Bei manchen PICs kann dieser Anschluss auch als normalen I/O Pin eingestellt werden. In dem Fall, bei ICSP Benutzung, soll noch eine Diode zwischen den pull-up und Versorgungsspannung angeschlossen werden, um die an MCLR Pin angeschlossene Hardware während der Programmierung zu schützen.

Bei externen Oszillatoren bleibt der Pin OSC2 nicht angeschlossen und kann als I/O benutzt werden. Falls ein interner Oszillator benutzt wird, können beide OSC Pins als I/O dienen.

Damit ein Programm zuverlässig ausgeführt werden kann, muss die Versorgungspannung störungsfrei sein. Dafür wird ein Keramik-Vielschicht-Kondensator 100 nF möglichts am kürzesten direkt zwischen VDD und VSS Pins geschaltet.

Folgende Skizzen zeigen die Grundbeschaltung eines PICs:

{|
|-
|
[[Bild:Pic-entstoer.png|thumb|160px|Entstörkondensator beim PIC]]
|
[[Bild:Qz-os.png|thumb|160px|Quarz ]]
|
[[Bild:Qos-os.png|thumb|160px|externer Quarzoszillator]]
|
[[Bild:Rc-os.png|thumb|160px|externer RC-Oszillator]]
|}

== Konfiguration ==

Die Konfiguration eines PICs wird beim "brennen" fest programmiert. Sie ist eigentlich für fast jeden PIC-Typ anders. Um Probleme zu vermeinden, muss sie für bestimmten PIC aus einer im MPASM Verzeichnis enthaltenen Datei "PXXFXX.INC" entnommen werden. Die Erklärung der Optionen befindet sich im entsprechenden Datenblatt unter "Special Features of the CPU"

Als Beispiel für PIC16F84 haben wir in der Datei "P16F84.INC":

;==========================================================================
;
; Configuration Bits
;
;==========================================================================

_CP_ON EQU H'000F'
_CP_OFF EQU H'3FFF'
_PWRTE_ON EQU H'3FF7'
_PWRTE_OFF EQU H'3FFF'
_WDT_ON EQU H'3FFF'
_WDT_OFF EQU H'3FFB'
_LP_OSC EQU H'3FFC'
_XT_OSC EQU H'3FFD'
_HS_OSC EQU H'3FFE'
_RC_OSC EQU H'3FFF'

Wobei:

_CP_ON - Programmspeicher ist vorm Auslesen geschützt
_CP_OFF - Programmspeicher kann ausgelesen werden (ist nicht geschützt)
_PWRTE_ON - Das Programm wird mit Verzögerung von ca. 72 ms nach dem Einschalten gestartet
_PWRTE_OFF - Das Program wird sofort nach dem Einschalten gestartet
_WDT_ON - Watchdog Timer ist aktiv
_WDT_OFF - Watchdog Timer ist unaktiv

Die alle folgende Optionen beziehen sich an den Oszillatortyp:

_LP_OSC - Oszillator bis ca. 200 kHz (z.B. Uhrenquarz 32768 Hz)
_XT_OSC - Oszillator bis ca. 3,5 MHz
_HS_OSC - Oszillator über 3,5 MHz (z.B. 4 MHz)
_RC_OSC - Externer RC Oszillator

Die Konfiguration wird im Quellcode (*.asm Datei) mit Direktive "__config" definiert, z.B. so:

LIST P=16F84
include "P16F84.inc" ; 4.000 MHz
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _XT_OSC

Alle Optionen müssen groß geschrieben sein, genauso wie in der "*.inc" Datei.

== Wahl des PICs ==

Es gibt PIC µC die in der Typenbezeichnung den Buchstaben "C" oder "F" haben.

Die älteren mit "C" haben EPROM Programmspeicher und die gibt es in zwei Versionen: ohne und mit Fenster (aus Quarz-Glass) fürs Löschen des EPROMs mit UV Strahlung. Bei denen ohne Fenster kann der Programmspeicher nur einmal beschrieben und nicht mehr gelöscht werden.

Die neuen mit "F" besitzen einen Flash-Programmspeicher, der bis zu 100 000 mal mit angelegter Spannung gelöscht und danach neu beschrieben werden kann.

Für die Wahl eines PICs für bestimmte Anwendung wichtig sind:

- Max. Taktfrequenz des Prozessors.

- Grösse des Datenspeichers (für Variablen).

- Grösse des Programmspeichers (für Programm).

- Integrierte Hardware (Komparatoren, A/D Wandler, Timer, USART, I²C, SPI, PWM, u.s.w.).

- Freie I/O Pins für externe Hardware (Display, Tasten, u.s.w.).

- Vorhandene Betriebspannung (Netzteil, Akku, Batterie).

In der Praxis wird meistens für die Programmerstellung ein grösserer PIC genommen (wenn möglich pinkompatibler z.B. PIC16F628 für PIC16F84 oder PIC16F630 für PIC12F629) und erst nach der Optimierung des lauffägiges Programms, der tatsächlich nötige, da seine Parameter am Anfang nur geschätzt werden können. Wenn man viele Programme für verschiedene PICs entwickelt, wäre der größte PIC16F877 mit 20 MHz max. Taktfrequenz optimal.

Diese Lösung hat auch den Vorteil, dass während der Programmerstellung kurze Hilfsprogramme (z.B. PIC Trainer) in den Programmspeicher kopiert und benutzt werden können, da sie sowohl ein bischen Programmspeicher und RAM als auch 2 freie I/O Pins fürs PIC Miniterminal brauchen.

= Programm =

== Allgemeines ==

Jedes Program kann man in kleinere Fragmente unterteilen, die auf bestimmte Weise miteinander verknüpft sind und gemeinsam die Aufgabe des Programms erfüllen. Das wichtigste Teil eines Programms ist das s.g. Hautprogram (kurz:HP), das eine führende Rolle spielt. Dem HP sind fast 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 komplizierter, da ein UP auch ein oder mehrere UPs nacheinander aufrufen kann. Ganz unten sind die UP1s, die ganz einfache Sachen erledigen. Höher ist 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 ohne Tricks maximal bis zu 8 Ebenen benutzt werden, da auf dem Stapel (stack) nur max. 8 Rücksprungadressen abgespeichert werden können. Siehe hierzu: [[#Programmspeicher|Programmspeicher]]

<center>
[[Bild:HP-UP.png|Hauptprogramm - Unterprogramm]]
</center>

Jedes UP kann jederzeit aufgerufen werden, je nach dem was gerade eledigt werden muss. Weil das nicht egal ist, welches UP aufgerufen wird, da jedes nur eine bestimmte Funktion im Programm hat, muss der Programmierer dafür sorgen, dass alles richtig nach Programablaufdiagramm, und nicht chaotisch, abläuft.

Die Programmierung in ASM ist ähnlich 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 Programm kopieren und ein geeignetes HP, das sie aufruft, schreiben.

Ein ASM Programm (Quellcode) muss in einer Texdatei mit der Endung .asm in der vom Assemblerprogramm erwarteten Form verfasst werden, um die fehlerfreie Konvertierung in die Maschinensprache (Assemblierung) zu gewährleisten. Dieser Prozess verläuft in der Form eines Dialoges.

Der Programmierer schreibt und gibt es dem Assemblerprogram zum Übersetzen. Alles was der Assembler nicht versteht oder nicht richtig ist, erscheint als Fehlermeldungen, die der Programmierer kennen muss um die Fehler korrigieren zu können. Eine .hex Datei wird erst dannn erstellt, wenn das Assemblerprogramm keine Fehler mehr im Quellcode findet. Deswegen ist es sehr wichtig, sich mit dem Assemblerprogramm vertraut zu machen, um die Dialogzeit zu minimieren.

== Programmdurchlaufdiagramm ==

Der Programdurchlaufdiagram (kurz: PAD) ist eine vorläufige und laufend änderbare Stufe zwischen einer Idee und ihrer Verwirklichung. Er wird erst dann fertig, wenn nach ihm erstelltes ASM Program auf einem µC so wie gewünscht funktioniert. Jedes sein Symbol (ausser "Start/Stop") muss später als Befehlsreihenfolge für den bestimmten CPU in den Quellcode übertragen werden. Die Anschriften "Ein" und "Aus" gehören nicht zu Symbolen des PADs und wurden nur zur Erklärung benutzt.

Der PAD ist sehr eifach zu erstellen, weil dafür nur drei Symbole benötigt sind:
<center>
[[Bild:PAD_kurz.png|Symbole des PAD]]
</center>
Das "Start/Stopp" Symbol bedeutet, dass das gesamte Programm sich im stabilen Zustand befindet und nicht "läuft". Anstatt "Stopp" kann auch "Schlaf" (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 eines Programms, endweder in der "ja" (J) oder "nein" (N) Richtung.

Als allgemeinnutziges Standard für µCs kann man folgender PAD bezeichnen:

PAD _____
/ \
Spannung ein (Ein) ----->( Start )
\_____/
| -
V |
.---------------. |
|Initialisierung| |
'---------------' |
| |
.--------->V |
| .---------------. |
| | Hauptprogramm | |
| '---------------' |
| | |
| V |
| A |
| / \ > Gesamtes Programm
| / \ |
| /Ende \____ |
| \ ? / J | |
| \ / | |
| \ / | |
| V | |
| N| | |
`----------´ | |
V |
.---------------. |
| Beenden | |
'---------------' |
| |
V -
_____
/ \
Spannung aus (Aus) <-------------( Stopp )
\_____/

Das Hauptprogram wird in einer endlosen Schleife ausgeführt, die durch die Prüfung "Ende?" unterbrochen werden kann. In dem Fall wird vor dem Beenden des gesammten Programms noch ein UP "Beenden" ausgeführt, das z.B. Daten im EEPROM speichert.

Es ist nicht nötig, immer die Symbole zu zeichnen, man kann sie sich vorstellen und nur den Text schreiben. Die Prüfungen werden mit "?" gekenzeichnet und die Zeichen "V", "A", "<" und ">" zeigen die Richtung des weiteren Verlaufs. Dann sieht der PAD so aus:

Ein > Start
V -
Initialisierung |
.------->V |
| Hauptprogramm > Gesamtes Programm
| V |
| Ende? J > Beenden |
| N V -
| V Stopp > Aus
`--------´

Man kann auch die unbedeutenden Richtungspfeile weg lassen:

PAD1 Ein > Start _
Initialisierung |
.------->V | Gesamtes
| Hauptprogramm | Programm
| Ende? J > Beenden _|
| N Stopp
| V V
`--------´ Aus

In der Praxis werden aus Platzgründen meistens die vereinfachten PADs benutzt. Als "movxx" wird oft ein Zeichen "->" benutzt. Zum Beispiel "A->W" bedeutet, dass der Inhalt des A Registers ins W-Register geladen (kopiert) wird. Ausserdem werden Zeichen ("+", "-", "*", "/", "^", u.s.w.) für arithmetische und ("&", "or", "xor", u.s.w.) für logische Operationen angewendet. In den Quellcode werden für diese Zeichen entsprechende Befehle geschrieben. Beispiel:

V
10h->W
W+B->B
V

wird im Quelcode so aussehen:

...........
movlw 10h
addwf B,1
...........

Der PAD1 kann aber für Hauptprogramme, die in beliebigem Moment unterbrochen werden dürfen, deutlich vereinfacht werden, da die Prüfung "Ende?" ob das Hauptprogram beendet werden soll, und das UP "Beenden", entfallen.

Die meisten ASM Programme für µC sind deswegen nach solchem PAD erstellt:

PAD2 Ein > Start _
Initialisierung |
.------->V |
| Hauptprogramm > Gesamtes Programm
| V |
`--------´ _|

Für Testprogramme wird meistens fogender PAD angewendet, weil es ziemlich einfach festzustellen
ist (z.B. durch Stromverbrauchmessung des µCs), wann sich die CPU schon im Schlaf befindet. Erst dann, darf die Betriebspannung des µCs ausgeschaltet werden.

PAD3 Ein > Start _
Initialisierung | Gesamtes
Hauptprogramm _| Programm
Schlaf > Aus

Und eine batteriebetriebene Uhr wird überwiegend so gestaltet:

PAD4 Ein > Start _
Interrupt Initialisierung |
Timer------------------------->V > Gesamtes Programm
Hauptprogramm _|
Schlaf

In dem Fall reicht es aus, wenn der CPU jede Minute vom Timer aufgeweckt wird, um die Zeit zu aktualisieren. Eine Uhr ist immer (ausser Batteriewechsel) ununterbrochen mit Spannung versorgt.

Für komplizierte Programme ist es unmöglich ein PAD zu erstellen, in dem jeder CPU Befehl sein eigenes Symbol hat. Man beschränkt sich nur auf alle Prüfungen, die über den Lauf des Programms entscheiden, und ganze UPs (z.B. "Initialisierung") nur als ein Symbol verwendet. Für jedes UP wird dann ein eigener PAD erstellt.

Das Erstellen von PAD bei ASM Programmen ist sehr wichtig und darf nicht unterschätzt werden. Je stärker ein Programmierer glaubt, dass er das ohne PAD schafft, um so mehr Zeit wird er danach bei Fehlersuche oder Änderungen im ASM Programm verlieren.

Beispiel aus dem Alltag:

"Das programm hat anfangs auf Anhieb funktioniert. Doch leider habe ich dann was geändert was ich nicht mehr weiß. Das Programm macht nun komische Sachen...... Ich kann mir nicht erklären warum, kann mir jemand helfen???"

Für einfache ASM Programme, die gut kommentiert sind, reicht es meistens aus, ein PAD nur "im Kopf" zu erstellen, aber ganz ohne PAD geht es sicher nicht.

Wenn ein ASM Programm nicht wie geplannt funktioniert, wird zuerst ein Fehler im PAD gesucht. Und erst wenn er i.O. ist, im als fehlerhaft festgestellten Codefragment.

== Hauptprogramm ==

Wie sein Namen schon vermuten lässt, ist das Hauptprogram das wichtigste Teil des gesamten Programms. Meistens ist es auch das kleinste Teil, vor allem, wenn die UPs sehr komplex sind. Seine Aufgabe ist die benötigte UPs in bestimmter Reihenfolge nacheinander aufzurufen, um die alle Funktionen des gesamten Programms zu realisieren.

Das HP ist meistens als endlose Schleife, wie im PAD2, aufgebaut. Weil die endlose Schleife sehr schnell läuft, werden alle durch die UPS realisierten Aufgaben quasi gleichzeitig ausgeführt. Wenn es unerwünscht ist, müssen einige UPs als Verzögerungen realisiert werden.

Typischer PDA für ein HP sieht so aus:

Haupt .--->V
| UP1
| UP2
| ...
| UPn
| V
`----´

In den Quellcode wird es so eigeschrieben:

Haupt call UP1
call UP2
...........
call UPn
goto Haupt

In der Praxis wird das HP schrittweise erstellt. Am Anfang wird sich nur ein UP im HP befinden und die folgenden kommen nach dessen Erstellung und Prüfen dazu, bis das HP fertig wird.

== Unterprogramm ==

Unterprogramm wird durch übergeordnetes Programmteil (Aufrufer) aufgerufen und nach seinem Ausführen, wird zurück zum Aufrufer gesprungen. Der Rückkehr zum Aufrufer wird durch "return" Befehl, der sich am Ende jedes UPs befinden muss, erreicht. Und das ist der einzige Unterschied zwischen einem HP und einem UP.

Jedes UP hat folgender PAD:

vom Aufrufer ------------>V
Tun
zurück zum Aufrufer <----------return

Ein HP von einem ASM Programm kann in anderem, mehr umfangreichem ASM Program als UP benutzt werden, wenn der sich am Ende des HPs befindlicher Befehl "goto" durch "return" ersetzt wird. Ein Beispiel dazu:

Haupt1 call UP11 Haupt1 call UP11
call UP21 call UP21
........... -------> ...........
call UPn1 call UPn1
goto Haupt1 return

Jetzt können wir im mehr komplexen HP (Haupt) das Haupt1 als Unterprogramm aufrufen:

Haupt call UP1
call Haupt1
...........
call UPn
goto Haupt

Jedes UP kann auch von einem anderen übergeordneten UP aufgerufen werden, wenn das was es realisiert, benötigt wird.

In der Praxis wird oft ein UP von mehreren anderen UPs benutzt. Zum Beispiel um LCD Display zu steuern, brauchen wir entweder ein Befehl (Cmd) oder ein Zeichen (Data) an Display zu schicken. In beiden Fällen wird ein Byte geschickt, einmal mit RS=0 (Befehl) und einmal mit RS=1 (Zeichen) laut folgendem PDA:

"Cmd" "Data"
RS=0 RS=1
V V
`-->V<--´
"Send" Byte schicken
return

Das wird in den Quellcode z.B. so eingeschrieben:

Cmd bcf RS
goto Send
Data bsf RS
Send ............
return

Das UP "Send" ist den UPs "Cmd" und "Data" untergeordnet, da es von beiden benutzt wird, kann aber weder "Cmd" noch "Data" benutzen.

=== Initialisierung ===

Damit der PIC ein Programm asführen kann, muss er vollständig und richtig initialisiert werden. Deswegen als erstes UP, das von dem gesamten Programm noch vor dem HP aufgerufen wird , ist "Initialisierung" (kurz: Init)

==== Variablen ====

Weil sich nach dem Einschalten der Spannung im RAM zufällige Werte befinden, wird meistens als erstes der benutzte Bereich des RAMs (z.B. 20h bis 7Fh) gelöscht. Es wird einfach und sparsam mit einer Schleife erledigt, die indirekte Adressierung verwendet:

V
Adresse des ersten Registers in FSR laden (20h)
.-------------------->V
RAMClr |Indirekt adressierter Register löschen (INDF)
| Adresse erhöhen
| Letzte Adresse + 1 (80h) J > Return
| N
| V
`---------------------´

Es wird wie folgt in Quellcode eingeschrieben:

movlw 0x20
movwf FSR
RAMClr ,->clrf INDF
| incf FSR,1
| btfss FSR,7
`-<goto RAMClr
return

Um Anzahl den Marken (label) zu verringern, wird oft ein Symbol "$" benutzt. Es bedeutet die Adresse der aktuellen Befehlszeile. Es kann also auch so eingeschrieben werden:

movlw 0x20
movwf FSR
,->clrf INDF
| incf FSR,1
| btfss FSR,7
`-<goto $-3 ; springe zu aktueller Adresse -3
return

Danach können den benötigtenen Variablen die gewünschte Werte zugewiesen werden:

movlw 0x3C
movwf LimH
movlw 0x5A
movwf LimL
u.s.w.

Somit sind die Variablen initialisiert.

==== I/O Ports ====

Nach dem Einschalten der Spannung sind die für Komparatoren oder A/D Wandler benutzte Pins als analoge Eingänge initialisiert. Wenn sie alle als digitale I/Os verwendet werden sollen, müssen sie als solche definiert werden. Das geschieht durch Schreiben des Wertes 7 in das entsprechende Register (CMCON bzw. ADCON1):

movlw 7 b.z.w. movlw 7
movwf CMCON movwf ADCON1

Wenn einige als analoge Eingänge benutzt werden sollen, müssen die entsprechende Werte dem Datenblatt des jeweiligen PICs entnommen werden.

Danach werden alle Ports nacheinander gelöscht und die gewünschte Werte die an den Pins vor dem Start des Hauptprogramms ausgegeben werden sollen, geschrieben:

clrf PORTA
movlw 0x37
movwf PORTA
usw.

Anchliessend werden für jeden Port die Werte in TRIS Register eingeschrieben, wobei ein Bit einem Pin entspricht. Ein Pin wird in TRIS Register durch 1 als Eingang und durch 0 als Ausgang definiert. Beispielweise beim PORTB sollen B7,B5 und B3 als Eingänge und restliche Pins als Ausgänge definiert werden. Das ergibt den Wert 10101000b = A8h, der in den TRISB Register geschrieben werden muss. Weil die alle TRIS Register sich in der Bank1 befinden, muss im STATUS-Register auf Bank1 und danach zurück auf Bank 0 umgeschaltet werden:

bsf STATUS,RP0
movlw 0xA8
movwf TRISB
bcf STATUS,RP0

Bei einem Umschalten der Bank können selbstverständlich alle TRIS Register nacheinander beschrieben werden.

Bei dem PORTA gibt es Pins, die nur "open drain" Ausgang haben (können nur auf GND schalten) b.z.w. nur als Eingang benutzt werden können. Bei Plannung der Verwendung von PORTA muss immer im Datenblatt geprüft werden, ob sich ein bestimmter Pin für die geplannte Anwendung eignet.

==== Hardware ====

Die für ASM Programm benutzte Hardware kann auf integrierte und externe geteilt werden. Für eine Initialisierung der integrierten Hardware (Komparatoren, A/D Wandler, Timer, USART, I²C, SPI, PWM, u.s.w.), müssen entsprechende SFRs (Spezial Function Registers) laut Datenblatt des PICs definiert werden.

Die externe Hardware muss nach Datenblättern der Herstellern initialisiert werden.

=== Einlesen ===

Um ein Bit von einem Portpin einzulesen und in ein bestimmtes Register zu Kopieren wird folgender PAD benutzt, weil ein PIC kein Befehl dafür hat:

V
Bit im Zielregister löschen
Quellbit = 0 ? J >------.
N |
V |
Bit im Zielregister setzen |
V<-------------´

Wenn wir z.B. ein bit3 von PortA als bit1 in den Register Tasten kopieren wollen, dann wird es in Quellcode so geschrieben:

bcf Tasten,1
btfsc PORTA,3
bsf Tasten,1

Wenn ein ganzes Byte vom Port in das W-Register eingelesen wird, kann man den Wert gleich komplett in das Zielregister schreiben.

=== Ausgeben ===

Um ein Bit an einem Portpin auszugeben wird ein bestimmtes Bit mit "bcf" gelöscht oder mit "bsf" gesetzt. Zum Beispiel bit4 im PORTA:

bcf PORTA,4.

Um ein Byte auszugeben wird es zuerst in das W-Register geladen und danach an den Port übergeben, z.B.:

movlw 0x12
movwf PORTA

=== Schleifen ===

Ein in ASM Programmen meist verbreitetes Codefragment ist eine Schleife.

Es kann eine endlose Schleife, die durch Prüfung einer bestimmten Bedingung (z.B. Taste) unterbrochen wird, sein:

V<-----.
Tun |
? N >--´
J
V
weiter

Es kann eine Schleife mit Schleifenzähler (z.B. Temp), die bestimmte Anzahl Durchläufe hat, sein:

V
Anzahl ins Temp laden
V<---------.
Tun |
Temp decrementieren |
Temp = 0 ? N >--´
J
V
weiter

Solche Schleifen können als UPs verwendet werden, wenn "weiter" mit "return" ersetzt wird.

Das waren Beispiele für Schleifen, die bewusst programmiert sind. Es gibt leider auch endlose Schleifen, die durch einen Fehler im Programm enstanden sind und zum "hängen" des Programms führen. Solche Schleifen sind im Programm nicht einfach zu finden, da ihre Parameter unbekannt sind.

=== Pause ===

Um eine Pause (Warten, Verzögerung) im Programm anzulegen wird der "nop" Befehl benutzt, während dessen Ausführung der CPU nichts macht. Mit einem "nop" kann eine Zeit gleich 4 Takten (Perioden) des Oszillators realisiert werden.

Für sehr kurze Wartezeiten benutzt man eine Reihe von nachfolgenden "nop"s. Beim einem Oszillator 4 MHz, die Ausführungszeit des Prozessors beträgt 1 µs pro "nop". Wenn z.B. 4 µs benötigt werden, werden dafür 4 "nop"s gebraucht:

...
nop
nop
nop
nop
...

Das gleiche bewirken 2 "goto"s, brauchen aber im Vergleich zu "nop"s nur die Hälfte der Bytes im Programmspeicher:

...
goto $+1
goto $+1
...

Der Befehl goto $+1 bedeutet "springe zur aktuellen Adresse + 1" (also nächster Adresse) und seine Ausführungszeit ist gleich 2 Prozessortakten.

Für kurze Zeiten werden s.g. Warteschleifen, wie im folgendem PAD benutzt:

V
n * nop
P0 laden
V<---------.
P0 decrementieren |
P0 = 0 ? N >--´
J
V

In Quellcode wird es als UP so eigeschrieben:

Warte nop Warte nop
... ...
nop nop
movlw 0xXX movlw 0xXX
movwf P0 movwf P0
Warte0 decfsz P0,1 decfsz P0,1
goto Warte0 goto $-1
return return

Der Sprung zur Marke "Warte0" ("goto Warte0") wurde in rechtem Beispiel durch "goto $-1" ersetzt.

Die gesammte Anzahl den CPU Takten (N) lässt sich aus folgender Formel berechnen:

N = 3 * P0 + 6 + n

und die Wartezeit (T) in Sekunden:

T = N * ( 4 / Fosc ), für Schätzungen T ~ 3 * P0 * ( 4 / Fosc )

Wobei:

P0 = Zahl im Register P0, 6 = Ausführungszeit von "call" (2) + "movlw" (1) + "movwf" (1) + "return" (2), n = Anzahl "nop"s, Fosc = Frequenz des Oszillators (z.B. Quartz)

Wenn in ein Register PX eine 0 eingeschrieben wird, bedeutet es, dass die decrementierung des Registers 100h = 256d Takten dauern wird, da dekrementierte 0 eine FFh = 255d ergibt. Deshalb in Warteschleifen ist die Zahl 0 die grösste und 1 die kleinste. Für solche einfache Schleifen (als UP) die Wartezeit beträgt min. 9 und max. ca. 800 Prozessortakten (ohne "nop"s).

Für mittlere Wartezeiten z.B. 0,1 Sekunde werden doppelte Warteschleifen verwendet:

Warte V
n * nop
P1 laden
Warte1 V<-------------.
P0 laden |
Warte0 V<---------. |
P0 decrementieren | |
P0 = 0 ? N >--´ |
J |
V |
P1 dekrementieren |
P1 = 0 ? N >------´
J
V

Das wird in Quellcode als UP so aussehen:

Warte nop Warte nop
... ...
nop nop
movlw 0xXX movlw 0xXX
movwf P1 movwf P1
Warte1 movlw 0xXX movlw 0xXX
movwf P0 movwf P0
Warte0 decfsz P0,1 decfsz P0,1
goto Warte0 goto $-1
decfsz P1,1 decfsz P1,1
goto Warte1 goto $-5
return return

Wie vorher wurden rechts die Marken durch "$-n" ersetzt.

Die gesammte Anzahl den CPU Takten (N) lässt sich aus folgender Formel berechnen:

N = P1 * (3 * P0 + 5) + 8 + n

und die Wartezeit (T) in Sekunden:

T = N * ( 4 / Fosc ), für Schätzungen T ~ 3 * P1 * P0 * ( 4 / Fosc )

Wobei:

P0 = Zahl im Register P0, P1 = Zahl im Register P1, 8 = Ausführungszeit von "call" + "return" + 2 * ("movlw" + "movwf"), n = Anzahl "nop"s, Fosc = Frequenz des Oszillators (z.B. Quartz)

Für solche doppelte Schleifen (als UP) die Wartezeit beträgt min. 16 und max. ca. 200 000 Prozessortakten (ohne "nop"s).

Für lange Wartezeiten z.B. 1 Sekunde werden 3-fache Warteschleifen angewendet.

Solche Warteschleife ist im folgenden PAD abgebildet:

Warte V
n * nop
P2 laden
Warte2 V<-----------------.
P1 laden |
Warte1 V<-------------. |
P0 laden | |
Warte0 V<---------. | |
P0 decrementieren | | |
P0 = 0 ? N >--´ | |
J | |
V | |
P1 decrementieren | |
P1 = 0 ? N >------´ |
J |
V |
P2 dekrementieren |
P2 = 0 ? N >----------´
J
V

Das wird in Quellcode als UP so aussehen:

Warte nop Warte nop
... ...
nop nop
movlw 0xXX movlw 0xXX
movwf P2 movwf P2
Warte2 movlw 0xXX movlw 0xXX
movwf P1 movwf P1
Warte1 movlw 0xXX movlw 0xXX
movwf P0 movwf P0
Warte0 decfsz P0,1 decfsz P0,1
goto Warte0 goto $-1
decfsz P1,1 decfsz P1,1
goto Warte1 goto $-5
decfsz P2,1 decfsz P2,1
goto Warte2 goto $-9
return return

Auch hier wurden rechts die Marken durch "$-n" ersetzt.

Die gesammte Anzahl den CPU Takten (N) lässt sich aus folgender Formel berechnen:

N = P2 * [ P1 * (3 * P0 + 5) + 9 ] + 10 + n

und die Wartezeit (T) in Sekunden:

T = N * ( 4 / Fosc ), für Schätzungen T ~ 3 * P2 * P1 * P0 * ( 4 / Fosc )

Wobei:

P0 = Zahl im Register P0, P1 = Zahl im Register P1, P2 = Zahl im Register P2, 10 = Ausführungszeit von "call" + "return" + 3 * ("movlw" + "movwf"), n = Anzahl "nop"s, Fosc = Frequenz des Oszillators (z.B. Quartz)

Für solche 3-fache Schleifen (als UP) die Wartezeit beträgt min. 27 und max. ca. 50 000 000 Prozessortakten (ohne "nop"s).

Die "nop"s in allen Warteschleifen sind nur notwendig um genaue Wartezeit einzustellen zu können. Sie können auch mit "goto $+1"s ersetzt, oder weg gelassen werden.

Anstatt "movlw 0xXX" kann auch "movf PauseX,0" angewendet werden, wenn die Schleife mehrmals mit verschiedenen Werten P0, P1 und P2 aus den Register Pause0, Pause1 und Pause2 benutzt wird.

Für sehr lange Wartezeiten können, nach gleichem Prinzip, Warteschleifen erstellt werden, die mehr als 3 Schleifen enthalten.

=== Tabellen ===

Es gibt zwei Arten von Tabellen: Sprungtabellen (computed goto) die "goto" Befehle enthalten und Wertetabellen (lookup table) in denen feste Werte in "retlw" gespeichert sind. Der wichtigste Unterschied zwischen dennen ist, dass die Sprungtabellen steuern den Programlauf abhängig vom Inhalt des W-Registers und die Wertetabellen liefern abhängig von Inhalt des W-Registers ein Wert an den Aufrufer zurück.

Beide werden in Programmspeicher erstellt. Sie können nur bis zu 256 Speicherstellen belegen, da in den W-Register auch nur so viel veschiedenen Zahlen "passen". Sie Fangen also (fast) immer bei einer Adresse XX00h an und enden bei XXFFh. Der Hochwertige Byte "XX" der Adresse an der sich der Anfang einer Tabelle befindet, muss vor dem Einsprung in die Tabelle ins PCLATH Register eingeschrieben werden, wenn die Tabelle weit vom Aufrufer liegt. In der Praxis werden solche Tabellen am oberen Ende des Programmspeichers angelegt, damit sie den ASM Code nicht unterbrechen.

Eine Sprungtabelle wird so aufgebaut:

org (XX-1)FF <--- eine Direktive für Assemblerprogramm, wo es
die Tabelle im Programmspeicher plazieren soll
Adresse Inhalt
-------------------------
Tab1 (XX-1)FF addwf PCL,1
XX00 goto Marke0
XX01 goto Marke1
.......................
XXFE goto Marke254
XXFF goto Marke255

Und so aufgerufen:

movlw 0xXX
movwf PCLATH
movf TWert,0
call Tab1

Wobei:

0xXX = Hochwertiger Byte der Adresse von Tab1, TWert = ein Wert, der die Wahl wohin gesprungen wird bestimmt

Nach ausführen der obiger Befehlsfolge, wird das ASM Programm z.B. für Twert=0x01 weiter ab Marke1 "laufen" bis es an "return" kommt. Dann springt es zurüch zum Aufrufer der Tabelle.

Eine Wertetabelle wird so aufgebaut:

org (XX-1)FF <--- eine Direktive für Assemblerprogramm, wo es
die Tabelle im Programmspeicher plazieren soll
Adresse Inhalt
-------------------------
Tab1 (XX-1)FF addwf PCL,1
XX00 retlw Wert0
XX01 retlw Wert1
.......................
XXFE retlw Wert254
XXFF retlw Wert255

Und so aufgerufen:

movlw 0xXX
movwf PCLATH
movf TWert,0
call Tab1

wobei:

0xXX = Hochwertiger Byte der Adresse von Tab1, TWert = ein Wert, für welchen, an den Aufrufer bestimmter Wert aus der Tabelle im W-Register zurückgeliefert wird

Wertetabelle kann auch mit Hilfe der MPASM Direktive "dt" erstellt werden. So kann man sich mehrfaches Schreiben von "retlw" Befehlen ersparen:

org 0x(XX-1)FF
Tabelle addwf PCL,1
; nachfolgend der benötigte Wert im W- Register
; vor dem Aufruf der Tabelle
dt 0x03, 0xE8 ; 0x00
dt 0x03, 0xE8 ; 0x02
dt 'M','H','z',0x00 ; 0x04
dt ' ',' ','W','A','I','T',0x00 ; 0x08
dt 'C','o','n','s','t',' ','X',0x00 ; 0x0F
dt 'C','=',0x00 ; 0x17
dt 'L','=',0x00 ; 0x1A
dt 'F','=',0x00 ; 0x1D
dt 'O','K',0x00 ; 0x20
u.s.w.

Das Lesen eines Strings muss ab entsprechendem Wert im W-Register (z.B. für "MHz" -> 0x04) anfangen und auf dem Wert 0x00 enden, der hier als Stringende dient. Einfacher ist, wenn alle Strings gleich lang sind (wie z.B. in einem Zeichengenerator fur Grafikdisplay).

=== Schnittstellen und Treiber ===

Als Schnittstelle wird externe Hadware, die zum steuern eines an sie angeschlossenes "Gerätes" dient, genannt. Das ASM Programm, das die Steuerung ermöglicht ist ein Treiber. Als Beispiele siehe: [[http://www.roboternetz.de/phpBB2/viewtopic.php?t=13685]] und [http://www.roboternetz.de/phpBB2/viewtopic.php?t=22749]

== Vorlage für MPASM ==

Diese Vorlage ist nur für ASM Programme ohne Interrupts geeignet:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration
#define _DTT1 GPIO,0 ; Portpins benennen
#define _CKT2 GPIO,1
#define _T3 GPIO,2
#define _RNG GPIO,3
#define _INT GPIO,4
#define _RL GPIO,5
u.s.w.
SecondL equ 0x20 ; Variablen definieren (Register benennen)
SecondH equ 0x21
MinuteL equ 0x22
MinuteH equ 0x23
StundeL equ 0x24
StundeH equ 0x25
u.s.w
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
Haupt ............ ; hier fängt das Hauptprogramm als endlose Schleife an
Eigener Code
............
goto Haupt ; hier endet das HP, gehe zum Anfang des HPs (zurück)
UP1 ............ ; Unterprogramme
Eigener Code
............
return
############
UPn ............
Eigener Code
............
return
Init clrf GPIO ; lösche Port
bsf STATUS,RP0 ; auf Bank1 umschalten
call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; kalibriere internen RC oscillator
bcf OPTION_REG,7 ; aktiviere pull-ups
movlw 0x38 ; definiere Portpins GPIO, (z.B. 0-2 Aus- und 3-5 Eingänge)
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
movlw 7 ; schalte Komparator aus
movwf CMCON ; und definiere GPIO 0-2 als digitale I/Os
............
eigener Code
............
return ; springe zurück (zum Haupt)
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

Die Variablen können auch kürzer mit s.g. cblock definiert werden:

cblock 0x20
SecondL
SecondH
MinuteL
MinuteH
StundeL
StundeH
endc

Bei sehr vielen Variablen sind aber die Registeradressen nicht so übersichtlich.

Für Programme mit Interrupts ist diese Vorlage geeignet:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration
#define _DTT1 GPIO,0 ; Portpins benennen
#define _CKT2 GPIO,1
#define _T3 GPIO,2
#define _RNG GPIO,3
#define _INT GPIO,4
#define _RL GPIO,5
u.s.w.
SecondL equ 0x20 ; Variablen definieren (Register benennen)
SecondH equ 0x21
MinuteL equ 0x22
MinuteH equ 0x23
StundeL equ 0x24
StundeH equ 0x25
u.s.w
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
goto Haupt ; gehe zum Hauptprogramm "Haupt"
org 0x004 ; hier fängt die ISR (interrupt service routine) an
.............
Eigener Code
.............
retfie ; hier endet die ISR
Haupt ............ ; hier fängt das Hauptprogramm als endlose Schleife an
Eigener Code
............
goto Haupt ; hier endet das HP, gehe zum Anfang des HPs (zurück)
UP1 ............ ; Unterprogramme
Eigener Code
............
return
############
UPn ............
Eigener Code
............
return
Init clrf GPIO ; lösche Port
bsf STATUS,RP0 ; auf Bank1 umschalten
call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; kalibriere internen RC oscillator
bcf OPTION_REG,7 ; aktiviere pull-ups
movlw 0x38 ; definiere Portpins GPIO, (z.B. 0-2 Aus- und 3-5 Eingänge)
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
movlw 7 ; schalte Komparator aus
movwf CMCON ; und definiere GPIO 0-2 als digitale I/Os
............
eigener Code
............
return ; springe zurück (zum Haupt)
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

== Das erste... ==

Hier wird detailiert das ganze Prozess der Erstellung eines ASM Programms beschrieben. Die Idee:

Es gibt 4 LEDs (_L1, _L2, _L3 und _L4), die mit 2 Tastern gesteuert werden sollen. Nach dem Einschalten soll keine LED leuchten. Solange der linke Taster (_T1) gedrückt ist, sollte eine leuchtende LED von links nach rechts "wandern" und von der letzten rechten Position wieder nach ganz linke "springen". Solange der rechte Taster (_T2) gedrückt ist, sollte eine leuchtende LED von rechts nach links "wandern" und von der letzten linken Position wieder nach ganz rechte "springen". Solange beide Taster gedrückt sind soll die leuchtende LED von links nach rechts und zurück "wandern".

Dafür nötige Hardware zeigt folgende Skizze:

.-----------------------------------------------.
| |
| PIC12F629 |
| |
| GPIO,3 GPIO,4 GPIO,5 GPIO,2 GPIO,1 GPIO,0|
'-----------------------------------------------'
4| 3| 2| 5| 6| 7|
| | .-. .-. .-. .-.
| | R | | R | | R | | R | |
| | 470| | 470| | 470| | 470| |
| | '-' '-' '-' '-'
\ o \ o | | | |
\ \ V -> V -> V -> V ->
\. \. - - - -
_T1 o _T2 o _L1 | _L2 | _L3 | _L4 |
| | | | | |
+-------+-------+---+---+-------+-------+
|
===
GND

Weil der Pin 4 (GPIO,3) nur einen "open drain" Ausgang hat (kann nur an GND schalten), wird er hier als Eingang benutzt.

Jetzt muss die Idee vom Programmierer in ein PAD verfasst werden, z.B. solcher:

Start
Initialisierung
.-------------->V
| _T1=0 gedrückt ? N >----.
| J |
| V |
| links->rechts "wandern" |
| V<------------´
| _T2=0 gedrückt ? N >----.
| J |
| V |
| rechts->links "wandern" |
| V<------------´
`---------------´

danach detailierter:

Start
Initialisierung
V<-------------------------------------------.
_T1=0 gedrückt ? N >---+--->_T2=0 gedrückt ? N >---+---´
J A J A
V | V |
_L1 an | _L4 an |
Warten | Warten |
_L1 aus | _L4 aus |
_L2 an | _L3 an |
Warten | Warten |
_L2 aus | _L3 aus |
_L3 an | _L2 an |
Warten | Warten |
_L3 aus | _L2 aus |
_L4 an | _L1 an |
Warten | Warten |
_L4 aus | _L1 aus |
V | V |
`------------´ `------------´

Zuerst wird im MPASM Verzeichnis ein neuer Verzeichniss (z,B. "PIC Programme") angelegt und in dem Verzeichniss neue Textdatei (z.B. "Erstes.txt") erstellt. Als nächstes wird die "Vorlage für MPASM" dorthin kopiert.

Danach müssen, die im Programm benutzte Portpins und Register mit "#define" und "equ" definiert werden.

Als Initialisierung wird das UP "Init" aus der Vorlage für MPASM mit geändertem "TRISIO" Wert (0x18) übernommen. Siehe: [[#Vorlage für MPASM|Vorlage für MPASM]]

Fürs "Warten" wird eine dreifache Warteschleife verwendet. Siehe: [[#Pause|Pause]]

Die Taster werden mit "btfsc" Befehl geprüft und zum LEDs An- und Ausschalten werden Befehle "bsf" und "bcf" für ensprechenden Portpin von GPIO angewendet. Siehe: [[#Ausgeben|Ausgeben]]

Anschlessend wird alles laut PAD in die Vorlage für MPASM eingeschrieben und der Quellcode ist fertig:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration
#define _T1 GPIO,3 ; Portpins benennen
#define _T2 GPIO,4
#define _L1 GPIO,5
#define _L2 GPIO,2
#define _L3 GPIO,1
#define _L4 GPIO,0
P0 equ 0x20 ; Variablen definieren (Register benennen)
P1 equ 0x21
P2 equ 0x22
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
Haupt btfsc _T1 ; Taster _T1=0 gedrückt ?, wenn ja, überspringe "goto T2Test"
goto T2Test ; wenn nicht, springe zu "T2Test"
bsf _L1 ; schalte _L1 an (setze den Pin 2 auf "1")
call Warten ; warte ca. 0,4 s (ca. 400 000 Prozessortakten)
bcf _L1 ; schalte _L1 aus (setze den Pin 2 auf "0")
bsf _L2 ; schalte _L2 an (setze den Pin 5 auf "1")
call Warten ; warte
bcf _L2 ; schalte _L2 aus (setze den Pin 5 auf "0")
bsf _L3 ; schalte _L3 an (setze den Pin 6 auf "1")
call Warten ; warte
bcf _L3 ; schalte _L3 aus (setze den Pin 6 auf "0")
bsf _L4 ; schalte _L4 an (setze den Pin 7 auf "1")
call Warten ; warte
bcf _L4 ; schalte _L4 aus (setze den Pin 7 auf "0")
T2Test btfsc _T2 ; Taster _T2=0 gedrückt ?, wenn ja, überspringe "goto Haupt"
goto Haupt ; wenn nicht, springe zu "Haupt"
bsf _L4 ; schalte _L4 an (setze den Pin 7 auf "1")
call Warten ; warte
bcf _L4 ; schalte _L4 aus (setze den Pin 7 auf "0")
bsf _L3 ; schalte _L3 an (setze den Pin 6 auf "1")
call Warten ; warte
bcf _L3 ; schalte _L3 aus (setze den Pin 6 auf "0")
bsf _L2 ; schalte _L2 an (setze den Pin 5 auf "1")
call Warten ; warte
bcf _L2 ; schalte _L2 aus (setze den Pin 5 auf "0")
bsf _L1 ; schalte _L1 an (setze den Pin 2 auf "1")
call Warten ; warte
bcf _L1 ; schalte _L1 aus (setze den Pin 2 auf "0")
goto Haupt ; springe zu "Haupt"
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 ; dekrementiere P0 und überspringe "goto $-1" bei P0 = 0
goto $-1 ; sonst gehe zur voherigen Adresse (Befehl "decfsz P0")
decfsz P1 ; dekrementiere P1 und überspringe "goto $-4" bei P1 = 0
goto $-4 ; sonst gehe zur aktueller Adresse - 4 (Befehl "clrf P0")
decfsz P2 ; 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 ("Haupt"),
Init clrf GPIO ; lösche Port (setze alle werdende Ausgänge auf "0")
bsf STATUS,RP0 ; auf Bank1 umschalten
call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; und kalibriere internen RC oscillator (4 MHz)
bcf OPTION_ REG,7 ; aktiviere pull-ups für die Portpins
movlw 0x18 ; definiere Portpins GPIO,3 und 4 als Eingänge
; und restlichen als Ausgänge
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
movlw 7 ; schalte Komparator aus
movwf CMCON ; und definiere GPIO 0-2 als digitale I/Os
return ; springe zurück (zum Haupt)
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

Jetzt wird der Quellcode in "Erstes.asm" umbenannt. Diese .asm Datei können wir dem MPASM zum "Übersetzten" geben. Nach der Assemblierung sehen wir 3 Meldungen (Messages) vom MPASM. Diese befinden sich in der vom MPASM erstellter Datei "Erstes.lst" und lauten:

Message[302]: Register in operand not in bank 0. Ensure that bank bits are correct.

Diese Meldung kann man übersetzen als:

Meldung[302]: Register im Befehl nicht in Bank 0. Vergewisse Dich das die Bank-Bits korrekt sind.

Wir sind sicher, dass die Register "OSCCAL", "OPTION_REG" und "TRISIO" in der Bank 1 sich befinden. Wenn man aber nicht sicher ist, soll man in Datenblatt nachschauen. Die Meldungen kommen immer für alle SFRs (Special Function Register) die sich in der Bank 1 befinden und können ignoriert werden.

Am Ende der Datei "Erstes.lst" befinden sich noch einige Informationen über Programmspeicher:

Program Memory Words Used: 52
Program Memory Words Free: 972

und die Anzahl den eventuellen Fehlern (Errors), Warnungen (Warnings) und Meldungen (Messages):

Errors : 0
Warnings : 0 reported, 0 suppressed
Messages : 3 reported, 0 suppressed

Insgesamt werden durch MPASM 4 Dateien erstellt: "*.cod", "*.err", "*.hex" und "*.lst".

Wichtigste davon, falls wegen Fehler keine "*.hex" Datei erstellt wird, ist die "*.err" Datei, wo alles was dem MPASM nicht "passt" aufgelistet ist. In der "*.lst" Datei kann man sich ein Programm mit genauen Adressen für jeden Befehl anschauen.

Die während der Assemblierung vom MPASM generierte Datei "Erstes.hex" kann jetzt durch ein Brenner mit geeignetem Programm in den PIC Programmspeicher eingeschrieben werden.

== Für anderen PIC umschreiben ==

Die wichtigste Vorraussetzung ist, das der PIC2, auf dem das vorhande ASM Programm für PIC1 laufen soll, zumindest für das ASM Program nötige interne Hardware hat. Die Frequenz des Oszillators sollte gleich sein. Der Code benötigt ausser UP "Init" keine Änderungen.

Wenn der Port vom PIC2 anderen Namen hat, muss man das im Quellcode umdefinieren, z.B.:

#define PORTC PORTB
#define TRISC TRISB

Dann wird das Assemblerprogramm, wenn es PORTC findet, immer PORTB nehmen. Das gleiche Betrifft die "__config" Ausdrücke, die entsprechend der "*.ini" Datei für den PIC2, geändert werden müssen.

Das Assemblerprogramm findet sicher alles, was ihm nicht "passt" und bringt Fehlermeldungen, auf die man entsprechend reagieren muss.

Als Beispiel, schreiben wir "Erstes.asm" für den PIC16F84A um.

Zum Ändern sind die ersten 3 Zeilen:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration

Sie werden für den PIC16F84A so aussehen:

list P=16F84A ; Prozessor definieren
include "P16F84A.inc" ; 4.000 MHz
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _HS_OSC

Dazu muss noch "GPIO" Port umdefiniert werden, da der PIC16F84A solchen nicht hat, z.B auf "B":

#define GPIO PORTB
#define TRISIO TRISB

Die Hardware muss natürlich an entsprechende Pins angeschlossen werden:

_T1 auf 12 (B3), _T2 auf 13 (B4), _L1 auf 14 (B5), _L2 auf 11 (B2), _L3 auf 10 (B1) und _L4 auf 9 (B0)

Jetzt assemblieren wir die Qelldatei und der MPASM bringt in der Datei "Erstes.err" folgende Fehler:

Error[113] C:\MPASM\PICPROG\PIC16F84\ERSTES.ASM 61 : Symbol not previously defined (OSCCAL)
Error[113] C:\MPASM\PICPROG\PIC16F84\ERSTES.ASM 67 : Symbol not previously defined (CMCON)

In dem UP "Init" müssen also noch die Befehle mit "OSCCAL" und "CMCON" Register entfernt werden, da der PIC16F84A sie nicht hat:

call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; kalibriere internen RC oscillator (4 MHz)

und:

movlw 7 ; schalte Komparator aus
movwf CMCON ; und mache GPIO 0-2 als digital I/O

Weiter kann schon alles übernommen werden und die Datei "Erstes.asm" für den PIC16F84A ist fertig:

list P=16F84A ; Prozessor definieren
include "P16F84A.inc" ; 4.000 MHz
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _HS_OSC
#define GPIO PORTB ; Ports umbenennen
#define TRISIO TRISB
#define _T1 GPIO,3 ; Portpins benennen
#define _T2 GPIO,4
#define _L1 GPIO,5
#define _L2 GPIO,2
#define _L3 GPIO,1
#define _L4 GPIO,0
P0 equ 0x20 ; Variablen definieren (Register benennen)
P1 equ 0x21
P2 equ 0x22
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
Haupt btfsc _T1 ; Taster _T1=0 gedrückt ?, wenn ja, überspringe "goto T2Test"
goto T2Test ; wenn nicht, springe zu "T2Test"
bsf _L1 ; schalte _L1 an
call Warten ; warte ca. 0,4 s (ca. 400 000 Prozessortakten)
bcf _L1 ; schalte _L1 aus
bsf _L2 ; schalte _L2 an
call Warten ; warte
bcf _L2 ; schalte _L2 aus
bsf _L3 ; schalte _L3 an
call Warten ; warte
bcf _L3 ; schalte _L3 aus
bsf _L4 ; schalte _L4 an
call Warten ; warte
bcf _L4 ; schalte _L4 aus
T2Test btfsc _T2 ; Taster _T2=0 gedrückt ?, wenn ja, überspringe "goto Haupt"
goto Haupt ; wenn nicht, springe zu "Haupt"
bsf _L4 ; schalte _L4 an
call Warten ; warte
bcf _L4 ; schalte _L4 aus
bsf _L3 ; schalte _L3 an
call Warten ; warte
bcf _L3 ; schalte _L3 aus
bsf _L2 ; schalte _L2 an
call Warten ; warte
bcf _L2 ; schalte _L2 aus
bsf _L1 ; schalte _L1 an
call Warten ; warte
bcf _L1 ; schalte _L1 aus
goto Haupt ; springe zu "Haupt"
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 ; dekrementiere P0 und überspringe "goto $-1" bei P0 = 0
goto $-1 ; sonst gehe zur voherigen Adresse (Befehl "decfsz P0")
decfsz P1 ; dekrementiere P1 und überspringe "goto $-4" bei P1 = 0
goto $-4 ; sonst gehe zur aktueller Adresse - 4 (Befehl "clrf P0")
decfsz P2 ; 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 ("Haupt"),
Init clrf GPIO ; lösche Port (setze alle werdende Ausgänge auf "0")
bsf STATUS,RP0 ; auf Bank1 umschalten
bcf OPTION_REG,7 ; aktiviere pull-ups
movlw 0x18 ; definiere Portpins GPIO,3 und 4 als Eingänge
; und die restlichen als Ausgänge
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
return ; springe zurück (zum Haupt), nach der Zeile
; aus der du afgerufen wurdest
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

== Optimierung ==
Work in Progress...
Wer sonst noch Beispiele hat, bitte hier vervollständigen...
BMS ...
=== Speicherbedarf ===
==== Programmspeicher ====
Die ersten Programme für den PIC sind natürlich einfach und kurz. Doch nach und nach werden die Codes länger und unübersichtlicher, das Brennen dauert auch umso länger. Das Programm ist zu umfangreich. Doch wo soll man etwas kürzen?

Es gibt unzählige Möglichkeiten - hier ein paar Beispiele:

===== Unterprogramme =====

Bestimmt wird man im Code immer die selben Abschnitte brauchen, zum Beispiel Warteschleifen oder ADC-Routinen, etc. Wieso sollte man diese also mehrfach (doppelt, dreifach, u.s.w.) schreiben?

Die Lösung: Der Programmteil wird als Unterprogramm benutzt. Man erstellt eine Sprungmarke (ab hier beginnt das Unterprogramm) und endet wieder mit einem "return"- oder "retlw"-Befehl.
Aufgerufen werden die Unterprogramme meistens mit dem "call"-Befehl. Es "lohnt sich" ein Codefragment als UP zu definieren erst wenn es min. 2 mal aufgerufen wird.

Ein "goto"-Befehl ist zu diesem Zweck geeignet nur, wenn der Prozessor zum letzten Aufrufer von "call" zurück springen soll, da die Rücksprungadresse vom letzten "call" auf dem Stapel (stack) abgelegt wurde. Somit kann man mehr als 8 Ebenen von UPs nutzen.

Den Unterprogrammen kann man natürlich auch Werte übergeben. Möchte man z.B. mehrere unterschiedliche Zeiten für Warteschleifen benutzen, so kann man die Parameter vor dem Aufruf des UPs in benötigte Anzahl von Register einschreben und dann das Unterprogramm mit "call" aufrufen. Das Unterprogramm verwendet dann die Zahlen von den Register. Siehe: [[#Pause|Pause]]

Um gleiche Vorgänge in mehreren Register durchzuführen (z.B. löschen) geeignet ist Anwendung von Schleifen mit bestimmter Anzahl der Abläufe und indirekter Adressierung. Siehe: [[#Variablen|Variablen]]

===== bsf und bcf =====

Bestimmt gibt es Situationen, in denen der PIC mehrere Bits an einem Port/Register setzen oder löschen muss. Z.B. wenn mehrere LEDs an einem Port ein- oder ausgeschaltet werden sollen.
Werden mehr als 2 Bits verändert, so kann man hier die "bsf"- und "bcf"-Befehle umgehen und einen kürzeren Code erstellen.

bsf PORTB,0 ;An PORTB sind 8 LEDs angeschlossen.
bsf PORTB,1 ;Es sollen die ersten 4 LEDs angeschaltet werden,
bsf PORTB,2 ;die anderen sollen ausgeschaltet werden.
bsf PORTB,3 ;links steht es mit bcf/bsf
bcf PORTB,4 ;ziemlich lang
bcf PORTB,5
bcf PORTB,6
bcf PORTB,7

movlw b'00001111' ;Das geht auch kürzer und übersichtlicher:
movwf PORTB

Man sieht - der Codeabschnitt umfasst nur noch 2 Zeilen anstatt 8. Somit braucht es weniger Speicher und wird von PIC schneller verarbeitet. Allerdings muss man aufpassen, da durch diese Routine der Inhalt des W-Registers und der Inhalt des gesamten Zielregisters verändert wird. Sollen die anderen Bits unangetastet bleiben, muss man es entweder bei den "bcf"/"bsf"-Befehlen belassen oder logische Funktionen (and bzw. or) durchführen.

===== Bit kopieren =====

;An den PIC ist ein Taster(RB0) und eine LED(RB1) angeschlossen.
;Taster: High=gedrückt Low=nicht gedrückt
;LED: High=Ein Low=Aus
;Wenn der Taster gedrückt ist, soll die LED leuchten
;wenn er nicht gedrückt ist, soll die LED nicht leuchten.
;1.Vorschlag:
btfss PORTB,0 ;ist der taster gedrückt?
goto no ;nein
bsf PORTB,1 ;ja - LED ein
goto endif ;fertig abgefragt - unten weitermachen...
no bcf PORTB,1 ;LED aus
endif

Der oben aufgeführte Code hat viele Nachteile: er ist relativ lang, braucht zwei Gotos und entspr. Sprungmarken. Ok, das ist vielleicht Erbsenzählerei, aber aus diesen 5 Zeilen kann man 3 machen.

bcf PORTB,1 ;Das Bit wird erst gelöscht
btfss PORTB,0 ;Taster gedrückt?
bsf PORTB,1 ;JA-LED an

Man geht davon aus, dass der Taster nicht gedrückt ist. Somit wird die LED erst einmal ausgeschaltet. Ist der Taster aber doch gedrückt, dann wird die LED angeschaltet.

Achtung möglicher Nebeneffekt: Wird dies in einer Schleife sehr schnell und oft ausgeführt, kann die LED flimmern oder nicht in ihrer vollen Helligkeit leuchten. Das passiert, weil ja angenommen wird, dass der Taster nicht gedrückt wird und die LED somit aus sein muss. Dann wird sie aber bei Tastendruck eingeschaltet. Somit entsteht ein schnelles ein-/ausschalten (PWM) und die LED leuchtet nicht mehr so hell.
Meist ist das aber nicht tragisch oder wird nicht unbedingt in einer Schleife sehr schnell abefragt. Siehe hierzu: [[#Einlesen|Einlesen]]

==== RAM ====

Um Anzahl benötigten Register zu sparen werden vorläufige Register (temporary) definiert, die von mehreren UPs benutzt werden. Als Beispiel, das Register "ATmp" in [[#Hex Dec Wandlung|Hex Dec Wandlung]]. Die Benutzung muss aber sehr genau nach PAD zugeteilt werden. Bei gleichzeitiger Benutzung des gleichen Registers durch mehrere UPS werden falsche Daten verarbeitet und im schlimmsten Fall können endlose Schleifen entstehen, die in Folge haben, dass das Programm nicht weiter ausgeführt wird ("hängt").

Fast alle im ASM Programm ungebrauchten SFRs können als "normale" Register (GPR) verwendet werden. Wenn zum Beispiel Timer1 nicht benutzt wird, können seine Register TMR1H und TMR1L für Speicherung von Daten benutzt werden. Es könnte aber gefährlich werden, wenn mehrere Programme gebindet sind. Deswegen muss es immer am Ende, beim volständigen Programm, geprüft werden, welche SFRs tatsächlich benutzt werden dürfen.

Für Konstanten (z.B. pi, ln2, Meldungen, u.s.w.), die sich im Laufe des Programms nicht ändern, kann EEPROM (mit MPASM Direktive "de") oder Programmspeicher (mit MPASM Direktive "dt") als Ablage benutzt werden. Siehe auch: [[#EEPROM|EEPROM]] und [[#Tabellen|Tabellen]]

=== Ausführungszeit ===

Alles was schnellmöglichst ablaufen soll, widersetzt sich der Optimierung des Programmspeichers.

Es können keine Schleifen und keine indirekte Adressierung benutzt werden, alles muss direkt programmiert werden.

Als Beispiel zur Verdeutlichung: Es sollen 16 Werte vom PORTA ins RAM ab Adresse 0x20 eingelesen werden.

Als Schleife mit indirekter Adressierung:

................
movlw 0x10 ;Anzahl Durchläufe
movwf Temp ;in den Schleifenzähler
movlw 0x20 ;erste Adresse
movwf FSR ;ins FSR Register
Einlesen movf PORTA,0 ;PortA ins W-Register
movwf INDF ;und ins aktuellen RAM Register
incf FSR,1 ;nächste Adresse
decfsz Temp,1 ;Temp = 0 ?
goto Einlesen ;nein, zum Einlesen
................ ;ja, weiter
Gesamtdauer: 100 Takten
Pause zwischen Einlesungen: 6 Takten
Programmspeicher Bedarf: 9 Speicherstellen
Direkt:

...............
movf PORTA,0
movwf 0x20
movf PORTA,0
movwf 0x21
movf PORTA,0
movwf 0x22
movf PORTA,0
movwf 0x23
movf PORTA,0
movwf 0x24
movf PORTA,0
movwf 0x25
movf PORTA,0
movwf 0x26
movf PORTA,0
movwf 0x27
movf PORTA,0
movwf 0x28
movf PORTA,0
movwf 0x29
movf PORTA,0
movwf 0x2A
movf PORTA,0
movwf 0x2B
movf PORTA,0
movwf 0x2C
movf PORTA,0
movwf 0x2D
movf PORTA,0
movwf 0x2E
movf PORTA,0
movwf 0x2F
...............
Gesamtdauer: 32 Takten
Pause zwischen Einlesungen: 2 Takten
Programmspeicher Bedarf: 32 Speicherstellen

Anstatt Warteschleifen (z.B. für Tastenentprellung) sollten Programmfragmente mit entsprechender Ausführungszeit benutzt werden (z.B. Ausgabe auf einem Display). Die nötige Zeit lässt sich aus mehreren UPs zusammensetzen.

Es sollte kein Prozessortakt ungenutzt bleiben.

= Mid-Range =

Zu Mid-Range gehören alle PICs mit 14-bit langen Befehlen aus den Familien 12FXXX und 16FXXX.

== Kurzübersicht Assembler Befehle ==

{|
|-
| valign=top |

{| {{Blauetabelle}}
|ADDLW||Add literal and W
|-
|ADDWF||Add W and f
|-
|ANDLW||AND literal with W
|-
|ANDWF||AND W with f
|-
|BCF||Bit Clear f
|-
|BSF||Bit Set f
|-
|BTFSC||Bit Test f, Skip if Clear
|-
|BTFSS||Bit Test f, Skip if Set
|-
|CALL||Call subroutine
|-
|CLRF||Clear f
|-
|CLRW||Clear W
|-
|CLRWDT||Clear Watchdog Timer
|}

| valign=top |

{| {{Blauetabelle}}
|-
|COMF||Complement f
|-
|DECF||Decrement f
|-
|DECFSZ||Decrement f, Skip if 0
|-
|GOTO||Go to address or label
|-
|INCF||Increment f
|-
|INCFSZ||Increment f, Skip if 0
|-
|IORLW||Inclusive OR literal with W
|-
|IORWF||Inclusive OR W with f
|-
|MOVF||Move f
|-
|MOVLW||Move literal to W
|-
|MOVWF||Move W to f
|-
|NOP||No Operation
|}

| valign=top |

{| {{Blauetabelle}}
|-
|RETFIE||Return from interrupt
|-
|RETLW||Return with literal in W
|-
|RETURN||Return from Subroutine
|-
|RLF||Rotate Left f through Carry
|-
|RRF||Rotate Right f through Carry
|-
|SLEEP||Go into standby mode
|-
|SUBLW||Subtract W from literal
|-
|SUBWF||Subtract W from f
|-
|SWAPF||Swap nibbles in f
|-
|XORLW||Exclusive OR literal with W
|-
|XORWF||Exclusive OR W with f
|}
[[:bild:pic_asm_short.jpg|Kurzübersicht zum Ausdrucken]]
|}


==Ausführliche Beschreibung zu den Befehlen==

Eine ausgegliederte Beschreibung der Befehle findet sich unter [[PIC Assemblerbefehle]]

Erklärungen zu den Verwendeten Platzhaltern:
*'''k''' stellt einen fest definierten Wert da. z.B. <tt>0x20</tt>, <tt>d'42'</tt> oder <tt>b'00101010'</tt>
*'''W''' steht für das W-Register.
*'''d''' steht für ''destination'' (Ziel). Im code wird d durch ein <tt>w</tt> bzw. <tt>0</tt> (der Wert wird in das W-Register gespeichert ) oder <tt>f</tt> bzw. <tt>1</tt> (der Wert wird in das davor definierte Register gespeichert)
*'''b''' steht für Bitnummer im Register (eine Zahl zwischen 0 und 7)
*'''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
*<tt>Schreibmaschinenstil</tt> bedeutet, dass es so im Quellcode geschrieben werden kann.

 ADDLW k Add W and literal - Addiere W und Zahl (k)<hr>
:Es wird die Rechenoperation <math>W+k</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|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

 ADDWF R,d Add W and f - Addiere W und f <hr>
:Es wird die Rechenoperation <math>W+R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Dieser Befehl beeinflusst das STATUS-Register. Siehe hierzu [[#Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

 ANDLW k AND literal with W<hr>
:Es wird bitweise die logische Funktion <math>k\ and\ W</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 Operation:
<dl><dd>
11001010 ;k
10101100 ;W-Register
-------- and
10001000 ;W-Register
</dd></dl>

 ANDWF R,d AND W with f<hr>
:Es wird bitweise die logische Funktion <math>W\ and\ R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Vergleiche ANDLW. Dieser Befehl wird oft benutzt zum Löschen bestimmten Bits im Register ohne restlichen Bits zu beeinflüssen.

BCF R,b Bit Clear f - Bit b im R wird gelöscht<hr>
:Mit dem Befehl <tt>BCF</tt> wird das Bit '''b''' im Register '''R''' gelöscht. Ein Beispiel:
<dl><dd>
movlw b'11111111' ;es wird b'11111111' in das W-Register geschrieben
BCF W,2 ;es wird bit 2 im W-Register gelöscht.
;das Ergebnis ist: b'11111011'
</dl></dd>

BSF R,b Bit Set f - Bit b im R wird gesetzt<hr>
:Mit dem Befehl <tt>BSF</tt> wird das Bit '''b''' im Register '''R''' gesetzt. Ein Beispiel:
<dl><dd>
clrw ;es wird b'00000000' in das W-Register geschrieben
BSF W,2 ;es wird bit 2 im W-Register gesetzt.
;das Ergebnis ist: b'00000100'
</dl></dd>

BTFSC R,b Bit Test f, Skip if Clear - Wenn das Bit b im Register R 0 ist, überspringe den nächsten Befehl<hr>
:Mit dem Befehl <tt>BTFSC</tt> kann eine Verzweigung im Programmablauf bewirkt werden. Wenn das Bit '''b''' im Register '''R''' 0 ist, wird der nächste Befehl übersprungen. Ein Beispiel:
<dl><dd>
movlw b'00000001' ;es wird die Zahl 1 in das W-Register kopiert.
BTFSC W,0 ;es wird bit 0 geprüft.
;wenn es 0 ist, wird der nächste Befehl übersprungen
goto IST_EINS ;springt zur Marke "IST_EINS" <- in diesem Fall wird dieser
;Sprungbefehl ausgeführt.
goto IST_NULL ;springt zur Marke "IST_NULL"
</dl></dd>

BTFSS R,b Bit Test f, Skip if Set - Wenn das Bit b im Register R 1 ist, überspringe den nächsten Befehl<hr>
:Mit dem Befehl <tt>BTFSS</tt> kann eine Verzweigung im Programmablauf bewirkt werden. Wenn das Bit '''b''' im Register '''R''' 1 ist, wird der nächste Befehl übersprungen. Ein Beispiel:
<dl><dd>
movlw b'00000001' ;es wird die Zahl 1 in das W-Register kopiert.
BTFSS W,0 ;es wird bit 0 geprüft.
;wenn es 1 ist, wird der nächste Befehl übersprungen
goto IST_NULL ;springt zur Marke "IST_NULL"
goto IST_EINS ;springt zur Marke "IST_EINS" <- in diesem Fall wird dieser
;Sprungbefehl ausgeführt, da der Befehl
;darüber übersprungen wurde.
</dl></dd>

CALL Call Subroutine - Rufe Unterprogramm auf<hr>
:Mit dem <tt>CALL</tt> Befehl wird ein Unterprogramm aufgerufen. Mit dem <tt>RETURN</tt>-Befehl wird das Unterprogramm beendet und man kehrt zum Befehl nach dem <tt>CALL</tt>-Befehl zurück. Das Unterprogramm wird so definiert, dass im Quellcode der Name des Unterprogramms nicht eingerückt steht. Ein Beispiel:

<dl><dd>
movlw d'13' ;in das W-Register wird 13d geladen
CALL Unterprogramm1 ;es wird das Unterprogramm "Unterprogramm1" aufgerufen
movwf ergebnis ;das W-Register wird in das Register "ergebnis" kopiert.
;im Register "ergebnis" steht nun 23d

Unterprogramm1 ;zählt 10 zum W-Register
addlw d'10' ;es wird 10d zum W-Register addiert
RETURN ;kehre zurück zum Aufrufer
</dl></dd>

CLRF R Clear f - Schreibe 0 in das Register R<hr>
:Das Register '''R''' wird mit Nullen gefüllt (gelöscht).

CLRW Clear W - Schreibe 0 in W<hr>
:Das W-Register (<tt>W</tt>) wird mit Nullen gefüllt (gelöscht).
:Der Befehl bewirkt das gleiche wie MOVLW 0 und darf im Programmen, die fur zukünftige Anwendung bei den PICs der serie 18F vorgesehen sind, nicht benutzt werden, da sie ihn nicht kennen.

CLRWDT Clear Watchdog Timer - Setzt den Watchdog-Timer zurück<hr>
:Es wird der WDT (Watchdog-Timer) zurückgesetzt und der Zähler des WDT auf 0 gesetzt, zusätzlich werden die STATUS-bits TO und PD gesetzt.

COMF R,d Complement f - negiere alle bits im Register R<hr>
:Von der Binärzahl im Register '''R''' werden alle 0 mit 1 und alle 1 mit 0 ersetzt. Das Ergebnis wird entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Ein kleines Beispiel: aus <tt>AAh</tt> (<tt>10101010b</tt>) wird <tt>55h</tt> (<tt>01010101b</tt>).

DECF R,d Decrement f - Subtrahiert 1 vom Regiser f<hr>
:Vom Wert des Registers '''R''' wird 1 subtrahiert und das Ergebnis entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
:Weil es keine "echte" Substraktion ist, beeinflusst dieser Befehl das C-Flag im STATUS-Register nicht.

DECFSZ R,d Decrement f, Skip if 0 - Subtrahiert 1 vom Regiser f, überspringe wenn 0<hr>
:Vom Wert des Registers '''R''' wird 1 subtrahiert und das Ergebnis entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Der Zusatz SZ steht für ''skip if zero'', d.h. wenn das Ergebnis der Rechnung Null ist, wird der nächste Befehl übersprungen. Dieser Befehl wird für Schleifen mit bestimmter Anzahl der Durchläufe benutzt.

GOTO Go to address - Gehe zu Adresse/Sprungmarke<hr>
:Nach dem GOTO Befehl wird das Programm ab der Adresse weiter ausgeführt, die nach dem GOTO-Befehl steht. Diese Adresse wird durch so genannte Sprungmarke definiert, welche, im Gegensatz zu den Befehlen nicht eingerückt im Quellcode stehen.

INCF R,d Increment f - Addiere 1 zum Register f<hr>
:Zum Wert des Registers '''R''' wird 1 addiert und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
:Weil es keine "echte" Addition ist, beeinflusst dieser Befehl das C-Flag im STATUS-Register nicht.

INCFSZ R,d Increment f, Skip if 0 - Addiere 1 zum Regiser f, überspringe wenn 0<hr>
:Zum Wert des Registers '''R''' wird 1 addiert und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Der Zusatz SZ steht für ''skip if zero'', d.h. wenn das Ergebnis der Rechnung Null ist, wird der nächste Befehl übersprungen. Dieser Befehl wird für Schleifen mit bestimmter Anzahl der Durchläufe benutzt.

 IORLW k OR literal with W<hr>
:Es wird bitweise die logische Funktion <math>k\ or\ W</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 Operation:
<dl><dd>
11001010 ;k
10101100 ;W-Register
-------- or
11101110 ;W-Register
</dd></dl>

 IORWF R,d OR W with f<hr>
:Es wird bitweise die logische Funktion <math>W\ or\ R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Vergleiche IORLW. Dieser Befehl wird oft benutzt zum Setzen bestimmten Bits im Register ohne restlichen Bits zu beeinflüssen.

MOVF R,d Move f - Bewege f<hr>
:Das Register R wird in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder wieder in R kopiert ('''d'''=<tt>F</tt>=<tt>1</tt>). Letzteres mag sinnlos scheinen, ist aber nützlich, da durch den Befehl das Z-Bit im STATUS-Register gesetzt wird, falls R Null ist.

MOVLW k Move literal to W - Bewege Zahl (k) in W-Register<hr>
:Der festgelegte Wert k wird in das W-Register kopiert.

:Dieser Befehl wird auch bei indirekter Adressierung zum laden der absoluter Adresse ins "FSR" Register benutzt. Beispiel:
:Der Register "Temp" wurde mit "Temp equ 0x20" definiert.
<dl><dd>
movlw Temp ;ins W-Register wird die absolute Adresse 0x20 vom "Temp" geladen
movwf FSR ;diese Adresse wird jetzt ins Register "FSR" kopiert
</dd></dl>
MOVWF R Move W to f - Bewege W-Register in das Register F<hr>
:Das W-Register wird in das Register '''R''' kopiert.

NOP No Operation - Kein Befehl zum Ausführen (warte)<hr>
: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. Siehe hierzu: [[#Pause|Pause]]

RETFIE Return from interrupt - Kehre zurück aus der Unterbrechung<hr>
:Mit diesem Befehl wird die Interrupt Service Routine (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 | Interrupt]]

RETLW k Return with literal in W - Kehre zurück mit Zahl k im W-Register<hr>
:Wurde ein Programmteil mit dem Befehl <tt>CALL</tt> aufgerufen, dann springt man mit dem Befehl <tt>RETLW</tt> zurück in die nächste Zeile nach der Zeile aus der das <tt>CALL</tt> 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 Wertetabellen (eng: lookup tables) verwendet.

RETURN Return from Subroutine - Kehre zurück zum Aufrufer<hr>
:Wurde ein Programmteil mit dem Befehl <tt>CALL</tt> aufgerufen, dann springt man mit dem Befehl <tt>RETURN</tt> zurück zu der nächsten Zeile nach der Zeile aus der das <tt>CALL</tt> Befehl ausgeführt wurde.

RLF R,d Rotate Left f through Carry - Rotiere das Register f mithilfe des Carry-bits nach links<hr>
:Alle Bits im Register '''R''' werden um eine Position nach links verschoben. Dabei wird das Carry bit (<tt>STATUS,C</tt>) 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'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
<dl><dd>
|<--- Register R --->|
|c|<-7<-6<-5<-4<-3<-2<-1<-0
V A
|________________________|
</dd></dl>
:Zur Verdeutlichung:
<dl><dd>
|C| |-Register R-| ;C steht für das Carry-bit, STATUS,C ; 0-7 stehen für Bitnummer im Register.
c 7 6 5 4 3 2 1 0 ;vor der Rotation
7 6 5 4 3 2 1 0 c ;nach der Rotation
</dd></dl>

RRF R,d Rotate Right f through Carry - Rotiere das Register f mithilfe des Carry-bits nach rechts<hr>
:Alle Bits im Register '''R''' werden um eine Position nach rechts verschoben. Dabei wird das Carry bit (<tt>STATUS,C</tt>) 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'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
<dl><dd>
|<--- Register R --->|
|c|->7->6->5->4->3->2->1->0
A V
|________________________|
</dd></dl>
:Zur Verdeutlichung:
<dl><dd>
|C| |-Register R-| ;C steht für das Carry-bit, STATUS,C ; 0-7 stehen für Bitnummer im Register.
C 7 6 5 4 3 2 1 0 ;vor der Rotation
0 C 7 6 5 4 3 2 1 ;nach der Rotation
</dd></dl>

SLEEP Go into standby mode - Versetze den Mirokontroller in Bereitschaftsmodus<hr>
: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.

 SUBLW k Subtract W from literal - Ziehe W von Zahl (k) ab<hr>
: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|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

 SUBWF R,d Subtract W from f - Ziehe W von f ab<hr>
:Es wird die Rechenoperation <math>R-W</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Dieser Befehl beeinflusst das STATUS-Register. Siehe hierzu [[#Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

:Beispiel:
<dl><dd>
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
</dd></dl>

SWAPF R,d Swap nibbles in f - Vertausche die Halbbytes (Nibbles)<hr>
:Es werden die höheren 4 bit (bit7-bit4) mit den niedrigeren 4 bit (bit3-bit0) eines Registers vertauscht und entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
:Beispiel:
<dl><dd>
movlw b'00001111' ;schreibe b'00001111' in das W-Register
movwf Register1 ;kopiert 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'
</dd></dl>

 XORLW k Exclusive OR literal with W<hr>
:Es wird bitweise die logische Funktion <math>k\ xor\ W</math> ausgeführt und das Ergebniss in das W-Register gespeichert. Dieser Befehl setzt das Z bit des STATUS-Registers, falls W=k und das Ergebnis 0 ist.
:Zur Verdeutlichung der Operation:
<dl><dd>
11001010 ;k
10101100 ;W-Register
-------- xor
01100110 ;W-Register
</dd></dl>

 XORWF R,d Exclusive OR W with f<hr>
:Es wird bitweise die logische Funktion <math>W\ xor\ R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Vergleiche XORLW. Dieser Befehl wird zum Vergleichen zwei Register benutzt.

==Besondere, oft gebrauchte Register==

=== STATUS ===
Der Statusregister beinhaltet den Status der Recheneinheit ALU (Arithmetic-Logic Unit), Resetinformationen und die beiden Bits zur Wahl der Speicherbank

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''STATUS''' (ADDRESSE 03h, 83h, 103h, 183h)</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R-1</td>
<td style="width:60px;">R-1</td>
<td style="width:60px;">R/W-x</td>
<td style="width:60px;">R/W-x</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''IRP'''</td>
<td style="background:#f5f7ff;">'''RP1'''</td>
<td style="background:#f5f7ff;">'''RP0'''</td>
<td style="background:#f5f7ff;">'''TO'''</td>
<td style="background:#f5f7ff;">'''PD'''</td>
<td style="background:#f5f7ff;">'''Z'''</td>
<td style="background:#f5f7ff;">'''DC'''</td>
<td style="background:#f5f7ff;">'''C'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

*Bit 7 '''IRP''': Register Bank Select Bit (für indirekte Adressierung)
:: 1 = Bank 2, 3 (100h-1FFh)
:: 0 = Bank 0, 1 (00h-FFh)
*Bit 6-5 '''RP<1:0>''': Register Bank Select Bits (für direkte Adressierung)
:: 11 = Bank 3 (180h-1FFh)
:: 10 = Bank 2 (100h-17Fh)
:: 01 = Bank 1 (80h-FFh)
:: 00 = Bank 0 (00h-7Fh)
*Bit 4 '''TO''': Time-out Bit
:: 1 = Nach Power-up, CLRWDT Befehl oder SLEEP Befehl
:: 0 = A Watchdogtimer time-out ist eingetreten
*Bit 3 '''PD''': Power-Down Bit
:: 1 = Nach Power-up oder durch den CLRWDT
:: 0 = Nach einem SLEEP befehl
*Bit 2 '''Z''': Zero bit
:: 1 = Das Ergebnis einer arithmetischen oder logischen Operation ist 0
:: 0 = Das Ergebnis einer arithmetischen oder logischen Operation ist NICHT 0
*Bit 1 '''DC''': Digit carry/borrow bit (ADDWF, ADDLW, SUBLW und SUBWF Befehle)
:: 1 = Ein Carry-out des 4.Niedrigsten Bits (Low Nibble) eines Rechenergebnisses existiert
:: 0 = Kein Carry-out des 4.Niedrigsten Bits eines Rechenergebnisses existiert
*Bit 0 '''C''': Carry/borrow Bit (ADDWF, ADDLW, SUBLW und SUBWF Befehle)
:: 1 = Ein Carry-out des MSB eines Rechenergebnisses existiert
:: 0 = Kein Carry-out des MSB eines Rechenergebnisses existiert

Das "Borrowbit" (to borrow = etwas borgen) dient zum erkennen, wenn ein Übertrag einer Rechenoperation exisitiert. 250+10 ergibt zum Beispiel 4, und setzt dabei das Borrowbit auf 1. Damit kann das Programm erkennen, wenn wieder einmal ein Ergebnis größer als 255 herauskam.
Bei Subtraktionen (SUBLW und SUBWF) verhält sich das Carry Bit umgekehrt als bei Additionen (ADDWF und ADDLW)!! Zum Beispiel 55-6=49 setzt Carry auf 1 aber 10-25=241 löscht das Carry-Flag.

====Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Registers====

{|
|-
|
{| {{Blauetabelle}}
|+ Auswirkungen auf das STATUS-Register bei Subtraktionen
|-
| Ergebnis
|| STATUS,C
|| STATUS,Z
|-
| positiv
|align="center"|1
|align="center"|0
|-
| negativ
|align="center"|0
|align="center"|0
|-
| Null
|align="center"|1
|align="center"|1
|}

||

{| {{Blauetabelle}}
|+ Auswirkungen auf das STATUS-Register bei Additionen
|-
| Ergebnis
|| STATUS,C
|| STATUS,Z
|-
| positiv
|align="center"|0
|align="center"|0
|-
| Überlauf
|align="center"|1
|align="center"|0
|-
| Null
|align="center"|1
|align="center"|1
|}
|}

=== INTCON ===

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''INTCON''' (ADDRESSE 0Bh, 8Bh, 10Bh, 18Bh)</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''GIE'''</td>
<td style="background:#f5f7ff;">'''PEIE'''</td>
<td style="background:#f5f7ff;">'''TMR0IE'''</td>
<td style="background:#f5f7ff;">'''INT0IE'''</td>
<td style="background:#f5f7ff;">'''RBIE'''</td>
<td style="background:#f5f7ff;">'''TMR0IF'''</td>
<td style="background:#f5f7ff;">'''INT0IF'''</td>
<td style="background:#f5f7ff;">'''RBIF'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

*Bit 7 '''GIE''': Global Interrupt Enable Bit
::1 = Aktiviert alle Interrupts
::0 = Deaktiviert alle Interrupts
*Bit 6 '''PEIE''': Peripheral Interrupt Enable Bit
::1 = Aktiviert alle peripheren Interrupts
::0 = Deaktiviert alle peripheren Interrupts
*Bit 5 '''TMR0IE''': TMR0 Overflow Interrupt Enable Bit (Overflow von Timer0 löst Interrupt aus)
::1 = Aktiviert den TMR0 Interrupt
::0 = Deaktiviert den TMR0 Interrupt
*Bit 4 '''INT0IE''': RB0/INT External Interrupt Enable Bit (Änderung an RB0 Pin löst Interrupt aus) *)
::1 = Aktiviert den RB0/INT Interrupt (Extern ausgelöst)
::0 = Deaktiviert den RB0/INT Interrupt (Extern ausgelöst)
*Bit 3 '''RBIE''': RB Port On-Change-Interrupt Enable Bit (Änderung an PortB löst Interrupt aus) **)
::1 = Aktiviert den RB port on-change-interrupt
::0 = Deaktiviert den RB port on-change-interrupt
*Bit 2 '''TMR0IF''': TMR0 Overflow Interrupt Flag Bit
::1 = TMR0 Register ist Übergelaufen (muss per Software gelöscht werden)
::0 = TMR0 register ist nicht Übergelaufen
*Bit 1 '''INT0IF''': RB0/INT External Interrupt Flag Bit
::1 = Eine Änderung an RB0/INT Pin hat stattgefunden (muss per Software gelöscht werden)
::0 = Eine Änderung an RB0/INT Pin hat nicht stattgefunden
*Bit 0 '''RBIF''': RB Port On-Change-Interrupt Flag bit
::1 = Mind. einer der Pins von RB7:RB4 hat sich geändert (muss per Software gelöscht werden)
::0 = Keiner der Pins von RB7:RB4 hat sich geändert

* *) Die Flanke auf die reagiert werden soll, wird mit dem Bit OPTION_REG.INTEDG definiert. (steigende = 1 oder fallende = 0)
* **) Der Interrupt klingt verführerischer Weise so, als ob er den gesamten Port überwacht. Dabei reagiert er nur auf RB7:RB4!!!! Er kann aber den Prozessor vom "Schlaf" aufwecken (z.B. durch einen Tastendruck).

=== PORTx ===

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''PORTx'''</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''Rx7'''</td>
<td style="background:#f5f7ff;">'''Rx6'''</td>
<td style="background:#f5f7ff;">'''Rx5'''</td>
<td style="background:#f5f7ff;">'''Rx4'''</td>
<td style="background:#f5f7ff;">'''Rx3'''</td>
<td style="background:#f5f7ff;">'''Rx2'''</td>
<td style="background:#f5f7ff;">'''Rx1'''</td>
<td style="background:#f5f7ff;">'''Rx0'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

!Das "x" steht in allen Fällen für den Buchstaben des Ports!
BSP: "PORTB" oder "RA1"

Diese Special Funktion Register liegen ALLE in Bank0 und Bank2(Falls vorhanden).

Jedes Bit eines PORT-Registers steht für einen Pin (Ein/Ausgang) des jeweiligen Ports. Je nachdem Ob ein Pin als Ausgang oder als Eingang definiert ist, kann man dort entweder den Wert schreiben oder auslesen. Es hat nicht Jeder PIC gleich viele Ports und es sind auch nicht immer 8 Pins pro Port, es können auch weniger sein. Alle PICs der Midrange-Serie besitzen nur bidirektionale Ports, d.h. sie können sowohl Eingang als auch Ausgang sein. Bei Port B kann man bei allen Pins einen internen PULL-UP Widerstand mit dem Bit OPTION_REG<RBPU> hinzuschalten (Standardmäßig auf nicht aktiviert, Bit muss gelöscht werden um die Funktion zu aktivieren). Weiters ist zu beachten, dass einzelne Pins nach dem Reset mit anderen Funktionen belegt sein können. Das gilt im Speziellen für PORTA, wo sich die Komperatoren, AD's (falls vorhanden) und die Oszillatoreingänge befinden. Siehe [[PIC Assembler#I/O Ports|I/O Ports]]. Bei den "kleinsten" PICs der 12F Serie die nur einen I/O Port (6 Pins) haben, heisst der PORT-Register GPIO.
{|{{Blauetabelle}}
|+ Beispiel PICs und ihre Ports (Zahlen in der Klammer sind die Anzahl der Pins des Ports)
|
|'''PIC16F628A'''
|'''PIC16F876'''
|'''PIC16F877'''
|-
|'''PORTA'''
|Ja
|Ja(5)
|Ja(6)
|-
|'''PORTB'''
|ja
|ja
|ja
|-
|'''PORTC'''
|/
|ja
|ja
|-
|'''PORTD'''
|/
|/
|ja
|-
|'''PORTE'''
|/
|/
|ja (3)
|-
|}

=== TRISx ===

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''TRISx'''</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''TRISx7'''</td>
<td style="background:#f5f7ff;">'''TRISx6'''</td>
<td style="background:#f5f7ff;">'''TRISx5'''</td>
<td style="background:#f5f7ff;">'''TRISx4'''</td>
<td style="background:#f5f7ff;">'''TRISx3'''</td>
<td style="background:#f5f7ff;">'''TRISx2'''</td>
<td style="background:#f5f7ff;">'''TRISx1'''</td>
<td style="background:#f5f7ff;">'''TRISx0'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

!Das "x" steht in allen Fällen für den Buchstaben des Ports!
BSP: "TRISB" oder "TRISA"

Bei den "kleinsten" PICs der 12F Serie die nur einen I/O Port (6 Pins) haben, heisst der TRIS-Register TRISIO.

Die TRIS-Bytes dienen dazu, einzelne I/O Pins als Eingang oder Ausgang zu definieren. Sie liegen immer genau eine Bank über den jeweiligen PORT-Bytes, d.h. sie liegen alle in Bank1 und Bank3(falls vorhanden.) Besonders zu beachten ist, dass manche Eingebaute Features wie die Serielle Schnittstelle, I2C, SPI usw nicht funktionieren, wenn die Jeweiligen Sende und Empfangspins nicht nicht manuell umgestellt werden, ja es ''muss'' sogar manchmal umgestellt werden (bei I2C z.B.) Egal ist dies jedoch für Komperatoren und AD-Wandler.

Merke:
* Eine 1 (als "I" für "Input" zu lesen) eines TRISxx-Bits definiert den zugehörigen PIN am PIC als Eingang.
* Eine 0 (als "O" für "Output" zu lesen) eines TRISxx-Bits definiert den zugehörigen PIN am PIC als Ausgang.

Siehe [[PIC Assembler#I/O Ports|I/O Ports]].

==Speicherbankorganisation==
===Programmspeicher===
Die Mid-Range MCUs haben einen 2-8k großen Programmspeicher. Dieser hat aber in jeder Speicherzelle nicht 8, sondern 14 Bit - also genau die Länge eines Befehls. Die aktuelle Stelle im Programm wird im PC (Program Counter) verwaltet. Er speichert immer die aktuelle Adresse im Programmspeicher (wird im Code oft als "$" bezeichnet). Bei einem PIC mit 8k Adressen muss er also die Adressen 0000-1FFF speichern können. Daraus folgt die Größe von 13 Bit für den PC. Der Programmspeicher ist in mehrere Bänke geteilt, die alle 2k groß sind. Das Programm springt ohne zutun des Benutzers von einer in die Nächste. Wenn man aber selber springen will, muss man die Register PCLATH (Program Counter Latch High) oder PCL (Program Counter Least Significant Byte) mit der Sprungadresse beschreiben.

===Datenspeicher===
Der Datenspeicher besteht aus den Special Function Registern (SFR) und den General Purpose
Registern (GPR). Die SFRs sind für die Funktionen des PICs zuständig (Interrupts, Timer, ADCs, CCPM...) und die GPRs für die Speicherung von Variablen und Daten.

Da immer nur 7 Bit der (Ziel)Adresse in einem Befehl gespeichert werden können, sind nur 7Fh (128d) Adressen im Datenbereich möglich. Deswegen wurde das "Banking" eingeführt. 2 Bit im Statusregister (welcher in allen Bänken der selbe ist und auch an der gleichen Stelle sitzt) geben die akutelle "Bank" an und sind nichts anderes als die 2 höchstwertigsten (MSB) Bits der Adresse. Damit lassen sich max. 4 Bänke ansprechen. Je nach PIC gibt es 2-4 Bänke. Die beiden Bits im Register STATUS heißen RP0 (STATUS<5>) und RP1 (STATUS<6>).

{| {{Blauetabelle}}
|+ Wechseln der Bänke mit RP0 und RP1
|-
|
|| RP1
|| RP0
|-
| Bank0
|align="center"|0
|align="center"|0
|-
| Bank1
|align="center"|0
|align="center"|1
|-
| Bank2
|align="center"|1
|align="center"|0
|-
| Bank3
|align="center"|1
|align="center"|1
|}

[[Bild:PIC midrange register.JPG]]
# '''FETTE Register''' sind in allen PICs vorhanden
# können je nach PIC unimplementierte Bereiche beinhalten - diese werden immer als 0 gelesen. (DATENBLATT!!)
# siehe 2
# Könnten je nach PIC auch nicht in Bank0 gemapped werden, sind dann eigenständige Register.
# je nach PIC kann es diese Bänke geben oder nicht geben.

== Codeschnipsel ==

=== Analog-Digital-Wandler (ADC) ===

Viele PICs besitzen einen Analog-Digital-Wandler, der eine angelegte Spannung messen kann und diese als Zahl speichert.

Es gibt AD-Wandler mit 8Bit bzw. 10Bit Auflösung, d.h. die Spannung an einem analogen Eingang wird linear 2^8=256 bzw. 2^10=1024 Werten zugeordnet.
Der höchste Wert, auch Referenzspannung genannt, (255 bzw. 1023; der Controller rechnet die Null auch mit) entspricht der Betriebsspannung des PICs oder wahlweise einer wählbaren Spannung, die an RA3 angelegt werden muss. Der niedrigste Wert entspricht 0 Volt.

Mit dem Analog-Digital-Wandler kann man somit z.B. Sensoren auswerten, die mehr als zwei Zustände ausgeben (Beispiele: Temperatursensor, Helligkeitssensor, Entfernungssensoren usw.) oder Akkuspannungen messen.

Bevor überhaupt gemessen werden kann, muss einiges eingestellt werden:

* Eingangsverteilung Analog/Digital bzw.Referenzspannung (Betriebsspannung oder RA3)
die genauen Einstellungsmöglichkeiten entnehmen sie bitte dem Datenblatt ihres Controllers (Register ADCON1 Bank 1).

* Wählen des Taktes für den ADC und Einschalten des ADCs

Das Register ADCON0 besitzt 8 Bits, die folgendes bestimmen:
Bit0 ADON - schaltet AD-Wandler ein oder aus (Strom sparen)
Bit1 - nicht vorhanden
Bit2 GO/Done - startet Wandlung / signalisiert, wann Umwandlung beendet ist.
Bit3 CHS0 - Channel Select 0 wählt Eingang aus
Bit4 CHS1 - Channel Select 1 wählt Eingang aus
Bit5 CHS2 - Channel Select 2 wählt Eingang aus
Bit6 ADCS0 - AD-Clock-Select wählt Takt
Bit7 ADCS1 - AD-Clock-Select wählt Takt

Kümmern wir uns zunächst um den Takt. Mit den zwei Bits ADCS0 und ADCS1 bestimmt man den Takt - hierbei gibt es vier Möglichkeiten:

ADCS1=0, ADCS0=0 -> Taktfrequenz des PICs :2
ADCS1=0, ADCS0=1 -> Taktfrequenz des PICs :8
ADCS1=1, ADCS0=0 -> Taktfrequenz des PICs :32
ADCS1=1, ADCS0=1 -> interner RC-Oszillator des ADCs verwenden

Die Taktfrequenz des ADCs darf 625kHz nicht überschreiten, dementsprechend ist ADCS0 und ADCS1 zu wählen.

Ist dies vollbracht, so kann man den AD-Wandler einschalten und das Go/Done-Bit löschen.
Codebeispiel:

bcf ADCON0,6 ;Takt für
bsf ADCON0,7 ;ADC (OSC/32)
bsf ADCON0,0 ;ADC einschalten, ADON=1
bcf ADCON0,2 ;Go/Done-Bit zurücksetzen

Nun ist der AD-Wandler bereit, Spannungen in Zahlen umzuwandeln.
Für eine Wandlung muss erst der entsprechende Eingang gewählt werden. Dafür sind die CHS0..CHS2-Bits zuständig:

CHS2 CHS1 CHS0 gewählter Eingang(falls vorhanden)
0 0 0 RA0
0 0 1 RA1
0 1 0 RA2
0 1 1 RA3
1 0 0 RA5
1 0 1 RE0
1 1 0 RE1
1 1 1 RE2

Achtung! RA4 ist kein analoger Eingang, folglich ist er oben nicht aufgelistet !!

Codebeispiel:

bcf ADCON0,3 ;RA2 auswählen
bsf ADCON0,4
bcf ADCON0,5

Als letztes muss die AD-Routine nur noch gestartet werden. Ist der AD-Wandler fertig, so löscht er das Bit wieder. Das Bit wird nun solange abgefragt, bis der AD-Wandler fertig ist. Den zugeordneten Wert findet man im Register 'ADRES'.
Code:

bsf ADCON0,2 ;start
wa btfsz ADCON0,2 ;warten,bis es wieder low ist
goto wa ;noch nicht fertig
;jetzt ist er fertig
movf ADRES,W ;ADRES in W verschieben, um damit gleich weiter zu arbeiten

Die AD-Wandlung ist somit fertig. Liest man mehrere Werte von unterschiedlichen Eingängen ein und möchte diese miteinander vergleichen o.ä., sollte man die Zahlen von ADRES in anderen Registern zwischenspeichern.

Desweiteren ist zu beachten, dass der Analog-Digital-Wandler eine gewisse Pause zwischen den Wandlungen benötigt, die sog. 'Aquisition Time'. Diese Zeitangabe entnehmen sie bitte ihrem Datenblatt.

mögliche Probleme:

;Der PIC liefert stark schwankende Werte
:-> Mögliche Ursachen dafür sind z.B. nicht stabile Betriebsspannung, falsche Zeiteinstellungen. Abhilfe schafft auch das mehrmalige Einlesen eines Eingangs. Auch können z.B. 8 Werte eingelesen werden und dann der Durchschnitt gebildet werden.
Evtl. kann ein Kondensator gegen Masse (z.B. 1nF) helfen; Wichtig ist auch eine kleine Verzögerung zwischen Kanalauswahl und Start der Wandlung. In dieser Zeit kann sich der interne Kondensator des ADC's aufladen.

;Die Spannung an einem Eingang wird erhöht, die Werte der anderen Eingänge werden aber auch beeinflusst.
:-> Dann sind Sie Opfer des sog. 'Ghostings' geworden (Werte 'scheinen durch', verschleißen). Die Werte der anderen Eingänge gehen mit, weil der interne Kondensator noch auf die Spannung des Vorgängers aufgeladen ist. Maßnahme: Aquisition Time erhöhen, Werte öfters abfragen, Pause zwischen Kanalauswahl und Start

;Der PIC liefert immer die gleichen Werte an einem Eingang, obwohl sich die angelegte Spannung ändert
:-> möglicherweise falsche Eingangsverteilung (ADCON1) eingestellt oder falschen Pin gewählt

=== Hex Dec Wandlung ===

Das ist ein Unterprogramm der mit call Hex_Dec aufgerufen wird. Es gibt 4 Register (A, B, C und D) mit jeweils 32 Bits, die aus jeweils 4 Register mit 8 Bits (z.B. fur A: A3, A2, A1 und A0) bestehen.

A3 A2 A1 A0
.--------.--------.--------.--------.
|76543210|76543210|76543210|76543210|
'--------'--------'--------'--------'
| |
|<----------- A Register ---------->|

Sie müssen (wegen FSR) so wie im Code nacheinander liegen (die absolute Adressen sind nicht wichtig). In das Register "A" wird die hex Zahl eingeschrieben und aus dem "D" die umgewandelte dec Zahl ausgelesen. A3,7 und D3,7 sind MSB und A0,0 und D0,0 sind LSB. Die "B" und "C" sind Hifsregister. Das UP kann für kleinere als 32-bittige hex Zahlen modifiziert werden. Zum Beispiel für 16-bittige hex Zahlen bleiben nur Register A1,A0,B1,B0,C1,C0,D1,D0 und in den UPs werden in die Register und als X, folgende Zahlen eingeschrieben: HTmp->0x10 (Anzahl Bits der hex Zahl),ATmp->2=X (Anzahl Bytes der hex Zahl). Es müssen auch die UPs "CClr", "DClr" und "CopyCB" entschprechend der Registerlänge angepasst werden. Genauso kann natürlich das UP auch für längere hex Zahlen modifiziert werden.

Das UP "AddCB" addiert dezimal die 32- bittige Register C und B, das Ergebniss befindet sich in C.
Das UP "AddDC" addiert dezimal die 32-bittige Register D und C, das Ergebniss befindet sich in D.

Die 32-bit Additionen werden in 4 Schritten wie folgt realisiert:

C0+B0->C0, C1+B1->C1, C2+B2->C2 und C3+B3->C3

D0+C0->D0, D1+C1->D1, D2+C2->D2 und D3+C3->D3

Die Flags "_Fcra", "_Fcrp" und "_Fdca" steuern die alle nötigen Korrekturen.

Die Wandlung wird in 32 Schritten laut folgender Formel durchgeführt:

Zahl(d)=B0*2^0+B1*2^1+B2*2^2+B3*2^3+B4*2^4+B5*2^5+B6*2^6+B7*2^7+B8*2^8+B9*2^9+B10*2^10+B11*2^11+

B12*2^12+B13*2^13+B14*2^14+B15*2^15+B16*2^16+B17*2^17+B18*2^18+B19*2^19+B20*2^20+B21*2^21+

B22*2^22+B23*2^23+B24*2^24+B25*2^25+B26*2^26+B27*2^27+B28*2^28+B29*2^29+B30*2^30+B31*2^31

Wobei B0 bedeutet den LSB und B31 den MSB der hex Zahl.

Die dec Zahl wird im D Register durch "AddDC" gebildet. In dem C Register befindet sich immer die laufende 2^X. Am Anfang wird dort 1=2^0 geladen. Da die nächste zu addierende dec Zahl immer gleich 2* vorherige ist, wird sie einfach so berechnet, dass die aktuelle aus C Register ins B Register kopiert ("CopyCB") und zum C addiert ("AddCB") wird. Diese dec Zahl wird zum D Register addiert nur wenn entsprechender Bit der hex Zahl gleich 1 ist. Weil im UP "Hex_Dec" immer das bit A0 dafür geprüft wird, wird das gesamte 32-bittige A Register nach jeder Addition "AddDC" um ein Bit mit "ARotRb" nach rechts rotiert. Die Flags "_Fcra" und "_Fcrp" übertragen die Bits zwischen den 8 Bit Register A0, A1, A2 und A3. Es würde zwar reichen, wenn das A Register nur verschoben würde, aber hier wurde Rotation gewählt, damit nach der Wandlung die hex Zahl im A Register unverändert steht.

#define _C STATUS,C
#define _Z STATUS,Z
#define _DC STATUS,DC
#define _Fcra Flags,0
#define _Fcrp Flags,1
#define _Fdca Flags,2
#define _Ferr Flags,3 ;Überlauf (Fehler)
;..................................................................................
A3 EQU 0x20 ;Register fürs Rechnen
A2 EQU 0x21
A1 EQU 0x22
A0 EQU 0x23
B3 EQU 0x24
B2 EQU 0x25
B1 EQU 0x26
B0 EQU 0x27
C3 EQU 0x28
C2 EQU 0x29
C1 EQU 0x2A
C0 EQU 0x2B
D3 EQU 0x2C
D2 EQU 0x2D
D1 EQU 0x2E
D0 EQU 0x2F
Flags EQU 0x30
ATmp EQU 0x31 ;Schleifenzähler
HTmp EQU 0x32 ;Schleifenzähler
RTmp EQU 0x33 ;Zwischenspeicher
;..................................................................................
Hex_Dec call CClr ;Hex>A, D>Dec
call DClr
movlw 1
movwf C0
movlw 0x20 ;32 bit Hex > 32 bit Dec (8 Stellen)
movwf HTmp
HexDecL btfsc A0,0
call AddDC
call CopyCB
call AddCB
call ARotRb
decfsz HTmp,1
goto HexDecL
return
CClr clrf C0
clrf C1
clrf C2
clrf C3
return
DClr clrf D0
clrf D1
clrf D2
clrf D3
return
CopyCB movf C0,0
movwf B0
movf C1,0
movwf B1
movf C2,0
movwf B2
movf C3,0
movwf B3
return
AddCB movlw B0 ;C+B>C
movwf FSR
goto AddR
AddDC movlw C0 ;D+C>D
movwf FSR
AddR bcf _Ferr ;Addiere zwei Register
bcf _Fcrp
movlw 4 ;X=4 Bytes lang
movwf ATmp
AddRL bcf _Fdca
bcf _Fcra
movf INDF,0
movwf RTmp
movlw 4 ;X=4
addwf FSR,1
btfss _Fcrp
goto AddRN
movlw 1
addwf INDF,1
call DecCor
AddRN movf RTmp,0
addwf INDF,1
call DecCor
btfss _Fdca
goto AddCor1
movlw 6
addwf INDF,1
AddCor1 btfss _Fcra
goto AddCor2
movlw 0x60
addwf INDF,1
btfsc _C
bsf _Fcra
AddCor2 movf INDF,0
andlw 0xF0
sublw 0xA0
btfss _Z
goto AddCor3
movf INDF,0
andlw 0x0F
clrf INDF
addwf INDF,1
bsf _Fcra
AddCor3 bcf _Fcrp
btfsc _Fcra
bsf _Fcrp
movlw 5 ;X+1=5
subwf FSR,1
decfsz ATmp,1
goto AddRL
btfsc _Fcra
bsf _Ferr
return
DecCor btfsc _DC ;dezimale Korrektur (equ DAW)
bsf _Fdca
btfsc _C
bsf _Fcra
movf INDF,0
andlw 0x0F
sublw 9
btfss _C
bsf _Fdca
movf INDF,0
andlw 0xF0
sublw 0x90
btfss _C
bsf _Fcra
return
ARotRb movlw A3 ;rotiere A register 1 Bit rechts
movwf FSR
RRotRb movlw 4 ;rotiere X=4 Bytes
movwf ATmp
bcf _Fcrp
btfsc A0,0
bsf _Fcrp
RRotRbL bcf _Fcra
btfsc INDF,0
bsf _Fcra
bcf _C
btfsc _Fcrp
bsf _C
rrf INDF,1
bcf _Fcrp
btfsc _Fcra
bsf _Fcrp
incf FSR,1
decfsz ATmp,1
goto RRotRbL
return

=== EEPROM ===

Alle PICs besitzen EEPROM in dem je nach Typ können 64 bis 256 Databytes abgespeichert werden. Die Adressierung des EEPROMs fängt immer mit 0x00 an. Hier werden nur geprüfte UPs kurz erklärt. Die ersten zwei brauchen nur ein Register "Temp" für Schleifenzähler, dessen Name, falls im Programm schon existiert, geändert werden muss. Die Adresse im EEPROM ist gleich der Adresse im RAM.

EEPROM beschreiben:

EEWrite movlw 0x20 ; ab der RAM Adresse wird in EEPROM abgespeichert
movwf FSR
movlw 4 ; soviel Bytes
movwf Temp ; Schleifenzähler
EEWLoop call EEWrite1
incf FSR,1 ; nächste Adresse
decfsz Temp,1
goto EEWLoop
return

EEWrite1 bcf INTCON,GIE ; Interrupts sperren
movf FSR,0
bsf STATUS,RP0 ; auf Bank1 umschalten
movwf EEADR ; EEPROM Adresse
movf INDF,0
movwf EEDATA ; EEPROM Data
bsf EECON1,WREN
movlw 0x55
movwf EECON2
movlw 0xAA
movwf EECON2
bsf EECON1,WR
bcf EECON1,WREN
btfsc EECON1,WR
goto $-1 ; warten bis WR=0
bcf STATUS,RP0 ; zurück auf Bank 0 umschalten
bsf INTCON,GIE ; Interrupts erlauben
return

EEPROM lesen und zurück in RAM schreiben:

EERead movlw 0x20 ; ab der Adressse wird aus EEPROM in RAM abgelegt
movwf FSR
movlw 4 ; soviel Bytes
movwf Temp ; Schleifenzähler
EERLoop call EERead1
incf FSR,1 ; nächste Adresse
decfsz Temp,1
goto EERLoop
return

EERead1 movf FSR,0
bsf STATUS,RP0 ; auf Bank1 umschalten
movwf EEADR ; EEPROM Adresse
bsf EECON1,RD
movf EEDATA,0 ; EEPROM Data
bcf STATUS,RP0 ; zurück auf Bank 0 umschalten
movwf INDF
return

Tabelle im EEPROM mit MPASM Direktive "de" erstellen:

org 0x2100 ; EEPROM initialisieren
; nachfolgend als Kommentar die EEPROM Adressen
de 0x03, 0xE8 ; 0x00
de 0x03, 0xE8 ; 0x02
de 'M','H','z',0x00 ; 0x04
de ' ',' ','W','A','I','T',0x00 ; 0x08
de 'C','o','n','s','t',' ','X',0x00 ; 0x0F
de 'C','=',0x00 ; 0x17
de 'L','=',0x00 ; 0x1A
de 'F','=',0x00 ; 0x1D
de 'O','K',0x00 ; 0x20
u.s.w.

Wenn die Tabelle sich im Quellcode befindet, wird sie beim brennen des PICs in EEPROM eigeschrieben.

Das Lesen eines Strings muss ab entsprechender EEPROM Adresse (z.B. für "MHz" -> 0x04) anfangen und auf dem Wert 0x00, der hier als Stringende dient, enden. Einfacher ist, wenn alle Strings gleich lang sind (wie z.B. in einem Zeichengenerator fur Grafikdisplay).

Die Adreesse "0x2100" in der "org" Direktive hat mit der Adresse im Programmspeicher nichts zu tun.

=== Interrupts ===

Das Programmteil misst eine Frequenz an TOCKI Pin und wurde für PIC16F870 geschrieben.

Benötigte Hardware: Widerstand 470 Ohm zwischen der Frequenzquelle und TOCKI Pin (A4).

Es fehlen UPs "Hex_Dec" [[#Hex Dec Wandlung|Hex Dec Wandlung]] und Ausgabe auf ein Display "DispFrq". Das HP ("Main") als leere endlose Schleife macht nichts ausser warten auf ein Interrupt von Timer0 bzw. Timer1. Man kann die Marke "Main" weglassen und das HP als "goto $" formulieren.

Der Zähler der Frequenz wurde um ein Zähler aus zwei zusätzlichen Register A2 und A3 erweitert und bei jedem Timer0 Überlauf erhöht. Der Prescaler wird ins Register A0 und der TIMER0 ins A1 kopiert. Somit ergibt sich 32-bittiger Ergebniss, der als hex Zahl in den Register A3 (MSB),A2, A1, und A0 (LSB) steht. Nach der "Hex_Dec" Wandlung kann die Frequenz aus den Register D3 (MSB), D2, D1 und D0 (LSB) an einem biliebigen Display angezeigt werden.

Es wird kein zusätzliches Register benötigt, da das "ATmp" und das "RTmp" die gleichen wie im UP "Hex_Dec" sind. Die Quarzfrequenz wurde gewählt, weil sie am nächsten der Temperaturstabiltesten Frequenz für AT Quarzen 7,2 MHz ist. Der PIC16F870 wurde nur wegen nötigen 19 I/O Pins für 6-stelligen 7-segment LCD Display LPH2673-1[[http://www.roboternetz.de/phpBB2/viewtopic.php?t=26005]] (ohne Kontroller) vom Pollin angewendet. Mit einem üblichen 1x16 Zeichen LCD Matrixdisplay und anderen PICs wurde das Programm für Frequenzen bis zum 100 MHz mit einer Genauigkeit
+/- 4 Hz positiv getestet.

Um die Frequenz mit Genauigkeit +/- 1Hz zu messen, muss die Messzeit 1 s von Timer1 erzeugt werden, das nur für Quarz bis 2,048 MHz möglich ist. Für sehr genaue Messungen wird empfohlen als Taktfrequenz für den Timer1, die Trägerfrequenz eines nächsten LW Senders (z.B. DLF 153 bzw. 207 kHz) zu nutzen. Die Genauigkeit der Frequenz ist ca. 1E-11 und geprüfter Empfänger kann laut der Skizze in [[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=13706&highlight=frequenzz%E4hler]] nachgebaut werden. In dem Fall müssen die Register vom Timer1 (TMR1H und TMR1L) vor seinem Start entsprechend geladen werden.

Mit dem Quarz 7,3728 MHz wird hier die Messzeit 0,25 s genutzt und die gemessene Frequenz durch 4 multipliziert (mittels 2 Additionen), was die Auflösung von +/- 4 Hz ergibt.

Das UP "Init" muss selbstverständlich für ein Matrixdisplay um Initialisierung des Displaykontrollers ergänzt werden.

; Programm zum Messen der Frequenz an T0CKI Pin mit 7,3728 MHz Quarz
LIST P=16F870
include "P16F870.inc"
__CONFIG _CP_OFF & _DEBUG_OFF & _WRT_ENABLE_ON & _CPD_OFF & _LVP_OFF & _BODEN_OFF &
_PWRTE_ON & _WDT_OFF & _HS_OSC
ORG 0x0000
call Init
Main goto Main
ORG 0x0004 ;ISR (interrupt service routine)
bcf INTCON,GIE ;interrupts sperren
btfss INTCON,T0IF ;ist Timer0 übelaufen ?
goto CheckTMR1 ;nein, dann prüfe Timer1
bcf INTCON,T0IF ;Timer0 interrupt flag löschen
movlw 1
addwf A2,1 ;erhöhe A2
btfsc STATUS,C
incf A3,1 ;increment A3, wenn A2 überlaufen ist
CheckTMR1 btfss PIR1,TMR1IF ;ist Timer1 überlaufen ?
retfie ;wenn nicht, springe zurück zu Main
bsf STATUS,RP0 ;stopp Timer0
movf TRISA,0
andlw 0xEF
movwf TRISA ;TOCKI Pin (A4) als Ausgang
bcf STATUS,RP0
bcf T1CON,TMR1ON ;stopp Timer1
bcf PIR1,TMR1IF ;Timer1 interrupt flag löschen
GetFreq movf TMR0,0 ;Prescaler ins Register A0 kopieren
movwf A1
movwf RTmp
clrf ATmp
FToggle incf ATmp,1
bsf STATUS,RP0
bsf OPTION_REG,T0SE
bcf OPTION_REG,T0SE
bcf STATUS,RP0
movf TMR0,0
subwf RTmp,0
btfsc STATUS,Z
goto FToggle
comf ATmp,1
incf ATmp,0
movwf A0
call Hex_Dec
clrf A3 ;Register A löschen
clrf A2
clrf A1
clrf A0
call CopyDC
call AddDC ;gemessene Frequenz * 2
call CopyDC
call AddDC ;gemessene Frequenz * 4 = tatsächliche Frequenz
call DispFrq ;eigenes UP für benutztes Display
clrf TMR0 ;Timer0 löschen
movlw 0x34 ;Timer1
movwf T1CON ;konfigurieren
movlw 0x1F ;Timer1 laden (für 0,25 s)
movwf TMR1H
clrf TMR1L
bsf STATUS,RP0 ;start Timer0
movf TRISA,0
iorlw 0x10
movwf TRISA ;TOCKI Pin (A4)als Eingang
bcf STATUS,RP0
bsf T1CON,TMR1ON ;start Timer1
retfie ;erlaube interrupts und springe zurück zu Main
CopyDC movf D0,0
movwf C0
movf D1,0
movwf C1
movf D2,0
movwf C2
movf D3,0
movwf C3
return
Init clrf PORTA ;Ports löschen
clrf PORTB
clrf PORTC
movlw 0x20 ;RAM (20-7Fh) löschen
movwf FSR
clrf INDF
incf FSR,1
btfss FSR,7
goto $-3
clrf ADCON0 ;schalte ADC off
movlw 7 ;sperre ADC
movwf ADCON1 ;und definiere RA0-7 als digitale I/Os
movlw 0xE0 ;GIE, PEIE & TMR0IE erlauben
movwf INTCON
bsf STATUS,RP0 ;bank 1
movlw 0xEF ;alle PORTA Pins als Eingänge
movwf TRISA ;nur TOCKI (A4) als Ausgang
clrf TRISB ;alle PORTB
clrf TRISC ;und PORTC Pins als Ausgänge
movlw 0xE7 ;Takt für Timer0 vom T0CKI Pin
movwf OPTION_REG ;Timer0 konfigurieren
bsf PIE1,TMR1IE ;TMR1 interrupt erlauben
bcf STATUS,RP0 ;Bank 0
clrf TMR0 ;Timer0 löschen
movlw 0x34 ;Timer1 konfigurieren
movwf T1CON ;(prescaler 8)
movlw 0x1F ;Timer1 laden (für 0,25 s)
movwf TMR1H
clrf TMR1L
bsf STATUS,RP0 ;start Timer0
iorlw 0x10
movwf TRISA ;TOCKI Pin (A4) als Eingang
bcf STATUS,RP0
bsf T1CON,TMR1ON ;start Timer1
return
end

=== Mausrad ===

Das UP wertet ein Mausrad aus und setzt, je nach Drehrichtug und sein Anschluss an PORT (PORTA,0 und PORTA,1), ein Flag "_Finc" bzw. "_Fdec", das vor der nächsten Abfrage, gelöscht werden muss. Zum Auswerten werden 3 Register "MausA", "MausB" und "MausC" benötigt. Als "_Z" wurde "STATUS,Z" definiert. Die Warteschleife "Delay" dient der Entprellung der Kontakte und soll ca. 10ms sein.

In dem UP "Mouse" wird PORTA eigelesen, die alle Bits ausser 0 und 1 durch "and" Funktion gelöscht und in den Register "MausB" und "MausC" gespeichert. Nach ca. 10ms wird das gleiche gemacht und im Register "MausA" gespeichert. Der Wert aus "MausA" wird mit dem vorherigen aus "MouseC" durch "xor" verglichen. Sind sie nicht identisch, wird je nach dem Wert "X" (0, 1, 2, b.z.w. 3) im "MausB" in das entsprechende UP "MouseX" gesprungen. Sonst wenn "MausA"="MausC", wird zum Aufrufer zurückgekehrt.

In einem UP "MouseX" wird der letzte Wert im "MausA" ermittelt und nach der Kombination der Werte im "MausB" und "MausA" (10 b.z.w. 20, 01 b.z.w. 31, 02 b.z.w. 32 oder 13 b.z.w. 23) entsprechendes der Drehrichtung Flag "_Finc" b.z.w. "_Fdec" gesetzt. Anschliessend wird zum Aufrufer zurückgesprungen.

Detailierter PAD:

Mouse V
PORTA->W
3 and W->W
W->MausB
W->MausC
Warten 10ms
PORTA->W
3 and W->W
W->MausA
W xor MausC->MausC
_Z=1 ? J > return
N
V
MausB->MausB
.--------------------------< J _Z=1 ?
| N
| V
| MausB->W
| W-1->W
| .----< J _Z=1 ?
| | N
| | V
| | MausB->W
| | W-2->W
| | _Z=1 ? J >---------------------------.
| | N |
| | V |
| | MausB->W |
| | W-3->W |
| | _Z=1 ? J >-----. |
| | N | |
| | V | |
| | return | |
| | | |
| | | |
Mouse0 V Mouse1 V Mouse3 V Mouse2 V
MausA->W MausA->MausA MausA->W MausA->MausA
W-1->W V W-1->W V
_Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--.
J | J | J | J |
V | V | V | V |
setze _Fdec | setze _Finc | setze _Finc | setze _Fdec |
V<-----´ V<-----´ V<-----´ V<-----´
MausA->W MausA->W MausA->W MausA->W
W-2->W W-3->W W-2->W W-3->W
_Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--.
J | J | J | J |
V | V | V | V |
setze _Finc | setze _Fdec | setze _Fdec | setze _Finc |
V<-----´ V<-----´ V<-----´ V<-----´
return return return return

und Quellcode:

Mouse movf PORTA,0
andlw 3
movwf MausB
movwf MausC
call Delay ; ca. 10 ms
movf PORTA,0
andlw 3
movwf MausA
xorwf MausC,1
btfsc _Z
return
movf MausB,1
btfsc _Z
goto Mouse0
movf MausB,0
sublw 1
btfsc _Z
goto Mouse1
movf MausB,0
sublw 2
btfsc _Z
goto Mouse2
movf MausB,0
sublw 3
btfsc _Z
goto Mouse3
return
Mouse0 movf MausA,0
sublw 1
btfsc _Z
bsf _Fdec
movf MausA,0
sublw 2
btfsc _Z
bsf _Finc
return
Mouse1 movf MausA,1
btfsc _Z
bsf _Finc
movf MausA,0
sublw 3
btfsc _Z
bsf _Fdec
return
Mouse2 movf MausA,1
btfsc _Z
bsf _Fdec
movf MausA,0
sublw 3
btfsc _Z
bsf _Finc
return
Mouse3 movf MausA,1
sublw 1
btfsc _Z
bsf _Finc
movf MausA,0
sublw 2
btfsc _Z
bsf _Fdec
return

=== Handy Display ===

Als Beispiel die Hardware und Testprogram für Nokia 3310/3330 Display: [[http://www.roboternetz.de/phpBB2/viewtopic.php?p=124669#124669]]

== Hilfsmittel ==

=== PIC Miniterminal ===

Das ist eine Schnittstelle, die nur 2 Leitungen zum Anschluss an PIC braucht. Sie ermöglicht Steuern von diversen LCD Displays mit üblichem Anschluss ("RS", "Enable" und 8 Databits) und Abfragen von 3 Tasten.

Hardware und Testprogramm: [[http://www.roboternetz.de/phpBB2/viewtopic.php?p=124559#124559]]

[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Category:PIC]]

Diskussion:PIC Assembler

2007-04-25T19:44:00Z

Andy:

== vorgeschlagene Gliederung ==

grün = schon fertig, orange = wird bzw. könnte noch ergänzt werden

* Einladung zur Diskussion...
(wird nach Beendigung des Artikels gelöscht)
* Einführung
** Bit, Byte, Nibble, Bin und Hex 
** Speicher und Register 
** Prozessor
** Assembler
** Grundbeschaltung
** Konfiguration
** Wahl des PICs
* Programm
** Allgemeines
** Programdurchlaufdiagram
** Hauptprogramm
** Unterprogramm
*** Initialisierung
**** Variablen
**** I/O Ports
**** Hardware
*** Einlesen
*** Ausgeben
*** Schleifen
*** Pause
*** Tabellen
*** Schnittstellen und Treiber
* Vorlage für MPASM
* Das erste...
* Für anderen PIC umschreiben
* Einbinden
* Interrupt
** Prinzip
** Quellen
** Interrupt Service Routine
* Optimierung
** Speicherbedarf
*** Programmspeicher
*** RAM
** Ausführungszeit
* Fehlersuche
* Mid-Range (mit 14 bit Befehlslänge)
** Kurzübersicht Prozessorbefehle
** Ausführliche Beschreibung zu den Befehlen
** Besondere, oft gebrauchte Register
*** STATUS 
*** INTCON 
*** TRIS 
*** PORT 
** Bänke (sowohl die bei mehr als 2k Befehle als auch die bei den normalen speicher bänken)
** Flagsüberprüfung im STATUS-Register
** Codeschnipsel
*** A/D-Wandler 
*** Hex Dec Wandlung
*** EEPROM
*** PWM
*** Interrupts
*** RS232 mit PC
*** Mausrad
*** Handy Display
** Hilfsmittel
*** PIC Miniterminal (mit Dot-Matrix LCD und drei Tasten, benötigt nur 2 I/O Pins vom PIC) (Hardware)
*** PIC RAM Monitor (mit eigenem Interrupt, zeigt Registerinhalte sogar wenn das Programm in endloser Schleife läuft, was besonders für Anfänger nutzlich ist, benötigt PIC Miniterminal)
*** PIC Trainer (Hilfswerkzeug für PIC Versuchsprogramme, benötigt PIC Miniterminal)
*** PIC Profiler (zum messen von Ausführungszeit zwischen call und return, benötigt Display oder PIC Miniterminal)
* High-End (mit 16 bit Befehlslänge)-->(?)

== Allgemeines ==
-------
... gelöschte Diskussion ...
----
joa. passt doch. ich mach dir dann wieder paar bilder. mal schaun ob ich es heute noch schaffe. [[Benutzer:Benedikt.Seidl|Benedikt.Seidl]] 08:52, 1. Apr 2007 (CEST)
-----
Vielen Dank im voraus!:) Wenn Du die drei Symbole die im PAD auftreten einzeln kopieren kannst, müsste es ziemlich schnell gehen. Nach der neuer Gliederung müsste ich jetzt über Quellcode schreiben, also schon (aber nur) "call" und "goto" einführen. Sonst werde ich alles im Textform (Kommentar) schreiben. Ich meine, dass es unvermeindbar ist, weil irgendwan es sowieso anfangen wird. Ich habe noch eine Frage an Dich. Würdest Du die MPASM Direktiven erklären, die ich von "deinem" in "mein" Teil verschoben habe?[[Benutzer:PICture|PICture]] 09:33, 1. Apr 2007 (CEST)
-----
wie meinst du? ich mache halt noch eine erklärung für alle befehle, brauche nur noch bisschen zeit, werde heute leider nicht dazukommen, da ich unterwegs bin :-/ aber in absehbarer zeit werde ich auch noch die anderen befehle beschreiben, und dann mir ein neues thema suchen ;-) [[Benutzer:Benedikt.Seidl|Benedikt.Seidl]] 18:54, 1. Apr 2007 (CEST)
------
Es hat sich schon erledigt. Ich habe es als unnötig gestuft und gelöscht. Ab jetzt wird ganz einfache Darstellung von PADs verwendet und es bleibt nur einer in Grafik zu verwandeln (PAD). Die alle anderen (PAD1, PAD2, PAD3, PAD4, und die noch kommen...) bleiben so, wie sie sind/werden. Und weiter würdest Du (hoffentlich) nichts mehr für mich zu tun haben. :)[[Benutzer:PICture|PICture]] 00:12, 2. Apr 2007 (CEST)
------
jetzt wollte ich mir ein neues thema raussuchen, was ich noch schreiben könnte, aber muss irgendwie zugeben, dass ich mit den befehlen schon mit meinem latein am ende bin :-/ also ich könnte schon bisschen was schreiben, aber so richtig sicher bin ich mir dabei dann nicht immer. [[Benutzer:Benedikt.Seidl|Benedikt.Seidl]] 12:25, 5. Apr 2007 (CEST)
------
Macht ja nichts. Wir arbeiten an dem Artikel bis zum Ende zusammen. Du hast mir schon viel geholfen, dann helfe ich Dir auch immer wieder. Ich versuche möglichst kurz das wichtigste schreiben, aber weiss ich selber nicht, ob das verständlich ist, da ich das alles sehr gut verstehe :). Was Dir nicht gefällt oder nicht genug verständlich ist kannst Du immer ändern (so wie bei der Grundbeschaltung) oder fragen (so wie mit den Buchstaben "C" und "F"). Wie Du sicher bemerkt hast, habe ich in den Befehlen auch ein bischen geändert. Jemand hat gesagt : "Es gibt keine dumme Fragen, nur dumme Antworten" und das stimmt!. Also keine Angst! :) Es gibt auch PN. Für mich ist Deine Meinung sehr wichtig! Ich denke, dass bis Interrupts sollte es schon für Anfänger ausreichen, bin mich aber auch nicht sicher wo eigentlich Ende vom Anfang ist. :) [[Benutzer:PICture|PICture]] 14:24, 5. Apr 2007 (CEST)
-----
wow! respekt! geht ja ganz schön schnell voran. das eine pad bekommst du auf jeden fall noch, brauche leider noch ein paar tage. noch dazu müsste ich langsam wirklich fürs abi lernen, aber solange noch andere dinge gehen, werde ich auch hier noch bisschen was machen ;-) [[Benutzer:Benedikt.Seidl|Benedikt.Seidl]] 12:37, 8. Apr 2007 (CEST)
-----
Mach Dir bitte mit dem Artikel keinen Stress, ich versuche bloss die freie Tage sinvoll nutzen.:). Es wird danach langsamer gehen, aber die Zeit ist nicht beschränkt. Sogar für die schon als fertig markierte Sachen schreibe ich immer wieder was dazu, was mir noch einfällt.[[Benutzer:PICture|PICture]] 16:11, 8. Apr 2007 (CEST)
----
Bit, Byte, Nibble, Bin und Hex
also ich würde schon die nummerierung der bits mit aufnehmen. habe mich lange gefragt, wie das funktioniert, weil man ja normalerweise von links nacht rechts zählt und mit 1 anfängt. [[Benutzer:Benedikt.Seidl|Benedikt.Seidl]] 21:28, 9. Apr 2007 (CEST)
----
Natürlich! :) Die Numerierung der Bits ist bei jedem Prozessor gleich und fängt immer von links mit 0 (LSB). Ich habe schon eine Idee für erstes ASM Programm, das wird aber noch ein bischen dauern, weil ich das zuerst selber ausprobieren muss (und will). Aber es ist noch weit zum Ende des Artikels. [[Benutzer:PICture|PICture]] 09:27, 10. Apr 2007 (CEST)
----
mein fehler. habe da wohl was verwechselt. sorry. die zahlen sind ja doch noch da :-/ [[Benutzer:Benedikt.Seidl|Benedikt.Seidl]] 12:52, 10. Apr 2007 (CEST)
----
@Benedikt.Seidl

Schau, bitte, am Anfang des Artikels habe ich noch was neues eingefügt. Als Folge haben wir noch einen Autor (den Gärtner), der schon wichtige Sachen toll ergänzt hat.

@Gärtner

Wenn Du willst, kannst auch etwas neues, wass noch nicht grün gekenzeichnet ist, anfangen. :)
[[Benutzer:PICture|PICture]] 13:17, 10. Apr 2007 (CEST)
----
wow! glückwunsch! http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=14953 [[Benutzer:Benedikt.Seidl|Benedikt.Seidl]] 16:13, 10. Apr 2007 (CEST)
----
Für Dich das gleiche ! Trotzdem schreibe ich weiter.:)[[Benutzer:PICture|PICture]] 16:59, 10. Apr 2007 (CEST)
----
Keine Angst, hab auch neues geschrieben ;) Hat wer eine bessere Idee bezüglich Textformation von SFRs? hab mich mal am Datenblatt bedient. Die Assemblerbefehle hab ich heute schon in einen eigenen Artikel geschrieben. Da fehlen nur noch Codeschnippsel. find das Übersichtlicher und werde die DETAILs zu den befehlen von hier bald RAUSLÖSCHEN. (wenn ich mit dem anderen Artikel fertig bin.) --[[Benutzer:Der Gärtner|Der Gärtner]] 18:06, 10. Apr 2007 (CEST)
----
:Die Asführliche Beschreibung zu den Befehlen hat der Benedikt.Seidl geschrieben, aber ich glaube, dass er nichts dagegen hätte. Dann werden die Codeschnipsel auch dorthin verschoben, oder ? Es wäre gut wenn Du das Link zu Deinem Artikel in diesen Artikel einfügst. Ich weiss nicht wo ich später die Hifsmittel (kleine Programmierwerkzeuge) hin schreiben soll.[[Benutzer:PICture|PICture]] 18:33, 10. Apr 2007 (CEST)
----
:ich finde es schon sehr schade, weil das schon viel arbeit gemacht hat hier. das tabellenlayout hat auch vor und nachteile. aber ich versteh nicht, warum du nicht auf meine beschreibung und code-schnipsel zurückgreifst, bzw. meine befehlsliste ergänzt hast? deine infos bzw. beschreibungen sind wahrscheinlich schon technischer und auch ok, aber für den normalen benutzer oder einsteiger sehe ich es eher als hindernis, wenn so komplizierte beschreibungen verwendet werden.
: trotzdem finde ich es schön, dass du mitarbeitest, gärtner ;-) [[Benutzer:Benedikt.Seidl|Benedikt.Seidl]] 19:18, 10. Apr 2007 (CEST)
----
@ Gärtner

Ich denke auch, dass Löschen nicht nötig ist und Dein Artikel wunderbar als Nachschlagewerk benutzt werden kann, wenn sein Link in diesem Artikel eingefügt wird.[[Benutzer:PICture|PICture]] 19:31, 10. Apr 2007 (CEST)
----
@ Gärtner

Erst heute habe ich Dein Artikel aufmerksam durchgelesen und folgendes nicht gut gefunden:

- die Wörter "verundert", "verodert" und "inklusiv verodert" sind vielleicht "cool" aber für jemanden die die logische Operationen gar nicht kennt, ganz unverständlich.

- bei "call" und "retlw" ist überhaupt nichts über funktionsweise im ASM Programm geschrieben, nur über Register, was nicht besonders wichtig ist. Bei "retfie" fehlt die wichtige Information, dass ausführen des Befehls das Bit GIE setzt, was die Interrupts wieder erlaubt.

- bei "clrw" ist falsches Register und bei "end" falsche Funktion gennant. Ausserdem, ich kenne Keine Pseudobefehle, sondern Direktiven für Assemblerprogramm.

Ohne Beipielen vom Code finde ich das ganze ungeeignet für Anfänger. Bleiben wir, bitte, in dem Artikel, der vor allem für Anfänger vorgesehen ist, bei der ausführlicher Beschreibung vom Benedikt.Seidl.[[Benutzer:PICture|PICture]] 09:08, 11. Apr 2007 (CEST)
----
Code kommt noch, und fehler sind echt vorprogramiert gewesen :)
Ich hab noch einiges an Dingen vor gehabt, die sowieso hier stehen. Die Begriffe "verundet" und "verodert" sind die einzigen, die ich jemals gehört habe, und JA, ich hab vor beispiele zu Schreiben / vom Seidl zu nehmen. Und wenn ich so scharf aufs Löschen wäre, dann hätt ichs schon gemacht :P

Den Begriff "Pseudobefehle" hab ich vom Sprut, kann ich ruhig ändern.

Werd heute da einiges ergänzen und die Register in diesem Beitrag weiter machen.
--[[Benutzer:Der Gärtner|Der Gärtner]] 11:09, 11. Apr 2007 (CEST)
----
@Gärtner

Das hört sich sehr gut an. Deine Beschreibung von Befehlen ist auch nötig, da kann man sofort die Beschreibung für ein Befehl lesen, das man braucht. Sie hat aber sehr langen Inhaltverzeichnis, länger, als dieser ganzen Artikel. Deswegen finde ich die Idee, das getrennt vom Artikel zu machen sehr gut.:) Übrigens, für mich ist der Sprut kein Experte und ich versuche immer mich an der Dokumentation vom Microchip (z.B. MPASM) zu halten um das ganze einheitlich zu gestalten. Es wäre auch eine Möglichkeit, um unnötige Arbeit zu vermeinden, einfach die ganze Beschreibung vom Seidl in Dein Artikel zu übernehmen (eventuell bischen ergänzen) und danach von unserem Artikel löschen und in dem Menüpunkt "Ausführliche Beschreibung zu den Befehlen" nur den Link zu Deinem Artikel lassen. Das scheint mir sogar optimale Lösung zu sein. Ich habe genauso bei "Interface und Treiber" gemacht. Ich werde erst am Wochenende wieder aktiv.[[Benutzer:PICture|PICture]] 19:02, 11. Apr 2007 (CEST)
----
Habe den Register INTCON beschrieben... --[[Benutzer:Der Gärtner|Der Gärtner]] 09:07, 12. Apr 2007 (CEST)
----
Habe schon dort bischen geändert... Hoffentlich gefällt Dir. :)[[Benutzer:PICture|PICture]] 09:56, 12. Apr 2007 (CEST)
----
Ich würde die Register ANSEL und TIMER nicht speziell und so alleine beschreiben. Die gehören entweder zu den ADCs oder zu den einzelnen Timern. "ANSEL" ist z.b. einer von mind. 4 Registern, die von den ADCs benutzt werden. das Selbe gilt für Timer (stichwort TMR0-2 unterschiedliche Architektur/CCPM/PWM...)

@PICture: passt sehr gut, man sieht ich hab die Matura, aber auch, dass ich NICHT in Deutsch maturiert habe - da fehlts an Retorik, Grammatik und Einfühlungsvermögen für nichteingeweihte beim schreiben ;)
--[[Benutzer:Der Gärtner|Der Gärtner]] 22:48, 12. Apr 2007 (CEST)
----
Kleine Frage am Rande, alle Pins an allen Ports der Midrangeserie sind BIDIREKTIONAL - oder...? Ich bin über einen 18F gestolpert, der da aus der Reihe tanzt. (4550er, die USB-Pins...)--[[Benutzer:Der Gärtner|Der Gärtner]] 22:53, 12. Apr 2007 (CEST)
-----
@Gärtner

"Nobody is perfect". Beim jedem Lesen des Artikels finde ich Fehler die ich bisher übersehen habe. Überprüfe noch Deine Logiktabelle für XOR. So wie ich weiss, 1,1->0. XAND kenne ich nicht.

Wenn es um Mid-Range PICs geht, da sind alle Pins an allen Ports bidirektional. Aber bei fast allen diesen PICs gibt es einen Portpin, der nur open drain ist (z.B. beim 12F629 GPIO,3) und ohne pull-up keine 1 ausgeben kann. Übrigens, was sind "Fusebits" ? Ich (und wahrscheinlich jeder Anfänger auch) habe noch nicht gehört. Ich vermute, dass sich hier um "configuration bits" handelt, es müsste aber irgendwo in unserem Artikel definiert werden. Vielleicht am Ende des Artikels machen wir noch ein "Wörterbuch" für Anfänger ?

Ich freue mich sehr, dass immer mehr Autoren des Artikels gibt. Der nächste, aber fast sicher nicht der letzte, ist der BMS, der gerade ein Codeschnipsel für ADC geschrieben hat. Je mehr Autoren um so besser. Die vorgeschlagene Gliederung ist noch offen und kann jederzeit von jedem geändert werden (z.B. bei der Registerbeschreibung)

@BMS

Dein Codeschnipsel finde ich sehr gut, nur Kleinigkeit gefällt mir nicht: die Kommentare zu den Befehlen befinden sich dazwischen und nicht wie üblich rechts, was den Codefragment schwer durchschaubar macht. [[Benutzer:PICture|PICture]] 07:50, 13. Apr 2007 (CEST)
----
@Gärtner

Heute früh habe ich Deinen Artikel durchgelesen und mehrere Fehler gefunden. [[Benutzer:PICture|PICture]] 07:20, 14. Apr 2007 (CEST)
----
codeschnipsel werd ich gleich ändern (kommentare)
bin erst wieder am montag da
[[Benutzer:BMS|BMS]] 13:35, 17. Apr 2007 (CEST)
----
@BMS

Ich habe wieder "ein bischen" geschrieben. Wenn Du Zeit hättest, lese es, bitte, durch und eventuell verbessere oder lösche was Du nicht gut findest. Vielen Dank im voraus.:)[[Benutzer:PICture|PICture]] 10:21, 23. Apr 2007 (CEST)
----

zu: Erklärungen in diesem Artikel. 
Begriffe wie Bit sind schon umfangreich an anderer Stelle erklört, daher wäre es evtl. sinnvoller, lediglich einen Verweis dorthin vorzusehen, statt einer eigenen Erklärung. 
z.B. BIT: http://de.wikipedia.org/wiki/Bit 
Gruß Andreas

PIC Assembler

2007-04-25T19:35:14Z

Andy: /* Einladung zur Diskussion... */

= Einladung zur Diskussion... =

Es wird hier versucht die ASM Programmierung von PIC Mikrocontrollern zu beschreiben.

Damit der enstehende Artikel wirklich nützlich wird, ist Ihre Mitwirkung nötig. Bitte schreiben Sie uns Ihre Meinung, was eventuell noch geändert (z.B. ergänzt) werden soll in diesem Thread:

http://www.roboternetz.de/phpBB2/viewtopic.php?p=271211#271211

Die Autoren bedanken sich im voraus für jeden Beitrag mit Vorschlägen !

= Einführung =

== Bit, Byte, Nibble, Bin und Hex ==

Ein Mikrocontroller (kurz: µC) kann eigentlich nur durch ein Portpin eine Spannung einlesen bzw. ausgeben. Er kann aber nur erkennen, ob eine Spannung vorhanden ist oder nicht. Wenn fast keine Spannung vorhanden ist erkennt er das als 0 und wenn eine Spannung fast so gross, wie seine Versorgungsspannung anliegt, als 1.

Genauso bei der Ausgabe, wenn er 0 ausgibt ist auf dem Portpin fast keine Spannung, wenn 1, eine Spannung fast gleich gross seiner Versorgungsspannung. Und das ist ein Bit, die kleinste Menge einer Information. Der Bit ist binär, weil er nur zwei unterschiedliche Werte 0 bzw. 1 haben kann.

Wenn wir gleichzeitig (paralell) 8 Bits haben, dann ist es ein Byte, der 256 Bitkombinationen von 00000000b bis 11111111b enhält, weil ein Bit (X) auf jeder Stelle 0 bzw. 1 sein kann.

<table border=0 cellpadding=3 cellspacing=2>

<tr>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
</tr>

<tr>
<td colspan=4 align=middle bgcolor=#007fff>High Nibble </td>
<td colspan=4 align=middle bgcolor=#ff8305>Low Nibble </td>
</tr>
<tr>
<td colspan=8 align=middle bgcolor=#810f40> Byte </td>
</tr>
</table>

Das "b" bedeutet, das es sich um binäre (kurz: bin) Darstellung (auch Zahl genannt) handelt. Binäre Zahlen sind aber lang, weil jeder Bit eine Stelle benötigt.

Um die Schreibweise zu verkürzen, wurden hexadezimale (kurz: hex) Zahlen eingeführt. Zuerst wurde ein Byte auf zwei 4-Bit Halbbytes (Nibbles) verteilt und danach ein Nibble als Ziffer genommen. Weil 4 Bit mehr als 10 Kombinationen ergeben, haben die Ziffer 0 bis 9 aus dem Dezimalsystem (d) nicht ausgereicht und wurden um Buchstaben A bis F erweitert. Die hexadezimalen Zahlen haben ein "h" Zeichen am Ende. Für die Zahlen 0 bis 9 sind die (h) und
(d) Zeichen nicht nötig, da sie beide gleich den entsprechenden bin Zahlen sind.

Die Umwandlung zwischen bin, hex und dec Zahlen für ein Nibble zeigt folgende Tabelle:

0b = 0h = 0d 100b = 4h = 4d 1000b = 8h = 8d 1100b = Ch = 12d
1b = 1h = 1d 101b = 5h = 5d 1001b = 9h = 9d 1101b = Dh = 13d
10b = 2h = 2d 110b = 6h = 6d 1010b = Ah = 10d 1110b = Eh = 14d
11b = 3h = 3d 111b = 7h = 8d 1011b = Bh = 11d 1111b = Fh = 15d

Damit kann ein Byte mit zwei hex Ziffern definiert werden z.B. 1100 0011b = C3h. Für zwei Bytes braucht man 4 hex Ziffern z.B.

101 0111 1010 1001b = 57A9h, u.s.w. So wie im Dezimalsystem werden führende Nullen nicht geschrieben, aber in einem PIC Register existieren immer 8 Bits also auch führende Nullen. Zum Beispiel die hex Zahl 3h sieht im Register so aus: 00000011b. Bei einer Wandlung bin->hex fängt man immer von der rechten Seite der bin Zahl an, da die Anzahl führenden Nullen unbekannt ist.

== Speicher und Register ==

Als Speicher bezeichnet man ein Teil der Hardware, in die eine Information eingeschrieben, in der gespeichert und aus der wieder ausgelesen werden kann.

Es gibt eigentlich nur zwei Arten von elektronischen Speicher: flüchtige und nichtflüchtige. Die Information die sich im flüchtigen Speicher befindet, geht verloren, wenn die Versorgungsspannung des Speichers unterbrochen oder abgeschaltet wird. Bei PICs ist es Dataspeicher (RAM).

Wenn die Versorgungsspannung vom nichtflüchtigen Speicher abgeschaltet wird, ist die gespeicherte Information zwar momentan nicht lesbar, bleibt aber erhalten und sobald der Speicher wieder mit Spannung versorgt wird, kann sie ausgelesen werden. Ein PIC hat zwei solche Speicher: Programmspeicher (Flash) und EEPROM.

Der wichtigste Unterschied zwischen den Speicherarten ist, das die flüchtigen direkt (sehr schnell) beschreibbar sind und das Beschreiben den nichtflüchtigen benötigt spezielle Algorithmen, die leider im Vergleich zu direkten Zugriffen langsamer sind. Beim Auslesen gibt es praktisch keinen Unterschied.

Ein Speicher besitzt bestimmte Menge von s.g. Speicherstellen. Jede Speicherstelle hat seine individuelle Adresse und kann eine binäre Information mit bestimmter Anzahl von Bits abspeichern.

Bei PIC haben die drei Arten von Speicher, wegen verschiedener Anwendung, auch unterschiedliche Struktur. Die beiden Speicher für Daten (RAM und EEPROM) haben jeweils 8-bitigen und Programmspeicher (Flasch) bei Mid-Range hat 14-bitigen Speicherstellen. Die Anzahl den Speicherstellen im bestimmten Speicher ist vom PIC-Typ abhängig.

Eine 8-bitige Speicherstelle im RAM wird bei PICs Register genannt und kann so skiziert werden:

<table border=0 cellpadding=3 cellspacing=2>

<tr>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
<td align=middle bgcolor="#CCCCCC" style="border:1px solid #333333">X</td>
</tr>

<tr>
<td> MSB </td>
<td colspan=6></td>
<td> LSB </td>
</tr>

<tr>
<td bgcolor="#007fff">bit 7</td>
<td bgcolor="#007fff">bit 6</td>
<td bgcolor="#007fff">bit 5</td>
<td bgcolor="#007fff">bit 4</td>
<td bgcolor="#007fff">bit 3</td>
<td bgcolor="#007fff">bit 2</td>
<td bgcolor="#007fff">bit 1</td>
<td bgcolor="#007fff">bit 0</td>
</tr>

<tr>
<td colspan=4 align=middle bgcolor=#ff8305>High Nibble </td>
<td colspan=4 align=middle bgcolor=#ff8305>Low Nibble </td>
</tr>
<tr>
<td colspan=8 align=middle bgcolor=#810f40> Byte </td>
</tr>
</table>

Der bit 7 wird als hochwertigste (MSB = Most Significant Bit) und bit0 als niederwertigste (LSB = Least Significant Bit) bezeichnet. Jeder Bit im Register (X) kann gleich 0 bzw. 1 sein.

Um ein Databyte in ein Register schreiben oder aus einem Register lesen, muss zuerst das Register durch seine Adresse gewählt werden. Dafür gibt es beim PIC folgende Möglichkeiten:

Direkte Adressierung per absolute Adresse: movwf 0x20

Direkte Adressierung per vorher definierten Namen des Registers (z.B. Temp equ 0x20): movwf Temp

Indirekte Adressierung durch "FSR" Register, in den die absolute Adresse des Registers "Temp" eingeschrieben wird und der Wert aus dem "Temp" sich im "INDF" Register befindet. Wie vorher wurde "Temp equ 0x20" definiert und weiter:

movlw Temp ;ins W-Register wird die absolute Adresse des Registers "Temp" geladen
movwf FSR ;diese Adresse wird ins "FSR" Register kopiert
movf INDF,0 ;der Wert aus dem indirekt adressierten Register "Temp", der sich jetzt
;im "INDF" befindet, wird ins W-Register geladen.

Weil in jedem 14-bittigem Befehl, der mit Datenspeicher verbunden ist, fur Adresse des ansprechenden Registers nur 7 Bits existieren, die bis zum 7Fh (128d) Register direkt ansprechen können, ist bei PICs der Datenspeicher (RAM) in s.g. Bänke verteilt.

Für Aswahl einer Bank sind zwei Bits "RP0" und "RP1" im "STATUS" Register zuständig. Die Anzahl von Bänke und ihre Verwendung ist von gesamter Grösse des RAMs abhängig und kann dem Datenblatt des PICs entnommen werden. Siehe: [[#Speicherbankorganisation|Speicherbankorganisation]]

== Prozessor ==

Der Prozessor von Mid-Range PICs gehört zu den RISC (Reduced Instruction Set Computer) Prozessoren und man hat nur 35 Befehle zu Erlernen, was seine Programmierung im Vergleich zu anderen µC deutlich vereinfacht. Jeder Befehl benötigt im Programmspeicher nur eine Speicherstelle und im Quellcode nur eine Zeile. Die Ausführung des Befehls dauert, abhängig vom Befehl zwischen 1-2 Prozessortakten.

Die Prozessoren der Mid-Range Serie von Microchip sind alle in der "Harvard"-Architektur gefertigt. Das Bedeuted, dass der Datenspeicher und Programmspeicher einen eigenen Bus zur CPU besitzen. Der Vorteil zur "von Neumann"-Architektur ist, dass sich die Busgrößen damit unterscheiden können. Das ermöglicht eine größere Bandbreite.

Der Befehl (beim PIC 14 bit) kann in nur einem Takt verarbeitet werden. Daher kommt auch das Aufteilen der Ausführung des Befehls in die 4 verschiedenen Vörgänge. Wärend der neue Befehl eingelesen ("gefatched") wird, wird der Vorige gerade gelesen ("read") und der Vorvorige verarbeited ("executed") und der Vorvorvorige schreibt gerade in den Datenspeicher ("write"). Das heist 4 Befehle werden jeweils um einen Oszillatortaktzyklus verschoben gleichzeitig verarbeitet.

Das geschieht in vier Perioden des Oszillators. Deswegen die Taktfrequenz des CPUs entspricht durch 4 geteilter Frequenz des Oszillators.

CPU Vorgang Richtung Speicher
------------------------------------------------- -
1.Befehl lesen (fatch) <------- Flash |
2.Daten lesen (read) <------- RAM | 1 Prozessortakt =
3.Daten verarbeiten (execute) | 4 Oszillatortakte
4.Daten schreiben (write) -------> RAM |
-

Nur o.g. CPU Vorgänge sind direkt möglich. Es können deswegen keine Befehle aus dem RAM oder EEPROM ausgeführt werden. Um ein Databyte aus einem RAM Register in ein anderes zu kopieren, muss er zuerst aus dem ersten RAM Register in das W-Register (eigenen s.g. Arbeitsregister des CPU) und erst davon in das zweite RAM Register kopiert werden.

Das Lesen/Schreiben aus/in den EEPROM Speicher ist mit Hilfe speziellen Register und Unterprogrammen bei allen Mid-Range PICs möglich. Der Lese und Schreibzugriff auf den Programmspeicher ist aber nur bei wenigen PIC-Typen (z.B. PIC16F87X) möglich. Dies ermöglicht ein "sich selbst Programmieren", was bei Bootloadern genützt wird.

== Assembler ==

Die Maschinensprache, auch Assembler oder kurz ASM genannt, ist eine Sprache die nur bestimmter CPU versteht. Für einen Menschen ist sie unverständlich, da sie nur aus 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 einen CPU hat somit ein "Namen", der aus englischer Sprache stammt. Siehe: [[#Kurzübersicht Assembler Befehle|Kurzübersicht Assembler Befehle]]

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 oder nötigen Aufgaben nicht unterstützen (z.B. Maus in Q-Basic).

ASM eignet sich aber sehr gut für kleine Anwendungen (meistens Steuerungen) mit µC, weil nur bei dieser Programmiersprache ein direkter Zusammenhang zwischen einem Bit im Programm und einer Spannung am I/O Pin besteht.

Dank der integrierten oder an Portpins angeschlosenen Hardware und dem entsprechenden Program kann ein µC umfangreiche Aufgaben realisieren, die fast unbegrenzt und schwer vorstellbar sind.

Die Aufgabe eines ASM-Programmierers ist, ein Programm zu schreiben, das das Assemblerprogramm (z.B. MPASM) fehlerfrei in die Machinensprache assembliert ("übersetzt") und der bestimmte CPU "versteht". Sie endet eigentlich erst dann, wenn das geschriebene Programm so wie geplannt funktioniert.

[[Bild:PAD_beispiel.png|thumb|80px|Beispiel für ein PAD]]

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 [http://gputils.sourceforge.net/ GPASM]) von dem für Menschen noch verständlichen Code in die Maschinensprache assembliert 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 Homepage des Herstellers von PICs [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en019469&part=SW007002] runtergeladen werden. Es muss zuerst vom Downloads die "MPLAB IDE v7.50 Full Zipped Installation" runtergeladen und erst danach können gewählte Programme (z.B. nur MPASM) intalliert werden. Für MPASM benutzer werden auch folgende .pdf Dateien empfohlen:

MPASM/MPLINK User's Guide (2628 KB) [Benutzerhandbuch]

MPASM™/MPLINK™ PICmicro® Quick Chart (81 KB) [Kurzübersicht]

Nach dem Eischalten der Betriebsspannung des µC, fängt der CPU an, sich im Programmspeicher befindliches Programm mit dem Befehl, der an der Adresse 0 steht, auszuführen.

Aber wann das Programm endet? Natürlich wenn die Versorgungsspannung abgeschaltet wird. Nein! Das ist die einfachste Lösung um ein laufendes Programm auf zufälliger Stelle zu unterbrechen,
aber keine um ihn auf einer definierten Stelle zu beenden.

Wenn an den µC angeschlossene externe Hardware (z.B. Grafikdisplay), eine bestimmte Befehlsfolge vor dem Abschalten benötigt oder wichtige Daten (in EEPROM oder Flash) abgespeichert werden sollen, darf die Spannung erst dann abgeschaltet werden, wenn der CPU eine Meldung ausgibt, dass er sich schon auf der "STOP" Stelle des Programms befinet. Es muss auch
definiert werden (z.B. durch eine Tastenkombination), wann der CPU zum letzten Fragment des ASM Programms vor dem "STOP" gehen soll.

== Grundbeschaltung ==

Der Prozessor von einem PIC kann sofort nach dem Einschalten der Versorgungsspannung (z.B. + 5V DC) arbeiten. Allerdings nur, wenn er den Takt, in dem er die Befehle ausführen soll, vorgegeben hat. Manche PICs besitzen einen internen RC-Oszillator, (z.B. PIC12F629, PIC16F630, PIC16F628, u.s.w.). Bei diesen reicht es bereits Spannung anzulegen und sie laufen bereits.
Die meisten haben ihn aber nicht (z.B. PIC16F84, PIC16F870, u.s.w.) und brauchen fürs Funktionieren zusätzliche Bauteile. Grundsätzlich gibt es mehrere Möglichkeiten:

* Quarz oder Keramik-Resonator + 2 Kondensatoren (LP,HS oder XT)
* Keramik-Resonator mit integrierten Kondensatoren (HS oder XT)
* Quarzoszillator (EC); genau und stabil
* Widerstand + Kondensator (RC); keine hohe Frequenzstabilität

Die entsprechenden Bauteile werden an die Pins OSC1/OSC2 angeschlossen, um den notwendigen Prozessortakt zu erzeugen. Im Konfiguration-Word "__config" muss noch angegeben werden, welcher Oszillator verwendet wird.

Desweiteren existiert ein MCLR-Pin, der beim PIC einen Neustart (=Reset) auslösen kann (Low-Pegel). Diesen Pin sollte man, wenn er in "__config" aktiviert ist, über einen Widerstand (pull-up) an Versorgungsspannung legen, damit der PIC anfängt, sein Programm abzuarbeiten. Der Anschluss wird auch für die Programmierung benötigt. Beim sog. High-Voltage-Programming wird MCLR auf ca. 12-14 Volt gelegt, um den PIC in den Programmiermodus zu schalten. Bei manchen PICs kann dieser Anschluss auch als normalen I/O Pin eingestellt werden. In dem Fall, bei ICSP Benutzung, soll noch eine Diode zwischen den pull-up und Versorgungsspannung angeschlossen werden, um die an MCLR Pin angeschlossene Hardware während der Programmierung zu schützen.

Bei externen Oszillatoren bleibt der Pin OSC2 nicht angeschlossen und kann als I/O benutzt werden. Falls ein interner Oszillator benutzt wird, können beide OSC Pins als I/O dienen.

Damit ein Programm zuverlässig ausgeführt werden kann, muss die Versorgungspannung störungsfrei sein. Dafür wird ein Keramik-Vielschicht-Kondensator 100 nF möglichts am kürzesten direkt zwischen VDD und VSS Pins geschaltet.

Folgende Skizzen zeigen die Grundbeschaltung eines PICs:

{|
|-
|
[[Bild:Pic-entstoer.png|thumb|160px|Entstörkondensator beim PIC]]
|
[[Bild:Qz-os.png|thumb|160px|Quarz ]]
|
[[Bild:Qos-os.png|thumb|160px|externer Quarzoszillator]]
|
[[Bild:Rc-os.png|thumb|160px|externer RC-Oszillator]]
|}

== Konfiguration ==

Die Konfiguration eines PICs wird beim "brennen" festprogrammiert. Sie ist eigentlich für fast jeden PIC-Typ anders. Um Probleme zu vermeinden, muss sie für bestimmten PIC aus einer im MPASM Verzeichniss enthaltener Datei "PXXFXX.INC" entnommen werden. Die Erklärung der Optionen befindet sich im entsprechenden Datenblatt unter "Special Features of the CPU"

Als Beispiel für PIC16F84 haben wir in der Datei "P16F84.INC":

;==========================================================================
;
; Configuration Bits
;
;==========================================================================

_CP_ON EQU H'000F'
_CP_OFF EQU H'3FFF'
_PWRTE_ON EQU H'3FF7'
_PWRTE_OFF EQU H'3FFF'
_WDT_ON EQU H'3FFF'
_WDT_OFF EQU H'3FFB'
_LP_OSC EQU H'3FFC'
_XT_OSC EQU H'3FFD'
_HS_OSC EQU H'3FFE'
_RC_OSC EQU H'3FFF'

Wobei:

_CP_ON - Programmspeicher ist vorm Auslesen geschützt
_CP_OFF - Programmspeicher kann ausgelesen werden (ist nicht geschützt)
_PWRTE_ON - Das Programm wird mit Verzögerung von ca. 72 ms nach dem Einschalten gestartet
_PWRTE_OFF - Das Program wird sofort nach dem Einschalten gestartet
_WDT_ON - Watchdog Timer ist aktiv
_WDT_OFF - Watchdog Timer ist unaktiv

Die alle folgende Optionen beziehen sich an den Oszillatortyp:

_LP_OSC - Oszillator bis ca. 200 kHz (z.B. Uhrenquarz 32768 Hz)
_XT_OSC - Oszillator bis ca. 3,5 MHz
_HS_OSC - Oszillator über 3,5 MHz (z.B. 4 MHz)
_RC_OSC - Externer RC Oszillator

Die Konfiguration wird im Quellcode (*.asm Datei) mit Direktive "__config" definiert, z.B. so:

LIST P=16F84
include "P16F84.inc" ; 4.000 MHz
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _XT_OSC

Die alle Optionen müssen gross geschrieben sein, genauso wie in der "*.inc" Datei.

== Wahl des PICs ==

Es gibt PIC µC die im Typenbezeichnung den Buchstaben "C" oder "F" haben.

Die älteren mit "C" haben EPROM Programmspeicher und die gibt es in zwei Versionen: ohne und mit Fenster (aus Quarz-Glass) fürs Löschen des EPROMs mit UV Strahlung. Bei denen ohne Fenster kann der Programmspeicher nur einmal beschrieben und nicht mehr gelöscht werden.

Die neuen mit "F" besitzen einen Flash-Programmspeicher, der bis zu 100 000 mal mit angelegter Spannung gelöscht und danach neu beschrieben werden kann.

Für die Wahl eines PICs für bestimmte Anwendung wichtig sind:

- Max. Taktfrequenz des Prozessors.

- Grösse des Datenspeichers (für Variablen).

- Grösse des Programmspeichers (für Programm).

- Integrierte Hardware (Komparatoren, A/D Wandler, Timer, USART, I²C, SPI, PWM, u.s.w.).

- Freie I/O Pins für externe Hardware (Display, Tasten, u.s.w.).

- Vorhandene Betriebspannung (Netzteil, Akku, Batterie).

In der Praxis wird meistens für die Programmerstellung ein grösserer PIC genommen (wenn möglich pinkompatibler z.B. PIC16F628 für PIC16F84 oder PIC16F630 für PIC12F629) und erst nach der Optimierung des lauffägiges Programms, der tatsächlich nötiger, da seine Parameter am Anfang nur geschätzt werden können. Wenn man viel Programme für verschiedene PICs entwickelt, optimal wäre der grösste PIC16F877 mit 20 MHz max. Taktfrequenz.

Diese Lösung hat auch den Vorteil, dass während der Programmerstellung kurze Hilfsprogramme (z.B. PIC Trainer) in den Programmspeicher kopiert und benutzt werden können, da sie sowohl ein bischen Programmspeicher und RAM als auch 2 freie I/O Pins fürs PIC Miniterminal brauchen.

= 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 fast 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 komplizierter, da ein UP kann auch ein oder mehrere UPs nacheinander aufrufen. Ganz unten sind die UP1s, die ganz einfache Sachen erledigen. Höher ist 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 ohne Tricks maximal bis zu 8 Ebenen benutzt werden, da auf dem Stapel (stack) nur max. 8 Rücksprungadressen abgespeichert werden können. Sishe hierzu: [[#Programmspeicher|Programmspeicher]]

<center>
[[Bild:HP-UP.png|Hauptprogramm - Unterprogramm]]
</center>

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 Programablaufdiagramm, und nicht chaotisch, abläuft.

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.

Ein ASM Programm (Quellcode) muss in einer Texdatei .asm in der vom Assemblerprogramm erwarteter Form verfasst werden, um fehlerfreie Konvertierung in die Maschinensprache (Assemblierung) zu gewährleisten. Dieses Prozess verläuft in der Form eines Dialoges.

Der Programmierer schreibt und gibt es dem Assemblerprogram zum Übersetzen. Alles was das Programm nicht versteht oder nicht richtig ist, erscheint als Fehlermeldungen, die der Programmierer kennen muss um die Fehler korrigieren zu können. Eine .hex Datei wird erst dannn erstellt, wenn das Assemblerprogramm keine Fehler mehr im Quellcode findet. Deswegen sehr wichtig ist, sich mit dem Assemblerprogramm vertaut zu machen, um die Dialogzeit zu minimieren.

== Programmdurchlaufdiagramm ==

Der Programdurchlaufdiagram (kurz: PAD) ist eine vorläufige und laufend änderbare Stufe zwischen einer Idee und ihrer Verwirklichung. Er wird erst dann fertig, wenn nach ihm erstelltes ASM Program auf einem µC so wie gewünscht funktioniert. Jedes sein Symbol (ausser "Start/Stop") muss später als Befehlsreihenfolge für den bestimmten CPU in den Quellcode übertragen werden. Die Anschriften "Ein" und "Aus" gehören nicht zu Symbolen des PADs und wurden nur zur Erklärung benutzt.

Der PAD ist sehr eifach zu erstellen, weil dafür nur drei Symbole benötigt sind:
<center>
[[Bild:PAD_kurz.png|Symbole des PAD]]
</center>
Das "Start/Stopp" Symbol bedeutet, dass das gesamte Programm sich im stabilen Zustand befindet und nicht "läuft". Anstatt "Stopp" kann auch "Schlaf" (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 eines Programms, endweder in der "ja" (J) oder "nein" (N) Richtung.

Als allgemeinnutziges Standard für µCs kann man folgender PAD bezeichnen:

PAD _____
/ \
Spannung ein (Ein) ----->( Start )
\_____/
| -
V |
.---------------. |
|Initialisierung| |
'---------------' |
| |
.--------->V |
| .---------------. |
| | Hauptprogramm | |
| '---------------' |
| | |
| V |
| A |
| / \ > Gesamtes Programm
| / \ |
| /Ende \____ |
| \ ? / J | |
| \ / | |
| \ / | |
| V | |
| N| | |
`----------´ | |
V |
.---------------. |
| Beenden | |
'---------------' |
| |
V -
_____
/ \
Spannung aus (Aus) <-------------( Stopp )
\_____/

Das Hauptprogram wird in einer endlosen Schleife ausgeführt, die durch die Prüfung "Ende?" unterbrochen werden kann. In dem Fall wird vor dem Beenden des gesamten Programms noch ein UP "Beenden" ausgeführt, das z.B. Daten in EEPROM speichert.

Es ist nicht nötig immer die Symbole zu zeichnen, man kann sich sie vorstellen und nur den Text schreiben. Die Prüfungen werden mit "?" gekenzeichnet und die Zeichen "V", "A", "<" und ">" zeigen die Richtung des weiteren Verlaufs. Dann sieht der PAD so aus:

Ein > Start
V -
Initialisierung |
.------->V |
| Hauptprogramm > Gesamtes Programm
| V |
| Ende? J > Beenden |
| N V -
| V Stopp > Aus
`--------´

Man kann auch die unbedeutende Richtungspfeilen weg lassen:

PAD1 Ein > Start _
Initialisierung |
.------->V | Gesamtes
| Hauptprogramm | Programm
| Ende? J > Beenden _|
| N Stopp
| V V
`--------´ Aus

In der Praxis werden aus Platzgründen meistens die vereinfachten PADs benutzt. Als "movxx" wird oft ein Zeichen "->" benutzt. Zum Beispiel "A->W" bedeutet, das der Inhalt des A Registers ins W-Register geladen (kopiert) wird. Ausserdem werden Zeichen ("+", "-", "*", "/", "^", u.s.w.) für arithmetische und ("&", "or", "xor", u.s.w.) für logische Operationen angewendet. In ein Quellcode werden für diese Zeichen entsprechende Befehle eingeschrieben. Beispiel:

V
10h->W
W+B->B
V

wird im Quelcode so aussehen:

...........
movlw 10h
addwf B,1
...........

Der PAD1 kann aber für Hauptprogramme, die in beliebigem Moment unterbrochen werden dürfen, deutlich vereifacht werden, da die Prüfung "Ende?" ob das Hauptprogram beendet werden soll, und das UP "Beenden", entfallen.

Die meisten ASM Programme für µC sind deswegen nach solchem PAD erstellt:

PAD2 Ein > Start _
Initialisierung |
.------->V |
| Hauptprogramm > Gesamtes Programm
| V |
`--------´ _|

Für Testprogramme wird meistens fogender PAD angewendet, weil es ziemlich einfach festzustellen
ist (z.B. durch Stromverbrauchmessung des µCs), wann sich der CPU schon im Schlaf befindet. Erst dann, darf die Betriebspannung des µCs ausgeschaltet werden.

PAD3 Ein > Start _
Initialisierung | Gesamtes
Hauptprogramm _| Programm
Schlaf > Aus

Und eine batteriebetriebene Uhr wird überwiegend so gestaltet:

PAD4 Ein > Start _
Interrupt Initialisierung |
Timer------------------------->V > Gesamtes Programm
Hauptprogramm _|
Schlaf

In dem Fall reicht es aus, wenn der CPU jede Minute vom Timer aufgeweckt wird, um die Zeit zu aktualisieren. Eine Uhr ist immer (ausser Batteriewechsel) ununterbrochen mit Spannung versorgt.

Für komplizierte Programme ist es unmöglich ein PAD zu erstellen, in dem jeder CPU Befehl sein eigenes Symbol hat. Man beschränkt sich nur auf alle Prüfungen, die über den Lauf des Programms entscheiden, und ganze UPs (z.B. "Initialisierung") nur als ein Symbol verwendet. Für jedes UP wird dann ein eigener PAD erstellt.

Das Erstellen von PAD bei ASM Programmen ist sehr wichtig und darf nicht unterschätzt werden. Je stärker ein Programmierer glaubt, dass er das ohne PAD schaft, um so mehr Zeit wird er danach bei Fehlersuche oder Änderungen im ASM Programm verlieren.

Beispiel aus dem Alltag:

"Das programm hat anfangs auf Anhieb funktioniert. Doch leider habe ich dann was geändert was ich nicht mehr weiß. Das programm macht nun komische Sachen...... Ich kann mir nicht erklären warum, kann mir jemand helfen???"

Für einfache ASM Programme, die gut kommentiert sind, reicht es meistens aus, ein PAD nur "im Kopf" zu erstellen, aber ganz ohne PAD geht es sicher nicht.

Wenn ein ASM Programm nicht wie geplannt funktioniert, wird zuerst ein Fehler im PAD gesucht. Und erst wenn er i.O. ist, im als fehlerhaft festgestellten Codefragment.

== Hauptprogramm ==

Wie sein Namen schon vermuten lässt, ist das Hauptprogram das wichtigste Teil des gesamten Programms. Meistens ist es auch das kleinste Teil, vor allem, wenn die UPs sehr komplex sind. Seine Aufgabe ist die benötigte UPs in bestimmter Reihenfolge nachainander aufzurufen, um die alle Funktionen des gesamten Programms zu realisieren.

Das HP ist meistens als endlose Schleife , wie im PAD2, aufgebaut. Weil die endlose Schleife sehr schnell läuft, werden die alle, die durch die UPS realisierte Aufgaben quasi gleichzeitig ausgeführt. Wenn es unerwünscht ist, müssen einige UPs als Verzögerungen realisiert werden.

Typischer PDA für ein HP sieht so aus:

Haupt .--->V
| UP1
| UP2
| ...
| UPn
| V
`----´

In den Quellcode wird es so eigeschrieben:

Haupt call UP1
call UP2
...........
call UPn
goto Haupt

In der Praxis wird das HP schrittweise erstellt. Am Anfang wird sich nur ein UP im HP befinden und die folgenden kommen nach dessen Erstellung und Prüfen dazu, bis das HP fertig wird.

== Unterprogramm ==

Unterprogramm wird durch übergeordnetes Programmteil (Aufrufer) aufgerufen und nach seinem Ausführen, wird zurück zum Aufrufer gesprungen. Der Rückkehr zum Aufrufer wird durch "return" Befehl, der sich am Ende jedes UPs befinden muss, erreicht. Und das ist der einzige Unterschied zwischen einem HP und einem UP.

Jedes UP hat folgender PAD:

vom Aufrufer ------------>V
Tun
zurück zum Aufrufer <----------return

Ein HP von einem ASM Programm kann in anderem, mehr umfangreichem ASM Program als UP benutzt werden, wenn der sich am Ende des HPs befindlicher Befehl "goto" durch "return" ersetzt wird. Ein Beispiel dazu:

Haupt1 call UP11 Haupt1 call UP11
call UP21 call UP21
........... -------> ...........
call UPn1 call UPn1
goto Haupt1 return

Jetzt können wir im mehr komplexen HP (Haupt) das Haupt1 als Unterprogramm aufrufen:

Haupt call UP1
call Haupt1
...........
call UPn
goto Haupt

Jedes UP kann auch von einem anderen übergeordneten UP aufgerufen werden, wenn das was es realisiert, benötigt wird.

In der Praxis wird oft ein UP von mehreren anderen UPs benutzt. Zum Beispiel um LCD Display zu steuern, brauchen wir entweder ein Befehl (Cmd) oder ein Zeichen (Data) an Display zu schicken. In beiden Fällen wird ein Byte geschickt, einmal mit RS=0 (Befehl) und einmal mit RS=1 (Zeichen) laut folgendem PDA:

"Cmd" "Data"
RS=0 RS=1
V V
`-->V<--´
"Send" Byte schicken
return

Das wird in den Quellcode z.B. so eingeschrieben:

Cmd bcf RS
goto Send
Data bsf RS
Send ............
return

Das UP "Send" ist den UPs "Cmd" und "Data" untergeordnet, da es von beiden benutzt wird, kann aber weder "Cmd" noch "Data" benutzen.

=== Initialisierung ===

Damit der PIC ein Programm asführen kann, muss er vollständig und richtig initialisiert werden. Deswegen als erstes UP, das von dem gesamten Programm noch vor dem HP aufgerufen wird , ist "Initialisierung" (kurz: Init)

==== Variablen ====

Weil nach dem Einschalten der Spannung im RAM sich zufällige Werte befinden, wird meistens als erstes, der benutzte Bereich des RAMs (z.B. 20h bis 7Fh) gelöscht. Es wird einfach und sparsam mit einer Schleife, die indirekte Adressierung verwendet, gemacht:

V
Adresse des ersten Registers in FSR laden (20h)
.-------------------->V
RAMClr |Indirekt adressierter Register löschen (INDF)
| Adresse erhöhen
| Letzte Adresse + 1 (80h) J > Return
| N
| V
`---------------------´

Es wird wie folgt in Quellcode eingeschrieben:

movlw 0x20
movwf FSR
RAMClr ,->clrf INDF
| incf FSR,1
| btfss FSR,7
`-<goto RAMClr
return

Um Anzahl den Marken (label) zu verringern, wird oft ein Symbol "$" benutzt. Es bedeutet die Adresse der aktuellen Befehlszeile. Es kann also auch so eingeschrieben werden:

movlw 0x20
movwf FSR
,->clrf INDF
| incf FSR,1
| btfss FSR,7
`-<goto $-3 ; springe zur aktueller Adresse -3
return

Danach können den benötigtenen Variablen die gewünschte Werte angegeben werden:

movlw 0x3C
movwf LimH
movlw 0x5A
movwf LimL
u.s.w.

Somit sind die Variablen initialisiert.

==== I/O Ports ====

Nach dem Einschalten der Spannung sind die für Komparatoren oder A/D Wandler benutzte Pins als analoge Eingänge initialisiert. Wenn sie alle als digitale I/Os verwendet werden sollen, müssen sie als solche definiert werden. Das geschieht durch Eischreiben in entsprechenden Register (CMCON bzw. ADCON1) des Wertes 7:

movlw 7 b.z.w. movlw 7
movwf CMCON movwf ADCON1

Wenn einige als Analoge Eingänge benutzt werden sollen, mussen die entsprechende Werte dem Datenblatt des jeweiligen PICs entnommen werden.

Danach werden alle Ports nacheinander gelöscht und die gewünschte Werte die an den Pins vor dem Start des Hauptprogramms ausgegeben werden sollen, geschrieben:

clrf PORTA
movlw 0x37
movwf PORTA
usw.

Anchliessend werden für jeden Port die Werte in TRIS Register eingeschrieben, wobei ein Bit einem Pin entspricht. Ein Pin wird in TRIS Register durch 1 als Eingang und durch 0 als Ausgang definiert. Beispielweise beim PORTB sollen B7,B5 und B3 als Eingänge und restliche Pins als Ausgänge definiert werden. Das ergibt den Wert 10101000b = A8h, der in den TRISB Register geschrieben werden muss. Weil die alle TRIS Register sich in der Bank1 befinden, muss im STATUS-Register auf Bank1 und danach zurück auf Bank 0 umgeschaltet werden:

bsf STATUS,RP0
movlw 0xA8
movwf TRISB
bcf STATUS,RP0

Bei einem Umschalten der Bank können selbstverständlich alle TRIS Register nacheinander beschrieben werden.

Bei dem PORTA gibt es Pins, die nur "open drain" Ausgang haben (können nur auf GND schalten) b.z.w. nur als Eingang benutzt werden können. Bei Plannung der Verwendung von PORTA muss immer im Datenblatt geprüft werden, ob sich bestimmter Pin für geplannte Anwendung eignet.

==== Hardware ====

Die für ASM Programm benutzte Hardware kann auf integrierte und externe geteilt werden. Für eine Initialisierung der integrierten Hardware (Komparatoren, A/D Wandler, Timer, USART, I²C, SPI, PWM, u.s.w.), müssen entsprechende SFRs (Spezial Function Registers) laut Datenblatt des PICs definiert werden.

Die externe Hardware muss nach Datenblättern der Herstellern initialisiert werden.

=== Einlesen ===

Um ein Bit von einem Portpin einzulesen und in ein bestimmtes Register zu Kopieren wird folgender PAD benutzt, weil ein PIC kein Befehl dafür hat:

V
Bit im Zielregister löschen
Quellbit = 0 ? J >------.
N |
V |
Bit im Zielregister setzen |
V<-------------´

Wenn wir z.B. ein bit3 von PortA als bit1 in den Register Tasten kopieren wollen, dann wird es in Quellcode so geschrieben:

bcf Tasten,1
btfsc PORTA,3
bsf Tasten,1

Natürlich wenn ein ganzer Byte vom Port in das W-Register eingelesen wird, kann mann den gleich in das Zielregister schreiben.

=== Ausgeben ===

Um ein Bit an einem Portpin auszugeben wird ein bestimmter Bit mit "bcf" gelöscht oder mit "bsf" gesetzt. Zum Beispiel bit4 im PORTA:

bcf PORTA,4.

Um ein Byte auszugeben wird er einfach zuerst in das W-Register geladen und danach an Port übergeben, z.B.:

movlw 0x12
movwf PORTA

=== Schleifen ===

In ASM Programmen meist verbreitetes Codefragment ist eine Schleife.

Es kann eine endlose Schleife, die durch Prüfung einer bestimmten Bedingung (z.B. Taste) unterbrochen wird, sein:

V<-----.
Tun |
? N >--´
J
V
weiter

Es kann eine Schleife mit Schleifenzähler (z.B. Temp), die bestimmte Anzahl Durchläufe hat, sein:

V
Anzahl ins Temp laden
V<---------.
Tun |
Temp decrementieren |
Temp = 0 ? N >--´
J
V
weiter

Solche Schleifen können als UPs verwendet werden, wenn "weiter" mit "return" ersetzt wird.

Das waren Beispiele für Schleifen, die bewusst programmiert sind. Es gibt leider auch endlose Schleifen, die durch ein Fehler im Programm enstanden sind und zum "hängen" des Programms führen. Solche Schleifen sind im Programm nicht einfach zu finden, da ihre Parameter unbekannt sind.

=== Pause ===

Um eine Pause (Warten, Verzögerung) im Programm anzulegen wird der "nop" Befehl benutzt, während dessen Ausführung der CPU nichts macht. Mit einem "nop" kann eine Zeit gleich 4 Takten (Perioden) des Oszillators realisiert werden.

Für sehr kurze Wartezeiten benutzt man eine Reihe von nachfolgenden "nop"s. Beim einem Oszillator 4 MHz, die Ausführungszeit des Prozessors beträgt 1 µs pro "nop". Wenn z.B. 4 µs benötigt werden, werden dafür 4 "nop"s gebraucht:

...
nop
nop
nop
nop
...

Das gleiche bewirken 2 "goto"s, brauchen aber im Vergleich zu "nop"s nur die Hälfte der Bytes im Programmspeicher:

...
goto $+1
goto $+1
...

Der Befehl goto $+1 bedeutet "springe zur aktueller Adresse + 1" (also nächster Adresse) und seine Ausführungszeit ist gleich 2 Prozessortakten.

Für kurze Zeiten werden s.g. Warteschleifen, wie im folgendem PAD benutzt:

V
n * nop
P0 laden
V<---------.
P0 decrementieren |
P0 = 0 ? N >--´
J
V

In Quellcode wird es als UP so eigeschrieben:

Warte nop Warte nop
... ...
nop nop
movlw 0xXX movlw 0xXX
movwf P0 movwf P0
Warte0 decfsz P0,1 decfsz P0,1
goto Warte0 goto $-1
return return

Der Sprung zur Marke "Warte0" ("goto Warte0") wurde in rechtem Beispiel durch "goto $-1" ersetzt.

Die gesammte Anzahl den CPU Takten (N) lässt sich aus folgender Formel berechnen:

N = 3 * P0 + 6 + n

und die Wartezeit (T) in Sekunden:

T = N * ( 4 / Fosc ), für Schätzungen T ~ 3 * P0 * ( 4 / Fosc )

Wobei:

P0 = Zahl im Register P0, 6 = Ausführungszeit von "call" (2) + "movlw" (1) + "movwf" (1) + "return" (2), n = Anzahl "nop"s, Fosc = Frequenz des Oszillators (z.B. Quartz)

Wenn in ein Register PX eine 0 eingeschrieben wird, bedeutet es, dass die decrementierung des Registers 100h = 256d Takten dauern wird, da dekrementierte 0 eine FFh = 255d ergibt. Deshalb in Warteschleifen ist die Zahl 0 die grösste und 1 die kleinste. Für solche einfache Schleifen (als UP) die Wartezeit beträgt min. 9 und max. ca. 800 Prozessortakten (ohne "nop"s).

Für mittlere Wartezeiten z.B. 0,1 Sekunde werden doppelte Warteschleifen verwendet:

Warte V
n * nop
P1 laden
Warte1 V<-------------.
P0 laden |
Warte0 V<---------. |
P0 decrementieren | |
P0 = 0 ? N >--´ |
J |
V |
P1 dekrementieren |
P1 = 0 ? N >------´
J
V

Das wird in Quellcode als UP so aussehen:

Warte nop Warte nop
... ...
nop nop
movlw 0xXX movlw 0xXX
movwf P1 movwf P1
Warte1 movlw 0xXX movlw 0xXX
movwf P0 movwf P0
Warte0 decfsz P0,1 decfsz P0,1
goto Warte0 goto $-1
decfsz P1,1 decfsz P1,1
goto Warte1 goto $-5
return return

Wie vorher wurden rechts die Marken durch "$-n" ersetzt.

Die gesammte Anzahl den CPU Takten (N) lässt sich aus folgender Formel berechnen:

N = P1 * (3 * P0 + 5) + 8 + n

und die Wartezeit (T) in Sekunden:

T = N * ( 4 / Fosc ), für Schätzungen T ~ 3 * P1 * P0 * ( 4 / Fosc )

Wobei:

P0 = Zahl im Register P0, P1 = Zahl im Register P1, 8 = Ausführungszeit von "call" + "return" + 2 * ("movlw" + "movwf"), n = Anzahl "nop"s, Fosc = Frequenz des Oszillators (z.B. Quartz)

Für solche doppelte Schleifen (als UP) die Wartezeit beträgt min. 16 und max. ca. 200 000 Prozessortakten (ohne "nop"s).

Für lange Wartezeiten z.B. 1 Sekunde werden 3-fache Warteschleifen angewendet.

Solche Warteschleife ist im folgenden PAD abgebildet:

Warte V
n * nop
P2 laden
Warte2 V<-----------------.
P1 laden |
Warte1 V<-------------. |
P0 laden | |
Warte0 V<---------. | |
P0 decrementieren | | |
P0 = 0 ? N >--´ | |
J | |
V | |
P1 decrementieren | |
P1 = 0 ? N >------´ |
J |
V |
P2 dekrementieren |
P2 = 0 ? N >----------´
J
V

Das wird in Quellcode als UP so aussehen:

Warte nop Warte nop
... ...
nop nop
movlw 0xXX movlw 0xXX
movwf P2 movwf P2
Warte2 movlw 0xXX movlw 0xXX
movwf P1 movwf P1
Warte1 movlw 0xXX movlw 0xXX
movwf P0 movwf P0
Warte0 decfsz P0,1 decfsz P0,1
goto Warte0 goto $-1
decfsz P1,1 decfsz P1,1
goto Warte1 goto $-5
decfsz P2,1 decfsz P2,1
goto Warte2 goto $-9
return return

Auch hier wurden rechts die Marken durch "$-n" ersetzt.

Die gesammte Anzahl den CPU Takten (N) lässt sich aus folgender Formel berechnen:

N = P2 * [ P1 * (3 * P0 + 5) + 9 ] + 10 + n

und die Wartezeit (T) in Sekunden:

T = N * ( 4 / Fosc ), für Schätzungen T ~ 3 * P2 * P1 * P0 * ( 4 / Fosc )

Wobei:

P0 = Zahl im Register P0, P1 = Zahl im Register P1, P2 = Zahl im Register P2, 10 = Ausführungszeit von "call" + "return" + 3 * ("movlw" + "movwf"), n = Anzahl "nop"s, Fosc = Frequenz des Oszillators (z.B. Quartz)

Für solche 3-fache Schleifen (als UP) die Wartezeit beträgt min. 27 und max. ca. 50 000 000 Prozessortakten (ohne "nop"s).

Die "nop"s in allen Warteschleifen sind nur notwendig um genaue Wartezeit einzustellen zu können. Sie können auch mit "goto $+1"s ersetzt, oder weg gelassen werden.

Anstatt "movlw 0xXX" kann auch "movf PauseX,0" angewendet werden, wenn die Schleife mehrmals mit verschiedenen Werten P0, P1 und P2 aus den Register Pause0, Pause1 und Pause2 benutzt wird.

Für sehr lange Wartezeiten können, nach gleichem Prinzip, Warteschleifen erstellt werden, die mehr als 3 Schleifen enthalten.

=== Tabellen ===

Es gibt zwei Arten von Tabellen: Sprungtabellen (computed goto) die "goto" Befehle enthalten und Wertetabellen (lookup table) in denen feste Werte in "retlw" gespeichert sind. Der wichtigste Unterschied zwischen dennen ist, dass die Sprungtabellen steuern den Programlauf abhängig vom Inhalt des W-Registers und die Wertetabellen liefern abhängig von Inhalt des W-Registers ein Wert an den Aufrufer zurück.

Beide werden in Programmspeicher erstellt. Sie können nur bis zu 256 Speicherstellen belegen, da in den W-Register auch nur so viel veschiedenen Zahlen "passen". Sie Fangen also (fast) immer bei einer Adresse XX00h an und enden bei XXFFh. Der Hochwertige Byte "XX" der Adresse an der sich der Anfang einer Tabelle befindet, muss vor dem Einsprung in die Tabelle ins PCLATH Register eingeschrieben werden, wenn die Tabelle weit vom Aufrufer liegt. In der Praxis werden solche Tabellen am oberen Ende des Programmspeichers angelegt, damit sie den ASM Code nicht unterbrechen.

Eine Sprungtabelle wird so aufgebaut:

org (XX-1)FF <--- eine Direktive für Assemblerprogramm, wo es
die Tabelle im Programmspeicher plazieren soll
Adresse Inhalt
-------------------------
Tab1 (XX-1)FF addwf PCL,1
XX00 goto Marke0
XX01 goto Marke1
.......................
XXFE goto Marke254
XXFF goto Marke255

Und so aufgerufen:

movlw 0xXX
movwf PCLATH
movf TWert,0
call Tab1

Wobei:

0xXX = Hochwertiger Byte der Adresse von Tab1, TWert = ein Wert, der die Wahl wohin gesprungen wird bestimmt

Nach ausführen der obiger Befehlsfolge, wird das ASM Programm z.B. für Twert=0x01 weiter ab Marke1 "laufen" bis es an "return" kommt. Dann springt es zurüch zum Aufrufer der Tabelle.

Eine Wertetabelle wird so aufgebaut:

org (XX-1)FF <--- eine Direktive für Assemblerprogramm, wo es
die Tabelle im Programmspeicher plazieren soll
Adresse Inhalt
-------------------------
Tab1 (XX-1)FF addwf PCL,1
XX00 retlw Wert0
XX01 retlw Wert1
.......................
XXFE retlw Wert254
XXFF retlw Wert255

Und so aufgerufen:

movlw 0xXX
movwf PCLATH
movf TWert,0
call Tab1

wobei:

0xXX = Hochwertiger Byte der Adresse von Tab1, TWert = ein Wert, für welchen, an den Aufrufer bestimmter Wert aus der Tabelle im W-Register zurückgeliefert wird

Wertetabelle kann auch mit Hilfe der MPASM Direktive "dt" erstellt werden. So kann man sich mehrfaches Schreiben von "retlw" Befehlen ersparen:

org 0x(XX-1)FF
Tabelle addwf PCL,1
; nachfolgend der benötigte Wert im W- Register
; vor dem Aufruf der Tabelle
dt 0x03, 0xE8 ; 0x00
dt 0x03, 0xE8 ; 0x02
dt 'M','H','z',0x00 ; 0x04
dt ' ',' ','W','A','I','T',0x00 ; 0x08
dt 'C','o','n','s','t',' ','X',0x00 ; 0x0F
dt 'C','=',0x00 ; 0x17
dt 'L','=',0x00 ; 0x1A
dt 'F','=',0x00 ; 0x1D
dt 'O','K',0x00 ; 0x20
u.s.w.

Das Lesen eines Strings muss ab entsprechendem Wert im W-Register (z.B. für "MHz" -> 0x04) anfangen und auf dem Wert 0x00 enden, der hier als Stringende dient. Einfacher ist, wenn alle Strings gleich lang sind (wie z.B. in einem Zeichengenerator fur Grafikdisplay).

=== Schnittstellen und Treiber ===

Als Schnittstelle wird externe Hadware, die zum steuern eines an sie angeschlossenes "Gerätes" dient, genannt. Das ASM Programm, das die Steuerung ermöglicht ist ein Treiber. Als Beispiele siehe: [[http://www.roboternetz.de/phpBB2/viewtopic.php?t=13685]] und [http://www.roboternetz.de/phpBB2/viewtopic.php?t=22749]

== Vorlage für MPASM ==

Diese Vorlage ist nur für ASM Programme ohne Interrupts geeignet:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration
#define _DTT1 GPIO,0 ; Portpins benennen
#define _CKT2 GPIO,1
#define _T3 GPIO,2
#define _RNG GPIO,3
#define _INT GPIO,4
#define _RL GPIO,5
u.s.w.
SecondL equ 0x20 ; Variablen definieren (Register benennen)
SecondH equ 0x21
MinuteL equ 0x22
MinuteH equ 0x23
StundeL equ 0x24
StundeH equ 0x25
u.s.w
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
Haupt ............ ; hier fängt das Hauptprogramm als endlose Schleife an
Eigener Code
............
goto Haupt ; hier endet das HP, gehe zum Anfang des HPs (zurück)
UP1 ............ ; Unterprogramme
Eigener Code
............
return
############
UPn ............
Eigener Code
............
return
Init clrf GPIO ; lösche Port
bsf STATUS,RP0 ; auf Bank1 umschalten
call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; kalibriere internen RC oscillator
bcf OPTION_REG,7 ; aktiviere pull-ups
movlw 0x38 ; definiere Portpins GPIO, (z.B. 0-2 Aus- und 3-5 Eingänge)
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
movlw 7 ; schalte Komparator aus
movwf CMCON ; und definiere GPIO 0-2 als digitale I/Os
............
eigener Code
............
return ; springe zurück (zum Haupt)
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

Die Variablen können auch kürzer mit s.g. cblock definiert werden:

cblock 0x20
SecondL
SecondH
MinuteL
MinuteH
StundeL
StundeH
endc

Bei sehr vielen Variablen sind aber die Registeradressen nicht so übersichtlich.

Für Programme mit Interrupts ist diese Vorlage geeignet:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration
#define _DTT1 GPIO,0 ; Portpins benennen
#define _CKT2 GPIO,1
#define _T3 GPIO,2
#define _RNG GPIO,3
#define _INT GPIO,4
#define _RL GPIO,5
u.s.w.
SecondL equ 0x20 ; Variablen definieren (Register benennen)
SecondH equ 0x21
MinuteL equ 0x22
MinuteH equ 0x23
StundeL equ 0x24
StundeH equ 0x25
u.s.w
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
goto Haupt ; gehe zum Hauptprogramm "Haupt"
org 0x004 ; hier fängt die ISR (interrupt service routine) an
.............
Eigener Code
.............
retfie ; hier endet die ISR
Haupt ............ ; hier fängt das Hauptprogramm als endlose Schleife an
Eigener Code
............
goto Haupt ; hier endet das HP, gehe zum Anfang des HPs (zurück)
UP1 ............ ; Unterprogramme
Eigener Code
............
return
############
UPn ............
Eigener Code
............
return
Init clrf GPIO ; lösche Port
bsf STATUS,RP0 ; auf Bank1 umschalten
call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; kalibriere internen RC oscillator
bcf OPTION_REG,7 ; aktiviere pull-ups
movlw 0x38 ; definiere Portpins GPIO, (z.B. 0-2 Aus- und 3-5 Eingänge)
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
movlw 7 ; schalte Komparator aus
movwf CMCON ; und definiere GPIO 0-2 als digitale I/Os
............
eigener Code
............
return ; springe zurück (zum Haupt)
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

== Das erste... ==

Hier wird detailiert das ganze Prozess der Erstellung eines ASM Programms beschrieben. Die Idee:

Es gibt 4 LEDs (_L1, _L2, _L3 und _L4), die mit 2 Tastern gesteuert werden sollen. Nach dem Einschalten soll keine LED leuchten. Solange der linke Taster (_T1) gedrückt ist, sollte eine leuchtende LED von links nach rechts "wandern" und von der letzten rechten Position wieder nach ganz linke "springen". Solange der rechte Taster (_T2) gedrückt ist, sollte eine leuchtende LED von rechts nach links "wandern" und von der letzten linken Position wieder nach ganz rechte "springen". Solange beide Taster gedrückt sind soll die leuchtende LED von links nach rechts und zurück "wandern".

Dafür nötige Hardware zeigt folgende Skizze:

.-----------------------------------------------.
| |
| PIC12F629 |
| |
| GPIO,3 GPIO,4 GPIO,5 GPIO,2 GPIO,1 GPIO,0|
'-----------------------------------------------'
4| 3| 2| 5| 6| 7|
| | .-. .-. .-. .-.
| | R | | R | | R | | R | |
| | 470| | 470| | 470| | 470| |
| | '-' '-' '-' '-'
\ o \ o | | | |
\ \ V -> V -> V -> V ->
\. \. - - - -
_T1 o _T2 o _L1 | _L2 | _L3 | _L4 |
| | | | | |
+-------+-------+---+---+-------+-------+
|
===
GND

Weil der Pin 4 (GPIO,3) nur einen "open drain" Ausgang hat (kann nur an GND schalten), wird er hier als Eingang benutzt.

Jetzt muss die Idee vom Programmierer in ein PAD verfasst werden, z.B. solcher:

Start
Initialisierung
.-------------->V
| _T1=0 gedrückt ? N >----.
| J |
| V |
| links->rechts "wandern" |
| V<------------´
| _T2=0 gedrückt ? N >----.
| J |
| V |
| rechts->links "wandern" |
| V<------------´
`---------------´

danach detailierter:

Start
Initialisierung
V<-------------------------------------------.
_T1=0 gedrückt ? N >---+--->_T2=0 gedrückt ? N >---+---´
J A J A
V | V |
_L1 an | _L4 an |
Warten | Warten |
_L1 aus | _L4 aus |
_L2 an | _L3 an |
Warten | Warten |
_L2 aus | _L3 aus |
_L3 an | _L2 an |
Warten | Warten |
_L3 aus | _L2 aus |
_L4 an | _L1 an |
Warten | Warten |
_L4 aus | _L1 aus |
V | V |
`------------´ `------------´

Zuerst wird im MPASM Verzeichnis ein neuer Verzeichniss (z,B. "PIC Programme") angelegt und in dem Verzeichniss neue Textdatei (z.B. "Erstes.txt") erstellt. Als nächstes wird die "Vorlage für MPASM" dorthin kopiert.

Danach müssen, die im Programm benutzte Portpins und Register mit "#define" und "equ" definiert werden.

Als Initialisierung wird das UP "Init" aus der Vorlage für MPASM mit geändertem "TRISIO" Wert (0x18) übernommen. Siehe: [[#Vorlage für MPASM|Vorlage für MPASM]]

Fürs "Warten" wird eine dreifache Warteschleife verwendet. Siehe: [[#Pause|Pause]]

Die Taster werden mit "btfsc" Befehl geprüft und zum LEDs An- und Ausschalten werden Befehle "bsf" und "bcf" für ensprechenden Portpin von GPIO angewendet. Siehe: [[#Ausgeben|Ausgeben]]

Anschlessend wird alles laut PAD in die Vorlage für MPASM eingeschrieben und der Quellcode ist fertig:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration
#define _T1 GPIO,3 ; Portpins benennen
#define _T2 GPIO,4
#define _L1 GPIO,5
#define _L2 GPIO,2
#define _L3 GPIO,1
#define _L4 GPIO,0
P0 equ 0x20 ; Variablen definieren (Register benennen)
P1 equ 0x21
P2 equ 0x22
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
Haupt btfsc _T1 ; Taster _T1=0 gedrückt ?, wenn ja, überspringe "goto T2Test"
goto T2Test ; wenn nicht, springe zu "T2Test"
bsf _L1 ; schalte _L1 an (setze den Pin 2 auf "1")
call Warten ; warte ca. 0,4 s (ca. 400 000 Prozessortakten)
bcf _L1 ; schalte _L1 aus (setze den Pin 2 auf "0")
bsf _L2 ; schalte _L2 an (setze den Pin 5 auf "1")
call Warten ; warte
bcf _L2 ; schalte _L2 aus (setze den Pin 5 auf "0")
bsf _L3 ; schalte _L3 an (setze den Pin 6 auf "1")
call Warten ; warte
bcf _L3 ; schalte _L3 aus (setze den Pin 6 auf "0")
bsf _L4 ; schalte _L4 an (setze den Pin 7 auf "1")
call Warten ; warte
bcf _L4 ; schalte _L4 aus (setze den Pin 7 auf "0")
T2Test btfsc _T2 ; Taster _T2=0 gedrückt ?, wenn ja, überspringe "goto Haupt"
goto Haupt ; wenn nicht, springe zu "Haupt"
bsf _L4 ; schalte _L4 an (setze den Pin 7 auf "1")
call Warten ; warte
bcf _L4 ; schalte _L4 aus (setze den Pin 7 auf "0")
bsf _L3 ; schalte _L3 an (setze den Pin 6 auf "1")
call Warten ; warte
bcf _L3 ; schalte _L3 aus (setze den Pin 6 auf "0")
bsf _L2 ; schalte _L2 an (setze den Pin 5 auf "1")
call Warten ; warte
bcf _L2 ; schalte _L2 aus (setze den Pin 5 auf "0")
bsf _L1 ; schalte _L1 an (setze den Pin 2 auf "1")
call Warten ; warte
bcf _L1 ; schalte _L1 aus (setze den Pin 2 auf "0")
goto Haupt ; springe zu "Haupt"
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 ; dekrementiere P0 und überspringe "goto $-1" bei P0 = 0
goto $-1 ; sonst gehe zur voherigen Adresse (Befehl "decfsz P0")
decfsz P1 ; dekrementiere P1 und überspringe "goto $-4" bei P1 = 0
goto $-4 ; sonst gehe zur aktueller Adresse - 4 (Befehl "clrf P0")
decfsz P2 ; 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 ("Haupt"),
Init clrf GPIO ; lösche Port (setze alle werdende Ausgänge auf "0")
bsf STATUS,RP0 ; auf Bank1 umschalten
call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; und kalibriere internen RC oscillator (4 MHz)
bcf OPTION_ REG,7 ; aktiviere pull-ups für die Portpins
movlw 0x18 ; definiere Portpins GPIO,3 und 4 als Eingänge
; und restlichen als Ausgänge
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
movlw 7 ; schalte Komparator aus
movwf CMCON ; und definiere GPIO 0-2 als digitale I/Os
return ; springe zurück (zum Haupt)
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

Jetzt wird der Quellcode in "Erstes.asm" umbenannt. Diese .asm Datei können wir dem MPASM zum "Übersetzten" geben. Nach der Assemblierung sehen wir 3 Meldungen (Messages) vom MPASM. Diese befinden sich in der vom MPASM erstellter Datei "Erstes.lst" und lauten:

Message[302]: Register in operand not in bank 0. Ensure that bank bits are correct.

Diese Meldung kann man übersetzen als:

Meldung[302]: Register im Befehl nicht in Bank 0. Vergewisse Dich das die Bank-Bits korrekt sind.

Wir sind sicher, dass die Register "OSCCAL", "OPTION_REG" und "TRISIO" in der Bank 1 sich befinden. Wenn man aber nicht sicher ist, soll man in Datenblatt nachschauen. Die Meldungen kommen immer für alle SFRs (Special Function Register) die sich in der Bank 1 befinden und können ignoriert werden.

Am Ende der Datei "Erstes.lst" befinden sich noch einige Informationen über Programmspeicher:

Program Memory Words Used: 52
Program Memory Words Free: 972

und die Anzahl den eventuellen Fehlern (Errors), Warnungen (Warnings) und Meldungen (Messages):

Errors : 0
Warnings : 0 reported, 0 suppressed
Messages : 3 reported, 0 suppressed

Insgesamt werden durch MPASM 4 Dateien erstellt: "*.cod", "*.err", "*.hex" und "*.lst".

Wichtigste davon, falls wegen Fehler keine "*.hex" Datei erstellt wird, ist die "*.err" Datei, wo alles was dem MPASM nicht "passt" aufgelistet ist. In der "*.lst" Datei kann man sich ein Programm mit genauen Adressen für jeden Befehl anschauen.

Die während der Assemblierung vom MPASM generierte Datei "Erstes.hex" kann jetzt durch ein Brenner mit geeignetem Programm in den PIC Programmspeicher eingeschrieben werden.

== Für anderen PIC umschreiben ==

Die wichtigste Vorraussetzung ist, das der PIC2, auf dem das vorhande ASM Programm für PIC1 laufen soll, zumindest für das ASM Program nötige interne Hardware hat. Die Frequenz des Oszillators sollte gleich sein. Der Code benötigt ausser UP "Init" keine Änderungen.

Wenn der Port vom PIC2 anderen Namen hat, muss man das im Quellcode umdefinieren, z.B.:

#define PORTC PORTB
#define TRISC TRISB

Dann wird das Assemblerprogramm, wenn es PORTC findet, immer PORTB nehmen. Das gleiche Betrifft die "__config" Ausdrücke, die entsprechend der "*.ini" Datei für den PIC2, geändert werden müssen.

Das Assemblerprogramm findet sicher alles, was ihm nicht "passt" und bringt Fehlermeldungen, auf die man entsprechend reagieren muss.

Als Beispiel, schreiben wir "Erstes.asm" für den PIC16F84A um.

Zum Ändern sind die ersten 3 Zeilen:

list P=12F629 ; Prozessor definieren
include "P12F629.inc" ; entsprechende .inc Datei für MPASM
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _MCLRE_OFF & _INTRC_OSC_NOCLKOUT ; Konfiguration

Sie werden für den PIC16F84A so aussehen:

list P=16F84A ; Prozessor definieren
include "P16F84A.inc" ; 4.000 MHz
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _HS_OSC

Dazu muss noch "GPIO" Port umdefiniert werden, da der PIC16F84A solchen nicht hat, z.B auf "B":

#define GPIO PORTB
#define TRISIO TRISB

Die Hardware muss natürlich an entsprechende Pins angeschlossen werden:

_T1 auf 12 (B3), _T2 auf 13 (B4), _L1 auf 14 (B5), _L2 auf 11 (B2), _L3 auf 10 (B1) und _L4 auf 9 (B0)

Jetzt assemblieren wir die Qelldatei und der MPASM bringt in der Datei "Erstes.err" folgende Fehler:

Error[113] C:\MPASM\PICPROG\PIC16F84\ERSTES.ASM 61 : Symbol not previously defined (OSCCAL)
Error[113] C:\MPASM\PICPROG\PIC16F84\ERSTES.ASM 67 : Symbol not previously defined (CMCON)

In dem UP "Init" müssen also noch die Befehle mit "OSCCAL" und "CMCON" Register entfernt werden, da der PIC16F84A sie nicht hat:

call 0x3FF ; hole Kalibrationswert
movwf OSCCAL ; kalibriere internen RC oscillator (4 MHz)

und:

movlw 7 ; schalte Komparator aus
movwf CMCON ; und mache GPIO 0-2 als digital I/O

Weiter kann schon alles übernommen werden und die Datei "Erstes.asm" für den PIC16F84A ist fertig:

list P=16F84A ; Prozessor definieren
include "P16F84A.inc" ; 4.000 MHz
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _HS_OSC
#define GPIO PORTB ; Ports umbenennen
#define TRISIO TRISB
#define _T1 GPIO,3 ; Portpins benennen
#define _T2 GPIO,4
#define _L1 GPIO,5
#define _L2 GPIO,2
#define _L3 GPIO,1
#define _L4 GPIO,0
P0 equ 0x20 ; Variablen definieren (Register benennen)
P1 equ 0x21
P2 equ 0x22
org 0x0000 ; bis da sind MPASM Direktiven
; hier fängt das gesamte ASM Programm an
call Init ; rufe UP "Init" (Initialisierung) auf
Haupt btfsc _T1 ; Taster _T1=0 gedrückt ?, wenn ja, überspringe "goto T2Test"
goto T2Test ; wenn nicht, springe zu "T2Test"
bsf _L1 ; schalte _L1 an
call Warten ; warte ca. 0,4 s (ca. 400 000 Prozessortakten)
bcf _L1 ; schalte _L1 aus
bsf _L2 ; schalte _L2 an
call Warten ; warte
bcf _L2 ; schalte _L2 aus
bsf _L3 ; schalte _L3 an
call Warten ; warte
bcf _L3 ; schalte _L3 aus
bsf _L4 ; schalte _L4 an
call Warten ; warte
bcf _L4 ; schalte _L4 aus
T2Test btfsc _T2 ; Taster _T2=0 gedrückt ?, wenn ja, überspringe "goto Haupt"
goto Haupt ; wenn nicht, springe zu "Haupt"
bsf _L4 ; schalte _L4 an
call Warten ; warte
bcf _L4 ; schalte _L4 aus
bsf _L3 ; schalte _L3 an
call Warten ; warte
bcf _L3 ; schalte _L3 aus
bsf _L2 ; schalte _L2 an
call Warten ; warte
bcf _L2 ; schalte _L2 aus
bsf _L1 ; schalte _L1 an
call Warten ; warte
bcf _L1 ; schalte _L1 aus
goto Haupt ; springe zu "Haupt"
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 ; dekrementiere P0 und überspringe "goto $-1" bei P0 = 0
goto $-1 ; sonst gehe zur voherigen Adresse (Befehl "decfsz P0")
decfsz P1 ; dekrementiere P1 und überspringe "goto $-4" bei P1 = 0
goto $-4 ; sonst gehe zur aktueller Adresse - 4 (Befehl "clrf P0")
decfsz P2 ; 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 ("Haupt"),
Init clrf GPIO ; lösche Port (setze alle werdende Ausgänge auf "0")
bsf STATUS,RP0 ; auf Bank1 umschalten
bcf OPTION_REG,7 ; aktiviere pull-ups
movlw 0x18 ; definiere Portpins GPIO,3 und 4 als Eingänge
; und die restlichen als Ausgänge
movwf TRISIO ; schreibe in TRIS Register
bcf STATUS,RP0 ; auf Bank0 umschalten
return ; springe zurück (zum Haupt), nach der Zeile
; aus der du afgerufen wurdest
; hier endet das gesamte ASM Programm
end ; MPASM Direktive

== Optimierung ==
Work in Progress...
Wer sonst noch Beispiele hat, bitte hier vervollständigen...
BMS ...
=== Speicherbedarf ===
==== Programmspeicher ====
Die ersten Programme für den PIC sind natürlich einfach und kurz. Doch nach und nach werden die Codes länger und unübersichtlicher, das Brennen dauert auch umso länger. Das Programm ist zu umfangreich. Doch wo soll man etwas kürzen?

Es gibt unzählige Möglichkeiten - hier ein paar Beispiele:

===== Unterprogramme =====

Bestimmt wird man im Code immer die selben Abschnitte brauchen, zum Beispiel Warteschleifen oder ADC-Routinen, etc. Wieso sollte man diese also mehrfach (doppelt, dreifach, u.s.w.) schreiben?

Die Lösung: Der Programmteil wird als Unterprogramm benutzt. Man erstellt eine Sprungmarke (ab hier beginnt das Unterprogramm) und endet wieder mit einem "return"- oder "retlw"-Befehl.
Aufgerufen werden die Unterprogramme meistens mit dem "call"-Befehl. Es "lohnt sich" ein Codefragment als UP zu definieren erst wenn es min. 2 mal aufgerufen wird.

Ein "goto"-Befehl ist zu diesem Zweck geeignet nur, wenn der Prozessor zum letzten Aufrufer von "call" zurück springen soll, da die Rücksprungadresse vom letzten "call" auf dem Stapel (stack) abgelegt wurde. Somit kann man mehr als 8 Ebenen von UPs nutzen.

Den Unterprogrammen kann man natürlich auch Werte übergeben. Möchte man z.B. mehrere unterschiedliche Zeiten für Warteschleifen benutzen, so kann man die Parameter vor dem Aufruf des UPs in benötigte Anzahl von Register einschreben und dann das Unterprogramm mit "call" aufrufen. Das Unterprogramm verwendet dann die Zahlen von den Register. Siehe: [[#Pause|Pause]]

Um gleiche Vorgänge in mehreren Register durchzuführen (z.B. löschen) geeignet ist Anwendung von Schleifen mit bestimmter Anzahl der Abläufe und indirekter Adressierung. Siehe: [[#Variablen|Variablen]]

===== bsf und bcf =====

Bestimmt gibt es Situationen, in denen der PIC mehrere Bits an einem Port/Register setzen oder löschen muss. Z.B. wenn mehrere LEDs an einem Port ein- oder ausgeschaltet werden sollen.
Werden mehr als 2 Bits verändert, so kann man hier die "bsf"- und "bcf"-Befehle umgehen und einen kürzeren Code erstellen.

bsf PORTB,0 ;An PORTB sind 8 LEDs angeschlossen.
bsf PORTB,1 ;Es sollen die ersten 4 LEDs angeschaltet werden,
bsf PORTB,2 ;die anderen sollen ausgeschaltet werden.
bsf PORTB,3 ;links steht es mit bcf/bsf
bcf PORTB,4 ;ziemlich lang
bcf PORTB,5
bcf PORTB,6
bcf PORTB,7

movlw b'00001111' ;Das geht auch kürzer und übersichtlicher:
movwf PORTB

Man sieht - der Codeabschnitt umfasst nur noch 2 Zeilen anstatt 8. Somit braucht es weniger Speicher und wird von PIC schneller verarbeitet. Allerdings muss man aufpassen, da durch diese Routine der Inhalt des W-Registers und der Inhalt des gesamten Zielregisters verändert wird. Sollen die anderen Bits unangetastet bleiben, muss man es entweder bei den "bcf"/"bsf"-Befehlen belassen oder logische Funktionen (and bzw. or) durchführen.

===== Bit kopieren =====

;An den PIC ist ein Taster(RB0) und eine LED(RB1) angeschlossen.
;Taster: High=gedrückt Low=nicht gedrückt
;LED: High=Ein Low=Aus
;Wenn der Taster gedrückt ist, soll die LED leuchten
;wenn er nicht gedrückt ist, soll die LED nicht leuchten.
;1.Vorschlag:
btfss PORTB,0 ;ist der taster gedrückt?
goto no ;nein
bsf PORTB,1 ;ja - LED ein
goto endif ;fertig abgefragt - unten weitermachen...
no bcf PORTB,1 ;LED aus
endif

Der oben aufgeführte Code hat viele Nachteile: er ist relativ lang, braucht zwei Gotos und entspr. Sprungmarken. Ok, das ist vielleicht Erbsenzählerei, aber aus diesen 5 Zeilen kann man 3 machen.

bcf PORTB,1 ;Das Bit wird erst gelöscht
btfss PORTB,0 ;Taster gedrückt?
bsf PORTB,1 ;JA-LED an

Man geht davon aus, dass der Taster nicht gedrückt ist. Somit wird die LED erst einmal ausgeschaltet. Ist der Taster aber doch gedrückt, dann wird die LED angeschaltet.

Achtung möglicher Nebeneffekt: Wird dies in einer Schleife sehr schnell und oft ausgeführt, kann die LED flimmern oder nicht in ihrer vollen Helligkeit leuchten. Das passiert, weil ja angenommen wird, dass der Taster nicht gedrückt wird und die LED somit aus sein muss. Dann wird sie aber bei Tastendruck eingeschaltet. Somit entsteht ein schnelles ein-/ausschalten (PWM) und die LED leuchtet nicht mehr so hell.
Meist ist das aber nicht tragisch oder wird nicht unbedingt in einer Schleife sehr schnell abefragt. Siehe hierzu: [[#Einlesen|Einlesen]]

==== RAM ====

Um Anzahl benötigten Register zu sparen werden vorläufige Register (temporary) definiert, die von mehreren UPs benutzt werden. Als Beispiel, das Register "ATmp" in [[#Hex Dec Wandlung|Hex Dec Wandlung]]. Die Benutzung muss aber sehr genau nach PAD zugeteilt werden. Bei gleichzeitiger Benutzung des gleichen Registers durch mehrere UPS werden falsche Daten verarbeitet und im schlimmsten Fall können endlose Schleifen entstehen, die in Folge haben, dass das Programm nicht weiter ausgeführt wird ("hängt").

Fast alle im ASM Programm ungebrauchten SFRs können als "normale" Register (GPR) verwendet werden. Wenn zum Beispiel Timer1 nicht benutzt wird, können seine Register TMR1H und TMR1L für Speicherung von Daten benutzt werden. Es könnte aber gefährlich werden, wenn mehrere Programme gebindet sind. Deswegen muss es immer am Ende, beim volständigen Programm, geprüft werden, welche SFRs tatsächlich benutzt werden dürfen.

Für Konstanten (z.B. pi, ln2, Meldungen, u.s.w.), die sich im Laufe des Programms nicht ändern, kann EEPROM (mit MPASM Direktive "de") oder Programmspeicher (mit MPASM Direktive "dt") als Ablage benutzt werden. Siehe auch: [[#EEPROM|EEPROM]] und [[#Tabellen|Tabellen]]

=== Ausführungszeit ===

Alles was schnellmöglichst ablaufen soll, widersetzt sich der Optimierung des Programmspeichers.

Es können keine Schleifen und keine indirekte Adressierung benutzt werden, alles muss direkt programmiert werden.

Als Beispiel zur Verdeutlichung: Es sollen 16 Werte vom PORTA ins RAM ab Adresse 0x20 eingelesen werden.

Als Schleife mit indirekter Adressierung:

................
movlw 0x10 ;Anzahl Durchläufe
movwf Temp ;in den Schleifenzähler
movlw 0x20 ;erste Adresse
movwf FSR ;ins FSR Register
Einlesen movf PORTA,0 ;PortA ins W-Register
movwf INDF ;und ins aktuellen RAM Register
incf FSR,1 ;nächste Adresse
decfsz Temp,1 ;Temp = 0 ?
goto Einlesen ;nein, zum Einlesen
................ ;ja, weiter
Gesamtdauer: 100 Takten
Pause zwischen Einlesungen: 6 Takten
Programmspeicher Bedarf: 9 Speicherstellen
Direkt:

...............
movf PORTA,0
movwf 0x20
movf PORTA,0
movwf 0x21
movf PORTA,0
movwf 0x22
movf PORTA,0
movwf 0x23
movf PORTA,0
movwf 0x24
movf PORTA,0
movwf 0x25
movf PORTA,0
movwf 0x26
movf PORTA,0
movwf 0x27
movf PORTA,0
movwf 0x28
movf PORTA,0
movwf 0x29
movf PORTA,0
movwf 0x2A
movf PORTA,0
movwf 0x2B
movf PORTA,0
movwf 0x2C
movf PORTA,0
movwf 0x2D
movf PORTA,0
movwf 0x2E
movf PORTA,0
movwf 0x2F
...............
Gesamtdauer: 32 Takten
Pause zwischen Einlesungen: 2 Takten
Programmspeicher Bedarf: 32 Speicherstellen

Anstatt Warteschleifen (z.B. für Tastenentprellung) sollten Programmfragmente mit entsprechender Ausführungszeit benutzt werden (z.B. Ausgabe auf einem Display). Die nötige Zeit lässt sich aus mehreren UPs zusammensetzen.

Es sollte kein Prozessortakt ungenutzt bleiben.

= Mid-Range =

Zu Mid-Range gehören alle PICs mit 14-bit langen Befehlen aus den Familien 12FXXX und 16FXXX.

== Kurzübersicht Assembler Befehle ==

{|
|-
| valign=top |

{| {{Blauetabelle}}
|ADDLW||Add literal and W
|-
|ADDWF||Add W and f
|-
|ANDLW||AND literal with W
|-
|ANDWF||AND W with f
|-
|BCF||Bit Clear f
|-
|BSF||Bit Set f
|-
|BTFSC||Bit Test f, Skip if Clear
|-
|BTFSS||Bit Test f, Skip if Set
|-
|CALL||Call subroutine
|-
|CLRF||Clear f
|-
|CLRW||Clear W
|-
|CLRWDT||Clear Watchdog Timer
|}

| valign=top |

{| {{Blauetabelle}}
|-
|COMF||Complement f
|-
|DECF||Decrement f
|-
|DECFSZ||Decrement f, Skip if 0
|-
|GOTO||Go to address or label
|-
|INCF||Increment f
|-
|INCFSZ||Increment f, Skip if 0
|-
|IORLW||Inclusive OR literal with W
|-
|IORWF||Inclusive OR W with f
|-
|MOVF||Move f
|-
|MOVLW||Move literal to W
|-
|MOVWF||Move W to f
|-
|NOP||No Operation
|}

| valign=top |

{| {{Blauetabelle}}
|-
|RETFIE||Return from interrupt
|-
|RETLW||Return with literal in W
|-
|RETURN||Return from Subroutine
|-
|RLF||Rotate Left f through Carry
|-
|RRF||Rotate Right f through Carry
|-
|SLEEP||Go into standby mode
|-
|SUBLW||Subtract W from literal
|-
|SUBWF||Subtract W from f
|-
|SWAPF||Swap nibbles in f
|-
|XORLW||Exclusive OR literal with W
|-
|XORWF||Exclusive OR W with f
|}
[[:bild:pic_asm_short.jpg|Kurzübersicht zum Ausdrucken]]
|}


==Ausführliche Beschreibung zu den Befehlen==

Eine ausgegliederte Beschreibung der Befehle findet sich unter [[PIC Assemblerbefehle]]

Erklärungen zu den Verwendeten Platzhaltern:
*'''k''' stellt einen fest definierten Wert da. z.B. <tt>0x20</tt>, <tt>d'42'</tt> oder <tt>b'00101010'</tt>
*'''W''' steht für das W-Register.
*'''d''' steht für ''destination'' (Ziel). Im code wird d durch ein <tt>w</tt> bzw. <tt>0</tt> (der Wert wird in das W-Register gespeichert ) oder <tt>f</tt> bzw. <tt>1</tt> (der Wert wird in das davor definierte Register gespeichert)
*'''b''' steht für Bitnummer im Register (eine Zahl zwischen 0 und 7)
*'''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
*<tt>Schreibmaschinenstil</tt> bedeutet, dass es so im Quellcode geschrieben werden kann.

 ADDLW k Add W and literal - Addiere W und Zahl (k)<hr>
:Es wird die Rechenoperation <math>W+k</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|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

 ADDWF R,d Add W and f - Addiere W und f <hr>
:Es wird die Rechenoperation <math>W+R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Dieser Befehl beeinflusst das STATUS-Register. Siehe hierzu [[#Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

 ANDLW k AND literal with W<hr>
:Es wird bitweise die logische Funktion <math>k\ and\ W</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 Operation:
<dl><dd>
11001010 ;k
10101100 ;W-Register
-------- and
10001000 ;W-Register
</dd></dl>

 ANDWF R,d AND W with f<hr>
:Es wird bitweise die logische Funktion <math>W\ and\ R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Vergleiche ANDLW. Dieser Befehl wird oft benutzt zum Löschen bestimmten Bits im Register ohne restlichen Bits zu beeinflüssen.

BCF R,b Bit Clear f - Bit b im R wird gelöscht<hr>
:Mit dem Befehl <tt>BCF</tt> wird das Bit '''b''' im Register '''R''' gelöscht. Ein Beispiel:
<dl><dd>
movlw b'11111111' ;es wird b'11111111' in das W-Register geschrieben
BCF W,2 ;es wird bit 2 im W-Register gelöscht.
;das Ergebnis ist: b'11111011'
</dl></dd>

BSF R,b Bit Set f - Bit b im R wird gesetzt<hr>
:Mit dem Befehl <tt>BSF</tt> wird das Bit '''b''' im Register '''R''' gesetzt. Ein Beispiel:
<dl><dd>
clrw ;es wird b'00000000' in das W-Register geschrieben
BSF W,2 ;es wird bit 2 im W-Register gesetzt.
;das Ergebnis ist: b'00000100'
</dl></dd>

BTFSC R,b Bit Test f, Skip if Clear - Wenn das Bit b im Register R 0 ist, überspringe den nächsten Befehl<hr>
:Mit dem Befehl <tt>BTFSC</tt> kann eine Verzweigung im Programmablauf bewirkt werden. Wenn das Bit '''b''' im Register '''R''' 0 ist, wird der nächste Befehl übersprungen. Ein Beispiel:
<dl><dd>
movlw b'00000001' ;es wird die Zahl 1 in das W-Register kopiert.
BTFSC W,0 ;es wird bit 0 geprüft.
;wenn es 0 ist, wird der nächste Befehl übersprungen
goto IST_EINS ;springt zur Marke "IST_EINS" <- in diesem Fall wird dieser
;Sprungbefehl ausgeführt.
goto IST_NULL ;springt zur Marke "IST_NULL"
</dl></dd>

BTFSS R,b Bit Test f, Skip if Set - Wenn das Bit b im Register R 1 ist, überspringe den nächsten Befehl<hr>
:Mit dem Befehl <tt>BTFSS</tt> kann eine Verzweigung im Programmablauf bewirkt werden. Wenn das Bit '''b''' im Register '''R''' 1 ist, wird der nächste Befehl übersprungen. Ein Beispiel:
<dl><dd>
movlw b'00000001' ;es wird die Zahl 1 in das W-Register kopiert.
BTFSS W,0 ;es wird bit 0 geprüft.
;wenn es 1 ist, wird der nächste Befehl übersprungen
goto IST_NULL ;springt zur Marke "IST_NULL"
goto IST_EINS ;springt zur Marke "IST_EINS" <- in diesem Fall wird dieser
;Sprungbefehl ausgeführt, da der Befehl
;darüber übersprungen wurde.
</dl></dd>

CALL Call Subroutine - Rufe Unterprogramm auf<hr>
:Mit dem <tt>CALL</tt> Befehl wird ein Unterprogramm aufgerufen. Mit dem <tt>RETURN</tt>-Befehl wird das Unterprogramm beendet und man kehrt zum Befehl nach dem <tt>CALL</tt>-Befehl zurück. Das Unterprogramm wird so definiert, dass im Quellcode der Name des Unterprogramms nicht eingerückt steht. Ein Beispiel:

<dl><dd>
movlw d'13' ;in das W-Register wird 13d geladen
CALL Unterprogramm1 ;es wird das Unterprogramm "Unterprogramm1" aufgerufen
movwf ergebnis ;das W-Register wird in das Register "ergebnis" kopiert.
;im Register "ergebnis" steht nun 23d

Unterprogramm1 ;zählt 10 zum W-Register
addlw d'10' ;es wird 10d zum W-Register addiert
RETURN ;kehre zurück zum Aufrufer
</dl></dd>

CLRF R Clear f - Schreibe 0 in das Register R<hr>
:Das Register '''R''' wird mit Nullen gefüllt (gelöscht).

CLRW Clear W - Schreibe 0 in W<hr>
:Das W-Register (<tt>W</tt>) wird mit Nullen gefüllt (gelöscht).
:Der Befehl bewirkt das gleiche wie MOVLW 0 und darf im Programmen, die fur zukünftige Anwendung bei den PICs der serie 18F vorgesehen sind, nicht benutzt werden, da sie ihn nicht kennen.

CLRWDT Clear Watchdog Timer - Setzt den Watchdog-Timer zurück<hr>
:Es wird der WDT (Watchdog-Timer) zurückgesetzt und der Zähler des WDT auf 0 gesetzt, zusätzlich werden die STATUS-bits TO und PD gesetzt.

COMF R,d Complement f - negiere alle bits im Register R<hr>
:Von der Binärzahl im Register '''R''' werden alle 0 mit 1 und alle 1 mit 0 ersetzt. Das Ergebnis wird entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Ein kleines Beispiel: aus <tt>AAh</tt> (<tt>10101010b</tt>) wird <tt>55h</tt> (<tt>01010101b</tt>).

DECF R,d Decrement f - Subtrahiert 1 vom Regiser f<hr>
:Vom Wert des Registers '''R''' wird 1 subtrahiert und das Ergebnis entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
:Weil es keine "echte" Substraktion ist, beeinflusst dieser Befehl das C-Flag im STATUS-Register nicht.

DECFSZ R,d Decrement f, Skip if 0 - Subtrahiert 1 vom Regiser f, überspringe wenn 0<hr>
:Vom Wert des Registers '''R''' wird 1 subtrahiert und das Ergebnis entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Der Zusatz SZ steht für ''skip if zero'', d.h. wenn das Ergebnis der Rechnung Null ist, wird der nächste Befehl übersprungen. Dieser Befehl wird für Schleifen mit bestimmter Anzahl der Durchläufe benutzt.

GOTO Go to address - Gehe zu Adresse/Sprungmarke<hr>
:Nach dem GOTO Befehl wird das Programm ab der Adresse weiter ausgeführt, die nach dem GOTO-Befehl steht. Diese Adresse wird durch so genannte Sprungmarke definiert, welche, im Gegensatz zu den Befehlen nicht eingerückt im Quellcode stehen.

INCF R,d Increment f - Addiere 1 zum Register f<hr>
:Zum Wert des Registers '''R''' wird 1 addiert und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
:Weil es keine "echte" Addition ist, beeinflusst dieser Befehl das C-Flag im STATUS-Register nicht.

INCFSZ R,d Increment f, Skip if 0 - Addiere 1 zum Regiser f, überspringe wenn 0<hr>
:Zum Wert des Registers '''R''' wird 1 addiert und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Der Zusatz SZ steht für ''skip if zero'', d.h. wenn das Ergebnis der Rechnung Null ist, wird der nächste Befehl übersprungen. Dieser Befehl wird für Schleifen mit bestimmter Anzahl der Durchläufe benutzt.

 IORLW k OR literal with W<hr>
:Es wird bitweise die logische Funktion <math>k\ or\ W</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 Operation:
<dl><dd>
11001010 ;k
10101100 ;W-Register
-------- or
11101110 ;W-Register
</dd></dl>

 IORWF R,d OR W with f<hr>
:Es wird bitweise die logische Funktion <math>W\ or\ R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Vergleiche IORLW. Dieser Befehl wird oft benutzt zum Setzen bestimmten Bits im Register ohne restlichen Bits zu beeinflüssen.

MOVF R,d Move f - Bewege f<hr>
:Das Register R wird in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder wieder in R kopiert ('''d'''=<tt>F</tt>=<tt>1</tt>). Letzteres mag sinnlos scheinen, ist aber nützlich, da durch den Befehl das Z-Bit im STATUS-Register gesetzt wird, falls R Null ist.

MOVLW k Move literal to W - Bewege Zahl (k) in W-Register<hr>
:Der festgelegte Wert k wird in das W-Register kopiert.

:Dieser Befehl wird auch bei indirekter Adressierung zum laden der absoluter Adresse ins "FSR" Register benutzt. Beispiel:
:Der Register "Temp" wurde mit "Temp equ 0x20" definiert.
<dl><dd>
movlw Temp ;ins W-Register wird die absolute Adresse 0x20 vom "Temp" geladen
movwf FSR ;diese Adresse wird jetzt ins Register "FSR" kopiert
</dd></dl>
MOVWF R Move W to f - Bewege W-Register in das Register F<hr>
:Das W-Register wird in das Register '''R''' kopiert.

NOP No Operation - Kein Befehl zum Ausführen (warte)<hr>
: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. Siehe hierzu: [[#Pause|Pause]]

RETFIE Return from interrupt - Kehre zurück aus der Unterbrechung<hr>
:Mit diesem Befehl wird die Interrupt Service Routine (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 | Interrupt]]

RETLW k Return with literal in W - Kehre zurück mit Zahl k im W-Register<hr>
:Wurde ein Programmteil mit dem Befehl <tt>CALL</tt> aufgerufen, dann springt man mit dem Befehl <tt>RETLW</tt> zurück in die nächste Zeile nach der Zeile aus der das <tt>CALL</tt> 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 Wertetabellen (eng: lookup tables) verwendet.

RETURN Return from Subroutine - Kehre zurück zum Aufrufer<hr>
:Wurde ein Programmteil mit dem Befehl <tt>CALL</tt> aufgerufen, dann springt man mit dem Befehl <tt>RETURN</tt> zurück zu der nächsten Zeile nach der Zeile aus der das <tt>CALL</tt> Befehl ausgeführt wurde.

RLF R,d Rotate Left f through Carry - Rotiere das Register f mithilfe des Carry-bits nach links<hr>
:Alle Bits im Register '''R''' werden um eine Position nach links verschoben. Dabei wird das Carry bit (<tt>STATUS,C</tt>) 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'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
<dl><dd>
|<--- Register R --->|
|c|<-7<-6<-5<-4<-3<-2<-1<-0
V A
|________________________|
</dd></dl>
:Zur Verdeutlichung:
<dl><dd>
|C| |-Register R-| ;C steht für das Carry-bit, STATUS,C ; 0-7 stehen für Bitnummer im Register.
c 7 6 5 4 3 2 1 0 ;vor der Rotation
7 6 5 4 3 2 1 0 c ;nach der Rotation
</dd></dl>

RRF R,d Rotate Right f through Carry - Rotiere das Register f mithilfe des Carry-bits nach rechts<hr>
:Alle Bits im Register '''R''' werden um eine Position nach rechts verschoben. Dabei wird das Carry bit (<tt>STATUS,C</tt>) 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'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
<dl><dd>
|<--- Register R --->|
|c|->7->6->5->4->3->2->1->0
A V
|________________________|
</dd></dl>
:Zur Verdeutlichung:
<dl><dd>
|C| |-Register R-| ;C steht für das Carry-bit, STATUS,C ; 0-7 stehen für Bitnummer im Register.
C 7 6 5 4 3 2 1 0 ;vor der Rotation
0 C 7 6 5 4 3 2 1 ;nach der Rotation
</dd></dl>

SLEEP Go into standby mode - Versetze den Mirokontroller in Bereitschaftsmodus<hr>
: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.

 SUBLW k Subtract W from literal - Ziehe W von Zahl (k) ab<hr>
: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|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

 SUBWF R,d Subtract W from f - Ziehe W von f ab<hr>
:Es wird die Rechenoperation <math>R-W</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Dieser Befehl beeinflusst das STATUS-Register. Siehe hierzu [[#Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

:Beispiel:
<dl><dd>
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
</dd></dl>

SWAPF R,d Swap nibbles in f - Vertausche die Halbbytes (Nibbles)<hr>
:Es werden die höheren 4 bit (bit7-bit4) mit den niedrigeren 4 bit (bit3-bit0) eines Registers vertauscht und entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
:Beispiel:
<dl><dd>
movlw b'00001111' ;schreibe b'00001111' in das W-Register
movwf Register1 ;kopiert 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'
</dd></dl>

 XORLW k Exclusive OR literal with W<hr>
:Es wird bitweise die logische Funktion <math>k\ xor\ W</math> ausgeführt und das Ergebniss in das W-Register gespeichert. Dieser Befehl setzt das Z bit des STATUS-Registers, falls W=k und das Ergebnis 0 ist.
:Zur Verdeutlichung der Operation:
<dl><dd>
11001010 ;k
10101100 ;W-Register
-------- xor
01100110 ;W-Register
</dd></dl>

 XORWF R,d Exclusive OR W with f<hr>
:Es wird bitweise die logische Funktion <math>W\ xor\ R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Vergleiche XORLW. Dieser Befehl wird zum Vergleichen zwei Register benutzt.

==Besondere, oft gebrauchte Register==

=== STATUS ===
Der Statusregister beinhaltet den Status der Recheneinheit ALU (Arithmetic-Logic Unit), Resetinformationen und die beiden Bits zur Wahl der Speicherbank

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''STATUS''' (ADDRESSE 03h, 83h, 103h, 183h)</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R-1</td>
<td style="width:60px;">R-1</td>
<td style="width:60px;">R/W-x</td>
<td style="width:60px;">R/W-x</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''IRP'''</td>
<td style="background:#f5f7ff;">'''RP1'''</td>
<td style="background:#f5f7ff;">'''RP0'''</td>
<td style="background:#f5f7ff;">'''TO'''</td>
<td style="background:#f5f7ff;">'''PD'''</td>
<td style="background:#f5f7ff;">'''Z'''</td>
<td style="background:#f5f7ff;">'''DC'''</td>
<td style="background:#f5f7ff;">'''C'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

*Bit 7 '''IRP''': Register Bank Select Bit (für indirekte Adressierung)
:: 1 = Bank 2, 3 (100h-1FFh)
:: 0 = Bank 0, 1 (00h-FFh)
*Bit 6-5 '''RP<1:0>''': Register Bank Select Bits (für direkte Adressierung)
:: 11 = Bank 3 (180h-1FFh)
:: 10 = Bank 2 (100h-17Fh)
:: 01 = Bank 1 (80h-FFh)
:: 00 = Bank 0 (00h-7Fh)
*Bit 4 '''TO''': Time-out Bit
:: 1 = Nach Power-up, CLRWDT Befehl oder SLEEP Befehl
:: 0 = A Watchdogtimer time-out ist eingetreten
*Bit 3 '''PD''': Power-Down Bit
:: 1 = Nach Power-up oder durch den CLRWDT
:: 0 = Nach einem SLEEP befehl
*Bit 2 '''Z''': Zero bit
:: 1 = Das Ergebnis einer arithmetischen oder logischen Operation ist 0
:: 0 = Das Ergebnis einer arithmetischen oder logischen Operation ist NICHT 0
*Bit 1 '''DC''': Digit carry/borrow bit (ADDWF, ADDLW, SUBLW und SUBWF Befehle)
:: 1 = Ein Carry-out des 4.Niedrigsten Bits (Low Nibble) eines Rechenergebnisses existiert
:: 0 = Kein Carry-out des 4.Niedrigsten Bits eines Rechenergebnisses existiert
*Bit 0 '''C''': Carry/borrow Bit (ADDWF, ADDLW, SUBLW und SUBWF Befehle)
:: 1 = Ein Carry-out des MSB eines Rechenergebnisses existiert
:: 0 = Kein Carry-out des MSB eines Rechenergebnisses existiert

Das "Borrowbit" (to borrow = etwas borgen) dient zum erkennen, wenn ein Übertrag einer Rechenoperation exisitiert. 250+10 ergibt zum Beispiel 4, und setzt dabei das Borrowbit auf 1. Damit kann das Programm erkennen, wenn wieder einmal ein Ergebnis größer als 255 herauskam.
Bei Subtraktionen (SUBLW und SUBWF) verhält sich das Carry Bit umgekehrt als bei Additionen (ADDWF und ADDLW)!! Zum Beispiel 55-6=49 setzt Carry auf 1 aber 10-25=241 löscht das Carry-Flag.

====Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Registers====

{|
|-
|
{| {{Blauetabelle}}
|+ Auswirkungen auf das STATUS-Register bei Subtraktionen
|-
| Ergebnis
|| STATUS,C
|| STATUS,Z
|-
| positiv
|align="center"|1
|align="center"|0
|-
| negativ
|align="center"|0
|align="center"|0
|-
| Null
|align="center"|1
|align="center"|1
|}

||

{| {{Blauetabelle}}
|+ Auswirkungen auf das STATUS-Register bei Additionen
|-
| Ergebnis
|| STATUS,C
|| STATUS,Z
|-
| positiv
|align="center"|0
|align="center"|0
|-
| Überlauf
|align="center"|1
|align="center"|0
|-
| Null
|align="center"|1
|align="center"|1
|}
|}

=== INTCON ===

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''INTCON''' (ADDRESSE 0Bh, 8Bh, 10Bh, 18Bh)</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''GIE'''</td>
<td style="background:#f5f7ff;">'''PEIE'''</td>
<td style="background:#f5f7ff;">'''TMR0IE'''</td>
<td style="background:#f5f7ff;">'''INT0IE'''</td>
<td style="background:#f5f7ff;">'''RBIE'''</td>
<td style="background:#f5f7ff;">'''TMR0IF'''</td>
<td style="background:#f5f7ff;">'''INT0IF'''</td>
<td style="background:#f5f7ff;">'''RBIF'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

*Bit 7 '''GIE''': Global Interrupt Enable Bit
::1 = Aktiviert alle Interrupts
::0 = Deaktiviert alle Interrupts
*Bit 6 '''PEIE''': Peripheral Interrupt Enable Bit
::1 = Aktiviert alle peripheren Interrupts
::0 = Deaktiviert alle peripheren Interrupts
*Bit 5 '''TMR0IE''': TMR0 Overflow Interrupt Enable Bit (Overflow von Timer0 löst Interrupt aus)
::1 = Aktiviert den TMR0 Interrupt
::0 = Deaktiviert den TMR0 Interrupt
*Bit 4 '''INT0IE''': RB0/INT External Interrupt Enable Bit (Änderung an RB0 Pin löst Interrupt aus) *)
::1 = Aktiviert den RB0/INT Interrupt (Extern ausgelöst)
::0 = Deaktiviert den RB0/INT Interrupt (Extern ausgelöst)
*Bit 3 '''RBIE''': RB Port On-Change-Interrupt Enable Bit (Änderung an PortB löst Interrupt aus) **)
::1 = Aktiviert den RB port on-change-interrupt
::0 = Deaktiviert den RB port on-change-interrupt
*Bit 2 '''TMR0IF''': TMR0 Overflow Interrupt Flag Bit
::1 = TMR0 Register ist Übergelaufen (muss per Software gelöscht werden)
::0 = TMR0 register ist nicht Übergelaufen
*Bit 1 '''INT0IF''': RB0/INT External Interrupt Flag Bit
::1 = Eine Änderung an RB0/INT Pin hat stattgefunden (muss per Software gelöscht werden)
::0 = Eine Änderung an RB0/INT Pin hat nicht stattgefunden
*Bit 0 '''RBIF''': RB Port On-Change-Interrupt Flag bit
::1 = Mind. einer der Pins von RB7:RB4 hat sich geändert (muss per Software gelöscht werden)
::0 = Keiner der Pins von RB7:RB4 hat sich geändert

* *) Die Flanke auf die reagiert werden soll, wird mit dem Bit OPTION_REG.INTEDG definiert. (steigende = 1 oder fallende = 0)
* **) Der Interrupt klingt verführerischer Weise so, als ob er den gesamten Port überwacht. Dabei reagiert er nur auf RB7:RB4!!!! Er kann aber den Prozessor vom "Schlaf" aufwecken (z.B. durch einen Tastendruck).

=== PORTx ===

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''PORTx'''</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''Rx7'''</td>
<td style="background:#f5f7ff;">'''Rx6'''</td>
<td style="background:#f5f7ff;">'''Rx5'''</td>
<td style="background:#f5f7ff;">'''Rx4'''</td>
<td style="background:#f5f7ff;">'''Rx3'''</td>
<td style="background:#f5f7ff;">'''Rx2'''</td>
<td style="background:#f5f7ff;">'''Rx1'''</td>
<td style="background:#f5f7ff;">'''Rx0'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

!Das "x" steht in allen Fällen für den Buchstaben des Ports!
BSP: "PORTB" oder "RA1"

Diese Special Funktion Register liegen ALLE in Bank0 und Bank2(Falls vorhanden).

Jedes Bit eines PORT-Registers steht für einen Pin (Ein/Ausgang) des jeweiligen Ports. Je nachdem Ob ein Pin als Ausgang oder als Eingang definiert ist, kann man dort entweder den Wert schreiben oder auslesen. Es hat nicht Jeder PIC gleich viele Ports und es sind auch nicht immer 8 Pins pro Port, es können auch weniger sein. Alle PICs der Midrange-Serie besitzen nur bidirektionale Ports, d.h. sie können sowohl Eingang als auch Ausgang sein. Bei Port B kann man bei allen Pins einen internen PULL-UP Widerstand mit dem Bit OPTION_REG<RBPU> hinzuschalten (Standardmäßig auf nicht aktiviert, Bit muss gelöscht werden um die Funktion zu aktivieren). Weiters ist zu beachten, dass einzelne Pins nach dem Reset mit anderen Funktionen belegt sein können. Das gilt im Speziellen für PORTA, wo sich die Komperatoren, AD's (falls vorhanden) und die Oszillatoreingänge befinden. Siehe [[PIC Assembler#I/O Ports|I/O Ports]]. Bei den "kleinsten" PICs der 12F Serie die nur einen I/O Port (6 Pins) haben, heisst der PORT-Register GPIO.
{|{{Blauetabelle}}
|+ Beispiel PICs und ihre Ports (Zahlen in der Klammer sind die Anzahl der Pins des Ports)
|
|'''PIC16F628A'''
|'''PIC16F876'''
|'''PIC16F877'''
|-
|'''PORTA'''
|Ja
|Ja(5)
|Ja(6)
|-
|'''PORTB'''
|ja
|ja
|ja
|-
|'''PORTC'''
|/
|ja
|ja
|-
|'''PORTD'''
|/
|/
|ja
|-
|'''PORTE'''
|/
|/
|ja (3)
|-
|}

=== TRISx ===

<table style="text-align: center;" cellspacing="0">
<tr>
<td colspan="8" style>'''TRISx'''</td>
</tr>
<tr style="border:0px;">
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-0</td>
<td style="width:60px;">R/W-x</td>
</tr>
<tr>
<td style="background:#f5f7ff;">'''TRISx7'''</td>
<td style="background:#f5f7ff;">'''TRISx6'''</td>
<td style="background:#f5f7ff;">'''TRISx5'''</td>
<td style="background:#f5f7ff;">'''TRISx4'''</td>
<td style="background:#f5f7ff;">'''TRISx3'''</td>
<td style="background:#f5f7ff;">'''TRISx2'''</td>
<td style="background:#f5f7ff;">'''TRISx1'''</td>
<td style="background:#f5f7ff;">'''TRISx0'''</td>
</tr>
<tr>
<td>Bit7</td>
<td colspan="6"></td>
<td>Bit0</td>
</tr>
</table>

!Das "x" steht in allen Fällen für den Buchstaben des Ports!
BSP: "TRISB" oder "TRISA"

Bei den "kleinsten" PICs der 12F Serie die nur einen I/O Port (6 Pins) haben, heisst der TRIS-Register TRISIO.

Die TRIS-Bytes dienen dazu, einzelne I/O Pins als Eingang oder Ausgang zu definieren. Sie liegen immer genau eine Bank über den jeweiligen PORT-Bytes, d.h. sie liegen alle in Bank1 und Bank3(falls vorhanden.) Besonders zu beachten ist, dass manche Eingebaute Features wie die Serielle Schnittstelle, I2C, SPI usw nicht funktionieren, wenn die Jeweiligen Sende und Empfangspins nicht nicht manuell umgestellt werden, ja es ''muss'' sogar manchmal umgestellt werden (bei I2C z.B.) Egal ist dies jedoch für Komperatoren und AD-Wandler.

Merke:
* Eine 1 (als "I" für "Input" zu lesen) eines TRISxx-Bits definiert den zugehörigen PIN am PIC als Eingang.
* Eine 0 (als "O" für "Output" zu lesen) eines TRISxx-Bits definiert den zugehörigen PIN am PIC als Ausgang.

Siehe [[PIC Assembler#I/O Ports|I/O Ports]].

==Speicherbankorganisation==
===Programmspeicher===
Die Mid-Range MCUs haben einen 2-8k großen Programmspeicher. Dieser hat aber in jeder Speicherzelle nicht 8, sondern 14 Bit - also genau die Länge eines Befehls. Die aktuelle Stelle im Programm wird im PC (Program Counter) verwaltet. Er speichert immer die aktuelle Adresse im Programmspeicher (wird im Code oft als "$" bezeichnet). Bei einem PIC mit 8k Adressen muss er also die Adressen 0000-1FFF speichern können. Daraus folgt die Größe von 13 Bit für den PC. Der Programmspeicher ist in mehrere Bänke geteilt, die alle 2k groß sind. Das Programm springt ohne zutun des Benutzers von einer in die Nächste. Wenn man aber selber springen will, muss man die Register PCLATH (Program Counter Latch High) oder PCL (Program Counter Least Significant Byte) mit der Sprungadresse beschreiben.

===Datenspeicher===
Der Datenspeicher besteht aus den Special Function Registern (SFR) und den General Purpose
Registern (GPR). Die SFRs sind für die Funktionen des PICs zuständig (Interrupts, Timer, ADCs, CCPM...) und die GPRs für die Speicherung von Variablen und Daten.

Da immer nur 7 Bit der (Ziel)Adresse in einem Befehl gespeichert werden können, sind nur 7Fh (128d) Adressen im Datenbereich möglich. Deswegen wurde das "Banking" eingeführt. 2 Bit im Statusregister (welcher in allen Bänken der selbe ist und auch an der gleichen Stelle sitzt) geben die akutelle "Bank" an und sind nichts anderes als die 2 höchstwertigsten (MSB) Bits der Adresse. Damit lassen sich max. 4 Bänke ansprechen. Je nach PIC gibt es 2-4 Bänke. Die beiden Bits im Register STATUS heißen RP0 (STATUS<5>) und RP1 (STATUS<6>).

{| {{Blauetabelle}}
|+ Wechseln der Bänke mit RP0 und RP1
|-
|
|| RP1
|| RP0
|-
| Bank0
|align="center"|0
|align="center"|0
|-
| Bank1
|align="center"|0
|align="center"|1
|-
| Bank2
|align="center"|1
|align="center"|0
|-
| Bank3
|align="center"|1
|align="center"|1
|}

[[Bild:PIC midrange register.JPG]]
# '''FETTE Register''' sind in allen PICs vorhanden
# können je nach PIC unimplementierte Bereiche beinhalten - diese werden immer als 0 gelesen. (DATENBLATT!!)
# siehe 2
# Könnten je nach PIC auch nicht in Bank0 gemapped werden, sind dann eigenständige Register.
# je nach PIC kann es diese Bänke geben oder nicht geben.

== Codeschnipsel ==

=== Analog-Digital-Wandler (ADC) ===

Viele PICs besitzen einen Analog-Digital-Wandler, der eine angelegte Spannung messen kann und diese als Zahl speichert.

Es gibt AD-Wandler mit 8Bit bzw. 10Bit Auflösung, d.h. die Spannung an einem analogen Eingang wird linear 2^8=256 bzw. 2^10=1024 Werten zugeordnet.
Der höchste Wert, auch Referenzspannung genannt, (255 bzw. 1023; der Controller rechnet die Null auch mit) entspricht der Betriebsspannung des PICs oder wahlweise einer wählbaren Spannung, die an RA3 angelegt werden muss. Der niedrigste Wert entspricht 0 Volt.

Mit dem Analog-Digital-Wandler kann man somit z.B. Sensoren auswerten, die mehr als zwei Zustände ausgeben (Beispiele: Temperatursensor, Helligkeitssensor, Entfernungssensoren usw.) oder Akkuspannungen messen.

Bevor überhaupt gemessen werden kann, muss einiges eingestellt werden:

* Eingangsverteilung Analog/Digital bzw.Referenzspannung (Betriebsspannung oder RA3)
die genauen Einstellungsmöglichkeiten entnehmen sie bitte dem Datenblatt ihres Controllers (Register ADCON1 Bank 1).

* Wählen des Taktes für den ADC und Einschalten des ADCs

Das Register ADCON0 besitzt 8 Bits, die folgendes bestimmen:
Bit0 ADON - schaltet AD-Wandler ein oder aus (Strom sparen)
Bit1 - nicht vorhanden
Bit2 GO/Done - startet Wandlung / signalisiert, wann Umwandlung beendet ist.
Bit3 CHS0 - Channel Select 0 wählt Eingang aus
Bit4 CHS1 - Channel Select 1 wählt Eingang aus
Bit5 CHS2 - Channel Select 2 wählt Eingang aus
Bit6 ADCS0 - AD-Clock-Select wählt Takt
Bit7 ADCS1 - AD-Clock-Select wählt Takt

Kümmern wir uns zunächst um den Takt. Mit den zwei Bits ADCS0 und ADCS1 bestimmt man den Takt - hierbei gibt es vier Möglichkeiten:

ADCS1=0, ADCS0=0 -> Taktfrequenz des PICs :2
ADCS1=0, ADCS0=1 -> Taktfrequenz des PICs :8
ADCS1=1, ADCS0=0 -> Taktfrequenz des PICs :32
ADCS1=1, ADCS0=1 -> interner RC-Oszillator des ADCs verwenden

Die Taktfrequenz des ADCs darf 625kHz nicht überschreiten, dementsprechend ist ADCS0 und ADCS1 zu wählen.

Ist dies vollbracht, so kann man den AD-Wandler einschalten und das Go/Done-Bit löschen.
Codebeispiel:

bcf ADCON0,6 ;Takt für
bsf ADCON0,7 ;ADC (OSC/32)
bsf ADCON0,0 ;ADC einschalten, ADON=1
bcf ADCON0,2 ;Go/Done-Bit zurücksetzen

Nun ist der AD-Wandler bereit, Spannungen in Zahlen umzuwandeln.
Für eine Wandlung muss erst der entsprechende Eingang gewählt werden. Dafür sind die CHS0..CHS2-Bits zuständig:

CHS2 CHS1 CHS0 gewählter Eingang(falls vorhanden)
0 0 0 RA0
0 0 1 RA1
0 1 0 RA2
0 1 1 RA3
1 0 0 RA5
1 0 1 RE0
1 1 0 RE1
1 1 1 RE2

Achtung! RA4 ist kein analoger Eingang, folglich ist er oben nicht aufgelistet !!

Codebeispiel:

bcf ADCON0,3 ;RA2 auswählen
bsf ADCON0,4
bcf ADCON0,5

Als letztes muss die AD-Routine nur noch gestartet werden. Ist der AD-Wandler fertig, so löscht er das Bit wieder. Das Bit wird nun solange abgefragt, bis der AD-Wandler fertig ist. Den zugeordneten Wert findet man im Register 'ADRES'.
Code:

bsf ADCON0,2 ;start
wa btfsz ADCON0,2 ;warten,bis es wieder low ist
goto wa ;noch nicht fertig
;jetzt ist er fertig
movf ADRES,W ;ADRES in W verschieben, um damit gleich weiter zu arbeiten

Die AD-Wandlung ist somit fertig. Liest man mehrere Werte von unterschiedlichen Eingängen ein und möchte diese miteinander vergleichen o.ä., sollte man die Zahlen von ADRES in anderen Registern zwischenspeichern.

Desweiteren ist zu beachten, dass der Analog-Digital-Wandler eine gewisse Pause zwischen den Wandlungen benötigt, die sog. 'Aquisition Time'. Diese Zeitangabe entnehmen sie bitte ihrem Datenblatt.

mögliche Probleme:

;Der PIC liefert stark schwankende Werte
:-> Mögliche Ursachen dafür sind z.B. nicht stabile Betriebsspannung, falsche Zeiteinstellungen. Abhilfe schafft auch das mehrmalige Einlesen eines Eingangs. Auch können z.B. 8 Werte eingelesen werden und dann der Durchschnitt gebildet werden.
Evtl. kann ein Kondensator gegen Masse (z.B. 1nF) helfen; Wichtig ist auch eine kleine Verzögerung zwischen Kanalauswahl und Start der Wandlung. In dieser Zeit kann sich der interne Kondensator des ADC's aufladen.

;Die Spannung an einem Eingang wird erhöht, die Werte der anderen Eingänge werden aber auch beeinflusst.
:-> Dann sind Sie Opfer des sog. 'Ghostings' geworden (Werte 'scheinen durch', verschleißen). Die Werte der anderen Eingänge gehen mit, weil der interne Kondensator noch auf die Spannung des Vorgängers aufgeladen ist. Maßnahme: Aquisition Time erhöhen, Werte öfters abfragen, Pause zwischen Kanalauswahl und Start

;Der PIC liefert immer die gleichen Werte an einem Eingang, obwohl sich die angelegte Spannung ändert
:-> möglicherweise falsche Eingangsverteilung (ADCON1) eingestellt oder falschen Pin gewählt

=== Hex Dec Wandlung ===

Das ist ein Unterprogramm der mit call Hex_Dec aufgerufen wird. Es gibt 4 Register (A, B, C und D) mit jeweils 32 Bits, die aus jeweils 4 Register mit 8 Bits (z.B. fur A: A3, A2, A1 und A0) bestehen.

A3 A2 A1 A0
.--------.--------.--------.--------.
|76543210|76543210|76543210|76543210|
'--------'--------'--------'--------'
| |
|<----------- A Register ---------->|

Sie müssen (wegen FSR) so wie im Code nacheinander liegen (die absolute Adressen sind nicht wichtig). In das Register "A" wird die hex Zahl eingeschrieben und aus dem "D" die umgewandelte dec Zahl ausgelesen. A3,7 und D3,7 sind MSB und A0,0 und D0,0 sind LSB. Die "B" und "C" sind Hifsregister. Das UP kann für kleinere als 32-bittige hex Zahlen modifiziert werden. Zum Beispiel für 16-bittige hex Zahlen bleiben nur Register A1,A0,B1,B0,C1,C0,D1,D0 und in den UPs werden in die Register und als X, folgende Zahlen eingeschrieben: HTmp->0x10 (Anzahl Bits der hex Zahl),ATmp->2=X (Anzahl Bytes der hex Zahl). Es müssen auch die UPs "CClr", "DClr" und "CopyCB" entschprechend der Registerlänge angepasst werden. Genauso kann natürlich das UP auch für längere hex Zahlen modifiziert werden.

Das UP "AddCB" addiert dezimal die 32- bittige Register C und B, das Ergebniss befindet sich in C.
Das UP "AddDC" addiert dezimal die 32-bittige Register D und C, das Ergebniss befindet sich in D.

Die 32-bit Additionen werden in 4 Schritten wie folgt realisiert:

C0+B0->C0, C1+B1->C1, C2+B2->C2 und C3+B3->C3

D0+C0->D0, D1+C1->D1, D2+C2->D2 und D3+C3->D3

Die Flags "_Fcra", "_Fcrp" und "_Fdca" steuern die alle nötigen Korrekturen.

Die Wandlung wird in 32 Schritten laut folgender Formel durchgeführt:

Zahl(d)=B0*2^0+B1*2^1+B2*2^2+B3*2^3+B4*2^4+B5*2^5+B6*2^6+B7*2^7+B8*2^8+B9*2^9+B10*2^10+B11*2^11+

B12*2^12+B13*2^13+B14*2^14+B15*2^15+B16*2^16+B17*2^17+B18*2^18+B19*2^19+B20*2^20+B21*2^21+

B22*2^22+B23*2^23+B24*2^24+B25*2^25+B26*2^26+B27*2^27+B28*2^28+B29*2^29+B30*2^30+B31*2^31

Wobei B0 bedeutet den LSB und B31 den MSB der hex Zahl.

Die dec Zahl wird im D Register durch "AddDC" gebildet. In dem C Register befindet sich immer die laufende 2^X. Am Anfang wird dort 1=2^0 geladen. Da die nächste zu addierende dec Zahl immer gleich 2* vorherige ist, wird sie einfach so berechnet, dass die aktuelle aus C Register ins B Register kopiert ("CopyCB") und zum C addiert ("AddCB") wird. Diese dec Zahl wird zum D Register addiert nur wenn entsprechender Bit der hex Zahl gleich 1 ist. Weil im UP "Hex_Dec" immer das bit A0 dafür geprüft wird, wird das gesamte 32-bittige A Register nach jeder Addition "AddDC" um ein Bit mit "ARotRb" nach rechts rotiert. Die Flags "_Fcra" und "_Fcrp" übertragen die Bits zwischen den 8 Bit Register A0, A1, A2 und A3. Es würde zwar reichen, wenn das A Register nur verschoben würde, aber hier wurde Rotation gewählt, damit nach der Wandlung die hex Zahl im A Register unverändert steht.

#define _C STATUS,C
#define _Z STATUS,Z
#define _DC STATUS,DC
#define _Fcra Flags,0
#define _Fcrp Flags,1
#define _Fdca Flags,2
#define _Ferr Flags,3 ;Überlauf (Fehler)
;..................................................................................
A3 EQU 0x20 ;Register fürs Rechnen
A2 EQU 0x21
A1 EQU 0x22
A0 EQU 0x23
B3 EQU 0x24
B2 EQU 0x25
B1 EQU 0x26
B0 EQU 0x27
C3 EQU 0x28
C2 EQU 0x29
C1 EQU 0x2A
C0 EQU 0x2B
D3 EQU 0x2C
D2 EQU 0x2D
D1 EQU 0x2E
D0 EQU 0x2F
Flags EQU 0x30
ATmp EQU 0x31 ;Schleifenzähler
HTmp EQU 0x32 ;Schleifenzähler
RTmp EQU 0x33 ;Zwischenspeicher
;..................................................................................
Hex_Dec call CClr ;Hex>A, D>Dec
call DClr
movlw 1
movwf C0
movlw 0x20 ;32 bit Hex > 32 bit Dec (8 Stellen)
movwf HTmp
HexDecL btfsc A0,0
call AddDC
call CopyCB
call AddCB
call ARotRb
decfsz HTmp,1
goto HexDecL
return
CClr clrf C0
clrf C1
clrf C2
clrf C3
return
DClr clrf D0
clrf D1
clrf D2
clrf D3
return
CopyCB movf C0,0
movwf B0
movf C1,0
movwf B1
movf C2,0
movwf B2
movf C3,0
movwf B3
return
AddCB movlw B0 ;C+B>C
movwf FSR
goto AddR
AddDC movlw C0 ;D+C>D
movwf FSR
AddR bcf _Ferr ;Addiere zwei Register
bcf _Fcrp
movlw 4 ;X=4 Bytes lang
movwf ATmp
AddRL bcf _Fdca
bcf _Fcra
movf INDF,0
movwf RTmp
movlw 4 ;X=4
addwf FSR,1
btfss _Fcrp
goto AddRN
movlw 1
addwf INDF,1
call DecCor
AddRN movf RTmp,0
addwf INDF,1
call DecCor
btfss _Fdca
goto AddCor1
movlw 6
addwf INDF,1
AddCor1 btfss _Fcra
goto AddCor2
movlw 0x60
addwf INDF,1
btfsc _C
bsf _Fcra
AddCor2 movf INDF,0
andlw 0xF0
sublw 0xA0
btfss _Z
goto AddCor3
movf INDF,0
andlw 0x0F
clrf INDF
addwf INDF,1
bsf _Fcra
AddCor3 bcf _Fcrp
btfsc _Fcra
bsf _Fcrp
movlw 5 ;X+1=5
subwf FSR,1
decfsz ATmp,1
goto AddRL
btfsc _Fcra
bsf _Ferr
return
DecCor btfsc _DC ;dezimale Korrektur (equ DAW)
bsf _Fdca
btfsc _C
bsf _Fcra
movf INDF,0
andlw 0x0F
sublw 9
btfss _C
bsf _Fdca
movf INDF,0
andlw 0xF0
sublw 0x90
btfss _C
bsf _Fcra
return
ARotRb movlw A3 ;rotiere A register 1 Bit rechts
movwf FSR
RRotRb movlw 4 ;rotiere X=4 Bytes
movwf ATmp
bcf _Fcrp
btfsc A0,0
bsf _Fcrp
RRotRbL bcf _Fcra
btfsc INDF,0
bsf _Fcra
bcf _C
btfsc _Fcrp
bsf _C
rrf INDF,1
bcf _Fcrp
btfsc _Fcra
bsf _Fcrp
incf FSR,1
decfsz ATmp,1
goto RRotRbL
return

=== EEPROM ===

Alle PICs besitzen EEPROM in dem je nach Typ können 64 bis 256 Databytes abgespeichert werden. Die Adressierung des EEPROMs fängt immer mit 0x00 an. Hier werden nur geprüfte UPs kurz erklärt. Die ersten zwei brauchen nur ein Register "Temp" für Schleifenzähler, dessen Name, falls im Programm schon existiert, geändert werden muss. Die Adresse im EEPROM ist gleich der Adresse im RAM.

EEPROM beschreiben:

EEWrite movlw 0x20 ; ab der RAM Adresse wird in EEPROM abgespeichert
movwf FSR
movlw 4 ; soviel Bytes
movwf Temp ; Schleifenzähler
EEWLoop call EEWrite1
incf FSR,1 ; nächste Adresse
decfsz Temp,1
goto EEWLoop
return

EEWrite1 bcf INTCON,GIE ; Interrupts sperren
movf FSR,0
bsf STATUS,RP0 ; auf Bank1 umschalten
movwf EEADR ; EEPROM Adresse
movf INDF,0
movwf EEDATA ; EEPROM Data
bsf EECON1,WREN
movlw 0x55
movwf EECON2
movlw 0xAA
movwf EECON2
bsf EECON1,WR
bcf EECON1,WREN
btfsc EECON1,WR
goto $-1 ; warten bis WR=0
bcf STATUS,RP0 ; zurück auf Bank 0 umschalten
bsf INTCON,GIE ; Interrupts erlauben
return

EEPROM lesen und zurück in RAM schreiben:

EERead movlw 0x20 ; ab der Adressse wird aus EEPROM in RAM abgelegt
movwf FSR
movlw 4 ; soviel Bytes
movwf Temp ; Schleifenzähler
EERLoop call EERead1
incf FSR,1 ; nächste Adresse
decfsz Temp,1
goto EERLoop
return

EERead1 movf FSR,0
bsf STATUS,RP0 ; auf Bank1 umschalten
movwf EEADR ; EEPROM Adresse
bsf EECON1,RD
movf EEDATA,0 ; EEPROM Data
bcf STATUS,RP0 ; zurück auf Bank 0 umschalten
movwf INDF
return

Tabelle im EEPROM mit MPASM Direktive "de" erstellen:

org 0x2100 ; EEPROM initialisieren
; nachfolgend als Kommentar die EEPROM Adressen
de 0x03, 0xE8 ; 0x00
de 0x03, 0xE8 ; 0x02
de 'M','H','z',0x00 ; 0x04
de ' ',' ','W','A','I','T',0x00 ; 0x08
de 'C','o','n','s','t',' ','X',0x00 ; 0x0F
de 'C','=',0x00 ; 0x17
de 'L','=',0x00 ; 0x1A
de 'F','=',0x00 ; 0x1D
de 'O','K',0x00 ; 0x20
u.s.w.

Wenn die Tabelle sich im Quellcode befindet, wird sie beim brennen des PICs in EEPROM eigeschrieben.

Das Lesen eines Strings muss ab entsprechender EEPROM Adresse (z.B. für "MHz" -> 0x04) anfangen und auf dem Wert 0x00, der hier als Stringende dient, enden. Einfacher ist, wenn alle Strings gleich lang sind (wie z.B. in einem Zeichengenerator fur Grafikdisplay).

Die Adreesse "0x2100" in der "org" Direktive hat mit der Adresse im Programmspeicher nichts zu tun.

=== Interrupts ===

Das Programmteil misst eine Frequenz an TOCKI Pin und wurde für PIC16F870 geschrieben.

Benötigte Hardware: Widerstand 470 Ohm zwischen der Frequenzquelle und TOCKI Pin (A4).

Es fehlen UPs "Hex_Dec" [[#Hex Dec Wandlung|Hex Dec Wandlung]] und Ausgabe auf ein Display "DispFrq". Das HP ("Main") als leere endlose Schleife macht nichts ausser warten auf ein Interrupt von Timer0 bzw. Timer1. Man kann die Marke "Main" weglassen und das HP als "goto $" formulieren.

Der Zähler der Frequenz wurde um ein Zähler aus zwei zusätzlichen Register A2 und A3 erweitert und bei jedem Timer0 Überlauf erhöht. Der Prescaler wird ins Register A0 und der TIMER0 ins A1 kopiert. Somit ergibt sich 32-bittiger Ergebniss, der als hex Zahl in den Register A3 (MSB),A2, A1, und A0 (LSB) steht. Nach der "Hex_Dec" Wandlung kann die Frequenz aus den Register D3 (MSB), D2, D1 und D0 (LSB) an einem biliebigen Display angezeigt werden.

Es wird kein zusätzliches Register benötigt, da das "ATmp" und das "RTmp" die gleichen wie im UP "Hex_Dec" sind. Die Quarzfrequenz wurde gewählt, weil sie am nächsten der Temperaturstabiltesten Frequenz für AT Quarzen 7,2 MHz ist. Der PIC16F870 wurde nur wegen nötigen 19 I/O Pins für 6-stelligen 7-segment LCD Display LPH2673-1[[http://www.roboternetz.de/phpBB2/viewtopic.php?t=26005]] (ohne Kontroller) vom Pollin angewendet. Mit einem üblichen 1x16 Zeichen LCD Matrixdisplay und anderen PICs wurde das Programm für Frequenzen bis zum 100 MHz mit einer Genauigkeit
+/- 4 Hz positiv getestet.

Um die Frequenz mit Genauigkeit +/- 1Hz zu messen, muss die Messzeit 1 s von Timer1 erzeugt werden, das nur für Quarz bis 2,048 MHz möglich ist. Für sehr genaue Messungen wird empfohlen als Taktfrequenz für den Timer1, die Trägerfrequenz eines nächsten LW Senders (z.B. DLF 153 bzw. 207 kHz) zu nutzen. Die Genauigkeit der Frequenz ist ca. 1E-11 und geprüfter Empfänger kann laut der Skizze in [[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=13706&highlight=frequenzz%E4hler]] nachgebaut werden. In dem Fall müssen die Register vom Timer1 (TMR1H und TMR1L) vor seinem Start entsprechend geladen werden.

Mit dem Quarz 7,3728 MHz wird hier die Messzeit 0,25 s genutzt und die gemessene Frequenz durch 4 multipliziert (mittels 2 Additionen), was die Auflösung von +/- 4 Hz ergibt.

Das UP "Init" muss selbstverständlich für ein Matrixdisplay um Initialisierung des Displaykontrollers ergänzt werden.

; Programm zum Messen der Frequenz an T0CKI Pin mit 7,3728 MHz Quarz
LIST P=16F870
include "P16F870.inc"
__CONFIG _CP_OFF & _DEBUG_OFF & _WRT_ENABLE_ON & _CPD_OFF & _LVP_OFF & _BODEN_OFF &
_PWRTE_ON & _WDT_OFF & _HS_OSC
ORG 0x0000
call Init
Main goto Main
ORG 0x0004 ;ISR (interrupt service routine)
bcf INTCON,GIE ;interrupts sperren
btfss INTCON,T0IF ;ist Timer0 übelaufen ?
goto CheckTMR1 ;nein, dann prüfe Timer1
bcf INTCON,T0IF ;Timer0 interrupt flag löschen
movlw 1
addwf A2,1 ;erhöhe A2
btfsc STATUS,C
incf A3,1 ;increment A3, wenn A2 überlaufen ist
CheckTMR1 btfss PIR1,TMR1IF ;ist Timer1 überlaufen ?
retfie ;wenn nicht, springe zurück zu Main
bsf STATUS,RP0 ;stopp Timer0
movf TRISA,0
andlw 0xEF
movwf TRISA ;TOCKI Pin (A4) als Ausgang
bcf STATUS,RP0
bcf T1CON,TMR1ON ;stopp Timer1
bcf PIR1,TMR1IF ;Timer1 interrupt flag löschen
GetFreq movf TMR0,0 ;Prescaler ins Register A0 kopieren
movwf A1
movwf RTmp
clrf ATmp
FToggle incf ATmp,1
bsf STATUS,RP0
bsf OPTION_REG,T0SE
bcf OPTION_REG,T0SE
bcf STATUS,RP0
movf TMR0,0
subwf RTmp,0
btfsc STATUS,Z
goto FToggle
comf ATmp,1
incf ATmp,0
movwf A0
call Hex_Dec
clrf A3 ;Register A löschen
clrf A2
clrf A1
clrf A0
call CopyDC
call AddDC ;gemessene Frequenz * 2
call CopyDC
call AddDC ;gemessene Frequenz * 4 = tatsächliche Frequenz
call DispFrq ;eigenes UP für benutztes Display
clrf TMR0 ;Timer0 löschen
movlw 0x34 ;Timer1
movwf T1CON ;konfigurieren
movlw 0x1F ;Timer1 laden (für 0,25 s)
movwf TMR1H
clrf TMR1L
bsf STATUS,RP0 ;start Timer0
movf TRISA,0
iorlw 0x10
movwf TRISA ;TOCKI Pin (A4)als Eingang
bcf STATUS,RP0
bsf T1CON,TMR1ON ;start Timer1
retfie ;erlaube interrupts und springe zurück zu Main
CopyDC movf D0,0
movwf C0
movf D1,0
movwf C1
movf D2,0
movwf C2
movf D3,0
movwf C3
return
Init clrf PORTA ;Ports löschen
clrf PORTB
clrf PORTC
movlw 0x20 ;RAM (20-7Fh) löschen
movwf FSR
clrf INDF
incf FSR,1
btfss FSR,7
goto $-3
clrf ADCON0 ;schalte ADC off
movlw 7 ;sperre ADC
movwf ADCON1 ;und definiere RA0-7 als digitale I/Os
movlw 0xE0 ;GIE, PEIE & TMR0IE erlauben
movwf INTCON
bsf STATUS,RP0 ;bank 1
movlw 0xEF ;alle PORTA Pins als Eingänge
movwf TRISA ;nur TOCKI (A4) als Ausgang
clrf TRISB ;alle PORTB
clrf TRISC ;und PORTC Pins als Ausgänge
movlw 0xE7 ;Takt für Timer0 vom T0CKI Pin
movwf OPTION_REG ;Timer0 konfigurieren
bsf PIE1,TMR1IE ;TMR1 interrupt erlauben
bcf STATUS,RP0 ;Bank 0
clrf TMR0 ;Timer0 löschen
movlw 0x34 ;Timer1 konfigurieren
movwf T1CON ;(prescaler 8)
movlw 0x1F ;Timer1 laden (für 0,25 s)
movwf TMR1H
clrf TMR1L
bsf STATUS,RP0 ;start Timer0
iorlw 0x10
movwf TRISA ;TOCKI Pin (A4) als Eingang
bcf STATUS,RP0
bsf T1CON,TMR1ON ;start Timer1
return
end

=== Mausrad ===

Das UP wertet ein Mausrad aus und setzt, je nach Drehrichtug und sein Anschluss an PORT (PORTA,0 und PORTA,1), ein Flag "_Finc" bzw. "_Fdec", das vor der nächsten Abfrage, gelöscht werden muss. Zum Auswerten werden 3 Register "MausA", "MausB" und "MausC" benötigt. Als "_Z" wurde "STATUS,Z" definiert. Die Warteschleife "Delay" dient der Entprellung der Kontakte und soll ca. 10ms sein.

In dem UP "Mouse" wird PORTA eigelesen, die alle Bits ausser 0 und 1 durch "and" Funktion gelöscht und in den Register "MausB" und "MausC" gespeichert. Nach ca. 10ms wird das gleiche gemacht und im Register "MausA" gespeichert. Der Wert aus "MausA" wird mit dem vorherigen aus "MouseC" durch "xor" verglichen. Sind sie nicht identisch, wird je nach dem Wert "X" (0, 1, 2, b.z.w. 3) im "MausB" in das entsprechende UP "MouseX" gesprungen. Sonst wenn "MausA"="MausC", wird zum Aufrufer zurückgekehrt.

In einem UP "MouseX" wird der letzte Wert im "MausA" ermittelt und nach der Kombination der Werte im "MausB" und "MausA" (10 b.z.w. 20, 01 b.z.w. 31, 02 b.z.w. 32 oder 13 b.z.w. 23) entsprechendes der Drehrichtung Flag "_Finc" b.z.w. "_Fdec" gesetzt. Anschliessend wird zum Aufrufer zurückgesprungen.

Detailierter PAD:

Mouse V
PORTA->W
3 and W->W
W->MausB
W->MausC
Warten 10ms
PORTA->W
3 and W->W
W->MausA
W xor MausC->MausC
_Z=1 ? J > return
N
V
MausB->MausB
.--------------------------< J _Z=1 ?
| N
| V
| MausB->W
| W-1->W
| .----< J _Z=1 ?
| | N
| | V
| | MausB->W
| | W-2->W
| | _Z=1 ? J >---------------------------.
| | N |
| | V |
| | MausB->W |
| | W-3->W |
| | _Z=1 ? J >-----. |
| | N | |
| | V | |
| | return | |
| | | |
| | | |
Mouse0 V Mouse1 V Mouse3 V Mouse2 V
MausA->W MausA->MausA MausA->W MausA->MausA
W-1->W V W-1->W V
_Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--.
J | J | J | J |
V | V | V | V |
setze _Fdec | setze _Finc | setze _Finc | setze _Fdec |
V<-----´ V<-----´ V<-----´ V<-----´
MausA->W MausA->W MausA->W MausA->W
W-2->W W-3->W W-2->W W-3->W
_Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--. _Z=1 ? N >--.
J | J | J | J |
V | V | V | V |
setze _Finc | setze _Fdec | setze _Fdec | setze _Finc |
V<-----´ V<-----´ V<-----´ V<-----´
return return return return

und Quellcode:

Mouse movf PORTA,0
andlw 3
movwf MausB
movwf MausC
call Delay ; ca. 10 ms
movf PORTA,0
andlw 3
movwf MausA
xorwf MausC,1
btfsc _Z
return
movf MausB,1
btfsc _Z
goto Mouse0
movf MausB,0
sublw 1
btfsc _Z
goto Mouse1
movf MausB,0
sublw 2
btfsc _Z
goto Mouse2
movf MausB,0
sublw 3
btfsc _Z
goto Mouse3
return
Mouse0 movf MausA,0
sublw 1
btfsc _Z
bsf _Fdec
movf MausA,0
sublw 2
btfsc _Z
bsf _Finc
return
Mouse1 movf MausA,1
btfsc _Z
bsf _Finc
movf MausA,0
sublw 3
btfsc _Z
bsf _Fdec
return
Mouse2 movf MausA,1
btfsc _Z
bsf _Fdec
movf MausA,0
sublw 3
btfsc _Z
bsf _Finc
return
Mouse3 movf MausA,1
sublw 1
btfsc _Z
bsf _Finc
movf MausA,0
sublw 2
btfsc _Z
bsf _Fdec
return

=== Handy Display ===

Als Beispiel die Hardware und Testprogram für Nokia 3310/3330 Display: [[http://www.roboternetz.de/phpBB2/viewtopic.php?p=124669#124669]]

== Hilfsmittel ==

=== PIC Miniterminal ===

Das ist eine Schnittstelle, die nur 2 Leitungen zum Anschluss an PIC braucht. Sie ermöglicht Steuern von diversen LCD Displays mit üblichem Anschluss ("RS", "Enable" und 8 Databits) und Abfragen von 3 Tasten.

Hardware und Testprogramm: [[http://www.roboternetz.de/phpBB2/viewtopic.php?p=124559#124559]]

[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Category:PIC]]