El UART, o Serial Port como se le conoce habitualmente en el mundo de Arduino, es un protocolo de comunicación que permite la transmisión y recepción de datos de forma asíncrona entre dispositivos.
A diferencia de las comunicaciones síncronas, como el SPI o el I2C, el UART no requiere una señal de reloj adicional. Esto lo convierte en una opción flexible y muy utilizada utilizada en una gran variedad de aplicaciones.
Los puertos UART nos permiten comunicarnos con otros dispositivos, como otros micros, el ordenador, sensores, módulos GPS, algunos tipos de pantallas, entre otros.
Si no sabes lo que es el puerto serie o necesitas más ayuda consulta estas entradas:
El UART en el ESP32
El ESP32 dispone de más de un UART, en función del modelo que estemos usando. En concreto:
- El ESP32 y el ESP32-S3 tienen 3 UART
- El ESP32-S3 y el ESP32-C3 tienen 2 UART
Estos puertos se llaman UART0, UART1 y UART2. Cada uno de ellos puede usar cuatro pines, RX, TX, CTS y RTS (pero el entorno de Arduino solo usa RX y TX).
Otra diferencia del ESP32 frente a un Arduino convencional es que, gracias a su multiplexor, podemos reasignar los UART a cualquier pin sin pérdida de rendimiento.
Los UART vienen preconfigurados para usar ciertos pines. Pero podemos (y en ocasiones debemos), cambiar los pines.
Estas son las asignaciones por defecto para el ESP32
| UART Port | TX | RX | RTS | CTS |
|---|---|---|---|---|
| UART0 | 1 | 3 | 22 | 19 |
| UART1 | 10 | 9 | 11 | 6 |
| UART2 | 17 | 16 | 7 | 8 |
Como vemos el UART1 los pines TX y RX coinciden con los usados para conectar la memoria SPI Flash. Por lo que si queremos usar el UART, obligatoriamente tendremos que reasignar los pines.
Estas son las asignaciones por defecto para el ESP32-S3
| UART Port | TX | RX | RTS | CTS |
|---|---|---|---|---|
| UART0 | 49 | 50 | 15 | 16 |
| UART1 | 17 | 18 | 19 | 20 |
| UART2 | - | - | - | - |
En este caso, el UART2 viene sin asociar por defecto a ningún pin. Por lo que si queremos usarlo, nuevamente tendremos que reasignarlo a algún pin a nuestra elección.
Cómo usar el UART en el ESP32 en el entorno de Arduino
Usar el UART en del ESP32 en el entorno de Arduino no es demasiado complicado (si tenemos claro lo que estamos haciendo).
Básicamente tenemos disponibles las mismas funciones que tendríamos en cualquier Arduino, como print(), println(), read(), available() y otras para enviar y recibir datos.
Serial.println("¡Hola, UART!");Si tenéis dudas, miras los enlaces de los tutoriales que os puesto antes.
Usando múltiples UART en el ESP32
El único “lío” que vais a tener es el de los pines del UART1 y UART2. Con afán de hacerlo más sencillo, igual que se hace en el Arduino Mega, el Core del ESP32 para Arduino define tres UART como Serial, Serial1 y Serial2.
El Serial “normal” es un alias para el UART0 y os va a funcionar sin problemas. Es usado para la programación y comunicación por el USB de la placa (con lo cuál, cambiarle los pines no es ni necesario, ni buena idea)
La cosa cambia en los Serial1 y Serial2. Dependiendo vuestro modelo de ESP32 y vuestra placa, lo normal es que la sintaxis Serial1 y Serial 2 no os funcione.
Lo mejor que podéis hacer si queréis usar más de un UART es definir a mano los pines. De hecho, a mi ni se me ocurriría usar el UART1 o UART2 sin especificar yo con que pines está asociado.
La buena noticia es que es muy sencillo asociarlos. Para ello necesitamos la biblioteca HardwareSerial, que son “las tripas” de lo que llamamos ‘Serial’ en Arduino.
Los pasos necesarios son
- Incluir la librería
- Definir un nuevo HardwareSerial
- Inicializarlo con
begin(...)
Aquí tenéis un ejemplo:
include <HardwareSerial.h>
HardwareSerial MySerial(1); // definir un Serial para UART1
const int MySerialRX = 16;
const int MySerialTX = 17;
void setup()
{
// inicializar el Serial a los pines
MySerial.begin(11500, SERIAL_8N1, MySerialRX, MySerialTX);
}
void loop()
{
// aqui podríamos usar nuestro MySerial con normalidad
while (MySerial.available() > 0) {
uint8_t byteFromSerial = MySerial.read();
//y lo que sea
}
MySerial.write(...);
}