![[Photo of the Author]](../../common/images/Guido-S.gif)
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]](../../common/images/article231/illustration.jpg)
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]](../../common/images/article231/schematic.gif)
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]](../../common/images/article231/avr4433.jpg) |
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]](../../common/images/article231/14pinicsocket.jpg) |
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]](../../common/images/article231/resistor_crystal_capacitor.jpg) |
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]](../../common/images/article231/connector.jpg) |
Cualquier tipo de conector/zólocalo de 5 patillas para
el programador. Normalmente compro estas tiras y corto 5 de ellos. |
![[matrix board]](../../common/images/article231/board.jpg) |
Placa perforada. |
![[db25]](../../common/images/article231/db25male.jpg)
|
1 x conector DB25 para conectar al puerto paralelo. |
![[led]](../../common/images/article231/led.jpg) |
1 x LED |
![[beardboard]](../../common/images/article231/breadboard.jpg) |
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]](../../common/images/article231/pcable.jpg)
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
<--, regresar al índice de este número
2004-06-23, generated by lfparser version 2.43
![[LinuxFocus-icon]](../../common/images/logolftop_319x45.gif){kind=small}
