Progettare con Adafruit Circuit Playground Classic: Parte 1

La scheda di sviluppo Adafruit Circuit Playground Classic offre una piattaforma completa dal punto di vista delle funzionalità per poter sviluppare una miriade di progetti embedded. Infatti, grazie alla ricca dotazione di sensoristica e alla presenza di LED RGB è possibile realizzare progetti divertenti e accattivanti semplicemente con la singola scheda. Inoltre, Adafruit ha elaborato differenti shield di espansione per aggiungere ulteriori funzionalità.

Introduzione e dotazione hardware

La scheda Adafruit Circuit Playground Classic è una scheda all-in-one. Questa, presenta a bordo una ricca dotazione di sensori e periferiche in grado di supportarci nella realizzazione di innumerevoli progetti. Grazie alla piena compatibilità con l’IDE Arduino e alla presenza della libreria ufficiale, è estremamente semplice poter lavorare con questa scheda e sfruttare a pieno le funzionalità.

Le caratteristiche hardware principali (indicate anche in Figura 1) della scheda sono:

microcontrollore ATmega32U4 con velocità di clock 8 MHz
alimentazione della parte digitale a 3,3V
sensore di temperatura
sensore di luce
microfono in tecnologia MEMS (Micro Electro Mechanical Systems)
altoparlante cicalino
sensore di movimento (STM LIS3DH) in tecnologia MEMS
10x LED RBG in tecnologia NeoPixel
2x LED classici con colori Rosso e Verde
8 general-purpose pads che possono essere configurati come input/output e anche funzionalità di input capacitivo
6 pads di alimentazione (GND, 3.3V e VBATT)
Connettore micro-USB
Connettore per batteria

Figura 1: Scheda Adafruit Circuit Playground Classic e indicazione dei sensori a bordo

L’unità Centrale

La scheda Circuit Playground è basata su un microcontrollore ATmega32U4 prima prodotto dalla Atmel e ora inglobato nel catalogo prodotti Microchip. Questo microcontrollore è basato su un’architettura AVR (in particolare di tipo RISC) a 8-bit e una velocità di clock di appena 8 MHz. La potenza di calcolo è molto ristretta e di certo ben lontana dalla generosa potenza di calcolo a cui ci stiamo abituando con le recenti architetture ARM. Tuttavia, la scelta di questo componente è strategica per la semplicità di utilizzo, la velocità di elaborazione, ma soprattutto il basso consumo energetico che consente di far lavorare questa scheda di sviluppo anche con una semplice batteria esterna senza problemi.

Le interfacce (connettori, switch e pulsanti)

Andiamo ora a sintetizzare la dotazione dal punto di vista delle interfacce fisiche. La scheda è dotata delle seguenti interfacce:

connettore Micro-USB: attraverso questo connettore è possibile sia alimentare la scheda che gestire la comunicazione USB per la seriale, il bootloader e la programmazione della board tramite l’IDE di Arduino.
Connettore JST 2 poli per batteria: questo connettore consente di collegare le batterie alla scheda. In particolare, è disponibile sul catalogo Adafruit un holder di batterie mini-stilo (AAA) in pacco da 3 che consente di alimentare facilmente la scheda per applicazioni remote. Il connettore funge solo da ingresso alimentazione e a bordo non c’è alcun chip di ricarica.

Inoltre, a bordo della scheda troviamo uno switch a slitta e due pulsanti che sono acquisiti dalla board e possono essere utilizzati per i propri progetti.

Arduino Start-up

Partiamo dal configurare l’IDE di Arduino. Nel mio caso sto utilizzando la versione 2.0.0. Di seguito, 5 semplici passaggi:

Step 1. Prima di tutto, aggiungiamo, se non ancora fatto, il pacchetto di driver per la compatibilità con le schede AVR. Basta fare click sul menu Tools e selezionare dal menu a tendina che si apre la voce Board -> Board Manager.
Step 2. Nel box di ricerca della finestra che si è appena aperta inseriamo “adafruit” ed individuiamo se il pacchetto corrispondente è già installato oppure da installare. Molto probabilmente sarà già installato, in questo caso verifichiamo che ci sia il quadratino verde con la dicitura “INSTALLED”, altrimenti procediamo all’installazione.
Step 3. Il passo successivo sarà quello di selezionare la board. Quindi, assicurandoci di aver collegato la scheda Adafruit Circuit Playground Classic al PC tramite un generico cavo dati micro-USB, andiamo a selezionare la voce “Adafruit Circuit Playground” dal menù Tools->Board->AVR Arduino boards
Step 4. Successivamente, selezioniamo la porta di comunicazione corretta dal menu Tools->Port
Step 5. Infine, verifichiamo la correttezza della comunicazione attraverso il comando “Get Board Info” presente sempre nel menu a tendina.

Figura 2: Installazione dei driver per le board AVR

Alla fine di questi semplici passi ci siamo assicurati che la nostra board Circuit Playground sia correttamente collegata al PC e configurata all’interno dell’IDE di Arduino. Dunque, siamo pronti per sviluppare e caricare i nostri progetti su questa scheda di sviluppo. Per poter sviluppare più velocemente le applicazioni possiamo sfruttare la libreria Adafruit_CircuitPlayground sviluppata direttamente da Adafruit. Per farlo, basta installarla attraverso il gestore di librerie con i seguenti semplici passi:

Step 1. Selezionare la voce “Manage Libraries” dal menu Tools
Step 2. Cercare Circuit Playground dal box di ricerca
Step 3. Individuare la libreria Adafruit_CircuitPlayground by Adafruit e fare click su “Install”
Step 4. Successivamente, fare “Install ALL” per aggiungere tutte le librerie collegate a questa che vogliamo aggiungere.
Step 5. Al termine dell’installazione avremo a disposizione anche diversi esempi già pronti che possiamo selezionare dal menu File -> Examples -> Adafruit Circuit Playground.

Per qualsiasi progetto vogliamo realizzare utilizzando la piattaforma Circuit Playground, ed ovviamente le librerie sviluppate da Adafruit, dobbiamo sempre inserire i seguenti blocchi di codice:

#include <Adafruit_CircuitPlayground.h> Questa istruzione, che va inserita all’inizio del programma, ci consente di includere la libreria Adafruit_CircuitPlayground che abbiamo precedentemente installato. L’IDE di Arduino selezionerà il file direttamente dalla directory in cui è installata la libreria.
CircuitPlayground.begin() Questa istruzione va inserita, in generale, all’interno della funzione void setup() in modo tale da inizializzare correttamente la scheda di sviluppo secondo quanto riportato all’interno della libreria stessa.

In particolare, di seguito vi riporto il codice della funzione “begin” all’interno della libreria:

/**************************************************************************/
/*!
@brief Set up the CircuitPlayground hardware
@param brightness Optional brightness to set the neopixels to
@returns True if device is set up, false on any failure
*/
/**************************************************************************/
bool Adafruit_CircuitPlayground::begin(uint8_t brightness) {
pinMode(CPLAY_REDLED, OUTPUT);
pinMode(CPLAY_BUZZER, OUTPUT);
#if defined(__AVR__)
pinMode(CPLAY_CAPSENSE_SHARED, OUTPUT);
pinMode(CPLAY_LEFTBUTTON, INPUT);
pinMode(CPLAY_RIGHTBUTTON, INPUT);
pinMode(CPLAY_SLIDESWITCHPIN, INPUT);
#elif defined(ARDUINO_NRF52840_CIRCUITPLAY) // bluefruit
pinMode(CPLAY_LEFTBUTTON, INPUT_PULLDOWN);
pinMode(CPLAY_RIGHTBUTTON, INPUT_PULLDOWN);
pinMode(CPLAY_SLIDESWITCHPIN, INPUT_PULLUP);
pinMode(CPLAY_SPEAKER_SHUTDOWN, OUTPUT);
digitalWrite(CPLAY_SPEAKER_SHUTDOWN, HIGH);
#elif defined(__SAMD21G18A__) // Circuit Playground Express
pinMode(CPLAY_LEFTBUTTON, INPUT_PULLDOWN);
pinMode(CPLAY_RIGHTBUTTON, INPUT_PULLDOWN);
pinMode(CPLAY_SLIDESWITCHPIN, INPUT_PULLUP);
irReceiver = IRrecvPCI(CPLAY_IR_RECEIVER);
irDecoder = IRdecode();
// since we aren't calling speaker.begin() anymore, do this here
pinMode(CPLAY_SPEAKER_SHUTDOWN, OUTPUT);
digitalWrite(CPLAY_SPEAKER_SHUTDOWN, HIGH);
#endif

strip = Adafruit_CPlay_NeoPixel();
strip.updateType(NEO_GRB + NEO_KHZ800);
strip.updateLength(10);
strip.setPin(CPLAY_NEOPIXELPIN);

#ifdef __AVR__ // Circuit Playground 'classic'
lis = Adafruit_CPlay_LIS3DH(CPLAY_LIS3DH_CS, &SPI); // SPI
#elif defined(ARDUINO_NRF52840_CIRCUITPLAY)
lis = Adafruit_CPlay_LIS3DH(&Wire1); // i2c on wire1
#else // samd21
lis = Adafruit_CPlay_LIS3DH(&Wire1); // i2c on wire1
#endif

mic = Adafruit_CPlay_Mic();

strip.begin();
strip.show(); // Initialize all pixels to 'off'
strip.setBrightness(brightness);

#if defined(__AVR__) || defined(ARDUINO_NRF52840_CIRCUITPLAY) // bluefruit
cap[0] = CPlay_CapacitiveSensor(CPLAY_CAPSENSE_SHARED, 0);
cap[1] = CPlay_CapacitiveSensor(CPLAY_CAPSENSE_SHARED, 1);
cap[2] = CPlay_CapacitiveSensor(CPLAY_CAPSENSE_SHARED, 2);
cap[3] = CPlay_CapacitiveSensor(CPLAY_CAPSENSE_SHARED, 3);
cap[4] = CPlay_CapacitiveSensor(CPLAY_CAPSENSE_SHARED, 6);
cap[5] = CPlay_CapacitiveSensor(CPLAY_CAPSENSE_SHARED, 9);
cap[6] = CPlay_CapacitiveSensor(CPLAY_CAPSENSE_SHARED, 10);
cap[7] = CPlay_CapacitiveSensor(CPLAY_CAPSENSE_SHARED, 12);
#elif defined(__SAMD21G18A__) // Circuit Playground Express
for (int i = 0; i < 7; i++) {
cap[i] = Adafruit_CPlay_FreeTouch(A1 + i, OVERSAMPLE_4, RESISTOR_50K,
FREQ_MODE_NONE);
if (!cap[i].begin())
return false;
}
#endif

return lis.begin(CPLAY_LIS3DH_ADDRESS);
}

Come osserviamo, in questa funzione vengono effettuate le seguenti funzionalità:

Configurazione del pinmode per: LED rosso, cicalino, pulsanti, switch, e tanto altro
Configurazione dei NeoPixel
Configurazione della comunicazione per il sensore di movimento. In particolare, questa è condizionata alla versione di scheda poiché cambia la comunicazione da SPI a I2C.
Configurazione del microfono
Configurazione dei tasti capacitivi

I LED classici ed i NeoPixel

La scheda è dotata di ben 10 LED di tipo NeoPixel, ossia del LED RGB (Red Green e Blue). In particolare, i LED NeoPixel, a differenza dei tradizionali LED RGB (che presentano 4 PIN ma con un anodo oppure catodo in comune) presentano 4 pin di cui 2 dedicati alla programmazione del colore mentre gli altri due all’alimentazione. In particolare, per poter lavorare con i NeoPixel abbiamo le seguenti funzioni:

CircuitPlayground.clearPixels(): la funzione consente di resettare lo stato dei LED
CircuitPlayground.setPixelColor(“posizione LED”, “colore Rosso”, “Colore Verde”, “Colore Blu”): ci consente di configurare il colore del LED nella specifica posizione (indicata attraverso il parametro posizione LED) ed assegnando 3 valori di intensità (che devono essere compresi tra 0 e 255) relativi alle 3 componenti cromatiche (nell'ordine rosso, verde e blu). In alternativa, si può utilizzare la funzione con due parametri CircuitPlayground.setPixelColor(“posizione LED”, "valore a 24bit") che sfrutta il valore del colore a 24bit, ottenibili in maniera più immediata con gli innumerevoli tool disponibili online.
CircuitPlayground.setBrightness(valore) Con questa funzione possiamo andare a configurare il valore di luminosità di ogni singolo neopixel. Il valore che possiamo usare è compreso tra 0 e 255.

Oltre ai Neopixel sono disponibili anche 2 LED classici in formato SMD, con le seguenti caratteristiche:

[...]

ATTENZIONE: quello che hai appena letto è solo un estratto, l'Articolo Tecnico completo è composto da ben 2312 parole ed è riservato agli ABBONATI. Con l'Abbonamento avrai anche accesso a tutti gli altri Articoli Tecnici che potrai leggere in formato PDF per un anno. ABBONATI ORA, è semplice e sicuro.