Communication entre cartes

Dans cet atelier, vous établirez des canaux de communication basés sur UART entre les cartes Pi 4 et HiFive 1.

Partie 0 :Configurer les connexions UART (pour les TA)

Dans cette partie, nous allons connecter les cartes HiFive1 et Raspberry Pi 4 via deux canaux UART.

(Notez que cette étape sera effectuée par les TA.)

Le Pi 4 possède 4 UART et nous en utiliserons deux (uart2 et uart3). Ajoutez la ligne suivante à la fin du fichier /boot/config.txt pour activer uart2 et uart3.

dtoverlay=uart2,115200 dtoverlay=uart3,115200

Après avoir redémarré le système, /dev/ttyAMA1 et /dev/ttyAMA2 seront créés.

Connectez l'UART1 RX de HiFive (broche 7) à l'UART2 TX de Raspberry Pi 4 (broche 27). C'est la principale ligne de communication entre le Pi 4 et le HiFive1. Depuis le Pi 4, vous pouvez accéder au canal via /dev/ttyAMA1.

Pour le débogage de HiFive 1, connectez l'UART0 TX de HiFive1 (broche 1) à l'UART3 RX de Pi 4 (broche 29). Depuis le Pi 4, il est accessible via /dev/ttyAMA2.

En résumé, vous pourrez accéder aux deux fichiers suivants depuis le Pi 4.

/dev/ttyAMA1             Pi 4 → HiFive1 :envoyer l'angle de braquage à HiFive1 (uart1).

/dev/ttyAMA2             HiFive1 → Pi 4 :Recevoir la sortie de la console HiFive1 (uart0)

Partie 1 :Programmation du HiFive1

Dans cette partie du laboratoire, vous programmerez le HiFive1 pour recevoir des données du Pi 4.

Sur votre PC (pas Pi 4), téléchargez le squelette du projet comme suit.

$  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 dans l'espace de travail VSCode.

Votre tâche consiste à recevoir les données du canal UART1 de HiFive1 et à envoyer les données reçues au canal UART0. Ce qui suit est un pseudo code approximatif de la tâche.

tandis que  (1)  {

if  (est  UART1  prêt ?)  { data  = read  from  UART1. imprimer les données dans  UART0.

}

} Pour implémenter la tâche, vous devrez peut-être utiliser l'API série fournie illustrée ci-dessous. Notez que devid vaut 0 pour accéder à UART0, alors qu'il vaut 1 pour accéder à UART1.

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);

En particulier, vous devrez peut-être utiliser la fonction ser_isready() pour vérifier si un canal UART donné a des données en attente à lire. Pour mieux comprendre ce que font les fonctions, consultez les fichiers eecs388_lib.h et eecs388_lib.c.

int     ser_isready(int devid)

{

uint32_t regval =*(volatile uint32_t *)(UART_ADDR(devid) + UART_IP); retour regval ;

}

Une fois la programmation du HiFive1 terminée, passez au Raspberry Pi 4 et ouvrez deux terminaux :un pour envoyer des données au HiFive1 et un pour voir le message de débogage émis par le HiFive1.

Terminal de l'expéditeur (terme1)

$  screen  /dev/ttyAMA1  115200

Terminal de débogage (term2)

$  screen  /dev/ttyAMA2  115200

Maintenant, tapez n'importe quelle chaîne sur le 'term1'.

Si vous avez correctement programmé votre HiFive 1, vous devriez voir le message sortir du terminal « term2 ».

Partie 2 :Programmation du Raspberry Pi 4.

Au lieu d'utiliser des terminaux, vous exécutez maintenant un programme python sur le Pi 4 pour communiquer avec le HiFive1. Votre tâche consiste à étendre le dnn.py de l'atelier précédent pour pouvoir envoyer la sortie de pilotage au canal série /dev/ttyAMA1. Le pseudo code suivant donne une idée générale des modifications que vous devrez apporter à dnn.py :

Ouvrez les connexions en série vers  /dev/ttyAMA1 et  /dev/ttyAMA2 Tant que  True :

image  = camera.read()

angle  = dnn_inference(image) Écrivez  'angle’  dans  /dev/ttyAMA1 Wait_till_next_period()

Fermer les connexions  série

Pour obtenir la fonctionnalité ci-dessus, vous devez utiliser l'API pySerial de Python qui peut être utilisée en important le package série :

importer  série

Avec lui, vous devez créer deux canaux série séparés, un pour écrire sur HiFive1 via

/dev/ttyAMA1 et un autre pour le débogage sur /dev/ttyAMA2. Notez que les deux canaux doivent être ouverts avec un débit en bauds de 115 200 bps.

ser1  = serial.Serial(…) ser2  = serial.Serial(…)

Les angles reçus du DNN lors du traitement des trames peuvent ensuite être envoyés au HiFive1 en utilisant la fonction serial write() :

ser1.write(…)

Cependant, write () nécessite une valeur d'octet alors que l'angle produit par le DNN est une valeur float32, vous devrez donc convertir les données d'angle afin de les envoyer au HiFive1. Enfin, une fois toutes les trames traitées, les connexions série peuvent être fermées en appelant la fonction serial close() :

ser1.close() ser2.close()

Annexe

Mapping GPIO du Pi 4.

Brochetage Raspberry Pi 4

Non seulement le Raspberry Pi 4 regorge de nouvelles fonctionnalités matérielles, mais sous le capot, il y a quelques fonctions GPIO supplémentaires pour rendre la vie un peu plus facile, permettant aux utilisateurs d'étendre leurs périphériques à leurs projets sans nécessiter de matériel supplémentaire. Interfaces I2C, UART et SPI utilisables sur le Raspberry Pi 4.

Brochetage GPIO

Vous pouvez trouver une liste complète des brochages GPIO sur le Raspberry PI 4 lui-même, accédez simplement à la ligne de commande et tapez brochage .

Vous trouverez ci-dessous une liste de toutes les nouvelles fonctionnalités de brochage supplémentaires du Raspberry Pi 4 :

GPIO - Broches d'entrée/sortie à usage général

Ces broches numériques peuvent être programmées pour recevoir des entrées numériques ou émettre un signal numérique. Le Raspberry Pi utilise une logique 3V3 sur chaque broche GPIO, ce qui signifie que 3V3 est un 1 numérique (ON) et 0V est un 0 numérique (OFF). Par conséquent, vous pouvez connecter un composant numérique au Raspberry Pi et lui fournir un signal 3V3 (ON) ou recevoir un signal numérique 3V3 à condition que le courant ne dépasse pas 16 mA.

I2C – Circuit Inter-Intégré

C'est un type de communication assez courant entre les appareils, il fonctionne en ayant un maître et un esclave. Le maître dans ce cas est le Raspberry Pi lui-même et les appareils esclaves sont des périphériques matériels qui étendraient normalement les fonctionnalités de vos projets. Ce qui est génial avec I2C, c'est que vous pouvez connecter des centaines d'appareils au même maître en utilisant la même interface à deux fils, à condition que chaque appareil ait une adresse I2C différente. Vous pouvez accéder à l'interface et voir quels périphériques sont connectés en utilisant la commande Linux suivante :

sudo i2cdetect -y 1

Où "1" est l'interface maître. Le Raspberry Pi 4 en a 6 au total.

SPI - Interface périphérique série

SPI est un autre type de protocole de communication pour communiquer entre les appareils. Il utilise également une configuration maître/esclave, mais est principalement utilisé sur de courtes distances entre un contrôleur principal (maître) et des périphériques (esclaves) tels que des capteurs. SPI utilise généralement 3 fils pour communiquer avec le Raspberry Pi; SCLK, MOSI et MISO. Avant d'utiliser SPI, vous devez l'activer dans le menu de configuration du Raspberry Pi :

UART – Récepteur/Émetteur asynchrone universel

Contrairement à I2c et SPI, UART n'est pas un protocole. UART (Serial) est un circuit physique conçu pour transmettre et recevoir des données série. UART ne nécessite pas de signal d'horloge, c'est pourquoi il est asynchrone. Cela minimise les câbles nécessaires pour envoyer et recevoir des données, mais cela nécessite également l'envoi de données supplémentaires avec les paquets pour la vérification des erreurs, telles qu'un bit de démarrage et un bit d'arrêt. Généralement, en ce qui concerne le Raspberry Pi, l'UART est utilisé dans une configuration sans tête, ce qui signifie qu'il n'y a pas d'interface graphique ou autre interface. Au lieu de cela, vous pouvez connecter le Raspberry Pi à votre ordinateur de bureau/ordinateur portable ou à un autre appareil et communiquer avec lui via UART à l'aide de l'interface de ligne de commande. Cette méthode est destinée aux utilisateurs les plus avancés car elle nécessite un peu plus de savoir-faire pour la configurer.

Une autre application, typique des utilisateurs de Raspberry Pi, consiste à connecter une carte Arduino UNO au Raspberry Pi, car le Pi a des fonctionnalités analogiques limitées.