Établir une Communication UART entre Raspberry Pi 4 et Cartes HiFive1

Dans ce labo, vous mettrez en place des liaisons UART fiables entre un Raspberry Pi 4 et un HiFive1, programmerez le HiFive1 pour écho des données reçues, et créerez un script Python sur le Pi pour transmettre des angles de direction à la carte.

Partie 0 : Activer l'UART sur le Raspberry Pi 4

Le Pi 4 est livré avec quatre contrôleurs UART. Pour cet exercice, nous utiliserons uart2 et uart3. Ajoutez la ligne suivante à /boot/config.txt et redémarrez :

dtoverlay=uart2,115200
dtoverlay=uart3,115200

Après redémarrage, les nœuds de périphérique /dev/ttyAMA1 (uart2) et /dev/ttyAMA2 (uart3) seront disponibles.

Connectez les cartes comme suit :

• HiFive1 UART1 RX (broche 7) ↔ Pi 4 UART2 TX (broche 27) — chemin de données pour les commandes de direction.
• HiFive1 UART0 TX (broche 1) ↔ Pi 4 UART3 RX (broche 29) — canal de débogage pour la sortie console.

Depuis le Pi, vous pouvez accéder à ces canaux via /dev/ttyAMA1 (envoi vers HiFive1) et /dev/ttyAMA2 (réception console HiFive1).

Partie 1 : Programmer le HiFive1

Sur votre PC (pas le Pi), téléchargez le projet squelette :

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

Ajoutez le dossier l10-interrupt à votre espace de travail VSCode. Le but est de lire les données depuis UART1, les écho sur UART0, et afficher le résultat sur la console.

Voici un algorithme concis :

while (1) {
    if (ser_isready(1)) {
        char data = ser_read(1);
        ser_write(0, data);
        ser_printline(0, "Received: ");
        /* ajuster le formatage si nécessaire */
    }
}

L'API série est définie dans 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);

Rappelez-vous que devid = 0 sélectionne UART0 et devid = 1 sélectionne UART1. La fonction ser_isready vérifie le registre IP UART pour les données en attente :

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

Après compilation et flashage, passez au Pi et ouvrez deux terminaux :

• Expéditeur de données : screen /dev/ttyAMA1 115200
• Visualiseur de débogage : screen /dev/ttyAMA2 115200

Tapez n'importe quelle chaîne dans le terminal expéditeur ; la même chaîne devrait apparaître dans le terminal de débogage, confirmant le bon fonctionnement.

Partie 2 : Script Python sur le Raspberry Pi 4

Au lieu de terminaux manuels, écrivez un programme Python qui :

• Ouvre /dev/ttyAMA1 pour écrire les angles de direction.
• Ouvre /dev/ttyAMA2 pour le débogage.
• Capture des images de caméra, exécute l'inférence DNN, et envoie l'angle résultant au HiFive1.

Squelette d'exemple utilisant pySerial :

import serial
import time
import cv2  # ou votre interface caméra

# Ouvrir les ports série
ser1 = serial.Serial('/dev/ttyAMA1', 115200, timeout=1)
ser2 = serial.Serial('/dev/ttyAMA2', 115200, timeout=1)

while True:
    # Capturer une frame
    frame = cv2.imread('frame.jpg')  # remplacer par lecture caméra réelle
    # Exécuter l'inférence DNN
    angle = dnn_inference(frame)  # float32
    # Convertir float en représentation 4 octets
    angle_bytes = angle.to_bytes(4, byteorder='little', signed=True)
    ser1.write(angle_bytes)
    # Optionnel : lire la sortie de débogage
    debug = ser2.readline().decode().strip()
    if debug:
        print('HiFive1:', debug)
    # Contrôle de timing (ex. 30 fps)
    time.sleep(1/30)

# Nettoyage
ser1.close()
ser2.close()

Note : Convertissez le float en octets avant l'envoi, et utilisez le même ordre d'octets sur le HiFive1 lors de l'interprétation de la valeur.

Annexe : Vue d'ensemble GPIO et Périphériques du Raspberry Pi 4

Le Pi 4 offre des interfaces I²C, SPI et UART étendues au-delà des modèles Pi originaux. Utilisez la commande pinout pour voir toutes les broches :

pinout

Périphériques clés :

• I²C — jusqu'à 6 bus, découvrez les dispositifs avec sudo i2cdetect -y 1.
• SPI — activez via raspi-config, utilisez les lignes standard SCLK/MOSI/MISO.
• UART — série asynchrone, idéal pour la communication headless ou la connexion à des microcontrôleurs comme le HiFive1.

Pour une configuration détaillée, consultez la documentation officielle Raspberry Pi : Guide Config-txt.