USB device configuration: Alternative to udev

Hi all
Every time I need to add multiple USB devices to a computer I get nervous and dread the architecture. The problem is when a computer boots it automatically brings up USB devices in whatever order it sees fit (think crazy race conditions). So if you have a motor controller, a camera, and a LIDAR that all use USB it can be difficult to know which device on the computer is which. You could check and manually change these every time you run your programs, however it is better to have your programs auto-detect which device to connect to.

There are some specialty cases that can make this problem easier. Most USB devices (in Linux) show up as /dev/ttyUSBX, where X is the number in which that device was initialized (ex. /dev/ttyUSB0). Some devices will come up differently. For example Hokuyo LIDAR’s show up as /dev/ttyACMX. And USB joysticks show up as a joystick device in /dev/input/jsX. So if you have one each of a joystick, a Hokuyo, and a motor controller you might get lucky and have them all map to different devices. But for the many times you are not lucky, how should you deal with it?

Random note: ACM refers to a USB modem. Most devices that we use are not really modems and just lie and claim to be an ACM device (often when they do the USB “stuff” on the main processor). Many USB to serial converter chips (such as FTDI) do not lie and show up as /dev/ttyUSB.

Random note 2: Remember that if you need USB 3.0 speeds you need USB3.0 cables and connectors. USB 2.0 gear will force your system to fall back to USB 2.0.

The traditional answer is to use udev rules. The basic idea is to make a file in /etc/udev/rules.d/ that will control how a device gets mapped and started. This allows you to change the links, change permissions, or run a script when a device is detected. A basic udev rule can follow the format of:

SUBSYSTEMS==”usb”, KERNEL==”ttyACM[0-9]*”, ACTION==”add”, ATTRS{idVendor}==”15d1″, ATTRS{idProduct}==”0000″, MODE=”666″, PROGRAM=”/opt/ros/hydro/lib/urg_node/getID /dev/%k q”, SYMLINK+=”sensors/hokuyo_%c”, GROUP=”dialout”

A great tutorial on udev, and also where I got the rule above is from Clearpath Robotics.

In my experience using udev rules for setting startup permission (to allow non-root access to the device) or running a script when a device is connected, works well. However the symlink that maps a device to a specific name, will sometimes create a link that you can not open (ie open(/dev/newSymLink) fails). There are also cases where you can not use udev in certain embedded systems or where you do not want to “install” udev rules.

There are several ways to avoid using udev. For example you could run the dmesg command, and find where the USB device was connected. Another way is to have a script run whenever a device is plugged in that updates a text file that stores the device name.
Another solution which I present below is ugly but it seems to work well in the cases that I tested where udev was giving me a hard time. The below is easier than parsing dmesg and does not require a udev rule to create a symlink that needs to be installed.

The first step which I got from here, gets the mapping of all your devices and the associated port numbers.

#!/bin/bash
for sysdevpath in $(find /sys/bus/usb/devices/usb*/ -name dev); do
     (
        syspath=”${sysdevpath%/dev}”
        devname=”$(udevadm info -q name -p $syspath)”
        [[ “$devname” == “bus/”* ]] && continue
        eval “$(udevadm info -q property –export -p $syspath)”
        [[ -z “$ID_SERIAL” ]] && continue
        echo “/dev/$devname – $ID_SERIAL”
    )
done

Running the script above will give you a list of all the attached USB devices. You can save the script above into a file called list_usb_devices.sh.

The next step is to run that script from your program. To do that I found some code here that allows you to run a system call and get the output into a string.

#include <string>
#include <iostream>
#include <cstdio>
#include <memory>

std::string system_exec(char* cmd)
{
    std::shared_ptr pipe(popen(cmd, “r”), pclose);
    if (!pipe) return “ERROR”;
    char buffer[128];
    std::string result = “”;
    while (!feof(pipe.get())) {
        if (fgets(buffer, 128, pipe.get()) != NULL)
            result += buffer;
        }
    return result;
}

So adding the above to the driver for the USB device, you can now use the following to get the port that you need to open

// get the names, grep to search for the device we want, cut the name of the port from the full line of text
std::string port = system_exec(“//list_usb_devices.sh |grep -m 1 |cut -c 1-12″);

// Get rid of any newlines (\n) in the string
port.erase(std::remove(port.begin(), port.end(), ‘\n’), port.end());

// switch to string to c style for using in the open command
const char * device = port.c_str();

// Finally we can now open our device
fd = open(device, O_RDWR | O_NOCTTY);

So as I said above this approach is ugly however it works. Using just the bash script and the system call from the c++ portion you can easily adapt this to any programming environment.

The above approach is often the wrong approach (since it is ugly), however it can help when udev is not working as expected or it can not be used.

I hope this helps you. Please leave comments below if this helped you or with other ways to handle USB devices.

In conclusion, I still avoid using USB devices when possible since they are a pain and are often not reliable. However if you must use them the information above **might** make your life a little better.

– Main image from https://pixabay.com/en/usb-flash-drive-broken-drive-27806/

Liked it? Take a second to support David Kohanbash on Patreon!