Archive for 2015
INSTRUCCIONES DE COMPARACIÓN
Los ejemplos de aplicación de estas instrucciones se verán mas adelante realizando programas.
Todas las instrucciones se encuentran en el set de instrucciones.
>> Instrucción CP, Compare
Esta instrucción permite la comparación entre el contenido de dos registros Rd y Rr. Como resultado de la ejecución de la instrucción ninguno de los registros cambia. Los saltos condicionales pueden ser usados luego de la ejecución de esta instrucción.Operación:
Rd - Rr
Sintaxis: Operandos
CP Rd,Rr 0 ≤ d ≤ 31, 0 ≤ r ≤ 31
>> Instrucción CPC, Compare with Carry
Esta instrucción permite la comparación entre el contenido de dos registros Rd y Rr y también toma en cuenta el carry previo. Como resultado de la ejecución de la instrucción de la ejecución de la instrucción ninguno de los registros cambia. Los saltos condicionales pueden ser usados luego de la ejecución de esta instrucción.Operación:
Rd - Rr - C
Sintaxis: Operandos
CPC Rd,Rr 0 ≤ d ≤ 31, 0 ≤ r ≤ 31
>> Instrucción CPI, Compare with Immediate
Esta instrucción permite la comparación entre el contenido del registro Rd y una constante. El contenido del registro no cambia. Los saltos condicionales pueden ser usados luego de la ejecución de esta instrucción.Operación:
Rd - K
Sintaxis: Operandos
CPI Rd,K 16 ≤ d ≤ 31, 0 ≤ K ≤ 255
>> Instrucción CPSE, Compare Skip if Equal
Esta instrucción permite la comparación entre el contenido de dos registros Rd y Rr, y salta a la siguiente instrucción si Rd = Rr.Operación:
Si Rr=Rd entonces salta a siguiente instrucción
Sintaxis: Operandos
CPI Rd,K 16 ≤ d ≤ 31, 0 ≤ K ≤ 255
INSTRUCCIONES DE ROTACIÓN Y DESPLAZAMIENTO
Los ejemplos de aplicación de estas instrucciones se verán mas adelante realizando programas de operaciones matemáticas.
Todas las instrucciones se encuentran en el set de instrucciones.
>> Instrucción LSL, Logical Shift Left
Esta instrucción desplaza todos los bits de Rd un lugar a la izquierda. El bit 0 es borrado y el bit 7 es cargado en la bandera de carry del registro SREG. Esta operación es equivalente a multiplicar por 2 valores con signo y sin signo.Operación:
←
|
||||||||||
C
|
←
|
b7
|
b0
|
←
|
0
|
|||||
Sintaxis: Operandos
LSL Rd 0 ≤ d ≤ 31
>> Instrucción LSR, Logical Shift Right
Esta instrucción desplaza todos los bits de Rd un lugar a la derecha. El bit 7 es borrado y el bit 0 es cargado en la bandera de carry del registro SREG. Esta operación es equivalente a dividir para 2 valores sin signo.Operación:
→
|
||||||||||
0
|
→
|
b7
|
b0
|
→
|
C
|
|||||
Sintaxis: Operandos
LSR Rd 0 ≤ d ≤ 31
>> Instrucción ROL, Rotate Left trough Carry
Esta instrucción desplaza todos los bits de Rd un lugar a la izquierda. La bandera del carry en SREG pasa al bit 0 de Rd. El bit 7 desplazado a la bandera de carry del registro SREG. Esta operación combinada con LSL es equivalente a multiplicar por 2 valores multi-byte con signo y sin signo.Operación:
←
|
||||||||||
C
|
←
|
b7
|
b0
|
←
|
C
|
|||||
Sintaxis: Operandos
ROL Rd 0 ≤ d ≤ 31
>> Instrucción ROR, Rotate Right trough Carry
Esta instrucción desplaza todos los bits de Rd un lugar a la derecha. La bandera del carry en SREG pasa al bit 7 de Rd. El bit 0 desplazado a la bandera de carry del registro SREG. Esta operación combinada con LSR o ASR es equivalente a dividir pora 2 valores multi-byte sin signo y con signo respectivamente.Operación:
→
|
||||||||||
C
|
→
|
b7
|
b0
|
→
|
C
|
|||||
Sintaxis: Operandos
ROR Rd 0 ≤ d ≤ 31
>> Instrucción ASR, Arithmetic Shift Right
Esta instrucción desplaza todos los bits de Rd un lugar a la derecha. El bit 7 se mantiene constante y el bit 0 es cargado en la bandera de carry del registro SREG. Esta operación es equivalente a dividir para 2 valores con signo.Operación:
→
|
||||||||||
b7
|
b0
|
→
|
C
|
|||||||
Sintaxis: Operandos
ASR Rd 0 ≤ d ≤ 31
>> Instrucción SWAP, Swap Nibbles
Esta instrucción intercambia nibbles alto y bajo de un registro.Operación:
b7
|
b6
|
b5
|
b4
|
b3
|
b2
|
b1
|
b0
|
Antes
|
|
b0
|
b1
|
b2
|
b3
|
b7
|
b6
|
b5
|
b4
|
Después
|
|
Sintaxis: Operandos
SWAP Rd 0 ≤ d ≤ 31
INSTRUCCIONES LÓGICAS
Todas las instrucciones se encuentran en el set de instrucciones.>> Instrucción COM, One's Complement
Esta instrucción permite realizar la operación de complemento a uno del contenido del registro Rd.Operación:
Rd ← $FF-Rd
Sintaxis: Operandos
COM Rd 0 ≤ d ≤ 31
Ejemplos:
ldi
r17,0b00001111 ; cargo en R17 el valor de 0b00001111
com r5 ; R5 =
0b11110000
>> Instrucción NEG, Two's Complement
Esta instrucción permite realizar la operación de complemento a dos del contenido del registro Rd.Operación:
Rd ← $00-Rd
Sintaxis: Operandos
NEG Rd 0 ≤ d ≤ 31
Ejemplos:
ldi
r17,0b00001111 ; cargo en R17 el valor de 0b00001111
neg
r5 ; R5 = 0b11110001>> Instrucción AND, Logical AND
Realiza la operación lógica AND entre el contenido de dos registros Rd y Rr y el resultado queda en el registro de destino Rd.Operación:
Rd ← Rd·Rr
Sintaxis: Operandos
AND Rd,Rr 0 ≤ d ≤ 31, 0 ≤ r ≤ 31
Ejemplos:
ldi
r16,0b00001111 ; cargo en R16 0b00001111
ldi
r17,0b00000011 ; cargo en R17 0b00000011
and
r16,r17 ; R16 termina con 0b00000011, R17 no cambia>> Instrucción ANDI, Logical AND with Immediate
Realiza la operación lógica AND entre el contenido del registro Rd y una constante. El resultado queda en el registro de destino Rd.Operación:
Rd ← Rd·K
Sintaxis: Operandos
ANDI Rd,K 16 ≤ d ≤ 31, 0 ≤ K ≤ 255
Ejemplos:
ldi
r16,0b00001111 ; cargo en R16 0b00001111
andi
r16,0b11111111 ; R16 termina con 0b00000000
>> Instrucción OR, Logical OR
Realiza la operación lógica OR entre el contenido de dos registros Rd y Rr y el resultado queda en el registro de destino Rd.Operación:
Rd ← Rd v Rr
Sintaxis: Operandos
OR Rd,Rr 0 ≤ d ≤ 31, 0 ≤ r ≤ 31
Ejemplos:
ldi
r16,0b00001111 ; cargo en R16 0b00001111
ldi
r17,0b11000011 ; cargo en R17 0b00000011
or
r16,r17 ; R16 termina con 0b11001111, R17 no cambia>> Instrucción ORI, Logical OR with Immediate
Realiza la operación lógica ORI entre el contenido del registro Rd y una constante. El resultado queda en el registro de destino Rd.Operación:
Rd ← Rd·K
Sintaxis: Operandos
ORI Rd,K 16 ≤ d ≤ 31, 0 ≤ K ≤ 255
Ejemplos:
ldi
r16,0b00001111 ; cargo en R16 0b00001111
ori
r16,0b11111111 ; R16 termina con 0b11111111
>> Instrucción EOR, Exclusive OR
Realiza la operación lógica EOR entre el contenido de dos registros Rd y Rr y el resultado queda en el registro de destino Rd.Operación:
Rd ← Rd (+) Rr
Sintaxis: Operandos
EOR Rd,Rr 0 ≤ d ≤ 31, 0 ≤ r ≤ 31
Ejemplos:
ldi
r16,0b00001111 ; cargo en R16 0b00000011
ldi
r17,0b11000011 ; cargo en R17 0b11000011
eor r16,r17 ; R16
termina con 0b11000000, R17 no cambiaINSTRUCCIONES ARITMÉTICAS
Todas las instrucciones se encuentran en el set de instrucciones.
>> Instrucción INC, Increment
Esta instrucción permite agregar 1 al contenido de Rd y el resultado es ubicado en el mismo Rd.Operación:
Rd ← Rd+1
Sintaxis: Operandos
INC Rd 0 ≤ d ≤ 31
Ejemplos:
ldi r16,20 ; cargo en R16
el valor de 20
inc r16 ; R16=R16+1
inc r16 ; R16=R16+1
; ==
R16 termina con el valor de 22 ==
>> Instrucción DEC, Decrement
Esta instrucción permite restar 1 al contenido del registro Rd y el resultado es ubicado en el mismo registro Rd.Operación:
Rd ← Rd-1
Sintaxis: Operandos
DEC Rd 0 ≤ d ≤ 31
Ejemplos:
ldi r20,15 ; cargo en R20
el valor de 15
dec r20 ; R20=R20-1
dec r20 ; R20=R20-1
; == R20 termina con el valor de 13 ==
>> Instrucción ADD, Add without carry
Esta instrucción suma los contenidos de dos registros Rd y Rr sin considerar la bandera del carry, y el resultado de la operación se lo ubica en el registro de destino Rd.Operación:
Rd ← Rd+Rr
Sintaxis: Operandos
ADD Rd,Rr 0 ≤ d ≤ 31, 0 ≤ r ≤ 31
Ejemplos:
ldi r16,15 ; cargo en R16
el valor de 15
ldi r17,14 ; cargo en R17
el valor de 14
add r16,r17 ; sumo R16+R17,
resultado se guarda en R16
;
= R16 termina con 29, R17 sigue con 14
>> Instrucción ADC, Add with carry
Esta instrucción suma los contenidos de dos registros Rd y Rr, considerando además la bandera del carry, y el resultado de la operación se lo ubica en el registro de destino Rd.Operación:
Rd ← Rd+Rr+C
Sintaxis: Operandos
ADC Rd,Rr 0 ≤ d ≤ 31, 0 ≤ r ≤ 31
Ejemplos:
ldi r16,15 ; cargo en R16
el valor de 15
ldi r17,14 ; cargo en R17
el valor de 14
sec ; hago que el carry sea C=1
add r16,r17 ; sumo
R16+R17+C, resultado se guarda en R16
;
= R16 termina con 30, R17 sigue con 14>> Instrucción ADIW, Add Immediate to Word
Esta instrucción suma de forma inmediata el valor de una constante (0-63) y el resultado es ubicado a un par de registros. Esta instrucción opera con los cuatro registros pares más altos y es apropiada para trabajar con los registros punteros.Operación:
Rd+1:Rd ← Rd+1:Rd+K
Sintaxis: Operandos
ADIW Rd+1:Rd,K d {24, 26, 28, 30} 0 ≤ K ≤ 63
Ejemplos:
adiw r26,5 ;
R27:R26=R27:R26+5
adiw r27:r26,5 ;
R27:R26=R27:R26+5
En los ejemplos anteriores las dos formas de utilizar la instrucción son equivalentes.
>> Instrucción SUB, Substract without carry
Esta instrucción realiza la sustracción del contenido del registro de origen del contenido del registro de destino, y el resultado queda en el registro de destino.Operación:
Rd ← Rd-Rr
Sintaxis: Operandos
SUB Rd,Rr 0 ≤ d ≤ 31, 0 ≤ r ≤ 31
Ejemplos:
ldi r28,12 ; cargo en R28
el valor de 12
ldi r15,10 ; cargo en R15
el valor de 10
sub r28,r15 ; resto R28-R15,
el resultado se guarda en R28
; = R28 termina con 2, r15 sigue con 12
>> Instrucción SBC, Substract with carry
Esta instrucción realiza la sustracción del contenido del registro de origen del contenido del registro de destino y además resta el carry, el resultado queda en el registro de destino.Operación:
Rd ← Rd-Rr-C
Sintaxis: Operandos
SBC Rd,Rr 0 ≤ d ≤ 31, 0 ≤ r ≤ 31
Ejemplos:
ldi r28,12 ; cargo en R28
el valor de 12
ldi r16,10 ; cargo en R15
el valor de 10
sec ; hago que el carry sea C=1
sub r28,r16 ; resto R28-R15,
el resultado se guarda en R28
; = R28 termina con 1, r15 sigue con 12
>> Instrucción SUBI, Substract inmediate
Esta instrucción realiza la sustracción de una constante del contenido del registro de destino y el resultado queda en el registro de destino. Esta instrucción trabaja con los registros R16 al 31.Operación:
Rd ← Rd-K
Sintaxis: Operandos
SUBI Rd,K 0 ≤ d ≤ 31, 0 ≤ K ≤ 255
Ejemplos:
ldi r25,13 ; cargo en R25
el valor de 13
subi r25,5 ; resto 5 de
R25
; = R25 termina con 8
>> Instrucción SBIW, Substract immediate from Word
Esta instrucción realiza la sustracción de forma inmediata de una constante (0-63) y el resultado es ubicado a un par de registros. Esta instrucción opera con los cuatro registros pares más altos y es apropiada para trabajar con los registros punteros.Operación:
Rd+1:Rd ← Rd+1:Rd-K
Sintaxis: Operandos
SBIW Rd+1:Rd,K d {24, 26, 28, 30} 0 ≤ K ≤ 63
Ejemplos:
sbiw r26,5 ;
R27:R26=R27:R26-5
sbiw
r27:r26,5 ; R27:R26=R27:R26-5En los ejemplos anteriores las dos formas de utilizar la instrucción son equivalentes.
>> Instrucción MUL, Multiply Unsigned
Esta instrucción realiza la multiplicación de dos numeros de 8bits, con un resultado de 16 bits.
Rd
|
Rr
|
R1
|
R0
|
||
Multiplicando
|
x
|
Multiplicador
|
→
|
Product
High
|
Product
Low
|
8
|
8
|
16
|
|||
Operación:
R1:R0 ← RdxRr (unsigned ← unsigned x unsigned)
Sintaxis: Operandos
MUL Rd,Rr 0 ≤ d ≤ 31, 0 ≤ r ≤ 31
Ejemplos:
ldi r18,100 ; cargo en R18
el valor de 100
ldi r19,200 ; cargo en R19
el valor de 200
mul r18,r19 ; multiplico R18
x R19 = 100 X 200 = 20000, guardado en R1:R0
movw r18,r0 ; copio el
resultado de vuelta a R19:R18
Registro de Trabajo y Punteros X, Y, Z
Todos los microcontroladores AVR de 8 bits, desde los ATtiny, ATmega y ATxmega tienen 32 registros de trabajo que van desde R0 a R31. Los Registros de Trabajo tienen la función de alojar los datos más inmediatos que el CPU procesa.
A continuación se puede notar, los registros de trabajo. Estos estan divididos de 16 en 16. La diferencia se encuentra en que los 16 primeros (R0-R15) no permiten el uso de la instrucción LDI, que sirve para cargar constantes al registro. Los registros (R16-31), si admiten el LDI, y por general son los más utilizados por este motivo.
Los registros (R26-R31) pueden adicionalmente funcionar como punteros de 16 bits cada uno.
El par de registros R27-R26 forma el Puntero X, el par R29-R28 forma el Puntero Y, y el par R31-R30 forma el Puntero Z.
Los punteros pueden apuntar a (contener la dirección de) cualquier locación del espacio de RAM. Esto junto con las instrucciones adecuadas conforman el direccionamiento indirecto más potente, muy útil por ejemplo para mover grandes bloques de datos.
Puntero X
|
R27
|
R26
|
Puntero Y
|
R29
|
R28
|
Puntero Z
|
R31
|
R30
|
INSTRUCCIONES DE TRANSFERENCIA DE DATOS
Todas las instrucciones se encuentran en el set de instrucciones.Este tipo de instrucciones permiten transferir o mover datos desde una localización de memoria a un registro o viceversa, así como entre registros internos o hacia o desde los puertos del circuito. Cada instrucción especifica el modo de direccionamiento utilizado. El set de instrucciones completo se encuentra en la página de Descargas.
El las siguientes instrucciones se utilizará la siguiente nomenclatura:
Rd
|
Registro de
Destino
|
Rr
|
Registro Fuente
|
K
|
Constante
|
k
|
Dirección de memoria
|
>> Instrucción MOV, Copy Register
Esta instrucción hace la copia del contenido de un registro en otro. El registro fuente Rr, que se encuentra a la derecha de los operandos, no cambia, mientras que el registro de destino Rd es caragado con una copia de Rr.Esta instrucción permite utilizar todos los registros del microcontrolador del 0 al 31
Operación:
(Rd) ← (Rr)
Sintaxis: Operandos
MOV Rd,Rr 0 ≤ d ≤ 31, 0 ≤ r ≤ 31
Ejemplo:
mov r16,r17 ; el contenido
de R17 es copiado a R16
>> Instrucción MOVW, Copy Register Word
Esta instrucción copia el contenido de un par de registros a otro. El contenido de los registros fuente par Rr+1:Rr, no cambia.
Operación:
Rd+1:Rd ← Rr+1:Rr
Sintaxis: Operandos
MOVW Rd+1:Rd,Rr+1:Rr d {0,2,4,....}, r {0,2,4,....}
Ejemplos:
Operación:
Rd+1:Rd ← Rr+1:Rr
Sintaxis: Operandos
MOVW Rd+1:Rd,Rr+1:Rr d {0,2,4,....}, r {0,2,4,....}
Ejemplos:
movw r0,r16 ; en
R0:R1 se copia el contenido de R16:R17
movw
r3:r2,r19:r18 ; en R2:R3 se copia el contenido de R18:R19
Las dos sintaxis utilizadas son correctas, pero la primera es más corta y se obtienen los mismos resultados.
>> Instrucción LDI, Load Inmediate
Esta instrucción carga una constante de 8 bits directamente a los registros 16 a 31.
Operación:
Rd ← K
Sintaxis: Operandos
LDI Rd,K 16 ≤ d ≤ 31
Ejemplos:
Operación:
Rd ← K
Sintaxis: Operandos
LDI Rd,K 16 ≤ d ≤ 31
Ejemplos:
ldi
r18,0b00001111 ; Constante en binario cargado a R18
ldi r20,255 ;
Constante en decimal cargado a R20
ldi r21,0xFE ;
Constante en hexadecimal cargado a R21
En las siguientes intrucciones la memoria de datos consiste en los registros del archivo de trabajo, memoria I/O, la memoria SRAM interna, y el espacio extendido de I/O.
>> Intruccion LD, Load Indirect from Data Space to Register using Index X, Y, Z
Esta instrucción permite cargar un byte a un registro con direccionamiento indirecto, con o sin desplazamiento, de la memoria de datos a un registro.
El registro puntero X, Y o Z, con la operacion no cambia o puede ser post-incrementado o pre-decrementado. Esta característica es especialmente aplicada para accesos a arreglos, tablas y puntero del stack.
Operación: Comentario
(i) Rd ← (X) X: No cambia
(ii) Rd ← (X) X: Post-incremento
(iii) Rd ← X-1 X: Pre-decremento
(i) Rd ← (Y) Y: No cambia
(ii) Rd ← (Y) Y: Post-incremento
(iii) Rd ← Y-1 Y: Pre-decremento
(i) Rd ← (Z) Z: No cambia
(ii) Rd ← (Z) Z: Post-incremento
(iii) Rd ← Z-1 Z: Pre-decremento
Sintaxis: Operandos
Para el puntero X
(i) LD Rd,X 0 ≤ d ≤ 31
(ii) LD Rd,X+ 0 ≤ d ≤ 31
(iii) LD Rd,-X 0 ≤ d ≤ 31
Para el puntero Y
(i) LD Rd,Y 0 ≤ d ≤ 31
(ii) LD Rd,Y+ 0 ≤ d ≤ 31
(iii) LD Rd,-Y 0 ≤ d ≤ 31
Para el puntero Z
(i) LD Rd,Z 0 ≤ d ≤ 31
(ii) LD Rd,Z+ 0 ≤ d ≤ 31
(iii) LD Rd,-Z 0 ≤ d ≤ 31
(i) Rd ← (X) X: No cambia
(ii) Rd ← (X) X: Post-incremento
(iii) Rd ← X-1 X: Pre-decremento
(i) Rd ← (Y) Y: No cambia
(ii) Rd ← (Y) Y: Post-incremento
(iii) Rd ← Y-1 Y: Pre-decremento
(i) Rd ← (Z) Z: No cambia
(ii) Rd ← (Z) Z: Post-incremento
(iii) Rd ← Z-1 Z: Pre-decremento
Sintaxis: Operandos
Para el puntero X
(i) LD Rd,X 0 ≤ d ≤ 31
(ii) LD Rd,X+ 0 ≤ d ≤ 31
(iii) LD Rd,-X 0 ≤ d ≤ 31
Para el puntero Y
(i) LD Rd,Y 0 ≤ d ≤ 31
(ii) LD Rd,Y+ 0 ≤ d ≤ 31
(iii) LD Rd,-Y 0 ≤ d ≤ 31
Para el puntero Z
(i) LD Rd,Z 0 ≤ d ≤ 31
(ii) LD Rd,Z+ 0 ≤ d ≤ 31
(iii) LD Rd,-Z 0 ≤ d ≤ 31
Ejemplos
ld r2,X ; en
R2 se carga el dato apuntado por X
ld
r3,X+ ; en R3 se carga el dato apuntado por X, X se incrementa
ld
r4,-X ; X se decrementa, y en R4 se carga el dato apuntado por X
ld
r2,Y ; en R2 se carga el dato apuntado por Y
ld
r3,Y+ ; en R3 se carga el dato apuntado por Y, Y se incrementa
ld
r4,-Y ; Y se decrementa, y en R4 se carga el dato apuntado por Y
ld
r2,Z ; en R2 se carga el dato apuntado por Z
ld
r3,Z+ ; en R3 se carga el dato apuntado por Z, Z se incrementa
ld
r4,-Z ; Z se decrementa, y en R4 se carga el dato apuntado por Z
>> Instrucción LDD, Load Indirect from Data Space to Register using index Y, Z
Esta instrucción permite cargar un byte a un registro con direccionamiento indirecto, es muy similar a LD, pero se puede sumar un desplazamiento (q) al puntero Y, Z.
El puntero Y, Z no cambia después de la instrucción.
Operación: Comentario
Rd ← (Y+q) Y: No cambia, q: Desplazamiento
Rd ← (Z+q) Z: No cambia, q: Desplazamiento
Sintaxis: Operandos
LDD Rd,Y+q 0 ≤ d ≤ 31, 0 ≤ q ≤ 63
LDD Rd,Z+q 0 ≤ d ≤ 31, 0 ≤ q ≤ 63
Ejemplos
ldd r16,y+15 ; en R16
se carga el dato puntado por Y desplazado 15
ldd r5,z+3 ; en R5 se carga el dato puntado por Z desplazado 3
ldd r5,z+3 ; en R5 se carga el dato puntado por Z desplazado 3
>>Instrucción LDS, Load Direct from Data Space
Esta instrucción carga un byte de la memoria de datos en un registro.
Operación:
Rd ← k
Rd ← k
Sintaxis: Operandos
LDS Rd,k 0 ≤ d ≤ 31, 0 ≤ k ≤ 65535
LDS Rd,k 0 ≤ d ≤ 31, 0 ≤ k ≤ 65535
k: Es una dirección de memoria.
Ejemplos
.dseg ; inicio de segmento de codigo en SRAM
ram1: .byte 1 ; variable ram1
guardada en la SRAM
.cseg ; inicio de segmento de codigo en memoria de programa
lds r18,ram1 ; cargo en R18,
el contenido que se encuentra en ram1
lds r20,0xFF00 ; cargo en R20, el
contenido que se encuentra en la direccion 0xFF00
>> Instrucción ST, Store Indirect from Register to Data Space using Index X, Y, Z
Esta instrucción guarda un byte indirectamente, con o sin desplazamiento desde un registro al espacio de datos.
La localización del dato apuntada por el puntero X, Y, Z no cambia su contenido, pero puede ser modificado si se aplica un post-incremento o un pre-decremento. Esta característica es especialmente aplicada para accesos a arreglos, tablas y puntero del stack.
Operación: Comentario
(i) (X) ← Rr X: No cambia
(ii) (X) ← Rr X: Post-incremento
(iii) X-1 ← Rr X: Pre-decremento
(i) (Y) ← Rr Y: No cambia
(ii) (Y) ← Rr Y: Post-incremento
(iii) Y-1 ← Rr Y: Pre-decremento
(i) (Z) ← Rr Z: No cambia
(ii) (Z) ← Rr Z: Post-incremento
(iii) Z-1 ← Rr Z: Pre-decremento
Sintaxis: Operandos
Para el puntero X
(i) ST X,Rr 0 ≤ r ≤ 31
(ii) ST X+,Rr 0 ≤ r ≤ 31
(iii) ST -X,Rr 0 ≤ r ≤ 31
Para el puntero Y
(i) ST Y,Rr 0 ≤ r ≤ 31
(ii) ST Y+,Rr 0 ≤ r ≤ 31
(iii) ST -Y,Rr 0 ≤ r ≤ 31
Para el puntero Z
(i) ST Z,Rr 0 ≤ r ≤ 31
(ii) ST Z+,Rr 0 ≤ r ≤ 31
(iii) ST -Z,Rr 0 ≤ r ≤ 31
Ejemplos
(i) (X) ← Rr X: No cambia
(ii) (X) ← Rr X: Post-incremento
(iii) X-1 ← Rr X: Pre-decremento
(i) (Y) ← Rr Y: No cambia
(ii) (Y) ← Rr Y: Post-incremento
(iii) Y-1 ← Rr Y: Pre-decremento
(i) (Z) ← Rr Z: No cambia
(ii) (Z) ← Rr Z: Post-incremento
(iii) Z-1 ← Rr Z: Pre-decremento
Sintaxis: Operandos
Para el puntero X
(i) ST X,Rr 0 ≤ r ≤ 31
(ii) ST X+,Rr 0 ≤ r ≤ 31
(iii) ST -X,Rr 0 ≤ r ≤ 31
Para el puntero Y
(i) ST Y,Rr 0 ≤ r ≤ 31
(ii) ST Y+,Rr 0 ≤ r ≤ 31
(iii) ST -Y,Rr 0 ≤ r ≤ 31
Para el puntero Z
(i) ST Z,Rr 0 ≤ r ≤ 31
(ii) ST Z+,Rr 0 ≤ r ≤ 31
(iii) ST -Z,Rr 0 ≤ r ≤ 31
Ejemplos
st X,r2 ; el dato
apuntado por X se carga con R2
st X+,r3 ; el dato
apuntado por X se carga con R3, X se incrementa
st -X,r4 ; X se
decrementa, y el dato apuntado por X se carga con R4
st Y,r2 ; el dato
apuntado por X se carga con R2
st Y+,r3 ; el dato
apuntado por X se carga con R3, X se incrementa
st -Y,r4 ; X se
decrementa, y el dato apuntado por X se carga con R4
st Z,r2 ; el dato
apuntado por X se carga con R2
st Z+,r3 ; el dato
apuntado por X se carga con R3, X se incrementa
st -Z,r4 ; X se
decrementa, y el dato apuntado por X se carga con R4
>> Instrucción STD, Store Indirect from Register to Data Space using Index Y, Z
Esta instrucción guarda un byte indirectamente, es muy similar a ST, pero se puede sumar un desplazamiento (q) al puntero Y, Z.
El puntero Y, Z no cambia después de la instrucción.
Operación: Comentario
(Y+q) ← Rr Y: No cambia, q: Desplazamiento
(Z+q) ← Rr Z: No cambia, q: Desplazamiento
Sintaxis: Operandos
STD Y+q,Rr 0 ≤ r ≤ 31, 0 ≤ q ≤ 63
STD Z+q,Rr 0 ≤ r ≤ 31, 0 ≤ q ≤ 63
Ejemplos
std z+25,r22 ; guardo el
contenido de R22 en el byte apuntado por Z desplazado 25
>> Instrucción STS, Store Direct to Data Space
Guarda un byte de un registro en el espacio de datos.
Operación:
(k) ← Rr
Sintaxis: Operandos
STS k,Rr 0 ≤ d ≤ 31, 0 ≤ k ≤ 65535(k) ← Rr
Sintaxis: Operandos
Ejemplos:
std y+5,r21 ; guardo el
contenido de R21 en el byte apuntado por Y desplazado 5
std z+25,r22 ; guardo el
contenido de R22 en el byte apuntado por Z desplazado 25
>> Instrucción LPM, Load Program Memory
Esta instrucción carga un byte apuntado por el registro Z en el registro de destino Rd. La memoria de programa esta organizada como palabras de 16 bits mientras que el puntero Z apunta a la dirección de un byte. El bit menos significativo (LSB) del puntero Z, selecciona o el byte bajo o el alto de la dirección apuntada.
Esta instrucción puede direccionar los primeros 64K bytes de la memoria de programa.
Operación:
R0 ← (Z)
Rd ← (Z)
Rd ← (Z) Z ← Z+1
R0 ← (Z)
Rd ← (Z)
Rd ← (Z) Z ← Z+1
Sintaxis: Operandos
LPM ninguno, R0 implícito
LPM Rd,Z 0 ≤ d ≤ 31
LPM Rd,Z+ 0 ≤ d ≤ 31
Si se utiliza la instrucción LPM sin operandos, el dato apuntado se guarda en R0, caso contrario se guarda en Rd.
Ejemplos:
LPM ninguno, R0 implícito
LPM Rd,Z 0 ≤ d ≤ 31
LPM Rd,Z+ 0 ≤ d ≤ 31
Si se utiliza la instrucción LPM sin operandos, el dato apuntado se guarda en R0, caso contrario se guarda en Rd.
Ejemplos:
lpm ; guarda el contenido apuntado por Z en R0
lpm r10,Z ; guarda el
contenido apuntado por Z en R10
lpm r18,Z+ ; guarda el
contenido apuntado por Z en R18, Z se incrementa
>> Instrucción OUT, Store Register to I/O location
Esta instrucción guarda el dato contenido en el registro Rr, en el registro del espacio específicado en entrada/salida (I/O: Pórticos, Temporizadores, Registros de Configuración, etc).
Operación:
I/O(A) ← Rr
I/O(A) ← Rr
Sintaxis: Operandos
OUT A,Rr 0 ≤ r ≤ 31, 0 ≤ A ≤ 63
OUT A,Rr 0 ≤ r ≤ 31, 0 ≤ A ≤ 63
A: Es una dirección de registro de (I/O), entrada/salida
Ejemplos:
Ejemplos:
ldi r16,0xF0 ; cargo en R16 el
valor de 0xF0
out porta,r16 ; cargo en el
PORTA (registro I/O) el contenido de R16
out
portd,r16 ; cargo en el PORTD (registro I/O) el contenido de R16>> Instrucción IN, Load an I/O location to register
Esta instrucción carga un dato del espacio de memoria de entrada/salida (I/O: Pórticos, Temporizadores, Registros de Configuración, etc) en un registro Rd.
Operación:
Rd ← I/O(A)
Rd ← I/O(A)
Sintaxis: Operandos
IN Rd,A 0 ≤ d ≤ 31, 0 ≤ A ≤ 63
A: Es una dirección de registro de (I/O), entrada/salida
IN Rd,A 0 ≤ d ≤ 31, 0 ≤ A ≤ 63
A: Es una dirección de registro de (I/O), entrada/salida
Ejemplos:
in r5,pinc ; guardo en R5
en contenido de PINC (registro I/O)
in r18,pinb ; guardo en R18
en contenido de PINC (registro I/O)
