LENGUAJES DE INTERFAZ: 2019

miércoles, 8 de mayo de 2019

Programa 9 Colores 2

include 'emu8086.inc'

CUADRO MACRO XI,YI,XF,YF,COLOR
MOV AX, 0600H
MOV BH, COLOR
MOV BL, 00H
MOV CH, YI
MOV CL, XI
MOV DH, YF
MOV DL, XF
INT 10h
endM

Cuadros macro

cuadro 1,1,10,5,160
posicion 2,3
desplegar M1

cuadro 1,1,10,5,40
posicion 3,3
desplegar M2

cuadro 1,1,10,5,70
posicion 4,3
desplegar M3

cuadro 1,1,10,5,100
posicion 5,3
desplegar M4

cuadro 1,1,10,5,130
posicion 6,3
desplegar M5

cuadro 1,1,10,5,160
posicion 7,3
desplegar M6

cuadro 1,1,10,5,180
posicion 8,3
desplegar M7

cuadro 1,1,10,5,200
posicion 2,3
desplegar M8

cuadro 1,1,10,5,20
posicion 2,3
desplegar M9

cuadro 1,1,10,5,40
posicion 2,3
desplegar M10

cuadro 1,1,10,5,60
posicion 2,3
desplegar M11

cuadro 1,1,10,5,80
posicion 2,3
desplegar M12

cuadro 1,1,10,5,120
posicion 2,3
desplegar M13

cuadro 1,1,25,5,160
posicion 2,3
desplegar M14

endM

POSICION MACRO X,Y
MOV DH, Y
MOV DL, X
MOV AH, 02
MOV BH, 00
INT 10H
ENDM

DESPLEGAR MACRO MENSAJE
MOV AH,09
MOV DX,OFFSET MENSAJE
INT 21h
ENDM

DATOS SEGMENT
M1 DB "E",'$'
M2 DB "Q",'$'
M3 DB "U",'$'
M4 DB "I",'$'
M5 DB "P",'$'
M6 DB "O",'$'
M7 DB "1",'$'
M8 DB "EQUIPO1",'$'
M9 DB "HUMBERTO",'$'
M10 DB "PEDRO",'$'
M11 DB "HUMBERTO",'$'
M12 DB "PEDRO",'$'
M13 DB "HUMBERTO",'$'
M14 DB "EQUIPO1 HUMBERTO, PEDRO",'$'

datos ends

CODIGO SEGMENT
ASSUME CS: CODIGO,DS:DATOS,SS:PILA
PRINCIPAL PROC

MOV AX,DATOS
MOV DS,AX
Cuadros

PRINCIPAL ENDP

CODIGO ENDS

END PRINCIPAL

Programa 9 Colores 2

sábado, 27 de abril de 2019

15 Programas en Turbo Assembler

https://drive.google.com/open?id=1rTDd9iiCr9weepxBG8Yi7fBr7fs_QxFj

PROGRAMA NO.15 NUMERO ASCII

M_ASCII_ASCII DB 13,10,13,10,"NUMERO ASCII IMPERO NORMALMENTE COMO LO HACE UNA PC (EN ASCII)",13,10,"$"
M_BINARIO_ASCII DB 13,10,13,10,"NUMERO BINARIO (YA CONVERTIDO),",13,10,"IMPERSO NORMALMENTE COMO LO HACE UNA PC (EN ASCII): ","$"
POTENCIA DW 001H, 000AH,0064H,03E8H,2710H,"$"
DATOS ENDS
PILA SEGMENT STACK 'STACK'
DW 128 DUP('P')
PILA ENDS
CODIGO SEGMENT
CAPT PROC NEAR
ASSUME CS:CODIGO,DS:DATOS,SS:PILA
MOV AX,DATOS
MOV DS,AX
MOV AH,0AH
MOV DX,OFFSET NUMERO_ASCII
INT 21H
MOV DI,OFFSET NUMERO_ASCII + 1
MOV CX, [DI]
MOV SI,OFFSET NUMERO_ASCII+2
XOR CH,CH
MOV DI,OFFSET POTENCIA
DEC SI
ADD SI,CX
XOR BX, BX
STD
CICLO:
LODSB
SUB AL,30H
CBW
MOV DX,[DI]
MUL DX
ADD DI,2
ADD BX,AX
LOOP CICLO
MOV NUMERO_BINARIO,BX
LEA DX,M_ENCABEZADO
CALL ESCRIBE
LEA DX,M_ASCII_ASCII
CALL ESCRIBE
LEA DX,NUMERO_ASCII - 1
CALL ESCRIBE
LEA DX, M_BINARIO_ASCII
CALL ESCRIBE
LEA DX, NUMERO_BINARIO
CALL ESCRIBE
LEA DX, M_ESPACIO
CALL ESCRIBE
CALL SALIR
CAPT ENDP
ESCRIBE PROC
MOV AH,IMPRIMIR
INT DOS
RET
ESCRIBE ENDP
SALIR PROC NEAR
MOV AX, FIN
INT DOS
SALIR ENDP
END CAPT

PROGRAMA NO.14 POTENCIA BINARIO

CR EQU 13
LF EQU 10
IMPRIMIR EQU 9
FIN EQU 4C00H
DOS EQU 21H
TAB EQU 09H
BELL EQU 07H
DATOS SEGMENT
ENCABEZADO DB 13,10,13,TAB,TAB, "=========="
DB 13,10,13,TAB,TAB,"PROGRAMA QUE CONVIERTE NUMEROS ASCII A BINARIO"
DB 13,10,13,TAB,TAB,"===============",13,10,13,"$"
VALOR_ASCII DB '33',"$"
VALOR_BINARIO DW 0, "$"
LONGITUD_ASCII DW 2,"$"
POTENCIA_10 DW 00000001B,"$"
DATOS ENDS
PILA SEGMENT STACK
DB 64 DUP('0')
PILA ENDS
CODIGO SEGMENT
POTE PROC NEAR
ASSUME CS:CODIGO,DS:DATOS,SS:PILA
MOV AX,DATOS
MOV DS,AX
LEA DX,VALOR_ASCII
CALL ESCRIBE
MOV BX,00001010B
MOV CX,LONGITUD_ASCII
LEA SI,VALOR_ASCII+1
ETIQUETA_1:
MOV AL,[SI]
AND AX,000FH
MUL POTENCIA_10
ADD VALOR_BINARIO, AX
MOV AX,POTENCIA_10
MUL BX
MOV POTENCIA_10,AX
DEC SI
LOOP ETIQUETA_1
LEA DX,ENCABEZADO
CALL ESCRIBE
LEA DX,VALOR_BINARIO
CALL ESCRIBE
CALL SALIR
POTE ENDP
ESCRIBE PROC
MOV AH,9
INT 21H
RET
ESCRIBE ENDP
SALIR PROC NEAR
MOV AX,FIN
INT DOS
RET
SALIR ENDP
CODIGO ENDS
END POTE

PROGRAMA NO.13 NUMEROS EN HEXADECIMAL

CR EQU 13
LF EQU 10
IMPRIMIR EQU 9
FIN EQU 4C00H
DOS EQU 21H
TAB EQU 09H
DATOS SEGMENT
ENCABEZADO DB 13,10,13,TAB,TAB, "=========="
DB 13,10,13,TAB,TAB,"PROGRAMA QUE IMPRIME NUMEROS HEXADECIMALES"
DB 13,10,13,TAB,TAB,"===============",13,10,13,"$"
DATOS ENDS
PILA SEGMENT STACK 'STACK'
DB 64 DUP ('0')
PILA ENDS
CODIGO SEGMENT
CEXA PROC NEAR
ASSUME CS:CODIGO, SS:PILA,DS:DATOS
ORG 100H
MOV AX,DATOS
MOV DS,AX
LEA DX,ENCABEZADO
CALL ESCRIBE
MOV CX, 200H
XOR DX,DX
CICLO:
CALL ESCRIBE_HEX
CALL ESCRIBE_CRLF
INC DX
LOOP CICLO
CALL SALIR
CEXA ENDP
ESCRIBE_HEX PROC NEAR
PUSH AX
PUSH CX
PUSH DX
OTRO_DIGITO:
PUSH CX
MOV CL,4
ROL DX,CL
CALL ESCRIBE_DIGITO_HEX
POP CX
LOOP OTRO_DIGITO
POP DX
POP CX
POP AX
RET
ESCRIBE_HEX ENDP
ESCRIBE_DIGITO_HEX PROC NEAR
PUSH AX
PUSH DX
AND DX,0FH
CMP DL,10
JAE ES_MAYOR_A_10
ADD DL,48
JMP IMPRIME_DIGITO
ES_MAYOR_A_10:
ADD DL,55
IMPRIME_DIGITO:
MOV AH,2
INT 21H
POP DX
POP AX
RET
ESCRIBE_DIGITO_HEX ENDP
ESCRIBE_CRLF PROC NEAR
PUSH AX
PUSH DX
MOV AH,2
MOV DL,13
INT 21H
MOV DL,10
INT 21H
POP DX
POP AX
RET
ESCRIBE_CRLF ENDP
ESCRIBE PROC
MOV AH,9
INT 21H
RET
ESCRIBE ENDP
SALIR PROC NEAR
MOV AX,FIN
INT DOS
RET
SALIR ENDP
CODIGO ENDS
END CEXA

PROGRAMA NO.12 CONVERSIÓN

CR EQU 13
LF EQU 10
IMPRIMIR EQU 9
FIN EQU 4C00H
DOS EQU 21H
TAB EQU 09H

DATOS SEGMENT
ASCII DB 'A','B','C','D','E','F','G','H'
ESPACIO DB CR,LF,"$"
BINARIO DB 64 DUP (?),"$"
MENSAJE1 DB CR,LF,TAB,"ANTES DE LA CONVERSION: ","$"
MENSAJE2 DB CR,LF,TAB,"DESPUES DE LA CONVERSION: ","$"
DATOS ENDS

PILA SEGMENT STACK 'STACK'
DW 128 DUP ('P')
PILA ENDS
CODIGO SEGMENT
CONV PROC FAR

ASSUME CS:CODIGO,SS:PILA,DS:DATOS
MOV AX,DATOS
MOV DS,AX
LEA DX,MENSAJE1
CALL ESCRIBE
LEA DX, ESPACIO
CALL ESCRIBE
LEA DX,ASCII
CALL ESCRIBE
LEA DX,ESPACIO
CALL ESCRIBE
LEA DX,BINARIO
CALL ESCRIBE
LEA DX,ESPACIO
CALL ESCRIBE
LEA SI,ASCII
LEA DI,BINARIO
CALL ASCII2BIN
LEA DX,MENSAJE2
CALL ESCRIBE
LEA DX, ESPACIO
CALL ESCRIBE
LEA DX,ASCII
CALL ESCRIBE
LEA DX,ESPACIO
CALL ESCRIBE
LEA DX,BINARIO
CALL ESCRIBE
LEA DX,ESPACIO
CALL ESCRIBE
CALL SALIR
CONV ENDP
ASCII2BIN PROC NEAR
XOR AX,AX
MOV CX,8
ASCII1:
MOV AL,[SI]
PUSH CX
MOV CX,8
LOOP_SHIFT:
SHL AL, 1
JC BIN_UNO
MOV [DI],BYTE PTR '0'
JMP CICLO_SHIFT
BIN_UNO:
MOV [DI], BYTE PTR '1'
CICLO_SHIFT:
INC DI
LOOP LOOP_SHIFT
POP CX
INC SI
LOOP ASCII1
RET
ASCII2BIN ENDP
ESCRIBE PROC
MOV AH,IMPRIMIR
INT DOS
RET
ESCRIBE ENDP
SALIR PROC NEAR
MOV AX, FIN
INT DOS
SALIR ENDP
CODIGO ENDS
END CONV

PROGRAMA NO.11 IMPRIME NUMEROS

CR EQU 13
LF EQU 10
IMPRIMIR EQU 9
FIN EQU 4C00H
DOS EQU 21H
TAB EQU 09H
VELL EQU 07H

DATOS SEGMENT
ENCABEZADO DB 13,10,13,TAB,TAB,"======================"
DB 13,10,13,TAB,TAB,"PROGRAMA QUE IMPRIME VALORES NUMERICOS DEC Y EXA 91.3 ;)"
DB 13,10,13,TAB,TAB,"=========================",13,10,13,"$"
VALOR_1 DW 41D,"$"
VALOR_2 DW 42D,"$"
VALOR_3 DW 43D,"$"
VALOR_4 DW 44D,"$"
VALOR_5 DW 45D,"$"
VALOR_6 DW 46,"$"
VALOR_7 DW 47,"$"
VALOR_8 DW 48,"$"
VALOR_9 DW 49,"$"
VALOR_10 DW 50,"$"
VALOR_11 DW 31H,"$"
VALOR_12 DW 32H,"$"
VALOR_13 DW 33H,"$"
VALOR_14 DW 34H,"$"
VALOR_15 DW 35H,"$"
VALOR_16 DW 36H,"$"
VALOR_17 DW 37H,"$"
VALOR_18 DW 38H,"$"
VALOR_19 DW 39H,"$"
VALOR20 DW 40H,"$"

DATOS ENDS

PILA SEGMENT STACK
DB 64 DUP('0')
PILA ENDS
CODIGO SEGMENT
EXA PROC NEAR
ASSUME CS:CODIGO,DS:DATOS,SS:PILA
MOV AX,DATOS
MOV DS,AX
LEA DX,ENCABEZADO
CALL ESCRIBE
LEA DX, VALOR_1
CALL ESCRIBE

LEA DX, VALOR_2
CALL ESCRIBE
LEA DX, VALOR_3
CALL ESCRIBE
LEA DX, VALOR_4
CALL ESCRIBE
LEA DX, VALOR_5
CALL ESCRIBE
LEA DX, VALOR_6
CALL ESCRIBE
LEA DX, VALOR_7
CALL ESCRIBE
LEA DX, VALOR_8
CALL ESCRIBE
LEA DX, VALOR_9
CALL ESCRIBE
LEA DX, VALOR_10
CALL ESCRIBE
LEA DX, VALOR_11
CALL ESCRIBE
LEA DX, VALOR_12
CALL ESCRIBE
LEA DX, VALOR_13
CALL ESCRIBE
LEA DX, VALOR_14
CALL ESCRIBE
LEA DX, VALOR_15
CALL ESCRIBE
LEA DX, VALOR_16
CALL ESCRIBE
LEA DX, VALOR_17
CALL ESCRIBE
LEA DX, VALOR_18
CALL ESCRIBE
LEA DX, VALOR_19
CALL ESCRIBE
LEA DX, VALOR20
CALL ESCRIBE
CALL SALIR
EXA ENDP
ESCRIBE PROC
MOV AH,9
INT 21H
RET
ESCRIBE ENDP
SALIR PROC NEAR
MOV AX,FIN
INT DOS
RET
SALIR ENDP
CODIGO ENDS
END EXA

PROGRAMA NO.10 BINARIO

CR EQU 13
LF EQU 10
IMPRIMIR EQU 9
FIN EQU 4C00H
DOS EQU 21H
TAB EQU 09H
BELL EQU 07H

DATOS SEGMENT
ENCABEZADO DB 13,10,13,TAB,TAB, "=========="
DB 13,10,13,TAB,TAB,"PROGRAMA QUE IMPRIME UN VALOR BINARIO"
DB 13,10,13,TAB,TAB,"===============",13,10,13,"$"
VALOR_ASCII DB '21314151',"$"
DATOS ENDS

PILA SEGMENT STACK
DB 64 DUP('0')
PILA ENDS

CODIGO SEGMENT
ASCI PROC NEAR
ASSUME CS:CODIGO,DS:DATOS,SS:PILA
MOV AX,DATOS
MOV DS,AX
LEA DX, ENCABEZADO
CALL ESCRIBE
CALL SALIR

ASCI ENDP

ESCRIBE PROC
MOV AH,9
INT 21H
RET
ESCRIBE ENDP

SALIR PROC NEAR
MOV AX,FIN
INT DOS
RET
SALIR ENDS
CODIGO ENDS
END ASCI

PROGRAMA NO.9 COLORES

CR EQU 13
LF EQU 10
BIOS EQU 10H
DOS EQU 21H
TEXTO EQU 3
FIN EQU 4C00H

DATOS SEGMENT
TITULO DB 'HPC'
COLORES DB 01001110B
DB 01101111B
DB 00110001B
DB 01011100B
DB 00110001B
DB 01011111B
DB 01101011B
DB 01011100B
DB 01101111B
DB 01001110B
DB 00110001B

DATOS ENDS

PILA SEGMENT STACK
DB 64 DUP('PILA')
PILA ENDS

CODIGO SEGMENT
COLO PROC FAR
ASSUME CS:CODIGO,DS:DATOS,SS:PILA
MOV AX,DATOS
MOV DS,AX
MOV AX,TEXTO
INT BIOS
MOV CX,11
XOR SI,SI
BUCLE:
PUSH CX
MOV DX,SI
ADD DX,35
MOV DH,12
CALL COLOCA
MOV AL,[SI+OFFSET TITULO]
MOV BL,[SI+OFFSET COLORES]
CALL COLOR
POP CX
INC SI
LOOPNZ BUCLE
MOV AH,8
INT DOS
XOR DX,DX
CALL COLOCA
MOV AX,FIN
INT DOS
COLO ENDP

COLOR PROC
MOV AH,9
XOR BH,BH
INT BIOS
RET
COLOR ENDP

COLOCA PROC
MOV AH,2
XOR BX,BX
INT BIOS
RET
COLOCA ENDP
CODIGO ENDS
END COLO

Programa No.8 PIDE 3 CADENAS

TECLADO EQU 8
IMPRIMIR EQU 9
FIN EQU 4C00H
DOS EQU 21H
BIOS EQU 10H
TAB EQU 09H
BELL EQU 07H
CR EQU 13
LF EQU 10

DATOS SEGMENT
NOMBRE DB 30 DUP(32),"$"
DIR DB 30 DUP(32),"$"
TLF DB 15 DUP(32),"$"
MENS1 DB "NOMBRE: $"
MENS2 DB "DIRECCION: $"
MENS3 DB "TELEFONO: $"
ENTERR DB CR,LF,"$"
DATOS ENDS

PILA SEGMENT STACK
DB 64 DUP("PILA")
PILA ENDS

CODIGO SEGMENT
ASSUME CS:CODIGO, DS:DATOS, SS:PILA
INICIO:
MOV AX,DATOS
MOV DS,AX
CALL MODO_DE_VIDEO

MOV DX,OFFSET MENS1
CALL ESCRIBE
MOV SI,OFFSET NOMBRE
MOV CX,8
CALL PEDIR
CALL SALTO_DE_LINEA

MOV DX,OFFSET MENS2
CALL ESCRIBE
MOV SI,OFFSET DIR
MOV CX,8
CALL PEDIR
CALL SALTO_DE_LINEA

MOV DX,OFFSET MENS3
CALL ESCRIBE
MOV SI,OFFSET TLF
MOV CX,10
CALL PEDIR
CALL SALTO_DE_LINEA

CALL ESCRIBE
CALL ESCRIBE
CALL ESCRIBE
MOV DX,OFFSET NOMBRE
CALL ESCRIBE
CALL SALTO_DE_LINEA
MOV DX,OFFSET DIR
CALL ESCRIBE
CALL SALTO_DE_LINEA

MOV DX,OFFSET TLF
CALL ESCRIBE
CALL SALTO_DE_LINEA
CALL SALIR

PEDIR PROC NEAR
BUCLE:
MOV AH,TECLADO
INT DOS
MOV[SI],AL
MOV AH,2
MOV DL,AL
INT DOS

INC SI
LOOPNZ BUCLE

RET
PEDIR ENDP

ESCRIBE PROC NEAR
MOV AH,IMPRIMIR
INT DOS
RET
ESCRIBE ENDP

SALTO_DE_LINEA PROC NEAR
MOV DX,OFFSET ENTERR
CALL ESCRIBE
RET
SALTO_DE_LINEA ENDP

MODO_DE_VIDEO PROC NEAR
MOV AX,3
INT BIOS
RET
MODO_DE_VIDEO ENDP

SALIR PROC NEAR
MOV AX,FIN
INT DOS
RET
SALIR ENDP
CODIGO ENDS
END INICIO

Programa No.7 Borra pantalla y posiciona el cursor

CR EQU 13
LF EQU 10
TECLADO_8 EQU 8
IMPRIMIR_9 EQU 9
FIN_4C00H EQU 4C00H
DOS_21H EQU 21H
BIOS_10H EQU 10H
TAB EQU 09H
BELL EQU 07H
DATOS SEGMENT
RENGLON DB 0
COLUMNA DB 0
MENSAJE DB CR,LF,'POSICION (X,Y), DEL MENSAJE: HUMBERTO PEREZ'
DB 'DESPUES DE BORRAR PANTALLA',CR,LF,'$'
DATOS ENDS

PILA SEGMENT STACK
DW 100 DUP('0')
PILA ENDS

CODIGO SEGMENT
CLSP PROC FAR
ASSUME CS:CODIGO,DS:DATOS,SS:PILA
MOV AX,DATOS
MOV DS,AX
LEA DX,MENSAJE
CALL LIMPIA_PANTALLA
CALL POSICIONA_CURSOR
MOV AH,IMPRIMIR_9
INT DOS_21H
MOV AX,FIN_4C00H
INT DOS_21H

CLSP ENDP

LIMPIA_PANTALLA PROC NEAR
MOV AX,0600H
MOV BH,0AH
MOV CX,000H
MOV DX,484FH
INT BIOS_10H
RET
LIMPIA_PANTALLA ENDP

POSICIONA_CURSOR PROC NEAR
MOV AH,02
MOV BH,00
MOV DH,RENGLON
MOV DL,COLUMNA
INT BIOS_10H
RET
POSICIONA_CURSOR ENDP

CODIGO ENDS
END CLSP

Programa No.6 Posición del cursor

CR EQU 13
LF EQU 10
TECLADO_8 EQU 8
IMPRIMIR_9 EQU 9
FIN_4C00H EQU 4C00H
DOS_21H EQU 21H
BIOS_10H EQU 10H
TAB EQU 09H
BELL EQU 07H

DATOS SEGMENT
RENGLON DB 0
COLUMNA DB 0
MENSAJE DB CR,LF,'POSICION (X,Y), DEL MENSAJE : HUMBERTO PEREZ',CR,LF,'$'
DATOS ENDS
PILA SEGMENT STACK
DW 100 DUP('0')
PILA ENDS

CODIGO SEGMENT
PC PROC FAR
ASSUME CS:CODIGO,DS:DATOS,SS:PILA
MOV AX,DATOS
MOV DS,AX
LEA DX,MENSAJE
CALL POSICIONA_CURSOR
MOV AH,IMPRIMIR_9
INT DOS_21H
MOV AX,FIN_4C00H
INT DOS_21H

PC ENDP
POSICIONA_CURSOR PROC NEAR
MOV AH,02
MOV BH,00
MOV DH,RENGLON
MOV DL,COLUMNA
INT BIOS_10H
RET
POSICIONA_CURSOR ENDP

CODIGO ENDS
END PC

Programa No.5 Limpiar la pantalla

FIN_4C00H EQU 4C00H
DOS_21H EQU 21H
BIOS_10H EQU 10H

PILA SEGMENT STACK
DW 100 DUP('0')

PILA ENDS

CODIGO SEGMENT
CLS PROC FAR
ASSUME CS:CODIGO,SS:PILA
CALL LIMPIA_PANTALLA
MOV AX,FIN_4C00H
INT DOS_21H
CLS ENDP

LIMPIA_PANTALLA PROC NEAR
MOV AX,0600H
MOV BH,0AH
MOV CX,000H
MOV DX,484FH
INT BIOS_10H
RET
LIMPIA_PANTALLA ENDP

CODIGO ENDS
END CLS

Programa No.4 Conjunto de líneas en pantalla con procedimiento

CR EQU 13
LF EQU 10

DATOS SEGMENT
LINEA1 DB CR,LF,'Humberto Perez Cruz',CR,LF,'$'
LINEA2 DB 'Tecnologico de Matamoros',CR,LF,'$'
LINEA3 DB 'ING. SISTEMAS COMPUTACIONALES',CR,LF,'$'
LINEA4 DB 'Soltero ;-;',CR,LF,'$'

DATOS ENDS

PILA SEGMENT STACK

DB 64 DUP('PILA')
PILA ENDS

CODIGO SEGMENT

LN PROC FAR

ASSUME CS:CODIGO,DS:DATOS,ss:PILA
MOV AX,DATOS
MOV DS,AX
LEA DX,LINEA1
CALL ESCRIBE
LEA DX,LINEA2
CALL ESCRIBE
LEA DX,LINEA3
CALL ESCRIBE
LEA DX,LINEA4
CALL ESCRIBE
MOv AX,4C00H
INT 21H

LN ENDP

ESCRIBE PROC
MOV AH,9
INT 21h
RET
ESCRIBE ENDP

CODIGO ENDS
END LN

Programa No.3 Hola mundo funcion

CR EQU 13
LF EQU 10

DATOS SEGMENT
MENSAJE DB CR,LF,'Hola mundo funcion',CR,LF,'$'

DATOS ENDS
PILA SEGMENT STACK
DB 64 DUP ('PILA')
PILA ENDS

CODIGO SEGMENT
HMF PROC FAR
ASSUME CS:CODIGO,DS:DATOS,SS:PILA
MOV AX,DATOS
MOV DS,AX
LEA DX,MENSAJE

CALL ESCRIBE
MOV AX,4C00H
INT 21H

HMF ENDP

ESCRIBE PROC
MOV AH,9
INT 21H
RET
ESCRIBE ENDP

CODIGO ENDS
END HMF

Programa No.2 Uso de constantes

CR EQU 13
LF EQU 10
IMPRIMIR EQU 9
FIN EQU 4C00H
DOS EQU 21H

DATOS SEGMENT
TEXTO DB 'Uso de constantes',CR,LF,'S'

DATOS ENDS
PILA SEGMENT STACK
DB 64 DUP ('PILA')
PILA ENDS

CODIGO SEGMENT
ASSUME CS:CODIGO,DS:DATOS,SS:PILA
INICIO: MOV AX,DATOS
MOV DS,AX
MOV DX,OFFSET TEXTO
MOV AH,IMPRIMIR
INT DOS
MOV AX,FIN
INT DOS

CODIGO ENDs
END INICIO

Programa No.1 Hola Mundo

Cr EQU 13
LF EQU 0Ah

Datos SEGMENT
MENSAJE DB CR,LF,'Hola mundo',CR,LF,'$'
DATOS ENDS

PILA SEGMENT STACK
DB 64 DUP('PILA')
PILA ENDS

CODIGO SEGMENT
HM PROC FAR
ASSUME CS: CODIGO,DS:DATOS,SS:PILA

MOV AX,DATOS
MOV DS,AX
LEA DX,MENSAJE

MOV AH,9
INT 21H

MOV AX,4C00H
INT 21H

HM ENDP
CODIGO ENDS
END HM

lunes, 1 de abril de 2019

Programa con loopz. Video

org 100h

.stack 64

.data

.code

inicio:

mov cx,10 ;cantidad de veces que repetira

mov al,'>' ;caracter inicial



Lee_car:

    mov ah,0eh ;Funcion para imprimir caracter

    int 10h   ;llama a la bios

 

    mov ah,00 ;funcion de espera de un caracter del teclado

    int 16h ;llama al bios

    cmp al,'S' ;compara el caracter con 'S'

    loope Lee_car  ;si es igual salta a otro

 

    mov ah,0eh ;funcion para imprimir caracter

    int 10h ;llamada al bios

 

    ;colocar el fin de la linea para que baje una linea y lo imprima

    mov ah,0eh ;funcion del bios para imprimir caracter

    mov al,10

    int 10h

 

    ;colocar el retorno de carro para ir al inicio

    mov al,13

    int 10h

    ;prepara la salida del programa

    mov ax,4c00h

    int 21h

end inicio

jueves, 21 de marzo de 2019

MULT CON DOS CIFRAS

.model small ;Modelo de memoria m?s utilizado

.stack



.data        ;definición de datos(variables), donde se almacenara información

.code

   chr1  db ? ;primer digito

   chr2  db ? ;segundo digito

   chr3  db ? ;multiplo

   chr4  db ?

   r1    db ? ;resultado 1

   r2    db ? ;resultado 2

   r3    db ?

   r4    db ?

   ac    db 0 ;acarreo

   ac1   db 0

.startup

   ;cls

   mov ah,00h     ;Function(Set video mode)

   mov al,03      ;Mode 80x25 8x8 16

   int 10h        ;Interruption Video



   mov ah,01h     ;Function(character read) Guarda en AL

   int 21h        ;Interruption DOS functions

   sub al,30h     ;ajustamos valores

   mov chr1,al    ;[chr1].chr2 * chr3 = ac.r1.r2



   mov ah,01h     ;Function(character read) Guarda en AL

   int 21h        ;Interruption DOS functions

   sub al,30h     ;Ajustamos valores

   mov chr2,al    ;chr1.[chr2] * chr3 = ac.r1.r2



   mov ah,02h     ;Function(character to send to standard output)

   mov dl,'*'     ;Character to show

   int 21h



   mov ah,01h     ;Function(Read character) Guarda en AL

   int 21h        ;Interruption DOS Functions

   sub al,30h     ;Transform(0dec = 30hex)

   mov chr3,al    ;chr1.chr2 * [chr3] = ac.r1.r2



   mov ah,01h     ;Function(Read character) Guarda en AL

   int 21h        ;Interruption DOS Functions

   sub al,30h     ;Transform(0dec = 30hex)

   mov chr4,al    ;chr1.chr2 * [chr3] = ac.r1.r2



   mov ah,02h     ;Character to send to standar output

   mov dl,'='     ;

   int 21h        ;Interruption DOS functions



   ;Realizamos operaci?n 



   mov al,chr4  ;unidad del segundo numero

   mov bl,chr2  ;unidad del primer numero

   mul bl       ;multiplicar

   mov ah,0     ;limpiamos ah0

   aam          ;separamos de hex a dec

   mov ac1,ah   ;decenas del primera multiplicacion

   mov r4,al    ;unidades del primera multiplicacion

         

   mov al,chr4  ;unidades del segundo numero

   mov bl,chr1  ;decentas del primer numero

   mul bl       ;multiplicar

   mov r3,al    ;movemos el resultado de la operacion a r3

   mov bl,ac1   ;movemos el acarreo a bl

   add r3,bl    ;sumamos resultado mas acarreo

   mov ah,00h   ;limpiamos ah por residuos

   mov al,r3    ;movemos el resultado de la suma a al

   aam          ;separamos  de hex a dec

   mov r3,al    ;guardamos unidades en r3

   mov ac1,ah   ;guardamos decenas en ac1



   



   mov al,chr3    ;al = chr3

   mov bl,chr2    ;bl = chr2

   mul bl         ;AL = chr3*chr2 (BL*AL)

   mov Ah,0h      ;

   AAM            ;ASCII Adjusment

   mov ac,AH      ;ac = AH (Acarreo)

   mov r2,AL      ;r2 = AL       (Unidad del resultado)



   mov al,chr3    ;AL = chr3

   mov bl,chr1    ;BL = chr1

   mul bl         ;AL = chr1*chr3 (BL*AL)

   mov r1,al      ;r1 = AL       (Decena del resultado)

   mov bl,ac      ;BL = Acarreo anterior

   add r1,bl      ;r1 = r1+ac (r1 + Acarreo)

   mov ah,00h     ;

   mov al,r1      ;AL = r1 (Asignaci?n para el ajust)

   AAM            ;ASCII Adjustment

   mov r1,al      ;r1 = AL

   mov ac,ah      ;ac = AH (Acarreo para la Centena del resultado)





   ;suma final

   ;R4 resulta ser las unidades de mul y no se toma en cuenta ya que se pasa entero





   mov ax,0000h   ;limpiamos ax



   mov al,r3      ;movemos el segundo resultado de la primera mult a al

   mov bl,r2      ;movemos primer resultado de la segunda mult a bl

   add al,bl      ;sumamos

   mov ah,00h     ;limpiamos ah

   aam            ;separamos hex a dec

   mov r3,al      ;r3 guarda las decenas del resultado final

   mov r2,ah      ;r2 se utiliza como nuevo acarreo



   mov ax,0000h   ;''''



   mov al,ac1     ;movemos el acarreo de la primera mult a al

   mov bl,r1      ;movemos segundo resultado de la segunda mult a bl

   add al,r2      ;sumamos el nuevo  acarreo de la suma anterior  a al

   add al,bl      ;sumamos al a bl

   mov ah,00h     ;limpiamos el registro ah

   aam            ;separamos de hex a dec

   mov r1,al      ;r1 guarda las centenas

   mov r2,ah      ;ah se sigue utilizando como acarreo



   mov al,r2      ;movemos el acarreo a al

   mov bl,ac      ;movemos ac a bl

   add al,bl      ;sumamos al a bl

   ;aam            ;separamos hex a dec

   mov ac,al      ;mov al a ac como nuestro acarreo final







   ;Mostramos resultado

   mov ah,02h

   mov dl,ac

   add dl,30h

   int 21h        ;Mostramos ac (millar)



   mov ah,02H

   mov dl,r1

   add dl,30h

   int 21h        ;Mostramos r1 (centena)



               



   mov ah,02H

   mov dl,r3

   add dl,30h

   int 21h        ;Mostramos r3 (decena)



   mov ah,02H

   mov dl,r4

   add dl,30h

   int 21h        ;unidad



.exit

end

miércoles, 13 de marzo de 2019

Programa que dice que si se encuentra La palabra

org 100h 
include 'emu8086.inc'
mov si, 0    ;ponemos si en 0 
   
   
comienzo: 
mov al, msg2[0]   ;copiar la primera letra de la palabra A al

cmp msg[si],"$"   ;si es el fin de la cadena mandar a final
 jz final      ; brinca si es igual

cmp msg[si], al   ;comparar si encuentra la primera letra de la cadena
 jne seguir    ;brica si es diferente


mov di, 1         ;poner en 1 di  

comprobar:

 mov al, msg2[di]
 mov bx, di
 cmp msg[si+bx], al     ;posicion de la letra coincidente + di, comparar con la cadena
 jne seguir             ;si no coincide mandar a seguir  


 inc di                 ;incrementar di para seguir recorriendo cadena

 cmp msg2[di],"$"       ;si es el fin de la cadena y el programa llego 
 jz resultado           ;aca quiere decir que la cadena es parte de la palabra


loop comprobar         ;bucle para recorrer cadena
                                                   
                                                   
seguir:  

 inc si       ;para seguir recorriendo la palabra

loop comienzo   ;bucle principal para recorrer palabra

resultado:

  mov dx, offset msg3    ;copiar msg3 a dx
  mov ah, 9              ;preparar ah con 9 para la interrupcion 21h
  int 21h                ;mostrar contenido en dx  
  
final: 



ret   

msg db "tecnologico$"
msg2 db "tec$"

msg3 db "Si se encuentra$"

martes, 12 de marzo de 2019

Despliegues con letreros Lea, Macro y Offset

;Despliegue con letrero con lea

org 100h

.model tiny

.data
dato db 10,13, 'letrero $'

.code

INICIO:
mov cx,4

comienzo:

mov ah,09h
lea dx,dato
int 21h

loop comienzo

ret

------------
;Desplegue de letrero con macro

ORG 100H
INCLUDE 'EMU8086.INC'

MOV CX,4

COMIENZO:
PRINTN 'LETRERO'

LOOP COMIENZO

RET

----------
;Despliegue con letrero con offset

org 100h

.model tiny

.data
dato db 10,13, 'letrero $'

.code

INICIO:
mov cx,4

comienzo:

mov ah,09h
;lea dx,dato
mov dx,OFFSET DATO
int 21h

loop comienzo

ret

jueves, 7 de marzo de 2019

Instrucciones de salto que prueban una sola bandera con ejemplos

Tabla de saltos condicionales.

salto incondicional jmp
salto condicional cmp

http://jbwyatt.com/253/emu/asm_tutorial_07.html

Ejemplo1

name"jmp incondicional"
org 100h

mov ax, 5 ; set ax to 5.
mov bx, 2 ; set bx to 2.

jmp calc ; go to 'calc'.

back: jmp stop ; go to 'stop'.

calc:
add ax, bx ; add bx to ax.
jmp back ; go 'back'.

stop:

ret ; return to operating system.

Ejemplo2

saltos condicionales
.model small
.stack
.data
include 'emu8086.inc'

num1 db 8
num2 db 9
msg1 db 'numeros iguales $'
msg2 db 'numero 1 mayor $'
msg3 db 'numero 2 mayor $'

.code
main:
mov ax, @data
mov ds,ax

mov al, num1

cmp al, num2

jc mayor2
jz igual
jnz mayor1

.exit

igual:
;printn 'numeros iguales'
jmp fin

mov ah,09h
lea dx,msg1
int 21h
jmp fin

mayor1:

;printn 'el numero 1 es mayor'
jmp fin

mov ah,09h
lea dx,msg2
int 21h
jmp fin

mayor2:
;printn 'el numero dos es mayor'
jmp fin

mov ah,09h
lea dx,msg3
int 21h
jmp fin

fin:

ret

miércoles, 6 de marzo de 2019

Ciclos condicionales

LOOP etiqueta
La instrucción loop decrementa CX en 1, y transfiere el flujo del programa a la etiqueta dada como operando si CX es diferente a 1.
Instrucción LOOPE
Propósito: Generar un ciclo en el programa considerando el estado de ZF

LOOPE etiqueta
Esta instrucción decrementa CX en 1. Si CX es diferente a cero y ZF es igual a 1, entonces el flujo del programa se transfiere a la etiqueta indicada como operando.

Instrucción LOOPNE
Propósito: Generar un ciclo en el programa, considerando el estado de ZF

LOOPNE etiqueta
Esta instrucción decrementa en uno a CX y transfiere el flujo del programa solo si ZF es diferente a 0.

Emu8086

Se define como un lenguaje de programación que se usa para dar directamente órdenes al ordenador. A diferencia de otros lenguajes, que usan el sistema operativo como intermediario para ejecutar las tareas (le dicen al sistema operativo que haga una cosa y este es quien se encarga de hacerselo saber al ordenador), el lenguaje de ensamblador (en inglés assembly) no usa intermediarios, sino que directamente le dá las órdenes a la máquina.

jueves, 28 de febrero de 2019

Calcula el promedio de tres materias

name "calcula el promedio de tres materias"
include "emu8086.inc"
org 100h

.data
pro db 4 dup (?)

.code
promedio proc
printn ""
print "introduce una calificacion: "
call scan_num
mov pro[0],cl
printn ""
print "introduce la 2da calificacion: "
call scan_num
mov pro[1],cl
printn ""
print "introduce la 3ra calificacion: "
call scan_num
mov pro[2],cl
printn ""
print "numero de materias: "
call scan_num
mov pro[3],cl
xor ax,ax
add al,pro[0]
add al,pro[1]
add al,pro[2]
div pro[3]
printn ""
print "promedio es= "
call print_num

promedio endp

exit:
printn ""
printn ""
print "presione para salir..."
mov ah,0
int 16h
ret
define_print_string
define_print_num
define_print_num_uns
define_scan_num

end

Resta de dos numeros libreria emu8086.inc

;creado por Yulissa Muraira Primero
name 'resta dos numeros'
include 'emu8086.inc'
org 100h

.data
resta db 2 dup (?)

.code
restas proc
print " " ;usa macro de la lib, un espacio en blanco
print "Introduce el primer numero: " ;usa macro print
call scan_num;uso del procedimiento scan_num de lib
mov resta[0],cl;guarda el valor en el arreglo
printn " ";usa macro print
printn " ";usa macro print
print " Introduce el segundo numero: ";
call scan_num ;usop del procedimiento scan_num
sub resta[1],cl
xor ax,ax ;limpia el reg az
add al,resta[0]
add al, resta[1]
printn " "
printn " "
print " La resta es==> "
call print_num
restas endp

exit:
print " "
printn " "
printn " "
print " Presiona cualquier letra o enter para salir..."
mov ah,0
int 16h
ret
define_print_string
define_print_num
define_print_num_uns
define_scan_num ;usa el procedimiento scan_num
end

ret

name "suma de dos numeros"
include "emu8086.inc"
org 100h

.data
suma db 2 dup (?);declaramos un arreglo de tamaño dos
.code
sumas proc Far
print " Introduce el primer numero: " ;uso de la macro p´rint de la libreria
call scan_num ;uso del procedimiento Scan_num
mov suma[0],cl
printn " ";macro que imprime un string y su retorno de carro
print " Introduce el segundo numero: " ;macro print
call scan_num ;procedimiento scan_num
mov suma[1],cl
xor ax,ax ;limpiar el registro ax
add al,suma[0]
add al,suma[1]
printn " "
print " La suma es: "
call print_num ;usa un procedimiento de la macro para imprimir un numero en ax
sumas endp
exit:
print " "
printn " "
print "Presiona enter para salir..."
mov ah,0 ;servicio de pulsación de teclado
int 16h ;invoca a servicios de taclado
ret
;define_print_string
define_print_num ;viene del uso del procedimeinto print_num
define_print_num_uns ; por usa un num dec
define_scan_num ;uso del proc_scan_num
end

miércoles, 27 de febrero de 2019

Registro de banderas

De los 16 bits del registro de banderas, nueve son comunes a toda la familia de procesadores 8086, y sirven para indicar el estado actual de la maquina y el resultado del procesamiento. Muchas instrucciones que piden comparaciones y aritmética cambian el estado de las banderas, algunas cuyas instrucciones pueden realizar pruebas para determinar la acción subsecuente. En resumen, los bits de las banderas comunes son como sigue:

OF (Overflow, desbordamiento). Indica desbordamiento de un bit de orden alto (mas a la izquierda) después de una operación aritmética.

DF (dirección). Designa la dirección hacia la izquierda o hacia la derecha para mover o comparar cadenas de caracteres.

IF (interrupción). Indica que una interrupción externa, como la entrada desde el teclado, sea procesada o ignorada.

TF (trampa). Permite la operación del procesador en modo de un paso. Los programas depuradores, como el DEBUG, activan esta bandera de manera que usted pueda avanzar en la ejecución de una sola instrucción a un tiempo, para examinar el efecto de esa instrucción sobre los registros de memoria.

SF (signo). Contiene el signo resultante de una operación aritmética (0 = positivo y 1 = negativo).

ZF (cero). Indica el resultado de una operación aritmética o de comparación (0 = resultado diferente de cero y 1 = resultado igual a cero).

AF (acarreo auxiliar). Contiene un acarreo externo del bit 3 en un dato de 8 bits para aritmética especializada.

PF (paridad). Indica paridad par o impar de una operación en datos de 8 bits de bajo orden (mas a la derecha).

CF (acarreo). Contiene el acarreo de orden mas alto (mas a la izquierda) después de una operación aritmética; también lleva el contenido del ultimo bit en una operación de corrimiento o de rotación.

Ejemplos:

https://www.youtube.com/watch?v=4puXc5S2WOg

Bandera CF(acarreo)

.model small
.stack
.data
 
.code
    mov al,255
    mov bl,1
    add al,bl
     
     
.exit
end

Bandera ZF

.model small
.stack
.data
 
.code
    mov al,2
    mov bl,2
    sub al,bl
     
     
.exit
end

Bandera SF

.model small
.stack
.data
 
.code
    mov al,1
    mov bl,2
    sub al,bl
     
     
.exit
end

Bandera OF

 
.model small
.stack
.data
 
.code
    mov al,100
    mov bl,50
    add al,bl
     
     
.exit
end

martes, 26 de febrero de 2019

Mas ejemplos con la libreria emu8086.inc

include emu8086.inc



ORG    100h



PRINT 'Hola mundo!'



GOTOXY 10, 5



PUTC 65           ; 65 - es un código ASCII para 'A'

PUTC 'B'



RET               ; Regreso al sistema operativo.

END               ; Directiva para detener el compilador.

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

; demonstrate get_string and print_string
;----------------------------------------
include 'emu8086.inc'
ORG    100h

LEA    SI, msg1       ; set up pointer (SI) to msg
                      ; to ask for the number
CALL   print_string   ; print message that SI points to

LEA    DI, buffer     ; set up pointer (DI) to input buffer
MOV    DX, bufSize    ; set size of buffer
CALL   get_string     ; get name & put in buffer

LEA    SI, newln      ; point at CR/LF / Hello message 
CALL   print_string   ; print message that SI points to

RET                   ; return to operating system.

; data
msg1   DB "Enter your name: ", 0  
newln  DB 13, 10
       DB "Hello, "
buffer DB 20 DUP (0)  ; input buffer for get_string   
bufSize = $-buffer    ; calculates size of buffer

DEFINE_GET_STRING
DEFINE_PRINT_STRING
END                   ; directive to stop the compiler.

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

; demonstrate scan_num, print_num, pthis
;----------------------------------------
include 'emu8086.inc'
ORG    100h

LEA    SI, msg1       ; ask for the number
CALL   print_string   ;
CALL   scan_num       ; get number in CX.

MOV    AX, CX         ; copy the number to AX.

; print the following string:
CALL   pthis
DB  13, 10, 'You have entered: ', 0

CALL   print_num      ; print number in AX.

RET                   ; return to operating system.

; data
msg1   DB  'Enter the number: ', 0

; macros to define procs
DEFINE_SCAN_NUM
DEFINE_PRINT_STRING
DEFINE_PRINT_NUM
DEFINE_PRINT_NUM_UNS  ; required for print_num.
DEFINE_PTHIS

END                   ; directive to stop the compiler.

http://jbwyatt.com/253/emu/asm_tutorial_05.html

Administración de Base de Datos