Running R on Raspberry Pi 5: Edge Analytics with I2C Sensor Data

R is traditionally confined to desktop workstations and cloud servers, but running R on Raspberry Pi hardware transforms the single-board computer into a powerful edge analytics node. Instead of shipping raw sensor data to the cloud for processing, you can poll I2C sensors, calculate rolling statistics, and trigger local alerts directly on the Pi. With the release of the Raspberry Pi 5 and its new RP1 I/O southbridge, the hardware is more than capable of handling heavy dataframes and statistical modeling in real-time.

This guide walks through building an edge-logging node using R on a Raspberry Pi 5 (8GB variant), reading a Sensirion SHT31-D temperature and humidity sensor via the I2C bus. We will cover the exact pin mappings, bypass the common OS-level permission errors, and provide a complete, production-ready R script with robust error handling.

Hardware Spec Sheet & Pin Mapping

Before writing any code, we need to establish the physical layer. The Raspberry Pi 5 utilizes the new RP1 southbridge chip for GPIO and I2C management. While the pinout remains backward-compatible with the Pi 4, the underlying clock stretching and pull-up resistor behaviors have slight firmware-level differences that affect high-speed I2C. For environmental sensing, the SHT31-D is ideal due to its high accuracy and simple I2C command structure.

The RP1 Chip, OS Config, and the 'Remote I/O' Error

When interfacing R with hardware on the Pi 5, you are not writing C-level drivers. Instead, the most robust method for R to interact with I2C without compiling custom C-extensions (like Rcpp wrappers) is to leverage the native Linux i2c-tools suite via R's system2() function. This keeps the R environment clean and avoids dependency hell.

However, this approach exposes you to OS-level permission and bus errors. The most notorious error string you will encounter when running hardware I/O scripts in R on Raspberry Pi OS is:

Warning message:
In system2("i2ctransfer", args = c("-y", "1", ...)) :
running command 'i2ctransfer -y 1 w2@0x44 0x2c 0x06 r6@0x44' had status 1
stderr: i2ctransfer: ioctl: I2C_RDWR: Remote I/O error

If you see Remote I/O error or Permission denied, do not rewrite your R code. The issue is at the Linux kernel or physical layer. Here are the first three things to check when it fails:

1. Verify I2C is enabled in the bootloader config: On the Pi 5, the config file moved. Open /boot/firmware/config.txt and ensure dtparam=i2c_arm=on is present and uncommented. Reboot after changing.
2. Check User Group Permissions: The /dev/i2c-1 device node requires specific group access. Ensure your user is in the i2c group by running sudo usermod -aG i2c $USER, then log out and log back in. Running R via sudo is a bad practice that breaks environment variables.
3. Validate the Physical Bus with i2cdetect: Run i2cdetect -y 1 in the terminal. If you see -- at address 0x44, your SDA/SCL wires are swapped, or the sensor lacks power. If you see UU, another kernel driver has claimed the sensor.

The R Script: Polling, Parsing, and Error Handling

The following R script is explicitly written for the Raspberry Pi 5 (8GB) running Raspberry Pi OS (64-bit, Bookworm or later). It uses i2ctransfer to send a high-repeatability measurement command to the SHT31-D, waits for the conversion, reads the 6-byte payload, and parses the hex values into human-readable temperature (°C) and humidity (%RH) metrics.

It also includes a rolling dataframe to store the last 10 readings, demonstrating how to build an edge-analytics buffer directly in R.

# =====================================================================
# Edge Analytics: SHT31-D I2C Sensor via R on Raspberry Pi 5
# Target Board: Raspberry Pi 5 (8GB)
# OS: Raspberry Pi OS (64-bit)
# Dependencies: i2c-tools (sudo apt install i2c-tools), r-base
# =====================================================================

# --- Pin & Bus Definitions ---
I2C_BUS <- 1
SENSOR_ADDR <- "0x44"
SDA_PIN <- 2  # GPIO 2 (Physical Pin 3)
SCL_PIN <- 3  # GPIO 3 (Physical Pin 5)

# Initialize rolling dataframe for edge analytics
sensor_log <- data.frame(
  timestamp = as.POSIXct(character(0)),
  temp_c = numeric(0),
  humidity_pct = numeric(0)
)

read_sht31 <- function(bus, addr) {
  # SHT31 Command: Measure High Repeatability (0x2C 0x06)
  # i2ctransfer syntax: w2@addr writes 2 bytes, r6@addr reads 6 bytes
  cmd_write <- sprintf("w2@%s 0x2c 0x06", addr)
  cmd_read <- sprintf("r6@%s", addr)
  
  # Execute I2C transfer via system call
  res <- tryCatch({
    system2("i2ctransfer", 
            args = c("-y", as.character(bus), cmd_write, cmd_read), 
            stdout = TRUE, stderr = TRUE)
  }, error = function(e) {
    stop("I2C System Call Failed: ", e$message)
  })
  
  # Error Handling: Check for OS-level I2C errors
  if (length(res) == 0 || any(grepl("Error|error|ioctl", res))) {
    stop("I2C Bus Error: ", paste(res, collapse = " "))
  }
  
  # Parse the space-separated hex string (e.g., "0x65 0x43 0x22 ...")
  # We only need the first 4 bytes (2 for Temp, 2 for Humidity). Bytes 3 and 6 are CRC.
  hex_vals <- unlist(strsplit(res[1], " "))
  if (length(hex_vals) < 6) stop("Incomplete I2C payload received.")
  
  raw_temp <- strtoi(hex_vals[1], 16L) * 256 + strtoi(hex_vals[2], 16L)
  raw_hum <- strtoi(hex_vals[4], 16L) * 256 + strtoi(hex_vals[5], 16L)
  
  # Sensirion SHT3x Datasheet Conversion Formulas
  temp_c <- -45 + 175 * (raw_temp / 65535)
  humidity_pct <- 100 * (raw_hum / 65535)
  
  return(list(temp = round(temp_c, 2), hum = round(humidity_pct, 2)))
}

# --- Main Execution Loop ---
cat("Starting Edge Analytics Node on Pi 5...\n")
cat(sprintf("Monitoring I2C Bus %d | SDA: GPIO %d | SCL: GPIO %d\n", I2C_BUS, SDA_PIN, SCL_PIN))

for (i in 1:10) {
  tryCatch({
    # Sensor requires ~15ms for high-repeatability measurement
    Sys.sleep(0.02) 
    
    reading <- read_sht31(I2C_BUS, SENSOR_ADDR)
    
    # Append to rolling dataframe
    new_row <- data.frame(
      timestamp = Sys.time(),
      temp_c = reading$temp,
      humidity_pct = reading$hum
    )
    sensor_log <- rbind(sensor_log, new_row)
    
    # Keep only the last 10 readings to manage memory on edge devices
    if (nrow(sensor_log) > 10) {
      sensor_log <- tail(sensor_log, 10)
    }
    
    cat(sprintf("[%s] Temp: %.2f C | Hum: %.2f %%\n", 
                format(Sys.time(), "%H:%M:%S"), reading$temp, reading$hum))
                
  }, error = function(e) {
    cat("FAULT DETECTED: ", conditionMessage(e), "\n")
    # Implement watchdog logic or alerting here
  })
  
  Sys.sleep(2) # Polling interval
}

# --- Edge Analytics Output ---
cat("\n--- Rolling Statistics (Last 10 Samples) ---\n")
cat(sprintf("Mean Temp: %.2f C | Std Dev: %.3f\n", mean(sensor_log$temp_c), sd(sensor_log$temp_c)))
cat(sprintf("Mean Hum:  %.2f %% | Std Dev: %.3f\n", mean(sensor_log$humidity_pct), sd(sensor_log$humidity_pct)))

Extending to Shiny or Simplifying to USB

Once you have the raw data flowing into R, you have two distinct paths depending on your project's end goal: scaling up into a local dashboard, or scaling down to avoid GPIO complexity.

How to Extend: Local Shiny Dashboard

The Raspberry Pi 5's quad-core Cortex-A76 is fully capable of hosting a local web server. You can extend the script above by wrapping the polling loop in a reactivePoll function and using the shiny and ggplot2 packages to render a live-updating dashboard. By running the Shiny app on port 8080, you can access the analytics dashboard from any device on your local LAN without ever sending data to an external cloud broker like AWS or Azure. This is ideal for agricultural monitoring, server room environmental tracking, or cleanroom telemetry where air-gapped data is a requirement.

How to Simplify: Bypass I2C with USB UART

If the Remote I/O error troubleshooting steps feel like a distraction from your actual statistical work, simplify the hardware layer. Instead of wiring an I2C sensor to the GPIO header, use a USB-to-UART bridge with a serial-output sensor (like the Sensirion SCD40 CO2 sensor on a USB-C breakout). In R, you can read USB serial data using the serial package or standard file("/dev/ttyUSB0", "r") connections. This entirely bypasses the need for i2c-tools, eliminates group permission headaches, and makes your R code completely portable to any Linux machine, not just the Raspberry Pi.

Running R on edge hardware bridges the gap between raw data collection and statistical insight. By understanding the Pi 5's RP1 I/O architecture and leveraging native Linux tools via R's system calls, you can build robust, self-contained analytics nodes that survive in the field.