Archivo del sitio

Programación de microcontroladores de la familia AVR en GNU/Linux (Debian/Ubuntu) Parte I

Nivel: Intermedio

¿Qué tengo que saber para este post?

  • Instalar software desde tu distribución de linux, acá sólo voy a hacer referencia sobre Debian/Ubuntu utilizando apt.
  • Copiar, crear y mover archivos como administrador del sistema (root) o con el comando sudo.
  • Programación de microcontroladores (no necesariamente de la familia AVR de Atmel).

—————————————

Bueno, sé que este es motivo de búsqueda para muchos. Yo mismo me he encontrado buscando ésto en google alguna vez, pero nadie lo concentraba en una forma amigable y bien detallada, como para un newbie en el asunto. Así que fui de a poco, leyendo en varios lados hasta que más o menos llegué a una forma amigable de programar AVRs en GNU/Linux y con todo bien organizado. Sin el ánimo de alardear, espero expresar a continuación, de la mejor manera posible, una sencilla guía como para dar los primeros pasos en este asunto.

Instalar el compilador

Para instalar el compilador, librerías y demás cosas esenciales para programar microcontroladores de la familia AVR, lo que debemos hacer es sencillamente poner lo siguiente en una terminal como root o si estamos en un sistema sin root (como Ubuntu) poner el “sudo” delante:

apt-get install gcc-avr avr-libc avrdude binutils-avr

Con eso instalamos lo necesario, el avrdude es el programa que nos permitirá, luego, bajar nuestro archivos *.hex al microcontrolador. Para esto debemos darle permisos de usuario a los puertos (USB, serie o paralelo) de cada dispositivo, pero eso lo haremos cuando llegue el momento.

Eligiendo un IDE (o no…)

Lo siguiente sería elegir un entorno de desarrollo que nos facilite la vida al momento de programar. En lo personal, he probado con 2 de ellos, el Code::Blocks que recientemente ha sacado una nueva versión estable, y el plug-in de AVR para la plataforma eclipse. Claro que también podemos editar nuestro código en el vim o nuestro editor favorito y compilarlo a manopla mano desde la consola, pero la realidad es que no vamos a ser más machos por ello y, sinceramente, no es muy amigable para  los poco conocedores. Además, tener una herramienta que nos agiliza el trabajo es más que tentador y nadie nos va a llamar put@s poco hombre o poco mujer (ejem) por usar un entorno de desarrollo.

Volvamos a los IDEs, tanto el Code::Blocks como el plug-in para el eclipse tienen sus pros y sus contras. El plug-in del eclipse tiene un par de bugs feos, como definir y “desdefinir” cosas en la linea del comando del compilador y a veces no toma los cambios hasta después de compilar, dando warnings y otras cuestiones como generar mal el makefile… en fin, tiene sus quilombos problemas, pero se deja usar a pesar de todo con un par de fixeos y parcheos trucos que se pueden usar para solventar estos problemas. Lo bueno de este plug-in son 2 cosas:

  • Nos agrega una solapa en la parte de abajo llamada “AVR device explorer” que nos muestra el nombre de los registros de los micros soportados por el compilador y los defines de los vectores de interrupción (lo cual está bueno si ya conocemos lo que hacen y cómo se utilizan).
  • Nos agrega un botón que llama al avrdude y baja el firmware directo al micro, y además podemos configurar los parámetros y fuses de forma gráfica.

La desventaja del Code::Blocks es que no tiene esa dos ventajas ya mencionadas que tiene el eclipse, aunque el botón para bajar el firmware lo podemos configurar. Y sus ventajas son:

  • El editor es excelente.
  • Tiene varios plug-ins que están muy buenos, incluyendo uno que invoca a doxygen, que es una herramienta para generar documentación, muy útil y utilizada.

Ambos son multiplataforma, es decir que en Windows funcionan de la misma manera, nada más que es necesario instalar el WinAVR, que es lo que sería el primer paso de esta guía, “Instalar el compilador”, instala también las librerías y el avrdude (pero como acá nos concentramos en GNU/Linux, dejemos a Ventanas a un lado).

Instalar Code::Blocks en Debian/Ubuntu

Primero debemos tener permisos de administrador, y luego editar el archivo “/etc/apt/sources.list” y agregar al final del archivo lo siguiente (para la versión estable):

# Code::Blocks
deb http://apt.jenslody.de/stable stable main
deb-src http://apt.jenslody.de/stable stable main

Para la versión testing solo deben reemplazar “testing” donde dice “stable” y listo y luego instalar el key-ring para que no les salte el warning de que hay paquetes que no están firmados, que lo hacen instalando el siguiente paquete como root:

apt-get update
apt-get install jens-lody-debian-keyring

Y ahora a instalar el Code::Blocks y otros paquetes que necesitamos para que no salten errores al compilar:

apt-get install codeblocks codeblocks-additional srecord

Y listo, eso sería lo necesario para instalar todo lo que necesitamos, la primera vez que lo ejecutemos nos mostrará una lista de los compiladores que detectó. El AVR GCC debería estar en esa lista. Para más detalles vean la página oficial.

Instalar eclipse y el plug-in avr

Bueno, básicamente es parecido. primero debemos instalar eclipse:

apt-get install eclipse-cdt

Una vez que lo tenemos instalado, debemos seguir las instrucciones de la página oficial del plug-in que tienen screenshots y es muy amigable, a pesar de estar en inglés 😉 y con eso ya estamos.

Configurando el acceso a los puertos a nivel usuario para el avrdude

Antes que nada, debemos hacernos (de) un programador. Muchos tienen la loca idea de arrancar armándose un programador USB, pero lamentablemente, ese nunca es el primer paso. Un programador USB tiene como “defecto” que necesita de un microcontrolador con un firmware que capture los datos del puerto y los traduzca a las señales de programación de los AVR (que es un protocolo muy sencillo: SPI). Así que, si tenías en mente hacerte un programador USB, olvídate, salvo que tengas un amigo que tenga un programador para prestarte. Mi consejo es:

  • Comprar un USBasp, que es un programador muy barato que vas a encontrar en ebay por pocos dolares.
  • Hacete el programador DASA, que se hace con una ficha DB9 hembra, 3 resistencias, 3 zeners, un cable plano de 6 vías y un IDC6 hembra. Y luego, con un ATmega8 hacete el USBasp.

El USBasp es el que le hago armar a mis estudiantes del colegio donde doy clase, porque programa también la familia 8051 de Atmel, luego subiré el circuito. Una vez que tengamos nuestro programador, debemos darle permisos a nuestro usuario para manejar el puerto deseado. Para eso, lo único que hay que hacer es agregar a nuestro usuario al grupo “dialout”. Verifiquen primero si su usuario ya pertenece a tal grupo escribiendo en su terminal el comando:

groups

Si dialout aparece en la lista, no deben hacer nada, sino como root deben escribir el siguiente comando:

addgroup <tu_usuario_aqui> dialout

Una vez que formemos parte de este grupo, podremos usar el programador DASA sin ningún problema a nivel usuario (si tienen algún problema, sólo reinicien su equipo). Pero si quieren usar el USBasp, hagan el paso anterior de todas formas. Ya que les voy a pasar un archivo que enumera los programadores USB más utilizados (por no decir todos ellos) y que deben agregar a la carpeta “/etc/udev/rules.d/”. También pueden crear el archivo como root, yo lo llamé “99-usb-avr-programmers.rules”, puede tener el nombre que quieran, pero el contenido debe ser el siguiente:

# Programmers for avrdude

ATTR{idVendor}=="03eb", ATTR{idProduct}=="2104", GROUP="dialout", MODE="0660" # AVRISP mkII
ATTR{idVendor}=="03eb", ATTR{idProduct}=="2107", GROUP="dialout", MODE="0660" # AVR-Dragon
ATTR{idVendor}=="03eb", ATTR{idProduct}=="2103", GROUP="dialout", MODE="0660" # JTAG ICE mkII
ATTR{idVendor}=="03eb", ATTR{idProduct}=="2106", GROUP="dialout", MODE="0660" # STK600
ATTR{idVendor}=="16c0", ATTR{idProduct}=="05dc", GROUP="dialout", MODE="0660" # USBASP von www.fischl.de
ATTR{idVendor}=="03eb", ATTR{idProduct}=="2ffa", GROUP="dialout", MODE="0660" # AT90USB
ATTR{idVendor}=="10c4", ATTR{idProduct}=="ea60", GROUP="dialout", MODE="0660" # AVR910
ATTR{idVendor}=="03eb", ATTR{idProduct}=="2105", GROUP="dialout", MODE="0660" # AVR ONE
ATTR{idVendor}=="03eb", ATTR{idProduct}=="210d", GROUP="dialout", MODE="0660" # Atmel XPLAIN CDC Gateway
ATTR{idVendor}=="03eb", ATTR{idProduct}=="2ffb", GROUP="dialout", MODE="0660" # AT90USB AVR DFU bootloader
ATTR{idVendor}=="1781", ATTR{idProduct}=="0c9f", GROUP="dialout", MODE="0660" # adafruit usbtiny

En algún lado lo verán diferente, pero así es como funciona en Debian y supongo que así también debería de funcionar en Ubuntu, si alguien me lo confirma, sería buenísimo.

NOTA: Recuerden que todas las PCs de escritorio, o mejor dicho, todas las motherboards de escritorio, siguen trayendo el puerto serie, históricamente conocido como COM1. Este suele estar en un conector del tipo IDC10. Donde el PIN1 del IDC10 es el que va soldado al PIN1 del DB9 y así el 2 con el 2, el 3 con el 3 y el 10 del IDC10 no se conecta. En general es así, pero verifiquen con el manual de su motherboard. Recuerden que la ficha DB9 debería ser MACHO cuando la compren ;).

Ya tenemos todas las herramientas básicas para empezar nuestro proyectos AVR en GNU/Linux. En la siguiente entrega les mostraré un primer programa (ahora estoy medio cansado para seguir). Les prometo screenshots, fotos y tal vez algún vídeo, tanto con Code::Blocks como con eclipse, enseñándoles un par de arreglos para que la experiencia con eclipse no sea tan decepcionante.