Arduino UNO R4 WiFi Bench Reference

// the classic AVR port macros work on the RA4M1
volatile uint32_t *out =
    portOutputRegister(digitalPinToPort(13));
uint32_t mask = digitalPinToBitMask(13);
*out |= mask;                // D13 high, no function call

// or straight at the peripheral
R_PORT1->PODR |= (1 << 2);   // P102 = D13

const int BUTTON = 2;

void setup() {
  pinMode(BUTTON, INPUT_PULLUP);
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  bool pressed = !digitalRead(BUTTON);   // LOW == pressed
  digitalWrite(LED_BUILTIN, pressed);
}

static bool prev = HIGH;
static uint32_t at = 0;
bool now = digitalRead(BUTTON);

// 25 ms of quiet before believing it
if (now != prev && millis() - at > 25) {
  at = millis();
  prev = now;
  if (now == LOW) { /* pressed, once */ }
}

A bare mechanical contact bounces for a few milliseconds. Without the timer you get five presses out of one push.

void loop() {
  int pot  = analogRead(A0);             // 0 … 1023
  int duty = map(pot, 0, 1023, 0, 255);
  analogWrite(9, duty);            // dim an LED on D9

  float volts = pot * (5.0f / 1023.0f);
}

for (int v = 0; v <= 255; v++) {   // up
  analogWrite(9, v); delay(4);
}
for (int v = 255; v >= 0; v--) {   // and back down
  analogWrite(9, v); delay(4);
}

PWM is a 490 Hz square wave, not a voltage. It dims an LED and drives a motor; it will not feed an analog input without a filter. The Analog section covers depth, frequency and the real DAC.

// two jobs at two rates, neither blocking the other
uint32_t tLed = 0, tLog = 0;

void loop() {
  uint32_t now = millis();

  if (now - tLed >= 250) {
    tLed = now;
    digitalWrite(13, !digitalRead(13));
  }
  if (now - tLog >= 1000) {
    tLog = now;
    Serial.println(analogRead(A0));
  }
}

#include <Servo.h>
Servo arm;

void setup() { arm.attach(9); }

void loop() {
  arm.write(0);              delay(600);
  arm.write(180);            delay(600);
  arm.writeMicroseconds(1500);   // centre
}

const int SPK = 8;
int notes[] = {262, 294, 330, 349};   // C4 D4 E4 F4

for (int n : notes) {
  tone(SPK, n, 200);
  delay(250);                        // note + a gap
}
noTone(SPK);

A piezo disc works straight off a pin. A loudspeaker does not — it needs a series resistor at the very least, and really wants an amplifier.

#include <SPI.h>
const int CS = 10;
pinMode(CS, OUTPUT);  digitalWrite(CS, HIGH);
SPI.begin();

SPI.beginTransaction(
  SPISettings(8000000, MSBFIRST, SPI_MODE0));
digitalWrite(CS, LOW);
uint8_t in = SPI.transfer(0x9F);
SPI.transfer(buf, len);   // in-place block transfer
digitalWrite(CS, HIGH);
SPI.endTransaction();

#include <Wire.h>
Wire.begin();            // controller on A4/A5
Wire1.begin();           // controller on Qwiic
Wire.setClock(400000);   // 100k / 400k

Wire.beginTransmission(0x3C);
Wire.write(0x00);  Wire.write(value);
uint8_t err = Wire.endTransmission();   // 0 = ok

Wire.requestFrom(0x3C, 2);
while (Wire.available()) uint8_t b = Wire.read();

// peripheral mode
Wire.begin(0x42);
Wire.onReceive(handler);  Wire.onRequest(handler);

#include <Arduino_CAN.h>
CAN.begin(CanBitRate::BR_250k);

uint8_t data[] = {0xCA,0xFE,0,0,0,0,0,0};
CanMsg msg(CanStandardId(0x20), sizeof(data), data);
CAN.write(msg);

if (CAN.available()) {
  CanMsg rx = CAN.read();
  Serial.println(rx.id, HEX);
}
CAN.setFilterMask_Standard(0x7FF);
CAN.setFilterId_Standard(0, 0x20);
CAN.enableInternalLoopback();  // bench test, no bus

#include <OPAMP.h>
// or OPAMP_SPEED_LOWSPEED
OPAMP.begin(OPAMP_SPEED_HIGHSPEED);
if (OPAMP.isRunning(0)) { /* … */ }
OPAMP.end();

Once started, the three pins belong to the amplifier — build your gain network externally between A3 and A2 exactly as you would with a discrete op-amp. The DAC on A0 makes a convenient signal source.

#include "FspTimer.h"
FspTimer t;

void tick(timer_callback_args_t *a) { /* ISR */ }

uint8_t type;
int8_t ch = FspTimer::get_available_timer(type);
if (ch < 0) {                       // nothing spare?
  FspTimer::force_use_of_pwm_reserved_timer();
  ch = FspTimer::get_available_timer(type, true);
}
t.begin(TIMER_MODE_PERIODIC, type, ch,
        1000.0f, 0.0f, tick, nullptr);
t.setup_overflow_irq();
t.open();
t.start();
// .stop()  .close()  .set_frequency()

Timer type constants are GPT_TIMER and AGT_TIMER.

volatile bool pressed = false;
void isr() { pressed = true; }

pinMode(2, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(2), isr, FALLING);

#include <WDT.h>
// timeout in ms, rounded to a legal prescaler
WDT.begin(2000);
void loop() {
  WDT.refresh();          // kick it, or the board resets
}
uint32_t t = WDT.getTimeout();
uint32_t c = WDT.getCounter();

Prescalers 1–8192 and reload values 128–16384 constrain the achievable timeouts; the library picks the closest pair and getTimeout() tells you what you actually got.

// non-blocking cadence — reach for this by default
static uint32_t last = 0;
if (millis() - last >= 500) { last += 500; /* … */ }

Install the ArduinoGraphics library and include it before the matrix header — the matrix class inherits from it only if it is already visible.

#include "ArduinoGraphics.h"   // must come first
#include "Arduino_LED_Matrix.h"
ArduinoLEDMatrix matrix;

matrix.beginDraw();
matrix.stroke(0xFFFFFFFF);
matrix.textScrollSpeed(50);
matrix.textFont(Font_5x7);        // or Font_4x6
matrix.beginText(0, 1, 0xFFFFFF);
matrix.println("    Hello World!    ");
// SCROLL_RIGHT, or omit it for static text
matrix.endText(SCROLL_LEFT);
matrix.endDraw();

The colour argument exists because ArduinoGraphics also drives RGB hardware; any non-zero value lights the LED. Twelve columns fits about two 5×7 characters, so scroll anything longer.

None of the eleven pins reach a header, so the matrix never conflicts with your wiring — only with your timer budget.

WiFiServer server(80);
server.begin();

WiFiClient c = server.available();
if (c) {
  while (c.connected()) {
    if (c.available()) { char ch = c.read(); /* … */ }
  }
  c.stop();
}

#include <OTAUpdate.h>
OTAUpdate ota;
ota.setCACert(root_ca);
ota.begin();
// or startDownload + downloadProgress
ota.download(url);
ota.verify();
ota.update();        // reboots into the new sketch

#include <ArduinoBLE.h>
if (!BLE.begin()) while (1);
BLE.scan();
BLEDevice p = BLE.available();
if (p && p.localName() == "Sensor") {
  BLE.stopScan();
  p.connect();
  p.discoverAttributes();
  BLECharacteristic c = p.characteristic(0);
  if (c.canRead()) c.read();
}

int average(int a, int b) { return (a + b) / 2; }

// default arguments and overloads are fine — this is C++
void blink(int pin, int times = 1);

// pass an array by pointer plus a length; arrays decay
void sum(const int *data, size_t n);

// lambdas work, and convert to a plain function pointer
attachInterrupt(2, []() { flag = true; }, FALLING);

Every String operation touches the heap. In a sketch meant to run for months, build output with snprintf() into a fixed buffer instead.