Arduino Uno R4 WiFi y Minima: diferencias con el R3 y qué comprar

El Arduino Uno R4 es la cuarta versión del Uno, la placa de desarrollo más usada del mundo, y el primer Uno con un procesador de 32 bits en lugar de un AVR de 8 bits. Existen dos modelos: el sencillo y más barato Uno R4 Minima y el Uno R4 WiFi, con Wi-Fi, Bluetooth y una matriz de LED de 12x8. Los dos conservan el tamaño, la distribución de pines y la tensión de trabajo de 5 V del R3, así que la mayoría de shields y circuitos encajan tal cual. A cambio, la memoria de programa es 8 veces mayor, el procesador es 3 veces más rápido y se añaden una salida analógica real (DAC), bus CAN, un reloj integrado (RTC) y soporte para teclado y ratón USB.

En esta guía verás exactamente en qué se diferencia el R4 del R3, cómo elegir entre el Minima y el WiFi, qué sketches y librerías antiguas funcionan sin problemas y cuáles no compilan, y por qué debes respetar el límite de 8 mA por pin. Al final montaremos tu primer proyecto, que usa juntas la matriz de LED y el Wi-Fi del R4 WiFi y se controla desde el móvil.

¿Qué es el Arduino Uno R4? Los modelos Minima y WiFi

En el corazón de ambos modelos está el microcontrolador RA4M1 (R7FA4M1AB3CFM) de Renesas: un núcleo Arm Cortex-M4 a 48 MHz con unidad de coma flotante (FPU). A diferencia de la mayoría de placas de 32 bits, este chip funciona a 5 V, y esa es la razón principal por la que Arduino eligió el RA4M1 para el R4. El Minima lleva solo este chip. El modelo WiFi añade un módulo ESP32-S3-MINI-1, que aporta Wi-Fi y Bluetooth y además hace de puente que habla con tu ordenador por USB. Como el ESP32-S3 funciona a 3,3 V, entre los dos chips hay un conversor de niveles.

Diferencias entre el Uno R3 y el Uno R4

Las filas más importantes de la tabla son la memoria y la velocidad. Los 2 KB de SRAM del R3 se llenan con unas cuantas variables String y un búfer de pantalla; en proyectos con pantalla OLED, arrays largos o JSON, la placa empieza a colgarse o reiniciarse al azar. Los 32 KB del R4 casi eliminan ese problema. Gracias a la FPU, las operaciones con float (calibración de sensores, PID, trigonometría) se hacen por hardware y son muchas veces más rápidas que en el R3. La alimentación también cambia mucho: el regulador lineal del R3 se calienta a 12 V, mientras que el R4 usa un convertidor conmutado (buck), por lo que acepta hasta 24 V y se calienta mucho menos.

El nuevo hardware que trae el R4

• DAC de 12 bits (A0): a diferencia del PWM, genera una tensión analógica real; sirve para audio, ondas senoidales y un generador de señales sencillo. La librería analogWave del paquete de la placa genera ondas senoidales, cuadradas y de diente de sierra con una sola línea.
• ADC de 14 bits: con analogReadResolution(14) lees valores de 0 a 16383; con una referencia de 5 V cada paso equivale a unos 0,3 mV, frente a 4,9 mV en el R3. Para no romper los sketches antiguos, la resolución por defecto sigue siendo de 10 bits.
• Amplificador operacional integrado: en los pines A1 (+), A2 (–) y A3 (salida); puedes amplificar señales pequeñas de sensores sin un chip extra. Para lo básico, mira ¿Qué es un amplificador operacional?
• Bus CAN: el bus de comunicación robusto que se usa en coches e industria; se usa con un módulo transceptor como el SN65HVD230 o el TJA1050 y la librería Arduino_CAN del paquete de la placa.
• RTC: guarda la fecha y la hora sin módulo adicional (librería RTC.h). En el R4 WiFi, si conectas al pin VRTC una pila de entre 1,6 y 3,6 V, el reloj sigue funcionando aunque se corte la alimentación de la placa.
• USB HID: la placa puede presentarse ante el ordenador como teclado o ratón; antes hacía falta un Leonardo (teclado USB con Arduino Leonardo).
• Tacto capacitivo: algunos pines pueden funcionar como botones táctiles sin módulo adicional con la librería Arduino_CapacitiveTouch.

Puedes probar dos de estas funciones ahora mismo. El siguiente sketch saca por el DAC tensiones crecientes y vuelve a leer esa misma tensión con el ADC de 14 bits. Solo tienes que unir los pines A0 y A1 con un cable jumper y abrir el Monitor Serie a 115200 baudios:

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}

En la salida verás que la lectura sube unos 2048 cada vez que el valor del DAC aumenta 512: un paso de la salida de 12 bits equivale a 4 pasos de la entrada de 14 bits. En el cálculo usamos 5,0 V, pero cuando la placa se alimenta por USB la línea de 5 V baja a unos 4,7 V por el diodo de protección. Si necesitas medidas precisas, mide el pin 5V con un multímetro y pon ese valor en lugar de 5.0 en la fórmula. La línea while (!Serial) evita que se pierdan las primeras líneas antes de abrir el Monitor Serie; si la placa va a funcionar sin ordenador, bórrala, porque si no el programa se queda esperando ahí. Tienes las bases de la lectura analógica en el artículo ADC y conversión analógica-digital.

El límite de corriente por pin: ¿por qué 8 mA en el R4?

Esta es la diferencia que más se pasa por alto al cambiar al R4. El ATmega328P del R3 entrega sin problema 20 mA por pin (40 mA de máximo absoluto), por eso la mayoría de ejemplos de internet conectan un LED directamente a un pin con una resistencia de 220 Ω. Para el R4, en cambio, Arduino indica un máximo de 8 mA por pin. Hagamos la cuenta con la ley de Ohm: al encender un LED rojo (unos 2 V) desde un pin de 5 V con 220 Ω, la corriente es (5 − 2) / 220 ≈ 13,6 mA, casi el doble del límite del R4. Lo más probable es que el LED se encienda, pero el pin puede dañarse con el tiempo, y ese daño suele acumularse sin que lo notes.

¿Funcionan los sketches y librerías antiguos en el R4?

Respuesta corta: casi todos, sí. Los sketches escritos con comandos estándar de Arduino como digitalWrite, analogRead, millis, Serial, Wire (I2C), SPI, EEPROM, Servo y tone compilan en el R4 sin cambios. Los problemas aparecen en el código que accede directamente al hardware del ATmega328P: las operaciones rápidas con registros como PORTB y DDRD, los ajustes del Timer1, los archivos de cabecera que empiezan por avr/ y las librerías que los usan no compilan en el R4. Por ejemplo, un sketch que usa PORTB falla con 'PORTB' was not declared in this scope.

Al compilar puede aparecer un aviso como 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). No es un error; el autor de la librería solo puso AVR en la lista de arquitecturas compatibles. Si el sketch se sube y funciona, no hay problema. Si te sale un error de verdad, instala primero la última versión de la librería (cómo añadir una librería en Arduino); si no se arregla, busca una alternativa compatible con el R4.

Hay otra diferencia a tener en cuenta: el R3 tiene un único puerto serie, conectado a la vez al USB y a los pines D0/D1. En el R4, Serial es solo el USB, y los pines D0 y D1 funcionan por separado como Serial1. Un sketch antiguo que lee por Serial un módulo como un Bluetooth HC-05 o un GPS conectado a D0/D1 no recibirá nada en el R4. El siguiente sketch puente envía al Monitor Serie lo que llega del módulo y al módulo lo que escribes en el Monitor Serie:

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}

Instalar el Uno R4 en el Arduino IDE

1. Instala o actualiza el Arduino IDE 2 (instalar el Arduino IDE).
2. Abre el Gestor de placas a la izquierda, escribe UNO R4 e instala el paquete Arduino UNO R4 Boards. Es un paquete oficial, así que no hace falta añadir ninguna URL.
3. Conecta la placa con un cable USB-C que transmita datos y elige Arduino UNO R4 Minima o Arduino UNO R4 WiFi en Herramientas > Placa.
4. Elige el puerto de la placa en Herramientas > Puerto, abre Archivo > Ejemplos > 01.Basics > Blink y súbelo. El LED integrado en D13 empieza a parpadear.
5. Si no aparece el puerto o la subida se queda a medias, pulsa rápidamente dos veces el botón RESET: la placa entra en modo bootloader y el puerto vuelve a aparecer. Para todos los problemas de subida, consulta la guía Arduino no sube el código.

Uno R4 WiFi: el ESP32-S3 y la matriz de LED de 12x8

Por defecto, el ESP32-S3 del R4 WiFi ejecuta un firmware instalado por Arduino que convierte las órdenes del RA4M1 en operaciones de Wi-Fi y Bluetooth. Tú sigues programando el RA4M1: para el Wi-Fi usas la librería WiFiS3 que viene con el paquete de la placa y para el Bluetooth la librería ArduinoBLE. Hay dos límites importantes: el módulo solo se conecta a redes de 2,4 GHz y, como el Wi-Fi y el Bluetooth comparten la antena, no puedes usar los dos a la vez. Algunas funciones nuevas necesitan el firmware del ESP32-S3 actualizado; puedes actualizarlo en el IDE desde Herramientas > Firmware Updater.

La matriz del frente de la placa está formada por 96 LED rojos en 8 filas y 12 columnas. Recién sacada de la caja, muestra una animación de Tetris. Los LED van conectados a 11 pines internos del RA4M1 mediante una técnica llamada charlieplexing; esos pines no salen a los conectores, así que usar la matriz no te quita ninguno de los pines D0–D13 ni A0–A5. La librería Arduino_LED_Matrix del paquete de la placa acepta un fotograma (frame) en dos formatos: un array de bytes de 8x12 o tres números de 32 bits. El método del array es más legible, porque ves en el propio código la forma que dibujan los 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() muestra el array que has dibujado tú, mientras que loadFrame() carga fotogramas ya hechos de la librería: LEDMATRIX_HEART_BIG, LEDMATRIX_EMOJI_HAPPY, LEDMATRIX_EMOJI_SAD y LEDMATRIX_DANGER son algunos de ellos. Con loadSequence() y play() puedes reproducir animaciones listas como LEDMATRIX_ANIMATION_TETRIS o LEDMATRIX_ANIMATION_WIFI_SEARCH. Para escribir y desplazar texto en la matriz tienes que instalar la librería ArduinoGraphics desde el Gestor de librerías. Si quieres una pantalla más grande, echa un vistazo a los artículos matriz LED MAX7219 y WS2812B NeoPixel.

Primer proyecto: controlar la matriz de LED desde el móvil

Ahora juntemos las dos funciones. Mientras la placa se conecta a la red de casa, la matriz muestra una animación de búsqueda de Wi-Fi; al conectarse, enseña la dirección IP como texto desplazable. Cuando abres esa dirección en el navegador de un móvil conectado a la misma red, unos botones te permiten mostrar un corazón, una cara alegre o triste, volver a desplazar la IP o apagar la matriz. No necesitas ningún componente aparte de la placa.

1. Instala la librería ArduinoGraphics desde el Gestor de librerías; WiFiS3 y Arduino_LED_Matrix vienen con el paquete de la placa.
2. Cambia el nombre de la red y la contraseña del sketch por los tuyos; cuidado con mayúsculas y minúsculas.
3. Elige Arduino UNO R4 WiFi como placa, sube el sketch y abre el Monitor Serie a 115200 baudios.
4. Escribe en el navegador del móvil la dirección IP que se desplaza por la matriz o aparece en el Monitor Serie.
5. Pulsa los botones de la página; la matriz cambia al instante.

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 lógica es sencilla: WiFi.begin() se repite hasta que hay conexión, luego el sketch espera a que el DHCP asigne una dirección IP y arranca un servidor web en el puerto 80. Lee la primera línea de la petición del móvil (por ejemplo "GET /kalp HTTP/1.1"), averigua con indexOf() qué botón se ha pulsado y carga en la matriz el fotograma correspondiente. endText(SCROLL_LEFT) detiene el programa mientras el texto se desplaza, por eso volvemos a desplazar la IP solo después de enviar la página y cerrar la conexión. Si la matriz muestra el símbolo de peligro y se queda parada, el ESP32-S3 no responde; desconecta y vuelve a conectar el cable USB de la placa y actualiza el firmware. Si la conexión no llega nunca, las comprobaciones de 2,4 GHz y contraseña del artículo el ESP32 no se conecta al Wi-Fi también sirven aquí.

Alimentación: pines VIN, 5V y 3,3 V

El R4 acepta 6–24 V en el conector DC o en el pin VIN; el convertidor buck de la placa lo baja a 5 V. Según la documentación de Arduino para el R4 WiFi, alimentando por VIN se pueden sacar unos 1,2 A del pin 5V; con alimentación USB la placa aguanta hasta 2 A, pero el límite real lo pone el puerto USB de tu ordenador. Esa corriente está pensada para sensores y módulos pequeños, no para motores y servos. El pin de 3,3 V del Minima se alimenta del regulador interno del RA4M1, así que solo da para sensores pequeños; no alimentes desde ahí módulos que consumen mucho, como un ESP-01 o un nRF24L01 con antena PA+LNA. El R4 WiFi tiene además un pin OFF (al unirlo a GND corta la alimentación de 5 V de la placa) y un pin VRTC para la pila del RTC. Para todas las opciones de alimentación, mira cómo alimentar un Arduino.

Ideas de proyectos con el Uno R4

• Estación meteorológica Wi-Fi: muestra la temperatura medida con un DHT11 como texto desplazable en la matriz y también en una página que abres en el móvil.
• Juegos en la matriz: la serpiente, Tetris o una pelota que rebota en la matriz de 12x8; para más ideas, mira el artículo proyectos de juegos con Arduino.
• Reloj por internet: obtén la hora de internet (NTP), guárdala en el RTC integrado y mantenla durante los cortes de luz con una pila en el pin VRTC.
• Teclado de macros USB: crea un teclado de cuatro botones que lance atajos en tu ordenador; gracias al soporte HID del R4 no necesitas un Leonardo.
• Sonido con el DAC: genera una onda senoidal en A0 con la librería analogWave y monta un sintetizador sencillo con un amplificador de audio y un altavoz.
• Lámpara controlada desde el móvil: combina el servidor web de este artículo con un módulo de relé y enciende una lámpara a distancia.

Errores frecuentes y cómo solucionarlos

¿Cuál deberías comprar: R3, R4 Minima o R4 WiFi?

• Uno R4 WiFi: la mejor opción si tus proyectos van a conectarse a internet, al móvil o por Bluetooth y quieres un indicador ya montado en la placa. También es divertido para principiantes, porque ves al momento en la matriz que tu código funciona.
• Uno R4 Minima: encaja si no necesitas conexión inalámbrica y quieres más memoria, velocidad, DAC y USB-C. Gracias a su conector SWD, también es buena opción si quieres conectar un depurador externo y ejecutar tu código paso a paso.
• Uno R3 o un clon compatible: sigue teniendo sentido si tienes proyectos antiguos con librerías específicas de AVR, quieres seguir al pie de la letra los ejemplos de un libro o buscas el menor coste; sus pines soportan 20 mA sin problema.
• ESP32: si quieres Wi-Fi con más pines y a menor precio, una placa ESP32 también merece la pena; solo recuerda que funciona a 3,3 V (¿Arduino o ESP32?).

En resumen, el Uno R4 es una mejora que mantiene la sencillez de siempre del Uno y añade memoria, velocidad y hardware nuevo; solo ten presente el límite de 8 mA y la diferencia de Serial1. Para conocer a fondo los pines de la placa, echa un vistazo al artículo pines del Arduino Uno. En la app BlueGrays encontrarás proyectos de LED, botones, sensores, LCD y matrices de LED para Arduino Uno con esquemas y código paso a paso; están escritos con comandos estándar, así que también funcionan en el R4, y solo tienes que subir las resistencias de los LED a 470 Ω.