Traceando código C en los AVR "in circuit": avarice

Cómo tracear un programa en C para AVR en GNU/Linux con avarice “in circuit”

Introducción

Bueno, como lo prometido es deuda he conseguido tracear un programa escrito en C para un ATMEGA128 en la propia placa de desarrollo utilizando solamente software libre. Aquí explicaré como lo he hecho y además, como extensión a la receta anterior sobre simulación de código para AVR explicaré como depurar con la herramienta libre ddd, que es básicamente un front-end para gdb muy fácil y cómodo de utilizar.
Así pues, sin mas preámbulos ¡¡¡¡Al turrónnnnn!!!! :-P

Preparando el terreno

Bueno, para nuestros propósitos neceistaremos un AVR JTAG ICE. Se trata de un programador/emulador para AVR y soporta muchísimos de los micros de ésta familia.

En lo referente al software, utilizaremos avarice que no es ni mas ni menos que nuestro interface con el JTAG. También haremos uso del ya conocido avr-gdb y de ddd como front-end de avr-gdb.

Bueno, pues suponiendo que seguisteis con atención la receta anterior en la que hablé de cómo simular los AVR, tan solo tendremos que instalar ddd y avarice en nuestra máquina para empezar…

javieralso@avalon:~$ sudo apt-get install avarice ddd

Compilación del código a simular

Bueno, para la compilación del código necesitamos exactamente las mismas opciones que para la simulación. De hecho, el proceso es el mismo, ya que en ambos casos usamos avr-gdb. La única diferencia es que avarice no necesita para nada el archivo .bin que creamos. En su lugar utilizaremos el .hex, que será el que carguemos en el microcontrolador para tracear. Por lo tanto podemos seguir utilizando el Makefile de la receta anterior y supondré que, de hecho, estamos trabajando con el mismo proyecto.

Simulando con ddd

Bueno, antes de empezar a tracear, voy a contar como utilizar ddd para simular. En realidad es muy sencillo. De hecho, hay que seguir exactamente todos los pasos de la receta anterior, salvo que en lugar de llamar a avr-gdbtui, se llama a ddd diciéndole que use por debajo a avr-gdb. Resumiendo, tenemos que hacer algo como esto:

javieralso@avalon:~$ ddd --debugger avr-gdb -x comandos.gdb

¡¡Y ya ta!! Ale, a simular cosas chulas :-P

Un poco de avarice

Antes de ponernos manos a la obra, explicaré un poco el uso de avarice. Bueno, avarice permite borrar, programar, cambiar los valores de los fusibles, leer el contenido de la memoria del chip, verificar el código del chip y, por supuesto, tracear. Para todo ello necesitaremos, como es de suponer, el JTAG antes mencionado.

Si queremos hacer cosas como por ejemplo borrar un chip, haríamos lo siguiente:

javieralso@avalon:~$ avarice -2 --erase  --jtag usb

la opción -2 se utiliza para decirle a avarice que estamos trabajando con el JTAG mkII, que es algo así como la segunda versión. —jtag usb indica que estamos utilizando la conexión USB del dispositivo. Si quisiéramos utilizar un puerto seríe, habría que sustituir usb por la ruta del archivo de dispositivo del puerto a utilizar.

Para programar un micro:

javieralso@avalon:~$ avarice -2 --erase --program --file archivo.hex --jtag usb

Después de pasar la opción —program, tenemos que decir qué archivo queremos utilizar. Para se utiliza la opción —file seguida del archivo que queremos transferir.

Si se utiliza la opción —P seguido de un modelo de micro podemos decirle a avarice que estaremos utilizando ése micro. Lo normal es que avarice sea capaz de leer la información de identificación del micro sin problemas.

Siempre que queramos programar un micro, deberemos borrarlo antes de manera explícita, ya que el borrado no se hace de forma automática al iniciar la programación, como si pasa con otros entornos.

Al meollo del asunto: TRACEANDO

Ahora ha llegado la hora de la verdad. Con todo listo, nuestro JTAG conectado al usb del ordenador y a la tarjeta a tracear nos disponemos a empezar. La forma en que se ejecutan las aplicaciones es la misma que en la receta anterior. De hecho, para avr-gdb, avarice cumple exactamente el mismo papel que simulavr y lo ve de la misma manera.

Lanzamos primero avarice, diciéndole que programe el micro si esque no lo habíamos hecho nosotros antes:

javieralso@avalon:~$ avarice -2 --erase --program --file rs232toRS485.hex --jtag usb:1212

Ésto es exactamenet lo que hicimos antes, pero con el añadido de que además, le hemos dicho que se quede escuchando conexiones entrantes por el puerto 1212

Ahora tenemos que lanzar ddd, pero antes necesitamos un archivo de comandos para que los ejecute al comienzo. Éste archivo es casi igual que el de la receta anterior, solo que cambian un par de cosillas, así que lo pongo tal y como lo tengo yo:

set debug remote 1
file rs232toRS485.out
target remote 192.168.0.19:1212
break main
continue

Bueno, podemos ver que el archivo es casi igual. Solo se ha eliminado el load, que aquí lo que hacía era cargar el código del micro en el simulador, cosa que no nos interesaba. También activamos la simulación remota (set debug remote 1).

Una vez hecho ésto, solo nos queda llamar al simulador:

javieralso@avalon:~$ ddd --debugger avr-gdb -x comandos.gdb

y ¡¡YA ESTÁ!! a partir de ahora, lo que hagamos en ddd se verá reflejado en nuestra placa de desarrollo. Podremos leer variables, asignarles otros valores, etc etc etc. Eso si, existen algunas limitaciones, como por ejemplo que solo podemos tener 3 breakpoints como mucho, pero vamos, menudencias ;-)

Pues nada més. Espero que lo disfrutéis como lo estoy disfrutando yo y que os sea tan útil para vuestros proyectos como lo está siendo para mi ;-)

Referencias

?