Inhaltsverzeichnis
Raspi Info
Welchen Raspi habe ich denn?
cat /sys/firmware/devicetree/base/model
Links
- Bei Bootproblemen: Pi Boot Issues - how to start a shell in emergence mode.
- building-a-canbus-app-part1 - with nodejs
Für das Beispiel müssen noch folgende Module im App-Ordner installiert werden:sudo apt install npm cd App npm init npm install socketcan npm install express npm install socket.io npm install canvas-gauges
nun nicht vergessen die IP-Adressen anzupassen (auch im HTML Ordner)
- OpenVpn Client für den Raspi:
- Bildschirm-Auflösung am HDMI-Ausgang einstellen - Feste Monitorauflösung einstellen.
Wenn am Raspi kein Monitor angeschlossen ist, und man mit VNC draufzugreift sollte man in der Bootkonfiguration eine feste Auflösung für den Monitor einstellen. - HDMI Auflösung erzwingen - Raspi feste Auflösung für den Monitor
- RasPi-Network- Raspi Netzwerk Einrichtungen
- https://raspberrytips.com/update-raspberry-pi-latest-version/ - Raspi updaten
- CAN-Simulator:
Raspi 3 - MCP-2515 - (SPI) CAN Support
Anhand meiner Umbauanleitung meines MCP-2515 CAN-Moduls wird hier die Konfiguration des CAN-Moduls beschrieben:
- SPI mit sudo raspi-config aktivieren
- /boot/config.txt folgnedes einfügen, bzw. kontrollieren ob diese Einträge schon gesetzt sind.
dtparam=spi=on # dtoverlay=mcp2515-can0-overlay,oscillator=20000000,interrupt=25 dtoverlay=mcp2515-can0,oscillator=20000000,interrupt=25 dtoverlay=spi-bcm2835-overlay
- CAN-Utils installieren:
sudo apt-get install can-utils
- reboot
sudo ip link set can0 up type can bitrate 250000
- eventuell mit
dmesg |grep spi [ 3.627804] mcp251x spi0.0 can0: MCP2515 successfully initialized.
auf Fehlermeldungen kontrollieren oder mal den Netzwerkstatus anschauen
ip -s -d link show can0
Hinweise
- Pi verwendet 3,3V Logik-Pegel (keine +5V verwenden sonst wird der Pi geschossen)
- Pin-Belegung am 40 poligen Header vom Raspberry Pi 3
- Pin1 - +3,3V ⇐ von mir verwendet
- Pin2,4 - +5V ⇐
- Pin 6 - GND ⇐
- (Pin17 - +3,3V)
- Pin 19 - MOSI (GPIO 10) ⇐
- Pin 20 - GND
- Pin 21 - MISO (GPIO 9) ⇐
- Pin 22 - GPIO 25 wird als INT1_IRQ vom MCP2515 verwendet (s. o. die Konfiguration) ⇐=
- Pin 23 - CLK (GPIO 11) ⇐
- Pin 24 - CS0 (GPIO 8) ⇐
- (Pin 26 - CS1 (GPIO 7) )
Kayak
Für die Verwendung von Kayak ist es erforderlich vorher den socketcand zu starten :
cd socketcand/ socketcand -i can0
Kayak nutzt diesen Socket, somit können auch entfernte Rechner mit Kayak simulatan die CAN-Daten analysieren. Der Connectstring hat dann folgendes Format:
can0@192.168.8.105:29536
Wenn keine Signale (.kdc) definiert sind kann nur das Raw-View Window für die Anzeige der Messages verwendet werden.
Die Signale werden mit dem offenen Format KDC beschrieben und und die Dateien müssen im Benutzer Homeverzeichnis unter:
- Linux: kayak/descriptions abgelegt sein ( „USER_DIR]/kayak/descriptions“ )
- Windows: C:\Users\Benutzername\kayak\descriptions
KCD Projekt - Github Projekt.
Installing Kayak
socketcand
Für die Installation von socketcand werden noch zusätzliche Pakete benötigt:
sudo apt install autoconf make sudo apt install libconfig-dev git clone https://github.com/linux-can/socketcand cd socketcand autoconf ./configure make sudo make install
Nan kann man den socketcand immer per Hand starten, wenn man Ihn nicht oft braucht, oder als „Servivc“ laufen lassen. Konfigurations Datei:
/etc/socketcand.conf
Und hier noch der Output vom Raspi-Canlogger:
socketcand -i can1 -l wlan0 -v Verbose output activated Using network interface 'wlan0' Listen adress is 192.168.111.81 Broadcast adress is 192.168.111.255 creating broadcast thread... binding socket to 192.168.111.81:29536 client connected connecting BCM socket... Closing client connection. client connected connecting BCM socket... client connected connecting BCM socket... state changed to 2
Die Verbindung kann auch mit Netcat getestet werden:
pi@raspberrypi:~ $ nc 192.168.178.76 29537 < hi >< open can1 > < ok >< rawmode > state changed to 2 < ok >< frame 1B8 1555242726.312172 12314423 >< frame 1B8 1555242726.512383 12314423 >< frame 200 1555242726.512620 0000000000000000 >< frame 12344444 1555242726.679495 1234567898000000 >< frame 1B8 1555242726.712588 12314423 >^C
oder kurzes Pyton skript:
import socket host = '192.168.178.76' port = 29537 s = socket.socket( socket.AF_INET, socket.SOCK_STREAM) s.connect( (host, port)) reply = s.recv(1024) if reply == '< hi >': s.send('< open can1 >') else: print "keine Antowr < hi >" exit reply = s.recv(1024) if reply == '< ok >': s.send('< rawmode >') else: print "fehler open CAN" exit() while True: reply = s.recv(1024) print reply
Starten per Skript ohne Fehlerausgabe ohne Fehlerausgabe und beide Gleichzeitig starten:
echo starte can0 over WLAN on Port 29536 socketcand -i can0 -l wlan0 -p 29536 &> /dev/null & echo starte can1 over WLAN on Port 29537 socketcand -i can1 -l wlan0 -p 29537 &> /dev/null &
Kayak compilieren
In inteliJI Idea als maven Projekt importieren und dann kompilieren und in der IDE starten.
Oder eine Jar erzeugen.
- File→Project Struture→Artifacts mit '+' Button anlegen
- Build Aritfacts… JAR - File erzeugen
- in der Konsole starten mit:
java -jar CANBabel.jar
Achtung Bug: Bug fehlende Main-Class
Bei mir hat das kopieren funktioniert, besser wäre wohl den richtigen Pfad zu setzen.
canbabel.jar
Kayak auf Raspi
Installations-Aneitung für Kayak auf einem Raspi 2 (gilt wohl auch für 3, to do: testen):
Links
- offizielle Doku von SPI von Raspberry
SPI-Readme
- Kayak - CAN-Logger auf Netbean Basis für Mac, Linux und Windows
- CANBabel - CAN Database Converter KDC←→DBC
- CAN Matrix - CAN Matrix Convert Libray and Tool, kann viele Formate und stellt folgende Skripte zur Verfügung (Python 2.7):
Usage: canconvert [options] import-file export-file import-file: *.dbc|*.dbf|*.kcd|*.arxml|*.json|*.xls(x)|*.sym export-file: *.dbc|*.dbf|*.kcd|*.arxml|*.json|*.xls(x)|*.sym
Usage: cancompare [options] cancompare matrix1 matrix2 matrixX can be any of *.dbc|*.dbf|*.kcd|*.arxml
- hängt noch von folgende Python Module ab die ebenfalls mit pip zu installieren sind:
lxml xlwt xlrd xlsxwriter pyyaml future
Falls die Installation von lxml nicht klappt am besten vorher noch folgendes installieren:
sudo apt-get install python-dev libxml2-dev libxslt1-dev zlib1g-dev
Wobei man wohl auf zlib1g-dev verzichten kann.
Hinweis: Unter WIN8.1 musste nichts nach installiert werden, hat alles auf Anhieb geklappt.
Dokumentation: CANMatrix - Doks (latest)
- cantools (Python) - Python CAN-Tools - Sehr interessant!
Beim Raspi3 lief es nicht mit Python3.5.3, erst nach einem Update auf Python3.9.4 hat es funktioniert (Python3.6 ginge wohl auch).wget https://www.python.org/ftp/python/3.9.4/Python-3.9.4.tar.xz
Für das Update wurden noch folgende Pakete benötigt:
sudo apt install libdb5.3-dev libgdbm-dev libsqlite3-dev libssl-dev sudo apt install libbz2-dev libffi-dev libreadline-dev sudo apt install tcl8.6-dev tk8.6-dev
- cantools - cantools is a set of libraries and command line tools for handling ASC, BLF, CLG, VSB, MDF, and DBC
Raspi 2 B
Konfiguration von der config.txt:
# for more options see http://elinux.org/RPi_config.txt dtparam=i2c_arm=on dtparam=spi=on # adde by andreas wegen SPI support MCP2515, IRQ sollte an GPIO12 sein # todo -pin für irq # https://www.raspberrypi.org/forums/viewtopic.php?t=141052 oder: # http://www.w3raspi.de/linux/raspberry-pi-mcp2515-can-bus/ dtoverlay=mcp2515-can0,oscillator=20000000,interrupt=12 dtoverlay=spi-bcm2835-overlay
Nach Reboot sollte dann folgendes erscheinen:
$ dmesg |grep spi [ 8.679718] spi spi0.0: setting up native-CS0 as GPIO 8 [ 8.695257] spi spi0.1: setting up native-CS1 as GPIO 7
RASPI 3 DUAL CAN Konfiguration
Das CAN Modul verwendet 2 MCP2515 die über SPI angebunden sind:
- CAN 1
- GPIO 25 Rx-IRQ
- CAN 2
- GPIO 24 Rx-IRQ
Standardmäßig sind die Terminierungen mit einem Jumper aktiviert.
Mein eigenes PI-CAN-DUO
https://www.elektronik-keller.de/index.php/projekte/raspberry-pi-module/pi-can-duo - Mein eigenes Modul, welches ein leicht andere Konfiguration benötigt (Quarz=20 MHz)
Installation
Die Installation ist im Prinzip die gleiche wie oben beschrieben.
/boot/config.txt
Bei Raspi3/4 ohne „-overlay“ im Namen.
dtparam=spi=on dtoverlay=mcp2515-can1-overlay,oscillator=16000000,interrupt=24 dtoverlay=mcp2515-can0-overlay,oscillator=16000000,interrupt=25 # dtoverlay=spi-bcm2835-overlay #wird nicht benötigt, hmm oder vielleicht doch
Hinweis: erst can1 dann can0 damit die Reihenfolge von can0 und can1 stimmt reboot Netzwerk aktivieren z.B. mit 500 kBit/s
sudo /sbin/ip link set can0 up type can bitrate 500000 sudo /sbin/ip link set can1 up type can bitrate 500000
Linux Treiber Patch
- mehr info
dtoverlay=mcp2515-can0,oscillator=16000000,interrupt=25,spimaxfrequency=500000
Hier sieht man wie man den SPI-Clock einstellen kann. Die Im Beispiel eingestellte 500kHz sind schon ein bisschen wenig.
todo: ist dieser Patch wirklich notwendig???
Bei mir hatte gleich alles funktioniert, ein Patch war bei mir nicht erforderlich
Tipp fürs Senden
Wenn man auch selber senden will, empfiehlt es sich den Sendebuffer zu erhöhen mit:
sudo ip link set can0 txqueuelen 1000 sudo ip link set can1 txqueuelen 1000
Autostart
In /etc/network/interfaces können die Interfaces konfiguriert werden, so daß beim Booten z.B. mit 100kBit/s initialisiert werden.
auto can0 iface can0 inet manual pre-up ip link set $IFACE type can bitrate 100000 listen-only off up /sbin/ifconfig $IFACE up down /sbin/ifconfig $IFACE down auto can1 iface can1 inet manual pre-up ip link set $IFACE type can bitrate 100000 listen-only off up /sbin/ifconfig $IFACE up down /sbin/ifconfig $IFACE down
Wenn die Baudrate nun nicht geändert werden soll, können die CAN-Schnittstellen einfach mit ifdown und ifup ab/eingeschaltet werden:
sudo ifdown can0 sudo ifup can0
Status des Interfaces anschauen mit:
ip -details -statistics link show can0
Um den Sendbuffer automatisch beim Login zu setzen, kann man folgendes in ~/.profile eintragen:
sudo ip link set can0 txqueuelen 1000 sudo ip link set can1 txqueuelen 1000 #autostart routing: sudo cangw -F sudo cangw -A -s can1 -d can0 sudo cangw -A -s can0 -d can1 echo echo "########################################" echo "########## cangw activated #############" echo
Automatic Bus Off Recovery
Um das Inteface nach einem Bus-Off oder Error Passiv automatisch wieder zu starten, darf der restart-ms - Wert nicht 0 sein, sondern es muss die Zeit in ms angegeben werden mit der ein Restart durchgeführt werden soll. ( can state ERROR-PASSIVE restart-ms 0 )
Beispiel um die Zeit auf 200 ms zusetzen.
sudo ip link set canX type can restart-ms 200
Einen manuellen Restart kann man mit:
sudo ip link set can0 type can restart-ms 100 sudo ip link set can0 up
durchführen.
Der Restart-Parameter kann auch oben beim Autostart hinzugefügt werden (/etc/network/interfaces)
#insert by andreas auto can0 iface can0 inet manual pre-up ip link set $IFACE type can bitrate 500000 listen-only off restart-ms 200 up /sbin/ifconfig $IFACE up down /sbin/ifconfig $IFACE down auto can1 iface can1 inet manual pre-up ip link set $IFACE type can bitrate 500000 listen-only off restart-ms 200 up /sbin/ifconfig $IFACE up down /sbin/ifconfig $IFACE down
Software
sudo apt install can-utils
die CAN-Utils installieren.
Wenn auch die Gateway Funktion genutzt werden soll muss auch das Modul can-gw geladen werden. (s.u.)
Und für CAN-ISO TP ist ein weiteres Kernelmodul erforderlich:
can-isotp
can-isotp - Python3
CAN-ISO-TP Installation
Achtung: Ab Kernel-Version V5.10 ist dies nicht mehr da notwendig, da dieses Modul dann standardmäßig enthalten ist
ISO-TP is part of Linux Mainline kernel since Linux 5.10
Erstmal die Kernel-header installieren:
sudo apt-get install build-essential raspberrypi-kernel-headers sudo reboot
ISO-TP Installation siehe link oben.
Optional kann nun das Kernelmodul mit:
sudo make modules_install
installiert werden. Wenn das CAN-Raw - Modul schon geladen ist (modprobe can) kann das ISO-TP-Modul mit
sudo insmod ./net/can/can-isotp.ko
geladen werden. Wenn oben das Modul (modules_install) installiert wurde, ist dies nicht mehr erforderlich, es wird dann automatisch beim Öffnen des Sockets geladen.
Besser ist wohl das man es im Modul /etc/modules: einträgt, damit es beim booten schon geladen wird
.. can-gw can-isotp
Hier nun in Kurzform alle Anweisungen:
git clone https://github.com/hartkopp/can-isotp.git cd can-isotp/ make sudo make modules_install sudo insmod ./net/can/can-isotp.ko sudo reboot # zum test ob es nach dem booten automatisch geladen wird isotpsniffer -s 200 -d 202 can0 # falls nicht, komm hier dann: socket: Protocol not supported isotpdump -s 0x200 -d 0x300 can0 # sollte jetzt funktionieren, hier kommt keine Fehlermeldung
Hinweis: Wenn nach einem Raspi-Update das Modul beim Test mit modprobe:
modprobe: FATAL: Module can-isotp not found in directory /lib/modules/4.14.98-v7+
nicht gefunden wird muss das Modul an dir richtige Stellte kopiert werden (das erneute compilieren mit den aktuellen Headern nicht vergessen) und
cd /lib/modules/4.14.98-v7+/ #Pfad von der aktuellen Version sudo cp -r /lib/modules/4.14.79-v7+/extra/ . #Das Modul von der alten Stelle kopieren inkl. Ordner cd extra/net/can/ cp ~/dev/can-isotp/net/can/can-isotp.ko . #die neu compalierte Version kopieren sudo depmode -a sudo modprobe can-isotp
ausgeführt werden, dann sollte es wieder gehen. Ich habe keine Ahnung warum ein erneutes compilieren und ein sudo make modules_install nicht funktioniert hatte. Somit blieb mir als einzige Lösung compilieren und die Moduldatei von Hand kopieren. Zumoindest geht jetzt wieder alles beim booten.
Nachtrag
Nach einem erneuten update hat es diesmal geklappt mit dem Kompilieren. Nach eiem Kernel Update sollte man erst einen Neustart machen damit beim Ausführen von make die neuen Header gefunden werden:
# can-isotp neu compilieren cd ~/dev/can-isotp/ make sudo make modules_install sudo depmod -a sudo modprobe can-isotp isotpsniffer -s 200 -d 202 can0
Linux J1939
CAN-Gateway
Ab Linux Kernel 3.2
Hiermit können Pakete zwischen den Schnittstelleln gerouted und manipuliert werden.
Wichtige Hinweise:
- Tritt bei der Ausführung des Befehls: „sudo cangw -A -s vcan0 -d vcan1 -e“ folgende Fehlermeldung auf:
netlink error -95 (Operation not supported)
Ist wahrscheinlich das Kernelmodul can-gw nicht geladen. Abhilfe, das can-gw Modul mit
sudo modprobe can-gw
laden.
Bzw. in /etc/modules eintragen, damit es beim Booten automatisch gestartet wird.
Kurzer Funktionstest mit den virtuellen CAN-Schnittstellen:
sudo ip link add dev vcan0 type vcan sudo ip link add dev vcan1 type vcan sudo ip link set up vcan0 sudo ip link set up vcan1 cangen vcan0 & sudo cangw -A -s vcan0 -d vcan1 -e cansniffer vcan1
Hier werden auf vcan0 CAN-Botschaften generiert, die die dann 1:1 auf vcan1 geroutet werden.
Die Option -e bedeutet Echo, somit würde diese Botschaft bei candump oder cansniffer auch angezeigt werden.
Möchte man jetzt in beide Richtungen routen, muss man mindestens 2 Regeln hinzufügen:
sudo cangw -A -s vcan0 -d vcan1 -e sudo cangw -A -s vcan1 -d vcan0 -e
Hier noch ein Beispiel um alle Botschaften bis auf 0x1B8 unmodifiziert von can0 nach can1 durchzulassen
D1 wird genullt, D0,D2,D3 werden nicht geändert:
sudo cangw -A can0 -f 1B8~C00007FF -d can1 sudo cangw -A -s can0 -d can1 -f 1B8:C00007FF -m AND:D:1B8.4.FF00FFFF4455667788 -m OR:D:1B8.4.0022000000000000
Socket CAN-Gateway cangw
Paper zu cangw - Leistungsanalyse
cangw - demo
http://www.embeddedpi.com/documentation/isolated-canbus/mypi-industrial-raspberry-pi-can-bus-card-configuration
CAN Logging
Hier noch ein paar Beispiele (Tipps) zu den diversen Tools
candump
candump -ta vcan0 # mit Zeitstempel absolute -td=delta, usw... candump -ta -a vcan0 # mit Zeitstempel und ASCII-Anzeige candump -L vcan0 # Verwendet für die Anzeige wie es beim Logfile abgespeichert wird candump -l vcan0 # CAN-Frames in Dateispeichern (dieses File kann mit log2asc in das lesbare Format konvertiert werden.) candump -l any # alle CAN Interfaces loggen candump -L can0 |log2long can0 # inkl. Konvertierung zu Long und ASCII candump -L can0 |log2asc can0 Aus Dump-File nur bestimmte IDs anzeigen: cat can.log | log2long can0 | egrep ' 020 | 02F ' candump -cae can0,0:0,#FFFFFFFF # alle IDs und Error Frames , ASCII, farblich Interface markieren Auszug von candump -h: Examples: candump -c -c -ta can0,123:7FF,400:700,#000000FF can2,400~7F0 can3 can8 candump -l any,0~0,#FFFFFFFF (log only error frames but no(!) data frames) candump -l any,0:0,#FFFFFFFF (log error frames and also all data frames) candump vcan2,92345678:DFFFFFFF (match only for extended CAN ID 12345678) candump vcan2,123:7FF (matches CAN ID 123 - including EFF and RTR frames) candump vcan2,123:C00007FF (matches CAN ID 123 - only SFF and non-RTR frames) Alle IDs bis auf 0x122 und 0x2FA aufzeichnen: candump can0,122~7FF,j,2fa~7FF,j Alle VW-Digagnose IDs >0x700 , ausser die 0x700 Broadcast ID: candump -ta -a can0,700~7FF,j,700:700
cansniffer
cansniffer -c -l1 -t0 vcan0 # Zeigt alle empfangene IDs statisch an,farbliche Änderungen # Timout = off , alle Ids bleiben dargestellt cansniffer -c -l1 vcan0 # besster geeignet wenn Events gesucht werden da statische IDs ausgeblendet werden.
Filter können im interaktiven Modus bzw. in der Kommandozeile angegeben werden
- Interaktive (Eingabe wird mit Enter abgeschlossen
- 200..2ff anzeigen ⇒ '+200700' (ID/Mask)
- 233 anzeigen ⇒ '+233' (nur ID)
- alle ausblenden ⇒ '-000000'
Auch das setzen von interaktiven Filter/Mask im ist sehr brauchbar. Hier ein paar Tipps:
- -000000[CR] löscht alle IDs, da diese Maske auf alle IDs passt # [CR] Return TAste
- +000700[CR] alle IDs von 00..FF anzzeigen
- +100700[CR] alle IDs von 100.1FF anzeigen
- +3407f0[CR] alle IDs von 340..34F anzeigen.
sinvolle Masken sind:
- 700 ⇒ 0x100 Bereich anzeigen
- 7F0 ⇒ 0xF Bereich anzeigen
- 7F8 ⇒ 0x8 Bereiche anzeigen
- 7FC ⇒ 0x4 Bereiche anzeigen (z.B. +3407FC[CR] alles von 0x340.. 0x343 )
Für die Masken empfiehlt es sich mal can.h anzuschauen (wegen den ID-Bits von Bit31-29). Auszug:
/* special address description flags for the CAN_ID */ #define CAN_EFF_FLAG 0x80000000U /* EFF/SFF is set in the MSB */ #define CAN_RTR_FLAG 0x40000000U /* remote transmission request */ #define CAN_ERR_FLAG 0x20000000U /* error message frame */ /* valid bits in CAN ID for frame formats */ #define CAN_SFF_MASK 0x000007FFU /* standard frame format (SFF) */ #define CAN_EFF_MASK 0x1FFFFFFFU /* extended frame format (EFF) */ #define CAN_ERR_MASK 0x1FFFFFFFU /* omit EFF, RTR, ERR flags */ /* * Controller Area Network Identifier structure * * bit 0-28 : CAN identifier (11/29 bit) * bit 29 : error message frame flag (0 = data frame, 1 = error message) * bit 30 : remote transmission request flag (1 = rtr frame) * bit 31 : frame format flag (0 = standard 11 bit, 1 = extended 29 bit) */
Für CAN-FD gibt es eine neue Struktur mit einem zusätzlichen „flags“-Feld:
#define CANFD_BRS 0x01 /* bit rate switch (second bitrate for payload data) */ #define CANFD_ESI 0x02 /* error state indicator of the transmitting node */ struct canfd_frame { canid_t can_id; /* 32 bit CAN_ID + EFF/RTR/ERR flags */ __u8 len; /* frame payload length in byte (0 .. 64) */ __u8 flags; /* additional flags for CAN FD */ __u8 __res0; /* reserved / padding */ __u8 __res1; /* reserved / padding */ __u8 data[64] __attribute__((aligned(8))); };
Wobei nur das BRS (Bitrate Switch für die Daten) für den User eine Rolle spielt. (cansend)
Da das ESI -Bit nur intern bei Transmit fehler generiert wird
canqv
CAN-Sniffer Ersatz für extended IDs
- canqv - einfacher CAN-Sniffer für Extended IDs
cangw
Grundsätzlicher Aufbau von cangw:
sudo cangw -A -s vcan0 -d vcan1 -e -f 244:C00007FF -m SET:ILD:333.4.1122334455667788
-m SET|AND|XOR|OR - gibt die Operation an
Dann kommt die Angabe was geändert werden soll:
- I - CAN-ID
- L - DLC
- D - Daten (Achtung es müssen immer alle 8 Datenbytes angebenen werden auch wenn DLC < 8 ist.
Hier jetzt noch ein paar Beispiele (Option -e wird hier nur wegen vcan verwendet):
- alles bis auf eine ID 1:1 routen und eine ID manipulieren
sudo cangw -A -s vcan0 -d vcan1 -e -f 244~244 ??? alles außer 244 ??? routen , Hmm oder müsste es -f 244~7FF heissen sudo cangw -A -s vcan0 -d vcan1 -e -f 244:C00007FF -m AND:D:244.8.FFFFFFFF00667788 // D4=0, D0..3 nicht ändern
- jetzt nur D3 filtern (nullen):
sudo cangw -A -s vcan0 -d vcan1 -e -f 244:C00007FF -m AND:D:244.5.11223300FF667788
sudo cangw -A -s can0 -d can1 -f 380:7F0 # nur IDs von 380 - 38F auf CAN1 routen sudo cangw -D -s can0 -d can1 -f 380:7F0 # obige Route wieder löschen
canplayer
canplayer -v -I candump-2019-01-16_193032.log can0=can0 can0=vcan1 # alle Botschaften von can0 und vcan1 auf can0 abspielen canplayer -v -I candump-2019-01-16_193032.log can0=can0 # alle can0 Botschaften aus dem Log auf can0 abspielen egrep -v "12d#" candump-2019-01-16_193032.log | canplayer can0=can0 # Alle IDs ausser 0x12D aus dem Log-File abspielen egrep "12d#" candump-2019-01-16_193032.log | canplayer can0=can0 # Nur die ID 0x12D aus dem Log-File abspielen egrep "(133#|401#)" acc_rev.log |canplayer # Nur die IDs 0x133 u. 0x401 aus dem Logfile abspielen
Links
Dual CAN Card Konfiguration
DUAL CAN Modul
Linux Kernel - Network CAN
Automobile-Hacking-Part-1-The-CAN-Protocol
Automobile-Hacking-Part-2-The-can-utils-or-SocketCAN
Automobile-Hacking-Part-3-Metasploit-for-Car-Hacking
Wiki Pi CAN-Bus
http://www.embeddedpi.com/documentation/isolated-canbus/mypi-industrial-raspberry-pi-can-bus-card-configuration
Sonstiges
building-a-car-hacking-development-workbench-part-1
building-a-car-hacking-development-workbench-part-2
building-a-car-hacking-development-workbench-part-3
Tripple PI CAN
SPI1 Raspi
Im Prinzip müsste dies auch möglich sein, wenn man noch den SPI1 aktiviert (ab Kernel 4.4):
- enabeling SPI1 - aus dem Raspi-Forum
- spi1 usable? - Beschreibt wie man den SPI1 aktivieren kann
SPI1 (available only on 40-pins P1 header) SPI Function Header Pin Broadcom Pin Name Broadcom Pin Function MOSI P1-38 GPIO20 SPI1_MOSI MISO P1-35 GPIO19 SPI1_MISO SCLK P1-40 GPIO21 SPI1_SCLK CE0 P1-12 GPIO18 SPI1_CE0_N CE1 P1-11 GPIO17 SPI1_CE1_N CE2 P1-36 GPIO16 SPI1_CE2_N
Caring Caribou
A friendly car security exploration tool for the CAN bus
Sobald unter Linux CAN funktioniert ist dies eine brauchbare Toolsammlung zum „Erforschen“ des CAN-Buses, besonders in Fahrzeugen. Caring_Caribou:Caring
Pi HAT - Module
HAT = Hardware Attached on Top
Ein HAT ist ein Zusatzboard für den B+ (40 poliger Buchsenleiste) welches bestimmten Regeln entspricht, die den Benutzern die Anwendung erleichtern.
Ein wesentliches Merkmal von HATs ist die Einbeziehung eines Systems, mit dem das B + einen verbundenen HAT identifizieren und die GPIOs und Treiber für die Karte automatisch konfigurieren kann, was dem Endbenutzer das Leben erheblich erleichtert!
Die automatische Konfiguration erfolgt über zwei dedizierte Pins (ID_SD und ID_SC) am 40 poligen GPIO-Header, die für ein I2C-EEPROM reserviert sind.
Hinweis: Die ersten 26 Pins des B + GPIO-Headers sind mit denen der Originalmodelle identisch, sodass die meisten vorhandenen Boards weiterhin funktionieren.
HAT ID EEPROM
Hier ist meine Kurzfassung von dem unten angegeben Link!
Achtung das hier sind erst mal Notizen von meinen Versuche mit HAT
file.tgz| Binaries für das EEPROM
Um eineigenes EEPROM einzurichten muss als erstes der Vidoecore I2C-Bus aktiviert werden. Dazu in der /boot/config.txt den folgenden Eintrag setzen:
dtparam=i2c_vc=on
und den einen Reboot durchführen.
Mit den I2C-Tools kann man einen Scann durchführen, um zu sehen ob das EEPROM an der Adresse 0x50 erkannt wird:
i2cdetect -y 0
Beim Booten und Schreibschutz aufgehoben, bekan ich folgende Meldungen:
[ 2.744779] i2c /dev entries driver [ 1068.367818] i2c i2c-0: new_device: Instantiated device 24c32 at 0x50 [ 1085.136703] i2c i2c-0: delete_device: Deleting device 24c32 at 0x50
Nun müssen noch die EEPROM Tools (DeviceTree Compiler) eingerichtet werden, dazu folgende Schritte durchführen:
(wobei auch: sudo apt-get install device-tree-compiler funktionieren müsste)
git clone https://github.com/raspberrypi/hats.git wget -c https://raw.githubusercontent.com/RobertCNelson/tools/master/pkgs/dtc.sh chmod +x dtc.sh ./dtc.sh
Nun in das EEPROM-Utils Verszichnis wechseln:
cd hat/eepromutils
Zuerst muss die eeprom_settings.txt angepasst werden, um ein eigenes HAT Board anzulegen. Die UUID darf nicht geändert werden, da diese automatisch generiert wird.
######################################################################## # EEPROM settings text file # # Edit this file for your particular board and run through eepmake tool, # then use eepflash tool to write to attached HAT ID EEPROM # # Tools available: # eepmake Parses EEPROM text file and creates binary .eep file # eepdump Dumps a binary .eep file as human readable text (for debug) # eepflash Write or read .eep binary image to/from HAT EEPROM # ######################################################################## ######################################################################## # Vendor info # 128 bit UUID. If left at zero eepmake tool will auto-generate # RFC 4122 compliant UUID product_uuid 00000000-0000-0000-0000-000000000000 # 16 bit product id product_id 0x0001 # 16 bit product version product_ver 0x0002 # ASCII vendor string (max 255 characters) vendor "Geier99" # ASCII product string (max 255 characters) product "PiCAN Duoboard" ######################################################################## # GPIO bank settings, set to nonzero to change from the default. # NOTE these setting can only be set per BANK, uncommenting any of # these will force the bank to use the custom setting. # drive strength, 0=default, 1-8=2,4,6,8,10,12,14,16mA, 9-15=reserved gpio_drive 0 # 0=default, 1=slew rate limiting, 2=no slew limiting, 3=reserved gpio_slew 0 # 0=default, 1=hysteresis disabled, 2=hysteresis enabled, 3=reserved gpio_hysteresis 0 # If board back-powers Pi via 5V GPIO header pins: # 0 = board does not back-power # 1 = board back-powers and can supply the Pi with a minimum of 1.3A # 2 = board back-powers and can supply the Pi with a minimum of 2A # 3 = reserved # If back_power=2 then USB high current mode will be automatically # enabled on the Pi back_power 0 ######################################################################## # GPIO pins, uncomment for GPIOs used on board # Options for FUNCTION: INPUT, OUTPUT, ALT0-ALT5 # Options for PULL: DEFAULT, UP, DOWN, NONE # NB GPIO0 and GPIO1 are reserved for ID EEPROM so cannot be set # GPIO FUNCTION PULL # ---- -------- ---- #setgpio 2 INPUT DEFAULT #setgpio 3 INPUT DEFAULT #setgpio 4 INPUT DEFAULT #setgpio 5 INPUT DEFAULT #setgpio 6 INPUT DEFAULT #setgpio 7 INPUT DEFAULT #setgpio 8 INPUT DEFAULT #setgpio 9 INPUT DEFAULT #setgpio 10 INPUT DEFAULT #setgpio 11 INPUT DEFAULT #setgpio 12 INPUT DEFAULT #setgpio 13 INPUT DEFAULT #setgpio 14 INPUT DEFAULT #setgpio 15 INPUT DEFAULT #setgpio 16 INPUT DEFAULT #setgpio 17 INTPUT DEFAULT setgpio 18 OUTPUT DEFAULT #setgpio 19 INPUT DEFAULT #setgpio 20 INPUT DEFAULT #setgpio 21 INPUT DEFAULT #setgpio 22 INPUT DEFAULT #setgpio 23 INPUT DEFAULT #setgpio 24 INPUT DEFAULT #setgpio 25 INPUT DEFAULT #setgpio 26 INPUT DEFAULT #setgpio 27 INPUT DEFAULT
Nun mit make die eeprom Toolls erstellen
cd hats/eepromutils/ make
Mit
./eepmake eeprom_settings.txt myhat.eep Opening file eeprom_settings.txt for read UUID=c488f0d4-e47e-45db-9802-5a27aacb04fe Done reading Writing out... Done.
wird jetzt die EEPROM-Datei (Binary) erstellt.
Wenn man sich an die Empfehlung gehalten hat, ein 4K-EEPROM zu verwenden, kann man die folgende Befehle direkt verwenden.
Eine gute Idee ist immer das EEPROM mal zu löschen (0x00)
dd if=/dev/zero ibs=1k count=4 of=blank.eep
erzeugt ein leere EEPROM-Datei. Bei anderen EEPROM größen muss „count“ angepasst werden.
Mit hexdump kann man sich die Datei anschauen.
Nun kann die Datei ins EEPROM geschrieben werden:
sudo ./eepflash.sh -w -f=blank.eep -t=24c32 This will attempt to talk to an eeprom at i2c address 0xNOT_SET on bus NOT_SET. Make sure there is an eeprom at this address. This script comes with ABSOLUTELY no warranty. Continue only if you know what you are doing. Do you wish to continue? (yes/no): yes Writing... 4096 Bytes (4,1 kB, 4,0 KiB) kopiert, 16,7481 s, 0,2 kB/s 8+0 Datensätze ein 8+0 Datensätze aus 4096 Bytes (4,1 kB, 4,0 KiB) kopiert, 16,7483 s, 0,2 kB/s Closing EEPROM Device. Done.
Eventuell noch mit den Optionen -d=0 -a=50 die Adresse des EEPROM angeben, hat bei mir aber auch so funktioniert.
Aber nicht vergessen, bevor der Schreibvorgang bestätigt wird den Jumper zum Aufheben des EEPROM Schreibschutzes zu setzen.
Wenn alles erfolgreich war kann das EEPROM ausgelesen werden mit (geht aber nur wenn es vorher beschrieben wurde):
sudo hexdump /sys/class/i2c-adapter/i2c-0/0-0050/eeprom
Da bei mir das nicht geklappt hat (es existierte kein „0-0050“-Ordner), es wurde kein EEPROM unter sys/class/i2c-adapter/… angelegt konnte ich das EEPRM mit den Standard i2C-Tools auslesen. (Protokoll Standard tools)
(Hmm, bin mir nicht sicher ob das wirklich funktioniert hat)
Nun sollte man lauter 0x00 sehen! Wenn alles geklappt hat, kann man jetzt das oben erzeugte eigenen EEPROM-Datei in das EEPROM schreiben:
sudo ./eepflash.sh -w -f=myhat.eep -t=24c32 This will attempt to talk to an eeprom at i2c address 0xNOT_SET on bus NOT_SET. Make sure there is an eeprom at this address. This script comes with ABSOLUTELY no warranty. Continue only if you know what you are doing. Do you wish to continue? (yes/no): yes Writing... 0+1 Datensätze ein 0+1 Datensätze aus 105 Bytes kopiert, 0,426529 s, 0,2 kB/s Closing EEPROM Device. Done.
Und dieses dann wieder mit dem hexdump auslesen und kontrollieren.
Und nicht vergessen den Jumper für den Schreibschutz zu entfernen.
Nun den Raspberry rebooten und schauen ob das HAT-Board erkannt wurde:
cd /proc/device-tree/hat/ more vendor more product
Hier sollten jetzt die Daten aus dem EEPROM stehen, falls ja - Gratulation!
- Overlays Readme - aktuelle Verson der Readme
Device Tree / Overlay
Nun geht mit dem Device Tree um eine automatsiche Konfiguration einzurichten, zurerst mal nur die LED einzuschalten. Dazu wieder in das eepromutils Verzeichnis wechseln.
Test GPIO 18 blinken
Zum der Autokonfiguration die GPIO18 blinken lassen (heartbeat). Dazu die Datei myled.dts:
/dts-v1/; /plugin/; / { compatible = "brcm,bcm2708"; fragment@0 { target = <&leds>; __overlay__ { my_led: myled { label = "MYLED"; gpios = <&gpio 18 0>; linux,default-trigger = "heartbeat"; }; }; }; };
anlegen. Und mit dem dtc Compiler kompilieren:
sudo dtc -@ -I dts -O dtb -o myled.dtb myled.dts ; sudo chown pi:pi myled.dtb
Zum Test könnte man diesen DTB als Overlay (dtoverlay= ) in der /boot/config.txt laden. Ich möchte aber die Kernel Autokonfiguration aus dem EEPROM testen. Nun kann mit
./eepmake eeprom_settings.txt myhat-with-dt.eep myled.dtb
eine neue EEPROM Datei erstellt werden welche die Board-Konfiguration und Devicetree-Konfiguration enthält. Und nun zum Testen das EEPROM neubeschreiben (inkl. EEPROM vorher löschen) und einen Neustart durchführen, dann sollte die LED wie ein „Herzschlag“ blinken.
sudo ./eepflash.sh -w -f=blank.eep -t=24c32 sudo ./eepflash.sh -w -f=myhat-with-dt.eep -t=24c32 sudo reboot
Hinweis: Man kann auch noch ein Benutzer-Konfiguration mit ins EEPROM packen (aucht maximale 4k vom EEPROM nicht überschreiten) welches man dann parsen kann.
./eepmake eeprom_settings.txt myhat-with-dt.eep myled.dtb -c myparams.json
Links
- RasPi-BplusHat.zip - 2 Vorlagen für Eagle
- RasPi-BplusHAT.sch -
- RasPi-BplusHAT_CamSlot.sch -
Device-Tree
- 2-Channel-CAN-BUS-FD-Shield-for-Raspberry-Pi - könnte als Vorlage dienen, erst aber mal PiCAN Duo anpassen dann PiCAN-FD Duo probieren
- 2 Kanal CAN-FD HAT - CAN-FD Hat aus China (inkl. Software)
- GPIOs - Ein paar Infos über die Konfiguration von GPIOs im Device-Tree
-
EEPROM Tools für Raspi
GPIOs
Zum Ansteuern am besten wiringPi nehmen:
- Pi GIPO How-To
Hinweis -g um die GPIO-Belegung vom zu nehmen.root@raspberrypi:/home/pi# gpio export 4 out root@raspberrypi:/home/pi# gpio -g write 4 1
mit
raspi-gpio get 5 raspi-gpio set 18 dh # setzt den Pin High (Ausgang muss nicht konfiguriert werden, dies hat das EERPOM übernommen :-))
erhält man den Zustand des Pins und Informationen über die Konfiguration des Pins. (hat nichts mit dem wiringPi Modul zu tun)
Übersicht der Pinzuordnugnen im Vergleich Raspi,wiringPi, usw. (wiringPi command):
gpio readall
bzw. mit
pinout
die aktuellen Beleugn anzeigen lassen.
Hier noch eine Lösung wenn man Pins beim Booten einschalten will:
Das direkte Ansteuern mit dem Device Tree geht wohl nicht, deshalb könnte man obiges verwenden.
I2C - Raspi
Einrichtung:
- I2C-Dev Interface - allgemeiner Zugriff auf das i2C Dev Interface (in C)
Python CAN
Python UDSONCAN
Es wird Python > 3.0 benötigt. Sollte auch Python-CAN verwendet werden nicht Python 3.7 installieren wegender fehlenden SQL-Lite Unterstützung
- Python UDSONCAN - Github Repository
CAN Dump in Rx-Liste
Hier ein kleines Beispielskript um aus einem CAN-Raw-Dump (.log-Format) eine Rx-Liste zu generieren:
Skript: dump2rxliste.awk (Achtung: hier fehlt noch die unten aufgeführte Modifikation für CAN-FD)
gawk -f dump2RxListe.awk inhouse/A-Klasse_W177/movement_touch.log
Hinweis: Unter Raspberry Pi hatte der awk nicht funktioniert, deshalb wird jetzt beim Pi der gawk genommen.
dump2RxListe.awk:
BEGIN { print "Konvertiere CAN-RAW Dump zur sortierte RX-Liste \n\nStart RX-Liste ", strftime("%d.%m.%Y", systime()),"\n------------------------------------------------"} $3 ~ /([0-9A-F]){3,8}/ { gsub(/##/, "#"); # modifziert für CAN-FD 12.09.2024 by geier99, oder weglassen, dann bleiben die Datenbytes leer aber die ID wird gezaehlt split($3, arr, "#") anzahl[arr[1]]+=1; message[arr[1]] = sprintf("%08s %-18s ", arr[1], arr[2]); } END { # unsortiert ausgeben deaktiviert # for (id in anzahl) { # print message[id], " (", anzahl[id], ")"; # } # print "------------------------------------------------\nEnde Rx-Liste" #sortiert ausgeben # print strftime("%d/%m/%Y", systime()); n=asorti(message,sorted); for(i=1;i<=n;i++) { print message[sorted[i]] ," (", anzahl[sorted[i]], ")" ; } print "------------------------------------------------\nEnde Rx-Liste\n\nAnzahl CAN-IDs = ",n; }
Will man das AWK-Skript direkt aufrufen so müssen die Dateirechte auf 755 gesetzt werden und in die erste Zeile des Skriptes muss folgnedes eingetragen werden:
#!/usr/bin/gawk -f
Somit würde sich der obige Aufruf folgendermassen verkürzen:
./dump2RxListe.awk A-Klasse_W177/movement_touch.log
Noch einfacher wird es, wenn man folgnedes Skript („makeRxList“) unter /usr/lokal/bin ablegt:
pi@raspberrypi4:~ $ cat /usr/local/bin/makeRxList #!/bin/bash #tr -d '\r' < $1 > $1_tmp gawk -f ~/dev/dump2RxListe.awk $1 #gawk -f ~/dev/dump2RxListe.awk $1_tmp #rm $1_tmp
Hier bei nicht vergessen das awk-Skript unter ~/dev abzulegen. Damit verinfacht sich der Aufruf dann zu:
makeRxList A-Klasse_W177/movement_touch.log
TRC2LOG Konverter
CANHacker Tracefiles mittels awk Skript in das Linux Logformat konvertieren.
- trc2log.txt - 1. Prototyp des Konvertes (STD und EXT IDs funktionieren)
- trc2log.awk - 2. Prototype kleine Änderung wergen log2asc unter Windows
Aufbau TRC-File:
Time ID DLC Data Comment 03,530 3DC 8 FC 00 00 00 00 01 00 00 Hier können Kommentare stehen 03,530 1B000010 8 10 00 04 02 10 00 00 00 kommtea
Die Zeitangabe kann mit '.' oder ',' vorkommen, beides wird akzeptiert. Und die Kommentare werden verworfen.
Beispiel (cygwin64):
awk -f trc2log.txt logfile.trc >logfile.log
Hinweise:
- der Header und Footer muss dann in der Datei von Hand entfernt werden. Für die weitere Konvertierung mit log2asc ist dies nicht notwendig
- Funktionert auch mit dem Raspberry Pi mit awk, da keine sort-Funktion verwendet wird.
Eventuell gibt es später noch einen Konverter in das ASC-Logformat. Hierfür kann vorerst dann der log2asc Konverter von den can-utils genommen werden um aus dem Log-Format dann das ASC-Format zu erzeugen.
TRC zu ASC Konverter (auf Windows Rechner)
Update : Hierzu am besten meinen neuen Konverter (s.u.) verwenden: TRC2-ASC.exe - Windows Version verwenden.
Hierzu wird das obige Skript (Konverter in das log-Format):
trc2log.awk
und mein nach Windows portierter „log2asc“ Konverter:
log2asc.exe
verwendet. Der Hintergrund ist, das man Logfiles im ASC-Foramt in VSP3 importieren kann.
Unter Windows (wegen dem awk-Skript z.B. cygwin verwenden) geschieht dies nun mit einer einzigen Befehlszeile (Wobei log2asc.exe auch direkt unter Windows läuft).
./trc2log.awk KIA.trc | ~/cantrace/log2asc.exe can0 -O KIA.asc # Einzeiler oder: ./trc2log.awk KIA.trc > KIA.log ~/cantrace/log2asc.exe -I KIA.trc -O KIA.asc can0 # Zweizeiler weitere Beispiele: ./trc2log.awk meinTrace.trc | ~/cantrace/log2asc.exe can0 # nur Ausgabe ./trc2log.awk meinTrace.trc | ~/cantrace/log2asc.exe can0 -O meinTrace.asc # Ausgabe in Datei
Und mit diesem Bash-Skript lässt sich der Aufruf von oben vereinfachen:
- can2asc - Bash-Skript um den Aufruf von oben zu vereinfachen
can2asc tracefile (ohne .trc) oder can2asc tracefile ascfile (jeweils ohne .trc und .asc)
Log2Long
Und hier noch der für Cygwin konvertierter log2long - Konverter aus den CAN-Utils:
- log2long.exe - Windows Variante
Beispiel aus dem MS-DOS Befehlsfenster:
type kuga_2008.log |log2long (1572297281.267871) can0 212 [8] F8 00 28 80 01 00 00 00 '..(.....' (1572297281.272799) can0 460 [8] 00 10 00 00 00 00 00 00 '........' (1572297281.273849) can0 203 [8] 00 00 00 00 00 00 00 00 '........' (1572297281.274528) can0 023 [1] 40 '@' (1572297281.275267) can0 210 [2] 40 24 '@$' (1572297281.275881) can0 265 [3] 00 10 00 '...' (1572297281.276561) can0 275 [3] A0 00 FF '...' (1572297281.277756) can0 433 [8] 00 00 FA 01 00 A0 00 00 '........'
CANHacker TRC2ASC Konverter
Hier noch mein eigener Konverter welcher auf dem Quellcode von LOG2ASC aus den CAN-Utils basiert:
trc2asc.exe - Windows Version
Der Zeitüberlauf vom CANHacker (0…59s und von meinem Logger 0…99s) wird berücksichtigt und korrigiert. Als Zeitbasis wird dann der Startzeitpunkt der Konvertierung genommen.
Somit entfällt der Umweg über das oben aufgeführte AWK-Skript.
Hinweis:
- Remote Frames werden vom CANHacker nur bei einem DLC von 0 korrekt erkannt und somit auch nur diese korrekt konvertiert.
- Beim Aufruf muss immer can0 als Interface angegeben werden, da der Konverter beim Einlesen des Tracefiles fest can0 zuordnet.
Cygwin Terminal: ./trc2asc.exe -I testlogs/KIA.trc can0 -O testlogs/KIA.asc oder nur die Ausgabe auf der Konsole ausgeben: ./trc2asc.exe -I testlogs/KIA.trc can0 date Wed Jul 24 14:53:02 2019 base hex timestamps absolute no internal events logged 0.000000 1 455 Rx d 8 55 01 00 00 00 00 FF FF 0.049000 1 448 Rx d 8 48 01 00 00 00 00 FF FF 0.078000 1 44D Rx d 8 4D 01 00 00 00 00 00 00 0.100000 1 455 Rx d 8 48 02 00 00 00 00 FF FF 0.145000 1 15 Rx d 4 39 39 A4 32 0.159000 1 244 Rx r 0.198000 1 2324223x Rx d 8 AA BB 00 00 00 00 00 00 0.245000 1 15 Rx d 4 39 39 A4 32 0.333000 1 333 Rx d 8 00 00 FF FF FF 3F 00 FF oder MS-DOS Fenster: C:\cygwin64\home\geier99\prog_trc2asc>trc2asc.exe -I testlogs\test1.trc can0
Die konvertierte Datei lässt sich dann prima Vehicle Spy3 abspielen und analysieren.
Hinweis:
mit trc2asc | asc2log kann man einen Can-Hacker-Trace auch direkt in das Log-Format konvertieren.
Bzw. folgendes Skript trc2log unter /usr/local/bin ablegen:
pi@raspberrypi4:~/canlogger/ $ cat /usr/local/bin/trc2log #!/bin/bash trc2asc -I $1 can0 |asc2log
Der Aufruf zum konvertieren eines TRC-Files zu Log-File erfolgt dann mit:
trc2log myLogfile.trc
PEAK -TRC-Files
Peak Trace Files haben ein anderes Format und können mit dem Tool:
peak-converter.zip
in das ASC-Format konvertiert werden.
Tracekonverter (BLF <--> ASC)
can_trace_converter - BLF ←→ ASC CAN-Trace Konverter
ASC Logformat
Hmm oder direkt einen Konverter für das ASC Format machen:
date Mon Jul 8 22:24:25 2019 base hex timestamps absolute no internal events logged 0.000000 1 1B000073x Rx d 8 73 00 01 01 0D 00 12 00 0.003000 1 474 Rx d 8 00 28 05 00 00 00 00 00 0.033000 1 3C0 Rx d 4 FA 09 03 00 0.034000 1 585 Rx d 8 01 3C 00 7F 13 00 00 00 46.079000 1 474 Rx d 8 00 08 05 10 00 00 00 00 46.195000 1 1B000073x Rx d 8 73 00 04 01 08 00 10 00
asc2log Konverter (Python)
Mit dem Python Modul lässt sich ein einfacher ASC→LOG Format Konverter machen der auch CAN-FD konvertiert (was mein eigener Konverter (C Programm) nicht kann)
simple_log_converter.py - einfacher Python Konverter
cat asc2log_new.py #!/usr/bin/python #!/usr/bin/python3 #!/usr/bin/env python """ Use this to convert .can/.asc files to .log files. Can be easily adapted for all sorts of files. Usage: python3 simple_log_convert.py sourceLog.asc targetLog.log """ import sys import can def main(): """The transcoder""" with can.LogReader(sys.argv[1]) as reader: with can.Logger(sys.argv[2]) as writer: for msg in reader: writer.on_message_received(msg) if __name__ == "__main__": main()
- asc2log_new - obiges Python Skript
- asc2logAll - Konvertiert alle ASC-Files in einem Ordner in die entsprechenden Unterorder „log“ und „txt“ welche bei Bedarf erzeugt werden. (die .py ist hier nur wegen dem Wiki angefügt, und sollte wieder entfernt wreden)
Hierfür muss aber das pyhton-can Modul installiert sein:
pip install python-can bzw. wenn es systemweit sein soll, dann mit: sudo apt install python3-can
- python3
- Skript für argparse anpassen!
Hinweis: - asc2log aus den can-utils könnte man auch nehmen können (aber hier geht's ja um Pyhton )
VS-Code auf Pi
Kurzanleitung um einfach den vs-code zu intallieren:
wget https://packagecloud.io/headmelted/codebuilds/gpgkey -O - | sudo apt-key add - curl -L https://code.headmelted.com/installers/apt.sh | sudo bash
VS-Code kann dann über die Menüs oder in der Shell mit:
code-oss
aufgerufen werden.
Quelle: VS-Code PI installieren
obiges ist veraltet! jetzt sollte ein:
sudo apt update sudo apt install code
ausreichen. Der Aufruf erfolgt dann über die grafische Oberfläche oder mit
code .
aus dem aktuellen Ordner.
SD-Karte sichern
Die SD-Karte kann auf einem Linux-PC mit dem dd - Befehl gesichert und wiederhergestellt werden:
sudo fdisk -l # um den Gerätenamen zu ermitteln (z.B. /dev/sdb1 ) #backup mit: sudo dd bs=4M if=/dev/sdb | gzip > /home/your_username/image`date +%d%m%y`.gz #restore mit: sudo gzip -dc /home/your_username/image.gz | dd bs=4M of=/dev/sdb
* eventuell fehlt beim restor ein sudo , todo prüfen
xosview installieren
Installation
sudo apt install xosview falls font fehler beim Starten von xosview auftritt, nochmal: sudo apt install xfonts-base ausführen und rebooten
Autostart
cd ~/.config/ mkdir autostart cd autostart cp /usr/share/applications/xosview.desktop .
Um die Position festzulegen kan beim Aufruf in der Autostartdatei die -geomtry Option gesetzt werden:
Exec=xosview -geometry '-8+36'
JSON Parser
jq
hier mit dem einfachsten Filter „.“ um die komplette Json-Datei anzuzeigen.
jq . file.json # joson file anzeigen