Comunicación en Serie Arduino de Raspberry Pi – Todo Lo Que Necesita Saber

En este tutorial, le mostraré cómo comunicarse entre una Raspberry Pi y una placa Arduino a través de comunicación en serie.

Primero, explicaré rápidamente qué es la comunicación en serie. Luego verá cómo configurar su hardware y software, y nos sumergiremos en el código Python (Cpp para Arduino). Un ejemplo básico al principio, que conduce a una aplicación más completa que usa una Raspberry Pi, un Arduino y otros dispositivos electrónicos.

Este tutorial funcionará con una placa Raspberry Pi 4 (y anteriores: 3B, 3B+) y cualquier placa Arduino. Usaré principalmente Arduino Uno, pero daré más detalles sobre las diferencias entre las placas Arduino cuando se trata de comunicación en serie.

Cuando se trabaja con dispositivos electrónicos, la comunicación es clave. Cada dispositivo, además de hacer bien lo que se supone que debe hacer, debe poder comunicarse claramente con otros dispositivos. Esa es una de las cosas más importantes en las que trabajar para pasar de una aplicación muy básica a otras más complejas.

Qué es la comunicación en serie (con UART)

La comunicación en serie es simplemente una forma de transferir datos. Los datos se enviarán secuencialmente, un bit a la vez (1 byte = 8 bits), contrariamente a la comunicación paralela, donde se envían muchos bits al mismo tiempo.

Protocolo UART

Más específicamente, cuando utiliza Serial con Arduino y Raspberry Pi, está utilizando el protocolo UART. UART significa «Recepción y Transmisión Asíncrona Universal».

¿Está aprendiendo a usar Raspberry Pi para construir sus propios proyectos?

Echa un vistazo a Raspberry Pi Para principiantes y aprende paso a paso.

Básicamente es un protocolo multi-maestro asíncrono basado en la comunicación en Serie, que le permitirá comunicarse entre las 2 tarjetas. Tranquilícese, hay bibliotecas que manejarán todas las capas bajas por usted.

Multi-maestro significa que todos los dispositivos conectados serán libres de enviar datos cuando lo deseen. Esta es una de las principales diferencias con los protocolos maestro-esclavos, donde solo el dispositivo maestro puede iniciar una comunicación. Por lo general, utilizará otros protocolos como I2C y SPI cuando necesite configuraciones de esclavos maestros: por ejemplo, cuando tiene una placa Arduino y varios sensores o actuadores.

La placa Arduino Uno tiene un UART que puede usar con un cable USB o desde los pines RX / TX (no lo use con ambos al mismo tiempo). Algunas tablas tienen más UARTs disponibles. Por ejemplo, el Arduino Mega tiene diferentes Series (Serial, Serial1, Serial2, Serial3) y el Arduino Zero solo tiene un puerto USB nativo (use SerialUSB en lugar de Serial).

En Raspberry Pi, puede conectar muchos dispositivos Serie en los puertos USB. Cada uno tendrá un nombre de dispositivo diferente (veremos cómo encontrarlos más adelante en este tutorial). También puede utilizar los GPIOs (RX0 / TX0) para un UART adicional.

Probablemente ya conozca la comunicación en serie

Ciertamente ya ha utilizado la comunicación en serie muchas veces. Estoy seguro de que ya conoce la biblioteca serial de Arduino, que le permite registrar lo que está sucediendo en su código y obtener la entrada del usuario. Cuando se utiliza el monitor en serie, bueno, básicamente, su IDE Arduino inicia una comunicación en serie con su Arduino. Puede recibir y enviar datos directamente desde el monitor en serie.

Lo que haremos aquí es casi lo mismo, excepto que en lugar de su IDE Arduino, el otro lado de la comunicación en serie será una placa Raspberry Pi. Tendremos que hacer alguna configuración y escribir algún código para que funcione. Entonces, tanto Raspberry Pi como Arduino podrán enviarse mensajes entre sí.

Veamos ahora cómo conectar físicamente las 2 placas.

Configuración de hardware para comunicación en serie

Hay 2 formas de conectar su Raspberry Pi y Arduino para comunicación en serie.

Serie a través de USB

La forma más fácil es usar un cable USB entre ambas placas.

En el lado de Raspberry Pi, todo lo que necesita es un simple conector USB. Puede elegir cualquiera de los 4 puertos USB disponibles en la placa.

Para Arduino, utilizará el puerto USB que utiliza para cargar código desde su computadora (con el IDE de Arduino) a su placa. Aquí, el conector USB dependerá de la versión que tenga. Para placas como Arduino Uno y Mega, el conector será diferente de Arduino Nano y de Arduino Zero.

Para este ejemplo he utilizado una placa Arduino Uno.

Como puedes ver, es la conexión de hardware más simple que puedes hacer entre Raspberry Pi y Arduino.

Nota: primero tendrá que conectar su Arduino a su computadora, para que pueda cargar el código en la placa. Después de eso, conecte el cable USB al Raspberry Pi. El Raspberry Pi alimentará el Arduino a través de este cable.

Serie a través de GPIOs

Para hacer una conexión en serie, también puede usar cables simples entre los GPIOs de Raspberry Pi y los pines Arduino.

Dependiendo de su placa Arduino, es posible que necesite usar un cambiador de nivel de voltaje. La Raspberry Pi funciona a 3,3 V. Para placas Arduino como Due, 101, estará bien porque también usan 3,3 V.

Pero, para muchos Arduino, como Uno, Mega, Leonardo, Nano y muchos más, la placa funciona a 5V. Por lo tanto, necesita un cambiador de nivel de 3.3 V/5V para proteger el Raspberry Pi al conectar RX y TX (más información sobre los pines Raspberry Pi y los pines Arduino Uno).

Para el resto de este tutorial usaremos la configuración con el cable USB. Esto será más fácil de administrar y, a menos que tenga una buena razón para no hacerlo, debería preferir usar el cable USB en lugar de gpios simples para la comunicación en serie.

Configuración del software Raspberry Pi

No necesita ninguna configuración especial para Arduino. Solo asegúrese de haber descargado e instalado el IDE de Arduino.

Ahora, en su Raspberry Pi, se requieren algunas cosas para que la comunicación funcione.

Conéctese a su Raspberry Pi, ya sea a través de ssh o mediante un complemento de pantalla+ratón+teclado, y abra un terminal. Si aún no has instalado un sistema operativo en tu Pi, puedes instalar Raspbian o Ubuntu muy fácilmente en una tarjeta SD.

Detectar la placa Arduino

Al conectar el Arduino con un cable USB, debería verlo aparecer como /dev / ttyACM0 o /dev / ttyUSB0 (a veces el número puede ser diferente, por ejemplo /dev/ttyACM1).

Simplemente ejecute ls /dev/tty* y debería verlo. En este punto, si no está seguro de qué dispositivo es la placa Arduino, simplemente desconecte la placa (retire el cable USB) y vuelva a ejecutar ls /dev/tty*. De esta manera, detectará fácilmente el nombre del dispositivo serie de su Arduino.

Permisos de hardware para Serial

Además, es posible que desee agregar su usuario al grupo de marcado, para evitar errores como: serial.serialutil.Excepción serial: no se pudo abrir el puerto / dev / ttyACM0: Permiso denegado: ‘/dev / ttyACM0’

$ sudo adduser your_username dialout

Esto asegurará que tenga acceso a dispositivos Serie (/dev/ttyACMx, /dev/ttyUSBx, …).

Después de que se haya agregado al grupo de marcado telefónico, debe reiniciar su Pi (o al menos cerrar sesión/inicio de sesión) para aplicar el cambio: obtenga más información sobre los permisos de hardware de Raspberry Pi.

Instalar biblioteca serie de Python en Raspberry Pi

Necesita instalar una biblioteca para poder usar la interfaz Serie con Python.

Para este tutorial usaremos la biblioteca pySerial (documentación para Python 3). Para instalarlo:

python3 -m pip install pyserial

Esta biblioteca de Python es bien conocida y se usa en muchas aplicaciones.

Al instalar, si obtiene un error como «/usr/bin/python3: No module named pip», debe instalar primero pip con sudo apt install python3-pip.

Comunicación en serie simple de Arduino a Raspberry Pi

Comencemos con un programa muy simple.

Código Arduino

Cargue este código desde su computadora a su Arduino, utilizando el IDE de Arduino.

void setup() { Serial.begin(9600);}void loop() { Serial.println("Hello from Arduino!"); delay(1000);}

En primer lugar, inicializamos la comunicación en serie y elegimos una velocidad de transmisión, aquí 9600. 9600 es una velocidad de transmisión de uso común, y también una bastante baja. En sus aplicaciones futuras, puede utilizar una velocidad de transmisión de 57600 o incluso 115200 sin ningún problema. Para este tutorial continuaremos con 9600.

Cada segundo hacemos que el Arduino envíe una cadena con Serial.println (). la función println () añadirá un carácter de nueva línea ‘\n’ al final de la cadena.

Puede abrir el monitor serie para ver la cadena en su computadora.

Código Python de Raspberry Pi

#!/usr/bin/env python3import serialif __name__ == '__main__': ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1) ser.flush() while True: if ser.in_waiting > 0: line = ser.readline().decode('utf-8').rstrip() print(line)

Entonces, ¿qué hace este código?

#!/usr/bin/env python3import serial

Primero, importamos la biblioteca serie que instalamos previamente.

if __name__ == '__main__': ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1)

La comunicación en serie se inicializa llamando a serie.Serial() junto con algunos parámetros:

• Nombre de dispositivo serie para Arduino: normalmente ‘/ dev / ttyACM0′,’ /dev/ttyUSB0′, o similar.
• Velocidad en baudios: este parámetro es muy importante. Necesitas usar la misma velocidad de transmisión que la que usaste en Arduino, o de lo contrario todo lo que leas y escribas será basura. Por lo tanto, elegimos 9600 como lo hicimos en el boceto de Arduino.
• tiempo de espera: este es un tiempo de espera para las operaciones de lectura. Aquí lo ponemos en 1 segundo. Significa que cuando leemos de Serial, el programa no se quedará atascado para siempre si los datos no llegan. Después de 1 segundo o lectura, si no se reciben todos los bytes, la función devolverá los bytes ya recibidos.

So, serie.Serial () devuelve un objeto que puede usar para todas sus operaciones en serie. Lo almacenamos en la variable ‘ser’.

 ser.flush()

Luego usamos la función flush (). Esto borrará cualquier búfer de entrada y salida, por lo que evitará recibir o enviar datos extraños/no útiles/no completos al comienzo de la comunicación.

 while True: if ser.in_waiting > 0: line = ser.readline().decode('utf-8').rstrip() print(line)

En un bucle infinito (piense en la función loop () en el croquis de Arduino), comprobamos si hay algunos datos disponibles con el atributo in_waiting (no ponga paréntesis, esto no es una función). En caso afirmativo, podemos leer los datos.

La función readline () leerá todos los bytes hasta que se detecte un carácter de nueva línea.

Si solo imprimiéramos lo que recibimos, veríamos b’Hello de Arduino.\r \ n’. Recibe bytes cuando lee de Serie, y tiene que convertir (decodificar) esos bytes en el tipo de datos apropiado. Por lo tanto, usamos decodificación(‘utf-8’), también puede usar decodificación(‘ascii’), para decodificar los datos recibidos en una cadena.

Finalmente, la función rstrip () es específica para cadenas, le permite eliminar cualquier carácter final (nueva línea, retorno de carro). De esta manera podemos eliminar ‘\r’ y ‘\n’ y obtener una cadena adecuada.

Nota: aquí leemos una línea completa cada vez. Si desea leer una cierta cantidad de bytes, uno o más, use la función read(size=1).

Prueba de comunicación en serie

Ahora, desconecte su placa Arduino de su computadora y conéctela a su placa Raspberry Pi.

El código Arduino ya se está ejecutando, tan pronto como se enciende.

En Raspberry Pi, haga que el archivo Python sea ejecutable y ejecútelo.

$ chmod +x receive_serial_data_from_arduino.py$ ./receive_serial_data_from_arduino.py Hello from Arduino!Hello from Arduino!Hello from Arduino!

funciona! La cadena enviada por Arduino cada segundo se muestra en el terminal Raspberry Pi.

Comunicación en serie bidireccional entre Raspberry Pi y Arduino

Hagamos las cosas un poco más interesantes. Ya has visto cómo enviar datos de Arduino a Raspberry Pi. En esta parte verás cómo hablar de Raspberry Pi a Arduino. Por lo tanto, tendrá ambos lados de la comunicación y podrá crear programas que esperen la entrada del otro.

Código Arduino

void setup() { Serial.begin(9600);}void loop() { if (Serial.available() > 0) { String data = Serial.readStringUntil('\n'); Serial.print("You sent me: "); Serial.println(data); }}

Aquí comprobamos si el Arduino ha recibido datos con Serie.disponible(). Esto le dará el número de bytes ya llegados y almacenados en el búfer de recepción.

Si han llegado algunos datos, usamos Serial.readStringUntil () con un carácter de nueva línea ‘\n’ para obtener la siguiente línea. Esto es similar a la función readline (). Todos los bytes recibidos hasta ‘\n ‘ se convierten automáticamente y se agregan en un objeto de cadena Arduino.

Luego, simplemente imprimimos los datos que recibimos, con un fragmento de texto adicional.

Nota: si desea leer bytes uno por uno, puede hacerlo con la Serie.función read (). Luego tendrás que convertir este (esos) byte (s)si es necesario: int, String, etc.

Código Python de Raspberry Pi

#!/usr/bin/env python3import serialimport timeif __name__ == '__main__': ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1) ser.flush() while True: ser.write(b"Hello from Raspberry Pi!\n") line = ser.readline().decode('utf-8').rstrip() print(line) time.sleep(1)

Utilice la función pySerial write () para enviar datos a Arduino. Aquí puedes ver que he agregado una ‘ b ‘ antes de la cadena a enviar. Esto codificará la cadena en bytes, porque solo puede enviar bytes a través de Serial. Cualquier dato que no sea un byte o una matriz de bytes debe convertirse antes de ser enviado. Si solo intenta enviar la cadena de esa manera, obtendrá este error «TypeError: las cadenas unicode no son compatibles, codifique a bytes:» ¡Hola desde Raspberry Pi!'»

Nota: en lugar de ser.write(b"Hello from Raspberry Pi!\n") podrías haber escrito ser.write("Hello from Raspberry Pi!\n".encode('utf-8')) o ser.write("Hello from Raspberry Pi!\n".encode('ascii')). Esto hará lo mismo. La función encode () tomará la cadena y la codificará para Serial.

Además, agregamos un carácter de nueva línea ‘\n ‘ porque eso es lo que se espera que el Arduino termine su lectura con Serial.readStringUntil (‘\n’).

Luego, hacemos lo mismo que hicimos antes: leemos una línea, la decodificamos en cadena y eliminamos cualquier carácter final. No estamos usando el ser.in_waiting aquí, porque para esta aplicación específica sabemos que Arduino enviará algunos datos justo después de recibir la cadena. Además, tenemos un tiempo de espera de 1 segundo para evitar quedar atascados en esta línea.

Finalmente, imprimimos la cadena recibida y esperamos 1 segundo con el tiempo.sleep() antes de enviar la siguiente cadena a través de Serial.

Probar la comunicación en serie bidireccional

En su Raspberry Pi, haga que su archivo Python sea ejecutable y ejecútelo.

$ chmod +x bidirectional_serial_communication.py $ ./bidirectional_serial_communication.py You sent me: Hello from Raspberry Pi!You sent me: Hello from Raspberry Pi!You sent me: Hello from Raspberry Pi!

¡Éxito! El Arduino recibió la cadena y la envió de vuelta con unas pocas palabras más. A continuación, la Raspberry Pi recibió e imprimió la cadena final.

Raspberry Pi Arduino Comunicación en serie: Ejemplo de aplicación

Ahora que sabe cómo configurar su Arduino y Raspberry Pi para la comunicación en serie, y escribir programas para hablar entre cada placa, vamos a crear una aplicación más compleja.

En esta aplicación, se conectarán 4 LED y un botón pulsador a la placa Arduino.

Raspberry Pi y Arduino se conectarán con un cable USB y utilizarán comunicación en serie para comunicarse entre sí.

Este es el resultado que queremos obtener:

• Cuando se pulsa el pulsador, Arduino enviará una notificación a Raspberry Pi (un byte simple).
• La Raspberry Pi calculará un número entero aleatorio entre 1 y 4, y lo enviará a Arduino.
• El Arduino encenderá el LED relacionado con este número y apagará los otros LED.

Esto le hará practicar en la comunicación y sincronización de tareas entre Arduino y Raspberry Pi.

Si llegaste a este punto del tutorial (¡felicidades!) Te animo a que intentes escribir el código por ti mismo antes de leer el código que he proporcionado a continuación. Además, no solo hay un código posible para cumplir con esos requisitos, por lo que su código puede ser diferente del mío, está totalmente bien. Puede obtener ayuda de Arduino Serial reference y pySerial API reference.

Esquemas

Para hacer este circuito:

• Conecte 4 ledes a los pines 9-12. Agregue una resistencia de 220 Ohmios para cada LED entre la pata más larga y el pasador digital. La pierna más corta está conectada al suelo.
• Agregue un pulsador con una resistencia de 10Kohm conectada a tierra (resistencia extraíble). Un lado del botón está conectado a 5V, el otro al pin digital 5 para lectura.
• No olvide hacer un terreno común entre todos los componentes: La placa Arduino, los 4 led y el botón pulsador. No agregue ninguna fuente de alimentación si al menos no ha conectado correctamente los terrenos.
• Conecte Arduino y Raspberry Pi a través de un cable USB, para la comunicación en serie (el cable USB ya administra la conexión a tierra entre sus 2 tarjetas).

Código Arduino

#define LED_1_PIN 9#define LED_2_PIN 10#define LED_3_PIN 11#define LED_4_PIN 12#define BUTTON_PIN 5byte lastButtonState = LOW;byte currentButtonState = LOW;unsigned long lastButtonDebounceTime = 0;unsigned long buttonDebounceDelay = 20;void powerOffAllLEDs(){ digitalWrite(LED_1_PIN, LOW); digitalWrite(LED_2_PIN, LOW); digitalWrite(LED_3_PIN, LOW); digitalWrite(LED_4_PIN, LOW);}void setup(){ Serial.begin(9600); pinMode(LED_1_PIN, OUTPUT); pinMode(LED_2_PIN, OUTPUT); pinMode(LED_3_PIN, OUTPUT); pinMode(LED_4_PIN, OUTPUT); pinMode(BUTTON_PIN, INPUT); powerOffAllLEDs();}void loop(){ byte readValue = digitalRead(BUTTON_PIN); if (readValue != lastButtonState) { lastButtonDebounceTime = millis(); } if (millis() - lastButtonDebounceTime > buttonDebounceDelay) { if (readValue != currentButtonState) { currentButtonState = readValue; if (currentButtonState == HIGH) { Serial.write(18); } } } lastButtonState = readValue; if (Serial.available() > 0) { int ledNumber = Serial.read() - '0'; powerOffAllLEDs(); switch (ledNumber) { case 1: digitalWrite(LED_1_PIN, HIGH); break; case 2: digitalWrite(LED_2_PIN, HIGH); break; case 3: digitalWrite(LED_3_PIN, HIGH); break; case 4: digitalWrite(LED_4_PIN, HIGH); break; default: // wrong pin number, do nothing // all LEDs will be powered off break; } }}

En la función setup() inicializamos los modos de pin para los 4 led y el pulsador. También nos aseguramos de que todos los led estén apagados.

Luego en el loop () hacemos 2 cosas: manejar el pulsador y administrar los 4 led. Ambas acciones se realizan una por una, pero se manejan muy rápido, por lo que es como si estuvieran sucediendo al mismo tiempo. Es un caso de multitarea de un programa Arduino.

Primera acción: manejo del pulsador.

byte readValue = digitalRead(BUTTON_PIN);if (readValue != lastButtonState) { lastButtonDebounceTime = millis();}if (millis() - lastButtonDebounceTime > buttonDebounceDelay) { if (readValue != currentButtonState) { currentButtonState = readValue; if (currentButtonState == HIGH) { Serial.write(18); } }}lastButtonState = readValue;

Necesitamos rebotar el botón para evitar valores no deseados. Cuando descubrimos que el botón está presionado, podemos enviar algunos datos a Raspberry Pi a través de Serial.

Aquí he usado el Serial.función write (): envía un byte o una serie de bytes. Esto es diferente de Serial.print () que hará que la salida sea agradable de ver en el monitor serie. Como estamos hablando con otra máquina y no con un humano, no hay problema con eso.

El número que enviamos aquí es 18. Este es solo un número aleatorio que asociaremos con el estado «se ha pulsado el botón», por lo que cuando Raspberry Pi reciba un número, comprobará si es igual a 18. Podría imaginar enviar diferentes acciones o mensajes a través de Serial, utilizando diferentes números.

Nota: por lo general, también puede usar interrupciones Arduino para saber cuándo se ha pulsado un botón. Si lo hace, no use la biblioteca en serie en la interrupción. Si es absolutamente necesario usar interrupciones, establezca un indicador dentro de la interrupción (una variable booleana simple) y use Serial dentro de su función loop ().

Y la segunda acción: gestionar los 4 ledes.

 if (Serial.available() > 0) { int ledNumber = Serial.read() - '0'; powerOffAllLEDs(); switch (ledNumber) { case 1: digitalWrite(LED_1_PIN, HIGH); break; case 2: digitalWrite(LED_2_PIN, HIGH); break; case 3: digitalWrite(LED_3_PIN, HIGH); break; case 4: digitalWrite(LED_4_PIN, HIGH); break; default: // wrong pin number, do nothing // all LEDs will be powered off break; } }

Primero comprobamos si el Arduino ha recibido algunos datos de Raspberry Pi a través de la comunicación en serie.

Si es así, leemos el siguiente byte con Serial.Leer(). Aquí puede notar un pequeño truco, que consiste en restar con ‘0’, que convertirá el carácter al número que representa, en este caso un entero.

Después de eso es bastante simple. Apagamos todos los LED, y luego encendemos solo el LED asociado con el número: 1, 2, 3 o 4. En caso de que se envíe un valor incorrecto, no se encenderá ningún LED.

Código Python de Raspberry Pi

#!/usr/bin/env python3import serialimport randomif __name__ == '__main__': ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1) ser.flush() while True: number = ser.read() if number != b'': if int.from_bytes(number, byteorder='big') == 18: led_number = random.randint(1,4) print("Button has been pressed.") print("Sending number " + str(led_number) + " to Arduino.") ser.write(str(led_number).encode('utf-8'))

Primero agregamos una línea de importación: la biblioteca aleatoria de Python.

En el bucle infinito («while True»), primero leemos un byte de Serial. El tiempo de espera se establece en 1 segundo. Si no se recibe nada después de un segundo, la función read() devolverá b».

Así que comprobamos si lo que recibimos está simplemente vacío (b») o si realmente había algo. En este último caso, convertimos los datos que recibimos en un entero para que podamos usarlos en el código. Para ello utilizamos la función int.from_bytes (), que decodificará b’ 0x12 ‘ (la representación hexadecimal de 18 es 0x12) a 18.

Como puede ver, verificamos que el número sea 18 para continuar la acción. Si tiene que manejar diferentes comandos, usar un número diferente para cada comando es una buena práctica.

Elegimos un número aleatorio entre 1 y 4 para determinar cuál llevó al encendido. Luego lo enviamos con la función pySerial write (). Para enviar un int a través de Serial, primero lo convertimos como una cadena con str(), y luego lo codificamos con encode(‘utf-8’).

Probando la aplicación

Ahora puede conectar el Arduino al Raspberry Pi utilizando el cable USB. El Raspberry Pi suministrará la energía tanto para el Arduino como para los 4 LED.

Si tiene muchas cosas conectadas a su Arduino, es posible que desee agregar una fuente de alimentación externa en el conector de la fuente de alimentación Arduino. Por ejemplo, si desea usar un motor paso a paso, el Raspberry Pi nunca tendrá suficiente corriente para sí mismo + el Arduino + el motor. En este caso, con 4 led está bien.

Ejecute su script Python y presione el botón pulsador. Verá un registro y uno de los LED del Arduino se encenderá.

$ chmod +x arduino_raspberry_pi_leds_button.py$ ./arduino_raspberry_pi_leds_button.py Button has been pressed.Sending number 3 to Arduino.Button has been pressed.Sending number 2 to Arduino.Button has been pressed.Sending number 4 to Arduino.Button has been pressed.Sending number 1 to Arduino.Button has been pressed.Sending number 3 to Arduino.Button has been pressed.Sending number 3 to Arduino.

Cada vez que pulse el botón:

• El Arduino lo detectará y enviará 18 a la Raspberry Pi.
• La Raspberry Pi recibirá algunos datos de Serial. Comprobará si el número es igual a 18. En caso afirmativo, se elige un número aleatorio (entre 1 y 4). El Raspberry Pi enviará este número al Arduino.
• El Arduino recibirá este número y encenderá el LED asociado.

Nota: para hacer esta aplicación más rápido y con menos código, también puede optar por usar el protocolo Firmata, con, por ejemplo, la biblioteca pyFirmata en Raspberry y la biblioteca Standarfirmata en Arduino. Echa un vistazo a esos tutoriales para obtener más información.

Conclusión

En este tutorial ha aprendido a comunicarse entre su Raspberry Pi y su placa Arduino a través de Serie.

Ahora, en la vida real, ¿le será útil? La respuesta es sí, y muy a menudo.

Raspberry Pi es ideal para tener una gran cantidad de potencia de computación incorporada en su aplicación. Puede ejecutar software completo en muchos idiomas, servidores web, aplicaciones de robótica, etc. La Raspberry Pi ciertamente tiene algunos GPIOs que puedes usar, pero no son tan buenos como los Arduino. Además, tiene más posibilidades de quemar su Pi si hace algo mal con el hardware.

El Arduino es más apropiado para manejar directamente sensores y actuadores de hardware: IMU, servomotores, motores paso a paso, cualquier cosa que requiera más potencia, etc. – más información sobre cuándo usar Arduino vs Raspberry Pi.

En conjunto, las 2 placas pueden funcionar perfectamente juntas: La Raspberry Pi como el » cerebro «de la aplicación, y la Arduino como los» músculos», con una comunicación en serie para hacerlos hablar entre sí.