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:

Hinweise

MCP2515 - CAN-Modul

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:

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.

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

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:

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

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:

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

Auch das setzen von interaktiven Filter/Mask im ist sehr brauchbar. Hier ein paar Tipps:

sinvolle Masken sind:

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

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:

Hier jetzt noch ein paar Beispiele (Option -e wird hier nur wegen vcan verwendet):

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

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:

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.

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:

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:

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: 

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

Hierfür muss aber das pyhton-can Modul installiert sein:

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