Paso 4: Otro vistazo a los indicadores y tablas de búsqueda
Ahora veamos si podemos utilizar nuestro analizador para tener una mejor idea de cómo funcionan estos punteros X, Y y Z y tablas de búsqueda. Me doy cuenta de que nuestra discusión en el tutorial pasado pudo haber sido un poco confuso para el recién llegado. Creo que esto ayudará a hacer todo más claro.
Vamos a comenzar por modificar nuestro código como sigue:
;************************************ ; escrito por: 1o_o7; Fecha: < 2014|11|03 >; versión: 1,0; el archivo se guarda como: analyzer2.asm; para AVR: atmega328p; frecuencia de reloj: 16MHz; *** ;************************************ ; written by: 1o_o7 ; date: <2014|11|03> ; version: 1.0 ; file saved as: analyzer2.asm ; for AVR: atmega328p ; clock frequency: 16MHz ;************************************ ; Program funcion:---------------------- ; analyzes the bits stored in a register ;--------------------------------------- .nolist .include "./m328Pdef.inc" .list .def temp = r16 .org 0x0000 rjmp Init numbers: .db 0b01111111, 0b11011110, 0b01011110, 0b11010010 .db 0b01010010, 0b11000000 Init: ser temp out DDRB,temp out DDRC,temp clr temp out PortB,temp out PortC,temp main: ldi ZH, high(2*numbers); ZH is the high byte of the address of numbers ldi ZL, low(2*numbers); ZL is the low byte of the address of numbers mov r20,r30 rcall analyze rjmp main analyze: clr temp out portb,temp out portc,temp sbrc r20,7 sbi portb,1 sbrc r20,6 sbi portb,2 sbrc r20,5 sbi portb,3 sbrc r20,4 sbi portb,4 sbrc r20,3 sbi portc,1 sbrc r20,2 sbi portc,2 sbrc r20,1 sbi portc,3 sbrc r20,0 sbi portc,4 ret .nolist .include ". / m328Pdef.inc".list main: ldi ZH, high(2*numbers) ldi ZL, low(2*numbers) mov r20,ZL rcall analyze rjmp main org 0 x 0000 rjmp Inicio números: .db 0b01111111, 0b11011110, 0b01011110, 0b11010010 .db 0b01010010, 0b11000000 main: ldi ZH, high(2*numbers) ldi ZL, low(2*numbers) lpm r20,Z rcall analyze rjmp main principal: ldi ZH, high(2*numbers); ZH es el byte alto de dirección de números ldi ZL, low(2*numbers); ZL es el byte bajo de la dirección de números mov r20, r30 rcall analizar principales rjmp main: ldi ZH, high(2*numbers) ldi ZL, low(2*numbers) adiw ZH:ZL,1 mov r20,ZL rcall analyze rjmp main
Simplemente hemos añadido una tabla de búsqueda en la parte superior (que es exactamente la misma que utilizamos en nuestro programa de dados de Tutorial 4) y luego agregamos las líneas ZL y ZH en nuestra rutina principal para inicializar el puntero de Z.
Luego cargar r30 en nuestro analizador registro r20 y analizarlo en nuestro tablero. Usted debe hacer esto. Usted debe encontrar que r30 contiene 0b00000010. Ahora lo mismo para r31 y conseguirá 0b00000000.
La dirección de "números" es 0x0001 que en binario es 0b0000000000000001
LDI ZH, high(2*numbers)
significa exactamente lo mismo que
LDI r31, high(0b0000000000000010)
que es
LDI r31, 0b00000000
Del mismo modo
LDI ZL, low(2*numbers)
significa exactamente lo mismo que
LDI r30, low(0b0000000000000010)
que es
LDI r30, 0b00000010
Recordar que r30 y r31 combinan juntos para hacer Z.
Prueba esto:
main: ldi ZH, high(2*numbers) ldi ZL, low(2*numbers) inc r30 lpm r20,Z rcall analyze rjmp main
Ahora ¿qué sucede si nos fijamos en Z? Bien vamos a probarlo:
.org 0x0000 rjmp Init .org 0x0008 numbers: .db 0b01111111, 0b11011110, 0b01011110, 0b11010010 .db 0b01010010, 0b11000000
Observe que, para poder usar Z, necesitamos el comando LPM. Esto cargará cualquier datos en la sala en la dirección apuntada por Z. La dirección A que z apunta encuentra a partir de lo que está en el r30 r31, que es 0b0000000000000010 y luego lo cambio de nuevo a la derecha para llegar a 0b0000000000000001. ¿Así que probarlo y ver lo que hay... derecha nifty? Tienes 0b01111111 que es exactamente lo que tenemos almacenado en esa dirección. Vamos a continuar tratar de hacerlo más evidente. Vamos a hacer lo siguiente:
main: ldi ZH, high(2*numbers) ldi ZL, low(2*numbers) adiw ZH:ZL,3 lpm r20,Z rcall analyze rjmp main
Puedes ver que hemos añadido 1 a ZH:ZL que hace ZL = 0b00000011. Si en el anterior reemplazó ZL con r30 obtienes exactamente lo mismo. Son diferentes nombres para el mismo número. Si, en lugar de utilizar "adiw ZH:ZL" en el anterior usado "inc ZL" o incluso "inc r30" Haz lo mismo otra vez. La adiw de instrucción significa "añadir inmediatamente a la palabra" y una "palabra" es de 2 bytes o 16 bits. Lo que necesitas para darle dos registros de 8 bits, ZH:ZL, o equivalente r31:r30 y agrega k a él. En nuestro ejemplo anterior k es 1.
Vamos a agregar 1 r30 y luego ver donde apunta Z:
main: ldi ZH, high(2*numbers) ldi ZL, low(2*numbers) ldi r31, 0 ldi r30, 19 lpm r20,Z rcall analyze rjmp main
Z contiene ZH:ZL que es lo mismo que r31:r30 que es 0x0003 desde "números:" empieza a 0x0001 y nos veces por 2 inicializar ZL y ZH que significó que Z contiene 0x0002, luego incrementa r30 (que es la mitad inferior de la Z) para que ahora Z = r31:r30 = 0x00:0x03 = 0x0003. Cuando la instrucción LPM se pide a la memoria de programa de carga de Z a r20 tiene el número de Z, que es 0x0003 = 0b0000000000000011 y dice: "bueno, el bit 0 es 1, que significa quiero agarrar el segundo byte en la dirección 0b0000000000000001 que es la dirección de obtener cambiando de Z a la derecha una posición (o dividir por 2)"
Quiero hacer una última cosa aquí para tratar de hacer menos confuso. Volvamos a la parte superior de nuestro programa y pegue una declaración .org allí. Por lo que tiene
¿Ves lo que he hecho? Os he dicho explícitamente la PC para pegar mi tabla de números en la dirección de memoria de programa 0x0008, que en binario es 0b0000000000001000
(Recordemos que desde que yo soy lo que no permite cualquier interrupciones puedo puede usar esos espacios de memoria para lo que me gusta).
¿Desde los números: tabla comienza en la dirección antes mencionada, lo que se consigue carga en r30 y r31 esta vez?
Bien esa dirección se multiplican por 2 y obtienes 0b0000000000010000 que se separa como 00000000:00010000 así que nos dice r31, ZH es si te gusta 0b00000000 y r30 o ZL si quieres, es 0b00010000.
Ejercicio 2: Compruébelo con su analizador por salida r30.
Ahora prueba esto:
Debe señalar en el número 4 en la lista desde que comenzamos en la primera de ellas y agrega 3 a la dirección. ¿Cuál es la dirección real de memoria de programa de este número? Bien, la dirección de memoria de programa para el primero de la lista es 0x0008, que es 0b0000000000001000, y la memoria del programa del segundo número en la lista también es 0x0008. La memoria del programa del tercer número de la lista es 0x0009 y la dirección de programa del cuarto número es 0x0009. Lo conseguimos ese cuarto número es comience con la dirección 0b0000000000001001 y nos cambio dejado por 1 bit (es decir, veces por 2) para obtener 0b0000000000010010 y esto te dará los valores de ZH:ZL para el primer número en esa dirección, es decir, el tercer número en la lista, para obtener el segundo número almacenado en esa misma dirección (en otras palabras la mitad superior de ese registro de 16 bits en la dirección 0x0009) solo agregamos a la número cambiado de puesto. Que es 0b0000000000010011. Este es el número 0 x 13 en hexadecimal, o 19 en decimal. Así queremos un número almacenado en el número de dirección de memoria de programa 9 y así establece ZH:ZL en 0:19 vamos a probar todo esto. Permite sólo pegar este número en y r30 r31 y ver lo que sale de Z.
Lo behold. Su LED muestran el número 4 en nuestra lista.
Espero que esto ha ayudado a personas a entender lo que están pasando con el puntero de Z, cómo se presenta memoria de programa, cómo funcionan los ADIW y LPM y por qué tienen que hacer esto multiplicando por dos cosas para obtener los datos correctos bytes de una dirección de memoria dada. Observe que hay dos cosas diferentes de 16 bits. La dirección de memoria del programa sí mismo es un número de 16 bits, y el registro en cada una de las dirección es 16 bits amplia. El primer dato Z tiene que ser hecha de 2 de nuestros registros de trabajo de 8 bits, por lo que puede contener una dirección de memoria completa, el segundo hecho es por eso que tenemos que multiplicar por 2 para que podamos conseguir el bajo o el alto octeto de datos almacenados en cada dirección.
Ejercicio 3: jugar con colocar datos en varios lugares de la memoria, incremento y decremento los registros r30 y r31, ¿qué pasa cuando empiezas en el r31 = 0xFF e incrementarlo? También intente usar la X y Y punteros también.
¡ UF! Vamos a tomar un descanso y hacer algo divertido...
