Ejercicios en ensamblador PDF

Preview

Summary

Una serie de ejercicios resueltos en ensamblador y encima de cada uno pone el titulo...

Description

Desarrolla un programa para la máquina ++ que almacene en la posición FFFF de la memoria el número de registros del banco que tienen el mismo valor que el acumulador A. No debe modificarse el valor de ningún registro STA E000

// GUARDAR A EN E000

MOV B A STA E001

// GUARDAR B EN E001

MOV C A STA E002

// GUARDAR C EN E002

MOV D A STA E003

// GURADAR D EN E003

MOV E A STA E004

// GUARDAR E EN E004

MVI 00 A STA FFFF LDA E001 MOV A B LDA E000

// CARGAMOS LO QUE HAY EN E001 // M0VEMOS LO DE A A B // CARGAMOS LO QUE HAY EN E000

CMP B // COMPARAMOS LO QUE HAY EN A CON LO QUE HAY EN B BEQ INCCONT1 // SI SON IGUALES SALTA BUCLE1:

LDA E002 MOV A B LDA E000 CMP B BEQ INCCONT2

BUCLE2:

LDA E003 MOV A B LDA E000 CMP B BEQ INCCONT3

BUCLE3:

LDA E004 MOV A B

LDA E000 CMP B BEQ INCCONT4 FINAL:

FIN

INCCONT1:

LDA FFFF INC A STA FFFF JMP BUCLE1

INCCONT2:

LDA FFFF INC A STA FFFF JMP BUCLE2

Desarrolla un programa para la Máquina ++ capaz de indicar (en el registro C) cuantas veces se encuentra un determinado valor en el segmento de memoria comprendido entre las posiciones F000 y F0FF. El valor a buscar se encontrará en la posición EFFF

BUCLE

MVI

F0 D

// PARTE ALTA DEL VECTOR

MVI

00 E

// PARTE BAJA DEL VECTOR

MVI

00 C

// INICIALIZAR CONTADOR

LDA

EFFF

MOV

AB

CMP

B

LDAX

BEQ NEXTPOS

INC

INCCONT E

BC

FINAL INCCONT

FINAL

JMP

BUCLE

INC

C

FIN

JMP NEXTPOS

Desarrolla una subrutina capaz de comparar el acumulador con el valor del registro C, teniendo en cuenta que ambos se encuentran codificados en binario puro con signo en C2. La rutina debe activar el flag C si A>=C y el flag Z si A=C. STA E001 SUB C BC FINAL BEQ FINAL FINAL:

LDA E001 FIN

Desarrolla un programa para la Máquina ++ que, empleando la rutina creada en el apartado anterior, calcule el número de posiciones de un determinado segmento de memoria cuyo contenido sea mayor que el valor almacenado en la posición E005 teniendo en cuenta que está codificado en BPCS en C2. El resultado quedará almacenado en las posiciones FFFE y FFFF, partes alta y baja respectivamente. La dirección de inicio del vector se almacena en las posiciones E000 y E001 (partes alta y baja respectivamente) y la dirección de final del vector en las posiciones E002 y E003. Se debe considerar la memoria como un vector circular de modo que la siguiente dirección a la última (FFFF) es la primera (0000). De esta forma no importa que la dirección inicial del vector sea posterior a la final.

MVI 00 A STA FFFE STA FFFF LDA E000

// CARGAMOS PARTE ALTA VECTOR

MOV A D LDA E001

// CARGAMOS PARTE BAJA VECTOR

MOV A E LDA E005 MOV A C

// EL CONTENIDO A COMPARAR

LDAX SUB C BC INCCONT NEXPOS:

LDA E002 MOV A D LDA E003 CMP E BEQ INCCOMP INC E

FINAL:

FIN

INCCONT:

LDA FFFF INC A BC INCCONTPALT STA FFFF JMP NEXPOS

INCCONTPALT: STA FFFF LDA FFFE INC A STA FFFE JMP NEXPOS INCCOMP:

LDA E003 CMP D BEQ FINAL INC D

Desarrolla una subrutina capaz de multiplicar el contenido de las posiciones de memoria E000 y E001 guardando el resultado en las posiciones E002 (Parte alta) y E003 (Parte baja). MVI 00 C

//CONTADOR

MVI 00 D

//PARTE ALTA

LDA E001 MOV A B LDA E000 BUCLE:

ADD A BC INCPARALT MOV B A CMP C BEQ FINAL INC C

NEXT:

JMP BUCLE

INCPARALT:

INR D JMP NEXT

FINAL:

STA E003 MOV D A STA E002

//Desarrolla un programa para la Máquina ++ que guarde a partir de la dirección E000 el vector de memoria comprendido entre las direcciones E025 y E02E ordenado de mayor a menor. //El vector original no debe modificarse. //Se supone que no hay valores negativos en los registros a ordenar

VOLCADO

INSP

E025

MVI

E0 D

MVI

00 E

MVI

F6 C

LOOP

POP STAX

ORDENAR

BUCLE

INR

E

INR

C

BEQ

ORDENAR

JMP

LOOP

MVI

00 C

MVI

00 E

MOV

AB

INR

E

LDAX // B = VECTOR DE K

LDAX

// A = VECTOR DE K + 1

CMP

B

// VECTOR DE K+A - VECTOR DE K

BEQ

SEGUIR

BC SEGUIR

MOV

INTERCAMBIAR

EA SUB

C

CPI

9

BEQ JMP

SIGUIENTENUM

FINAL

INC

FIN

SIGUIENTENUM BUCLE

C MOV

CA

CPI

9

BEQ

FINAL

MVI

00 E

JMP

BUCLE

INTERCAMBIAR:

STAX

FFFF MOV

//TEMP = VECTOR DE K+1 BA

STAX MOV

//VECTOR DE K+1 = VECTOR DE K EA

SUI

1

MOV

AE

LDA

FFFF

// E = E-1

//VECTOR DE K = TEMP

STAX INR

E

JMP

SEGUIR

realizar un programa en el ensamblador de la M+ que sume el contenido de los registros D y E. En caso de que se produzca acarreo en dicha suma, se debe escribir el valor hexadecimal AA en la posición de memoria 2500 H. Después se debe poner a 0 el flag de acarreo y volver a iniciar el programa. En caso de no haber acarreo, se almacena el valor hexadecimal EE en la dirección de memoria 3500 H, y, posteriormente, se inicial el programa. Se supone que el registro E está cargados con el valor correspondiente y que el contenido del registro D está en el acumulador

BUCLE:

MOV D A ADD E BC ESCRIBIRMEM MVI EE A STA 3500 JMP BUCLE

ESCRIBIRMEM: MVI AA A STA 2500 MVI 00 A SFA JMP BUCLE

implementa un programa de ensamblador para la maquina plus que guarde en las posiciones E001 y E000 el resultado de la suma de los 5 registros de A, B, C, D y E STA FFFF MOV B A STA FFFE MOV C A STA FFFD MOV D A STA FFFC MOV E A STA FFFB

BUCLE:

MVI FF E

// PARTE ALTA

MVI FB D

// PARTE BAJA

MVI 00 B

// PARTE BAJA CONT

MVI 00 C

// PARTE ALTA CONT

LDAX ADD B BC INCPARTEALTA

NEXT:

INC D CPI FF BEQ FINAL JMP BUCLE

INCPARTEALTA: INC C JMP NEXT FINAL:

MOV B A STA E300 MOV C A STA E 3001 FIN

IMPLEMENTA UN PROGRAMA EN ENSAMBLADOR DE LA MAQUINA PLUSQUE CUENTE EL NUMERO DE POSICIONES DE LA MEMORIA QUE CONTIENTE EL VALOR 0 ALMACENANDO EL RESULTADO EN LAS POSICIONES FFFE (PARTE ALTA) Y FFFF (PARTE BAJA). ESTAS DOS POSICIONES NO SERAN EVALUADAS

BUCLE1:

MVI 00 B

// CONT PARTE ALTA

MVI 00 C

// CONT PARTE BAJA

MVI 00 D

// PARTE BAJA

MVI 00 E

// PARTE ALTA

LDAX CPI 00 BEQ INCCONTPARTBA

BUCLE:

INC D CPI FD BEQ FINAL

FIN:

MOV C A STA FFFE MOV D A STA FFFF JMP FIN

INCCONTPARTBA:

INC C CPI FF INCPARTEALTA

INCPARTEALTA:

INC B MVI 00 D JMP CONT

CONT:

MOV C A CPI FF BEQ INCPARTEALTCONT

INCPARTEALTCONT:

INC B MVI 00 C JMP BUCLE

FINAL:

INC E MOV E A CPI FF BEQ FIN INC D JMP BUCLE1

Suma las ultimas 16 posiciones de memoria y guarda el resultado en E001(A) y E000(B) MVI 00 B

// PARTE BAJA CONTADOR

MVI 00 C

// PARTE ALTA CONTADOR

MVI FF D MVI F0 E BUCLE:

LDAX ADD B BC INCONTALT

NEXT:

MOV A B INC E MOV E A CPI FF BEQ FINAL JMP BUCLE

INCONTALT:

INC C JMP NEXT

FINAL:

MOV B A STA E000 MOV C A STA E3001

implementa un programa de ensamblador para la maquina plus que guarde en las posiciones E001 y E000 el resultado de la suma de los 5 registros de A, B, C, D y E STA FFFF MOV B A STA FFFE MOV C A STA FFFD MOV D A STA FFFC MOV E A STA FFFB MVI 00 C MVI 00 B MVI FF D MVI FB E

BUCLE:

LDAX ADD B BC INCPARTEALTA

NEXT:

INC E CPI FF BEQ FINAL JMP BUCLE

INCPARTEALTA: INC C JMP NEXT FINAL:

MOV B A STA E000 MOV C A STA E001 FIN

// V1 = E000- E025 V2 = D000- D025

// DE ----> Dir indirecto // B---> Temp // C ---> Contador MVI MVI BUCLE:

MVI

OO, C//INICIALIZAMOS EL CONTADOR 00, E//INICIALIZAMOS PARTE BAJA DE AMBOS VECTORES

E0, D// CARGAMOS PARTE ALTA DE V1 LDAX

// LEEMOS POSICION DEL VECTOR1

MOV

A,B // ALMACENAMOS EN REGISTRO TEMPORAL LA POSICION

MVI

D0, D//PASO A APUNTAR EL VECTOR 2

DEL VECTOR 1

LDAX

// LEER LA POSICION DEL VECTOR 2

CMP

B

BEQ NEXTPOS

MV1

//COMPARAMOS A(VECTOR2) CON B(VECTOR1)

INCCONT // SI A Y B SON IGUALES INCREMENTAMOS 25,A // GUARDO EN A LA ULTIMA POSICION DE CADA VECTOR

CMP BEQ

E

// COMPARAMOS LA POSICION ACTUAL

E

//PASAMOS A SIGUIENTE POSICION EN

FINAL

INC CADA VECTOR JMP

BUCLE

FINAL:

FIN

INCONT:

INC

C //SE INCREMENTA EL CONTADOR

JMP

NEXTPOS // PASAMOS A LA SIGUIENTE POSICION DE CADA VECTOR

IMPLEMENTA EN ENSAMBLADOR QUE COMPARE LAS POSICIONES CORRELATIVAS DE DOS VECTORES Y CALCULE EL NUMERO DE COINCIDENCIAS. VECTOR 1 CUBRE LAS PSOICIONES DE LA F000 A LA F01F Y EL VECTOR 2 DE LAS POSICIONES F020 A LA F03F // VECTOR 1 = F000 - F01F // VECTOR 2 = F020 - F03F // PARTE ALTA DE AMBOS VECTORES ES F0 --> D = E0 //PARTE BAJA DEL VECTOR 1 B e003 y e004 y num de posiciones en la e005 v3 --> e006 y e007 y num de posiciones en la e008 el programa almacenara el e009 y e00a el num de vectores, en e00b num de posiciones y e00c el checksum INISP 0000 LDA E000 MOV A, D LDA E001 MOV A, E LDA E002 MOV A, C CALL calcularCS MOV B, A

PUSH

//Subrutina que calcula el checksum de inicio //argumentos //posicion inicio

D-E

//longitud

C

calcularCS MVI loopCS:

00, B

LDAX

// B ALMACENA EL VALOR DEL CHECK SUM

// RECUPERO VALOR DE LA POSICIÓN DEL V1 ADD

B

MOV

A, B

MOV

C, A

//SUMO POSICION ACTUAL

//ACTUALIZAMOS CHECK SUM CON LA SUMA

SUI

1

BEQ

finCS

MOV

A,C

INC

E

//DECREMENTO NUMERO DE

POSICIONES

BEQ incDCS // INCREMENTAMOS PARTE BAJA Y SI DESBORDE, SALTAMOS A INCREMENTAR LA PARTE ALTA JMP incDCS

INC

D JMP

finCS

loopCS

loopCS

RET

Sumar lo que haya en las posiciones E001 E101 y E201 y almacenarlo en E301

LDA

E001

MOV

AB

LDA

E101

ADD

B

MOV

AB

LDA

E301

ADD

B

STA

E301

Realizar un programa que convierta un valor hexadecimal situado en la direccion F000 en un valor situado en las direcciones E000 PARTE BAJA Y E001 PARTE ALTA LDA

RESTAR100

00 C

//CENTENAS

MVI

00 D

//DECENAS

CalcDE

CPI

SUI

CPI

00 B

BC

RESTAR100

JMP

CalcDE

64 INR

C

JMP

CalcCE

0A

JMP SUI

//UNIDADES

64

BC

RESTAR10

//RECUPERAMOS VALOR

MVI

MVI CalcCE

F000

RESTAR10 CalcUD

0A INR

D

JMP

CalcDE

CalcUD

MOV

AB MVI

MULTX2

SUMARUDES

ADD

04 E

MOV

DA

ADD

A

INR

E

BEQ

SUMARUDES

JMP

MULTX2

B STA

E000

MOV

CA

STA

E001

implementa un programa de ensamblador para la maquina plus que guarde en las posiciones E001 y E000 el resultado de la suma de los 5 registros de A, B, C, D y E

STA

FFFF // PARA CARGAR EN MEMORIAR

MOV

B, A

STA

FFFE

MOV

C, A

STA

FFFD

MOV

D, A

STA

FFFC

MOV

E, A

STA

FFFB

MVI FF, D MVI FB, E MVI 00, B MVI 00, C

LOOP:

LDAX

ADD

B

BC NEXT:

INCH:

INC

INCH

E BEQ

FINAL

JMP

LOOP

INC C JMP NEXT

FINAL:

MOV B,A STA E000 MOV C, A STA E3001 FIN...