Quick answer: the Arduino UNO R4 Minima keeps the familiar UNO header layout but replaces the 8-bit ATmega328P with a 48 MHz Renesas RA4M1 Arm Cortex-M4. It remains a 5 V board, provides 14 digital pins and six analogue inputs, but adds a 14-bit-capable ADC, a true 12-bit DAC on A0, CAN 2.0B, a built-in RTC, native USB-C with HID support, more memory and a much wider 6–24 V VIN range.
For normal Arduino wiring, the familiar assignments remain: D3/D5/D6/D9/D10/D11 are the officially supported PWM pins, A4/A5 are I²C, D10–D13 are SPI and D0/D1 are the primary hardware UART. However, the RA4M1 adds alternate functions that did not exist on UNO R3, especially CAN on D4/D5, DAC on A0 and the op-amp functions on A1–A3.
The biggest electrical warning is easy to miss: although UNO R4 Minima is a 5 V board, Arduino’s official pinout specifies only 8 mA maximum per GPIO and 60 mA maximum overall. Do not carry UNO R3 current assumptions into an R4 design.
UNO R4 Minima Specifications
| Feature | Arduino UNO R4 Minima |
|---|---|
| Main MCU | Renesas R7FA4M1AB3CFM (RA4M1) |
| CPU | 32-bit Arm Cortex-M4 with FPU |
| Clock | 48 MHz |
| Board logic voltage | 5 V |
| Digital I/O | 14: D0–D13 |
| Analogue inputs | 6: A0–A5 |
| ADC | Up to 14 bit |
| DAC | 12 bit, A0 |
| PWM | D3, D5, D6, D9, D10, D11 |
| Flash | 256 KB |
| SRAM | 32 KB |
| Data Flash / EEPROM-style storage | 8 KB |
| UART | 1 default on D0/D1 |
| I²C | 1 default on A4/A5 / SDA/SCL |
| SPI | D10–D13 and ICSP header |
| CAN | CAN 2.0B on D4/D5; external transceiver required |
| RTC | Built into RA4M1 |
| USB | USB 2.0 Full-Speed via USB-C |
| Native USB HID | Yes |
| VIN operating range | 6–24 V |
UNO R4 Minima Pinout Quick Reference
| Arduino pin | RA4M1 pin | Main functions / notes |
|---|---|---|
| D0 / RX | P301 | UART RX, GPIO |
| D1 / TX | P302 | UART TX, GPIO |
| D2 | P105 | GPIO, external interrupt |
| D3 ~ | P104 | PWM, external interrupt, GPIO |
| D4 | P103 | GPIO, CAN TX |
| D5 ~ | P102 | PWM, CAN RX |
| D6 ~ | P106 | PWM, GPIO |
| D7 | P107 | GPIO |
| D8 | P304 | GPIO |
| D9 ~ | P303 | PWM, GPIO |
| D10 ~ | P112 | PWM, SPI CS |
| D11 ~ | P109 | PWM, SPI COPI/MOSI |
| D12 | P110 | SPI CIPO/MISO |
| D13 | P111 | SPI SCK, LED_BUILTIN |
| A0 | P014 | ADC, 12-bit DAC output |
| A1 | P000 | ADC, OPAMP + |
| A2 | P001 | ADC, OPAMP – |
| A3 | P002 | ADC, OPAMP output |
| A4 / SDA | P101 | ADC, I²C SDA |
| A5 / SCL | P100 | ADC, I²C SCL |
UNO R4 Keeps the Classic UNO Header Layout
One of the design goals of the R4 family was physical compatibility with the familiar UNO shield layout. Most older shields can therefore plug into the same header positions.
Physical compatibility does not guarantee software compatibility. Libraries written around direct ATmega328P registers, AVR timers, AVR interrupt registers or assumptions about the old 16 MHz architecture may need updating.
A shield that only uses normal Arduino APIs such as digitalWrite(), Wire, SPI or Serial is much more likely to move cleanly.
The RA4M1 Is a Major Upgrade from ATmega328P
UNO R4 Minima moves the UNO platform from an 8-bit AVR running at 16 MHz to a 32-bit Cortex-M4 at 48 MHz with hardware floating-point support.
| Resource | UNO R3 | UNO R4 Minima |
|---|---|---|
| CPU | ATmega328P 8-bit AVR | RA4M1 32-bit Cortex-M4 + FPU |
| Clock | 16 MHz | 48 MHz |
| Flash | 32 KB | 256 KB |
| SRAM | 2 KB | 32 KB |
| EEPROM/data storage | 1 KB EEPROM | 8 KB data flash |
| ADC | 10 bit | Up to 14 bit |
| True DAC | No | Yes, 12 bit |
| CAN controller | No | Yes |
| RTC | No built-in RTC | Yes |
| Native USB in main MCU | No | Yes |
Digital GPIO D0 to D13
All numbered digital pins can be used through the normal Arduino API.
const int outputPin = 8;
const int buttonPin = 7;
void setup() {
pinMode(outputPin, OUTPUT);
pinMode(buttonPin, INPUT_PULLUP);
}
void loop() {
digitalWrite(outputPin,
digitalRead(buttonPin) == LOW ? HIGH : LOW);
}The board’s digital reference is 5 V, which preserves compatibility with many traditional UNO circuits and shields.
The 8 mA GPIO Limit Matters
Do not assume an UNO R4 pin can source or sink the same current you may have used on an R3. Arduino’s official R4 Minima pinout gives:
- 8 mA maximum per pin.
- 60 mA maximum overall GPIO current.
Use GPIO as control signals. LEDs should use sensible resistor values, and relays, motors, solenoids, high-power LEDs and other loads need external driver stages.
A design that depended on driving several 20 mA LEDs directly from an UNO R3 should be redesigned rather than copied blindly to R4.
PWM Pins
The officially supported PWM pins are the same familiar six positions:
- D3
- D5
- D6
- D9
- D10
- D11
void setup() {
pinMode(9, OUTPUT);
analogWrite(9, 128);
}
void loop() {
}By default, Arduino’s PWM API uses the familiar 8-bit 0–255 range. The R4 core can also support higher write resolutions where the peripheral permits it using analogWriteResolution().
Remember that D5 is also the CAN RX pin and D10/D11 belong to the default SPI interface, so peripheral choice can consume PWM-capable pins.
Analogue Inputs A0 to A5
UNO R4 Minima keeps six analogue header positions but upgrades to the RA4M1’s higher-resolution ADC.
The Arduino API defaults to a familiar lower resolution for compatibility, but you can request up to 14 bits.
void setup() {
Serial.begin(115200);
analogReadResolution(14);
}
void loop() {
int value = analogRead(A1); // 0..16383 at 14-bit setting
Serial.println(value);
delay(100);
}Higher numerical resolution does not automatically guarantee 14 bits of real-world measurement accuracy. Reference stability, source impedance, noise, layout and calibration still matter.
A0 Is a Real DAC Output
A major difference from UNO R3 is that A0 can act as a true DAC output. The RA4M1 provides a 12-bit D/A converter.
This is fundamentally different from PWM. PWM switches a digital output on and off; a DAC generates an analogue voltage level.
void setup() {
analogWriteResolution(12);
}
void loop() {
analogWrite(DAC, 2048); // approximately mid-scale
}Depending on core version/examples, the DAC may be referenced using A0 or the board’s DAC alias. Check the current Arduino R4 examples if using library-specific names.
A true DAC is useful for waveform generation, audio experiments, control voltages and analogue set-points, although an external buffer/amplifier may still be needed depending on the load.
A1, A2 and A3 Expose the Internal Op-Amp
The RA4M1 includes an operational amplifier. On the UNO R4 analogue header:
| Pin | Op-amp role |
|---|---|
| A1 | OPAMP + input |
| A2 | OPAMP – input |
| A3 | OPAMP output |
This is an advanced RA4M1 capability rather than a normal UNO R3 feature. It can be useful for analogue conditioning, but use board/core documentation when configuring it because normal analogRead() use and op-amp mode are different peripheral configurations.
I2C: A4/A5 and SDA/SCL
| Signal | UNO R4 Minima pin |
|---|---|
| SDA | A4 / D18 / SDA |
| SCL | A5 / D19 / SCL |
As on UNO R3, the dedicated SDA/SCL header positions duplicate the same physical MCU signals as A4/A5. They are not a second I²C bus.
#include <Wire.h>
void setup() {
Wire.begin();
}
void loop() {
}SPI: D10 to D13 and the ICSP Header
| SPI signal | UNO R4 Minima pin |
|---|---|
| CS / SS | D10 |
| COPI / MOSI | D11 |
| CIPO / MISO | D12 |
| SCK | D13 |
Arduino’s newer documentation uses COPI and CIPO terminology instead of MOSI/MISO. They describe the same signal directions in controller/peripheral language.
The ICSP header carries the same SPI bus and is useful for shields that expect SPI in the standardized 6-pin position.
D13 Is LED_BUILTIN
D13 remains connected to the onboard user LED and is also the default SPI clock pin.
void setup() {
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
digitalWrite(LED_BUILTIN, HIGH);
delay(250);
digitalWrite(LED_BUILTIN, LOW);
delay(250);
}UART: D0 RX and D1 TX
The primary hardware serial pins remain in the traditional UNO positions:
| Signal | Pin |
|---|---|
| RX | D0 |
| TX | D1 |
Unlike UNO R3, the RA4M1 has native USB hardware, so USB communication no longer depends on an ATmega16U2 USB-to-UART converter in the same architecture.
D0/D1 are still valuable for hardware UART devices, while USB Serial can use the native USB interface.
CAN Bus: D4 TX and D5 RX
UNO R4 Minima includes a real CAN 2.0B controller inside the RA4M1.
| CAN signal | UNO R4 Minima pin |
|---|---|
| CAN TX | D4 |
| CAN RX | D5 |
The MCU CAN controller does not connect directly to CANH and CANL. You still need an external CAN transceiver such as an appropriate TJA, MCP or SN65 family device.
UNO R4 Minima CAN transceiver CAN bus
D4 CAN TX -------> TXD
D5 CAN RX <------- RXD
CANH -------------- CANH
CANL -------------- CANLTermination, bus voltage, transceiver supply and protection still follow normal CAN rules.
Also note the pin conflict: D5 is one of the standard PWM pins. If CAN is enabled, do not expect to use D5 independently for PWM.
CAN Pins Differ from UNO R4 WiFi
Do not assume advanced alternate-function pins are identical between the R4 Minima and R4 WiFi just because both use RA4M1.
On the Minima’s official pinout, CAN is exposed on D4/D5. The R4 WiFi board routes some alternate functions differently. Always use the pinout for the exact board revision you own.
Real-Time Clock
The RA4M1 includes an RTC capable of maintaining calendar/time state and generating alarms while the board is powered.
#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);
}The Minima does not expose the dedicated VRTC backup header found on the UNO R4 WiFi. If your application must retain accurate time through complete power removal, an external RTC with battery backup may be the simpler solution.
For powered operation, the built-in RTC is still useful for timestamps, alarms and scheduled events without adding another chip.
Native USB-C
UNO R4 Minima uses the RA4M1 USB 2.0 Full-Speed peripheral and provides a USB-C connector.
This enables more than programming and Serial Monitor. The board can present itself to a computer as a native USB device, including HID use cases.
- USB keyboard.
- USB mouse.
- Game controller-style HID.
- Native USB serial.
- Custom USB device experiments supported by the core/libraries.
This is a substantial architectural difference from UNO R3, where the ATmega328P itself has no USB peripheral.
USB HID Safety
A sketch that emulates a keyboard or mouse can immediately take control of the host computer when connected.
During development, include a physical enable condition, delay or button so a broken HID sketch does not continuously type or move the pointer every time you connect the board.
BOOT Pin
The power header area includes a BOOT pin in addition to RESET and IOREF. It is part of the RA4M1’s boot/programming architecture and is mainly relevant for recovery or low-level development.
For normal Arduino IDE use, you generally do not need to manipulate BOOT manually.
SWD Debugging
UNO R4 Minima exposes SWD signals on its debug header. That allows proper Cortex-M debugging with an appropriate probe/toolchain:
- Breakpoints.
- Single stepping.
- Register inspection.
- Memory inspection.
- Low-level firmware development.
For advanced RA4M1 development, this is a major improvement over treating the board as only a basic Arduino sketch target.
Power Pins
| Pin | Purpose |
|---|---|
| VIN | 6–24 V input through board regulator path |
| 5V | Main 5 V rail |
| 3V3 | 3.3 V output rail |
| GND | Ground |
| IOREF | 5 V I/O reference |
| RESET | Reset input |
| BOOT | Boot-mode control |
| AREF | ADC reference |
Arduino’s current UNO R4 Minima datasheet specifies a 6–24 V operating range on VIN/DC jack and 5 V USB-C power.
A wide VIN range does not mean every load should be powered through the board. Regulator thermal performance and total current still matter, especially near the top of the input-voltage range.
UNO R4 Minima Is Still a 5 V Board
The RA4M1 family can operate across a range of supply voltages, but Arduino configures the UNO R4 Minima as a 5 V board to preserve UNO shield compatibility.
That means its normal header GPIO logic is 5 V.
When connecting an ESP32, Raspberry Pi Pico, STM32 or another 3.3 V-only device, treat an R4 output exactly as a 5 V signal unless you have verified the receiving pin is tolerant.
UNO R4 Minima vs UNO R3
| Feature | UNO R3 | UNO R4 Minima |
|---|---|---|
| CPU | ATmega328P, 8-bit AVR | RA4M1, 32-bit Cortex-M4 + FPU |
| Clock | 16 MHz | 48 MHz |
| Flash | 32 KB | 256 KB |
| SRAM | 2 KB | 32 KB |
| Logic voltage | 5 V | 5 V |
| ADC | 10 bit | Up to 14 bit |
| DAC | No | 12 bit on A0 |
| CAN | No | Yes, transceiver required |
| RTC | No | Built in |
| USB in main MCU | No | Yes |
| USB connector | USB-B | USB-C |
| Normal GPIO current figure | 20 mA typical design figure | 8 mA max per official R4 pinout |
The R4 is not merely a faster R3. Its MCU architecture, timer hardware, USB system and low-level registers are completely different.
Read the Arduino UNO R3 pinout guide for the classic ATmega328P layout.
Shield Compatibility
The 5 V I/O and UNO form factor give the R4 Minima strong electrical compatibility with many older shields.
However, check three areas before assuming compatibility:
- Does the library contain AVR-specific register code?
- Does the shield assume R3 timer behaviour or interrupt numbers?
- Does it draw more GPIO current than the R4 permits?
Hardware may plug in perfectly while software still needs an updated library.
UNO R4 Minima vs STM32 Blue Pill
UNO R4 Minima and the STM32F103 Blue Pill are both Arm-based 32-bit boards, but they target different workflows.
Blue Pill is faster at 72 MHz and has a rich peripheral set, but it is a 3.3 V board with a less beginner-friendly pin map. R4 Minima keeps the familiar UNO headers, 5 V logic and official Arduino ecosystem while adding modern features such as DAC, RTC and native USB.
UNO R4 Minima vs ESP32
ESP32 remains the stronger choice for integrated Wi-Fi/Bluetooth and Home Assistant/IoT projects. UNO R4 Minima has no onboard wireless.
The R4 is attractive when you want 5 V shield compatibility, deterministic local control, CAN, DAC, RTC and native USB without adding a wireless stack.
See the ESP32 DevKitC V4 pinout for the ESP32 side of the comparison.
Common Mistake: Treating R4 Like an ATmega328P
Code that manipulates AVR registers such as PORTB, TCCR1A or ATmega-specific interrupt registers will not map directly to RA4M1.
Use portable Arduino APIs where possible or rewrite low-level code for the Renesas architecture.
Common Mistake: Assuming 20 mA GPIO
This is probably the most important R3-to-R4 electrical mistake. The R4 Minima pinout specifies 8 mA maximum per pin and 60 mA total.
Use external transistor/MOSFET drivers for loads and choose LED resistors accordingly.
Common Mistake: Connecting CANH/CANL Directly
D4/D5 are logic-side CAN controller signals. They are not CANH/CANL.
A CAN transceiver is mandatory between the MCU and the differential bus.
Common Mistake: Expecting the RTC to Survive Power Removal
The Minima has an internal RTC, but it does not expose the same backup-supply header found on the R4 WiFi. Do not assume unplugging the board will preserve time indefinitely.
Use an external battery-backed RTC if persistent timekeeping is a hard requirement.
Common Mistake: Using PWM on a Pin Already Needed by a Peripheral
Several pins multiplex functions. D5 is both PWM and CAN RX; D10/D11 are PWM and SPI.
The pin can only perform the configured peripheral function at a given time. Plan the complete interface map before wiring a shield plus extra peripherals.
Common Mistake: Assuming A0 DAC Means High-Current Analogue Output
A DAC is a signal source, not a power amplifier. If the load needs significant current, buffer the DAC output with an appropriate op-amp or driver circuit.
A Practical Default Pin Plan
- Keep D0/D1 free if you need the hardware UART.
- Reserve D4/D5 when CAN is planned.
- Reserve D10–D13 for SPI.
- Reserve A4/A5 for I²C.
- Use A0 when the true DAC is required.
- Use D3/D6/D9 for PWM first when CAN and SPI are both needed.
- Use D7/D8 and unused analogue pins for general GPIO.
Because R4 has more alternate-function capability than R3, deliberate pin planning becomes more important even though the header still looks familiar.
Final Recommendation
UNO R4 Minima is one of the easiest ways to move from classic 8-bit Arduino into a modern 32-bit MCU without abandoning the UNO form factor or 5 V shield ecosystem.
Remember the main map: D3/D5/D6/D9/D10/D11 are PWM; D4/D5 carry CAN; D10–D13 are SPI; A4/A5 are I²C; D0/D1 are UART; A0 is the 12-bit DAC; and A0–A5 support ADC operation up to 14-bit resolution.
The two biggest cautions are equally simple: the board’s GPIO current limit is only 8 mA per pin, and low-level AVR code written for UNO R3 is not portable to the RA4M1. Design around those differences and the R4 Minima is a substantial upgrade while still feeling like an UNO.
Related Guides
- Arduino UNO R3 Pinout: GPIO, PWM, ADC, SPI, I2C and Interrupts
- STM32F103C8T6 Blue Pill Pinout, GPIOs & Arduino IDE Guide
- ESP32 DevKitC V4 Pinout Diagram & Safe GPIOs
Official Resources
- Arduino UNO R4 Minima Documentation — official board overview, pinout, schematics and tutorials.
- Arduino UNO R4 Minima Full Pinout — official GPIO and alternate-function mapping.
- Arduino UNO R4 Minima Datasheet — power, MCU, memory and interface specifications.
- Renesas RA4M1 — official Cortex-M4, ADC, DAC, CAN and USB peripheral specifications.