PROFILPELAJAR.COM

SocketCAN is a set of open source CAN drivers and a networking stack contributed by Volkswagen Research to the Linux kernel. SocketCAN was formerly known as Low Level CAN Framework (LLCF).

Typical CAN communication layers. With SocketCAN (left) or conventional (right).

Traditional CAN drivers for Linux are based on the model of character devices. Typically they only allow sending to and receiving from the CAN controller. Conventional implementations of this class of device driver only allow a single process to access the device, which means that all other processes are blocked in the meantime. In addition, these drivers typically all differ slightly in the interface presented to the application, stifling portability. The SocketCAN concept on the other hand uses the model of network devices, which allows multiple applications to access one CAN device simultaneously. Also, a single application is able to access multiple CAN networks in parallel.

The SocketCAN concept extends the Berkeley sockets API in Linux by introducing a new protocol family, PF_CAN, that coexists with other protocol families, such as PF_INET for the Internet Protocol. The communication with the CAN bus is therefore done analogously to the use of the Internet Protocol via sockets. Fundamental components of SocketCAN are the network device drivers for different CAN controllers and the implementation of the CAN protocol family. The protocol family, PF_CAN, provides the structures to enable different protocols on the bus: Raw sockets for direct CAN communication and transport protocols for point-to-point connections. Moreover the broadcast manager which is part of the CAN protocol family provides functions e.g. for sending CAN messages periodically or realize complex message filters. Since Linux kernel Version 5.10 the protocol family also includes an ISO-TP implementation, CAN_ISOTP.^[1]

Patches for CAN were added in the 2.6.25 Linux kernel. Meanwhile some controller drivers were added and work is going on to add drivers for a variety of controllers.

Usage

The application first sets up its access to the CAN interface by initialising a socket (much like in TCP/IP communications), then binding that socket to an interface (or all interfaces, if the application so desires). Once bound, the socket can then be used like a UDP socket via read, write, etc...

Python added support for SocketCAN in version 3.3.^[2] An open source library python-can provides SocketCAN support for Python 2 and Python 3^[3]^{[circular reference]}.

Installing a CAN device requires loading the can_dev module and configuring the IP link to specify the CAN bus bitrate, for example:

$ modprobe can_dev
$ modprobe can
$ modprobe can_raw
$ sudo ip link set can0 type can bitrate 500000
$ sudo ip link set up can0

There is also a virtual CAN driver for testing purposes which can be loaded and created in Linux with the commands below.

$ modprobe can
$ modprobe can_raw
$ modprobe vcan
$ sudo ip link add dev vcan0 type vcan
$ sudo ip link set up vcan0
$ ip link show vcan0
3: vcan0: <NOARP,UP,LOWER_UP> mtu 16 qdisc noqueue state UNKNOWN 
    link/can

The following code snippet is a working example of the SocketCAN API, that sends a packet using the raw interface. It is based on the notes documented in the Linux Kernel.^[4]

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

#include <net/if.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>

#include <linux/can.h>
#include <linux/can/raw.h>

int
main(void)
{
	int s;
	int nbytes;
	struct sockaddr_can addr;
	struct can_frame frame;
	struct ifreq ifr;

	const char *ifname = "vcan0";

	if ((s = socket(PF_CAN, SOCK_RAW, CAN_RAW)) == -1) {
		perror("Error while opening socket");
		return -1;
	}

	strcpy(ifr.ifr_name, ifname);
	ioctl(s, SIOCGIFINDEX, &ifr);
	
	addr.can_family  = AF_CAN;
	addr.can_ifindex = ifr.ifr_ifindex;

	printf("%s at index %d\n", ifname, ifr.ifr_ifindex);

	if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
		perror("Error in socket bind");
		return -2;
	}

	frame.can_id  = 0x123;
	frame.can_dlc = 2;
	frame.data[0] = 0x11;
	frame.data[1] = 0x22;

	nbytes = write(s, &frame, sizeof(struct can_frame));

	printf("Wrote %d bytes\n", nbytes);
	
	return 0;
}

The packet can be analyzed on the vcan0 interface using the candump utility which is part of the SocketCAN can-utils^[5] package.

user@server:~/can-utils $ ./candump vcan0
  vcan0  123  [2] 11 22

References

^ "hartkopp/can-isotp". May 14, 2021 – via GitHub.
^ "Issue 10141: SocketCan support - Python tracker". bugs.python.org.
^ SocketCAN
^ Viewable online from Linux Kernel Documentation or in linux/Documentation/networking/can.txt in most recent source trees
^ can-utils https://github.com/linux-can/can-utils/

External links

[1] "hartkopp/can-isotp". May 14, 2021 – via GitHub.

[2] "Issue 10141: SocketCan support - Python tracker". bugs.python.org.

[3] SocketCAN

[4] Viewable online from Linux Kernel Documentation or in linux/Documentation/networking/can.txt in most recent source trees

[5] -utils https://github.com/linux-can/can-utils/

[1]

[2]

[3]

[4]

[5]

PROFILPELAJAR.COM

SocketCAN

Usage

References

External links

Read other articles:

Distrik Sông Hinh

Uji protein metode Bradford

العلاقات السويسرية الفانواتية

Pertempuran Bucha

نشر

Wirtschaftswunder

Шаблон:Мифология

Géographie du Maine

Новотитаровское сельское поселение

Barmah

Geography of Niger

Chevrolet Cruze

ملف:صورة شخصية صالح القلاب.jpg

1930 Minnesota gubernatorial election

FC Shodmon Ghissar

安東尼·愛德華茲 (籃球運動員)

Oceanography

The Witcher 2: Assassins of Kings

Quantum nonlocality

Hardware