Curiosity Nano + Code Configurator per entrare nel mondo dei microcontrollori PIC® senza sforzo e in economia

Le schede Curiosity Nano

E’ da un po’ che sto utilizzando con molto piacere le piccole schede di sviluppo Microchip® Curiosity Nano per alcuni progetti. La scelta è ricaduta su di loro piuttosto che su altre perchè hanno delle caratteristiche molto interessanti:

  • Hanno un prezzo davvero contenuto e spesso Microchip le mette in offerta mediante codici sconto.
  • Non hanno bisogno di un programmatore esterno: hanno a bordo un programmatore/debugger utilizzabile tramite porta USB.
  • La porta USB utilizzata dal programmatore può essere anche sfruttata dalla UART del microcontrollore per la comunicazione seriale.
  • Le schede sono riconosciute da MPLAB X IDE e possono essere programmate in due diversi modi: direttamente da MPLAB X IDE tramite il tasto program o trascinando un file HEX (programma già compilato) da una finestra di esplora risorse sulla periferica di archiviazione generata dalla scheda stessa.
  • Si trovano sia per microcontrollori PIC che AVR.
  • Sono molto piccole e adatte per essere utilizzate su breadboard previa saldatura di pin-strip (non forniti).
  • Possono essere montate direttamente su schede finite grazie alla castellatura esterna e un eventuale aggiornamento firmware è facile perchè può essere distribuito il file HEX che il cliente finale può caricare sulla scheda in piena autonomia senza effettuare complicati operazioni: gli basta una semplice operazione di drag’n drop.

Capirete che sono quindi l’ideale per chi ha sempre avuto dei dubbi per entrare nel mondo dei microcontrollori PIC® ma anche uno strumento molto potente per la prototipazione rapida e per imparare nuove funzionalità. Tutto questo, unito alla potenza dell’ MPLAB Code Configurator, consente di avere applicazioni funzionanti in poco tempo senza andare a leggere nei datasheet.

Oltre alle schede Curiosity Nano, che di distinguono per il form-factor di dimensioni ridotte, la Microchip ha in catalogo anche le schede Curiosity (senza Nano) che sono più grandi e comprendono anche l’utilizzo di microcontrollori a 16 e 32 bit (qui il link alla serie completa). Le Curiosity funzionano come le Curiosity Nano: hanno il debugger integrato, ma, essendo più grandi, hanno più accessori a bordo tra cui i socket per accogliere le schedine di espansione Clickboard prodotte dalla MikroElektronika.

Le schede Curiosity sono pensate per essere utilizzate soprattutto con il nuovo ambiente di sviluppo online della Microchip: MPLAB Xpress di cui, però, non mi occuperò in questo articolo e il cui utilizzo, tuttavia, è quasi del tutto simile al tool offline.

Scopo di questo tutorial

In questo tutorial illustrerò l’utilizzo di una delle ultime Curiosity Nano che ho acquistato in offerta sullo store Microchip (MicrochipDirect):  La PIC16F15376 Curiosity Nano (codice prodotto: DM164148). Andremo ad usare il Code Configurator per impostare da subito il clock da utilizzare, led e pulsante inclusi sulla scheda e la UART che comunica tramite porta USB.

Di cosa c’è bisogno:

  • Una scheda PIC16F15376 Curiosity Nano, ovviamente. (la trovate su Microchip Direct, ma anche su Mouser, Digikey e altri negozi di componenti elettronici on-line cercando il codice DM164148).
  • Un cavetto da USB tipo A a USB micro B (probabilmente va bene anche quello che usate per il cellulare a meno che non abbiate un cellulare con USB tipo C o un iPhone…)
  • L’ultima versione di MPLAB X IDE. Nel momento in cui scrivo c’è la 5.30
  • L’ultima versione del compilatore XC8.  Nel momento in cui scrivo c’è la 2.10, che viene utilizzata sia per i PIC che per gli AVR.
  • La documentazione (manuale d’uso e schema) della scheda, reperibili a questo indirizzo.

 

Installazione MPLAB Code Configurator

Una volta installato MPLAB X IDE e il compilatore bisogna installare il Code Configurator, che è un plug-in di MPLAB X Ide. Nel caso in cui non l’abbiate già installato, da MPLAB X Ide cliccare su Tools > Plugins. Si apre la finestra per la gestione dei Plugins. Cliccare sulla scheda “Available Plugins” e cercare MPLAB® Code Configurator. Selezionarlo dando la spunta sulla rispettiva check-box e premere il pulsante “Install” che è comparso in basso alla lista. Nel caso in cui, in questa lista, non compare la voce, vuol dire che l’avete già installato e ve lo ritrovate, piuttosto, nella scheda “Installed”. Il pulsante per accedere al Code Configurator appare sulla barra dei pulsanti come uno scudo azzurro con dentro la scritta MCC:

Avviamo un nuovo progetto

Clicchiamo su File > New Project. Nella finestra che compare lasciamo selezionato “Microchip Embedded” nel riquadro di sinistra e “Standalone Project” in quello di destra. Premiamo il pulsante Next in basso. Nella casella a discesa “Family” selezioniamo “Mid-Range 8-bit MCUs (PIC10/12/16/MCP)” e nella casella sottostante, Device, selezioniamo PIC16F15376:

Premiamo quindi Next. In questa schermata ci viene chiesto quale tool utilizzare per la programmazione fisica del dispositivo. Nel caso non l’avessimo ancora fatto, possiamo anche collegare la nostra curiosity nano ed aspettare che venga enumerata dal sistema. A questo punto nella finestra di selezione deve comparire la nostra scheda all’interno della cartella “Microchip Kits” con il numero seriale al di sotto: selezioniamo proprio questo:

 

Posso immaginare che la sigla PKOB stia per qualcosa tipo PicKit On Board.

Notate che compare il doppio pallino giallo affianco, che sta a significare che il supporto su MPLAB X IDE è ancora in via di definizione o parziale. Questa cosa non ci interessa perchè, anche quando il dispositivo è in giallo, viene programmato ugualmente senza problemi; il supporto parziale si riferisce probabilmente a qualche particolare funzione di debug: non ho approfondito la questione relativamente a questa particolare scheda. Premiamo quindi il pulsante Next. In questa finestra ci viene chiesto quale Toolchain di compilazione utilizzare per il nostro progetto. Sceglieremo chiaramente XC8 (v 2.10) – che è l’ultima versione disponibile al momento di stesura di questo articolo. Chiaramente voi utilizzerete la versione più aggiornata che troverete, ma nulla vieta di usare anche versioni vecchie.

Premiamo Next. Ci viene chiesto di dare un nome al progetto e dove salvarlo. La scelta è personale. Io evito sempre di usare caratteri strani e spazi nel nome e salvo in una cartella predefinita gestita da un servizio di cloud in maniera da avere sempre disponibile i miei progetti anche su altri PC.

L’utilizzo della versione MPLAB Xpress, on line, quando ci si registra e si accede col proprio account, salva automaticamente il progetto su cloud della Microchip, quindi anche in questo caso avrete sempre i progetti a portata di mano. Io preferisco avere il controllo di ogni singolo file sul mio hard-disk. Sono scelte personali.

Ricordiamoci di tenere selezionata la casella “Set as main project”: questo è molto importante perchè MPLAB X è basato su Netbeans, e questa piattaforma prevede di avere un progetto “principale” che è quello su cui agisce quando, ad esempio, si premono i pulsanti per la compilazione e la programmazione anche se nell’editor abbiamo aperti files di progetti che non appartengono al principale.

Premiamo, infine, il pulsante Finish.

Utilizziamo il Code Configurator

Lo scopo di questo tutorial è quello di configurare le periferiche che ci interessano con dei semplici click, riducendo  la scrittura di codice al minimo indispensabile. Clicchiamo quindi sul pulsante del Code Configurator (lo scudo blu con la scritta MCC). Attendiamo un po’ che si apra la finestra relativa: ci potrebbe volere anche un minuto. La prima cosa che compare è una finestra che ci chiede di salvare il file di configurazione. Di default il file si chiama “MyConfig.mc3” e viene salvato nella stessa cartella del progetto: io in genere lascio tutto così.

La schermata che si presenta può intimidire non poco e anche io le prime volte sono rimasto un po’ impressionato, poi col tempo ho imparato ad apprezzarla ma soprattutto ad utilizzarla. Partiamo con il configurare il clock di sistema, anche perchè è in base a questo che il code configurator farà poi le considerazioni relativamente a tutte le periferiche che richiedono il timing (come il baudrate della UART per questo tutorial).

Clock di Sistema e Word di configurazione

Questo PIC può girare fino a 32MHz, e scelgo di impostare proprio questa frequenza. La scheda Curiosity Nano non ha il quarzo perchè prevede l’utilizzo dell’oscillatore interno. La finestra che mi si presenta al centro per prima è proprio quella dell’oscillatore, che fa parte del gruppo System Module, divisa in due schede: Easy Setup (selezionata di default) e Registers (che permette di fare una selezione più approfondita). In realtà tutte le periferiche hanno una scheda “Easy” e una più approfondita, e per un utilizzo di base, la Easy è quasi sempre sufficiente.

Anche se le configurazioni, con l’ MCC, sono facilitate da semplici Click, è comunque necessario avere una conoscenza di base per non incorrere in errori: bisogna necessariamente conoscere la differenza tra HFINTOSC, EXTOSC ecc tanto per dirne una. Sotto questo punto di vista vi rimando alle lezioni precedenti e in particolare alla lezione sulla scrittura della word di configurazione per il PIC16F18877 che, anche se relativa ad un microcontrollore diverso (ma la configurazione è più o meno uguale), copre in gran parte tutta la questione delle parole chiave utilizzate nelle configurazioni dei microcontrollori PIC, soprattutto per quanto riguarda il Clock che viene gestito da una catena molto sofisticata.

In Oscillator Select andrò a selezionare HFINTOSC che è l’unica scelta corretta da fare se si vuole usare l’oscillatore interno a 32MHz, dato che con questo il PLL non è utilizzabile. In HF Internal Clock selezioniamo 32_MHz e in Clock Divider scegliamo 1 perchè non vogliamo divisione. Come vedete, in alto in questa finestra c’è un’etichetta che recita “Current system clock xxMHz” che si aggiorna man mano che eseguiamo delle scelte e riporta il valore del clock di sistema che otterremo all’avvio del programma. Lasciamo invariate le altre selezioni e soprattutto lasciamo spuntata la selezione “Low Voltage Programming” dato che la Curiosity Nano utilizza questa modalità di programmazione.

La Microchip ha scelto, giustamente, la modalità di programmazione LVP per queste schede in modo da realizzare un programmatore on-board più economico e semplice da implementare circuitalmente.

Lasceremo tutte le altre impostazioni di default, quindi non andremo a smanettare nella scheda Registers che ci permette di modificare singolarmente le singole opzioni di configurazione.

Impostazione UART

Adesso andremo ad includere il modulo UART nella nostra configurazione. Tutte le periferiche disponibili per il microcontrollore scelto si trovano nel riquadro Device Resources, mentre quelle che abbiamo già scelto e incluso nella nostra configurazione/programma vengono riportate nel riquadro Project Resources.

Scorriamo l’elenco dei Device Resources fino ad incontrare EUSART (Enhanced Universal Synchronous Asynchronous Receiver Transmitter). Espandiamolo: compaiono due periferiche EUSART, difatti questo microcontrollore PIC ne ha ben due.

Ricordo che, quando c’è più di una periferica uguale, vengono utilizzati gli indici 1 e 2 per distinguerle tra loro, e così anche i nomi dei registri e dei singoli bit possiederanno l’indice 1 o 2. Per retrocompatibilità, ci si può riferire ai registri delle periferiche numero 1 anche senza indice ma non consiglio di farlo.

Dobbiamo scegliere accuratamente quale delle due periferiche utilizzare dal momento che abbiamo detto sopra che vogliamo utilizzare la porta USB del debugger come ponte seriale verso il nostro microcontrollore. Il debugger incluso sulla scheda ha la periferica USB CDC (Communication Device Class) collegata ai pin RD0 (TX) e RD1 (RX) del PIC16F15376 come possiamo vedere dallo schema:

La porta USB del debugger su questa scheda svolge molteplici funzioni: una volta collegata al PC vengono enumerati ben 3 dispositivi. Uno è un dispositivo di archiviazione di massa chiamato “Curiosity”, accessibile su Windows da esplora risorse. All’interno di questo dispositivo di archiviazione ci sono dei files standard con le istruzioni per l’utilizzo del dispositivo, ma la funzione principale è quella di programmazione on-the-go: trascinando un file HEX (programma già compilato), il debugger se ne accorge e inizia subito la fase di programmazione col file fornito. E’ questa la modalità di programmazione che si utilizza con la versione on line (Xpress) di MPLAB dato che a fine compilazione scarica dal browser il file HEX generato.

Gli altri due dispositivi rilevati sono visibili, da Windows, nella gestione delle risorse del sistema:

Si tratta di una porta COM virtuale (il dispositivo USB CDC appunto) e di un dispositivo USB Curiosity Data Gateway, che è quello che viene utilizzato da MPLAB X Ide per la programmazione e debug.

Per sfruttare quindi la porta USB come “ponte” tra il chip del debugger e il PIC che andremo a programmare è necessario utilizzare proprio quei due pin: RD0 e RD1.  Il microcontrollore PIC in oggetto ha la caratteristica ormai nota di possedere il PPS (Peripheral Pin Select) che consente alle periferiche di utilizzare dei pin a piacere per lo sbocco verso l’esterno. Non è però possibile scegliere qualsiasi pin ma piuttosto ogni periferica, oltre ai pin assegnati di default, ha un gruppo di pin sui quali può essere rimappata. In particolare la EUSART1 non ha la possibilità di essere mappata su alcun pin del banco di porte D (ha la possibilità di usare i banchi B e C), mentre la EUSART2 può utilizzare sia il banco B che il D, per cui andremo a configurare la EUSART2 per il nostro scopo.

L’elenco dei pin utilizzabili per la funzione PPS è normalmente indicata nei datasheet al paragrafo “PPS INPUT SIGNAL ROUTING OPTIONS”. In particolare per il microcontrollore PIC in oggetto si trova nella tabelle 15.1 e 15.2 a partire da pagina 233. Una caratteristica interessante della EUSART, ad esempio è che i pin RX e TX vengono gestiti separatamente per cui è addirittura possibile utilizzare soltanto la ricezione o la trasmissione liberando un pin per altri scopi o anche mappare i due pin su porte di banchi differenti.

Finite le premesse, nel riquadro Device Resources, clicchiamo sul tasto verde + posto affianco ad EUSART2 per aggiungere questa periferica al nostro progetto. Attendiamo qualche secondo e la finestra centrale viene spostata sulla scheda EUSART2. Contemporaneamente nel  riquadro Project Resources compare la nuova periferica e da qui possiamo anche rimuoverla, se abbiamo sbagliato, cliccando sulla X rossa.

Nella scheda Easy Setup della EUSART2 andiamo a configurare le funzionalità di base. Lasciamo il valore Asyncronous presente di default nel campo Mode. Lasciamo il segno di spunta su Enable Transmit e lasciamo il baudrate a 9600 (che con un clock di 32MHz è quello che fornisce l’errore più basso). Dato che nel nostro esempio non utilizzerò la ricezione, possiamo togliere il segno di spunta da Enable Receive: in questo modo liberiamo un pin. Scorriamo più in basso e selezioniamo la casella Redirect STDIO to USART: questo genererà le funzioni getch e putch che potranno essere utilizzare dalle altre funzioni della libreria stdio, tra cui la printf.

Nel riquadro di destra, dove è riportato il disegno del PIC16F15376 (in formato UQFN40) vediamo che il pin numero 14 da celeste è diventato verde ad indicare che è utilizzato e affianco ad RB6 (funzione predefinita di quel pin) c’è scritto TX2 : il pin di default per la funzione di trasmissione della EUSART2 è difatti RB6. Provvederemo di seguito a cambiarlo mediante il pin manager dal momento che questa non è una funzione appartenente alla periferica EUSART ma è legata alla gestione delle modalità di funzionamento dei pin.

Impostazione dei Pin con il pin manager

Nella parte bassa abbiamo un gruppo di schede che comprende il pin manager, nel caso non fosse aperto clicchiamo sul nome della scheda pin manager per aprirlo. Questo fornisce una panoramica di tutti i pin del microcontrollore PIC, in fila, con tante caselle munite di lucchetti. Vediamo che in alto a sinistra è possibile cambiare il package, di default UQFN40, per poter scegliere quello che ci è più congeniale: lavorando ancora in tecnologia PTH (Plated Through Hole) ovvero sulle millefori, spesso mi è congeniale selezionare il formato PDIP40. Cambiando il formato viene anche aggiornata l’immagine del microcontrollore PIC e questa è una funzionalità decisamente comoda e che incontriamo anche in altri sistemi di sviluppo per altri microcontrollori (ad esempio STM32CubeMX per gli STM32).

Osserviamo attentamente la scheda del pin manager: vediamo che in cima c’è EUSART2 diviso in 2 righe che sono RX2 e TX2 e possiede una serie di lucchetti soltanto sui banchi B e D (dicevo poco fa che la EUSART2 può essere ridirezionata su qualsiasi pin di questi due banchi: l’avevamo visto dal datasheet ma vediamo che, tutto sommato, non era necessario ricorrere a tale documento dato che il pin manager si fa capire abbastanza bene).

Notiamo che tutti i lucchetti aperti sono su sfondo blu: questo indica “opzione possibile” mentre abbiamo un lucchetto chiuso, su sfondo verde, in corrispondenza del pin 14 (tale numero si legge come intestazione colonna, ma è chiaramente diverso a seconda del package selezionato!) o, se preferiamo, in corrispondenza del pin 6 del banco di porte B, sulla riga TX2: questo indica “opzione selezionata” ovvero TX2 (funzione di output della EUSART2) direzionato sul pin RB6, e questa è l’opzione di default.

Abbiamo detto che per utilizzare la periferica USB CDC come ponte di comunicazione seriale, vogliamo utilizzare RD0 (TX). Clicchiamo quindi sul lucchetto che abbiamo trovato chiuso in corrispondenza TX2/Port B 6: in questo modo lo apriamo e la periferica non ha più sbocchi. Clicchiamo quindi sul lucchetto aperto in corrispondenza di TX2/Port D 0: il lucchetto si chiude, lo sfondo diventa verde e quel pin diventa la nuova opzione scelta.

Notiamo che, per questa periferica, può essere selezionato più di un pin per la stessa funzione: vuol dire che la periferica, se lo vogliamo, potrà trasmettere anche su due pin.

Quando dei lucchetti su una riga o su una colonna assumono lo sfondo di colore rosso, vuol dire che c’è già un’opzione selezionata per una determinata funzione su quel pin, per cui l’opzione scelta esclude le altre lungo la riga o la colonna. Se, ad esempio, selezioniamo un pin come uscita, automaticamente la funzione di entrata assume colorazione rossa.

La configurazione della EUSART2, per quanto ci riguarda, è terminata. Abbiamo detto che sulla scheda in oggetto ci sono anche un led ed un pulsante e vogliamo utilizzare anche quelli. Andando a vedere il manuale della scheda, o lo schema per vedere come sono collegati questi due componenti:

Il LED è di colore giallo, è indicato come LED0, ha il catodo collegato al pin RE0 e l’Anodo verso la tensione di alimentazione del dispositivo: questo vuol dire che il led si accenderà quando il pin in questione verrà portato a livello logico basso. Il pulsante è collegato su RE2, chiude verso GND e non ha resistenze di pull-up: questo vuol dire che è necessario attivare su tale pin la resistenza di pull-up integrata e che rileveremo la chiusura del pulsante quando il pin RE2 si trova a livello logico basso. Pulsante e LED operano quindi in modalità “attivo basso” che è un po’ la regola quando si utilizzano i microcontrollori e, se sembra una banalità, lo scrivo giusto per alcuni amici che, abituati a programmare dispositivi diversi dai microcontrollori, non sono abituati a ragionare “al contrario”.

Bene: dobbiamo quindi impostare il pin RE0 come uscita, per poter pilotare il led, e il pin RE2 come ingresso con pull-up per poter leggere lo stato del pulsante. Andiamo sempre sul pin manager e soffermiamoci nella casella Pin Module, divisa in due righe GPIO (input e output). Scorriamo verso destra arrivando al banco di porte E. RE0 deve essere impostato come uscita per poter accendere il led; chiudiamo quindi il lucchetto, cliccandoci sopra, in corrispondenza di GPIO output/PORT E 0. Clicchiamo quindi il lucchetto in corrispondenza di GPIO input/PORT E 2 per poter utilizzare RE2 come ingresso e leggere il pulsante. Alla fine la situazione del pin manager dovrà apparire come la seguente:

Tutte queste operazioni, anzichè dal pin manager, possono anche essere fatte dall’immagine del chip cliccando col tasto destro su ogni pin e selezionando dal menù a discesa che compare la funzione: ma così non si ha una panoramica completa, ad esempio, nel caso di ridirezionamento di una periferica.

Mancano ancora alcuni aggiustamenti, tra cui la funzione analogica sempre presente di default sui pin e che causa malfunzionamenti ai ragazzi alle prime armi, nonchè la resistenza di pull-up da abilitare su RE2 per poter leggere correttamente il pulsante.

Nel riquadro centrale, dove dovremmo avere ancora la finestra di configurazione della EUSART2, clicchiamo sulla scheda col nome Pin Module. In questo riquadro dovremmo avere soltanto 3 righe, relative ai 3 pin che abbiamo configurato: RD0, assegnato alla EUSART2, RE0 e RE2. 

Togliamo da subito il segno di spunta alle caselle presenti sotto la colonna Analog, in modo da disabilitare la funzione analogica su tali pin. Cambiamo anche i nomi dei pin: questo ci aiuterà a ricordare più facilmente cosa c’è collegato. Nella colonna Custom Name scriviamo LED0 nella riga di RE0 e scriviamo SW0 nella riga di RE2. Vediamo che dopo aver scritto i nomi, l’immagine del chip si aggiorna e affianco al nome standard della porta compare anche il nome scelto da noi.

Alla colonna Start High (parti a livello alto) mettiamo il segno di spunta in corrispondenza di LED0: in questo modo all’avvio il led sarà spento (perchè, ricordiamo, ha l’anodo collegato al pin e quindi si accenderà con livello logico basso). Alla colonna WPU (Weak Pull-Up) mettiamo il segno di spunta in corrispondenza di SW0: questo abiliterà la resistenza di pull-up tale pin e ci consentirà, quindi, di avere un livello logico alto stabile in assenza di pressione del pulsante.

Giusto per completezza di informazione: la colonna OD (Open Drain) serve per impostare una porta come a Collettore aperto (casella selezionata) o Push-Pull (deselezionata), mentre la colonna IOC (Interrupt On Change) serve per abilitare il sollevamento dell’interrupt in concomitanza ad un preciso evento di cambio di stato logico sul pin.

Bene, l’impostazione dei pin è completa e non resta che far generare tutto il codice al configuratore automatico: nel riquadro Project Resources premiamo il pulsante Generate. Si apre una finestra di log in basso, dove è presente anche il pin manager, con le operazioni eseguite: quando compare la riga “INFO: Saved configuration to file (…)” vuol dire che la generazione del codice è terminata e possiamo quindi chiudere il Code Configurator premendo nuovamente il pulsante a scudo MCC.

Struttura del codice generato dal Configurator

Chiuso l’MCC ci ritroviamo di nuovo con la finestra dell’editor aperta. Nel navigatore in alto a sinistra (che contiene le schede Project e Files) posizioniamoci sulla scheda Projects ed espandiamo il progetto su cui stiamo lavorando: vediamo che il code configurator crea due cartelle dal nome MCC Generated Files in Header Files e in Source Files: queste cartelle contengono rispettivamente i files con estensione H (headers) e i files con estensione C (sources) generati dal code configurator.

Questa è l’organizzazione logica. Fisicamente, invece, c’è una sola cartella mcc_generated_files nella cartella di progetto che contiene sia i files H che i C generati dall’MCC. Cerchiamo sempre di distinguere l’organizzazione logica da quella fisica.

In Source Files compare anche un main.c generato automaticamente. Facciamo doppio click sul main. Aprendolo vediamo che contiene unicamente una funzione main che richiama SYSTEM_Initialize(); tale funzione esegue la configurazione di tutte le periferiche. La main termina con il ciclo infinito, vuoto, nel quale andremo a scrivere la nostra applicazione. Analizziamo quindi i files header generati:

  • device_config.h : contiene il define di _XTAL_FREQ (32milioni) espresso in Hertz che potrà essere utile, ad esempio, per le richiamare la funzione di ritardo inclusa da XC8 __delay_ms()
  • eusart2.h: contiene i prototipi funzione legati all’utilizzo della EUSART2. Nelle note prima di ogni funzione si può leggere come vanno utilizzate. Tali note vengono mostrate anche come tooltip quando scriviamo una funzione correttamente
  • mcc.h: contiene i prototipi funzione per l’inizializzazione di tutte le periferiche di sistema e aggiunte.
  • pin_manager.h: è quello più interessante perchè contiene le funzioni utili per la gestione degli IO. Dal momento che abbiamo cambiato i nomi ai pin vediamo che possiamo disporre di funzioni come LED0_Toggle() per invertire lo stato del led o SW0_GetValue() per leggere lo stato del pulsante, solo per citarne due. Le stesse funzioni sono presenti anche col nome classico del pin.

Nei files source generati, abbiamo invece le controparti “attive”:

  • device_config.c: c’è l’impostazione della word di configurazione
  • eusart2.c: contiene l’implementazione delle funzioni da utilizzare con la EUSART2
  • mcc.c: contiene l’implementazione delle funzioni per inizializzare il sistema. Vediamo che SYSTEM_Initialize(), richiamata nel main, non fa altro che richiamare singolarmente tutte le altre funzioni per il setup delle periferiche singole le quali non tutte trovano posto in questo file (mcc.c) ma possono anche trovarsi in altri files come appunto il setup della EUSART che si trova in eusart.c. In particolare la funzione PMD_Initialize serve a configurare i registri PMD (Peripheral Module Disable) che è un sistema comodo per disabilitare periferiche non utilizzate in maniera rapida e quindi risparmiare sulla corrente assorbita.
  • pin_manager.c: contiene solo l’inizializzazione dei GPIO dato che le funzioni di toggle, set low/high, read ecc sono state implementate mediante #defines nel file header relativo.

Nel main sotto la nota Add your application code, scriviamo:

if (!SW0_GetValue()) // pulsante premuto
   {
   LED0_SetLow(); // accendo il led
   __delay_ms(80); // ritardo per antirimbalzo
   if (!SW0_GetValue()) // controllo che il pulsante negli 80mS sia ancora premuto
      {
      printf("BUTTON PRESSED\r"); // messaggio su seriale   
      while(!SW0_GetValue()); // rimango bloccato finchè non si rilascia il pulsante
      __delay_ms(100); // ulteriore ritardo per ricominciare il ciclo
      }
   LED0_SetHigh(); // spengo il led            
   }

In pratica è un semplice codice che rileva la pressione del pulsante (il not messo prima della funzione è per verificare il livello basso). A questo punto viene acceso il led e si attendono 80 millisecondi per scongiurare eventuali rimbalzi del pulsante, dopodichè si verifica nuovamente che il pulsante sia rimasto premuto. A questo punto viene inviato un messaggio sulla seriale mediante la funzione printf della libreria stdio. Rimaniamo quindi bloccati in questa parte di codice fino a che non si rilascia il pulsante e aspettiamo ancora 100 mSec prima di ricominciare. Viene quindi spento il led e si ricomincia daccapo.

Stiamo quindi utilizzando la funzione printf per inviare un messaggio sulla seriale: questo è possibile perchè nella configurazione abbiamo spuntato l’opzione Redirect STDIO to USART che crea le funzioni getch() e putch(), quest’ultima richiesta proprio da printf per poter inviare un singolo char alla volta nel buffer di trasmissione seriale man mano che viene scansionato l’array passato alla funzione. Per poter utilizzare printf nel main, però, abbiamo bisogno di includere anche la libreria che definisce questa funzione, quindi al di sopra del main, in cima al codice, dobbiamo scrivere:

#include <stdio.h>

Possiamo quindi compilare e caricare il programma premendo il pulsante che normalmente usiamo anche con il PICkit:

Se anzichè seguire il tutorial passo passo, avete scaricato il progetto, vi si presenterà, a questo punto, la finestra che vi chiede di selezionare il tool da usare per la programmazione dal momento che il mio ha sicuramente un numero seriale differente dal vostro.

Finita la programmazione, se avete seguito tutto per filo e per segno non possono essere generati errori, anche perchè codice noi non ne abbiamo scritto, tranne che per quelle poche righe nel main! Apriamo quindi un programma terminale seriale (io in genere uso CoolTerm) e impostiamolo per comunicare con la porta COM virtuale generata dalla nostra scheda e settiamo le impostazioni di comunicazione a 9600,N,8,1.

Premendo il pulsante SW0 sulla scheda si accende il led e viene inviata la scritta “Button Pressed” sulla porta seriale. Il led si spegne e il ciclo ricomincia nel momento in cui rilasciamo il pulsante.

Letture consigliate

Se siete interessati al mondo dei Microcontrollori PIC® non posso fare altro che consigliarvi due splendidi libricini (solo in lingua inglese) scritti dal grande Lucio di Jasio  che spiegano in maniera più estesa quello che ho spiegato qui adesso:

  • In 10 Lines of Code – Spiega la programmazione dei PIC mediante il tool online MPLAB Xpress unito all’ MPLAB Xpress Code Configurator che, come nell’esempio appena illustrato, riduce al minimo la scrittura del codice.
  • This is (not) Rocket Science – Spiega l’utilizzo delle periferiche Core Independent che velocizzano di molto lo sviluppo di alcune applicazioni liberando il processore da molti compiti.

 

Download

Potete scaricare il progetto dal mio repository Github, qui.

Se questo tutorial vi è piaciuto, vi chiedo di lasciare un like sulla pagina Facebook