lunes, 25 de noviembre de 2013

ACTIVIDAD 25 NOV. 2013



1.Qué es el acceso a dispositivos de almacenamiento?
Forma en que se puede leer y escribir datos en un dispositivo auxiliar a la memoria principal.

2.Como se hace el acceso a disco usando lenguaje ensamblador?
La interrupción 21h, función 7305h, es decir la lectura y escritura de disco absoluta, permite leer y escribir sectores lógicos de disco. La función 7305 trabaja en el sistema de archivos FAT12, FAT16 y FAT32. Cualquier programa que permita leer y escribir los sectores de disco puede sobrepasar los permisos de los archivos y directorios compartido

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 grafico.

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

3- El area de despliegue de video: en memoria contiene la informacion que el monitor va a mostrar. las interrupciones que manejan el despliegue en pantalla de forma directa transfieren a esta area sus datos.
Las localidades del adaptador de video dependen de los modos de video que se esten usando.

A000:[0] utilizada para descripcion de fuentes cuando esta en modo de texto y para graficos de alta resolucion para EGA,MCGA Y VGA
B000:[0] Modo de texto monocromatico para MDA,EGA Y VGA
B100:[0] Para HCG
B800:[0] Modos de texto para CGA,MCGA,EGA Y VGA Y modos graficos para CGA,EGA,MCGA Y VGA


 

miércoles, 20 de noviembre de 2013

Acceso a discos en lenguaje ensamblador




1.Qué es el acceso a dispositivos de almacenamiento?
Forma en que se puede leer y escribir datos en un dispositivo auxiliar a la memoria principal.

2.Como se hace el acceso a disco usando lenguaje ensamblador?

La interrupción 21h, función 7305h, es decir la lectura y escritura de disco absoluta, permite leer y escribir sectores lógicos de disco. La función 7305 trabaja en el sistema de archivos FAT12, FAT16 y FAT32. Cualquier programa que permita leer y escribir los sectores de disco puede sobrepasar los permisos de los archivos y directorios compartido

3. Busque y ejecute un programa de demuestre en su ejecucion el acceso a disco para grabar y leer


 un ejemplo podria ser : rutina_absolutedRead: transfiere de un o mas sectores al buffer especificado accesando directamente a los sectores logicos.
en caso de error se enciende el bit de acarreo y ax con el codigo de error.


invocacion: push<unidad de disco>
            push<numero de sectores a leer>
            push<primer sector a leer>
            push SEG<buffer>
            push OFFSET<buffer>
            call_AbsoluteRead


            PUBLIC_AbsoluteRead
_AbsoluteRead  PROCNEAR
            ARG Buffer:DWORD,Start:WORD,NumSect:WORD,Drive:BYTE=ArgLen
            push bp        ;salvar BP
            mov bp,sp      ;permitir acceso a los argumentos
            push bx        ;salvar registros
            push cx
            push dx 
            push ds 

            mov al,Drive   ;lectura absoluta del disco
            mov cx,NumSect
            mov dx,Start
            lds bx,Buffer
            int 25h
            pop bx

            pop ds         ;recuperar registros 
            pop dx
            pop cx
            pop bx
            pop bp
            ret ArgLen
AbsoluteRead  ENDP

Programación de dispositivos resumen






 
programa ejemplo:

 
 
 
 


miércoles, 13 de noviembre de 2013

actividad de competencia

1. pregunta de  código ( lenguaje ensamblador), corrección de error, contenido de registro etc


1- ¿que es lo que hace la linea 19 en el siguiente código?





2- realice las siguientes sumas de números binarios:









3 - conteste la siguiente pregunta:















martes, 12 de noviembre de 2013

Actividad #12


En un lenguaje de su conocimiento debe Hacer un programa para imprimir 100 veces un mensaje
1. Sin usar procedimientos
2. Usando llamadas a procedimientos
3. Incluya una funcion de tiempo que imprima el tiempo de inicio y el tiempo al final para medir el tiempo de ejecución




-----------------sin procedimientos----------------------------------

package unidad3;

public class ejemplo2 {
     
    double inicio1,finals1;
  
    public void mensaje1(){
        inicio1=System.currentTimeMillis();
       
        System.out.println("\tTiempo inicio: "+inicio1);
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
         System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
         System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
         System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
         System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
         System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
         System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
         System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
         System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
         System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
        System.out.println(".-"+" mi clase de lenguajes de interfaz");
       
       
       
        finals1=System.currentTimeMillis()-inicio1;
       
  
        System.out.println("\tTiempo final: "+finals1);
    }
        public static void main(String[] args) {
            ejemplo2 app=new ejemplo2();
            app.mensaje1();
           
        }
       










-------------------con procedimientos-----------------------


package unidad3;

public class procedimientos {
     
    double inicio,finals;
  
    public void mensaje(){
        inicio=System.currentTimeMillis();
       
        System.out.println("\tTiempo inicio: "+inicio);
       
        for (int i = 1; i<=100; i++){
        System.out.println(i+".-"+" mi clase de lenguajes de interfaz");
       
        finals=System.currentTimeMillis()-inicio;
       
        }
        System.out.println("\tTiempo final: "+finals);
    }
        public static void main(String[] args) {
            procedimientos app=new procedimientos();
            app.mensaje();
           
        }
       
    }
  
   



 

domingo, 10 de noviembre de 2013

Actividad #11


MACROS

Las macros son útiles para los siguientes propósitos:

* Simplificar y reducir la cantidad de codificación repetitiva.
* Reducir errores causados por la codificación repetitiva.
* Linealizar un programa en lenguaje ensamblador para hacerlo mas legible.


INITZ MACRO                      ;define macro 
      MOV   AX,@data             ;}cuerpo de 
      MOV   DS,AX                ;{la definicion
      MOV   ES,AX                :{de la macro
      ENDM                       ;Fin de la macro

una macro que recibe un parametro y que permite cadenas en pantalla seria  :


.MACRO Imprime_Cad(cadena)
LEA DX,Cadena
MOV AH,09h
INT 21h
ENDM

PROCEDIMIENTOS

A continuación se describen los pasos necesarios para la ejecución de un procedimiento:

1. Se encuentra la llamada Call.
2. El microprocesador almacena en la Pila el contenido del IP.
3. Se coloca en el IP el valor del desplazamiento correspondiente al Procedimiento.
4. El microprocesador ejecuta las instrucciones del procedimiento.
5. El procedimiento termina cuando se encuentra con la instrucción Ret.
6. Se saca de la Pila el valor original del IP y se continua el flujo del programa

El siguiente procedimiento coloca el cursor en las coordenadas establecidas en DI y DH:

PROC GotoXY
XOR BH,BH
MOV AH,02H
INT 10h
RET
ENDP GotoXY

--------------------------------------------------------



         page 60,132 
TITLE     P08CALLP (EXE) Llamada a procedimientos 
               .MODEL     SMALL 
               .STACK      64 
               .DATA 
;--------------------------------------------------------------------- 
               .CODE 
BEGIN    PROC        FAR 
               CALL          B10             ;Llama a B10 
;              ... 
               MOV         AX,4C00H     ;Salida a DOS 
               INT 21H 
BEGIN    ENDP 
;--------------------------------------------------------------------- 
B10        PROC       NEAR 
              CALL         C10               ;Llama a C10 
;             ... 
              RET                                ;De regreso 
B10       ENDP                              ;Quien llama 
;--------------------------------------------------------------------- 
             END BEGIN



diferencia entre macro y procedimiento:

El empleo de macros no debemos confundirlo con el empleo de procedimientos, ya que una llamada a una macro sustituye su nombre por el cuerpo de la misma, en cambio, una llamada a procedimientos lo único que realiza es un enlace con otro programa. Las macros se suelen incluir todas dentro de ficheros específicos. En cada uno de los ficheros situaremos las macros que tengan alguna relación entre sí

domingo, 3 de noviembre de 2013

act 28 de octubre (if-thn)



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

Este programa calcula el máximo de los elementos del array a, almacenádolo en la variable max.












jueves, 31 de octubre de 2013

Instrucciones de Desplazamiento, Rotación y Adeudos.

SHL, SAL desplazar a la izquierda(desplazamient o aritmético)


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.



· SHR desplazar a la derecha


SHR (Shift Right = desplazamiento a la derecha)

(s) shr {R|M}, {cl|I8}

(explicación)

La instrucción shr funciona de la misma forma que shl, pero desplazando los bits a la derecha en lugar de a la izquierda, tal y como se muestra en la figura siguiente.

· SAR desplazamientoaritmético a la derecha



SAR (Shift Arithmetic Right = desplazamiento aritmético a la derecha)

(s) sar {R|M}, {cl|I8}

(explicación)

Esta instrucción desplaza los bits del operando destino a la derecha tantos bits como indique el operando fuente. Esta forma de funcionamiento es similar a la de la instrucción shr; sin embargo, ambas instrucciones se diferencian en que sar, en vez introducir ceros por la izquierda del operando, replica el bit de mayor peso (bit de signo) en cada desplazamiento. esquemáticamente, la instrucción sar trabaja de la siguiente forma:

El desplazamiento a la derecha realizado por la instrucción sar recibe el nombre de aritmético porque sirve para dividir un operando entre una potencia entera de 2.

El desplazamiento aritmético a la derecha de un operando (considerado con signo) n posiciones equivale a la división entera del operando entre 2n.

(ejemplo)

Supongamos que se desea desplazar aritméticamente el contenido del registro AL dos posiciones a la izquierda, y que el contenido de este registro antes de realizar el desplazamiento es B0h, que interpretado en complemento a 2 equivale al entero -80.


· ROL rotación a 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:



MOV CL, 03
MOV BL, 10110111B ; 10110111
SHR BL, 01 ; 11011011 Una rotación a la izquierda
SHR BL, CL ; 00001011 Tres rotaciones a la izquierda
SHR BX, 03 ; Válido para 80186 y procesadores posteriores
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.




· ROR rotación a la derecha


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.


· RCL rotación con acarreo a 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.

 

Puede usar la instrucción JC (salta si hay acarreo) para comprobar el bit rotado hacia la CF en el extremo de una operación de rotación.


· CLC borrar acarreo


Propósito: Limpiar bandera de acarreo.

Sintaxis:

CLC

Esta instrucción apaga el bit correspondiente a la bandera de acarreo, o sea, lo pone en cero.


·STC poner acarreo a 1