miércoles, 11 de enero de 2012

Comunicación Serial con Arduino

Abstract

(go to English Version)

Una de las principales ventajas de un micro es la posibilidad que tenemos de comunicarnos con el mismo vía puerto serial.

En este artículo y próximos tendremos un acercamiento a lo que podemos hacer, y algunas de las herramientas que he encontrado interesantes para interactuar con un microcontrolador, involucrando internet...

A menos que un micro se programe con una implementación standalone, es decir, que se su funcionamiento se circunscriba a acciones que no dependan de la interacción externa (más allá de sus entradas digitales o analógicas), no será necesario ejecutar los mecanismos que en este artículo se describen. Es cierto que muchas de las aplicaciones de los microcontroladores no requieren asomarse a su entorno, pero cada vez es más común pensar en la comunicación como herramienta de interacción con las aplicaciones que diseñamos para estos ambientes. Para muestra, veamos el siguiente ejemplo.
...
Comunicación con microControladores tipo Arduino

Si poseemos una casa con ventanas panorámicas (de estas que se abren deslizándolas horizontalmente), tal que una persona puede entrar sin inconvenientes a través del espacio disponible una vez abiertas, y nos gusta salir a menudo de vacaciones, tendremos un problema de seguridad. La probabilidad que irrumpan en nuestro hogar en esos momentos en que la casa está sola será muy alta.

Para alguien que quiera diseñar su sistema de seguridad, en primera instancia seguramente pensará en colocar sensores de movimiento o apertura para activar una alarma muy ruidosa al momento que haya una intrusión en la residencia. Esto puede ser una solución, pero la alarma alertará solo al entorno inmediato a la casa, y a los intrusos.

Ahora bien, también podemos pensar en un sistema de seguridad silencioso al entorno inmediato a la residencia, pero que a través de un sistema de comunicación al exterior vía internet, envíe un mensaje de texto con la alerta a algún medio de recepción, sea email, chat client (messenger) o a twitter!.

Otro ejemplo de comunicación remota es, por ejemplo, la posibilidad de crear un sistema de control de luces y electrodomésticos en nuestro hogar. El mismo puede ser automatizado desde el micro definiendo un horario de ejecución de eventos para encender o apagar luces, mover una celda solar orientándola al sol de forma eficiente, motorizar una ventana para la entrada de luz de acuerdo a la luminosidad del entorno o simplemente encender el aire acondicionado de nuestra habitación cercano a la hora de nuestra llegada.

Con este último ejemplo, que tal si llegamos más temprano a casa?. Pudiéramos comunicarnos con nuestro micro utilizando nuestro celular inteligente a través de messenger enviando un mensaje como el siguiente:

AC: encender

De esta forma y a través del software adecuado, este mensaje puede ser recibido y ejecutado, en línea.

Como estos ejemplos, existen muchos más que solo la imaginación y la necesidad particular pueden producir.

Para realizar tareas como estas, debemos empezar de lo sencillo a lo complejo. Lo primero que debemos saber es que con los microcontroladores como el arduino, pinguino, teensy, etc. podemos comunicarnos a un servidor vía puerto serial.

Con arduino o teensy la comunicación serial se establece a través de la interfaz USB de la cual disponemos para conectar el micro al computador. Al inicializar el puerto serial desde el micro, en ambientes linux/unix se mapeará un directorio en /dev/ttyXXXn que permitirá enviar o recibir información.

El siguiente código define la salida secuencial de un mensaje al puerto serie de nuestro computador.

int i=0;
void setup()
{
  Serial.begin(9600);
}
void loop()
{
  Serial.print("mensaje de prueba: ");
  Serial.println(++i);
  delay(1000);
}

En el bloque setup() inicializamos el puerto serial a 9600 baudios con Serial.begin(9600). En el bloque loop() enviamos vía serial el mensaje seguido de un consecutivo el cual actualizamos secuencialmente con ++i.

Desde el computador podremos observar esta salida si interrogamos adecuadamente al puerto mapeado en /dev/ttyACMn. Donde n>=0.

Para este ejemplo el puerto fue mapeado contra /dev/ttyACM0. En mi caso utilizo ubuntu, pero para cualquier linux/MAC debe ser muy similar.

Cuando el micro es conectado a cualquier puerto USB de nuestro computador el mismo puede ser accedido vía línea de comando desde un terminal o a través de algún programa hecho para este fin. Una tercera opción es crear nuestro propio programa de lectura y/o escritura al puerto serial. Esta última opción es la adecuada si quisiéramos interactuar con el puerto para obtener información del puerto o instruir al micro a ejecutar alguna acción.

Para nuestro sencillo ejemplo podemos interrogar inicialmente al puerto utilizando el terminal serial que viene como herramienta del IDE de Arduino o a través de gtkterminal o minicom.

VIDEO: Comunicación Serial 1

Desde el micro podemos también leer desde el puerto serial y así poder tomar decisiones de que ejecutar de acuerdo a la entrada.

El siguiente programa permite simplemente leer la entrada serial y devolver la cadena de caracteres obtenida, detectando el fin de línea.

char caracter;
byte i=0;
char cadena[100];
void setup()
{
  Serial.begin(9600);
}
void loop()
{
  if (Serial.available())
  {
    caracter=Serial.read();
    if (caracter == 10)
    {
      cadena[i++]='\0';
      i=0;
      Serial.println(cadena);
    }
    else
      cadena[i++]=caracter;
  }
}

En el bloque setup() inicializamos el puerto, seguidamente en el bloque loop() chequeamos el buffer del puerto con Serial.available().

Si hay caracteres disponibles los leemos secuencialmente con Serial.read(). Si detectamos el fin de línea agregamos a la cadena de caracteres el caracter de fin de cadena y reseteamos el contador, enviando de vuelta la cadena de caracteres al puerto.

En caso que no sea un fin de linea (10) entonces vamos anexando a la cadena cada catacter recibido actualizando el indice i.

VIDEO: Comunicación Serial 2

Ahora veamos como utilizar este último programa para adecuarlo para accionar el encendido o el apagado el aire acondicionado del segundo ejemplo mostrado en este artículo.

#include string.h
#define ENCENDER 1
#define APAGAR 0
char caracter;
byte i=0;
char cadena[100];

void AC_Action(int accion)
{
  

    if (accion == ENCENDER)  
    {
        Serial.println("Encendiendo el Aire Acondicionado Principal... ");
        //Accion de encender
        //esperar resultado
        delay(500);
        Serial.println("Aire Acondicionado Encendido... Status OK");
    }   
    if (accion == APAGAR)  
    {    
        Serial.println("Apagando el Aire Acondicionado Principal... ");
        //Accion de apagado
        //esperar resultado
        delay(500);
        Serial.println("Aire Acondicionado Apagado... Status OK");
    
}
void setup()
{

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

    if (Serial.available())  
    {    
        caracter=Serial.read();
        if (caracter == 10)
        {
              cadena[i++]='\0';
              i=0;
              if (!strcmp(cadena,"AC: Encender"))
                AC_Action(ENCENDER);
              if (!strcmp(cadena,"AC: Apagar"))
                AC_Action(APAGAR); 
        
        else
          cadena[i++]=caracter; 
      }
}

Hemos creado una procedimiento que dependiendo del parámetro acción encenderá o apagará el aire acondicionado, asumiendo que tenemos un dispositivo conectado al micro capaz de hacerlo. En nuestro caso el micro devolverá vía serial el mensaje de encendido y apagado correspondiente.

El bloque loop() mantiene el mismo esquema, solo que cuando se hace match con una cadena específica se ejecuta la función AC_Action() pasándole el parámetro ENCENDER o APAGAR definidos al principio del programa.

VIDEO: Comunicación Serial 3

El próximo paso va a ser comunicarnos desde el exterior del PC a través de diferentes medios para poder interactuar con el micro.

En próximos artículos seguiremos explorando posibilidades de comunicación, interacción y ejecución.
Read More......

domingo, 19 de junio de 2011

Entrada Analógica (Analog Input)

Hoy nos dedicaremos a interactuar con una entrada analógica, la cual a diferencia de una entrada digital (entrega anterior) permite leer un rango de valores. Estos valores representan voltaje, pero dentro del microcontrolador pueden ser representados por un rango de valores enteros, los cuales pueden ir de 0 a 255 o de 0 a 1024, etc., esto depende del tipo de procesador que estemos utilizando... por eso es muy útil obtener las especificaciones del micro y las funciones asociadas (en el lenguaje que escogiéramos) a la lectura de un puerto analógico.

La idea de un puerto analógico es leer de un puerto diferentes valores, lo cual permite tomar decisiones más amplias o interactuar con rangos que permiten realizar tareas diferentes.

En lo personal, cuando pienso en una entrada digital pienso en un switch on/off, y cuando pienso en una entrada analógica pienso en un potenciómetro, o cualquier dispositivo cuya salida oscile entre 0V y 5V.

Estos dispositivos (ejemplo un lm35 - termómetro digital) alimentándolos con 5V, pueden entregar al puerto en donde se conecten un rango de valores de acuerdo a las características con las cuales el dispositivo está diseñado.

Por ejemplo, un potenciómetro permite entregar al micro un rango de voltaje que depende del voltaje con el cual esté alimentado. Un termómetro digital, entregará un voltaje de acuerdo a la alimentación del mismo y a las condiciones de temperatura a la cual esté expuesto. En cualquier caso, siempre se obtiene un voltaje asociado a la lectura del dispositivo, y a través de este voltaje podemos tomar decisiones y ejecutar tareas.

El siguiente circuito conecta 8 leds a la plataforma de prototipado pinguino en los pines 0-7, que son puertos digitales. Un potenciómetro es conectado a los puertos GND,VCC del micro y su salida la enviamos al puerto 13, el cual es analógico.


El código que utilizaremos permite utilizar los 8 leds como una barra de indicación. Cuando el potenciómetro está en el tope izquierdo, este entrega al puerto 13 cero voltios. Cuando el potenciómetro está en el tope derecho le entrega al puerto 5V.

El micro traduce este voltaje en un número entero que oscilará entre 0 y 1024, dependiendo del voltaje, el cual estará en un rango de oV a 5V.

Nuestra intención es que a medida que vamos rotando el potenciómetro a la derecha (0->5)V la barra de 8 leds debe ir iluminándose a la derecha hasta llegar a encender los 8 leds, justamente cuando el potenciómetro esté en el tope derecho. En la rotación contraria (5->0)V, los leds deben irse apagando uno a uno de derecha a izquierda hasta quedar todos apagados.

A continuación el codigo

// Ejemplo de utilización de lectura de potenciometro y encendido de leds
#include "ADlib/__map.c"

const int potPin=13;

void setup()
{
byte i;
for (i=0; i < 8; i++)
pinMode(i,OUTPUT);
pinMode(potPin,INPUT);
}

void apagarLeds()
{
byte i;
for (i=0; i<8; i++)
digitalWrite(i,LOW);
}

void encenderLeds(int count)
{
byte i;
for (i=0; i<count; i++)
digitalWrite(i,HIGH);
}

void loop()
{
apagarLeds();
encenderLeds(map(analogRead(potPin),0,1024,0,8));
delay(50);
}

Veamos como funciona esto. En primer lugar tenemos la declaración de una constante (potPin) que nos indica cual es el puerto que utilizaremos para leer el voltaje que nos entrega el potenciómetro.

Luego tenemos la función setup() para definir la modalidad de los puertos. Los puertos de entrada(0,7) los definimos como salidas en el ciclo for. Asimismo, el puerto 13 lo definimos como entrada con la función pinMode.

Hemos creado 2 funciones. apagarLeds() nos permite apagar todos los leds al tiempo utilizando un ciclo for con el siguiente rango (0<=i<8). Luego definimos una función que nos permite encender hasta el led definido por el parámetro count.

En el ciclo Loop(), vemos como apagamos los leds para luego encender hasta el led que nos devuelve la función map.

La función map es una función que nos permite convertir un rangoA en un rangoB. Esta función es estándar en arduino, pero no en pinguino, por lo que está programada y agregada al directorio de librerías de pinguino, y es por esta razón que la segunda línea existe.

#include "ADlib/__map.c"

En nuestro caso, la función mapea el rango (0,1024) al rango (0,8) utilizando como entrada lo que devuelve analogRead(potPin). Esta conversión es muy conveniente ya que directamente le pasamos un valor entre 0 y 8 a la función encenderLeds(). Este ciclo se repite infinitamente cada 50 milisegundos debido la función delay(50) que hemos colocado al final del loop.

// map function
// Alejandro-Dirgan 2011

#ifndef __MAP__
#define __MAP__

#define MAP 1

float map(int value, int fLow, int fHigh, int tLow, int tHigh)
{
return ((float )tHigh*(float )(value-fLow)+(float )tLow*(fHigh-value))/(float )(fHigh-fLow);
}

#endif

Veamos como funciona en la práctica.


Con las entradas analógicas se pueden hacer infinidad de cosas, solo la imaginación y los requerimientos lo dirán.

En la próxima entrega veremos las salidas analógicas.


Read More......

jueves, 16 de junio de 2011

Entrada Digital (Digital Input)

En el artículo anterior vimos como utilizar las salidas del microcontrolador para encender y apagar leds, utilizando valores lógicos altos y bajos (0,5V):(LOW;HIGH) con la función digitalWrite(). En este artículo utilizaremos los puertos para obtener información del entorno.

Generalmente cuando pensamos en una entrada digital, inmediatamente evocamos un switch ON/OFF. Cuando el swith está en off, no hay paso de energía y nuestro puerto, al cual está conectado el switch, se encontrará en un nivel bajo (LOW, 0v). Por el contrario, si el switch está en ON, el mismo permitirá el paso de energía y el puerto destino obtendrá un valor alto (HIGH, 5v). Esta lógica esta perfecta, pero veamos como podemos implementarla adecuadamente y veremos las variantes correspondientes.

Lo primero que debemos entender es como mantenemos un valor estable en un puerto de entrada. Como estamos hablando de una entrada digital, nuestra intención es determinar cuando la misma tiene un valor alto o bajo, y luego tomar una decisión al respecto, para por ejemplo encender un led, iniciar una secuencia de comandos, para activar un parámetro, etc.

En general, si no definimos una voltaje en una entrada digital esta podrá tener un valor flotante, lo cual debemos evitar. Requerimos tener un valor alto o un valor bajo, y esto se logra a través de las resistencias pull-up o pull-down.


En la figura de la derecha vemos como el terminal 1 del circuito lógico puede ser alimentado con un valor bajo (LOW, 0V) en el momento que el switch S1 es presionado.

Esto efectivamente sucede cuando el switch S1 se presiona, ya que hay un camino directo desde tierra a este terminal. Pero que pasa cuando S1 esta abierto?. El problema es que no podemos garantizar que valor lee el terminal 1 cuando esta condición prevalece.

En toda entrada lógica digital siempre debemos garantizar los dos valores a leer (alto y bajo), de forma que no haya ambigüedad.

Para ello existen dos modalidades, utilizando conceptos básicos de circuitos digitales: las resistencias pull-up y pull-down.

Veamos la siguiente figura:


En el circuito de la izquierda podemos observar que el terminal 1 esta conectado a través de una resistencia pull-up a Vcc (HIGH, 5V), cuando S1 está abierto. En este estado estamos garantizando un valor Alto cuando S1 no está presionado. Cuando S1 se presiona, el terminal 1 quedará conectado directamente a tierra, obteniendo un valor bajo (LOW, 0V). El valor de la resistencia puede conseguirse persiguiendo un valor bajo de corriente a circular entre VCC y Masa, utilizando V=I*R. La idea es dejar pasar menos de 1 mA para no dañar ni el circuito ni el cableado (en general el valor de esta resistencia está entre 10K y 47K).

En el circuito de la derecha estamos implementando una resistencia pull-Down a Tierra (LOW, 0V), garantizando 0V cuando S1 está abierto y 5V cuando S1 esta cerrado. De esta forma estamos garantizando en cualquier caso un valor predicho que podemos leer desde nuestro microcontrolador.

Como podemos observar, dependiendo que variante hayamos escogido, S1 puede representar un valor alto o bajo cuando está presionado, y viceversa. Depende de nuestra lógica y de como deseemos programar nuestro la escogencia de alguna de las modalidades descritas anteriormente.

OK. ya sabemos entonces como colocar un valor predecible en una entrada, ahora veamos como leerla y utilizarla para nuestros fines.

La figura muestra la conexión hecha para que el sketch que mostramos funcione adecuadamente.


El siguiente programa muestra

const int potPin=14, ledPin=12;

void setup()
{
pinMode(potPin,INPUT);
pinMode(ledPin,OUTPUT);
}

void loop()
{
if (analogRead(potPin))
digitalWrite(ledPin,LOW);
else
digitalWrite(ledPin,HIGH);

delay(50);
}

Objetivo:

Demostrar como leer una entrada digital y tomar una decisión de acuerdo a lo leído, para la ejecución de una acción.

Descripción:

(1) const int potPin=14, ledPin=12;

Definen constantes asociadas a el pin de entrada (14) y el pin de salida (12).

(2) Procedimiento setup()
{
pinMode(potPin,INPUT);
pinMode(ledPin,OUTPUT);
}

Definimos los pines como de entrada y salida en el procedimiento de setup.

(3) procedimiento loop()
{
if (analogRead(potPin))
digitalWrite(ledPin,LOW);
else
digitalWrite(ledPin,HIGH);

delay(50);
}

En el loop del programa, vemos una estructura de toma de decisiones.

if (analogRead(potPin))

analogRead es una función que permite obtener una lectura del pin potPin (14). En la estructura if lo único que requerimos es saber si esta lectura es mayor que cero (0), para apagar el led, o si la lectura es cero (0) (cuando se evalúa el else), para en encender el led.

Esta lógica aplica porque el circuito que montamos está basado en una resistencia pull-up.

Este ciclo se repite cada 50 milisegundos. Si el switch está abierto el if (analogRead(potPin)) nos retornará true, y apagaremos el led con digitalWrite(ledPin,LOW).

Por el contrario, si el switch está cerrado el potPin estará conectado directamente a tierra y se leerá un valor bajo (oV), lo que hace que en el ciclo del programa la instrucción asociada al else se ejecute: digitalWrite(ledPin,HIGH).

Es muy sencilla su programación. Luego compilamos el programa buscando que todo esté OK y reprogramamos el microcontrolador (en mi caso el pinguino) y dejamos que ejecute el programa.

En el video se puede observar que he agregado un display lcd 16x2 para mostrar si el valor de potPin es alto o bajo y para indicar que estamos ejecutando de acuerdo a estos valores.


Read More......

lunes, 6 de junio de 2011

Playing with LEDS

En la entrega anterior vimos como utilizar las salidas digitales. En este artículo solo quiero mostrar que lo que se puede hacer con las salidas digitales es directamente proporcional a lo que podemos hacer programando.

La inteligencia de estos dispositivos electrónicos es solo cuestión de imaginación y capacidad de programación.

En esta entrega quiero mostrarles como hacer un divertimento de iluminación de leds.

EL ESQUEMA

7 LEDs conectados a las salidas 0-6 del pinguino 2550.



EL CODIGO

Un simple programa que permite iluminar 7 leds. El código está definido con 6 procedimientos:

- ledOff(): Pone las salidas 0-6 en LOW
- secuencia1(): hace una secuencia del pin 0 al 6 con 10 ms de retardo
- secuencia2(): hace una secuencia del pin 6 al 0 con 10 ms de retardo
- secuencia3(): enciende los leds impares y hace flash en los pares
- secuencia4(): enciende los leds pares y hace flash en los impares
- secuencia5(): hace flash alternativo entre los leds pares e impares

//Playing with leds
byte const pines[]={0,1,2,3,4,5,6};
byte pausa1, pausa2;

void ledOff()
{
byte i;
for (i=1;i<7;i++)
digitalWrite(pines[i-1],LOW);

}

void setup()
{
byte i;
for (i=0;i<7;i++)
pinMode(pines[i],OUTPUT);
pausa1=10;
pausa2=50;
ledOff();
}

void secuencia1()
{
byte i;
ledOff();
for (i=1;i<7;i++)
{
digitalWrite(pines[i-1],HIGH);
delay(pausa1);
digitalWrite(pines[i-1],LOW);
delay(pausa1);
}
}

void secuencia2()
{
byte i;
ledOff();
for (i=7;i>=1;i--)
{
digitalWrite(pines[i-1],HIGH);
delay(pausa1);
digitalWrite(pines[i-1],LOW);
delay(pausa1);
}
}

void secuencia5()
{
byte i;
ledOff();
for (i=0;i<7;i++)
{
digitalWrite(pines[0],HIGH);
digitalWrite(pines[2],HIGH);
digitalWrite(pines[4],HIGH);
digitalWrite(pines[6],HIGH);
delay(pausa2);
digitalWrite(pines[0],LOW);
digitalWrite(pines[2],LOW);
digitalWrite(pines[4],LOW);
digitalWrite(pines[6],LOW);
delay(pausa2);
digitalWrite(pines[1],HIGH);
digitalWrite(pines[3],HIGH);
digitalWrite(pines[5],HIGH);
delay(pausa2);
digitalWrite(pines[1],LOW);
digitalWrite(pines[3],LOW);
digitalWrite(pines[5],LOW);
delay(pausa2);
}
}

void secuencia3()
{
byte i;
ledOff();
digitalWrite(pines[0],HIGH);
digitalWrite(pines[2],HIGH);
digitalWrite(pines[4],HIGH);
digitalWrite(pines[6],HIGH);
for (i=0;i<7;i++)
{
digitalWrite(pines[1],HIGH);
digitalWrite(pines[3],HIGH);
digitalWrite(pines[5],HIGH);
delay(pausa2);
digitalWrite(pines[1],LOW);
digitalWrite(pines[3],LOW);
digitalWrite(pines[5],LOW);
delay(pausa2);
}
digitalWrite(pines[0],LOW);
digitalWrite(pines[2],LOW);
digitalWrite(pines[4],LOW);
digitalWrite(pines[6],LOW);
}

void secuencia4()
{
byte i;
ledOff();
digitalWrite(pines[1],HIGH);
digitalWrite(pines[3],HIGH);
digitalWrite(pines[5],HIGH);
for (i=0;i<7;i++)
{
digitalWrite(pines[0],HIGH);
digitalWrite(pines[2],HIGH);
digitalWrite(pines[4],HIGH);
digitalWrite(pines[6],HIGH);
delay(pausa2);
digitalWrite(pines[0],LOW);
digitalWrite(pines[2],LOW);
digitalWrite(pines[4],LOW);
digitalWrite(pines[6],LOW);
delay(pausa2);
}
digitalWrite(pines[1],LOW);
digitalWrite(pines[3],LOW);
digitalWrite(pines[5],LOW);
}

void loop()
{
byte j;
for (j=0;j<7;j++)
secuencia1();
for (j=0;j<7;j++)
secuencia2();
secuencia3();
secuencia4();
secuencia5();
}

EL RESULTADO

El siguiente video muestra el resultado de cargar este programa en el pinguino y ejecutarlo conectado al breadboard con los 7 leds.



Read More......

domingo, 22 de mayo de 2011

Salida Digital - Encender y apagar un led

El Hola Mundo que les propongo es utilizar un puerto de salida digital para encender y apagar un led con una secuencia definida.

Empezaremos por alistarnos para ejecutar un demo de utilización de la salida digital de un microcontrolador. A continuación lo que requerimos para hacer nuestro hola mundo.

1) El ambiente de desarrollo instalado en nuestro computador del microcontrolador que hallamos escogido.

2) El microcontrolador que hallamos comprado o construido por nosotros mismo (DIY)

3) Un led de cualquier color

4) Un protoboard (opcional)

Utilizar una salida digital de nuestro micro requiere que sepamos cuales son puertos de e/s digitales y analógicos. Para ello lo primero que debemos hacer es obtener el mapa de entrada y salida de nuestro hardware. Este lo podemos obtener desde la páqina web del fabricante del mismo.

Para nuestro hola mundo he escogido utilizar una plataforma de prototipado rápido basado en el PIC18f2550 (pinguino). El mismo lo construí hace un tiempo y lo he utilizado por algunos meses con todo éxito.

El mapa de E/S de este microcontrolador lo podemos ver en la figura. Los puertos 0-10 son puertos que permiten tanto la entrada digital como la salida digital.

Los puertos 11-12 permiten entrada digital pero su salida es analógica. Los puertos 13-17 permiten entradas analógicas y salidas digitales.

asimismo vemos dos puertos que nos ofrecen tierra y VCC 5V, lo cuales podemos utilizar para darle energía a nuestro led.

Teniendo claro el mapa de puertos y que hace cada uno, es mas fácil ejecutar la siguiente tarea: Armar el circuito básico.

El protoboard es opcional ya que si ven el mapa, pudiéramos colocar el led directamente entre tierra (gnd) y el puerto 9. El puerto nueve permite salida digital (0-5V/0-1), por lo que si queremos encenderlo colocamos el puerto nueve en high (1 o 5V). Si queremos el led apagado colocamos el puerto 9 en low (0 o 0V).

El led debe soportar la corriente que el micro le estregará. Si no es el caso, habría que colocar un limitador de corriente, el cual sería una resistencia. Para este ejemplo no la requeriremos ya que el led que utilizamos puede manejar la corriente que el micro le entrega.

El diagrama muestra la conexión si utilizáramos un protoboard. En este caso el ánodo del led (el terminal posivo) lo conectamos al puerto 9 y el cátodo, o terminal negativo, lo conectamos a tierra (GND).

LED, 5mm, green (int).svg

Una vez conectado estamos listos para programar al microcontrolador. Para hacer un programa que prenda y apague un led de forma periódica solo requiere de unas pocas líneas de programación, pero requerimos entender un poco la arquitectura de un programa en el lenguaje que usa Arduino y sus parientes.

Anatomía de un Sketch

Un programa o sketch de Arduino tiene tres partes fundamentales:

1) Sección de encabezados

Esta sección se utiliza para inicializar variables, definir constantes o invocar librerías.

2) Sección de Setup

Esta sección, la cual se ejecuta una sola vez, permite ejecutar aciones o asignarle valores a variables que se requieren para su utilización en la ejecución del programa.

3) Sección de Ejecución Continua

En esta sección, la cual se ejecuta continuamente, se colocan las líneas de programa que son requeridas para definir el comportamiento del proyecto.

Veamos como encender intermitentemente un led en un skecth de Arduino.

#define ledPort 9

void setup(void)
{
pinMode(ledPort,OUTPUT); // pin 9 como salida
}

void loop(void)
{
digitalWrite(ledPort,HIGH);
delay(500);
digitalWrite(ledPort,LOW);
delay(500);
}

El skecth que acabamos de listar muestra las tres partes fundamentales de cualquier sketch de arduino.

En el encabezado definimos una variable la cual indicará el puerto en donde conectaremos el ánodo del led. En nuestro caso ledPort mantendrá el valor 9, indicando el puerto número 9 el cual permite una salida digital.

En la sección Setup, la cual es una procedimiento llamado setup(), definimos la caraterística de nuestro puerto. Cada puerto debe definirse como una entrada o una salida.

Como nuestra intención es usar el puerto para encender o apagar un led, el puerto debe configurarse como una salida.

La instrucción pinMode(ledPort,OUTPUT) permite definir a través de una constante (OUTPUT) que el puerto 9 será utilizado como puerto de salida.

Finalmente definimos la sección loop, la cual es otro procedimiento, pero este se ejecuta continuamente (mientras el microprocesador esté energizado). En esta sección típicamente colocamos instrucciones que se ejecutarán de forma cíclica y que definirán el comportamiento.

En nuestro ejemplo, utilizamos el comando digitalWrite indicando en que puerto debemos escribir la constante HIGH. Esta constante escribe en el puerto un valor alto (1) para colocarlo en 5V, lo cual será la salida.

Luego utilizamos el comando delay(500), cuyo argumento indica los milisegundos que el programa o sketch suspende su ejecución, para luego reanudar con la ejecución del comando que apaga el led.

digitalWrite(ledPort, LOW) escribe en el puerto un valor bajo (0) para colocar el puerto en 0V, lo cual apagará el led. Luego de este comando se ejecuta de nuevo delay(500) para suspender la ejecución del sketch por 500ms.

Esto ejecutado continuamente tiene como efecto la intermitencia del led cada 500ms o medio segundo.

Una vez escrito el programa en el ambiente de desarrollo se debe compilar para convertir el programa de alto nivel en un formato que pueda exportarse al microcontrolador para su ejecución.

Lo primero que debemos hacer es presionar el botón circunscrito en el recuadro rojo. La compilación puede tener dos resultados.

Mostrar errores o mostrar el mensaje que vemos en la parte inferior del ambiente de desarrollo, el cual muestra los mensajes que el compilador emite.

En nuestro caso, el mensaje obtenido es:

Compilation Done...

y luego muestra la cantidad de bytes que el programa ocuparía en memoria y el total de la memoria (en bytes) que el procesador tiene disponible para sketchs.

Adicionalmente indica en porcentaje la memoria utilizada.

Una vez compilado el programa se encuentra listo para ser exportado al dispositivo.

Conectamos el dispositivo a través de su puerto USB a nuestro computador. El procedimiento estándar de grabar el sketch en el micro es presionando el botón de reset del micro y pulsar el botón de escribir (ver figura) un par de segundos luego de haber presionado el botón de reset.

Lo que sucede en este pequeño intervalo de tiempo, es que el micro se presenta a través del puerto USB y el ambiente de desarrollo puede contactar el dispositivo y pasarle el archivo .hex, gracias al bootloader que tiene implementado el microcontrolador.

Luego de pasar el programa al micro también veremos un mensaje en el área de mensajes del IDE. En nuestro ejemplo podemos ver:

Processing device 005
erasing section [2000, 7fff]
writing section [2000, 7fff]

Lo que indica que no hay errores, y que el dispositivo descubierto con identificación 05, se borró totalmente (en su área de de programa) y se re-escribió con el programa.

Pinguino tiene 2 leds on board. Un led está destinado a indicar que el micro está energizado, por lo que desde se conecta al computador este led enciende. El otro led es el testigo de ejecución de programa. Este solo enciende luego que el micro se conecta y pasan 5 segundos y se ejecuta el programa que tiene grabado.

Por tanto, luego de grabar el skecth, el micro tardará unos segundo antes de empezar a ejecutar automaticamente el mismo. Este comportamiento se repetirá cada vez que se encienda el dispositivo.

Para este ejemplo, y si todo está ok, el led conectado el pinguino empezará parpadear con medio segundo entre encendido y apagado.

Read More......

miércoles, 18 de mayo de 2011

Arduino and relatives - 101




Los componentes básicos de una plataforma Arduino o relacionados son, en primer lugar el hardware con el cual vamos a interactuar.

En nuestro contexto, y basándonos en artículos anteriores, es el microcontrolador. Veamos algunos de ellos.. todos basados en su precursor y más evolucionado ancestro- Arduino.

La imagen muestra un Arduino UNO. Esta plataforma de desarrollo presenta un número considerable de puertos de entrada y de salida para interactuar con el micro y un puerto USB para contectarlo con nuestro ordenador y poder programarlo o comunicarnos con El vía protocolo serial sobre el USB.

Generalmente utilizamos la energía del puerto USB (+5V) para alimentar el hardware, es decir, conectándolo al ordenador lo energizamos para poder programar el dispositivo.

Algunos parientes de Arduino los podemos encontrar en la red. Por ejemplo el Teensy permite trabajar como lo haríamos con Arduino pero a menor costo.

Los componentes se mantienen muy similares. Un puerto USB que energiza el componente de hardware y permite comunicarnos con El, así como puertos de entrada y salida para ponerlo a hacer algo con el exterior.

Pinguino, como comentaba en un artículo anterior, es una plataforma muy parecida a las anteriores, con la diferencia fundamental de que está basado en un micro PIC. Es muy sencillo de ensamblar desde cero y es muy barato de implementar.


Adicionalmente a los puertos de entrada/salida y USB, podemos encontrar un botón que nos permite resetear el dispositivo. Resetear el mismo permite:

  • Llevar al dispositivo a un estado consistente de inicio.
  • Ejecutar desde cero el programa cargado en El.
  • Generalmente, existe un delta de tiempo antes de iniciar el programa cargado en un micro, que nos permite pasar del IDE el archivo .hex producto de la compilación del programa con el cual deseamos cargarlo. Por tanto, si queremos reprogramar el dispositivo utilizamos el botón de reset y el IDE.
Para más info de arduino pueden ir a esta introducción.

El segundo componente es el IDE, en el cual programamos, compilamos y cargamos nuestro programa en el dispositivo.

El IDE puede verse de la siguiente forma.


También llamado ambiente de desarrollo, el mismo consta de:
  • Editor de Texto, el cual nos permite escribir nuestro código.
  • Area de Mensajes, en donde recibimos los mensajes de compilación y en algunos casos las salidas de la comunicación del dispositivo vía serial.
  • Area de Botones, los cuales nos permiten compilar y cargar nuestro .hex en el dispositivo.
  • Menú, en donde conseguiremos las opciones que el IDE nos ofrece.
El código en arduino se denomina Sketch, lo cual es un nombre diferente a lo que nosotros estamos acostumbrados, pero básicamente es lo mismo que un programa.

Para mayor referencia del ambiente de desarrollo pueden entrar aqui (IDE).

Estos dos componentes básicos son indivisibles si queremos desarrollar, aunque si tenemos el dispositivo programado y en producción, el ambiente de desarrollo no es necesario... solo la energía para alimentar al dispositivo utilizado.

Para obtener el componente de hardware tenemos básicamente dos (2) opciones: lo compramos o lo fabricamos.

Arduino y sus parientes son plataformas de hardware abierto, lo que nos permite obtener los diseños en las páginas web de los fabricantes y fabricarlos nosotros mismos (DIY - Do It Yourself).

Existe toda una tendencia hoy para los que nos gusta tomar los planos o esquemáticos y ejecutar desde cero... los DIYers y los Tinkerers. Los primeros ya los intuimos, los segundos son personas que les gusta reparar y/o esperimentar con máquinas y sus partes.

Lo más sencillo sin duda alguna es buscar algún proveedor local y obtener inicialmente el más modesto de los dispositivos. También podemos fabricarlos, como lo he hecho yo con pinguino... pero esa es otra historia.

Otros componentes de hardware que debemos buscar con nuestro proveedor de electrónica son:

Lista Básica para iniciarnos con un Hello World y entreternernos con algunos ejemplos simples para poder aprender.
  • Protoboard
  • Algunos leds
  • Algunas resistencias de 470 Ohm
  • 1 potenciometro de 10K Ohm
  • 1 switch
  • 1 pulsador
  • cables
  • y algunas herramientas básicas como una pinza y un cortafrio y un tester
Les aseguro que esta lista empezará a crecer muy rápido en lo que le tomen el gusto a esto.

El segundo componente lo obtenemos del fabricante directamente. En las páginas de Arduino, teensy y pinguino podrán conseguir los links desde donde bajarse la versión que más se ajuste al sistema operativo de su preferencia.

En mi caso trabajo con Linux, y aunque es un poco más elaborada la instalación en estos ambientes operativos, no es dificil realmente, aunque en Windows siempre es muy sencillo e intuitivo.

Como lectura complementaria les dejo:


No pierdan de vista a Processing... lo estaremos usando para hacer cosas muy interesantes.



Read More......

domingo, 15 de mayo de 2011

Arduino o No Arduino

En artículos anteriores hemos avanzado en el tema teórico de los microcontroladores, lo cual es "Nice" cuando queremos introducirnos a un terreno donde nunca hemos estado. Habiéndolo recorrido con suficiente extensión desde una perspectiva de hobby, creo ya conveniente que vayamos directo a la experimentación.

Pero no iremos directamente a experimentar sin antes escoger que tecnología debemos usar para, desde mi punto de vista, cumplir con tres objetivos:

1) Ser sencillo

Esto es muy importante. Yo soy un fiel creyente que se pueden hacer cosas muy interesantes y útiles sin la necesidad de ser un ingeniero... solo hay que tener conocimientos básicos, ser ávido lector, y tener suficiente curiosidad como para escudriñar temas y llegar a su núcleo para entenderlos lo suficiente como para empezar a crear.

2) Ser Amplio

Tener capacidad de ser utilizado en múltiples aplicaciones.

3) Estar al Alcance

Ser una tecnología accesible a cualquier en muchas partes del mudo, y sobre todo en nuestros países latinoamericanos.

Cuando inicié a investigar acerca de los micros, lo primero que conseguí fue información del microcontrolador más popular de todos los tiempos... el PIC. De este se consiguen todos los modelos y tamaños (pines, memoria, etc), y aunque es relativamente sencillo aprender a programarlos, no cumple fielmente con mi primer objetivo... ser sencillo.

Recuerdo que después de algunas semanas leyendo acerca de ellos y trabajando en simuladores pensé... debe haber otras tecnologías que permitan hacer lo mismo de manera más rápida y sencilla. Con esta idea en mente empecé a buscar como hacer algo basado en PIC que me permitiera no tener que adquirir un programador especializado y además que fuese sencillo... y dando vueltas en la red conseguí a Arduino.

"Arduino is an open-source electronics prototyping platform based on flexible, easy-to-use hardware and software. It's intended for artists, designers, hobbyists, and anyone interested in creating interactive objects or environments."

Y en el pequeño concepto obtenido de su página web vemos algo clave: prototyping. Esta es una herramienta de prototipado rápido, lo que permite llevar un concepto de la idea a la práctica de forma muy rápida, además de ser sencillo y flexible, y es suficientemente multipropósito como para cubrir al menos los objetivos 1 y 2.

Inmediatamente después de conseguir a Arduino me dediqué a la tarea de averiguar si lo podía conseguir en algún lugar cercano a mi residencia, lo cual efectivamente conseguí, por lo que el tercer objetivo fue cumplido.

Ahora bien, luego de tener mi primer encuentro con Arduino decidí que este era el microcontrolador para mi, y empecé a estudiarlo y recorrer la red para ver que había. Es asombroso ver como una plataforma abierta puede ser tan masiva y tan apetecible por expertos y principiantes.

Siendo una plataforma abierta se presta para que mucha gente desarrolle y cree cosas nuevas, además de plataformas afines (no clones) que pueden ser alternativas válidas de desarrollo.

Lo interesante de arduino es que ha creado todo un ambiente de desarrollo basado en un lenguaje de programación muy intuitivo y una forma de interactuar con el dispositivo realmente sencillo, por lo que los desarrollos alternativos han buscado aprovechar este esquema y reproducirlo, lo cual permite que alguien que ha estudiado arduino pueda con muy poco esfuerzo intelectual hacer las mismas cosas que con arduino.

Navegando en la red me topé entonces con Teensy. Esta es una plataforma alternativa a arduino mucho más económica y con prestancias similares, a lo cual respondí comprando un Teensy 2.0+.

Luego, buscando cosas acerca de esta plataforma conseguí algo que me pareció más interesante aún... conseguí a Pinguino.

Esta plataforma es un clone de arduino pero basado en el microcontrolador PIC, además de ser muy simple de implementar desde el punto de vista de hardware. Cuando hablo de un clone es que el look-and-feel de su lenguaje de programación, así como la interacción con el micro es muy parecida (para no decir igual) a arduino, lo que permite tener una plataforma de prototipado rápido adicional, amén que es muy barato construir los dos modelos propuestos en hackinglabs.

Pero entonces cual escoger?. Arduino o No Arduino?... esa es la cuestión.

Como mi intención es aprender y escribir acerca de mis experiencias, y pensando en los primeros tres objetivos, creo que el tema no es escoger a arduino como plataforma sino como filosofía. Esto hace que uno pueda comprar un arduino original o adquirir o construir cualquiera de las plataformas alternativas que existen basados en la filosofía de arduino.

En el próximo artículo iniciaremos a arduino y su filosofía y empezaremos a experimentar.

Antes de finalizar quisiera mostrar algo de verdad interesante... es tan masivo el tema de Arduino que hace poco Google lanzó una plataforma de desarrollo para Android basado en arduino.



English Section

In previous articles we have advanced in the theoretical subject of the microcontrollers, which is " Nice" when we want to introduce ourselves to a land where we never have been. Having studied this subject with sufficient extension from a hobby perspective, I think it is the time to go directly to the experimentation arena.

But we can't go to experimentation if we haven't choose which technology is the ideal technology to work on. From my point of view we have to fulfill three objectives first:

1) Simple

This is very important. I am a believing faithful that we can make very useful and interesting things without a Master Degree… The only prerequisites needed is basic knowledge, to be an eager reader, and to have sufficient curiosity to dig in subjects and to arrive at his core to understand them.
.
2) Ample

Have the capacity to be used in multiple applications.

3) everybody's reachable

Need to be an accessible technology to everybody in many parts of the world, and mainly in our Latin American countries.

When I started to investigate about microcontrollers, the first micro that came up was the PIC micro. You can find PIC in all models and sizes (pins, memory, etc), and although this technology is relatively simple to learn and program, does not fulfill my immediate goal faithfully… to be simple.

I remember that after some weeks reading about them and working over simulators I thought… there must have other technologies that allow me to do the same, faster and simpler. With this idea in mind I began to look for something based on PIC that allowed me to program them without a specialized burner and in addition, it had to be simple… and digging out on internet I got Arduino..

"Arduino is an open-source electronics prototyping platform based on, easy-to-uses hardware and software. Its' for intended artists, designers, hobbyists, and anyone interested in creating interactivates objects or environments."

At the small reading above obtained from its Web page we can see something that for me is the key: prototyping. This is a prototyping tool, which allows us to convert a concept from an idea to a final result in a very fast way. Additionally it is simple, flexible, and it is multipurpose.

Immediately after knowing Arduino I dedicated myself to the task of finding out if it could be obtained anywhere near to my place, which indeed I found, reason why the third objective was fulfilled.

After to have my first encounter with Arduino I decided that this was the microcontroller for my projects, and began to study it and looked out on internet to see what is in there about this technology. It is amazing to see how an open platform can be so massive and so tempting for experts or beginners.

As an open platform, a lot of people are developing and creating new things, additionally to create compatible platforms that can be a valid alternative for development.

The most interesting thing of arduino is that the development environment is based on a very intuitive programming language and the way of interacting with the microcontroller is really simple, reason why alternative developments are adopting this technology more and more.

Navigating internet, few days after, I found Teensy. This is an alternative platform but far less expensive than arduino and with similar features, to which I responded buying a Teensy 2.0+.

Then, looking for things related to this platform I obtained something even more interesting to me… Pinguino. This platform is a clone of arduino but based on PIC microcontroller, and it is very simple to implement from the hardware stand point. Understanding by clone that the look-and-feel of its programming language is practically the same as arduino environmet, as well as the interaction with the microcontroller, which allows us to have a fast prototyping platform and it is cheaper than teensy.

But then what to choose?. Arduino or Not Arduino? … that is the question. As my intention is to learn and to write about my experiences, and thinking about the first three objectives, I believe that the goal is not to choose arduino as a platform, but a philosophy. This gives us the ability to have a wide number of platforms related to arduino, learning only one technology.

In the next blog we are going to start introducing arduino and make some hello world examples and experimentation.

... Arduino is so massive that Google launched a developing environment to Android based on Arduino... very nice.



Read More......