Directivas de Ensamblador

Directivas de ensambladorDirectriz Descripción

BYTE Reserva byte (s) a una variable.

CSEG Segmento de Código

CSEGSIZE Tamaño de la memoria de programa

DB Definir byte constante (s)

DEF Definir un nombre simbólico en un registro

DSEG Segmento de datos

DW Definir palabra Constante (s)

ENDM, ENDMAKRO Endmacro

EQU Establecer un símbolo igual a una expresión

ESEG Segmento EEPROM

SALIDA Salir de archivo

CONTENER Leer fuente de otro archivo

LISTA Gire generación listfile en

LISTMAC Gire a la expansión de macros en el archivo de lista de

MACRO Comience Macro

NOLIST Gire generación listfile off

ORG Origen Set programa

SET Establecer un símbolo de una expresión

ELSE, ELIF Ensamblaje condicional

TERMINARA SI Ensamblaje condicional

ERROR Emite un mensaje de error

SI, IFDEF, IFNDEF Ensamblaje condicional

MENSAJE Devuelve una cadena de mensaje

DD Definir palabra doble

DQ Definir palabra cuádruple

UNDEF Símbolo registro undefine

ADVERTENCIA Emite un mensaje de advertencia

OVERLAP / NOOVERLAP Establecer sección superposición

NotaTenga en cuenta que todas las directivas deben ir precedidos por un punto.

BYTE - reserva de bytes para una variable

Los recursos de las reservas directiva BYTE memoria en la SRAM o EEPROM. Con el fin de ser capaz de hacer referencia a la ubicación reservada, la directiva BYTE debe ir precedida de una etiqueta. La directiva toma un parámetro, que es el número de bytes para reservar. La directiva no se puede utilizar dentro de un segmento de código (ver directivas ESEG, CSEG, DSEG) .Nota que se debe dar un parámetro. No se inicializan Los bytes asignados.Sintaxis:ETIQUETA: expresión .BYTEEjemplo:

.DSEG var1: .BYTE 1; reservar 1 byte a var1tabla: tab_size .BYTE; bytes tab_size reserva

.CSEG r30 LDI, baja (Q1); Cargar Z registro bajor31 LDI, alta (Q1); Cargar Z registro de altar1 ld, Z; Cargar VAR1 en el registro 1

Segmento de código - CSEG

La directiva CSEG define el inicio de un segmento de código. Un archivo de ensamblador puede consistir en varios segmentos de código, que se concatenan en un solo segmento de código cuando se ensamblan. La directiva BYTE no se puede utilizar dentro de un segmento de código. El tipo de segmento por defecto es Código. Los segmentos de código tienen su propio contador de ubicación que es un contador de palabras. La directiva ORG se puede utilizar para colocar código y constantes en ubicaciones específicas en la memoria de programa. La directiva no toma ningún parámetro.Sintaxis:.CSEGEjemplo:

.DSEG; Comience segmento de datosvartab: .BYTE 4; Reserva 4 bytes de SRAM

.CSEG; Comience segmento de códigoconst: .DW 2; Escribe 0x0002 en prog.mem.mov r1, r0; Hacer algo

CSEGSIZE - memoria del programa Tamaño

AT94K dispositivos tienen una partición de memoria de usuario configurable entre la memoria del programa AVR y la memoria de datos. El programa y los datos SRAM se divide en tres bloques: 10K x 16 dedicado SRAM programa, 4K x 8 dedicado SRAM de datos, y 6K x 16 o 12K x 8 SRAM configurable que pueden ser intercambiadas entre el programa y memoria de datos espacios en 2K x 16 o 4K x 8 particiones. Esta directiva se utiliza para especificar el tamaño del bloque de memoria de programa.Sintaxis:.CSEGSIZE = 10 | 12 | 14 | 16Ejemplo:

.CSEGSIZE = 12; Especifica el tamaño meory programa 12K x 16

DB - Definir byte constante (s) en la memoria de programa y EEPROM

Los recursos reservas directivas de memoria DB en la memoria de programa o en la memoria EEPROM. Con el fin de ser capaz de referirse a los lugares reservados, la directiva DB debe ir precedida de una etiqueta.La directiva DB toma una lista de expresiones, y debe contener al menos una expresión. La directiva DB debe ser colocado en un segmento de código o un segmento EEPROM.La lista de expresión es una secuencia de expresiones, delimitado por comas. Cada expresión debe evaluar a un número entre -128 y 255. Si la expresión se evalúa como un número negativo, los 8 bits complemento a dos del número se colocarán en la posición de memoria de programa o memoria EEPROM.Si la directiva DB se da en un segmento de código y el ExpressionList contiene más de una expresión, las expresiones se empaquetan de modo que dos bytes se colocan en cada palabra de memoria de programa. Si el ExpressionList contiene un número impar de expresiones, la última expresión será colocado en una palabra de memoria de programa propio, incluso si la línea siguiente en el código assemby contiene una directiva DB. El medio no utilizado de la palabra programa se pone a cero. Una advertencia se da, con el fin de notificar al usuario que un byte adicional cero se añade el comunicado .DBSintaxis:ETIQUETA: .DB ExpressionListEjemplo:

.CSEG consts: .DB 0, 255, 0b01010101, -128, 0xAA

.ESEG const2: .DB 1,2,3

DEF - Establezca un nombre simbólico en un registro

La directiva DEF permite que los registros para ser remitidos a través de símbolos. Un símbolo definido se puede utilizar en el resto del programa para hacer referencia al registro que está asignado. Un registro puede tener varios nombres simbólicos que se le atribuye. Un símbolo puede ser redefinido más tarde en el programa.Sintaxis:.def Símbolo = RegistroEjemplo:

.def Temp = R16

.def Ior = R0

.CSEG temp LDI, 0xF0; Cargar 0xF0 en el registro de temperaturaen ior, 0x3f; Leer SREG en ior registroeo temp, ior; Exclusiva o temporal y ior

UNDEF - undefine un nombre simbólico registro

"La directiva UNDEF se utiliza quitar la definición de un símbolo previamente definido con el DEF Directiva. Esto proporciona una forma sencilla de obtener una determinación del alcance de las definiciones de registro, para evitar las advertencias sobre reutilización registro.Sintaxis:Símbolo .UNDEFEjemplo:

.def Var1 = R16 LDI var1, 0x20 ...; hacer algo más con var1

.UNDEF Var1

.def Var2 = R16; R16 ahora puede ser reutilizado sin previo aviso.

DSEG - segmento de datos

La directiva DSEG define el inicio de un segmento de datos. Un archivo de fuente en ensamblador puede consistir en varios segmentos de datos, que se concatenan en un solo segmento de datos cuando se ensamblan. Un segmento de datos será normalmente sólo constará de directivas BYTE (y etiquetas). Los segmentos de datos tienen su propio contador de ubicación que es un contador de bytes. La directiva ORG se puede utilizar para colocar las variables en ubicaciones específicas en la SRAM. La directiva no toma ningún parámetro.Sintaxis:.DSEGEjemplo:

.DSEG; Comience segmento de datosvar1: .BYTE 1; reservar 1 byte a var1tabla: tab_size .BYTE; reserva tab_size bytes.

.CSEG r30 LDI, baja (Q1); Cargar Z registro bajor31 LDI, alta (Q1); Cargar Z registro de altar1 ld, Z; Cargar var1 en el registro 1

DW - Definir la palabra constante (s) en la memoria de programa y EEPROM

Los recursos reservas directivas de memoria DW en la memoria de programa o en la memoria EEPROM. Con el fin de ser capaz de referirse a los lugares reservados, la directiva DW debe ir precedida de una etiqueta. La directiva DW toma una lista de expresiones, y debe contener al menos una expresión. La directiva DB debe ser colocado en un segmento de código o un segmento EEPROM.La lista de expresión es una secuencia de expresiones, delimitado por comas. Cada expresión debe evaluar a un número entre -32768 y 65535. Si la expresión se evalúa como un número negativo, los 16 bits complemento de la serie de dos llegarán a ser colocado en la memoria de programa o ubicación de la memoria EEPROM.Sintaxis:ETIQUETA: .DW ExpressionListEjemplo:

.CSEG varlist: .DW 0, 0xffff, 0b1001110001010101, -32.768, 65.535

.ESEG eevarlst: .DW 0,0xffff, 10

DD - Definir doubleword constante (s) en la memoria de programa y EEPROM

DQ - Definir palabra cuádruple constante (s) en la memoria de programa y EEPROM

Estas directrices son muy similares a la DW Directiva, excepto que se utilizan para definir 32 bits (palabra doble) y 64 bits (palabra cuádruple), respectivamente. La disposición de los datos en la memoria es estrictamente little-endian.Sintaxis:ETIQUETA: .Dd ExpressionListETIQUETA: .DQ ExpressionListEjemplo:

.CSEG varlist: .Dd 0, 0xfadebabe, -2147483648, 1 << 30

.ESEG eevarlst: 0,0xfadebabedeadbeef .DQ, 1 << 62

> ELIF, ELSE - ensamblaje condicional

.ELIF Incluirá código hasta el ENDIF correspondiente de la siguiente ELIF al mismo nivel si la expresión es verdadera, y tanto la cláusula .IF inicial y todas las siguientes cláusulas .ELIF son falsas..ELSE Incluirá código hasta el .endif correspondiente si la cláusula initial.IF y todas las cláusulas .ELIF (en su caso) todos son falsos.Sintaxis:.ELIF <Expresión>.ELSE.IFDEF Símbolo <> | .IFNDEF <símbolo>....ELSE | .ELIF <Expresión>....TERMINARA SIEjemplo:

.IFDEF DEBUG

.message "Depuración .."

.ELSE

.message "Release .."

.TERMINARA SI

ENDIF - ensamblaje condicional

Ensamblaje condicional incluye un conjunto de comandos en el tiempo de montaje. La directiva ENDIF define el final para el SI condicional o IFDEF o ifndef directivas.Condicionales (.IF ... ELIF ... ELSE ... ENDIF bloques) se pueden anidar, pero todos los condicionales deben terminar al final del archivo (condicionales no pueden abarcar varios archivos).Sintaxis:.TERMINARA SI.IFDEF Símbolo <> | .IFNDEF <símbolo>....ELSE | .ELIF <Expresión>....TERMINARA SIEjemplo:

.IFNDEF DEBUG

.message "Release .."

.ELSE

.message "Depuración .."

.TERMINARA SI

ENDM, ENDMAKRO - Fin macro

La directiva ENDMAKRO define el final de una definición de macro. La directiva no toma ningún parámetro. Ver la directiva MACRO para obtener más información sobre la definición de macros. ENDM es una forma alternativa, totalmente equivalentes con ENDMAKRO.Sintaxis:.ENDMACRO.ENDMEjemplo:

.MACRO SUBI16; Comience macro definiciónsubi r16, bajo (@ 0); Byte bajo Rester17 SBCI, alta (@ 0); Byte alto Reste.ENDMACRO

EQU - Establecer un símbolo igual a una expresión

La directiva EQU asigna un valor a una etiqueta. Esta etiqueta se puede utilizar en expresiones posteriores. Una etiqueta asignada a un valor por la directiva EQU es una constante y no puede ser modificado o redefinido.Sintaxis:Etiqueta .equ = expresiónEjemplo:

.equ Io_offset = 0x23

.equ Porta = io_offset + 2.CSEG; Comience segmento de códigoclr r2; Registro Claro 2porta cabo, r2; Escriba a Puerto A

ERRORES Emite una cadena de mensajes de error

La directiva ERROR da salida a una cuerda y se detiene el montaje. Puede ser utilizado en el montaje condicional.Sintaxis:.ERROR "<Cadena>"Ejemplo:

.IFDEF TOBEDONE

.ERROR "Still cosas que hacer .."

.TERMINARA SI

ADVERTENCIA - Emite una cadena de mensaje de alerta

La directiva .WARNING emite una cadena de advertencia, pero a diferencia de la Directiva .ERROR no detiene el montaje. Puede ser utilizado en el montaje condicional.Sintaxis:.WARNING "<Cadena>"

Ejemplo:

.IFDEF EXPERIMENTAL_FEATURE

.WARNING "Esto no está bien probado, utilice por cuenta y riesgo."

.TERMINARA SI

ESEG - Segmento EEPROM

La directiva ESEG define el inicio de un segmento EEPROM. Un archivo de fuente en ensamblador puede consistir en varios segmentos de EEPROM, la cual se concatenan en un solo segmento de EEPROM cuando se ensamblan. Un segmento EEPROM normalmente sólo constará de DB y directivas DW (y etiquetas). Los segmentos EEPROM tienen su propio contador de ubicación que es un contador de bytes. La directiva ORG se puede utilizar para colocar las variables en ubicaciones específicas en la EEPROM. La directiva no toma ningún parámetro.Sintaxis:.ESEGEjemplo:

.DSEG; Comience segmento de datosvar1: .BYTE 1; reservar 1 byte a var1tabla: tab_size .BYTE; reserva tab_size bytes.

.ESEG eevar1: .DW 0xffff; inicializar 1 palabra en EEPROM

EXIT - Salir de este archivo

La directiva SALIDA indica al ensamblador que parar de montar el archivo. Normalmente, el ensamblador se prolongará hasta el final del archivo (EOF). Si una directiva SALIR aparece en un archivo incluido, el ensamblador continúa desde la línea que sigue la directiva incluir en el archivo que contiene la directiva INCLUDE.Sintaxis:.SALIDAEjemplo:

.SALIDA ; Salir de este archivo

INCLUYE - Incluir otro archivo

La directiva include le dice al ensamblador para empezar a leer desde un archivo especificado. El ensamblador y luego ensambla el archivo especificado hasta el final del archivo (EOF) o se encuentra una directiva SALIR. Un archivo incluido puede contener en sí CONTENER directivas. La diferencia entre las dos formas es que el primero busca en el directorio actual primero, el segundo no lo hace.Sintaxis:"Nombre de archivo" .include.include <Nombre de archivo>Ejemplo:

; iodefs.asm:.equ SREG = 0x3F; Registro de estado.equ Sphigh = 0x3e; Pila puntero alta.equ Splow = 0x3D; Pila puntero baja

; incdemo.asm

Iodefs.asm .include; Incluir las definiciones de E / Sen r0, SREG; Leer registro de estado

SI, IFDEF, IFNDEF - ensamblaje condicional

Ensamblaje condicional incluye un conjunto de comandos en el tiempo de montaje. La directiva IFDEF incluirá código hasta que la correspondiente directiva else if <símbolo> se define. El símbolo se debe definir con el EQU o directiva SET. (No funciona con la directiva DEF) la Directiva si incluirá código si <expresión> se evalúa diferente de 0. Válido hasta el correspondiente ELSE o directiva ENDIF.Hasta 5 niveles de anidamiento es posible.Sintaxis:.IFDEF <Símbolo>.IFNDEF <Símbolo>.IF <Expresión>.IFDEF Símbolo <> | .IFNDEF <símbolo>....ELSE | .ELIF <Expresión>....TERMINARA SIEjemplo:

.MACRO SET_BAT

.IF @ 0> 0x3F

.message "Dirección mayor que 0x3F" lds @ 2, @ 0 sbr @ 2, (1 << @ 1) pts @ 0, @ 2 .ELSE .message "Dirección menor o igual 0x3F" .TERMINARA SI .ENDMACRO

LISTA - Girar la generación listfile en

La directiva LISTA dice al ensamblador para convertir la generación listfile sucesivamente. El ensamblador genera un listfile que es una combinación de código fuente montaje, direcciones y códigos de operación.Generación listfile está activada de forma predeterminada. La directiva también se puede utilizar junto con la directiva NOLIST con el fin de generar solamente listfile de partes seleccionadas de un archivo de origen de ensamblaje.Sintaxis:.listEjemplo:

.NOLIST; Deshabilitar la generación listfile

.include "Macro.inc"; Los archivos incluidos no lo hará

.include "Const.def"; se muestra en la listfile

.list; Vuelva a activar la generación listfile

LISTMAC - Turn expansión macro en

La directiva LISTMAC dice al ensamblador que cuando una macro se llama, la expansión de la macro se muestra en el listfile generada por el ensamblador. El valor por defecto es que sólo la macro-llamada con parámetros se muestra en el listfile.Sintaxis:

.LISTMACEjemplo:

.MACRO MACX; Definir un ejemplo macroañadir r0, @ 0; Hacer algoeo r1, @ 1; Hacer algo.ENDMACRO; Terminar macro definición

.LISTMAC; Activar la expansión de macros

MACX r2, r1; Llame macro, show de expansión

MACRO - Comience macro

La directiva MACRO le dice al ensamblador que este es el comienzo de una macro. La directiva MACRO toma el nombre de la macro como parámetro. Cuando el nombre de la macro se escribe más adelante en el programa, la definición de macro se expande en el lugar que fue utilizado. Una macro puede tardar hasta 10 parámetros. Estos parámetros se conocen como @ 0- @ 9 dentro de la definición de macros. Al emitir una llamada de macro, los parámetros se dan como una lista separada por comas. La definición de macro se termina por una directiva ENDMAKRO.Por defecto, sólo la llamada a la macro se muestra en la listfile generada por el ensamblador. Con el fin de incluir la expansión de la macro en el listfile, se debe utilizar una directiva LISTMAC. Una macro es marcada con un + en el campo código de operación del listfile.Sintaxis:.MACRO MacronameEjemplo:

.MACRO SUBI16; Comience macro definiciónsubi @ 1, bajo (@ 0); Byte bajo ResteSBCI @ 2, alta (@ 0); Byte alto Reste.ENDMACRO; Terminar macro definición

.CSEG; Comience segmento de códigoSUBI16 0x1234, r16, r17; Sub.0x1234 de r17: r16

MENSAJE - Salida de una cadena de mensaje

La directiva MENSAJE emite una cadena. Útil en el ensamblaje condicional.Sintaxis:.message "<Cadena>"Ejemplo:

.IFDEF DEBUG

.message "Modo de depuración"

.TERMINARA SI

NOLIST - Girar generación listfile off

La directiva NOLIST dice al ensamblador para convertir la generación listfile apagado. El ensamblador normalmente genera una listfile que es una combinación del código fuente montaje, direcciones y códigos de operación. Generación listfile está activada de forma predeterminada, pero se puede desactivar mediante el uso de esta directiva. La directiva también se puede utilizar junto con la directiva LISTA con el fin de generar solamente listfile de partes seleccionadas de un archivo de origen de ensamblaje.Sintaxis:

.NOLISTEjemplo:

.NOLIST; Deshabilitar la generación listfile

.include "Macro.inc"; Los archivos incluidos no lo hará

.include "Const.def"; se muestra en la listfile

.list; Vuelva a activar la generación listfile

Origen programa Set - ORG

La directiva ORG establece el contador de ubicación para un valor absoluto. El valor de establecer se da como un parámetro. Si una directiva ORG se da dentro de un segmento de datos, entonces es el contador de ubicación SRAM que se fija, si la directiva se da dentro de un segmento de código, entonces es el contador de la memoria de programa que se establece y si la directiva se da dentro de un Segmento EEPROM, es el contador de ubicación EEPROM que se fija.Los valores por defecto del Código y los contadores ubicación EEPROM son cero, y el valor por defecto de la barra de ubicación SRAM es la dirección inmediatamente después del final de E / S del espacio de direcciones I (0x60 para dispositivos sin que extendió de E / S, 0x100 o más para dispositivos con extendido de E / S) cuando se inicia el montaje. Tenga en cuenta que los contadores de SRAM y ubicación EEPROM cuentan bytes mientras que el contador de posición de memoria de programa cuenta con palabras. También tenga en cuenta que algunos dispositivos carecen de SRAM y / o EEPROM.Sintaxis:Expresión .ORGEjemplo:

.DSEG; Comience segmento de datos

.ORG 0x120; Establecer dirección SRAM a hexadecimal 120variables: .BYTE 1; Reserve un byte a adr SRAM. 0x120

.CSEG

.ORG 0x10; Establecer contador de programa a hexadecimal 10mov r0, r1; Hacer algo

SET - Establece un símbolo igual a una expresión

La directiva SET asigna un valor a una etiqueta. Esta etiqueta se puede utilizar en expresiones posteriores. A diferencia del EQU Directiva, una etiqueta asignada a un valor por la directiva SET se puede cambiar (redefinido) más tarde en el programa.Sintaxis:Etiqueta .SET = expresiónEjemplo:

.SET FOO = 0x114; establecer FOO para que apunte a una ubicación SRAMlds r0, FOO; ubicación de carga en r0.SET FOO FOO = + 1; incremento (redefinir) FOO. Esto sería ilegal si se utiliza .equlds r1, FOO; cargar próxima ubicación en r1

OVERLAP / NOOVERLAP - Configure la sección superposición

Introducido en AVRASM 2.1. Estas directrices son para proyectos con necesidades especiales y se deben normalmente no se pueden utilizar.Estas directivas sólo afectan el segmento activo actualmente (CSEG / DSEG / ESEG).

Las directivas / nooverlap .overlap marcan una sección que se permitirá a superponerse código / datos con código / datos definidos en otro lugar, sin ningún error o mensajes de advertencia que se generan. Esto es totalmente independiente de lo que se establece mediante los #pragma directivas. El atributo de superposición-permitido permanecerá en efecto a través de directivas .org, pero no va a seguir a través de .cseg / .eseg / .dseg directivas (cada segmento marcado por separado).Sintaxis:.OVERLAP.NOOVERLAPEjemplo:

.overlap

.org 0; sección 1rjmp por defecto .nooverlap .org 0; sección 2rjmp REINICIAR; No hay error dado aquí.org 0; la sección # 3rjmp REINICIAR; Error aquí porque se solapan con # 2

Macros Asamblea

http://www.avr-tutorials.com/projects/avr-microcontroller-based-projects

¿Qué es un Macros?

En la programación de ensamblaje de una macro es básicamente un conjunto de

instrucciones representado por una sola sentencia. Una macro puede ser visto como una

nueva instrucción creado por el programador para el microcontrolador.

Tenga en cuenta sin embargo que esta nueva instrucción (la macro) se crea mediante el

uso de las instrucciones existentes que se proporcionan con el microcontrolador AVR.

El uso de un Macros Asamblea

Digamos que usted quiere inicializar el puntero de pila AVR. Se necesitarían cuatro (4) instrucciones para realizar esta tarea, como se muestra en el código ensamblador AVR continuación. Aquí estamos cargando la última dirección de SRAM en el puntero de pila microcontrolador AVR.

; Inicializar el puntero de pila microcontrolador AVR LDI R16, baja (RAMEND) OUT SPL, R16 LDI R16, alta (RAMEND) OUT SPH, R16

Ahora, en lugar de escribir los cuatro (4) de instrucciones para inicializar el puntero de pila

AVR puede definir una macro, decir LSP, con estas instrucciones y utilizar esta macro

para reemplazar el conjunto de la instrucción como se muestra en el código

ensamblador AVR continuación.

; Inicializar la pila LSP R16, RAMEND

Pasos en escritos macros montaje AVR

Las macros son simples de código, como se muestra en el ejemplo de código a continuación, sólo tienes que seguir los sencillos pasos dados aquí:

1. Todas las definiciones de macros se inicia con la MACRO Directiva ensamblador

seguido por el nombre de la macro en la misma línea. Aquí el nombre de nuestro

macro es LSP.

2. Fíjese en la definición macro por debajo de la @ 0 y @ 1 símbolos. Estos son

marcadores de posición para los argumentos que se pasarán a la macro, @ 0 y @

1 se reemplazan con el primer y segundo argumentos respectivamente. Nota que

también podría tener @ 2, @ 3 y así sucesivamente.

3. Utilice la ENDMAKRO Directiva ensamblador AVR para poner fin a la definición de

la macro.

. MACRO LSP LDI @ 0, baja (@ 1) OUT SPL, @ 0 LDI @ 0, alta (@ 1) OUT SPH, @ 0. ENDMAKRO

Una vez que haya definido su macro se puede utilizar como cualquier otra de las

instrucciones de microcontroladores AVR. A continuación se muestra como se puede

utilizar la macro simplemente definir arriba.Nótese aquí que @ 0 y @ 1 será sustituido

por R16 y RAMEND, respectivamente, en la definición de la macro.

LSP R16, RAMEND

AVR Tutoriales espera este tutorial montaje sobre escribiendo macros montaje AVR fue

beneficioso para usted y espera con interés sus continuas visitas para todas sus

necesidades de tutoría microcontrolador.

El reloj ATmega16 LCD Digital

En este proyecto ATmega16 AVR estaremos diseñando e implementando un reloj digital con la ayuda de un microcontrolador Atmel AVR ATmega16 y una pantalla de cristal líquido alfanumérico (LCD). Nota: Aunque este proyecto AVR fue diseñado alrededor del ATmega16 el proyecto podría haber utilizado otra microcontrolador tal como un ATmega32, ATMega8515, etc. ATmega16 LCD Operación Reloj Digital Nuestro reloj digital funciona como sigue. Cuando el circuito se enciende el reloj comienza a "00:00:00" para "HH: MM: SS". Hay dos pulsadores utilizados para ajustar la hora. Interruptor SW1 se utiliza para configurar los minutos, al pulsar este botón los minutos en aumento hasta llegar a 59 y luego restablecer y empezar a contar desde 0. Interruptor SW2 es para establecer las horas.

ATmega16 LCD Reloj Digital Descripción del hardware

La figura a continuación da el diagrama de circuito para la pantalla LCD Reloj Digital ATmega16.

Nota Importante: Para que nuestro reloj digital para que funcione correctamente el

oscilador interno del microcontrolador ATmega16 AVR debe estar habilitado y se puso a 4

MHz.

Software ATmega16 LCD Reloj Digital

A continuación se muestra la ejecución AVR C de todo el código para el reloj digital LCD basada ATmega16. El código fue implementado y construido con AVR Studio 5. Recuérdese que el reloj interno del microcontrolador ATmega16 debe estar habilitado y programado para funcionar a 4 MHz para el código AVR C para funcionar

correctamente. Un video del reloj digital LCD en la operación se presenta al final de esta página.

/ * * LCD-Digital-Clock.c * * Escrito en AVR Studio 5 * Compilador: AVR GNU C Compiler (GCC) * * Creado: 12/22/2011 6:34:36 PM * Autor: AVR Tutoriales * Sitio web: www.AVR-Tutorials.com * / #define F_CPU 4000000UL #include <avr / delay.h> #include <avr / io.h> #include <string.h> #include <avr / interrupt.h> / * Variables globales Declaraciones * / unsigned Char horas = 0; sin firmar Char minutos = 0; sin firmar Char segundo = 0; Char tiempo [] = "00:00:00"; / * Declaraciones de funciones LCD */ void LCD_send_command ( unsigned char cmnd ) ; void LCD_send_data ( unsigned char data ) ; void LCD_init ( ) ; void LCD_goto ( unsigned char y , unsigned char x ) ; void LCD_print ( char * string ) ; void LCD_update_time ( void ) ; / * Contador Temporizador 1 Comparar rutina de ajuste de un Servicio de Interrupción / Interrumpir Manejador * / ISR (TIMER1_COMPA_vect); #define LCD_DATA_PORT PORTB #define LCD_DATA_DDR DDRB #define LCD_DATA_PIN PINB #define LCD_CNTRL_PORT PORTC #define LCD_CNTRL_DDR DDRC #define LCD_CNTRL_PIN PINC #define LCD_RS_PIN 5 #define LCD_RW_PIN 6 #define LCD_ENABLE_PIN 7 #define SET_HOUR 3 #define SET_MINUTE 4 int principal (void) {unsigned

char i;

LCD_init (); LCD_goto (1, 2); LCD_print ("AVR-tutoriales"); LCD_goto (2, 4); LCD_print (tiempo);

LCD_CNTRL_PORT = (1 << SET_HOUR | 1 << SET_MINUTE);

TCCR1B = (1 << CS12 | 1 << WGM12); OCR1A = 15 625 - 1; TIMSK = 1 << OCIE1A; sei ();

while ( 1 )

{ if ( ! ( LCD_CNTRL_PIN & ( 1 << SET_HOUR ) ) ) {

hours ++; if ( hours > 23 )

hours = 0 ; } if ( ! ( LCD_CNTRL_PIN & ( 1 << SET_MINUTE ) ) ) {

minutes ++; if ( minutes > 59 )

minutes = 0 ; } _delay_ms ( 250 ) ;

} } / * Esta función envía un comando 'CMND' al LCD module*/ void LCD_send_command ( unsigned char cmnd ) {

LCD_DATA_PORT = cmnd ; LCD_CNTRL_PORT &= ~ ( 1 << LCD_RW_PIN ) ; LCD_CNTRL_PORT &= ~ ( 1 << LCD_RS_PIN ) ;

LCD_CNTRL_PORT |= ( 1 << LCD_ENABLE_PIN ) ; _delay_us ( 2 ) ; LCD_CNTRL_PORT &= ~ ( 1 << LCD_ENABLE_PIN ) ; _delay_us ( 100 ) ;

} / * Esta función envía 'datos' los datos al LCD module*/ void LCD_send_data ( unsigned char data ) {

LCD_DATA_PORT = data ; LCD_CNTRL_PORT &= ~ ( 1 << LCD_RW_PIN ) ; LCD_CNTRL_PORT |= ( 1 << LCD_RS_PIN ) ;


}

void LCD_init ()

{LCD_CNTRL_DDR = 0xFF; LCD_CNTRL_PORT = 0x00; LCD_DATA_DDR = 0xFF; LCD_DATA_PORT = 0x00;

_delay_ms ( 10 ) ; LCD_send_command ( 0x38 ) ; LCD_send_command ( 0x0C ) ; LCD_send_command ( 0x01 ) ; _delay_ms ( 10 ) ; LCD_send_command ( 0x06 ) ;

} / * Esta función mueve el cursor a la recta y la columna x en el módulo LCD * / void LCD_goto (sin firmar carbón y, sin firmar carbón x) {unsigned carbón firstAddress [] = {0x80, 0xC0, 0x94, 0xD4};

LCD_send_command (firstAddress [y - 1] + x - 1); _delay_ms (10);}

void LCD_print (Char * cadena) {unsigned char i;

mientras (string [i] =! 0) {LCD_send_data (string [i]); i ++;}} void LCD_update_time () {unsigned carbón temp;

LCD_goto (2, 4);

itoa (horas / 10, temp, 10); LCD_print (temp); itoa (hora% 10, temporales, 10); LCD_print (temp); LCD_print (":");

itoa (minutos / 10, temp, 10); LCD_print (temp); itoa ((minuto% 10), temperatura, 10); LCD_print (temp); LCD_print (":");

itoa (segundos / 10, temp, 10); LCD_print (temp);

itoa (segundos% 10, temp, 10); LCD_print (temp);} / * Contador Temporizador 1 Compara Partido Un

servicio de interrupción Rutina / Interrumpir Manejador * / ISR (TIMER1_COMPA_vect)

{segundo ++;

si (segundo == 60)

{segundos = 0; minutos ++;}

si (minutos == 60)

{minutos = 0; horas ++;}

si (hora> 23) horas = 0;

LCD_update_time ();}

El Termómetro Digital LM35 ATmega16 LCD

En este proyecto ATmega16 AVR estaremos diseñando e implementando un termómetro digital con la ayuda de un microcontrolador Atmel AVR ATmega16, una temperatura LM35 sensor / transductor y un módulo LCD alfanumérico. Nota: Aunque este proyecto AVR fue diseñado alrededor del ATmega16 el proyecto podría han utilizado otro microcontrolador tales como ATmega32, etc. El microcontrolador debe contener un Analog-to-Digital Converter (ADC) sin embargo. ATmega16 LCD Termómetro Operación Digital y Hardware DescripciónNuestro circuito LCD termómetro digital y el programa C es la siguiente. Cuando el circuito se enciende la temperatura del aire actual se mostrará en la pantalla LCD. La figura a continuación da el diagrama de circuito para el Termómetro Digital LCD ATmega16.

Nota Importante: Para que la unidad Termómetro Digital LM35 LCD para que funcione

correctamente el oscilador interno del microcontrolador ATmega16 AVR debe estar

habilitado y se puso a 4 MHz.

Software para el Termómetro Digital LCD ATmega16

A continuación se muestra la ejecución AVR C de todo el código de los ATmega16

Termómetro Digital LCD basada. El código fue implementado y construido con AVR

Studio 5. Recuérdese que el reloj interno del microcontrolador ATmega16 debe estar

habilitado y programado para funcionar a 4 MHz para el código AVR C para funcionar

correctamente. Un video del Termómetro Digital LCD en funcionamiento se presenta al

final de esta página.

/ * * Digital_Thermometer.c * * Autor: AVR Tutoriales * Sitio web: www.AVR-Tutorials.com * * Escrito en AVR Studio 5 * Compilador: AVR GNU C Compiler (GCC) * / #define F_CPU 4000000UL #include <avr / delay.h> #include <avr / io.h> #include <string.h> #include <avr / interrupt.h> / * Variables globales Declaraciones * / / * Declaraciones de funciones LCD */ void LCD_send_command ( unsigned char cmnd ) ; void LCD_send_data ( unsigned char data ) ; void LCD_init ( ) ; void LCD_goto ( unsigned char y , unsigned char x ) ; void LCD_print ( char * string ) ; / * Conversión ADC completa rutina de servicio de interrupción (ISR) * / ISR (ADC_vect); #define LCD_DATA_PORT PORTB #define LCD_DATA_DDR DDRB #define LCD_DATA_PIN PINB #define LCD_CNTRL_PORT PORTC #define LCD_CNTRL_DDR DDRC #define LCD_CNTRL_PIN PINC #define LCD_RS_PIN 5 #define LCD_RW_PIN 6 #define LCD_ENABLE_PIN 7 #define SET_HOUR 3 #define SET_MINUTE 4 int principal (void) {unsigned

char i; LCD_init ();

LCD_goto (1, 2); LCD_print ("La temperatura es");

LCD_CNTRL_PORT = (1 << SET_HOUR | 1 << SET_MINUTE);

DDRA = 0x00; // Configurar PortA como entrada

ADCSRA = 0x8F; // Activar el ADC y su

función de interrupción // y establecer el ACD reloj pre-

escalar a CLK / 128 ADMUX = 0xE0; // Seleccione 2.56V interna como Vref, dejó

justificar // registros de datos y seleccione ADC0 como canal de entrada

sei (); // Habilitar Global

interrupciones ADCSRA | = 1 << ADSC; // Iniciar conversión

mientras que (1);}

/ * Esta función envía un comando 'CMND' al LCD module*/ void LCD_send_command ( unsigned char cmnd ) {

LCD_DATA_PORT = cmnd ; LCD_CNTRL_PORT &= ~ ( 1 << LCD_RW_PIN ) ; LCD_CNTRL_PORT &= ~ ( 1 << LCD_RS_PIN ) ;


} / * Esta función envía 'datos' los datos al LCD module*/ void LCD_send_data ( unsigned char data ) {

LCD_DATA_PORT = data ; LCD_CNTRL_PORT &= ~ ( 1 << LCD_RW_PIN ) ; LCD_CNTRL_PORT |= ( 1 << LCD_RS_PIN ) ;


} void LCD_init ()

{LCD_CNTRL_DDR = 0xFF; LCD_CNTRL_PORT = 0x00; LCD_DATA_DDR = 0xFF; LCD_DATA_PORT = 0x00;

_delay_ms ( 10 ) ; LCD_send_command ( 0x38 ) ; LCD_send_command ( 0x0C ) ; LCD_send_command ( 0x01 ) ; _delay_ms ( 10 ) ; LCD_send_command ( 0x06 ) ;

} / * Esta función mueve el cursor a la recta y la columna x en el módulo LCD * / void LCD_goto (sin firmar carbón y, sin firmar carbón x) {unsigned carbón firstAddress [] = {0x80, 0xC0, 0x94, 0xD4};

LCD_send_command (firstAddress [y - 1] + x - 1); _delay_ms (10);}

void LCD_print (Char * cadena) {unsigned char i = 0;

mientras (string [i] =! 0) {LCD_send_data (string [i]); i ++;}}

/ * Conversión ADC completa rutina de servicio de interrupción (ISR) * / ISR (ADC_vect) {Char tempC, tempF, pantalla; float tempff;

tempC = ADCH; // ADCH Salida a PORTD tempff = (float) tempC; tempff = (tempff * 9) / 5 + 32; tempF = tempff;

LCD_goto ( 2 , 4 ) ; itoa ( tempC / 10 , display , 10 ) ; LCD_print ( display ) ; itoa ( tempC % 10 , display , 10 ) ; LCD_print ( display ) ; LCD_send_data ( 0xDF ) ; LCD_print ( "C " ) ; itoa ( tempF / 10 , display , 10 ) ; LCD_print ( display ) ; itoa ( tempF % 10 , display , 10 ) ; LCD_print ( display ) ; LCD_send_data ( 0xDF ) ; LCD_print ( "F" ) ; _delay_ms ( 500 ) ; ADCSRA |= 1 << ADSC ; // Comience

Conversión}

El ATmega16 siete segmentos Reloj Digital

En este proyecto ATmega16 AVR estaremos diseñando e implementando un reloj digital con la ayuda de un microcontrolador Atmel AVR ATmega16 y siete segmentos Displays. Como tal antes de ir a través de este proyecto AVR reloj digital se recomienda para completar el tutorial sobre Interconexión una pantalla de siete segmentos con el AVR microcontrolador. Nota: Aunque este proyecto AVR fue diseñado alrededor del ATmega16 el proyecto podría haber utilizado otro microcontrolador tales como ATmega32 , ATMega8515, etc. ATmega16 Reloj Digital Operación Nuestro reloj digital funciona como sigue. Cuando el circuito se enciende el reloj comienza a"00:00:00" para "HH: MM: SS". Hay dos pulsadores utilizados para ajustar la hora. Interruptor SW1 se utiliza para configurar los minutos, al pulsar este botón los minutos en aumento hasta llegar a 59 y luego restablecer y empezar a contar desde 0. Interruptor SW2 es para establecer las horas.

ATmega16 Reloj Digital Descripción del hardware

La figura a continuación da el diagrama de circuito para el ATmega16 Seven Segment Display Digital Clock. Una característica a tener en cuenta en que los siete exhibiciones de segmento son impulsados por el mismo puerto(PortB). El microcontrolador a través de controles de Puerto C indican cuales siete pantalla segmento se muestra en cada dígito. Tenga en cuenta que estos siete segmentos Muestra son cátodo común pantalla.

http://www.avr-tutorials.com/interfacing/interfacing-seven-segment-display-avr-microcontroller


Nota Importante: Para que nuestro reloj digital para que funcione correctamente el

oscilador interno del microcontrolador ATmega16 AVR debe estar habilitado y se puso a 4

MHz.

ATmega16 Software Digital Clock

A continuación se muestra la implementación AVR C de todo el código para el reloj digital basado ATmega16. El código fue implementado y construido con AVR Studio 5. Recuérdese que el reloj interno del microcontrolador ATmega16 debe estar habilitado y programado para funcionar a 4 MHz para el código AVR C para funcionar correctamente. Un video del reloj digital en la operación se presenta al final de esta página.

Por favor ver la Interfaz de una pantalla de siete segmentos con el AVR

Microcontrolador tutorial para obtener más información en la pantalla de siete segmentos.

A continuación se muestra el código AVR C para el reloj digital basada ATmega16. Este

código fue escrito en AVR Studio 5.

/ * * DigitalClock.c * Escrito en AVR Studio 5 * Compilador: AVR GNU C Compiler (GCC) * * Creado: 10/12/2011 1:17:19 PM * Autor: AVR Tutoriales * Sitio web: www.AVR-Tutorials.com * / #define F_CPU 4000000UL #include <avr / delay.h> #include <avr / io.h> #include <avr / interrupt.h> #define SegDataPort PORTB #define SegDataPin PINB #define SegDataDDR DDRB #define SegCntrlPort PORTC #define SegCntrlPin PINC #define SegCntrlDDR DDRC / * Variables globales Declaraciones * / unsigned Char horas = 0; sin firmar Char minutos = 0; sin firmar Char segundo = 0; / * Función

Dígitos (0-9) a siete valores del segmento Encoder * / unsigned carbón DigitTo7SegEncoder (sin firmar carbón dígitos, sin firmar carbón común);



/ * Contador Temporizador 1 Comparar rutina de ajuste de un Servicio de Interrupción / Interrumpir Manejador * / ISR (TIMER1_COMPA_vect); / * Inicio Program*/ /*****************************************************************************/ int main ( void ) { SegDataDDR = 0xFF ;

SegCntrlDDR = 0x3F ; SegCntrlPort = 0xFF ;

TCCR1B = (1 << CS12 | 1 << WGM12); OCR1A = 15 625 - 1; TIMSK = 1 << OCIE1A; sei ();

mientras que (1) {/ * Minutos establecidos al pulsar SegCntrl Pin 6 Interruptor * /

si ((SegCntrlPin y 0x40) == 0)

{_delay_ms (200); si (minuto <59)

minutos ++; else

minutos = 0; }

/ * Horas establecidos al pulsar SegCntrl Pin 7 Interruptor * / si ((SegCntrlPin y 0x80) == 0)

{_delay_ms (200); si (horas <23)

horas ++; else

horas = 0;}

SegDataPort = DigitTo7SegEncoder ( seconds % 10 , 1 ) ; SegCntrlPort = ~ 0x01 ; SegDataPort = DigitTo7SegEncoder ( seconds / 10 , 1 ) ; SegCntrlPort = ~ 0x02 ; SegDataPort = DigitTo7SegEncoder ( minutes % 10 , 1 ) ; SegCntrlPort = ~ 0x04 ; SegDataPort = DigitTo7SegEncoder ( minutes / 10 , 1 ) ; SegCntrlPort = ~ 0x08 ; SegDataPort = DigitTo7SegEncoder ( hours % 10 , 1 ) ; SegCntrlPort = ~ 0x10 ; SegDataPort = DigitTo7SegEncoder ( hours / 10 , 1 ) ; SegCntrlPort = ~ 0x20 ;

}

Volver 0;}

/ ** Función descriptiva:* Codificar un dígito decimal 0-9 a su equivalente de siete segmentos.** Argumentos de función:* Dígito - dígito decimal a codificar* Común - Ánodo común (0), Cátodo Común (1)* SegVal - Codificado Valor siete segmentos ** Conexiones:* Encoded SegVal es el retorno en la otra GFEDCBA es A es el menos* Poco significativo (bit 0) y G bit 6.* / Unsigned carbón DigitTo7SegEncoder (sin firmar carbón dígitos, sin firmar carbón común) {unsigned carbón SegVal;

switch ( digit ) {

case 0 : if ( common == 1 ) SegVal = 0b00111111 ;

else SegVal = ~ 0b00111111 ;

break ; case 1 : if ( common == 1 ) SegVal = 0b00000110

; else SegVal = ~

0b00000110 ; break ;


else SegVal = ~ 0b01011011 ;


; else SegVal = ~

0b01001111 ; break ;


else SegVal = ~ 0b01100110 ;


; else SegVal = ~

0b01101101 ; break ;


else SegVal = ~ 0b01111101 ;


; else SegVal = ~

0b00000111 ; break ;


else SegVal = ~ 0b01111111 ;


; else SegVal = ~

0b01101111 ; } return SegVal ;

} / * Contador Temporizador 1 Comparar Partido Un servicio de interrupción de rutina / Interrumpir Manejador * / ISR (TIMER1_COMPA_vect)

{segundo ++;

si (segundo == 60)

{segundos = 0; minutos ++;}

si (minutos == 60)

{minutos = 0; horas ++;}

si (hora> 23) horas = 0;}

Directivas de Ensamblador

Documents

Transcript of Directivas de Ensamblador