Cómo configurar el puerto serie TTL (UART) en un Raspberry PLC

1. Paso 1Activa la UARTraspi-config o config.txt
2. Paso 2Comprueba /dev/serial0Dispositivo y permisos del usuario
3. Paso 3Prueba con pyserialBucle de retorno y luego un equipo real
4. Paso 4Conecta un PLC de 5 VM-Duino o Ardbox con adaptador de niveles

Qué es el serie TTL

Una UART (Universal Asynchronous Receiver-Transmitter) envía los datos bit a bit por dos líneas: TX (transmisión) y RX (recepción), más una GND común. Es full duplex y punto a punto: un equipo en cada extremo. "TTL" significa que las líneas usan los niveles lógicos del chip: 0 V y 3,3 V en una Raspberry Pi, y 0 V y 5 V en las placas Arduino de 5 V.

El serie TTL no es diferencial como el RS-485 ni tiene drivers de línea como el RS-232, así que sirve para cables cortos dentro del mismo armario. Para distancias más largas o con ruido eléctrico, usa los puertos RS-485 del PLC.

Paso 1: activa la UART

Un Raspberry PLC preparado con la imagen o el script install.sh de Industrial Shields ya tiene la UART activada: el script añade enable_uart=1 a la configuración de arranque y quita la consola serie. Compruébalo en el paso 2. En una instalación nueva de Raspberry Pi OS, actívala con raspi-config:

sudo raspi-config

1. Ve a Interface Options > Serial Port.
2. "Would you like a login shell to be accessible over serial?": No. La consola usaría el mismo puerto y enviaría los mensajes de arranque a tu equipo.
3. "Would you like the serial port hardware to be enabled?": Yes.
4. Termina y reinicia.

Para hacerlo a mano, edita la configuración de arranque:

sudo nano /boot/firmware/config.txt

Añade esta línea al final:

enable_uart=1

Después quita este texto de /boot/firmware/cmdline.txt, que es una sola línea, y reinicia:

console=serial0,115200

En Bookworm y posteriores los archivos están en /boot/firmware/. En Bullseye y anteriores son /boot/config.txt y /boot/cmdline.txt.

Paso 2: comprueba /dev/serial0 y los permisos

ls -l /dev/serial*

/dev/serial0 es un enlace a la UART principal, la de los pines TTL. Usa este nombre en tus programas, porque el dispositivo real cambia según la configuración:

La mini UART no tiene paridad y su velocidad depende del reloj del procesador. Para 8N1 a 9600 o 115200 baudios es suficiente. Si el otro equipo necesita paridad (8E1, por ejemplo), asigna la UART completa a los pines con esta línea en /boot/firmware/config.txt, que pasa el Bluetooth a la mini UART, y reinicia:

dtoverlay=miniuart-bt

Tu usuario debe estar en el grupo dialout para abrir el puerto sin sudo. Compruébalo y, si falta, añádelo y vuelve a iniciar sesión:

groups
sudo usermod -aG dialout $USER

Paso 3: lee y escribe el puerto

Prueba rápida desde el terminal

Une TX y RX del Raspberry PLC con un cable (bucle de retorno; los dos son de 3,3 V, así que es seguro). Configura el puerto a 9600 baudios en modo raw sin eco, léelo en segundo plano y envía una línea:

stty -F /dev/serial0 9600 raw -echo
cat /dev/serial0 &
echo "hello" > /dev/serial0

La palabra hello vuelve a aparecer en pantalla: ha salido por TX y ha vuelto por RX. Detén la lectura en segundo plano con kill %1.

Python con pyserial

pyserial es la librería de Python para puertos serie. El script de Industrial Shields la instala; en otro sistema, instala el paquete de Debian:

sudo apt install -y python3-serial

Guarda este programa como serial_ping.py. Envía PING cada segundo y muestra lo que recibe:

#!/usr/bin/env python3
# Send PING on the TTL serial port every second and print the replies
import sys
import time
import serial

PORT = sys.argv[1] if len(sys.argv) > 1 else "/dev/serial0"  # primary UART
BAUD = 9600  # use the same speed on both devices

ser = serial.Serial(PORT, BAUD, bytesize=serial.EIGHTBITS,
                    parity=serial.PARITY_NONE,
                    stopbits=serial.STOPBITS_ONE, timeout=1)
ser.reset_input_buffer()
try:
    while True:
        ser.write(b"PING\n")         # send one line
        line = ser.readline()        # wait up to 1 s for a full line
        if line:
            print("Received:", line.decode(errors="replace").strip())
        else:
            print("No reply")
        time.sleep(1)
except KeyboardInterrupt:
    pass
finally:
    ser.close()

Ejecútalo con el cable del bucle todavía puesto:

python3 serial_ping.py

Received: PING
Received: PING

Detenlo con Ctrl+C. Sin el cable y sin ningún equipo, muestra No reply. El puerto y la velocidad están al principio del programa: el otro equipo debe usar la misma velocidad y el mismo formato (8 bits de datos, sin paridad, 1 bit de parada).

Paso 4: conecta el Raspberry PLC a un M-Duino o un Ardbox

Conéctalo así:

• TX del Raspberry PLC al lado de baja tensión (LV, 3,3 V) de un adaptador de niveles bidireccional, y el lado de alta tensión (HV, 5 V) al RX del PLC de 5 V.
• TX del PLC de 5 V al lado HV del adaptador, y el lado LV al RX del Raspberry PLC.
• GND de los dos PLC unidas, y a la GND del adaptador. Sin GND común los datos no llegan.

Lo mínimo es un divisor de tensión en la línea que va del TX de 5 V al RX de la Raspberry (por ejemplo 1 kΩ en serie y 2 kΩ a GND, que dan unos 3,3 V). En el otro sentido, 3,3 V está cerca del nivel alto mínimo que acepta una entrada de 5 V, así que puede funcionar, pero sin margen. Un adaptador de niveles resuelve los dos sentidos.

En el M-Duino, usa Serial1 (pines TX1 y RX1) y deja Serial para el puerto USB, que comparte TX0 y RX0. En algunos modelos TX1 y RX1 comparten bornes con entradas y se seleccionan con interruptores: mira cómo usar TTL en un Arduino PLC. En el Ardbox, consulta en el User Guide de tu modelo qué pines dan el serie TTL.

Este sketch para el M-Duino responde a cada línea que envía el Raspberry PLC:

// M-Duino: answer each line received from the Raspberry PLC on Serial1 (TX1/RX1)
void setup() {
  Serial.begin(115200);   // USB port, to see the messages on the PC
  Serial1.begin(9600);    // TTL port to the Raspberry PLC, same speed
}

void loop() {
  if (Serial1.available()) {
    String line = Serial1.readStringUntil('\n');  // waits up to 1 s
    line.trim();
    Serial.println("From Raspberry PLC: " + line);
    Serial1.print("ACK ");
    Serial1.println(line);  // reply ends with CR LF
  }
}

Con el M-Duino conectado y serial_ping.py en marcha en el Raspberry PLC, la salida es:

Received: ACK PING
Received: ACK PING

Para más de un metro de cable, o en un armario con variadores y contactores, usa RS-485: los dos PLC lo tienen. Mira RS-485 entre una Raspberry Pi y un M-Duino y RS-485 con un Raspberry PLC.

Preguntas frecuentes sobre el puerto serie TTL del Raspberry PLC

¿Qué nombre de dispositivo uso: serial0, ttyS0 o ttyAMA0?

/dev/serial0. Siempre apunta a la UART de los pines TTL, sea cual sea la configuración. /dev/ttyACM0, que aparece en algunos ejemplos, es un dispositivo USB, no el puerto TTL.

¿El puerto TTL tolera 5 V?

No. Funciona a 3,3 V, directo de la Raspberry Pi. Usa un adaptador de niveles con equipos de 5 V.

¿Por qué recibo caracteres extraños?

La velocidad o el formato son distintos en cada lado, la consola serie sigue activa en el puerto o la GND no es común. Revisa las tres cosas.

¿Puedo usar paridad?

No con la mini UART. Añade dtoverlay=miniuart-bt para asignar la UART completa a /dev/serial0, como en la guía de Modbus RTU para el TouchBerry Pi.

¿Cómo veo la señal?

Con un analizador lógico en TX, RX y GND: mira analizador lógico y puerto serie con un Raspberry PLC.

Comunicación serie con los PLC de Industrial Shields

La familia Raspberry PLC tiene un puerto serie TTL, dos puertos RS-485 y dos puertos Ethernet, con Debian Bookworm de 64 bits preinstalado. La familia M-Duino tiene RS-485, RS-232 y serie TTL sobre una placa Arduino, y el Ardbox tiene RS-485 (consulta en el User Guide de tu modelo sus otros puertos serie). Para compararlos, mira cómo elegir un controlador industrial.