Code-Anleitung: Wie Sie die RS485 Schnittstelle mit einem Raspberry PI direkt in C auslesen!

Die RS485-Schnittstelle ist ein echtes Arbeitstier in der industriellen Automatisierung. Sie ermöglicht robuste und zuverlässige Kommunikation über weite Strecken und in störungsreichen Umgebungen. Wenn Sie einen Raspberry Pi in Ihren Projekten verwenden und direkt in C programmieren möchten, um diese Schnittstelle auszulesen, sind Sie hier genau richtig. Dieser Artikel führt Sie Schritt für Schritt durch die Hardware-Einrichtung, die notwendigen Software-Konfigurationen und zeigt Ihnen, wie Sie mit einem C-Programm Daten über RS485 senden und empfangen können.

Warum RS485, Raspberry Pi und C?

Die Vorteile von RS485

RS485 ist ein Standard für die serielle Datenübertragung, der sich durch seine Differenzialsignalisierung auszeichnet. Das bedeutet, Daten werden als Spannungsdifferenz zwischen zwei Leitungen (A und B) übertragen, anstatt gegen eine gemeinsame Masse. Dies macht die Kommunikation extrem unempfindlich gegenüber elektromagnetischen Störungen und ermöglicht Übertragungsdistanzen von bis zu 1200 Metern bei Datenraten von bis zu 10 Mbit/s. Ein weiterer großer Vorteil ist die Möglichkeit, mehrere Geräte an einem gemeinsamen Bus zu betreiben (Multidrop-Fähigkeit), wobei bis zu 32 Transceiver (oder mehr mit Repeatern) kommunizieren können.

Der Raspberry Pi als Kommandozentrale

Der Raspberry Pi ist weit mehr als nur ein Hobby-Computer. Seine kompakte Größe, seine leistungsstarke Hardware, die auf einem Linux-Betriebssystem läuft, und die vielseitigen GPIO-Pins (General Purpose Input/Output) machen ihn zur idealen Plattform für industrielle Steuerungs- und Überwachungsanwendungen. Er bietet eine kostengünstige und flexible Lösung, um Daten von Sensoren, PLCs oder anderen Systemen über Schnittstellen wie RS485 zu erfassen und zu verarbeiten.

Die Kraft von C für direkte Hardware-Kontrolle

Während Python auf dem Raspberry Pi sehr beliebt ist, bietet C Programmierung entscheidende Vorteile, wenn es um die direkte Interaktion mit Hardware und performance-kritische Anwendungen geht. C-Code ist oft schneller, speichereffizienter und ermöglicht eine tiefere Kontrolle über die Systemressourcen. Für die serielle Kommunikation, insbesondere wenn es auf präzises Timing oder die Verarbeitung großer Datenmengen ankommt, ist C oft die bevorzugte Wahl. Es ermöglicht den direkten Zugriff auf die Linux-Systemaufrufe für die serielle Schnittstelle, was maximale Flexibilität und Leistung bietet.

Hardware-Einrichtung: Raspberry Pi und RS485-Modul

Bevor wir uns dem Code widmen, müssen wir die Hardware korrekt einrichten.

Benötigte Komponenten:

• Raspberry Pi (jedes Modell mit GPIO-Pins und UART ist geeignet, z.B. Raspberry Pi 3, 4 oder Zero W)
• RS485 Transceiver-Modul (z.B. basierend auf MAX485, SP3485 oder SN75176). Diese Module wandeln die TTL-Signale des Raspberry Pi in die RS485-Differenzialsignale um.
• Jumper-Kabel
• Optional: Ein zweites RS485-Gerät zum Testen (z.B. ein weiterer Pi mit Modul, ein Modbus-Sensor etc.)

Schaltplan und Verkabelung:

Die serielle Schnittstelle (UART) des Raspberry Pi befindet sich auf den GPIO-Pins. Standardmäßig sind GPIO14 (TXD) und GPIO15 (RXD) dafür vorgesehen. Ein RS485-Transceiver-Modul benötigt üblicherweise folgende Anschlüsse:

• VCC (5V oder 3.3V, je nach Modul – der Pi liefert beides)
• GND (Masse)
• RO (Receiver Output) – wird mit dem RXD (GPIO15) des Raspberry Pi verbunden
• DI (Driver Input) – wird mit dem TXD (GPIO14) des Raspberry Pi verbunden
• DE (Driver Enable) – Aktiviert den RS485-Treiber (Senden)
• RE (Receiver Enable) – Aktiviert den RS485-Empfänger (Empfangen)
• A (RS485+ Leitung)
• B (RS485- Leitung)

Wichtiger Hinweis zu DE und RE: Da RS485 oft halbduplex ist (entweder senden oder empfangen), müssen DE und RE über einen GPIO-Pin des Raspberry Pi gesteuert werden. Viele Module haben DE und RE bereits gebrückt, sodass sie zusammen an einen GPIO-Pin angeschlossen werden können. Wenn dieser GPIO auf HIGH gesetzt wird, ist der Treiber aktiv (Senden), bei LOW der Empfänger (Empfangen). Achten Sie auf die Logik Ihres Moduls; manchmal ist RE aktiv-niedrig. Für unser Beispiel gehen wir davon aus, dass DE und RE gebrückt sind und ein HIGH-Signal zum Senden aktiviert.

Beispiel-Verkabelung (MAX485-Modul):

• Raspberry Pi GPIO14 (TXD) -> MAX485 DI
• Raspberry Pi GPIO15 (RXD) -> MAX485 RO
• Raspberry Pi GPIO [beliebiger freier GPIO, z.B. GPIO17] -> MAX485 DE/RE (gebrückt)
• Raspberry Pi 5V -> MAX485 VCC (oder 3.3V, je nach Modul)
• Raspberry Pi GND -> MAX485 GND
• MAX485 A -> RS485-Bus A
• MAX485 B -> RS485-Bus B

Vergessen Sie nicht die Abschlusswiderstände! An beiden Enden eines RS485-Busses sollte ein 120-Ohm-Widerstand angebracht werden, um Signalreflexionen zu vermeiden und die Signalintegrität zu gewährleisten.

Software-Konfiguration auf dem Raspberry Pi

Bevor wir mit dem C-Code starten, muss die UART-Schnittstelle des Raspberry Pi für unsere Zwecke vorbereitet werden.

1. UART aktivieren und Konsole deaktivieren

Standardmäßig kann die primäre UART-Schnittstelle des Raspberry Pi für die Systemkonsole verwendet werden, was sie für unsere Anwendung blockieren würde. Wir müssen dies ändern:

1. Öffnen Sie die Konfigurationsdatei mit sudo nano /boot/config.txt
2. Fügen Sie am Ende der Datei die Zeilen hinzu oder stellen Sie sicher, dass sie wie folgt konfiguriert sind:
   enable_uart=1
dtoverlay=disable-bt (deaktiviert Bluetooth, falls es die UART belegt, besonders bei Pi 3/4/Zero W)
   #dtoverlay=miniuart-overlay (optional, falls Sie die schnellere PL011-UART für Bluetooth belassen und die Mini-UART nutzen möchten – für die meisten Zwecke ist `disable-bt` einfacher)
3. Speichern und schließen Sie die Datei (Strg+X, Y, Enter).
4. Deaktivieren Sie die serielle Konsole:
   sudo raspi-config
   Gehen Sie zu „3 Interface Options” -> „P6 Serial Port” -> „Would you like a login shell to be accessible over serial?” -> „No” -> „Would you like the serial port hardware to be enabled?” -> „Yes”.
5. Starten Sie den Raspberry Pi neu: sudo reboot

Nach dem Neustart sollte die serielle Schnittstelle unter /dev/ttyS0 (oder /dev/ttyAMA0, je nach Pi-Modell und Konfiguration) verfügbar sein.

C-Programmierung für RS485

Nun geht es ans Eingemachte: Das C-Programm, um die RS485-Schnittstelle anzusteuern. Wir nutzen die Standard-Linux-Systemaufrufe für die serielle Kommunikation.

1. GPIO-Steuerung für DE/RE

Da wir den DE/RE-Pin des RS485-Moduls manuell steuern müssen, verwenden wir den sysfs-Ansatz, der es erlaubt, GPIO-Pins durch Schreiben in spezielle Dateien zu kontrollieren. Dieser Ansatz ist in C implementierbar und erfordert keine externen Bibliotheken wie `wiringPi` oder `libgpiod` für diesen Teil.

Wir definieren eine Funktion zum Steuern des GPIO-Pins. Für dieses Beispiel nehmen wir GPIO17 als DE/RE-Steuerpin.

„`c
#include
#include
#include
#include
#include
#include
#include

#define SERIAL_PORT „/dev/ttyS0” // Oder „/dev/ttyAMA0”
#define BAUDRATE B9600 // Baudrate für die Kommunikation
#define GPIO_DE_RE 17 // GPIO-Pin für DE/RE

// — GPIO-Steuerfunktionen —
int gpio_export(int gpio) {
char buffer[256];
int fd = open(„/sys/class/gpio/export”, O_WRONLY);
if (fd == -1) {
perror(„Fehler beim Öffnen von /sys/class/gpio/export”);
return -1;
}
snprintf(buffer, sizeof(buffer), „%d”, gpio);
write(fd, buffer, strlen(buffer));
close(fd);
return 0;
}

int gpio_set_direction(int gpio, const char *direction) {
char path[256];
char buffer[256];
snprintf(path, sizeof(path), „/sys/class/gpio/gpio%d/direction”, gpio);
int fd = open(path, O_WRONLY);
if (fd == -1) {
perror(„Fehler beim Öffnen des GPIO-Richtungspfads”);
return -1;
}
write(fd, direction, strlen(direction));
close(fd);
return 0;
}

int gpio_set_value(int gpio, int value) {
char path[256];
char buffer[2];
snprintf(path, sizeof(path), „/sys/class/gpio/gpio%d/value”, gpio);
int fd = open(path, O_WRONLY);
if (fd == -1) {
perror(„Fehler beim Öffnen des GPIO-Wertpfads”);
return -1;
}
snprintf(buffer, sizeof(buffer), „%d”, value);
write(fd, buffer, 1); // Wert ist nur ein Zeichen (‘0’ oder ‘1’)
close(fd);
return 0;
}

int gpio_unexport(int gpio) {
char buffer[256];
int fd = open(„/sys/class/gpio/unexport”, O_WRONLY);
if (fd == -1) {
perror(„Fehler beim Öffnen von /sys/class/gpio/unexport”);
return -1;
}
snprintf(buffer, sizeof(buffer), „%d”, gpio);
write(fd, buffer, strlen(buffer));
close(fd);
return 0;
}
„`

2. Serielle Port-Konfiguration und Kommunikation

Der Kern des Programms besteht aus dem Öffnen, Konfigurieren und Schließen des seriellen Ports, sowie dem Senden und Empfangen von Daten.

„`c
// Hauptprogramm
int main() {
int serial_port;
struct termios tty;

// — GPIO initialisieren für DE/RE —
printf(„Initialisiere GPIO%d für DE/RE-Steuerung…n”, GPIO_DE_RE);
if (gpio_export(GPIO_DE_RE) == -1) return 1;
if (gpio_set_direction(GPIO_DE_RE, „out”) == -1) {
gpio_unexport(GPIO_DE_RE);
return 1;
}
gpio_set_value(GPIO_DE_RE, 0); // Standardmäßig auf Empfangen (LOW) setzen

// — Seriellen Port öffnen —
serial_port = open(SERIAL_PORT, O_RDWR | O_NOCTTY | O_NDELAY);
if (serial_port < 0) { perror("Fehler beim Öffnen des seriellen Ports"); gpio_unexport(GPIO_DE_RE); return 1; } printf("Serieller Port %s erfolgreich geöffnet.n", SERIAL_PORT); // --- Serielle Port-Konfiguration --- if (tcgetattr(serial_port, &tty) != 0) { perror("Fehler beim Abrufen der seriellen Port-Attribute"); close(serial_port); gpio_unexport(GPIO_DE_RE); return 1; } // Löschen alter Flags, setzen neuer Flags tty.c_cflag &= ~PARENB; // Keine Parität tty.c_cflag &= ~CSTOPB; // 1 Stopbit tty.c_cflag &= ~CSIZE; // Maskiere Bit-Größen-Bits tty.c_cflag |= CS8; // 8 Datenbits tty.c_cflag &= ~CRTSCTS; // Kein Hardware-Flusskontrolle tty.c_cflag |= CREAD | CLOCAL; // Empfänger aktivieren, lokale Verbindung tty.c_iflag &= ~IGNBRK; // Kein Break ignorieren tty.c_iflag &= ~BRKINT; // Keine Break-Unterbrechung tty.c_iflag &= ~PARMRK; // Keine Paritätsfehler markieren tty.c_iflag &= ~ISTRIP; // Keine Zeichen von 8 auf 7 Bits strippen tty.c_iflag &= ~INLCR; // Keine Newline in Carriage Return konvertieren tty.c_iflag &= ~IGNCR; // Keine Carriage Return ignorieren tty.c_iflag &= ~ICRNL; // Keine Carriage Return in Newline konvertieren tty.c_iflag &= ~IXON; // Kein XON/XOFF tty.c_iflag &= ~IXOFF; // Kein XON/XOFF tty.c_iflag &= ~IXANY; // Kein XON/XOFF tty.c_lflag &= ~ECHO; // Kein Echo tty.c_lflag &= ~ECHONL; // Kein Echo für Newline tty.c_lflag &= ~ICANON; // Kein kanonischer Modus (Rohdaten) tty.c_lflag &= ~ISIG; // Keine Signalzeichen (INTR, QUIT, SUSP) tty.c_oflag &= ~OPOST; // Keine Nachbearbeitung des Outputs tty.c_oflag &= ~ONLCR; // Keine Newline zu CR/LF Konvertierung tty.c_cc[VTIME] = 1; // Warte bis zu 100ms (1 * 0.1s) für Zeichen tty.c_cc[VMIN] = 0; // Minimal 0 Zeichen zum Lesen // Baudrate setzen cfsetispeed(&tty, BAUDRATE); cfsetospeed(&tty, BAUDRATE); if (tcsetattr(serial_port, TCSANOW, &tty) != 0) { perror("Fehler beim Setzen der seriellen Port-Attribute"); close(serial_port); gpio_unexport(GPIO_DE_RE); return 1; } printf("Serieller Port konfiguriert: %s, Baudrate %d, 8N1.n", SERIAL_PORT, BAUDRATE); // --- Test-Kommunikation --- char tx_buffer[] = "Hallo RS485 Welt!n"; char rx_buffer[256]; int n_written = 0; int n_read = 0; printf("nSende-Modus aktivieren (DE/RE HIGH)...n"); gpio_set_value(GPIO_DE_RE, 1); // DE/RE auf HIGH (Senden) usleep(1000); // Kurze Verzögerung für Modul zum Umschalten printf("Sende Daten: "%s"n", tx_buffer); n_written = write(serial_port, tx_buffer, strlen(tx_buffer)); if (n_written < 0) { perror("Fehler beim Senden von Daten"); } else { printf("%d Bytes gesendet.n", n_written); } tcdrain(serial_port); // Warten, bis alle Daten gesendet wurden printf("Empfangs-Modus aktivieren (DE/RE LOW)...n"); gpio_set_value(GPIO_DE_RE, 0); // DE/RE auf LOW (Empfangen) usleep(1000); // Kurze Verzögerung printf("Warte auf eingehende Daten...n"); // Einlesen von Daten über eine Schleife // In einer echten Anwendung würde man hier in einer Endlosschleife lesen oder auf Events warten n_read = read(serial_port, rx_buffer, sizeof(rx_buffer) - 1); if (n_read < 0) { if (errno == EAGAIN || errno == EWOULDBLOCK) { printf("Keine Daten verfügbar.n"); } else { perror("Fehler beim Lesen von Daten"); } } else if (n_read > 0) {
rx_buffer[n_read] = ‘’; // Nullterminierung
printf(„%d Bytes empfangen: „%s”n”, n_read, rx_buffer);
} else {
printf(„Keine Daten empfangen (Timeout).n”);
}

// Optional: Kurz nach dem Empfangen weitere Lesevorgänge, falls mehr Daten erwartet werden
// usleep(500000); // Warte 0.5 Sekunden
// n_read = read(serial_port, rx_buffer, sizeof(rx_buffer) – 1);
// if (n_read > 0) {
// rx_buffer[n_read] = ‘’;
// printf(„Zusätzliche %d Bytes empfangen: „%s”n”, n_read, rx_buffer);
// }

// — Aufräumen —
printf(„nSchließe seriellen Port und de-initialisiere GPIO…n”);
close(serial_port);
gpio_unexport(GPIO_DE_RE);
printf(„Programm beendet.n”);

return 0;
}
„`

3. Kompilieren und Ausführen

Speichern Sie den Code als rs485_comm.c auf Ihrem Raspberry Pi. Um ihn zu kompilieren, verwenden Sie GCC:

gcc -o rs485_comm rs485_comm.c

Führen Sie das Programm mit Root-Rechten aus, da der Zugriff auf /dev/ttyS0 und /sys/class/gpio dies erfordert:

sudo ./rs485_comm

Wenn Sie ein zweites RS485-Gerät (z.B. einen anderen Raspberry Pi mit demselben Programm oder einen Modbus-Slave) angeschlossen haben, sollten Sie sehen, wie die Nachricht gesendet und möglicherweise eine Antwort empfangen wird.

Erläuterung des C-Codes

• Includes:
  • stdio.h, stdlib.h, string.h: Standard-Bibliotheken für Ein-/Ausgabe, Speicherverwaltung und String-Manipulation.
  • fcntl.h: Für Dateisteuerungsoptionen wie open().
  • termios.h: Die wichtige Bibliothek für die Konfiguration serieller Schnittstellen.
  • unistd.h: Für read(), write(), close() und usleep().
  • errno.h: Für Fehlercodes.
• SERIAL_PORT: Definiert den Pfad zu Ihrem seriellen Port. Prüfen Sie, ob es /dev/ttyS0 oder /dev/ttyAMA0 ist.
• BAUDRATE: Die Baudrate der Kommunikation, muss mit dem Kommunikationspartner übereinstimmen.
• GPIO_DE_RE: Der GPIO-Pin, den Sie für die DE/RE-Steuerung gewählt haben.
• GPIO-Funktionen (`gpio_export`, `gpio_set_direction`, `gpio_set_value`, `gpio_unexport`): Diese Funktionen kapseln den `sysfs`-Ansatz zur GPIO-Steuerung. Sie öffnen und schreiben in spezielle Systemdateien, um den GPIO-Pin zu konfigurieren (exportieren, als Ausgang setzen) und seinen Zustand zu ändern (HIGH/LOW).
• open(SERIAL_PORT, O_RDWR | O_NOCTTY | O_NDELAY):
  • O_RDWR: Öffnet den Port zum Lesen und Schreiben.
  • O_NOCTTY: Verhindert, dass das Betriebssystem den seriellen Port als steuerndes Terminal verwendet. Dies ist entscheidend.
  • O_NDELAY: Macht read() nicht blockierend. Wenn keine Daten vorhanden sind, kehrt read() sofort mit 0 Bytes oder einem Fehler zurück.
• tcgetattr() und tcsetattr(): Lesen und Schreiben der Terminaleinstellungen.
• struct termios tty: Die Struktur, die alle Einstellungen der seriellen Schnittstelle enthält:
  • c_cflag (Control Flags): Konfiguriert Baudrate, Datenbits, Stopbits, Parität, Hardware-Flusskontrolle, Aktivierung des Empfängers.
  • c_iflag (Input Flags): Konfiguriert die Eingabeverarbeitung (z.B. Ignorieren von Break-Bedingungen, Flusskontrolle XON/XOFF).
  • c_lflag (Local Flags): Konfiguriert den lokalen Modus (z.B. Echo, kanonischer Modus). Für Rohdatenkommunikation sind diese oft deaktiviert.
  • c_oflag (Output Flags): Konfiguriert die Ausgabeverarbeitung.
  • c_cc[VTIME] und c_cc[VMIN]: Legen das Verhalten von read() fest. VTIME=1 und VMIN=0 bedeuten, dass read() nach 0 Zeichen oder einem Timeout von 100ms zurückkehrt (nicht blockierend, aber mit kurzer Wartezeit).
• cfsetispeed() und cfsetospeed(): Setzen die Ein- und Ausgabe-Baudrate.
• write(): Sendet Daten. Vor dem Senden muss der DE/RE-Pin auf HIGH gesetzt werden.
• tcdrain(): Wartet, bis alle ausgehenden Daten aus dem Puffer gesendet wurden. Dies ist wichtig, bevor der DE/RE-Pin wieder auf Empfangen umgeschaltet wird, um die letzten Bits der Nachricht nicht abzuschneiden.
• read(): Empfängt Daten. Nach dem Senden (und tcdrain()) sollte der DE/RE-Pin auf LOW gesetzt werden, um den Empfang zu ermöglichen.
• Fehlerbehandlung: Wichtige Systemaufrufe werden auf Fehler überprüft, und bei Problemen werden entsprechende Meldungen ausgegeben und das Programm beendet.

Praktische Überlegungen und Fehlersuche

• Timing: Bei RS485 ist das präzise Umschalten zwischen Sende- und Empfangsmodus entscheidend. Die kleinen usleep()-Verzögerungen im Code sind wichtig, um dem Transceiver Zeit zum Umschalten zu geben. Je nach Modul und Baudrate kann dies variieren.
• Fehlerprüfung: Implementieren Sie in einer realen Anwendung CRC (Cyclic Redundancy Check) oder Prüfsummen, um die Integrität der empfangenen Daten zu gewährleisten.
• Multidrop-Kommunikation: Bei mehreren Geräten am Bus müssen Sie ein Protokoll (z.B. Modbus) implementieren, das Adressierung und Master/Slave-Kommunikation handhabt. Jedes Gerät muss eine eindeutige Adresse haben, und der Master steuert, welches Gerät wann sprechen darf.
• Baudrate: Stellen Sie sicher, dass die Baudrate des Raspberry Pi genau der des Kommunikationspartners entspricht.
• Kabel und Abschlusswiderstände: Schlechte Verkabelung oder fehlende/falsche Abschlusswiderstände sind häufige Fehlerursachen bei RS485. Überprüfen Sie diese sorgfältig.
• GPIO-Pin-Konflikte: Stellen Sie sicher, dass der für DE/RE gewählte GPIO-Pin nicht bereits von einem anderen Dienst oder Programm auf Ihrem Pi verwendet wird.
• Fehler beim Öffnen von `/dev/ttyS0`: Überprüfen Sie die Konfiguration in /boot/config.txt und raspi-config. Stellen Sie sicher, dass der Port nicht von der Konsole belegt ist.

Fazit

Sie haben nun einen umfassenden Einblick und eine detaillierte Anleitung erhalten, wie Sie die RS485-Schnittstelle mit einem Raspberry Pi direkt in C ansteuern und auslesen können. Von der Hardware-Einrichtung über die Software-Konfiguration bis hin zum vollständigen C-Code-Beispiel sind Sie jetzt in der Lage, Ihre eigenen industriellen Kommunikationslösungen zu entwickeln. Die Kombination aus der Robustheit von RS485, der Flexibilität des Raspberry Pi und der Performance von C schafft eine mächtige Plattform für anspruchsvolle Embedded-Systeme und IoT-Anwendungen.

Mit diesem Wissen können Sie nun beginnen, Daten von einer Vielzahl von RS485-Geräten zu erfassen, zu verarbeiten und in Ihre Projekte zu integrieren. Viel Erfolg bei der Entwicklung Ihrer seriellen Kommunikation!