PIC-Mikrocontroller sind ein sehr nützliches und vielseitiges Werkzeug für viele elektronische Projekte. Sie sind sehr günstig und leicht zu finden. Sie sind auch sehr leistungsstark und viele können mit dem internen Oszillatorblock Geschwindigkeiten von bis zu 64 MIPS erreichen, was etwa 16-mal schneller ist als bei den meisten vergleichbaren AVR-Mikrocontrollern. PICs sind ebenfalls einfach zu programmieren, jedoch kann es manchmal schwierig sein, das Projekt einzurichten. Diese Anweisungen führen Sie durch den Prozess des Einrichtens der Software, des Erstellens eines neuen Projekts und des Programmierens einiger sehr einfacher Funktionen, um die Konfiguration zu testen und sicherzustellen, dass alles funktioniert. Sie sind so konzipiert, dass sie sehr offen sind. Nachdem das Projekt erstellt und die Grundlagen fertiggestellt wurden, wird der Leser aufgefordert, alle Funktionen und Extras zu erkunden, die in dieser Anleitung nicht behandelt werden. Sie werden auch feststellen, dass diese Anweisungen Schritt für Schritt durchlaufen werden. Wenn sich die Anweisungen jedoch dem Ende nähern, wird der Leser aufgefordert, andere Möglichkeiten zur Erfüllung der Aufgaben zu erkunden und das Projekt zu seinem eigenen zu machen.

Was Sie benötigen Um ein Projekt mit einem PIC-Mikrocontroller zu erstellen, sind nur wenige Elemente erforderlich.

• PIC-Mikrocontroller
  • Diese Anweisungen dienen zum Programmieren einer MCU der PIC18F-Serie, obwohl andere ähnlich sind.
  • Erhalten von der Microchips-Website.
  • Mit Microchip können Schüler mit gültigen .edu-E-Mail-Adressen kostenlos Beispiel-PICs erhalten!
  • Der PIC, mit dem ich diese Anweisungen erstelle, ist ein PIC18F22K80
• PICkit 3 In-Circuit-Debugger
  • Erhältlich bei Microchip.
  • Kostet $ 45 für die breite Öffentlichkeit und # 34 mit Studentenrabatt, wenn Sie eine .edu-E-Mail-Adresse haben.
  • Es gibt auch andere Programmierer, die genauso gut funktionieren. Dies ist jedoch die beste für den Anfang.
• Steckbrett und Steckbrettdrähte
• LEDs, Tasten, Potentiometer oder alles andere, was Sie an den PIC anschließen möchten

Schritt 1: Hardware erstellen

Bevor Sie programmieren, müssen Sie zunächst die Hardware erstellen. Obwohl das PIC18F-Portfolio sehr groß ist, haben viele der Chips mehrere Gemeinsamkeiten. Weitere Informationen finden Sie im Abschnitt "Richtlinien für den Einstieg in PIC18Fxxxx-Mikrocontroller" in Ihrem Gerätedatenblatt. Detaillierte Pinbelegungen des PIC-Mikrocontrollers finden Sie im Abschnitt "Pin-Diagramm" in Ihrem Gerätedatenblatt.

Hinweis: VDD = positive Spannung und VSS = Masse.

1. Verbinden Sie den MCLR-Pin über einen 1kΩ-Widerstand mit VDD.
2. Schließen Sie einen 0, 1 μF-Kondensator zwischen jedem Paar benachbarter VDD-VSS-Paare oder AVDD-AVSS-Paare an.
3. Schließen Sie einen 10μF-Kondensator zwischen VCAP und Vss an.
4. Verbinden Sie den MCLR-Pin mit Pin 1 des PICkit 3.
5. Verbinden Sie den VDD mit Pin 2 des PICkit 3.
6. Verbinden Sie VSS mit Pin 3 des PICkit 3.
7. Verbinden Sie den PGD-Pin mit Pin 4 des PICkit 3.
8. Verbinden Sie den PGC-Pin mit Pin 5 des PICkit 3.
9. Lassen Sie Pin 6 des PICkit 3 nicht angeschlossen.
10. Verbinden Sie alle analogen Eingänge mit Pins mit ANx-Funktionalität, wobei x eine Zahl ist.
11. Verbinden Sie alle digitalen Ein- oder Ausgänge mit Pins mit Rxy-Funktionalität, wobei x ein Buchstabe ist, der den Port identifiziert, und y eine Zahl ist, die das Bit identifiziert.

In meinem Beispiel habe ich eine LED zwischen RA0 und Masse, den Scheibenwischer eines an AN1 angeschlossenen Potentiometers und einen an RA2 angeschlossenen DPST-Schalter. Möglicherweise ist es einfacher, den PIC zu programmieren, wenn Sie ein Schema Ihrer Schaltung skizziert haben.

Schritt 2: Software herunterladen

Diese Anweisungen verwenden den XC8-Compiler und die MPLAB X IDE von Microchip. In diesem Schritt wird erläutert, wie Sie diese Tools erhalten und sicherstellen, dass sie korrekt installiert wurden.

1. Die neueste Version der Software finden Sie auf der Microchips-Website unter //www.microchip.com/pagehandler/en-us/family/mplabx/.
2. Wählen Sie die Software für Ihr Betriebssystem aus und befolgen Sie die Standardinstallationsanweisungen.

Hinweis: Wenn Sie Windows 8 verwenden, müssen Sie die Installationsprogramme möglicherweise im Kompatibilitätsmodus für Windows 7 ausführen.

3. Starten Sie nach der Installation der Software MPLAB X.
4. Wählen Sie in der Menüleiste Extras-> Optionen
5. Wählen Sie im Dialogfeld "Optionen" die Registerkarte "Eingebettet" und stellen Sie sicher, dass XC8 in der Toolchain-Liste aufgeführt ist.
6. Wenn es aufgelistet ist, wählen Sie OK und fahren Sie mit dem nächsten Schritt fort.
7. Wenn es nicht aufgeführt ist, stellen Sie sicher, dass die Instillation abgeschlossen ist, und klicken Sie auf die Schaltfläche Nach Build-Tools suchen.
8. Wenn dies immer noch nicht aufgeführt ist, suchen Sie im Microchips-Forum nach Hilfe bei Ihrem speziellen Problem.

Schritt 3: Neues Projekt erstellen

In diesem Schritt erstellen wir ein neues Projekt basierend auf einer Vorlage von Microchip.

1. Wählen Sie in der Menüleiste Datei-> Neues Projekt ...
2. Erweitern Sie im Dialogfeld "Neue Datei" die Option "Beispiele" und wählen Sie "Eingebetteter Mikrochip" aus
3. Wählen Sie im Projektfeld PIC18 C Template aus
4. Wählen Sie Weiter
5. Geben Sie dem Projekt einen beliebigen Namen
6. Wählen Sie im Feld Projektspeicherort einen Speicherort aus, an dem das Projekt gespeichert werden soll
7. Belassen Sie den Projektordner als Standardoptionen
8. Aktivieren Sie das Kontrollkästchen "Als Hauptprojekt festlegen"
9. Wählen Sie Fertig stellen

Das Projekt wird nun in Project Explore auf der linken Seite des Bildschirms angezeigt.

Schritt 4: Parameter erstellen

Bevor wir mit der Programmierung beginnen können, müssen wir die Build-Parameter festlegen.
Konfiguration erstellen

1. Klicken Sie mit der rechten Maustaste auf den Projektnamen in der Projektsymbolleiste.
2. Wählen Sie im Dialogfeld Projekteigenschaften die Option Konfigurationen verwalten ...
3. Wählen Sie im Dialogfeld "Konfigurationen" die Option "Neu"
4. Geben Sie im Dialogfeld Neuer Konfigurationsname Standard ein und klicken Sie auf OK
5. Stellen Sie im Dialogfeld "Konfigurationen" sicher, dass "Standard" ausgewählt ist, und klicken Sie auf "Aktiv setzen"
6. Klicken Sie im Dialogfeld "Konfigurationen" auf "OK"

Legen Sie die Konfigurationseigenschaften fest

1. Wählen Sie im Dialogfeld Projekteigenschaften in der Liste Kategorien die Option "Conf: [Standard]" aus
   1. Geben Sie im Feld Gerät den Namen des verwendeten Geräts ein. In meinem Fall PIC18F26K80
   2. Wählen Sie in der Liste Hardware Tools die Option PICkit3 aus
   3. Wählen Sie in der Compiler-Toolchain XC8 (v ...) aus, wobei ... die von Ihnen installierte Version ist.
   4. Wählen Sie Übernehmen
2. Wählen Sie unter Conf: [Default] PICkit 3 aus
   1. Wählen Sie für Optionskategorien die Option Leistung
   2. Überprüfen Sie "Power Target Circuit von PICkit3
   3. Wählen Sie Übernehmen.
3. Wählen Sie unter Conf: [Default] den XC8-Compiler aus
   1. Wählen Sie unter Optionskategorien Optimierungen aus
   2. Setzen Sie "Optimization Set" auf "none"
   3. Wählen Sie Übernehmen
4. Klicken Sie auf OK, um das Dialogfeld zu schließen

Testen der Konfiguration Um die Konfiguration zu testen, klicken Sie auf die Schaltfläche Reinigen und Erstellen (die mit Hammer und Besen). Der Text wird im Ausgabefenster unten auf der Seite gescrollt. Wenn alles erfolgreich ist, wird in diesem Text BUILD SUCCESSFUL (Gesamtzeit: ...) angezeigt . Wenn Sie eine Fehlermeldung erhalten, gehen Sie diesen Schritt erneut durch und stellen Sie sicher, dass Sie nichts verpasst haben und dass alles angewendet wurde.

Schritt 5: Konfigurationsbits festlegen

Der nächste Schritt ist das Setzen der Konfigurationsbits. Die Konfigurationsbits teilen der MCU ihre Anfangsbedingungen für das Einschalten mit. Sie werden verwendet, um die Taktquelle und -geschwindigkeit, die Watchdog-Zeitkonfiguration und andere ähnliche Funktionen einzustellen. Konfigurationsbits sind geräteabhängig. Weitere Informationen finden Sie im Datenblatt des verwendeten Chips.

1. Erweitern Sie im Projektexplorer Quelldateien und öffnen Sie configuration_bits.c
2. Entfernen Sie den gesamten Text unter der Zeile #endif
3. Beachten Sie, dass am unteren Bildschirmrand eine neue Registerkarte geöffnet wurde
4. Stellen Sie die Bits nach Bedarf für Ihr Projekt ein. Da diese chipabhängig sind, überprüfen Sie das Datenblatt auf weitere Informationen zu den jeweiligen Funktionen. Es folgen einige allgemeine Einstellungen:
   1. Erweiterter Befehlssatz - Sollte bei Verwendung der Vorlage auf AUS gesetzt werden
   2. Oszillator - Dient zur Auswahl des Prozessors. Wenn Sie keinen externen Quarz verwenden, lassen Sie ihn als internen RC-Oszillator eingestellt. Weitere Oszillatorkonfigurationen finden Sie im Datenblatt. Hinweis: CLKOUT erleichtert das Debuggen und sollte aktiviert werden, falls verfügbar.
   3. PLL aktivieren - Ermöglicht die zukünftige Verwendung der PLL. Hinweis: Dadurch wird die PLL nicht aktiviert, sondern nur aktiviert. Es wird empfohlen, es zu aktivieren.
   4. Watchdog-Timer - Der Watchdog-Timer wird verwendet, um sicherzustellen, dass der Prozessor nicht blockiert. Es macht es jedoch viel schwieriger zu debuggen. Es wird empfohlen, es während der ersten Programmierung zu deaktivieren und erst zu aktivieren, nachdem das Projekt fast abgeschlossen ist.
   5. Code / Tabelle Schreib- / Leseschutz - Wird verwendet, um das Schreiben oder Lesen in bestimmte Speicherbereiche zu deaktivieren. Lassen Sie alle diese deaktiviert.
   6. Wenn Sie sich über eine Einstellung nicht sicher sind, können Sie diese normalerweise auf der Standardeinstellung belassen.
5. Nachdem alle Konfigurationsbits gesetzt wurden, klicken Sie unten im Bedienfeld auf die Schaltfläche "Quellcode für Ausgabe generieren".
6. Das Bedienfeld wechselt nun zur Registerkarte Ausgabe. Wählen Sie den gesamten Text auf dieser Registerkarte aus und kopieren Sie ihn in die Zwischenablage
7. Fügen Sie es am Ende der Datei configuration_bits.c ein und speichern Sie es vorab.
8. Bereinigen und erstellen Sie das Projekt erneut, indem Sie auf das Besen- und Hammersymbol klicken.
9. Stellen Sie sicher, dass der Build erfolgreich war. Stellen Sie außerdem sicher, dass die Ausgabe keine Fehler enthält

Wenn alles geklappt hat, fahren Sie mit dem nächsten Schritt fort. Wenn es Fehler oder Warnungen gibt, beheben Sie diese, bevor Sie fortfahren.

Schritt 6: Konfigurieren Sie den Oszillator

Der nächste Schritt besteht darin, mit der Programmierung zu beginnen. Bevor wir jedoch zum Anwendungscode gelangen, müssen wir den Systemcode programmieren. Der Systemcode sind die Low-Level-Funktionen wie die Konfiguration des Oszillators und die grundlegenden Verzögerungsfunktionen.

Einstellungen festlegen

Bevor wir die Einstellungen programmieren können, müssen wir auswählen, mit welcher Geschwindigkeit wir laufen möchten. In diesem Beispiel verwende ich 16 MHz, da die meisten PICs mit dieser Geschwindigkeit betrieben werden können. Für meine Konfiguration verwende ich den 4-MHz-Postscaller vom HF-INTOSC und die 4x PLL mit einer Ausgangsfrequenz von 4 MHz * 4x = 16 MHz

1. Im Datenblatt finden Sie den Abschnitt mit der Bezeichnung Oszillatorkonfigurationen
2. Das erste, was in diesem Abschnitt aufgeführt ist, sind Oszillatortypen. Wenn Sie den internen Oszillator verwenden, verwenden Sie die Einstellungen für INTIO1
3. Auf den nächsten ein oder zwei Seiten finden Sie eine schematische Zeichnung des Oszillators ähnlich der gezeigten. Es ist hilfreich, das Signal in dieser Zeichnung zu verfolgen, um sicherzustellen, dass die richtige Geschwindigkeit ausgewählt wird.
4. Der nächste Schritt besteht darin, diese Einstellungen auf die MCU zu programmieren. Dies erfolgt durch Einstellen von Registern. Das erste zu setzende Register ist OSCCON.
   1. IDLEN - wird verwendet, um die Aktion des Schlafbefehls zu steuern. Kann als Standard belassen werden.
   2. IRCF - Oszillatorauswahl. Da ich HF-INTOSC / 4 (4 MHz) verwende, muss ich dies auf einen Binärwert von 101 einstellen
   3. OSTS - Nur-Lese-Bit
   4. HFIOFS - Nur-Lese-Bit
   5. SCS - Taktauswahlbits. Da ich den internen Oszillator verwende, werde ich auf 1x setzen, wobei x 0 oder 1 sein kann
5. Das nächste Register ist OSCCON2; Dieses Register ist jedoch meist schreibgeschützt und an dieser Stelle nicht wichtig
6. Das letzte Oszillatorkonfigurationsregister ist OSCTUNE. Wir werden die Frequenz für dieses Projekt nicht einstellen, müssen jedoch dieses Register verwenden, um die PLL mit dem PLLEN-Bit einzuschalten.

Einstellungen anwenden

1. Kehren Sie zu MPLAB zurück
2. Öffnen Sie im Projektexplorer unter Quelldateien system.c
3. Am Ende dieser Datei befindet sich die Funktion ConfigureOscillator. Entfernen Sie die Kommentare in dieser Funktion.
4. Um die Bits eines Registertyps in Großbuchstaben zu setzen, geben Sie den Registernamen ein, gefolgt von den Kleinbuchstabenbits und dann einer Periode und dem Bitnamen.
5. Um die Bits zu setzen, folgen Sie dem mit einem Gleichheitszeichen. Um die Binärzahl zu verwenden, geben Sie 0bXXXX ein, wobei XXXX die Binärzahl ist. Zuletzt beenden Sie die Zeile mit einem Semikolon.
6. Setzen Sie alle oben für das OSCCON-Register festgelegten Bits. Beispiel: OSCCONbits.IRCF = 0b101;
7. Machen Sie dasselbe für alle anderen benötigten Oszillatorregister. Unten finden Sie ein Beispiel für eine fertige ConfigureOscillator-Funktion.
8. Wenn Sie fertig sind, prüfen Sie, ob Warnungen / Fehler vorliegen

 / ** * Konfigurieren Sie die Taktquelle und die Geschwindigkeit * / void ConfigureOscillator (void) {OSCCONbits. IRCF = 0b101; OSCCONbits. SCS = 0b00; OSCTUNEbits. PLLEN = 0b1; }} 

Schritt 7: Warten Sie Milli-Sekunden-Funktion

Eine der nützlichsten Funktionen ist wait_ms. Dies ist jedoch keine Funktion in der Standardbibliothek und muss von Ihnen programmiert werden. Für diese Implementierung gibt es eine Schleife, die den Prozessor hält, bis die angegebene Zeit abgelaufen ist.

PIC18F-Mikrocontroller benötigen 4 Taktzyklen, um eine Zeile Assembler-Code auszuführen. Daher werden bei einem Takt von 16 MHz Leitungen mit 4 Millionen Zeilen pro Sekunde = 4000 Zeilen pro Millisekunde ausgeführt. Da eine for-Schleife jedes Mal einen Befehl für den Vergleich und zwei für die Operation einen für den Körper der Schleife benötigt, funktioniert sie perfekt. Wir brauchen nur die for-Schleife, um 1000 Mal pro Millisekunde zu schleifen.

1. Erstellen Sie in system.c eine neue Funktion am Ende der Datei vom Typ void wait_ms (uint16_t time).
2. Unten ist die abgeschlossene Funktion

 / ** * Warten Sie mit dem Besetztschema auf eine bestimmte Anzahl von Millisekunden. * @param time - Wartezeit in ms. * / void wait_ms (uint16_t time) {statische lange Zeit = 0; Zeit = Zeit * 1000l; for (; timel; timel -); // keine Anfangsbedingung, während die Zeit> 0 ist, dekrementiere die Zeit für jede Schleife} 

1. Öffnen Sie system.h im Ordner Header Files im Projektbrowser
2. Fügen Sie am Ende die Zeile void wait_ms (uint16_t) hinzu. Prototyp der Funktion.
3. Ändern Sie Zeile 8 von 8000000L in 16000000L
4. Erstellen und überprüfen Sie auf Fehler / Warnungen

Schritt 8: Blinken Sie eine LED

Der beste Weg, um zu testen, ob alles richtig eingerichtet ist, besteht darin, ein LED-Licht zu blinken. Wenn das Licht mit der erwarteten Geschwindigkeit blinkt, wurde alles korrekt konfiguriert. In diesem Beispiel ist die LED an PORT A, Pin 0 (RA0 im Datenblatt) angeschlossen. Wenn Sie Ihre LED an einen anderen Pin angeschlossen haben, verwenden Sie die entsprechenden Register und Bits.

1. Öffnen Sie main.c im Projekt-Viewer unter Quelldateien.

Die Funktion void main (void) ist der Haupteinstiegspunkt des Programms. Beim ersten Einschalten der MCU wird diese Funktion aktiviert. In der ersten Zeile wird die von Ihnen ausgefüllte ConfigureOscillator-Funktion aufgerufen, um die Taktquelle und die Geschwindigkeit einzustellen. Die nächste Zeile ruft InitApp auf, eine Funktion, die wir in Kürze ausfüllen werden, und tritt schließlich in eine Endlosschleife ein. Da es kein Betriebssystem gibt, zu dem die Funktion zurückkehren kann, erfolgt am Ende kein Rückruf.
Die fertige Funktion sollte folgendermaßen aussehen:

1. Fügen Sie unmittelbar über der while-Schleife den folgenden Code hinzu.
   1. Setzen Sie den LED-Pin als Ausgang - TRISAbits.TRISA0 = 0; // Setzen eines TRIS-Bits auf 0 Sätze als Ausgang, Setzen auf 1 Sätze als Eingang
2. Fügen Sie innerhalb der while-Schleife den folgenden Code hinzu
   1. Stellen Sie die LED auf OFF - LATAbits.LATA0 = 0; // Die LAT-Bits steuern den Ausgang eines Pins. 0 = NIEDRIG, 1 = HOCH
   2. Warten Sie eine halbe Sekunde - wait_ms (500);
   3. Stellen Sie die LED auf ON - LATAbits.LATA0 = 1;
   4. Warten Sie eine halbe Sekunde - wait_ms (500);

 void main (void) {/ * Konfiguriere den Oszillator für das Gerät * / ConfigureOscillator (); / * E / A und Peripheriegeräte für die Anwendung initialisieren * / InitApp (); TRISAbits.TRISA0 = 0; // setze Pin als Ausgang während (1) {LATAbits.LATA0 = 0; // Pin LOW setzen wait_ms (500); // warte 0, 5 Sekunden LATAbits.LATA0 = 1; // setze Pin HIGH wait_ms (500); // 0, 5 Sekunden warten}} 

1. Erstellen Sie das Programm und suchen Sie nach Fehlern oder Warnungen
2. Stellen Sie sicher, dass das PICkit korrekt mit dem PIC und dem Computer verbunden ist
3. Klicken Sie auf die Schaltfläche Gerät erstellen und programmieren (die Schaltfläche rechts neben der Schaltfläche Bereinigen und Erstellen).
4. Wenn Sie dazu aufgefordert werden, wählen Sie PICkit 3 und klicken Sie auf OK
5. Wenn die Warnung eine doppelte Überprüfung anzeigt, haben Sie den richtigen PIC in der Schaltung und klicken Sie auf OK
6. Wenn eine Warnung zur Zielgeräte-ID angezeigt wird, klicken Sie auf OK, um sie zu ignorieren

Schritt 9: Lesen eines Analogwerts

Bisher kann das Programm eine LED blinken lassen. Als nächstes geben wir ihm einige Benutzereingaben. Wir werden ein Potentiometer verwenden, um ein analoges Signal zu erzeugen, das die Geschwindigkeit der LED ändert. Der ADC nimmt eine analoge Spannung auf und gibt einen digitalen Wert aus.

1. Öffnen Sie im Projektbrowser user.c unter Quelldateien
2. Über der InitApp-Funktion erstellen Sie eine neue Funktion void init_adc(void)
3. Geben Sie den folgenden Code ein, um das ADC-Modul zu initialisieren

 / ** * Initialisieren Sie den Analog-Digital-Wandler. * / void init_adc (void) {TRISAbits. TRISA1 = 0b1; // Pin als Eingang ANCON0bits setzen. ANSEL1 = 0b1; // Pin als analoge ADCON1bits setzen. VCFG = 0b00; // setze v + Referenz auf Vdd ADCON1bits. VNCFG = 0b0; // setze v- Referenz auf GND ADCON1bits. CHSN = 0b000; // setze den negativen Eingang auf GND ADCON2bits. ADFM = 0b1; // rechts die Ausgabe ADCON2bits ausrichten. ACQT = 0b110; // 16 TAD ADCON2bits. ADCS = 0b101; // benutze Fosc / 16 für die Taktquelle ADCON0bits. ADON = 0b1; // ADC einschalten} 

4. Erstellen Sie als Nächstes unmittelbar nach dem Aufruf von uint16_t adc_convert(uint8_t channel) eine weitere Funktion.

 / ** * Führen Sie eine Analog-Digital-Wandlung durch. * @param channel Der zu verwendende ADC-Eingangskanal. * @return Der Wert der Konvertierung. * / uint16_t adc_convert (uint8_t channel) ADRESL; // gebe das Ergebnis zurück 

5. Fügen Sie in der InitApp-Funktion die Zeile init_adc()
6. Fügen Sie in der Datei user.h den Prototyp uint16_t adc_convert(uint8_t);
7. Ändern Sie main auf Folgendes:

 void main (void) {uint16_t adc_value; // Variable zum Halten des ADC-Konvertierungsergebnisses in / * Konfiguriere den Oszillator für das Gerät * / ConfigureOscillator (); / * E / A und Peripheriegeräte für die Anwendung initialisieren * / InitApp (); TRISAbits. TRISA0 = 0; // Pin als Ausgang setzen während (1) {LATAbits. LATA0 = 0; // Pin LOW setzen adc_value = adc_convert (1); // A / D-Wandlung auf Kanal 1 durchführen (wait_ms (adc_value >> 2); // 0, 5 Sekunden warten LATAbits. LATA0 = 1; // setze Pin HIGH adc_value = adc_convert (1); // A / D-Wandlung auf Kanal 1 durchführen (wait_ms (adc_value >> 2); // 0, 5 Sekunden warten}} 

8. Erstellen Sie den Code und laden Sie ihn herunter. Wenn Sie den POT drehen, sollte sich die Geschwindigkeit ändern, mit der die LED blinkt

Schritt 10: Lesen Sie einen digitalen Wert

Als nächstes erhalten wir einen digitalen Eingang vom Schalter. Wenn der Schalter ausgeschaltet ist, lässt das Programm das tun, was es die ganze Zeit getan hat, und wenn der Schalter eingeschaltet ist, leuchtet die LED dauerhaft auf, bis der Schalter wieder ausgeschaltet wird.

1. Um einen Pin als Eingang zu setzen, schreiben Sie eine 1 in das TRIS-Registerbit des Pins - TRISAbits.TRISA2 = 1;
2. Wenn ein Pin analoge Funktionen gemeinsam nutzt, muss er möglicherweise auf digital gesetzt werden, indem das entsprechende Bit im ANCONx-Register gelöscht wird
3. Verwenden Sie beim Schreiben eines Werts in einen Pin das LAT-Register. Verwenden Sie jedoch beim Lesen eines Werts von einem Pin das PORT-Register - value = PORTAbits.RA2;
4. Ändern Sie main auf Folgendes:

 void main (void) {uint16_t adc_value; // Variable zum Halten des ADC-Konvertierungsergebnisses in / * Konfiguriere den Oszillator für das Gerät * / ConfigureOscillator (); / * E / A und Peripheriegeräte für die Anwendung initialisieren * / InitApp (); TRISAbits. TRISA0 = 0; // Pin als Ausgang TRISAbits setzen. TRISA2 = 1; // Pin als Eingang ANCON0bits setzen. ANSEL2 = 0; // Pin als digital setzen während (1) {if (PORTAbits. RA2) // wenn der Pin hoch ist {LATAbits. LATA0 = 1; // setze den Pin auf high} else // wenn der Pin niedrig ist {// blink die LED LATAbits. LATA0 = 0; // Pin LOW setzen adc_value = adc_convert (1); // A / D-Wandlung auf Kanal 1 durchführen (wait_ms (adc_value >> 2); // warte einige Zeit LATAbits. LATA0 = 1; // setze Pin HIGH adc_value = adc_convert (1); // A / D-Wandlung auf Kanal 1 durchführen (wait_ms (adc_value >> 2); // etwas warten}}} 

Das ist es! Sie haben jetzt die Grundkenntnisse, wie Sie ein neues Projekt einrichten, digitale Pins lesen und schreiben und wie Sie von analogen Pins lesen. Mit diesen drei Funktionen können Sie 90% der Projekte mit PICs im Internet ausführen. Wenn Sie sich weiter mit PIC-Mikrocontrollern befassen, werden Sie feststellen, dass die meisten anderen Funktionen sehr ähnliche Schritte zum Konfigurieren von Peripheriegeräten sowie zum Lesen und Recht auf Register erfordern.