UART-Kommunikation zwischen Raspberry Pi 4 und HiFive1 Boards herstellen

In diesem Lab richten Sie zuverlässige UART-Verbindungen zwischen Raspberry Pi 4 und HiFive1 ein, programmieren den HiFive1 zum Echo empfangener Daten und erstellen ein Python-Skript auf dem Pi zur Weiterleitung von Lenkwinkeln an das Board.

Teil 0: UART auf Raspberry Pi 4 aktivieren

Der Pi 4 hat vier UART-Controller. Für diese Übung nutzen wir uart2 und uart3. Folgende Zeile zu /boot/config.txt hinzufügen und rebooten:

dtoverlay=uart2,115200
dtoverlay=uart3,115200

Nach Reboot stehen Device-Nodes /dev/ttyAMA1 (uart2) und /dev/ttyAMA2 (uart3) bereit.

Boards wie folgt verbinden:

• HiFive1 UART1 RX (Pin 7) ↔ Pi 4 UART2 TX (Pin 27) – Datenpfad für Lenkkommandos.
• HiFive1 UART0 TX (Pin 1) ↔ Pi 4 UART3 RX (Pin 29) – Debug-Kanal für Console-Output.

Vom Pi aus Zugriff via /dev/ttyAMA1 (Senden an HiFive1) und /dev/ttyAMA2 (Empfang HiFive1 Console).

Teil 1: HiFive1 programmieren

Auf Ihrem PC (nicht dem Pi) Skeleton-Projekt herunterladen:

$ cd ~/Documents/PlatformIO
$ wget https://ittc.ku.edu/~heechul/courses/eecs388/l10-comm.tar.gz
$ tar zxvf l10-comm.tar.gz

l10-interrupt Ordner zu VSCode Workspace hinzufügen. Ziel: Daten von UART1 lesen, auf UART0 echoen, Ergebnis auf Console printen.

Kurz-Algorithmus:

while (1) {
    if (ser_isready(1)) {
        char data = ser_read(1);
        ser_write(0, data);
        ser_printline(0, "Received: ");
        /* Formatierung nach Bedarf anpassen */
    }
}

Serial API definiert in eecs388_lib.h/c:

void ser_setup(int devid);
int ser_isready(int devid);
void ser_write(int devid, char c);
void ser_printline(int devid, char *str);
char ser_read(int devid);
int ser_readline(int devid, int n, char *str);

Beachten Sie: devid = 0 wählt UART0, devid = 1 wählt UART1. ser_isready prüft UART IP Register auf pending Daten:

int ser_isready(int devid) {
    uint32_t regval = *(volatile uint32_t *)(UART_ADDR(devid) + UART_IP);
    return regval;
}

Nach Kompilieren und Flashen, auf Pi wechseln und zwei Terminals öffnen:

• Data Sender: screen /dev/ttyAMA1 115200
• Debug Viewer: screen /dev/ttyAMA2 115200

Beliebigen String im Sender-Terminal eingeben; derselbe String sollte im Debug-Terminal erscheinen – bestätigt korrekte Operation.

Teil 2: Python-Skript auf Raspberry Pi 4

Statt manueller Terminals Python-Programm schreiben, das:

• /dev/ttyAMA1 zum Senden von Lenkwinkeln öffnet.
• /dev/ttyAMA2 für Debugging öffnet.
• Kamera-Frames erfängt, DNN-Inferenz läuft, resultierenden Winkel an HiFive1 sendet.

Beispiel-Skeleton mit pySerial:

import serial
import time
import cv2  # oder Ihr Kamera-Interface

# Serielle Ports öffnen
ser1 = serial.Serial('/dev/ttyAMA1', 115200, timeout=1)
ser2 = serial.Serial('/dev/ttyAMA2', 115200, timeout=1)

while True:
    # Frame erfassen
    frame = cv2.imread('frame.jpg')  # durch echten Kamera-Read ersetzen
    # DNN Inferenz
    angle = dnn_inference(frame)  # float32
    # Float zu 4-Byte Representation konvertieren
    angle_bytes = angle.to_bytes(4, byteorder='little', signed=True)
    ser1.write(angle_bytes)
    # Optional: Debug-Output lesen
    debug = ser2.readline().decode().strip()
    if debug:
        print('HiFive1:', debug)
    # Timing Control (z. B. 30 fps)
    time.sleep(1/30)

# Cleanup
ser1.close()
ser2.close()

Hinweis: Float vor Senden in Bytes konvertieren, und gleiche Byte-Order auf HiFive1 beim Interpretieren nutzen.

Anhang: Raspberry Pi 4 GPIO und Peripherie-Überblick

Pi 4 bietet erweiterte I²C, SPI und UART Interfaces über originale Pi-Modelle hinaus. pinout Befehl zeigt alle Pins:

pinout

Wichtige Peripherie:

• I²C – bis zu 6 Busse, Geräte entdecken mit sudo i2cdetect -y 1.
• SPI – via raspi-config aktivieren, Standard SCLK/MOSI/MISO Lines nutzen.
• UART – asynchrone Serial, ideal für headless Kommunikation oder Mikrocontroller-Anbindung wie HiFive1.

Für detaillierte Konfiguration offizielle Raspberry Pi Dokumentation konsultieren: Config-txt Guide.