Quick answer: the Arduino UNO R4 WiFi keeps the familiar UNO header layout and 5 V logic, but combines a 48 MHz Renesas RA4M1 Cortex-M4 with an onboard ESP32-S3-MINI-1-N8 for Wi-Fi and Bluetooth. It also adds a 12×8 LED matrix, Qwiic connector, true DAC, RTC, CAN controller, native USB-C and far more memory than the UNO R3.
The RA4M1 is the main microcontroller that runs your Arduino sketch. The ESP32-S3 normally runs Arduino’s connectivity/bridge firmware and handles Wi-Fi, Bluetooth and USB-serial support. You can program the ESP32-S3 directly, but doing so replaces its default firmware and can break normal RA4M1-to-ESP communication until the original firmware is restored.
Two board-specific details matter immediately: the Qwiic connector is a separate 3.3 V I²C bus using Wire1, while the normal A4/A5 header uses Wire; and on the R4 WiFi the RA4M1 CAN controller is exposed on D10 CANTX and D13 CANRX, not on D4/D5 as on the UNO R4 Minima.
UNO R4 WiFi Specifications
| Feature | Arduino UNO R4 WiFi |
|---|---|
| Main MCU | Renesas RA4M1 R7FA4M1AB3CFM |
| Main CPU | 32-bit Arm Cortex-M4 with FPU @ 48 MHz |
| Wireless MCU | ESP32-S3-MINI-1-N8 |
| Wi-Fi | 2.4 GHz via ESP32-S3 |
| Bluetooth | Bluetooth LE via ESP32-S3 |
| RA4M1 Flash | 256 KB |
| RA4M1 SRAM | 32 KB |
| RA4M1 data flash | 8 KB |
| Digital I/O | 14: D0–D13 |
| Analogue inputs | 6: A0–A5 |
| ADC | Up to 14 bit |
| DAC | 12 bit on A0 |
| PWM | D3, D5, D6, D9, D10, D11 |
| CAN | CAN 2.0A/B; external transceiver required |
| RTC | Yes, with VRTC backup pin |
| USB | USB-C |
| LED matrix | 12 × 8, 96 red LEDs |
| Qwiic | 3.3 V secondary I²C bus |
| Logic voltage | 5 V on normal UNO headers |
| GPIO current | 8 mA max per pin, 60 mA overall |
| VIN operating range | 6–24 V |
UNO R4 WiFi Pinout Quick Reference
| Arduino pin | RA4M1 pin | Main functions / notes |
|---|---|---|
| D0 / RX | P301 | UART RX, GPIO |
| D1 / TX | P302 | UART TX, GPIO |
| D2 | P104 | GPIO, external interrupt |
| D3 ~ | P105 | PWM, external interrupt |
| D4 | P106 | GPIO |
| D5 ~ | P107 | PWM |
| D6 ~ | P111 | PWM |
| D7 | P112 | GPIO |
| D8 | P304 | GPIO |
| D9 ~ | P303 | PWM |
| D10 ~ | P103 | PWM, SPI CS, CAN TX |
| D11 ~ | P411 | PWM, SPI COPI/MOSI |
| D12 | P410 | SPI CIPO/MISO |
| D13 | P102 | SPI SCK, LED_BUILTIN, CAN RX |
| A0 | P014 | ADC, 12-bit DAC output |
| A1 | P000 | ADC, OPAMP + |
| A2 | P001 | ADC, OPAMP – |
| A3 | P002 | ADC, OPAMP output |
| A4 / SDA | P101 | ADC, main I²C SDA |
| A5 / SCL | P100 | ADC, main I²C SCL |
The Board Has Two Microcontrollers
UNO R4 WiFi is not simply an RA4M1 board with a radio module bolted on. The RA4M1 and ESP32-S3 cooperate closely.
RA4M1 responsibilities:
- Runs the normal Arduino sketch.
- Controls the classic UNO headers.
- Provides ADC, DAC, PWM, CAN, RTC and most general-purpose peripherals.
- Handles the 12×8 LED matrix.
ESP32-S3 responsibilities in the normal factory configuration:
- Wi-Fi connectivity.
- Bluetooth connectivity.
- USB serial/bridge functions.
- Assisting RA4M1 programming/reset behaviour.
- Arduino Cloud/network coprocessor functions.
This architecture is quite different from an ordinary ESP32 development board where the ESP32 itself runs your entire Arduino sketch.
The ESP32-S3 Is 3.3 V Only
The normal UNO header side is 5 V, but the exposed ESP32-S3 header signals are 3.3 V only. Arduino explicitly warns not to connect 5 V signals to that header.
This matters because the same PCB contains both voltage domains. Do not assume every exposed signal on the R4 WiFi is 5 V tolerant just because the UNO headers are.
If you program or interface with the ESP32-S3 header directly, treat it like any other 3.3 V ESP32-S3 circuit.
Main UNO Header Is 5 V Logic
The familiar D0–D13 and A0–A5 Arduino headers operate in the UNO R4’s normal 5 V I/O domain.
That preserves compatibility with many classic shields, but the same warning as the R4 Minima applies: a 5 V output must not be connected directly to a 3.3 V-only ESP32, RP2350 or STM32 input unless that destination pin is explicitly tolerant.
GPIO Current Is Only 8 mA per Pin
Like the R4 Minima, the R4 WiFi is not designed around the old UNO R3’s higher per-pin current assumptions.
- Maximum per GPIO: 8 mA.
- Maximum overall GPIO current: 60 mA.
Use GPIO to control external circuitry rather than powering loads directly. Use MOSFETs/transistors for relays, motors and solenoids, and size LED resistors appropriately.
PWM Pins
The officially supported PWM pins are:
- D3
- D5
- D6
- D9
- D10
- D11
void setup() {
pinMode(9, OUTPUT);
analogWrite(9, 128);
}
void loop() {
}The default Arduino PWM API uses an 8-bit value range, but R4 can support higher resolution through analogWriteResolution().
D10 is also CAN TX and SPI CS; D11 is also SPI COPI/MOSI. Plan peripheral conflicts before choosing a PWM channel.
Analogue Inputs and 14-Bit ADC
A0–A5 can be used as analogue inputs. The RA4M1 ADC supports higher resolution than UNO R3.
void setup() {
Serial.begin(115200);
analogReadResolution(14);
}
void loop() {
int value = analogRead(A2);
Serial.println(value); // 0..16383
delay(100);
}The Arduino core defaults to a lower resolution for compatibility. Asking for 14-bit numerical resolution does not guarantee 14 effective noise-free bits; analogue design still matters.
A0 Is a True 12-Bit DAC
A0 can act as the RA4M1’s true DAC output.
void setup() {
analogWriteResolution(12);
}
void loop() {
analogWrite(DAC, 2048);
}Unlike PWM, the DAC produces a real analogue level. It is useful for set-points, waveform generation and analogue control signals, though loads may require buffering.
A1–A3 Expose the Internal Op-Amp
| Pin | Op-amp function |
|---|---|
| A1 | OPAMP + input |
| A2 | OPAMP – input |
| A3 | OPAMP output |
These pins can still be used as ordinary analogue inputs when the op-amp is not configured. The op-amp feature is useful for advanced analogue conditioning but requires deliberate peripheral configuration.
Main I2C Bus: Wire on A4/A5
| Signal | Header pin |
|---|---|
| SDA | A4 / D18 |
| SCL | A5 / D19 |
The normal UNO I²C bus is accessed using Wire. The dedicated SDA/SCL positions near AREF duplicate A4/A5.
#include <Wire.h>
void setup() {
Wire.begin();
}
void loop() {
}Qwiic Is a Separate I2C Bus
This is one of the most useful differences between R4 WiFi and older UNO boards.
The onboard Qwiic connector is connected to a second RA4M1 I²C controller using P400/P401 and the Arduino Wire1 object.
#include <Wire.h>
void setup() {
Wire1.begin(); // Qwiic connector
}
void loop() {
}This means a Qwiic sensor is not electrically sharing the same bus as a sensor connected to A4/A5 unless your software deliberately bridges data between them.
The Qwiic Connector Is 3.3 V Only
The Qwiic connector supplies 3.3 V and uses 3.3 V I²C signalling through onboard level-shifting circuitry.
Do not connect a Qwiic device that requires 5 V power to that connector unless its own documentation explicitly supports the 3.3 V supply available there.
This 3.3 V Qwiic bus is a deliberate exception to the normal 5 V UNO header world.
SPI
| SPI signal | UNO R4 WiFi pin |
|---|---|
| CS / SS | D10 |
| COPI / MOSI | D11 |
| CIPO / MISO | D12 |
| SCK | D13 |
The same SPI signals are available on the ICSP-style 6-pin header.
Arduino documentation now uses COPI/CIPO terminology; they correspond to the directions traditionally called MOSI/MISO.
D13 Is LED_BUILTIN and CAN RX
D13 carries three notable roles:
- SPI SCK.
- Built-in user LED.
- CAN RX alternate function.
If your project uses CAN, D13 is not available as an ordinary SPI clock or LED pin at the same time in the way you might expect from a basic sketch.
Hardware UART
| UART signal | Pin |
|---|---|
| RX | D0 |
| TX | D1 |
The R4 WiFi architecture gives you a native USB communication path separately from the D0/D1 hardware UART. That is a major improvement over UNO R3, where the single ATmega328P UART was also the USB serial programming path.
You can therefore use D0/D1 for an external serial peripheral while still using USB Serial, subject to the core/library configuration.
CAN Bus: D10 TX and D13 RX
The RA4M1 contains a CAN controller compatible with CAN 2.0A/B.
| CAN signal | UNO R4 WiFi pin |
|---|---|
| CANTX | D10 |
| CANRX | D13 |
You still need a CAN transceiver between those logic-level signals and CANH/CANL.
UNO R4 WiFi CAN transceiver CAN bus
D10 CANTX --------> TXD
D13 CANRX <-------- RXD
CANH -------------- CANH
CANL -------------- CANLThis mapping differs from the UNO R4 Minima, whose CAN pins are D4/D5. Do not copy Minima CAN wiring to the WiFi board.
Because D10/D13 are also part of the normal SPI interface, using CAN creates an important peripheral conflict with SPI on the header.
CAN Library
Arduino provides the Arduino_CAN library for the board.
#include <Arduino_CAN.h>
void setup() {
Serial.begin(115200);
if (!CAN.begin(CanBitRate::BR_500k)) {
while (1) {}
}
}
void loop() {
}Bit rate, termination and transceiver wiring must match the rest of the CAN network.
12×8 LED Matrix
UNO R4 WiFi includes a 12 × 8 matrix of 96 red LEDs directly on the board.
Arduino provides the Arduino_LED_Matrix library so you can display icons, patterns and simple animations without adding an external display.
#include "Arduino_LED_Matrix.h"
ArduinoLEDMatrix matrix;
void setup() {
matrix.begin();
}
void loop() {
}The matrix is excellent for status indicators, simple gauges, animations and classroom projects. It is not a general graphics display, but having 96 individually controllable LEDs onboard is unusually useful for a UNO-format board.
LED Matrix and GPIO Conflicts
The matrix is connected internally to RA4M1 resources rather than appearing as a simple extra GPIO header device. Use the official matrix library rather than trying to drive it as if it were an external LED panel.
If a low-level library reconfigures internal timer or pin resources used by the matrix, test carefully for conflicts. Normal Arduino-level use is designed to coexist cleanly.
RTC and VRTC Backup Pin
The RA4M1 has a real-time clock, and the R4 WiFi exposes a dedicated VRTC backup input.
Arduino specifies approximately 1.6–3.6 V on VRTC to keep the RTC running when the main board supply is removed.
This is a practical advantage over the R4 Minima, which has the RTC internally but does not expose the same convenient VRTC backup pin.
RTC Example
#include "RTC.h"
void setup() {
Serial.begin(115200);
RTC.begin();
}
void loop() {
RTCTime now;
RTC.getTime(now);
Serial.print(now.getHour());
Serial.print(":");
Serial.print(now.getMinutes());
Serial.print(":");
Serial.println(now.getSeconds());
delay(1000);
}OFF Pin
UNO R4 WiFi exposes an OFF pin that can be used as part of board power-control strategies.
This is not an ordinary GPIO. Treat it as a system/power-control signal and use the official board documentation before integrating it into a low-power circuit.
Native USB-C
UNO R4 WiFi uses USB-C and supports HID-style functionality such as keyboard and mouse emulation through the board architecture.
The ESP32-S3 and RA4M1 cooperate in a flexible USB/serial arrangement. For normal Arduino use this is transparent: upload sketches and use Serial as usual.
As with any HID-capable board, add a safe enable condition when developing keyboard/mouse sketches so a bug cannot continuously control the host PC.
ESP32-S3 Header
A 2×3 header exposes selected ESP32-S3 signals including UART and download-mode access.
The important electrical rule is simple: these signals are 3.3 V only.
This header is for advanced use cases such as direct ESP32-S3 programming or debugging. Normal UNO users do not need it.
Programming the ESP32-S3 Directly
It is possible to replace the ESP32-S3’s factory connectivity firmware with your own firmware.
That can be useful for experimentation, but it changes the normal board architecture. Once the ESP32 firmware is overwritten, RA4M1 Wi-Fi/Bluetooth communication and bridge behaviour may stop working until the Arduino firmware is restored.
If your real goal is simply to run an ESP32-S3 sketch directly, an ordinary ESP32-S3 development board is usually simpler.
Wi-Fi and Bluetooth
Wireless connectivity comes from the ESP32-S3-MINI-1-N8 module.
The board therefore gains:
- 2.4 GHz Wi-Fi.
- Bluetooth Low Energy.
- Arduino Cloud connectivity.
- Network libraries exposed through the UNO R4 WiFi software stack.
Unlike the original ESP32, ESP32-S3 does not provide Bluetooth Classic; it provides BLE.
UNO R4 WiFi Is Not the Same as Arduino Nano ESP32
Both boards contain ESP32-S3 technology, but their architectures are fundamentally different.
On the UNO R4 WiFi, the RA4M1 is the main sketch MCU and the ESP32-S3 acts primarily as the connectivity/bridge processor. On the Nano ESP32, the ESP32-S3 itself is the main application processor.
That difference affects GPIO, libraries, low-level code and how networking integrates with the application.
Power Pins
| Pin | Purpose |
|---|---|
| VIN | 6–24 V input |
| 5V | Main 5 V rail |
| 3V3 | 3.3 V output |
| IOREF | 5 V logic reference |
| VRTC | RTC backup supply input |
| OFF | Board power-control input |
| RESET | RA4M1 reset |
| BOOT | Boot/system control |
| AREF | ADC reference |
| GND | Ground |
The wide 6–24 V VIN range is convenient, but high input voltage plus significant board/peripheral current creates regulator heat. Use a properly regulated external supply for larger loads.
UNO R4 WiFi vs UNO R4 Minima
| Feature | UNO R4 Minima | UNO R4 WiFi |
|---|---|---|
| Main MCU | RA4M1 | RA4M1 |
| Wi-Fi / BLE | No | ESP32-S3 module |
| LED matrix | No | 12×8 / 96 LEDs |
| Qwiic | No | Yes, separate 3.3 V I²C bus |
| VRTC pin | No convenient exposed backup pin | Yes |
| OFF pin | No | Yes |
| CAN pins | D4 TX / D5 RX | D10 TX / D13 RX |
| ESP32 header | No | Yes, 3.3 V only |
| UNO logic | 5 V | 5 V |
| GPIO max | 8 mA/pin | 8 mA/pin |
If you only need the RA4M1, CAN, DAC, RTC and USB, the UNO R4 Minima is simpler. If Wi-Fi/BLE, onboard visual feedback or Qwiic matter, the WiFi version is much more capable.
UNO R4 WiFi vs UNO R3
Compared with the UNO R3, the R4 WiFi is a major architectural change: 32-bit CPU, much more memory, true DAC, CAN, RTC, native USB, Wi-Fi/BLE, LED matrix and Qwiic.
The trade-off is that low-level AVR libraries are not automatically compatible, and GPIO current capability is lower.
UNO R4 WiFi vs ESP32-S3 Dev Board
A dedicated ESP32-S3 DevKitC-1 runs the user application directly on ESP32-S3, exposes far more of its native GPIO/peripherals and is generally better for ESPHome or pure ESP32 development.
UNO R4 WiFi is better when you want the UNO shield ecosystem, 5 V logic, RA4M1 peripherals and Arduino’s dual-MCU abstraction with wireless added.
Common Mistake: Treating the ESP32 Header as 5 V
The normal UNO headers are 5 V. The ESP32-S3 header is not. It uses 3.3 V logic and can be damaged by 5 V signals.
Common Mistake: Using Wire on the Qwiic Connector
The Qwiic connector is on the secondary I²C bus and uses Wire1, not the normal Wire object.
If a Qwiic sensor appears completely invisible while A4/A5 devices work, check that your library can be told to use Wire1.
Common Mistake: Assuming Qwiic Is 5 V Because UNO Is 5 V
The Qwiic connector is explicitly 3.3 V. Do not use it to power a module that requires 5 V.
Many modern Qwiic/STEMMA QT sensors are designed for 3.3 V and work perfectly; verify the specific breakout.
Common Mistake: Copying Minima CAN Wiring
The R4 WiFi exposes CAN on D10/D13, while R4 Minima uses D4/D5. They share the RA4M1 but not every alternate function is routed to the same Arduino header pins.
Common Mistake: Connecting CAN Directly to the Vehicle Bus
D10/D13 are logic-level CAN controller signals, not CANH/CANL. You need a CAN transceiver and appropriate termination/protection.
Common Mistake: Forgetting CAN and SPI Share Pins
R4 WiFi CAN TX/RX use D10 and D13, which are also SPI CS and SCK.
A project that needs both the default SPI bus and CAN must be planned carefully; you cannot assume those pin functions operate independently at the same time.
Common Mistake: Overwriting the ESP32 Firmware
Direct ESP32-S3 programming is possible, but doing so replaces the firmware Arduino uses for Wi-Fi/Bluetooth and bridge functions.
Back up or know how to restore the default connectivity firmware before experimenting.
Common Mistake: Using R3 Current Assumptions
UNO R4 WiFi GPIO is limited to 8 mA per pin. Recalculate LED resistors and use proper external drivers for loads.
A Practical Pin Plan
- Keep D0/D1 for hardware UART if needed.
- Reserve D10/D13 if CAN is required.
- Reserve D10–D13 if using default SPI instead of CAN.
- Use A4/A5 with
Wirefor the normal 5 V-header I²C bus. - Use Qwiic with
Wire1for 3.3 V plug-and-play I²C modules. - Use A0 when the true DAC is required.
- Use D3/D5/D6/D9/D11 for PWM depending on other peripheral conflicts.
- Use D2/D3 when dedicated external interrupts are useful.
Final Recommendation
UNO R4 WiFi is one of the most feature-rich boards ever released in the classic UNO format. It combines a 5 V RA4M1 control platform with wireless connectivity from ESP32-S3, while adding an onboard 12×8 matrix, dual I²C buses, Qwiic, DAC, CAN, RTC and native USB.
The pin map to remember is: D3/D5/D6/D9/D10/D11 PWM; D10/D11/D12/D13 SPI; D10 CANTX and D13 CANRX; A4/A5 main I²C with Wire; Qwiic secondary I²C with Wire1; A0 DAC; D0/D1 UART.
The three biggest traps are equally important: the ESP32 header is 3.3 V only, the Qwiic connector is 3.3 V only, and R4 GPIO is limited to 8 mA per pin. Respect those rules and the board offers far more capability than its familiar UNO shape suggests.
Related Guides
- Arduino UNO R3 Pinout: GPIO, PWM, ADC, SPI, I2C and Interrupts
- Arduino UNO R4 Minima Pinout: GPIO, DAC, CAN, RTC and USB
- ESP32-S3 DevKitC-1 Pinout & Safe GPIOs
Official Resources
- Arduino UNO R4 WiFi Documentation — official board overview, downloads and tutorials.
- Arduino UNO R4 WiFi Full Pinout — official RA4M1, ESP32-S3, Qwiic and header mappings.
- Arduino UNO R4 WiFi Datasheet — power, interfaces, Qwiic and board architecture.
- Arduino UNO R4 WiFi User Manual — ADC, PWM, DAC, RTC, CAN, Qwiic, LED matrix and ESP32-S3 usage.