The Arduino UNO R4 WiFi and UNO R4 Minima have a much more capable analog subsystem than the classic UNO R3.
The Renesas RA4M1 gives both boards:
- six analog inputs, A0 to A5;
- ADC resolution selectable up to 14 bits;
- a true 12-bit DAC on A0;
- an internal operational amplifier exposed on A1, A2 and A3;
- multiple analog-reference options.
Those specifications sound impressive, but one important distinction matters immediately:
Resolution is not the same thing as accuracy.
A 14-bit ADC can represent 16,384 different digital codes, but that does not mean an UNO R4 can measure every input voltage to perfect 0.3 mV accuracy. Reference noise, board noise, source impedance, offset error, gain error and ADC linearity all affect the real result.
This guide explains how the UNO R4 ADC and DAC actually work, how to change resolution, how to convert readings into volts, what the internal reference does, how much voltage one ADC or DAC code represents and how to improve practical analog accuracy.
UNO R4 Analog Features at a Glance
| Feature | UNO R4 WiFi / Minima |
|---|---|
| Analog input pins | A0 to A5 |
| Default ADC resolution | 10 bit |
| Selectable ADC resolution | 10, 12 or 14 bit |
| Default analog reference | 5 V nominal board analog supply/reference |
| Internal reference option | Approximately 1.5 V class internal reference through Arduino API |
| True DAC outputs | 1 |
| DAC pin | A0 |
| DAC resolution | 12 bit |
| Internal OPAMP pins | A1 = +, A2 = -, A3 = output |
| ADC hardware | RA4M1 ADC14 |
| DAC hardware | RA4M1 DAC12 |
The Six Analog Pins
Both R4 boards expose the same six analog positions:
|
1 2 3 4 5 6 7 8 9 |
A0 A1 A2 A3 A4 A5 |
All six can be used with analogRead().
Several pins also have additional functions:
| Pin | Additional analog/digital role |
|---|---|
| A0 | ADC input and 12-bit DAC output |
| A1 | ADC input and OPAMP + input |
| A2 | ADC input and OPAMP – input |
| A3 | ADC input and OPAMP output |
| A4 | ADC input and I2C SDA |
| A5 | ADC input and I2C SCL |
A4 and A5 should not be treated as ordinary analog inputs while the same pins are actively being used for I2C.
Default analogRead() Is Still 10 Bit
Although the RA4M1 contains a 14-bit ADC, Arduino keeps the familiar default behaviour:
|
1 2 3 4 |
int value = analogRead(A0); |
By default the returned value is scaled to 10 bits:
|
1 2 3 4 |
0 to 1023 |
This helps older Arduino code behave as expected.
To use the extra ADC resolution you must request it explicitly.
Using 12-Bit ADC Resolution
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
void setup() { Serial.begin(115200); analogReadResolution(12); } void loop() { int value = analogRead(A0); Serial.println(value); delay(100); } |
At 12 bits, the output range becomes:
|
1 2 3 4 |
0 to 4095 |
Using 14-Bit ADC Resolution
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
void setup() { Serial.begin(115200); analogReadResolution(14); } void loop() { int value = analogRead(A0); Serial.println(value); delay(100); } |
At 14 bits:
|
1 2 3 4 |
0 to 16383 |
This is the full nominal ADC resolution available through the UNO R4 Arduino core.
How Much Voltage Is One ADC Count?
The ideal voltage represented by one code is approximately:
|
1 2 3 4 |
LSB = Vref / 2^N |
where:
- Vref is the ADC reference voltage;
- N is the ADC resolution in bits.
Using a nominal 5 V reference:
| Resolution | Codes | Ideal LSB at 5 V |
|---|---|---|
| 10 bit | 1024 | 4.883 mV |
| 12 bit | 4096 | 1.221 mV |
| 14 bit | 16384 | 0.305 mV |
This is the theoretical code spacing, not a guarantee that the board can measure an absolute voltage to 0.305 mV.
Converting a 14-Bit Reading to Voltage
With a measured 5.000 V reference, the calculation is:
|
1 2 3 4 |
voltage = reading * Vref / 16383.0 |
Example:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
const float vref = 5.000; void setup() { Serial.begin(115200); analogReadResolution(14); } void loop() { uint16_t raw = analogRead(A0); float voltage = raw * vref / 16383.0; Serial.print(raw); Serial.print(" "); Serial.print(voltage, 4); Serial.println(" V"); delay(200); } |
The important word here is measured.
If the actual analog supply/reference is 4.91 V and your calculation assumes exactly 5.000 V, the calculated result will contain a systematic scale error even though the ADC itself is behaving correctly.
Do Not Assume the 5 V Rail Is Exactly 5.000 V
A USB-powered board may see a 5 V rail that differs slightly with:
- USB supply voltage;
- cable resistance;
- load current;
- regulator behaviour;
- other peripherals connected to the board.
If absolute voltage accuracy matters, measure the reference rail with a calibrated meter and use that value in your conversion.
For even better repeatability, use a stable reference appropriate to the voltage range being measured.
Changing the Analog Reference
Arduino’s current UNO R4 documentation provides the normal default reference and an internal reference option.
The default is selected with:
|
1 2 3 4 |
analogReference(AR_DEFAULT); |
Arduino documents this as the normal 5 V reference environment.
The internal reference can be selected with:
|
1 2 3 4 |
analogReference(AR_INTERNAL); |
The Arduino R4 core also contains support for additional Renesas reference modes, but for portable application code the officially documented reference options are the safest starting point.
Why Use a Lower Reference Voltage?
Suppose your sensor only outputs 0 to 1.2 V.
With a 5 V reference, much of the ADC range is unused.
At 14 bits and 5 V:
|
1 2 3 4 |
1.2 V / 5 V × 16383 ≈ 3932 counts |
Only about one quarter of the available range is being used.
A lower reference lets a small signal occupy more ADC codes, improving voltage resolution.
This does not automatically improve absolute accuracy, but it improves quantisation resolution.
Nominal Code Size with a 1.5 V Reference
Using a nominal 1.5 V reference:
| Resolution | Ideal LSB at 1.5 V |
|---|---|
| 10 bit | 1.465 mV |
| 12 bit | 0.366 mV |
| 14 bit | 0.0916 mV |
Again, those are ideal quantisation steps. They do not mean the board suddenly becomes accurate to 92 µV.
Resolution vs Accuracy
This is the most important concept in the entire guide.
A 14-bit converter gives:
|
1 2 3 4 |
16384 possible output codes |
But several error sources determine how closely those codes match the real input voltage:
- reference-voltage error;
- offset error;
- full-scale gain error;
- integral non-linearity;
- differential non-linearity;
- quantisation error;
- thermal noise;
- digital switching noise;
- source impedance;
- PCB grounding;
- sensor noise.
So “14-bit ADC” describes the converter’s resolution, not the guaranteed number of accurate bits in every Arduino setup.
What the RA4M1 Datasheet Says About 14-Bit Accuracy
Renesas specifies the ADC at chip level under controlled electrical conditions.
In 14-bit high-speed conversion mode, the datasheet lists figures such as:
- 14-bit resolution;
- typical integral non-linearity around ±1 LSB in one set of conditions;
- maximum INL figures that are larger depending on channel and operating conditions;
- offset and full-scale error limits measured in multiple LSBs;
- source-impedance restrictions for the specified conversion timing.
The practical lesson is not to memorise one error number. It is to understand that the converter itself has finite error even before board-level noise is added.
14 Bits Does Not Mean 14 Effective Noise-Free Bits
If your raw readings look like this:
|
1 2 3 4 5 6 7 8 9 10 |
8210 8207 8213 8205 8211 8209 8214 |
the least-significant bits are moving because the ADC sees a combination of:
- real input noise;
- reference noise;
- converter noise;
- digital activity on the board.
This is normal.
A higher-resolution ADC often reveals noise that a lower-resolution ADC simply hides inside one larger code step.
12 Bit Can Be a Very Practical Setting
For many projects, 12-bit mode is a useful compromise.
At 5 V, the ideal step is about:
|
1 2 3 4 |
1.22 mV |
That is already four times finer than the classic 10-bit Arduino step.
Meanwhile the least-significant bits are often more stable than when trying to use every possible 14-bit code in a noisy breadboard setup.
If you do not genuinely need 14-bit quantisation, test both 12-bit and 14-bit modes and judge the repeatability of the complete measurement system.
Source Impedance Matters
An ADC input is not an infinite-impedance voltmeter during sampling.
Internally, the converter must charge a sampling capacitor to the input voltage.
If the sensor or resistor divider driving the ADC has very high source impedance, that capacitor may not settle fully during the sampling interval.
This can cause:
- low readings;
- channel-to-channel interaction;
- slow settling;
- apparent non-linearity.
Why a 1 MΩ Sensor Divider Can Be a Problem
Imagine a divider using:
|
1 2 3 4 5 |
1 MΩ 1 MΩ |
The static divider works mathematically, but its Thevenin source impedance is:
|
1 2 3 4 |
500 kΩ |
That is very high for a fast ADC sampling input.
A lower resistance divider such as tens of kilohms, or a buffer amplifier, is often much more reliable.
Exact values depend on power consumption, signal bandwidth and the required acquisition speed.
Add a Small Capacitor at the ADC Input
For slowly changing signals, a small capacitor from the ADC input to ground can provide a local charge reservoir and filter high-frequency noise.
A common arrangement is:
|
1 2 3 4 5 6 7 8 |
sensor/divider ---- resistor ----+---- A0 | capacitor | GND |
The resistor and capacitor form a low-pass filter.
Do not choose values blindly. The filter should be fast enough for the signal you actually need to measure.
Average Multiple Samples
For slowly changing signals, averaging can reduce random noise.
|
1 2 3 4 5 6 7 8 9 10 |
uint32_t sum = 0; for (int i = 0; i < 32; i++) { sum += analogRead(A0); } float average = sum / 32.0; |
Averaging helps with uncorrelated noise. It does not correct:
- wrong reference voltage;
- ADC gain error;
- offset error;
- sensor calibration error.
Complete 14-Bit Averaging Example
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
const uint8_t adcPin = A0; const int samples = 32; const float vref = 5.000; void setup() { Serial.begin(115200); analogReadResolution(14); } void loop() { uint32_t sum = 0; for (int i = 0; i < samples; i++) { sum += analogRead(adcPin); } float rawAverage = sum / (float)samples; float voltage = rawAverage * vref / 16383.0; Serial.print("ADC = "); Serial.print(rawAverage, 1); Serial.print(" Voltage = "); Serial.print(voltage, 4); Serial.println(" V"); delay(200); } |
Median Filtering for Spikes
If the problem is occasional large spikes rather than continuous random noise, a median filter can work better than a simple average.
For example, five readings:
|
1 2 3 4 5 6 7 8 |
8120 8122 12400 8119 8121 |
have one obvious outlier.
The mean is pulled upward by the spike, while the median remains close to 8121.
Median filtering is useful around:
- relay switching;
- motors;
- ignition systems;
- long sensor wires;
- electrically noisy machinery.
Separate Analog and Noisy Loads
If possible, avoid sampling sensitive analog signals at the exact moment you:
- switch a relay;
- change a high-current PWM output;
- transmit a large radio burst;
- start a motor;
- switch a solenoid.
Noise can couple through:
- ground impedance;
- the 5 V rail;
- electric fields;
- magnetic fields;
- shared wiring.
Good measurement design is as much about PCB and wiring practice as ADC bit depth.
Grounding Matters
The ADC measures input voltage relative to the board’s analog ground reference.
If a sensor ground and Arduino ground differ by 30 mV because of motor current flowing through the same wire, the ADC effectively sees that error as part of the signal.
Keep high-current return paths away from sensitive analog returns where possible.
Calibrate the Complete Measurement Chain
For accurate measurement, calibrate the entire system rather than assuming every nominal value is exact.
A two-point calibration is often enough for simple applications.
For example, apply two accurately known voltages:
|
1 2 3 4 5 |
V1 = 0.5000 V V2 = 4.0000 V |
Measure their ADC codes:
|
1 2 3 4 5 |
C1 C2 |
Then derive:
|
1 2 3 4 5 6 7 |
slope = (V2 - V1) / (C2 - C1) offset = V1 - slope * C1 voltage = slope * code + offset |
This can correct much of the combined offset and scale error of the complete chain.
Do Not Calibrate Away Noise
Calibration corrects repeatable systematic error.
It does not solve unstable measurements caused by:
- poor grounding;
- switching noise;
- high source impedance;
- unstable sensor output;
- unstable supply/reference voltage.
Fix the hardware first, then calibrate.
The 12-Bit DAC on A0
A0 is special on both UNO R4 boards because it can operate as either:
- an ADC input;
- a true DAC output.
The DAC produces a real analog voltage rather than PWM pulses.
Basic DAC Example
|
1 2 3 4 5 6 7 8 9 10 |
void setup() { analogWriteResolution(12); } void loop() { analogWrite(A0, 2048); } |
At 12 bits, the digital range is:
|
1 2 3 4 |
0 to 4095 |
A value near 2048 requests approximately half scale.
DAC Ideal Step Size
For an ideal 5 V full-scale reference:
|
1 2 3 4 |
5 V / 4096 ≈ 1.221 mV per code |
Again, this is ideal quantisation spacing, not guaranteed absolute voltage accuracy.
The DAC Is Not Perfectly Rail-to-Rail
The RA4M1 datasheet specifies a finite DAC output range rather than perfect 0 V to AVCC operation.
Under the published test conditions, the 12-bit DAC output is specified roughly from:
|
1 2 3 4 5 6 |
0.35 V to AVCC - 0.47 V |
depending on the selected reference mode and load conditions.
That means:
- code 0 should not be treated as a precision 0.000 V source;
- code 4095 should not be treated as a precision 5.000 V source;
- the DAC is not a substitute for a precision laboratory reference.
DAC Load Impedance Matters
The Renesas datasheet specifies DAC behaviour with a relatively light load.
It lists a minimum resistive load of around 30 kΩ for the stated characteristics.
Do not use A0 to directly drive:
- a speaker;
- a motor;
- a relay;
- a low-resistance load;
- a long heavily capacitive cable.
Use a buffer amplifier if the next circuit presents a significant load.
Buffering the DAC
A voltage follower is a common arrangement:
|
1 2 3 4 5 6 7 8 9 10 |
UNO R4 A0 DAC │ ▼ op-amp buffer │ ▼ external load |
The op-amp should be selected for:
- the required supply voltage;
- input common-mode range;
- output swing;
- load current;
- signal bandwidth.
Generating a Ramp with the DAC
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
void setup() { analogWriteResolution(12); } void loop() { for (int value = 0; value <= 4095; value += 16) { analogWrite(A0, value); delayMicroseconds(100); } } |
This produces a staircase ramp.
The maximum practical waveform frequency is limited by:
- DAC conversion time;
- software overhead;
- the Arduino API;
- load capacitance;
- required waveform quality.
Generating a Sine Wave
A simple waveform generator can use a lookup table:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
const uint16_t sineTable[] = { 2048, 2831, 3495, 3939, 4095, 3939, 3495, 2831, 2048, 1265, 601, 157, 0, 157, 601, 1265 }; void setup() { analogWriteResolution(12); } void loop() { for (uint16_t value : sineTable) { analogWrite(A0, value); delayMicroseconds(100); } } |
This is useful for learning and low-frequency signal generation.
For low-distortion precision waveforms, use a dedicated DAC or waveform-generator IC.
DAC vs PWM
On a normal PWM pin:
|
1 2 3 4 |
analogWrite(D9, 128); |
does not produce a steady half-supply voltage.
It produces a digital pulse train with approximately 50% duty cycle.
On the R4 DAC pin:
|
1 2 3 4 |
analogWrite(A0, value); |
after setting the appropriate resolution uses the DAC hardware and creates a real analog level.
This is a major difference.
When PWM Is Still Better
A true DAC is not always the best output.
PWM is often preferable for:
- LED brightness;
- motor control;
- switch-mode power control;
- servo-style outputs;
- high-current switching through a driver.
The DAC is better when the receiving circuit actually requires a voltage level.
A0 Cannot Be DAC Output and ADC Input Simultaneously
A0 is shared.
When you configure and use it as a DAC output, do not expect it to behave simultaneously as an independent external analog input.
If the project needs a DAC output and analog measurement at the same time, use:
|
1 2 3 4 5 |
A0 = DAC output A1-A5 = analog inputs |
The Internal OPAMP
The RA4M1 includes analog operational-amplifier hardware exposed on:
|
1 2 3 4 5 6 |
A1 = OPAMP + A2 = OPAMP - A3 = OPAMP output |
This can be useful for:
- buffering sensors;
- analog amplification;
- active filters;
- signal conditioning.
The OPAMP is an advanced feature and should be configured with the appropriate Arduino/Renesas API for the exact application.
Using the OPAMP as an ADC Buffer
One potential use is isolating a high-impedance sensor from the ADC sampling input.
|
1 2 3 4 5 6 7 8 9 10 |
high-impedance sensor │ ▼ internal/external buffer │ ▼ ADC |
This reduces the effect of ADC sampling current on the original signal source.
Measuring a Potentiometer
A simple potentiometer test is a good way to verify ADC behaviour.
|
1 2 3 4 5 6 |
5V ---- potentiometer ---- GND | +---- A0 |
Example:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
void setup() { Serial.begin(115200); analogReadResolution(14); } void loop() { uint16_t value = analogRead(A0); Serial.println(value); delay(20); } |
Rotating the potentiometer should produce a reading that moves across most of the 0–16383 range.
Measuring More Than 5 V
Do not connect a voltage above the allowed analog-input range directly to an R4 analog pin.
Use a resistor divider.
For example, to measure a nominal 12 V supply you might design a divider that keeps the ADC comfortably below 5 V at the maximum expected input.
|
1 2 3 4 5 6 7 8 |
Vin ---- R1 ----+---- ADC | R2 | GND |
The ideal divider equation is:
|
1 2 3 4 |
Vadc = Vin × R2 / (R1 + R2) |
Then:
|
1 2 3 4 |
Vin = Vadc × (R1 + R2) / R2 |
Leave Margin in Divider Designs
Do not design a divider where the ADC reaches exactly 5.000 V at the nominal maximum source voltage.
Real systems experience:
- charging-voltage variation;
- transients;
- resistor tolerance;
- supply tolerance;
- measurement error.
Leave sensible headroom and add protection when the source can produce spikes.
Automotive Voltage Measurement
A “12 V” automotive system can operate above 14 V during charging and experience much larger electrical transients.
A permanent automotive input should include appropriate:
- voltage scaling;
- series impedance;
- transient protection;
- filtering;
- grounding.
A simple breadboard divider alone is not an automotive-qualified input stage.
Measuring Sensors with Small Outputs
For a sensor producing only a few hundred millivolts, consider:
- a lower ADC reference;
- analog amplification;
- good grounding;
- filtering;
- averaging;
- calibration.
Using 14-bit mode alone does not solve a poor signal-to-noise ratio.
Practical Accuracy Checklist
- Know the actual reference voltage. Do not assume the rail is exactly nominal.
- Keep source impedance reasonable. Very large resistor values can cause settling errors.
- Filter noisy signals. Use sensible analog RC filtering when appropriate.
- Average samples. This reduces random noise on slowly changing signals.
- Separate analog grounds from heavy-current returns.
- Avoid sampling during major switching events.
- Use shielded/twisted wiring where the environment requires it.
- Calibrate the complete chain.
- Do not confuse code resolution with absolute accuracy.
When 10-Bit Mode Is Enough
Use the default 10-bit mode when:
- the sensor itself is not very accurate;
- you only need rough control values;
- you are porting an older UNO sketch;
- measurement noise is larger than several millivolts;
- the exact value is unimportant.
Examples include:
- potentiometer controls;
- light-dependent resistors;
- simple joystick inputs.
When 12-Bit Mode Is a Good Choice
Use 12-bit mode for:
- general instrumentation;
- battery-voltage monitoring;
- temperature sensors;
- pressure sensors;
- filtered analog signals;
- projects that need more resolution without chasing every least-significant bit.
When 14-Bit Mode Makes Sense
Use 14-bit mode when:
- the sensor and reference are stable;
- the PCB/wiring is electrically quiet;
- you have a reason to exploit smaller quantisation steps;
- you understand the ADC’s real accuracy limits;
- you are willing to filter and calibrate.
It is particularly useful when oversampling and averaging slow precision signals.
UNO R4 vs UNO R3 Analog Capability
The improvement over UNO R3 is substantial.
| Feature | UNO R3 | UNO R4 |
|---|---|---|
| ADC nominal resolution | 10 bit | Up to 14 bit |
| ADC codes | 1024 | 16384 at 14 bit |
| True DAC | No | 12-bit DAC on A0 |
| Internal OPAMP | No Arduino-exposed equivalent | Yes |
This makes the R4 much more interesting for instrumentation and mixed-signal projects.
For the broader generational comparison, see our Arduino UNO R4 vs UNO R3 guide.
UNO R4 WiFi vs Minima Analog Hardware
The main analog features discussed in this guide are shared by both R4 models because they come from the same RA4M1:
- A0-A5 ADC inputs;
- 14-bit-capable ADC;
- 12-bit DAC on A0;
- OPAMP pins;
- analog-reference support.
The WiFi board’s ESP32-S3, LED matrix and Qwiic connector do not make its RA4M1 ADC inherently higher resolution than the Minima.
See our UNO R4 WiFi vs UNO R4 Minima comparison for the non-analog differences.
Final Thoughts
The UNO R4’s analog subsystem is one of the most meaningful upgrades over the classic Arduino UNO.
The RA4M1 gives you six analog inputs, selectable 10/12/14-bit conversion, a true 12-bit DAC on A0 and an internal op-amp.
At a nominal 5 V reference, a 14-bit code represents only about:
|
1 2 3 4 |
0.305 mV |
but that figure describes resolution. It does not guarantee 0.305 mV absolute measurement accuracy.
For good results:
- use a stable reference;
- keep source impedance sensible;
- filter noise;
- average when appropriate;
- separate high-current and analog grounds;
- calibrate against known voltages.
The DAC deserves the same realism. It provides a genuine analog output, but it is not perfectly rail-to-rail and should not drive low-impedance loads directly.
Used properly, the UNO R4 is capable of much better mixed-signal work than older UNO boards. The biggest improvement does not come from selecting analogReadResolution(14) alone; it comes from treating the reference, source impedance, grounding and calibration as part of the measurement system.