5. Microcontrollori e Arduino

Il microcontrollore (o MCU, MicroController Unit) è un dispositivo elettronico integrato su singolo chip, nato come evoluzione alternativa al microprocessore. È progettato per applicazioni specifiche (special purpose) di controllo digitale in sistemi embedded (incorporati), in cui deve interagire direttamente con il mondo esterno tramite un programma residente nella propria memoria interna e mediante l'uso di pin specializzati o configurabili dal programmatore.

La gamma di funzioni analogiche e digitali integrate sullo stesso chip permette di sostituire schede elettroniche cablate tradizionalmente ben più complesse e costose.

Breve storia evolutiva:

• 1975 — Intel rilascia l'8048, primo computer on-chip con RAM e ROM integrate, usato in oltre un miliardo di tastiere per PC.
• Anni '80 — I modelli si dividono in due varianti: ROM programmata in fabbrica (OTP, One Time Programming) e EPROM cancellabile con luce ultravioletta (riconoscibile dalla finestrella di quarzo sul chip).
• 1993 — Microchip introduce il PIC16C84 con memoria EEPROM cancellabile elettricamente, che consente l'aggiornamento del firmware a circuito montato (In-System Programming).
• 1993 — Atmel rilascia il primo MCU con memoria Flash, più veloce e compatta, con ciclo di vita (cancellazioni) molto più elevato: segna l'inizio del massiccio utilizzo degli MCU nelle applicazioni più disparate.

Il microprocessore (CPU) nasce nel 1972 con l'Intel 8008 a 8 bit e si è evoluto verso potenza di calcolo sempre crescente; tuttavia integra sul chip solo la logica di elaborazione, richiedendo memorie e dispositivi periferici esterni per interagire con il mondo.

Il microcontrollore è invece un sistema completo che integra nello stesso chip: processore, memoria permanente (Flash/ROM), memoria volatile (RAM), canali di I/O e moduli specializzati. È ottimizzato per un campo applicativo specifico, con consumi ridottissimi e costo molto basso.

Caratteristica                                  MCU         µP (CPU)
Velocità massima di clock                    200 MHz         4 GHz
Capacità elaborativa massima (MegaFLOPS)         200          5.000
Potenza minima dissipata (Watt)              0,001 W            50 W
Prezzo minimo per unità (USD)                 0,50 $           50 $
Pezzi venduti annualmente (milioni)          11.000          1.000

Diversamente dal microprocessore che esegue programmi da memoria di massa o volatile, nei microcontrollori il programma è memorizzato in una ROM/Flash ed è a tutti gli effetti un firmware. Per questo i programmi per MCU si scrivono, compilano e caricano sul chip con strumenti appositi.

Arduino è un framework open source per la prototipazione rapida e l'apprendimento dell'elettronica e della programmazione. Nasce all'Interaction Design Institute di Ivrea (fondato da Olivetti e Telecom Italia); il nome richiama quello del bar di Ivrea frequentato dai fondatori e di Arduino d'Ivrea, Re d'Italia nel 1002.

La piattaforma si compone di due elementi principali: una scheda hardware con microcontrollore AVR Atmel, connettori di I/O, regolatore di tensione e interfaccia USB, e un IDE multipiattaforma (Linux, macOS, Windows) che permette anche ai principianti di scrivere programmi in un linguaggio derivato dal C/C++ chiamato Wiring, liberamente scaricabile e modificabile.

Arduino può funzionare come sistema stand-alone oppure interagire con software su PC (Adobe Flash, Processing, Max/MSP, Pure Data, SuperCollider, Vvvv). L'hardware originale è prodotto da Smart Projects (Italia) e alcune schede da SparkFun Electronics (USA).

Sono state commercializzate 16 versioni ufficiali dell'hardware Arduino. Le principali:

Modello          MCU              Flash  SRAM  I/O dig.  I/O an.  USB
Serial           ATmega8            8KB   1KB     14        6    Seriale DB9
Diecimila        ATmega168          16KB   1KB     14        6    FTDI
Duemilanove      ATmega168/328   16/32KB 1/2KB   14        6    FTDI
Nano             ATmega168/328   16/32KB 1/2KB   14        8    FTDI
Mini             ATmega168          16KB   1KB     14        6    Adattatore
LilyPad          ATmega168/328V     16KB   1KB     14        6    Nessuno (⌀50mm)
BT               ATmega168          16KB   1KB     14        6    Bluetooth
Mega             ATmega1280        128KB   8KB     54       16    FTDI
Uno              ATmega328P         32KB   2KB     14        6    ATmega8U2
Mega2560         ATmega2560        256KB   8KB     54       16    ATmega8U2
Leonardo         ATmega32u4         32KB 2,5KB    20       12    integrato
Due              Atmel SAM3X8E      512KB  96KB    54       12    ATmega16U2
Zero Pro         Atmel SAMD21 (M0+)  256KB  32KB   14        6    integrato
Yún              ATmega32u4+AR9331  32KB 2,5KB   20       12    integrato+Linux

L'IDE di Arduino è un'applicazione Java multipiattaforma, derivata dall'IDE del linguaggio Processing. Include editor con syntax highlighting, compilatore e upload in un solo click. I programmi Arduino (chiamati sketch) sono scritti in C/C++ con la libreria Wiring che semplifica le operazioni di I/O.

Ogni sketch è composto da due funzioni obbligatorie:

// setup() — eseguita UNA SOLA VOLTA all'avvio
void setup() {
  // inizializza pin, librerie, impostazioni
}

// loop() — eseguita RIPETUTAMENTE fino allo spegnimento
void loop() {
  // codice principale del programma
}

Quando si fa click su "Upload", l'IDE aggiunge automaticamente il file header WProgram.h e una funzione main() che chiama init(), poi setup() una volta, poi loop() in un ciclo infinito.

Esempio classico — lampeggio LED (pin 13):

#define LED_PIN 13

void setup() {
  pinMode(LED_PIN, OUTPUT);   // abilita il pin 13 come uscita
}

void loop() {
  digitalWrite(LED_PIN, HIGH); // accende il LED
  delay(1000);                  // aspetta 1 secondo
  digitalWrite(LED_PIN, LOW);  // spegne il LED
  delay(1000);                  // aspetta 1 secondo
}

Tipi di dato principali:

boolean       // true / false
char          // singolo carattere ASCII (-128 ... 127)
byte          // intero senza segno (0 ... 255)
int           // intero con segno (-32.768 ... 32.767) — il più usato
unsigned int  // intero senza segno (0 ... 65.535)
long          // intero lungo (-2.147.483.648 ... 2.147.483.647)
unsigned long // intero lungo senza segno (0 ... 4.294.967.295)
float         // numero in virgola mobile (4 byte)
double        // doppia precisione in virgola mobile
String        // stringa di testo (oggetto)
char[]        // array di caratteri (stringa C-style)
array         // es: int Luce[4] = {0, 25, 50, 100};

Strutture di controllo principali:

// if...else — decisione condizionale
if (val == 1) { digitalWrite(LED, HIGH); }
else          { digitalWrite(LED, LOW);  }

// for — ciclo con contatore
for (int i = 0; i < 10; i++) { Serial.print("Ciao"); }

// while — ciclo condizionale
while (valoreSensore < 500) {
  digitalWrite(13, HIGH);
  valoreSensore = analogRead(1);
}

// switch — selettore a casi multipli
switch (valoreSensore) {
  case 38: digitalWrite(12, HIGH); break;
  case 55: digitalWrite(3,  HIGH); break;
  default: digitalWrite(12, LOW);
}

Operatori aritmetici e booleani: + - * / % (modulo), == != < > <= >=, && (AND), || (OR), ! (NOT). Operatori computazionali: ++ -- += -= *= /=.

Funzioni di I/O digitale e analogico:

// Digitale
pinMode(13, OUTPUT);          // configura il pin come uscita o entrata
digitalWrite(7, HIGH);        // imposta pin digitale HIGH o LOW
int val = digitalRead(7);    // legge HIGH o LOW da un pin

// Analogico
int val = analogRead(0);     // legge tensione 0-5V → 0-1023
analogWrite(9, 128);          // PWM: valore 0-255 su pin PWM
                               // es. 128 = 50% luminosità LED

// PWM disponibile sui pin 3, 5, 6, 9, 10, 11 (Uno)

Funzioni di tempo:

delay(1000);                   // pausa di 1000 millisecondi (1 s)
delayMicroseconds(2000);       // pausa di 2000 microsecondi (2 ms)
unsigned long t = millis();   // ms trascorsi dall'avvio del programma
unsigned long t = micros();   // µs trascorsi dall'avvio

Funzioni matematiche:

min(x, y)                     // restituisce il minore tra x e y
max(x, y)                     // restituisce il maggiore tra x e y
abs(x)                        // valore assoluto
constrain(x, a, b)            // limita x nell'intervallo [a, b]
map(val, 0, 1023, 100, 200)   // rimappa un valore tra due range
pow(base, esponente)          // potenza
sqrt(x)                       // radice quadrata
sin(rad) / cos(rad) / tan(rad)

randomSeed(seed);             // inizializza il generatore pseudo-casuale
long n = random(0, 13);       // numero random tra 0 e 12

Comunicazione seriale (USB):

Serial.begin(9600);           // apre la porta seriale a 9600 bps
Serial.print(32);             // invia 32 come testo decimale
Serial.print(32, BIN);        // invia 100000 (binario)
Serial.print(32, HEX);        // invia 20 (esadecimale)
int n = Serial.available();   // bytes in attesa nel buffer
int d = Serial.read();        // legge 1 byte dalla seriale
Serial.flush();               // svuota il buffer in ingresso

I pin di Arduino configurati come INPUT dispongono di una resistenza interna di pull-up che li mantiene a livello logico 1 (HIGH) quando non sono collegati a nulla. Principali configurazioni di ingresso:

• Pulsante/interruttore verso GND — il modo più semplice: a pulsante rilasciato l'ingresso vale 1 (pull-up interno), premuto vale 0.
• Pulsante verso +5V — richiede una resistenza di pull-down da 470 Ω verso GND per contrastare il pull-up interno.
• Porte logiche TTL/CMOS a 5V — le uscite di porte logiche si collegano direttamente ai pin di ingresso di Arduino.
• Ingressi a 12/24V — si riduce la tensione con un partitore resistivo. Per 12 V: R1 = 1kΩ, R2 = 680Ω. Per 24 V: R1 = 2,2kΩ. Si può aggiungere un condensatore da 100 nF in parallelo a R2 per migliorare la reiezione ai disturbi.
• Ingresso optoisolato — garantisce isolamento galvanico completo tra segnali esterni e Arduino tramite un optoisolatore.
• Potenziometro (misura resistenza/tempo) — misura il tempo di carica di un condensatore tramite la resistenza variabile; versione migliorata con diodo D1 per scarica istantanea.
• Encoder meccanico, finecorsa, sensore magnetico, sensore antifurto — tutti si collegano come comuni interruttori, verso GND o verso +5V con opportuna resistenza di pull-down.
• Ingresso in corrente alternata — per leggere segnali AC (campanelli 12-24V, quadri elettrici) si usa un circuito raddrizzatore dedicato.

I pin configurati come OUTPUT possono erogare al massimo 40 mA ciascuno. I principali dispositivi pilotabili:

• LED (configurazione negativa) — anodo verso +5V, catodo verso il pin di Arduino tramite resistenza da 390 Ω (~10 mA). Il LED si accende quando il pin è LOW. Configurazione alternativa (positiva): catodo verso GND tramite resistenza, si accende quando il pin è HIGH.
• LED doppio / bicolore — due LED collegati in antiparallelo tra il pin e GND (con resistenze da 390 Ω ciascuno): uno si accende quando il pin è HIGH, l'altro quando è LOW.
• Gruppi di LED — fino a 12 LED per uscita in due catene da 6, con resistenza da 390 Ω in serie. Con meno LED aumentare la resistenza (5 LED → 470 Ω, 4 LED → 680 Ω, ecc.).
• Relè a 5V/9V/12V — pilotato tramite transistor con diodo flyback in antiparallelo sulla bobina. Isola il carico esterno dal circuito Arduino. Attenzione: per carichi a 220V rispettare le norme di sicurezza.
• Buzzer a 5V — pilotato direttamente da un pin OUTPUT (solo cicalini elettronici, max 40 mA).
• Buzzer a 12V — tramite transistor Darlington (es. TIP122) fino a 100 mA.
• Lampade a bassa tensione (3-24V CC) — transistor Darlington di potenza (TIP122); con segnale PWM si modula l'intensità luminosa.
• Lampade a 220V — tramite optoTRIAC per isolare il circuito Arduino dalla rete. Usare TRIAC da almeno 600V/5A per carichi fino a 200W. Non adatto per motori, trasformatori, lampade al neon.
• Motori DC (ON/OFF) — transistor Darlington per motori fino a 48V/600 mA.
• Motori DC (avanti/stop/indietro) — ponte H con due circuiti a mezzo ponte; le combinazioni delle 2 uscite definono: 00=stop, 01=avanti, 10=indietro, 11=stop.
• Motori passo-passo bipolari — 4 circuiti a mezzo ponte, sequenza di pilotaggio a 4 passi; invertendo la sequenza si inverte la rotazione.

Una volta completato il proprio progetto su breadboard, per renderlo permanente senza sacrificare la scheda Arduino originale si può costruire una board compatibile su stripboard (basetta millefori) a basso costo.

Componenti necessari:

• Microcontrollore ATmega328P con bootloader Arduino preinstallato
• Stripboard con almeno 23×14 fori
• Regolatore di tensione LM7805
• 2 condensatori elettrolitici 100 µF / 25V (C1, C2)
• 2 condensatori ceramici 100 nF (C3, C4)
• 2 condensatori ceramici a disco (C5, C6) per l'oscillatore
• Socket DIP a 28 pin per l'ATmega
• Connettore femmina a 6 pin per la programmazione seriale
• Switch per il RESET
• 2 resistenze da 10 kΩ (marrone-nero-arancione)
• Quarzo da 16 MHz
• Cavo USB-seriale per la programmazione

Fasi di assemblaggio:

1.  ALIMENTAZIONE: LM7805 + condensatori (C1-C4).
    Row 1 = ingresso alimentazione positiva (7-12V),
    Row 2 = GND (negativo),
    Row 3 = uscita 5V stabilizzata.
    ⚠️ Non invertire la polarità: brucia l'LM7805!

2.  VERIFICA: con un multimetro misura la tensione tra
    Row 2 e Row 3 → deve essere ~5V.

3.  SOCKET + CONNETTORE: salda il socket DIP-28 e il
    connettore seriale a 6 pin sulla stripboard.

4.  CIRCUITO DI RESET: resistenza da 10kΩ tra Row 3
    (+5V) e Row 8 (mantiene RESET alto),
    switch tra Row 6 e Row 2 (GND).
    Un cavetto collega Row 4 e Row 8.

5.  CONNETTORE SERIALE: collega VCC del connettore
    a +5V, TX del connettore a RX dell'ATmega e
    RX del connettore a TX dell'ATmega
    (con resistenza di disaccoppiamento).

6.  OSCILLATORE: quarzo + 2 condensatori ceramici
    (C5, C6) collegati ai pin XTAL1 e XTAL2
    dell'ATmega. Nessuna polarità da rispettare.

7.  ULTIMI COLLEGAMENTI: GND e alimentazione agli
    appositi pin dell'ATmega; eventuali pin di I/O
    su connettore femmina aggiuntivo a 3 pin.

8.  PROGRAMMAZIONE: inserire l'ATmega nel socket,
    collegare il cavo USB-seriale, caricare lo sketch
    dall'IDE di Arduino → done!