Dominar la comunicación en serie con Arduino

Cuando se trabaja en grandes proyectos Arduino, es bastante común quedarse sin pines disponibles para conectar componentes. Supongamos que desea conectar varios sensores/actuadores con la necesidad urgente de conservar pines adicionales para alimentar un módulo de visualización hambriento de pines.

A menos que haga algo de magia, a veces es difícil manejar todas estas conexiones en una sola placa Arduino, especialmente cuando decide usar placas más pequeñas porque tiene poco espacio. Ahí es cuando entra en juego la comunicación serial.

Exploremos qué es la comunicación en serie y las formas en que puede configurarla con Arduino para tareas como el procesamiento distribuido y la integración general.

¿Qué es la comunicación en serie?

La comunicación en serie es un método de envío y recepción de datos entre dos o más dispositivos electrónicos, un bit a la vez a través de una sola línea de comunicación. Como sugiere el nombre, los datos se envían en "series

".

Incluso poder cargar bocetos en su placa Arduino favorita utiliza comunicación en serie a través de USB.

Protocolos de comunicación serie en Arduino

Las placas Arduino son increíblemente versátiles y pueden comunicarse con una amplia gama de dispositivos. Admiten cuatro protocolos de comunicación en serie: Soft Serial, SPI (interfaz periférica en serie), UART estándar (receptor-transmisor asíncrono universal) e I2C (circuito interintegrado). Para obtener más detalles, consulte nuestra guía completa sobre cómo funcionan las comunicaciones seriales UART, SPI e I2C.

Este tutorial utiliza bocetos básicos para mostrar cómo puede configurar una conexión en serie entre dos placas Arduino Uno utilizando varios protocolos. Adapte el código para cumplir con sus requisitos específicos.

SPI (interfaz periférica en serie)

SPI es un protocolo de comunicación serial síncrona que permite la comunicación de alta velocidad entre microcontroladores y dispositivos periféricos. Este protocolo requiere cuatro hilos para la comunicación: SCK (Reloj de serie), MOSI (Maestro de salida Esclavo de entrada), MISO (Master In Slave Out), y SS (Selección de esclavo).

El SPI.h biblioteca es muy útil para este tipo de comunicación y debe incluirse en la parte superior de su boceto.

#incluir

Aquí están los pines SPI en la placa Arduino Uno:

Después de inicializar la comunicación en serie, deberá configurar los pines de comunicación.

vacíoconfiguración(){
SPI.comenzar(115200);
// Establecer modos pin para SS, MOSI, MISO y SCK
pinMode(SS, PRODUCCIÓN);
pinMode(MOSI, PRODUCCIÓN);
pinMode(MISO, APORTE);
pinMode(SCK, PRODUCCIÓN);
// Establezca el pin de selección de esclavo (SS) alto para deshabilitar el dispositivo esclavo
escritura digital(SS, ALTO);
}

La señal SS se usa para decirle al dispositivo esclavo cuando se están transfiriendo datos.

//Seleccionar el esclavo
escritura digital(SS, BAJO);
// Enviar datos al dispositivo esclavo
SPI.transferir(datos);
// Deseleccionar el dispositivo esclavo
escritura digital(SS, ALTO);

Aquí se explica cómo conectar dos placas Arduino usando SPI.

Código para la placa maestra:

#incluir
constanteEn t pinSeleccionarEsclavo = 10;
vacíoconfiguración(){
SPI.comenzar(115200);
pinMode(pinSeleccionaresclavo, PRODUCCIÓN);
}
vacíobucle(){
escritura digital(pinSeleccionaresclavo, BAJO);
SPI.transferir('H');
escritura digital(pinSeleccionaresclavo, ALTO);
demora(1000);
}

Código para la placa esclava:

#incluir
constanteEn t pinSeleccionarEsclavo = 10;
vacíoconfiguración(){
SPI.comenzar(115200);
pinMode(pinSeleccionaresclavo, PRODUCCIÓN);
}
vacíobucle(){
si (lectura digital(esclavoSeleccionarPin) == BAJO) {
carbonizarse datos recibidos = SPI.transferir('L');
De serie.imprimir(datos recibidos);
 }
}

Asegúrese de que sus dispositivos compartan un terreno común para una configuración adecuada.

UART (receptor-transmisor asíncrono universal)

UART es un protocolo de comunicación en serie asíncrono que permite la comunicación entre dispositivos usando solo dos cables: TX (transmitir) y RX (recibir). UART se usa comúnmente para la comunicación con dispositivos como módulos GPS, módulos Bluetooth y otros microcontroladores. Cada placa Arduino viene equipada con al menos un puerto para UART.

Los pines UART en las placas Arduino populares incluyen:

Puede obtener la tabla completa de Documentación en línea de Arduino sobre la comunicación serie.

Primero, conecta tus tableros así:

Luego use este código para el tablero del remitente:

vacíoconfiguración(){
De serie.comenzar(9600);
}
vacíobucle(){
// Enviar un mensaje en serie cada segundo
De serie.imprimir("¡Hola desde el tablero del remitente!");
demora(1000);
}

Código para la placa del receptor:

vacíoconfiguración(){
De serie.comenzar(9600);
}
vacíobucle(){
// Comprobar si hay datos entrantes
si (De serie.disponible() > 0) {
// Leer los datos entrantes e imprimirlos en el monitor serial
Cadena datos entrantes = De serie.leerCadena();
De serie.imprimir(datos entrantes);
 }
}

El Arduino Uno opera en un nivel lógico de 5V mientras que el puerto RS232 de una computadora usa un nivel lógico de +/-12V.

Conectar directamente un Arduino Uno a un puerto RS232 puede dañar su placa.

I2C (Circuito Inter-Integrado)

I2C es un protocolo de comunicación serial síncrona que permite la comunicación entre múltiples dispositivos usando solo dos cables: SDA (Serial Data) y SCL (Serial Clock). I2C se usa comúnmente para la comunicación con sensores, EEPROM y otros dispositivos que necesitan transferir datos en distancias cortas.

Los pines I2C en el Arduino Uno son ASD (A4) y SCL (A5).

Crearemos un programa simple para establecer una conexión entre dos placas Arduino usando comunicación I2C. Pero primero, conecta tus tableros así:

Código para la placa maestra:

#incluir
vacíoconfiguración(){
Cable.comenzar(); // unirse al bus I2C como maestro
De serie.comenzar(9600);
}
vacíobucle(){
Cable.comenzarTransmisión(9); // transmitir al dispositivo esclavo con dirección 9
Cable.escribir('a'); // envía un byte 'a' al dispositivo esclavo
Cable.transmisión final(); // deja de transmitir
demora(500);
}

Código para la placa esclava:

#incluir
vacíoconfiguración(){
Cable.comenzar(9); // unirse al bus I2C como esclavo con dirección 9
Cable.en Recibir(recibirEvento);
De serie.comenzar(9600); 
}
vacíobucle(){
demora(100);
}
vacíorecibir evento(En t bytes){
mientras(Cable.disponible()) { // recorrer todos los bytes recibidos
carbonizarse byte recibido = Cable.leer(); // lee cada byte recibido
De serie.imprimir(byte recibido); // imprime el byte recibido en el monitor serie
 }
}

¿Qué es SoftwareSerial?

La biblioteca Arduino SoftwareSerial se desarrolló para emular la comunicación UART, lo que permite la comunicación en serie a través de dos pines digitales cualquiera en las placas Arduino. Es útil cuando el UART de hardware ya está en uso por otros dispositivos.

Para configurar SoftwareSerial, primero incluya la biblioteca SoftwareSerial en el boceto.

#incluir

Luego cree una instancia del objeto SoftwareSerial especificando el RX y Texas pines que se utilizarán para la comunicación.

SoftwareSerialmiSerial(2, 3); // Pines RX, TX

Aquí hay un código de ejemplo para Arduino que demuestra el uso de SoftwareSerial:

#incluir
SoftwareSerialmiSerial(2, 3); // Pines RX, TX
vacíoconfiguración(){
De serie.comenzar(9600); // inicia la serie de hardware
 miSerial.comenzar(9600); // iniciar serie suave
}
vacíobucle(){
si (miSerial.disponible()) {
De serie.escribir(miSerial.leer()); // enviar los datos recibidos a la serie de hardware
 }
si (De serie.disponible()) {
 miSerial.escribir(De serie.leer()); // enviar datos de la serie de hardware a la serie de software
 }
}

La biblioteca serial

La biblioteca Serial es una herramienta poderosa en Arduino que permite la comunicación entre el microcontrolador y una computadora u otros dispositivos a través de una conexión en serie. Algunas funciones comunes incluyen:

Tasa de baudios y formato de datos en serie

La tasa de baudios se refiere a la velocidad a la que se transfieren los datos a través de la conexión en serie. Representa el número de bits que se transmiten por segundo. La velocidad en baudios debe configurarse de la misma manera tanto en el dispositivo emisor como en el receptor, de lo contrario, la comunicación puede ser distorsionada o no funcionar en absoluto. Las tasas de baudios comunes para Arduino incluyen 9600, 19200, 38400 y 115200.

El formato de datos en serie se refiere a la estructura de los datos que se envían a través de la conexión en serie. Hay tres componentes principales para el formato de datos en serie: bits de inicio, bits de datos y bits de parada.

• Bits de datos: El número de bits utilizados para representar un solo byte de datos.
• Paridad: Un bit opcional utilizado para la verificación de errores. Se puede establecer en paridad nula, par o impar, según los requisitos del canal de comunicación.
• Bits de parada: El número de bits utilizados para señalar el final de un byte de datos.

El formato de datos debe ser el mismo en los dispositivos de transmisión y recepción para garantizar una comunicación adecuada. Este es un ejemplo de cómo puede establecer formatos de datos específicos:

vacíoconfiguración(){
// Configure la comunicación en serie con una velocidad de transmisión de 9600 baudios, 8 bits de datos, sin paridad y 1 bit de parada
De serie.comenzar(9600, SERIE_8N1); 
}

Aquí, SERIE_8N1 representa el formato de datos con 8 bits de datos, sin paridad, y 1 poco de parada. Otras opciones como SERIE_7E1, SERIE_8O2, etc., se pueden utilizar dependiendo de los requisitos específicos del proyecto.

Charla en serie

Las placas Arduino brindan varias opciones de comunicación en serie que permiten un intercambio de datos eficiente y confiable entre dispositivos. Al comprender cómo configurar protocolos de comunicación en serie en el IDE de Arduino, puede aprovechar el poder del procesamiento distribuido o reducir en gran medida la cantidad de cables utilizados en sus proyectos.