Advanced Arduino Projects: Building a CAN Bus Telemetry Logger

Project Overview & Difficulty Rating

When makers transition from blinking LEDs to building real-world embedded systems, they hit a wall: standard 8-bit AVR boards lack the hardware peripherals and processing headroom for high-speed industrial protocols. True advanced Arduino projects require concurrency, hardware-level bus arbitration, and robust fault tolerance.

This build is a High-Speed CAN Bus Telemetry Logger. It reads raw CAN frames from a vehicle or robotics network, polls an I2C environmental sensor, and logs the fused data to a MicroSD card while simultaneously streaming it over WiFi via MQTT. We are ditching the classic Arduino Uno and SPI-based MCP2515 shields. Instead, we will use the native TWAI (Two-Wire Automotive Interface) hardware controller built into the ESP32-S3 silicon, managed by the Arduino Nano ESP32 board.

Hardware BOM & Pin Mapping

The Arduino Nano ESP32 bridges the gap between the familiar Arduino Nano footprint and the raw power of the ESP32-S3. Because the S3 operates at 3.3V logic, you must select 3.3V-compatible peripherals. Using a 5V CAN transceiver like the standard TJA1050 without level shifters will fry the Nano's GPIO pins.

Bill of Materials

• Microcontroller: Arduino Nano ESP32 (Part: ABX00092)
• CAN Transceiver: SN65HVD230 module (3.3V logic, integrated 120-ohm resistor option)
• Storage: Adafruit MicroSD SPI Breakout Board (Part: 1508)
• Sensor: BME280 I2C Temperature/Humidity/Pressure Sensor (3.3V variant)
• Passives: 2x 120-ohm 1/4W resistors (for CAN bus termination if not on module), twisted pair wire (Cat5e works perfectly for CAN_H/CAN_L).

Pin Mapping Table

The Nano ESP32 maps physical board pins to specific internal ESP32-S3 GPIOs. The firmware below uses the internal GPIO numbers for the hardware drivers, but the table below tells you exactly where to plug in your jumper wires.

Step-by-Step Assembly & Wiring

1. Prep the CAN Bus Wiring: Cut two lengths of wire from a twisted pair cable. Strip the ends and solder them to the CAN_H and CAN_L terminals on your SN65HVD230 module. Twist the wires tightly; CAN bus relies on differential signaling, and untwisted wires will act as antennas for EMI.
2. Verify Termination: A CAN bus requires exactly two 120-ohm terminating resistors—one at each physical end of the bus. If your SN65HVD230 module has a jumper or switch for the 120-ohm resistor, enable it. If your device under test (e.g., a motor controller) doesn't have termination, solder a 120-ohm resistor across the CAN_H and CAN_L pins on that end.
3. Wire the SPI SD Card: Connect the Adafruit MicroSD breakout to the Nano ESP32 using the physical pins D10 through D13. Ensure the breakout's VCC is tied to the Nano's 3.3V pin, not the 5V pin.
4. Wire the I2C Sensor: Connect the BME280 SDA to A4 and SCL to A5. Tie VCC to 3.3V and GND to GND.
5. Power Isolation: If you are tapping into a 12V or 24V vehicle/robotics battery to power the Nano via the VIN pin, ensure you use a buck converter rated for at least 1A. Automotive voltage spikes (load dump) can easily exceed the Nano's linear regulator limits.

The Firmware: FreeRTOS CAN Logger Code

This firmware targets the Arduino Nano ESP32 using the official Arduino IDE 2.x board package. It leverages the ESP-IDF TWAI driver for hardware-accelerated CAN reading and uses FreeRTOS to separate the high-priority CAN ingestion from the lower-priority SD card writing. This prevents SD card write-latency spikes from causing CAN buffer overruns.

Required Libraries: Install 'Adafruit BME280 Library' and 'Adafruit Unified Sensor' via the Library Manager. SD and SPI are built-in.

#include <driver/twai.h>
#include <SPI.h>
#include <SD.h>
#include <Wire.h>
#include <Adafruit_BME280.h>

// --- PIN DEFINITIONS (Internal ESP32-S3 GPIOs) ---
#define CAN_TX_GPIO GPIO_NUM_5
#define CAN_RX_GPIO GPIO_NUM_4
#define SD_CS_PIN   7

// --- TWAI (CAN) CONFIGURATION ---
// 500kbps is standard for most automotive and robotics applications
twai_general_config_t g_config = TWAI_GENERAL_CONFIG_DEFAULT(CAN_TX_GPIO, CAN_RX_GPIO, TWAI_MODE_NORMAL);
twai_timing_config_t t_config = TWAI_TIMING_CONFIG_500KBITS();
twai_filter_config_t f_config = TWAI_FILTER_CONFIG_ACCEPT_ALL();

// --- GLOBAL OBJECTS & HANDLES ---
Adafruit_BME280 bme;
File logFile;
QueueHandle_t canDataQueue;

// Structure to pass data between FreeRTOS tasks
struct TelemetryPacket {
  uint32_t id;
  uint8_t data[8];
  uint8_t dlc;
  float temp;
};

// --- FREERTOS TASK: CAN BUS READER ---
void canReaderTask(void *pvParameters) {
  twai_message_t message;
  TelemetryPacket packet;
  
  while (1) {
    // Block for up to 100ms waiting for a CAN frame
    if (twai_receive(&message, pdMS_TO_TICKS(100)) == ESP_OK) {
      if (!(message.flags & TWAI_MSG_FLAG_RTR)) { // Ignore Remote Transmission Requests
        packet.id = message.identifier;
        packet.dlc = message.data_length_code;
        memcpy(packet.data, message.data, packet.dlc);
        packet.temp = bme.readTemperature();
        
        // Send to queue. If queue is full, drop frame to prevent watchdog timeout
        xQueueSend(canDataQueue, &packet, 0);
      }
    }
    
    // Check for Bus-Off state and attempt recovery
    twai_status_info_t status_info;
    twai_get_status_info(&status_info);
    if (status_info.state == TWAI_STATE_BUS_OFF) {
      Serial.println("[ERR] CAN Bus-Off detected. Initiating recovery...");
      twai_initiate_recovery();
      vTaskDelay(pdMS_TO_TICKS(100));
    }
  }
}

// --- FREERTOS TASK: SD LOGGER ---
void sdLoggerTask(void *pvParameters) {
  TelemetryPacket packet;
  while (1) {
    if (xQueueReceive(canDataQueue, &packet, portMAX_DELAY) == pdTRUE) {
      if (logFile) {
        logFile.print(millis());
        logFile.print(",");
        logFile.print(packet.id, HEX);
        logFile.print(",");
        logFile.print(packet.temp, 2);
        logFile.print(",");
        for (int i = 0; i < packet.dlc; i++) {
          logFile.print(packet.data[i], HEX);
          if (i < packet.dlc - 1) logFile.print(":");
        }
        logFile.println();
        logFile.flush(); // Ensure data is written to physical media
      }
    }
  }
}

void setup() {
  Serial.begin(115200);
  delay(1000);
  Serial.println("[SYS] Advanced CAN Telemetry Logger Booting...");

  // 1. Initialize I2C Sensor
  Wire.begin(18, 21); // SDA, SCL for Nano ESP32
  if (!bme.begin(0x76)) {
    Serial.println("[ERR] BME280 not found. Check wiring.");
  }

  // 2. Initialize SD Card
  if (!SD.begin(SD_CS_PIN)) {
    Serial.println("[ERR] SD Card Mount Failed. Check CS pin and formatting (FAT32).");
  } else {
    logFile = SD.open("/telemetry.csv", FILE_APPEND);
    if (logFile) logFile.println("Timestamp_ms,CAN_ID,Temp_C,Payload_HEX");
  }

  // 3. Initialize TWAI (CAN) Driver
  if (twai_driver_install(&g_config, &t_config, &f_config) == ESP_OK) {
    Serial.println("[SYS] TWAI Driver installed.");
  } else {
    Serial.println("[ERR] Failed to install TWAI driver. Halting.");
    while(1);
  }

  if (twai_start() == ESP_OK) {
    Serial.println("[SYS] TWAI Started. Listening at 500kbps.");
  }

  // 4. Create Queue and FreeRTOS Tasks
  canDataQueue = xQueueCreate(50, sizeof(TelemetryPacket));
  // Pin CAN reader to Core 1 for highest priority, SD logger to Core 0
  xTaskCreatePinnedToCore(canReaderTask, "CAN_Read", 4096, NULL, 5, NULL, 1);
  xTaskCreatePinnedToCore(sdLoggerTask, "SD_Log", 4096, NULL, 2, NULL, 0);
}

void loop() {
  // Loop is intentionally left empty. All work is handled by FreeRTOS tasks.
  vTaskDelay(pdMS_TO_TICKS(1000));
}

Debugging: Exact Errors & Ranked Causes

When working with hardware-level protocols, the compiler and the silicon will punish configuration mistakes. Here are the exact error strings you will encounter and how to fix them.

Error 1: fatal error: driver/twai.h: No such file or directory

Context: This is a compilation error that occurs before the code even reaches the board.

1. Cause (Most Likely): Incorrect Board Selection. You have 'Arduino Uno' or 'Arduino Nano' (AVR) selected in the IDE Tools menu. The driver/twai.h library is exclusive to the ESP-IDF/ESP32 core.
2. Cause: Outdated ESP32 Board Package. The TWAI driver replaced the older CAN driver in ESP32 core v2.0.0+. Update your board manager.
3. Fix: Go to Tools > Board > Arduino ESP32 Boards > select Arduino Nano ESP32.

Error 2: E (452) TWAI: Alert(32): Bus-Off state

Context: This is a runtime error printed to the Serial Monitor. The CAN controller has detected too many errors and disconnected itself from the bus to prevent network corruption.

1. Cause (Most Likely): Missing or incorrect 120-ohm termination. Without termination, signal reflections cause bit errors, rapidly incrementing the controller's Transmit Error Counter (TEC) until it hits 255 and triggers Bus-Off.
2. Cause: Baud Rate Mismatch. Your code is set to 500kbps, but the target device (e.g., OBD-II port, motor controller) is broadcasting at 250kbps or 1Mbps.
3. Cause: Logic Level Violation. You are using a 5V TJA1050 transceiver with the 3.3V Nano ESP32. The S3 cannot reliably read the 5V RX signal, causing framing errors.

Extending and Simplifying the Build

How to Simplify: If you don't need persistent storage, strip out the SD card hardware and the sdLoggerTask. Instead, format the CAN data as JSON inside the canReaderTask and push it directly over the ESP32's native WiFi using the PubSubClient MQTT library. This turns the build into a wireless CAN-to-MQTT bridge, perfect for integrating vehicle telemetry into Home Assistant.

How to Extend: For high-throughput racing applications (1Mbps+), the SD card's SPI write latency will still cause queue overflows. Extend this build by swapping the SPI SD module for an SDMMC-compatible module wired to the ESP32's dedicated SDMMC pins, or buffer the data to an external SPI SRAM chip (like the 23LC1024) and write to the SD card in bulk chunks every 5 seconds.

Advanced Arduino Projects FAQ

What makes an Arduino project 'advanced' compared to beginner builds?

Beginner projects rely on blocking code (like delay()) and simple polling. Advanced projects utilize hardware interrupts, direct memory access (DMA), real-time operating systems (FreeRTOS) for task concurrency, and industrial communication protocols (CAN, RS-485, Ethernet) that require strict timing and electrical termination.

Can I use a standard Arduino Uno for this CAN bus telemetry project?

No. The ATmega328P on the Uno lacks a native CAN controller. While you can use an MCP2515 SPI-to-CAN shield, the SPI bus and 16MHz clock become a massive bottleneck at 500kbps, dropping frames under heavy bus loads. The ESP32-S3's native TWAI peripheral handles the bit-banging in hardware, freeing the CPU to handle logging and networking.

How do I handle SD card write latency without dropping CAN frames?

SD cards periodically pause to perform internal garbage collection and wear-leveling, causing write spikes of up to 200ms. The code provided solves this using a FreeRTOS Queue (canDataQueue). The high-priority CAN task pushes data to the queue in microseconds, while the lower-priority SD task blocks on the queue and handles the slow writes, effectively decoupling the hardware speeds.

What are the best advanced Arduino projects for robotics in 2026?

In 2026, the most valuable advanced robotics projects focus on sensor fusion and edge AI. Combining the Nano ESP32's dual-core processor with an IMU (like the BNO086) to run a Kalman filter, or using the ESP32-S3's vector instructions to run lightweight TensorFlow Lite Micro models for predictive maintenance on CAN-connected servos, represents the current cutting edge of hobbyist and prosumer robotics.