Arduino Pro Mini: programmazione, pinout e basso consumo a pile
Cos'è l'Arduino Pro Mini? 3,3 V o 5 V, programmazione con USB-TTL, pinout, sleep in µA con LowPower, sensore nRF24 a batteria e confronto con il Nano.
L'Arduino Pro Mini è una scheda Arduino con lo stesso processore ATmega328P dell'Arduino Uno, ma misura appena 18 × 33 mm e non ha la presa USB. Esiste in due versioni, 3,3 V / 8 MHz e 5 V / 16 MHz, e si programma con un convertitore USB-TTL. Le dimensioni ridotte, il prezzo basso e una corrente di sleep che, se preparata bene, scende a pochi microampere la rendono la scheda preferita per sensori wireless che funzionano mesi o anche anni a batteria, progetti indossabili e circuiti fissi chiusi in una scatola.
In questa guida imparerai la differenza tra le due versioni e come capire quale hai, il pinout, i pin di alimentazione RAW e VCC e la programmazione con un convertitore USB-TTL con reset automatico tramite DTR. Poi manderai la scheda in sleep con la libreria LowPower, porterai il consumo da milliampere a microampere togliendo il LED di alimentazione e il regolatore, e costruirai un nodo sensore a batteria che invia la temperatura misurata con un nRF24L01. Nell'ultima sezione confronterai il Pro Mini con l'Arduino Nano per capire quale scegliere e quando.

Cos'è l'Arduino Pro Mini? Versioni da 3,3 V e 5 V
Il Pro Mini è stato progettato in origine da SparkFun; la maggior parte delle schede in commercio oggi sono cloni dello stesso progetto aperto. La scheda monta l'ATmega328P, cuore dell'Uno, un quarzo, un piccolo regolatore di tensione, due LED e un pulsante di reset; non ha chip USB, presa USB né un grande stadio di alimentazione. Quasi tutto il codice scritto per l'Uno funziona senza modifiche. La vera scelta riguarda la tensione di lavoro. L'ATmega328P ha bisogno di circa 3,8 V o più per funzionare in modo affidabile a 16 MHz, per questo la versione da 3,3 V ha un quarzo da 8 MHz e va a metà velocità. In cambio, la versione da 3,3 V parla con moduli a 3,3 V come nRF24L01, BME280 o una scheda SD senza convertitore di livello e si può alimentare direttamente da una batteria.
| Caratteristica | Versione 3,3 V / 8 MHz | Versione 5 V / 16 MHz |
|---|---|---|
| Processore | ATmega328P | ATmega328P |
| Frequenza di clock | 8 MHz | 16 MHz |
| Livello logico e VCC | 3,3 V | 5 V |
| Ingresso RAW | 3,35–12 V | 5–12 V |
| Memoria programma | 32 KB (30 KB utilizzabili, 2 KB di bootloader) | 32 KB (30 KB utilizzabili) |
| SRAM / EEPROM | 2 KB / 1 KB | 2 KB / 1 KB |
| Pin digitali / PWM | 14 / 6 | 14 / 6 |
| Ingressi analogici | 8 (A0–A7) | 8 (A0–A7) |
| Velocità di caricamento | 57600 baud | 57600 baud |
| Scritta sul quarzo | 8.000 | 16.000 |
| Ideale per | Sensori a batteria, moduli a 3,3 V | Sensori a 5 V, relè e driver LED, lavori che richiedono velocità |
Pinout dell'Arduino Pro Mini
Il Pro Mini ha 12 pin su ciascun lato lungo e il connettore di programmazione a sei pin sul lato corto. I numeri dei pin sono esattamente quelli dell'Uno, quindi puoi provare un progetto sull'Uno e portarlo sul Pro Mini con lo stesso codice. L'unica differenza da tenere presente è che A4, A5, A6 e A7 non sono sul bordo ma in fori separati all'interno della scheda. Per vedere al volo cosa c'è su ogni pin puoi consultare anche lo strumento pinout.
| Pin | Funzione | Nota |
|---|---|---|
| D0 (RXI), D1 (TXO) | Porta seriale (UART) | Collegati al connettore di programmazione; scollega eventuali moduli su questi pin durante il caricamento |
| D2, D3 | Interrupt esterno (INT0, INT1) | I pin migliori per risvegliare la scheda |
| D3, D5, D6, D9, D10, D11 | PWM (analogWrite) | Come sull'Uno |
| D10, D11, D12, D13 | SPI (SS, MOSI, MISO, SCK) | nRF24L01, scheda SD, display TFT |
| D13 | LED integrato | Condiviso con il clock SPI; il LED tremola quando usi l'SPI |
| A0–A3 | Ingresso analogico o pin digitale | Sul lato lungo |
| A4 (SDA), A5 (SCL) | I2C | All'interno della scheda; nei cloni la posizione può cambiare |
| A6, A7 | Solo ingresso analogico | pinMode e digitalRead non funzionano su questi pin |
| RAW | Ingresso del regolatore | Qui va la batteria o l'alimentatore |
| VCC | 3,3 V o 5 V regolati | Uscita del regolatore; si può anche alimentare direttamente da una sorgente regolata |
| RST | Reset | Portandolo a GND la scheda si riavvia |
| BLK, GND, VCC, RXI, TXO, GRN | Connettore di programmazione | BLK = GND, GRN = DTR (reset automatico) |
Alimentazione: RAW, VCC e il regolatore
Puoi alimentare il Pro Mini in due modi. Se colleghi una sorgente non regolata (pila da 9 V, 3 stilo AA o un pacco da 7,4 V) al pin RAW, il piccolo regolatore della scheda la porta a 3,3 V o 5 V. Se hai già una tensione regolata, come l'uscita del convertitore USB-TTL o 2 stilo AA, la porti direttamente al pin VCC e il regolatore viene escluso. Il regolatore integrato di solito è un piccolo LDO da circa 150 mA (un MIC5205 nell'originale, componenti simili nei cloni). Basta per la scheda e qualche sensore, ma non alimentare da lì componenti che assorbono molto come servo, strisce LED lunghe o moduli Wi-Fi.
| Sorgente | Pin da usare | Nota |
|---|---|---|
| Pila da 9 V o alimentatore 7–12 V | RAW | Il regolatore trasforma l'eccesso in calore; scalda a 12 V e con correnti alte |
| Pacco Li-ion 2S (7,4 V) | RAW | Va bene per entrambe le versioni |
| Singola cella Li-ion (3,0–4,2 V) | RAW (versione 3,3 V) | Non basta per la versione a 5 V |
| 2 stilo AA (2,4–3,2 V) | VCC (versione 3,3 V) | Salta il regolatore; ideale per il consumo minimo |
| Convertitore USB-TTL | VCC | Durante la programmazione; scegli 3,3 V o 5 V secondo la versione |
| 5 V già regolati (caricatore USB, powerbank) | VCC (versione 5 V) | Su RAW il regolatore non avrebbe abbastanza margine |
Programmazione con convertitore USB-TTL e reset tramite DTR

Non avendo un chip USB, per caricare il codice sul Pro Mini ti serve un convertitore USB-TTL esterno (CH340, CP2102 o FT232). Durante il caricamento la scheda deve resettarsi, perché il bootloader accetta un nuovo programma solo nel breve intervallo dopo l'avvio. Collegando il pin DTR del convertitore al pin GRN del Pro Mini, il condensatore da 100 nF sulla scheda trasforma la discesa di DTR in un breve impulso di reset e il caricamento avviene senza toccare il pulsante. Spesso l'ordine dei pin coincide e il convertitore si innesta direttamente sul connettore del lato corto, ma confronta sempre le scritte prima.
| USB-TTL | Pro Mini | Nota |
|---|---|---|
| GND | GND / BLK | Massa comune |
| VCC (3,3 V o 5 V) | VCC | Imposta il ponticello secondo la versione della scheda |
| TXD | RXI | Collegamento incrociato |
| RXD | TXO | Collegamento incrociato |
| DTR | GRN | Reset automatico |
- Nell'Arduino IDE scegli Strumenti > Scheda > Arduino AVR Boards > Arduino Pro or Pro Mini.
- Da Strumenti > Processore scegli l'opzione della tua scheda: ATmega328P (3.3V, 8 MHz) o ATmega328P (5V, 16 MHz).
- Da Strumenti > Porta scegli la porta del convertitore (per esempio COM3 su Windows, /dev/cu.usbserial... o /dev/cu.wchusbserial... su macOS).
- Apri File > Esempi > 01.Basics > Blink e premi Carica. Il LED su D13 dovrebbe lampeggiare una volta al secondo.
- Se il LED cambia ogni due secondi hai caricato una scheda a 8 MHz con l'opzione a 16 MHz; se cambia ogni mezzo secondo è il contrario. Correggi il processore e ricarica.
Se il convertitore non ha il pin DTR, sincronizzi il caricamento a mano: appena l'IDE finisce di compilare e nella finestra di output compare "Uploading...", premi e rilascia il pulsante di reset del Pro Mini. Se non hai alcun convertitore, puoi usare temporaneamente un Arduino Uno al suo posto: collega il pin RESET dell'Uno a GND, il pin 0 (RX) dell'Uno al RXI del Pro Mini e il pin 1 (TX) al suo TXO. In questo caso il collegamento è diretto e non incrociato, perché il chip USB dell'Uno fa già la traduzione. Se durante il caricamento compare l'errore "stk500_getsync(): not in sync", trovi le soluzioni nell'articolo Arduino non carica lo sketch.
Basso consumo: modalità sleep e libreria LowPower
Un sensore di solito misura ogni cinque minuti e per oltre il 99% del tempo intermedio non fa nulla. Aspettare con delay() lascia il processore a piena velocità; nel frattempo un Pro Mini a 3,3 V assorbe qualche milliampere. La modalità di sleep più profonda dell'ATmega328P è il power-down: il clock si ferma, restano attivi solo il watchdog e gli interrupt esterni, e il consumo del chip scende a pochi microampere. La libreria Low-Power di Rocket Scream (cercala come "Low-Power" nel Gestore librerie) riduce queste complesse impostazioni dei registri a una sola riga. Il watchdog conta al massimo 8 secondi, quindi le pause più lunghe si fanno in un ciclo; anche un pulsante o un sensore su D2 o D3 può risvegliare la scheda.
1// Pro Mini uyku testi: LED yanar, kart 8 sn uyur; D2'deki buton erken uyandırır
2// Pro Mini sleep test: the LED lights, the board sleeps 8 s; a button on D2 wakes it early
3#include <LowPower.h>
4
5const int LED = 13;
6const int WAKE_PIN = 2; // INT0, buton GND'ye / button to GND
7volatile bool buttonWake = false;
8
9void onWake() {
10 buttonWake = true; // kesmede yalnız bayrak kaldır / only set a flag in the ISR
11}
12
13void setup() {
14 pinMode(LED, OUTPUT);
15 pinMode(WAKE_PIN, INPUT_PULLUP);
16}
17
18void loop() {
19 digitalWrite(LED, HIGH);
20 delay(buttonWake ? 100 : 1000); // butonla uyandıysa kısa yan / short flash after a button wake
21 digitalWrite(LED, LOW);
22 buttonWake = false;
23
24 attachInterrupt(digitalPinToInterrupt(WAKE_PIN), onWake, LOW);
25 LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF); // 8 sn ya da buton / 8 s or the button
26 detachInterrupt(digitalPinToInterrupt(WAKE_PIN));
27}powerDown() riceve tre parametri. Il primo è la durata dello sleep: le opzioni vanno da SLEEP_15MS a SLEEP_8S, più SLEEP_FOREVER per risvegliarsi solo con un interrupt. L'oscillatore del watchdog non è preciso come un quarzo, quindi uno sleep di 8 secondi può scostarsi di circa il 10% con temperatura e tensione; se ti servono tempi precisi, è meglio risvegliare la scheda con l'uscita di allarme di un modulo RTC. Il secondo parametro spegne l'ADC durante lo sleep. Il terzo disattiva in sleep il rilevatore di sottotensione (BOD), risparmiando circa altri 20 µA. Con attachInterrupt il risveglio avviene su D2 e D3 (gli altri pin richiedono un interrupt di cambio stato); in modalità power-down questi due pin reagiscono solo al livello LOW, per questo il codice usa LOW e scollega l'interrupt appena si risveglia.
Scendere ai microampere togliendo il LED e il regolatore
Quando la scheda dorme il processore non consuma quasi nulla, eppure misuri ancora 1–3 mA. La colpa è di due componenti sulla scheda: il LED di alimentazione, sempre acceso, da solo consuma 1–3 mA, e il regolatore assorbe corrente per il proprio circuito interno anche senza carico (circa 80 µA per i regolatori tipo MIC5205). Togliendo questi due componenti, il Pro Mini scende a circa 4–5 µA con il watchdog attivo e sotto 1 µA quando dorme aspettando solo un interrupt esterno. La tabella mostra i valori tipici di una scheda da 3,3 V / 8 MHz e la durata teorica con i circa 2000 mAh di due stilo AA. Per fare il calcolo con i tuoi valori usa il calcolatore di durata della batteria.
| Stato (3,3 V / 8 MHz) | Corrente approssimativa | Durata teorica con 2000 mAh |
|---|---|---|
| Non dorme mai, aspetta con delay() | 4–5 mA | Circa 17–21 giorni |
| Sleep con LowPower, scheda di serie | 1–3 mA | Circa 1–3 mesi |
| LED di alimentazione rimosso | Circa 80–100 µA (dipende dal regolatore) | Circa 2–3 anni |
| LED e regolatore rimossi, sleep watchdog di 8 s | Circa 4–5 µA | Oltre 40 anni sulla carta; in pratica limita l'autoscarica della pila |
| LED e regolatore rimossi, SLEEP_FOREVER | Sotto 1 µA | Limitato dalla durata a magazzino della pila |
- Per prima cosa misura la corrente in sleep: imposta il multimetro sulla portata mA e collegalo in serie tra il positivo della batteria e il pin di alimentazione della scheda. Quando il valore scende sotto 1 mA, passa alla portata µA.
- Trova il LED di alimentazione: è il piccolo LED che resta acceso finché la scheda è alimentata (quello su D13 è quello che lampeggia). Scalda a turno i suoi due capi con il saldatore e sollevalo, oppure togli la resistenza in serie accanto; anche tagliare la sua pista con un taglierino funziona.
- Trova il regolatore: è il piccolo componente SOT-23 a cinque piedini vicino al pin RAW. Aggiungi abbondante stagno sui piedini e scaldali tutti insieme per sollevarlo.
- Tolto il regolatore, il pin RAW non funziona più. Alimenta la scheda direttamente da VCC, con 1,8–3,6 V per la versione da 3,3 V: due stilo AA, una cella LiFePO4 o una singola cella Li-ion dietro un regolatore che a vuoto assorbe pochi microampere, come l'HT7333 o l'MCP1700.
- Misura di nuovo la corrente. Se non sei intorno a 4–5 µA, la colpa è quasi sicuramente di un modulo collegato: LED e regolatori dei moduli assorbono corrente allo stesso modo.
Un sensore che funziona per mesi a batteria: NTC e nRF24L01

Ora mettiamo tutto insieme: un Pro Mini da 3,3 V si sveglia ogni cinque minuti, misura la temperatura con un termistore NTC e la propria tensione di alimentazione, invia il risultato a un ricevitore con un nRF24L01 e torna a dormire. Ci sono due trucchi importanti. Primo, il partitore dell'NTC non è collegato a 5V o VCC ma a un pin digitale, così assorbe corrente solo per i pochi millisecondi della misura. Un partitore da 10 kΩ + 10 kΩ sempre acceso a 3 V sprecherebbe 150 µA, trenta volte la corrente di sleep. Secondo, per la tensione della batteria non servono componenti aggiuntivi: il codice calcola VCC in millivolt confrontando il riferimento interno da 1,1 V dell'ATmega328P con l'alimentazione. Dato che la misura dell'NTC è raziometrica, la temperatura resta corretta anche quando la tensione cala.
| Componente | Pro Mini (3,3 V) | Nota |
|---|---|---|
| nRF24L01 VCC / GND | VCC / GND | Solo 3,3 V; metti un condensatore da 10–100 µF sui pin del modulo |
| nRF24L01 CE / CSN | D9 / D10 | RF24 radio(9, 10) nel codice |
| nRF24L01 SCK / MOSI / MISO | D13 / D11 / D12 | Pin SPI hardware |
| Alimentazione del partitore NTC | D4 → 10 kΩ → A0 | HIGH solo durante la misura |
| NTC 10 kΩ (B = 3950) | A0 → NTC → GND | Si può prolungare fino al punto di misura |
| Batteria | VCC e GND (regolatore rimosso) | 2 stilo AA o LiFePO4 |
1// Pille çalışan sıcaklık düğümü: Pro Mini 3,3 V + NTC + nRF24L01
2// Battery-powered temperature node: Pro Mini 3.3 V + NTC + nRF24L01
3#include <SPI.h>
4#include <RF24.h>
5#include <LowPower.h>
6
7RF24 radio(9, 10); // CE, CSN
8const byte ADDRESS[6] = "NODE1"; // alıcıyla aynı adres / same address as the receiver
9const int NTC_PWR = 4; // bölücüyü besleyen pin / pin that powers the divider
10const int NTC_PIN = A0;
11const int SLEEP_CYCLES = 37; // 37 x 8 sn = yaklaşık 5 dk / about 5 minutes
12const float R_FIXED = 10000.0; // sabit direnç / fixed resistor
13const float R0 = 10000.0; // NTC'nin 25 °C direnci / NTC resistance at 25 °C
14const float BETA = 3950.0; // NTC B katsayısı / NTC beta coefficient
15const float T0 = 298.15; // 25 °C kelvin / 25 °C in kelvin
16const byte UNUSED[] = {2, 3, 5, 6, 7, 8, A1, A2, A3};
17
18struct Packet {
19 uint8_t nodeId;
20 int16_t tempC10; // 23,4 °C -> 234
21 uint16_t vccMv; // pil gerilimi (mV) / battery voltage (mV)
22 uint16_t counter;
23};
24Packet pkt = {1, 0, 0, 0};
25
26long readVccMv() {
27 ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1); // AVcc'ye karşı 1,1 V / 1.1 V against AVcc
28 delay(2);
29 ADCSRA |= _BV(ADSC);
30 while (bit_is_set(ADCSRA, ADSC)) {}
31 return 1100L * 1024L / ADCW;
32}
33
34float readTempC() {
35 digitalWrite(NTC_PWR, HIGH); // bölücüye yalnız şimdi güç ver / power the divider only now
36 delay(2);
37 analogRead(NTC_PIN); // ilk okumayı at / discard the first reading
38 int raw = analogRead(NTC_PIN);
39 digitalWrite(NTC_PWR, LOW);
40 raw = constrain(raw, 1, 1022);
41 float rNtc = R_FIXED * raw / (1024.0 - raw); // oransal, VCC'den bağımsız / ratiometric
42 return 1.0 / (1.0 / T0 + log(rNtc / R0) / BETA) - 273.15;
43}
44
45void setup() {
46 for (byte i = 0; i < sizeof(UNUSED); i++) pinMode(UNUSED[i], INPUT_PULLUP); // boşta kalmasın / no floating pins
47 pinMode(NTC_PWR, OUTPUT);
48 digitalWrite(NTC_PWR, LOW);
49
50 radio.begin();
51 radio.setPALevel(RF24_PA_LOW);
52 radio.setDataRate(RF24_250KBPS); // daha uzun menzil / longer range
53 radio.setRetries(5, 5);
54 radio.openWritingPipe(ADDRESS);
55 radio.stopListening();
56 radio.powerDown(); // yaklaşık 1 µA / about 1 µA
57}
58
59void loop() {
60 pkt.vccMv = readVccMv();
61 pkt.tempC10 = (int16_t)(readTempC() * 10.0);
62 pkt.counter++;
63
64 radio.powerUp();
65 delay(5); // osilatör otursun / let the oscillator settle
66 radio.write(&pkt, sizeof(pkt));
67 radio.powerDown();
68
69 for (int i = 0; i < SLEEP_CYCLES; i++) {
70 LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);
71 }
72}A ogni risveglio il nodo assorbe qualche milliampere (circa 10 mA mentre l'nRF24 trasmette) per circa 20–40 ms. Funzionare 40 ms ogni cinque minuti aggiunge alla media solo circa 1 µA; il resto è la corrente di sleep di circa 4–5 µA e l'1 µA dell'nRF24 in standby. La media resta quindi sotto 10 µA e, sulla carta, due stilo AA durano decenni; in pratica il limite è la durata a magazzino delle pile. Il contatore nel pacchetto permette al ricevitore di accorgersi dei pacchetti persi, e vccMv ti dice quando è ora di cambiare le pile. Come ricevitore puoi usare un Uno o un Nano collegato alla USB; con la stessa libreria RF24 chiami openReadingPipe(1, ADDRESS) e startListening() e leggi i dati con la stessa definizione di Packet.
Arduino Pro Mini o Nano?

| Caratteristica | Arduino Pro Mini | Arduino Nano (V3) |
|---|---|---|
| Dimensioni | 18 × 33 mm | 18 × 45 mm |
| USB | No, serve un convertitore USB-TTL | Sì (mini USB, CH340 o FT232) |
| Versioni | 3,3 V / 8 MHz e 5 V / 16 MHz | Solo 5 V / 16 MHz |
| Memoria programma utilizzabile | 30 KB | 30 KB (vecchio bootloader) o 31,5 KB (nuovo bootloader) |
| Ingressi analogici | 8 (A0–A7) | 8 (A0–A7) |
| Corrente di sleep | 1–3 mA; pochi µA senza LED e regolatore | Nell'ordine dei mA per chip USB, LED e regolatore |
| Breadboard | Si inserisce dopo aver saldato i pin | Disponibile con pin già saldati |
| Debug con il Monitor seriale | Finché il convertitore è collegato | In qualsiasi momento tramite cavo USB |
| Ideale per | Progetti piccoli, fissi e a batteria | Imparare, prototipi e progetti collegati alla USB |
In breve, l'Arduino Nano è più comodo mentre impari e fai prototipi: colleghi il cavo USB, carichi il codice e fai debug dal Monitor seriale. Quando il progetto è definito, passi al Pro Mini se deve funzionare a batteria, stare in una scatola piccola o parlare con moduli a 3,3 V senza convertitore di livello. Dato che lo stesso codice gira su entrambe le schede, il passaggio di solito si riduce a cambiare il processore selezionato. Nei progetti con molte schede basta un solo convertitore USB-TTL per tutti i Pro Mini e il costo per scheda scende.
Idee di progetti con l'Arduino Pro Mini
- Rete wireless di temperatura: metti un nodo Pro Mini + nRF24 in ogni stanza e raccogli i dati su un unico ricevitore.
- Sensore porta e finestra a batteria: con un reed switch su D2 la scheda dorme in SLEEP_FOREVER e si sveglia solo per segnalare l'apertura.
- Guardiano dell'umidità per vasi: alimenta il sensore di umidità del terreno da un pin digitale e misura una volta all'ora; non essendo sempre alimentato, durano di più sia la batteria sia gli elettrodi.
- Telecomando tascabile: costruisci un telecomando per TV o condizionatore con un LED IR e qualche pulsante; puoi adattare al lato trasmettitore i codici dell'articolo su ricevitore IR e telecomando.
- Luci indossabili: cuci alcuni LED WS2812B su una giacca o uno zaino per un effetto luminoso in movimento.
- Data logger: costruisci un registratore nascosto in una scatola che salva per settimane la temperatura o la tensione di una batteria con un RTC e un modulo per scheda SD.
Errori comuni e come risolverli
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Errore "stk500_getsync(): not in sync" | TX-RX collegati dritti, DTR non collegato o reset fuori tempo | Collega TX a RXI e RX a TXO; DTR a GRN, oppure premi reset quando compare "Uploading..." |
| Il codice si carica ma i tempi sono doppi o dimezzati | Processore sbagliato (16 MHz invece di 8 MHz o viceversa) | Controlla la scritta sul quarzo e ricarica con l'opzione giusta |
| Caratteri senza senso nel Monitor seriale | Processore sbagliato o baud rate diverso dal codice | Controlla il processore e la velocità di Serial.begin |
| Ancora oltre 1 mA in sleep | LED di alimentazione, regolatore o LED dei moduli | Togli LED e regolatore, alimenta i moduli da un pin digitale |
| Qualche centinaio di µA in più in sleep | Ingressi flottanti | Imposta i pin inutilizzati come INPUT_PULLUP |
| L'nRF24 non funziona o perde pacchetti | Alimentato dal VCC della versione a 5 V o tensione che crolla in trasmissione | Alimenta il modulo a 3,3 V e aggiungi 10–100 µF sui suoi pin |
| La scheda si resetta di continuo con due stilo AA | Tensione scesa sotto la soglia BOD di 2,7 V | Cambia le pile o usa una cella LiFePO4 |
| digitalRead(A6) restituisce sempre lo stesso valore | A6 e A7 sono solo ingressi analogici | Usa analogRead o scegli un altro pin |
L'Arduino Pro Mini è il modo più economico per portare tutto ciò che hai imparato con l'Uno su una scheda grande come un polpastrello, un dispositivo che vive con pochi microampere. Prova prima il codice su un Uno o un Nano, poi sposta lo stesso circuito sul Pro Mini. Tutti i progetti con LED, pulsanti, LDR e sensori dell'app BlueGrays puoi costruirli prima su un Uno passo passo, con schema e codice pronto, e poi trasferirli sul Pro Mini con gli stessi numeri di pin.
Domande frequenti
Come si programma un Arduino Pro Mini?
Non avendo la presa USB, si usa un convertitore USB-TTL basato su CH340, CP2102 o FT232. Si collegano GND, VCC, TX → RXI, RX → TXO e DTR → GRN, poi nell'Arduino IDE si sceglie la scheda "Arduino Pro or Pro Mini" e il processore giusto. Se DTR non è collegato, si preme a mano il pulsante di reset all'inizio del caricamento.
Meglio il Pro Mini da 3,3 V o da 5 V?
Per un progetto a batteria che parla con moduli a 3,3 V come nRF24L01, BME280 o una scheda SD, scegli la versione da 3,3 V / 8 MHz. Se ti servono sensori a 5 V, moduli relè o più velocità di calcolo, è più adatta la versione da 5 V / 16 MHz. Entrambe eseguono lo stesso codice; cambia solo il processore selezionato.
Quanta corrente assorbe un Arduino Pro Mini?
La versione da 3,3 V / 8 MHz assorbe circa 4–5 mA in funzione, quella da 5 V / 16 MHz intorno a 15–20 mA. In sleep con LowPower la scheda di serie consuma ancora 1–3 mA, perché il LED di alimentazione e il regolatore restano attivi. Togliendo questi due componenti, la corrente di sleep scende a circa 4–5 µA con il watchdog attivo.
Si può collegare un cavo USB all'Arduino Pro Mini?
No, il Pro Mini non ha né presa né chip USB. Per collegarlo al computer serve un convertitore USB-TTL; con il convertitore collegato alimenti la scheda, carichi il codice e usi il Monitor seriale. Se vuoi usarlo direttamente via USB, l'Arduino Nano, con lo stesso processore, è la scelta più pratica.
Perché A6 e A7 non funzionano come pin digitali sul Pro Mini?
Nell'ATmega328P i canali A6 e A7 sono collegati solo al multiplexer analogico e non hanno un circuito di ingresso/uscita digitale. Per questo pinMode, digitalRead e digitalWrite non funzionano su di essi. Se devi collegarci un ingresso digitale come un pulsante, usa una resistenza di pull-up esterna e controlla con analogRead se il valore è sopra o sotto 512.
Quanto dura un Arduino Pro Mini a batteria?
Dipende tutto dalla corrente di sleep. Una scheda che non dorme mai dura circa tre settimane con due stilo AA, una che dorme con LowPower ma senza altre modifiche da 1 a 3 mesi. Senza LED di alimentazione e regolatore la corrente media scende sotto 10 µA e le stesse pile durano anni; a quel punto il limite è l'autoscarica.
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.

Accendere un LED con un pulsante (Push)
Come un campanello: la luce resta accesa finché premi e si spegne quando lasci. L'Arduino ascolta il pulsante di continuo; mentre è premuto accende il LED, e appena togli il dito lo spegne.

Misurare l'intensità luminosa con LDR
Vuoi vedere quanto è luminosa la tua stanza sotto forma di numero? L'LDR, un piccolo componente sensibile alla luce, misura la luce ambiente e l'Arduino scrive il valore sullo schermo del computer…

Temperatura e umidità con DHT11
Quanti gradi ci sono nella tua stanza, e l'aria è umida o secca? Il sensore DHT11 misura temperatura e umidità, e l'Arduino scrive i valori su uno schermo LCD a due righe, aggiornandoli ogni paio di…

Misura di temperatura con NTC e display Lcd 2x16
Misura la temperatura dell'ambiente con un sensore che sembra una piccola perlina.

Comunicazione unidirezionale tra 2 Arduino
Fai parlare due Arduino con un solo filo: premi il pulsante sull'uno e il LED dell'altro si accende, premi di nuovo e si spegne.

Rilevatore di movimento con sensore di movimento
Un semplice guardiano che ti avvisa quando qualcuno entra nella stanza. Il sensore di movimento percepisce il calore emesso dal corpo umano, e l'Arduino tiene acceso il LED finché c'è movimento e lo…

Sensore porta con contatto reed
Capisci se la tua porta è aperta o chiusa guardando una luce. Metti un piccolo magnete sulla porta e sul telaio un interruttore che sente i magneti; a porta chiusa stanno vicini e si accende il LED…
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

