SocketCAN

SocketCAN Device Drivers

  • include/nuttx/net/netdev.h. All structures and APIs needed to work with drivers are provided in this header file. The structure struct net_driver_s defines the interface and is passed to the network via netdev_register().

  • include/nuttx/can.h. CAN & CAN FD frame data structures and dlc to len size

    uint8_t can_bytes2dlc(uint8_t nbytes);
uint8_t can_dlc2bytes(uint8_t dlc);

  • int netdev_register(FAR struct net_driver_s *dev, enum net_lltype_e lltype)'. Each driver registers itself by calling netdev_register().

  • Include/nuttx/net/can.h. contains lookup tables for CAN dlc to CAN FD len sizes named

  • Initialization sequence is as follows.

    1. xxx_netinitialize(void) is called on startup of NuttX in this function you call your own init function to initialize your CAN driver

    2. In your own init function you create the net_driver_s structure set required init values and register the required callbacks for SocketCAN

    3. Then you ensure that the CAN interface is in down mode (usually done by calling the d_ifdown function)

    4. Register the net_driver_s using netdev_register

  • Receive sequence is as follows.

    1. Device generates interrupt

    2. Process this interrupt in your interrupt handler

    3. When a new CAN frame has been received you process this frame

    4. When the CAN frame is a normal CAN frame you allocate the can_frame struct, when it’s a CAN FD frame you allocate a canfd_frame struct (note you can of course preallocate and just use the pointer).

    5. Copy the frame from the driver to the struct you’ve allocated in the previous step.

    6. Point the net_driver_s d_buf pointer to the allocated can_frame

    7. Call the can_input(FAR struct net_driver_s *dev) function include/nuttx/net/can.h

  • Transmit sequence is as follows.

    1. Socket layer executes d_txavail callback

    2. An example of the txavail function can be found in arch/arm/src/s32k1xx/s32k1xx_flexcan.c

    3. An example of the txpoll function can be found in arch/arm/src/s32k1xx/s32k1xx_flexcan.c

    4. In your transmit(struct driver_s *priv) function you check the length of net_driver_s.d_len whether it matches the size of a struct can_frame or struct canfd_frame then you cast the content of the net_driver_s.d_buf pointer to the correct CAN frame struct

SocketCAN protocol stack

SocketCAN is a CAN protocol stack implementation based on the BSD socket API, providing a more standardized and flexible CAN communication interface. SocketCAN uses the network protocol stack framework, allowing applications to use standard socket system calls (such as socket(), bind(), send(), recv(), etc.) for CAN communication.

Architecture

The SocketCAN implementation follows the standard network layer hierarchy:

  1. Application Layer Interface: Uses standard socket API (AF_CAN address family)

  2. Protocol Layer: CAN protocol processing (located in net/can/)

  3. Device Layer: CAN network device drivers

File Locations

Files supporting SocketCAN can be found in the following locations:

  • Protocol Implementation: The SocketCAN protocol stack is located in the net/can/ directory

  • Header File: include/nuttx/net/can.h

  • Main Modules:

    • can_conn.c - Connection management

    • can_sockif.c - Socket interface implementation

    • can_sendmsg.c - Message transmission

    • can_sendmsg_buffered.c - Message transmission with buffering

    • can_recvmsg.c - Message reception

    • can_poll.c - Polling support

    • can_callback.c - Callback handling

Configuration Options

To enable SocketCAN, configure the following options:

  • CONFIG_NET_CAN - Enable SocketCAN support

  • CONFIG_NET_CAN_NOTIFIER - Enable CAN notifier (optional)

  • CONFIG_NET_CAN_NBUFFERS - Number of CAN buffers

  • CONFIG_NET_RECV_BUFSIZE - Receive buffer size

Usage Notes

SocketCAN uses the standard socket programming model:

/* Create CAN socket */
int sock = socket(AF_CAN, SOCK_RAW, CAN_RAW);

/* Bind to CAN interface */
struct sockaddr_can addr;
addr.can_family = AF_CAN;
addr.can_ifindex = if_nametoindex("can0");
bind(sock, (struct sockaddr *)&addr, sizeof(addr));

/* Send CAN frame */
struct can_frame frame;
frame.can_id = 0x123;
frame.can_dlc = 8;
/* Fill data */
send(sock, &frame, sizeof(frame), 0);

/* Receive CAN frame */
recv(sock, &frame, sizeof(frame), 0);

Features

  • Standard Socket API: Uses familiar socket programming interface

  • Filtering Support: Set CAN ID filters via socket options

  • Non-blocking I/O: Supports non-blocking mode and polling

  • Multiple Connections: Supports multiple sockets accessing the same CAN bus simultaneously

  • Read Buffering: Supports data read buffering to prevent data loss

  • CAN FD Support: Supports CAN FD frames if enabled in configuration

  • Extensible: Easy to extend for additional CAN protocols