Programa que pone 3 colores y 3 letras

include 'emu8086.inc'

CUADRO MACRO XI,YI,XF,YF,COLOR
MOV AX, 0600H ;
MOV BH, COLOR ; COLOR DE FONDO Y LETRA
MOV BL, 00H
MOV CH, YI ; Y INICIAL
MOV CL, XI ; X INICIAL
MOV DH, YF ; Y FINAL
MOV DL, XF ; X FINAL
INT 10h
endM

POSICION MACRO X,Y
; **** POSICIONA EL CURSOR ********
MOV DH, Y ; POSICI[ON EN Y
MOV DL, X ; POSICI[ON EN X
MOV AH, 02
MOV BH, 00
INT 10H
ENDM

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

DATOS SEGMENT ;SEGMENTO DE DATOS
M1 DB "L",'$'
M2 DB "Y",'$'
M3 DB "A",'$'

datos ends
cincocuadros macro

cuadro 1,1,20,5,22
posicion 10,3
desplegar M1

cuadro 21,1,40,5,11
posicion 30,3
desplegar M2

cuadro 41,1,60,5,17
posicion 50,3
desplegar M3

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

MOV AX,DATOS
MOV DS,AX

cincocuadros

PRINCIPAL ENDP ;FIN DEL PROCEDIMIENTO
CODIGO ENDS ;FIN DEL SEGMENTO

END PRINCIPAL

TASM 15

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

 Captura de resultado:

2- Uso de constantes

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

DATOS SEGMENT
    TEXTO DB 'EJEMPLO DEL USO DE CONSTANTES',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
           MOV DX,OFFSET TEXTO
           MOV AH,IMPRIMIR
           INT DOS 
           MOV AX,FIN
           INT DOS
           
      CODIGO ENDS
      END INICIO

Captura de resultado:

3- Hola mundo con función

CR EQU 13  
LF EQU 10

DATOS SEGMENT
    MENSAJE DB CR,LF,'HOLA MUNDO',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

Captura de resultado:

4- Lineas en pantalla con procedimiento

CR EQU 13  
LF EQU 10

DATOS SEGMENT 
    LINEA1 DB CR,LF,'MANUEL RAMIREZ BONILLA',CR,LF,'$'
    LINEA2 DB 'TECNOLOGICO DE MATAMOROS',CR,LF,'$'
    LINEA3 DB 'INGENIERIA EN 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

Captura de resultado:

5- Programa que limpia 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
        INT BIOS_10H
        RET
        LIMPIA_PANTALLA ENDP
        
    CODIGO ENDS
    END CLS

Captura de resultado:

6- Programa que controla la 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: MANUEL RAMIREZ',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

Captura de resultado:

7- Programa que borra pantalla y posiciona 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: Manuel Ramirez"
            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,01
            MOV BH,00
            MOV DH,RENGLON
            MOV DL,COLUMNA
            INT BIOS_10H
            RET
            POSICIONA_CURSOR ENDP
            
        CODIGO ENDS
        END CLSP

Captura de resultado:

8-  Programa que pide 3 cadenas y las muestra en pantalla

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

Captura de resultado:

9- Programa que cambia los colores del texto y su fondo

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

DATOS SEGMENT 
    TITULO DB "JUENITO_XD"
    COLORES DB 01001110B
    DB 11101111B
    DB 10110001B
    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

Captura de resultado:

10- Muestra un valor 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,"$"
    VALOR_ASCII DB "0101010110","$"
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
    
    LEA DX, VALOR_ASCII
    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

Captura de resultado:

11- Muestra valores numéricos en decimal y hexadecimal

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 VALORES NUMERICOS DEC Y EXA 91.3 ;)"
    DB 13,10,13,TAB,TAB,"==================================",13,10,"$"
    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,"$"
    VALOR_20 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, VALOR_20
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 

Captura de resultado:

12- Conversión de letras a binario 

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, DS:DATOS, SS:PILA
  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

Captura de resultado:

13- Números 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 EN HEXADECIMAL"
DB 13,10,13,TAB,TAB,"==================================",13,10,13,10,"$"
DATOS ENDS
PILA SEGMENT STACK
DB 64 DUP('0')
PILA ENDS
CODIGO SEGMENT   
    CEXA PROC NEAR
ASSUME CS:CODIGO,DS:DATOS,SS:PILA
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

Captura de resultado:

14- Convierte numero ASCII a 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 UN NUMERO ASCII A BINARIO"
DB 13,10,13,TAB,TAB,"======================================================",13,10,"$"
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 BX, 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

Captura de resultado:

15- Convierte numero ASCII a binario (ingresando el numero)

LF EQU 10
IMPRIMIR EQU 9
FIN EQU 4C00H
DOS EQU 21H
TAB EQU 09H
BELL EQU 07H
TECLADO EQU 8
DATOS SEGMENT
NUMERO_BINARIO DW 0,"$"
NUMERO_ASCII DW 6,0,6 DUP (?),"$"
M_ENCABEZADO DB 13,10,13,10,TAB,"================================================================="
DB 13,10,13,TAB,"   PROGRAMA QUE CONVIERTE UN NUMERO ASCII (CAPTURADO) A BINARIO"
DB 13,10,13,TAB,"===============================================================",13,10,"$"
M_ESPACIO DB 13,10,13,10,13,10,13,10,13,10,13,10,"$"
M_ASCII_ASCII DB 13,10,13,10,"NUMERO ASCII IMPRESO NORMALMENTE COMO LO HACE UNA PC (EN ASCII)",13,10,"$"
M_BINARIO_ASCII DB 13,10,13,10,"NUMERO BINARIO (YA CONVERTIDO),",13,10,"IMPRESO NORMALMENTE COMO LO HACE UNA PC (EN ASCII): ","$"
POTENCIA DW 001H, 000AH, 0064, 03E8H, 2710H,"$"
DATOS ENDS
PILA SEGMENT STACK
DB 64 DUP('0')
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
CODIGO ENDS
END CAPT

Captura de resultado:

Programa multiplicacion mejorado con emu8086.inc

include 'emu8086.inc'
.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
   
   gotoxy 0,8
   printn 'La multiplicacion es:'
   gotoxy 0,0
   printn 'Ingrese un numero de 2 digitos'   
inicio:
   mov ah,00h
   call scan_num
   mov ax,cx
   cmp ax,99
   jg  mayor1
   gotoxy 0,10 
   call print_num
   mov al,cl
   aam
   mov chr1,ah    ;[chr1].chr2 * chr3 = ac.r1.r2
   mov chr2,al    ;chr1.[chr2] * chr3 = ac.r1.r2
   
   gotoxy 2,10
   putc '*'
   gotoxy 0,2

   printn 'Ingrese otro numero de 2 digitos'
cont:
   mov ah,00h
   mov cl,00h                                                               
   call scan_num
   mov ax,cx
   cmp ax,99
   jg mayor2
   gotoxy 3,10 
   call print_num
   mov al,cl
   aam
   mov chr3,ah    ;chr1.chr2 * [chr3].chr4 = ac.r1.r2
   mov chr4,al    ;chr1.chr2 * chr3.[chr4] = ac.r1.r2
   
   putc '='
   
   ;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 ax,0000h
   
   ;Mostramos ac (millar)
   mov ah,02h 
   mov dl,ac
   add dl,30h
   int 21h
   ;mov bl,ac
   ;add bl,30h
   ;lea ax,bl
   ;call print_num
           
   
   ;Mostramos r1 (centena)
   mov ah,02H
   mov dl,r1
   add dl,30h
   int 21h
   ;mov bl,r1
   ;add bl,30h
   ;lea ax,bl
   ;call print_num        

   ;Mostramos r3 (decena)
   mov ah,02H
   mov dl,r3
   add dl,30h
   int 21h        
   ;mov bl,r3
   ;add bl,30h
   ;lea ax,bl
   ;call print_num
   
   ;unidad
   mov ah,02H
   mov dl,r4
   add dl,30h
   int 21h
   ;mov bl,r4
   ;add bl,30h
   ;call print_num        
 
.exit

mayor1:
  gotoxy 7,1
  mov dh,8
  BackSpace:
   cmp dh,0            
   jz borrado
   
   mov ah, 02h         ; DOS Display character call
   mov dl, 08h         ; Another backspace character to move cursor back again
   int 21h             ; Display it 
   mov dl, 20h         ; A space to clear old character 
   int 21h             ; Display it  
   mov dl, 08h         ; Another backspace character to move cursor back again
   int 21h             ; Display it
   dec dh
   loop Backspace
  borrado: 
   printn 'Ingrese correctamente'
  gotoxy 21,1
  mov dh,22
  BackSpace1:
   cmp dh,0            
   jz borrado1
   
   mov ah, 02h         
   mov dl, 08h         
   int 21h             
   mov dl, 20h        
   int 21h             
   mov dl, 08h         
   int 21h             
   dec dh
   loop Backspace1
  borrado1:         
   jmp inicio
   
mayor2:
  gotoxy 7,3
  mov dh,8
  BackSpace2:
   cmp dh,0            
   jz borrado2
   
   mov ah, 02h         ; DOS Display character call
   mov dl, 08h         ; Another backspace character to move cursor back again
   int 21h             ; Display it 
   mov dl, 20h         ; A space to clear old character 
   int 21h             ; Display it  
   mov dl, 08h         ; Another backspace character to move cursor back again
   int 21h             ; Display it
   dec dh
   loop Backspace2
  borrado2: 
   printn 'Ingrese correctamente'        
  gotoxy 21,3
  mov dh,22
  BackSpace3:
   cmp dh,0            
   jz borrado3
   
   mov ah, 02h         ; DOS Display character call
   mov dl, 08h         ; Another backspace character to move cursor back again
   int 21h             ; Display it 
   mov dl, 20h         ; A space to clear old character 
   int 21h             ; Display it  
   mov dl, 08h         ; Another backspace character to move cursor back again
   int 21h             ; Display it
   dec dh
   loop Backspace3
  borrado3:
   jmp cont
   
define_scan_num
define_print_num
define_print_num_uns
end

2.5 Programa que detecta si una subpalabra se encuentra dentro de una palabra

Programa mas complicado el cual detecta si dentro de una palabra se encuentra una subcadena y despliega si se encuenra o no se encuentra.

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:
cmp di,0
jz no 
ret

no:
print "No se encontro la cadena"
ret   

msg db "tecnologico$"
msg2 db "tec$"
msg3 db "Si se encuentra$"

La Subpalabra a encontrar es 'tec' dentro de la palabra 'Tecnologico'

2.4 Programa que imrpime 10 veces un letrero

Programa el cual utiliza un contador y un loop para poder imprimir 10 veces un letrero

include 'emu8086.inc'
org 100h
                           
mov cx,10
mov bx,1
mov dl,2

    comienzo:
    printn 'letrero'
LOOP comienzo
ret

2.3 Programa Saltos incondicionales

Programa un poco mas complicado el cual realiza comparaciones entre 2 numeros viendo cual numero es el mayor de los 2

include 'emu8086.inc'
.model small
.stack
.data
    num1 db 4
    num2 db 4
    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:
    mov ah, 09h
    lea dx,msg1
    printn 'Los numeros son iguales'
    int 21h
.exit

mayor1:
    mov ah, 09h
    lea dx,msg2
    printn 'El primer numero es mayor'
    int 21h
.exit

mayor2:
    mov ah, 09h
    lea dx,msg3
    printn 'El segundo numero es mayor'
    int 21h
.exit

Los numeros al ser 2 cuatros son iguales entonces nos depslegara los numeros son iguales

2.2 Programa de saltos

Otro programa de saltos simple el cual realiza una comparacion y realiza un salto dependiendo si son iguale o si no lo son

include "emu8086.inc"

org    100h

mov    al, 25     ;Se le da aun valor de 25 AL. 
mov    bl, 10     ;Se le da un valor de 10 a 25 a BL. 

cmp    al, bl     ;Compara AL y BL. 

je     equal      ;Realiza el salto si son iguales AL y BL.

putc   'n'        ;Si llega hasta aqui significa que AL es diferente de B. 
printn 'No es igual'
jmp    stop       ;Asi que imprimira 'n' y saltaria hasta stop.

equal:            ;Si llega hasta aqui
putc   'y'        ;Entonces al = bl, asi que imprimira 'y'.

stop:

ret               ;Llega aqui no importa que.

Al no ser iguales 25 y 10 nos desplegara en pantalla que no son iguales