COMUNICACIÓN SERIE CON EL MUNDO EXTERIOR
Más antes que después, vamos a necesitar comunicar nuestro
Arduino con nuestro PC. Las razones son varias, enviarle órdenes o recibir
información o señales por ejemplo.
Los PCs disponen de teclados, pantallas y adaptadores de
red, pero con Arduino tenemos que usar el puerto USB que establecerá una conexión
en serie con nuestro PC.
La comunicación en serie es muy sencilla, bastan dos hilos
para enviar una diferencia de tensión entre ellos y poder marcar niveles alto
(5V) y bajo(0V) y con esto podemos transmitir información digital. Ahora solo
nos falta pactar dos cosas entre quien envía y quien recibe:
Un código común para codificar los caracteres que
enviamos.
Un acuerdo de velocidad para saber a qué ritmo hay
que leer los datos.
El código común que vamos a usar con Arduino se llama código
ASCII y es estándar en todos los PCs. Es una forma de codificar las letras
mediantes números que representas estos caracteres. Recordad que solo podemos
transmitir unos y ceros.
Así por ejemplo la letra A se representa por el numero 65,
la B el 66, C el 67… Prácticamente todos los PCs actuales utilizan
este código y eso incluye a Windows, Mac y Linux (y por eso podemos leer emails
enviados desde distintas plataformas), pero es importante comprender que esté
es uno más entre varios códigos de caracteres posibles (EBCDIC por ejemplo).
Actualmente, en realidad, se suele usar una extensión del código
ASCII(llamada Unicode) que permita el uso de caracteres no incluidos en la
tabla original, y que permita representar caracteres como las Ñ, o acentos para
el español, pero también alfabetos distintos como el Kanji chino o el alfabeto
cirílico. Y este es el motivo por el que podéis leer las letras chinas o rusas
en las páginas de internet de estos países..
El otro factor a pactar para realizar una comunicación serie
es la velocidad. Dado que solo disponemos de dos hilos para transmitir,
necesitamos saber cuándo hay que leer la línea y esto se hace estableciendo un
acuerdo de velocidad. Si la velocidad de envío es distinta de la velocidad de
lectura, el mensaje final será irreconocible.
Buena parte de los errores de comunicación serie programando
con Arduino se suelen deber a una diferencia de velocidad entre el emisor y el
receptor.
Esta velocidad se mide en bits por segundo y vamos a ver que
Arduino soporta diferentes velocidades de comunicación serie.
ESTABLECIENDO LA COMUNICACIÓN SERIE
.
Arduino dispone de una librería serie incluida llamada
Serial, que nos permite envía información al PC y para usarla simplemente
tenemos que pedirle en nuestro setup() que la incluya. La instrucción que se
encarga es:
Serial.begin( velocidad ) ;
Nótese que Serial tiene la S mayúsculas y que C++ diferencia
entre mayúsculas y minúsculas
La velocidad es una valor entre 300 y 115.200 bits por
segundo. Y suele ser costumbre establecerla en 9600 (el valor por defecto) pero
no hay ninguna razón para ello y esta no es una velocidad especialmente alta.
Para enviar un mensaje desde Arduino a nuestro PC podemos
usar las funciones Serial.print() y Serial.println().Veamos un ejemplo:
int LED = 10 ; int boton = 6 ;
bool estado = false ;
void setup()
{
Serial.begin(9600) ; // Inicializa el Puerto seria 9600 bits por segundo
}
void loop()
{
int i = 54 ;
Serial.println( i );
}
El println() enviara el valor de i al puerto serie de
Arduino (repetidamente). Para leerlo en nuestro PC necesitamos un monitor de
puerto serie. El IDE de Arduino incluye uno muy sencillo, pero suficiente que
se invoca con el botón del monitor:
Necesitamos además asegurarnos de que la velocidad de
conexión es la misma en ambos extremos. Fíjate en la parte inferior derecha del
monitor serie:
Normalmente la velocidad por defecto son los 9600 bits por
segundo o baudios en los que hemos programado nuestra puerta serie, y
si lo desplegáis, veréis las diferentes velocidades aceptables para Arduino.
Estrictamente hablando, bits por segundo y baudios no son
exactamente lo mismo salvo bajo ciertas condiciones particulares que en Arduino
se cumplen, por lo que aquí podemos usarlos como sinónimos.
En el mundo Arduino parece haber un acuerdo de usar
velocidades bajas como 9600 en lugar de más altas como 115200, para evitar
problemas. Esto es algo que hace años estaba justificado por problemas de
transmisión, pero con la tecnología actual no hay motivo para ello. Es más, en
cuanto necesitemos utilizar dispositivos de comunicaciones como adaptadores
Ethernet o BlueTooth para comunicarnos, la velocidad tendrá que subir
necesariamente.
Ahora que sabemos enviar información y resultados al
PC, vamos a ver cómo podemos operar con enteros y mostrar el resultado en la
puerta serie. En C++ los operadores numéricos son los normales en cálculo (y
algunos menos frecuentes):
·
Adición:
+
·
Resta:
–
·
Multiplicación: *
·
División entera: /
Cociente sin decimales (puesto que
operamos con enteros
·
Resto:
%
Devuelve el resto de una división.
En C++ tenemos que expresar las operaciones matemáticas en
una sola línea y utilizar paréntesis para garantizar que se opera como
necesitamos. Vamos con algunos ejemplos:
OPERACIÓN
|
RESULTADO
|
COMENTARIO
|
int i = 4 * 2
|
resultado = 8
|
|
int i = 4 * 2 / 3
|
resultado = 2
|
Porque desprecia los decimales al ser entero
|
int i = 14 % 3
|
resultado = 2
|
El resto de 14 entre 3
|
Int i = 2 + 8 / 2
|
resultado = 6
|
Calcula primero la división.
|
Int i = (2+8) / 2
|
resultado = 5
|
El paréntesis fuerza a que se realice primero la suma
|
Dada una expresión, la precedencia de operadores indica que
operaciones se realizaran antes y cuales después en función de su rango. Para
los que se inician en C++ no es fácil saber que operadores tienen preferencia,
por lo que es más seguro que ante la duda uséis paréntesis.
Los paréntesis fuerzan las operaciones de una forma clara y
conviene utilizarlos ante la duda porque de otro modo, detectar los errores de
operación puede volverse muy difícil especialmente cuando uno empieza a
programar.
El operador resto es más útil de lo que parece a primera
vista porque nos permite saber si un numero es múltiplo de otro.
Supongamos que queremos saber si un número dado es par.
Podríamos escribir un programa como este:
void setup()
{
Serial.begin(9600) ; // Inicializa el Puerto serie
}
void loop()
{
int i = 27 ; //El número en cuestión
if ( i % 2 == 0)
Serial.println("Es par.") ;
else
Serial.println("Es impar");
}
k
Dando a i distintos valores podemos comprobar cómo funciona
el operador resto %. Volveremos sobre esto cuando veamos algunos ejemplos de
cómo calcular números primos.
En este programa hemos usado de un modo diferente el Serial.println()
pasándole una String de texto entrecomillada. Serial.print() envía el texto (
entrecomillado) que le pongamos pero no da salto de línea cuando termina. En
cambio Serial.println() hace lo mismo e incluye al final ese salto de línea.
void setup()
{
Serial.begin(9600) ; // Inicializa el Puerto serie
}
void loop()
{
Serial.print("Buenos ") ;
Serial.print("Dias ") ;
Serial.println("a todos.") ;
}
C++ dispone de un tipo de variables llamadas Strings,
capaces de contener textos. Podemos operar con ellas simplemente definiéndolas
como cualquier otro tipo de C++:
void loop()
{
int resultado = 25 ;
String s = “ El resultado es: ” ; // Nótese que la S de string es mayúscula.
Serial.print( s) ;
Serial.println( resultado);
}
Un tipo String se define simplemente poniendo entre comillas
dobles un texto, y se puede operar con ellas de una forma similar a como
operamos con enteros. Prueba:
void loop()
{
String a = "hola " ;
String b = "a todos." ;
Serial.println( a + b);
}
g
Y también podemos construir un String sobre la marcha
así:
void loop()
{
int resultado = 25 ;
String s = "El resultado es: " ;
Serial.println( s + String( resultado ));
}
Comentarios
Publicar un comentario