RS232-zu-TTL-Konvertermodul MAX3232, DB9-Buchse, Versorgung 3.3-5V, 4 TTL-Pins

Das RS232-zu-TTL-Modul mit MAX3232 stellt die Verbindung zwischen einer klassischen seriellen RS232-Schnittstelle mit DB9-Stecker und einem Mikrocontroller her, der mit logischen Pegeln von 3.3 V oder 5 V arbeitet. Sie setzen es ein, wenn Sie ältere oder industrielle Geräte anschließen möchten, etwa Laborgeräte, Lesegeräte, Router-Konsolen, GSM-Module oder SPS, oder wenn Sie mit einem COM-Port eines Computers kommunizieren möchten.

In diesem Tutorial verwenden wir ein Arduino Uno R3 Board, denn das Modul wandelt nur die Signalpegel um und benötigt einen Mikrocontroller, der die Daten sendet und empfängt. Der Test besteht aus einer seriellen Verbindung in beide Richtungen zwischen dem Arduino und einem Computer, über ein USB-zu-RS232-Kabel.

So funktioniert es:

Ein Mikrocontroller erzeugt TTL-Pegel, also 0 V für logisch 0 und 3.3 V oder 5 V für logisch 1. Der Standard RS232 verwendet andere Pegel und eine invertierte Logik: Eine logische 1 ist eine negative Spannung zwischen -3 V und -15 V, eine logische 0 ist eine positive Spannung zwischen +3 V und +15 V. Würden Sie einen RS232-Port direkt an einen Arduino-Pin anschließen, würden Sie die vom Pin verkraftbare Spannung überschreiten und ihn beschädigen können.

Der integrierte Schaltkreis MAX3232 (U1 auf der Platine) löst dieses Problem. Er besitzt zwei Treiber und zwei Empfänger, wobei das Modul nur einen Kanal nutzt. Eine Ladungspumpe aus den Kondensatoren C1 - C4 mit je 100 nF erzeugt aus der Versorgung von 3.3 - 5 V die positiven und negativen Spannungen, die die RS232-Leitung benötigt. Der Kondensator C5 filtert die Versorgung. Der Schaltkreis arbeitet zwischen 3.0 V und 5.5 V und erreicht 250 kbit/s.

Am DB9-Buchsenstecker ist Pin 2 der Sendeausgang des Moduls, Pin 3 der Empfangseingang und Pin 5 die Masse. Steuerleitungen zur Flusskontrolle gibt es nicht. Auf der TTL-Seite ist der Pin RXD der Ausgang des Moduls zum Empfangspin des Mikrocontrollers, und der Pin TXD ist der Eingang des Moduls vom Sendepin des Mikrocontrollers. Deshalb erfolgt die Verbindung direkt, RXD an RX und TXD an TX, ohne Kreuzung.

Bei 9600 Baud mit dem Format 8N1 belegt jedes Zeichen 10 Bit, also ein Startbit, acht Datenbits und ein Stoppbit. Die Dauer eines Bits beträgt 1 / 9600, also etwa 104 Mikrosekunden, und ein Zeichen dauert etwa 1.04 ms. Daraus ergeben sich rund 960 Zeichen pro Sekunde.

Anschluss:

Versorgen Sie das Modul über den Pin 5V des Arduino Uno, der TTL-Pegel von 5 V liefert, die zum Uno passen. Verwenden Sie ein Board mit 3.3 V, versorgen Sie das Modul ebenfalls mit 3.3 V. Das Arduino Board bleibt über USB vom Computer versorgt. Verbinden Sie die Pins des DB9-Steckers niemals direkt mit den Pins des Arduino. An den Arduino werden nur die vier Pins der TTL-Leiste angeschlossen, die mit GND, TXD, RXD und VCC gekennzeichnet sind.

Der DB9-Stecker des Moduls ist eine Buchse und passt direkt in einen DB9-Stecker, wie er am USB-zu-RS232-Kabel oder am COM-Port eines Computers vorhanden ist. Hat das angeschlossene Gerät ebenfalls eine Buchse, verwenden Sie ein Nullmodemkabel.

Wir haben die Pins D10 und D11 mit der Bibliothek SoftwareSerial gewählt, weil die Pins D0 und D1 des Uno Boards vom seriellen Hardware-Port belegt sind, der über USB mit dem Serial Monitor kommuniziert. So können Sie die Meldungen auf dem Computer sehen, ohne etwas abzuziehen.

Taster, Einstellungen und Anzeigen:

Das Modul hat keine Taster, Potentiometer, Jumper oder Schalter, es gibt also nichts einzustellen. Es besitzt eine einzige Anzeige und zwei Anschlüsse.

Nachdem Sie die Verbindungen hergestellt und den Arduino per USB angeschlossen haben, muss die LED D1 sofort aufleuchten. Dies ist das einzige sichtbare Zeichen dafür, dass das Modul versorgt wird. Um zu prüfen, ob auch die Datenübertragung funktioniert, verwenden Sie das folgende Programm.

Board und Bibliotheken:

Wählen Sie in der Arduino IDE das Board Arduino Uno unter Tools > Board aus dem Paket Arduino AVR Boards, das mit der Arduino IDE geliefert wird und im Boards Manager zu finden ist. Es muss keine Bibliothek installiert werden, denn SoftwareSerial gehört zur Arduino IDE.

Auf dem Computer benötigen Sie außerdem ein Terminalprogramm für den COM-Port des USB-zu-RS232-Kabels, zum Beispiel PuTTY unter Windows oder screen unter Linux und macOS.

Der Code:

Das Programm sendet alle zwei Sekunden eine nummerierte Meldung an den RS232-Port und zeigt alles, was es von dort empfängt, im Serial Monitor an. Außerdem wird alles, was Sie im Serial Monitor eingeben, auf der RS232-Leitung weitergeleitet.

/*
  RS232 to TTL converter module (MAX3232) - two-way serial test
  Board (Arduino IDE, Tools > Board): Arduino Uno
  Board package: Arduino AVR Boards (comes with the Arduino IDE)
  Libraries: none to install. SoftwareSerial is included with the Arduino IDE.
  Wiring:
    Module VCC -> Arduino 5V
    Module GND -> Arduino GND
    Module RXD -> Arduino D10 (SoftwareSerial RX)
    Module TXD -> Arduino D11 (SoftwareSerial TX)
    Module DB9 female -> USB to RS232 cable with DB9 male, connected to the PC
  Settings: 9600 baud, 8N1 on the Serial Monitor and on the terminal
  of the USB to RS232 cable (for example PuTTY).
*/
#include <SoftwareSerial.h>
const uint8_t RX_PIN = 10;                  // Arduino receives here (module RXD)
const uint8_t TX_PIN = 11;                  // Arduino transmits here (module TXD)
const unsigned long BAUD_RATE = 9600;       // Same speed on all sides
const unsigned long SEND_INTERVAL = 2000;   // Time between test messages in ms
const uint8_t BUFFER_SIZE = 64;             // Maximum length of a received line
SoftwareSerial rs232(RX_PIN, TX_PIN);       // Software serial port for the module
char rxBuffer[BUFFER_SIZE];                 // Buffer for the line received from RS232
uint8_t rxIndex = 0;                        // Current position in the buffer
unsigned long lastSendTime = 0;             // Time of the last test message
unsigned int counter = 0;                   // Number of test messages sent
void setup() {
  Serial.begin(BAUD_RATE);                  // USB serial port for the Serial Monitor
  rs232.begin(BAUD_RATE);                   // Serial port to the RS232 module
  Serial.println(F("RS232 to TTL test started at 9600 baud."));
  Serial.println(F("Open a terminal on the COM port of the USB-RS232 cable (9600, 8N1)."));
}
void loop() {
  // Read what arrives from the RS232 side and print it as a line
  while (rs232.available() > 0) {
    char c = rs232.read();
    if (c == '\n' || c == '\r') {
      if (rxIndex > 0) {                    // Ignore empty lines
        rxBuffer[rxIndex] = '\0';           // End the string
        Serial.print(F("Received from RS232: "));
        Serial.println(rxBuffer);
        rxIndex = 0;                        // Start a new line
      }
    } else if (rxIndex < BUFFER_SIZE - 1) {
      rxBuffer[rxIndex++] = c;              // Store the character
    }
  }
  // Forward what you type in the Serial Monitor to the RS232 side
  while (Serial.available() > 0) {
    rs232.write(Serial.read());
  }
  // Send a numbered test message at a fixed interval
  if (millis() - lastSendTime >= SEND_INTERVAL) {
    lastSendTime = millis();
    counter++;
    rs232.print(F("Hello from Arduino #"));
    rs232.print(counter);
    rs232.print(F("\r\n"));                 // Line end for the terminal
    Serial.print(F("Sent to RS232: Hello from Arduino #"));
    Serial.println(counter);
  }
}

So funktioniert der Code:

Zu Beginn werden die Konstanten RX_PIN (10) und TX_PIN (11), die Baudrate BAUD_RATE (9600), das Intervall SEND_INTERVAL (2000 ms) und die Größe BUFFER_SIZE (64) der empfangenen Zeile definiert. Das Objekt rs232 ist der mit SoftwareSerial auf den Pins D10 und D11 erzeugte softwareseitige serielle Port. Die Variablen rxBuffer, rxIndex, lastSendTime und counter speichern die gerade empfangene Zeile, deren Position darin, den Zeitpunkt der letzten gesendeten Meldung und die Anzahl der gesendeten Meldungen.

In der Funktion setup() starten wir den seriellen Hardware-Port Serial für den Serial Monitor und den Port rs232 zum Modul, beide mit 9600 Baud, danach geben wir zwei Startmeldungen aus.

In der Funktion loop() erledigen wir drei Dinge. Zuerst lesen wir die Zeichen, die vom Modul über rs232 eintreffen, mit rs232.read() und sammeln sie in rxBuffer. Erscheint ein Zeilenende ('\n' oder '\r') und der Puffer ist nicht leer, schließen wir die Zeichenkette mit '\0' ab und geben sie mit dem Präfix Received from RS232 aus. Leere Zeilen werden ignoriert, und der Puffer kann nicht überlaufen.

Danach leiten wir alles, was Sie im Serial Monitor eingeben, Zeichen für Zeichen mit rs232.write(Serial.read()) auf die RS232-Leitung weiter. Zum Schluss prüfen wir mit millis(), ob seit der letzten Meldung 2000 ms vergangen sind. Ist dies der Fall, erhöhen wir counter, senden den Text Hello from Arduino # gefolgt von der Nummer und dem Zeilenende \r\n und geben dieselbe Meldung auch im Serial Monitor aus.

Ergebnis:

Öffnen Sie den Serial Monitor mit 9600 Baud und ein Terminal (PuTTY oder screen) am COM-Port des USB-zu-RS232-Kabels, ebenfalls mit 9600 Baud, 8N1. Im Serial Monitor erscheinen die Meldungen, die alle zwei Sekunden gesendet werden, und im Terminal erscheint der Text Hello from Arduino mit der Nummer der Meldung. Was Sie im Terminal eingeben und mit Enter senden, erscheint im Serial Monitor mit dem Präfix Received from RS232.

RS232 to TTL test started at 9600 baud.
Open a terminal on the COM port of the USB-RS232 cable (9600, 8N1).
Sent to RS232: Hello from Arduino #1
Sent to RS232: Hello from Arduino #2
Received from RS232: Test from PC
Sent to RS232: Hello from Arduino #3
Sent to RS232: Hello from Arduino #4
Received from RS232: Second message
Sent to RS232: Hello from Arduino #5

Häufige Probleme:

Die LED D1 leuchtet nicht. Die Ursache ist fehlende Versorgung des Moduls. Prüfen Sie die Verbindungen VCC an 5V und GND an GND sowie die richtige Ausrichtung auf der TTL-Leiste, wo die Markierungen GND, TXD, RXD, VCC lauten.

Im Serial Monitor oder im Terminal kommt nichts an. Die Ursache kann das Kabel oder die Datenleitungen sein. Prüfen Sie, ob das Terminal den richtigen COM-Port verwendet, mit 9600 Baud, 8N1. Hat das externe Gerät einen DB9-Buchsenstecker, verwenden Sie ein Nullmodemkabel. Sind die Verbindungen korrekt und kommen trotzdem keine Daten an, vertauschen Sie die Leitungen an den Pins D10 und D11, denn die Markierungen RXD und TXD können bei verschiedenen Platinenvarianten unterschiedlich sein.

Im Terminal erscheinen seltsame Zeichen. Die Ursache ist eine unterschiedliche Baudrate auf den beiden Seiten oder fehlende gemeinsame Masse. Stellen Sie überall dieselbe Baudrate und dasselbe Format ein und prüfen Sie die Verbindung GND.

Die Daten gehen bei hohen Geschwindigkeiten verloren oder werden verfälscht. Die Ursache ist die Bibliothek SoftwareSerial, die auf dem Arduino Uno bei hohen Geschwindigkeiten nicht zuverlässig arbeitet. Verwenden Sie 9600 Baud oder höchstens 19200 Baud, oder einen seriellen Hardware-Port.

Das Board mit 3.3 V arbeitet instabil oder wird warm. Die Ursache ist die Versorgung des Moduls mit 5 V, die TTL-Pegel von 5 V liefert. Versorgen Sie das Modul mit 3.3 V.

Einschränkungen und Tipps:

Das Modul wandelt nur die Signale TX, RX und Masse um. Steuerleitungen zur Flusskontrolle (RTS, CTS) gibt es nicht, daher eignet es sich nicht für Geräte, die diese verlangen. Die maximale Geschwindigkeit des Schaltkreises MAX3232 beträgt 250 kbit/s, und die TTL-Seite akzeptiert eine Versorgung zwischen 3.3 V und 5 V.

Verwenden Sie für lange Verbindungen geschirmte Kabel und sorgen Sie für eine gemeinsame Masse. Mit diesem Modul können Sie ein Datenprotokoll eines Geräts mit seriellem Port aufzeichnen, eine Brücke zwischen einem industriellen Gerät und einer Mikrocontroller-Platine aufbauen oder eine serielle Konsole für einen Router realisieren.