Antes de seguir avanzando con los tutoriales, vale la pena pararse un poco y explicar una cualidad que posee Arduino y que se está integrando cada vez en más dispositivos, es la propiedad de poder comunicarse con otros periféricos mediante el "puerto serial". Esta cualidad puede ser muy útil a la hora de interconectar dispositivos y hacer proyectos complejos, pero ahora que estáis empezando a programar, donde va a tener una gran utilidad va a ser a la hora de depurar vuestros programas y buscar errores, ya que algunas veces, no sabréis si lo que falla es el programa o si por lo contrario el problema está en el cableado.
El entorno de programación de Arduino, posee una herramienta llamada "Monitor Serial", esta herramienta abrirá una consola con la que podemos comunicarnos con Arduino, tanto para mandarle comandos como para recibir información . Esto es muy útil para conocer el estado de las variables de programa y saber qué es lo que realmente está pasando dentro de nuestro Arduino.
Para esta práctica vamos a usar el montaje de la practica anterior (E/S analógicas) y utilizando el puerto serial, vamos a leer el valor de las variables que usamos en el programa.
En función del modelo de Arduino con el que estéis trabajando, dispondréis de más o menos puertos serial para la comunicación, pero como mínimo tendréis un puerto serial asociado a los pines 0 (RX) y 1 (TX) de vuestro Arduino.
Tened en cuenta que si habilitáis el puerto serial, no podréis usar los pines 0 y 1 como entrada o salida digital.
{module ads_texto_articulo}
Primer ejercicio
Para trabajar con el puerto serial, lo primero que debéis de hacer es habilitarlo, para ello tenéis que incluir la función Serial.begin(baud-rate) dentro del SetUp, asignándole el valor al cual queremos realizar la comunicación. Un valor muy común es el de 9600.
La inicialización del puerto serial quedaría de la siguiente manera:
void setup(){
Serial.begin(9600); //inicialización del puerto serial
}Ahora que hemos inicializado el puerto serial, vamos con el programa completo, como podéis ver, es el mismo programa que usamos en la práctica anterior, pero le he incluido alguna instrucciones para visualizar los datos del programa mediante el puerto serial.
/* Tutorial 3: Puerto Serial
En este tutorial, vamos a leer y escribir datos en el puerto serial.
Ejemplo 1º: Lectura de variables de programa a traves del puerto serial.
*/
int LED = 10; //Asociamos el pin 10 a la salida del LED
int NIVEL_TENSION = 0; //Asociamos el pin 0 a la entrada de señal
int VALOR = 0; //Creamos una variable y le asignamos el valor "0" como partida
void setup(){
Serial.begin(9600);
pinMode(LED, OUTPUT); //Establece el el pin al que conectamos el LED como salida (no es necesario)
pinMode(NIVEL_TENSION, INPUT); //Establece el el pin por el que entrará la señal analógica (no es necesario)
}
void loop(){
VALOR = analogRead(NIVEL_TENSION); //Asignamos a la variable "VALOR" el nivel de tensión leido
Serial.print("Valor 10 bit's: "); //Imprime el texto que esta entre las comillas
Serial.print(VALOR); //Imprime el la variable "VALOR" (10 bit's)
Serial.print("\t"); //Introduce una tabulación
VALOR = VALOR/4; //Al leer un valor analogico, este tiene 10 bit's, va de 0 a 1023, por lo que debemos adaptarlo al rango de 0 a 255
//(una manera sencilla es dividiendo entre 4)
analogWrite (LED, VALOR);
Serial.print("Valor 8 bit's: "); //Imprime el texto que esta entre las comillas
Serial.println(VALOR); //Imprime el la variable "VALOR" (8 bit's)
delay(1000);
}Las instrucciones que he usado son Serial.print(valor) que imprime en el puerto serial los datos de la variable en formato ASCII. Esta instrucción puede tener un parámetro extra si queremos visualizar los datos en otro formato, quedando la instrucción de la siguiente manera:
Serial.print(valor, formato)
Pudiendo "formato" tomar los valores BIN (binario), OCT (octal), DEC (decimal) y HEX (hexadecimal). En versiones antiguas de Arduino, también estaba disponible el sacar los datos en formato "BYTE", pero este formato fue eliminado, si queremos sacar un byte en pantalla, podemos utilizar la función Serial.write(valor).
También debéis saber, que si lo que queréis mostrar en pantalla no es una variable de programa o algún otro dato, sino que es un texto, podéis imprimirlo en pantalla simplemente poniendo el texto que queráis entre comillas, quedando de la siguiente manera:
Serial.print("Texto que se desea mostrar")
La instrucción Serial.println(valor) funciona igual que la instrucción Serial.print(valor), la única diferencia es que introduce un retorno de carro y salto de línea, esto se usa para ver los datos ordenados en el monitor serial, ya que si no hiciéramos esto, saldría todo en la misma línea y sería totalmente ilegible.
Otra instrucción que he colocado para hacer más visible los datos es Serial.print("\t"), y es que el comando "\t" introduce una tabulación entre los datos, quedando estos separados y haciéndolos mucho mas legibles. Si queréis introducir un salto de línea sin usar la función Serial.println(valor), podéis poner Serial.print("\n") y automáticamente los datos se empezarán a escribir en una nueva línea.
Para abrir el monitor serial y ver cómo trabajan realmente estas funciones, id a la barra de herramientas y haced clic en "Monitor Serial" o bien usad el atajo de teclado (Ctrl+Mayúsculas+M), automáticamente se os abrirá una consola desde donde podréis ver impreso en pantalla las variables "VALOR" antes y después de realizar la conversión de 10 a 8 bit's (VALOR = VALOR/4).
En la parte superior de la consola, hay un hueco donde se puede escribir y mandar datos a Arduino, esto es muy útil cuando estamos desarrollando aplicaciones que requieren una comunicación o cuando para depurar el programa hacemos que Arduino ejecute una u otra cosa en función de los datos que le mandemos a través del puerto serial.
Segundo ejercicio
En este segundo ejercicio, además de usar las funciones para imprimir o escribir en el puerto serial, vamos a usar dos funciones muy útiles a la hora de trabajar con el puerto serial, la primera función que vamos a usar será para leer un valor del puerto serial y la segunda, lo que nos va a decir es la disponibilidad del puerto serial, ya que puede haber algún dato en el búfer esperando ser leído.
Este segundo ejemplo va a seguir guardando relación con el ejemplo del tutorial anterior (el de las E/S analógicas), usando el mismo montaje y los mismo elementos. El programa, como hacia anteriormente, leerá el valor del potenciómetro, pero esta vez no va a hacer que el LED brille mas o menos en función de este valor, sino que va a usar este valor como una variable a mostrar por el puerto serial. Esta variable podría mostrarse de igual forma que en el ejercicio anterior, haciendo que cada X segundos se imprimiera en pantalla, pero voy a implementar una función que comprueba la disponibilidad del puerto serial y si hay datos en el buffer (le introducimos un valor en el puerto serial) pasará a ejecutar las instrucciones que estén dentro del condicional "if".
Aquí tenéis el programa completo:
/* Tutorial 3: Puerto Serial
En este tutorial, vamos a leer y escribir datos en el puerto serial.
Ejemplo 2º: Lectura de variables de programa a traves del puerto serial.
*/
int LED = 10; //Asociamos el pin 10 a la salida del LED
int NIVEL_TENSION = 0; //Asociamos el pin 0 a la entrada de señal
int VALOR = 0; //Creamos una variable y le asignamos el valor "0" como partida
int LEIDO = 0;
void setup(){
Serial.begin(9600);
pinMode(LED, OUTPUT); //Establece el el pin al que conectamos el LED como salida (no es necesario)
pinMode(NIVEL_TENSION, INPUT); //Establece el el pin por el que entrará la señal analógica (no es necesario)
}
void loop(){
VALOR = analogRead(NIVEL_TENSION); //Asignamos a la variable "VALOR" el nivel de tensión leido
if(Serial.available()>0){ //Comprueba si hay datos en el buffer de entrada
//(si no hay datos Serial.aviable será igual a 0 y no entraría en el bloque "if")
digitalWrite(LED, HIGH); //LED para indicar que estamos dentro del bloque "if"
LEIDO = Serial.read(); //Almacena el dato leido del puerto serial en la variable "LEIDO"
Serial.write (LEIDO); //Escribe en pantalla el dato leido en le puerto serial
Serial.print ("\t"); //Introduce una tabulación para separar el texto
Serial.println (VALOR); //Imprime en pantalla el valor asociado al nivel de tensión del potenciómetro.
delay(500); //Espera 500ms
}
digitalWrite(LED, LOW); //Apaga el LED para indicar que estamos fuera del bloque "if"
}La primera instrucción desconocida hasta ahora que nos encontramos es Serial.available(), esta instrucción, la voy a usar para detectar si hay datos esperando en el buffer de entrada, ya que Serial.available(), va a devolver un valor entero con el numero de bytes que están en el buffer a la espera de ser leídos.
El número máximo de bytes que podemos almacenar en el buffer es de 64
En el programa, he creado un bloque "if" al que le he dado la condición para entrar "Serial.available()>0", quedando de la siguiente manera:
Esta sentencia, se puede traducir por "Si hay algún dato disponible en el buffer para la lectura ejecuta las sentencias que están entre las llaves".
Dentro del bloque "if", la primera instrucción que nos encontramos, enciende el LED conectado al pin 10, esto no es ms que un indicador para saber que estamos dentro del bloque "if". Como podemos ver, posteriormente leemos el dato del buffer.
Para leer datos del puerto serial, es muy sencillo, tan solo debemos de usar la función Serial.read(dato) y almacenar este dato en alguna variable, quedando la función de esta manera:
Variable = Serial.read(dato)
Una vez que tenemos este dato almacenado en una variable, ya podremos trabajar con él a placer y aplicarle cuantas operaciones queramos, por ejemplo, se me ocurre trabajar con condicionales que hagan una cosa y otra en función del dato introducido en el puerto serial.
En este ejemplo, y para seguir trabajando con las funciones del puerto serial, lo que hago es mostrar en pantalla, tanto el dato introducido por el puerto serial como el valor de tensión leido del potenciómetro.
Comentarios potenciados por CComment