Pinout del Arduino UNO R4 WiFi: guía completa de sus 35 pines

El Arduino UNO R4 WiFi es un salto importante para la comunidad maker: trae conectividad inalámbrica al formato clásico del UNO. Igual que su hermano el UNO R4 Minima, marca la transición definitiva desde la antigua arquitectura AVR de 8 bits —el ATmega328P del Arduino UNO R3— hacia un ecosistema Arm Cortex-M de 32 bits, mucho más potente.

Al integrar el microcontrolador Renesas RA4M1 junto a un coprocesador ESP32-S3, el UNO R4 WiFi gana velocidad, memoria y capacidades, y suma Wi-Fi y Bluetooth Low Energy (BLE).

Además de lo inalámbrico, conserva las prestaciones ampliadas de la plataforma R4: bus CAN, amplificador operacional, DAC y soporte HID por USB. Y añade características propias de esta placa, como la matriz de LEDs de 12×8 integrada y el conector Qwiic.

Ahora bien, esa capacidad extra trae diferencias importantes que conviene entender antes de cablear por costumbre. El UNO R4 WiFi cambia la arquitectura de alimentación, introduce dos dominios de señal —el lado de 5 V del RA4M1 y el de 3,3 V del ESP32-S3— y modifica los límites de corriente de los GPIO. Si vienes del Arduino UNO R3, presta atención al pinout para aprovechar estas funciones sin dañar la placa.

Pinout del Arduino UNO R4 WiFi

El UNO R4 WiFi tiene 35 pines en total. Esta es su distribución:

Veamos cada grupo en detalle, empezando por los pines digitales.

Pines digitales de entrada y salida

El UNO R4 WiFi tiene 14 pines digitales de entrada/salida, etiquetados de D0 a D13.

Puedes configurarlos como entrada o como salida. Como entrada leen señales digitales —por ejemplo, si un botón está pulsado o no—. Como salida envían señales para controlar LEDs, motores o relés.

Para usar un pin digital primero debes indicarle a Arduino cómo debe comportarse con la función pinMode(). Si lo quieres como entrada, usas pinMode(pin, INPUT) y luego lees su estado con digitalRead(pin). Si lo quieres como salida, usas pinMode(pin, OUTPUT) y lo controlas con digitalWrite(pin, HIGH) o digitalWrite(pin, LOW).

Hay límites eléctricos que conviene tener presentes. Estos pines trabajan con lógica de 5 V. Cada pin digital admite con seguridad hasta 8 mA, y el conjunto de todos los pines no debería superar los 60 mA.

Nota: Esta es una diferencia importante respecto del ATmega328P del UNO R3, donde cada pin soportaba entre 20 y 40 mA. Si vienes del UNO R3, ten cuidado de no alimentar directamente cargas de consumo alto —optoacopladores de baja resistencia o varios LEDs— sin resistencias limitadoras o transistores de potencia. Si superas los 8 mA, el voltaje del pin puede caer de forma inesperada o puedes dañar de forma permanente los drivers de salida del microcontrolador.

Resistencias pull-up internas

Cada pin digital del UNO R4 WiFi incluye una resistencia pull-up interna. Es especialmente útil cuando usas el pin como entrada y no hay nada conectado: sin pull-up, la entrada queda «flotando» y puede alternar al azar entre HIGH y LOW por el ruido eléctrico del entorno.

La resistencia pull-up interna resuelve eso llevando suavemente el pin a HIGH cuando no hay otra señal presente. Así la lectura se mantiene estable. Al conectar un botón, pulsarlo lleva el pin a LOW y Arduino detecta el cambio con claridad.

Para activarla usas pinMode(pin, INPUT_PULLUP) en lugar de pinMode(pin, INPUT). El valor de esta resistencia no es fijo, pero ronda los 20 kΩ.

Pines de interrupción

Los pines de interrupción son entradas digitales especiales que pueden disparar un bloque de código concreto —una rutina de servicio de interrupción o ISR— cuando ocurre un evento externo, como un cambio de nivel de voltaje. Esto permite que Arduino reaccione de inmediato sin tener que consultar constantemente el estado del pin dentro del loop().

El UNO R4 WiFi tiene dos pines de interrupción externa principales: D2 y D3.

Admite cuatro modos de disparo, que determinan cuándo se ejecuta tu ISR:

Para configurar una interrupción se usa attachInterrupt(interrupcion, ISR, modo). El valor interrupción indica cuál usar: la 0 corresponde al pin digital 2 y la 1 al pin digital 3. ISR es el nombre de la función que se ejecutará, y modo define cómo se dispara.

Vale la pena saber que el UNO R4 WiFi usa un microcontrolador basado en Cortex-M4 con un sistema llamado NVIC (Nested Vector Interrupt Controller), bastante más sofisticado, que admite interrupciones en casi cualquier pin digital y analógico. Sin embargo, para mantener la compatibilidad y la sencillez, el entorno de Arduino se centra en D2 y D3, igual que en las placas UNO clásicas.

Pines PWM

Los pines PWM (Pulse-Width Modulation, modulación por ancho de pulso) son pines digitales que pueden simular una salida analógica. Lo hacen conmutando entre HIGH y LOW muy rápido, tanto que el resultado se percibe como un voltaje intermedio estable. La clave es el ciclo de trabajo: el porcentaje de tiempo que la señal permanece en HIGH dentro de cada ciclo. Variándolo controlas el voltaje medio que llega al componente, lo que permite atenuar LEDs, regular la velocidad de motores o generar tonos simples.

El UNO R4 WiFi ofrece 6 pines con PWM: D3, D5, D6, D9, D10 y D11. Los reconoces en la placa por el símbolo de virgulilla (~) junto al número.

Nota: Los pines D0, D1, D2, D4, D7, D8, D12, D13, SDA y SCL también son capaces de generar PWM, pero pueden interferir con otras funciones de la placa. Conviene no usarlos para eso, porque no son pines PWM oficialmente soportados.

Para generar una señal PWM, primero configuras el pin como salida con pinMode(pin, OUTPUT) dentro de setup(). Después usas analogWrite(pin, valor), donde valor controla el ciclo de trabajo.

Por defecto la resolución PWM es de 8 bits, es decir, valores de 0 a 255. Así el código escrito para placas Arduino antiguas funciona sin cambios. Pero el UNO R4 WiFi permite subirla: con analogWriteResolution() puedes llegar hasta 12 bits, lo que da valores de 0 a 4096 y un control mucho más fino.

analogWriteResolution(12); // Fija la resolución PWM en 12 bits
analogWriteResolution(8);  // Vuelve a 8 bits (valor por defecto)

Pines analógicos (ADC)

Los pines de entrada analógica se usan para leer señales continuas, normalmente provenientes de sensores que miden magnitudes físicas como temperatura, luz, sonido o presión. A diferencia de una señal digital, que solo vale HIGH o LOW, una señal analógica puede tomar muchos niveles de voltaje. Para interpretarla, Arduino usa un conversor analógico-digital (ADC) que traduce el voltaje a un número que tu programa puede usar.

El UNO R4 WiFi tiene seis entradas analógicas, de A0 a A5.

Para leer un valor analógico usas analogRead(pin), que devuelve un entero proporcional al voltaje presente en ese pin.

Por defecto el ADC trabaja con 10 bits de resolución, por compatibilidad: devuelve valores de 0 a 1023. Eso divide el rango de 0 a 5 V en 1.024 pasos, con lo que la placa distingue cambios de apenas 4,9 mV.

Pero el R4 WiFi da para más: puedes subir la resolución a 12 o incluso 14 bits y detectar variaciones mucho más pequeñas. Con 14 bits el paso es de unos 0,3 mV en un rango de 5 V. La resolución se cambia con analogReadResolution() dentro de setup().

analogReadResolution(10); // por defecto
analogReadResolution(12);
analogReadResolution(14);

Otro detalle útil: si te quedas sin pines digitales, los pines A0 a A5 también funcionan como entradas y salidas digitales normales.

Cambiar el voltaje de referencia analógico

Por defecto el UNO R4 WiFi mide voltajes analógicos con una referencia de 0 a 5 V, la propia alimentación de la placa. Esa referencia define el voltaje máximo que el ADC puede medir. Si trabajas con un sensor que funciona a un voltaje menor —3,3 V, por ejemplo—, puede que quieras medir con más precisión en ese rango.

Para eso está el pin AREF junto con la función analogReference(tipo):

analogReference(AR_DEFAULT);  // Referencia por defecto de 5 V
analogReference(AR_INTERNAL); // Referencia interna de 1,5 V
analogReference(AR_EXTERNAL); // Referencia externa aplicada al pin AREF

Pin DAC

El UNO R4 WiFi incorpora un conversor digital-analógico (DAC). Hace lo contrario que el ADC: en vez de leer un voltaje y convertirlo en número, toma un valor digital y lo convierte en un voltaje analógico continuo. Es una mejora importante, muy útil para generar ondas senoidales suaves, controlar osciladores en sintetizadores o entregar un voltaje de referencia variable.

En el UNO R4 WiFi el DAC está disponible en el pin analógico A0.

Para usarlo se emplea la misma función analogWrite(pin, valor) que para el PWM.

analogWrite(pin, valor);

Por defecto el DAC trabaja a 8 bits, con valores de 0 a 255. Escribir 0 entrega cerca de 0 V y escribir 255 se acerca a 5 V; un valor de 127, aproximadamente la mitad, da unos 2,5 V en A0.

Para algunas aplicaciones, sobre todo de audio, 8 bits pueden no bastar. El UNO R4 WiFi permite subir la resolución del DAC hasta 12 bits: los valores pasan a ir de 0 a 4095, lo que da un control mucho más fino del voltaje de salida.

analogWriteResolution(12);

Nota: Si usas A0 como salida del DAC, no puedes usarlo al mismo tiempo como entrada analógica para leer sensores.

Pines del amplificador operacional

Una de las novedades más potentes del R4 WiFi es que incluye un amplificador operacional. Tenerlo integrado te evita añadir circuitos externos para tareas como acondicionar señales, amplificar la salida débil de un sensor o filtrar ruido.

El microcontrolador Renesas RA4M1 tiene cuatro amplificadores operacionales internos, y la placa expone uno de ellos en el conector analógico: A1 como entrada no inversora (+), A2 como entrada inversora (−) y A3 como salida.

Para empezar a usarlo necesitas incluir la biblioteca OPAMP.h e inicializarlo con OPAMP.begin(velocidad). El parámetro de velocidad es opcional y permite elegir entre OPAMP_SPEED_LOWSPEED, de menor consumo, y OPAMP_SPEED_HIGHSPEED, más rápido pero con mayor consumo.

#include <OPAMP.h>

void setup() {
  OPAMP.begin(OPAMP_SPEED_HIGHSPEED);
}

void loop() {
}

Algunos usos

El uso más simple es como seguidor de voltaje (o búfer): basta conectar físicamente A2 (la entrada −) directamente a A3 (la salida). Así, el voltaje que apliques en A1 aparece igual en A3, pero con mayor capacidad de entregar corriente.

También puedes montar un amplificador de voltaje para levantar una señal pequeña: conecta una resistencia de 10 kΩ entre A2 y tierra, y otra de 10 kΩ entre A3 y A2. Con eso, la señal que entre por A1 sale por A3 con el doble de amplitud. Eso sí, cuidado al amplificar: el voltaje de salida no debería superar unos 4,7 V. Si lo fuerzas más, la señal se recorta y en casos extremos puedes dañar la placa.

Otra opción es usarlo como comparador entre dos voltajes de entrada, con una salida de tipo digital HIGH o LOW, o montar circuitos más avanzados como integradores y derivadores. Estos ejemplos son solo el comienzo de lo que se puede hacer con el operacional integrado.

Pines táctiles capacitivos

El UNO R4 WiFi tiene 11 pines con detección táctil capacitiva: D0, D1, D2, D3, D8, D9, D11, D13, A1, A2 y LOVE_BUTTON, el pad con forma de corazón que está en la parte trasera de la placa.

Estos pines detectan cuando algo conductor, como tu dedo, se acerca a ellos. Funcionan midiendo un cambio de capacitancia: al aproximar el dedo se alteran ligeramente las propiedades eléctricas del circuito, y la placa interpreta ese cambio como un toque.

No estás limitado a tocar el pin directamente. Si conectas un material conductor —papel de aluminio, tela conductora o pintura conductora— a uno de estos pines, conviertes ese material en un pad táctil. Es una forma sencilla de crear botones a medida, lámparas táctiles o piezas de arte interactivo.

Para usarlo necesitas instalar e incluir la biblioteca Arduino_CapacitiveTouch. Creas un objeto de la clase CapacitiveTouch indicando el pin, llamas a begin() en setup() para inicializar el sensor, y luego usas read() para obtener el valor bruto o isTouched() si solo te interesa saber si hay contacto. La sensibilidad se ajusta con setThreshold(umbral).

#include "Arduino_CapacitiveTouch.h"

CapacitiveTouch touchButton = CapacitiveTouch(D0);

void setup() {
  touchButton.begin();
  touchButton.setThreshold(2000);
}

void loop() {
  int sensorValue = touchButton.read();
  bool isTouched = touchButton.isTouched();
}

Pines I2C

Una de las mejoras de diseño más relevantes del UNO R4 WiFi es que incluye dos buses I2C independientes. Con eso resuelve un problema antiguo: la convivencia entre dispositivos de 5 V y de 3,3 V. Mezclar esos niveles de forma incorrecta puede dañar componentes sensibles, y al separar los buses la placa permite conectar ambos tipos con seguridad.

El bus heredado de 5 V

El primer bus es el tradicional de 5 V. En el UNO R4 WiFi los pines SDA y SCL están en los pines analógicos A4 (SDA) y A5 (SCL), y también aparecen junto al pin AREF. Este bus existe sobre todo para mantener la compatibilidad con shields y módulos antiguos de 5 V.

Conviene saber que el UNO R4 WiFi no trae resistencias pull-up en las líneas I2C por defecto. Sí tiene pads de soldadura en la placa por si quieres añadirlas tú.

Para usar el bus I2C de 5 V incluyes la biblioteca Wire y llamas a Wire.begin() dentro de setup(). Cada dispositivo I2C tiene su propia dirección, que le indica a Arduino con cuál está hablando. Este ejemplo envía datos al dispositivo con dirección 1 y cierra la comunicación correctamente:

#include <Wire.h>

void setup() {
  Wire.begin();
  Wire.beginTransmission(1); // inicia la transmisión al dispositivo 1
  Wire.write(byte(0x00));    // envía el byte de instrucción
  Wire.write(val);           // envía un valor
  Wire.endTransmission();    // termina la transmisión
}

void loop() {
}

El bus Qwiic / STEMMA QT

El UNO R4 WiFi incluye además un segundo bus I2C conectado al conector Qwiic / STEMMA QT, pensado para enchufar directamente los sensores modernos de 3,3 V de SparkFun y Adafruit.

Como este segundo bus está separado del de 5 V, protege a los dispositivos de 3,3 V de quedar expuestos a señales de 5 V. Eso significa que puedes usar dispositivos de ambos voltajes al mismo tiempo sin necesitar conversores de nivel ni hardware adicional.

Para usar el conector Qwiic no sirve el objeto Wire habitual: hay que usar el secundario Wire1. El resto del proceso es igual que en el primer bus.

#include <Wire.h>

void setup() {
  Wire1.begin();              // se conecta al segundo bus I2C
  Wire1.beginTransmission(1); // inicia la transmisión al dispositivo 1
  Wire1.write(byte(0x00));    // envía el byte de instrucción
  Wire1.write(val);           // envía un valor
  Wire1.endTransmission();    // termina la transmisión
}

void loop() {
}

Pines SPI

El UNO R4 WiFi también admite SPI (Serial Peripheral Interface), otro protocolo de comunicación serial, en general más rápido que I2C. SPI usa pines separados para enviar datos, recibirlos y sincronizar la comunicación mediante una señal de reloj.

Nota: El UNO R4 WiFi usa la nomenclatura moderna Controller/Peripheral para los pines SPI, en lugar de la antigua Master/Slave. La función es exactamente la misma.

En esta placa, el pin 11 es COPI (Controller Out, Peripheral In, antes MOSI) y Arduino lo usa para enviar datos a otro dispositivo. El pin 12 es CIPO (Controller In, Peripheral Out, antes MISO), por donde el periférico devuelve datos. El pin 13 es SCK, el reloj que mantiene sincronizada la transferencia. Y el pin 10 se usa habitualmente como CS (Chip Select), que indica con cuál dispositivo SPI se quiere hablar — algo especialmente importante cuando hay varios conectados a la vez.

Además de estos pines, el UNO R4 WiFi tiene un conector ICSP que da acceso a las mismas señales SPI. Puedes usar indistintamente los pines digitales o el conector ICSP.

Este ejemplo muestra el uso básico de SPI:

#include <SPI.h>

const int CS = 10;

void setup() {
  pinMode(CS, OUTPUT);   // configura el pin CS como salida
  SPI.begin();           // inicializa el bus SPI
  digitalWrite(CS, LOW); // pone CS en LOW para iniciar la comunicación
  SPI.transfer(0x00);    // envía un byte por SPI
  digitalWrite(CS, HIGH);// pone CS en HIGH para terminar
}

void loop() {
}

En el ejemplo, Arduino configura el pin Chip Select como salida, arranca el sistema SPI, selecciona el dispositivo bajando CS, envía un byte y cierra la comunicación subiendo CS.

Pines UART

Aquí hay una mejora notable respecto de su antecesor: el UNO R4 WiFi tiene dos interfaces UART por hardware independientes.

• Una expuesta por el puerto USB-C.
• Otra expuesta en los pines RX/TX.

En el UNO R3, el puerto USB y los pines digitales 0 y 1 compartían la misma interfaz serial. Eso impedía usar el Monitor Serie del computador y un módulo externo —un GPS o un receptor Bluetooth— al mismo tiempo sin que se interfirieran.

El UNO R4 WiFi los separa: el puerto USB-C se conecta a una interfaz serial, a la que accedes en el código como Serial, mientras que los pines 0 (RX) y 1 (TX) van a una segunda interfaz totalmente independiente, que usas como Serial1. Así puedes depurar en el computador y comunicarte con un dispositivo externo a la vez.

Si alguna vez necesitas más puertos serie, puedes seguir usando la biblioteca SoftwareSerial para crear puertos virtuales en otros pines digitales. Ten en cuenta que esos puertos por software son más lentos y consumen más CPU que los de hardware.

Para usar el UART de los pines RX y TX, primero fijas la velocidad en setup(), usando el objeto Serial1 en lugar de Serial:

Serial1.begin(9600);

Para leer datos entrantes puedes comprobar si hay información disponible e ir leyéndola carácter a carácter:

while (Serial1.available()) {
  delay(2);
  char c = Serial1.read();
  incoming += c;
}

Y para enviar datos por la conexión UART:

Serial1.write("Hello world!");

Pines CAN

El UNO R4 WiFi admite también comunicación CAN (Controller Area Network), un protocolo fiable y resistente al ruido. Bosch lo desarrolló originalmente para automóviles, pero hoy se usa ampliamente en sistemas industriales y de automatización. Una de sus ventajas principales es que los dispositivos se comunican entre sí directamente sobre una red compartida, sin necesidad de un computador central.

La placa incluye un controlador CAN integrado compatible con los estándares CAN 2.0A y CAN 2.0B. Las señales están en el pin digital D4 para CAN TX (transmisión) y D5 para CAN RX (recepción).

Nota: Es muy importante entender que el UNO R4 WiFi incluye solo el controlador CAN, no el transceptor. El controlador maneja la lógica de los datos, pero no genera las señales eléctricas que circulan por un bus CAN. Para conectar la placa a otros dispositivos CAN necesitas un módulo transceptor externo, como un MCP2551 o un TJA1050, que convierte las señales lógicas de 5 V de Arduino en las señales diferenciales CAN-H y CAN-L que exige la red.

Para comunicarte con dispositivos CAN, primero incluyes la biblioteca Arduino_CAN:

#include <Arduino_CAN.h>

Después inicializas el sistema eligiendo una velocidad de bits con CAN.begin(CanBitRate rate). La velocidad debe coincidir con la que usan los demás dispositivos del bus. Las opciones habituales son 125 kbps, 250 kbps, 500 kbps y 1 Mbps:

CAN.begin(CanBitRate::BR_125k);  // 125 kbps
CAN.begin(CanBitRate::BR_250k);  // 250 kbps
CAN.begin(CanBitRate::BR_500k);  // 500 kbps
CAN.begin(CanBitRate::BR_1000k); // 1 Mbps

Para enviar un mensaje CAN creas primero un objeto de mensaje, que incluye un identificador (CAN ID), el tamaño de los datos y los datos en sí. Luego lo envías con CAN.write():

uint8_t const msg_data[] = {0xCA,0xFE,0,0,0,0,0,0};
memcpy((void *)(msg_data + 4), &msg_cnt, sizeof(msg_cnt));
CanMsg msg(CAN_ID, sizeof(msg_data), msg_data);
CAN.write(msg);

Para recibir, compruebas si hay algún mensaje disponible con CAN.available() y, si lo hay, lo lees y lo procesas:

if (CAN.available()) {
  CanMsg const msg = CAN.read();
  Serial.println(msg);
}

Conector ICSP

Si has usado un UNO R3, reconocerás de inmediato el conector ICSP de 6 pines (In-Circuit Serial Programming). Sin embargo, en el UNO R4 WiFi su función cambió por completo.

En el UNO R3 el conector ICSP se usaba sobre todo para dos cosas: grabar el bootloader con un programador externo —un AVR ISP u otro Arduino haciendo de ISP— y comunicarse con dispositivos SPI.

En el UNO R4 WiFi ya no sirve para grabar el bootloader. La razón es que la placa usa un microcontrolador distinto, el Renesas RA4M1, que no admite programación por SPI. Según el manual de hardware del RA4M1, en su sección de modos de operación, este microcontrolador admite dos métodos para programar su memoria flash: el modo SCI Boot, que usa una interfaz UART, y el modo USB Boot, que usa la interfaz USB integrada. Por eso el método ISP tradicional sobre SPI no está soportado.

El conector ICSP se mantiene, entonces, principalmente por compatibilidad con shields y hardware basados en SPI que esperan encontrar esas señales en ese conector.

Conector ESP

El Arduino UNO R4 WiFi incluye un pequeño conector de 2×3 pines cerca del botón RESET. Sirve para acceder directamente al módulo ESP32-S3 y reprogramarlo.

Los pines disponibles son:

• GPIO42 — MTMS, depuración
• GPIO41 — MTDI, depuración
• GPIO43 (TXD0) — transmisión serial (UART)
• GPIO0 — Boot
• GPIO44 (RXD0) — recepción serial (UART)
• GND — tierra

Nota: Hay que tener mucho cuidado con este conector. Todas estas señales trabajan a 3,3 V y el ESP32-S3 no tolera 5 V. Si conectas por accidente alguno de estos pines a una señal de 5 V, puedes dañar el chip de forma permanente.

Matriz de LEDs

Una de las características más llamativas del Arduino UNO R4 WiFi es su matriz de LEDs de 12×8 integrada. Son 96 LEDs rojos dispuestos en 12 columnas y 8 filas, que puedes programar para mostrar patrones, iconos, texto desplazándose, animaciones o incluso juegos sencillos.

Los 96 LEDs se controlan mediante una técnica llamada Charlieplexing, que permite manejar muchos LEDs con pocos pines del microcontrolador. Funciona invirtiendo con cuidado el sentido de la corriente por los pines, de modo que solo se enciendan los LEDs deseados en cada instante. Así se ahorran recursos de hardware sin perder control sobre la matriz completa.

Para usarla incluyes la biblioteca Arduino_LED_Matrix y creas un objeto que representa la matriz. Para mostrar algo defines un frame: un arreglo bidimensional donde un 1 enciende el LED y un 0 lo deja apagado. Inicializas la matriz con begin() dentro de setup() y, cuando quieras mostrar tu diseño, llamas a renderBitmap() pasándole el frame.

Este ejemplo dibuja un corazón:

#include "Arduino_LED_Matrix.h"

ArduinoLEDMatrix matrix;

byte heart[8][12] = {
  { 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0 },
  { 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0 },
  { 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0 },
  { 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
  { 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
};

void setup() {
  Serial.begin(115200);
  matrix.begin();
}

void loop() {
  matrix.renderBitmap(heart, 8, 12);
}

Pines de alimentación

El UNO R4 WiFi ofrece varios pines de alimentación, tanto para energizar la propia placa como para alimentar sensores, módulos y otros componentes externos.

Para entender cómo circula la energía por la placa, este es un diagrama de bloques simplificado del árbol de alimentación:

El pin VIN permite alimentar el Arduino desde una fuente externa, como un adaptador de pared o un pack de baterías. Es ideal para proyectos autónomos que no están conectados a un computador por USB. El rango de entrada va típicamente de 6 V a 24 V. Ese voltaje se reduce a unos 5 V estables mediante el conversor reductor ISL854102FRZ, que alimenta al RA4M1 y al resto de la placa. VIN está además conectado al jack DC, así que cuando alimentas por el conector cilíndrico ese mismo voltaje queda disponible en VIN.

El pin 5V entrega una salida regulada de 5 V que puedes usar para alimentar sensores, módulos y shields que necesiten esa tensión. La corriente disponible depende de cómo estés alimentando la placa:

• Si alimentas por VIN o el jack, el conversor reductor está activo y el pin 5V puede entregar hasta unos 1,2 A entre la placa y los periféricos conectados.
• Si alimentas por el puerto USB-C, el conversor queda fuera del camino. En ese caso la corriente máxima depende de la fuente USB —computador o adaptador— y puede llegar a unos 2 A sin dañar la placa.

Si tu proyecto incluye componentes de consumo alto, como servomotores, conviene alimentarlos con una fuente externa independiente en vez de tomar la energía del pin 5V del Arduino.

Nota: Cuando la placa se alimenta por USB, el voltaje del pin 5V es algo menor, en torno a 4,7 V, por la caída de tensión en un diodo Schottky de protección.

El pin 3.3V entrega una salida regulada de 3,3 V, obtenida a partir de la línea de 5 V mediante un regulador LDO secundario SGM2205. Esta línea alimenta el módulo Wi-Fi ESP32-S3, el conector Qwiic y sirve como referencia para tus sensores de 3,3 V. Hay que evitar sobrecargar este pin: el ESP32-S3 consume corriente a ráfagas cuando transmite por Wi-Fi, así que si conectas dispositivos externos que exijan demasiado de la línea de 3,3 V mientras el Wi-Fi está activo, el voltaje puede caer y provocar reinicios del ESP32 e inestabilidad en la conexión.

Pines OFF y VRTC

El Arduino UNO R4 WiFi incorpora dos pines que no existían en las placas UNO anteriores: OFF y VRTC. Ambos dan más control sobre la gestión de energía y sobre el reloj de la placa.

El pin OFF

El pin OFF es un control de apagado activo en bajo. Es decir: cuando lo conectas a GND, el conversor reductor de 5 V se apaga y la placa se desconecta.

Resulta muy útil en proyectos de bajo consumo, como estaciones de monitoreo ambiental alimentadas por batería. Por ejemplo, un circuito temporizador de bajo consumo puede llevar el pin OFF a nivel bajo para apagar la placa por completo durante varias horas; después libera el pin y el sistema despierta apenas lo necesario para tomar lecturas, enviar los datos por Wi-Fi y volver a apagarse. Con este método, la autonomía puede pasar de unos pocos días a varios meses.

Nota: El pin OFF solo funciona cuando la placa se alimenta por VIN o por el jack. Si la alimentas por USB-C, la línea de 5 V viene directamente de la fuente USB y no pasa por el conversor reductor, así que el pin OFF no tiene efecto.

El pin VRTC

El pin VRTC tiene que ver con el reloj de tiempo real (RTC) integrado en la placa. El UNO R4 WiFi lleva un RTC interno que mantiene la hora, de modo que no necesitas conectar un módulo externo como el DS3231 para proyectos de registro de datos.

Mientras la alimentación principal —USB o VIN— esté conectada, el RTC funciona con normalidad. Pero si se corta, el reloj se detendría. Para evitarlo, la placa ofrece el pin VRTC cerca del jack de alimentación: conectando una pequeña fuente de respaldo, como una pila de botón CR2032 o un supercondensador, el RTC sigue funcionando aunque se retire la alimentación principal. El pin VRTC admite entre 1,6 V y 3,6 V.

Fuente

Este tutorial es una traducción y adaptación al español de Arduino UNO R4 WiFi Pinout Reference, publicado por Amrit Prabhu en Last Minute Engineers. Las imágenes provienen del artículo original.