Lenguajes de Interfaz

domingo, 1 de diciembre de 2013

viernes, 22 de noviembre de 2013

actividad

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

¿Comó 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.

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 tamamaño de un sector se mide en bytes y depende de las caracteristicas del disco.

Programa en ensamblador que realice el acceso a disco para grabar y leer
TITLE Sector Display Program (Sector.asm)

; Demonstrates INT 21h function 7305h (ABSDiskReadWrite)
; This Real-mode program reads and displays disk sectors.
; Works on FAT16 & FAT32 file systems running under Windows
; 95, 98, and Millenium.
; Last update: 06/01/2006

INCLUDE Irvine16.inc

Setcursor PROTO, row:BYTE, col:BYTE
EOLN EQU <0dh,0ah>
ESC_KEY = 1Bh
DATA_ROW = 5
DATA_COL = 0
SECTOR_SIZE = 512
READ_MODE = 0 ; for Function 7505h

DiskIO STRUCT
startSector DWORD ? ; starting sector number
numSectors WORD 1 ; number of sectors
bufferOfs WORD OFFSET buffer ; buffer offset
bufferSeg WORD SEG buffer ; buffer segment
DiskIO ENDS

.data
driveNumber BYTE ?
diskStruct DiskIO <>
buffer BYTE SECTOR_SIZE DUP(0),0 ; one sector

curr_row BYTE ?
curr_col BYTE ?

; String resources
strLine BYTE EOLN,79 DUP(0C4h),EOLN,0
strHeading BYTE "Sector Display Program (Sector.exe)"
BYTE EOLN,EOLN,0
strAskSector BYTE "Enter starting sector number: ",0
strAskDrive BYTE "Enter drive number (1=A, 2=B, "
BYTE "3=C, 4=D, 5=E, 6=F): ",0
strCannotRead BYTE EOLN,"*** Cannot read the sector. "
BYTE "Press any key...", EOLN, 0
strReadingSector \
BYTE "Press Esc to quit, or any key to continue..."
BYTE EOLN,EOLN,"Reading sector: ",0

.code
main PROC
mov ax,@data
mov ds,ax
call Clrscr
mov dx,OFFSET strHeading ; display greeting
call Writestring ; ask user for...
call AskForSectorNumber

L1: call Clrscr
call ReadSector ; read a sector
jc L2 ; quit if error
call DisplaySector
call ReadChar
cmp al,ESC_KEY ; Esc pressed?
je L3 ; yes: quit
inc diskStruct.startSector ; next sector
jmp L1 ; repeat the loop

L2: mov dx,OFFSET strCannotRead ; error message
call Writestring
call ReadChar

L3: call Clrscr
exit
main ENDP

;-----------------------------------------------------
AskForSectorNumber PROC
;
; Prompts the user for the starting sector number
; and drive number. Initializes the startSector
; field of the DiskIO structure, as well as the
; driveNumber variable.
;-----------------------------------------------------
pusha
mov dx,OFFSET strAskSector
call WriteString
call ReadInt
mov diskStruct.startSector,eax
call Crlf
mov dx,OFFSET strAskDrive
call WriteString
call ReadInt
mov driveNumber,al
call Crlf
popa
ret
AskForSectorNumber ENDP

;-----------------------------------------------------
ReadSector PROC
;
; Reads a sector into the input buffer.
; Receives: DL = Drive number
; Requires: DiskIO structure must be initialized.
; Returns: If CF=0, the operation was successful;
; otherwise, CF=1 and AX contains an
; error code.
;-----------------------------------------------------
pusha
mov ax,7305h ; ABSDiskReadWrite
mov cx,-1 ; always -1
mov dl,driveNumber ; drive number
mov bx,OFFSET diskStruct ; sector number
mov si,READ_MODE ; read mode
int 21h ; read disk sector
popa
ret
ReadSector ENDP

;-----------------------------------------------------
DisplaySector PROC
;
; Display the sector data in <buffer>, using INT 10h
; BIOS function calls. This avoids filtering of ASCII
; control codes.
; Receives: nothing. Returns: nothing.
; Requires: buffer must contain sector data.
;-----------------------------------------------------
mov dx,OFFSET strHeading ; display heading
call WriteString
mov eax,diskStruct.startSector ; display sector number
call WriteDec
mov dx,OFFSET strLine ; horizontal line
call Writestring
mov si,OFFSET buffer ; point to buffer
mov curr_row,DATA_ROW ; set row, column
mov curr_col,DATA_COL
INVOKE SetCursor,curr_row,curr_col

mov cx,SECTOR_SIZE ; loop counter
mov bh,0 ; video page 0
L1: push cx ; save loop counter
mov ah,0Ah ; display character
mov al,[si] ; get byte from buffer
mov cx,1 ; display it
int 10h
call MoveCursor
inc si ; point to next byte
pop cx ; restore loop counter
loop L1 ; repeat the loop
ret
DisplaySector ENDP

;-----------------------------------------------
MoveCursor PROC
;
; Advance the cursor to the next column,
; check for possible wraparound on screen.
;-----------------------------------------------
cmp curr_col,79 ; last column?
jae L1 ; yes: go to next row
inc curr_col ; no: increment column
jmp L2
L1: mov curr_col,0 ; next row
inc curr_row
L2: INVOKE Setcursor,curr_row,curr_col
ret
MoveCursor ENDP

;-----------------------------------------------------
Setcursor PROC USES dx,
row:BYTE, col:BYTE
;
; Set the screen cursor position
;-----------------------------------------------------
mov dh, row
mov dl, col
call Gotoxy
ret
Setcursor ENDP

END main

http://kipirvine.com/asm/examples/index.htm

resumen

miércoles, 13 de noviembre de 2013

preguntas

¿Qué realiza este código?

pregunta 2

pregunta 3

martes, 12 de noviembre de 2013

programa imprime 100 veces

programa que imprime 100 veces un mensaje:

lunes, 11 de noviembre de 2013

procedimientos y macros

ejemplos de macros:
Programa 1:
FIN MACRO
MOV AH, 4CH
INT 21H
ENDM
;---------------------------------------------------

PILA SEGMENT PARA STACK "STACK"
DB 200 DUP (0)
PILA ENDS
;---------------------------------------------------

DATOS SEGMENT PARA "DATA"
VA DB "DESPUES DE MEDIO DIA (Y/N): ","$"
VD DB 13,10," BUENOS DIAS","$"
VT DB 13,10," BUENAS TARDES","$"
DATOS ENDS
;---------------------------------------------------

CODIGO SEGMENT PARA "CODE"
EMPIEZA PROC FAR
ASSUME CS: CODIGO, DS: DATOS, SS: PILA

MOV AX, DATOS
MOV DS, AX

MOV AH, 0FH
INT 10H
MOV AH, 00H
INT 10H

MOV DX,OFFSET VA
MOV AH,9
INT 21H

CALL PREGUNTA

EMPIEZA ENDP

PREGUNTA PROC NEAR

MOV AH, 01H
INT 21H

CMP AL, "Y"
JZ TARDES

CMP AL, "N"
JZ DIAS

CMP AL, "y"
JZ TARDES

CMP AL, "n"
JZ DIAS

TARDES:
MOV DX, OFFSET VT
MOV AH, 09
INT 21H
FIN

DIAS:
MOV DX, OFFSET VD
MOV AH, 09
INT 21H
FIN

RET
PREGUNTA ENDP

CODIGO ENDS
END EMPIEZA

Programa 2:

 INICIO   MACRO           ; Define macro
             MOV AX, DATA    ; cuerpo de  
             MOV DS, AX      ; la definición
             MOV ES, AX      ; de la macro
    ENDM

ejemplo de 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

La principal diferencia entre una macro y un procedimiento es que en la macro se hace posible el paso de parámetros y en el procedimiento no (esto es aplicable solo para el MASM, hay otros lenguajes de Programación que si lo permiten). Al momento de ejecutarse la macro cada parámetro es sustituido por el nombre o valor especificado al momento de llamarla.

Podemos decir entonces que un procedimiento es una extensión de un determinado programa, mientras que la macro es un módulo con funciones específicas que puede ser utilizado por diferentes programas.

Otra diferencia entre una macro y un procedimiento es la forma de llamar a cada uno, para llamar a un procedimiento se requiere el uso de una directiva, en cambio la llamada a las macros se realiza como si se tratara de una instrucción del ensamblador.

lunes, 4 de noviembre de 2013

programa 2

Ejemplo # 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:
Código:

#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;

}