UART-Serielle Kommunikationsexperiment basierend auf Raspberry Pi 4B und STM32

Globaler Lieferant elektronischer Komponenten AMPHEO PTY LTD: Umfangreiches Inventar für One-Stop-Shopping. Einfache Anfragen, schnelle, individuelle Lösungen und Angebote.

Dieses Experiment zeigt, wie eine UART (Universal Asynchronous Receiver/Transmitter)-serielle Kommunikation zwischen einem Raspberry Pi 4B und einem STM32-Mikrocontroller aufgebaut wird.

UART-Serielle Kommunikationsexperiment basierend auf Raspberry Pi 4B und STM32 - Blog - Ampheo

Hardware-Anforderungen

Raspberry Pi 4B
STM32-Entwicklungsboard (z.B. STM32F103C8T6, STM32F407 usw.)
USB-zu-TTL-Seriell-Wandler (falls benötigt)
Jumper-Kabel
Steckbrett (optional)

Verbindungsdiagramm

Raspberry Pi 4B          STM32
---------------------------------
GPIO 14 (TXD)  ------>  USART_RX (z.B. PA3)
GPIO 15 (RXD)  <------  USART_TX (z.B. PA2)
GND           ------>  GND

Hinweis: Stellen Sie sicher, dass beide Geräte eine gemeinsame Masseverbindung haben.

Raspberry Pi-Einrichtung

1. UART auf dem Raspberry Pi aktivieren

Bearbeiten Sie die Konfigurationsdatei:

sudo nano /boot/config.txt

Fügen Sie folgende Zeilen hinzu oder ändern Sie sie:

enable_uart=1
dtoverlay=disable-bt

Starten Sie den Pi neu:

sudo reboot

2. Notwendige Tools installieren

sudo apt-get install python3-serial

3. Python-Code für den Raspberry Pi

import serial
import time

# Seriellen Port konfigurieren
ser = serial.Serial(
    port='/dev/serial0',  # Standard-UART-Port
    baudrate=115200,
    parity=serial.PARITY_NONE,
    stopbits=serial.STOPBITS_ONE,
    bytesize=serial.EIGHTBITS,
    timeout=1
)

try:
    while True:
        # Daten an STM32 senden
        message = "Hallo STM32 vom Raspberry Pi!\n"
        ser.write(message.encode())
        print(f"Gesendet: {message.strip()}")
        
        # Daten von STM32 empfangen
        if ser.in_waiting > 0:
            received_data = ser.readline().decode('utf-8').strip()
            print(f"Empfangen: {received_data}")
        
        time.sleep(1)

except KeyboardInterrupt:
    print("Kommunikation gestoppt")
    ser.close()

STM32-Einrichtung (mit HAL-Bibliothek)

1. CubeMX-Konfiguration

USART-Peripheriegerät im asynchronen Modus aktivieren
Baudrate konfigurieren (muss mit dem Raspberry Pi übereinstimmen, z.B. 115200)
USART-Global-Interrupt aktivieren (optional für interrupt-basierten Empfang)

2. STM32-Code-Beispiel

#include "stm32f1xx_hal.h"

UART_HandleTypeDef huart1;

void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART1_UART_Init(void);

int main(void) {
    HAL_Init();
    SystemClock_Config();
    MX_GPIO_Init();
    MX_USART1_UART_Init();
    
    char rxBuffer[100];
    char txBuffer[100];
    
    while (1) {
        // Daten vom Raspberry Pi empfangen
        HAL_UART_Receive(&huart1, (uint8_t*)rxBuffer, sizeof(rxBuffer), HAL_MAX_DELAY);
        
        // Empfangene Daten verarbeiten (Beispiel: Echo zurücksenden)
        sprintf(txBuffer, "Echo: %s", rxBuffer);
        
        // Antwort an Raspberry Pi senden
        HAL_UART_Transmit(&huart1, (uint8_t*)txBuffer, strlen(txBuffer), HAL_MAX_DELAY);
        
        // Puffer leeren
        memset(rxBuffer, 0, sizeof(rxBuffer));
        memset(txBuffer, 0, sizeof(txBuffer));
        
        HAL_Delay(1000);
    }
}

// USART1-Initialisierungsfunktion
static void MX_USART1_UART_Init(void) {
    huart1.Instance = USART1;
    huart1.Init.BaudRate = 115200;
    huart1.Init.WordLength = UART_WORDLENGTH_8B;
    huart1.Init.StopBits = UART_STOPBITS_1;
    huart1.Init.Parity = UART_PARITY_NONE;
    huart1.Init.Mode = UART_MODE_TX_RX;
    huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    if (HAL_UART_Init(&huart1) != HAL_OK) {
        Error_Handler();
    }
}

// Fehlerbehandlungsfunktion und andere notwendige Funktionen würden hier stehen

Test der Kommunikation

Laden Sie den Code auf Ihr STM32-Board hoch
Führen Sie das Python-Skript auf dem Raspberry Pi aus:
bash
```
python3 uart_communication.py
```
Sie sollten Nachrichten sehen, die zwischen den Geräten ausgetauscht werden

Fehlerbehebung

Keine Kommunikation:
- Überprüfen Sie die Kabelverbindungen
- Stellen Sie sicher, dass die Baudraten auf beiden Geräten übereinstimmen
- Stellen Sie sicher, dass eine gemeinsame Masseverbindung besteht
Verzerrte Daten:
- Überprüfen Sie die Baudraten-Einstellungen
- Überprüfen Sie die Spannungspegel (RPi ist 3,3V, STM32 kann 3,3V oder 5V sein - ggf. Pegelwandler verwenden)

Zugriffsverweigerungsfehler auf dem Raspberry Pi:

sudo usermod -a -G dialout pi
sudo chmod a+rw /dev/serial0

Erweiterte Optionen

Implementieren Sie interrupt-basierten Empfang auf dem STM32 für bessere Leistung
Fügen Sie Protokoll-Rahmen hinzu (z.B. Start-/Endmarkierungen, Prüfsummen) für zuverlässige Kommunikation
Verwenden Sie DMA für Hochgeschwindigkeits-Datenübertragung
Implementieren Sie Flusskontrolle bei Bedarf (RTS/CTS)

Dieses grundlegende UART-Kommunikationssetup kann als Grundlage für komplexere Embedded-System-Projekte dienen, die die Fähigkeiten von Raspberry Pi und STM32 kombinieren.