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.
Dies geschieht indem Ihr in der „setup()“-Funktion die Funktion
Serial.begin(115200);
aufruft. Die Zahl „115200“ steht dabei für die Baudrate – also die Geschwindigkeit – mit der die Symbole Nicht Bits oder Bytes) über die serielle Schnittstelle übertragen werden. Diese Geschwindigkeit solltet ihr von der „Qualität“ der Verbindungsleitung abhängig machen.
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
Egal welche Geschwindigkeit Ihr einstellt, dieser Wert muss auch im „Seriellen Monitor“ – also dem anderen Kommunikationspartner der seriellen Kommunikation – eingestellt werden. Nur dann werden die Zeichen korrekt empfangen und gesendet. Mehr dazu erfahrt Ihr im Laufe des Textes.
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.
Diese sendet den Text „Hallo Welt!“ inklusive Zeilenumbruch an den Computer.
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); }
In der folgenden Kombination sendet die Funktion den Text „Hallo Welt!“ ohne Zeilenumbruch an den Computer.
Serial.print("¡Hola mundo!");
Hay otro ejemplo de esto.
configuración vacía () { Serial.begin (115200); } void loop() { Serial.print("¡Hola mundo!"); retraso (1000); }
Wollt Ihr Variabel-Werte – in diesem Fall den Wert der Variable „lustige_variable“ – senden könnt Ihr dies wie folgt tun:
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.
Ihr findet es als Teil der Arduino-IDE unter dem Menüpunkt „Werkzeuge/Serieller Monitor“. Tools wie dieser „Serielle Monitor“ werden auch Terminalprogramme genannt. Eine gute Alternative zu dem „Seriellen Monitor“ der Arduino-IDE ist auch das Programm 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.
Im Bereich „Befehle und Parameter an den Arduino senden“ wird dies ausführlich erklärt.
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);
Die Variable „VariableMitEinemMesswert“ sollte natürlich euren Messwert als Zahl enthalten.
Auf dem Computer müsst ihr dann den Seriellen Plotter starten. Diesen findet ihr unter „Werkzeuge/Serieller Plotter“.
Ein simples Beispiel das auf dem seriellen Plotter eine Sinus-Kurve ausgibt ist das folgende. Probiert den Code einfach aus. Er sollte sich auf jedem Arduino ausführen lassen. Denkt daran Euren „Seriellen Plotter“ auf 115200 baud einzustellen.
/* _ _ _ _ _ | | | | |(_) | | __ ____ ____ __ | | | ___ _ __ __| | _ _ _ __| | ___ / / / / / / / / / | . ` | / _ | '__|/ _` || || | | | / _` | /_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()
Diese prüft ob neue Zeichen im Empfangspuffer des Arduino enthalten sind. Der Empfangspuffer ist dabei eine Art zwischenspeicher in dem empfangene Zeichen solange gespeichert werden bis der Mikrocontroller des Arduinos Zeit hat sich um die empfangegenen Zeichen zu „kümmern“.
In dem Fall, dass neue Zeichen empfangen, aber noch nicht aus dem Empfangspuffer gelesen wurden gibt die Funktion „Serial.available()“ „true“ zurück ansonsten „false“.
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).
Innerhalb der while-Schleife werden währenddessen zeichenweise die auf dem Emfpangspuffer enthaltenen Zeichen ausgelesen (Serial.read()), der Variable „aktuellesZeichen“ zugewiesen und an den String „seriellerPuffer“ angehängt.
Hier kommt nun auch das im Abschnitt „Serieller Monitor“ erwähnte Zeilenabschlusszeichen ins Spiel. In diesem (und jedem anderen Terminalprogramm) lässt sich nämlich ein Zeichen einstellen, welches nach jedem Absenden eines Zeichens oder einer Zeichenkette automatisch angehängt und mitgesendet wird.
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)...
Lasst euch von der 13 nicht verwirren. Das Problem bei Zeilenabschlusszeichen ist nämlich, dass diese auf einer Tastatur nicht aufgeführt sind. Man kann sie also nicht als Vergleichszeichen in den Code „eintippen“.
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).
Wenn ihr im Arduino also zum Beispiel ein „A“ speichert, so speichert dieser eigentlich den Zahlenwert „65“.
Würde man nun prüfen wollen ob ein empfangenes Zeichen einem „A“ entspricht könnte man entweder
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?
Wir bzw. der Arduino hat nun also einen Befehl empfangen. Dieser ist in der String-Variable „seriellerPuffer“ gespeichert und wird als Funktionsparameter an die Funktion „empfangene_zeichen_auswerten()“ übergeben.
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.
Danach kann mit einer einfachen IF-Abfrage geprüft werden welcher Zeichenkette der empfangene Befehl entspricht. Hier wird zum Beispiel geprüft ob der Befehl der Zeichenkette „simplerBefehlDerWasTut“ entspricht.
Ist dies der Fall wird die Funktion „simpler_befehl_der_was_tut();“ ausgeführt.
Mithilfe dieser „absoluten“ Befehle könntet ihr nun einfache Befehle absetzen. Zum Beispiel um ein Licht ein- oder auszuschalten.
Um nun aber auch Werte übergeben zu können müssen auch Befehle der Form „helligkeitSetzenAuf=20“ ausgewertet werden können.
Es muss also der Befehlsname (in diesem Fall „helligkeitSetzenAuf“) und der Wert (in diesem Fall „20“) erkannt werden.
Esto se hace en la parte posterior del código que se muestra arriba.
Sollte nämlich keiner der „absoluten“ Befehle zu der empfangenen Zeichenkette passen wird geprüft ob in der empfangenen Zeichenkette ein „=“-Zeichen Vorhanden ist.
Solltet Ihr also zum Beispiel den Befehl „setzeHelligkeit=100“ an den Arduino gesendet haben wird er die gesamte Zeichenkette „setzeHelligkeit=100“ keinem „absoluten“ Befehl zuordnen können.
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('='));
Nun ist in der Variable „empfangenerWert“ die „100“ und in der Variable „empfangenerParameter“ der Befehl „setzeHelligkeit“ gespeichert.
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