Arduino Uno R4 WiFi e Minima: differenze con R3 e primo progetto

L'Arduino Uno R4 è la quarta versione di Uno, la scheda di sviluppo più usata al mondo, e il primo Uno con un processore a 32 bit al posto di un AVR a 8 bit. Esiste in due modelli: l'Uno R4 Minima, essenziale e più economico, e l'Uno R4 WiFi, con Wi-Fi, Bluetooth e una matrice di LED 12x8. Entrambi mantengono dimensioni, piedinatura e tensione di lavoro a 5 V dell'R3, quindi la maggior parte degli shield e dei circuiti si collega così com'è. In compenso la memoria di programma è 8 volte più grande, il processore è 3 volte più veloce e si aggiungono una vera uscita analogica (DAC), il bus CAN, un orologio integrato (RTC) e il supporto per tastiera e mouse USB.

In questa guida vedrai esattamente in cosa l'R4 si distingue dall'R3, come scegliere tra Minima e WiFi, quali vecchi sketch e librerie funzionano senza problemi e quali non compilano, e perché devi rispettare il limite di 8 mA per pin. Alla fine costruiremo il tuo primo progetto, che usa insieme la matrice di LED e il Wi-Fi dell'R4 WiFi e si controlla dallo smartphone.

Che cos'è l'Arduino Uno R4? I modelli Minima e WiFi

Il cuore di entrambi i modelli è il microcontrollore RA4M1 (R7FA4M1AB3CFM) di Renesas: un core Arm Cortex-M4 a 48 MHz con unità in virgola mobile (FPU). A differenza della maggior parte delle schede a 32 bit, questo chip funziona a 5 V, ed è proprio il motivo principale per cui Arduino ha scelto l'RA4M1 per l'R4. Il Minima monta solo questo chip. Il modello WiFi aggiunge un modulo ESP32-S3-MINI-1, che fornisce Wi-Fi e Bluetooth e fa anche da ponte per comunicare con il computer via USB. Poiché l'ESP32-S3 lavora a 3,3 V, tra i due chip c'è un traslatore di livello.

Differenze tra Uno R3 e Uno R4

Le righe più importanti della tabella sono memoria e velocità. I 2 KB di SRAM dell'R3 si riempiono con qualche variabile String e un buffer per il display; nei progetti con display OLED, array lunghi o JSON la scheda comincia a bloccarsi o a riavviarsi a caso. I 32 KB dell'R4 eliminano quasi del tutto il problema. Grazie alla FPU i calcoli in float (calibrazione dei sensori, PID, trigonometria) avvengono in hardware e sono molte volte più veloci che sull'R3. Anche l'alimentazione cambia molto: il regolatore lineare dell'R3 scalda a 12 V, mentre l'R4 usa un convertitore switching (buck), quindi accetta fino a 24 V e scalda molto meno.

Il nuovo hardware dell'R4

• DAC a 12 bit (A0): a differenza del PWM produce una vera tensione analogica; si usa per audio, onde sinusoidali e un semplice generatore di segnali. La libreria analogWave del pacchetto della scheda genera onde sinusoidali, quadre e a dente di sega con una sola riga.
• ADC a 14 bit: con analogReadResolution(14) leggi valori da 0 a 16383; con riferimento a 5 V un passo vale circa 0,3 mV, contro i 4,9 mV dell'R3. Per non rompere i vecchi sketch, la risoluzione di default resta a 10 bit.
• Amplificatore operazionale integrato: sui pin A1 (+), A2 (–) e A3 (uscita); puoi amplificare piccoli segnali dei sensori senza un chip in più. Per le basi, leggi Che cos'è un amplificatore operazionale?
• Bus CAN: il robusto bus di comunicazione usato nelle auto e nell'industria; si usa con un modulo transceiver come SN65HVD230 o TJA1050 e la libreria Arduino_CAN del pacchetto della scheda.
• RTC: tiene data e ora senza moduli aggiuntivi (libreria RTC.h). Sull'R4 WiFi, se colleghi al pin VRTC una batteria tra 1,6 e 3,6 V, l'orologio continua a funzionare anche quando l'alimentazione della scheda viene tolta.
• USB HID: la scheda può presentarsi al computer come tastiera o mouse; una volta serviva un Leonardo (tastiera USB con Arduino Leonardo).
• Sensore tattile capacitivo: alcuni pin possono funzionare come pulsanti touch senza moduli aggiuntivi grazie alla libreria Arduino_CapacitiveTouch.

Due di queste funzioni puoi provarle subito. Lo sketch qui sotto genera con il DAC tensioni crescenti e rilegge la stessa tensione con l'ADC a 14 bit. Basta collegare i pin A0 e A1 con un cavetto jumper e aprire il Monitor seriale a 115200 baud:

1// A0 (DAC) ile A1'i bir jumper kabloyla bağla / connect A0 (DAC) to A1 with a jumper wire
2
3void setup() {
4  Serial.begin(115200);
5  while (!Serial) {}            // USB seri port açılana kadar bekle / wait for the USB serial port
6  analogWriteResolution(12);    // DAC: 0–4095
7  analogReadResolution(14);     // ADC: 0–16383
8}
9
10void loop() {
11  for (int value = 0; value < 4096; value += 512) {
12    analogWrite(DAC, value);              // A0'dan gerçek analog gerilim / true analog voltage on A0
13    delay(10);
14    int raw = analogRead(A1);             // 14 bit okuma / 14-bit reading
15    float volts = raw * 5.0 / 16383.0;    // 5 V referans / 5 V reference
16    Serial.print("DAC: ");
17    Serial.print(value);
18    Serial.print("  ADC: ");
19    Serial.print(raw);
20    Serial.print("  V: ");
21    Serial.println(volts, 3);
22    delay(500);
23  }
24}

Nell'output vedrai che la lettura sale di circa 2048 ogni volta che il valore del DAC aumenta di 512: un passo dell'uscita a 12 bit corrisponde a 4 passi dell'ingresso a 14 bit. Nel calcolo abbiamo usato 5,0 V, ma quando la scheda è alimentata via USB la linea a 5 V scende a circa 4,7 V a causa del diodo di protezione. Se ti servono misure precise, misura il pin 5V con il multimetro e usa quel valore al posto di 5.0 nella formula. La riga while (!Serial) evita che le prime righe vadano perse prima di aprire il Monitor seriale; se la scheda deve funzionare senza computer, cancellala, altrimenti il programma resta fermo lì. Le basi della lettura analogica le trovi nell'articolo ADC e conversione analogico-digitale.

Il limite di corrente per pin: perché 8 mA sull'R4?

È la differenza che sfugge più spesso a chi passa all'R4. L'ATmega328P dell'R3 eroga tranquillamente 20 mA per pin (40 mA come massimo assoluto), per questo la maggior parte degli esempi online collega un LED direttamente a un pin con una resistenza da 220 Ω. Per l'R4, invece, Arduino indica al massimo 8 mA per pin. Facciamo il conto con la legge di Ohm: pilotando un LED rosso (circa 2 V) da un pin a 5 V con 220 Ω, la corrente è (5 − 2) / 220 ≈ 13,6 mA, quasi il doppio del limite dell'R4. Molto probabilmente il LED si accende, ma il pin può danneggiarsi col tempo, e il danno di solito si accumula senza che te ne accorga.

I vecchi sketch e le librerie funzionano sull'R4?

Risposta breve: quasi tutti sì. Gli sketch scritti con i comandi standard di Arduino come digitalWrite, analogRead, millis, Serial, Wire (I2C), SPI, EEPROM, Servo e tone compilano sull'R4 senza modifiche. I problemi nascono nel codice che accede direttamente all'hardware dell'ATmega328P: le operazioni veloci sui pin tramite registri come PORTB e DDRD, le impostazioni del Timer1, i file di intestazione che iniziano con avr/ e le librerie che li usano non compilano sull'R4. Per esempio, uno sketch che usa PORTB si ferma con 'PORTB' was not declared in this scope.

Durante la compilazione può comparire un avviso come WARNING: library LiquidCrystal I2C claims to run on avr architecture(s) and may be incompatible with your current board which runs on renesas_uno architecture(s). Non è un errore; l'autore della libreria ha semplicemente indicato solo AVR tra le architetture supportate. Se lo sketch si carica e funziona, va tutto bene. Se ottieni un vero errore, installa prima l'ultima versione della libreria (aggiungere una libreria ad Arduino); se non basta, cerca un'alternativa compatibile con l'R4.

C'è un'altra differenza a cui fare attenzione: l'R3 ha una sola porta seriale, collegata sia all'USB sia ai pin D0/D1. Sull'R4, invece, Serial è solo l'USB, mentre i pin D0 e D1 funzionano separatamente come Serial1. Un vecchio sketch che legge con Serial un modulo collegato a D0/D1, come un Bluetooth HC-05 o un GPS, sull'R4 non riceve nulla. Lo sketch ponte qui sotto inoltra al Monitor seriale i dati del modulo e al modulo quello che scrivi nel Monitor seriale:

1// R4'te Serial = USB, Serial1 = D0 (RX) ve D1 (TX) / on the R4, Serial = USB, Serial1 = D0 (RX) and D1 (TX)
2
3void setup() {
4  Serial.begin(115200);   // bilgisayar (Seri Monitör) / computer (Serial Monitor)
5  Serial1.begin(9600);    // D0/D1'e bağlı modül, örn. HC-05 / module on D0/D1, e.g. HC-05
6}
7
8void loop() {
9  if (Serial1.available()) {
10    Serial.write(Serial1.read());   // modülden bilgisayara / module to computer
11  }
12  if (Serial.available()) {
13    Serial1.write(Serial.read());   // bilgisayardan modüle / computer to module
14  }
15}

Installare l'Uno R4 nell'IDE di Arduino

1. Installa o aggiorna l'Arduino IDE 2 (installare l'IDE di Arduino).
2. Apri il Gestore schede a sinistra, scrivi UNO R4 e installa il pacchetto Arduino UNO R4 Boards. È un pacchetto ufficiale, quindi non devi aggiungere nessun URL.
3. Collega la scheda con un cavo USB-C che trasmette dati e scegli Arduino UNO R4 Minima o Arduino UNO R4 WiFi da Strumenti > Scheda.
4. Scegli la porta della scheda da Strumenti > Porta, apri File > Esempi > 01.Basics > Blink e caricalo. Il LED integrato su D13 comincia a lampeggiare.
5. Se la porta non compare o il caricamento si interrompe a metà, premi rapidamente due volte il pulsante RESET: la scheda entra in modalità bootloader e la porta ricompare. Per tutti i problemi di caricamento, consulta la guida Arduino non carica lo sketch.

Uno R4 WiFi: l'ESP32-S3 e la matrice di LED 12x8

Di default l'ESP32-S3 dell'R4 WiFi esegue un firmware installato da Arduino che traduce i comandi dell'RA4M1 in operazioni Wi-Fi e Bluetooth. Tu continui a programmare l'RA4M1: per il Wi-Fi usi la libreria WiFiS3 inclusa nel pacchetto della scheda e per il Bluetooth la libreria ArduinoBLE. Ci sono due limiti importanti: il modulo si collega solo a reti a 2,4 GHz e, poiché Wi-Fi e Bluetooth condividono l'antenna, non puoi usarli entrambi nello stesso momento. Alcune funzioni recenti richiedono il firmware dell'ESP32-S3 aggiornato; puoi aggiornarlo dall'IDE con Strumenti > Firmware Updater.

La matrice sul fronte della scheda è formata da 96 LED rossi su 8 righe e 12 colonne. Appena tolta dalla scatola mostra un'animazione di Tetris. I LED sono collegati a 11 pin interni dell'RA4M1 con una tecnica chiamata charlieplexing; questi pin non arrivano ai connettori, quindi usare la matrice non ti costa nessuno dei pin D0–D13 o A0–A5. La libreria Arduino_LED_Matrix del pacchetto della scheda accetta un fotogramma (frame) in due formati: un array di byte 8x12 oppure tre numeri a 32 bit. Il metodo dell'array è più leggibile, perché vedi direttamente nel codice la forma disegnata dagli 1:

1#include "Arduino_LED_Matrix.h"   // kart paketiyle gelir / ships with the board package
2
3ArduinoLEDMatrix matrix;
4
5// 8 satır x 12 sütun: 1 = LED yanar / 8 rows x 12 columns: 1 = LED on
6uint8_t kalp[8][12] = {
7  { 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0 },
8  { 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0 },
9  { 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0 },
10  { 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
11  { 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0 },
12  { 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0 },
13  { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 },
14  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
15};
16
17void setup() {
18  matrix.begin();
19}
20
21void loop() {
22  matrix.renderBitmap(kalp, 8, 12);          // kendi çizimin / your own drawing
23  delay(1000);
24  matrix.loadFrame(LEDMATRIX_EMOJI_HAPPY);   // kütüphanedeki hazır kare / ready-made frame from the library
25  delay(1000);
26  kalp[7][11] = 1;                           // tek bir LED'i yak: satır 7, sütun 11 / turn on one LED: row 7, column 11
27}

renderBitmap() mostra l'array che hai disegnato tu, mentre loadFrame() carica fotogrammi già pronti della libreria: LEDMATRIX_HEART_BIG, LEDMATRIX_EMOJI_HAPPY, LEDMATRIX_EMOJI_SAD e LEDMATRIX_DANGER sono alcuni di questi. Con loadSequence() e play() puoi riprodurre animazioni pronte come LEDMATRIX_ANIMATION_TETRIS o LEDMATRIX_ANIMATION_WIFI_SEARCH. Per scrivere e far scorrere testo sulla matrice devi installare la libreria ArduinoGraphics dal Gestore librerie. Se vuoi un display più grande, dai un'occhiata agli articoli matrice LED MAX7219 e WS2812B NeoPixel.

Primo progetto: controllare la matrice di LED dallo smartphone

Ora uniamo le due funzioni. Mentre la scheda si collega alla rete di casa, la matrice mostra un'animazione di ricerca Wi-Fi; una volta connessa, visualizza l'indirizzo IP come testo scorrevole. Quando apri quell'indirizzo nel browser di uno smartphone collegato alla stessa rete, alcuni pulsanti ti permettono di mostrare un cuore, una faccina felice o triste, far scorrere di nuovo l'IP oppure spegnere la matrice. Oltre alla scheda non serve nessun componente.

1. Installa la libreria ArduinoGraphics dal Gestore librerie; WiFiS3 e Arduino_LED_Matrix sono incluse nel pacchetto della scheda.
2. Sostituisci nome della rete e password nello sketch con i tuoi; attenzione a maiuscole e minuscole.
3. Scegli Arduino UNO R4 WiFi come scheda, carica lo sketch e apri il Monitor seriale a 115200 baud.
4. Digita nel browser dello smartphone l'indirizzo IP che scorre sulla matrice o compare nel Monitor seriale.
5. Premi i pulsanti della pagina; la matrice cambia all'istante.

1#include "ArduinoGraphics.h"      // Arduino_LED_Matrix'ten ÖNCE eklenmeli / must come BEFORE Arduino_LED_Matrix
2#include "Arduino_LED_Matrix.h"
3#include "WiFiS3.h"
4
5char ssid[] = "AgAdi";            // Wi-Fi adın / your Wi-Fi name
6char pass[] = "Sifre123";         // Wi-Fi şifren / your Wi-Fi password
7
8ArduinoLEDMatrix matrix;
9WiFiServer server(80);
10
11void scrollText(String text) {
12  matrix.beginDraw();
13  matrix.stroke(0xFFFFFFFF);
14  matrix.textScrollSpeed(60);             // her adım 60 ms / 60 ms per step
15  matrix.textFont(Font_5x7);
16  matrix.beginText(0, 1, 0xFFFFFF);
17  matrix.print("   " + text + "   ");
18  matrix.endText(SCROLL_LEFT);            // yazıyı sola kaydır / scroll the text to the left
19  matrix.endDraw();
20}
21
22void sendPage(WiFiClient &client) {
23  client.println("HTTP/1.1 200 OK");
24  client.println("Content-Type: text/html; charset=utf-8");
25  client.println("Connection: close");
26  client.println();
27  client.println("<!DOCTYPE html><html><head><meta name='viewport' content='width=device-width'></head><body>");
28  client.println("<h2>UNO R4 WiFi</h2>");
29  client.println("<p><a href='/kalp'><button>Kalp / Heart</button></a></p>");
30  client.println("<p><a href='/mutlu'><button>Mutlu / Happy</button></a></p>");
31  client.println("<p><a href='/uzgun'><button>Uzgun / Sad</button></a></p>");
32  client.println("<p><a href='/ip'><button>IP</button></a></p>");
33  client.println("<p><a href='/kapat'><button>Kapat / Off</button></a></p>");
34  client.println("</body></html>");
35}
36
37void setup() {
38  Serial.begin(115200);
39  matrix.begin();
40
41  if (WiFi.status() == WL_NO_MODULE) {               // ESP32-S3 yanıt vermiyor / ESP32-S3 not responding
42    Serial.println("WiFi modulu bulunamadi / WiFi module not found");
43    matrix.loadFrame(LEDMATRIX_DANGER);
44    while (true) {}
45  }
46
47  matrix.loadSequence(LEDMATRIX_ANIMATION_WIFI_SEARCH);   // bağlanırken animasyon / animation while connecting
48  matrix.play(true);
49
50  while (WiFi.begin(ssid, pass) != WL_CONNECTED) {
51    Serial.println("Baglaniyor / connecting...");
52    delay(5000);
53  }
54  while (WiFi.localIP() == IPAddress(0, 0, 0, 0)) {   // DHCP adresini bekle / wait for the DHCP address
55    delay(100);
56  }
57
58  server.begin();
59  Serial.print("IP: ");
60  Serial.println(WiFi.localIP());
61  scrollText(WiFi.localIP().toString());     // IP adresini matriste göster / show the IP on the matrix
62  matrix.loadFrame(LEDMATRIX_EMOJI_HAPPY);
63}
64
65void loop() {
66  WiFiClient client = server.available();
67  if (!client) {
68    return;
69  }
70
71  String request = client.readStringUntil('\n');   // ör. "GET /kalp HTTP/1.1" / e.g. "GET /kalp HTTP/1.1"
72  while (client.available()) {
73    client.read();                                 // kalan başlıkları at / discard the remaining headers
74  }
75
76  bool showIp = false;
77  if (request.indexOf("GET /kalp") >= 0) {
78    matrix.loadFrame(LEDMATRIX_HEART_BIG);
79  } else if (request.indexOf("GET /mutlu") >= 0) {
80    matrix.loadFrame(LEDMATRIX_EMOJI_HAPPY);
81  } else if (request.indexOf("GET /uzgun") >= 0) {
82    matrix.loadFrame(LEDMATRIX_EMOJI_SAD);
83  } else if (request.indexOf("GET /kapat") >= 0) {
84    matrix.clear();
85  } else if (request.indexOf("GET /ip") >= 0) {
86    showIp = true;
87  }
88
89  sendPage(client);
90  delay(10);
91  client.stop();                                   // bağlantıyı kapat / close the connection
92
93  if (showIp) {
94    scrollText(WiFi.localIP().toString());         // sayfa gittikten sonra kaydır / scroll after the page is sent
95  }
96}

La logica è semplice: WiFi.begin() viene ripetuto finché la connessione non è attiva, poi lo sketch aspetta che il DHCP assegni un indirizzo IP e avvia un server web sulla porta 80. Legge la prima riga della richiesta dello smartphone (per esempio "GET /kalp HTTP/1.1"), capisce con indexOf() quale pulsante è stato premuto e carica sulla matrice il fotogramma corrispondente. endText(SCROLL_LEFT) blocca il programma mentre il testo scorre; per questo facciamo scorrere di nuovo l'IP solo dopo aver inviato la pagina e chiuso la connessione. Se la matrice mostra il simbolo di pericolo e si ferma, l'ESP32-S3 non risponde; scollega e ricollega il cavo USB della scheda e aggiorna il firmware. Se la connessione non arriva mai, i controlli su 2,4 GHz e password dell'articolo l'ESP32 non si connette al Wi-Fi valgono anche qui.

Alimentazione: pin VIN, 5V e 3,3 V

L'R4 accetta 6–24 V sul jack DC o sul pin VIN; il convertitore buck della scheda li riduce a 5 V. Secondo la documentazione di Arduino per l'R4 WiFi, con alimentazione da VIN si possono prelevare circa 1,2 A dal pin 5V; con alimentazione USB la scheda regge fino a 2 A, ma il limite reale lo stabilisce la porta USB del tuo computer. Questa corrente è pensata per sensori e piccoli moduli, non per motori e servo. Il pin 3,3 V del Minima è alimentato dal regolatore interno dell'RA4M1 e basta quindi solo per piccoli sensori; non alimentare da lì moduli che assorbono molto, come un ESP-01 o un nRF24L01 con antenna PA+LNA. L'R4 WiFi ha inoltre un pin OFF (collegato a GND spegne l'alimentazione a 5 V della scheda) e un pin VRTC per la batteria dell'RTC. Per tutte le opzioni di alimentazione, leggi come alimentare Arduino.

Idee di progetti con l'Uno R4

• Stazione meteo Wi-Fi: mostra la temperatura misurata con un DHT11 come testo scorrevole sulla matrice e anche su una pagina che apri sullo smartphone.
• Giochi sulla matrice: snake, Tetris o una pallina che rimbalza sulla matrice 12x8; per altre idee, leggi l'articolo progetti di giochi con Arduino.
• Orologio via internet: prendi l'ora da internet (NTP), scrivila nell'RTC integrato e conservala anche durante i blackout con una batteria sul pin VRTC.
• Tastiera macro USB: costruisci un tastierino a quattro pulsanti che lancia scorciatoie sul computer; grazie al supporto HID dell'R4 non ti serve un Leonardo.
• Suono con il DAC: genera un'onda sinusoidale su A0 con la libreria analogWave e costruisci un semplice sintetizzatore con un amplificatore audio e un altoparlante.
• Lampada comandata dallo smartphone: unisci il server web di questo articolo a un modulo relè e accendi una lampada a distanza.

Errori comuni e come risolverli

Quale comprare: R3, R4 Minima o R4 WiFi?

• Uno R4 WiFi: la scelta migliore se i tuoi progetti devono collegarsi a internet, allo smartphone o via Bluetooth e vuoi un indicatore già pronto sulla scheda. È divertente anche per chi inizia, perché vedi subito sulla matrice che il tuo codice funziona.
• Uno R4 Minima: va bene se non ti serve la connessione wireless e vuoi più memoria, velocità, un DAC e la USB-C. Grazie al connettore SWD è anche una buona opzione se vuoi collegare un debugger esterno ed eseguire il codice passo dopo passo.
• Uno R3 o un clone compatibile: ha ancora senso se hai vecchi progetti con librerie specifiche per AVR, vuoi seguire alla lettera gli esempi di un libro o cerchi il costo più basso; i suoi pin reggono 20 mA senza problemi.
• ESP32: se vuoi il Wi-Fi con più pin e a un prezzo più basso, vale la pena considerare anche una scheda ESP32; ricorda solo che lavora a 3,3 V (Arduino o ESP32?).

In breve, l'Uno R4 è un aggiornamento che conserva la semplicità di sempre dell'Uno e aggiunge memoria, velocità e nuovo hardware; tieni solo a mente il limite di 8 mA e la differenza di Serial1. Per conoscere a fondo i pin della scheda, dai un'occhiata all'articolo piedinatura dell'Arduino Uno. Nell'app BlueGrays trovi progetti con LED, pulsanti, sensori, LCD e matrici di LED per Arduino Uno con schemi e codice passo dopo passo; sono scritti con comandi standard, quindi funzionano anche sull'R4, e ti basta portare le resistenze dei LED a 470 Ω.