CAN Bus Setup on
BeagleBone Black

Download the correct image

https://files.beagle.cc/file/beagleboard-public-2021/images/
am335x-debian-13.5-iot-armhf-2026-05-19-4gb.img.xz

Flash with Balena Etcher

• Click Flash from file → select the .img.xz file
• Click Select target → select your microSD card
• Click Flash and wait for verification to complete

Set credentials in sysconf.txt

# Remove the # and set your values:
user_name=beagle
user_password=beagle
root_password=debian

Boot sequence

• Disconnect all power from the BBB
• Insert the microSD card
• Hold the S2 button (small button next to the microSD slot)
• Connect the USB cable while keeping S2 held
• Release S2 after 5–6 seconds
• Wait 3–5 minutes for first boot to complete

Mount the eMMC and edit its uEnv.txt

sudo su
mkdir -p /mnt/emmc2
mount /dev/mmcblk1p2 /mnt/emmc2
echo "mmcdev=0" >> /mnt/emmc2/boot/uEnv.txt
sync && reboot

Assign UsbNcm driver via Device Manager

• Open Device Manager — Win + X → Device Manager
• Find "Unknown USB Device" or "CDC NCM" under Other Devices
• Right-click → Update Driver → Browse → Let me pick
• Network Adapters → uncheck "Show compatible hardware"
• Manufacturer: Microsoft → Model: UsbNcm Host Device

Verify connectivity

c:\windows\system32\ping.exe 192.168.7.2

PuTTY connection settings

sudo su
cat /etc/debian_version  → 13.5
uname -r               → 6.18.32-bone35

Load the SocketCAN stack

modprobe can && modprobe can_raw && modprobe c_can && modprobe c_can_platform
lsmod | grep can

Confirm overlay file exists

find / -name "*CAN0*" 2>/dev/null
/boot/dtbs/6.18.32-bone35/overlays/BB-CAN0-00A0.dtbo

Edit /boot/uEnv.txt

nano /boot/uEnv.txt
# Find and change:
#uboot_overlay_addr0=<file0>.dtbo
# To:
uboot_overlay_addr0=BB-CAN0-00A0.dtbo
# Ctrl+X → Y → Enter → reboot

Verify can0 after reboot

ip link show can0

Bring up can0 in loopback mode

ip link set can0 down
ip link set can0 up type can bitrate 500000 loopback on

Send and receive a test frame

Terminal 1:

candump can0

Terminal 2:

cansend can0 123#DEADBEEF

Create the init script and systemd service

cat > /usr/local/bin/can-init.sh << 'EOF'
#!/bin/bash
ip link set can0 down 2>/dev/null || true
ip link set can0 type can bitrate 500000
ip link set can0 up
EOF
chmod +x /usr/local/bin/can-init.sh

cat > /etc/systemd/system/can-init.service << 'EOF'
[Unit]
Description=CAN bus init
After=network.target

[Service]
Type=oneshot
ExecStart=/usr/local/bin/can-init.sh
RemainAfterExit=yes

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl enable can-init.service
systemctl start can-init.service

Boot from eMMC (old Debian 7.8) as a staging environment

Remove the SD card and power up normally — the board boots into the old eMMC system. Connect via PuTTY (192.168.7.2). This gives us a running Linux environment to write the new image from.

Put the image file on a USB stick and mount it

sudo su
mkdir -p /mnt/usb
mount /dev/sda1 /mnt/usb
ls /mnt/usb
# Confirm: am335x-debian-13.5-base-v6.18-armhf-2026-05-19-4gb.img

Identify the eMMC block device

lsblk

Write the image to eMMC

dd if=/mnt/usb/am335x-debian-13.5-base-v6.18-armhf-2026-05-19-4gb.img \
   of=/dev/mmcblk0 bs=4M status=progress

3774873600 bytes (3.8 GB) copied, 411 s, 9.2 MB/s
sync

Remove SD card, reboot, reconnect

umount /mnt/usb && reboot

After ~3 minutes, reconnect via PuTTY. On first boot you'll be prompted to change the password.

sudo su
cat /etc/debian_version  → 13.5
ip link show can0        → state DOWN (ready)

Hardware — wiring the LED to BBB

Finding the correct GPIO number for P9_12

On kernel 6.x, GPIO numbers are offset from the gpiochip base — they are not the same as the physical pin number. The correct number must be calculated before export.

Step 1 — Find P9_12's line number:

gpioinfo 2>/dev/null | grep P9_12
line  28:  "P9_12"  input
# P9_12 is line 28

Step 2 — Find the gpiochip base:

ls /sys/class/gpio/ | grep gpiochip
gpiochip512
gpiochip544
gpiochip576
gpiochip608
# The first chip starts at 512

Step 3 — Calculate the GPIO number:

# GPIO number = gpiochip base + line number
# GPIO number = 512 + 28 = 540

Export, verify, then control

Always verify the pin state before writing to it — confirm the direction and value are consistent with what you expect.

Export the GPIO:

echo 540 > /sys/class/gpio/export

This file is a special kernel interface — writing a GPIO number to it causes the kernel to create a new directory with all the files needed to control that pin:

# Before export:
/sys/class/gpio/
├── export
├── unexport
├── gpiochip512/
└── gpiochip544/

# After:  echo 540 > /sys/class/gpio/export
/sys/class/gpio/
├── export
├── unexport
├── gpio540/              ← this directory was created
│   ├── direction         ← set "in" or "out"
│   ├── value             ← read or write 0 / 1
│   ├── active_low        ← logic polarity
│   └── edge
├── gpiochip512/
└── gpiochip544/

echo out > /sys/class/gpio/gpio540/direction

Verify — check direction and current value:

cat /sys/class/gpio/gpio540/direction
out                          ← must be "out" before writing

cat /sys/class/gpio/gpio540/value
0                            ← 0 = LOW = LED off (expected at start)

cat /sys/class/gpio/gpio540/active_low
0                            ← 0 = normal logic (1=HIGH=LED on)

Check can0 is UP before proceeding:

ip link show can0
4: can0: <NOARP,ECHO> mtu 16 ... state DOWN ...  ← DOWN = not ready
4: can0: <NOARP,UP,LOWER_UP,ECHO> mtu 16 ... state UP ...  ← UP = ready

If state is DOWN, bring it up:

ip link set can0 type can bitrate 500000
ip link set can0 up
ip link show can0
4: can0: <NOARP,UP,LOWER_UP,ECHO> mtu 16 ... state UP ...  ← now UP

Now turn the LED on and off:

echo 1 > /sys/class/gpio/gpio540/value   # LED ON  — verify visually
cat /sys/class/gpio/gpio540/value
1                                         ← confirms HIGH

echo 0 > /sys/class/gpio/gpio540/value   # LED OFF — verify visually
cat /sys/class/gpio/gpio540/value
0                                         ← confirms LOW

Transfer can_led.c to BBB

First, find the correct home directory on your BBB — it may be /home/beagle or /home/debian depending on the image:

ls /home/
debian   ← use this name in the path below

Option A — scp over USB network (from Windows Command Prompt):

scp can_led.c debian@192.168.7.2:/home/debian/can_led.c

Option B — paste directly via PuTTY:

cat > /home/debian/can_led.c << 'EOF'
// paste the full can_led.c source code here (from Step 19)
EOF

Option C — USB stick:

mkdir -p /mnt/usb && mount /dev/sda1 /mnt/usb
cp /mnt/usb/can_led.c /home/debian/can_led.c
umount /mnt/usb

Verify the file arrived:

ls -lh /home/debian/can_led.c
-rw-r--r-- 1 root root 1.1K Jun 11 10:00 /home/debian/can_led.c
← non-zero size confirms the file is complete

Compile and run can_led.c on BBB

This program listens on can0 for any incoming frame. If DATA byte = 0x01, it turns the LED on. If 0x00, it turns it off.

// can_led.c — compile: gcc -o can_led can_led.c
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <net/if.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <linux/can.h>
#include <linux/can/raw.h>

#define LED_GPIO "540"
#define GPIO_VAL "/sys/class/gpio/gpio540/value"

static void led_set(int on) {
    int fd = open(GPIO_VAL, O_WRONLY);
    if (fd < 0) { perror("gpio"); return; }
    write(fd, on ? "1" : "0", 1);
    close(fd);
}

static void gpio_init() {
    int fd = open("/sys/class/gpio/export", O_WRONLY);
    if (fd >= 0) { write(fd, LED_GPIO, strlen(LED_GPIO)); close(fd); }
    usleep(100000);
    fd = open("/sys/class/gpio/gpio540/direction", O_WRONLY);
    if (fd >= 0) { write(fd, "out", 3); close(fd); }
}

int main(int argc, char *argv[]) {
    const char *iface = argc > 1 ? argv[1] : "can0";
    gpio_init();
    led_set(0);

    int sock = socket(PF_CAN, SOCK_RAW, CAN_RAW);
    struct ifreq ifr;
    strncpy(ifr.ifr_name, iface, IFNAMSIZ - 1);
    ioctl(sock, SIOCGIFINDEX, &ifr);
    struct sockaddr_can addr = { .can_family = AF_CAN, .can_ifindex = ifr.ifr_ifindex };
    bind(sock, (struct sockaddr *)&addr, sizeof(addr));

    printf("Listening on %s — 0x01=ON  0x00=OFF\n", iface);
    struct can_frame f;
    while (1) {
        read(sock, &f, sizeof(f));
        if (f.can_dlc < 1) continue;
        printf("[RX] ID=0x%03X  DATA=0x%02X  → LED %s\n",
               f.can_id & CAN_SFF_MASK, f.data[0],
               f.data[0] ? "ON" : "OFF");
        led_set(f.data[0] ? 1 : 0);
    }
}

cd /home/debian
gcc -o can_led can_led.c
./can_led can0

ESP32 — main.cpp

Type 1 or 0 in the serial monitor. The ESP32 sends a 1-byte CAN frame to the bus; BBB receives it and controls the LED.

#include <Arduino.h>
#include <driver/twai.h>

#define TX_PIN GPIO_NUM_17
#define RX_PIN GPIO_NUM_16

void setup() {
  Serial.begin(115200);
  twai_general_config_t g = TWAI_GENERAL_CONFIG_DEFAULT(TX_PIN, RX_PIN, TWAI_MODE_NORMAL);
  twai_timing_config_t  t = TWAI_TIMING_CONFIG_500KBITS();
  twai_filter_config_t  f = TWAI_FILTER_CONFIG_ACCEPT_ALL();
  twai_driver_install(&g, &t, &f);
  twai_start();
  Serial.println("Ready — type 1 to turn LED ON, 0 to turn it OFF:");
}

static void send_led(uint8_t val) {
  twai_message_t msg = {};
  msg.identifier       = 0x123;
  msg.data_length_code = 1;
  msg.data[0]          = val;
  if (twai_transmit(&msg, pdMS_TO_TICKS(100)) == ESP_OK)
    Serial.printf("[TX] 0x%02X → LED %s\n", val, val ? "ON" : "OFF");
  else
    Serial.println("[TX] Failed");
}

void loop() {
  if (Serial.available()) {
    char c = Serial.read();
    if      (c == '1') send_led(0x01);
    else if (c == '0') send_led(0x00);
  }
}

Run it — expected output

With ./can_led can0 running on BBB and the ESP32 flashed and connected:

Load the system overlay — filename only, no path

The correct overlay is already compiled and present in the system:

find /boot/dtbs -name "BB-CAN0-00A0.dtbo" 2>/dev/null
/boot/dtbs/6.18.32-bone35/overlays/BB-CAN0-00A0.dtbo

Add to /boot/uEnv.txt — filename only, no path prefix:

uboot_overlay_addr4=BB-CAN0-00A0.dtbo

After reboot, verify the overlay loaded:

sudo beagle-version 2>/dev/null | grep "Loaded Overlay"
UBOOT: Loaded Overlay:[BB-CAN0-00A0.kernel]   ← must appear here

Note: the pinmux registers may still display 0x30 after reboot — this is a kernel 6.x debug readout quirk. The overlay is applied correctly; verify by testing with cansend.