Introduzione all’ambiente di sviluppo MPLAB X IDE, al compilatore XC8 per microcontrollori ad 8-bit ed al programmatore PICkit3.

 

 

 

 

 

INTRODUZIONE
In questa guida viene presentata un’introduzione all’uso dell’ambiente di sviluppo ufficiale Microchip, MPLAB X IDE, e del programmatore della casa madre, il PICkit3. Vengono riportate le istruzioni per installare e poter utilizzare MPLAB X IDE in combinazione con il compilatore XC8, un semplice codice di esempio di un lampeggiatore LED e le istruzioni per utilizzare il PICkit3 ed eseguire la programmazione di un PIC18F252.
Non viene riportata una spiegazione della struttura interna di un PICmicro e dei suoi blocchi, per la quale si rimanda a “Guida alla Programmazione in C del PIC, 1° Parte”.

AMBIENTE DI SVILUPPO – MPLAB X IDE
L’ambiente di sviluppo ufficiale Microchip è MPLAB X IDE, che supporta tutti i microcontrollori PICmicro, sia le versioni ad 8-bit (famiglie PIC10, PIC12, PIC16 e PIC18), a 16-bit (famiglia PIC24) che a 32-bit (famiglia PIC32), ed anche i Digital Signal Controller dsPIC. Inoltre, a partire dalla versione MPLAB X IDE v 5.00 è possibile utilizzare i microcontrollori AVR.
MPLAB X è gratuito ed è scaricabile dal sito Microchip. Una volta scaricato ed eseguito il file .exe si avvierà la procedura di installazione e compariranno una serie di messaggi, uno dei quali per la scelta dei tool da installare: selezionare sia MPLAB X IDE che MPLAB X IPE.

COMPILATORE – XC8
Una volta installato l’ambiente di sviluppo è necessario scaricare il compilatore C. Infatti, se si prova a creare un progetto sarà possibile scegliere esclusivamente il compilatore MPASM installato insieme a MPLAB X IDE e che permette di scrivere codici in Assembler.

Il compilatore da utilizzare per poter programmare PICmicro a 8-bit è XC8, anch’esso scaricabile gratuitamente (nella versione limitata) dal sito Microchip. Una volta scaricato ed eseguito parte l’installazione, al termine della quale viene chiesto di inserire il codice per attivare la licenza e non avere limitazioni. Per utilizzare la versione free è sufficiente premere “Cancel”.
Durante il settaggio delle impostazioni di installazione mettere la spunta su “Add xc8 to the PATH environment variable”. Se l’installazione è andata a buon fine, provando a creare un nuovo progetto si potrà scegliere anche il compilatore XC8:

È possibile installare più versioni di compilatore XC8 (in questo caso v1.45) e scegliere quale usare durante la creazione di un nuovo progetto. È possibile scegliere una diversa versione anche ad un progetto creato in precedenza e che utilizza una versione più datata di XC8. Per fare questo selezionare la cartella nella scheda Project, tasto destro e scegliere Properties. Nella Compiler Toolchain a destra scegliere la versione desiderata di XC8.

   

CODICE ESEMPIO – LAMPEGGIO LED
A questo punto è possibile scrivere il codice. Come esempio si realizza un semplice lampeggio LED con frequenza 1 Hz, il cui schema elettrico è riportato sotto:

• 

I pin 8 e 19 vanno connessi a VSS, il pin 20 a VDD.
Il resistore di pull-up R1 da 10 k\(\Omega\) permette di non portare il microcontrollore in reset. I resistori da 330 \(\Omega\) servono a limitare la corrente che scorre nei diodi LED. 
Il quarzo da 8 MHz insieme ai due condensatori da 22 pF realizzano l’oscillatore necessario per generare il segnale di clock che scandisce le varie operazioni del microcontrollore.

Per realizzare il progetto bisogna:

1. Selezionare File >> New Project
2. Scegliere Microchip Embedded
3. Scegliere il microcontrollore, in questo caso PIC18F252
4. Selezionare il programmatore, in questo caso PICkit3 (il tipo di programmatore può essere cambiato anche successivamente)
5. Scegliere il compilatore, in questo caso XC8 (la versione del compilatore può essere cambiata anche successivamente)
6. Dare un nome al progetto

A questo punto si torna alla schermata principale di MPLAB X IDE e in alto a sinistra nella scheda Projects comparirà il progetto appena creato. Ora vanno creati due file, un file main.c ed un file header.h.
I file.c contengono le istruzioni che vengono compilate e inserite nel file .hex che viene caricato sul microcontrollore. Il file main.c costituisce il file principale e deve sempre essere presente.
Per creare il file main.c selezionare Source Files, tasto destro e selezionare New >> main.c

Compare una finestra in cui va specificato il nome main.c.

I file .h possono contenere variabili, define e le configurazioni dei registri. Per creare il file header selezionare Header Files, tasto destro e selezionare New >> xc8_header.h

Compare una finestra in cui va specificato il nome, per esempio config.h.

Header File
Il file config.h appena creato contiene una serie di scritte commentate (per commentare una riga si usa //, mentre per commentare una porzione di testo su una o più righe si usa /* all’inizio e */ alla fine).
In questo caso il testo generato durante la creazione del file.h non serve e va cancellato interamente. Dalla toolbar selezionare Window >> Target Memory Views >> Configuration Bits:

Viene aperta in basso a destra una finestra con un menu a tendina per ogni registro del microcontrollore. Per impostare correttamente i registri bisogna consultare il datasheet.
Le prime due voci sono relative all’oscillatore che in questo caso sarà un oscillatore esterno al quarzo da 8 MHz. Andando sul datasheet del PIC18F252 si trova, relativamente all’oscillatore, la seguente tabella:

in cui si nota che la modalità da usare per un quarzo da 8 MHz è HS, per cui nel menu a tendina alla voce OSC si seleziona HS. Per la seconda voce relativa all’oscillatore, cioè OSCS, si può scegliere OFF in quanto non serve la possibilità di switching.
Per le voci Power-Up Time (PWRT), Brown-out Reset (BOR) Watch Dog Timer (WDT) e Stack Full/Underflow Reset Enable (STVR) selezionare OFF poiché al momento non sono richieste.
Infine, alla voce Low Power ICSP Enable bit (LVP) selezionare OFF altrimenti la programmazione fallirà.
Per tutte le voci in cui compare la parola protection selezionare OFF altrimenti il microcontrollore non potrà più essere riprogrammato.
Ricapitolando si deve avere una cosa del genere:

È ora possibile generare il codice relativo ai Configuration Bits premendo il tasto Generate Source Code to Output. Comparirà una nuova scheda in basso chiamata Output – Config Bits Source, selezionare tutto il testo, copiarlo e incollarlo nel file config.h. Cancellare l’ultima riga contente #include <xc.h> in quanto già contenuta nel main.c.
A questo punto rimane solamente da aggiungere una riga che definisce la frequenza dell’oscillatore, in questo caso 8 MHz. Per farlo basta scrivere:

#define _XTAL_FREQ 8000000

Il file config.h è ora terminato ed appare così:

 #define _XTAL_FREQ 8000000  

// PIC18F252 Configuration Bit Settings 
// 'C' source line config statements 

// CONFIG1H 
#pragma config OSC = HS         // Oscillator Selection bits (HS oscillator) 
#pragma config OSCS = OFF       // Oscillator System Clock Switch Enable bit (Oscillator system clock switch option is disabled (main oscillator is source)) 

// CONFIG2L 
#pragma config PWRT = OFF       // Power-up Timer Enable bit (PWRT disabled) 
#pragma config BOR = OFF        // Brown-out Reset Enable bit (Brown-out Reset disabled) 
#pragma config BORV = 20        // Brown-out Reset Voltage bits (VBOR set to 2.0V) 

// CONFIG2H 
#pragma config WDT = OFF        // Watchdog Timer Enable bit (WDT disabled (control is placed on the SWDTEN bit)) 
#pragma config WDTPS = 128      // Watchdog Timer Postscale Select bits (1:128) 

// CONFIG3H 
#pragma config CCP2MUX = OFF    // CCP2 Mux bit (CCP2 input/output is multiplexed with RB3) 

// CONFIG4L 
#pragma config STVR = OFF       // Stack Full/Underflow Reset Enable bit (Stack Full/Underflow will not cause RESET) 
#pragma config LVP = OFF        // Low Voltage ICSP Enable bit (Low Voltage ICSP disabled) 

// CONFIG5L 
#pragma config CP0 = OFF        // Code Protection bit (Block 0 (000200-001FFFh) not code protected) 
#pragma config CP1 = OFF        // Code Protection bit (Block 1 (002000-003FFFh) not code protected) 
#pragma config CP2 = OFF        // Code Protection bit (Block 2 (004000-005FFFh) not code protected) 
#pragma config CP3 = OFF        // Code Protection bit (Block 3 (006000-007FFFh) not code protected) 

// CONFIG5H 
#pragma config CPB = OFF        // Boot Block Code Protection bit (Boot Block (000000-0001FFh) not code protected) 
#pragma config CPD = OFF        // Data EEPROM Code Protection bit (Data EEPROM not code protected) 

// CONFIG6L 
#pragma config WRT0 = OFF       // Write Protection bit (Block 0 (000200-001FFFh) not write protected) 
#pragma config WRT1 = OFF       // Write Protection bit (Block 1 (002000-003FFFh) not write protected) 
#pragma config WRT2 = OFF       // Write Protection bit (Block 2 (004000-005FFFh) not write protected) 
#pragma config WRT3 = OFF       // Write Protection bit (Block 3 (006000-007FFFh) not write protected) 

// CONFIG6H 
#pragma config WRTC = OFF       // Configuration Register Write Protection bit (Configuration registers (300000-3000FFh) not write protected) 
#pragma config WRTB = OFF       // Boot Block Write Protection bit (Boot Block (000000-0001FFh) not write protected) 
#pragma config WRTD = OFF       // Data EEPROM Write Protection bit (Data EEPROM not write protected) 

// CONFIG7L 
#pragma config EBTR0 = OFF      // Table Read Protection bit (Block 0 (000200-001FFFh) not protected from Table Reads executed in other blocks) 
#pragma config EBTR1 = OFF      // Table Read Protection bit (Block 1 (002000-003FFFh) not protected from Table Reads executed in other blocks) 
#pragma config EBTR2 = OFF      // Table Read Protection bit (Block 2 (004000-005FFFh) not protected from Table Reads executed in other blocks) 
#pragma config EBTR3 = OFF      // Table Read Protection bit (Block 3 (006000-007FFFh) not protected from Table Reads executed in other blocks) 

// CONFIG7H 
#pragma config EBTRB = OFF      // Boot Block Table Read Protection bit (Boot Block (000000-0001FFh) not protected from Table Reads executed in other blocks) 

// #pragma config statements should precede project file includes. 
// Use project enums instead of #define for ON and OFF. 

Source File
Si può ora passare a file main.c precedentemente creato, che conterrà un commento con nome del file, autore e data di creazione. Compare anche una riga con un include che contiene le informazioni relative al microcontrollore necessarie al compilatore. Subito dopo compare la funzione main:

Per prima cosa va aggiunto, tramite #include, il file config.h. Poiché si sta aggiungendo un file creato dall’utente si devono usare gli apici “” e non <>:

#include "config.h"

Si crea ora una funzione, per esempio chiamata CFG_Init, contente le inizializzazioni relative alla direzione e allo stato dei pin. Questa funzione non è necessaria e la porzione di codice può essere inserita nel main prima del ciclo while; tuttavia permette di avere maggior ordine e trovare più facilmente la configurazione di porte e periferiche del microcontrollore se ci si trova a lavorare con codici più lunghi.

void CFG_Init(void){
   TRISAbits.TRISA0 = 0;       // PIN TRISA0 impostato come uscita
   TRISB = 0b11011111;         // PIN TRISB5 impostato come uscita
   TRISC = 0b00000000;         // PIN TRISC  impostati come uscite

   LATA = 0b00000000;
   LATB = 0b00000000;
   LATC = 0b00000000;
 }

Il registro TRISx imposta la direzione del I/O pin, cioè lo setta come input o output. I pin non utilizzati di TRISB vengono settati come input così da evitare che vengano attraversati da correnti eccessive in caso di cortocircuiti accidentali. Stessa cosa andrebbe fatta per il TRISA ma in questo caso viene impostato un solo pin per mostrare la validità di quest’altra modalità di settaggio.          
I registri PORTx e LATx permettono di leggere o scrivere un dato sul rispettivo pin a seconda se il registro TRISx impone quel dato pin come ingresso o uscita. Nella documentazione ufficiale Microchip relativa alla famiglia 18F (PICmicro 18C MCU Family Reference Manual) si trova che i due registri funzionano in maniera differente. In lettura il registro LATx permette di leggere lo stato sul data latch che potrebbe essere diverso dallo stato del pin, mentre il registro PORTx permette di leggere lo stato effettivo del pin. Quindi per la lettura dello stato di un pin va usato il registro PORTx. In scrittura invece, come riportato nella documentazione Microchip, è preferibile usare il registro LATx che permette di evitare problemi legati ad operazioni Read-Modify-Write. Sia per il registro LATx che PORTx porre un bit a 0 o 1 impone un valore 0 o 1 sul rispettivo pin.

Nel caso di PICmicro non della famiglia 18F ma sempre ad 8 bit, cioè i PIC16F o i PIC12F, non esistono i registri LATx, quindi si usa PORTx sia in lettura che scrittura.

Per agire su tutti i bit di un registro si usa:

TRISA = 0b00000000;        //tutti i bit di TRISA sono settati come Output      - Notazione binaria  
LATA  = 255;               //tutti i bit di LATA sono settati come uscite alte  – Notazione decimale 
LATA  = 0x00;              //tutti i bit di LATA sono settati come uscite basse – Notazione esadecimale

Se si vuole agire su un solo bit si usa:

TRISAbits.TRISA1 = 0;       //bit 1 di TRISA settato come Output
LATAbits.LATA1 = 0;         //bit 1 di LATA settato come uscita bassa
PORTBbits.RB1 = 1;          //bit 1 di PORTA settato come uscita alta

Ora si passa alla funzione main, nella quale prima si aggiunge la chiamata alla funzione CFG_Init e poi si crea un loop infinito tramite un while(1) la cui condizione è sempre verificata:

void main(void) {
    CFG_Init();

    while(1){
    }
}  

Nel loop si impone l’accensione e lo spegnimento dei LED intervallati da una pausa di 0,5 secondi:

   while(1){
      LATAbits.LATA0 = 1;     // LED ON
      LATBbits.LATB5 = 0;     // LED OFF
      LATC = 0b11111111;      // LED ON
      __delay_ms(500);           // Pausa di 0,5 secondi
      LATAbits.LATA0 = 0;     // LED OFF
      LATBbits.LATB5 = 1;     // LED ON
      LATC = 0b00000000;      // LED OFF
      __delay_ms(500);           // Pausa di 0,5 secondi
} 

Si setta alto il solo pin RA0 di LATA, si setta basso il solo pin RB5 di LATB e si settano alti tutti i pin di LATC. Viene inserito un ritardo di 0,5 millisecondi con il comando __delay_ms(500) e si cambia lo stato dei pin. Infine, si impone un altro ritardo di 0,5 millisecondi per poter completare il ciclo di lampeggio.
Il file main.c completo risulta quindi:

#include <xc.h>
#include "config.h"

void CFG_Init(void){
    TRISAbits.TRISA0 = 0;       // PIN TRISA0 impostato come uscita
    TRISB = 0b11011111;         // PIN TRISB5 impostato come uscita
    TRISC = 0b00000000;         // PIN TRISC  impostati come uscite
    
    LATA = 0b00000000;         
    LATB = 0b00000000;         
    LATC = 0b00000000;         
}

void main(void) {
    CFG_Init();
    
    while(1){
        LATAbits.LATA0 = 1;     // LED ON
        LATBbits.LATB5 = 0;     // LED OFF
        LATC = 0b11111111;      // LED ON 
        __delay_ms(500);           // Pausa di 0,5 secondi
        LATAbits.LATA0 = 0;     // LED OFF
        LATBbits.LATB5 = 1;     // LED ON
        LATC = 0b00000000;      // LED OFF 
        __delay_ms(500);           // Pausa di 0,5 secondi
    }
}

I pin RB6 ed RB7 sono utilizzati dal programmatore e, come riportato nella documentazione Microchip in “In-Circuit Serial Programming – Section 28”, sono stati volutamente lasciati inutilizzati. Nella documentazione viene infatti riportato che, se il progetto lo consente, è preferibile lasciare liberi questi due pin. Se invece dovessero essere necessariamente utilizzati per esigenze progettuali sono disponibili varie soluzioni per non avere problemi in fase di programmazione, consultabili nella documentazione ufficiale Microchip.

PROGRAMMAZIONE
Esistono diversi compilatori per microcontrollori, ma ogni volta che si esegue la compilazione vengono generati una serie di file, uno dei quali ha estensione .hex. È questo il file che va caricato sul microcontrollore.
Per fare questo esistono diverse soluzioni. Nel caso di schede di sviluppo il programmatore è già integrato, mentre per i microcontrollori discreti montati su breadboard o su PCB si usa un programmatore esterno. Ne esistono di diversi tipi, quelli prodotti dalla casa madre, per esempio il PICkit della Microchip, oppure di terze parti, i quali sono più economici ma non si integrano al meglio con l’ambiente di sviluppo e non sempre permettono di programmare qualunque dispositivo. Un esempio è il PIC K150 già presentato in questo sito.
Il programmatore ufficiale della Microchip, il PICkit3 in questo caso, supporta tutti i microcontrollori PICMicro, dagli 8-bit fino ai 32-bit e si integra con l’ambiente di sviluppo MPLAB X.
Dispone di un connettore mini-USB tipo B per connetterlo al PC e di un connettore femmina a 6-pin per connetterlo ai pin del microcontrollore. Il programmatore viene fornito con un connettore a 6 cavi colorati, collegati ognuno ad uno specifico pin del PICkit3:

1. VPP/MCLR (Marrone): sul PICkit3 è il primo pin a destra ed è indicato da una freccia; va connesso al pin MCLR del PIC
2. VDD Target (Rosso): va connesso ai pin VDD del PIC
3. VSS (Arancione): va connesso ai pin VSS del PIC
4. ICSPDAT/PGD (Giallo): va connesso al pin PGD del PIC
5. ICSPCLK/PGC (Verde): va connesso al pin PGC del PIC
6. LVP (Blu): utilizzato solo nella programmazione Low Voltage

Per programmare il microcontrollore è possibile usare i cavi forniti col programmatore e programmarlo on-board oppure usare un adattatore da connettere al connettore a 6-pin del PICkit3. Nell’immagine è riportato il caso di un PIC18F252 in package DIP con evidenziati i pin ai quali collegare i cavetti colorati:

Utilizzando il PICkit3 sono disponibili due modalità di programmazione, una tramite MPLAB X IPE con la quale si procede a caricare manualmente il file .hex nel microcontrollore, ed una tramite MPLAB X IDE con la quale si esegue la compilazione e la programmazione con un solo passaggio.

Programmazione tramite MPLAB X IPE
Per programmare tramite MPLAB X IPE bisogna eseguire una serie di step:

1. Per prima cosa compilare il progetto precedentemente scritto premendo il tasto F11 oppure premendo il tasto della toolbar raffigurante martello e scopa:

Verrà così compilato il codice e se tutto è stato scritto correttamente e non ci sono errori avrà esito positivo:

2. Si apre ora MPLAB X IPE e nel riquadro Device si seleziona il microcontrollore in uso, in questo caso il PIC18F252:

3. Si collega il PICkit3 e si alimenta il microcontrollore. Per alimentare il circuito la scelta migliore è quella di usare l’alimentatore che fornirà energia al circuito. Un’altra possibilità è quella di utilizzare il PICkit3 ma non sempre funziona correttamente. Se si vuole alimentare il circuito tramite programmatore si deve selezionare la cartella nella scheda Project, tasto destro e scegliere Properties. In categoria scegliere PICkit3, dal menu a tendina selezionare Power e spuntare la voce Power target circuit from PICkit3; in caso contrario ignorare questo passaggio.
Con il circuito alimentato si preme prima il pulsante Apply e successivamente Connect. Se tutto procede correttamente uscirà un messaggio del genere:

4. Si carica il file .hex premendo sul tasto Browse e si naviga fino alla cartella del progetto. Una volta arrivati nella cartella del progetto, andare in dist >> default >> production e selezionare il file production.hex. Dovrebbe comparire un messaggio che conferma il corretto caricamento del file .hex:

5. Premere il tasto Program per avviare la programmazione, al termine della quale comparirà un messaggio di conferma:

Scollegando o disconnettendo il PICkit3, il circuito inizierà a funzionare.

Se si vuole programmare il microcontrollore usando il PICkit3 ma caricando un file .hex generato tramite un altro ambiente di sviluppo e compilatore (per esempio MikroC usato nelle altre guide di questo sito) vanno eseguite le istruzioni dal punto 2 al punto 5.

Programmazione tramite MPLAB X IDE
Per programmare tramite MPLAB X IDE per prima cosa occorre connettere il PICkit3 al PC e al circuito alimentato. Le operazioni di compilazione e di programmazione vengono eseguite automaticamente una dopo l’altra premendo il tasto Make and Program Device:

Comparirà un messaggio in cui viene chiesto di scegliere il programmatore, in questo caso il PICkit3 ma può essere uno qualunque di quelli disponibili. A programmazione terminata comparirà un messaggio simile a quello ottenuto tramite MPLAB X IPE, che conferma la corretta programmazione del PICmicro:

In questo caso il circuito inizierà a funzionare non appena le operazioni di programmazioni saranno terminate, senza dover scollegare o disconnettere il PICkit3, poiché MPLAB X IDE provvederà a disconnettere il programmatore.

DOWNLOAD

Al seguente link è possibile scaricare i file .c e .h utilizzati: DOWNLOAD.

   

[Voti Totali: 0 Media Voti: 0]

Devi fare il login per votare

Segui la Nostra Pagina Facebook: