Medidor de luz en Cocoa usando Arduino

junio 8, 2010

Hace tiempo que no publicaba nada del magnífico Arduino. La culpa, como siempre, de que los días sólo tengan 24 horas 😉

En el anterior post sobre Arduino, presentamos lo fácil que era conectar processing con Arduino. En este post vamos a ver que no sólo con Processing, realmente leer los datos que nos da el Arduino es fácil desde cualquier sitio.

Para presentarlo vamos a mostrar un pequeño programa hecho en Cocoa que lee los datos recogidos por el Arduino y lo muestra gráficamente.

En primer lugar pondremos el esquema del circuito.

El circuito es bastante sencillo y sin muchos secretos, el único detalle a tener en cuenta es que utilizamos una resistencia pull-up de 1KOhm para medir la tensión después del sensor LDR. Esto lo conectamos a la entrada 0 de la placa del Arduino.

De esta manera el arduino leerá el valor de esa entrada, pero necesitamos alguna manera para comunicarnos con el PC. Aquí es donde entra la sencillez del Arduino, ya que podemos usar el puerto USB para comunicarnos. Los datos los enviaremos con la librería Serial. Desde el PC, al tratarse de una comunicación serie, podemos usar cualquier mecanismo para leer del puerto. Y cuando decimos cualquiera, realmente hay un mundo de posibilidades, por mencionar algunos, tenemos librerias en Python, Java o incluso usando la librería estandar de C.

El código del programa que cargamos en el arduino es el siguiente

int LDR = 0;
int val = 0;
int delayTime = 500;

void setup()
{
  pinMode(LDR, INPUT);
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  val = analogRead(LDR);
  Serial.println(val);
  val = 0;
  delay(delayTime);
}

Como vemos es bastante sencillo. En el Setup, configuramos el puerto serie con una velocidad de 9600 baudios y cada lectura la escribimos en el puerto serie usando el Serial.write.

De la misma manera podemos usar el puerto USB para establecer la comunicación inversa, en algun futuro post veremos como realizarla, y como usar el Arduino como medio para mostrar información de forma diferente.

Cuando instalamos el driver de Arduino en nuestro PC, nos crea un dispositivo que variará segun el sistema operativo. En mi caso, OSX, el dispositivo es /dev/tty.usbserial-A900aeKy , por lo que con el programa cargado, podremos leer de ese puerto los datos que esta leyendo la placa del sensor. Para ello podemos usar el programa screen, que viene con la gran mayoría de sistemas basados en UNIX.

Si ejecutamos en una terminal el comando

$ screen /dev/tty.usbserial-A900aeKy

Deberíamos ver algo parecido a esto:

En pantalla podemos ver como van apareciendo los valores que esta leyendo la placa, si variamos la intensidad de la luz, efectivamente vemos como dichos valores cambian.

Una vez que tenemos lista la parte del Arduino, la siguiente parte es crear la aplicación en PC. Como hemos mencionado antes, para capturar los datos que nos llegan, debemos leer del puerto serie. Para ello, y al estar en un sistema Unix, podemos utilizar la Api estándar para leer de un dispositivo.

Como esto lo vamos a usar desde una aplicación en Cocoa, vamos a encapsular estas funciones en un objeto de cocoa, de tal manera que su uso sea mas sencillo. Este objeto al construirse abrirá el puerto serie, y nos ofrecerá un método para obtener el siguiente valor leído.

Hablando del código en C, como podeis suponer no tiene mucho secreto, usando open() abriremos el fichero que representa el dispositivo, y con read() leeremos los datos.

El enlace al código fuente esta al final de la entrada, pero el código principal que realiza esto es algo como lo siguiente:

int fd = open("/dev/tty.usbserial-A900aeKy", O_RDWR | O_NOCTTY | O_NDELAY);
char buffer[100]; memset(buffer, 0, 100);
int nbytes = read(fd, buffer, 100);

La última parte que nos falta del puzzle es la aplicación Cocoa que se encargará de mostrar los datos, la idea es mostrar un numero que indique el valor leido del sensor, y un medidor del tipo NSLevelIndicator para mostrar un indicador gráfico del valor del sensor.

No entraré en detalle en comentar la aplicación en Cocoa ya que es muy sencilla, la aplicación consta de una Custom View que pinta el número leido. Para realizar las lecturas periodicas, se utiliza un NSTimer que llamará periodicamente a un método que le especifiquemos y que se encargará de actualizar la vista con el nuevo dato leido.

Para finalizar el post, os dejo con un video del programa en funcionamiento y el código de la aplicacion Cocoa y del programa de Arduino.

Codigo Fuente


Aplicaciones gráficas con Processing y Arduino

marzo 2, 2010

En mis aventuras con Arduino, una de las cosas que he descubierto es la librería Processing.

En un principio no la conocía de nada por lo que el primer contanto con esta librería fue algo extraño. Al acceder a su página lo que te encuentras es una librería centrada en la creación de contenidos gráficos, y la pregunta es, ¿Qué tiene que ver esto con Arduino? Pues bastante, como vamos a ver 🙂

Si nos descargamos el entorno de Processing, lo primero que nos daremos cuenta es que el entorno de desarrollo de Arduino es completamente similar al de Processing. Más allá de una simple libería, Processing nos ofrece un completo entorno donde podamos desarrollar nuestros prototipos usando su propio lenguaje. Si bien, el lenguaje de processing es muy similar a Java.

Este concepto de entorno de desarrollo donde podemos crear el código y ejecutarlo es precisamente la misma idea de Arduino.

A la izquierda el editor de Arduino, a la derecha el de Processing

Uno de los beneficios de processing es que desde el punto de vista de la programación crear una animación es bastante sencillo, ya que la plataforma nos facilita la mayoría de los detalles. El objetivo es poder plasmar rapidamente nuestras ideas en un programa informático, cosa que no podemos conseguir de la misma forma usando los lenguajes y librerías tradicionales.

Sacado de la propia web de Processing, si queremos poner un par de lineas en pantalla, lo único que deberíamos escribir en nuestro “sketch” sería:

size(400, 400);
background(192, 64, 0);
stroke(255);
line(150, 25, 270, 350);
line(100, 25, 200, 300);

Desde el punto de vista de un desarrollador de Arduino, Processing, además de “prestarnos” su entorno de desarrollo, nos ofrece un medio muy interesante para añadir una parte visual a nuestro proyecto de Arduino. Como ya sabemos, Arduino es capaz de escribir y leer desde el puerto serie, por lo que usando esta interfaz, podemos recibir datos y enviar ordenes a nuestra placa.

Dado al nivel de unión que existe entre ambos proyectos, este “enlace” se realiza mediante la libreria Serial que existe en Processing. Usando esta librería, podemos leer del puerto serie, por lo que podremos adecuar nuestra animación según los datos que recibamos, así como enviarle datos al arduino según lo que se produzca en la aplicación gráfica.

Usando esta combinación se abre un buen abanico de posibilidades, ya que de una forma bastante sencilla podemos crear aplicaciónes gráficas bastante aparentes, que muestren datos recibidos del mundo externo.

Para terminar, os dejo con una animación hecha en Processing en youtube, y galería de proyectos en la web de Processing.


Construyendo un contador binario con Arduino

febrero 7, 2010

Del poco tiempo que tengo ultimamente para hacer cosillas, el Viernes por fin pude ir a la tienda de electrónica para comprar materiales :).

Básicamente compre una placa de prototipos, unos leds con resistencias y un LDR ( Resistencia variable según la luz ). De momento dejaremos el LDR para otra entrada y centremonos en las bombillas.

La conexión del circuito es bastante sencilla, simplemente enchufamos la salida digital del arduino al lado positivo del LED poniendo entre medias una resistencia, mientras que el lado negativo de cada LED iría al la conexión de tierra de la placa Arduino.

Como veis en el esquema, nada complicado 😉

Montandolo en la placa de prototipos, a mi me ha quedado algo así:

Una vez tenemos el circuito montado, viene la parte de la programación, antes de nada hay que descargarse el genial entorno de programación de la gente de Arduino. Os lo podeis descargar desde aquí.

El código en cuestión sería algo como:

int outPin[] = {13, 12, 11, 10, 9};

int delayValue = 600;

void setup()
{
  int i = 0;
  for ( i = 0; i < 5; i++)
    pinMode(outPin[i], OUTPUT);
}

void loop()
{

  int i = 0, j=0;

  for ( i = 0; i < 32; i++)
  {
     for ( j = 0; j < 5; j++)
     {
       if ( ( (i >> j) & 1 )  == 1 )
           digitalWrite(outPin[j], HIGH);
       else digitalWrite(outPin[j], LOW);
     }
     delay(delayValue);
  }
}

Como veis es bastante sencillo, declaramos un array con el conjunto de pines a los cuales estan enganchados nuestros LEDs. En la función setup, los configuramos en modo salida.

La chicha esta en la función loop(), esta se ejecutará una y otra vez, lo que hacemos es iterar por los 32 numeros que podemos mostrar, ya que tenemos 5 LEDs, y 2 elevado a 5 son 32. Por cada número, encedemos o apagamos cada led correspondiente. La clave esta en el bucle que realiza la operación “(i >> j) & 1”. Cada iteración del bucle divide el numero en cuestion por 2 y se queda unicamente con el bit de menor valor. Asi sabemos si tenemos que encender o no el LED.

Por ejemplo, para mostrar el número 21, que en binario es (10101) deberiamos encender los LEDs 0, 2 y 4 y dejar apagados el resto. El calculo sería:

  • LED 0: 21 (10101 & 1) -> 1 , encendido
  • LED 1: 21 / 2 = 10 (01010 & 1) -> 0, apagado
  • LED 2: 21 / 4 = 5 (00101 & 1) -> 1, encendido
  • LED 3: 21 / 8 = 2 (00010 & 1) -> 0, apagado
  • LED 4: 21 / 16 = 1 (00001 & 1) -> 1, encendido

Como vemos, el resultado del calculo es correcto. Básicamente lo que se hace es ir desplazando los bits hacia la derecha y quedandonos con el bit menos significativo.

Bueno, pues dada la maravillosa sencillez que caracteriza al Arduino, solo nos queda darle al boton de Upload, y veremos, como las lucecitas empiezan a encenderse.

Os dejo un video de mi resultado 🙂


Hardware con Arduino

enero 9, 2010

Una de las cosas que dejaron por aquí los reyes magos ha sido una placa Arduino. Hace tiempo estuve mas o menos metido en el tema de la electrónica, y lo cierto es que es un mundo que me parece apasionante, aunque uno de los grandes problemas era lo dificultoso que era el punto de entrada. Construirse una placa sencilla con resistencias o leds no era del todo complicado, pero cuando querias ir algo mas allá, y entrabas en los microcontroladores, la cosa se complicaba. En mis tiempos de estudiante, Microchip tenía una placa de desarrollo basado en PICs que estaba bastante bien, hasta llegamos a hacer algo curioso en la universidad, pero el precio era un obstaculo importante. Incluso, no era muy complicado llegar a cargartela conectando de forma incorrecta las cosas.

Arduino viene a eliminar algunas de estas barreras que hacian los primeros pasos algo complicados.

El primer detalle que salta a la vista es que la placa Arduino es Hardware Abierto, esto es, el diseño de la placa esta totalemte disponible, y cualquiera se podría fabricar una, por otro lado, las herramientas de desarrollo también son libres, por lo que podemos desarrollar sin ningun coste. Como ya sabemos el hecho del software libre, no solo implica a los costes, sino que también suele significar que hay una gran comunidad detrás apoyando al proyecto, y en el caso de arduino, la hay.

Además podemos hablar del precio, una de las grandes ventajas de arduino precisamente es esta, el precio de la placa de entrada, la Duemilianove esta por debajo de los 30€, lo cual lo hace perfecto para empezar. Incluso, los modelos algo mas avanzados no llegan a los 100€

El segundo punto fuerte de Arduino es la facilidad de desarrollo, desde su sitio web podemos descargarnos un entorno de desarrollo multiplataforma ( ya que esta hecho en Java ). Mediante un lenguaje similar a C, podemos escribir con muy poco esfuerzo un programa, subirlo a nuestra placa pinchando en un botón y ejecutarlo.

Por ejemplo, el código de ejemplo que hace que un led parpadee seria algo como:

int ledPin =  13;    // LED connected to digital pin 13
// The setup() method runs once, when the sketch starts
void setup()   {
// initialize the digital pin as an output:
  pinMode(ledPin, OUTPUT);
}
// the loop() method runs over and over again,
// as long as the Arduino has power
void loop()
{
  digitalWrite(ledPin, HIGH);   // set the LED on
  delay(1000);                  // wait for a second
  digitalWrite(ledPin, LOW);    // set the LED off
  delay(1000);                  // wait for a second
}

En mi caso tardé 10 minutos en tener el programa cargado y ejecutandose en la placa. Todo un logro y que dice mucho de la facilidad con la que podemos hacer cosas.

A nivel técnico, el corazón de la placa es un chip Atmega de la empresa Atmel, este chip tiene una arquitectura AVR. Esto significa que podemos usar el toolchain para gcc sobre arquitecturas AVR, llamado avr-gcc. Aparte de las herramientas de compilación, también existe un port de la libreria estandar de c para esta arquitectura, por lo que además de poder programar usando la variación de C que se nos ofrece en el IDE, también podremos programar directamente en C, compilando desde la linea de comandos