[LinuxFocus-icon]
<--  | Hogar  | Mapa  | Indice  | Busqueda

Noticias | Arca | Enlaces | Sobre LF
Este documento está disponible en los siguientes idiomas: English  Castellano  ChineseGB  Deutsch  Francais  Italiano  Nederlands  Russian  Turkce  

[Photo of the Author]
por Guido Socher (homepage)

Sobre el autor:

A Guido le encanta Linux por ser el paraíso de los desarrolladores de su propio software y hardware.



Traducido al español por:
Daniel Serrano Izquierdo, Lydia López Sánchez <Daniel_S_I/at/teleline.es, enelatico/at/iespana.es>

Contenidos:

 

Programando el Microcontrolador AVT con GCC

[Illustration]

Resumen:

El Microcontrolador AVR 8-Bit RISC de Atmel is un Microcontrolador muy común. Es un único integrado con EEPROM, Ram, conversor Analógico a Digital, un montón de líneas de entrada y salida digital, temporizadores, UART para comunicación RS-232 y muchas otras cosas.

Lo mejor es sin embargo que está disponible un completo entorno de desarrollo para Linux: puedes programar este Microcontrolador en C usando GCC. En este artículo explicaré cómo instalar y usar GCC. Explicaré también cómo cargar el software en el Microcontrolador. Todo lo que necesitas para esto es un Microcontrolador AT90S4433, un cristal de 4Mhz, algún cable y algunos otros componentes muy baratos.

Este artículo será sólamente una introducción. En otro artículo posterior construiremos un display LCD con unos pocos pulsadores, entradas analógicas y digitales, perro guardián del hardware y LEDs. La idea es que esto será un panel de control de uso general para un Servidor Linux pero primero aprenderemos cómo instalar el entorno de programación y eso es de lo que trata este artículo.
_________________ _________________ _________________

 

Instalación del Software: Qué necesitas

Para usar el entorno de desarrollo GNU C necesitas el siguiente software:
binutils-2.11.2.tar.bz2 Disponible desde:
ftp://ftp.informatik.rwth-aachen.de/pub/gnu/binutils/
o
ftp://gatekeeper.dec.com/pub/GNU/binutils/
gcc-core-3.0.3.tar.gz Disponible desde: ftp://ftp.informatik.rwth-aachen.de/pub/gnu/gcc/
o
ftp://gatekeeper.dec.com/pub/GNU/gcc/
avr-libc-20020106 .tar.gz La Biblioteca C de AVR está disponible desde: http://www.amelek.gda.pl/avr/libc/ También la podrás descargar desde este servidor: descarga
uisp-20011025.tar.gz El programador AVR está disponible desde: http://www.amelek.gda.pl/avr/libc/ También la podrás descargar desde este servidor: descarga
Instalaremos todos los programas en /usr/local/atmel. Esto es para mantener el programa separado de tu compilador de Linux C normal. Crea este directorio con el comando:

mkdir /usr/local/atmel

 

Instalación del Software: GNU binutils

El paquete binutils provee todas las utilidades de bajo nible necesarias para construir archivos objeto. Incluye un ensamblador AVR (avr-as), enlazador (avr-ld), herramientas de maneno de librerías (avr-ranlib, avr-ar), progrmas para generar archivos objeto grabables en la EEPROM del Microcontrolador (avr-objcopy), desensamblador (avr-objdump) y utilidades como avr-strip y avr-size.

Ejecuta los siguientes comandos para construir e instalar las binutils :

bunzip2 -c binutils-2.11.2.tar.bz2 | tar xvf -
cd binutils-2.11.2
./configure --target=avr --prefix=/usr/local/atmel
make
make install

Añade la línea /usr/local/atmel/lib alr archivo /etc/ld.so.conf y ejecuta el comando /sbin/ldconfig para reconstruir la caché del enlazador.  

Instalación del Software: AVR gcc

avr-gcc será nuestro compilador de C.

Ejecuta los siguientes comandos para construirlo e instalarlo:

tar zxvf gcc-core-3.0.3.tar.gz
cd gcc-core-3.0.3
./configure --target=avr --prefix=/usr/local/atmel --disable-nls --enable-language=c
make
make install

 

Instalación del Software installation: La biblioteca C de AVR

La biblioteca C está todavía bajo desarrollo. La instalación podría cambiar aún un poco de versión a versión. Recomiendo utilizar la versión mostrada en la tabla siguiente si quieres seguir las instrucciones paso a paso. He probado esta versión y funciona bien con todos los programas que escribiremos en este y posteriores artículos.

Ajustar algunas variables de entorno (la sintaxis es para bash):
export CC=avr-gcc
export AS=avr-as
export AR=avr-ar
export RANLIB=avr-ranlib
export PATH=/usr/local/atmel/bin:${PATH}

./configure --prefix=/usr/local/atmel --target=avr --enable-languages=c --host=avr
make
make install

 

Instalación del Software: El Programador

El software programador carga el código objeto especialmente preparado en la EEPROM de nuestro Microcontrolador.

El programador uisp para Linux es un programador muy bueno. Puede ser usado directamente desde un Makefile. Sólo añade una regla "make load" y ya puedes compilar y cargar el software de una tirada.

uisp se instala como sigue:

tar zxvf uisp-20011025.tar.gz
cd uisp-20011025/src
make
cp uisp /usr/local/atmel/bin

 

Un pequeño proyecto de prueba

Empezaremos con un pequeño circuito de prueba. El propósito de este circuito es sólo probar nuestro entorno de desarrollo. Podemos utilizarlo para compilar, descargar y probar un programa simple. El programa simplemente hará encenderse un LED.
Propongo hacer un pequeño circuito impreso para el Microcontrolador. Puedes extender este circuito más después para hacer tus propios experimentos. Una buena idea es utilizar una placa universal para esto. No obstante no deberías intentar poner el AVR con su cristal de 4Mhz directamente en la placa. Es mejor usar unos cables cortos para conectar las líneas de entrada y salida con la placa ya que dichas placas universales no están hechas para veloces circuitos digitales. El cristal de 4Mhz y los condensadores deben estar físicamente muy cerca del Microcontrolador. [circuit diagram]
Las resistencias del conector para el programador no son realmente necesarias en nuestro caso. Las necesitarás únicamente si piensas usar las líneas de entrada/salida del Puerto-B para otros propósitos.

Udo Puetz ha proporcionano un esquema posiblemente más amigable para novatos que puedes encontrar aquí: avr_layout_newbiefriendly.gif.    

Hardware Necesario

Necesitas los componentes listados en la tabla siguiente. Todos ellos son muy comunes y baratos. Sólo el Microcontrolador es un poco más caro, unos 7,50 €. Aunque es un Microcontrolador muy común puede no estar disponible en cada tienda local pero distribuidores mayores de componentes como ( www.reichelt.de (alemania), www.conrad.de (alemania), www.selectronic.fr (francia), etc..., probablemente hay sitios similares en tu país) tienen existencias de todos ellos.
[avr] 1 x AT90S4433, procesador Atmel 8 bit Avr risc. Las resistencias del conector para el programador no son realmente necesarias en nuestro caso. Las necesitarás únicamente si piensas usar las líneas de entrada/salida del Puerto-B para otros propósitos.

Udo Puetz ha proporcionano un esquema posiblemente más amigable para novatos que puedes encontrar aquí: avr_layout_newbiefriendly.gif.  
Hardware Necesario
Necesitas los componentes listados en la tabla siguiente. Todos ellos son muy comunes y baratos. Sólo el Microcontrolador es un poco más caro, unos 7,50 €. Aunque es un Microcontrolador muy común puede no estar disponible en cada tienda local pero distribuidores mayores de componentes como ( www.reichelt.de (alemania), www.conrad.de (alemania), www.selectronic.fr (francia), etc..., probablemente hay sitios similares en tu país) tienen existencias de todos ellos.
[socket] 2 x zócalos para CI de 14 patillas
o
1 x zócalo de 28 patillas de 7,5mm para integrado
El zócalo de 28 patillas es un poco más difícil de conseguir. Normalmente los zócalos  de 28 son de 14mm de ahcho pero necesitamos uno de 7,5mm.
[resistor crystal capacitor] 1 x resistencia de 10K (código de colores: marrón, negro, naranja)
3 x resistencias de 470 Ohmios (código de colores: amarillo, violeta, marrón)
1 x resistencia de 1K (código de colores: marrón, negro, rojo)
1 x resistencia de 220 Ohmios (código de colores: rojo, rojo, marrón)
1 x cristal de 4Mhz
2 x condensadores cerámico de 27pf
[connector] Cualquier tipo de conector/zólocalo de 5 patillas para el programador. Normalmente compro estas tiras y corto 5 de ellos.
[matrix board] Placa perforada.
[db25] 1 x conector DB25 para conectar al puerto paralelo.
[led] 1 x LED
[beardboard] Una placa universal de conexiones. No la utilizaremos pero es muy útil si quieres hacer futuros experimentos con el AVR.
Sugiero que dejes el Microcontrolador junto al cristal y los condensadores en la placa perforada y conectes las líneas de entrada/salida mediante pequeños cables la la placa universal.
Además de los componentes anteriores necesitas una fuente de alimentación de 5V estabilizada electrónicamente o puedes utilizar una pila de 4,5V como fuente de alimentación.    

Construyendo el hardware del programador

El AT90S4433 permite "for in circuit programming" (ISP). [AVR programmer]
Esto es: no necesitas sacar el Microcontrolador de la placa para programarlo. Verás que puedes comprar el hardware programador preparado por 50-150 Euros. No necesitas invertir esa cantidad en un programador. Con Linux, el software uisp y un puerto paralelo libre puedes construir un muy buen y simple programador AVR. Es un sencillo cable. El cableado para el programador debe ser como sigue: 
pin del AVR Pin del puerto paralelo
Reset (1) Init (16)
MOSI (17) D0 (2)
MISO (18) Busy (11)
SCK (19) Strobe (1)
GND GND (18)

El cable no debe ser más largo que 70cm.  

Software de grabación

El AT90S4433 puede ser programado en C plano con la ayuda de gcc. Saber algo de ensamblador AVR puede ser útil pero no es necesario. La libc AVR viene con una referencia-avr-libc que documenta la mayoría de las funciones. Harald Leitner ha escrito un documento con un montón de ejemplos útiles de cómo usar el AVR y GCC (haraleit.pdf, 286Kb, originalmente desde http://www.avrfreaks.net/AVRGCC/). Desde el sitio web de Atmel, (www.atmel.com, ir a: avr products -> 8 bit risc-> Datasheets), puedes descargar la hoja de datos completa (copia local: avr4433.pdf, 2361Kb) . Describe todos los registros y cómo utilizar la CPU.

Una cosa a tener en mente cuando utilizamos el 4433 es que tiene sólo 128Bytes de RAM y 4K de EEPROM. Eso quiere decir que no tienes que declarar estructuras o cadenas largas. Tu programa no debe usar llamadas jerarquizadas profundamente o recursión. Escribir una línea como
char string[90];
será ya demasiado. Un entero es de 16 bit. Si necesitas un entero corto entonces usa
unsigned char i; /* 0-255 */

No obstante te sorprenderás de lo grandes que puedes escribir los programas. ¡Es un procesador realmente potente!

Mucho mejor que toda la teoría es un ejemplo real. Escribiremos un programa que hace brillar nuestro LED a intervalos de 0,5 segundos. No muy útil pero es bueno para empezar a probar el entorno de desarrollo y el programador.

void main(void)
{
      /* enable PD5 as output */
      sbi(DDRD,PD5);
      while (1) {
            /* led on, pin=0 */
            cbi(PORTD,PD5);
            delay_ms(500);
            /* set output to 5V, LED off */
            sbi(PORTD,PD5);
            delay_ms(500);
      }
}

El código anterior muestra lo simple que es escribir un programa. Ves únicamente el programa principal. La función delay_ms está incluída en el  listado completo (avrledtest.c). Para usar la patilla PD5 como salida necesitas ajustar el bit PD5 en el registro de dirección de datos del puerto D (DDRD). Después de eso puedes ajustar PD5 a 0V con la función cbi(PORTD, PD5) (clear bit PD5), o a 5V con sbi(PORTD, PD5) (set bit PD5).
El valor de "PD5" está definido en io4455.h que es incluído por io.h. No debes ovidar esto. Si ya tienes escritos programas para sistemas multiusuario/multitarea como Linux sabes que uno nunca debe programar un bucle sin fin no bloqueante. Esto malgastará tiempo de CPU y ralentizará el sistema mucho. En el caso del AVR esto es diferente. No tenemos varias tareas y no hay otro proceso ejecutándose. No hay siquiera un sistema operativo. Es por lo tanto perfectamente normal un bucle ocupado para siempre.  

Compilando y cargando

Antes de que empieces debes asegurarte de que tiene /usr/local/atmel/bin in el PATH. Si es necesario edita tu .bash_profile o .tcshrc y añade:

export PATH=/usr/local/atmel/bin:${PATH} (for bash)
setenv PATH /usr/local/atmel/bin:${PATH} (for tcsh)

Utilizamos el puerto paralelo y uisp para programar el AVR. uisp utiliza la interfaz ppdev del kernel. Por lo tanto necesitas tener cargados los siguientes módulo del kernel:

# /sbin/lsmod
parport_pc
ppdev
parport

Comprueba con el comando /sbin/lsmod que están cargados o en caso contrario cárgalos (como root) con

modprobe parport
modprobe parport_pc
modprobe ppdev

Es una buena idea ejecutar estos comandos automáticamente durante el arranque. Puedes añadirlos a un script rc (p.e. para RedHat /etc/rc.d/rc.local).
Para utilizar el interfaz ppdev como usuario normal el administrador necesita escribir los permisos ejecutando una única vez el comando

chmod 666 /dev/parport0

Asegúrate también de que no está ejecutándose ningún duende del puerto paralelo. Si tienes uno ejecutándose entonces detenlo antes de conectar el cable del programador. Ahora está todo listo para compilar y programar nuestro Microcontrolador.

El paquete de nuestro programa de prueba (avrledtest-0.1.tar.gz) incluye un Makefile. Todo lo que necesitas hacer es teclear:
make
make load
Esto compilará y cargará el software. No abordaremos los detalles de todos lo comandos. Puedes verlos en el  Makefile y son siempre los mismos. Yo mismo no puedo recordarlos todos. Sólo sé que necesito usar "make load". Si  quieres escribir un programa diferente entonces sólo reemplaza todas las coincidencias  de avrledtest del Makefiele con el nombre de tu programa.  

Algunas binutils interesantes

Más interesantes que el proceso real de la compilación son algunas de las binutils.

avr-objdump -h avrledtest.out

Muestra el tamaño de las diferentes secciones de tu programa. .text es el código de instrucciones y carga en la flash EEPROM. .data es los datos iniciados como
static char str[]="hello";
y .bss son los datos globales sin iniciar. Ambos son cero en nuestro caso. El .eeprom es para varianles alojadas en la eeprom. Nunca le ha dado uso a esto. stab y stabstr es la información de depuración y no se construirá en el AVR.
avrledtest.out:     file format elf32-avr

Sections:
Idx Name Size VMA LMA File off Algn
0 .text 0000008c 00000000 00000000 00000094 2**0
CONTENTS, ALLOC, LOAD, READONLY, CODE
1 .data 00000000 00800060 0000008c 00000120 2**0
CONTENTS, ALLOC, LOAD, DATA
2 .bss 00000000 00800060 0000008c 00000120 2**0
ALLOC
3 .eeprom 00000000 00810000 00810000 00000120 2**0
CONTENTS
4 .stab 00000750 00000000 00000000 00000120 2**2
CONTENTS, READONLY, DEBUGGING
5 .stabstr 000005f4 00000000 00000000 00000870 2**0
CONTENTS, READONLY, DEBUGGING
Puedes usar también el comando avr-size para obtener esto de una manera más comprimida:

avr-size avrledtest.out

   text    data     bss     dec     hex filename
140 0 0 140 8c avrledtest.out
Cuando se trabaja con el AVR necesitas supervisar que text+data+bss no es mayor de 4k y data+bss+stack (no puedes ver el tamaño de la pila, depente de cuántas llamadas a funciones jerarquizadas tienes) no debe ser de más de 128 Bytes.

También es interesante el comando

avr-objdump -S avrledtest.out

Generará un listado en ensamblador de tu código.  

Conclusión

Ahora sabes lo suficiente para comenzar tus propios proyectos con el hardware AVR y GCC. También habrá otros artículos en LinuxFocus con hardware más complejo e interesante.  

Referencias

 

Formulario de "talkback" para este artículo

Cada artículo tiene su propia página de "talkback". A través de esa página puedes enviar un comentario o consultar los comentarios de otros lectores
 Ir a la página de "talkback" 

<--, regresar al índice de este número

Contactar con el equipo de LinuFocus
© Guido Socher, FDL
LinuxFocus.org
Información sobre la traducción:
en --> -- : Guido Socher (homepage)
en --> es: Daniel Serrano Izquierdo, Lydia López Sánchez <Daniel_S_I/at/teleline.es, enelatico/at/iespana.es>

2004-06-23, generated by lfparser version 2.43