¡Saludos, estudiantes!. ¡Bienvenidos!. ¡Pasad!, ¡pasad!. ¡Me alegro mucho de veros otra vez!.

En esta ocasión, vamos a tratar de llevar a cabo una práctica que nos sirva de introducción al puerto serie de Arduino. Ya hemos hecho algo así en otro texto en el que teníamos como intención realizar alguna cosita con Bluetooth en un segundo paso. Como el hombre propone y Dios dispone, esa intención de momento no ha abandonado el cielo de los buenos propósitos para encarnarse en un artículo como Dios manda. Sin embargo, y aprovechando que en estas fechas estoy introduciendo a mi alumnado de 4º de ESO de Tecnología Robótica al uso de este utilísimo puerto, vamos a enfocar este mismo aspecto de nuestra queridísima Arduino desde un punto de vista mucho más simplón.

¿Qué es el puerto serie y qué utilidad le puedo sacar?

Como siempre, te reconoceré que hay multitud de webs y fuentes mucho más documentadas y autorizadas que este humilde rincón para explicarte qué es el puerto Serie. De todos modos, sí te puedo decir que un puerto, en Informática, es cualquier zona física o virtual en un sistema informático que permite la entrada y/o salida de información de dicho sistema (sea éste un ordenador, un smartphone, una tablet, etc...)

En el IDE de la plataforma Arduino, y en el momento de escribir estas líneas, el botón que abre la ventana del puerto Serie (el monitor serie, o Serial Monitor, en inglés), está arriba, a la derecha, y tiene una forma que recuerda a una lupa.

Al abrir esta ventana, veremos tres zonas claramente diferenciadas: arriba hay un cuadro de texto en el que podremos enviar información (enviar), la zona principal muestra la información que Arduino envía al ordenador (recibir), y abajo podremos especificar la velocidad a la queremos que se realice la comunicación (9600 baudios, o bits por segundo, por defecto) y si queremos que cada "golpe" de información se produzca con retornos de carro o  no, etc... (fuente de la imagen: www.luisllamas.es)

¡En fin!. Al primer golpe de vista, puede parecer complicado. Vamos a ver si con un par de ejemplos prácticos os lo dejo algo más claro.

Tres comandos para empezar: Serial.begin(), Serial.println() y Serial.print()

A través del cable USB, nuestra Arduino puede comunicarse directamente con el ordenador, a través del monitor Serie. Para ello, necesitamos inicializarlo siempre en setup() con la orden Serial.begin(9600);

9600 es la velocidad en baudios (bits por segundo) a la que pueden intercambiar datos ambas plataformas. Estas velocidades, concretamente cuando "peleemos" con otras plataformas, como Bluetooth, pueden cambiar, dependiendo del modelo con el que trabajemos. De momento, no nos moveremos de este valor.

En la función loop(), usaremos, al principio, sólo dos comandos distintos para que Arduino envíe datos al ordenador:

Serial.print(“whatever”); //Escribe una línea sin cambio de renglón

Serial.println(“more whatever”);//Escribe el texto con cambio de renglón

Nota: Cuando queramos escribir tabulaciones, utilizaremos el comando Serial.print(“\t”);

 Ejemplo: cuenta de segundos a través del puerto Serie

//Declaramos una variable de tipo Integer
int cuenta=0;
void setup() {
//Inicializamos el puerto Serie
Serial.begin(9600);
}

void loop() {
//Pasamos el valor "cuenta" por el puerto serie, separado por retornos de carro
Serial.println(cuenta);
cuenta=cuenta+1;
delay(1000);
}

Si subís el código a vuestra placa, y manteniendo el cable USB conectado activáis el monitor Serie, veréis que el resultado es poco espectacular, pero muy ilustrativo: una cuenta atrás. 0... 1... 2... 3...

Como alternativas, os sugiero que cambiéis la instrucción Serial.println(cuenta); por Serial.print(cuenta); (la diferencia es que ahora los números de la cuenta atrás se imprimen de modo seguido en el mismo renglón). Un último cambio interesante sería sustituir este comando por dos:

Serial.print(cuenta);
Serial.print("\t");

¿Podéis ver las sutiles diferencias?. ¡No es tan difícil!. ¡Vamos a complicar un poco la cosa!

Enviando datos a Arduino a través del puerto Serie. El comando Serial.read();

Arduino también puede leer datos que le enviemos nosotros a través del comando Serial.read(); es importante comprender que hay que asignar este comando a una variable, y tener muy claro qué tipo de variable será esta, lo que al principio es un poco engorroso. Nosotros, en nuestras prácticas, empezaremos con variables de tipo char (texto de un sólo carácter). Todos los textos, en Arduino, deben ir rodeados de comillas SIMPLES (la tecla que hay al lado del 0).

El mejor modo de comprenderlo es realizando una práctica. Así que vamos a empezar con el circuito más sencillo del mundo: un LED conectado al pin 13 (no por nada, sino porque el pin 13 es el que está normalmente asociado al led integrado en la placa, por lo que podemos ahorrarnos su montaje en protoboard). Ya sé que, a estas alturas, sabéis montar de sobra un led, pero, sólo por deferencia a los recien llegados, permitidme que ponga de nuevo el esquema a realizar:

Pasemos a picar (o copiar/pegar) el siguiente código:

//Declaramos las variables char valor (inicializada con espacio vacío) y entera led
char valor='d'
int led=13;
void setup() {
//Inicializamos el puerto serie
Serial.begin(9600);
//Preparamos el pin 13 como salida
pinMode(led,OUTPUT);
}

void loop() {
  //Asignamos a la variable lo que se lee por el puerto serie
valor=Serial.read();
//¿Hemos puesto la tecla 'e'?,¡Enciende!
if (valor=='e'){
  digitalWrite(led,HIGH);
}
//¿Hemos puesto la tecla 'a'?,¡Apaga!
if (valor=='a'){
  digitalWrite(led,LOW);
}
//dejamos un tiempo prudencial de espera
delay(100);
}

Si escribimos algo en el puerto serie, la función loop() la asignará a la variable valor. Las dos sentencias de control de flujo if() comprueban si valor vale 'e' o 'a', y actúa en consecuencia (enciende o apaga el led). ¡Fácil!

Antes de que los puristas os lancéis en tromba, ya adelanto yo que en realidad, un uso racional de Serial.read() debería ir precedido de un if (Serial.available()>0) para garantizar que sólo se procede cuando hay datos en el puerto, sobre todo si necesitamos un flujo constante de datos entre la placa y el ordenador. No lo he hecho así tratando de simplificar al máximo nuestro ejemplo, y porque para el caso que nos ocupa funciona igualmente.

Parece que le habéis cogido el tranquillo... ¡Vamos a complicar un poquito la cosa!

¿Qué?. ¿Lo habéis pillado?. ¡Pues vamos a pasar de pantalla!. ¡Vamos a por el monstruo de final de fase!

Ahora, lo que vamos a hacer, es controlar un diodo RGB (también podemos utilizar tres led de color rojo, verde y azul, pero así queda más espectacular) conectado a las patillas 13 (rojo), 12 (verde) y 11 (azul), y que conectará/desconectará cada una de sus tres luces según tecleemos en el puerto serie una 'R', una 'G' o una 'B' respectivamente. El esquema de conexionado es éste:

En el código que incluiremos más abajo, como en el anterior, estaremos pendientes de recibir un valor de tipo char en el puerto Serie, que asignaremos a nuestra variable valor. Pero ahora, además, vamos a declarar tres variables:

 //Declaro tres variables booleanas para controlar si está encendido el rojo 
//(re),el verde(ve), y el azul(ae)
boolean re;
boolean ve;
boolean ae;
int azul=11;
int verde=12;
int rojo=13;

 void setup(){
//declaro los pines como salidas
pinMode(rojo, OUTPUT);
pinMode(verde,OUTPUT);
pinMode(azul, OUTPUT);
//Inicializao el puerto serie
Serial.begin(9600);
//Apago los tres led
digitalWrite(rojo,LOW);
digitalWrite(verde,LOW);
digitalWrite(azul,LOW);
//Indico a las booleanas que los tres led están apagados
re=false;
ve=false;
ae=false;
}
void loop(){
//Leo el puerto serie
char valor=Serial.read();
//Esta sentencia considera tres casos: valor vale ‘R’, ‘G’ o ‘B’, actuando
//en consecuencia
switch (valor){
case 'R':
  if (re==true){
//El rojo estaba encendido; apago
    digitalWrite(rojo,LOW);
    re=false;
  }else{
//El rojo estaba apagado; enciendo
        digitalWrite(rojo,HIGH);
    re=true;
  }
break;
case 'G':

  if (ve==true){
//El verde estaba encendido; apago
    digitalWrite(verde,LOW);
    ve=false;
  }else{
//El verde estaba apagado; enciendo
        digitalWrite(verde,HIGH);
    ve=true;
  }
break;
case 'B':
  if (ae==true){
//El azul estaba encendido; apago
    digitalWrite(azul,LOW);
    ae=false;
  }else{
//El azul estaba apagado; enciendo
        digitalWrite(azul,HIGH);
    ae=true;
  }
  break;

}
}

 Haz la prueba y verás, como te demuestro en este video, que todo funciona como te he dicho (puede que, si no estés familiarizado con las sentencias switch/case, te cueste un poquito más entender el programa, pero si lo analizas con detenimiento, seguro que lo acabas comprendiendo).

¡Y eso es todo por hoy!. ¡Espero que nos veamos pronto!.

¡Bueno!, ¡bueno!, ¡bueno!. Como podéis ver, el puerto serie es una herramienta sencillita de utilizar, a la par que muy potente. En próximos artículos, la utilizaremos para monitorizar las señales captadas por Arduino, concretamente las mostradas por un potenciómetro conectado a un convertidor A/D. Pero eso tendrá que ser en otra ocasión. ¡Muchas gracias a todos por vuestra visita!. ¡Hasta pronto!. ¡Sed felices!. ¡Siempre creciendo!. ¡Siempre aprendiendo!. ¡Cultura maker!