In this guide, you’ll find the Arduino UNO R4 WiFi pinout diagram, its datasheet and schematic diagram, and every pin group explained with its default pins and gotchas. Without further ado, let’s get right into it!
The Arduino UNO R4 WiFi is two microcontrollers on one UNO board. A Renesas RA4M1 (48MHz Arm Cortex-M4F, 256KB flash, 32KB SRAM) runs your sketch at 5v logic, and an ESP32-S3 module handles Wi-Fi, Bluetooth LE and the USB-C port. It adds a 12×8 LED matrix, a 3.3v Qwiic connector, a 12-bit DAC, an op-amp, and CAN.
Arduino UNO R4 WiFi Pinout Diagram
Here is a detailed Arduino UNO R4 WiFi Pinout Diagram with colored labels and legends to help you easily identify the functionalities that each pin can perform. It shows the JANALOG (power + analog) and JDIGITAL headers, the JOFF header (OFF, GND, VRTC), and callouts for the Qwiic connector, the ICSP header and the ESP32-S3 header, with the Arduino pin numbers, the RA4M1 port pins, and every pin’s ADC, DAC, op-amp, PWM timer, UART, SPI, I2C, CAN and interrupt functions.
Each row shows the Arduino pin number used in digitalWrite() and pinMode() (D0–D13 are 0–13, A0–A5 are 14–19), the pin name, the RA4M1 port (P301, P014…), and its functions, color-coded by peripheral. Power and control pins (BOOT, IOREF, RESET, 3V3, 5V, VIN, AREF, OFF, VRTC) have no number. The dot symbol means a 5v I/O, the PWM symbol marks a GPT timer output, and the numbered badges point to the notes at the bottom of the diagram.
With the USB-C connector at the top, JANALOG is on the left (BOOT at the top, A5 at the bottom) and JDIGITAL is on the right (SCL at the top, D0 at the bottom), in the standard UNO R3 shield footprint. The SDA and SCL pins next to AREF are the same pins as A4 and A5.
Buy an Arduino UNO R4 WiFi: If you don’t have one yet, you can get the genuine Arduino board (ABX00087) from Amazon or AliExpress. It fits every UNO shield, and Wi-Fi, Bluetooth, and the LED matrix are ready to use right out of the box.
Download Arduino UNO R4 WiFi Pinout Diagram (Full Resolution)
The Arduino UNO R4 WiFi pinout diagram (JANALOG, JDIGITAL and JOFF headers, with the Qwiic, ICSP and ESP32 headers) in full resolution (5120×2800 px WebP), in one ZIP file. Print it, zoom in, or keep it next to your bench. Please consider supporting my work if it helped you.
Arduino UNO R4 WiFi Datasheet
This development board is built around the Renesas RA4M1 microcontroller (R7FA4M1AB3CFM, LQFP64), with an Espressif ESP32-S3-MINI-1 module as its Wi-Fi, Bluetooth, and USB co-processor. So the Arduino UNO R4 WiFi datasheet set has three parts: Arduino’s documents for the board, Renesas’s for the main chip, and Espressif’s for the radio module. Here are the official documents you’ll need, linked to their original sources:
| Document | ID | Revision | What You’ll Use It For | Link |
|---|---|---|---|---|
| Arduino UNO R4 WiFi datasheet | ABX00087 | Rev 10 (6 Nov 2026) | Board specs, power options, current limits, header pin lists | |
| Arduino UNO R4 WiFi schematic | ABX00087 | 23 Aug 2023 | The full board circuit (see the next section) | |
| Arduino UNO R4 WiFi full pinout | ABX00087 | Apr 2025 | Arduino’s pin map, including the ESP32-S3 pins | |
| Arduino UNO R4 WiFi user manual (cheat sheet) | Arduino Docs | Sep 2026 | Core features: LED matrix, Wi-Fi, RTC, DAC, OPAMP, CAN, Qwiic, HID | Web |
| RA4M1 Group datasheet | R01DS0355EJ0110 | Rev.1.10 (Sep 2023) | Pin functions (multiplexing), electrical limits, drive current, input levels | |
| RA4M1 Group User’s Manual: Hardware | R01UH0887EJ0110 | Rev.1.10 (Sep 2023) | Registers and every peripheral (GPT, SCI, IIC, CAN, ADC, DAC, CTSU, boot modes) | |
| ESP32-S3-MINI-1 datasheet | Espressif | v1.7 | The Wi-Fi/Bluetooth module: pins, strapping, RF |
Which document do I need? The Arduino datasheet for the board’s power limits and header map, the schematic for what’s connected to each pin, the RA4M1 datasheet for pin functions and electrical limits, the hardware manual when you write register-level code, and the ESP32-S3-MINI-1 datasheet only if you work on the ESP header. Arduino keeps all its board files on the Arduino UNO R4 WiFi product page.
Note: The Arduino UNO R4 WiFi datasheet’s feature list says “1x CAN (pin D4, D5)”. That line was copied from the UNO R4 Minima. On the WiFi board, the schematic, the RA4M1 pin list, the datasheet’s own pin table, Arduino’s CAN tutorial, and the core all put CAN on D10 (CAN TX) and D13 (CAN RX). Two smaller slips: the datasheet’s pin table labels D0 as “TX0” (it’s RX), and its board-topology table is shifted by one row.
Arduino UNO R4 WiFi Schematic
The Arduino UNO R4 WiFi schematic is shown below. Sheet 1 holds the whole board and sheet 2 the LED matrix, so here is sheet 1 in full, followed by close-ups of each block and the LED matrix sheet. Click a page to view it full screen.
Official source: the Arduino UNO R4 WiFi schematic ABX00087 (PDF) on Arduino Docs. Here’s what to look at:
- Power path: the DC jack and VIN (6v–24v) go through the reverse-polarity Schottky diode D1 (PMEG6020) into the ISL854102 buck converter (U3), which makes 5v. Renesas rates the ISL854102 at 1.2A. USB-C VBUS reaches the same 5v rail through a second Schottky diode, D2, so the 5V pin reads about 4.7v on USB power.
- 3.3v rail: the SGM2205-3.3 LDO (U5) makes 3.3v from the 5v rail. SG Micro rates the SGM2205 at 800mA, but the same rail powers the ESP32-S3, whose Wi-Fi transmit bursts take a big share of it, and the Qwiic port (through the PTC fuse F1).
- OFF pin: JOFF-1 is the buck converter’s EN pin, pulled up to VIN by R35 (100kΩ). Tie it to GND to switch the 5v buck off. It only cuts VIN power; USB power still reaches the 5v rail through D2.
- RA4M1 (U1): runs from the 5v rail (VCC and AVCC0 = 5v), which is why every header pin is 5v logic. There is no crystal on it: XTAL/EXTAL (P212/P213) drive the LED matrix, and XCIN/XCOUT (P214/P215) aren’t connected, so the chip runs on its internal oscillators. VBATT is the VRTC pin on the JOFF header.
- Headers: JANALOG-1 is the RA4M1 MD pin (BOOT), with the 5.1kΩ pull-up R7; on the UNO R3 that position is NC. AREF goes to VREFH0 through the ferrite bead L1, with the 5.1kΩ pull-up R6 to 5v. The I2C pull-ups for A4/A5 (R4/R5) are marked “I2C PULLUPS NOT MOUNTED”.
- Reset: the RESET button (PB1) with its 100kΩ pull-up (R3) resets only the RA4M1. The ESP32-S3’s EN pin has its own 100kΩ pull-up (R26) and only two test pads, so the button doesn’t reset the radio module.
- ESP32-S3 link: a TXB0108 level translator (U4) connects the 5v RA4M1 to the 3.3v ESP32-S3: two UARTs (P501/P502 for Wi-Fi, P109/P110 for the USB bridge), SWD (P108/P300), MD and RESET. That’s how the ESP32-S3 uploads your sketch.
- USB-C: two NLASB3157 switches (U2, U6) send the USB data lines to the ESP32-S3 by default. Driving P408 HIGH, or bridging the solder jumper SJ1, routes them to the RA4M1’s own USB instead.
- Qwiic (J2): the RA4M1’s second I2C bus, IIC0 on P401 (SDA) and P400 (SCL), goes through two 2N7002 MOSFET level shifters (Q1, Q2) with 5.1kΩ pull-ups on both sides, and gets 3.3v through the 500mA PTC fuse F1.
- LEDs: the L LED (labelled SCK LED) on D13 is driven through the MOSFET Q3, so it doesn’t load the SPI clock. The TX LED is on P109 and the RX LED on the ESP32-S3’s TXD0 line: they show USB serial traffic, not D0/D1.
Arduino UNO R4 WiFi Specs
The Arduino UNO R4 WiFi is a UNO-size RA4M1 board with an ESP32-S3 radio co-processor. Here are its specifications, including the board-level parts that chip-only spec lists usually skip.

Get an Arduino UNO R4 WiFi: The genuine Arduino board is the one I recommend. Grab it from Amazon or AliExpress.
| Item | Arduino UNO R4 WiFi |
|---|---|
| Microcontroller | Renesas RA4M1 (R7FA4M1AB3CFM, LQFP64) |
| CPU | 32-bit Arm Cortex-M4F at 48MHz, with FPU |
| Memory | 256KB flash, 32KB SRAM, 8KB data flash (EEPROM) |
| Co-processor | Espressif ESP32-S3-MINI-1-N8 (dual-core Xtensa LX7, 8MB flash), 3.3v |
| Wireless | Wi-Fi 4 (2.4GHz) and Bluetooth LE 5, PCB antenna |
| Logic level | 5v on every UNO header pin; 3.3v on the Qwiic connector and the ESP header |
| I/O pins | 20: D0–D13, A0–A5 |
| Analog | 6 ADC inputs (A0–A5, up to 14-bit), 1x 12-bit DAC (A0), 1x op-amp (A1–A3) |
| Board supply | USB-C 5v, or 6v–24v on VIN / the DC jack |
| 5v regulator | ISL854102 synchronous buck converter, rated 1.2A |
| 3.3v regulator | SGM2205-3.3 LDO, rated 800mA, shared with the ESP32-S3 |
| Pin current | 8mA per pin (Arduino); RA4M1: 4mA source on most D pins |
| Display | 12×8 red LED matrix (96 LEDs) |
| USB connector | USB-C, through the ESP32-S3 USB bridge (switchable to the RA4M1’s native USB) |
| Connectors | UNO R3 headers, JOFF (OFF, GND, VRTC), ICSP (2×3), ESP header (2×3), Qwiic (JST SH 4-pin) |
| User I/O | L LED (D13), TX/RX LEDs, power LED, reset button |
| Form factor | Arduino UNO, 68.6 × 53.4mm |
| Operating temperature | −40°C to +85°C |
Arduino UNO R4 WiFi Specifications Summary
- The Arduino UNO R4 WiFi runs a Renesas RA4M1 (Arm Cortex-M4F) at 48MHz with 256KB flash, 32KB SRAM and 8KB EEPROM; an ESP32-S3 adds Wi-Fi 4 and Bluetooth LE 5.
- Your sketch runs on the RA4M1; the ESP32-S3 is the radio and the USB-to-serial bridge.
- It has 20 I/O pins (D0–D13, A0–A5), all at 5v logic.
- It has 6 analog inputs (A0–A5) with a 14-bit ADC (10-bit by default), a 12-bit DAC on A0, and an op-amp on A1 (+), A2 (−), A3 (out).
- Arduino marks 6 PWM pins with “~” (D3, D5, D6, D9, D10, D11), and every D pin plus A4/A5 has a GPT timer output.
- Serial is the USB-C port; Serial1 is the hardware UART on D0 (RX) / D1 (TX).
- Wire is on A4 (SDA) / A5 (SCL) at 5v with no pull-ups; Wire1 is the Qwiic connector at 3.3v.
- SPI is D11 (COPI), D12 (CIPO), D13 (SCK) with D10 as CS, also on the ICSP header.
- The CAN pins are D10 (TX) and D13 (RX), not D4/D5; they need an external transceiver.
- Power it from USB-C (5v) or VIN / DC jack (6v–24v); never feed more than 5v into USB-C.
- LED_BUILTIN is on D13; the 12×8 LED matrix uses its own 11 RA4M1 pins, so no header pin is lost.
- Arduino rates each pin at 8mA; the RA4M1 sources only 4mA on D0–D10, D13, A4 and A5.
Arduino UNO R4 WiFi Peripherals: RA4M1 vs On the Headers
The RA4M1 has more peripherals than the UNO headers can expose. This table shows what the chip has and what you can actually reach on the UNO R4 WiFi.
| Peripheral | RA4M1 | On the UNO R4 WiFi |
|---|---|---|
| GPIO | 51 I/O on the LQFP64 | 20 (D0–D13, A0–A5) |
| ADC | 14-bit SAR, up to 25 channels | 6 Arduino inputs (A0–A5); the chip also has AN019/AN020 on D10/D13 |
| DAC | 1x 12-bit (DA0) | A0 |
| Op-amp | 4 (OPAMP0–3) | OPAMP0 on A1 (+), A2 (−), A3 (out) |
| Comparator | 2 (ACMPLP) | CMPIN0/CMPREF0 on A5/A4, CMPIN1/CMPREF1 on D13/D10 |
| PWM timers | 2x 32-bit GPT + 6x 16-bit GPT | 16 GPT outputs: D0–D13, A4, A5 |
| UART (SCI) | 4 (SCI0, SCI1, SCI2, SCI9) | Serial1 = SCI2 on D0/D1; SCI1 and SCI9 go to the ESP32-S3 |
| SPI | 2 (SPI0, SPI1) | SPI = SPI0 on D10–D13 and the ICSP header |
| I2C | 2 (IIC0, IIC1) | Wire = IIC1 on A4/A5 (5v); Wire1 = IIC0 on Qwiic (3.3v) |
| CAN | 1 (CAN 2.0B) | D10 (TX), D13 (RX) |
| USB | USB 2.0 Full-Speed | Through the USB-C switches (ESP32-S3 bridge by default) |
| Touch (CTSU) | Yes | D0, D1, D2, D3, D6, D8, D9, D11, D12, A1, A2 and the LOVE pad (library) |
| RTC | Yes (with VBATT) | Internal oscillator (no 32.768kHz crystal); VRTC pin for a backup battery |
| LED matrix pins | – | 11 RA4M1 pins, not on the headers |
Arduino UNO R4 WiFi Quick Pin Selection Guide
Not sure which pin to use? Here are the Arduino UNO R4 WiFi pins I’d pick first for each job, and why.
| Use Case | Recommended Pins | Why |
|---|---|---|
| Serial to the PC | USB-C (Serial) | Bridged by the ESP32-S3; D0/D1 stay free |
| Serial to a module (GPS, GSM…) | D0 (RX), D1 (TX) as Serial1 | The only hardware UART on the headers |
| 5v I2C sensors and displays | A4 (SDA), A5 (SCL) | The Arduino Wire bus; add pull-ups |
| 3.3v I2C sensors | Qwiic connector (Wire1) | Level-shifted, with pull-ups and 3.3v power |
| SPI devices | D11 (COPI), D12 (CIPO), D13 (SCK), D10 (CS) | The Arduino SPI pins, also on ICSP |
| Analog inputs | A0–A3 first | A4/A5 are the I2C pins |
| True analog output | A0 (DAC) | 12-bit DAC, a real voltage instead of PWM |
| PWM (LEDs, motors, servos) | D3, D5, D6, D9, D10, D11 | The default “~” pins |
| CAN bus | D10 (TX), D13 (RX) | Arduino_CAN defaults; add a transceiver |
| External interrupt | D2, D3 | Each on its own IRQ channel, as on the UNO R3 |
| Touch buttons | D2, D3, D8, D9, LOVE pad | CTSU channels in the Arduino_CapacitiveTouch library |
| Safest general GPIO | D2, D4, D5, D7, D8, D9 | No bus, boot or analog role |
Arduino UNO R4 WiFi Pins to Use With Caution
| Pin | Reason | What to Do |
|---|---|---|
| BOOT (JANALOG-1) | RA4M1 MD pin: LOW at reset starts the Renesas ROM boot mode | Leave it open; check shields that use the old NC pin |
| D10, D13 | SPI CS/SCK and CAN TX/RX share these pins | Use either native CAN or SPI, not both |
| A4, A5 (= SDA, SCL) | The Wire bus, with no pull-ups on the board | Add 4.7kΩ to 5v; don’t use them as ADC inputs while I2C runs |
| AREF | Pulled to 5v through 5.1kΩ | Use a reference that can drive against 5.1kΩ, or leave it open |
| D0, D1 | Serial1 | Free for GPIO if you don’t need the UART |
| A0, A1–A3 | DAC output; op-amp pins | Not ADC inputs while the DAC or OPAMP.begin() is active |
| D0–D10, D13, A4, A5 | P1xx/P3xx ports: 4mA source limit | Drive LEDs and loads through a transistor |
| Qwiic, ESP header | 3.3v only | Never connect 5v signals |
| OFF | Pulling it LOW turns off the 5v buck | Leave it open unless you want a power switch |
| 5V on USB power | About 4.7v (Schottky drop) | Expect analog readings against 5v to shift slightly |
Arduino UNO R4 WiFi: RA4M1 vs ESP32-S3, Which Chip Does What?
The Arduino UNO R4 WiFi has two processors, and only one of them runs your sketch. The Renesas RA4M1 runs your Arduino code and owns every UNO header pin. The ESP32-S3-MINI-1 runs Arduino’s bridge firmware: it’s the Wi-Fi and Bluetooth radio, the USB-to-serial converter that uploads your sketches, and nothing else by default.
| Job | RA4M1 (5v) | ESP32-S3 (3.3v) |
|---|---|---|
| Runs your sketch | Yes | No (bridge firmware) |
| UNO header pins, LED matrix, Qwiic | Yes | No |
| Wi-Fi and Bluetooth LE | Through WiFiS3 / ArduinoBLE commands | Yes (the radio) |
| USB-C port | Optional (P408 / SJ1 switch) | Yes, by default (USB bridge) |
| Link between them | SCI1 P501/P502 (Serial2, Wi-Fi), SCI9 P109/P110 (USB serial), SWD | Through the TXB0108 level translator |
| Own pins you can reach | All UNO headers | ESP header J6 only (GPIO41/42, UART0, GPIO0) |
In practice, you program the board exactly like a UNO: WiFiS3.h sends the Wi-Fi commands from the RA4M1 to the ESP32-S3 over Serial2, so you never touch the ESP32-S3 yourself. The only time it matters is when you reflash the bridge firmware, or use the ESP header for your own ESP32-S3 code.
Arduino UNO R4 WiFi Pins Functions
The 35 header pins of the Arduino UNO R4 WiFi (14 on JANALOG, 18 on JDIGITAL and 3 on JOFF) are divided into the following groups based on the hardware functionality they’re used for. Most I/O pins belong to several groups at once.
- Power Pins: VIN, 5V, 3V3, IOREF, GND, OFF, VRTC
- 20x Digital GPIO Pins
- 13x Interrupt Pins
- 6x ADC Analog Input Pins
- 1x DAC Pin & 1x Op-Amp
- 16x PWM Pins (6 marked “~”)
- 11x Capacitive Touch Pins
- 1x UART Port (+ USB Serial)
- 2x I2C Buses (A4/A5 and Qwiic)
- 1x SPI Port (+ ICSP header)
- 1x CAN Bus
- ESP32-S3 Header
- BOOT & Reset Pins
We’ll discuss each pin group in the following sections one by one in more detail.
Arduino UNO R4 WiFi Power Pins
The Arduino UNO R4 WiFi is powered from the USB-C port (5v) or from 6v–24v on VIN or the DC jack. VIN goes through the ISL854102 buck converter to the 5v rail that runs the RA4M1, and an SGM2205 LDO makes 3.3v for the ESP32-S3, the 3V3 pin and the Qwiic connector. The power pins are highlighted in red in the pinout diagram.

| Pin | Header Pin | Range | Notes |
|---|---|---|---|
| VIN | JANALOG-8 | 6v–24v in | Same node as the DC jack (after D1), into the ISL854102 buck (1.2A rated) |
| 5V | JANALOG-5 | 5v | The main 5v rail (MCU supply); about 4.7v on USB power |
| 3V3 | JANALOG-4 | 3.3v out | SGM2205 LDO (800mA rated), shared with the ESP32-S3 and Qwiic |
| IOREF | JANALOG-2 | 5v | Tells shields the board’s logic level |
| GND | JANALOG-6, 7, JDIGITAL-15, JOFF-2 | 0v | All grounds are common |
| OFF | JOFF-1 | Pull LOW | Enable pin of the 5v buck (100kΩ pull-up to VIN); LOW = buck off |
| VRTC | JOFF-3 | 1.6v–3.6v in | The RA4M1 VBATT pin: a backup battery keeps the RTC running |
USB-C must never get more than 5v (the board has no regulator on that input), and VIN must stay within 6v–24v. When both are connected, the two Schottky diodes pick the higher supply, so you can leave the USB cable plugged in while the board runs from VIN.
Note: Don’t plan on the full 800mA from the 3V3 pin. The ESP32-S3 shares that regulator, and its Wi-Fi transmit bursts draw a large share of it. Keep 3.3v loads small, and power motors, LED strips or servos from their own supply.
Arduino UNO R4 WiFi GPIO Pins
The Arduino UNO R4 WiFi has 20 GPIO pins: D0–D13 and A0–A5 (digital pins 14–19). All of them work at 5v logic, like the UNO R3, so 5v sensors, modules and shields connect directly.

Each pin can be INPUT, INPUT_PULLUP or OUTPUT. Here are the electrical limits from the Arduino and Renesas datasheets:
- Logic level 5v; never apply more than 5.5v to any pin.
- A HIGH input needs at least 4.0v (0.8 × VCC, RA4M1 datasheet), so a 3.3v signal isn’t a guaranteed HIGH.
- Arduino rates each pin at 8mA. The RA4M1 datasheet is stricter for the P1xx/P3xx ports, which are D0–D10, D13, A4 and A5: 4mA source and 8mA sink. A0–A3, D11 and D12 can source 8mA.
- That’s far less than the UNO R3’s 20mA–40mA, so an LED with a 220Ω resistor, fine on an R3, is already too much for most UNO R4 WiFi pins.
Note: If your old UNO R3 projects drive LEDs, relays or buzzers straight from the pins, check the current first. On the Arduino UNO R4 WiFi, use a 1kΩ resistor for indicator LEDs, and a transistor or MOSFET for anything bigger.
Learn more in our Arduino digitalWrite() GPIO Tutorial.
Also Read
Arduino UNO R4 WiFi Interrupt Pins
The Arduino UNO R4 WiFi has 13 interrupt pins: D0, D1, D2, D3, D6, D8, D11, D12 and A1–A5. attachInterrupt(digitalPinToInterrupt(pin), isr, mode) works on any of them, with RISING, FALLING, CHANGE and LOW triggers. D2 and D3 are the classic UNO interrupt pins and each has its own IRQ channel.

| Pin | IRQ Channel | Shared With | Pin | IRQ Channel | Shared With |
|---|---|---|---|---|---|
| D0 | IRQ6 | A1 | A1 | IRQ6 | D0 |
| D1 | IRQ5 | D12 | A2 | IRQ7 | – |
| D2 | IRQ1 | A4 | A3 | IRQ2 | A5 |
| D3 | IRQ0 | – | A4 | IRQ1 | D2 |
| D6 | IRQ4 | D11 | A5 | IRQ2 | A3 |
| D8 | IRQ9 | – | D11 | IRQ4 | D6 |
| D12 | IRQ5 | D1 |
Two pins on the same IRQ channel can’t both be interrupts at the same time: pick D2 or A4, D6 or D11, and so on. D4, D5, D7, D9, D10, D13 and A0 have no external interrupt.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
volatile bool pressed = false; void onPress() { pressed = true; } void setup() { Serial.begin(115200); pinMode(2, INPUT_PULLUP); // button from D2 to GND attachInterrupt(digitalPinToInterrupt(2), onPress, FALLING); } void loop() { if (pressed) { pressed = false; Serial.println("Button pressed"); } } |
Learn more in our Arduino External Interrupts Tutorial.
Also Read
Arduino UNO R4 WiFi ADC Pins
The Arduino UNO R4 WiFi has 6 ADC pins, A0–A5, on the RA4M1’s 14-bit ADC. analogRead() returns 10-bit values (0–1023) by default, for UNO R3 compatibility, and analogReadResolution(12) or (14) gives 0–4095 or 0–16383. The input range is 0v to 5v. The ADC pins are highlighted in green in the pinout diagram.

| Pin | RA4M1 Port | ADC Channel | Also |
|---|---|---|---|
| A0 | P014 | AN009 | DAC output |
| A1 | P000 | AN000 | Op-amp + input |
| A2 | P001 | AN001 | Op-amp − input |
| A3 | P002 | AN002 | Op-amp output |
| A4 | P101 | AN021 | I2C SDA (Wire) |
| A5 | P100 | AN022 | I2C SCL (Wire) |
The default reference is the 5v rail, through the AREF pin’s 5.1kΩ resistor. analogReference(AR_INTERNAL) switches to the internal reference, about 1.43v in the core, for small signals. Let’s say you read a 0–1v sensor: with the 5v reference and 14-bit resolution you get about 3,277 steps across its range; with the internal reference you get more than 11,000.
Note: On USB power the 5v rail is only about 4.7v (the Schottky diode drop), so a reading against the default reference is off by about 6% unless you power the board from VIN or use the internal reference.
There are so many sensors that we can read with the ADC pins, which include: potentiometers, LDRs, analog temperature sensors (LM35, TMP36, NTC thermistors), soil moisture sensors, joysticks, current sensors (ACS712), and much more.
|
1 2 3 4 5 6 7 8 9 10 11 |
void setup() { Serial.begin(115200); analogReadResolution(14); // 0..16383 } void loop() { int raw = analogRead(A1); float volts = raw * 5.0 / 16383.0; // default 5v reference Serial.println(volts, 3); delay(500); } |
Learn more in our Arduino ADC analogRead() Tutorial.
Also Read
Arduino UNO R4 WiFi DAC and Op-Amp Pins
The Arduino UNO R4 WiFi has a 12-bit DAC on A0 and a built-in op-amp on A1 (+), A2 (−) and A3 (output). Neither exists on the UNO R3.
| Function | Pin | How to Use It |
|---|---|---|
| DAC output (12-bit) | A0 (P014, DA0) | analogWriteResolution(12); analogWrite(DAC, 2048); gives about 2.5v |
| Op-amp + input | A1 (P000) | #include <OPAMP.h>, then OPAMP.begin(OPAMP_SPEED_HIGHSPEED); |
| Op-amp − input | A2 (P001) | Wire the feedback network here |
| Op-amp output | A3 (P002) | The amplified signal |
The DAC gives a real analog voltage (0v to the 5v reference), not a PWM square wave, so you can make audio tones, sine waves, or a programmable reference without a filter. The op-amp is a full amplifier: wire A3 to A2 for a voltage follower (buffer), or add two resistors for a non-inverting amplifier (two 10kΩ resistors give a gain of 2).
Note: While the DAC runs, A0 isn’t an ADC input, and while OPAMP.begin() is active, A1–A3 aren’t ADC inputs either. If you also use I2C on A4/A5, plan your analog inputs carefully.
Arduino UNO R4 WiFi PWM Pins
The Arduino UNO R4 WiFi has 6 default PWM pins marked “~”: D3, D5, D6, D9, D10 and D11, the same as the UNO R3. Behind them, every D pin and A4/A5 has a GPT timer output, 16 pins in all, and the core’s analogWrite() sets up a timer for any pin that has one. The PWM pins are highlighted in orange in the pinout diagram.

Arduino UNO R4 WiFi Default PWM Pins: D3, D5, D6, D9, D10, and D11 (8-bit by default, up to 16-bit with analogWriteResolution(16)).
| GPT Timer | Output A | Output B |
|---|---|---|
| GPT0 (32-bit) | D5~ | D4 |
| GPT1 (32-bit) | D3~ | D2 |
| GPT2 | D10~ | D13 |
| GPT3 | D6~ | D7 |
| GPT4 | D1 | D0 |
| GPT5 | A4 | A5 |
| GPT6 | D11~ | D12 |
| GPT7 | D8 | D9~ |
The two pins of one GPT timer share its counter, so they share one PWM frequency (users have seen D5 and D6 change frequency together when they change one timer; Arduino Forum). Use the six “~” pins first; each sits on a different timer.
There are so many things that we can control with PWM, which include: LED dimming, RGB LEDs, DC motor speed (with a driver), servo motors, buzzers, ESCs for brushless motors, and much more.
Learn more in our Arduino PWM analogWrite() Tutorial.
Also Read
Arduino UNO R4 WiFi Capacitive Touch Pins
The Arduino UNO R4 WiFi has 11 capacitive touch pins on its headers: D0, D1, D2, D3, D6, D8, D9, D11, D12, A1 and A2, plus the heart-shaped LOVE pad on the board. They use the RA4M1’s CTSU touch peripheral through Arduino’s Arduino_CapacitiveTouch library.
This list is different from the UNO R4 Minima’s (D6 and D12 are touch pins on the WiFi; D13 isn’t), so pages that copy the Minima list get it wrong. The library’s own pin table and the RA4M1 touch channels (TS02–TS34) agree with the list above.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
#include "Arduino_CapacitiveTouch.h" CapacitiveTouch touch = CapacitiveTouch(D2); // or LOVE_BUTTON void setup() { Serial.begin(115200); touch.begin(); touch.setThreshold(500); // lower = more sensitive } void loop() { if (touch.isTouched()) Serial.println("Touched!"); delay(100); } |
Arduino UNO R4 WiFi UART Pins
The Arduino UNO R4 WiFi has 1 hardware UART on its headers: Serial1 on D0 (RX) and D1 (TX) (RA4M1 SCI2). Serial is the USB-C port, bridged by the ESP32-S3, and Serial2 is the internal link to the ESP32-S3 used by Wi-Fi. The UART pins are highlighted in blue in the pinout diagram.

Arduino UNO R4 WiFi Default UART Pins: D0 (RX) and D1 (TX) for Serial1.
| Port | Arduino Object | RX Pin | TX Pin | Note |
|---|---|---|---|---|
| SCI9 | Serial | P110 | P109 | USB-C, through the ESP32-S3 USB bridge |
| SCI2 | Serial1 | D0 (P301) | D1 (P302) | 5v logic, on the headers |
| SCI1 | Serial2 | P502 | P501 | Internal link to the ESP32-S3 (Wi-Fi) |
Unlike the UNO R3, D0/D1 aren’t shared with the USB port, so you can talk to a GPS or GSM module on Serial1 and print debug messages on Serial at the same time. The TX and RX LEDs show the USB traffic, not D0/D1.
|
1 2 3 4 5 6 7 8 9 |
void setup() { Serial.begin(115200); // USB-C to the PC Serial1.begin(9600); // D0 = RX, D1 = TX } void loop() { while (Serial1.available()) Serial.write(Serial1.read()); // module -> PC while (Serial.available()) Serial1.write(Serial.read()); // PC -> module } |
Note: Old UNO R3 sketches use Serial for a module on D0/D1. On the Arduino UNO R4 WiFi, change them to Serial1, or the module gets nothing. When Serial1 prints garbage, check the wiring and baud rate first: a loopback test (D0 to D1) shows the port itself works (Arduino Forum).
There are so many modules that we can interface with the UART pins, which include: GPS modules, GSM/LTE modules, fingerprint sensors, RS485 transceivers, DFPlayer Mini, other microcontrollers, and much more.
Learn more in our Arduino UART Serial Communication Tutorial.
Arduino UNO R4 WiFi I2C Pins
The Arduino UNO R4 WiFi has 2 I2C buses. Wire is on A4 (SDA) and A5 (SCL) at 5v (RA4M1 IIC1), also brought out as the SDA/SCL pins next to AREF. Wire1 is the Qwiic connector at 3.3v (RA4M1 IIC0 on P401/P400), with on-board level shifters. The I2C pins are highlighted in yellow in the pinout diagram.

Arduino UNO R4 WiFi Default I2C Pins: A4 (SDA) and A5 (SCL) for Wire; the Qwiic connector for Wire1.
| I2C Bus | Arduino Object | SDA | SCL | Level | Note |
|---|---|---|---|---|---|
| IIC1 | Wire | A4 / SDA (P101) | A5 / SCL (P100) | 5v | No pull-ups on the board (R4/R5 not mounted) |
| IIC0 | Wire1 | Qwiic pin 3 (P401) | Qwiic pin 4 (P400) | 3.3v | 5.1kΩ pull-ups on both sides of the shifters |
The Qwiic connector is a JST SH 4-pin (SM04B-SRSS-TB) in the standard order: GND, 3.3v, SDA, SCL. It works with SparkFun Qwiic, Adafruit STEMMA QT and Arduino Modulino boards.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
#include <Wire.h> // gives both Wire and Wire1 void setup() { Serial.begin(115200); Wire.begin(); // A4/A5, 5v devices Wire1.begin(); // Qwiic, 3.3v devices for (byte a = 1; a < 127; a++) { Wire1.beginTransmission(a); if (Wire1.endTransmission() == 0) { Serial.print("Qwiic device at 0x"); Serial.println(a, HEX); } } } void loop() {} |
Note: The Arduino UNO R4 WiFi has no I2C pull-ups on A4/A5. A bare sensor with no pull-ups of its own won’t answer until you add 4.7kΩ resistors to 5v (Arduino Forum). And most Qwiic library examples call Wire: on this board the Qwiic port is Wire1, so pass it to the library, for example sensor.begin(Wire1) (SparkFun Community).
There are so many modules and sensors that we can interface with the I2C bus, which include: OLED displays (SSD1306), I2C LCDs, RTC modules (DS3231), IMUs (MPU6050), BME280 sensors, port expanders, Qwiic and Modulino nodes, and much more.
Learn more in our Arduino I2C Tutorial.
Also Read
Arduino UNO R4 WiFi SPI Pins
The Arduino UNO R4 WiFi has 1 SPI port (RA4M1 SPI0). The default SPI pins are D11 (COPI), D12 (CIPO) and D13 (SCK), with D10 as CS, the same as the UNO R3. The same signals are on the 2×3 ICSP header. The SPI pins are highlighted in pink in the pinout diagram.

Arduino UNO R4 WiFi Default SPI Pins: D11 (COPI/MOSI), D12 (CIPO/MISO), D13 (SCK), and D10 (CS).
| Signal | Pin | RA4M1 Port | ICSP Pin |
|---|---|---|---|
| SCK | D13 | P102 (RSPCKA) | 3 |
| CIPO (MISO) | D12 | P410 (MISOA) | 1 |
| COPI (MOSI) | D11 | P411 (MOSIA) | 4 |
| CS (SS) | D10 | P103 (SSLA0) | – |
| +5V / RESET / GND | – | – | 2 / 5 / 6 |
The ICSP header (printed “SPI” on production boards, “ICSP” on Arduino’s renders) is just the RA4M1’s SPI bus. Unlike the UNO R3, you can’t use it to burn a bootloader into the main chip.
There are so many modules that we can interface with the SPI bus, which include: TFT displays (ILI9341, ST7789), SD card modules, LoRa radios (SX1276), nRF24L01 radios, MAX7219 LED drivers, W5500 Ethernet modules, and much more.
Arduino UNO R4 WiFi CAN Pins
The Arduino UNO R4 WiFi CAN pins are D10 (CAN TX) and D13 (CAN RX), not D4/D5 as the board’s datasheet and many pinout pages say. The RA4M1 has 1 CAN 2.0B controller (up to 1Mbps), and it needs an external CAN transceiver, since the board has none. The CAN pins are highlighted in purple in the pinout diagram.

Arduino UNO R4 WiFi Default CAN Pins: D10 (TX) and D13 (RX), used by the Arduino_CAN library that comes with the core (see Arduino’s UNO R4 WiFi CAN tutorial).
Because the board is 5v, you can use a 5v transceiver like the MCP2551 or TJA1050 directly. Wire its TXD to D10 and RXD to D13, and terminate the bus with 120Ω at both ends. A 3.3v transceiver outputs only 3.3v on RXD, below the 4.0v HIGH level of D13.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
#include <Arduino_CAN.h> void setup() { Serial.begin(115200); if (!CAN.begin(CanBitRate::BR_500k)) { Serial.println("CAN init failed"); while (1); } } void loop() { uint8_t data[] = {0xCA, 0xFE}; CAN.write(CanMsg(CanStandardId(0x20), sizeof(data), data)); delay(1000); } |
Note: CAN shares D10 and D13 with the SPI bus (CS and SCK), so you can’t use the native CAN pins and an SPI device (an SD card, a display) at the same time. If you need both, use an SPI CAN controller module (MCP2515) on the SPI bus instead of the native CAN pins.
Arduino UNO R4 WiFi ESP32 Header and USB
The Arduino UNO R4 WiFi’s ESP header (J6, 2×3, next to the RESET button) gives direct access to the ESP32-S3: its UART0, the GPIO0 boot pin and two JTAG pins. It runs at 3.3v and is wired straight to the module, so never connect 5v signals to it.
| Pin | Signal | Pin | Signal |
|---|---|---|---|
| 1 | ESP_IO42 (MTMS, JTAG) | 2 | ESP_IO41 (MTDI, JTAG) |
| 3 | ESP_TXD0 (GPIO43, UART0 TX) | 4 | ESP_DOWNLOAD (GPIO0, boot strap) |
| 5 | ESP_RXD0 (GPIO44, UART0 RX) | 6 | GND |
You’d use it to reflash the ESP32-S3 by hand (GPIO0 LOW at reset = ESP ROM download mode) or to run your own ESP32-S3 firmware. For normal use, update the bridge firmware with Arduino’s firmware updater over USB instead.
The USB-C port goes to the ESP32-S3 by default, which converts it to the RA4M1’s Serial UART and handles the uploads. Two NLASB3157 switches can route the USB lines straight to the RA4M1’s native USB instead: drive P408 HIGH in code, or bridge the SJ1 solder jumper to make it permanent (then uploads no longer go through the ESP32-S3).
Arduino UNO R4 WiFi BOOT and Reset Pins
The Arduino UNO R4 WiFi has a BOOT pin (JANALOG-1) and a RESET pin (JANALOG-3). BOOT is the RA4M1’s MD pin: if it’s LOW when the chip comes out of reset, the RA4M1 starts its Renesas ROM boot mode instead of your sketch. On the UNO R3 that position was NC (not connected).
| Pin | RA4M1 | Role | On the Board |
|---|---|---|---|
| BOOT (JANALOG-1) | MD (P201) | LOW at reset = ROM boot mode | 5.1kΩ pull-up to 5v (R7) |
| RESET (JANALOG-3) | RES | Reset, active LOW | 100kΩ pull-up (R3), RESET button PB1, ICSP pin 5 |
| SWDIO / SWCLK | P108 / P300 | SWD debug | Wired to the ESP32-S3, no header |
If your board stops showing up after an upload, double-tap the RESET button: the RA4M1 stays in the Arduino bootloader, and you can upload a working sketch. Note that the button resets only the RA4M1, not the ESP32-S3.
Note: Some old shields connect the UNO R3’s unused NC pin (now BOOT) to something. If a shield holds it LOW at power-up, the UNO R4 WiFi sits in ROM boot mode instead of running your sketch. Check what your shield does with that pin.
Arduino UNO R4 WiFi On-Board Features
Besides the headers, the Arduino UNO R4 WiFi has a 12×8 LED matrix, four LEDs, a reset button, the Qwiic connector, a real-time clock, and the ESP32-S3 radio. Here’s what each one does.
| Part | Pin / Connection | What It Does |
|---|---|---|
| 12×8 LED matrix | 96 red LEDs on 11 RA4M1 pins (P003, P004, P011, P012, P013, P015, P204, P205, P206, P212, P213) | Text, icons and animations with Arduino_LED_Matrix |
| L LED (DL4, yellow) | D13 through MOSFET Q3 | LED_BUILTIN, active HIGH |
| TX LED (DL1) | P109 (USB serial TX) | Board → PC serial traffic |
| RX LED (DL2) | ESP32-S3 TXD0 | PC → board serial traffic |
| ON LED (DL3, green) | 5v rail | Board powered |
| Reset button (PB1) | RA4M1 RES | One press resets; a double-tap enters the bootloader |
| Qwiic connector (J2) | IIC0 (P401/P400) via level shifters | 3.3v I2C bus, Wire1 |
| RTC | Internal, VRTC backup pin | Date and time with RTC.h |
The LED matrix is charlieplexed on its own 11 pins, so it costs you no header pins. Here’s the quickest way to light it up:
|
1 2 3 4 5 6 7 8 9 10 |
#include "Arduino_LED_Matrix.h" ArduinoLEDMatrix matrix; void setup() { matrix.begin(); matrix.loadFrame(LEDMATRIX_HEART_BIG); // a built-in frame } void loop() {} |
A note on the RTC: the board has no 32.768kHz crystal, so the RTC runs from the RA4M1’s internal low-speed oscillator and can drift. On this board that’s easy to fix: sync the RTC from an NTP server over Wi-Fi at start-up and every few hours. A coin cell (1.6v–3.6v) on VRTC keeps it running while the board is off.
Getting Started With Arduino UNO R4 WiFi
You can program the Arduino UNO R4 WiFi with the Arduino IDE, Arduino Cloud or PlatformIO, all over the USB-C cable. No external programmer is needed.
- Arduino IDE 2: in the Boards Manager, install “Arduino UNO R4 Boards” (the same core as the UNO R4 Minima and Nano R4), then select Arduino UNO R4 WiFi.
- Libraries in the core: WiFiS3.h (Wi-Fi), ArduinoBLE (install it from the Library Manager), Arduino_LED_Matrix.h, RTC.h, OPAMP.h, Arduino_CAN.h, EEPROM.h, and the usual Wire and SPI.
- Most UNO R3 code runs as is. Check the pin current, use Serial1 for D0/D1, and add I2C pull-ups.
| Arduino Name | Pin | Default |
|---|---|---|
Serial | USB-C | USB serial through the ESP32-S3 |
Serial1 | D0 (RX), D1 (TX) | SCI2 |
Wire | A4 (SDA), A5 (SCL) | IIC1, 5v |
Wire1 | Qwiic connector | IIC0, 3.3v |
SPI | D11 / D12 / D13, SS = D10 | SPI0 |
CAN | D10 (TX), D13 (RX) | CAN0 |
LED_BUILTIN | 13 | L LED, active HIGH |
DAC | A0 | 12-bit DAC |
Since the Arduino UNO R4 WiFi uses the same RA4M1 and core as the Arduino Nano R4, the ADC, DAC, op-amp, PWM and CAN code from that guide works here too; only the pin numbers change.
Arduino UNO R4 WiFi Common Problems & Fixes
Why doesn’t CAN work on D4/D5? Because on the UNO R4 WiFi it’s on D10 (TX) and D13 (RX). The datasheet’s “D4, D5” line was copied from the UNO R4 Minima.
Why isn’t my I2C sensor found on A4/A5? The board has no I2C pull-ups. Add 4.7kΩ resistors from SDA and SCL to 5v, unless your module has its own.
Why isn’t my Qwiic sensor found? The Qwiic port is Wire1, not Wire. Call Wire1.begin() and pass Wire1 to the sensor library. And don’t add more pull-ups to that bus: too many can lock it up.
Why doesn’t my GPS or Bluetooth module work on D0/D1? Use Serial1, not Serial. On the UNO R4 WiFi, Serial is the USB port.
Why can’t I use CAN and an SD card together? CAN RX/TX are D13/D10, the same pins as SPI SCK and CS. Use an MCP2515 SPI CAN module, or keep the native CAN and drop the SPI device.
Why did my pin stop working after driving an LED from it? The RA4M1 pins are rated 8mA (4mA source on most D pins), far less than the UNO R3. Use a bigger resistor or a transistor.
Why do two of my PWM pins change frequency together? They’re on the same GPT timer (D4/D5, D2/D3, D6/D7…). Move one of them to a pin on another timer.
Why won’t the board start on my shield? The shield may hold the BOOT pin (the old NC position) LOW at power-up, which starts the ROM boot mode.
Why isn’t my UNO R4 WiFi detected after an upload? Double-tap the RESET button and upload a working sketch. If the port still doesn’t appear, update the ESP32-S3 bridge firmware with Arduino’s firmware updater.
Arduino UNO R4 WiFi vs UNO R4 Minima vs UNO Q vs UNO R3
The Arduino UNO R4 WiFi is the connected version of the UNO R4 Minima. Here’s how it compares with the Minima, the Linux-capable UNO Q, and the classic Arduino UNO R3:
| Feature | Arduino UNO R4 WiFi | UNO R4 Minima | UNO Q | UNO R3 |
|---|---|---|---|---|
| Main chip | Renesas RA4M1 (Cortex-M4F) | Renesas RA4M1 | Qualcomm QRB2210 (Linux) + STM32U585 | ATmega328P |
| Clock | 48MHz | 48MHz | 2.0GHz quad-core + 160MHz MCU | 16MHz |
| Flash / RAM (MCU) | 256KB / 32KB | 256KB / 32KB | 2MB / 786KB (STM32U585) | 32KB / 2KB |
| Logic level | 5v | 5v | 3.3v | 5v |
| Wireless | Wi-Fi 4 + BLE (ESP32-S3) | None | Wi-Fi 5 + Bluetooth 5.1 | None |
| LED matrix | 12×8 red | No | 8×13 blue | No |
| Qwiic connector | Yes (Wire1) | No | Yes | No |
| CAN pins | D10 / D13 | D4 / D5 | Yes (STM32 FDCAN) | No |
| DAC / op-amp | Yes / Yes | Yes / Yes | DAC on A0 / – | No / No |
| USB | USB-C via ESP32-S3 | USB-C, native | USB-C (with video out) | USB-B, 16U2 bridge |
| VIN | 6v–24v | 6v–24v | 7v–24v | 7v–12v |
| Pin current | 8mA | 8mA | STM32 limits | 20mA (40mA max) |
Pick the Arduino UNO R4 WiFi when you want UNO shields and 5v logic plus Wi-Fi, Bluetooth and the LED matrix. The UNO R4 Minima is the same RA4M1 board without the radio, the matrix and Qwiic, for less money. The UNO Q is a different class of board: a Linux computer plus an STM32 MCU, at 3.3v. And the UNO R3 is still fine for simple 5v projects, as long as you don’t need its pins to source more than a few mA on the R4.
Arduino UNO R4 WiFi Pin Details
Here is every Arduino UNO R4 WiFi header pin in physical order, with its Arduino number, RA4M1 port, main functions, all its alternate functions from the Renesas datasheet, and a short description. With the USB-C connector at the top, JOFF and JANALOG are on the left (JANALOG-1 is BOOT, at the top), and JDIGITAL is on the right, numbered from D0 (pin 1, bottom) to SCL (pin 18, top), as on Arduino’s schematic.
Arduino UNO R4 WiFi JOFF Header Pins
| Pin | Label | Arduino # | RA4M1 Port | Main Functions | All Alternate Functions | Logic Level | Description |
|---|---|---|---|---|---|---|---|
| JOFF-1 | OFF | – | – | Buck enable | – | – | Pull LOW to switch off the 5v buck converter (VIN power only). |
| JOFF-2 | GND | – | – | Ground | – | – | Ground. |
| JOFF-3 | VRTC | – | VBATT | RTC backup in | – | – | Backup battery input (1.6v–3.6v) that keeps the RTC running. |
Arduino UNO R4 WiFi JANALOG Header Pins
Click to expand the full pin table (14 pins)
| Pin | Label | Arduino # | RA4M1 Port | Main Functions | All Alternate Functions | Logic Level | Description |
|---|---|---|---|---|---|---|---|
| JANALOG-1 | BOOT | – | MD (P201) | Boot mode select | – | 5v | The RA4M1 MD pin with a 5.1kΩ pull-up; LOW at reset starts the ROM boot mode. |
| JANALOG-2 | IOREF | – | – | 5v reference | – | – | Tied to 5v; tells shields the logic level. |
| JANALOG-3 | RESET | – | RES | Reset (active LOW) | – | 5v | Resets the RA4M1 when pulled LOW, like the button. |
| JANALOG-4 | 3V3 | – | – | 3.3v out | – | – | Output of the SGM2205 LDO, shared with the ESP32-S3. |
| JANALOG-5 | 5V | – | – | 5v rail | – | – | The board’s 5v rail; about 4.7v on USB power. |
| JANALOG-6 | GND | – | – | Ground | – | – | Ground. |
| JANALOG-7 | GND | – | – | Ground | – | – | Ground. |
| JANALOG-8 | VIN | – | – | 6v–24v in | – | – | External supply input, the same node as the DC jack. |
| JANALOG-9 | A0 | 14 | P014 | ADC, DAC | AN009, DA0 | 5v | Analog input and the 12-bit DAC output. |
| JANALOG-10 | A1 | 15 | P000 | ADC, OPAMP + | IRQ6, AN000, AMP0+, TS21 | 5v | Analog input, op-amp + input, and a touch pin. |
| JANALOG-11 | A2 | 16 | P001 | ADC, OPAMP − | IRQ7, AN001, AMP0−, TS22 | 5v | Analog input, op-amp − input, and a touch pin. |
| JANALOG-12 | A3 | 17 | P002 | ADC, OPAMP out | IRQ2, AN002, AMP0O | 5v | Analog input and the op-amp output. |
| JANALOG-13 | A4 | 18 | P101 | ADC, I2C SDA (Wire) | KR01/IRQ1, AGTEE0, GTETRGB, GTIOC5A, TXD0/MOSI0/SDA0, CTS1_RTS1/SS1, SDA1, MOSIA, AN021, CMPREF0, VL2 | 5v | The default I2C SDA pin (no pull-up on the board), also an analog input. |
| JANALOG-14 | A5 | 19 | P100 | ADC, I2C SCL (Wire) | KR00/IRQ2, AGTIO0, GTETRGA, GTIOC5B, RXD0/MISO0/SCL0, SCK1, SCL1, MISOA, AN022, CMPIN0, VL1 | 5v | The default I2C SCL pin (no pull-up on the board), also an analog input. |
Arduino UNO R4 WiFi JDIGITAL Header Pins
Click to expand the full pin table (18 pins)
| Pin | Label | Arduino # | RA4M1 Port | Main Functions | All Alternate Functions | Logic Level | Description |
|---|---|---|---|---|---|---|---|
| JDIGITAL-1 | D0 / RX | 0 | P301 | Serial1 RX, PWM | IRQ6, AGTIO0, GTOULO, GTIOC4B, RXD2/MISO2/SCL2, CTS9_RTS9/SS9, SSLB2, SEG01/COM5, TS09 | 5v | Serial1 receive pin; also an interrupt and touch pin. |
| JDIGITAL-2 | D1 / TX | 1 | P302 | Serial1 TX, PWM | IRQ5, GTOUUP, GTIOC4A, TXD2/MOSI2/SDA2, SSLB3, SEG02/COM6, TS08 | 5v | Serial1 transmit pin; also an interrupt and touch pin. |
| JDIGITAL-3 | D2 | 2 | P104 | GPIO, interrupt, PWM | KR04/IRQ1, GTETRGB, GTIOC1B, RXD0/MISO0/SCL0, SSLA1, COM0, TS13 | 5v | Classic interrupt pin (IRQ1, shared with A4) and a touch pin. |
| JDIGITAL-4 | ~D3 | 3 | P105 | PWM, interrupt | KR05/IRQ0, GTETRGA, GTIOC1A, SSLA2, COM1, TS34 | 5v | Default PWM pin with its own interrupt (IRQ0); also a touch pin. |
| JDIGITAL-5 | D4 | 4 | P106 | GPIO, PWM | KR06, GTIOC0B, SSLA3, COM2 | 5v | General-purpose I/O; PWM-capable (GPT0 B). Not a CAN pin on this board. |
| JDIGITAL-6 | ~D5 | 5 | P107 | PWM | KR07, GTIOC0A, COM3 | 5v | Default PWM pin (GPT0 A). Not a CAN pin on this board. |
| JDIGITAL-7 | ~D6 | 6 | P111 | PWM, interrupt | IRQ4, GTIOC3A, SCK2, SCK9, RSPCKB, CAPH, TS12 | 5v | Default PWM pin; also an interrupt and touch pin. |
| JDIGITAL-8 | D7 | 7 | P112 | GPIO, PWM | GTIOC3B, TXD2/MOSI2/SDA2, SCK1, SSLB0, SSIBCK0, CAPL, TSCAP | 5v | General-purpose I/O; PWM-capable (GPT3 B). |
| JDIGITAL-9 | D8 | 8 | P304 | GPIO, interrupt, PWM | IRQ9, GTIOC7A, SEG20, TS11 | 5v | General-purpose I/O with its own interrupt (IRQ9); also a touch pin. |
| JDIGITAL-10 | ~D9 | 9 | P303 | PWM | GTIOC7B, SEG03/COM7, TS02 | 5v | Default PWM pin; also a touch pin. |
| JDIGITAL-11 | ~D10 | 10 | P103 | SPI CS, CAN TX, PWM | KR03, GTOWUP, GTIOC2A, CTX0, CTS0_RTS0/SS0, SSLA0, AN019, CMPREF1, VL4 | 5v | SPI chip select and the CAN TX pin. |
| JDIGITAL-12 | ~D11 | 11 | P411 | SPI COPI, PWM | IRQ4, AGTOA1, GTOVUP, GTIOC6A, TXD0/MOSI0/SDA0, MOSIA, SEG07, TS07 | 5v | SPI COPI (MOSI), also on ICSP-4; a default PWM and touch pin. |
| JDIGITAL-13 | D12 | 12 | P410 | SPI CIPO, PWM | IRQ5, AGTOB1, GTOVLO, GTIOC6B, RXD0/MISO0/SCL0, MISOA, SEG08, TS06 | 5v | SPI CIPO (MISO), also on ICSP-1; an interrupt and touch pin. |
| JDIGITAL-14 | D13 | 13 | P102 | SPI SCK, CAN RX, LED_BUILTIN | KR02, AGTO0, GTOWLO, GTIOC2B, CRX0, SCK0, TXD2/MOSI2/SDA2, RSPCKA, AN020/ADTRG0, CMPIN1, VL3 | 5v | SPI SCK (ICSP-3), the CAN RX pin, and the L LED (through a MOSFET). |
| JDIGITAL-15 | GND | – | – | Ground | – | – | Ground. |
| JDIGITAL-16 | AREF | – | VREFH0 | ADC reference | – | – | ADC reference input, pulled to 5v through 5.1kΩ. |
| JDIGITAL-17 | SDA | 18 | P101 | I2C SDA (Wire) | Same pin as A4 | 5v | The same net as A4. |
| JDIGITAL-18 | SCL | 19 | P100 | I2C SCL (Wire) | Same pin as A5 | 5v | The same net as A5. |
Wrap Up
To conclude this guide article, the Arduino UNO R4 WiFi is a very solid upgrade for anyone who grew up on the UNO R3. It keeps the shield footprint and 5v logic, and adds a 48MHz Cortex-M4F, Wi-Fi and Bluetooth through the ESP32-S3, a 12×8 LED matrix, a Qwiic port, a 12-bit DAC, an op-amp, and CAN. Just remember the board-level gotchas: CAN is on D10/D13, A4/A5 have no pull-ups, the pins are rated only 8mA, the Qwiic port is Wire1, D0/D1 are Serial1, and JANALOG-1 is BOOT.
I hope you’ve found this guide helpful for your project. For more boards, check out the Pinouts, Datasheets & Schematic Diagrams Library. Follow this Arduino Series of Tutorials to learn more about Arduino programming.
If you’re just getting started with Arduino, you need to check out the Arduino Getting Started Ultimate Guide below.
The complete beginner’s guide to Arduino programming: installing the IDE, your first sketch, and the Arduino tutorials series step by step.






