Contrôler du matériel depuis un Raspberry Pi Une fois ses bus de communication maîtrisés, c'est incroyablement amusant et utile. Au quotidien, les principaux sont l'UART et l'I2C : l'un est le bus série asynchrone traditionnel ; l'autre, un bus synchrone à deux fils permettant de connecter plusieurs périphériques simultanément. Voici un guide clair et simple pour les utiliser sur Raspberry Pi.
En plus d'expliquer ce qu'ils sont et comment les activer, Vous découvrirez des configurations réelles sur Raspberry Pi. (console série, broches, outils), exemples pratiques en Python, détails précis sur le Bluetooth et le mini-UART dans certains modèles, et un section de diagnostic Pour les erreurs courantes comme la redoutable erreur d'E/S distante lors du mélange d'I2C et d'UART, nous avons également inclus l'approche Windows 10/IoT avec RhProxy et ACPI, au cas où vous travailleriez dans ce domaine.
Que sont UART et I2C et pourquoi devriez-vous vous en soucier ?
UART (récepteur-émetteur asynchrone universel) Il s'agit d'une interface série asynchrone qui transmet et reçoit des données sans horloge partagée. Elle utilise deux lignes dédiées : TX (expédition) y RX (réception)Puisqu'il n'y a pas d'horloge, les deux extrémités doivent s'accorder sur la même vitesse, c'est-à-dire la débit en bauds (Par exemple, 9 600 ou 115 200 bits/s). Comparé aux protocoles SPI ou I2C, il est plus simple à câbler, bien qu’il soit généralement plus lent et qu’il s’agisse de communications point à point.
De l'autre côté, nous avons I2C (circuit inter-intégré), un protocole série synchrone qui fonctionne avec seulement deux fils : SDA (données) et SCL (horloge). Chaque appareil sur le bus possède Adresse unique de 7 ou 10 bitsCela permet de connecter plusieurs capteurs, écrans ou périphériques de mémoire aux mêmes lignes. Il prend en charge différentes vitesses (100 kHz standard, 400 kHz rapide et des variantes supérieures telles que 3.4 Mbit/s). multi-maîtres Sous certaines conditions.
Dans la pratique, L'interface UART est idéale pour les consoles, les GPS, le Bluetooth ou les microcontrôleurs. qui communiquent en série classique ; l’I2C excelle pour la lecture de plusieurs capteurs avec un câblage minimal et une bonne intégration dans les projets IoT, robotique et automatisationLes deux fonctionnent à merveille ensemble sur Raspberry Pi, à condition de configurer correctement leurs broches et d'éviter les chevauchements.
Configuration UART sur Raspberry Pi : broches, console et touches
Sur le Raspberry Pi, L'interface UART principale est accessible via les broches GPIO14 (TXD) et GPIO15 (RXD). du connecteur à 40 broches. Par défaut, beaucoup images système activer le série de consoles Ces broches sont très utiles pour le débogage sans moniteur ni réseau. Historiquement, le SoC Broadcom comprend deux UART : UART0 (PL011, complet) y UART1 (mini-UART, tronqué).
Dans des modèles comme le Raspberry Pi 3, L'interface UART « performante » (PL011) est réservée au Bluetooth. et la console bascule sur le mini-UART. Cela a des conséquences : le mini-UART dépend de la fréquence du cœur, et pour qu’il soit stable, il est généralement définir core_freq=250Sinon, vous risquez de subir des variations de débit en bauds avec le régulateur de fréquence et de perdre des caractères à profusion.
Si vous souhaitez utiliser l'UART pour votre projet au lieu de la console, la procédure habituelle est la suivante : désactiver la console sérieVous avez plusieurs options : utiliser raspi-config dans Interfaces > Série, désactiver la connexion série (tout en conservant le matériel activé), ou manuellement en modifiant le fichier de configuration. /boot/cmdline.txt ôter console=serial0,115200 y redémarrerSur ce, Les broches GPIO 14 et 15 sont libres. pour votre candidature.
Une autre option très utile consiste à utiliser un Adaptateur USB-UARTDe nombreux câbles comportent quatre fils : rouge (5 V), noir (GND), blanc et vert (TX/RX). En utilisation typique avec le Raspberry Pi, Ne branchez pas le fil rouge. (Le Raspberry Pi est déjà auto-alimenté.) Connectez la masse (GND) à la masse (GND) et inversement (TX et RX). Connectez l'extrémité USB au Raspberry Pi pour communiquer avec une autre carte ou un autre Raspberry Pi via… /dev/ttyUSB0 o / dev / ttyACM0.
Pour tester la console série du Raspberry Pi lui-même à l'aide de l'adaptateur, Vous pouvez utiliser miniterm.py ou autre terminal série : miniterm.py /dev/ttyUSB0 115200Vous verrez l'invite de connexion (nom d'utilisateur). pi, mot de passe framboise (dans les systèmes classiques). Pour quitter miniterm dans l'exemple de l'atelier, utilisez Ctrl + AltGr + ]Si vous préférez un écran : écran /dev/ttyUSB0 115200 et tu sors avec Ctrl-A suivi de \.
I2C sur Raspberry Pi : activation, câblage et outils essentiels
I2C sur Raspberry Pi Il est accessible via les broches physiques 3 et 5 du connecteur (SDA1 et SCL1, correspondant à GPIO2 et GPIO3). La première étape consiste à l'activer. Sous Raspberry Pi OS, accédez à sudo raspi-config et, dans « Options avancées » ou « Options d’interface », activez I2CL'assistant propose de charger le module au démarrage.
Dans les configurations classiques, ils étaient ajoutés à / etc / modules les lignes i2c-bcm2708 e i2c-devLes images récentes d'aujourd'hui gèrent déjà les superpositions, mais i2c-dev Il demeure essentiel à l'espace utilisateur. Installez les utilitaires avec : mise à jour de sudo apt y sudo apt install i2c-tools python-smbus (o python3-smbus (selon votre version).
Pour vérifier que tout fonctionne, exécutez lsmod | grep i2c Vous verrez alors les modules chargés. Ensuite, identifiez le bus et explorez-le avec i2cdetect -y 1 (sur les très anciens modèles, c'était -et 0S'il existe des appareils correctement connectés et avec tractions Adapté aux normes SDA et SCL, le scan affichera des adresses telles que : MONITORING, MONITORING, etc.
N'oubliez pas que le bus I2C nécessite résistances de rappel en SDA et SCL (à 3.3 V sur le Pi) et que Toutes les masses doivent être unies (Masse commune). L'absence de résistances de rappel ou un câblage long/bruyant peuvent provoquer des problèmes intermittents ou des réponses négatives, notamment à 400 kHz et au-delà.
Communication I2C depuis Python (smbus/smbus2)
Pour interagir avec les périphériques I2C depuis Python, vous pouvez utiliser smbus o smbus2Installez-le si nécessaire avec pip installer smus2Un exemple simple d'écriture et de lecture à l'adresse MONITORING serait le suivant:
from smbus2 import SMBus
DEVICE_ADDRESS = 0x48 # Dirección I2C del dispositivo
bus = SMBus(1) # Bus I2C 1 en Raspberry Pi
# Escribir un byte (por ejemplo, 0x01) al dispositivo
bus.write_byte(DEVICE_ADDRESS, 0x01)
# Leer un byte del dispositivo
data = bus.read_byte(DEVICE_ADDRESS)
print(f"Dato leído: {data}")
bus.close()Ce modèle de écrire/lire Cela vous permet de vérifier que l'appareil répond. Si vous rencontrez un problème, Erreur d'E/S distante, normalement l'esclave Il ne reconnaît pas l'adresse ou l'enregistrement/la transaction envoyé(e), ou Les lignes SDA/SCL ne sont pas en bon état. (résistances de rappel, câblage, masse ou alimentation).
Communication UART avec Arduino : USB ou GPIO, à vous de choisir
Pour que Raspberry Pi et Arduino communiquent en série, la méthode la plus directe consiste à câble USBVous connectez l'Arduino au Raspberry Pi, et un port comme celui-ci apparaîtra. / dev / ttyACM0 o /dev/ttyUSB0C'est pratique et cela évite les problèmes de niveau et de console. Sinon, vous pouvez utiliser Broches GPIO (UART matériel) si vous désactivez la connexion série avec Raspi-config et vous laissez le matériel actif.
Installez la bibliothèque série Python avec sudo apt install python3-serial et localiser le port disponible avec ls /dev/tty*Dans Arduino, téléchargez un programme simple qui envoie du texte :
void setup() {
Serial.begin(9600);
}
void loop() {
Serial.println("Hello from Arduino!");
delay(1000);
}Sur le Raspberry Pi, un lecteur minimal avec pysérial Cela ressemblerait à ceci :
import serial
import time
ser = serial.Serial('/dev/ttyUSB0', 9600, timeout=1)
# Espera breve para que Arduino reinicie al abrir el puerto
time.sleep(2)
try:
while True:
if ser.in_waiting > 0:
data = ser.readline().decode('utf-8', errors='ignore').strip()
print(f"Received: {data}")
except KeyboardInterrupt:
ser.close()Pour envoyer des données du Raspberry Pi à l'Arduino, il suffit de... ser.write(b"Bonjour depuis Raspberry Pi !\n") et dans le sketch, lisez avec Serial.readStringUntil('\n')Il est vital que Les deux utilisent la même vitesse (baud), et il est conseillé d'attendre quelques secondes lors de l'ouverture du port afin que l'ATmega puisse redémarrer et éviter les "déchets" initiaux.
L'approche Windows 10/IoT : API utilisateur pour GPIO, I2C, SPI et UART avec RhProxy et ACPI
Si vous travaillez avec Windows 10/IoT Core ou Windows Enterprise, il existe un mécanisme pour Exposez les interfaces GPIO, I2C, SPI et UART au mode utilisateur. par l'intermédiaire d'un contrôleur appelé RhProxyL'idée est de déclarer, dans les tables ACPI (ASL/AML), les ressources SPB/GPIO autorisées à l'utilisateur, et RhProxy les rend accessibles via les API Windows.Devices.*. C'est l'approche utilisée par des cartes telles que… Framboise Pi 2/3 dans cet écosystème.
Le point de départ consiste à créer un nœud ACPI comme Dispositif (RHPX) avec _HID/_CID «MSFT8000» est notre valeur principale. _UIDet dans définir des ressources de type Bus série SP, Bus série I2C, Bus série UART et les GPIO autorisé à l'utilisateur. Dans le _DSD des propriétés sont associées à des éléments tels que bus-SPI-SPI0, SPI0-MinClockInHz, SPI0-MaxClockInHz, Longueurs de bits de données prises en charge par SPI0 o bus-I2C-I2C1afin que l'API puisse renvoyer un « contrôleur par défaut » pour chaque bus.
Pour I2C, un exemple de descripteur serait quelque chose comme I2CSerialBus(… «\_SB.I2C1» …), tandis que pour l'UART, vous avez Bus série UART avec des champs de baud initial, parité, tampons et l' Source de ressources du contrôleur. En SPI, chaque CE (sélection de puce) Elle est déclarée comme une ressource distincte, puis regroupée par bus dans le DSD avec des indices de ressources.
Un concept puissant dans ce contexte est le multiplexage des broches en temps réelGrâce aux ressources spéciales de l'ACPI Configuration de la fonction Msft(), les cadres GpioClx, SpbCx y SerCx Ils indiquent au contrôleur GPIO de modifier la fonction des broches lorsqu'un client déverrouille l'appareil (par exemple, DeIdAsync() (dans UWP). Si les broches étaient déjà utilisées par une autre fonction, l'ouverture échoue; lors de la fermeture du descripteur, il revient multiplexage.
Du point de vue du développeur de la plateforme, la validation Cela implique de vérifier auprès de devcon que les pilotes SpbCx/GpioClx/SerCx se chargent, que rhproxy existe dans le système (clé d'enregistrement de service), compilez l'ASL pour ACPITABL.dat avec asl.exe (mode /MsftInternal pour MsftFunctionConfig) et activer test de signatureVous pouvez ensuite lister les appareils des utilisateurs à l'aide d'outils comme I2cTestTool.exe -list, SpiTestTool.exe -list, GpioTestTool.exe -list o MinComm.exe -listet mettez-les en pratique avec des exemples d'exercices de lecture/écriture. Pour la certification, passez les tests de HLK (I2C WinRT, GPIO WinRT, SPI WinRT).
Utilisation simultanée des interfaces I2C et UART sans erreurs : diagnostics d’E/S à distance et autres surprises
Un cas typique : vous exécutez un programme qui parle à travers I2C avec capteur IMU (ITG/MPU) et un autre qui utilise UART avec un contrôleur (par exemple, SSC-32), et soudain le processus I2C explose avec Erreur d'E/S distanteCette erreur indique que l'enseignant ne reçoit pas ACK Sur le bus : l’appareil ne répond pas ou les lignes ne sont pas dans l’état correct.
Pour sortir des embouteillages, vérifiez les points suivants : 1) Console série désactivée Si vous utilisez les broches GPIO 14/15 pour votre propre UART ; 2) Sur Raspberry Pi 3 et dérivés, tenez compte de Désactiver le Bluetooth Si vous avez besoin que l'interface UART du PL011 soit stable, ou du moins fixe. fréquence_du_noyau=250 si vous tirez sur le mini-UART ; 3) Vérifiez GND commun parmi tous les équipements (Pi, IMU, contrôleur), et un manger sainement (Les IMU sont sensibles aux chutes de tension).
4) Vérifiez le Adressage I2C: scanner avec i2cdetect -y 1 et assurez-vous que l'adresse (par exemple, 0x68/0x69 sur de nombreuses centrales inertielles) apparaît. Si ce n'est pas le cas, vous devrez peut-être utiliser le mauvais bus, il y a un câble défectueux, ou le tractions5) Vérifiez le vitesse du bus (Si vous utilisez 400 kHz et que le montage se fait sur une plaque d'essai avec de longs fils, réduisez la fréquence à 100 kHz et effectuez un test.) 6) Évitez les conflits d'accès : bien que Linux autorise plusieurs processus sur /dev/i2c-1Si deux threads accèdent en parallèle sans se coordonner, cela peut provoquer des comportements inattendus ; utilisez serrures ou sérialise les opérations.
7) Si l'erreur apparaît au moment précis où le programme UART se charge ou augmente la charge du processeur, suspectez le problème suivant : mini-UART désynchronisé dû à la mise à l'échelle de la fréquence (symptôme dans Pi 3). Fixe fréquence_du_noyau=250 en /boot/config.txt ou libère le PL011 pour votre UART 8) Vérifiez que Vous ne partagez pas les épingles Entre autres : sous Windows/IoT, l’ouverture échouerait en raison du multiplexage ; sous Raspberry Pi OS, une superposition ou un service pourrait monopoliser certaines broches GPIO. 9) Enfin, validez le câblage physique: SDA avec SDA, SCL avec SCL, sans croisement, et TX–RX croisés en série.
Des tests rapides et des utilitaires qui vous sauvent la mise
Pour I2C, le trident de base est : i2cdetect -y 1 pour visualiser les appareils, i2cget/i2cset pour des lectures et écritures de registres simples, et un script de smbus2 pour valider le flux réel. Si i2cdetect Il ne détecte pas l'IMU, ne perdez pas votre temps avec ce code : Il y a un problème physique ou de superposition..
Pour l'UART, utilisez miniterm.py o à l'écran Utilisez-le comme terminal série et vérifiez que vous pouvez envoyer/recevoir à la vitesse choisie sans caractères étranges. En Python, pysérial avec délai d'attente et courte pause initiale Il évite généralement les relevés vides. Et si vous travaillez avec Windows IoT, devcon, ACPITABL.dat avec asl.exe et les outils d'exemple Outil de test I2c/Outil de test Spi/Outil de test Gpio/Commande minimale Ils vous offrent une visibilité totale.
Vous disposez désormais du schéma complet pour travailler avec I2C et UART. sur Raspberry OS (et également sur Windows/IoT le cas échéant) : de leur nature et de leur activation à leur utilisation en Python, la gestion de la console, les fonctionnalités UART sur le Pi 3 et le multiplexage des broches, jusqu’à la résolution de Errno 121 Une fois combinés, correctement configurés et avec un câblage propre, ces deux bus constituent des outils robustes pour tout projet de capteur, de robotique ou de contrôle.
