BE-IIS-HPP-LIN

Zwei isolierte LIN-Kanäle für Raspberry Pi – vom direkten LIN-Zugriff bis zur eigenen Anwendungslogik.

Kommt in Kürze

MPN: BE-IIS-HPP-LIN

Was ist das BE-IIS-HPP-LIN?

Das BE-IIS-HPP-LIN ist ein HAT++ für LIN-Kommunikation mit zwei galvanisch getrennten LIN-Kanälen.

Ein Mikrocontroller auf dem Board übernimmt die zeitkritische LIN-Kommunikation. Dadurch muss Linux weder LIN-Timing erzeugen noch zeitkritisch auf einzelne Busereignisse reagieren.

Die Software ist bewusst in mehreren Schichten aufgebaut. Je nach Anwendung kann sehr hardwarenah oder auf einer deutlich höheren Anwendungsebene gearbeitet werden.

Die Software-Schichten

C- oder Python-Anwendung auf Linux
               |
               | Unix-Socket
               v
           beiis-lind
               |
               | Runtime-Daten + GPIO6-Interrupt
               v
        Queries / App-Worker
               |
               v
       direktes MicroPython
               |
               v
        natives C-LIN-Modul
               |
               v
           LIN1 / LIN2

Schicht 1 – natives C-LIN-Modul

Das native C-Modul ist die unterste Software-Schicht.

Hier werden die zeitkritischen LIN-Funktionen ausgeführt:

LIN initialisieren,
Master-Frame senden,
Slave-Antwort anfordern,
Slave-Antwort bereitstellen,
Master-Daten als Slave empfangen,
Checksumme und Bus-Timing behandeln.

Diese Schicht ist Teil der Firmware. Änderungen erfordern eine Firmware-Anpassung und einen neuen Build.

Geeignet für: neue zeitkritische LIN-Funktionen oder Funktionen, die direkt in die Firmware gehören.

Schicht 2 – direkter MicroPython-Zugriff

Für Anwender ist der direkte Zugriff über das MicroPython-Modul lin die niedrigste komfortable Ebene.

Beispiel:

import lin

lin.init(1, 19200)
lin.send(1, 0x12, b"\x11\x22\x33\x44", True)
data = lin.request(1, 0x22, 4, True)

MicroPython ruft dabei das native C-LIN-Modul auf. Das LIN-Timing bleibt daher weiterhin in der nativen Firmware.

Dieser Weg eignet sich besonders für Bring-up, Tests und Low-Level-Diagnose.

Geeignet für: direkten Zugriff auf einzelne LIN-Operationen.

Schicht 3 – Runtime, Queries und App-Worker

Für komplexere Anwendungen kann Logik auf dem Mikrocontroller ausgeführt werden.

Host
 ↓
TX-Query
 ↓
App- oder Native-Worker
 ↓
RX-Query
 ↓
Host

Eine Query transportiert Daten zwischen Host und Worker. Der Worker entscheidet, was diese Daten bedeuten.

Die Standard-Worker stellen weiterhin einzelne LIN-Operationen wie SEND oder REQUEST bereit. Ein eigener Worker kann jedoch eine höhere Anwendungsschicht abbilden, beispielsweise:

einen vollständigen Sensor oder Aktor simulieren,
mehrere LIN-Frames zu einer Funktion zusammenfassen,
Zustände verwalten,
auf Busereignisse reagieren,
Prüfabläufe selbstständig abarbeiten,
nur noch Ergebnisse oder Ereignisse an Linux melden.

Damit muss eine Host-Anwendung nicht zwangsläufig jeden einzelnen LIN-Befehl selbst auslösen.

Geeignet für: zustandsbehaftete Protokolle, Simulation, Testlogik und eigene Anwendungsfunktionen.

Schicht 4 – C- oder Python-Anwendung auf Linux

Normale Anwendungen greifen über den Unix-Socket auf beiis-lind zu.

C / Python / andere Anwendung
            |
            v
        beiis-lind
            |
            v
          Runtime

Die Anwendung muss dadurch weder I²C noch GPIO selbst bedienen.

Der Mikrocontroller signalisiert bereitstehende Daten über eine isolierte Interruptleitung an Raspberry Pi GPIO6. beiis-lind verwendet diesen Interrupt als Wakeup-Signal und liest anschließend die Daten über I²C.

Eine C- oder Python-Anwendung kann deshalb auf Daten warten, ohne selbst GPIO-Polling oder I²C-Polling implementieren zu müssen.

Geeignet für: normale Anwendungen, Testprogramme, Gateways und Automatisierung.

Aufbau des Repositorys

Das Repository ist entsprechend diesen Schichten aufgebaut.

be-iis-lin/
├── host/
│   ├── beiis_lin/
│   │   ├── daemon.py
│   │   ├── client.py
│   │   ├── socket_protocol.py
│   │   ├── i2c_transport.py
│   │   └── gpio_irq.py
│   └── tests/
│
├── stm32/
│   ├── boards/BEIIS_LIN_HAT/
│   │   ├── board_init.c
│   │   └── frozen/
│   │       └── beiis_runtime.py
│   │
│   ├── lib/
│   │   ├── lin/
│   │   └── app_i2c/
│   │
│   └── micropython/
│       ├── modules/
│       │   ├── lin/
│       │   └── appio/
│       │
│       └── apps/
│           ├── query.py
│           ├── lin_native.py
│           └── logging_native.py
│
├── protocol/
├── examples/
│   ├── runtime/
│   └── ip-over-lin/
│
├── scripts/
└── docs/human/

Linux-Anwendung und Socket

host/beiis_lin/ enthält die Linux-Seite.

client.py            Python-Client für Anwendungen
daemon.py            beiis-lind
socket_protocol.py   JSON-Protokoll über SOCK_SEQPACKET
i2c_transport.py     Transport zwischen Linux und Mikrocontroller
gpio_irq.py          GPIO6-Interrupt auf dem Raspberry Pi

Wenn eine Anwendung in Python oder C eingebunden werden soll, ist diese Schicht der wichtigste Einstieg.

Runtime auf dem Mikrocontroller

Die Runtime selbst liegt unter:

stm32/boards/BEIIS_LIN_HAT/frozen/beiis_runtime.py

Dort werden Instanzen gestartet, Nachrichten verteilt und die aktiven Runtime-Pfade verwaltet.

Die wiederverwendbaren Anwendungen liegen unter:

stm32/micropython/apps/

Wichtige Dateien:

query.py             generische TX-/RX-Query
lin_native.py        Runtime-Worker für LIN
logging_native.py    Logging-Worker

Direkter MicroPython-Zugriff

Die Python-Schnittstelle import lin wird durch das native MicroPython-Modul bereitgestellt:

stm32/micropython/modules/lin/

Dieses Modul verbindet MicroPython mit dem nativen C-LIN-Kern.

Native C-LIN-Schicht

Die eigentliche LIN-Implementierung liegt unter:

stm32/lib/lin/

Hier befinden sich die zeitkritischen Funktionen für Master, Slave, Checksumme und LIN-Frames.

Die boardspezifische Anbindung von UART, GPIO, LEDs, I²C und Host-Interrupt befindet sich in:

stm32/boards/BEIIS_LIN_HAT/board_init.c

Beispiele

Direkt ausführbare Beispiele befinden sich unter:

examples/runtime/

Dort liegen unter anderem:

python_basic.py
c_basic.c
custom_query_worker.py
install_custom_query.py
custom_query_client.py

Das separate Verzeichnis:

examples/ip-over-lin/

enthält das IP-over-LIN-Experiment. Es gehört nicht zur normalen LIN-Anwendungsschicht.

Installation und Protokolldokumentation

Die Standard-Runtime wird mit folgendem Skript eingerichtet:

scripts/install-standard-runtime.py

Das interne Runtime-Protokoll ist dokumentiert unter:

protocol/APP-RUNTIME.md

Ausführlichere Entwicklerdokumentation befindet sich unter:

docs/human/

Welche Schicht ist die richtige?

Einzelne LIN-Frames testen oder Hardware in Betrieb nehmen

→ direkter MicroPython-Zugriff oder die fertigen Beispiele unter Senden & Empfangen

Eine normale C- oder Python-Anwendung entwickeln

→ Socket-Schnittstelle über beiis-lind, siehe Python & C

Eine höhere Anwendungslogik auf dem Mikrocontroller ausführen

→ Runtime mit Queries und eigenem Worker, siehe Runtime & Queries

Neue zeitkritische Busfunktionen ergänzen

→ natives C-LIN-Modul in der Firmware

Weiterführende Dokumentation

Senden & Empfangen – Master TX, Master RX, Slave TX, Slave RX und Baudrate
Python & C – Einbindung in eigene Linux-Anwendungen
Runtime & Queries – Aufbau der Runtime und der internen Datenpfade
Eigene Queries & Logging – eigene Worker, Taps und erweiterte Anwendungen
Firmware & Flashing – Firmware bauen, aktualisieren und wiederherstellen

Verfügbarkeit: Kommt in Kürze.