You are on page 1of 26

__________________________________________________________________________ITSP

Directivas y Software del AVR Studio

4.1 DIRECTIVAS Y EXPRESIONES DEL ENSAMBLADOR AVR


STUDIO

Directivas del Ensamblador

La Directivas en el Ensamblador se ajustan al código del usuario. Por ejemplo, podrás


cambiar la localidad del código en la memoria del programa, asignando etiquetas que
direccionan a la SRAM o definir los valores de las constantes. “.macro” es también una
directiva en el ensamblador. Las directivas del ensamblador se pueden dividir dentro de
los siguientes grupos:

Directivas de la Memoria Programa

.cseg

"Segmento de Código"; esta directiva le dice al ensamblador que el siguiente código o


expresiones deberán colocarse en la memoria de programa. Esto es necesario cuando
la directiva .dseg se usa para declarar constantes y datos.

Sintaxis:

.cseg

.db

"Byte de Datos"; con esta directiva podrás colocar valores de las constantes en la
memoria de programa en una dirección conocida, por ejemplo, números seriados,
cadenas para un menú, tablas. Ellos son tratados como bytes y deberán estar dentro de
un rango de 8 bits. Casi todas las expresiones utilizan la directiva .db.

Cada directiva .db se colocara al inicio de una nueva palabra en la memoria de


programa. Así, dos directivas .db de un solo byte como argumento usaran dos palabras,
mientras que una directiva .db con dos bytes como argumentos usaran solamente una
palabra. Ver el ejemplo siguiente:

Sintaxis:

.db expresión1,expresión2,expresión3, ...

Documento traducido de la pagina AVRfreaks.net 1


__________________________________________________________________________ITSP

Ejemplos:

.org 0x0100 ;colocar en la memoria de programa a partir de la dirección 0x0100


.db 128 ;coloca el numero 128 en el byte bajo de la dirección 0x0100 en memoria de programa
.db low(1000) ;coloca el byte bajo de 1000 en la dirección baja de 0x0101
;coloca 128 en el byte bajo y el byte bajo de 1000 en la dirección alta de la dirección 0x0102 en la
.db 128,low(1000) memoria de programa

Las cadenas pueden ser colocadas en la memoria de programa con solo la directiva
.db:

.db "Hello World!"

Esto rellenará 6 palabras de datos o 12 bytes. Si deseas que a la cadena se le añada


un 0 al final de la misma deberás colocarla así:

.db "Hello World!", 0

.dw

"Palabra de Datos"; la directiva .dw trabaja como la directiva .db, pero se usará una
palabra para cada valor.

.org

.org puede ser usada para establecer el contador de programa a un valor específico.

.org 0x01 es el Vector de Interrupción para una interrupción externa 0 en dispositivos


con una tabla de interrupción de una palabra.

Sintaxis:

.org localidad (es la dirección de la localidad donde se colocaran las tablas de


instrucciones o datos).

Directivas SRAM

.byte

Reserva un número de bytes en el espacio de la SRAM para una etiqueta. Esta


directiva es solamente permitida en segmentos de datos.

Sintaxis:

.byte tamaño

Documento traducido de la pagina AVRfreaks.net 2


__________________________________________________________________________ITSP

array_5: .byte 5 ; array_5 es un segmento de 5 bytes en la SRAM


my_word: .byte 2 ;y es seguida por my_word de dos bytes

.dseg

"Segmento de Datos"; le dice al ensamblador que el siguiente texto es usado para


establecer la SRAM. Para cambiarse al segmento de código de nuevo, use .cseg.

.org

Utilice esta directiva para establecer el contador de la localidad SRAM a un valor


específico dentro de .dseg. Juntos con .byte puedes definir las localidades de la
SRAM en direcciones especificas con un tamaño específico.

Directivas EEPROM

Las directivas EEPROM trabajan justo como las directivas para la memoria de
programa y la SRAM. Los valores pueden ser descargados para almacenarlos en la
EEPROM y las directivas .db y .dw se usan de igual manera.

.db

.dw

.eseg

.org

Directivas de Registros y Constantes

.def

"Definir (registros)"; con esta directiva podrás asignar nombres a los registros para
identificarlos.

Sintaxis:

.def nombre = registro

Ejemplo:

.def temp = r16

.equ

Esta directiva asigna un nombre a una constante la cual no pueda cambiarse después:

.equ max_byte = 255

Documento traducido de la pagina AVRfreaks.net 3


__________________________________________________________________________ITSP

.set

Esta directiva trabaja de forma similar a .def, pero el valor de la etiqueta puede
cambiarse despues:

.set contador = 1

.set contador = 2

.set contador = 1 se le sobreescribe con .set contador = 2.

Directivas de Código

.endm / .endmacro

"Fin de la Macro"; Esta le dice al ensamblador que una macro previamente comenzó y
finalice aquí. Solamente se usa cuando al inicio se tenga la directiva .macro.

.macro

Esta inicia un código de macro.

.include

Incluye archivos (por ejemplo, la definición de archivos para cada AVR) y tiene la
posibilidad de separar código dentro de varios archivos.

Sintaxis:

.include path

Ejemplo:
.include c:\Archivos de programa\Atmel\AVR Tools\AvrAssembler\Appnotes\m32def.inc"
.include "\drv_routines\lcd.inc"

Directivas de Salida del Ensamblador

.device

Esta directiva le dice al ensamblador cual AVR se va a utilizar para el código y se


establecen los parámetros del Simulador AVR Studio.

AT90S1200
ATmega32
ATtiny26

Sintaxis:

.device codigo_del_dispositivo

Documento traducido de la pagina AVRfreaks.net 4


__________________________________________________________________________ITSP

.exit

Le dice al ensamblador cuando detenerse el archivo actual.

Ejemplo:

.def byte_max = 255


.def clock = 8000000
.exit

El valor máximo de un byte es de 255 y algunos dispositivos trabajan a 8 MHz

.list

El ensamblador por default crea un archivo de lista (una combinación de código fuente,
código de operación y constantes). Aunada con .nolist puedes especificar que partes
del archivo se mostraran en el archivo de lista.

.listmac

Esta directiva creara una macro expansión del archivo lista. Por default, solamente se
ve que macro es llamada y que argumentos se usan. Para poder ver que esta pasando
durante la ejecución, para propósitos de debugging.

.nolist

Directiva que detiene la generación del archivo de lista.

Documento traducido de la pagina AVRfreaks.net 5


__________________________________________________________________________ITSP

4.2 INICIALIZANDO EL AVR STUDIO

• Inicialice el programa del AVR Studio 4 dando un clic en:


• Inicio  Todos los Programas  ATMEL AVR Tools  AVR Studio 4
Una vez que dio clic en el programa, se verá una pantalla como esta.

4.3 CREANDO UN PROYECTO NUEVO


En esta sección se creará un programa simple que incremente el valor de uno en los
registros del PUERTO, haciendo un conteo binario.

Para crear un proyecto nuevo, vaya al menú “Project” y selecciona “New Project”. Un
cuadro de dialogo se mostrará como aparece en la siguiente figura. En este cuadro de
dialogo podrás ver dos tipos de proyectos, si deseas realizar un programa en
ensamblador (.asm) elige Atmel AVR Assembler, o de lo contrario si deseas realizar un
programa en Lenguaje C (.c) elige AVR GCC. Se elegirá un programa en ensamblador
y de Project name “led”, pero este puede ser cualquier nombre.

Después tendrás que seleccionar el lugar donde se guardará el proyecto. Este es el


lugar donde el AVR Studio almacenara todos los archivos asociados con este proyecto.
Usa un directorio como el c:\CodeAVR. Si la carpeta no existe, AVR Studio
automáticamente la creará sin ninguna notificación.

Documento traducido de la pagina AVRfreaks.net 6


__________________________________________________________________________ITSP

NOTA: Si c:\CodeAVR ya existe, borrará esta carpeta y su contenido.

Después dando un clic en “Next>>” te llevará a la siguiente pantalla, en donde


preguntará que plataforma para el debugger y que dispositivo utilizaras. Deberás elegir
AVR Simulator y el Dispositivo Atmega32.

Documento traducido de la pagina AVRfreaks.net 7


__________________________________________________________________________ITSP

Después de dar un clic en “Finish”, el administrador de proyectos te mostrará una figura


como la siguiente. En esta vista, se verán todos los archivos asociados con el proyecto,
los cuales estarán vacíos en este momento.

Editando el Archivo en Ensamblador

El próximo paso es llenar el archivo vacío led.asm. Abra el archivo led.asm dando
doble clic en él en la ventana de proyectos. El cursor se coloca al inicio del archivo
vacío y tendrás que insertar el siguiente código o simplemente Copiarlo y Pegarlo
directamente donde se encuentra la ventana de edición.

;**************************************************************
.include "m32def.inc" ;Incluir este archivo para el ATMega32
rjmp RESET ;Saltar a la etiqueta Reset
;**************************************************************

RESET:
.def temp =r16 ;Definir al registro 16 como temp

ldi temp,low(RAMEND) ;Cargar parte baja del fin de la RAM


out SPL,temp ;en temp, y despues al stack
ldi temp,high(RAMEND) ;Cargar parte alta del fin de la RAM
out SPH,temp ;en temp, y despues al stack
;Inicializar el Apuntador de Pila

ser temp ;Colocar a unos el registro 16 = temp


out DDRB,temp ;Colocar PuertoB como salida en DDRB
loop: ;Etiqueta del lazo
out PORTB,temp ;Sacar al PuertoB el dato de temp
inc temp ;Incrementar temp
rjmp loop ;Saltar a loop

Documento traducido de la pagina AVRfreaks.net 8


__________________________________________________________________________ITSP

La ventana del editor deberá mostrarse como en la siguiente figura:

Ensamblado del Código Fuente

Este ejemplo requiere que el archivo m32def.inc sea insertado en la carpeta


c:\CodeAVR\. Este archivo contiene las definiciones necesarias para el ensamblado
del microcontrolador ATmega32. Extrae y copia el archivo m32def.inc de la dirección:
C:\Archivosdeprograma\Atmel\AVRTools\AvrAssembler\Appnotes en la
dirección de la carpeta en c:\CodeAVR\led\.

El próximo paso ahora es ensamblar el archivo. Esto se realiza seleccionando “Build”


del menú Build, o simplemente presionando <F7>.

Documento traducido de la pagina AVRfreaks.net 9


__________________________________________________________________________ITSP

La ventana de Salida ahora mostrará información del ensamblado. Haciendo referencia


a la cantidad de bytes usados para el código, datos y eeprom. De esta ventana
podemos ver que solo el área de código esta siendo usada solo por 20 bytes del
programa, siendo menos del 0.1% lo utilizado, además de que el ensamblado fue
completado sin errores.

Documento traducido de la pagina AVRfreaks.net 10


__________________________________________________________________________ITSP

Añadiendo un archivo ASM

Ahora añadiremos un archivo en ensamblador al proyecto. Esto con la finalidad de usar


el mismo proyecto ya configurado para ATmega32 con otros archivos para el mismo
microcontrolador. Se ilustra en las figuras de abajo como se puede realizar:

• Si deseas añadir un archivo existente al proyecto, da un clic con el botón derecho


en “Source Files” y selecciona “Add File to Project”. Se abrirá un cuadro de
dialogo, navega hacia la carpeta donde se encuentra el archivo deseado,
seleccionalo y añádelo dando un clic en el botón “Abrir”.

Documento traducido de la pagina AVRfreaks.net 11


__________________________________________________________________________ITSP

Para poder ensamblar el archivo recientemente insertado deberás colocarlo como


archivo de entrada. Esto se realiza dando un clic en el archivo insertado con el botón
derecho y seleccionando “Set As Entry File”.

Documento traducido de la pagina AVRfreaks.net 12


__________________________________________________________________________ITSP

El archivo nuevo automáticamente se marcara como “Archivo de entrada en


Ensamblador”. Esto indica que el ensamblador iniciara con este archivo cuando se
ensamble el proyecto. El fólder de los archivos a ensamblar solamente contendrá un
solo archivo marcado. El archivo actual de entrada se indica con una flecha roja en el
icono.

Ahora haremos correr el código en el simulador.

Documento traducido de la pagina AVRfreaks.net 13


__________________________________________________________________________ITSP

4.4 SIMULACIÓN DEL CÓDIGO


En este punto hemos generado un archivo para poder simular el código. Si desea correr
un código, seleccione “Build and Run” del menú Build o simplemente presione
<Ctrl+F7>.

Apuntador de Instrucción

Ahora analizaremos el editor, veras una flecha amarilla que aparece al margen
izquierdo del código. Esta flecha indica la posición del contador de programa. En otras
palabras, apunta a la siguiente instrucción a ser ejecutada. Lo que debemos hacer
ahora es ver las líneas de entrada salida para visualizar que esta pasando en los
registros del Puerto B, durante la ejecución del programa.

Documento traducido de la pagina AVRfreaks.net 14


__________________________________________________________________________ITSP

Estableciendo la visualización a IO

Abra la ventana de IO seleccionando la pestaña "IO” del menu "View"”Toolbars”. Ya


que hemos seleccionado el ATmega32 durante las opciones del simulador
estableciendo la visualización de IO se abrirá automáticamente.

NOTA: Si ya esta marcada con una √ ya no es necesario el paso anterior.

La ventana de IO se utiliza para inspeccionar y modificar los contenidos de los registros


de I/O en la ejecución. La configuración estándar te da una vista rápida del hardware
con la habilidad para expandir los símbolos particulares para mayor información.

Documento traducido de la pagina AVRfreaks.net 15


__________________________________________________________________________ITSP

Abra el Puerto B dando dos clics en el icono del puerto. Ahora se expandirá y se
mostraran todos los registros asociados con el Puerto B, estos son: Registro de Datos
del Puerto B (PORT B), la Dirección de Datos (DDRB) y los Pines de Entrada (PINB).
Como se muestra cada bit en los registros se representan por un cuadro de chequeo.
Un “cero” lógico (0) se representa por el cuadro de chequeo sin marca y un “uno” lógico
(1) se representa por el cuadro de chequeo con una marca. Estos cuadros de chequeo
serán actualizados durante la ejecución del programa, y muestran el estado actual de
cada bit. También podrás colocar un uno o limpiar estos bits dando un clic en el cuadro
de chequeo apropiado en cualquier tiempo durante la ejecución del programa.

Documento traducido de la pagina AVRfreaks.net 16


__________________________________________________________________________ITSP

Programa paso a paso

Existen dos comandos para correr el código paso a paso. Son "Step Over" <F10> y
"Trace Into" <F11>. La diferencia entre estos dos comandos es que <F10> no entra
dentro de las subrutinas. Ya que en nuestro ejemplo no contiene ninguna subrutina, no
habrá diferencia entre la operación de estos comandos en este ejemplo.

Ahora ejecutando paso a paso hasta la ultima línea del código (rjmp loop)
presionando repetidamente <F11> o seleccionando "Trace Into" del menú "Debug".
Note como el color cambia de negro a rojo en los registros donde cambia el valor. Esto
hace más fácil identificar cuales registros cambian los valores en cada instrucción.
Continua presionando <F11> y se vera como el valor binario del Puerto B se
incrementa.

Documento traducido de la pagina AVRfreaks.net 17


__________________________________________________________________________ITSP

Colocando Breakpoints

Los breakpoints son un método para detener el flujo de la ejecución. Añadiendo en el


código ensamblador, podemos correr el programa a velocidad real, y este se detendrá
en la línea que contenga el breakpoint. Por ahora solo se ha comentado que
presionando <F11> tres veces iras a través del loop una vez. Añadiremos un breakpoint
en la instrucción rjmp loop para mostrarte como se usa para detener el proceso de
debug. Coloca el cursor en la instrucción rjmp loop del código fuente y presiona
<F9> (o en el menú Debug selecciona "Toggle Breakpoint"). Un círculo rojo aparecerá
al margen izquierdo del código fuente como se muestra. Presionando <F5> o "Go" del
menú "Debug" el programa empezara a correr y hará una parada (stop) en la
instrucción que contenga el breakpoint.

Documento traducido de la pagina AVRfreaks.net 18


__________________________________________________________________________ITSP

Modificando el Código

Ahora vamos a programar un conteo descendente. Para hacer este cambio editaremos
el código fuente. Coloca el cursor en la ventana de la fuente, y cambia la instrucción de
inc a dec. Si ahora presionas <F5> (Go) el siguiente cuadro de dialogo aparecerá.
Este cuadro indica que uno de los archivos fuente ha sido cambiado, y el proyecto
deberá recompilarlo. Presione "Yes".

El proyecto ahora se recompilara, y el apuntador de instrucción apuntara al inicio de la


primera línea del código. Note como el breakpoint permanece.

Abriendo la ventana Watch

Abra la ventana Watch seleccionando "Watch" del menu "View".

Documento traducido de la pagina AVRfreaks.net 19


__________________________________________________________________________ITSP

Las variables que son definidas (por la directiva .def) pueden ser colocadas en la
ventana Watch. La única variable definida en este código es la variable temp. De un clic
con el botón derecho y la ventana "Watches" se abrirá, seleccione "Add Watch". Teclee
en el nombre de la variable temp y presione Enter. Como se continúa con la ejecución
del programa, la variable temp constantemente se actualizara durante la ejecución del
programa.

Ajustando la información del Procesador

Ahora ajustaremos la información del Procesador. Abra esta información dando un clic
en "Processor" dentro de la ventana de “IO” del menú "View".

Documento traducido de la pagina AVRfreaks.net 20


__________________________________________________________________________ITSP

Dentro de la información que muestra el procesador especifica el registro de Banderas


de estado y el actual valor de los diferentes apuntadores. Aquí también encontraras el
contador de ciclos y la ventana de Stop. Estas ventanas son útiles si deseas medir la
longitud de un lazo o cuanto tiempo utiliza una subrutina especifica. No utilizaremos
esta información directamente en este ejemplo, pero provee mucha información durante
el debugging de un proyecto.

Salvando el Proyecto

En el AVR Studio para salvar el proyecto selecciona "Save" del menú "Project".

4.5 GRABANDO EL ARCHIVO EN EL MEGA32


Cuando se ha finalizado la simulación del programa, y el programa ya este funcionando
sin errores de programación, entonces se requiere que este sea descargado al mega32
usando el AVR Studio.

Primeramente se necesita que el AVR Studio genere como archivo con formato de
salida en HEX. Para hacer esto, se necesita generar "Intel Hex Format Output". Así que
en el menú “Project” das un clic en “Assembler Options”.

Documento traducido de la pagina AVRfreaks.net 21


__________________________________________________________________________ITSP

Después de dar un clic en “Assembler Options” se genera la siguiente ventana.

En la opción “Hex Output Format”, deberá asegurarse de que se encuentre la opción


“Intel intellec 8/MDS (Intel hex), en la Opción “Output File” se marca la casilla “Entry
File” y en la opción “AVR Assembler”, se marca la casilla “Versión 2”. Después OK.

Documento traducido de la pagina AVRfreaks.net 22


__________________________________________________________________________ITSP

Configurando el Convertidor de USB a Serial.

Asegúrese de que el mega32 este insertado en la tarjeta programadora, así como


también se encuentre alimentado con su adaptador de CA/CD.

Inserte por el puerto serial la interfase Serial y a su puerto de su PC la interfase USB,


una vez insertada la terminal, su computadora le pedirá que instale los controladores
USB-Serial, para esto tendrá que tener a la mano su disco de instalación. Ejecútelo. Y
espere la ventana de haber instalado su “driver” correctamente.

Ahora abra el Panel de control en Sistema, y dando un clic en la pestaña Hardware abra
el Administrador de dispositivos.

Revise los puertos (COM & LPT), y de un clic en la cruz (+), esta se abrirá mostrando
algo como la siguiente ventana.

Documento traducido de la pagina AVRfreaks.net 23


__________________________________________________________________________ITSP

Dando dos clics en USB-SERIAL CH430, se abrirá una ventana como la siguiente.

Diríjase a la pestaña de “Configuración de puerto”, y aparecerá una ventana como esta.

Documento traducido de la pagina AVRfreaks.net 24


__________________________________________________________________________ITSP

De un clic en “Opciones avanzadas” y aparecerá la siguiente ventana. En la casilla de


“Número de puerto COM:” asegúrese de que seleccione un puerto que se encuentre
libre como COM1, COM2, COM3 o COM4. Ya que el AVR Studio solamente verifica
estos 4 puertos por si está alguna tarjeta grabadora de avrs1, en un puerto USB.

De Aceptar, Aceptar, Archivo Salir y Aceptar. Y Listo tu computadora ya está


configurada para conectarse con la tarjeta grabadora de AVRs.

Diríjase al AVR Studio y en el menú “Tools” seleccione “AVR Prog…”.

Documento traducido de la pagina AVRfreaks.net 25


__________________________________________________________________________ITSP

Aparecerá la siguiente ventana para descargar el programa en HEX, desde el AVR


Studio.

En la opción “Hex File“ busque el archivo en hexadecimal del programa a grabar. En la


opción “Device” seleccione el ATmega32 como microcontrolador a grabarse.

De un clik en “Program” de la pestaña “flash”, para grabar el archivo en la memoria flash


del Mega32 o en su defecto en “Program” de la pestaña “EEPROM” para grabar el
archivo en la memoria “EEPROM”.

NOTA: La tarjeta grabadora deberá estar alimentada con el adaptador de CA/CD.

1
http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&p=432640

http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=36947&postdays=0&postorder=asc&start=20

Documento traducido de la pagina AVRfreaks.net 26