Arduino Uno

Che cos’è

Arduino Uno è una piccola scheda di sviluppo basata sul ATmega328P di Microchip, un microcontrollore a 8 bit. Espone i pin del chip su connettori con etichette, aggiunge una porta USB per programmazione e alimentazione e gestisce le parti delicate: regolatore di tensione, quarzo del clock e circuito di reset, così puoi concentrarti sul codice e sul cablaggio. Per una parte enorme di chi impara la robotica, Uno è il modo in cui fa girare per la prima volta un motore o accendere un sensore.

Il suo fascino duraturo non è la potenza pura: per gli standard moderni è lento e povero di memoria. È la tolleranza. I pin a 5 V sopportano gli errori di cablaggio dei principianti, la comunità ha risposto quasi a ogni domanda possibile e quasi ogni sensore e driver hobbistico include codice di esempio che presuppone un Uno.

Come funziona

Scrivi uno sketch, un programma C++ con due funzioni. setup() viene eseguito una volta all’accensione; loop() viene poi eseguito per sempre. Al loro interno leggi gli ingressi e piloti le uscite tramite i pin:

• I pin digitali leggono o scrivono un segnale HIGH/LOW (5 V / 0 V): la pressione di un pulsante, un LED, l’ingresso direzione di un driver del motore.
• I pin PWM (contrassegnati con ~) simulano una tensione analogica accendendosi e spegnendosi molto velocemente. È così che regoli la velocità del motore o la luminosità di un LED.
• Gli ingressi analogici misurano una tensione da 0–5 V e la riportano come numero da 0–1023. È così che leggi un potenziometro o un sensore di linea analogico.

Uno non ha alcun sistema operativo. Il tuo codice è l’unica cosa in esecuzione, il che rende le temporizzazioni prevedibili: prezioso quando chiudi un ciclo di controllo attorno a un robot reale.

Quando usarlo

Scegli Uno quando stai imparando, quando vuoi il maggiore numero possibile di tutorial e librerie compatibili o quando il compito del robot è semplice e in tempo reale: leggere alcuni sensori, eseguire un ciclo di controllo, pilotare due motori. Un seguilinea, un robot che evita ostacoli o un piccolo rover a trazione differenziale rientrano pienamente nel suo terreno.

Cerca altrove quando ti servono Wi-Fi o Bluetooth (ESP32 è di solito l’aggiornamento), calcoli pesanti o visione con la fotocamera (Raspberry Pi), oppure molta memoria. I 2 KB di SRAM di Uno si esauriscono più in fretta di quanto i principianti si aspettino: stringhe lunghe e array grandi sono di solito i colpevoli.

Trappole comuni

• È una scheda a 5 V. Molti sensori moderni sono a 3.3 V e possono danneggiarsi con logica a 5 V. Controlla la scheda tecnica prima di cablare.
• Non alimentare i motori dalla scheda. Il regolatore di Uno non può fornire la corrente del motore; usa una batteria separata e un driver del motore. Alimentare i motori direttamente da Uno è il modo più comune in cui i principianti provocano un brownout o un reset della scheda.
• delay() blocca tutto. Mentre la scheda è in delay(), non può leggere i sensori né reagire. Per qualsiasi cosa responsiva, misura il tempo con millis().
• Fai attenzione alla memoria. Se la scheda si comporta in modo irregolare senza un motivo chiaro, potresti aver esaurito la SRAM.

Piedinatura: che cosa può fare davvero ogni pin

Quattordici pin digitali e sei analogici, ma non sono intercambiabili. Sei hanno una seconda funzione importante.

Due di queste righe determinano la forma di molti progetti robotici. D2 e D3 sono gli unici veri pin di interrupt, quindi un robot con due encoder delle ruote li usa entrambi e non ne resta nessuno. E A4/A5 sono il bus I²C, quindi su Uno un MPU-6050 più un array di sensori analogici entra subito in conflitto per i pin.

Questa pressione sui pin è la ragione più comune per cui un progetto supera le capacità di Uno, non la velocità né la memoria. Quattordici pin digitali e sei analogici scompaiono in fretta quando aggiungi un driver del motore (6 pin), una coppia di encoder (4 pin, 2 dei quali interrupt) e un array di sensori (6 analogici).

Alimentarlo e i tre modi di sbagliare

Il regolatore è lineare, quindi dissipa come calore la differenza fra ingresso e 5 V. Con 12 V in ingresso e 200 mA assorbiti, sono (12 − 5) × 0.2 = 1.4 W in un piccolo contenitore: diventa genuinamente caldo. Se puoi scegliere, alimentalo a 9 V anziché a 12 V.

Tre errori specifici da nominare:

Alimentare i motori dal pin 5 V. Il regolatore non può fornire corrente ai motori, quindi la linea crolla, la scheda si resetta e il sintomo sembra un arresto anomalo del software. I motori ricevono un’alimentazione propria e condividono soltanto la massa.

Alimentare il pin 5 V da una sorgente non regolata. Quel pin è direttamente sulla linea, quindi qualsiasi tensione superiore a circa 5.5 V raggiunge direttamente l’ATmega328P.

Alimentare contemporaneamente da USB e jack. La scheda gestisce questa situazione: c’è un comparatore che seleziona la sorgente con tensione più alta. Tuttavia una batteria sul jack non si carica e può retroalimentare una scheda clone con un progetto marginale.

Che cosa possono fornire davvero i pin

Il pin a 3.3 V è una sorpresa frequente per chi lavora con Arduino. Non è una linea per uso generale, ma una comodità da 50 mA. Un modulo ESP-01 che tenta di trasmettere va immediatamente in brownout su quel pin.

Il problema dei 2 KB di memoria

Uno ha 32 KB di flash per il programma e 2 KB di SRAM per le variabili durante l’esecuzione. La flash è raramente il vincolo. La SRAM lo è, costantemente.

Ogni stringa letterale in una Serial.print viene copiata in SRAM all’avvio:

Serial.println("Calibration complete, entering drive mode");   // 43 bytes of SRAM, forever

Venti messaggi di questo tipo sono 800 byte, cioè il 40% del totale. La soluzione è F(), che lascia la stringa in flash e la legge solo quando serve:

Serial.println(F("Calibration complete, entering drive mode"));  // 0 bytes of SRAM

Gli array sono l’altro grande consumatore. Un float è 4 byte, quindi un buffer di registrazione da 200 campioni è 800 byte e non produce alcun avviso: il compilatore riporta volentieri l’uso della flash e non dice nulla di utile sulla SRAM durante l’esecuzione.

Il sintomo dell’esaurimento non è un errore pulito. Lo stack cresce verso il basso, l’heap verso l’alto e quando si incontrano le variabili si corrompono silenziosamente a vicenda. La scheda si comporta in modo irregolare: letture assurde, un ciclo che salta, un reset senza causa. Se Uno inizia a comportarsi in modo irrazionale dopo che hai aggiunto una funzionalità, sospetta la SRAM prima di ogni altra cosa.

// Drop this in and watch it while you develop.
int freeRam() {
  extern int __heap_start, *__brkval;
  int v;
  return (int)&v - (__brkval == 0 ? (int)&__heap_start : (int)__brkval);
}

Con meno di circa 200 byte liberi, aspettati problemi.

Risoluzione dei problemi

Uno o qualcos’altro?

La Nano merita una menzione particolare per i robot: è lo stesso ATmega328P con lo stesso codice ed espone A6 e A7 come ingressi analogici aggiuntivi. Per un array di riflessione a 8 canali, è la differenza fra riuscire o meno a montarlo: è esattamente il motivo per cui le costruzioni di inseguitori di linea spesso specificano una Nano.

Il riepilogo onesto è che il valore di Uno sta nel fatto che tutto funziona al primo tentativo. Ogni libreria, ogni tutorial e ogni schema di cablaggio presuppone una Uno. Durante l’apprendimento vale più di qualsiasi specifica e, quando la superi, ciò che hai superato è quasi sempre il numero di pin.