Collegare batterie in serie e parallelo: tensione e Arduino
Collegare batterie in serie aumenta la tensione, in parallelo la capacità. Esempi con AA, 9 V e 18650, portabatterie e pacco giusto per Arduino.
Collegare le batterie in serie significa unire il polo positivo di una al negativo dell'altra per sommare le tensioni: con quattro pile AA da 1,5 V in serie ottieni 6 V, ma la capacità resta quella di una sola pila. In parallelo invece tutti i positivi e tutti i negativi vengono uniti tra loro: la tensione non cambia, mentre capacità e corrente erogabile si sommano. Quando vuoi rendere portatile il tuo progetto con Arduino, ESP32 o Raspberry Pi Pico, sapere quante batterie usare e come collegarle decide se il progetto durerà ore o pochi minuti.
In questo articolo vedrai con le formule come serie e parallelo cambiano tensione e capacità. Spieghiamo passo passo esempi reali con pile AA, 9 V e 18650, perché mescolare batterie diverse è pericoloso, come scegliere il portabatterie giusto e come trovare la combinazione adatta alla tua scheda. Alla fine trovi codice pronto per misurare il livello della batteria con un partitore di tensione su Arduino, ESP32 e Pico.

Cos'è il collegamento in serie e come funziona?
In serie metti le batterie una dopo l'altra come in una catena: il positivo della prima va al negativo della seconda, il positivo della seconda al negativo della terza; il primo negativo libero e l'ultimo positivo sono i poli del pacco. Poiché la corrente attraversa tutte le batterie una dopo l'altra, ognuna porta la stessa corrente e le tensioni si sommano: V_totale = V1 + V2 + … + Vn. La capacità invece non si somma: quattro batterie da 2500 mAh in serie danno ancora un pacco da 2500 mAh, perché tutte scaricano la stessa carica nello stesso momento. Per esempio quattro AA alcaline danno 4 × 1,5 = 6 V, due celle 18650 danno 2 × 3,7 = 7,4 V. In elettronica il numero di celle in serie si indica con la lettera "S": 2S sono due celle in serie, 3S tre.
Collegamento in parallelo: stessa tensione, più capacità
In parallelo tutti i poli positivi si uniscono in un punto e tutti i negativi in un altro. La tensione resta quella di una sola batteria, ma la capacità si somma: C_totale = C1 + C2 + … + Cn. Poiché la corrente del carico si divide tra le batterie, ognuna è meno sollecitata, il pacco dura di più e può erogare correnti più alte. Il numero di celle in parallelo si indica con "P": un pacco 2S2P è formato da quattro celle, due gruppi in serie collegati in parallelo, e con 18650 da 2500 mAh offre 7,4 V e 5000 mAh. Per capire quanta energia porta davvero un pacco guarda i wattora: E (Wh) = V × Ah. Quattro pile da 1,5 V e 2,5 Ah, sia in serie (6 V × 2,5 Ah) sia in parallelo (1,5 V × 10 Ah), danno 15 Wh in totale: il tipo di collegamento non cambia l'energia, ma la tensione e la corrente con cui viene fornita.
| Caratteristica | Serie | Parallelo | Serie-parallelo (2S2P) |
|---|---|---|---|
| Collegamento | Positivo al negativo della batteria successiva | Positivi insieme, negativi insieme | Due gruppi in serie collegati in parallelo |
| Tensione | Si somma (n × V) | Non cambia (V) | 2 × V |
| Capacità (mAh) | Non cambia (C) | Si somma (n × C) | 2 × C |
| Capacità di corrente | Pari a quella di una batteria | Moltiplicata per n | Raddoppiata |
| Esempio 4 × AA (1,5 V, 2500 mAh) | 6 V, 2500 mAh | 1,5 V, 10.000 mAh | 3 V, 5000 mAh |
| Energia totale | 15 Wh | 15 Wh | 15 Wh |
Tipi di batterie: confronto tra AA, 9 V e 18650
| Batteria | Tensione nominale | Tensione piena / scarica | Capacità tipica | Ricaricabile? |
|---|---|---|---|---|
| AA alcalina | 1,5 V | 1,6 V / 0,9–1,0 V | 2000–2800 mAh | No |
| AA NiMH | 1,2 V | 1,4 V / 1,0 V | 1900–2500 mAh | Sì |
| 9 V alcalina | 9 V | 9,5 V / circa 6 V | 400–550 mAh | No |
| 9 V NiMH | 8,4 V | circa 9,8 V / 7 V | 170–300 mAh | Sì |
| 18650 Li-ion | 3,6–3,7 V | 4,2 V / 2,5–3,0 V | 2000–3500 mAh | Sì (con circuito di carica dedicato) |

Esempi pronti: quale combinazione dà quanti volt?
| Combinazione | Tensione | Capacità | Dove va bene |
|---|---|---|---|
| 2 × AA in serie | 3 V (NiMH: 2,4 V) | circa 2500 mAh | Circuiti con LED, semplici circuiti a 3 V |
| 3 × AA in serie | 4,5 V | circa 2500 mAh | VSYS del Pico, pin 5V di Arduino (si indebolisce man mano che si scarica) |
| 4 × AA NiMH in serie | 4,8 V | circa 2000 mAh | Pin 5V di Arduino, servomotori |
| 4 × AA alcaline in serie | 6 V (6,4 V da nuove) | circa 2500 mAh | Servo e motori DC; non va collegato direttamente al pin 5V dell'Uno |
| 6 × AA in serie | 9 V | circa 2500 mAh | VIN di Arduino o jack DC, alimentazione del L298N |
| 1 × 9 V | 9 V | circa 500 mAh | Prove brevi con Arduino, circuiti a basso consumo |
| 1S 18650 | 3,7 V (4,2 V a piena carica) | 2000–3500 mAh | ESP32 (con LDO), VSYS del Pico |
| 2S 18650 in serie | 7,4 V (8,4 V a piena carica) | 2000–3500 mAh | VIN di Arduino Uno / Nano, auto robot |
| 1S2P 18650 | 3,7 V | 4000–7000 mAh | Progetti ESP32 e Pico di lunga durata |
Il rischio di mischiare batterie diverse
In un pacco in serie tutte le batterie portano la stessa corrente, quindi la più debole si scarica per prima. Le altre, ancora cariche, continuano a spingere la corrente attraverso quella scarica, che viene caricata al contrario (inversione di cella). Il risultato è surriscaldamento, fuoriuscita di gas e, nelle alcaline, una perdita bianca e corrosiva che rovina le molle del portabatterie e le piste in rame della scheda. In parallelo il pericolo è diverso: la batteria con tensione più alta spinge corrente direttamente in quella più bassa. Poiché la resistenza interna è molto bassa (circa 20–50 mΩ in una 18650), anche una differenza di 0,3 V tra due celle significa una corrente incontrollata di diversi ampere che le scalda. Usare insieme batterie nuove e vecchie, alcaline e NiMH, da 2000 e da 3000 mAh spreca quindi capacità e crea un rischio per la sicurezza.
- Stessa chimica: non mettere mai celle alcaline, NiMH e Li-ion nello stesso pacco; tensioni e curve di scarica sono diverse.
- Stessa marca, modello e capacità: le resistenze interne devono essere simili; la cella con meno capacità si esaurisce sempre prima.
- Stessa età e stesso livello di carica: sostituisci tutte le batterie del pacco insieme; cambiarne una sola con una nuova rompe l'equilibrio.
- Prima di collegare celle Li-ion in parallelo, equalizza la tensione: la differenza tra le celle deve essere sotto 0,05 V; misurala con il multimetro e, se serve, carica le celle separatamente.
- Usa un BMS nei pacchi Li-ion in serie: i pacchi 2S o 3S vanno usati con una scheda di protezione con bilanciamento (BMS) contro sovraccarica, scarica eccessiva e cortocircuito.
- Fusibile contro il cortocircuito: nei pacchi che possono erogare corrente elevata, un piccolo fusibile o polyfuse sulla linea positiva riduce molto il rischio d'incendio.
Come scegliere il portabatterie?

- Il numero di posti decide la tensione: i portabatterie AA e AAA già pronti sono quasi sempre in serie internamente; scegli la tensione che ti serve in base al numero di posti.
- Modelli con interruttore e coperchio: un portabatterie con interruttore on/off permette di spegnere il circuito senza togliere le pile; quello con coperchio evita che le pile saltino fuori nei robot in movimento.
- Controlla il cablaggio nei portabatterie 18650: alcuni portabatterie doppi 18650 sono cablati in serie (7,4 V), altri in parallelo (3,7 V). Non collegarli al circuito senza aver inserito le celle e misurato l'uscita con il multimetro.
- Capacità di corrente: le molle e i fili sottili dei modelli economici causano una caduta di tensione evidente già a poche centinaia di milliampere. Nei robot con motori DC scegli portabatterie con fili spessi e molle robuste.
- Clip per la 9 V: la batteria 9 V si collega all'alimentazione di Arduino con una clip a scatto e, se vuoi, un adattatore per jack DC; se i poli scoperti della clip si toccano, la batteria va in cortocircuito.
- Lunghezza delle celle protette: le 18650 con circuito di protezione possono arrivare a 67–70 mm e non entrare in portabatterie corti; controlla la lunghezza accettata prima di acquistare.
La combinazione giusta per Arduino, ESP32 e Pico
| Scheda | Ingresso di alimentazione | Intervallo accettato | Batteria consigliata |
|---|---|---|---|
| Arduino Uno / Nano | Pin VIN o jack DC (Uno) | 7–12 V consigliati | 2S 18650 (7,4 V) o 6 × AA (9 V) |
| Arduino Uno / Nano | Pin 5V | 5 V stabilizzati (massimo 5,5 V) | 4 × AA NiMH (4,8 V) o pacco con regolatore |
| Scheda di sviluppo ESP32 | Pin 5V / VIN | 5 V (va al regolatore da 3,3 V sulla scheda) | 1S 18650 + step-up a 5 V oppure 4 × AA NiMH |
| Scheda di sviluppo ESP32 | Pin 3V3 | 3,0–3,6 V | 1S 18650 + regolatore LDO a 3,3 V a bassa caduta |
| Raspberry Pi Pico | Pin VSYS | 1,8–5,5 V | 1S 18650, 3 × AA alcaline o 3 × AA NiMH |
Per stimare quanto durerà la batteria usa questa formula: durata (ore) = capacità (mAh) / corrente media (mA) × 0,8. Il coefficiente 0,8 è il margine per le perdite del regolatore, la temperatura e il fatto che la batteria non si scarica mai del tutto. Un Arduino Uno da solo assorbe circa 45–50 mA; con qualche sensore e LED arriva a 60 mA. Con un pacco 2S 18650 da 2500 mAh funziona 2500 / 60 × 0,8 ≈ 33 ore. Lo stesso circuito con una 9 V da 500 mAh dura solo 500 / 60 × 0,8 ≈ 6,5 ore; e poiché la tensione della 9 V cala in fretta sotto carico, la durata reale è ancora più breve. Un ESP32 con Wi-Fi attivo assorbe in media 80–120 mA, con picchi fino a 250 mA; per questo nei progetti ESP32 una 18650 o un pacco 1S2P, usati insieme al deep sleep, possono durare giorni o addirittura settimane. Se non vuoi fare il calcolo a mano, usa il calcolatore della durata della batteria.
Misurare la tensione della batteria: collegamento del partitore
Il modo più facile per capire quanto è carica una batteria è misurarne la tensione. Però gli 8,4 V di un pacco 2S superano i 5 V che l'ingresso analogico di Arduino può sopportare, e i 4,2 V di una cella 1S superano il limite di 3,3 V di ESP32 e Pico. Per questo costruisci un partitore di tensione con due resistenze: V_out = V_batt × R2 / (R1 + R2). Due resistenze uguali dimezzano esattamente la tensione: 8,4 V diventano 4,2 V e 4,2 V diventano 2,1 V. Poiché il partitore assorbe corrente in continuazione, su ESP32 e Pico usa resistenze da 100 kΩ per salvare la batteria; sull'Uno bastano 10 kΩ per una lettura stabile dell'ADC e a 8,4 V consumano solo 0,42 mA. Puoi adattare i valori al tuo pacco con il calcolatore del partitore di tensione.
| Collegamento | Arduino Uno (2S 18650) | ESP32 (1S 18650) | Raspberry Pi Pico (1S 18650) |
|---|---|---|---|
| Positivo della batteria (+) | Estremo superiore di R1 e VIN | Estremo superiore di R1 e ingresso LDO | Estremo superiore di R1 e VSYS |
| Punto centrale R1 – R2 | A0 | GPIO 34 | GP26 (ADC0) |
| Estremo inferiore di R2 | GND | GND | GND |
| Negativo della batteria (−) | GND | GND | GND |
| Valori delle resistenze | R1 = R2 = 10 kΩ | R1 = R2 = 100 kΩ | R1 = R2 = 100 kΩ |
| Tensione massima sul pin | 4,2 V | 2,1 V | 2,1 V |
Indicatore del livello batteria con Arduino
- Inserisci due celle 18650 nel portabatterie doppio in serie e verifica con il multimetro che l'uscita sia tra 7,4 e 8,4 V.
- Collega il filo positivo del portabatterie al pin VIN dell'Uno (o all'adattatore per jack DC) e il filo negativo a GND.
- Collega due resistenze da 10 kΩ in serie tra il positivo della batteria e GND; porta il punto di unione delle due resistenze ad A0.
- Userai il LED integrato (pin 13) come avviso di batteria scarica; non serve nessun altro componente.
- Carica il codice, apri il Monitor Seriale a 9600 baud e confronta la tensione mostrata con il valore del multimetro.
1const int BAT_PIN = A0; // bölücü orta noktası / divider midpoint
2const int LED_PIN = 13; // düşük pil uyarısı / low battery warning
3const float R1 = 10000.0; // üst direnç / top resistor
4const float R2 = 10000.0; // alt direnç / bottom resistor
5const float VREF = 5.0; // ADC referansı / ADC reference
6const float V_EMPTY = 6.4; // 2S boş (2 x 3,2 V) / 2S empty
7const float V_FULL = 8.4; // 2S dolu (2 x 4,2 V) / 2S full
8const float V_LOW = 6.8; // uyarı eşiği / warning threshold
9
10void setup() {
11 Serial.begin(9600);
12 pinMode(LED_PIN, OUTPUT);
13}
14
15void loop() {
16 long sum = 0;
17 for (int i = 0; i < 16; i++) { // 16 ölçümün ortalaması / average of 16 samples
18 sum += analogRead(BAT_PIN);
19 delay(2);
20 }
21 float raw = sum / 16.0;
22 float vPin = raw * VREF / 1023.0; // pindeki gerilim / voltage at the pin
23 float vBat = vPin * (R1 + R2) / R2; // pil gerilimi / battery voltage
24 int pct = (int)((vBat - V_EMPTY) / (V_FULL - V_EMPTY) * 100.0);
25 pct = constrain(pct, 0, 100); // 0-100 aralığında tut / keep within 0-100
26
27 Serial.print(F("Pil / Battery: "));
28 Serial.print(vBat, 2);
29 Serial.print(F(" V %"));
30 Serial.println(pct);
31
32 digitalWrite(LED_PIN, vBat < V_LOW ? HIGH : LOW); // pil zayıfsa LED yanar / LED on when battery is low
33 delay(1000);
34}Per ridurre il rumore, il codice legge 16 campioni da A0 e ne calcola la media. Il valore grezzo è compreso tra 0 e 1023; moltiplicato per il riferimento di 5 V e diviso per 1023 dà la tensione sul pin, poi moltiplicato per il rapporto del partitore (R1 + R2) / R2 = 2 dà la tensione della batteria. Il calcolo della percentuale considera 6,4 V (3,2 V per cella) come scarica e 8,4 V come carica. Poiché la curva di scarica del Li-ion non è lineare, questa percentuale è solo una stima approssimativa: la cella passa la maggior parte del tempo tra 3,6 e 3,9 V e alla fine crolla rapidamente. Quando la tensione scende sotto 6,8 V, il LED integrato si accende e ti avvisa che è ora di ricaricare. Poiché la misura prende come riferimento la linea 5 V della scheda, con alimentazione USB una tensione bassa come 4,8 V può spostare la lettura di qualche punto percentuale; per un risultato più preciso sostituisci la costante VREF con il valore reale misurato sul pin 5V.
Misurare la batteria con ESP32 e Raspberry Pi Pico
Una singola cella 18650 è la fonte di alimentazione più pratica per ESP32 e Pico. Sull'ESP32 collega il punto centrale del partitore al GPIO 34; questo pin appartiene all'ADC1 e può essere letto anche con il Wi-Fi attivo (i pin ADC2 entrano in conflitto con il Wi-Fi). La funzione analogReadMilliVolts(), presente nelle versioni 2.x e 3.x del core Arduino, restituisce direttamente i millivolt usando la calibrazione di fabbrica della scheda, così non devi occuparti della non linearità dell'ADC dell'ESP32. Sul Pico puoi collegare la cella direttamente al pin VSYS, perché il convertitore buck-boost sulla scheda trasforma un ingresso tra 1,8 e 5,5 V in 3,3 V. Collega l'uscita del partitore a GP26; in MicroPython read_u16() restituisce un valore da 0 a 65535. Sul Pico standard VSYS/3 è già collegato internamente a GP29 e si legge con ADC(29) senza resistenze esterne; sul Pico W questo pin è condiviso con il chip wireless, quindi un partitore esterno è più sicuro.
1const int BAT_PIN = 34; // bölücü orta noktası (ADC1) / divider midpoint (ADC1)
2const float DIVIDER = 2.0; // (R1 + R2) / R2, 100k + 100k
3const float V_EMPTY = 3.2; // boş hücre / empty cell
4const float V_FULL = 4.2; // dolu hücre / full cell
5
6void setup() {
7 Serial.begin(115200);
8 analogReadResolution(12); // 12 bit çözünürlük / 12-bit resolution
9}
10
11void loop() {
12 uint32_t sum = 0;
13 for (int i = 0; i < 16; i++) {
14 sum += analogReadMilliVolts(BAT_PIN); // kalibre mV / calibrated mV
15 delay(2);
16 }
17 float vBat = (sum / 16.0) / 1000.0 * DIVIDER; // pil gerilimi / battery voltage
18 int pct = (int)((vBat - V_EMPTY) / (V_FULL - V_EMPTY) * 100.0);
19 pct = constrain(pct, 0, 100);
20 Serial.printf("Pil / Battery: %.2f V %%%d\n", vBat, pct);
21 delay(2000);
22}1from machine import ADC
2import time
3
4adc = ADC(26) # GP26 = ADC0, bölücü orta noktası / divider midpoint
5DIVIDER = 2.0 # 100k + 100k bölücü / 100k + 100k divider
6V_EMPTY = 3.2 # boş hücre / empty cell
7V_FULL = 4.2 # dolu hücre / full cell
8
9while True:
10 total = 0
11 for _ in range(16): # 16 ölçümün ortalaması / average of 16 samples
12 total += adc.read_u16()
13 time.sleep_ms(2)
14 v_bat = total / 16 * 3.3 / 65535 * DIVIDER # pil gerilimi / battery voltage
15 pct = (v_bat - V_EMPTY) / (V_FULL - V_EMPTY) * 100
16 pct = max(0, min(100, pct)) # 0-100 aralığında tut / keep within 0-100
17 print("Pil / Battery: {:.2f} V %{:.0f}".format(v_bat, pct))
18 time.sleep(2)Idee di progetti a batteria
- Auto robot: alimenta sia Arduino sia il driver dei motori con un pacco 2S 18650; i dettagli sono nell'articolo sulla costruzione di un'auto robot.
- Tester per batterie: costruisci con un partitore di tensione e un LCD uno strumento che mostra il livello di carica delle pile; l'articolo sul voltmetro con Arduino è un buon punto di partenza.
- Stazione di sensori a lunga durata: un ESP32 alimentato da una sola 18650 può misurare, andare in deep sleep e inviare dati per settimane.
- Torcia ricaricabile o luce notturna: con una 1S 18650, un modulo di carica TP4056 e qualche LED costruisci una lampada portatile ricaricabile via USB.
- Console portatile con Pico: un Pico alimentato da 3 × AA su VSYS diventa una console tascabile con un piccolo display e qualche pulsante.
- Allarme di batteria scarica: un piccolo circuito che fa suonare un buzzer quando la tensione del pacco scende sotto la soglia è il modo più economico per proteggere le tue batterie ricaricabili dalla scarica eccessiva.
Errori comuni e come risolverli
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Arduino si resetta di continuo | La batteria 9 V non regge la corrente di motori o servo | Collega i motori a un pacco separato, usa 2S 18650 o 6 × AA, unisci i GND |
| Il pacco dà metà della tensione prevista | Il portabatterie è cablato in parallelo o una batteria è montata al contrario | Controlla il verso di ogni batteria, misura l'uscita con il multimetro |
| Una batteria si scalda o perde liquido | Sono state usate insieme batterie vecchie e nuove o di tipo diverso | Sostituisci tutte le batterie del pacco con batterie nuove dello stesso tipo |
| Il regolatore dell'Uno si scalda molto | Su VIN arriva una tensione superiore a 12 V (es. due 9 V in serie = 18 V) | Resta tra 7 e 12 V o usa un convertitore buck esterno |
| L'ESP32 si spegne quando si connette al Wi-Fi | Batteria debole o filo sottile; la tensione crolla nel picco istantaneo da 250 mA | Usa fili spessi e una cella carica, aggiungi un condensatore da 470 µF sulla linea 3V3 |
| La misura della batteria oscilla | Partitore ad alta resistenza e rumore elettrico | Fai la media, metti un condensatore da 100 nF tra il pin ADC e GND |
| Con il Pico collegato all'USB la batteria si scalda | Non c'è protezione tra batteria e VSYS, la tensione USB spinge corrente nella batteria | Aggiungi un diodo Schottky tra la batteria e VSYS |
In sintesi: se ti serve tensione, collega le batterie in serie; se ti servono autonomia e corrente, in parallelo; se ti servono entrambe, costruisci pacchi serie-parallelo come il 2S2P e usa sempre batterie dello stesso tipo e della stessa età. Per Arduino un 2S 18650, per ESP32 e Pico una singola 18650 o 3 × AA sono la scelta più equilibrata per la maggior parte dei progetti. Per saperne di più sui modi di alimentare la tua scheda dai un'occhiata all'articolo sull'alimentazione di Arduino. Nell'app BlueGrays trovi tante applicazioni, dai circuiti con LED all'auto robot fino ai progetti ESP32 a basso consumo, con schema elettrico e codice passo passo, così puoi provare subito il tuo nuovo pacco batterie in un progetto.
Domande frequenti
Cosa succede se collego le batterie in serie?
In serie le tensioni delle batterie si sommano, mentre la capacità resta quella di una sola batteria. Per esempio, con quattro pile AA da 1,5 V e 2500 mAh in serie ottieni un pacco da 6 V e 2500 mAh. Poiché ogni batteria porta la stessa corrente, devono essere dello stesso tipo e allo stesso livello di carica.
Se collego le batterie in parallelo, la tensione aumenta?
No, in parallelo la tensione resta quella di una sola batteria. Aumentano capacità e corrente erogabile: due 18650 da 3,7 V e 3000 mAh in parallelo danno 3,7 V e 6000 mAh. Prima di collegare celle Li-ion in parallelo bisogna equalizzarne le tensioni.
Quanto dura Arduino con una batteria da 9 V?
Una 9 V alcalina standard ha circa 500 mAh e può alimentare un Arduino Uno, che da solo assorbe 45–50 mA, al massimo per 6–8 ore. Aggiungendo sensori, LED o motori la durata scende a poche ore. Per progetti lunghi un pacco 2S 18650 o 6 × AA dà risultati molto migliori.
Si possono usare insieme batterie vecchie e nuove?
No. In serie la batteria vecchia e più debole si scarica per prima e viene caricata al contrario dalle altre, con surriscaldamento e perdite. Sostituisci sempre tutte le batterie del pacco insieme, con batterie nuove della stessa marca e dello stesso tipo.
Posso alimentare Arduino con 4 pile stilo?
Quattro AA alcaline danno 6,4 V da nuove: troppo per il pin 5V e poco per l'ingresso VIN, quindi non è la scelta giusta. Quattro pile NiMH ricaricabili danno 4,8 V e possono andare sul pin 5V. Se usi VIN o il jack DC, scegli 6 × AA (9 V) o 2S 18650 (7,4 V).
Come si caricano le 18650 collegate in serie?
Un pacco 2S di due 18650 in serie si carica con un caricabatterie 2S da 8,4 V e una scheda di protezione BMS che bilancia le celle. I moduli monocella come il TP4056 caricano solo fino a 4,2 V, quindi non vanno bene per un pacco 2S. In alternativa puoi estrarre le celle dal portabatterie e caricarle una a una.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
LED lampeggiante
Il primissimo ciao dell'elettronica: accendere e spegnere un solo LED. L'Arduino accende e spegne il LED a intervalli brevissimi, così la luce lampeggia veloce.

Semaforo
Una copia in miniatura del semaforo che vedi ogni giorno per strada. Il rosso resta acceso due secondi, il giallo brilla per un attimo, il verde resta due secondi, poi si torna al rosso passando di…

LED Lampeggiante con ESP32
Insegna l'uso di base delle uscite GPIO con l'ESP32. Otteniamo un effetto lampeggiante accendendo e spegnendo un LED dal pin digitale. Versione ESP32 del classico progetto blink su Arduino UNO; i comandi di base di blink nell'ambiente Arduino sono gli stessi, ma la disposizione dei pin e i livelli GPIO a 3,3 V dell'ESP32 sono diversi da quelli di Arduino UNO.

Lampeggio LED Integrato Raspberry Pi Pico (Pico e Pico W)
Il progetto d'apertura della serie Raspberry Pi Pico! Facciamo lampeggiare il LED verde integrato del Pico per verificare che la scheda funzioni: il classico primo esperimento in stile "Hello World". Niente componenti esterni, bastano il Pico e un cavo USB. Il codice è scritto in MicroPython, il linguaggio supportato ufficialmente dalla Raspberry Pi Foundation.

Voltmetro digitale con display LCD
Scopri quanta tensione dà una pila o un alimentatore con uno strumento costruito da te.

Auto controllata via Bluetooth con L298N
Trasforma il telefono in un telecomando e guida la tua auto robot. L'Arduino riceve tramite un modulo Bluetooth i comandi di un'app di controllo remoto sul telefono e fa girare le ruote con un driver…

Robot che evita gli ostacoli
Che ne dite di costruire un veicolo intelligente che trova la propria strada? L'Obstacle Avoiding Robot scruta costantemente l'ambiente circostante grazie al sensore a ultrasuoni posto davanti a lui.

ESP32 Deep Sleep — Risparmio della batteria (OLED + contatore in RTC RAM)
La modalità Deep Sleep dell'ESP32 spegne la CPU e quasi tutte le periferiche e riduce il consumo a circa 10µA, un aspetto cruciale per i dispositivi IoT a batteria. Il progetto usa tre sorgenti di risveglio: un timer (15 s), un pin esterno (EXT0, il pulsante su GPIO 33) e un pin touch (T0/GPIO 4). I contatori marcati con RTC_DATA_ATTR restano salvati durante il deep sleep.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

