Libre Car

Milestone 5 Update

2024-04-25T01:25:00+02:00

Automotive Protcols on Litex

Universal Measurement and Calibration Protocol

The CAN Calibration Protocol (CCP) is an interface that enables read/write access to an Electronic Control Unit (ECU). It enables calibration, data measurement, flashing and more.

The Universal Measurement and Calibration Protocol (XCP) is the successor to CCP with various improvements including support for more transport layers such as Ethernet, FlexRay and SxL.

XCP provides direct access to the inner workings of an ECU. This lets you request high-frequency parameter data that may otherwise only be known to the ECU. Further, it also lets you modify the ECU algorithms and variables, making it easy to test and calibrate ECUs.

The CCP/XCP protocol is based on a single-master/multi-slave concept. An external measurement & calibration tool (e.g. a PC/device/data logger) serves as the master and is able to read/write from one or more ECUs aka slaves.

Opensource implementation of XCP is available at : https://github.com/vectorgrp/XCPlite

To enable basic XCP on Litex, a small demo implementation is mirrored at : https://github.com/disdi/XCPlite

As part of this milestone this is now integrated in buildroot : https://gitlab.com/saket.sinha89/buildroot/-/commit/e75a1e270292d99e62bd656b3f162dc79caadac8

The below image shows the demo working with creating a dummy XCP Server which talks to XCP slave on Litex over localhost via UDP to measure variables at fixed memory address.

Milestone 5

2024-04-24T01:25:00+02:00

Automotive Protcols on Litex

Unified Diagnostic Services

Unified Diagnostic Services (UDS) is a communication protocol used in automotive Electronic Control Units (ECUs) to enable diagnostics, firmware updates, routine testing and more.

UDS communication is performed in a client-server relationship -

client being a tester-tool
server being a vehicle ECU

The UDS protocol (ISO 14229) is supported on both CAN and Ethernet.It describes the application layer requirements for UDS (independent of what lower layer protocol is used). Opensource implementation on CAN is available at:

https://pypi.org/project/udsoncan/

The standard which specifies a transport protocol and network layer services for use in CAN based vehicle networks is CAN ISO-TP - Transport Protocol (ISO 15765). Opensource implementation is available at:

https://pypi.org/project/can-isotp/

DoIP(Diagnostics over Internet Protocol) is a standardized diagnostic transport protocol according to ISO 13400. It encapsulates diagnostics messages of protocol standards like Unified Diagnostic Services (UDS) over Ethernet. Opensource implementation is available at:

https://pypi.org/project/doipclient/

As part of this milestone, integration of the above Opensource projects to buildroot is compelted so that it is available on Linux on Litex. The link to the integration effort in buildroot project is available at below link -

https://gitlab.com/saket.sinha89/buildroot

Once these python packages are added to buildroot project, the buildroot configuration can be updated with below options:

The screenshoot below shows these packages working on buildroot rootfs of Litex Console:

Milestone 4 Complete

2024-04-04T14:21:00+02:00

Bringing up Ethernet interface on Litex

Support for CTUCAN interfaces has been extended from Arty to below FPGA boards :

Genesys2 : https://digilent.com/reference/programmable-logic/genesys-2/ commit : https://github.com/litex-hub/linux-on-litex-vexriscv/pull/378/commits/4e2d1bc537c68c8ab7b63ab31b31a27257dd8a23

Nexys A7 : https://digilent.com/reference/programmable-logic/nexys-a7/ commit : https://github.com/litex-hub/linux-on-litex-vexriscv/pull/378/commits/975064cddb70a86cf43d26888ccb749caaf26be8

All the above boards have "ethernet" available in litex project by default so bitstream need not be modified.

I added support in litex buildroot configuration file to support bringing up network interface via DHCP.

commit : https://github.com/litex-hub/linux-on-litex-vexriscv/pull/378/commits/241ffa8e6a4b3069e7a3f16b9d586160af55d406

As a result in Litex rootfs, buildroot generated /etc/network/interfaces with dhcp enabled for eth0 as shown below :

Bringing up Cannelloni on Litex

Cannelloni uses UDP, TCP or SCTP to transfer CAN frames between two machines not connected via CAN bus.

Repository: https://github.com/mguentner/cannelloni

Cannelloni on RPI

We use Raspberry-Pi(RPI) to test cannelloni packet exchange with Litex as shown below :

The above image shows RPI using a virtual CAN interface and starting cannelloni with Litex IP as remote.

Cannelloni on Litex

Cannelloni is already supported in buildroot. I added support in litex buildroot configuration file to support cannelloni on Litex.

commit : https://github.com/litex-hub/linux-on-litex-vexriscv/pull/378/commits/6a7676b3ef6d7b3c4a9c905e9fba3d0beddb69e8

As a result in Litex rootfs, cannelloni package is installed as shown below :

The above image shows Litex using CTUCAN interface and starting cannelloni with RPI IP as remote. We then use can-utils(cansend and candump) to send/receive CAN packets over UDP.

All commits are part of the Pull request to Linux on Litex Project : https://github.com/litex-hub/linux-on-litex-vexriscv/pull/378

Milestone 3 Complete

2024-03-17T14:21:00+01:00

Controlling BLDC Motor for Vehicle with CTUCAN

This is to update on completion of Milestone 3 of the project which involved controlling a motor on the CAN network with CTUCAN device. We would need to have a motor contoller to interface with our CAN bus and control the motor.

The ODrive is a motor control board based on the STM32 microcontroller. It can be used with BLDC motors (brushless DC motors), over a CAN bus to set acceleration, braking, and other parameters for motor control systems.

Hardware for ODrive is available for sale on online shop: https://odriverobotics.com/shop

The entire firware and GUI software to interface with Odrive is available on GitHub: https://github.com/odriverobotics/ODrive/

Hardware Requirements

A brushless motor.
Odrive S1
FPGA device with CAN controller/transceiver
A >12V power supply or battery.

Hardware Connections

Connect screw terminals representing the motor phases to A/B/C of Odrive S1 Power Pads.
Connect the power supply cables to Odrive S1 solder pads that are labelled +/- and Arty A7 board

Since CAN bus is not isolated, use power supply to power both. To run Arty A7 board with same DC source, below accesories can be used :

DC-DC convertor : https://amzn.eu/d/iUmVObb

DC Hollow Connector : https://amzn.eu/d/gej5q8E

Connect Odrive S1 with FPGA board over CAN bus.
Connect motor to Odrive S1 via 3 phase wire.

Complete setup can be illustrated in below daigram

In reality, it resemebles like seen in below image:

Controlling Motor Controller with CAN bus

Power up Arty board with CTUCAN driver enabled

Use GUI Wizard of Odrive to calibrate the motor.

Check if any data is recevied on CAN bus with candump

To make sense of this data we would use CAN Simple protocol provided by Odrive.

https://github.com/odriverobotics/ODriveResources/blob/master/examples/can_simple.py

Motor should start rotating with torque of 1 turns per second.

Documentation

2024-01-07T21:43:12+02:00

Documentation to build and test CAN bus with Litex has been added to Wiki section of this website. Direct link can be found at : https://disdi.github.io/librecar-wiki/ .

Milestone 2 Complete

2023-12-16T14:21:00+01:00

This is to update on completion of Milestone 2 of the project which involved communication on the CAN network with real CAN devices.

The major work done in this Milestone involved :

Bring UP the CTUCAN device enumerated in first Milestone. Update of Litex interfaces was needed to make CAN interface UP and running.

Refer : https://github.com/disdi/linux-on-litex-vexriscv/commit/b4c7c81e48d285977055b19cb08069af642ff516
Use ip utilites of linux which treats CAN as network device and make it up. Support was added to buildroot to include needed utilities for CAN and make it part of bootup script.

Refer : https://github.com/disdi/linux-on-litex-vexriscv/commit/64ecd04d2eefc14753181dbf8a1bc65d09c65991

Below image shows CAN bus coming up on system restart and can-utils is used for communication over CAN network :
Now when CAN IP is up, we needed a CAN transceiver to connect to CAN network. SN65HVD230 CAN Board is used for this purpose.

Refer : https://www.waveshare.com/sn65hvd230-can-board.htm

can_tx and canrx are are mapped to ck_io pins exposed on J4 of Arty Board. https://github.com/disdi/linux-on-litex-vexriscv/blob/master/soc_linux.py#L34

They are connected to CAN RX and CAN TX of transceiver with 3.3V to power it. Connection between FPGA board and CAN transceiver is shown below :
Considerable testing is done over different CAN devices to confirm CTUCAN IP is able to comunicate over CAN network. PCAN-USB adapter is used to emulate CAN device over development computer.

Refer : https://www.peak-system.com/PCAN-USB.199.0.html?&L=1

Connection between PCAN-USB adapter with DB9 connector and CAN transceiver is shown below :

CANH and CANL of transceiver is attached to (pin2 and pin7) DB9 connector. For DB9 Connector pinout for CAN, refer : https://documentation.help/NI-CAN/High-Speed_CAN_Pinout_Cable.html
PCAN-View software run on development computer is to analyze the CAN network to check for the protocal conformity and errors.

Refer : https://www.peak-system.com/PCAN-View.242.0.html?&L=1

TestBench Setup

The testbench results can be seen by referencing Section 2 where 01010101 sent from Litex Console is recieved in PCAN-View In Section 5.

Milestone 1 Complete

2023-06-08T14:21:00+02:00

CTUCAN Controller for Linux

We updated linux-on-litex kernel config to enable CTUCAN linux driver.

The screenshoot below shows the menuconfig to enable CTUCAN driver:

Next we had to update the device tree manually to add a section for CTUCAN driver:

CTU_CAN_FD_0: CTU_CAN_FD@80010000 {: compatible = "ctu,ctucanfd"; reg = <0x80010000 0x10000>; interrupt-parent = <&intc0>; interrupts = <0 30 4>; clocks = <&sys_clk>; status = "okay"; };

The link to the complete modified device-tree is available at below link - https://github.com/disdi/linux-on-litex-vexriscv/commit/64970aea0ce4dfb10d16ffeece8837b032a702d4

When Linux boots up, it shows the CTUCAN linux driver getting initialized.

In the buildroot Image booting up we can clearly see the CTUCAN driver module is associated with a device:

Further, it gets enumerated as a network device:

Next step is to connect Digilent Arty Board running CTUCAN IP core with an external MCP2551 CAN transceiver Board and attempt CAN transmission to another device on this CAN Bus.

Milestone 1 Update

2023-05-30T01:25:00+02:00

CTUCAN Controller for Linux

We updated linux-on-litex project to integrate CTUCAN Controller booting over Linux.

The link to the code is available at below link - https://github.com/disdi/linux-on-litex-vexriscv/commit/e9f9c6b14bca11cca2195bd61f9c5334ead3221d

When Litex BIOS boots up, it shows all the peripherals needed to boot linux alongwith CTUCAN Controller in the memory region. The screenshoot below of Litex Console:

Next step is to modify linux kernel booting over the litex bitstream with CTUCAN Controller to enumerate a CAN device.

Milestone 1

2023-05-09T21:43:12+02:00

This is to update on the first milestone that is archeived in Libre Car Control project.

FPGA board boots up Linux using linux-on-litex-vexriscv

Replacing ECP5 with Artix7

We switched from Lattice ECP5 to Xillinx Artix7 FPGA since we found that yosys toolchain was not able to synthesize vhdl code. The project is now being develop on Digilent Artix7 board. We are able to boot Linux on Artix7 from the official Litex repository since this board is officially supported.

CTUCAN Controller IP

- CTUCAN controller Litex Integration

We generated VHDL code for CTUCAN controller and used the CTUCAN wrapper to integrate it in Litex ecosystem. It became available as python egg in the development environment.

- Litex SOC with CTUCAN Controller

We created a new Litex Core with CTUCAN controller and mapped it to the processor. When Litex BIOS boots up, CTUCAN controller can be seen in the memory region.

The link to the code is available here

Introduction

2023-05-01T21:43:12+02:00

This is introductory post for the project Libre Car Control.

This project is funded through the NGI Zero Entrust Fund, a fund established by NLnet with financial support from the European Commission’s Next Generation Internet program.

Learn more on the NLnet project page.