Bueno, demos cuenta del último de los talleres en Medialab que celebramos el mes pasado. Como recordarás el tercer y último taller corrió a cargo de Jeroen Domburg y se trataba de introducir al personal en el fascinante y misterioso mundo de los microcontroladores.

Porque, verás, además de fascinantes y misteriosos los microcontroladores son tremendamente útiles. Con uno de estos pequeños circuitos integrados y un poco de práctica uno puede comunicarse con todo tipo de elementos electrónicos devolviéndoles su utilidad o incluso dándoles una totalmente nueva. Como ejemplo, durante el taller empezamos haciendo parpadear un LED, pero terminamos interactuando con un display LCD (como los que se pueden encontrar en las típicas impresoras multifunción) y un viejo ratón PS/2.

Estos trastos son tan molones… pero taaan molones, que cualquiera con el culo un poco inquieto y un soldador acabará, tarde o temprano, tonteando con la idea de usarlos en sus proyectos. El mayor problema, como en casi todo, está en el primer paso. Porque vale que uno sabe programar. Ningún problema. Pero, ¿cómo demonios se hace para meter un programa ahí dentro? Con lo chiquitico que es eso.

Eso es lo que me pasaba a mí al menos. Y por lo que pude oír durante el taller, le pasa a bastante gente. Así que tanto si viniste al taller como si no, atiende, que te voy a contar todo lo que hace falta para programar un microcontrolador.

Material

Lo primero y más importante es el microcontrolador en sí [/perogrullo]. El tipo de micro que vayas a utilizar condiciona el resto del montaje. No se programa igual un PIC que un AVR. Nosotros en los talleres usamos un ATMega88, (puedes descargarte su datasheet aquí) que forma parte de la familia AVR fabricada por Atmel. Los micros de esta familia comparten un conjunto básico de instrucciones, así que, al menos en teoría, es muy posible que los ejemplos que usemos aquí funcionen para otros modelos aparte del ATMega88.

Pero centrémonos un poco. Para quien le interesen estas cosas diremos que nuestro micro en concreto tiene un procesador RISC de 8 bits, 8 KBytes de memoria de programa, 1KByte de memoria RAM, 512 Bytes  de memoria EEPROM y 23 pines de entrada/salida digital, 6 de los cuales se pueden usar como conversores analógico/digitales de 10 bits. También es interesante saber que el ATMega88 es virtualmente identico a los ATMega48 y ATMega168, con la diferencia de que el 48 tiene 4 KBytes de memoria de programa y el 168 tiene 16, por lo que si tu programa acaba siendo demasiado grande (o si es lo suficientemente pequeño y quieres ajustar gastos), te puede interesar emplear uno de estos en lugar del 88. En cuanto al precio, los micros del taller costaron 3 leuros cada uno. Pocas cosas encuentra uno más baratas

También necesitarás un ordenador. Como en los talleres anteriores, usamos los PIII a 600 MHz con 256 megas de RAM que rescatamos de los desechos de la Universidad Complutense. También como en talleres anteriores, el sistema operativo empleado ha sido Xubuntu, mayormente por sus bajos requerimientos.

Otra cosa que va a hacerte falta es un software que te permita compilar los programas que escribas y se encargue de grabarlos en el micro. En Xubuntu y demás sistemas basados en Debian, puedes encontrar todo lo que necesitas en los repositorios. Necesitarás instalar los paquetes «avr-gcc«, «avr-libc» y «avrdude«. Para ello basta con que ejecutes la orden «aptitude install avr-gcc avr-libc avrdude» desde una terminal con derechos de administrador. Para Windows, existe un programa equivalente llamado WinAVR, también gratuito, pero no te puedo decir qué tal va porque no lo hemos probado.

Y claro, necesitamos un programador en el sentido físico-material del termino. Un cacharrito que nos permita conectar nuestro micro al ordenador para que se digan todo lo que tengan que decirse. Si tienes suerte y tu ordenador tiene puerto paralelo puedes construirte uno como éste por cuatro perras. Básicamente se trata de coger un conector de puerto paralelo y conectar con cables algunos de los pines del puerto con los del micro tal como dice en esta tabla:

Puerto paralelo	Microcontrolador
Pin 7	AVR /RESET
Pin 8	AVR SCK (clock input)
Pin 9	AVR MOSI (instruction in)
Pin 10	AVR MISO (data out)
Pin 18	Signal Ground

También se aconseja poner resistencias del orden de 1K en los extremos de los cables para protejer el puerto en caso de que se produzca algún error de conexión.

Si no tienes tanta suerte y tu ordenador no tiene puerto paralelo puedes comprar/construir un programador USB como éste, pero claro, ten en cuenta que va a ser más caro/complicado.

Y ya por último necesitas una fuente de alimentación adecuada. Hace falta suministrarle 5V a los microcontroladores para que funcionen. Durante el taller empleamos estas pequeñas fuentes que construí para la ocasión, y te aconsejo encarecidamente que uses algo similar. Aunque en teoría se podría usar, por ejemplo, la fuente de un ordenador, que también suministra 5V, el caso es que este tipo de fuentes no son muy estables con tan poca carga, y además, si se produce un error de conexión, son tan potentes que freirían el micro en segundos.

Montaje

Muy bien, ya tenemos todo el material. Vamos a montar el tinglado:

1. Pincha el microcontrolador en el centro de la placa de prototipado.
2. Conecta la alimentación. Las dos patas GND se conectan a tierra y las patas VCC y AVCC se conectan a +5V. Para filtrar la corriente de posibles interferencias se recomienda poner un condensador de 100 nF entre +5V y tierra. (Recuerda que puedes ver los nombre de los pines del microcontrolador en la datasheet o en la imagen que hay más arriba).



3. Conecta los 5 cables del programador a los pines del micro del mismo nombre.
4. Como nuestro programa de prueba consiste en hacer parpadear un LED tenemos que conectar el susodicho LED al pin PB0. Conectamos la pata más larga (la positiva) del LED al pin PB0 del micro. Conectamos la otra pata en serie con una resistencia de 470 Ohmnios, y conectamos la pata que queda libre en la resistencia a tierra.
5. Por último conecta el programador al ordenador. (Al puerto paralelo o al USB, lo que corresponda).

Compilación y volcado

Con eso terminan las manualidades. Vamos a compilar por fin. Puedes empezar bajándote el código fuente de los ejemplos que usamos durante el taller.

Dentro del archivo .zip encontrarás tres directorios con el código necesario. El directorio «LCD-skeleton» tiene el armazón de un programa que permite mostrar texto en un display LCD conectado al microcontrolador, pero esta incompleto. La idea es que el alumno complete el código con lo que ha aprendido en el taller. En el directorio «ps2», por su parte, se puede encontrar una serie de funciones necesarias para comunicarse con un ratón ps2. La idea es que, más adelante, se puedan usar estas funciones desde el programa «LCD-Skeleton» para mostrar en pantalla si se está pulsando algún botón del ratón. Así que para empezar nos quedamos con el directorio «Hello World».

Ahí dentro puedes encontrar los dos ficheros necesarios para compilar el programa «HelloWorld». «Hello World», por cierto, es el nombre que se le da siempre al primer programa que compila uno cuando está aprendiendo un nuevo lenguaje. En un alarde de creatividad lo primero que hacen todos los programadores cuando empiezan sacar las palabras «Hello world» («Hola mundo») por pantalla.

Como nosotros no tenemos pantalla nuestro programa lo que va a hacer es que parpadee un LED conectado al pin 0 del puerto B del AVR.  No voy a entrar ahora en comentar cómo funciona el programa, que si no no acabo nunca. Está en C y está bastante bien comentado. Ademas hay multitud de tutoriales sobre programación de AVRs ahí fuera y casi todos empiezan con un programa similar a éste. Me interesa más explicar cómo se compila todo y se graba en el chip, que esta bastante menos documentado.

Bueno, como habrás visto el directorio del programa tiene dos ficheros. El fichero «main.c» contiene el código fuente en C del programa. Como suele ser habitual, puedes usar el editor de texto que prefieras para editarlo. El fichero «Makefile» tambien lo puedes editar con el programa que prefieras y en él están definidas todas las opciones de compilación que necesitas. Es un archivo largo y bastante abrumador, pero de momento sólo nos importan algunas de las primeras lineas.

# Hey Emacs, this is a -*- makefile -*-

# AVR-GCC Makefile template, derived from the WinAVR template (which
# is public domain), believed to be neutral to any flavor of "make"
# (GNU make, BSD make, SysV make)

TARGET = helloworld
SRC = main.c
DEPS =
MCU = atmega88
FORMAT = ihex
ASRC =
OPT = s

Aquí nos interesan las siguientes etiquetas:

• TARGET: Indica el nombre del proyecto. En este caso helloworld.
• SRC: Determina qué ficheros se van a compilar. Ahora solo estamos usando un fichero, main.c, pero proyectos más complejos pueden necesitar más de uno. En ese caso pondremos los nombres de todos ellos separados por espacios. Por ejemplo, si nuestro programa está repartido en los ficheros main.c, lcd.c y ps2.c tendremos que poner:

  SRC = main.c lcd.c ps2.c

• MCU: Esta etiqueta indica el tipo de microcontrolador que queremos programar. El montaje que estamos usando permite programar casi cualquier AVR, pero aquí tenemos que indicar cual de ellos estamos usando en concreto. Puedes ver una lista de todos los chips soportados aquí.

El resto de las opciones son más o menos comunes a cualquier proyecto y no deberías tener necesidad de cambiarlas. Hasta que, mucho más abajo llegamos a:

AVRDUDE_PROGRAMMER = bsd

Esta etiqueta es la que indica qué tipo de programador estamos usando. Si construiste el programador para el puerto paralelo que he puesto más arriba la opción es bsd. Para otros programadores, puedes ver la lista de dispositivos soportados tambien aquí.

Venga, que ya terminamos. Ya tenemos todo conectado y configurado. Ahora, para compilar el programa y grabarlo al AVR, en una consola con permisos de administrador, vete al directorio directorio de nuestro proyecto y pon:

make program

Con esta orden el programa «make» abre el fichero «Makefile «y usa las opciones de configuración que hemos definido ahí para compilar y grabar todo en la memoria de programa del microcontrolador.

El resultado

Si todo ha ido bien tendras un bonito y parpadeante LED saludando al mundo. Ahora puedes desconectar los cables del programador. El microcontrolador seguirá ejecutando el programa independientemente. Además, el contenido de la memoria de programa no es volátil, con lo que puedes retirarle el suministro electrico al micro y cuando se lo vuelvas a conectar el programa volverá a ejecutarse sin problemas.

El siguiente paso ya sería buscarse algún tutorial sobre programación de AVRs y bajarse algunos programas de ejemplo. A partir de ahí, la imaginación es el límite, ya sabes.

Si no fue tan bien todo, revisa las conexiones, comprueba que los paquetes necesarios se instalaron correctamente y vuelve a intentarlo. Es normal necesitar un par de intentos la primera vez que se hacen este tipo de cosas. No desesperes. Si hay alguna parte del proceso que no se entiende bien siempre puedes plasmar tus dudas en los comentarios. Intentaré resolverlas lo mejor que pueda. Tambien podeis contactar directamente con Sprite[Jeroen] aquí, que despues de todo es el experto en estos temas (aunque tendrá que ser en inglés). Y recuerda que ya hay gran cantidad de información sobre este tema en internet. Solo hay que tirar un poco de Google.