diff --git a/README.MD b/README.MD index d9964c6..05632a7 100644 --- a/README.MD +++ b/README.MD @@ -1,16 +1,15 @@ # Beispiele für EtherLab mit External Mode -Dieses Repo enthält Simulink-Modelle und Matlab-Code die die Benutzung von EtherLab mit External Mode Patch (IRT-Version) zeigen. +Dieses Repo enthält Simulink-Modelle und Matlab-Code die die Benutzung von EtherLab mit External-Mode-Patch (IRT-Version von Lucas Jürgens) zeigen. Die Beispiele sind prinzipiell auch für die offizielle EtherLab-Version mit PDServ geeignet, allerdings funktioniert die Datenaufnahme im External Mode dabei nicht. Voraussetzungen: * Matlab R2018b (damit getestet, letzte bekannte lauffähige Version) -* [IMES Matlab Toolbox (interner Link)](https://gitlab.projekt.uni-hannover.de/imes-material/matlab-toolbox) bzw. [externer Link](https://github.com/SchapplM/matlab_toolbox) -* Echtzeitrechner mit EtherLab (siehe Anleitungen rt.md und ethercat.md aus Repo [Linux-Tools](https://gitlab.projekt.uni-hannover.de/imes-material/linux-tools)) -* Installation von EtherLab auf Entwicklungsrechner (siehe ethercat.md). Das sollte der Rechner sein, auf dem die Beispiele ausprobiert werden. Unter Windows werden sie so nicht ohne weiteres funktionieren (ist aber prinzipiell möglich, mit einiger Nacharbeit). - * Der Echtzeitrechner ist in der SSH-Konfiguration eingestellt: `ssh irtpc077_ec` entspricht `ssh ec@130.75.135.77`. Die IP muss natürlich an den verwendeten Echtzeitrechner angepasst werden. +* Echtzeitrechner mit EtherCAT. Siehe Anleitungen [SETUP_RTPC.MD](SETUP_RTPC.MD) und [SETUP_ETHERCAT.MD](SETUP_ETHERCAT.MD). +* Installation von EtherLab auf Entwicklungsrechner [SETUP_ETHERCAT.MD](SETUP_ETHERCAT.MD). Das sollte der Rechner sein, auf dem die Beispiele ausprobiert werden. Unter Windows werden sie so nicht ohne weiteres funktionieren (ist aber prinzipiell möglich, mit einiger Nacharbeit). + * Der Echtzeitrechner ("RTPC") ist in der SSH-Konfiguration `~/.ssh/config` des Entwicklungsrechners ("DEVPC") eingestellt: Der Befehl `ssh RTPC_ec` entspricht `ssh ec@10.144.130.83`. Die IP muss natürlich an den verwendeten Echtzeitrechner angepasst werden. * Es sollte ein Ordner für die Echtzeit-Modelle erstellt werden: - `ssh irtpc077_ec` (auf Entwicklungsrechner) + `ssh RTPC_ec` (auf Entwicklungsrechner) `mkdir ~/rtmdl` (auf Prozessrechner, über SSH-Fenster) Moritz Schappler, moritz.schappler@imes.uni-hannover.de, 2020-03 @@ -27,9 +26,9 @@ Vorgehensweise: * Bei Erfolg ist eine neue Datei `extmode_minimal` (ohne Endung) im Modellordner entstanden * Modell auf Echtzeitrechner kopieren: * Konsole im Ordner öffnen - * `scp extmode_minimal irtpc077_ec:~/rtmdl` + * `scp extmode_minimal RTPC_ec:~/rtmdl` * Modell auf Echtzeitrechner ausführen - * `ssh irtpc077_ec` (auf Entwicklungsrechner) + * `ssh RTPC_ec` (auf Entwicklungsrechner) * `cd ~/rtmdl` * `./extmode_minimal` Ausgabe, wenn es funktioniert: @@ -47,6 +46,7 @@ Vorgehensweise: * Wenn es funktioniert hat, sind jetzt im Ordner results mat-Dateien (measurement_data_0.mat, ...) gespeichert worden * Skript extmode_minimal_postprocess.m ausführen * Darin ist ein Beispiel-Code um die Messdaten nachzuverarbeiten + * Voraussetzung: IMES Matlab Toolbox: [(interner Link)](https://gitlab.projekt.uni-hannover.de/imes-material/matlab-toolbox) bzw. [externer Link](https://github.com/SchapplM/matlab_toolbox). ## Ixxat ETCio 100 @@ -393,7 +393,7 @@ Vorbereitung des Entwicklungsrechners: Hostnamen des Echtzeitrechners bekanntmac ``` sudo nano /etc/hosts -10.144.130.83 imessmartrtpc1 # Neuer Eintrag mit IP und Hostnamen des Echtzeitrechners, falls abweichend +10.144.130.83 RTPC # Neuer Eintrag mit IP und Hostnamen des Echtzeitrechners, falls abweichend ``` Dann wird der ROS-Workspace mit folgendem Befehl kompiliert: @@ -405,7 +405,7 @@ build.sh Hierfür sind keine zusätzlichen Pfad-Initialisierungen (source ...) notwendig. Der dadurch erzeugte Ordner "install" enthält alle ausführbaren Dateien der ROS-Packages. Ein Kopieren des Quelltextes auf den Echtzeitrechner und dortiges kompilieren ist nicht notwendig. Die ausführbaren Dateien werden auf den Echtzeitrechner kopiert. -Das Kopierskript "sync.sh" muss vorher an den Zielrechner angepasst werden (Anpassen des SSH-Verbindungsnamens "imessmartrtpc1_ec" an den in der ~/.ssh/config eingestellten). +Das Kopierskript "sync.sh" muss vorher an den Zielrechner angepasst werden (Anpassen des SSH-Verbindungsnamens "RTPC_ec" an den in der ~/.ssh/config eingestellten). ``` sync.sh @@ -444,6 +444,62 @@ Dafür wird `build.sh` und `sync.sh` neu ausgeführt. Vorher müssen die laufenden Programme mit `tmux kill-session -t app` oder durch Beenden der einzelnen Tasks in der tmux-Konsole geschlossen werden. Es reicht teilweise aus, nur die Programme neu zu starten, die auch neu kompiliert wurden. +# Eigene Modelle erstellen + +Eigene Beispiele können prinzipiell mit den vorgestellten Minimalbeispielen als Vorlage erstellt werden. + +## EtherCAT-Konfiguration auslesen + +Zunächst sollte die aktuelle EtherCAT-Konfiguration geprüft werden. Für die Diagnose-Befehle sollten ähnliche Ausgaben erscheinen. Die folgenden Befehle werden auf dem Echtzeitrechner (z.B. in einer SSH-Konsole) ausgeführt. + +Funktionalität des Masters: + +``` +$ /etc/init.d/ethercat status +Checking for EtherCAT master 1.5.2 +Master0 running +``` + +Status des Masters: +``` +$ /opt/etherlab/bin/ethercat master +Master0 + Phase: Idle + Active: no + Slaves: 6 + Ethernet devices: + Main: 00:02:b3:8d:c1:43 (attached) + Link: UP + Tx frames: 95418 + Tx bytes: 6021048 + Rx frames: 95414 + .... + ... +``` + +Status der Slaves (stark abhängig von den eingesetzten Slave-Modulen) + +``` +$ /opt/etherlab/bin/ethercat slaves +0 0:0 PREOP + EK1100 EtherCAT Coupler (2A E-Bus) +1 0:1 PREOP + EL4004 4K. Ana. Ausgang 0-10V, 12bit +... +``` + +Anschließend sollte die Slave-Konfiguration ausgelesen werden + +``` +/opt/etherlab/bin/ethercat pdos --skin etherlab > ~/pdos_etherlab.m +``` + +Diese Konfiguration sollte auf den Entwicklungsrechner kopiert werden: `scp RTPC_ec:~/pdos_etherlab.m .` (auf dem Entwicklungsrechner ausführen). + +## Modell konfigurieren + +In der Matlab-Datei befindet sich der Code für die einzelnen Slave-Module. +Dieser Code sollte in Matlab-Funktionen eingefügt werden, wie z.B. die Datei [etcio100_slave.m](ixxat/etcio100_slave.m) im [Ixxat-Beispiel](#bsp_ixxat). +Diese Funktion konfiguriert dann den Block "generic slave" aus der Etherlab-Simulink-Bibliothek. +Anschließend muss das Simulink-Modell noch entsprechend dem Einsatzzweck weiter ausgearbeitet werden. Die Konfiguration des Modells und mögliche Fehlerbehebungen ist teilweise in [SETUP_ETHERCAT.MD](SETUP_ETHERCAT.MD) beschrieben. # Quellen diff --git a/SETUP_ETHERCAT.MD b/SETUP_ETHERCAT.MD new file mode 100644 index 0000000..50f3faa --- /dev/null +++ b/SETUP_ETHERCAT.MD @@ -0,0 +1,507 @@ +# Anleitung für Linux Echtzeit-PC als EtherCAT Master + +Ziel dieser Anleitung ist das Aufsetzen von PCs zum Betrieb als EtherCAT-Master mit Etherlab und Simulink um z.B. Prüfstände zu regeln und Messungen durchzuführen. +In dieser Anleitung wird zwischen dem Echtzeit-PC (EtherCAT-Master, laufendes Simulink-Modell) und dem Entwickler-PC (Simulink-Modell-Überwachung über external Mode, Kompilierung des Modells unterschieden). + +Es wird in dieser Anleitung für den Echtzeit-PC die IP 10.144.130.83 angenommen, die IP und der Benutzername muss entsprechend der eigenen Konfiguration angepasst werden. + +Es wird davon ausgegangen, dass der Echtzeit-PC entsprechend der Anleitung in [SETUP_RTPC.MD](SETUP_RTPC.MD) aufgesetzt wurde (Debian/Ubuntu mit Preempt-RT-Patch). + +Wird derselbe PC als EtherCAT-Master und als Entwickler-PC benutzt, müssen die Schritte für den [Echtzeit-PC](#rtpc) und den [Entwickler-PC](#entwpc) durchgeführt werden. +Die Pfade müssen dann etwas angepasst werden. + +## Inhalt + +* [Echtzeit-PC](#rtpc) + * [EtherCAT](#rtpc_ethercat) + * [PDServ](#rtpc_pdserv) +* [Entwickler-PC](#entwpc) + * [Simulink-Einstellungen](#simulink) +* [Fehlerbehebung](#fehler) + +## Anleitung für Echtzeit-PC + +### EtherCAT-Master installieren + +Master-Code vorbereiten (Auf Entwickler-PC) . Vorher: In geeigneten Ordner wechseln. Z.B. durch +`mkdir -p ~/EtherCAT && cd ~/EtherCAT` + + hg clone http://hg.code.sf.net/p/etherlabmaster/code etherlabmaster-code + cd etherlabmaster-code + hg update stable-1.5 + +Open configure.ac and remove ”-Werror” at ”AM_INIT_AUTOMAKE” entry. + + nano configure.ac + +Etherlab-Master-Code per SSH auf Rechner kopieren + + scp -r ~/EtherCAT/etherlabmaster-code RTPC_ec:/tmp + +Folgende Befehle auf dem Echtzeitrechner ausführen: + + sudo mv /tmp/etherlabmaster-code /usr/src/ + + sudo apt-get install autoconf libtool lshw + + cd /usr/src/etherlabmaster-code + ./bootstrap + +Alle gepatchten Ethernet-Treiber deaktivieren. Nur den generic-Treiber benutzen. +Die gepachten Treiber werden nicht für RT_PREEMPT benötigt, sondern nur für RTAI (andere Art von Echtzeit-Linux). +Folgende Zeile ausführen und die installierten Netzwerktreiber zu finden, die deaktiviert werden müssen. + + sudo lshw -c network + +Die Ausgabe enthält z.B. `driver=r8169`. Dieser Treiber muss dann unten deaktiviert werden. +EtherCAT konfigurieren. +Standard-Konfiguration (Alternative 1): + + ./configure --disable-8139too --disable-e100 --disable-e1000 --disable-e1000e --disable-r8169 --enable-generic --prefix=/opt/etherlab + +Konfiguration für Encoder-Slaves (Alternative 2): + + ./configure --disable-8139too --enable-sii-assign --enable-hrtimer --enable-cycles --prefix=/opt/etherlab + +Make und Install + + sudo apt-get install g++ + make -j8 + make modules + sudo make modules_install install + +Config installieren und Initialisierungsskripte + + sudo ln -s /opt/etherlab/etc/init.d/ethercat /etc/init.d/ethercat + sudo mkdir /etc/sysconfig + sudo cp /opt/etherlab/etc/sysconfig/ethercat /etc/sysconfig/ethercat + +MAC-Adresse der für EtherCAT vorgesehenen Netzwerkkarte: + + ifconfig + +In /etc/sysconfig/ethercat folgende Einstellungen vornehmen: + + $sudo nano /etc/sysconfig/ethercat + + set MASTER0_DEVICE={network adapter MAC address} + set DEVICE_MODULES={appropriate driver, if in doubt use generic} + +Als Dienst einrichten, falls gewünscht (dann startet der EtherCAT-Treiber automatisch). Weitere Details können der EtherLab-Anleitung entnommen werden. + + sudo update-rc.d ethercat defaults + +Andernfalls muss der EtherCAT master manuell bei jedem Booten gestartet werden: + + sudo /etc/init.d/ethercat start + +Benutzerrechte für die Gruppe realtime setzen: + + $cd /lib/udev/rules.d/ + $sudo nano 99-EtherCAT.rules + +Folgende Zeile einfügen: + + KERNEL=="EtherCAT[0-9]*", MODE="0660", GROUP="realtime" + +Installation prüfen + + cat 99-EtherCAT.rules + sudo /etc/init.d/ethercat restart + ls -l /dev/EtherCAT0 + +Funktionalität prüfen: +Damit die folgenden Befehle, als auch die Binary des Simulinkmodells, ohne sudo-Rechte laufen, muss der Nutzer der aktuellen Sitzung in der Gruppe realtime sein. + + /opt/etherlab/bin/ethercat master + /opt/etherlab/bin/ethercat slaves ### IF CONNECTED + +Etherlab zu Umgebungsvariablen hinzufügen: + + $sudo nano /etc/environment + +Ort der Library zum Library-Suchpfad hinzufügen (notwendig zum Starten des Simulink-Modells) + + LD_LIBRARY_PATH="/opt/etherlab/lib" ### als zusätzliche Zeile (falls nicht schon vorhanden) + +### Optional: PDServ installieren + +Muss nur gemacht werden, wenn die offizielle Etherlab-Version benutzt wird. Nicht für die IRT-Version + +Quelle: +* [Symbitron-Wiki / EtherLab Installation](https://www.symbitron.eu/wiki/index.php?title=EtherLab_Installation#Installing_pdServ_1.1.0) +* INSTALL-Datei des pdserv-Repos + +Herunterladen (vorher in geeigneten Ordner wechseln) + + hg clone http://hg.code.sf.net/p/pdserv/code pdserv-code + +PDServ-Code per SSH auf Rechner kopieren + + scp -r pdserv-code RTPC_ec:/tmp + +Folgende Befehle auf dem Echtzeitrechner ausführen: + + sudo mv /tmp/pdserv-code /usr/src/ + +Abhängigkeiten installieren + + sudo apt-get install cmake g++ cmake pkg-config libyaml-dev libcommoncpp2-dev liblog4cplus-dev libdb-dev libsasl2-dev + +Installation (auf Echtzeit-PC nach /opt/etherlab) + + cd /usr/src/pdserv-code + sudo chown sysadm:sysadm -R . + rm -rf build + mkdir build + cd build + cmake -DCMAKE_INSTALL_PREFIX=/opt/etherlab .. + make + sudo make install + +## Anleitung für Entwickler-PC + +Wenn statt Echtzeit-/ und Entwickler-PC nur ein PC exisitiert, auf dem EtherCAT und Matlab/Simulink läuft, muss der folgende Code entsprechend ausgeführt werden. +Quellen: + +* README-Datei im Repo etherlab-code + +Installation von Etherlab-Code +Alternative 1: IRT-Version: + + git clone git@irtfs.irt.uni-hannover.de:software/etherlab-code + +Alternative 2: Original-Version: + + hg clone http://hg.code.sf.net/p/etherlab/code etherlab-code + +Abhängigkeit zum Kompilieren, falls nicht schon installiert: + + sudo apt-get install cmake + +Wechsle in Verzeichnis + + cd etherlab-code + +Bei Neukompilierung: + + rm -rf build/ + +Optional: Für eine Neu-Installation (bei Änderung der EtherLab-Version): Lösche den Ordner im System. + + sudo rm -rfv /usr/local/share/etherlab + +Lege die Matlab-Version fest, in die installiert werden soll: + + MATLAB_VERSION=R2018b + +Installation: Erstellt den Ordner /usr/local/share/etherlab + + mkdir build + cd build/ + cmake .. + sudo make install + +Optional: Für eine Neu-Installation in den Matlab-Ordner. Lösche bisherigen Ordner von etherlab): + + + sudo rm -rfv /usr/local/MATLAB/$MATLAB_VERSION/rtw/c/etherlab + +Installationsskript (Etherlab-Dateien in Matlab-Installation hineinkopieren) + + sudo mkdir -p /usr/local/MATLAB/$MATLAB_VERSION/rtw/c/ + sudo chmod o+w -R /usr/local/MATLAB/$MATLAB_VERSION/rtw/c/ + /usr/local/share/etherlab/install.sh /usr/local/MATLAB/$MATLAB_VERSION + sudo chmod o-w -R /usr/local/MATLAB/$MATLAB_VERSION/rtw/c/ + +Matlab: Mex-Kompilierung. Achtung: Es sollte __kein__ `sudo matlab` benutzt werden, da dies die Rechte einiger Dateien durcheinander bringt und sicherheitstechnisch kritisch ist. Außerdem weiß man durch Rechteentzug genau, welche Dateien nur geändert werden konnten. + + sudo chmod o+w -R /usr/local/MATLAB/$MATLAB_VERSION/toolbox/local + sudo chmod o+w -R /usr/local/MATLAB/$MATLAB_VERSION/rtw/c/ + /usr/local/MATLAB/$MATLAB_VERSION/bin/matlab -nodesktop -nosplash -r "run(fullfile(matlabroot, 'rtw/c/etherlab', 'setup_etherlab.m'));quit" + sudo chmod o-w -R /usr/local/MATLAB/$MATLAB_VERSION/rtw/c/ + sudo chmod o-w -R /usr/local/MATLAB/$MATLAB_VERSION/toolbox/local + +### Etherlab-Master-Code bereitstellen + +Wird nicht benötigt, wenn über eine SDK z.B. für ARM-Architektur Cross-kompililiert wird. +Dies führt eine reine Installation in den Ordner /usr/local/share/etherlab durch. Es werden keine Treiber installiert (wie für den Echtzeit-Rechner). + + +Abhängigkeiten zum Bauen (falls nicht schon vorhanden) + + sudo apt-get install autoconf libtool lshw + + Vorher: Auschecken des etherlabmaster-code-Repos und wechseln in dieses Verzeichnis (siehe [oben](#etherlabmastercode)). (Nicht: Etherlab-Code). + + cd /path/to/repo/etherlabmaster-code + +Kompilieren und installieren (nur als Abhängigkeit, nicht als Treiber). +Der Befehl `make install` wird nicht als sudo ausgeführt, damit wird sichergestellt, dass nichts systemweit installiert wird. Stattdessen werden die erwarteten Zielordner vorher auf durch den Benutzer schreibbar gestellt. Die Nutzerrechte des Zielordners werden dabei angepasst. So wird sichergestellt, dass keine systemweiten Dateien aus Versehen falsch beschrieben werden. + + ./bootstrap + ./configure --disable-8139too --disable-e100 --disable-e1000 --disable-e1000e --disable-r8169 --enable-generic --prefix=/usr/local/share/etherlab + make -j8 + sudo chmod o+w -R /usr/local/share/etherlab + make install + sudo chown root:root -R /usr/local/share/etherlab + sudo chmod o-w -R /usr/local/share/etherlab + +#### Hinweis für EtherLab-Versionen vor hg-rev. 1112 (2016-11-26): + +Früher wurde etherlab nach /opt/etherlab installiert. Das hat sich jetzt geändert. +Folgender Befehl ist nur für den alten Fall notwendig: + +Ort der Library zum Library-Suchpfad hinzufügen (notwendig zum Kompilieren des Simulink-Modells) + + $sudo nano /etc/environment + LD_LIBRARY_PATH="/opt/etherlab/lib" ### als zusätzliche Zeile (falls nicht schon vorhanden) + +#### Optional: PDServ installieren + +Die Schnittstelle ist in der IRT-Variante aus dem Target entfernt. Es wird External Mode statt Test Manager benutzt. +Für die Original-Version von EtherLab ist PDServ notwendig. Ansonsten kann dieser Schritt übersprungen werden. Dieser Abschnitt ist größtenteils identisch mit dem Abschnitt oben bei der Installation von pdserv für den Echtzeitrechner. Zur einfacheren Durchführbarkeit (Copy-Paste) wird das aber hier repliziert. + +Abhängigkeiten installieren + + sudo apt-get install cmake g++ cmake pkg-config libyaml-dev libcommoncpp2-dev liblog4cplus-dev libdb-dev libsasl2-dev + +Herunterladen (vorher in geeigneten Ordner wechseln) + + hg clone http://hg.code.sf.net/p/pdserv/code pdserv-code + +Installation (auf Entwickler-PC nach /usr/local/share/etherlab) + + cd pdserv-code + rm -rf build + mkdir build + cd build + cmake -DCMAKE_INSTALL_PREFIX=/usr/local/share/etherlab .. + make + sudo make install + +Fertig. + + +### Einstellungen des Simulink-Modells + +Um ein funktionierendes Simulink-Modell als Echtzeit-Programm mit Etherlab-Integration zu kompilieren, sollte am Besten ein bestehendes, getestetes Modell als Vorlage genommen werden und "entkernt" werden (alle Blöcke löschen). +Alternativ kann auch ein neues Modell erstellt werden mit Anpassung der Modelleinstellungen. +Die folgenden Einstellungen beziehen sich auf die IRT-Version mit External Mode. In der Original-Version von EtherLab muss der TestManager benutzt werden. + + +Code Generation: + +* System target file: etherlab.tlc (Bei Auswahl erscheinen die anderen Einstellungsoptionen mit gesetzten Standardwerten) + +Code Generation/Interface: + +* Haken bei "External Mode" +* Transport layer "none" +* MEX-file arguments: "'10.144.130.83' 0 17725" (IP-Adresse des Echtzeit-Rechners eintragen) +* Static memory allocation: Haken setzen (Ansonsten kann es zu Echtzeitverletzungen beim alloziieren neuen Speichers kommen +* Static memory buffer size: 10000000 (10MB; Standard-Wert erhöhen, damit Speicher ausreicht) + +Code Generation/EtherLab C code generation: + +* BIO Buffer time: "2" +* External Mode Mex File Arguments: "'localhost' 0 17725" (hier muss nicht die IP-Adresse des Echtzeit-Rechners angegeben werden. +* ASYNC Mode: Kein Haken notwendig. (Der ASYNC Mode war nur im BeagleBone-Target enthalten). + +Sonstige Einstellungen im Modell (nicht in den Modelleinstellungen, sondern im Menü oben): + +Menü-Leiste: Code -> External Mode Control Panel: +* Haken bei "enable data uploading" + Duration: "auto" (Standard-Wert) +* Signal & Triggering: + * Alle "Selected". + * Source: manual -> Trigger ausgegraut. + * "Arm when connecting to target". + * Duration 10000; Delay 0; + Der Wert für Duration sollte eher lang gewählt sein, ansonsten werden sehr viele kleine mat-Dateien erzeugt. + Aber auch nicht so lang, dass der notwendige Speicher zum Vorhalten der Daten nicht alloziiert werden kann. + Der Wert hängt also vom Umfang der zu übertragenen Daten ab. + Bei zu großen Zahlen entsteht [die unten beschriebene Fehlermeldung](#debug_scope_leer). +* Data Archiving + * Haken bei "enable archiving" + * Directory: relativen Pfad zum Modell wählen (z.B. "./results"), ist aber beliebig + * File: "measurement_data" (z.B.) + * Alle Haken weg. + +Zusätzlich muss bei Scope-Blöcken zur Datenspeicherung Signal Logging konfiguriert werden. [Siehe Text unten.](#debug_mat_leer) Ansonsten werden keine Daten gespeichert, sondern nur live in den Scopes angezeigt. +* Doppelklick auf den Scope-Block (der die gewünschten Signale ausgibt) +* View -> Configuration Parameters +* Karteireiter "Logging" + * Limit data points: Haken wegnehmen (sonst werden nur die letzten Daten gespeichert) + * Decimation: Haken wegnehmen, oder 1 setzen (sonst werden die Daten ausgedünnt) + * Log data to workspace: + Variable name: Unter diesem Namen werden die Daten gespeichert + Save format: Structure with Time. Die Daten können danach besser nachverarbeitet werden + +Bei der Modelleinstellung muss anstatt "Normal" "External" eingestellt werden (im oberen Menüband). Weitere Optionen sind "Accelerator" und "Rapid Accelerator". + +## Fehlerbehebungen + +### Fehler beim Kompilieren des Simuilink-Modells + +#### Datei nicht gefunden: ecrt.h + +Auf dem Entwicklungsrechner muss auch der EtherCAT-Master installiert werden (die Abhängigkeiten im Ordner /opt/etherlab, nicht der Treiber). +Behebung: Siehe [oben](#etherlabmastercode) "Etherlab-Master-Code bereitstellen ...". + +#### Datei nicht gefunden: libethercat.so + +Fehlermeldung: + + /usr/bin/ld: cannot find -lethercat + collect2: error: ld returned 1 exit status + gmake: *** [../pcu_impctrl] Fehler 1 + +Die Etherlab-Bibliothek liegt nicht im Library-Linker-Suchpfad: + + ld -lethercat --verbose + +Finde den Ort der Bibliothek heraus: + + find /usr/local/share/etherlab -name libethercat.* + +Lösung: Etherlab-Bibliothek in Ordner verlinken, der im Suchpfad ist. + +Variante 1: Symbolische Verknüpfung nach /usr/local/lib/: + + sudo ln -s /usr/local/share/etherlab/lib/libethercat.so /usr/local/lib/libethercat.so + +Variante 2: Mit `find` gefundenen Pfad (/usr/local/share/etherlab/lib) in Umgebungsvariable `LD_LIBRARY_PATH` eintragen: + + sudo nano /etc/environment + LD_LIBRARY_PATH="/usr/local/share/etherlab/lib" ### als zusätzliche Zeile (falls nicht schon vorhanden) + +Das scheint aber unter neueren Rechnerinstallationen nicht mehr zu funktionieren. + +Hintergrund: Bei Installation des Etherlabmaster-codes kommt folgende Meldung: + +``` +Libraries have been installed in: + /usr/local/share/etherlab/lib + +If you ever happen to want to link against installed libraries +in a given directory, LIBDIR, you must either use libtool, and +specify the full pathname of the library, or use the '-LLIBDIR' +flag during linking and do at least one of the following: + - add LIBDIR to the 'LD_LIBRARY_PATH' environment variable + during execution + - add LIBDIR to the 'LD_RUN_PATH' environment variable + during linking + - use the '-Wl,-rpath -Wl,LIBDIR' linker flag + - have your system administrator add LIBDIR to '/etc/ld.so.conf' +``` + +#### /usr/bin/ld: cannot find -lpdserv + +Die pdserv-Bibliothek ist nicht im Library-Linker-Suchpfad + + ld -lpdserv --verbose + +Finde den Ort der Bibliothek heraus: + + find /usr/local/share/etherlab -name libpdserv.* + +Behebung: Symbolische Verknüpfung nach /usr/local/lib/: + + sudo ln -s /usr/local/share/etherlab/lib/libpdserv.so /usr/local/lib/libpdserv.so + +#### Meldung External mode MEX-file 'noextcomm' + +Vollständige Meldung: +``` +Meldung External mode MEX-file 'noextcomm' does not exist or is not on the MATLAB path. Note that the MEX-file name entered should not have a file extension. +``` + +Tritt wahrscheinlich nur bei der modifizierten IRT-Version des Targets auf. +In der mdl-Datei muss händisch ext_comm anstatt noextcomm eingetragen werden. Das ist ein Problem mit der Maske beim Wechseln der Option. +Zusätzlich kann es sein, dass das Target etherlab.tlc neu ausgewählt werden muss und der Haken bei External Mode entfernt und wieder neu gesetzt werden muss. + + +### Fehler beim Ausführen des Simulink-Modells + +#### Echtzeitverletzungen durch unendlich kleine sample time + +Beim Starten des Simulinkmodells wird die Konsole mit der Fehlermeldung + Loop 12583. OVERRUN (1). Threadtime 8186.977043462 s, endtime 8186.976644763 s, diff -1774056 ns +vollgeschrieben. + +Überprüfen kann man dies mit dem Befehl + `timeout 0.001 ./` +der die Ausgabe nach 0.001 Sekunden abbricht, damit man noch die Ausgabe lesen kann. Wenn z.B. + Sample-Time: 0.000400 +ausgegeben wird, ist die o.g. Ursache wahrscheinlich nicht das Problem, sondern es werden zu viele Rechenoperationen in zu geringer Zeit gefordert. +Wenn + Sample-Time: 0.0000000 +ausgegeben wird, ist der o.g. Fall eingetreten und das Problem liegt wahrscheinlich an einem Block mit kontinuierlicher Abtastzeit, welcher diese geringe Abtastzeit erzwingt. Simulink berechnet in diesem Fall mit der kleinstmöglichen Abtastzeit, erreicht folglich die geforderte Abtastzeit nicht und gibt den o.g. Fehler aus. + +Die Lösung des Problems besteht darin, alle Module des Modells schrittweise auszukommentieren und zu überprüfen, ob der o.g. behoben wurde. + +Weitere Anmerkungen: +* bekannte Blöcke, mit denen dies passiert sind der Block 'Ramp', sowie der Block 'clock'. Es reicht nicht aus, eine rate transition zu verwenden. Diese Blöcken müssen ersetzt werden. +* Auch zeitkontinuierliche Blöcke wie der PID-Regler von Matlab oder der Differenzierer sind mögliche Ursachen. Es dürfen nur zeitdiskrete Blöcke benutzt werden +* Einige Etherlab-Slave-Blocke aus der Etherlab-Bibliothek sind standardmäßig auf Schrittweite 0 eingestellt. +* der Block 'clock' kann durch 'Digital Clock' ersetzt werden. +* Unter Matlab R2015a wurden diese Probleme nicht beobachtet, jedoch führte der gleiche Code in R2017b zu dem o.g. Fehler. +* Dieser Fehler kann selbst auftreten, wenn die o.g. Blöcke auskommentiert sind. +* Zur Diagnose sollte in Simulink Display -> Sample Time -> All benutzt werden + +#### mlockall-Fehler beim Start des Simulink-Modells + +Fehlermeldung beim Start des Modells: + + mlockall() failed: Cannot allocate memory + +Wird in hrt_main.c aufgeworfen. +Ursache: Der Speicherbereich kann nicht reserviert werden. +Siehe: https://linux.die.net/man/2/mlockall, http://sanketpadawe.blogspot.de/2012/06/prevent-page-locking-when-using.html. + +Eintragen eines größeren Grenzwertes mit den folgenden Zeilen. (Zahlen erhöhen, so wie realistisch): + + $sudo nano /etc/security/limits.conf + + @realtime soft memlock 102400 + @realtime hard memlock 102400 + +Statt der Gruppe @realtime kann auch eine höhere Grenze für den Benutzer eingetragen werden. + +Prüfen der Limits + + $ ulimit -l + +#### Verbinden mit External Mode funktioniert mit Fehlermeldung, Scopes bleiben aber leer + +In der Ausgabe des Modell-Kompilats kommt folgende Fehlermeldung: +Error in UploadLogInfoInit(). Most likely a memory allocation error or an attempt to re-initialize the signal selection during the data logging process (i.e., multiple EXT_SELECT_SIGNAL packets were received before the logging session terminated or an EXT_CANCEL_LOGGING packet was received) + +Das Verbinden im External Mode funktioniert, in der Fußzeile in Simulink läuft die Zeit des Simulationsmodells. +Beim Öffnen eines Scope-Blocks bleibt dieses aber leer und bei T=0 stehen. + +Mögliche Ursache: Es werden zu viele Datenpakete in einem zu übertragendem External-Mode-Paket gespeichert. So viel Speicher kann nicht zugewiesen werden. +Der Wert unter "Signal & Triggering" muss kleiner gewählt werden. Die Beschreibung des Wertes lautet: "Number of samples to collect in one buffer". + +#### libpdserv.so.xxxxx: cannot open shared object file + +Betrifft nur Original-Etherlab mit PDServ. + +Fehlermeldung nach Starten der Simulink-Programmdatei auf dem Echtzeitrechner: + + ./ETCio100_example_2018b: error while loading shared libraries: libpdserv.so.3919610c9f6a: cannot open shared object file: No such file or directory.... + +Mögliche Ursache: PDServ wurde auf Entwicklungsrechner und Echtzeitrechner mit anderen Programmbibliotheken erzeugt (z.B: libgnutls.so 3.4.10 vs 3.5.18). +Mögliche Abhilfe: Gleiche Debian/Ubuntu-Version auf beiden Rechnern nutzen. + +### Ungereimtheiten beim Ausführen des Simulink-Modells + +#### Die über external Mode gespeicherten mat-Dateien sind leer + +Die Datenspeicherung muss für jedes Scope aktiviert werden. Siehe [Einstellung des Simulink-Modells](#simulink). + +## Quellen + +* Bachelorarbeit von Lucas Jürgens. Durchgeführt 2017 am Institut für Regelungstechnik, Leibniz Universität Hannover. Betreuer: Moritz Schappler. Titel der Arbeit: "Implementation and Evaluation of a Prosthesis Control Unit on a mobile ARM-based Computing Platform". Enthält u.a. die Beschreibung des External-Mode-Patches der IRT-Version von EtherLab +* [Mailing-Liste etherlab-users](https://www.mail-archive.com/etherlab-users@etherlab.org/) diff --git a/SETUP_RTPC.MD b/SETUP_RTPC.MD new file mode 100644 index 0000000..c065118 --- /dev/null +++ b/SETUP_RTPC.MD @@ -0,0 +1,284 @@ +# Anleitung zum Aufsetzen eines Linux-Echtzeit-PCs + +Im Folgenden wird beschrieben, wie ein Linux-Echtzeit-PC aufgesetzt wird. + +Syntax: +* Befehle auf Entwicklungsrechner (§) +* Normale Befehle auf Echtzeitrechner ($) +* Root-Befehle auf Echtzeitrechner (#) + +## Linux-Distribution auswählen + +Folgende Kriterien spielen bei der Auswahl des Linux-Kernels eine Rolle: +* Der Kernel muss mit RT-Patch unterstützt sein: https://www.kernel.org/pub/linux/kernel/projects/rt +* Optional: Sollte langzeit-unterstützt sein: https://de.wikipedia.org/wiki/Linux_(Kernel)#Versionen_mit_Langzeitunterst.C3.BCtzung + +Folgende Kriterien spielen bei der Auswahl der Linux-Distribution eine Rolle: +* Welche Kernel-Versionen werden unterstützt? +* Distribution sollte langzeituntstützt sein +* Soll ROS unterstützt werden? (z.B. für RT-Interface) + * Ubuntu 14.04 (Trusty) für ROS Indigo, Ubuntu 16.04 (Xenial) für ROS Kinetic, Ubuntu 18.04 (Bionic) für ROS Melodic + +Siehe auch: +* https://wiki.ubuntu.com/Kernel/Support + +Erprobt wurden bisher folgende Konfigurationen: +* LUbuntu 18.04 mit Kernel 4.19 (LUbuntu ist eine leichte Ubuntu-Variante) +* LUbuntu 16.04.1 mit Kernel 4.4 +* LUbuntu 14.04.5 mit Kernel 4.4 + +## Distribution installieren + +Allgemein: Installation von Live-USB-Stick. +Kopiere iso-Image auf USB-Stick. Am einfachstenunter Ubuntu mit dem "Startmedienersteller" + +### Ubuntu + +Herunterladen über offizielle Internetseite von Ubuntu + +### LUbuntu + +Die Alternate-Variante hat eine besonders einfache Desktop-Umgebung. Die Installation von ROS ist trotzdem möglich. + +* LUbuntu 18.04: [lubuntu-18.04-alternate-amd64.iso](http://cdimage.ubuntu.com/lubuntu/releases/18.04/release/) +* LUbuntu 16.04: [lubuntu-16.04.1-alternate-amd64.iso](http://cdimage.ubuntu.com/lubuntu/releases/16.04/release/) + +### Kernel-Version der Linux-Distribution aktualisieren + +manche Distributionen kommen bereits mit einer Kernel-Version, die RT-unterstützt ist (z.B. LUbuntu 16.04.1 mit Kernel 4.4). Bei anderen ist dies nicht der Fall (z.B. LUbuntu 18.04 mit Kernel 4.15). + +Modifiziere die [Anleitung zur Installation des Kernels 4.19](http://ubuntuhandbook.org/index.php/2018/10/linux-kernel-4-19-released-install-ubuntu/): + +Nach Recherche des aktuellen Kernels: Hier z.B. 4.19.106, weil 4.19.106-rt45 die aktuellste RT-Patch-Version ist. + +Passe die Download-Liste an: Wähle "generic", weil durch den RT-Patch bessere Eigenschaften als bei der Variante "lowlatency" erreicht werden. + + $mkdir -p /tmp/kernel419 + $cd /tmp/kernel419 + $wget -c https://kernel.ubuntu.com/~kernel-ppa/mainline/v4.19.106/linux-headers-4.19.106-0419106_4.19.106-0419106.202002240333_all.deb + $wget -c https://kernel.ubuntu.com/~kernel-ppa/mainline/v4.19.106/linux-headers-4.19.106-0419106-generic_4.19.106-0419106.202002240333_amd64.deb + $wget -c https://kernel.ubuntu.com/~kernel-ppa/mainline/v4.19.106/linux-image-unsigned-4.19.106-0419106-generic_4.19.106-0419106.202002240333_amd64.deb + $wget -c https://kernel.ubuntu.com/~kernel-ppa/mainline/v4.19.106/linux-modules-4.19.106-0419106-generic_4.19.106-0419106.202002240333_amd64.deb + $sudo dpkg -i *.deb + +Anschließend sollte in diesen Kernel gebootet werden. Wenn das nicht funktioniert (aus Hardware-Inkompatibilität) braucht man gar nicht mit dem Echtzeitpatch weitermachen. Dafür neustarten und im Grub-Bootloader den Kernel auswählen. +Tipp: Teilweise muss man beim Booten Shift (links) drücken, damit der Bootloader angezeigt wird. + +## Konfiguration Teil 1 + +### Allgemeine Konfiguration + +Benutzer anlegen (hier am Beispiel des EtherCAT-Benutzers "ec") + + $sudo adduser ec + +SSH-Schlüssel für Benutzer erzeugen: https://wiki.ubuntuusers.de/SSH/#Authentifizierung-ueber-Public-Keys + + §ssh-keygen -t rsa -b 4096 -f ~/.ssh/RTPC_ec + §ssh-copy-id -i ~/.ssh/RTPC_ec.pub ec@10.144.130.83 + + +SSH-Profil auf Entwicklungsrechner anlegen: https://wiki.ubuntuusers.de/SSH/#ssh-config + + §nano ~/.ssh/config + +Hineinkopieren (IP-Adresse dabei anpassen) + + Host RTPC_ec + HostName 10.144.130.83 + Port 22 + User ec + IdentityFile ~/.ssh/RTPC_ec + +Optional: Paketquellen auf Uni-Server umstellen: http://mirrors.ubuntu.com/mirrors.txt +Je nach Inhalt ist der eingestellte Server auch z.B. us.archive.ubuntu.com. + + $sudo cp /etc/apt/sources.list /etc/apt/sources.list.orig + OLDMIRROR=http://de.archive.ubuntu.com/ubuntu/ + NEWMIRROR=http://ftp.rrzn.uni-hannover.de/pub/mirror/linux/ubuntu/ + $sudo sed -i "s|$OLDMIRROR|$NEWMIRROR|g" /etc/apt/sources.list + +Programme installieren + + $sudo apt-get install openssh-server sudo make gcc vim cmake + +## Echtzeit-Kernel installieren + +Die Umgebungsvariablen `KERNEL` und `RTPATCH` beschreiben die entsprechenden Versionen und sind abhängig vom installierten System (s.o.). + +Für Ubuntu 16.04.1 und Ubuntu 14.04.5 bspw folgende Werte. Diese Variablen müssen an die gewählten Versionen angepasst werden: + + KERNEL=4.4.66 + RTPATCH=4.4.66-rt79 + +### Konfigurieren + +Abhängigkeiten dafür installieren + + sudo apt-get install bison flex + +Kernel-Quellen herunterladen + + $uname -a + + $mkdir -p ~/src + $cd ~/src + $wget https://www.kernel.org/pub/linux/kernel/v4.x/linux-$KERNEL.tar.gz + + $tar xvzf linux-$KERNEL.tar.gz + +RT-Patch. Suche in https://www.kernel.org/pub/linux/kernel/projects/rt +Die Zahl "4.4" muss ggf. noch angepasst werden. +Herunterladen und entpacken: + + $wget https://www.kernel.org/pub/linux/kernel/projects/rt/4.4/patch-$RTPATCH.patch.gz + $gzip -d patch-$RTPATCH.patch.gz + +Patch anwenden: +http://linux-sxs.org/upgrading/patching.html + + $cd linux-$KERNEL + $cat ../patch-$RTPATCH.patch | patch -p1 + +Konfigurieren: Option "5" wählen (Fully Preemptible Kernel (RT) (PREEMPT_RT_FULL)). Den Rest auf Standard lassen (Enter gedrückt halten) + + $cp /boot/config-$(uname -r) .config && make oldconfig + +Setze parameter CONFIG_MODULE_SIG = No + + $nano .config + +### Kompilieren + +Bauen: https://wiki.ubuntuusers.de/Kernel/Kompilierung/ + +Abhängigkeiten installieren: + + $sudo apt-get install libssl-dev kernel-package + +Kompilieren + + $sed -rie 's/echo "\+"/#echo "\+"/' scripts/setlocalversion + $make-kpkg clean + $CONCURRENCY_LEVEL=$(getconf _NPROCESSORS_ONLN) fakeroot make-kpkg --initrd --revision=0 kernel_image kernel_headers + +### Installieren + +Installation + + $sudo dpkg -i ../linux-{headers,image}-$RTPATCH_*.deb + +### Standard-Booteintrag ändern (RT-Kernel soll automatisch geändert werden) + +Anpassen der Werte: https://wiki.ubuntuusers.de/GRUB_2/Konfiguration/#Bedeutung-der-Variablen + + $sudo nano /etc/default/grub + +#### Alternative 1: Standard-Boot-Eintrag speichern und einmal händisch in den RT-Kernel Booten + + GRUB_DEFAULT=saved + GRUB_SAVEDEFAULT=true + +Übernehmen + + $sudo update-grub + +Anschließend kann in den RT-Kernel geboot werden (Auswahl des Eintrags im GRUB-Menü) + +#### Alternative 2: Standard-Boot-Eintrag statisch festlegen. + +Namen des Boot-Eintrags herausfinden: Suche nach Stichwort "-rt" + + $nano /boot/grub/grub.cfg + +Liefert (z.B.): "Ubuntu, with Linux 4.19.106-rt45". Einsetzen in Grub-Eintrag (englische Lokalisierung vorausgesetzt): + + GRUB_DEFAULT="Previous Linux versions>Ubuntu, with Linux 4.19.106-rt45" + +Testweise übernehmen: + + $sudo update-grub + +Liefert (in diesem Beispiel): + + Warning: Please don't use old title `Previous Linux versions>Ubuntu, with Linux 4.19.106-rt45' for GRUB_DEFAULT, use `Advanced options for Ubuntu>Ubuntu, with Linux 4.19.106-rt45' (for versions before 2.00) or `gnulinux-advanced-1c2a0fb0-7a54-456d-8c60-830a6ed6feac>gnulinux-4.19.106-rt45-advanced-1c2a0fb0-7a54-456d-8c60-830a6ed6feac' (for 2.00 or later) + +Neuen korrekten Wert eintragen (für dieses Beispiel): + + GRUB_DEFAULT="gnulinux-advanced-1c2a0fb0-7a54-456d-8c60-830a6ed6feac>gnulinux-4.19.106-rt45-advanced-1c2a0fb0-7a54-456d-8c60-830a6ed6feac" + +Übernehmen + + $sudo update-grub + +Anschließend wird automatisch in den Echtzeit-Kernel gebootet (Keine manuelle Auswahl des Eintrags im GRUB-Menü erforderlich). + + $sudo reboot now + +## Konfiguration Teil 2 + +Nutzerrechte setzen + + $sudo addgroup realtime + $sudo adduser ec realtime + +Prioritäten + + $sudo nano /etc/security/limits.conf + +Eintragen der folgenden Zeilen. + + @realtime soft rtprio 99 + @realtime soft priority 99 + @realtime soft memlock 102400 + @realtime hard rtprio 99 + @realtime hard priority 99 + @realtime hard memlock 102400 + +Energiesparmodi deaktivieren + + $sudo apt-get install sysfsutils + +CPU-Frequenz und -energieverhalten +https://wiki.ubuntuusers.de/Prozessortaktung/ + + +Anzahl CPUs bestimmen: + + $ls /sys/devices/system/cpu/ | grep cpu + + +Konfiguration bearbeiten: + + $sudo nano /etc/sysfs.conf + +Füge in Datei ein (Anpassung an tatsächliche Anzahl CPUs) + + devices/system/cpu/cpu0/cpufreq/scaling_governor = performance + devices/system/cpu/cpu1/cpufreq/scaling_governor = performance + devices/system/cpu/cpu2/cpufreq/scaling_governor = performance + devices/system/cpu/cpu3/cpufreq/scaling_governor = performance + devices/system/cpu/cpu4/cpufreq/scaling_governor = performance + devices/system/cpu/cpu5/cpufreq/scaling_governor = performance + devices/system/cpu/cpu6/cpufreq/scaling_governor = performance + devices/system/cpu/cpu7/cpufreq/scaling_governor = performance + +Kernel-Argumente für CPU + + $sudo nano /etc/default/grub + +In Zeile GRUB_CMDLINE_LINUX_DEFAULT ergänzen: + + processor.max_cstate=1 idle=poll + +Aktualisieren + + $sudo update-grub + +## Quellen + +Die folgenden Quellen bieten einen Einstieg in ein tieferes Verständnis der Echtzeit-PC Konfiguration: + +* [Linux-Magazin: Harte Echtzeit mit Linux durch Preempt-RT zum Messen und Steuern](https://www.linux-magazin.de/ausgaben/2017/03/echtzeit-praxis/2/) +* [HOWTO setup Linux with PREEMPT_RT properly](https://wiki.linuxfoundation.org/realtime/documentation/howto/applications/preemptrt_setup) +