Imprima en pantalla los caracteres correspondientes a los valores 0-255

Se le agregan algunos valores y se le agrega la pila con un valor de 256 y la .DATA y se mueven los registros MOV ax,@data y MOV DS,AX

Corremos nuestro programa 

Después corremos en .exe y esto es lo que nos muestra

Cuestionario

1. Qué es el acceso a dispositivos de almacenamiento

los dispositivos de almacenamiento de acceso directo (direct access storage device o DASD en inglés) es cualquier tipo de dispositivo de almacenamiento secundario que tiene un tiempo de acceso bajo en proporción a su capacidad.

2. Como se hace el acceso a disco usando lenguaje ensamblador
Los datos se registran sobre la superficie del disco en una serie de circunferencias concentricas llamadas pistas (track).
Varias pistas , una por cada cara del disco (generalmente 2) , componen un cluster. Cada pista esta divida en porciones iguales llamadas sectores. Un sector es la unidad basica del almacenamiento en un disco, el tamaño de un sector se mide en bytes y depende de las caracteristicas del disco.

3. mencione y describa las unidades básicas de adaptador de video

1.-El controlador de video: Esta unidad es el "caballo de batalla", genera las señales de rastreo del monitor para el modo seleccionado, texto o gráfico. El procesador de la computadora envía instrucciones a los registros del controlador y lee ahí la información de estado.

2.- El video de BIOS: Actúa como una interfaz con el adaptador de video , contiene rutinas, como para establecer el cursor y desplegar caracteres.

3.- El área de despliegue de video: En memoria contiene la información que el monitor va a mostrar. Las interrupciones que manejan el despliegue en pantalla de forma directa transfieren a esta área sus datos. Las localidades del adaptador de video dependen de los modos de video que esten usando.

Para los adaptadores principales, a continuación están las direcciones del inicio de los segmentos de despliegue de video:

- A000:[0] Utilizada para descripción de fuentes cuando está en modo texto y para gráficos de alta resolución para EGA, MCGA y VGA.

- B000:[0] Modo de texto monocromático para MDA, EGA y VGA.

- B100:[0] Para HCG

-B800:[0] Modos de texto para CGA, MCGA, EGA y VGA y modos gráficos para CGA, EGA, MCGA y VGA.

Programación de dispositivos

Resumen

Ejecución de programa

Acceso a discos en lenguaje ensamblador

Dispositivo de almacenamiento de acceso directo a cualquier tipo de dispositivo de almacenamiento secundario que tiene un tiempo de acceso bajo en proporción a su capacidad.

Como se hace el acceso a disco usando lenguaje ensamblador:los datos se registran sobre la superficie del disco en una serie de circunferencias concentricas llamadas pistas (track).

varias pistas , una por cada cara del disco (generalmente 2) , componen un cluster. cada pista esta divida en porciones iguales llamadas sectores. un sector es la unidad básica del almacenamiento en un disco. el tamaño de un sector se mide en bytes y depende de las características del disco.

Un ejemplo de las 3 rutinas son : que permiten lectura y escritura absoluta de sectores, asi como la determinación del espacio libre
disponible en un disco.

Manejo de Disco
Para almacenar información permanente en grandes cantidades, las computadoras
cuentan con dispositivos especiales, llamados memoria secundaria o externa,
generalmente son dispositivos que almacenan información magnética.

Un disco es una superficie plana, magnética dividida en círculos concéntricos a los
cuales se les llama Tracks (pistas); además de tener 2 lados; cabe hacer mencionar que los
primero discos únicamente tenían 1 sola cara. Cada track esta dividido en sectores, los
cuales almacenan un determinado número de bytes.

Las unidades de disco, son dispositivos capaces de leer o escribir en un disco para
eso tienen una cabeza lectora quien realiza una operación de moverse al track deseado
(Seek Time), y luego espera por el sector seleccionado (Latency Time).








Seek Time: Tiempo en que se tarda en posicionar la cabeza lectora en moverse a un track.

El número de tracks y lados en un disco depende del hardware del disco, y de la

unidad que lo maneja, pero el número de sectores y el tamaño de los mismos se determina

en el momento de formatear el disco (depende del software).

Acceso al disco

Para leer o escribir en un disco, no se realiza byte a byte, sino más bien en bloques

de bytes, debido a que el acceso a disco implica movimientos mecánicos además de que el

acceso se da por sectores; en este proceso no intervienen el CPU, puesto que solo envía los

comandos a la interfase que maneja la unidad de disco y ésta es la que se encarga de leer o

escribir información de un área especial de memoria, llamada DMA; este proceso es

conocido como acceso directo a memoria






Un archivo se puede acceder de dos formas: acceso secuencial; en este caso se

sigue un orden en la lectura/escritura de registros, acceso aleatorio; en esta caso no se

sigue un orden establecido y se puede leer/escribir en cualquier registro.

En DOS, para trabajar con archivos se necesitan dos estructuras de datos:

Un área de memoria para el DTA, donde se van a escribir los registros.

DTA DB 128 DUP (0)
 Un área para el bloque de control de archivos (FCB) en donde se guarda

información importante para el acceso a archivo.

FCB DB 36 DUP (0)

El formato para el FCB es el siguiente:

Byte Contenido

0 Número de unidad donde se encuentra el archivo:

0 = Unidad corriente

1 = A

2 = B ...

1 – 8 Nombre del archivo en ASCII, los espacios que no se ocupen se

llenan con espacios en blanco.

9 – 0Bh Extensión en ASCII

0Ch – 0Dh Número de bloque corriente.

0Eh – 0Fh Tamaño de los registros, por default 80h.

10h – 13h Tamaño del archivo.

14h – 15h Fecha de la última actualización.

16h – 17h Hora de la última actualización.

<0 ... 4> segundos

<5 ... 11> minutos

<12 ... 15> horas

18h – 1Fh Reservados por el sistema.

20h Número de registro corriente relativo al inicio del bloque

corriente.

21h – 24h Número de registro corriente relativo al inicio del archivo.



Un bloque de archivo consta de 80h registros de 80h bytes cada uno. Al iniciar el

manejo de un archivo los únicos campos del FCB que se inicializan son el de la unidad, el

nombre y la extensión; los demás bytes se ponen en cero y son actualizados por el sistema

ejemplo

procedimientos y macros

   

 

 

 

Actividad #12

public class interfaz implements Runnable {

public static void main(String[] args) {
String mensaje = "";
byte opcion = 1;

System.out.print(" mensaje 100 veces\n"
+ " mensaje: ");
mensaje = new Scanner(System.in).next();
System.out.print("\n\n1) Con procedimiento\n2) Sin procedimiento\n: ");
opcion = new Scanner(System.in).nextByte();

Proc proc=new Proc();
new Thread(new interfaz()).start();
new Thread(proc).start();

if (opcion == 1) {
new interfaz().procedimiento(mensaje, 0);
} else if (opcion == 2) {
for (int i = 0; i < 100; i++) {
System.out.println(mensaje);
}
} else {
System.err.println("Opcion no valida!");
}
System.out.println("Tiempo: " + proc.paraYDevuelve()+ " milisegundos");
}

public void procedimiento(String mensaje, int iteracion) {
System.out.println(mensaje);
if (iteracion < 100) procedimiento(mensaje, iteracion + 1);
}

@Override public void run() {}
}

class Proc implements Runnable {
private boolean continua = true;
private int contador = 0;

public int paraYDevuelve() {
continua = false;
return contador;
}

@Override public void run() {
do {
try {
Thread.sleep(1);
} catch (InterruptedException ex) {
Logger.getLogger(interfaz.class.getName()).log(Level.SEVERE, null, ex);
}
contador++;
} while (continua);
}
}

 

Con proceso

 

Sin proceso

Actividad #11

La diferencia entre un procedimiento y un macro, es que los procedimientos leen línea por línea el código, y los macros no, los procedimientos usan la sentencia call para ser llamados en caso de que no esten implícitos en el código, y los macros utilizan la sentencia include cuando son externos al programas, tomando un conjunto de instrucciones que ya estan definidas y solo se ejecutan tal y como estan.
PROCEDIMIENTOS


SUM2DW_P.ASM
;
; Este programa suma dos variables de tipo palabra doble
; y guarda el resultado en una variable de tipo palabra
; doble. Este programa utiliza un procedimiento para
; efectuar la suma.
;
; El pseudocódigo de este programa es:
;
; DX:AX = dato1
; CX:BX = dato2
;
; suma2dw()
;
; resul = DX:AX
;**********************************************************
;****** CÓDIGO DE INICIO **********************************
ideal
dosseg
model small
stack 256
;****** VARIABLES DEL PROGRAMA ****************************
dataseg
codsal db 0
dato1 dd ?
dato2 dd ?
resul dd ?
;****** CÓDIGO DEL PROGRAMA *******************************
codeseg
inicio:
mov ax, @data ; Inicializa el
mov ds, ax ; segmento de datos
mov ax, [word dato1] ; DX:AX = dato1
mov dx, [word dato1+2]
mov bx, [word dato2] ; CX:BX = dato2
mov cx, [word dato2+2]
; Llama al procedimiento para efectuar la suma
call suma2dw ; suma2dw()
mov [word resul], ax ; resul = DX:AX
mov [word resul+2], dx
salir:
mov ah, 04Ch
mov al, [codsal]
int 21h
;****** PROCEDIMIENTOS ************************************
;**********************************************************
; SUMA2DW
;
; Este procedimiento suma dos variables de tipo
; palabra doble.
;
; Parámetros:
;
; DX:AX = Primer sumando
; CX:BX = Segundo sumando
;
; Regresa:
;
; DX:AX = Suma
;
; El pseudocódigo de este procedimiento es:
;
; DX:AX += CX:BX
;**********************************************************
proc suma2dw
add ax, bx ; DX:AX += CX:BX
adc dx, cx
ret ; Regresa del
; procedimiento
endp suma2dw
;****** CÓDIGO DE TERMINACIÓN *****************************
end inicio

;**********************************************************
; SWAPNIBL2.ASM
;
; Este programa intercambia los MSN y LSN de una variable
; de un byte. El resultado queda en la misma variable.
; Este programa utiliza un procedimiento para intercambiar
; los nibles.
;
; El pseudocódigo de este programa es:
;
; AL = dato
; swapnibl()
; dato = AL
;**********************************************************
;****** CÓDIGO DE INICIO **********************************
ideal
dosseg
model small
stack 256
;****** VARIABLES DEL PROGRAMA ****************************
dataseg
codsal db 0
dato db ?
;****** CÓDIGO DEL PROGRAMA *******************************
codeseg
inicio:
mov ax, @data ; Inicializa el
mov ds, ax ; segmento de datos
mov al, [dato] ; AL = dato
; Llama al procedimiento para intercambiar los nibles
call swapnibl ; swapnibl()
mov [dato], al ; dato = AL
salir:
mov ah, 04Ch
mov al, [codsal]
int 21h
;****** PROCEDIMIENTOS ************************************
;**********************************************************
; SWAPNIBL
;
; Este procedimiento intercambia los MSN y LSN de una
; variable de un byte.
;
; Parámetro:
;
; AL = dato
;
; Regresa:
;
; AL = dato con los nibles intercambiados.
;
; El pseudocódigo de este procedimiento es:
;
; CL = 4
; rol al, 4
;**********************************************************
proc swapnibl
push cx ; Preserva CX
mov cl, 4
rol al, cl
pop cx ; Recupera CX
ret
endp swapnibl
;****** CÓDIGO DE TERMINACIÓN *****************************
end inicio


MACROS
;Programa que muestra un marco desde la coordenada (Fila1,Columna1) hasta la (Fila2,Columna2)
;El programa, utiliza macros. funciona con LOOP. y utiliza la función 02h de la interreucipon 21h
;02:15 p.m. Miercoles, 18 de Octubre de 2006
MARCO MACRO FILA1, COL1, FILA2, COL2
LOCAL LINE_TOP
LOCAL EXIT_TOP
LOCAL LINE_BOTTOM
LOCAL EXIT_BOTTOM
LOCAL LINE_LEFT
LOCAL EXIT_LEFT
LOCAL LINE_RIGHT
LOCAL EXIT_RIGHT
;Recorremos desde COL2 hasta COL1 en FILA1
MOV cl,COL2 ;El contador decrementará desde COL2
LINE_TOP: ;
MOV AH,02h ;Set cursor position (Int 10/02)
MOV DH,fila1 ;Row
MOV DL,cl ;Column
MOV BH,0 ;page number: 0 = in graphics modes
int 10h ;Video (Int 10)

MOV AH,02h ;Write attributes/characters at cursor position (Int 10/09)
MOV DL,'+' ;Character
INT 21H ;

CMP Cl,COL1
je EXIT_TOP
LOOP LINE_TOP ;dec cx;cmp cx,0;jne line_left;
EXIT_TOP:

;Recorremos desde COL2 hasta COL1 en FILA2
MOV cl,col2
LINE_BOTTOM:
MOV AH,02h ;Set cursor position (Int 10/02)
MOV DH,fila2 ;Row
MOV DL,cl ;Column
MOV BH,0 ;page number: 0 = in graphics modes
int 10h ;Video (Int 10)

MOV AH,02h ;Write characters only at cursor position (Int 10/0A)
MOV DL,'+' ;Character
INT 21H

CMP Cl,COL1
je EXIT_BOTTOM
LOOP LINE_BOTTOM ;dec cx;cmp cx,0;jne line_left;
EXIT_BOTTOM:

;Recorremos desde FILA2 hasta FILA1 en COL1
MOV cl,FILA2
LINE_LEFT:
MOV AH,02h ;Set cursor position (Int 10/02)
MOV DH,cl ;Row
MOV DL,COL1 ;Column
MOV BH,0 ;page number: 0 = in graphics modes
int 10h ;Video (Int 10)

MOV AH,02h ;Write characters only at cursor position (Int 10/0A)
MOV DL,'+' ;Character
INT 21H

CMP Cl,FILA1
je EXIT_LEFT
LOOP LINE_LEFT ;dec cx;cmp cx,0;jne line_left;
EXIT_LEFT:

;Recorremos desde FILA2 hasta FILA1 en COL2
MOV cl,FILA2
LINE_RIGHT:
MOV AH,02h ;Set cursor position (Int 10/02)
MOV DH,cl ;Row
MOV DL,COL2 ;Column
MOV BH,0 ;page number: 0 = in graphics modes
int 10h ;Video (Int 10)

MOV AH,02h ;Write characters only at cursor position (Int 10/0A)
MOV DL,'+' ;Character
INT 21H

CMP Cl,FILA1
je EXIT_RIGHT
LOOP LINE_RIGHT ;dec cx;cmp cx,0;jne line_left;
EXIT_RIGHT:

;Dibujamos esquinas
MOV AH,02h ;Set cursor position (Int 10/02)
MOV DH,FILA1 ;Row
MOV DL,COL1 ;Column
MOV BH,0 ;page number: 0 = in graphics modes
int 10h ;Video (Int 10)

MOV AH,02h ;Write characters only at cursor position (Int 10/0A)
MOV DL,'@' ;Character
INT 21H

MOV AH,02h ;Set cursor position (Int 10/02)
MOV DH,FILA1 ;Row
MOV DL,COL2 ;Column
MOV BH,0 ;page number: 0 = in graphics modes
int 10h ;Video (Int 10)

MOV AH,02h ;Write characters only at cursor position (Int 10/0A)
MOV DL,'@' ;Character
INT 21H

MOV AH,02h ;Set cursor position (Int 10/02)
MOV DH,FILA2 ;Row
MOV DL,COL1 ;Column
MOV BH,0 ;page number: 0 = in graphics modes
int 10h ;Video (Int 10)

MOV AH,02h ;Write characters only at cursor position (Int 10/0A)
MOV DL,'@' ;Character
INT 21H

MOV AH,02h ;Set cursor position (Int 10/02)
MOV DH,FILA2 ;Row
MOV DL,COL2 ;Column
MOV BH,0 ;page number: 0 = in graphics modes
int 10h ;Video (Int 10)

MOV AH,02h ;Write characters only at cursor position (Int 10/0A)
MOV DL,'@' ;Character
INT 21H

ENDM

CLS MACRO ;Clear Screen
MOV AH, 00H ;Set video mode
MOV AL, 03H ;Video mode 80x25, 8x8, 16, 4, B800, CGA
INT 10H ;Video (Int 10)
ENDM

.model small
.stack
.code
.startup

CLS
MARCO 1,1,22,78
MARCO 5,15,15,25
MARCO 3,3,8,8
MARCO 3,30,18,70

;Enviar cursor a ultima línea
MOV AH,02h ;Set cursor position (Int 10/02)
MOV DX,1700H ;Row & Col
MOV BH,0 ;Page number: 0 = in graphics mode
int 10h

.exit
end

Preguntas

Actividad Martes 5

Calcular el numero mayor y el menor

 

 

Menor

 

 

Ejercicios en ensamblador

Se pretende realizar un programa en lenguaje ensamblador equivalente al siguiente código en C:

#include <iostream.h>

main()
{

int a[] = {12, 5, 34, 75, 10, 25};
int n = 6;
int max, i;
for (max = i = 0; i < n; i++)
if (a[i] > max)
max = a[i];
cout << max << end1;
}

Analisis en cuaderno

Código  en ensamblador

Aplicacion de DEBUG

Ejercicio # 2

#2: (Implementación de la condición if-then-else) Se pretende realizar un programa en lenguaje ensamblador equivalente al siguiente código en C:#include <iostream.h>
main()
{
int a[] = {-12, 5, -34, -75, -10, 25};
int n = 6;
int max, i;
int npos, nneg;
for (i = npos = nneg = 0; i < n; i++)
if (a[i] > 0)
npos++;
else
nneg++;
cout << “+: “ << npos << “; -: “ << nneg << end1;
}

Analisis

En el programa se utiliza las variables npos y nneg,max despues se utiliza el .DATA en
el codigo del lengujes ensamblador. despues moviendo axa ds y despues cargar los valores de a en SI, para despues
utilizar el ciclo que compara cada uno de los datos del arreglo a
con cero, y asi determinar si es positivo o negativo y asi ir agregando los valores en las variables npos y nneg.

 

 Código en ensamblador

 

Debug

Desplazamiento, Rotación y Adeudos

Desplazamiento, Rotación y Adeudos


Las instrucciones de corrimiento, que son parte de la capacidad lógica de la computadora, pueden realizar las siguientes acciones:

1. Hacer referencia a un registro o dirección de memoria.
2. Recorre bits a la izquierda o a la derecha.
3. Recorre hasta 8 bits en un byte, 16 bits en una palabra y 32 bits en una palabra doble.
4. Corrimiento lógico (sin signo) o aritmético (con signo).


El segundo operando contiene el valor del corrimiento, que es una constante (un valor inmediato) o una referencia al registro CL. Para los procesadores 8088/8086, la constante inmediata solo puede ser 1; un valor de corrimiento mayor que 1 debe estar contenido en el registro CL. Procesadores posteriores permiten constantes de corrimiento inmediato hasta 31.



DESPLAZAMIENTO O CORRIMIENTO DE BITS HACIA LA DERECHA.
Los corrimientos hacia la derecha (SHR y SAR) mueven los bits hacia la derecha en el registro designado. El bit recorrido fuera del registro mete la bandera de acarreo. Las instrucciones de corrimiento a la derecha estipulan datos lógicos (sin signo) o aritméticos (con signo):

Las siguientes instrucciones relacionadas ilustran SHR y datos con signo:

INSTRUCCION COMENTARIO
MOV CL, 03
MOV AL, 10110111B ; AL = 10110111
SHR AL, 01 ; AL = 01011011 Un corrimiento a la derecha
SHR AL, CL ; AL = 00001011 Tres corrimientos adicionales a la derecha

El primer SHR desplaza el contenido de AL un bit hacia la derecha. El bit de mas a la derecha es enviado a la bandera de acarreo, y el bit de mas a la izquierda se llena con un cero. El segundo SHR desplaza tres bits más a AL. La bandera de acarreo contiene de manera sucesiva 1, 1 y 0; además, tres bits 0 son colocados a la izquierda del AL.


SAR se difiere de SHR en un punto importante: SAR utiliza el bit de signo para llenar el bit vacante de más a la izquierda. De esta manera, los valores positivos y negativos retienen sus signos. Las siguientes instrucciones relacionadas ilustran SAR y datos con signo en los que el signo es un bit 1:

En especial, los corrimientos a la derecha son útiles para (dividir entre 2) obtener mitades de valores y son mucho más rápidas que utilizar una operación de división. Al terminar una operación de corrimiento, puede utilizar la instrucción JC (Salta si hay acarreo) para examinar el bit desplazado a la bandera de acarreo.



DESPLAZAMIENTO O CORRIMIENTO DE BITS A LA IZQUIERDA.


Los corrimientos hacia la izquierda (SHL y SAL) mueven los bits a la izquierda, en el registro designado. SHL y SAL son idénticos en su operación. El bit desplazado fuera del registro ingresa a la bandera de acarreo. Las instrucciones de corrimiento hacia la izquierda estipulan datos lógicos (sin signo) y aritméticos (con signo):

SHL: Desplazamiento lógico a la izquierda SAL: Desplazamiento aritmético a la izquierda




Las siguientes instrucciones relacionadas ilustran SHL para datos sin signo:

INSTRUCCION COMENTARIO
MOV CL, 03
MOV AL, 10110111B ; AL = 10110111
SHL AL, 01 ; AL = 01101110 Un corrimiento a la izquierda
SHL AL, CL ; AL = 01110000 Tres corrimientos mas

El primer SHL desplaza el contenido de AL un bit hacia la izquierda. El bit de más a la izquierda ahora se encuentra en la bandera de acarreo, y el último bit de la derecha del AL se llena con cero. El segundo SHL desplaza tres bits más a AL. La bandera de acarreo contiene en forma sucesiva 0, 1 y 1, y se llena con tres ceros a la derecha del AL.


Los corrimientos a la izquierda llenan con cero el bit de mas a la derecha. Como resultado de esto, SHL y SAL don idénticos. Los corrimientos a la izquierda en especial son útiles para duplicar valores y son mucho más rápidos que usar una operación de multiplicación.


Al terminar una operación de corrimiento, puede utilizar la instrucción JC (Salta si hay acarreo) para examinar el bit que ingreso a la bandera de acarreo.



ROTACIÓN A LA DERECHA DE BITS
Las rotaciones a la derecha (ROR y RCR) desplazan a la derecha los bits en el registro designado. Las instrucciones de rotación a la derecha estipulan datos lógicos (sin signo) o aritméticos (con signo):


Las siguientes instrucciones relacionadas ilustran ROR:


INSTRUCCION COMENTARIO
MOV CL, 03
MOV BH, 10110111B ; BH = 10110111
ROR BH, 01 ; BH = 11011011 Una rotación a la derecha
ROR BH, CL ; BH = 00001011 Tres rotaciones a la derecha


El primer ROR desplaza el bit de más a la derecha del BH a la posición vacante de más a la izquierda. La segunda y tercera operaciones ROR realizan la rotación de los tres bits de mas a la derecha.


RCR provoca que la bandera de acarreo participe en la rotación. Cada bit que se desplaza fuera de la derecha se mueve al CF y el bit del CF se mueve a la posición vacante de la izquierda.


ROTACIÓN A LA IZQUIERDA DE BITS
Las rotaciones a la izquierda (ROL y RCL) desplazan a la izquierda los bits del registro designado. Las instrucciones de rotación a la izquierda estipulan datos lógicos (sin signo) y aritméticos (con signo):

Las siguientes instrucciones relacionadas ilustran ROL:


INSTRUCCION COMENTARIO
MOV CL, 03
MOV BL, 10110111B ; BL = 10110111
SHR BL, 01 ; BL = 11011011 Una rotación a la izquierda
SHR BL, CL ; BL = 00001011 Tres rotaciones a la izquierda

El primer ROL desplaza el bit de mas a la izquierda del BL a la posición vacante de mas a la derecha. La segunda y tercera operaciones ROL realizan la rotación de los tres bits de mas a la izquierda.


De manera similar a RCR, RCL también provoca que la bandera de acarreo participe en la rotación. Cada bit que se desplaza fuera por la izquierda se mueve al CF, y el bit del CF se mueve a la posición vacante de la derecha.

Hacer manualmente la ejecución y comprobar con el debug