PIC-Tutorial - Von Registern zu Interrupts

PIC-Tutorial - Von Registern zu Interrupts

Bevor Sie sich mit den winzigen Details der PIC-Programmierung befassen, sollten Sie zunächst einige gute Programmiermethoden erlernen.

Register verstehen

Angenommen, Sie geben an einem beliebigen Punkt des Programms ein (Semikolon) ein. Alle nach diesem Semikolon gesetzten Zeichen werden vom Compiler ignoriert, bis der Wagen natürlich wieder in die Position zurückkehrt.

Mit der oben genannten Funktion können wir Kommentare oder Anmerkungen hinzufügen, sodass sie nicht Teil des Programms werden, das Programm jedoch mithilfe der Kommentare daneben identifizieren können. Das Einfügen von Kommentaren wird empfohlen, wenn Sie einen IC programmieren.



Als nächstes ist es wichtig, den verschiedenen Konstanten Namen zuzuweisen (Sie werden sie später ausführlich lernen). Dies macht es auch einfacher zu verstehen, worauf geschrieben wird oder was die beteiligten Werte betrifft, anstatt mit den enthaltenen Zahlen verwechselt zu werden.

Dies muss in Form von tatsächlichen Namen erfolgen, damit sie sofort erkannt werden können, z. B. COUNT. Es ist wichtig zu beachten, dass hier alle Großbuchstaben verwendet werden, um sie zu unterscheiden, und dass es sich um einen konstanten Wert handelt.


Wie wir sehen können, erfolgt das oben Gesagte in Form einer Box aus Semikolons, wodurch es nur sauberer aussieht. Versuchen Sie außerdem, das Programm auch auf Papier zu dokumentieren. Diese Vorgehensweise hilft dabei, die Dinge schrittweise zu verstehen.

2. Die Register.

Das Register innerhalb eines PIC ist ein Bereich, der schriftliche Details akzeptiert und das Lesen daraus ermöglicht. Sie können es mit einem Blatt Papier vergleichen, auf dem Sie Inhalte visualisieren und durch Hinzufügen darüber hinzufügen können.

Die folgende Abbildung zeigt eine typische Registerdateikarte, die in einen PIC16F84 eingebettet ist. Das Format ist nicht wirklich im PIC festgelegt, sondern dient lediglich dazu, anzugeben, wie die Bits im Chip angeordnet sein können, und einige der beteiligten Befehle zu verstehen.

Sie können sehen, dass es grundsätzlich in Bank 0 und Bank 1 unterteilt ist. Bank 1 ist für die Steuerung der tatsächlichen Funktionsweise des PIC verantwortlich. Beispielsweise teilt sie dem PIC mit, welche Bits an Port A als Eingänge und welche als Ausgänge zugewiesen sind.

Bank 2 dient nur zur Manipulation der Informationen.

Lassen Sie uns dies anhand des folgenden Beispiels verstehen:

Angenommen, wir möchten ein Bit bei PortA high zuweisen. Dazu müssten wir zuerst zur Bank 1 gehen, um das angegebene Bit oder den angegebenen Pin an Port A in Form eines Ausgangs zu setzen. Danach kehren wir zu Bank 0 zurück und liefern eine logische 1 (Bit 1) an diesen bestimmten Pin.

Die häufigsten Register, die wir in Bank 1 verwenden möchten, sind STATUS, TRISA und TRISB.

STATUS hilft uns, zur Bank 0 zurückzukehren. Mit TRISA können wir auswählen, welche Pins an Port A Ausgänge sind und welche Eingänge sein können, während TRISB die Auswahl zwischen Ausgang und Eingangspin an Port B erleichtert. Das SELECT-Register in BANK 0 ermöglicht es dem Benutzer zur Bank 1 wechseln.

Fassen wir das gesamte Konzept mit der folgenden Beschreibung zusammen:

STATUS:

Um von Bank 0 zu Bank 1 zu wechseln, befehlen wir das STATUS-Register. Dies wird implementiert, indem Bit 5 des STATUS-Registers auf 1 gesetzt wird. Um zur Bank 0 zurückzukehren, weisen wir Bit 5 des STATUS-Registers 0 zu. Das STATUS-Register befindet sich an der Adresse 03h, hier bezeichnet h die Nummer kann hexadezimal sein.

TRISA und TRISB:

Diese befinden sich entsprechend an der Adresse 85h und 86h. Um einen Pin als Ausgang oder Eingang zu programmieren, liefern wir einfach eine Null oder eine Eins an das bestimmte Bit im Register. Dies kann nun auf zwei Arten erfolgen, über Binär oder Hex. Falls jemand den Parameter nicht konvertieren kann, kann er sich für einen wissenschaftlichen Taschenrechner zur Implementierung der Werte entscheiden.

Jetzt haben wir 5 Pins an Port A, was 5 Pins entspricht. Wenn wir beabsichtigen, einen der Pins als Eingänge zu fixieren, liefern wir dem jeweiligen Bit eine „1“.

Wenn wir einen der Pins als Ausgänge zuweisen möchten, setzen wir den spezifischen Pin auf „0“. Die Bits werden genau nach unten entsprechend den Bits unterstützt, oder genauer gesagt ist Bit 0 RA0, Bit 1 wäre RA1, Bit 2 = RA2 und so weiter. Lassen Sie es uns so verstehen:

Angenommen, Sie möchten RA0, RA3 und RA4 als Ausgänge festlegen, während RA1 / RA2 als i / ps ausgeführt wird. Senden Sie dazu 00110 (06h). Überprüfen Sie, ob Bit 0 wie hier angegeben nach rechts zeigt:

Port A Pin RA4 RA3 RA2 RA1 RA0

Bit Nummer 4 3 2 1 0

Binär 0 0 1 1 0

Gleiches gilt für TRISB.

PORTA und PORTB

Um einen der Ausgangspins hoch zu schalten, bieten wir einfach eine '1' an, um das jeweilige Bit in unserem PORTA- oder PORTB-Register zu drücken. Ein identisches Verfahren kann auch für TRISA- und TRISB-Register angewendet werden. Bevor wir mit unserer ersten Beispielcodierung beginnen, wollen wir nur ein Coupé mit mehr Registern verstehen, nämlich: w und f.

W und F.

Das W-Register ist ein gewöhnliches Register, mit dem Sie einen beliebigen Wert Ihrer Wahl zuweisen können. Sobald Sie W eine Größe zuweisen, können Sie diese zu einem anderen Wert hinzufügen oder einfach verschieben. Wenn ein anderer Wert zugewiesen wird, werden die Details einfach auf W überschrieben.

Das F-Register leitet seine schriftlichen Unterlagen an ein Register weiter. Wir würden verlangen, dass dieses F-Register einen Wert über einem Register zuweist, möglicherweise über dem STATUS- oder dem TRISA-Register, da wir damit die Werte nicht direkt darüber setzen können. Ein Beispielprogramm

Lassen Sie uns den folgenden Beispielcode untersuchen, der uns zeigt, wie die obige Anweisung implementiert wird, und der auch einige der Anweisungen im Kurs enthält.

Beginnen wir mit der Reparatur von Port A wie oben beschrieben.

Dazu müssen wir von Bank 0 zu Bank 1 wechseln. Dazu wird das STATUS-Register an der Adresse 03h, Bit 5 bis 1 eingerichtet.

BSF 03h, 5

Das BSF bedeutet Bit-Set F. Nach diesem Befehl verwenden wir zwei Zahlen - 03h, die STATUS-Registeradresse, und die Zahl 5, die der Bitnummer entspricht.

Wir sagen also: 'Setzen Sie Bit 5 in Adresse 03h auf 1'.

Wir sind jetzt in Bank 1.

MOVLW 00110b

Wir setzen den Binärwert 00110 (der Buchstabe b bedeutet, dass die Zahl binär ist) in unser Allzweckregister W. Ich hätte dies natürlich auch hexadezimal tun können. In diesem Fall wäre unsere Anweisung:

MOVLW 06h

Entweder funktioniert. Das MOVLW bedeutet 'Move Literal Value Into W', was auf Englisch bedeutet, dass der folgende Wert direkt in das W-Register eingetragen wird.

Jetzt müssen wir diesen Wert in unser TRISA-Register eintragen, um den Port einzurichten:

MOVWF 85h

Diese Anweisung gibt an, dass der Inhalt von W in die folgende Registeradresse verschoben werden soll. In diesem Fall bezieht sich die Adresse auf TRISA.

Unser TRISA-Register trägt zu diesem Zeitpunkt die Abbildung 00110 oder ist grafisch dargestellt:

Port A Pin RA4 RA3 RA2 RA1 RA0

Binär 0 0 1 1 0

Ein- / Ausgang O O I I O.

Jetzt, da wir unsere Port A-Pins besitzen, müssen wir zur Bank 0 zurückkehren, um eine der Informationen anzupassen.

BCF 03h, 5

Diese Anweisung bewirkt die Umkehrung von BSF. Dies impliziert 'Bit Clear F'. Das entsprechende Zahlenpaar ist die Adresse des Registers, hier das STATUS-Register sowie die Bitzahl, in diesem Fall Bit fünf. Was wir derzeit genau abgeschlossen haben, ist das definierte Bit 5 auf unserer

STATUS-Register auf 0

Wir sind zu diesem Zeitpunkt in Bank 0 zurückgekehrt.
Das Folgende ist der Code in einem Block:

BSF 03h, 5 Gehen Sie zu Bank 1
MOVLW 06h 00110 in W setzen
MOVWF 85h Bewegen Sie 00110 auf TRISA
BCF 03h, 5 Kommen Sie zurück zu Bank 0

In der letzten Anweisung haben wir Ihnen bestätigt, wie Sie die E / A-Port-Pins am PIC so einrichten können, dass sie möglicherweise eingegeben oder ausgegeben werden.

In diesem Kurs möchte ich Sie beim Senden von Daten an die Ports unterstützen.

Senden von Daten an Ports

Im folgenden Tutorial werden wir eine LED ein- und ausschalten, die aus einer vollständigen Programmdetails und einem einfachen Schaltplan besteht, damit Sie sehen können, wie der PIC genau das ausführt, was wir erwarten.

Versuchen Sie nicht, Ihren PIC mit den folgenden Ergebnissen zusammenzustellen und zu programmieren, da es sich nur um Abbildungen handelt. Zunächst werden wir Port A Bit 2 als Ausgabe einrichten:

Dies könnte aus der vorherigen Anleitung erkennbar sein. Die einzige Unterscheidung könnte sein, dass wir jedes Bit der Pins auf A als Ausgang fixiert haben, indem wir 0h an das Drei-Zustands-Register geliefert haben. Jetzt muss er also eine LED einschalten.

Dies erreichen wir, indem wir einen der Pins (den mit der LED verbunden) hoch einplanen. Anders ausgedrückt, wir wenden eine „1“ auf den Pin an. Genau so wird es ausgeführt (beachten Sie die Kommentare zur Klarstellung für jede Zeile):

Daher haben wir jetzt die LED einmal ein- und ausgeschaltet. Wir wünschen uns, dass sich die LED anschließend kontinuierlich ausschaltet.

Dies erreichen wir, indem wir das Programm erhalten, um zum Start zurückzukehren. Dies erreichen wir, indem wir zu Beginn unseres Programms zunächst ein Tag einrichten und das Programm anschließend anweisen, dorthin zurückzukehren. Wir geben ein Tag ganz einfach an.

Wir geben einen Begriff ein, sagen wir START, und geben als nächstes den Code ein:

Wie gezeigt wurde, haben wir den Ausdruck 'Start' zunächst unmittelbar zu Beginn des Programms erwähnt.

Als nächstes haben wir ganz am Ende des Programms deutlich „goto Start“ erwähnt. Die Anweisung 'goto' führt genau das aus, was sie deklariert.

Dieses Programm schaltet die LED beim Ein- und Ausschalten des Stromkreises ständig ein und aus und neigt dazu, sich auszuschalten, sobald wir den Strom entfernen. Vielleicht sollten wir unser Programm noch einmal überprüfen:

Sicherlich haben wir die Kommentare weggelassen, aber wir können immer noch die Anweisungen und die Zahlen beachten.

Dies kann später etwas rätselhaft sein, wenn Sie versuchen, das Programm zu beheben, und während Sie den Code schreiben, den Sie sich alle Adressen merken.

Obwohl die Kommentare noch platziert werden können, kann es etwas unübersichtlich werden. Dies erfordert die Benennung der Nummern und kann durch eine zusätzliche Anweisung erreicht werden: 'equ' Die Anweisung 'equ' legt nahe, dass einige Dinge möglicherweise anderen Dingen entsprechen.

Dies ist möglicherweise keine Anweisung für PIC, sondern für den Assembler. Dieser Befehl erleichtert das Zuweisen eines Namens zu einem Registeradressenort oder einer Konstante zu einem Programmierbegriff.

Wir werden einige Konstanten für unser Programm festlegen und auch sehen, wie einfach es ist, das Programm zu lesen.

Seitdem haben wir die konstanten Werte festgelegt, indem wir sie in unser Programm aufnehmen. Die konstanten Werte müssen vor ihrer Verwendung festgelegt werden.

Stellen Sie daher sicher, dass Sie sie immer am Anfang des Programms positionieren. Wir werden das Programm ohne die Kommentare noch einmal umschreiben, um die frühere Kennzeichnung mit der neuesten zu vergleichen.

Vielleicht können Sie feststellen, dass die Konstanten ein etwas einfacheres Verständnis des Programms ermöglichen. Wir sind jedoch immer noch ohne Kommentare, aber keine Sorge, da wir noch nicht fertig sind.

Möglicherweise gibt es einen kleinen Nachteil unseres blinkenden LED-Programms.
Jeder Befehl benötigt 1 Taktsequenz, um zu beenden. Wenn wir einen 4-MHz-Kristall verwenden, erfordert jeder Befehl 1/4-MHz oder 1uS, um fertig zu werden.

Da wir nur fünf Anweisungen verwendet haben, würde die LED in 5uS aktiviert und dann ausgeschaltet. Dies könnte viel zu schnell sein, als dass die Leute es bemerken könnten. Außerdem scheint es, dass die LED vollständig leuchtet.

Was wir stattdessen erreichen sollten, ist eine Hemmung zwischen dem Ein- und Ausschalten der LED. Die Theorie der Hemmung besagt, dass wir von einer früheren Größe herunterzählen. Wenn sie also auf Null geht, hören wir auf zu zählen.

Der Nullwert bedeutet den Abschluss der Verzögerung und wir arbeiten unseren Prozess während des gesamten Programms weiter. Daher müssen wir zunächst eine Konstante bestimmen, die als Zähler verwendet werden soll.

Nennen wir diese Konstante COUNT. Danach müssen wir bestimmen, von welcher Bedeutung eine Zahl ausgehen soll. Sicherlich ist die größte Zahl, die wir einschließen könnten, 255 oder FFh in hex. Wie ich im vorherigen Tutorial erwähnt habe, weist der Befehl equ einer Registersituation einen Ausdruck zu.

Dies bedeutet, dass unabhängig von der Menge, die wir unserem COUNT zuweisen, diese mit den Elementen eines Registers übereinstimmt. Wenn wir versuchen, den Wert FFh zu bestimmen, werden wir einen Fehler bekommen, sobald wir das Programm kompilieren können.

Der Grund dafür ist der Standort FFh, daher können wir keinen Zugriff darauf erhalten. Wie müssen wir also eine echte Nummer bezeichnen? Sicherlich wird es ein wenig seitliches Nachdenken erfordern.

Wenn wir beispielsweise unseren COUNT der Adresse 08h zuordnen, würde dies ein grundlegendes Zielregisterziel anzeigen. Standardmäßig sind die unberührten Bereiche auf FFh eingestellt. Wenn COUNT zu 08h führt, werden Sie beim ersten Einschalten auf den Wert von FFh stoßen. Trotzdem, ich Sie, wie können wir COUNT auf eine andere Zahl festlegen? Alles, was wir anwenden, ist, zuerst eine Bewertung an dieses Ziel zu verschieben.

Nehmen wir zur Veranschaulichung an, wir wollten, dass COUNT einen Wert von 85h besitzt. Wir können COUNT nicht als 85h bezeichnen, da dies die Position unseres Tri-State-Registers für Port A ist. Genau das, was wir erreichen, ist das Folgende: movlw 85hFirst put der Wert von 85h im W-Register movwf 08h

Verschieben Sie es jetzt in unser 08h-Register. Wenn wir COUNT gleich 08h ausdrücken, entspricht COUNT anschließend dem Wert 85h. Zart, nicht wahr? Daher bestimmen wir zunächst unsere Konstante: COUNT equ 08h Anschließend müssen wir diesen COUNT um eins reduzieren, bis er Null wird.

Es kommt einfach so vor, dass es eine Anweisung gibt, die dies für uns erreichen soll, indem ein 'goto' und ein Tag verwendet werden.

Die Anweisung, die wir anwenden werden, lautet: DECFSZ COUNT, 1 In dieser Anweisung heißt es: „Dekrementieren Sie das Register (hier COUNT) um die Zahl, die das Komma verfolgt. Wenn wir Null erreichen, hüpfen Sie zwei Punkte voraus. “Lassen Sie es uns zuerst in Aktion finden, bevor wir es in unseren Kurs aufnehmen.

Wir haben zunächst unsere konstante COUNT auf 255 festgelegt. Das nachfolgende Segment positioniert ein Tag namens LABEL in der Nähe unserer decfsz-Anweisung.

Der decfsz COUNT, 1 reduziert den Wert von COUNT um eins und behält das Endergebnis direkt in COUNT bei. Außerdem wird überprüft, ob COUNT den Wert 0 besitzt.

Ist dies nicht der Fall, wird das Programm in diesem Fall veranlasst, in die nachfolgende Zeile zu wechseln. Jetzt haben wir eine 'goto' -Deklaration, die uns zu unserer decfsz-Anweisung zurückbringt.

Wenn der Wert von COUNT gleich ist, führt die decfsz-Anweisung dazu, dass unser Programm 2 Punkte nach vorne springt und an die Stelle gesendet wird, an der wir behauptet haben, hier weiterzumachen.

Wie Sie sehen können, haben wir daher das Programm veranlasst, eine vorherbestimmte Zeit an einem Ort zu sitzen, bevor wir fortfahren. Dies könnte als Verzögerungsschleife bezeichnet werden.

Grundlegendes zu Verzögerungsschleifen

Falls wir eine größere Verzögerung benötigen, können wir eine Schleife zur nächsten verfolgen. Je mehr Schleifen, desto länger die Verzögerung. Nehmen wir mindestens zwei an, vorausgesetzt, wir möchten den LED-Blitz beobachten. Wir werden diese Verzögerungsschleifen in unser Programm einfügen und dies durch Einfügen von Kommentaren zu einem echten Programm machen:

Es ist möglich, dieses Programm zu kompilieren, nach welchem ​​Programm der PIC. Stellen Sie natürlich sicher, dass Sie versuchen, die Schaltung zu überprüfen, ob sie tatsächlich funktioniert. Das Folgende ist ein Schaltplan, den Sie erstellen sollten, sobald Sie den PIC programmiert haben.


Gut gemacht, Sie hätten tatsächlich Ihr erstes PIC-Programm komponieren und eine Schaltung zum Ein- und Ausschalten einer LED erstellen können. Bis jetzt haben Sie, falls Sie diese Kurse absolviert haben, möglicherweise insgesamt sieben von 35 Anweisungen gelernt, aber ohne Zweifel steuern Sie bisher möglicherweise die E / A-Ports!

Würden Sie versuchen, die Verzögerungsschleifen zu ändern, um den LED-Blitz schneller zu rendern - wie sieht der minimale Wert von COUNT aus, um den LED-Blitz im Wesentlichen zu sehen? Oder vielleicht möchten Sie nach der ersten eine dritte oder zusätzliche Verzögerungsschleife einfügen, um die LED nach unten zu stabilisieren. eine eindeutige Konstante für jede Verzögerungsschleife.

Sie könnten dann möglicherweise tatsächlich an Ihren Verzögerungsschleifen herumspielen, um den LED-Blitz mit einer bestimmten Geschwindigkeit zu rendern, beispielsweise nach einer Sekunde. Lassen Sie uns in der nächsten Anleitung sehen, wie wir eine so genannte Unterroutine verwenden können, um das Programm kompakt und einfach zu halten. Eine Unterroutine ist ein integraler Bestandteil von Code oder Programm, auf das verwiesen werden kann und wann Sie es benötigen. Unterprogramme werden in Fällen verwendet, in denen Sie häufig die identische Funktion ausführen.

Was sind Unterprogramme?

Die Verwendung einer Unterroutine hat den Vorteil, dass es wahrscheinlich einfacher ist, den Wert innerhalb einer Unterroutine einmal zu ändern, als beispielsweise zehnmal während Ihres gesamten Programms, und dass dies erheblich dazu beiträgt, den Speicherbedarf Ihres Programms innerhalb der zu verringern PIC. Wir werden eine Unterroutine auschecken:

Zunächst müssen wir unserem Unterprogramm eine Bezeichnung geben, und in dieser Situation haben wir ROUTINE ausgewählt. Danach geben wir den Code ein, den wir wie gewohnt ausführen möchten. Aus diesem Grund haben wir die Verzögerung in unserem blinkenden LED-Programm ausgewählt. Zuletzt schließen wir das Unterprogramm mit der Eingabe der Anweisung RETURN ab.

Um die Unterroutine von einer beliebigen Stelle in unserem Programm aus zu starten, geben wir schnell die Anweisung CALL und dann die Bezeichnung der Unterroutine ein.

Wir werden dies etwas genauer betrachten. Sobald wir den Abschnitt unseres Programms CALL xxx erreicht haben, in dem xxx der Name unserer Unterroutine ist, springt das Programm an eine beliebige Stelle, an der die Unterroutine xxx installiert ist. Die Anweisungen innerhalb des Unterprogramms werden ausgeführt.

Immer wenn der Befehl RETURN ausgeführt wird, springt das Programm zurück zu unserem Hauptprogramm zu dem Befehl, der auf unseren Befehl CALL xxx folgt.

Es ist möglich, die ähnliche Unterroutine mehrmals aufzurufen, wie Sie möchten, was erklärt, warum die Verwendung von Unterroutinen die allgemeine Dauer unseres Programms verkürzt.

Dennoch gibt es einige Faktoren, die Sie kennen sollten. Wie bei unserem Hauptprogramm müssen zunächst bestimmte Konstanten bestätigt werden, bevor Sie sie verwenden können.

Diese können möglicherweise innerhalb des Unterprogramms selbst oder direkt zu Beginn des Hauptprogramms bestätigt werden. Ich schlage Ihnen vor, dass Sie zu Beginn Ihres Hauptprogramms alles anerkennen, seitdem erkennen Sie, dass sich die Dinge in einer identischen Position befinden. Als nächstes sollte man sicherstellen, dass das Hauptprogramm die Unterroutine überspringt.

Was ich damit impliziere, ist, wenn Sie das Unterprogramm direkt am Ende Ihres primären Programms platzieren, außer wenn Sie eine 'Springen'-Deklaration verwenden, um von der Position des Unterprogramms zu springen, würde das Programm das Unterprogramm fortsetzen und implementieren, unabhängig davon, ob Sie erfordern es zu oder auf andere Weise.

Der PIC würde nicht zwischen einem Unterprogramm und dem Hauptprogramm unterscheiden. Wir werden unser blinkendes LED-Programm überprüfen, aber dieses Mal werden wir eine Unterroutine für die Verzögerungsschleife verwenden. Im Idealfall werden Sie feststellen, wie viel weniger kompliziert das Programm erscheint, und Sie werden möglicherweise feststellen, wie das Unterprogramm praktisch angewendet wird.

Schließlich können Sie feststellen, dass wir durch die Verwendung eines Unterprogramms für unsere Verzögerungsschleife möglicherweise die Dimensionen des Programms verkleinert haben.

Jedes Mal, wenn wir eine Verzögerung wünschen, möglicherweise wenn die LED ein- oder ausgeschaltet ist, rufen wir im Grunde die Verzögerungsunterroutine auf. Am Ende des Unterprogramms führt das Programm zurück zu der Zeile, die unserer Anweisung 'Aufruf' folgt. In der obigen Abbildung schalten wir die LED ein.

Danach kontaktieren wir das Unterprogramm. Das Programm kommt dann zurück, damit wir die LED ausschalten können. Wir rufen die Unterroutine noch einmal auf, für den Fall, dass die Unterroutine abgeschlossen sein könnte, das Programm zurückkommt und die nachfolgende Anweisung, die es erkennt, 'goto Start' ist. Für alle, die fasziniert sein könnten, war unser erstes Programm 120 Bytes lang.

Durch die Verwendung des Unterprogramms konnten wir unsere Programmgröße auf 103 Bytes reduzieren. Dies könnte nicht so fantastisch klingen, aber angesichts der Tatsache, dass wir insgesamt nur 1024 Bytes im PIC haben, profitiert jede kleine Menge.

Lassen Sie uns in der nächsten Anleitung das Lesen an den Ports überprüfen.

Bisher haben wir an Port A komponiert, damit wir eine LED ein- und ausschalten können. An diesem Punkt werden wir sehen, wie wir die E / A-Pins an den Ports lesen werden.

Eingangs- / Ausgangsanschlüsse lesen

Dies ist genau, um sicherzustellen, dass wir einen externen Schaltkreis verbinden und bestimmte Ausgänge beeinflussen können, die er bietet.

Wenn Sie sich unsere früheren Kurse merken und die E / A-Ports einrichten möchten, mussten wir von Bank 0 zu Bank 1 springen. Dies werden wir zunächst erreichen:

Zu diesem Zeitpunkt haben wir das Bit 0 von Port A für die Eingabe festgelegt. Wir müssen jetzt prüfen, ob der Stift hoch oder niedrig ist. Um dies zu erreichen, kann man nur eine von zwei Anweisungen verwenden:

BTFSC und BTFSS.

Der BTFSC-Befehl bedeutet: 'Führen Sie einen Bittest für das Register sowie das von uns angegebene Bit durch.'

Wenn es eine 0 ist, lassen wir in diesem Fall die nachfolgende Anweisung weg. “ BTFSS impliziert: „Führen Sie einen Bittest in dem von uns erstellten Register und Bit durch. Wenn es auf 1 gesetzt ist, umgehen wir die nachfolgende Anweisung.

Welches wir verwenden, hängt davon ab, wie genau unser Programm reagieren soll, während wir den Input studieren. Zur Veranschaulichung: Wenn wir nur darauf warten, dass die Eingabe eine 1 ist, können wir den BTFSS-Befehl möglicherweise auf folgende Weise verwenden:

Code hier:

BTFSS PortA, 0Gehen Sie weiter Machen Sie hier weiter:
::

Das Programm würde einfach auf 'Weiter hier' wechseln, vorausgesetzt, Bit 0 in PortA ist auf 1 geplant.

Wir werden derzeit ein Programm schreiben, das eine LED mit einer Rate auffordern könnte. Wenn jedoch ein Schalter gedrückt wird, blinkt die LED doppelt so langsam.

Es ist möglich, dieses Programm vielleicht selbst auszuüben, dennoch haben wir die Auflistung irgendwie aufgenommen.

Sie können versuchen, das gesamte Programm zu verfassen, um zu überprüfen, ob Sie die Prinzipien verstanden haben. Wir werden das Ersatzschaltbild wie zuvor verwenden, einschließlich eines an RA0 angebrachten Schalters des PIC und der positiven Schiene unserer Versorgung.

Was wir hier erreicht haben, ist das Einschalten der LED. Ich stelle anschließend fest, ob der Schalter geschlossen ist.

Falls es begrenzt ist, verbinde ich mich als nächstes mit unserer Verzögerungs-Subroutine. Dies gibt uns die gleiche Verzögerung wie zuvor, jedoch kontaktieren wir sie an dieser Stelle zweimal.

Das Gleiche gilt, wenn die LED aus ist. Falls der Schalter nicht geschlossen ist, haben wir unsere vorherigen Ein- und Ausschaltperioden aufgezeichnet.

Haben Sie diese Lektionen von Anfang an verfolgt, möchten Sie vielleicht verstehen, dass Sie derzeit zehn der 35 Anweisungen für den PIC 16F84 entdeckt haben! Und jedes Bit davon wird zufällig durch Ein- und Ausschalten einer LED gelernt.

Bis jetzt haben wir das PIC-Blinken einer LED ein- und ausgeschaltet.

Anschließend konnten wir mit unserem PIC einen Schalter einbauen und so die Blitzgeschwindigkeit variieren.

Speicherplatz effizient nutzen

Das einzige Problem ist, dass das Programm ziemlich langwierig ist und wenig Speicherplatz zur Verfügung stellt. Es schien in Ordnung zu sein, als ich die Befehle zum ersten Mal einfügte, aber es sollte eine einfachere Möglichkeit geben, sie auszuführen. Positiv ist, dass wir analysieren werden, wie wir die LED buchstäblich ein- und ausgeschaltet haben.

movlw 02hmovwf PORTAmovlw 00hmovlw PORTA

Zuerst haben wir unser w-Register mit 02h gefüllt, danach haben wir es in unser PortA-Register übertragen, um die LED einzuschalten. Um es auszuschalten, haben wir w mit 00h gepackt und danach in unser PortA-Register verschoben.

Zwischen all diesen Routinen mussten wir uns mit einer Unterroutine in Verbindung setzen, um sicherzustellen, dass wir das Blinken der LED beobachten konnten.

Daher mussten wir ein paar Mal zwei Informationssätze übertragen (einmal in das w-Register, dann in PORTA) und zweimal ein Unterprogramm aufrufen (einmal für ein, einmal für aus). Wie können wir dies mit zusätzlicher Effizienz erreichen? Sehr einfach.

Wir verwenden eine andere Anweisung, die als XORF bekannt ist. Die XORF-Anweisung führt eine exklusive ODER-Funktion für das Register aus, das wir mit den von uns bereitgestellten Informationen festlegen. Ich glaube, ich muss klären, was in aller Welt ein exklusiver OP ist, bevor wir fortfahren. Wenn wir zwei Eingänge und einen Ausgang haben, kann der Eingang nur dann eine 1 sein, wenn und solange sich die beiden Eingänge unterscheiden. Während sie gleich sind, wird die Ausgabe wahrscheinlich 0 sein. Das Folgende ist eine Wahrheitstabelle für Personen, die diese überprüfen möchten:

A B F0 0 00 1 11 0 11 1 0

Wir werden an dieser Stelle überprüfen, was passiert, wenn wir B genau wie unsere frühere Ausgabe rendern und einfach den Wert von A ändern:

A B F.
0 0 0
0 0 0
1 0 1
1 1 0
1 0 1

Wenn wir den Wert von A auf 1 setzen und ihn mit der Ausgabe exklusiv ODER verknüpfen, wird die Ausgabe umgeschaltet. Falls Sie dies aus der Wahrheitstabelle nicht ersehen können, können Sie dies anhand der Binärdatei beobachten:

0 Stromausgang
EX-OR mit 1 1 neuer Ausgang
EX-OR Mit 1 0 Neuausgang

Vielleicht können Sie feststellen, dass wir durch exklusives ODER-Verknüpfen der Ausgabe mit 1 die Ausgabe jetzt von 0 auf 1 auf 0 umschalten.
Um unsere LED ein- und auszuschalten, benötigen wir daher nur ein paar Sätze:

MOVLW 02h
XORWF-TÜR, 1

Was genau wir erreichen werden, ist das Hinzufügen unseres w-Registers mit 02h. Wir sind in diesem Fall exklusiv ODER geben diese Nummer an, unabhängig davon, was sich auf unserer PortA befindet. Wenn Bit 1 eine 1 ist, ändert es sich in eine 0. Wenn Bit 1 eine 0 ist, ändert es sich in eine 1. Untersuchen wir diesen Code ein- oder zweimal, um anzuzeigen, wie er binär ausgeführt wird:

TÜR
00010
xorwf 00000
xorwf 00010
xorwf 00000
xorwf 00010

Wir müssen nicht jedes Mal den identischen Wert in unser w-Register laden, daher ist es möglich, dies einmal zu Beginn durchzuführen und einfach zu unserem Umschaltbefehl zurückzukehren. Außerdem sollten wir keinen Wert in unserem PortA-Register festlegen. Der Grund? Da es sich beim Einschalten um eine 1 handelt, können wir sie leicht umschalten. Ich, alternativ eine 0 beim Einschalten, wir würden es sogar jetzt umschalten.

Daher möchten Sie unseren neu gebildeten Code sehen. Der erste zeigt unseren blinkenden LED-Code, während der zweite den mit dem zusätzlichen Schalter zeigt:

Wünschen wir uns, Sie können feststellen, dass wir jetzt einfach den Umfang unseres Programms verkleinern, indem wir einfach eine einfache Anweisung verwenden. Die Wahrheit ist, um zu zeigen, um wie viel wir unsere Programme reduzieren könnten, haben wir die beiden Programme, genau das, was zusammengesetzt wurde, und ihre Dimensionen in der folgenden Tabelle gezeigt:

Programm Ändern der Abmessungen (Bytes)
Blinkende LED Original 120
Blinkende LED-Unterroutine hinzugefügt 103
Blinkende LED XOR-Funktion Verwendet 91
LED mit Schalter Original 132
LED mit Schalter XOR Funktion verwendet 124.

Daher haben wir nicht nur einige neuartige Anweisungen entdeckt, sondern auch die Größe unserer Skripte verringert!

Im Folgenden analysieren wir, wie Sie einzelne Bits wackeln, bestimmte einfache Arithmetik- und Datentabellen ausführen können.

Logische Manager

Im letzten Tutorial habe ich die exklusive ODER-Operation vorgestellt. Die ExOR-Funktion wird als logischer Operator verstanden.

In diesem Tutorial werde ich die zusätzlichen logischen Operatoren erläutern, die der PIC fördert. In Punktprogrammen gibt es keinerlei Fälle. Wir lernen jedoch einfache Methoden zur Verwendung der Operatoren, indem wir kleine Codebereiche anwenden.

UND Die UND-Funktion analysiert grundsätzlich zwei Bits und liefert eine 1, ob sie gleich sind, und eine 0, falls sie unterscheidbar sind. Wenn wir zum Beispiel 1 UND 1 erwähnen, ist das Ergebnis 1, während für den Fall, dass wir 1 UND 0 deklariert haben, die Konsequenz 0 wäre.

Unnötig zu erwähnen, dass wir auch Wörter auswerten können und die UND-Funktion nur die beiden Begriffe Stück für Stück überprüft. Die folgende Instanz zeigt zwei 8-Bit-Wörter, die zusammen mit dem Produkt UND-verknüpft werden:

11001011
UND 10110011
Entspricht 10000011

Ich hoffe, Sie stimmen zu, das Ergebnis wird einfach eine 1 besitzen, wenn 2 1s in einem Wortpaar Hand in Hand miteinander gehen. Mit der AND-Funktion können wir beispielsweise die Ports überprüfen.

Wenn wir einige E / A-Pins überprüfen, die mit einer Schaltung verbunden sind, und eine bestimmte Situation im Auge behalten sollten, in der nur einige der Pins hoch sind, können wir in diesem Fall die ziemlich genau lesen Port, nach dem UND das Ergebnis mit der Bedingung, auf die wir untersucht haben, identisch mit der obigen Instanz.

Der PIC liefert uns zwei Zutaten für AND.
Sie sind ANDLW und ANDWF. Mit ANDLW können wir eine UND-Funktion mit den Details des W-Registers und einem von uns festgelegten Betrag ausführen.

Die Syntax lautet: ANDLW wobei genau das ist, was wir wollen UND der Inhalt von W mit.

Die Konsequenz der UND-Funktion würde direkt im W-Register gespeichert.
Mit ANDWF können wir eine UND-Funktion für das W-Register und ein anderes Register ausführen, beispielsweise einen PORT. Die Syntax lautet: ANDWF, d in welchem ​​Register wir begeistert sind, z. PORTA und d zeigen den PIC an, wo Sie das Ergebnis positionieren sollten. Wenn d = 0 ist, wird das Ergebnis in das W-Register eingetragen, und von d = 1 wird das Endergebnis in dem von uns festgelegten Register gespeichert. Die beiden folgenden Codeteile zeigen ein gutes Beispiel für jede UND-Funktion.

Die Initiale untersucht den Status der PORTA, in der überprüft werden muss, ob die Eingaben 1100 sind. Wir können das Ergebnis wieder in das W-Register eintragen

movlw 1100
ANDWF 05h, 0Die zweite Abbildung könnte nun den Inhalt des W-Registers überprüfen:
ANDLW 1100

ODER

Wir haben inzwischen eine ODER-Funktion entdeckt, genauer gesagt die XOR. Dies entwickelt sich zu einer 1, wenn zwei Bits nicht gleich, sondern unterschiedlich sind. Sie können eine andere ODER-Funktion namens IOR finden, nämlich das inklusive ODER. Diese Funktion generiert eine 1, falls eines der Bits eine 1 ist, aber zusätzlich, wenn jedes Bit 1 ist. Nachfolgend finden Sie eine eindeutige Wahrheitstabelle, um dies zu veranschaulichen:

A B O / P.
0 0 0
0 1 1
1 0 1
1 1 1

Was sind arithmetische Operatoren?

HINZUFÜGEN

Diese Funktion erfüllt das, was sie normalerweise behauptet. Es trägt zwei Zahlen bei! Wenn die Konsequenz des Addierens der beiden Zahlen 8 Bit überschreitet, wird in diesem Fall wahrscheinlich ein CARRY-Flag gesetzt. Das CARRY-Flag befindet sich an der Adresse 03h Bit 0.

Wenn dieses Bit geplant ist, haben die beiden Zahlen 8 Bits überschritten. Wenn es eine 0 ist, liegt in diesem Fall die Konsequenz innerhalb von 8 Bits. Nach wie vor liefert uns der PIC zwei Arten von ADD, insbesondere ADDLW und ADDWF. Wie Sie vielleicht angenommen haben, entspricht dies der obigen Funktion. ADDLW bietet den von uns festgelegten Inhalt des W-Registers an. Die Syntax lautet: ADDLW ADDWF fügt den Inhalt des W-Registers und eines anderen von uns festgelegten Registers hinzu.

Die Syntax lautet: ADDWF, d ist wo

SUB

An diesem Punkt können Sie vermutlich nicht davon ausgehen, was diese Funktion leistet! In der Tat haben Sie es vermutet, diese Funktion
subtrahiert ein Bit von einem anderen. Wieder bietet uns der PIC zwei Geschmacksrichtungen: SUBLW und SUBWF. Die Syntax ist genau die gleiche wie für die ADD-Funktion, abgesehen davon, dass Sie offensichtlich SUB anstelle von ADD eingeben!

Inkrement Wenn wir 1 zu einer Zahl in den PIC aufnehmen möchten, können wir die ADD-Funktion unbedingt nutzen und die Nummer eins verwenden. ~ Die Schwierigkeit dabei ist, dass wir die Figur zuerst in das W-Register einfügen und anschließend mit dem ADDLW 1-Regler inkrementieren müssen. Falls wir 1 in ein Register aufnehmen möchten, kann es noch schlimmer sein. Wir müssen zuerst die Nummer 1 in das W-Register eintragen, danach ADDWF 1 verwenden. Um beispielsweise 1 bis Position 0C einzuschließen, müssten wir beispielsweise den folgenden Teil des Skripts besitzen:

movlw 01
addwf 0c, 1

Es gibt eine einfachere Methode, dies durchzuführen. Wir können den Befehl INCF ausüben. Die Syntax lautet: INCF, d wobei das Register oder der Ort ist, um den es sich handelt, und d den PIC zeigt, an dem Sie das Ergebnis positionieren sollten. Im Fall d = 0 liegt das Ergebnis im W-Register, und im Fall d = 1 wird die Konsequenz in dem von uns festgelegten Register festgelegt.

Durch die Verwendung dieser individuellen Anweisung können wir tatsächlich fünfzig Prozent der Codierung ausführen. Falls wir wollten, dass das Ergebnis in das W-Register zurückgeführt wird, in diesem Fall unter Verwendung der obigen Instanz, mussten wir möglicherweise einen zusätzlichen Befehl einfügen, um die Elemente von 0C wieder in das W-Register zu verschieben, wonach das 0C-Register wieder auf Nr. 1 gesetzt wird egal was es war.

Es gibt einen Inkrementierungsbefehl. Es ist INCFSZ. Dieser Befehl kann das von uns festgelegte Register inkrementieren. Wenn jedoch das Register nach dem Inkrement (das auftritt, während wir 1 bis 127 einschließen) gleich 0 ist, wird der PIC wahrscheinlich den nachfolgenden Befehl umgehen. Der folgende Teil des Codes spiegelt dies wider:

Schleife incfsz 0C
Gehe zu Schleife
::
::
Rest des Programms.

Im obigen Teil des Codes wird 0C um 1 erhöht. Als nächstes besitzen wir eine Anweisung, die den PIC anweist, zu unserem Tag mit dem Namen Loop zurückzukehren, und 0C erneut um 1 zu erhöhen. Dies wird fortgesetzt, bis 0C gleich 127 ist. Unter diesen Umständen, wenn wir 0C um 1 erhöhen, wird 0C jetzt mit 0 übereinstimmen. Unser INCFSZ-Befehl könnte den PIC sehr gut informieren, den nachfolgenden Befehl wegzulassen, der in diesem Fall die goto-Deklaration ist. Daher wird der PIC mit dem Rest des Programms fortfahren.

Dekrement

Wir haben die Dekrementierungsfunktion bereits in früheren Schulungen besprochen, daher werde ich sie nicht mehr überarbeiten.

Ergänzen

Die letzte Anweisung in dieser Diskussion würde jedes einzelne Bit in dem von uns festgelegten Register umkehren. Die Syntax lautet: COMF, d wobei

Grundlegendes zu Bitoperationen

Dies könnte zum Beispiel verwendet werden, um die Pins eines Ports schnell von Ausgang zu Eingang usw. zu vertauschen. Mit Bitfunktionen können wir ein einzelnes Bit innerhalb eines Ausdrucks formen. Sie ermöglichen es uns, einzelne Bits in Registern oder Zahlen, die wir festlegen, fortzusetzen, zu setzen und zu entfernen.

Am Ende dieses Kurses werden wir ein Programm vorstellen, mit dem eine Reihe von Sequenzierungslichtern erstellt werden soll, die vorwärts und dann rückwärts ablaufen. Wir haben dies bereits früher beobachtet, als wir die exklusive ODER-Funktion untersucht haben, bei der wir die Ports ausschließlich mit einem Ausdruck ODER-verknüpft haben. Wir haben bis jetzt einige Bitfunktionen bemerkt, als wir die Ports auf dem PIC eingerichtet haben, und

Lassen Sie mich ihre Verwendung hier wiederholen.

BCF

Diese Anweisung löscht ein Bit, das wir in einem von uns festgelegten Register festlegen. Die Syntax
ist:
BCF,

Wir haben dies früher verwendet, um von Seite 1 zu Seite 0 zu wechseln, indem wir ein Bit im STATUS-Register entfernt haben. Wir können es ebenfalls verwenden, um ein Bit in einem anderen Register / Ort auf 0 zu setzen. Wenn wir beispielsweise das in Abschnitt 0C gespeicherte 3. Bit in 11001101 auf 0 setzen möchten, können wir dies tun
einfügen:

BCF 0C, 03

BSF

Diese Anweisung würde jedes von uns festgelegte Bit in jedem von uns angegebenen Register auf 1 setzen. Wir haben dies früher verwendet, um von Seite 0 zu Seite 1 zu gelangen. Die Syntax lautet: BSF ,, und wird in genau der gleichen Methode wie oben BCF verwendet.

BTFSCUp bis jetzt konnten wir ein bisschen in einem Register setzen oder löschen. Stellen Sie sich jedoch vor, wir müssen grundsätzlich prüfen, ob ein Bit eine 1 oder eine 0 in einem Register ist.

Sicher ist es möglich, BTFSC zu verwenden. Es gibt das Bit-Testregister F an und überspringt, wenn es klar ist. Diese Anweisung analysiert das Bit, das wir im Register angeben. Wenn das Bit eine 0 ist, würde der Befehl den PIC anweisen, den nachfolgenden Befehl zu umgehen.

Wir können diese Anweisung verwenden, wenn wir ein Flag überprüfen möchten, beispielsweise das Übertragsflag. Dies erspart es uns, das STATUS-Register zu lesen und nach den einzelnen Bits zu suchen, um zu erfahren, welche Flags fest sind. 29 Wenn wir beispielsweise überprüfen möchten, ob das Carry-Flag auf 1 gesetzt wurde, nachdem wir 2 Ziffern hinzugefügt haben, können wir Folgendes eingeben:

BTFSC 03h, 0
hier weitermachen, wenn auf 1 gesetzt
oder hier, wenn auf 0 gesetzt

Wenn der Status des Bits eine 1 ist, würde in diesem Fall der Befehl nach BTFSC abgeschlossen sein. Wenn es auf 0 gesetzt ist, wird in diesem Fall die nachfolgende Anweisung übersprungen. Der folgende Teil des Codes zeigt, in welchen Bereichen er verwendet werden kann:

Schleife:
::
::
BTFSC 03,0
Gehe zu Schleife

Im obigen Code verlässt der PIC einfach die Schleife, wenn Bit 0 des STATUS-Registers (oder das Carry-Flag) auf 0 definiert ist. Andernfalls wird der Befehl goto ausgeführt.

BTFSS

Diese Anweisung gibt das Bit-Testregister F an und überspringt, wenn gesetzt. Dies kann mit dem BTFSC-Befehl vergleichbar sein, abgesehen davon, dass der PIC den nachfolgenden Befehl weglassen würde, wenn das von uns ausgewertete Bit auf 1 anstatt auf 0 gesetzt wird.

CLRF

Diese Anweisung würde die gesamten Details eines Registers auf 0 setzen. Die Syntax lautet:

CLRF
Wir haben dies früher verwendet, um die Ausgabe der Ports durch Anwenden von CLRF 85h auf 0 zu setzen. Wir haben es außerdem verwendet, um die Ports so zu fixieren, dass sie alle Pins enthalten, die unter Verwendung von CLRF ausgegeben werden sollen
05h.

CLRW

Dies könnte dem CLRF-Befehl ähneln, außer dass das W-Register gelöscht wird. Die Syntax ist ziemlich einfach:

CLRW

RLF und RRF

Diese Richtungen würden ein Bit in einem Register einen einzelnen Schlitz nach links (RLF) oder rechts (RRF) in einem Register transportieren. Wenn wir beispielsweise 00000001 benötigen und RLF verwenden, besitzen wir in diesem Fall möglicherweise 00000010. Was passiert an diesem Punkt, wenn 10000000 vorhanden ist und die RLF-Anweisung angewendet wird? Sicherlich würde die 1 in der Übertragsflagge positioniert sein. Wenn wir den RLF-Befehl erneut anwenden, wird die 1 beim Start wieder angezeigt. Das Gleiche tritt jedoch umgekehrt für den RRF-Befehl auf. Der folgende Fall zeigt dies für den RLF-Befehl, in dem wir die 8 Bits eines Registers sowie das Übertragsflag sehen können:

C 87654321
0 00000001
RLF 0 00000010
RLF 0 00000100
RLF 0 00001000
RLF 0 00010000
RLF 0 00100000
RLF 0 01000000
RLF 0 10000000
RLF 1 00000000
RLF 0 00000001

Beispielprogramm

Wir werden jetzt einen Beispielcode sehen, den man kompilieren und steuern kann. Es würde ein Sequenzierungslicht erzeugen, das bei PortA-Bit 0 beginnt und zu PortB-Bit 8 und geht
dann zurückkehren.
Schließen Sie LEDs an jeden der Port-Pins an. Wir werden etwas davon haben
Verfahren, auf die in diesem Tutorial hingewiesen wird.

TIME EQU 9FH Variable für die Verzögerungsschleife.
PORTB EQU 06H Port B Adresse.
TRISB EQU 86H Port B Tristate-Adresse.
PORTA EQU 05H Port Eine Adresse.
TRISA EQU 85H Port Eine Tristate-Adresse.
STATUS EQU 03H Seitenauswahlregister.
COUNT1 EQU 0CH Schleifenregister.
COUNT2 EQU 0DH Schleifenregister.

BSF STATUS, 5 Weiter mit Seite 1
MOVLW 00H und einrichten
MOVWF TRISB beide Ports A und B.
MOVLW 00H zur Ausgabe,
MOVWF TRISA kehren dann zu zurück
BCF STATUS, 5 Seite 0.
MOVLW 00H Port A löschen.
MOVWF-TÜR

Start des Hauptprogramms

RUNMOVLW
01H Setze das erste bitMOVWF
PORTB auf Port B.CALL
VERZÖGERUNG Warten Sie eine Weile
VERZÖGERN
Bewegen Sie das Bit an Port B nach links und halten Sie dann an
PORTB, 1CALL
DELAYCALL
DELAYRLF
PORTB, 1CALL
DELAYCALL
DELAYRLF
PORTB, 1CALL
DELAYCALL
DELAYRLF
PORTB, 1CALL
DELAYCALL
DELAYRLF
PORTB, 1CALL
DELAYCALL
DELAYRLF
PORTB, 1CALL
DELAYCALL
DELAYRLF
PORTB, 1CALL
DELAYCALL
DELAYRLF
PORTB, 1 Dies verschiebt das Bit in das Übertragsflag
Gehen Sie nun zu Port A und bewegen Sie das Bit nach links
PORTA, 1 Dies verschiebt das Bit vom Null-Flag in PortACALL
DELAYCALL DELAYRLF
TÜR, 1RUF
DELAYCALL
DELAYRLF
TÜR, 1RUF
DELAYCALL
DELAYRLF
TÜR, 1RUF
DELAYCALL
VERZÖGERN
Bewegen Sie das Bit auf Port ARRF zurück
TÜR, 1RUF
DELAYCALL
DELAYRRF
TÜR, 1RUF
DELAYCALL
DELAYRRF
TÜR, 1RUF
DELAYCALL
DELAYRRF
PORTA, 1 Dies verschiebt das Bit in das Null-Flag. Verschieben Sie nun das Bit
zurück auf Port BRRF
PORTB, 1CALL
DELAYCALL
DELAYRRF
PORTB, 1CALL
DELAYCALL
DELAYRRF
PORTB, 1CALL
DELAYCALL
DELAYRRF
PORTB, 1CALL
DELAYCALL DELAYRRF
PORTB, 1CALL
DELAYCALL
DELAYRRF
PORTB, 1CALL
DELAYCALL
DELAYRRF
PORTB, 1CALL
DELAYCALL
VERZÖGERUNG Jetzt sind wir wieder da, wo wir angefangen haben, GOTO
RUN lass uns nochmal gehen.

Das Trainingsset enthält eine großartige Option, mit der Sie eine Datentabelle verwenden können.

Eine Datentabelle ist nur eine Liste von Datenzitaten, in denen anhand einiger Überlegungen alles überprüft wird.
Zum Beispiel könnten Sie eine Schaltung haben, die einen PIC verwendet, der die Anzahl der Instanzen zählt, bei denen ein Eingangspin in 1 Sekunde hoch wird. Danach können Sie die Nummer auf einer 7-Segment-Anzeige anzeigen.

Sobald das Timing gestartet ist, beginnt der PIC zu zählen, wie oft der Pin hoch geht. Nach 1 Sekunde besucht es die Tabelle und schaut nach den Daten. Es muss die Nummer auf dem Display anzeigen, die die Anzahl der Situationen symbolisiert, in denen der Pin hoch wurde. Dies kann von Vorteil sein, da wir die Zahl erst bestimmen, wenn der PIC seine Schätzung erreicht hat.

Mithilfe einer Tabelle können wir dem PIC ermöglichen, zu bestimmen, welche Figur dargestellt werden soll. Bevor ich Ihnen weiter zeigen kann, wie die Datentabelle funktioniert, muss ich Ihnen an dieser Stelle möglicherweise mitteilen, dass der PIC den Pfad des Aufenthaltsorts in dem Programm beibehält, in dem er sich befindet, während das Programm ausgeführt wird.

Es erleichtert für diejenigen, die bestimmte Programmierungen in BASIC durchgeführt haben. Andernfalls machen Sie sich keine Sorgen, vielleicht möchten Sie weiterhin etwas über die Theorie lernen. Stellen Sie sich vor, es gibt ein BASIC-Programm ähnlich dem unten dargestellten:

10 Jahre K = 0
11 K = K + 1
12 WENN K> 10 DANN GOTO 20 SONST GOTO 11
20 DRUCKEN K.
21 ENDE

Das Programm beginnt in Zeile 10. Sobald K auf 0 gesetzt ist, geht es weiter zu Zeile 11. Nachdem wir 1 zu K aufgenommen haben, fahren wir danach mit Zeile 12 fort.

An diesem Punkt könnten wir neugierig sein, ob K höher als 10 ist. Falls dies der Fall ist, gehen wir als nächstes zu Zeile 20 oder kehren zu Zeile 11 zurück.

Zeile 20 dokumentiert das K und Zeile 21 schließt das Programm ab. BASIC verwendet Linienstatistiken, um dem Programmierer zu helfen, Aufzeichnungen darüber zu führen, wo Probleme auftreten, da Etiketten nicht autorisiert sind. Der PIC verwendet Labels, um zwischen Zielen zu entkommen - oder kann das wirklich?

Wir verwenden die Etiketten, um sicherzustellen, dass wir wissen, wo Probleme liegen, und um sicherzustellen, dass wir den PIC auf einfache Weise darüber informieren können, wo gesucht werden soll.

Genau das, was passiert, ist, dass der PIC einen inneren Zeilenzähler nutzt, der als Programmzähler bezeichnet wird. Der Programmzählerspur (abgekürzt als PC) des Speicherziels, an dem sich der vorliegende Befehl befindet.

Immer wenn wir den PIC über den Besuch eines ausgewählten Etiketts informieren, versteht er den Speicherplatz und erweitert daher den PC, bis er dieses Speicherziel sieht. Dies ist genau die gleiche Methode wie im obigen BASIC-Programm. Unten finden Sie neben jeder Anweisung ein Codesegment mit den Speicherplätzen oder den Elementen des PCs:

PC Instruction0000 movlw 03
0001 movwf 0C
0002 Loop decfsc 0C
0003 gehe zu Loop
0004 Ende

In der obigen Demonstration haben wir den PC auf 0000 festgelegt. Darauf haben wir den Befehl movlw 03. Wenn der PIC diese Daten implementiert hat, erhöht er den PC, damit der nachfolgende Befehl gescannt wird. Zu diesem Zeitpunkt zeigt der PIC movwf 0C an. Der PC wird noch einmal inkrementiert.

Jetzt untersucht der PIC decfsc 0C. Falls die Details von 0C nicht 0 sind, wird in diesem Fall der PC um 1 erhöht, und die folgende Anweisung, gehe zu Schleife, weist den PC an, zu Position 0003 zurückzukehren, wo sich diese Schleife befindet. Wenn die Details von 0C 0 sind, wird dem PC empfohlen, um 2 zu erhöhen. Lassen Sie einfach die nachfolgende Anweisung weg.

Grundlegendes zu Datentabellen

Dies bringt den PC an Position 0004, an der das Programm beendet wird. Die Ziele werden vom Assembler festgelegt, und wir sollten uns im Allgemeinen keine Gedanken darüber machen, was der PC leistet. Bis wir feststellen, dass wir es genau wie bei der Verwendung von Datentabellen unter Kontrolle bringen müssen. Der bequemste Weg, um die Funktionsweise einer Datentabelle zu beschreiben, besteht darin, mit einer Abbildung zu beginnen.

PC equ 02
movlw 03
Tabelle aufrufen
::
Tabelle addwf PC
retlw 01
retlw 02
retlw 03
retlw 04
retlw 05
retlw 06
retlw 07
Rückkehr

Die anfängliche Anweisung weist dem Etiketten-PC die Adresse des Programmzählers (02h) zu. Wir werden bald nach dem Einfügen des Wertes von 03h in das w-Register sein. Danach kommunizieren wir mit dem Tisch. Die vorderste Zeile in der Unterprogrammtabelle erweitert die Details des W-Registers (03h) zum Programmzähler.

Dies veranlasst den Programmzähler, um 3 zu erhöhen oder anders ausgedrückt, den Programmzähler zu veranlassen, 3 Zeilen nach unten zu gehen. Während der Zähler 3 Zeilen weiter unten ankommt, erkennt der PIC den Befehl retlw. Dieser Befehl sendet den darauf folgenden Wert in das W-Register, wonach er vom Unterprogramm zurückkehrt. RETLW bedeutet im Grunde Return, Literal to W.

Siehe Ich habe ein Komma nach dem Wort Zurück gesetzt. Da wir uns in einer Unterroutine befinden, benötigen wir eine Return-Anweisung, um sie anzuzeigen. Daher das RET in der Anweisung. Nach dem RETLW-Befehl steht eine Zahl, und genau das wird in das W-Register eingetragen.

In diesem Fall ist es die Abbildung 3. Wir könnten dem W-Register eine beliebige Größe zuweisen. Solange diese Abbildung mit dem Programmzähler in der Tabellenunterroutine kombiniert wird, werden wir einen Befehl retlw entdecken. In der obigen Abbildung bedeutet dies, dass wir eine beliebige Zahl von 1 bis 7 besitzen können. Wenn wir über das Unterprogramm hinausgehen, können wir möglicherweise einen zusätzlichen Abschnitt des Programms abschließen. Aus diesem Grund ist es normalerweise eine kluge Entscheidung, die Datentabelle genau gegen Ende des PIC-Programms zu platzieren. Wenn wir in diesem Fall ein Überschwingen durchführen, werden wir trotzdem zum Abschluss des Programms gelangen.

Das Thema Interrupts wird wahrscheinlich das längste und schwierigste sein, das es zu durchlaufen gilt.

Sie können keine unkomplizierte Methode zur Detaillierung von Interrupts finden, aber mit etwas Glück gegen Ende dieses Teils können Sie Interrupts möglicherweise in Ihre eigenen Programme anwenden.
Wir haben den Abschnitt in 2 Stufen unterteilt. Dies dient dazu, das Thema in Abschnitte zu unterteilen und Ihnen ein praktisches Plit zum leichteren Verständnis zu bieten.

Was genau ist ein Interrupt? Wie der Begriff schon sagt, ist ein Interrupt sicherlich eine Technik oder ein Signal, das einen Mikroprozessor / Mikrocontroller daran hindert, dass etwas anderes passiert.

Gestatten Sie mir, Ihnen täglich eine Illustration zu geben. Denken Sie, Sie entspannen sich in Ihrem eigenen Zuhause und unterhalten sich mit einer anderen Person. Plötzlich ertönt das Telefon.

Sie hören auf zu sprechen und greifen zum Telefon, um mit dem Anrufer zu sprechen. Sobald Sie Ihre Telefoninteraktion haben, entscheiden Sie sich, wieder mit der Person zu sprechen, bevor das Telefon klingelte. Es ist möglich, die Hauptroutine zu berücksichtigen, während Sie mit jemandem chatten. Das Klingeln des Telefons führt zu einer Unterbrechung Ihrer Konversation, und die Unterbrechung der Routine ist die Methode zum Telefonieren.

Während die Telefondiskussion endet, kehren Sie zu Ihrer primären Chat-Routine zurück. Diese Abbildung zeigt genau, wie ein Prozessor unterbrochen wird, um Maßnahmen zu ergreifen.

Das Primärprogramm arbeitet und führt bestimmte Funktionen in einem Schaltkreis aus. Wenn jedoch eine Unterbrechung auftritt, wird das Primärprogramm angehalten, während eine andere Routine ausgeführt wird. Wenn die Routine endet, kehrt der Prozessor wie zuvor zur primären Routine zurück.

Interrupts verstehen

Der PIC verfügt über 4 Interruptquellen. Sie könnten in ein paar Gruppen unterteilt werden. Zwei sind Quellen von Interrupts, die nach außen zum PIC genutzt werden können, während die anderen beiden innere Prozesse sind. Lassen Sie mich hier die beiden externen Typen erläutern. Die anderen beiden werden in verschiedenen Tutorials beschrieben, sobald wir zu Timern kommen und Daten speichern.

Wenn Sie die Pinbelegung des PIC überprüfen, werden Sie feststellen, dass es sich bei Pin 6 um RB0 / INT handelt. Zu diesem Zeitpunkt ist RB0 eindeutig Port B Bit 0. Das INT repräsentiert, dass es auch als externer Interrupt-Pin konfiguriert werden kann. Darüber hinaus können die Pins 4 bis 7 von Port B (Pins 10 bis 13) auch für Interrupts verwendet werden. Bevor wir den INT oder einen anderen Port B-Pins verwenden können, müssen wir zwei Aufgaben ausführen. Zuerst müssen wir den PIC darüber informieren, dass wir Interrupts verwenden werden.

Als nächstes müssen wir festlegen, welchen Port B-Pin wir als Interrupt und nicht als E / A-Pin verwenden möchten. Innerhalb des PIC befindet sich ein Register namens INTCON, das sich unter der Adresse 0Bh befindet. In diesem Register finden Sie 8 Bits, die aktiviert oder deaktiviert sein können. Bit 7 von INTCON ist als GIE bekannt. Dies ist die globale Interrngupt-Aktivierung. Wenn Sie dies auf 1 setzen, wird der PIC darüber informiert, dass ein Interrupt verwendet wird.

Bit 4 von INTCON ist als INTE, INTerrupt Enable bekannt. Wenn Sie dieses Bit auf 1 setzen, wird dem PIC mitgeteilt, dass RB0 ein Interrupt-Pin sein wird. Das Konfigurieren von Bit 3, RBIE genannt, informiert den PIc darüber, dass wir die Bits 4 bis 7 von Port B verwenden werden. An diesem Punkt versteht der PIC, wann dieser Pin hoch oder niedrig sein kann, muss seine Leistung anhalten und mit einem Interrupt fortfahren Routine. An diesem Punkt müssen wir den PIC darüber informieren, ob der Interrupt wahrscheinlich auf der aufsteigenden Flanke (0 V bis + 5 V) oder der abfallenden Flanke (+ 5 V bis 0 V) ​​des Signals liegt oder nicht.

Wünschen wir einfach gesagt, dass der PIC jedes Mal unterbrochen wird, wenn sich das Signal von niedrig nach hoch oder von hoch nach niedrig bewegt. Durch Kriminalität kann festgestellt werden, dass dies an der steigenden Flanke platziert wird.

Die Flankenauslösung wird in einem zusätzlichen Register, dem OPTION-Register, unter der Adresse 81h geplant. Das Bit, von dem wir begeistert sind, ist Bit 6, das oft als INTEDG bezeichnet wird.

Wenn Sie dies auf 1 setzen, wird der PIC an der Montagekante unterbrochen (Standardzustand), und wenn Sie ihn auf 0 setzen, wird der PIC an der Gleitkante gestört. Wenn Sie möchten, dass der PIC bei steigender Flanke aktiviert wird, müssen Sie mit diesem Bit sicherlich nichts anfangen.

Zu diesem Zeitpunkt befindet sich das Optionsregister leider in Bank 1, was bedeutet, dass wir gerne von Bank 0 zu Bank 1 wechseln, das Bit im Optionsregister setzen und danach zu Bank 0 zurückkehren. Der Schlüssel hier ist, jedes Bit zu erreichen der Bank 1 registriert sich in einem einzigen Streik, zum Beispiel beim Einrichten der Port-Pins, und kehrt danach zur Bank 0 zurück, wenn Sie fertig sind.

Gut, folglich haben wir dem PIC mitgeteilt, welcher Pin wahrscheinlich der Interrupt sein wird und wo die Flanke ausgelöst werden soll. Was passiert im Programm und im PIC jedes Mal, wenn der Interrupt auftritt? Ein paar Sachen finden statt. Zunächst ist eine Flagge geplant.

Dies informiert den internen Prozessor des PIC darüber, dass ein Interrupt aufgetreten ist. Als nächstes verweist der Programmzähler (über den ich im vorherigen Tutorial gesprochen habe) auf eine bestimmte Adresse im PIC. Lassen Sie uns all dies schnell einzeln überprüfen. Interrupt-Flag In unserem INTCON-Register ist Bit 1 das Interrupt-Flag namens INTF. Zu diesem Zeitpunkt wird dieses Flag bei jedem Interrupt wahrscheinlich auf 1 gesetzt.

Wenn es keinen Interrupt gibt, wird das Flag auf 0 gesetzt. An diesem Punkt überlegen Sie möglicherweise, was der Punkt ist. Obwohl dieses Flag auf 1 festgelegt ist, kann und wird der PIC sicherlich nicht auf einen anderen Interrupt reagieren. Lassen Sie uns daher zum Ausdruck bringen, dass wir eine Unterbrechung verursachen. Das Flag wird wahrscheinlich auf 1 festgelegt, und der PIC geht möglicherweise zu unserer Routine, um den Interrupt zu bearbeiten.

Wenn dieses Flag nicht auf 1 festgelegt war und der PIC weiterhin auf den Interrupt antworten durfte, konnte durch kontinuierliches Pulsieren des Pins der PIC zum Beginn unserer Interrupt-Routine zurückkehren und diesen auf keinen Fall abschließen. Zurück zu meiner Abbildung des Telefons: Es ist ähnlich wie beim Abheben des Telefons. Sobald Sie mit der Diskussion beginnen, klingelt es erneut, da eine andere Person mit Ihnen sprechen möchte.

Es ist ratsam, einen Dialog zu führen und dann das Telefon erneut zu greifen, um mit der nachfolgenden Person zu sprechen. Sie können ein kleines Problem mit dieser Flagge finden. Obwohl der PIC dieses Flag schnell auf 1 setzt, setzt er es nicht erneut auf 0! Diese Aktivität muss vom Programmierer ausgeführt werden - d. H. Von Ihnen. Dies kann mühelos erreicht werden, da ich sicher bin, dass dies erreicht werden muss, nachdem der PIC die Interruptroutine ausgeführt hat.

Speicherort Wenn Sie den PIC zum ersten Mal einschalten oder wenn ein Reset vorliegt, gibt der Programmzähler einen Hinweis auf 0000h, der möglicherweise sofort am Anfang des Programmspeichers steht. Im Falle eines Interrupts zeigt der Programmzähler jedoch die Adresse 0004h an.

Während wir unser Programm zusammenstellen, das Interrupts haben wird, müssen wir daher zuerst den PIC informieren, über die Adresse 0004h zu springen, und die Interruptroutine beibehalten, die an der Adresse 0004h beginnt, die vom Rest des Programms getrennt ist.

Dies kann problemlos durchgeführt werden. Zunächst beginnen wir unser Programm mit einem Befehl namens ORG. Dieser Befehl gibt Origin oder Start an. Wir halten uns mit einer Adresse daran. Da der PIC an der Adresse 0000h beginnt, geben wir ORG 0000h ein. Danach müssen wir die Adresse 0004h umgehen. Dies erreichen wir, indem wir eine GOTO-Anweisung zusammen mit einem Etikett anbringen, das Tipps für unser primäres Programm enthält.

Danach halten wir uns mit einem weiteren ORG an diesen GOTO-Befehl, in diesem Moment mit der Adresse 0004h. Nach diesem Befehl fügen wir unsere Interruptroutine ein. Zu diesem Zeitpunkt können wir möglicherweise unsere Interruptroutine direkt nach dem zweiten ORG-Befehl eingeben oder eine GOTO-Anweisung positionieren, die auf die Interruptroutine verweist.

Es hängt wirklich mit der Option von Ihrer Seite zusammen. Um den angebotenen PIC am Ende der Interruptroutine zu informieren, müssen wir den Befehl RTFIE gegen Ende der Routine positionieren. Dieser Befehl bedeutet die Rückkehr von der Interruptroutine. Während der PIC dies bemerkt, zeigt der Programmzähler die endgültige Position an, an der sich der PIC befand, bevor der Interrupt auftrat. Wir haben unten einen kurzen Codeabschnitt eingerichtet, um Folgendes anzuzeigen:

Es gibt einige Dinge, die Sie bei der Verwendung von Interrupts wissen sollten. Der Anfang besteht in der Regel darin, dass sich die Details des Registers höchstwahrscheinlich ändern, wenn der Interrupt stattfindet, wenn Sie möglicherweise das identische Register in Ihrem Primärprogramm und in der Interruptroutine verwenden.

Verwenden Sie beispielsweise das w-Register, um Daten an das primäre Programm von Port A weiterzuleiten. Daher können Sie das w-Register in der Interruptroutine zusätzlich verwenden, um Daten von einem Ziel zu einem anderen zu verschieben.

Wenn Sie nicht vorsichtig sind, enthält das w-Register den letzten Wert, den es während der Interrupt-Routine empfangen hat. Wenn Sie also vom Interrupt zurückkehren, werden diese Informationen an Port A übermittelt und nicht an den Wert, den Sie zuvor besessen haben Der Interrupt ist aufgetreten.

Das Mittel dazu besteht darin, die Details des w-Registers kurz zu speichern, bevor Sie es erneut in der Interrupt-Routine verwenden. Das zweite ist die Tatsache, dass Sie eine Verzögerung zwischen dem Zeitpunkt, zu dem ein Interrupt stattfindet, und dem Zeitpunkt, zu dem der nachfolgende auftreten kann, feststellen können. Während Sie verstehen, besitzt der PIC eine Außenuhr, die möglicherweise ein Kristall oder eine Widerstands-Kondensator-Kombination sein kann.

Unabhängig von der Frequenz dieses Takts teilt der PIC ihn durch 4 und verwendet ihn anschließend für das innere Timing. Wenn Sie beispielsweise einen 4-MHz-Quarz mit Ihrem PIC verbunden haben, führt der PIC in diesem Fall die Anweisungen bei 1 MHz aus. Dieses innere Timing wird als Befehlszyklus bezeichnet. An dieser Stelle behauptet das Datenblatt (zweifellos in Verkleinerung), dass Sie 3 bis 4 Anweisungsrunden zwischen Interrupts aktivieren müssen.

Mein wäre, 4 Runden zu ermöglichen. Der Grund für die Verzögerung ist, dass der PIC Zeit benötigt, um zur Interrupt-Adresse, dem Flag, zu springen und von der Interrupt-Routine zurückzukehren. Denken Sie daher daran, wenn Sie mit einem alternativen Schaltkreis arbeiten, um einen Interrupt für den PIC zu aktivieren.

An dieser Stelle ist ein Punkt zu, dass, wenn Sie die Bits 4 bis 7 von Port B als Interrupt verwenden. Sie können keine bestimmten Pins an Port B auswählen, die als Interrupt fungieren sollen.

Wenn Sie diese Stifte zulassen, sind sie wahrscheinlich alle erhältlich. Daher können Sie beispielsweise nicht einfach die Bits 4 und 5 haben - die Bits 6 und 7 werden wahrscheinlich gleichzeitig aktiviert. Was genau ist der Zweck, vier Bits als Interrupt darzustellen? Sicherlich haben Sie möglicherweise eine Schaltung, die an den PIC angeschlossen ist, falls eine der vier Leitungen hoch geht. In diesem Fall kann dies ein Problem sein, das der PIC sofort beeinflussen muss.

Ein Beispiel hierfür könnte ein Alarm für die Sicherheit zu Hause sein, bei dem vier Sensoren mit den Pins 4 bis 7 von Port B verbunden sind. Jeder spezifische Sensor kann den PIC auffordern, einen Alarm auszulösen, und die Alarmsignalisierungsroutine ist die Interruptroutine. Dies erspart die ständige Überprüfung der Ports und ermöglicht es dem PIC, mit verschiedenen Angelegenheiten fortzufahren. Im nächsten Tutorial werden wir ein Programm zum Verwalten eines Interrupts erstellen.

Wir haben uns im letzten Tutorial mit vielen Grundlagen befasst, daher denke ich, dass es an der Zeit ist, unser erstes Programm zu komponieren.

Das Programm, das wir schreiben, zählt die Anzahl der Fälle, in denen wir einen Schalter einschalten, und zeigt dann die Anzahl an.

Das Programm würde von 0 bis 9 zählen und auf 4 LEDs in binärer Form angezeigt werden. Der Eingang oder Interrupt befindet sich wahrscheinlich auf RB0.

Das Wichtigste, was wir tun müssen, ist, den PIC zu informieren, über die Adresse zu springen, auf die der Programmzähler zeigt, wenn ein Interrupt stattfindet.

Sie werden feststellen, dass wir eine einzigartige Methode zur Darstellung von Hexadezimalzahlen anwenden. Bevor ich passiert bin, wende F9h an, wobei h hexadezimal angibt. Wir könnten dies als 0xF9 schreiben, was die Struktur ist, die wir von nun an verwenden werden.

Jetzt müssen wir dem PIC mitteilen, dass wir Interrupts verwenden werden, und wir verwenden RB0-Pin 6 als Interrupt-Pin:

bsf INTCON, 7GIE - Globale Interrupt-Freigabe (1 = Freigabe)
bsf INTCON, 4INTE - RB0 Interrupt Freigabe (1 = Freigabe)
Ich werde das Interrupt-Flag für alle Fälle löschen (ich vertraue nie etwas!)
bcf INTCON, 1INTF - Löscht das Flag-Bit für alle Fälle

Derzeit müssen wir unsere 2 Ports einrichten. Beachten Sie, dass RB0 jetzt als Interrupt-Pin verwendet wird und dies als Eingabe eingerichtet werden muss:

Wir werden eine Variable namens COUNT verwenden, um die Anzahl der Schalterzählungen zu speichern. Wir könnten einfach den Wert an Port A erhöhen, aber Sie werden sehen, warum ich eine Variable verwende, wenn wir unsere Interruptroutine schreiben.

Daher besteht unser Hauptprogramm, und an dieser Stelle müssen wir den PIC darüber informieren, wie bei jedem Interrupt vorzugehen ist. In diesem Beispiel wird unser Interrupt wahrscheinlich der Schalter sein. Wir möchten, dass der PIC jedes Mal, wenn der Schalter gedrückt wird, einer der einstellbaren COUNT ist.

Trotzdem möchten wir nur zeigen, wie oft der Schalter von 0 auf 9 schließt. Oben habe ich angegeben, dass wir den Wert an Port A möglicherweise jedes Mal, wenn ein Interrupt auftritt, einfach erhöhen können. Port A hat jedoch 5 Bits. Wenn wir den Port einfach inkrementieren, haben wir die höchste Anzahl von 31. Es gibt einige Erklärungen, warum ich mich entschieden habe, nicht auf 31 zu wechseln.

Zunächst werden wir einen 7-Segment-Bildschirm verwenden, der höchstens von 0 bis 15 (0 bis F in hex) gehen kann. Als nächstes möchte ich Ihnen einige der arithmetischen Befehle zeigen, auf die Sie in den letzten Lektionen gestoßen sind.

Deshalb werden wir unsere Interruptroutine fortsetzen. Derzeit müssen wir zunächst die Details unseres w-Registers kurz speichern, da wir dies angewendet haben, um den Inhalt von COUNT auf PORTA zu verschieben. Falls wir es nicht speichern, können wir in diesem Fall aufgrund unserer Arithmetik möglicherweise eine völlig andere Zahl liefern. Lassen Sie uns dies zuerst tun:

An diesem Punkt verstehen wir, ob der Wert von COUNT 9 oder mehr beträgt. Was wir jetzt tun müssen, ist, wenn COUNT größer als 9 ist, es auf 0 zurückzusetzen oder zum Hauptprogramm zurückzukehren, um sicherzustellen, dass wir es an Port A liefern können. Der BTFSS-Befehl, da Sie verstehen, würde der folgende sein
Anweisung für den Fall, dass das Übertragsflag geplant ist, d. h. COUNT = 10:

Jetzt müssen wir nur noch gemeinsam eingeben und Werte für unsere Konstanten ermitteln, die wir direkt zu Beginn unseres Programms ausführen können.

Jedes Mal, wenn Sie den Schalter aktivieren, zählen die LEDs binär von 0000 bis 1010 und dann zurück bis 0000.

Die folgende Abbildung zeigt den Schaltplan, der mit dem oben erläuterten Code kompatibel ist. Interessanterweise werden Sie feststellen, dass der Zeitkondensator im Design enthalten ist. Dies ist ein netter kleiner Trick, durch den Sie die Freiheit haben, die Einbeziehung des Kondensators zu vermeiden, falls Sie während dieser Zeit keinen bei sich haben.

Hier kommt die Kapazität über die Streukapazität zwischen Oszillatorstift und Masse ins Spiel.
Natürlich scheint es kein sehr intelligenter Weg zu sein, einen Kondensator praktisch zu vermeiden, da der Streuwert unter verschiedenen gegebenen Bedingungen variieren kann.

Ein weiterer Abschnitt, der in der Schaltung beobachtet werden kann, ist das denunzierende Netzwerk über den Switch. Dies verhindert Störungen beim mechanischen Schalten und verhindert, dass der PIC verwirrt wird, wenn es sich bei dem Umschalten um einen einzelnen oder mehrere Umschalter handelt.




Zurück: Programmierbare bidirektionale Motor-Timer-Schaltung Weiter: Funktionsweise von Buck-Boost-Schaltkreisen