Cada placa Arduino suele programarse a través de la interfaz serie.
Pero no sólo el código del programa se puede transferir al Arduino. También puedes enviar comandos de control al Arduino o recibir valores del Arduino.
Describo cómo funciona esto y qué opciones tienes en el siguiente artículo.
Instrucciones de seguridad
Sé que las siguientes notas siempre son un poco molestas y parecen innecesarias. Desafortunadamente, muchas personas que sabían "mejor" han perdido ojos, dedos u otras cosas debido a un descuido o se lesionaron. La pérdida de datos es casi insignificante en comparación, pero incluso estos pueden ser realmente molestos. Por lo tanto, tómese cinco minutos para leer las instrucciones de seguridad. Porque incluso el proyecto más genial no vale la pena lesionarse u otros problemas.
https://www.nerdiy.de/sicherheitshinweise/
Enlaces afiliados / enlaces publicitarios
Los enlaces a las tiendas en línea enumerados aquí son los llamados enlaces de afiliados. Si hace clic en dicho enlace de afiliado y realiza una compra a través de este enlace, Nerdiy.de recibirá una comisión de la tienda en línea o el proveedor correspondiente. El precio no cambia para usted. Si realiza sus compras a través de estos enlaces, ayuda a Nerdiy.de a poder ofrecer otros proyectos útiles en el futuro. 🙂
Preparar interfaz serial
Para utilizar el puerto serie en su programa, debe inicializarlo.
Esto se hace usando la función en la función "setup()"
Serial.begin(115200);
llamadas. El número "115200" representa la velocidad en baudios, es decir, la velocidad, a la que se transmiten los símbolos (no bits ni bytes) a través de la interfaz serie. Esta velocidad debe depender de la “calidad” de la línea de conexión.
Por ejemplo, si tiene un cable blindado y muy corto, la velocidad se puede establecer muy alta.
Esta velocidad no debe elegirse tan alta para cables no apantallados y/o muy largos.
Las velocidades de baudios comunes incluyen los siguientes valores:
50 110 150 300 1200 2400 4800 9600 19200 38400 57600 115200 230400 460800 500000
Independientemente de la velocidad que establezca, este valor también debe configurarse en el “monitor en serie”, es decir, en el otro interlocutor para la comunicación en serie. Sólo así los caracteres serán recibidos y enviados correctamente. Descubrirá más sobre esto a lo largo del texto.
Si no está seguro de qué velocidad en baudios debe utilizar, le recomiendo valores entre 9600 baudios y 115200 baudios. Estos y los valores intermedios son también valores comunes para muchos productos terminados, como sensores y actuadores.
Enviar datos desde la placa Arduino a la computadora conectada
Para que pueda enviar datos desde su placa Arduino a la computadora conectada, debe llamar a la siguiente función.
Esto envía el texto "¡Hola mundo!" incluyendo saltos de línea a la computadora.
Serial.println("¡Hola mundo!");
Como ejemplo, puede probar el siguiente código.
configuración vacía () { Serial.begin (115200); } void loop() { Serial.println("¡Hola mundo!"); retraso (1000); }
En la siguiente combinación, la función envía el texto "¡Hola mundo!" al ordenador sin saltos de línea.
Serial.print("¡Hola mundo!");
Hay otro ejemplo de esto.
configuración vacía () { Serial.begin (115200); } void loop() { Serial.print("¡Hola mundo!"); retraso (1000); }
Si desea enviar valores de variables – en este caso el valor de la variable “funny_variable” – puede hacerlo de la siguiente manera:
uint8_t variable_divertida=5; Serial.println(String(funny_variable));
Como ejemplo, todo se ve así de nuevo.
configuración vacía () { Serial.begin (115200); } void loop() { uint8_t variable_divertida=5; Serial.println(String(funny_variable)); retraso (1000); }
Enviar un salto de línea significa que, además del contenido real del mensaje, se envía un carácter de control que indica al destinatario que pase a la siguiente línea.
Usar monitor serie
El monitor serie es la contraparte de la placa Arduino. Es el programa que recibe los datos en la computadora y los hace legibles para usted.
Puede encontrarlo como parte del IDE de Arduino en el elemento de menú "Herramientas/Monitor serie". Herramientas como este “Serial Monitor” también se denominan programas de terminal. El programa también es una buena alternativa al “Serial Monitor” del IDE de Arduino. HTERM.
La velocidad en baudios se puede configurar en la ventana del monitor serie. Aquí se debe establecer el mismo valor que configuró previamente en el código del programa.
¿Ustedes con el comando
Serial.begin(115200);
Entonces, si configura una velocidad en baudios de 115200 baudios, también debe configurar una velocidad en baudios de 115200 baudios en el monitor serie.
Además de la velocidad en baudios, también se puede configurar el carácter de terminación de línea. Solo necesita esta configuración si desea enviar datos desde la computadora al Arduino.
Aquí puede configurar el carácter que se agrega y envía automáticamente cada vez que se envía un valor.
Puede utilizar esto en su código, por ejemplo, para detectar en Arduino si se ha completado la transmisión de un comando o valor.
Esto se explica en detalle en la sección “Envío de comandos y parámetros al Arduino”.
Usar plotter en serie
El trazador en serie es una herramienta con la que se pueden visualizar valores numéricos (p. ej. valores medidos) directamente en el ordenador en forma de progresión temporal. Para ello hay que programar el Arduino para que envíe los valores numéricos al ordenador.
Esto se puede hacer, por ejemplo, con el comando:
Serial.println(VariableConUnaLectura);
Por supuesto, la variable “VariableWithAMeasured Value” debe contener su valor medido como un número.
Luego debe iniciar el trazador en serie en la computadora. Puede encontrarlo en "Herramientas/Plotter serie".
Un ejemplo simple que genera una curva sinusoidal en el trazador en serie es el siguiente. Simplemente prueba el código. Debería ejecutarse en cualquier Arduino. Recuerde configurar su “trazador en serie” a 115200 baudios.
/* _ _ _ _ _ | | | | |(_) | | __ ____ ____ __ | | | ___ _ __ __| | _ _ _ __| | ___ / / / / / / / / / | . ` | / _ | '__|/ _` || || | | | / _` | /_VV/VV/VV/_ | | || __/| | | (_| || || |_| | _| (_| || __/ \_/\_/ \_/\_/ \_/\_/(_)|_| \_| \___| |_| \__,_||_| \__, |(_)\__,_| \___| __/ | |___/ sinusPrueba realizada por Fabian Steppat Información en https://www.nerdiy.de/ardunio- die-serial-interface/ Este programa es software gratuito: puede redistribuirlo y/o modificarlo según los términos de la Licencia Pública General GNU publicada por la Free Software Foundation, ya sea la versión 3 de la Licencia o (a su elección). ) cualquier versión posterior. Este programa se distribuye con la esperanza de que sea útil, pero SIN NINGUNA GARANTÍA; ni siquiera la garantía implícita de COMERCIABILIDAD o IDONEIDAD PARA UN PROPÓSITO PARTICULAR. Consulte la Licencia Pública General GNU para obtener más detalles. Debería tener recibió una copia de la Licencia Pública General GNU junto con este programa. Si no, consulte . Encontrará información adicional sobre este proyecto en la siguiente dirección:
HowTo: Ardunio – Usar el puerto serie
Este codenippet imprime una onda sinusoidal a través de una consola serial o un plotter serial */ //variables y constantes float gradeAngle = 0; flotar sinusValue = 0; constante flotante pi = 3.1415; float radianAngle = 0; const uint8_t sinusFactor = 50; configuración vacía () { Serial.begin (115200); } bucle vacío () { ángulo radiante = ángulo de grado * pi / 180; //haciendo grados en radianes sinusValue = sin(radiantAngle); //calcular el seno a partir del ángulo radiante gradeAngle += 1.0; //aumenta el retraso del ángulo(5); //hace que la salida sea un poco más lenta si (ángulo de grado > 360) //si se alcanza el límite de grados, reinícielo a cero { ángulodegrado = 0; } Serial.println(sinusFactor * sinusValue); //salida al monitor/trazador serie}
Por supuesto, el trazador no sólo trabaja con valores sinusoidales, sino también con todos los demás valores numéricos.
Envía comandos y parámetros al Arduino
Ahora ya sabe cómo enviar varios mensajes de estado o valores desde el Arduino a la computadora.
Pero también sucede al revés. Esto es particularmente útil o práctico si controlas el Arduino desde fuera y no quieres conectar dispositivos de entrada como botones, etc. al Arduino (o no puedes hacerlo debido a la falta de GPIO).
Por ejemplo, puede ajustar el brillo o el color de un LED o la velocidad del motor de un motor conectado utilizando únicamente la interfaz serie.
El IDE de Arduino proporciona algunas funciones útiles para la comunicación a través de la interfaz serie. (La documentación con más detalles se puede encontrar aquí: https://www.arduino.cc/reference/en/language/functions/communication/serial/)
Para garantizar que los comandos se reciban y evalúen, ahora hay tres tareas que resolver:
1. ¿Cómo reconoce Arduino los caracteres recibidos?
2. ¿Cómo se componen los comandos completos de los caracteres recibidos?
3. ¿Cómo se pueden evaluar estos comandos recibidos?
1. ¿Cómo reconoce Arduino los caracteres recibidos?
Para reaccionar a los caracteres entrantes existe la función
Serial.disponible()
Esto comprueba si hay nuevos caracteres contenidos en el búfer de recepción del Arduino. El búfer de recepción es un tipo de búfer en el que los caracteres recibidos se almacenan hasta que el microcontrolador Arduino tiene tiempo de "cuidarse" de los caracteres recibidos.
En el caso de que se hayan recibido nuevos caracteres pero aún no se hayan leído del búfer de recepción, la función "Serial.available()" devuelve "verdadero", en caso contrario "falso".
Esta función es perfecta para comprobar si actualmente se han recibido caracteres que ahora deben evaluarse. El comando no nos dice cuántos caracteres se recibieron. Simplemente dice que hay al menos un carácter en el búfer de recepción.
2. Cómo convertir los caracteres recibidos en comandos completos
Bien, ahora gracias a la función anterior hemos reconocido que al menos un carácter está disponible en el buffer de recepción. Pero, ¿cómo obtenemos las señales recibidas?
Los caracteres del búfer de recepción se pueden leer con el comando
Serie.leer()
leer. La función genera el primer carácter contenido en el búfer de recepción y lo elimina automáticamente del búfer de recepción.
Para ahora leer todos los caracteres y escribirlos en una variable, ahora leemos del búfer de recepción hasta que esté vacío y observamos cada carácter leído.
Puedes hacer esto con un bucle, por ejemplo:
void check_serial_receipt() { Cadena serialBuffer; while (Serial.available()) { char currentChar = (char)Serial.read(); if (carácter actual == 13) //comprueba si el carácter leído es el carácter terminador de línea { evalua_received_character(serialbuffer); } else { serialBuffer += currentCharacter; } } }
Como puede ver, el código consta de un bucle while que se ejecuta hasta que el búfer de recepción está vacío (luego Serial.available()==false).
Dentro del bucle while, los caracteres contenidos en el búfer de recepción se leen carácter por carácter (Serial.read()), se asignan a la variable "carácter actual" y se agregan a la cadena "búfer serie".
Aquí es donde entra en juego el terminador de línea mencionado en la sección "Monitor serie". En este (y en cualquier otro programa de terminal) puede configurar un carácter que se agrega y envía automáticamente cada vez que se envía un carácter o una cadena de caracteres.
Con este terminador de línea ahora se puede detectar si la cadena de caracteres leída anteriormente está completa y, por lo tanto, se puede evaluar.
Esto significa que se debe verificar cada carácter recibido para ver si es el terminador de línea. En el código que se muestra arriba, esto se hace a través de
si (carácter actual == 13)...
No dejes que el 13 te confunda. El problema con los terminadores de línea es que no aparecen en el teclado. Por lo tanto, no puede "escribirlos" en el código como caracteres de comparación.
Para seguir verificando el carácter recibido para el terminador de caracteres, usamos un truco aquí.
Gracias a tabla ASCII Sabemos que cada carácter en la computadora corresponde a un valor de byte (es decir, un valor numérico entre 0 y 255).
Por ejemplo, si almacena una "A" en el Arduino, en realidad almacena el valor numérico "65".
Si ahora desea comprobar si un carácter recibido corresponde a una "A", puede hacerlo
if (personaje actual == "A")
o también
if (carácter actual == 65)
escribir. Ambas comparaciones llevarían al mismo resultado.
Ahora usaremos este truco. Para verificar si el carácter recibido actualmente es un terminador de línea como CR (=CarriageReturn), no verificamos el carácter en sí sino el valor del carácter en la tabla Ascii: Entonces 13.
Tan pronto como se recibe este carácter, sabemos que todos los caracteres enviados anteriormente deben representar un comando y ahora deben evaluarse.
3. ¿Cómo se pueden evaluar estos comandos recibidos?
Entonces nosotros o Arduino hemos recibido un comando. Esto se almacena en la variable de cadena "búfer serie" y se pasa como parámetro de función a la función "receive_character_evaluate()".
Por ejemplo, esta función podría verse así:
void evalua_received_characters(String serialBuffer) { Serial.println(""" + String(serialBuffer) + "" recibido."); // genera el comando que acabas de recibir if (serialBuffer == "simplerCommandOfWhatDoes") { simpler_command_of_what_does(); } else if (serialBuffer.indexOf('=') != -1) { uint16_tceivedValue = serialBuffer.substring(serialBuffer.indexOf('=') + 1).toInt(); Cadena recibidaParameter = serialBuffer.substring(0, serialBuffer.indexOf('=')); if (receivedParameter == "commandSettingAValue") { if (receivedValue <= 23 &&ceivedValue >= 0) { command_setting_a_value(receivedValue); } else { Serial.println(F("Valor fuera del rango de valores permitido.")); } } else { Serial.print(F("El comando "")); Serial.print(serialBuffer); Serial.print(F("" no fue reconocido.")); } } else { Serial.print(F("El comando "")); Serial.print(serialBuffer); Serial.print(F("" no fue reconocido.")); } }
Después de recibir un comando, se emite nuevamente, lo cual resulta muy práctico, especialmente para fines de depuración. De esta manera puedes comprobar qué cadena de caracteres llegó finalmente al Arduino.
Luego puede utilizar una consulta IF simple para verificar qué cadena de caracteres corresponde al comando recibido. Aquí se comprueba, por ejemplo, si el comando corresponde a la cadena "simplerCommandDerWasTut".
Si este es el caso, la función “simpler_command_that_does_();” ejecutado.
Usando estos comandos “absolutos”, ahora puedes emitir comandos simples. Por ejemplo, para encender o apagar una luz.
Para poder transferir valores, también se deben poder evaluar comandos del tipo “brightnessSetUp=20”.
Por lo tanto, se debe reconocer el nombre del comando (en este caso “brightnessSetOn”) y el valor (en este caso “20”).
Esto se hace en la parte posterior del código que se muestra arriba.
Si ninguno de los comandos "absolutos" coincide con la cadena de caracteres recibida, se comprueba si hay un carácter "=" en la cadena de caracteres recibida.
Por ejemplo, si envió el comando "setBrightness=100" al Arduino, no podrá asignar la cadena completa "setBrightness=100" a un comando "absoluto".
En este caso, la cadena de caracteres recibida se comprueba en busca de un signo igual y también se encuentra.
La cadena de caracteres recibida se divide en la parte anterior y posterior al signo igual con los siguientes comandos.
uint16_t ReceiveValue = serialbuffer.substring(serialbuffer.indexOf('=') + 1).toInt(); Cadena de parámetros recibidos = serialbuffer.substring(0, serialbuffer.indexOf('='));
Ahora el "100" se almacena en la variable "receivedValue" y el comando "setBrightness" se almacena en la variable "receivedParameter".
Una vez extraídos de la cadena recibida, los dos valores se pueden procesar y responder más a fondo.
Pruébalo. 🙂
Puede encontrar el código completo para volver a intentarlo aquí:
/* _ _ _ _ _ | | | | |(_) | | __ ____ ____ __ | | | ___ _ __ __| | _ _ _ __| | ___ / / / / / / / / / | . ` | / _ | '__|/ _` || || | | | / _` | /_VV/VV/VV/_ | | || __/| | | (_| || || |_| | _| (_| || __/ \_/\_/ \_/\_/ \_/\_/(_)|_| \_| \___| |_| \__,_||_| \__, |(_)\__,_| \___| __/ | |___/ serialTest de Fabian Steppat Información en https://www.nerdiy.de/ardunio- die-serial-interface/ Este programa es software gratuito: puede redistribuirlo y/o modificarlo según los términos de la Licencia Pública General GNU publicada por la Free Software Foundation, ya sea la versión 3 de la Licencia o (a su elección). ) cualquier versión posterior. Este programa se distribuye con la esperanza de que sea útil, pero SIN NINGUNA GARANTÍA; ni siquiera la garantía implícita de COMERCIABILIDAD o IDONEIDAD PARA UN PROPÓSITO PARTICULAR. Consulte la Licencia Pública General GNU para obtener más detalles. Debería tener recibió una copia de la Licencia Pública General GNU junto con este programa. Si no, consulte . Encontrará información adicional sobre este proyecto en la siguiente dirección:
HowTo: Ardunio – Usar el puerto serie
Este fragmento de código es un concepto básico de comunicación en serie para controlar un arduino mediante comandos en serie */ { Serial.begin(115200); } bucle vacío() { check_serial_receipt(); } void check_serial_receipt() { String serialBuffer; while (Serial.available()) { char currentChar = (char)Serial.read(); if (currentCharacter == 13) { evaluar_received_character(serialBuffer); } else { serialBuffer += currentCharacter; } } } void evalua_received_characters(String serialBuffer) { Serial.println(""" + String(serialBuffer) + "" recibido."); if (serialBuffer == "simplerCommandOfWhatDoes") { simple_command_of_what_does(); } else if (serialBuffer.indexOf('=') != -1) { uint16_tceivedValue = serialBuffer.substring(serialBuffer.indexOf('=') + 1).toInt(); Cadena recibidaParameter = serialBuffer.substring(0, serialBuffer.indexOf('=')); if (receivedParameter == "commandSetAValue") { if (receivedValue & lt; = 23 & amp; &ceivedValue & gt; = 0) { command_set_a_value(receivedValue); } else { Serial.println(F("Valor fuera del rango de valores permitido.")); } } else { Serial.print(F("El comando "")); Serial.print(serialBuffer); Serial.print(F("" no fue reconocido.")); } } else { Serial.print(F("El comando "")); Serial.print(serialBuffer); Serial.print(F("" no fue reconocido.")); } }
Diviértete con el proyecto.
Espero que todo te haya funcionado como se describe. Si no es así, o si tiene alguna pregunta o sugerencia, hágamelo saber en los comentarios. Si es necesario, lo añadiré al artículo.
Las ideas para nuevos proyectos siempre son bienvenidas. 🙂
PS Muchos de estos proyectos, especialmente los proyectos de hardware, cuestan mucho tiempo y dinero. Por supuesto que hago esto porque lo disfruto, pero si crees que es genial que comparta la información contigo, me encantaría hacer una pequeña donación al fondo del café. 🙂
Español 
Deutsch 
English 
Français 
Nederlands