PIC-microcontrollers programmeren

PIC-microcontrollers zijn een zeer nuttig en veelzijdig hulpmiddel voor gebruik in veel elektronische projecten. Ze zijn erg goedkoop en gemakkelijk te vinden. Ze zijn ook erg krachtig en velen zijn in staat om snelheden tot 64 MIPS te gebruiken met behulp van het interne oscillatorblok, ongeveer 16 keer sneller dan de meeste vergelijkbare AVR-microcontrollers. PIC's zijn ook eenvoudig te programmeren, maar het kan soms lastig zijn om het project op te zetten. Deze instructies doorlopen het proces van het instellen van de software, het maken van een nieuw project en het programmeren van enkele zeer eenvoudige functies om de configuratie te testen en ervoor te zorgen dat alles werkt. Ze zijn ontworpen om zeer open te zijn; nadat het project is gemaakt en de basis is voltooid, wordt de lezer aangemoedigd om alle functies en extra's te verkennen die niet in deze instructies worden behandeld. Je zult ook merken dat deze instructies stap voor stap zullen beginnen, maar als de instructies tegen het einde worden aangemoedigd, wordt de lezer aangemoedigd om andere manieren te verkennen om de taken uit te voeren en het project eigen te maken.

Wat je nodig hebt Om een ​​project met een PIC-microcontroller te bouwen, heb je maar een paar items nodig.

  • PIC-microcontroller
    • Deze instructies zijn bedoeld voor het programmeren van een PIC18F-serie MCU, hoewel andere vergelijkbaar zijn.
    • Opgehaald van de Microchips-website.
    • Met Microchip kunnen studenten met geldige .edu-e-mailadressen gratis PIC's bekijken!
    • De PIC die ik gebruik om deze instructies te maken, is een PIC18F22K80
  • PICkit 3 In-Circuit Debugger
    • Verkrijgbaar bij Microchip.
    • Kost $ 45 voor het grote publiek en # 34 met studentenkorting als je een .edu-e-mailadres hebt.
    • Er zijn ook andere programmeurs die net zo goed zullen werken; dit is echter de beste om mee te beginnen.
  • Breadboard en breadboard draden
  • LED's, knoppen, potentiometers of iets anders dat u op de PIC wilt aansluiten

Stap 1: Bouw hardware

Voordat u begint met programmeren, moet u eerst de hardware bouwen. Hoewel het PIC18F-portfolio erg groot is, hebben veel van de chips verschillende overeenkomsten. Voor meer gedetailleerde informatie, zie de "Richtlijnen om aan de slag te gaan met PIC18Fxxxx Microcontrollers" in de datasheet van uw apparaat. Voor gedetailleerde pin-outs van de PIC-microcontroller, zie de sectie "Pin Diagram" in de datasheet van uw apparaat.

Opmerking: VDD = positieve spanning en VSS = aarde.
  1. Verbind de MCLR-pin via een 1kΩ-weerstand met VDD.
  2. Sluit een condensator van 0, 1 μF aan tussen elk paar aangrenzende VDD-VSS-paren of AVDD-AVSS-paren.
  3. Sluit een condensator van 10 μF aan tussen VCAP en Vss.
  4. Sluit de MCLR-pin aan op pin 1 van de PICkit 3.
  5. Sluit VDD aan op pin 2 van de PICkit 3.
  6. Sluit VSS aan op pin 3 van de PICkit 3.
  7. Sluit de PGD-pin aan op pin 4 van de PICkit 3.
  8. Sluit de PGC-pin aan op pin 5 van de PICkit 3.
  9. Laat pin 6 van de PICkit 3 niet aangesloten.
  10. Sluit alle analoge ingangen aan op pinnen met ANx-functionaliteit waarbij x een getal is.
  11. Sluit alle digitale in- of uitgangen aan op pinnen met Rxy-functionaliteit waarbij x een letter is die de poort identificeert en y een nummer dat de bit identificeert.
Voor mijn voorbeeld heb ik een LED aangesloten tussen RA0 en aarde, de wisser van een potentiometer aangesloten op AN1 en een DPST-schakelaar aangesloten op RA2. Misschien vindt u het gemakkelijker om de PIC te programmeren als u een schema van uw circuit hebt geschetst.

Stap 2: Software downloaden

Deze instructies gebruiken de XC8-compiler en MPLAB X IDE van Microchip. Deze stap legt uit hoe u deze tools kunt verkrijgen en hoe u ervoor kunt zorgen dat ze correct zijn geïnstalleerd.
  1. Bezoek de Microchips-website op //www.microchip.com/pagehandler/en-us/family/mplabx/ voor de nieuwste versie van de software.
  2. Selecteer de software voor uw besturingssysteem en volg de standaard installatie-instructies.
Opmerking: als u Windows 8 gebruikt, moet u mogelijk de installatieprogramma's uitvoeren in de compatibiliteitsmodus voor Windows 7.
  1. Start MPLAB X zodra de software is geïnstalleerd
  2. Selecteer in de menubalk Extra-> Opties
  3. Selecteer in het dialoogvenster Opties het tabblad Ingesloten en zorg ervoor dat XC8 wordt vermeld in de Toolchain-lijst.
  4. Als het wordt vermeld, selecteert u OK en gaat u verder met de volgende stap.
  5. Als het niet wordt vermeld, zorg dan dat de instillatie is voltooid en klik op de knop Scan for Build Tools.
  6. Als het nog steeds niet wordt vermeld, kijk dan op het Microchips-forum voor hulp bij uw specifieke probleem.

Stap 3: Maak een nieuw project

In deze stap zullen we een nieuw project maken op basis van een sjabloon van Microchip.
  1. Selecteer op de menubalk Bestand-> Nieuw project ...
  2. Vouw in het nieuwe bestandsdialoogvenster Monsters uit en selecteer Microchip Embedded
  3. Selecteer in het projectvak PIC18 C-sjabloon
  4. Selecteer Volgende
  5. Geef het project elke gewenste naam
  6. Kies een locatie om het project in op te slaan in het vak Projectlocatie
  7. Laat de projectmap als standaardopties staan
  8. Vink het vakje "Instellen als hoofdproject" aan
  9. Selecteer Finish
Het project wordt nu weergegeven in Project Explore aan de linkerkant van het scherm.

Stap 4: Build-parameters

Voordat we kunnen beginnen met programmeren, moeten we de buildparameters instellen.
Configuratie maken
  1. Klik met de rechtermuisknop op de projectnaam in de werkbalk van het project.
  2. Selecteer in het dialoogvenster Projecteigenschappen Configuraties beheren ...
  3. Selecteer Nieuw in het dialoogvenster Configuraties
  4. Typ Standaard in het dialoogvenster Nieuwe configuratienaam en klik op OK
  5. Zorg ervoor dat Standaard is geselecteerd in het configuratiedialoogvenster en klik op Actief instellen
  6. Klik op OK in het configuratiedialoogvenster
Configuratie-eigenschappen instellen
  1. Selecteer in het dialoogvenster Projecteigenschappen "Conf: [Standaard]" in de lijst Categorieën
    1. Typ in het vak Apparaat de naam van het apparaat dat u gebruikt. In mijn geval PIC18F26K80
    2. Selecteer PICkit3 in de lijst Hardware Tools
    3. Selecteer in de Compiler Toolchain XC8 (v ...) Waar ... is de versie die u hebt geïnstalleerd.
    4. Selecteer Toepassen
  2. Selecteer onder Conf: [Standaard] PICkit 3
    1. Selecteer voor optiecategorieën Power
    2. Controleer "Power target circuit van PICkit3
    3. Selecteer Toepassen.
  3. Selecteer onder Conf: [Standaard] XC8-compiler
    1. Selecteer voor Optiecategorieën Optimalisaties
    2. Stel 'Optimalisatieset' in op 'geen'
    3. Selecteer Toepassen
  4. Klik op OK om het dialoogvenster te sluiten
Test de configuratie Om de configuratie te testen, klikt u op de knop Reinigen en bouwen (die met de hamer en bezem). Tekst begint te scrollen in het uitvoervenster onderaan de pagina. Als alles gelukt is, zal deze tekst SUCCESVOL BOUWEN (totale tijd: ...) . Als je een foutmelding krijgt, ga dan terug door deze stap en zorg ervoor dat je niets hebt gemist en dat alles is toegepast.

Stap 5: Configuratiebits instellen

De volgende stap is het instellen van de configuratiebits. De configuratiebits vertellen de MCU de initiële voorwaarden voor wanneer deze wordt ingeschakeld. Ze worden gebruikt om de klokbron en -snelheid, watchdog-tijdconfiguratie en andere vergelijkbare functies in te stellen. Configuratiebits zijn apparaatafhankelijk, dus controleer het gegevensblad van de chip die u gebruikt voor meer informatie.
  1. Vouw in de projectverkenner Bronbestanden uit en open configuratie_bits.c
  2. Verwijder alle tekst onder de #endif-regel
  3. Merk op dat er een nieuw tabblad is geopend onder aan het scherm
  4. Stel de bits in zoals nodig voor uw project. Aangezien deze chipafhankelijk zijn, raadpleegt u het gegevensblad voor meer informatie over wat elk doet. Enkele veel voorkomende instellingen volgen:
    1. Uitgebreide instructieset - Moet worden ingesteld op UIT bij gebruik van sjabloon
    2. Oscillator - Gebruikt om de processor te selecteren. Tenzij u een extern kristal gebruikt, laat u deze ingesteld als interne RC-oscillator. Zie gegevensblad voor andere oscillatorconfiguraties. Opmerking: CLKOUT zorgt voor eenvoudigere foutopsporing en moet worden ingeschakeld indien beschikbaar.
    3. PLL inschakelen - Maakt toekomstig gebruik van de PLL mogelijk. Opmerking: hierdoor wordt de PLL niet ingeschakeld, maar wordt deze alleen ingeschakeld. Het wordt aanbevolen om het in te schakelen.
    4. Watchdog-timer - De watchdog-timer wordt gebruikt om ervoor te zorgen dat de processor niet vergrendelt. Het maakt het echter veel moeilijker om te debuggen. Het wordt aanbevolen om het tijdens de eerste programmering uit te schakelen en pas in te schakelen nadat het project bijna is voltooid.
    5. Code / tabel schrijven / lezen beschermt - Wordt gebruikt om schrijven of lezen naar bepaalde geheugenbereiken uit te schakelen. Laat al deze uitgeschakeld.
    6. Als u niet zeker bent van een instelling, is het meestal veilig om deze standaard te laten staan.
  5. Nadat alle configuratiebits zijn ingesteld, klikt u op de knop "Genereer broncode voor uitvoer" onderaan het paneel.
  6. Het paneel schakelt nu over naar het tabblad Uitvoer. Selecteer alle tekst op dit tabblad en kopieer deze naar het klembord
  7. Plak het onderaan het bestand configuration_bits.c en sla het op.
  8. Maak het project schoon en bouw het opnieuw op door op het pictogram bezem en hamer te klikken.
  9. Zorg ervoor dat de build is geslaagd. Controleer ook of er geen fouten in de uitvoer waren
Als alles heeft gewerkt, ga dan verder met de volgende stap. Als er fouten of waarschuwingen zijn, herstel deze dan voordat u verder gaat.

Stap 6: Configureer Oscillator

De volgende stap is om te beginnen met programmeren; Voordat we echter bij de applicatiecode komen, moeten we de systeemcode programmeren. De systeemcode zijn de functies op laag niveau, zoals het configureren van de oscillator en basisvertragingsfuncties.

Instellingen bepalen

Voordat we de instellingen kunnen programmeren, moeten we kiezen met welke snelheid we willen lopen. Voor dit voorbeeld zal ik 16 MHz gebruiken omdat de meeste PIC's met deze snelheid kunnen werken. Voor mijn configuratie gebruik ik de 4 MHz postscaller van de HF-INTOSC en de 4x PLL met een uitgangsfrequentie van 4 MHz * 4x = 16 MHz
  1. In de datasheet vindt u de sectie Oscillatorconfiguraties
  2. Het eerste dat in deze sectie wordt vermeld, zijn oscillatortypen. Als u de interne oscillator gebruikt, gebruik dan de instellingen met betrekking tot INTIO1
  3. Op de volgende pagina of twee vindt u een schematische tekening van de oscillator die lijkt op de getoonde. Het is handig om het signaal op deze tekening te volgen om er zeker van te zijn dat de juiste snelheid wordt geselecteerd.
  4. De volgende stap is om deze instellingen op de MCU te programmeren. Dit wordt gedaan door registers in te stellen. Het eerste register dat moet worden ingesteld, is OSCCON.
    1. IDLEN - gebruikt om de actie van het slaapcommando te besturen. Kan standaard blijven staan.
    2. IRCF - Oscillatorselectie. Aangezien ik HF-INTOSC / 4 (4 MHz) gebruik, moet ik dit instellen op een binaire waarde van 101
    3. OSTS - Alleen-lezen bit
    4. HFIOFS - Alleen-lezen bit
    5. SCS - klokselectiebits. Omdat ik de interne oscillator gebruik, zal ik instellen op 1x waar x 0 of 1 kan zijn
  5. Het volgende register is OSCCON2; dit register is echter meestal alleen-lezen en op dit moment niet belangrijk
  6. Het laatste oscillatorconfiguratieregister is OSCTUNE. We zullen de frequentie voor dit project niet afstemmen, maar we moeten dit register gebruiken om de PLL in te schakelen met behulp van de PLLEN-bit.

Instellingen toepassen

  1. Keer terug naar MPLAB
  2. Open in de projectverkenner onder Bronbestanden het systeem. C
  3. Onderaan dit bestand staat de functie ConfigureOscillator. Verwijder de opmerkingen in die functie.
  4. Om de bits van een registertype in alle hoofdletters in te stellen, wordt de registernaam gevolgd door de kleine woordbits en vervolgens een punt en de bitnaam.
  5. Om de bits in te stellen, volgt u dat met een gelijkteken. Om binair type 0bXXXX te gebruiken waarbij XXXX het binaire getal is. Eindig de regel met een puntkomma.
  6. Stel alle bits in zoals hierboven bepaald voor het OSCCON-register. Voorbeeld: OSCCONbits.IRCF = 0b101;
  7. Doe hetzelfde voor alle andere benodigde oscillatorregisters. Zie hieronder voor een voorbeeld van een voltooide ConfigureOscillator-functie.
  8. Als u klaar bent met bouwen en controleren op waarschuwingen / fouten

 / ** * Configureer de klokbron en snelheid * / void ConfigureOscillator (void) {OSCCONbits. IRCF = 0b101; OSCCONbits. SCS = 0b00; OSCTUNEbits. PLLEN = 0b1; } 

Stap 7: Wacht Milli-Second-functie

Een van de handigste functies is wait_ms. Dit is echter geen functie in de standaardbibliotheek en moet door u worden geprogrammeerd. Voor deze implementatie zal er een lus zijn die de processor vasthoudt totdat de gegeven tijd is verstreken.

PIC18F-microcontrollers hebben 4 klokcycli nodig om één regel montagecode uit te voeren. Daarom worden met een klok van 16 MHz lijnen uitgevoerd met 4 miljoen regels per seconde = 4000 regels per milliseconde. Aangezien een for-lus elke keer één instructie nodig heeft voor de vergelijking en twee voor de operatie één voor de body van de lus, zal het perfect werken. We hebben alleen de for-lus nodig om 1000 keer per milliseconde te herhalen.
  1. Maak in system.c een nieuwe functie onderaan het bestand van het type void wait_ms (uint16_t tijd)
  2. Hieronder is de voltooide functie
 / ** * Wacht een bepaald aantal milliseconden volgens het schema voor bezet wachten. * @param time - tijd in ms om te wachten. * / void wait_ms (uint16_t time) {statische lange tijd = 0; timel = tijd * 1000l; voor (; timel; timel -); // geen beginvoorwaarde, terwijl de tijd> 0 is, de tijd voor elke lus verlagen} 
  1. Open system.h in de map Header Files in de projectbrowser
  2. Voeg aan het einde de regel leegte wait_ms (uint16_t) toe; om de functie te prototypen.
  3. Wijzig lijn 8 van 8000000L in 16000000L
  4. Bouw en controleer op fouten / waarschuwingen

Stap 8: Knipper een LED

De beste manier om te testen of alles correct is ingesteld, is door een LED-lampje te laten knipperen. Als het lampje met de verwachte snelheid knippert, is alles correct geconfigureerd. In dit voorbeeld is de LED aangesloten op POORT A, Pin 0 (RA0 op het gegevensblad). Als je je LED op een andere pin hebt aangesloten, gebruik dan de juiste registers en bits.
  1. Open main.c in de projectviewer onder bronbestanden.
De functie void main (void) is het hoofdingangspunt van het programma. Wanneer de MCU voor het eerst wordt ingeschakeld, wordt deze functie geactiveerd. De eerste regel roept de ConfigureOscillator-functie op die u hebt ingevuld om de klokbron en -snelheid in te stellen. De volgende regel roept InitApp aan, een functie die we binnenkort zullen invullen, en uiteindelijk komt het in een oneindige lus. Aangezien er geen besturingssysteem is waarnaar de functie moet terugkeren, is er aan het einde geen retouroproep.
De voltooide functie zou er als volgt uit moeten zien:
  1. Voeg direct boven de while-lus de volgende code toe.
    1. Stel de LED-pin in als output - TRISAbits.TRISA0 = 0; // instellen van een TRIS-bit op 0 sets als uitvoer, instellen op 1 sets als invoer
  2. Voeg in de while-lus de volgende code toe
    1. Zet de LED op OFF - LATAbits.LATA0 = 0; // de LAT-bits besturen de uitvoer van een pin. 0 = LAAG, 1 = HOOG
    2. Wacht 1/2 seconde - wait_ms (500);
    3. Zet de LED op ON - LATAbits.LATA0 = 1;
    4. Wacht 1/2 seconde - wait_ms (500);
 void main (void) {/ * Configureer de oscillator voor het apparaat * / ConfigureOscillator (); / * Initialiseer I / O en randapparatuur voor toepassing * / InitApp (); TRISAbits.TRISA0 = 0; // stel pin in als output terwijl (1) {LATAbits.LATA0 = 0; // pin instellen LAAG wait_ms (500); // wacht 0, 5 seconden LATAbits.LATA0 = 1; // pin HIGH wait_ms (500) instellen; // wacht 0, 5 seconden}} 
  1. Bouw het programma en controleer op fouten of waarschuwingen
  2. Zorg ervoor dat de PICkit correct is aangesloten op de PIC en de computer
  3. Klik op de knop Apparaat maken en programmeren (de knop rechts van de knop Opschonen en bouwen)
  4. Selecteer desgevraagd PICkit 3 en klik op OK
  5. Wanneer de waarschuwing dubbele controle aangeeft, hebt u de juiste PIC in het circuit en klikt u op OK
  6. Als er een waarschuwing verschijnt over de doelapparaat-ID, klik dan op OK om deze te negeren

Stap 9: Een analoge waarde lezen

Tot dusver kan het programma een LED knipperen. Laten we het vervolgens wat gebruikersinvoer geven. We zullen een potentiometer gebruiken om een ​​analoog signaal te creëren dat de snelheid van de LED zal veranderen. De ADC neemt een analoge spanning aan en voert een digitale waarde uit.
  1. Open user.c in de projectbrowser onder Bronbestanden
  2. Maak boven de InitApp-functie een nieuwe functie void init_adc(void)
  3. Voer de volgende code in om de ADC-module te initialiseren
 / ** * Initialiseer de analoog-digitaalomzetter. * / void init_adc (void) {TRISAbits. TRISA1 = 0b1; // stel pin in als invoer ANCON0bits. ANSEL1 = 0b1; // stel pin in als analoge ADCON1bits. VCFG = 0b00; // set v + verwijzing naar Vdd ADCON1bits. VNCFG = 0b0; // set v- verwijzing naar GND ADCON1bits. CHSN = 0b000; // stel negatieve invoer in op GND ADCON2bits. ADFM = 0b1; // Rechtvaardig de uitvoer ADCON2bits. ACQT = 0b110; // 16 TAD ADCON2bits. ADCS = 0b101; // gebruik Fosc / 16 als klokbron ADCON0bits. ADON = 0b1; // zet de ADC aan} 
  1. Maak vervolgens direct na het uint16_t adc_convert(uint8_t channel) nog een functie
 / ** * Voer een analoog naar digitaal conversie uit. * @param channel Het ADC-ingangskanaal dat moet worden gebruikt. * @return De waarde van de conversie. * / uint16_t adc_convert (uint8_t kanaal) ADRESL; // retourneer het resultaat 
  1. Voeg in de InitApp-functie de regel init_adc()
  2. Voeg in het bestand user.h het prototype uint16_t adc_convert(uint8_t);
  3. Wijzig de hoofdtekst om het volgende te matchen:
 void main (void) {uint16_t adc_value; // variabele om het ADC-conversieresultaat vast te houden in / * Configureer de oscillator voor het apparaat * / ConfigureOscillator (); / * Initialiseer I / O en randapparatuur voor toepassing * / InitApp (); TRISAbits. TRISA0 = 0; // stel pin in als output terwijl (1) {LATAbits. LATA0 = 0; // set pin LAAG adc_value = adc_convert (1); // preform A / D-conversie op kanaal 1 wait_ms (adc_value>> 2); // wacht 0, 5 seconden LATAbits. LATA0 = 1; // set pin HIGH adc_value = adc_convert (1); // preform A / D-conversie op kanaal 1 wait_ms (adc_value>> 2); // wacht 0, 5 seconden}} 
  1. Bouw en download de code. Als u de POT draait, moet de snelheid van de knipperende LED veranderen

Stap 10: Lees een digitale waarde

Vervolgens krijgen we digitale invoer van de schakelaar. Als de schakelaar uit is, laten we het programma doen wat het al die tijd heeft gedaan, en als de schakelaar aan staat, zal het LED-lampje continu branden totdat de schakelaar weer wordt uitgeschakeld.
  1. Om een ​​pin als invoer in te stellen, schrijft u een 1 naar die TRIS registerbit - TRISAbits.TRISA2 = 1;
  2. Als een pin analoge functies deelt, kan het nodig zijn om deze op digitaal in te stellen door de juiste bit in het ANCONx-register te wissen
  3. Gebruik het LAT-register wanneer u een waarde naar een pin schrijft; gebruik bij het lezen van een waarde van een pin echter het PORT-register - value = PORTAbits.RA2;
  4. Verander hoofd naar het volgende:
 void main (void) {uint16_t adc_value; // variabele om het ADC-conversieresultaat vast te houden in / * Configureer de oscillator voor het apparaat * / ConfigureOscillator (); / * Initialiseer I / O en randapparatuur voor toepassing * / InitApp (); TRISAbits. TRISA0 = 0; // set pin als output TRISAbits. TRISA2 = 1; // stel pin in als invoer ANCON0bits. ANSEL2 = 0; // stel pin in als digitaal terwijl (1) {if (PORTAbits. RA2) // als de pin hoog is {LATAbits. LATA0 = 1; // stel de pin in als hoog} anders // als de pin laag is {// knippert de LED LATAbits. LATA0 = 0; // set pin LAAG adc_value = adc_convert (1); // preform A / D-conversie op kanaal 1 wait_ms (adc_value>> 2); // wacht enige tijd LATAbits. LATA0 = 1; // set pin HIGH adc_value = adc_convert (1); // preform A / D-conversie op kanaal 1 wait_ms (adc_value>> 2); // wacht even}}} 

Dat is het! Je hebt nu de basiskennis van het opzetten van een nieuw project, het lezen en schrijven naar digitale pinnen en het lezen van analoge pinnen. Met deze drie functies kunt u 90% van de projecten uitvoeren met behulp van PIC's op internet. Als u doorgaat met uw onderzoek naar PIC-microcontrollers, zult u ook merken dat de meeste andere functies zeer vergelijkbare stappen vereisen om randapparatuur te configureren en lees en recht op registers.

Verwante Artikelen