Programmazione di microcontrollori PIC

I microcontrollori PIC sono uno strumento molto utile e versatile per l'uso in molti progetti elettronici. Sono molto economici e facili da trovare. Sono anche molto potenti e molti sono in grado di velocità fino a 64 MIPS utilizzando il blocco oscillatore interno, circa 16 volte più veloce della maggior parte dei microcontrollori AVR comparabili. I PIC sono anche facili da programmare, tuttavia a volte impostare il progetto può essere complicato. Queste istruzioni illustreranno il processo di installazione del software, la creazione di un nuovo progetto e la programmazione di alcune funzioni molto semplici per testare la configurazione e garantire che tutto funzioni. Sono progettati per essere molto aperti; dopo che il progetto è stato creato e le basi sono terminate, il lettore è incoraggiato a esplorare tutte le funzionalità e gli extra non trattati in queste istruzioni. Scoprirai inoltre che queste istruzioni inizieranno a camminare passo dopo passo, ma poiché le istruzioni verso la fine il lettore è incoraggiato a esplorare altri modi per svolgere i compiti e rendere il progetto proprio.

Cosa ti servirà Per costruire un progetto con un microcontrollore PIC sono necessari solo pochi elementi.

  • Microcontrollore PIC
    • Queste istruzioni sono per la programmazione di un MCU serie PIC18F, sebbene altri siano simili.
    • Ottenuto dal sito Web di Microchips.
    • Microchip consente agli studenti con indirizzi e-mail validi .edu di esempio PIC gratuiti!
    • Il PIC che sto usando per creare queste istruzioni è un PIC18F22K80
  • Debugger in-circuit di PICkit 3
    • Disponibile da Microchip.
    • Costa $ 45 per il grande pubblico e # 34 con lo sconto per studenti se hai un indirizzo email .edu.
    • Ci sono anche altri programmatori che funzioneranno altrettanto bene; tuttavia, questo è il migliore per iniziare.
  • Fili per tagliere e taglieri
  • LED, pulsanti, potenziometri o qualsiasi altra cosa che si desidera collegare al PIC

Passaggio 1: costruire l'hardware

Prima di eseguire qualsiasi programmazione, il primo passo è costruire l'hardware. Sebbene il portafoglio PIC18F sia molto ampio, molti chip hanno molti punti in comune. Per informazioni più dettagliate, consultare la sezione "Linee guida per iniziare con i microcontrollori PIC18Fxxxx" nel foglio dati dei dispositivi. Per i pin-out dettagliati del microcontrollore PIC, consultare la sezione "Diagramma dei pin" nel foglio dati del dispositivo.

Nota: VDD = Tensione positiva e VSS = Terra.
  1. Collegare il pin MCLR tramite una resistenza da 1kΩ a VDD.
  2. Collegare un condensatore da 0, 1 μF tra ogni coppia di coppie VDD-VSS adiacenti o coppie AVDD-AVSS.
  3. Collegare un condensatore da 10μF tra VCAP e Vss.
  4. Collegare il pin MCLR al pin 1 di PICkit 3.
  5. Collegare VDD al pin 2 di PICkit 3.
  6. Collegare VSS al pin 3 di PICkit 3.
  7. Collegare il pin PGD al pin 4 di PICkit 3.
  8. Collegare il pin PGC al pin 5 di PICkit 3.
  9. Lasciare scollegato il pin 6 di PICkit 3.
  10. Collegare eventuali ingressi analogici ai pin con funzionalità ANx in cui x è un numero.
  11. Collegare eventuali ingressi o uscite digitali ai pin con funzionalità Rxy in cui x è una lettera che identifica la porta e y è un numero che identifica il bit.
Per il mio esempio ho un LED collegato tra RA0 e terra, il tergicristallo di un potenziometro collegato a AN1 e un interruttore DPST collegato a RA2. Potresti trovare più facile programmare il PIC se hai tracciato uno schema del tuo circuito.

Passaggio 2: scarica il software

Queste istruzioni utilizzeranno il compilatore XC8 e l'IDE MPLAB X di Microchip. Questo passaggio spiegherà come ottenere questi strumenti e garantire che siano stati installati correttamente.
  1. Per ottenere l'ultima versione del software, visitare il sito Web di Microchips all'indirizzo //www.microchip.com/pagehandler/en-us/family/mplabx/
  2. Seleziona il software per il tuo sistema operativo e segui le istruzioni di installazione standard.
Nota: se si utilizza Windows 8, potrebbe essere necessario eseguire i programmi di installazione in modalità compatibilità per Windows 7.
  1. Una volta installato il software, avviare MPLAB X
  2. Nella barra dei menu seleziona Strumenti-> Opzioni
  3. Nella finestra di dialogo Opzioni selezionare la scheda Incorporato e assicurarsi che XC8 sia elencato nell'elenco Toolchain.
  4. Se è elencato, seleziona OK e vai al passaggio successivo.
  5. Se non è elencato, assicurarsi che l'installazione sia stata completata e fare clic sul pulsante Cerca strumenti di costruzione.
  6. Se ancora non elencato, cerca nel forum Microchips per assistenza con il tuo problema specifico.

Passaggio 3: creare un nuovo progetto

In questo passaggio creeremo un nuovo progetto basato su un modello di Microchip.
  1. Nella barra dei menu selezionare File-> Nuovo progetto ...
  2. Nella finestra di dialogo Nuovo file espandi Esempi e seleziona Microchip Embedded
  3. Nella casella progetto selezionare Modello C PIC18
  4. Seleziona Avanti
  5. Dai al progetto il nome che preferisci
  6. Scegliere una posizione in cui salvare il progetto nella casella Posizione progetto
  7. Lascia la cartella del progetto come opzioni predefinite
  8. Seleziona la casella "Imposta come progetto principale"
  9. Seleziona Fine
Il progetto verrà ora visualizzato in Esplora progetto sul lato sinistro dello schermo.

Passaggio 4: costruire parametri

Prima di poter iniziare la programmazione, dobbiamo impostare i parametri di compilazione.
Crea configurazione
  1. Fare clic con il tasto destro sul nome del progetto nella barra degli strumenti dei progetti.
  2. Nella finestra di dialogo Proprietà progetto selezionare Gestisci configurazioni ...
  3. Nella finestra di dialogo Configurazioni selezionare Nuovo
  4. Nella finestra di dialogo Nuovo nome configurazione immettere Predefinito e fare clic su OK
  5. Nella finestra di dialogo Configurazioni assicurarsi che Predefinito sia selezionato e fare clic su Imposta attivo
  6. Fai clic su OK nella finestra di dialogo Configurazioni
Imposta proprietà di configurazione
  1. Nella finestra di dialogo Proprietà progetto selezionare "Conf: [Default]" nell'elenco Categorie
    1. Nella casella Dispositivo digitare il nome del dispositivo che si sta utilizzando. Nel mio caso PIC18F26K80
    2. Nell'elenco Strumenti hardware selezionare PICkit3
    3. Nella toolchain del compilatore selezionare XC8 (v ...) Where ... è la versione installata.
    4. Seleziona Applica
  2. In Conf: [Default] selezionare PICkit 3
    1. Per le categorie di Opzioni selezionare Potenza
    2. Controllare "Power target circuit from PICkit3
    3. Seleziona Applica.
  3. In Conf: [Predefinito] selezionare il compilatore XC8
    1. Per le categorie di opzioni selezionare Ottimizzazioni
    2. Impostare "Set di ottimizzazione" su "nessuno"
    3. Seleziona Applica
  4. Fare clic su OK per chiudere la finestra di dialogo
Prova la configurazione Per provare la configurazione fai clic sul pulsante clean and build (quello con il martello e la scopa). Il testo inizierà a scorrere nella finestra di output nella parte inferiore della pagina. Se tutto ha successo, questo testo dirà COSTRUIRE SUCCESSO (tempo totale: ...) . Se ricevi un errore, torna indietro attraverso questo passaggio assicurandoti di non aver perso nulla e che tutto sia stato applicato.

Passaggio 5: impostare i bit di configurazione

Il prossimo passo è impostare i bit di configurazione. I bit di configurazione indicano all'MCU le sue condizioni iniziali per l'accensione. Sono utilizzati per impostare l'origine e la velocità dell'orologio, la configurazione dell'ora del watchdog e altre funzioni simili. I bit di configurazione dipendono dal dispositivo, quindi controllare la scheda tecnica del chip in uso per ulteriori informazioni.
  1. In Esplora progetti espandere File di origine e aprire configuration_bits.c
  2. Rimuovi tutto il testo sotto la riga #endif
  3. Si noti che è stata aperta una nuova scheda nella parte inferiore dello schermo
  4. Imposta i bit come necessario per il tuo progetto. Poiché questi dipendono dal chip, controlla la scheda tecnica per ulteriori informazioni su ciò che ciascuno di essi fa. Seguono alcune impostazioni comuni:
    1. Set di istruzioni esteso: deve essere impostato su OFF quando si utilizza il modello
    2. Oscillatore: utilizzato per selezionare il processore. A meno che non si utilizzi un cristallo esterno, lasciare impostato come oscillatore RC interno. Vedere la scheda tecnica per altre configurazioni dell'oscillatore. Nota: CLKOUT consentirà un debug più semplice e dovrebbe essere attivato se disponibile.
    3. Abilita PLL: consentirà l'utilizzo futuro del PLL. Nota: questo non accenderà il PLL, lo abiliterà solo. Si consiglia di abilitarlo.
    4. Timer watchdog: il timer watch dog viene utilizzato per garantire che il processore non si blocchi. Tuttavia, rende molto più difficile il debug. Si consiglia di disabilitarlo durante la programmazione iniziale e di abilitarlo solo dopo che il progetto è quasi terminato.
    5. Proteggi da scrittura / lettura codice / tabella - Utilizzato per disabilitare la scrittura o la lettura in determinati intervalli di memoria. Lascia tutti disabilitati.
    6. In caso di dubbi su un'impostazione, in genere è sicuro lasciarlo predefinito.
  5. Dopo aver impostato tutti i bit di configurazione, fare clic sul pulsante "Genera codice sorgente in uscita" nella parte inferiore del pannello.
  6. Il pannello ora passerà alla scheda Output. Seleziona tutto il testo in questa scheda e copialo negli appunti
  7. Incollalo nella parte inferiore del file configuration_bits.c e salva pres.
  8. Pulisci e costruisci di nuovo il progetto facendo clic sull'icona scopa e martello.
  9. Assicurarsi che la compilazione abbia avuto esito positivo. Verificare inoltre che non vi siano errori nell'output
Se tutto ha funzionato, passa al passaggio successivo. In caso di errori o avvisi, risolverli prima di proseguire.

Passaggio 6: configurare l'oscillatore

Il prossimo passo è iniziare la programmazione; tuttavia, prima di arrivare al codice dell'applicazione, è necessario programmare il codice di sistema. Il codice di sistema sono le funzioni di basso livello come la configurazione dell'oscillatore e le funzioni di ritardo di base.

Determinazione delle impostazioni

Prima di poter programmare le impostazioni, dobbiamo scegliere a quale velocità vorremmo correre. Per questo esempio userò 16MHz poiché la maggior parte dei PIC può funzionare a questa velocità. Per la mia configurazione userò il postscaller a 4MHz dell'HF-INTOSC e il PLL 4x con una frequenza di uscita di 4MHz * 4x = 16MHz
  1. Nella scheda tecnica trova la sezione Configurazioni dell'oscillatore
  2. La prima cosa elencata in questa sezione è Tipi di oscillatori. Se si utilizza l'oscillatore interno, utilizzare le impostazioni relative a INTIO1
  3. Nella pagina o nelle pagine successive troverai un disegno schematico dell'oscillatore simile a quello mostrato. È utile tracciare il segnale su questo disegno per assicurarsi che sia selezionata la velocità corretta.
  4. Il prossimo passo è programmare queste impostazioni sull'MCU. Questo viene fatto impostando i registri. Il primo registro da impostare è OSCCON.
    1. IDLEN - usato per controllare l'azione del comando sleep. Può essere lasciato come predefinito.
    2. IRCF - Selezione dell'oscillatore. Dal momento che sto usando HF-INTOSC / 4 (4MHz) dovrò impostarlo su un valore binario di 101
    3. OSTS - Bit di sola lettura
    4. HFIOFS - Bit di sola lettura
    5. SCS - bit di selezione dell'orologio. Dal momento che sto usando l'oscillatore interno, imposterò su 1x dove x può essere 0 o 1
  5. Il prossimo registro è OSCCON2; tuttavia, questo registro è per lo più di sola lettura e non è importante a questo punto
  6. L'ultimo registro di configurazione dell'oscillatore è OSCTUNE. Non sintonizzeremo la frequenza per questo progetto, tuttavia dobbiamo usare questo registro per attivare il PLL usando il bit PLLEN.

Applicazione delle impostazioni

  1. Ritorna a MPLAB
  2. Nell'esploratore del progetto in File di origine aprire system.c
  3. Nella parte inferiore di questo file si trova la funzione ConfigureOscillator. Rimuovi i commenti in quella funzione.
  4. Per impostare i bit di un tipo di registro in tutte le maiuscole, il nome del registro, seguito dai bit della parola minuscola e quindi da un punto e dal nome del bit.
  5. Per impostare i bit segui quello con un segno di uguale. Per utilizzare il tipo binario 0bXXXX dove XXXX è il numero binario. Infine, termina la linea con un punto e virgola.
  6. Impostare tutti i bit come sopra determinato per il registro OSCCON. Esempio: OSCCONbits.IRCF = 0b101;
  7. Fare lo stesso per tutti gli altri registri oscillatori necessari. Vedi sotto per un esempio di una funzione ConfigureOscillator terminata.
  8. Al termine compilare e verificare la presenza di avvisi / errori

 / ** * Configura l'origine e la velocità del clock * / void ConfigureOscillator (void) {OSCCONbits. IRCF = 0b101; OSCCONbits. SCS = 0b00; OSCTUNEbits. PLLEN = 0b1; } 

Passaggio 7: attendere la funzione Milli-Second

Una delle funzioni più utili è wait_ms. Questa tuttavia non è una funzione nella libreria standard e dovrà essere programmata da te. Per questa implementazione ci sarà un ciclo che conterrà il processore fino a quando non sarà trascorso il tempo indicato.

I microcontrollori PIC18F richiedono 4 cicli di clock per eseguire una riga di codice assembly. Pertanto, con un clock di 16 MHz, le linee verranno eseguite a 4 milioni di linee al secondo = 4000 linee al milli-secondo. Poiché un ciclo for prenderà un'istruzione ogni volta per il confronto e due per l'operazione uno per il corpo del loop, funzionerà perfettamente. Abbiamo solo bisogno del loop for per loop 1000 volte al milli-secondo.
  1. In system.c crea una nuova funzione nella parte inferiore del file di tipo void wait_ms (uint16_t time)
  2. Di seguito è la funzione completata
 / ** * Attendere un determinato numero di milli-secondi utilizzando lo schema di attesa occupato. * @param time - tempo in ms per l'attesa. * / void wait_ms (uint16_t time) {tempo lungo statico = 0; timel = time * 1000l; per (; timel; timel -); // nessuna condizione iniziale, mentre il tempo è> 0, decrementa ogni ciclo} 
  1. Aprire system.h nella cartella File di intestazione nel browser del progetto
  2. Alla fine aggiungi la riga void wait_ms (uint16_t); per prototipare la funzione.
  3. Cambia la riga 8 da 8000000L a 16000000L
  4. Costruire e verificare errori / avvisi

Passaggio 8: lampeggiare un LED

Il modo migliore per verificare che tutto sia impostato correttamente è far lampeggiare una luce a LED. Se la luce lampeggia alla velocità prevista, tutto è stato configurato correttamente. In questo esempio il LED è collegato alla PORTA A, Pin 0 (RA0 sul foglio dati). Se il LED è collegato a un pin diverso, utilizzare i registri e i bit appropriati.
  1. Apri main.c nel visualizzatore di progetti sotto i file di origine.
La funzione void main (void) è il punto di ingresso principale del programma. Quando l'MCU si accende per la prima volta, entra in questa funzione. La prima riga chiama la funzione ConfigureOscillator che hai inserito per impostare l'orologio e la velocità. La riga successiva chiama InitApp, una funzione che completeremo a breve e infine entra in un ciclo infinito. Poiché non esiste un sistema operativo per il ritorno della funzione, alla fine non è presente alcuna chiamata di ritorno.
La funzione finita dovrebbe apparire così:
  1. Immediatamente sopra il ciclo while aggiungere il seguente codice.
    1. Imposta il pin LED come uscita - TRISAbits.TRISA0 = 0; // l'impostazione di un bit TRIS su 0 imposta come output, l'impostazione su 1 imposta come input
  2. All'interno del ciclo while aggiungi il seguente codice
    1. Impostare il LED su OFF - LATAbits.LATA0 = 0; // i bit LAT controllano l'uscita di un pin. 0 = BASSO, 1 = ALTO
    2. Attendere 1/2 secondo - wait_ms (500);
    3. Impostare il LED su ON - LATAbits.LATA0 = 1;
    4. Attendere 1/2 secondo - wait_ms (500);
 void main (void) {/ * Configura l'oscillatore per il dispositivo * / ConfigureOscillator (); / * Inizializza I / O e periferiche per l'applicazione * / InitApp (); TRISAbits.TRISA0 = 0; // imposta il pin come output while (1) {LATAbits.LATA0 = 0; // imposta il pin LOW wait_ms (500); // aspetta 0, 5 secondi LATAbits.LATA0 = 1; // imposta il pin HIGH wait_ms (500); // attendi 0, 5 secondi}} 
  1. Compilare il programma e verificare la presenza di errori o avvisi
  2. Assicurarsi che PICkit sia collegato correttamente al PIC e al computer
  3. Fai clic sul pulsante Crea e programma dispositivo (il pulsante a destra del pulsante Pulisci e crea)
  4. Se richiesto, selezionare PICkit 3 e fare clic su OK
  5. Quando l'avviso mostra un doppio controllo, hai il PIC corretto nel circuito e fai clic su OK
  6. Se viene visualizzato un avviso sull'ID dispositivo di destinazione, fare clic su OK per ignorarlo

Passaggio 9: lettura di un valore analogico

Finora il programma può far lampeggiare un LED. Successivamente, diamo un input all'utente. Useremo un potenziometro per creare un segnale analogico che cambierà la velocità del LED. L'ADC prende una tensione analogica ed emette un valore digitale.
  1. Nel browser del progetto, aprire user.c in File di origine
  2. Sopra la funzione InitApp creare una nuova funzione void init_adc(void)
  3. Immettere il codice seguente per inizializzare il modulo ADC
 / ** * Inizializza il convertitore da analogico a digitale. * / void init_adc (void) {TRISAbits. TRISA1 = 0b1; // imposta il pin come input ANCON0bits. ANSEL1 = 0b1; // imposta il pin come ADCON1bits analogico. VCFG = 0b00; // imposta v + riferimento a Vdd ADCON1bits. VNCFG = 0b0; // imposta il riferimento v su GND ADCON1bits. CHSN = 0b000; // imposta l'input negativo su GND ADCON2bits. ADFM = 0b1; // right giustifica l'output ADCON2bits. ACQT = 0b110; // 16 TAD ADCON2bits. ADCS = 0b101; // usa Fosc / 16 per l'orologio ADCON0bits. ADON = 0b1; // attiva ADC} 
  1. Quindi crea un'altra funzione immediatamente dopo chiamata uint16_t adc_convert(uint8_t channel)
 / ** * Preforma una conversione da analogico a digitale. * @param channel Il canale di ingresso ADC da utilizzare. * @return Il valore della conversione. * / uint16_t adc_convert (canale uint8_t) ADRESL; // restituisce il risultato 
  1. Nella funzione InitApp aggiungi la riga init_adc()
  2. Nel file user.h aggiungi il prototipo uint16_t adc_convert(uint8_t);
  3. Cambia main in modo che corrisponda a quanto segue:
 void main (void) {uint16_t adc_value; // variabile per contenere il risultato della conversione ADC in / * Configura l'oscillatore per il dispositivo * / ConfigureOscillator (); / * Inizializza I / O e periferiche per l'applicazione * / InitApp (); TRISAbits. TRISA0 = 0; // imposta il pin come output while (1) {LATAbits. LATA0 = 0; // imposta il pin LOW adc_value = adc_convert (1); // preforma conversione A / D sul canale 1 wait_ms (adc_value>> 2); // aspetta 0, 5 secondi LATAbits. LATA0 = 1; // imposta il pin ALTO adc_value = adc_convert (1); // preforma conversione A / D sul canale 1 wait_ms (adc_value>> 2); // attendi 0, 5 secondi}} 
  1. Compilare e scaricare il codice. Quando si gira il POT, la velocità del LED lampeggiante dovrebbe cambiare

Passaggio 10: leggere un valore digitale

Successivamente consente di ottenere l'ingresso digitale dallo switch. Quando l'interruttore è spento, il programma farà ciò che ha sempre fatto, e quando l'interruttore è acceso, il LED si accende fino a quando l'interruttore non viene nuovamente spento.
  1. Per impostare un pin come input, scrivere un 1 su quel bit Registro TRIS bit - TRISAbits.TRISA2 = 1;
  2. Se un pin condivide funzionalità analogiche, potrebbe essere necessario impostarlo su digitale cancellando il bit appropriato nel registro ANCONx
  3. Quando si scrive un valore su un pin, utilizzare il registro LAT; tuttavia, quando leggi un valore da un pin usa il registro PORT - value = PORTAbits.RA2;
  4. Cambia principale in quanto segue:
 void main (void) {uint16_t adc_value; // variabile per contenere il risultato della conversione ADC in / * Configura l'oscillatore per il dispositivo * / ConfigureOscillator (); / * Inizializza I / O e periferiche per l'applicazione * / InitApp (); TRISAbits. TRISA0 = 0; // imposta il pin come uscita TRISAbits. TRISA2 = 1; // imposta il pin come input ANCON0bits. ANSEL2 = 0; // imposta il pin come digitale while (1) {if (PORTAbits. RA2) // se il pin è alto {LATAbits. LATA0 = 1; // imposta il pin come alto} altrimenti // se il pin è basso {// lampeggia i LED LATAbits. LATA0 = 0; // imposta il pin LOW adc_value = adc_convert (1); // preforma conversione A / D sul canale 1 wait_ms (adc_value>> 2); // aspetta un po 'di tempo LATAbits. LATA0 = 1; // imposta il pin ALTO adc_value = adc_convert (1); // preforma conversione A / D sul canale 1 wait_ms (adc_value>> 2); // aspetta un po '}}} 

Questo è tutto! Ora hai le conoscenze di base su come impostare un nuovo progetto, leggere e scrivere su pin digitali e come leggere da pin analogici. Queste tre funzionalità ti permetteranno di eseguire il 90% dei progetti utilizzando PIC su Internet. Inoltre, mentre continui l'esplorazione dei microcontrollori PIC, scoprirai che la maggior parte delle altre funzionalità richiede passaggi molto simili per configurare le periferiche e leggere e accedere ai registri.

Articoli Correlati