Arduino UNO R4 Minima Pinout Reference

The Arduino UNO R4 Minima represents a major leap forward for the maker community. It marks the definitive transition from the older 8-bit AVR architecture (the ATmega328P found in the Arduino UNO R3) to a modern and much more powerful 32-bit Arm® Cortex®-M ecosystem.

By integrating the powerful Renesas RA4M1 microcontroller while keeping the familiar UNO board shape, the UNO R4 Minima delivers a massive boost in speed, memory, and capabilities. It introduces advanced features, such as a Controller Area Network (CAN) bus, a built-in Operational Amplifier (OPAMP), and a high-resolution Digital-to-Analog Converter (DAC); all while maintaining compatibility with the vast library of existing shields and accessories.

However, this new power comes with some new rules. There are significant changes in the power supply architecture, particularly regarding the 3.3V power rail and GPIO current limits. If you are migrating from the reliable old Arduino UNO R3, you need to pay close attention to the pinout to ensure your projects transition smoothly without damaging your new board.

Arduino UNO R4 Minima Pinout

The UNO R4 Minima has a total of 32 pins. The pinout is as follows:

Let’s take a closer look at the Arduino pins and their functions, starting with the digital pins.

Arduino UNO R4 Minima Digital I/O Pins

The UNO R4 Minima includes 14 digital I/O pins, labeled D0 through D13.

You can configure these pins to act as either Inputs or Outputs. When a pin is set as an input, it can read digital signals, such as whether a button is pressed or not. When a pin is set as an output, it can send digital signals to control other devices like LEDs, motors, or relays.

To use a digital pin, you first need to tell the Arduino how that pin should behave using the pinMode() function. If you want to set a pin as an input, you use pinMode(pin, INPUT), and then you can read the pin’s state using the digitalRead(pin) function. If you want to set a pin as an output, you use pinMode(pin, OUTPUT). You can then control the pin by writing digitalWrite(pin, HIGH) to turn it on or digitalWrite(pin, LOW) to turn it off.

When using digital I/O pins, there are a few important electrical limits to keep in mind. These pins operate at 5V logic level. Each digital pin can safely handle up to 8 mA of current, and all the digital pins together should not exceed a total of 60 mA.

This is an important difference compared to the ATmega328P microcontroller used on the UNO R3, where each pin could typically handle between 20 and 40 mA. If you are migrating from the UNO R3, you must be careful not to directly drive high-current loads (like low-resistance optocouplers or multiple LEDs) without using proper current-limiting resistors or driver transistors. If you exceed the 8 mA limit, you could permanently damage the microcontroller’s internal output drivers.

Internal Pull-up Resistors

Each digital pin on the UNO R4 Minima includes a built-in pull-up resistor. This feature is especially useful when a pin is used as an input and nothing is connected to it. Without a pull-up resistor, an input pin can float, which means it may randomly switch between HIGH and LOW because of electrical noise in the environment. This can cause unpredictable and confusing results.

The internal pull-up resistor helps solve this problem by gently pulling the voltage of the pin up to HIGH when no other signal is present. This keeps the input reading stable and reliable. When you connect a button or switch, pressing it can pull the pin down to LOW, allowing the Arduino to clearly detect a change.

To turn on the internal pull-up resistor, you use pinMode(pin, INPUT_PULLUP) instead of just pinMode(pin, INPUT).

Please note that the value of this internal pull-up resistor is not fixed, but it is usually around 20 kΩ.

Arduino UNO R4 Minima Interrupt Pins

Interrupt pins are special digital input pins that can trigger a specific block of code (an interrupt service routine or ISR) when an external event occurs, such as a change in voltage level (HIGH to LOW or vice versa). This allows the Arduino to respond immediately to events without constantly checking the pin’s state in the main loop of your code.

The UNO R4 Minima has two primary external interrupt pins, located on pins 2 and 3:

The UNO R4 Minima supports four trigger modes that determine when your ISR executes, as shown in the table below:

To set up an interrupt, the Arduino uses a function called attachInterrupt(interrupt, ISR, mode). In this function, the interrupt value tells the Arduino which interrupt to use, where interrupt 0 corresponds to digital pin 2 and interrupt 1 corresponds to digital pin 3. The ISR is the name of the function that should run when the interrupt happens. The mode defines how the interrupt is triggered, such as RISING, FALLING, CHANGE, or LOW.

It is also important to understand that the UNO R4 Minima uses a modern Cortex-M4-based microcontroller, which includes a system called a Nested Vector Interrupt Controller, or NVIC. This system is far more sophisticated and supports interrupts on almost every digital and analog pin. However, to keep things simple and familiar for users, the Arduino software mainly focuses on pins D2 and D3 for external interrupts, matching the behavior of the classic UNO boards.

Arduino UNO R4 Minima PWM Pins

PWM (Pulse-Width Modulation) pins on the UNO R4 Minima are digital pins that can simulate analog output. They do this by switching the pin between HIGH and LOW extremely fast; so fast that it appears as a steady voltage somewhere in between. The key idea behind PWM is the duty cycle, which is the percentage of time the signal stays HIGH during one complete cycle. By varying the duty cycle, you can control the average voltage delivered to a connected component, allowing you to dim LEDs, control motor speeds, and even generate simple audio tones.

The UNO R4 Minima provides 6 PWM-capable pins: D3, D5, D6, D9, D10, and D11. You can easily spot these on the board by the tilde symbol (~) printed next to the pin number.

To generate a PWM signal, you first need to set the desired PWM pin as an output using the pinMode(pin, OUTPUT) function inside the setup() part of your sketch. After that, you use the analogWrite(pin, value) function to set the PWM output. In this function, pin is the PWM-capable pin number, and value controls the duty cycle.

By default, the PWM resolution on the UNO R4 Minima is set to 8 bits. This means PWM values range from 0 to 255. This ensures that code written for older Arduino boards works perfectly without modification.

However, the UNO R4 Minima is more powerful and allows you to increase the PWM resolution. By using the analogWriteResolution() function, you can increase the resolution up to 12 bits, which allows values from 0 to 4096 and gives you finer control over the output.

analogWriteResolution(12);  //Sets the PWM resolution to 12 bits
analogWriteResolution(8);   //Sets the PWM resolution to 8 bits (default)

Arduino UNO R4 Minima ADC Pins

Analog input pins on the UNO R4 Minima are used to read continuous analog signals. These signals usually come from sensors that measure physical quantities such as temperature, light intensity, sound, or pressure. Unlike digital signals, which are only HIGH or LOW, analog signals can have many different voltage levels. To understand these signals, the Arduino uses a built-in Analog-to-Digital Converter, or ADC, which converts the analog voltage into a digital number that your program can use.

The UNO R4 Minima has six analog input pins, labeled A0 through A5.

To read an analog value from a pin, you use the analogRead(pin) function. This function returns an integer value that represents the voltage on the selected pin.

By default, the ADC on the UNO R4 Minima uses a 10-bit resolution for backward compatibility. With a 10-bit resolution, the returned value ranges from 0 to 1023. This means that an input voltage between 0 and 5 V is divided into 1024 equal steps. At this setting, the Arduino can detect voltage changes as small as 4.9 mV.

However, the R4 Minima is much more powerful than its predecessors. You can boost the resolution up to 12 bits or even 14 bits, which allows the Arduino to detect much smaller changes in voltage. At 14-bit resolution, the voltage step size is approximately 0.3 mV when using a 5 V range. To change the ADC resolution, you use the analogReadResolution() function inside the setup() part of your sketch.

analogReadResolution(10); //(default)
analogReadResolution(12);
analogReadResolution(14);

It is also worth remembering that if you run out of standard digital pins, pins A0 through A5 can function as regular digital I/O pins as well.

Changing Analog Reference Voltage

By default, the UNO R4 Minima measures analog voltages using a reference range of 0 to 5V (board’s 5V supply). This reference voltage determines the maximum voltage the ADC can measure. In some cases, such as if you’re using a sensor that operates at a lower voltage (like 3.3V), you may want to measure lower voltages more accurately.

To do this, you can change the analog reference voltage using the AREF pin and the analogReference(type) function.

analogReference(AR_DEFAULT);   //Uses the default analog reference of 5V.
analogReference(AR_INTERNAL);  //Uses an internal reference voltage of 1.5V.
analogReference(AR_EXTERNAL);  //Uses an external reference voltage applied to the AREF pin.

Arduino UNO R4 Minima DAC Pin

The UNO R4 Minima includes a built-in Digital-to-Analog Converter (DAC). A DAC does the opposite of an ADC: instead of reading an analog voltage and turning it into a number, it takes a digital value and converts it into a smooth analog voltage. This is a massive upgrade for the UNO R4 Minima, making it perfect for audio projects like generating smooth sine waves, controlling Voltage Controlled Oscillators (VCOs) in synthesizers, or providing a variable reference voltage.

On the UNO R4 Minima, the DAC is available on the A0 analog pin.

To use the DAC, you actually use the exact same analogWrite(pin, value) function that you use for generating PWM signals.

analogWrite(pin, value);

By default, the DAC pin operates at an 8-bit resolution, meaning it accepts values between 0 and 255. For example, writing a value of 0 will output close to 0 V, while writing 255 will output close to 5 V. A value around 127, which is roughly the middle of the range, will output about 2.5 V on the A0 pin.

For some applications, especially audio projects, an 8-bit resolution may not provide smooth enough output. In those cases, the UNO R4 Minima allows you to increase the DAC resolution up to 12 bits. When using 12-bit resolution, the values you write to the pin will range from 0 to 4095, giving you incredibly fine control over the output voltage.

analogWriteResolution(12);

Just keep in mind that if you are using A0 as a DAC output, you cannot simultaneously use it as an analog input to read sensors.

Arduino UNO R4 Minima OP-Amp Pins

One of the most powerful new features of the R4 Minima is the inclusion of an Operational Amplifier (op-amp). Having a built-in op-amp saves you from needing external chips for tasks like buffering signals, amplifying weak sensor data, filtering noise, or performing many other analog tasks.

While the microcontroller used on the UNO R4 Minima, the Renesas RA4M1, actually has four internal op-amps, the board exposes one of them for you to use on the analog header. Specifically, it uses A1 as the positive (Non-Inverting) input, A2 as the negative (Inverting) input, and A3 as the output.

To start using the op-amp on the UNO R4 Minima, you need to include the OPAMP.h library in your sketch and then initialize it using the OPAMP.begin(speed) function. The optional speed parameter allows you to choose between different operating modes. You can select OPAMP_SPEED_LOWSPEED for lower power usage or OPAMP_SPEED_HIGHSPEED for faster performance with higher power consumption.

#include <OPAMP.h>

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

void loop() {
}

Use Cases

One simple way to use the op-amp is as a Voltage Follower, also known as a Buffer, by physically connecting A2 (the minus input) directly to A3 (the output). In this setup, whatever voltage you apply to A1 (the plus input) will be mirrored at the output A3, but with more current-driving capability.

You can also use it to build a Voltage Amplifier to boost a tiny signal. To do this, you connect a 10k resistor between A2 and ground, and a second 10k resistor between A3 and A2. With this setup, any signal fed into A1 will appear at A3 with double the amplitude. However, you must be careful when amplifying signals. The output voltage should not exceed approximately 4.7V. If you try to push it higher, the signal will be clipped, and in extreme cases, you could damage the board.

Or you can use the op-amp as a Comparator to compare two input voltages and output a digital-style HIGH or LOW result, or even use it for more advanced circuits such as integrating and differentiating signals.

Ofcorce these examples are just the beginning of what you can do with the built-in op-amp.

Arduino UNO R4 Minima I2C Pins

The UNO R4 Minima supports I2C, which stands for Inter-Integrated Circuit. I2C is a common serial communication method that allows the Arduino to communicate with many sensors and devices using only two wires called SDA and SCL. On the UNO R4 Minima, SDA is connected to analog pin A4, and SCL is connected to analog pin A5. SDA and SCL are also available on dedicated pins near the AREF pin.

Note:

I2C communication uses what are called open-drain signals. This means that I2C devices can only pull the signal line down to LOW; they never actively drive it HIGH. Instead, the lines must be pulled HIGH using pull-up resistors. On the UNO R4 Minima, these pull-up resistors are not installed on the board by default, although there are solder pads available if you want to add them yourself.

There are some important advantages to not having the pull-up resistors installed from the factory. First, because the I2C pins are shared with A4 and A5, these pins can also be used as regular digital input/output pins or as analog input pins. If pull-up resistors were permanently installed, these pins would always tend to read as HIGH, which would limit their functionality to only I2C. Second, by choosing your own pull-up resistor values, you can decide whether the I2C bus operates at 3.3 V or 5 V. This makes it easier to safely connect different types of I2C devices that may require different voltage levels.

To use I2C communication in your Arduino sketch, you first need to include the Wire library at the top of your code. Inside the setup() function, you then initialize the I2C system. Once I2C is initialized, you can send data to a connected I2C device. Each I2C device has its own address, which the Arduino uses to know which device it is talking to. The following example shows how to send data to a device with address 1 and how to properly close the connection afterwards:

#include <Wire.h>

void setup() {
  Wire.begin();

  Wire.beginTransmission(1);  //begin transmit to device 1
  Wire.write(byte(0x00));     //send instruction byte
  Wire.write(val);            //send a value
  Wire.endTransmission();     //stop transmit
}

void loop() {
}

Arduino UNO R4 Minima SPI Pins

The UNO R4 Minima also supports SPI, which stands for Serial Peripheral Interface. SPI is another type of serial communication, and it is generally faster than I2C. SPI uses separate pins for sending data, receiving data, and synchronizing communication with a clock signal.

On the UNO R4 Minima, pin 11 is labeled COPI (Controller Out, Peripheral In), formerly known as MOSI. This pin is used by the Arduino to send data to another device. Pin 12 is labeled CIPO (Controller In, Peripheral Out), formerly known as MISO, and it is used by the peripheral device to send data back to the Arduino. Pin 13 is the SCK (Serial Clock) pin, which keeps the data transfer synchronized. Pin 10 is typically used as the CS (Chip Select) pin. This pin tells the Arduino which SPI device it wants to communicate with, which is especially important when multiple SPI devices are connected at the same time.

In addition to these standard SPI pins, the UNO R4 Minima also includes an ICSP (In-Circuit Serial Programming) header. This header provides access to the same SPI signals. You can use either the standard digital pins or the ICSP header for SPI communication.

The following example shows how to use SPI:

#include <SPI.h>

const int CS = 10;

void setup() {
  pinMode(CS, OUTPUT);     // Set CS pin as output
  SPI.begin();             // Initialize SPI bus
  digitalWrite(CS, LOW);   // Pull CS low to start communication with the device
  SPI.transfer(0x00);      // Send a single byte (0x00) over SPI
  digitalWrite(CS, HIGH);  // Pull CS high to end communication
}

void loop() {
}

In this example, the Arduino sets the Chip Select pin as an output, starts the SPI system, selects the connected device by pulling CS LOW, sends a single byte of data, and then ends the communication by pulling CS HIGH.

Arduino UNO R4 Minima UART Pins

The UNO R4 Minima features a significant upgrade over its predecessor: it has two separate hardware UART interfaces.

1. One port is exposed via USB-C, and
2. One is exposed via RX/TX pins.

On the older UNO R3, the USB port and the digital pins 0/1 were connected to the same serial interface. This meant you couldn’t use the Serial Monitor on your computer and an external module (like a GPS or Bluetooth receiver) at the same time without them interfering with each other.

The R4 Minima solves this by separating them. The USB-C port connects to one serial interface (which you access in code as Serial), while pins 0 (RX) and 1 (TX) connect to a second, completely independent interface (which you access as Serial1). This allows you to debug your code on your computer while simultaneously communicating with an external device.

If you ever need even more serial ports, you can still use the SoftwareSerial library to create virtual serial ports on other digital pins. However, keep in mind that these software-based ports are slower and more CPU-intensive than the dedicated hardware ports.

To use the UART connected to the RX and TX pins, you first need to set the baud rate in the setup() function. When working with these pins on the UNO R4 Minima, you use the Serial1 object instead of Serial.

Serial1.begin(9600);

To read incoming data, you can check whether data is available and then read it one character at a time. A simple loop might look like this:

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

To send data through the UART connection, you can use the following command:

Serial1.write("Hello world!");

Arduino UNO R4 Minima CAN Pins

The UNO R4 Minima also supports CAN (Controller Area Network) communication. It is a reliable and noise-resistant communication protocol. CAN was originally developed by Bosch for use in cars, but it is now widely used in many industrial and automation systems. One of the main advantages of CAN is that devices can communicate with each other directly over a shared network without needing a central computer.

The UNO R4 Minima includes a built-in CAN controller that supports both the CAN 2.0A and CAN 2.0B standards. The CAN signals are available on digital pin D4 for CAN TX (transmit) and digital pin D5 for CAN RX (receive).

It is very important to understand that the UNO R4 Minima only includes the CAN controller, not the CAN transceiver. The controller handles the data logic, but it does not generate the actual electrical signals used on a CAN bus. To connect the Arduino to other CAN devices, you must use an external CAN transceiver module (like an MCP2551 or TJA1050). These transceivers convert the Arduino’s 5V logic signals into the differential CAN-H and CAN-L signals required by the CAN network.

To communicate with CAN devices, you first will need to include the Arduino_CAN library at the top of your sketch.

#include <Arduino_CAN.h>

Next, you initialize the CAN system by selecting a bit rate. This is done using the CAN.begin(CanBitRate rate) function. The bit rate must match the speed used by the other devices on the CAN bus. Common options include 125 kbps, 250 kbps, 500 kbps, and 1 Mbps.

CAN.begin(CanBitRate::BR_125k);   //sets the bit rate to 125 kbps
CAN.begin(CanBitRate::BR_250k);   //sets the bit rate to 250 kbps
CAN.begin(CanBitRate::BR_500k);   //sets the bit rate to 500 kbps
CAN.begin(CanBitRate::BR_1000k);  //sets the bit rate to 1 Mbps

To send a CAN message, you first create a CAN message object. This message includes an identifier (CAN ID), the size of the data, and the data itself. Once the message is prepared, you send it using the CAN.write() function.

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);

To receive a CAN message, you first check whether a message is available using CAN.available(). If one is available, you can then read it and process it in your program.

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

Arduino UNO R4 Minima ICSP Header

If you’ve used an Arduino UNO R3 before, you’ll immediately recognize the 6-pin ICSP (In-Circuit Serial Programming) header. However, its function has completely changed on the R4 Minima.

On the UNO R3, the ICSP header was commonly used for two main purposes: flashing the bootloader using an external programmer (such as an AVR ISP or another Arduino acting as an ISP), and communicating with SPI devices.

On the UNO R4 Minima, the ICSP header is no longer used for flashing the bootloader. This is because the UNO R4 Minima uses a completely different microcontroller, the Renesas RA4M1, which does not support programming over SPI. According to the Renesas RA4M1 Hardware User’s Manual, specifically in the section that describes “Operating Modes”, this microcontroller supports two primary methods for programming its flash memory. One method is SCI Boot Mode, which uses a UART interface, and the other is USB Boot Mode, which uses the built-in USB interface. Because of this, the traditional ISP method over SPI is not supported.

Therefore, the ICSP header on the UNO R4 Minima is mainly kept for compatibility with SPI-based shields and hardware that expect the SPI signals to be available on this connector. For tasks like low-level programming and recovery, the board instead provides a dedicated SWD/JTAG header.

Arduino UNO R4 Minima SWD / JTAG Header

The 10-pin SWD / JTAG header is the modern equivalent of the ICSP header for ARM-based chips. This is what you use for deep programming, recovering a bricked board, or professional-grade debugging.

By connecting an external hardware debugger, such as a Segger J-Link, ST-Link V3, or a DAPLink-compatible device, you can:

1. Perform step-by-step debugging: Unlike the traditional method of using Serial.print() statements everywhere to guess what your code is doing, this port lets you pause your code mid-execution. You can inspect the value of every variable in real-time, watch how memory changes, and set breakpoints to stop the code exactly where you suspect a bug is hiding.
2. Unbrick the board: If you accidentally corrupt the bootloader so badly that the USB port stops recognizing the board, this port bypasses the standard interface entirely. It is the only way to force-flash a new bootloader directly onto the bare metal of the chip and restore the board to a working state.

Arduino UNO R4 Minima Power Pins

The UNO R4 Minima provides several power pins that are used to power the board itself and to supply power to connected sensors, modules, and other external components.

To help you understand how the power flows through the board, here is a simplified block diagram of the power tree:

VIN pin allows you to power the Arduino using an external power source, such as a wall adapter or a battery pack.This is perfect for standalone projects that are not connected to a computer through USB. The input voltage range for VIN is typically 6V to 24V. Any voltage supplied to this pin is regulated down to a stable 5V by ISL854102FRZ DC-DC Step-Down (Buck) Converter, which then powers the microcontroller and other parts of the board. The Vin pin is also connected to the DC-jack (barrel plug connector). This means that when you power the board through the barrel jack, that same voltage is also available on the VIN pin.

5V pin provides a regulated 5V (* read the note below) output that you can use to power external sensors, modules, and shields that require a stable 5V supply. The amount of current available here depends on how you are powering the board.

1. If you are powering the board via the VIN pin or the barrel jack, the onboard buck converter is active, and the 5V pin can supply up to about 1.2 amps of current to the board and connected peripherals.
2. If you are powering the board via the USB-C port, you bypass the buck converter entirely. In this case, the maximum available current depends on the USB power source, such as a computer or a wall adapter, and can be as high as around 2 amps without damaging the board.

If your project includes components that draw large amounts of current, such as servo motors, it is best to power those components using a separate external power supply rather than relying on the Arduino’s 5V pin.

3.3V pin provides a regulated 3.3V output, but it comes with a critical warning. Unlike Arduino UNO R3 that has a dedicated 3.3V regulator, the 3.3V on the R4 Minima is generated internally by the Renesas RA4M1 microcontroller itself. Because this power comes directly from the microcontroller, it has a very limited current capacity, typically only 50mA to 100mA. This pin is intended strictly for providing reference voltages or powering extremely low-power sensors. You should not attempt to power high-current 3.3V devices, such as large OLED/TFT displays, Wi-Fi modules, or LoRa radios directly from this pin. Doing so can cause voltage sags (brownouts) that will crash your board, or worse, permanently damage the microcontroller. If your project requires more than 100mA at 3.3V, you must use a separate external voltage regulator instead of relying on the Arduino’s 3.3V pin.

Arduino UNO R4 Minima Special Function Pins

In addition to the standard digital, analog, and communication pins, the UNO R4 Minima also includes several special function pins.

D13 If you have ever run the Blink sketch, you are already familiar with this pin. Pin D13 is connected to a built-in LED right on the board. When the pin is set to HIGH, the LED lights up; when set to LOW, it turns off. This makes it an incredibly handy tool for quick debugging without needing to wire up external components. Just remember that if you use D13 as a regular digital input or output for your project, that onboard LED will still flicker along with your signals, which can be confusing if you aren’t expecting it.

IOREF stands for Input/Output Reference Voltage. This pin is essentially a translator for external shields. It provides a reference voltage that tells connected shields exactly what voltage the Arduino is running at. On the UNO R4 Minima, this pin outputs 5V. Smart shields read this pin to automatically adjust their own logic levels or enable voltage translators, ensuring they don’t accidentally fry your board with a voltage mismatch. However, it is crucial to note that IOREF is a reference signal, not a power supply. Never try to power external components from this pin, as it can permanently damage the board.

RESET pin is your hardware reboot button. It is Active LOW, which means the microcontroller will restart the moment this pin is connected to Ground (GND). By default, an internal pull-up resistor keeps this pin HIGH so the board runs normally. You can wire a physical button between this pin and Ground to create a manual reset switch for your project.

BOOT pin controls the operating mode of the Renesas RA4M1 microcontroller during startup. Under normal circumstances, when the pin is HIGH or left floating, the chip boots into “Single-chip mode”, which simply runs your sketch or the standard Arduino bootloader. However, if you pull this pin LOW while powering up the board, you force the chip into “ROM Bootloader mode”. This mode bypasses your sketch entirely and loads a hard-coded bootloader that was burned into the chip at the factory. This is the only way to recover a bricked board. For example, if you uploaded a sketch that crashes the USB port instantly and prevents you from uploading anything new. By entering this mode, you can re-flash the firmware externally and bring the board back to life.