This is a series of scripts used for making a UDS connection to a Simos18 ECU (assuming it has a compatible ASW). This was developed around the Eurodyne Maestro ECU in the MQB chassis VW/Audi
Installation is relatively straightforward. Assuming you have a working pi with piCan hat, drivers, etc:
clone the repository into the home directory of your pi user
pi@raspberrypi:~ $ whoami
pi
pi@raspberrypi:~ $ pwd
/home/pi
pi@raspberrypi:~ $ git clone https://github.com/joeFischetti/SimosHighSpeedLogger.git
Cloning into 'SimosHighSpeedLogger'...
remote: Enumerating objects: 58, done.
remote: Counting objects: 100% (58/58), done.
remote: Compressing objects: 100% (35/35), done.
remote: Total 58 (delta 23), reused 49 (delta 14), pack-reused 0
Unpacking objects: 100% (58/58), done.
pi@raspberrypi:~ $ cd SimosHighSpeedLogger/
pi@raspberrypi:~/SimosHighSpeedLogger $ At this point, you'll have a basic, working, logger.
Using the logger with a front end is relatively straightforward. With network connectivity to your pi and it plugged into the car, you can ssh in and run the logger with a TUI gague cluster:
pi@raspberrypi:~/SimosHighSpeedLogger $ python3 pyLog.pyYou'll need to press "enter" to tell it to connect to the car, and when it does, you should get live display on the gauges. Pressing the enter key will toggle logging on and off.
If, instead, you want to run it headless:
pi@raspberrypi:~/SimosHighSpeedLogger $ python3 pyLog.py --headlessHeadless mode will trigger the logger to start logging when the cruise control has been turned on, and will stop logging 5 seconds after it's been turned off. Cruise control does not need to be active, just on.
There's 2 additional files that are used by the logger. Examples of each are provided.
parameters.yaml is used to define the memory locations, scaling factors, and size of each parameter you wish to log. These are generally available via an A2L file and they WILL be specific to the software version running on your ECU.
Engine speed:
length: 0x02
signed: False
function: "x/1.0"
units: "RPM"
location: '0xD0012400'config.yaml is used to define other configuration options that the logger can use. At the time of writing, the config file currently only needs to be used to specify SMTP settings for notification emails from the script. These emails are helpful (especially when running headless) because they will
1.Tell you when the logger has starter and what it's IP address is 2.Email you an activity log if the logger crashes, so you can see what happened
Since the logger has the capability of running headless, I've included a few scripts that can be used to trigger it when USB sticks are inserted.
systemd udev has the capability of triggering scripts based on specific events. The following files within the repo are notable:
etc/systemd/system/usb-mount@.service
etc/systemd/system/pyLog@.service
etc/udev/rules.d/50-usbstick_test.rules
etc/udev/rules.d/50-usbstick.rules
usr/local/bin/usb-mount.sh
These files can be moved to their respective locations on the root filesystem. Once you've done that:
sudo systemctl daemon-reload
sudo udevadm control --reload-rulesDescriptions of each file:
etc/udev/rules.d/50-usbstick_test.rules etc/udev/rules.d/50-usbstick.rules These files are used to trigger events within udev. They trigger the systemd file (which launches the mount script in /usr/local/bin)
etc/systemd/system/usb-mount@.service This systemd file will mount the usb stick that was passed in the argument. A script called via udev directly doesn't have the proper permissions to handle the mount operation
usr/local/bin/usb-mount.sh This script is used to automatically mount the flash drive that was called, check the contents of it, and if there's a 'parameters.yaml' file, launch the pi in headless logging mode
etc/systemd/system/pyLog@.service This is a systemd unit file that takes the USB mounted stick as a parameter. It'll set that as both the output location for logs and as the parameter file to be used for reading logging parameters
Argparse also does a great job displaying a basic help menu:
pi@raspberrypi:~/SimosHighSpeedLogger $ python3 pyLog.py --help
usage: pyLog.py [-h] [--headless] [--params PARAMS]
Simos18 High Speed Logger
optional arguments:
-h, --help show this help message and exit
--headless
--params PARAMS location of a parameter file to use for parameters, specify
full pathHuge thanks to Brian for helping me out along the way: https://github.com/bri3d/
UDEV/Systemd stuff adapted from: https://www.andreafortuna.org/2019/06/26/automount-usb-devices-on-linux-using-udev-and-systemd/
Creating an SD card for the raspberry pi needs to be done from a computer with an SD card reader Insert the card into the machine and follow the directions on this page: https://www.raspberrypi.org/documentation/installation/installing-images/
From a fresh SDCard (still in the machine that you created it on) Create an empty file to enable ssh.
On mac/linux you could:
touch /boot/ssh
On Windows:
Open the SD card (boot) from windows explorer
right click -> new file -> ssh (with no extension)
Create a file (/boot/wpa_supplicant.txt) with wifi info if applicable
Once you boot up the Pi for the first time, SSH in and:
sudo update
sudo upgrade
sudo apt install python3-pip can-utils vim gitAt the end of /boot/config.txt, add the following text: If you've never used 'vim' before, you would type:
sudo vim /boot/config.txtNotes on vim - there's 'view' mode and 'edit' mode.
To enter "edit" mode, press 'i'. To exit edit mode press 'escape'
To save the file, from view mode press : and then "w" (for write) and "q" (for quit)
dtparam=spi=on
dtoverlay=mcp2515-can0,oscillator=16000000,interrupt=25
dtoverlay=spi-bcm2835-overlayCreate a systemd unit file to auto start your can interface on boot
sudo vim /etc/systemd/system/can0interface.service
with the following:
[Unit]
Description=Setup SocketCAN interface can0 with a baudrate of 500000
After=multi-user.target
[Service]
Type=oneshot
RemainAfterExit=yes
ExecStartPre=/sbin/ip link set can0 type can bitrate 500000
ExecStart=/sbin/ip link set can0 up
ExecStop=/sbin/ip link set can0 down
[Install]
WantedBy=multi-user.targetThen reload systemd and enable and start the can interface:
systemctl daemon-reload
systemctl enable can0interface
systemctl start can0interfaceNext, switch to your home directory and clone this repo and the repo for can-isotp
git clone https://github.com/joeFischetti/SimosHighSpeedLogger.git
git clone https://github.com/hartkopp/can-isotp.gitAnd then, set up can-isotp:
cd can-isotp
sudo apt install raspberrypi-kernel-headers
make
sudo depmod -a
sudo make modules_install
sudo insmod ./net/can/can-isotp.ko
sudo echo "/home/pi/can-isotp/net/can/can-isotp.ko" >> /etc/modulesWhen updating your kernel, you'll NEED to rebuild the kernel module:
cd ~/can-isotp
make clean
git pull
make
sudo depmod -a
sudo make modules_installFinally, install some necessary python modules via pip:
sudo python3 -m pip install pyyaml udsoncan can-isotpDo a better job documenting the way the udev rules work (mainly - how to identify the sticks, and how to set them up) Stop/Kill the logger when another USB stick is inserted into the pi.