Modulo convertitore RS232 a TTL MAX3232, connettore DB9 femmina, alimentazione 3.3-5V, 4 pin TTL

Il modulo RS232 a TTL con MAX3232 fa da collegamento tra una porta seriale RS232 classica, con connettore DB9, e un microcontrollore che lavora con livelli logici di 3.3 V o 5 V. Lo utilizzate quando volete collegare apparecchi più vecchi o industriali, come strumenti da laboratorio, lettori, console di router, moduli GSM o PLC, oppure quando volete comunicare con una porta COM di un computer.

In questo tutorial usiamo una scheda Arduino Uno R3, perché il modulo si limita a convertire i livelli del segnale e ha bisogno di un microcontrollore che invii e riceva i dati. Il test consiste in una connessione seriale in entrambi i sensi tra Arduino e un computer, tramite un cavo da USB a RS232.

Come funziona:

Un microcontrollore produce livelli TTL, cioè 0 V per il logico 0 e 3.3 V o 5 V per il logico 1. Lo standard RS232 usa altri livelli e una logica invertita: un 1 logico è una tensione negativa, tra -3 V e -15 V, mentre uno 0 logico è una tensione positiva, tra +3 V e +15 V. Se collegaste direttamente una porta RS232 a un pin di Arduino, superereste la tensione sopportata dal pin e potreste danneggiarlo.

Il circuito integrato MAX3232 (U1 sulla scheda) risolve il problema. Ha due driver e due ricevitori, ma il modulo ne usa un solo canale. Una pompa di tensione formata dai condensatori C1 - C4 da 100 nF produce dall'alimentazione di 3.3 - 5 V le tensioni positive e negative necessarie alla linea RS232. Il condensatore C5 filtra l'alimentazione. Il circuito integrato lavora tra 3.0 V e 5.5 V e arriva a 250 kbit/s.

Sul connettore DB9 femmina, il pin 2 è l'uscita di trasmissione del modulo, il pin 3 è l'ingresso di ricezione e il pin 5 è la massa. Non ci sono linee di controllo del flusso. Sul lato TTL, il pin RXD è l'uscita del modulo verso il pin di ricezione del microcontrollore, mentre il pin TXD è l'ingresso del modulo dal pin di trasmissione del microcontrollore. Per questo motivo il collegamento si fa direttamente, RXD a RX e TXD a TX, senza incrocio.

A 9600 baud con formato 8N1, ogni carattere occupa 10 bit, cioè un bit di start, otto bit di dati e un bit di stop. La durata di un bit è 1 / 9600, cioè circa 104 microsecondi, mentre un carattere dura circa 1.04 ms. Ne risultano circa 960 caratteri al secondo.

Collegamento:

Alimentate il modulo dal pin 5V della scheda Arduino Uno, che gli fornisce livelli logici di 5 V, adatti alla Uno. Se usate una scheda a 3.3 V, alimentate il modulo sempre a 3.3 V. La scheda Arduino resta alimentata via USB dal computer. Non collegate mai i pin del connettore DB9 direttamente ai pin di Arduino. Ad Arduino si collegano solo i quattro pin dell'header TTL, contrassegnati GND, TXD, RXD e VCC.

Il connettore DB9 del modulo è femmina e si inserisce direttamente in un connettore DB9 maschio, come quello di un cavo da USB a RS232 o di una porta COM del computer. Se l'apparecchio che collegate ha anch'esso un connettore femmina, usate un cavo null-modem.

Abbiamo scelto i pin D10 e D11 con la libreria SoftwareSerial perché i pin D0 e D1 della scheda Uno sono usati dalla porta seriale hardware, che comunica con il Serial Monitor tramite USB. In questo modo potete vedere i messaggi sul computer senza scollegare nulla.

Pulsanti, regolazioni e indicatori:

Il modulo non ha pulsanti, potenziometri, jumper o interruttori, quindi non c'è nulla da regolare. Ha un solo indicatore e due connettori.

Dopo aver eseguito i collegamenti e aver collegato Arduino alla USB, il LED D1 deve accendersi subito. Questo è l'unico segnale visibile che il modulo è alimentato. Per verificare che anche il trasferimento dei dati funzioni, usate il programma qui sotto.

Scheda e librerie:

Nell'Arduino IDE selezionate la scheda Arduino Uno da Tools > Board, dal pacchetto Arduino AVR Boards, che è incluso nell'Arduino IDE e si può trovare nel Boards Manager. Non serve installare alcuna libreria, perché SoftwareSerial fa parte dell'Arduino IDE.

Sul computer vi serve anche un programma terminale per la porta COM del cavo da USB a RS232, ad esempio PuTTY su Windows oppure screen su Linux e macOS.

Il codice:

Il programma invia ogni due secondi un messaggio numerato verso la porta RS232 e mostra nel Serial Monitor tutto ciò che riceve da essa. Inoltre, quello che scrivete nel Serial Monitor viene inoltrato sulla linea RS232.

/*
  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);
  }
}

Come funziona il codice:

All'inizio sono definite le costanti RX_PIN (10) e TX_PIN (11), la velocità BAUD_RATE (9600), l'intervallo SEND_INTERVAL (2000 ms) e la dimensione BUFFER_SIZE (64) della riga ricevuta. L'oggetto rs232 è la porta seriale software creata con SoftwareSerial sui pin D10 e D11. Le variabili rxBuffer, rxIndex, lastSendTime e counter memorizzano la riga in corso di ricezione, la posizione al suo interno, il momento dell'ultimo messaggio inviato e il numero dei messaggi inviati.

Nella funzione setup() avviamo la porta seriale hardware Serial per il Serial Monitor e la porta rs232 verso il modulo, entrambe a 9600 baud, poi stampiamo due messaggi di avvio.

Nella funzione loop() facciamo tre operazioni. Per prima cosa leggiamo i caratteri arrivati dal modulo con rs232.read() e li accumuliamo in rxBuffer. Quando compare una fine riga ('\n' o '\r') e il buffer non è vuoto, chiudiamo la stringa con '\0' e la stampiamo con il prefisso Received from RS232. Le righe vuote vengono ignorate, e il buffer non può essere superato.

Poi ritrasmettiamo sulla linea RS232 tutto ciò che scrivete nel Serial Monitor, carattere per carattere, con rs232.write(Serial.read()). Infine, con millis(), verifichiamo se sono passati 2000 ms dall'ultimo messaggio. Se sì, incrementiamo counter, inviamo il testo Hello from Arduino # seguito dal numero e dalla fine riga \r\n, e stampiamo lo stesso messaggio anche nel Serial Monitor.

Risultato:

Aprite il Serial Monitor a 9600 baud e un terminale (PuTTY o screen) sulla porta COM del cavo da USB a RS232, anch'esso a 9600 baud, 8N1. Nel Serial Monitor compaiono i messaggi inviati ogni due secondi, mentre nel terminale appare il testo Hello from Arduino con il numero del messaggio. Quello che scrivete nel terminale e inviate con Invio compare nel Serial Monitor, con il prefisso 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

Problemi frequenti:

Il LED D1 non si accende. La causa è la mancanza di alimentazione del modulo. Controllate i collegamenti VCC a 5V e GND a GND, nonché il verso di inserimento sull'header TTL, dove i contrassegni sono GND, TXD, RXD, VCC.

Non arriva nulla nel Serial Monitor o nel terminale. La causa può essere il cavo o i fili dei dati. Verificate che il terminale usi la porta COM corretta, a 9600 baud, 8N1. Se l'apparecchio esterno ha un connettore DB9 femmina, usate un cavo null-modem. Se i collegamenti sono corretti e non compaiono ancora dati, invertite i fili dei pin D10 e D11, perché le sigle RXD e TXD possono differire da una versione di scheda all'altra.

Nel terminale compaiono caratteri strani. La causa è una velocità diversa sulle due parti o l'assenza della massa comune. Impostate la stessa velocità e lo stesso formato ovunque e verificate il collegamento GND.

I dati si perdono o si danneggiano alle velocità elevate. La causa è la libreria SoftwareSerial, che non è affidabile alle alte velocità su Arduino Uno. Usate 9600 baud o al massimo 19200 baud, oppure una porta seriale hardware.

La scheda a 3.3 V funziona in modo instabile o si scalda. La causa è l'alimentazione del modulo a 5 V, che gli fornisce livelli logici di 5 V. Alimentate il modulo a 3.3 V.

Limitazioni e consigli:

Il modulo converte solo i segnali TX, RX e la massa. Non ci sono linee di controllo del flusso (RTS, CTS), quindi non è adatto agli apparecchi che le richiedono. La velocità massima del circuito MAX3232 è 250 kbit/s, mentre il lato TTL accetta un'alimentazione tra 3.3 V e 5 V.

Per collegamenti lunghi usate cavi schermati e mantenete una massa comune. Con questo modulo potete costruire un registratore di dati da un apparecchio con porta seriale, un ponte tra un apparecchio industriale e una scheda con microcontrollore, oppure una console seriale per un router.