Geiers Wiki

Diese Seite ist nicht editierbar. Du kannst den Quelltext sehen, jedoch nicht verändern. Kontaktiere den Administrator, wenn du glaubst, dass hier ein Fehler vorliegt.
====== Raspi Info ======
Welchen Raspi habe ich denn?
<code>cat /sys/firmware/devicetree/base/model</code>
===== Links =====
  * Bei Bootproblemen: [[https://samx18.io/blog/2017/11/05/piBootIssue.html|Pi Boot Issues]] - how to start a shell in emergence mode.
  * [[https://www.moderndaymods.com/2020/01/26/building-a-canbus-app-part1/|building-a-canbus-app-part1]] - with nodejs \\ Für das Beispiel müssen noch folgende Module im App-Ordner installiert werden:<code>sudo apt install npm
cd App 
npm init
npm install socketcan
npm install express
npm install socket.io
npm install canvas-gauges
</code> nun nicht vergessen die IP-Adressen anzupassen (auch im HTML Ordner)
  * [[https://github.com/sebi2k1/node-can|Node-CAN]]
  * OpenVpn Client für den Raspi: 
    * [[https://jankarres.de/2014/10/raspberry-pi-openvpn-vpn-client-installieren/|Installations Anleitung]]
    * [[https://forum-raspberrypi.de/forum/thread/3528-openvpn-client-einrichten/|Raspi-Forum - OpenVpn Client einrichten]]
  * [[https://www.elektronik-kompendium.de/sites/raspberry-pi/2101201.htm|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. 
  * [[https://pi-buch.info/hdmi-aufloesung-erzwingen/|HDMI Auflösung erzwingen]] - Raspi feste Auflösung für den Monitor
  * [[http://www.netzmafia.de/skripten/hardware/RasPi/RasPi_Network.html|RasPi-Network]]- Raspi Netzwerk Einrichtungen
  * [[https://raspberrytips.com/update-raspberry-pi-latest-version/]] - Raspi updaten
  * [[https://www.pragmaticlinux.com/2021/07/automatically-bring-up-a-socketcan-interface-on-boot/?utm_content=cmp-true]]
  * CAN-Simulator:
    * [[https://github.com/carloop/simulator|simulator]]
    * [[https://github.com/carloop/simulator-program|simulator-program]]


====== Raspi 3 - MCP-2515 - (SPI) CAN Support ======
Anhand meiner [[public:MCP-2515:Raspi-Umbauanleitung|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. <code>dtparam=spi=on

# dtoverlay=mcp2515-can0-overlay,oscillator=20000000,interrupt=25
dtoverlay=mcp2515-can0,oscillator=20000000,interrupt=25
dtoverlay=spi-bcm2835-overlay
</code>
  * CAN-Utils installieren: <code>sudo apt-get install can-utils</code>
  * reboot
  * <code> sudo ip link set can0 up type can bitrate 250000</code>
  * eventuell mit <code>dmesg |grep spi

[   3.627804] mcp251x spi0.0 can0: MCP2515 successfully initialized.
</code> auf Fehlermeldungen kontrollieren oder mal den Netzwerkstatus anschauen <code> ip -s -d link show can0</code>

===== Hinweise =====
{{ :public:mcp-2515:raspi_pi3_modifikation_01.jpg?400|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 : <code>
 cd socketcand/
 socketcand -i can0</code>
Kayak nutzt diesen Socket, somit können auch entfernte Rechner mit Kayak simulatan die CAN-Daten analysieren. Der Connectstring hat dann folgendes Format:<code>can0@192.168.8.105:29536</code>

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**

[[https://github.com/julietkilo/kcd|KCD Projekt]] - Github Projekt. \\ 
[[http://skpang.co.uk/blog/archives/1242|Installing Kayak]]

==== socketcand ====
Für die Installation von socketcand werden noch zusätzliche Pakete benötigt:
<code>
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

</code>
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: <code>
 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

</code>

Die Verbindung kann auch mit Netcat getestet werden:<code>
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
</code>
oder kurzes Pyton skript:
<code>
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
    
</code>

**Starten per Skript ohne Fehlerausgabe**
ohne Fehlerausgabe und beide Gleichzeitig starten:<code>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 &
</code>

==== 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: <code>java -jar CANBabel.jar</code>

Achtung Bug: [[https://stackoverflow.com/questions/20952713/wrong-manifest-mf-in-intellij-idea-created-jar|Bug fehlende Main-Class]] \\ Bei mir hat das kopieren funktioniert, besser wäre wohl den richtigen Pfad zu setzen. \\ {{ :public:canbabel.jar |canbabel.jar}}

==== Kayak auf Raspi ====
Installations-Aneitung für Kayak auf einem Raspi 2  (gilt wohl auch für 3, to do: testen):
  * [[http://skpang.co.uk/blog/archives/1242|Kayak on Raspi 2]]
  




===== Links  =====
  * [[https://copperhilltech.com/pican2-duo-can-bus-board-for-raspberry-pi-2-3/|Dual CAN Raspi]]
  * [[https://www.raspberrypi.org/forums/viewtopic.php?t=141052|tipps can zu pi]]
  * offizielle Doku von SPI von Raspberry \\ [[https://www.raspberrypi.org/documentation/hardware/raspberrypi/spi/README.md| SPI-Readme]]
  * [[https://learn.sparkfun.com/tutorials/raspberry-pi-spi-and-i2c-tutorial/all|Sparkfun- Tutorial SPI and I²C]]

  * [[http://kayak.2codeornot2code.org/|Kayak]] - CAN-Logger auf Netbean Basis für Mac, Linux und Windows\\ 
  * [[https://can4python.readthedocs.io/en/latest|CAN4Python - Dokumentation]]
  * [[https://github.com/sebi2k1/openCanSuite| openCanSuite]]
  * [[http://qcanobserver.sourceforge.net/|QCANObserver]]

  * [[https://github.com/julietkilo/CANBabel|CANBabel]] - CAN Database Converter KDC<-->DBC
  * **[[https://github.com/ebroecker/canmatrix|CAN Matrix]]** - CAN Matrix Convert Libray and Tool, kann viele Formate und stellt folgende Skripte zur Verfügung (Python 2.7):
    * <code>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
</code>
    * <code>Usage:
    cancompare [options] cancompare matrix1 matrix2

    matrixX can be any of *.dbc|*.dbf|*.kcd|*.arxml
</code>
    * hängt noch von folgende Python Module ab die ebenfalls mit pip zu installieren sind: <code>lxml
xlwt
xlrd
xlsxwriter
pyyaml
future</code>Falls die Installation von lxml nicht klappt am besten vorher noch folgendes installieren:<code>
sudo apt-get install python-dev libxml2-dev libxslt1-dev zlib1g-dev</code>Wobei man wohl auf zlib1g-dev verzichten kann.\\ Hinweis: Unter WIN8.1 musste nichts nach installiert werden, hat alles auf Anhieb geklappt. \\ Dokumentation: [[https://canmatrix.readthedocs.io/en/latest/|CANMatrix - Doks (latest)]]

  * [[https://python-can.readthedocs.io/en/master/|Python-CAN]]
  * [[https://github.com/eerimoq/cantools|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).<code>wget https://www.python.org/ftp/python/3.9.4/Python-3.9.4.tar.xz</code> Für das Update wurden noch folgende Pakete benötigt:<code>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</code>
  * [[https://github.com/aheit/cantools.git|cantools]] - cantools is a set of libraries and command line tools for handling ASC, BLF, CLG, VSB, MDF, and DBC 
  * [[https://github.com/peterh/pyobd.git|pyobd]]
  * [[https://github.com/Pbartek/pyobd-pi.git|pyobd-pi]] \\     
  * [[https://sgframework.readthedocs.io/en/latest/readme.html|SecureGateway Framework (python)]]
  * [[https://gist.github.com/jackm/f33d6e3a023bfcc680ec3bfa7076e696|Sammlung von CAN-Tools]]

====== Raspi 2 B ======
Konfiguration von der config.txt: <code>
# 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</code>

Nach Reboot sollte dann folgendes erscheinen:<code>$ 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</code>


====== 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. 

[[https://copperhilltech.com/content/PICAN2DUOUGB.pdf|User Guide]]\\ 
[[http://skpang.co.uk/catalog/images/raspberrypi/pi_2/PICAN2DUODSB.pdf|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.**
<code>
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
</code>
Hinweis: erst can1 dann can0 damit die Reihenfolge von can0 und can1 stimmt 
reboot
Netzwerk aktivieren z.B. mit 500 kBit/s
<code>sudo /sbin/ip link set can0 up type can bitrate 500000
sudo /sbin/ip link set can1 up type can bitrate 500000
</code>
==== Linux Treiber Patch ====
  * [[https://github.com/raspberrypi/linux/issues/2175|Linux Patch]]\\ 
  * [[https://www.raspberrypi.org/forums/viewtopic.php?t=190868| mehr info]]\\ <code>dtoverlay=mcp2515-can0,oscillator=16000000,interrupt=25,spimaxfrequency=500000 </code> 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:<code> sudo ip link set can0  txqueuelen 1000
 sudo ip link set can1  txqueuelen 1000</code>

==== Autostart ====
In **/etc/network/interfaces** können die Interfaces konfiguriert werden, so daß beim Booten z.B. mit 100kBit/s initialisiert werden.
<code>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
</code>
Wenn die Baudrate nun nicht geändert werden soll, können die CAN-Schnittstellen einfach mit **ifdown** und **ifup** ab/eingeschaltet werden:<code>sudo ifdown can0
sudo ifup can0</code>

Status des Interfaces anschauen mit: <code>ip -details -statistics link show can0</code>
Um den Sendbuffer automatisch beim Login zu setzen, kann man folgendes in **~/.profile** eintragen:<code>
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


</code>
==== 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. 
<code>sudo ip link set canX type can restart-ms 200</code>

Einen manuellen Restart kann man mit:<code>
sudo ip link set can0 type can restart-ms 100
sudo ip link set can0 up
</code> durchführen.

Der Restart-Parameter kann auch oben beim Autostart hinzugefügt werden (/etc/network/interfaces)<code>#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
</code>





===== Software =====
<code> sudo apt install can-utils</code> 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|public:can-utils_tipps]]

Und für CAN-ISO TP ist ein weiteres Kernelmodul erforderlich:\\ [[https://github.com/hartkopp/can-isotp|can-isotp]]\\ [[https://pypi.org/project/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**<code>ISO-TP is part of Linux Mainline kernel since Linux 5.10</code>

Erstmal die Kernel-header installieren:
<code>sudo apt-get install build-essential raspberrypi-kernel-headers
sudo reboot</code>

ISO-TP Installation siehe link oben. 

Optional kann nun das Kernelmodul mit:<code>sudo make modules_install</code> installiert werden.
Wenn das CAN-Raw - Modul schon geladen ist (modprobe can) kann das ISO-TP-Modul mit <code> sudo insmod ./net/can/can-isotp.ko</code> 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<code>..
can-gw
can-isotp
</code> 

Hier nun in Kurzform alle Anweisungen: <code>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
</code>
Hinweis: Wenn nach einem Raspi-Update das Modul beim Test mit modprobe:<code>modprobe: FATAL: Module can-isotp not found in directory /lib/modules/4.14.98-v7+</code> nicht gefunden wird muss das Modul an dir richtige Stellte kopiert werden (das erneute compilieren mit den aktuellen Headern nicht vergessen) und <code>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</code> 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: <code>
# 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

</code>
==== Linux J1939 ====
[[https://elinux.org/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: <code>netlink error -95 (Operation not supported)</code>Ist wahrscheinlich das Kernelmodul **can-gw** nicht geladen. Abhilfe, das can-gw Modul mit <code>sudo modprobe can-gw</code>laden.

Bzw. in **/etc/modules** eintragen, damit es beim Booten automatisch gestartet wird.


Kurzer Funktionstest mit den virtuellen CAN-Schnittstellen:<code>
   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

</code>
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:
<code>
sudo cangw -A -s vcan0 -d vcan1 -e
sudo cangw -A -s vcan1 -d vcan0 -e
</code>

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:
<code>
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
</code>


[[https://jansblog.org/2012/01/28/das-socketcan-gateway-cangw/|Socket CAN-Gateway cangw]]\\ 
[[https://static.lwn.net/images/conf/rtlws-2011/proc/Sojka.pdf|Paper zu cangw - Leistungsanalyse]]

[[https://jansblog.org/2012/01/28/das-socketcan-gateway-cangw/|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 ===
<code>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

</code>
=== cansniffer ===
<code>
 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.
</code>

**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 [[https://github.com/torvalds/linux/blob/master/include/uapi/linux/can.h|can.h]] anzuschauen (wegen den ID-Bits von Bit31-29). Auszug:<code>/* 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)
 */
</code>
Für CAN-FD gibt es eine neue Struktur mit einem zusätzlichen "flags"-Feld:
<code>
#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)));
};
</code>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
  * [[https://github.com/kurt-vd/canqv|canqv]] - einfacher CAN-Sniffer für Extended IDs 

=== cangw ===
Grundsätzlicher Aufbau von cangw:<code>
 sudo cangw -A -s vcan0 -d vcan1 -e -f 244:C00007FF -m SET:ILD:333.4.1122334455667788
</code> -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<code>
  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
</code>
  * jetzt nur D3 filtern (nullen): <code>
 sudo cangw -A -s vcan0 -d vcan1 -e -f 244:C00007FF -m AND:D:244.5.11223300FF667788 </code>
  * <code>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</code>

[[https://github.com/torvalds/linux/blob/master/include/uapi/linux/can.h|can.h]]
=== canplayer ===
<code>
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
</code>


===== Links =====
[[http://www.embeddedpi.com/documentation/iso-can-duo/embeddedpo-dual-can-card|Dual CAN Card Konfiguration]]\\ 
[[https://copperhilltech.com/pican2-duo-can-bus-board-for-raspberry-pi-2-3/|DUAL CAN Modul]]\\ 
[[https://www.kernel.org/doc/Documentation/networking/can.txt|Linux Kernel - Network CAN]]

[[https://www.hackers-arise.com/single-post/2017/08/04/Automobile-Hacking-Part-1-The-CAN-Protocol|Automobile-Hacking-Part-1-The-CAN-Protocol]]\\
[[https://www.hackers-arise.com/single-post/2017/08/08/Automobile-Hacking-Part-2-The-can-utils-or-SocketCAN|Automobile-Hacking-Part-2-The-can-utils-or-SocketCAN]]\\ 
[[https://www.hackers-arise.com/single-post/2017/10/19/Automobile-Hacking-Part-3-Metasploit-for-Car-Hacking|Automobile-Hacking-Part-3-Metasploit-for-Car-Hacking]]\\ 
[[http://raspberrypi.link-tech.de/doku.php?id=canbus|Wiki Pi CAN-Bus]]\\
[[http://www.embeddedpi.com/documentation/isolated-canbus/mypi-industrial-raspberry-pi-can-bus-card-configuration]]


===== Sonstiges =====
[[https://blog.rapid7.com/2017/07/11/building-a-car-hacking-development-workbench-part-1/|building-a-car-hacking-development-workbench-part-1]]\\ 
[[https://blog.rapid7.com/2017/07/17/building-a-car-hacking-development-workbench-part-2/|building-a-car-hacking-development-workbench-part-2]]\\ 
[[https://blog.rapid7.com/2017/07/20/building-a-car-hacking-development-workbench-part-3/|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):
  * [[https://tutorials.technology/tutorials/69-Enable-additonal-spi-ports-on-the-raspberrypi.html|Enable SPI1]]
  * [[https://www.raspberrypi.org/forums/viewtopic.php?t=190664 | enabeling SPI1]] - aus dem Raspi-Forum
  * [[https://www.raspberrypi.org/forums/viewtopic.php?f=44&t=22608&p=1216154#p1216154|spi1 usable?]] - Beschreibt wie man den SPI1 aktivieren kann<code>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
</code>



====== 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|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**

{{ :entwicklung:raspi3:file.tgz |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: <code>dtparam=i2c_vc=on</code> 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:<code>i2cdetect -y 0 </code>

Beim Booten und Schreibschutz aufgehoben, bekan ich folgende Meldungen:<code>[    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
</code>

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)<code>
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</code>
Nun in das EEPROM-Utils Verszichnis wechseln:<code>cd hat/eepromutils</code>
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.<code>########################################################################
# 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
</code>

Nun mit make die eeprom Toolls erstellen <code> cd hats/eepromutils/
make</code>
Mit <code>./eepmake eeprom_settings.txt myhat.eep

Opening file eeprom_settings.txt for read
UUID=c488f0d4-e47e-45db-9802-5a27aacb04fe
Done reading
Writing out...
Done.
</code> 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) <code>dd if=/dev/zero ibs=1k count=4 of=blank.eep</code> 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:<code>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.
</code> 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):<code>sudo hexdump /sys/class/i2c-adapter/i2c-0/0-0050/eeprom</code>


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. ([[hat_eeprom_protokoll|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:<code> 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.
</code> 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: <code>cd /proc/device-tree/hat/
more vendor
more product</code>

Hier sollten jetzt die Daten aus dem EEPROM stehen, falls ja - Gratulation!

  * [[https://www.raspberrypi.org/forums/viewtopic.php?t=108134|Howto EEPROM einrichten]]
  * [[https://learn.adafruit.com/introduction-to-the-beaglebone-black-device-tree/compiling-an-overlay|Compiling an Overlay]]
  * [[https://www.raspberrypi.org/documentation/configuration/device-tree.md|Device Tree Konfiguration]]
  * [[https://github.com/raspberrypi/firmware/blob/master/boot/overlays/README|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**:<code>/dts-v1/;
/plugin/;

/ {
    compatible = "brcm,bcm2708";

    fragment@0 {
        target = <&leds>;
        __overlay__ {
            my_led: myled {
                label = "MYLED";
                gpios = <&gpio 18 0>;
                linux,default-trigger = "heartbeat";
            };
        };
    };
};</code> anlegen. Und mit dem **dtc Compiler** kompilieren:<code>sudo dtc -@ -I dts -O dtb -o myled.dtb myled.dts ; sudo chown pi:pi myled.dtb</code>
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 <code>./eepmake eeprom_settings.txt myhat-with-dt.eep myled.dtb</code> 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. <code>sudo ./eepflash.sh -w -f=blank.eep -t=24c32
sudo ./eepflash.sh -w -f=myhat-with-dt.eep -t=24c32
sudo reboot</code>
Hinweis: Man kann auch noch ein Benutzer-Konfiguration mit ins EEPROM packen (aucht maximale 4k vom EEPROM nicht überschreiten) welches man dann parsen kann. <code>./eepmake eeprom_settings.txt myhat-with-dt.eep myled.dtb -c myparams.json</code>



===== Links =====
  * [[https://www.raspberrypi.org/blog/introducing-raspberry-pi-hats/|Enführung in Pi Hats]]
  * [[https://github.com/raspberrypi/hats|HAT Specification]]
  * [[https://github.com/raspberrypi/hats/blob/master/designguide.md|HAT Design Guide]]
  * [[https://www.raspberrypi.org/forums/viewtopic.php?t=82618| Forum CAD EAGLE HAT template]]
  * [[http://www.flyfish-tech.com/pub/RasPi-BplusHAT.zip|RasPi-BplusHat.zip]] - 2 Vorlagen für Eagle
    * RasPi-BplusHAT.sch - 
    * RasPi-BplusHAT_CamSlot.sch - 
  * [[http://bastelstube.rocci.net/projects/MBS19_RasPi-GPIO/RasPi-GPIO.html]]
  * [[https://www.raspberrypi.org/documentation/hardware/raspberrypi/mechanical/README.md|Raspi Drawings Mechanical]]
==== Device-Tree ====
  * [[http://wiki.seeedstudio.com/2-Channel-CAN-BUS-FD-Shield-for-Raspberry-Pi|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
  *  [[http://www.waveshare.net/wiki/2-CH_CAN_FD_HAT|2 Kanal CAN-FD HAT]] - CAN-FD Hat aus China (inkl. Software)
  * [[https://www.kernel.org/doc/Documentation/devicetree/bindings/gpio/gpio.txt|GPIOs]] - Ein paar Infos über die Konfiguration von GPIOs im Device-Tree
  * [[https://www.devicetree.org/specifications/|Specifications Linux Devicetrees]]
  * [[https://forum.armbian.com/topic/11651-spi-based-canfd-driver-overlay-mcp2517mcp2518/|CAN-FD Fehler Kernel]] -
  * [[https://github.com/Seeed-Studio/seeed-linux-dtoverlays/tree/master/modules/CAN-HAT|Github SEED CAN-FD]]
    * [[https://wiki.seeedstudio.com/2-Channel-CAN-BUS-FD-Shield-for-Raspberry-Pi/|2-Channel-CAN-BUS-FD-Shield-for-Raspberry-Pi]]


====== EEPROM Tools für Raspi ======
  * [[hat_eeprom_protokoll#eeprog_tool|HAT - EEPROM auslesen]]

====== GPIOs ======
Zum Ansteuern am besten wiringPi nehmen:
  * [[http://raspberrypiguide.de/howtos/raspberry-pi-gpio-how-to/|Pi GIPO How-To]]\\ Hinweis -g um die GPIO-Belegung vom zu nehmen.<code>root@raspberrypi:/home/pi# gpio export 4 out
root@raspberrypi:/home/pi# gpio -g write 4 1</code>
mit <code> raspi-gpio get 5 
 raspi-gpio set 18 dh    # setzt den Pin High (Ausgang muss nicht konfiguriert werden, dies hat das EERPOM übernommen :-))</code> 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):
<code> gpio readall</code>
bzw. mit <code>pinout</code> die aktuellen Beleugn anzeigen lassen.

Hier  noch eine Lösung wenn man Pins beim Booten einschalten will:
  * [[https://raspberrypi.stackexchange.com/questions/4664/setting-gpio-value-on-boot|Setting GPIO value on boot]]

Das direkte Ansteuern mit dem Device Tree geht wohl nicht, deshalb könnte man obiges verwenden.
====== I2C - Raspi ======
Einrichtung:
  * [[http://ozzmaker.com/i2c/|Raspi I2C]]
  * [[https://www.kernel.org/doc/Documentation/i2c/dev-interface|I2C-Dev Interface]] - allgemeiner Zugriff auf das i2C Dev Interface (in C)
  * [[http://www.raspberry-pi-geek.de/Magazin/2015/06/EEPROM-Speicher-mit-dem-Raspberry-Pi-nutzen/(offset)/2]]
====== Python CAN =====
[[entwicklung:raspi3:pythoncan:pythoncan|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
  * [[https://github.com/pylessard/python-udsoncan|Python UDSONCAN]] - Github Repository
  * [[entwicklung:raspi3:pythoncan:pythoncan#python_udsoncan|Python UDSONCAN]]
====== CAN Dump in Rx-Liste ======
Hier ein kleines Beispielskript um aus einem CAN-Raw-Dump (.log-Format) eine Rx-Liste zu generieren:

Skript: {{ :public:dump2rxliste.awk |dump2rxliste.awk}} (Achtung: hier fehlt noch die unten aufgeführte Modifikation für CAN-FD)
<code>
 gawk -f dump2RxListe.awk inhouse/A-Klasse_W177/movement_touch.log</code>

Hinweis: Unter Raspberry Pi hatte der **awk** nicht funktioniert, deshalb wird jetzt beim Pi der **gawk** genommen.

dump2RxListe.awk:
<code>
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;
    }
</code>
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:<code>#!/usr/bin/gawk -f</code>Somit würde sich der obige Aufruf folgendermassen verkürzen:<code>./dump2RxListe.awk A-Klasse_W177/movement_touch.log</code>

Noch einfacher wird es, wenn man folgnedes Skript ("makeRxList") unter /usr/lokal/bin ablegt:<code>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
</code>Hier bei  nicht vergessen das awk-Skript unter ~/dev abzulegen. Damit verinfacht sich der Aufruf dann zu:<code>makeRxList A-Klasse_W177/movement_touch.log </code>


====== TRC2LOG Konverter ======
CANHacker Tracefiles mittels awk Skript in das Linux Logformat konvertieren.
  * {{ :public:trc2log.txt |trc2log.txt}} - 1. Prototyp des Konvertes (STD und EXT IDs funktionieren)
  * {{ :public:trc2log.awk |trc2log.awk}} - 2. Prototype kleine Änderung wergen log2asc unter Windows

Aufbau TRC-File:<code>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</code>
Die Zeitangabe kann mit '.' oder ',' vorkommen, beides wird akzeptiert. Und die Kommentare werden verworfen.


Beispiel (cygwin64):<code>
awk -f trc2log.txt  logfile.trc >logfile.log
</code>
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: [[pi3_tipps#canhacker_trc2asc_konverter|TRC2-ASC.exe - Windows Version]] verwenden.

Hierzu wird das obige Skript (Konverter in das log-Format):\\ {{ :public:trc2log.awk | trc2log.awk}} \\ und mein nach Windows portierter  "log2asc" Konverter:\\ {{ :public: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).

<code>
./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
</code>

Und mit diesem Bash-Skript lässt sich der Aufruf von oben vereinfachen:
  * {{ :public:can2asc.txt | can2asc}} - Bash-Skript um den Aufruf von oben zu vereinfachen <code>can2asc tracefile                 (ohne .trc)
oder
can2asc tracefile  ascfile        (jeweils ohne .trc und .asc) </code>

====== Log2Long  ======
Und hier noch der für Cygwin konvertierter **log2long** - Konverter aus den CAN-Utils:
  * {{ :media:log2long.exe | log2long.exe}} - Windows Variante

Beispiel aus dem MS-DOS Befehlsfenster:
<code>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   '........'
</code>




====== CANHacker TRC2ASC Konverter ======
Hier noch mein eigener Konverter welcher auf dem Quellcode von LOG2ASC aus den CAN-Utils basiert:\\ {{ :media:trc2asc.exe |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.

<code>
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

</code>
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:<code>pi@raspberrypi4:~/canlogger/ $ cat /usr/local/bin/trc2log
#!/bin/bash
trc2asc -I $1 can0 |asc2log
</code>Der Aufruf zum konvertieren eines TRC-Files zu Log-File erfolgt dann mit: <code>trc2log myLogfile.trc</code>
===== PEAK -TRC-Files =====
Peak Trace Files haben ein anderes Format und können mit dem Tool:\\ [[http://www.peak-system.com/fileadmin/media/files/peak-converter.zip|peak-converter.zip]]   \\ in das ASC-Format konvertiert werden.


==== Tracekonverter (BLF <--> ASC) ====
[[https://github.com/TDahlmann/can_trace_converter/tree/main|can_trace_converter]] - BLF <--> ASC CAN-Trace Konverter
====== ASC Logformat ======
Hmm oder direkt einen Konverter für das ASC Format machen:
<code>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   
</code>

===== 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)\\ [[https://github.com/hardbyte/python-can/blob/main/examples/simple_log_converter.py|simple_log_converter.py]] - einfacher Python Konverter
<code> 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()

</code>
  * {{ ::asc2log.py |asc2log_new}} - obiges Python Skript
  * {{ ::asc2logall.py |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:
  * <code>pip install python-can
bzw. wenn es systemweit sein soll, dann mit:
sudo apt install python3-can
</code>
  * python3
  * Skript für **[[https://docs.python.org/3/library/argparse.html|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: <code>
wget https://packagecloud.io/headmelted/codebuilds/gpgkey -O - | sudo apt-key add -
curl -L https://code.headmelted.com/installers/apt.sh | sudo bash
</code>
VS-Code kann dann über die Menüs oder in der Shell mit:\\  **code-oss** \\ aufgerufen werden.\\ 
Quelle: [[https://pimylifeup.com/raspberry-pi-visual-studio-code/|VS-Code PI installieren]]

**obiges ist veraltet!**
jetzt sollte ein:<code>sudo apt update
sudo apt install code</code> ausreichen. 
Der Aufruf erfolgt dann über die grafische Oberfläche oder mit <code>code . </code> aus dem aktuellen Ordner.



====== SD-Karte sichern  ======
Die SD-Karte kann auf einem Linux-PC mit dem dd - Befehl gesichert und wiederhergestellt werden:<code>

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
</code>
* eventuell fehlt beim restor ein sudo , todo prüfen

====== xosview installieren ======
===== Installation =====
<code>
sudo apt install xosview

falls font fehler beim Starten von xosview auftritt, nochmal:

sudo apt install xfonts-base

ausführen und rebooten
</code>
===== Autostart =====
<code>
cd ~/.config/
mkdir autostart
cd autostart

cp /usr/share/applications/xosview.desktop .
</code>

Um die Position festzulegen kan beim Aufruf in der Autostartdatei die -geomtry Option gesetzt werden:
<code>
Exec=xosview -geometry '-8+36'
</code>
====== JSON Parser ======
jq

hier mit dem einfachsten Filter "."  um die komplette Json-Datei anzuzeigen.
<code>jq . file.json     # joson file anzeigen</code>