Practicas y codigo ejemplo para comunicación serie y monitor serie con ARDUINO UNO (MIC043S)

Las comunicaciones serie son ampliamente usadas en electrónica. En la actualidad casi todo equipo electrónico las usa. En este artículo aprenderemos como usar la comunicación serie y ver su utilidad. también usaremos el monitor serie de la IDE de Arduino, el cual sirve para verificar y testar lo códigos ejemplos o código desarrollado por cualquier programador o usuario.

Los ejemplos presentados en este artículo, son un punto de partida para entender las comunicaciones serie. Muchos protocolos como internet, intranet, CAN, Bluetooth, etc, usancomunicaciones serie, para enviar y recibir datos. La tarjeta Arduino Uno, cuenta con un puerto serie, para comunicaciones con otros sistemas y dispositivos. Vea la Figura 1.

Figura 1 - Puerto de Comunicacion Serie de la Targeta Arduino Uno

Como se puede observar en la imagen, los pines digitales 0 y 1, son usados para el puerto serie. El pin 0 es el receptor y por eso es etiquetado conRX . El pin 1 es el transmisor y es etiquetado con TX. La Figura 2 muestra el modo de conexión serie entre una tarjeta Arduino Uno y un computador.

Figura 2 - Modo de conexion serie

Observemos que el trasmisor del Arduino, se debe conectar al receptor del computador y el receptor del Arduino, al transmisor del computador. En la actualidad los computadores portátiles, ya no traen el puerto serie, pero se usan circuitos integrados que hacen una conversión y usan el puerto USB para este propósito. El circuito integrado hace una conversión: Serie/USB/Serie. Los portátiles antiguos, si traían el puerto serie y su conexión se hacía como indicado anteriormente. Es necesario conectar los negativos de los dos circuitos, es decir del Arduino Uno y del computador, para su correcto funcionamiento.

También, en la IDE de Arduino, existe una aplicación o programa llamadaMonitor Serie, que nos permite interactuar con el puerto serie de esta tarjeta. Vea laFigura 3 .

Figura 3 - Programa Monitor Serie

En este programa podemos ver o monitorear los datos enviados o recibidos por el puerto serie de la tarjeta Arduino Uno. Esto es muy útil para desarrollar y testar los programas hechos para Arduino, aunque esta técnica es empleada, también con otros microcontroladores. Los siguientes códigos ejemplo, mostrados en este artículo, los puede encontrar en el menú:Archivos->Ejemplos->04 .Communication. Vea laFigura 4 .

Figura 4 - Menu para codigo ejemplo

La mayoría de los códigos ejemplo para comunicación serie, tiene algunos códigos comentados en la parte inferior de los programas o sketch, los cuales son códigos que corren en otras IDEs, las cuales tienen la capacidad de interactuar con el puerto serie del computador. Un ejemplo de estas IDEs, es el programa Processing, el cual es muy parecido a Arduino, pero se utiliza para desarrollar programas para el computador.

CODIGO EJEMPLO Graph.

Este programa envía datos o bytes al computador o PC. Los datos o bytes son leídos desde el puerto analógico A0 y enviados al computador por el puerto serial. La Figura 5 muestra cómo hacer un circuito con un potenciómetro o resistencia variable para demostrar el funcionamiento del programa.

Figura 5 - Circuito electrónico para testar el código ejemplo Graph

El potenciómetro puede ser cambiado por cualquier sensor que entregue una señal analógica. Se puede usar el monitor serie para ver los datos recibidos en el computador. Para activar el monitor serie, vaya el menú: Herramientas->Monitor Serie. Vea la Figura 6. Este código ejemplo está en el menú: Archivo->Ejemplos->04.Communication->Graph. El siguiente es el código ejemplo:

void setup() {

   // initialize the serial communication:
   Serial.begin(9600);
}



void loop() {
   // send the value of analog input 0:
   Serial.println(analogRead(A0));
   // wait a bit for the analog-to-digital converter to stabilize after the last reading:
   delay(2);
}

Figura 6 - Menú de acceso para el Monitor Serie

El envió de datos al computador o PC es una tarea sencilla en Arduino Uno. En la función setup() es inicializado y configurado el puerto serial con la siguiente función:

Serial.begin(9600);

Esta función recibe un parámetro para indicar la velocidad de transmisión del puerto serial. Para el caso de este programa, usamos 9600 baudios o bits por segundos. Después en la función loop(), se lee la entrada analógico en el canal 0, con la siguiente función:

analogRead(A0)

El valor retornado por la función analogRead(A0), es directamente pasado a la función:

Serial.println()

La cual se encarga de enviar o transmitir el dato leído hacia el computador. Después, es realizo un retardo con el fin de estabilizar el conversor analógico para digital de su última lectura. Esto es muy importante, porque si el circuito análogo para digital, no se ha estabilizado puede dar valores falsos. Esto lo hacemos con la función:

delay(2);

Con el Monitor Serie, abierto, podemos ver los datos. Recordemos que los conversores analógicos de Arduino Uno, son de 10 bits, por lo tanto los valores presentados en elmonitos serie, oscilaran entre 0 y 1023.Vea la Figura 7 .

Figura 7 - Datos mostrados en el Monitor Serie

CODIGO EJEMPLO Dimmer.

El siguiente programa controla el brillo de un LED, de acuerdo al valor enviado desde el computador o PC a la tarjeta Arduino Uno. Para enviar el byte que controlan el LED, utilizamos el Monitor Serie. Usamos el pin 9 de la placa Arduino, porque este puede ser utilizado para controlar el brillo de LED, debido a su capacidad de manejarPWM . Los pines que pueden ser usados para controlar PWM son: 3, 4, 6, 9, 10 y 11. La Figura 8 muestra cómo hacer el circuito para este programa. Este código ejemplo está en el menú: Archivo->Ejemplos->04.Communication->Dimmer. El siguiente es el código ejemplo:

const int ledPin = 9; // the pin that the LED is attached to



void setup() {
   // initialize the serial communication:
   Serial.begin(9600);
   // initialize the ledPin as an output:
   pinMode(ledPin, OUTPUT);
}


void loop() {
   byte brightness;
   // check if data has been sent from the computer:
   if (Serial.available()) {
      // read the most recent byte (which will be from 0 to 255):
      brightness = Serial.read();
      // set the brightness of the LED:
      analogWrite(ledPin, brightness);
   }

}

Figura 8 - Circuito electronico para testar el codigo ejemplo Dimmer

El código comienza con la función setup(), donde es configurado el puerto serial para transmitir a 9600 bit por segundos y también es configurado el pin 9 como salida con la función:

pinMode(ledPin, OUTPUT);

En el bucle principal, es decir en la función setup(), es verificado si hay datos disponibles en el puerto serial. Esto se hace con la función:

if (Serial.available())

Caso hayan datos disponible, la función retorna verdadero y ejecuta el bloque de código. Lo primero que se hace en bloque de código, es leer el puerto serial con la función:

brightness = Serial.read();

El dato recibido es almacenado en la variablebrightness . Después es usado este valor para enviarlo a la función:

analogWrite(ledPin, brightness);

La cual se encarga de controlar el pin ledPin(pin 9). El control es por PWM y por eso es posible ver el LED cambiar de brillo.

Este programa demuestra cómo podemos enviar datos desde el computador o PC, para la placa Arduino Uno. Así es posible controlar desde el computador cualquier proyecto hecho con Arduino.

CODIGO EJEMPLO VirtualColorMixer.

Este código ejemplo, muestra como enviar varios datos al computador y verlos en el Monitor Serie. El programa lo que hace es leer los pines de entrada analógicos A0, A1 y A2 y usando la instrucción Serial.print() enviarlos al computador. La Figura 9 muestra un posible circuito electrónico para testar este programa. El código ejemplo está en el menú: Archivo->Ejemplos->04.Communication->VirtualColorMixer. El siguiente es el código para este ejemplo:

const int redPin = A0; // sensor to control red color
const int greenPin = A1; // sensor to control green color
const int bluePin = A2; // sensor to control blue color

void setup() {
   Serial.begin(9600);
}

void loop() {
   Serial.print(analogRead(redPin));
   Serial.print(“,”);
   Serial.print(analogRead(greenPin));
   Serial.print(“,”);
   Serial.println(analogRead(bluePin));
}

Figura 9 - Circuito electrónico para testar el código ejemplo VirtualColorMixer

Como podemos observar, es muy fácil enviar varios datos al computador y verlos en el Monitor Serie. Por experiencia, en algunos proyectos prácticos, he enviado muchos datos de un sistema para otro a través de la puerta serial. Casi todos los sistemas electrónicos modernos, hacen uso de alguna comunicación serial para enviar datos. De ahí, la importancia de saber cómo arreglarlos o agruparlos para posteriormente poderlos transmitir.

CODIGO EJEMPLO PhysicalPixel.

Este código ejemplo demuestra cómo podemos controlar pines digitales configurados como salida, a través de bytes envidos desde el computador u otro sistema, a la placa Arduino Uno. La Figura 10 muestra el circuito electrónico para testar este programa.

Figura 10 - Circuito electrónico para testar el código ejemplo PhysicalPixel

En este ejemplo se configura un pin como salida para controlar un LED. El control lo hacemos así:

Si el byte recibido es el carácterH, entonces el LED se prende (on).

Si el byte recibido es el carácterL, entonces el LED se apaga (off).

La Figura 11 muestra cómo se puede hacer el envió de bytes por elmonitor serie .

Figura 11 - Enviando el caracter 'H' por el Monitor Serie

El código ejemplo está en el menú:Archivo->Ejemplos->04.Communication-> PhysicalPixel . El siguiente es el código para este ejemplo:

const int ledPin = 13; // the pin that the LED is attached to
int incomingByte; // a variable to read incoming serial data into


void setup() {
   // initialize serial communication:
   Serial.begin(9600);
   // initialize the LED pin as an output:
   pinMode(ledPin, OUTPUT);
}

void loop() {
   // see if there’s incoming serial data:
   if (Serial.available() > 0) {
      // read the oldest byte in the serial buffer:
      incomingByte = Serial.read();
       // if it’s a capital H (ASCII 72), turn on the LED:
      if (incomingByte == ‘H’) {
         digitalWrite(ledPin, HIGH);
      }
      // if it’s an L (ASCII 76) turn off the LED:
      if (incomingByte == ‘L’) {
         digitalWrite(ledPin, LOW);
      }
   }

}

Este método es usado en casi todos las comunicaciones donde es necesario hacer algún tipo de control. El programador puede escoger los caracteres ASCII de acuerdo a su criterio. Aunque existen algunos protocolos ya definidos para esta clase de aplicaciones, pero en general se basan en el mismo principio. Un uso muy actual de este tipo de control, es el que usa módulos de comunicación por Bluetooth.

CODIGO EJEMPLO ReadASCIIString.

Este programa ejemplo, lee una cadena de texto o string y la convierte a números enteros. Estos números son usados para controlar el brillo de 3 LEDs, conectados a los pines 3, 5 y 6 de la tarjeta Arduino Uno. La Figura 12 muestra el circuito electrónico para testar este programa.

Figura 12 - Circuito electronico para testar el codigo ejemplo ReadASCIIString

La Figura 13 muestra como digitar el string o cadena de texto para enviar a la tarjeta Arduino Uno.

Figura 13 - Enviando un string para testar el codigo ejemplo ReadASCIIString

El código ejemplo está en el menú:Archivo->Ejemplos->04.Communication->ReadASCIIString . El siguiente es el código para este ejemplo:

const int redPin = 3;
const int greenPin = 5;
const int bluePin = 6;

void setup() {
   // initialize serial:
   Serial.begin(9600);
   // make the pins outputs:
   pinMode(redPin, OUTPUT);
   pinMode(greenPin, OUTPUT);
   pinMode(bluePin, OUTPUT);
}

void loop() {
   // if there's any serial available, read it:
   while (Serial.available() > 0) {
      // look for the next valid integer in the incoming serial stream:
      int red = Serial.parseInt();
      // do it again:
      int green = Serial.parseInt();
      // do it again:
      int blue = Serial.parseInt();
      // look for the newline. That's the end of your sentence:
      if (Serial.read() == '\n') {
         // constrain the values to 0 - 255 and invert
         // if you're using a common-cathode LED, just use "constrain(color, 0, 255);"
         red = 255 - constrain(red, 0, 255);
         green = 255 - constrain(green, 0, 255);
         blue = 255 - constrain(blue, 0, 255);

         // fade the red, green, and blue legs of the LED:
         analogWrite(redPin, red);
         analogWrite(greenPin, green);
         analogWrite(bluePin, blue);

         // print the three numbers in one string as hexadecimal:
         Serial.print(red, HEX);
         Serial.print(green, HEX);
         Serial.println(blue, HEX);
      }
   }

}

El programa comienza definiendo los pines 3, 5 y 6 como redPin, greenPin y bluePin, respectivamente. Esto lo hace con las siguientes líneas de código:

const int redPin = 3;

const int greenPin = 5;

const int bluePin = 6;

Después, en la función setup(), es inicializada la comunicación serial a 9600 bits por segundos y los pines redPin, greenPin y bluePin son configurados como salida. En la función loop(), se verifica si se recibió algún byte en el puerto serie. Esto se hace con la instrucción:

while (Serial.available() > 0)

Si así fue, entonces se lee la cadena de texto, hasta que se encuentre algún carácter diferente de un valor numérico. Como la cadena enviada está separada por el carácter coma (,), entonces la función:

Serial.parseInt();

Se encarga de retirar el próximo número entero que encuentre en el puerto serial. Cualquier carácter que no represente un número entero será saltado (skipped). El valor leído es asignado a la variable red. Esta operación se repite para las variables enteras green y blue. Las líneas de código que hacen esto son:

int red = Serial.parseInt();

int green = Serial.parseInt();

int blue = Serial.parseInt();

Después, se verifica si llego el carácter ASCII de nueva línea, para lo cual usamos la siguiente instrucción:

if (Serial.read() == '\n')

Si llego el carácter de nueva línea, entonces limitamos los valores enteros recibidos para que estén en un rango de 0 hasta 255, para lo cual usamos la siguiente línea de código:

constrain(red, 0, 255);

Esta función, lo que hace es recibir en su primer parámetro un numero entero y si el valor está dentro del rango de los dos siguientes parámetros, entonces retorna el mismo valor, pero si el número, es menor que el segundo parámetro, entonces retorna el valor del segundo parámetro. Si el número entero es mayor que el tercer parámetro, entonces retorna el valor del tercer parámetro. En otras palabras esta función limita un número para un cierto rango.

En caso de que este usando LEDs de ánodo común, es necesario invertir el numero entero para que corresponda al valor recibido por el puerto serie. Para esto podemos usar la siguiente función:

red = 255 - constrain(red, 0, 255);

Se debe hacer lo mismo para los números enterosgreen y blue . Finalmente, se controla el brillo de los LEDs con las instrucciones:

analogWrite(redPin, red);

analogWrite(greenPin, green);

analogWrite(bluePin, blue);

Y se imprime en elMonitor Serie, los números enteros en forma hexadecimal. Para esto se usan las instrucciones:

Serial.print(red, HEX);

Serial.print(green, HEX);

Serial.println(blue, HEX);

CODIGO EJEMPLO ASCIITable.

Este programa o sketch imprime o visualiza en el monitor serie, la tabla de caracteres ASCII. La Figura 14, muestra el resultado de este programa.

Figura 14 - Envio de caracteres ASCII al Monitor Serie

Junto al carácter ASCII, también es enviado su valor equivalente en decimal, hexadecimal, octal y binario. El análisis de cómo trabaja este programa es muy sencillo, pues las funciones son muy intuitivas. El código ejemplo está en el menú: Archivo->Ejemplos->04.Communication->ASCIITable . El siguiente es el código para este ejemplo:

void setup() {
   //Initialize serial and wait for port to open:
   Serial.begin(9600);

   while (!Serial) {
      ; // wait for serial port to connect. Needed for native USB port only
   }

   // prints title with ending line break
   Serial.println("ASCII Table ~ Character Map");

}



// first visible ASCIIcharacter '!' is number 33:

int thisByte = 33;

// you can also write ASCII characters in single quotes.

// for example, '!' is the same as 33, so you could also use this:

// int thisByte = '!';


void loop() {
   // prints value unaltered, i.e. the raw binary version of the byte.
   // The Serial Monitor interprets all bytes as ASCII, so 33, the first number,
   // will show up as '!'
   Serial.write(thisByte);

   Serial.print(", dec: ");
   // prints value as string as an ASCII-encoded decimal (base 10).
   // Decimal is the default format for Serial.print() and Serial.println(),
   // so no modifier is needed:

   Serial.print(thisByte);
   // But you can declare the modifier for decimal if you want to.
   // this also works if you uncomment it:
   // Serial.print(thisByte, DEC);

   Serial.print(", hex: ");
   // prints value as string in hexadecimal (base 16):
   Serial.print(thisByte, HEX);

   Serial.print(", oct: ");
   // prints value as string in octal (base 8);
   Serial.print(thisByte, OCT);

   Serial.print(", bin: ");
   // prints value as string in binary (base 2) also prints ending line break:
   Serial.println(thisByte, BIN);


   // if printed last visible character '~' or 126, stop:
   if (thisByte == 126) { // you could also use if (thisByte == '~') {
      // This loop loops forever and does nothing
      while (true) {
       continue;
      }
  }

// go on to the next character
thisByte++;

}

CONCLUSIÓN.

Podemos ver que el manejo de la comunicación serial es muy simple. La principal función usada es Serial.println(). Esta función tiene algunas variantes, mas todas hacen prácticamente lo mismo, enviar datos a través del puerto serie. La utilidad es muy grande y solo la imaginación puede determinar cómo usarla. Más una de sus principales aplicaciones es para ver resultados de datos y hacer depuraciones de código en los programas o sketchs.