Geiers Wiki

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Zuletzt angesehen: • pi3_tipps
pi3_tipps

Inhaltsverzeichnis

Raspi Info

Welchen Raspi habe ich denn? 

cat /sys/firmware/devicetree/base/model

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

MCP2515 - CAN-Modul

  • 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

  • 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)

  • Python-CAN
  • 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
  • pyobd
  • pyobd-pi
  • SecureGateway Framework (python)
  • Sammlung von CAN-Tools

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.

User Guide
PI-CANDUO-Datasheet

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

  • Linux 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.)

public:can-utils_tipps

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

Linux CAN 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

can.h

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):

  • Enable SPI1
  • 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!

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

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:

Python CAN

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

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:

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
pi3_tipps.txt · Zuletzt geändert: 2024/09/14 07:42 von geier99