Per chi come noi si è affacciato relativamente di recente a qualche timida sperimentazione nel campo dell’embedded computing, le maggiori difficoltà sono state, come accade spesso, quelle relative al reperimento di ciò che serve per muovere i primi passi. Anche se ovviamente non c’è mai semplicemente il modo “giusto” di iniziare, quella che segue è una sorta di checklist che ci ha permesso di diventare operativi, partendo veramente da zero, in un paio d’ore.
Prima di tutto, però, cerchiamo di fissare qualche concetto utile a chi proviene come noi dallo sviluppo software per PC:
- i microcontrollori sono microprocessori con spiccate funzionalità I/O built-in
- il software per microcontrollori viene spesso chiamato firmware, ad indicare che si tratta tipicamente di programmi che accompagnano il dispositivo per tutta la vita già da quando lascia l’azienda che lo ha prodotto
- i microcontrollori non hanno un sistema operativo all’interno del quale girano diversi task: ogni programma che viene “installato” è l’unico programma in funzione all’interno del processore
- i programmi per microcontrollore vengono comunemente realizzati attraverso un compilatore che tipicamente permette l’utilizzo di linguaggi a basso livello, quale l’assembly o il C (anche se non mancano esempi di compilatori di linguaggi ad alto livello, quali il BASIC o, come nel caso dei microcontrollori presenti nei moduli compatibili con il .NET Microframework, anche C# o VB.NET)
- esistono molti, molti diversi modelli di microcontrollore, ciascuno caratterizzato da un costruttore, da una famiglia di appartenenza, da una serie di parametri “quantitativi” (architettura, quantità di memoria, numero di I/O, frequenza di funzionamento, ecc.) e, ovviamente, da un costo: quello che è importante sapere per chi sviluppa software è che ogni modello è incompatibile con i programmi scritti per un altro (!), anche se ragionevolmente i microcontrollori di famiglie “vicine” sono programmabili in maniera piuttosto simile, pur mantenendo una incompatibilità binaria
Ciò premesso, vediamo come realizzare una prima applicazioncina dimostrativa che, seppur nella sua allarmante semplicità, ci permetterà di familiarizzare con alcuni degli elementi tipici del mondo embedded, ed in particolare con la più diffusa ed economica famiglia di microcontrollori esistente sul mercato: i PIC, e più in particolare con la serie 16F, adottata nella stragrande maggioranza degli elettrodomestici grazie al giusto compromesso tra potenza di calcolo, facilità di programmazione e costo.
Prima di iniziare a scrivere codice, procuriamoci:
- Un PIC 16F886, disponibile in diversi tipi di “involucro” (detto package), ciascuno caratterizzato da uno specifico numero di “piedini” (detti PIN) e da un diverso layout
- Una scheda di sviluppo, a 28 o a 44 pin, che contenga al suo interno, oltre all’ovvio alloggiamento per il PIC, un po’ di elettronica di contorno, tipicamente dedicata alla comunicazione con il mondo esterno (ad esempio per poter essere collegati ad un dispositivo esterno con cui verranno “programmati”, ossia che permetterà di “scrivere” il programma sviluppato nella memoria non volatile interna al PIC stesso), alla alimentazione (3 batterie da 1,5V andranno più che bene per far girare la vostra applicazione per settimane, se non per mesi) e che contenga qualche componente utile alla sperimentazione, quali led, potenziometri, pulsanti e connettori. La scheda più diffusa in questo senso è sicuramente questa qui, che integra al suo interno già un PIC 16F886, un connettore ICSP per poter programmare il PIC senza toglierlo dallo zoccolo, 4 led, un potenziometro, un pulsante, un connettore da 14 pin per una delle 2 file di piedini del PIC e molte “piazzole” forate alle quali poter saldare altri connettori se necessario.
- Un programmer, ossia un dispositivo tipicamente collegato da un lato al PC e dall’altro al PIC (o alla scheda di sviluppo, utilizzando il connettore ICSP). Quello che utilizziamo noi è il PIC Kit 2, economico, funzionale e soprattutto dotato di drivers USB/HID che lo rendono utilizzabile senza problemi anche sui PC con Windows Vista (sia 32 che 64 bit). Tra l’altro è disponibile in una confezione che contiene al suo interno già la scheda di sviluppo di cui sopra.
- Un compilatore C a scelta tra quello della HI-TECH (disponibile anche in una versione lite gratuita qui e caratterizzato da un IDE molto ben fatto basato su Eclipse) o quello della CCS (indubbiamente superiore ma disponibile, demo a parte, solo a pagamento), che trovate qui
- Il software (per PC) di controllo del programmer. Nel caso del PIC Kit 2 il programma (attualmente alla versione 2.55) è contenuto nella confezione e comunque scaricabile nella sezione contenente tutte le informazioni sul prodotto, disponibile a questo link.
Una volta collegato il PIC Kit 2 al PC, installato il programma di controllo e collegata la scheda di sviluppo alla porta ICSP dello stesso PIC Kit 2 la situazione che avrete sarà pressappoco questa (tester a parte):
Lanciate il programma di controllo del PIC Kit 2 e, se tutto è a posto, questo dovrebbe rilevare la presenza del microcontrollore, come indicato dalla scritta in alto a sinistra (accanto all’etichetta “Device”):
Lanciate il compilatore (utilizzeremo quello della HI-TECH), create un nuovo progetto e nel wizard scegliete il processore 16F886 con package a 28 pin. Appena creato il progetto lanciate il wizard di configurazione (C-Wiz editor) e lasciate che questo crei i file con il codice di inizializzazione del dispositivo.
L’ambiente si presenterà a questo punto più o meno così:
Senza addentrarci nei particolari, almeno per questo post, scriviamo nel nostro sorgente main.c il codice seguente:
#include "init.h" // included by C-Wiz
#include <htc.h>
void delay_s(float s);
void init_a2d(void);
unsigned int read_a2d(unsigned int channel);
void main(void)
{
init(); // Function call inserted by C-Wiz
init_a2d();
int i=1;
char dir='R';
unsigned int adcval=0;
while (1)
{
// Demo Supercar...
PORTB=i;
if(dir=='R')
{
i=i<<1;
if(i==0b00001000) dir='L';
}
else
{
i=i>>1;
if(i==0b00000001) dir='R';
}
adcval=read_a2d(1); // 0-255
delay_s(1.0 - adcval/255.0);
}
}
void delay_s(float s)
{
for(int t=0;t<s*10;t++)
{
__delay_ms(100); // delay for 100 milliseconds
}
}
/* Sample code to set up the A2D module */
void init_a2d(void)
{
ADCON0=0; // select Fosc/2
ADCON1=0; // select left justify result. A/D port configuration 0
ADON=1; // turn on the A2D conversion module
}
/* Return an 8 bit result */
unsigned int read_a2d(unsigned int channel)
{
channel&=0x07; // truncate channel to 3 bits
ADCON0&=0xC5; // clear current channel select
ADCON0|=(channel<<3); // apply the new channel select
GODONE=1; // initiate conversion on the selected channel
while(GODONE) continue;
return(ADRESH); // return 8 MSB of the result
}
Mentre il file init.c sarà configurato come segue:
#include <htc.h>
/* Program device configuration word
* Oscillator = External RC Clockout
* Watchdog Timer = On
* Power Up Timer = Off
* Master Clear Enable = RE3 is digital input
* Code Protect = Off
* Data EE Read Protect = Off
* Brown Out Detect = BOD and SBOREN disabled
* Internal External Switch Over Mode = Enabled
* Monitor Clock Fail-safe = Enabled
* Low Voltage Program = Enabled
* Background Debug = Disabled
*/
__CONFIG(0x3FFF & WDTDIS & PWRTEN & MCLREN & UNPROTECT & DUNPROTECT &
INTIO & IESODIS & FCMDIS & LVPDIS & DEBUGDIS & BORV21);
// Peripheral initialization function
void init(void){
/***** Common Code ****
* Global interrupt disabled during initialization
*/
INTCON = 0b00000000;
/***** 16F886 Code ****
* Internal oscillator set to 4MHz
*/
OSCCON = 0b01100000;
TRISB=0x00;
ei(); // Global interrupts enabled
}
A questo punto compilate il progetto. Se non ci sono errori questo produrrà un file con suffisso “.hex” che potrete “dare in pasto” al programma di controllo del Pic Kit 2, utilizzando la funzione “Import…”.
Cliccate sul tasto “Write”, attendete qualche secondo e spuntate il checkbox “On” nel riquadro “VDD PICKit 2” (che in pratica alimenterà la scheda di sviluppo). Se sulla scheda non succede nulla, provate a resettarla mediante il pulsante presente sulla scheda stessa o attivando e disattivando il checkbox “/MCLR” presente nella stessa sezione dell’altro checkbox.
Se tutto va come sperato, i 4 led della scheda dovrebbero iniziare ad accendersi a turno da 1 a 4 e viceversa (riproducendo una sorta di effetto “Supercar”). Inoltre, agendo sul potenziometro presente sulla scheda, potrà essere modificata la velocità di “scorrimento” dell’accensione dei led.
Questo è l’effetto complessivo (anche se qui è ovviamente statico) che dovreste ottenere:
Che soddisfazione! Vero?