Programa de series de luces programables en Arduino

Codigo version 1:

int timer =150;

int timer2= 10;// The higher the number, the slower the timing.
int ledPins[] = {2,3, 4,5,6,7,8,9,10}; // an array of pin numbers to which LEDs are attached
int pinCount = 12; // the number of pins (i.e. the length of the array)


void setup(){
// the array elements are numbered from 0 to (pinCount - 1).
 // use a for loop to initialize each pin as an output:
  for (int i = 0; i < pinCount; i++) {
 pinMode(ledPins[i], OUTPUT);
 }
}

void loop() {
  
 // loop from the lowest pin to the highest:
 for (int i = 0; i < pinCount; i++) {
 // turn the pin on:
digitalWrite(ledPins[i], HIGH);
delay(timer);


// turn the pin off:
digitalWrite(ledPins[i], LOW);
delay (timer2);

}
 // loop from the highest pin to the lowest:
for (int i = pinCount - 1; i >= 0; i--) {
//turn the pin on:
digitalWrite(ledPins[i], HIGH);
delay(timer);
// turn the pin off:
digitalWrite(ledPins[i], LOW);}
delay(timer2);
if (timer>=20)
  timer=timer-10;
  else
  timer=20;
}
   
 

Codigo version 2

//Solo funciona con 3 salidas,pero solo es cuestion de modificar dentro del arreglo ledPins
int timer =150;
int c=0;
int timer2= 10;// The higher the number, the slower the timing.
int ledPins[] = {4,5,7}; // an array of pin numbers to which LEDs are attached
int green[]={7};//an array of pin numbers in color green
int red[]={5};
int blue[]={4};
int pinCount = 3; // 12 the number of pins (i.e. the length of the array)
int pinCount2=4;


void setup(){
// the array elements are numbered from 0 to (pinCount - 1).
 // use a for loop to initialize each pin as an output:
  for (int i = 0; i < pinCount; i++) {
 pinMode(ledPins[i], OUTPUT);
 }
 for (int i = 0; i < pinCount2; i++) {
 pinMode(ledPins[i], OUTPUT);
 }
}

void loop() {
  here:
 // loop from the lowest pin to the highest:
c=0;
timer=150; 
 while(c<50){
 for (int i = 0; i < pinCount; i++) {
 // turn the pin on:
digitalWrite(ledPins[i], HIGH);
delay(timer);
// turn the pin off:
digitalWrite(ledPins[i], LOW);
delay (timer2);

}
 // loop from the highest pin to the lowest:
 
for (int i = pinCount - 1; i >= 0; i--) {
//turn the pin on:
digitalWrite(ledPins[i], HIGH);
delay(timer);
// turn the pin off:
digitalWrite(ledPins[i], LOW);}
delay(timer2);
if (timer>=20)
  timer=timer-10;
  else
  timer=20;
  c=c+1;
}
c=0;
timer=150;
while (c<=50){
  for (int i = 0; i < pinCount2; i++) {
 // turn the pin on:
digitalWrite(green[i], HIGH);
delay(timer);


// turn the pin off:
digitalWrite(green[i], LOW);
delay (timer2);

}
 // loop from the highest pin to the lowest:
 
for (int i = pinCount2 - 1; i >= 0; i--) {
//turn the pin on:
digitalWrite(green[i], HIGH);
delay(timer);
// turn the pin off:
digitalWrite(green[i], LOW);}
delay(timer2);
if (timer>=20){
  timer=timer-10;
  c=c+1;}
  else
  {timer=20;
  c=c+1;} 
}
c=0;
timer=150;
while (c<=50){
  for (int i = 0; i < pinCount2; i++) {
 // turn the pin on:
digitalWrite(red[i], HIGH);
delay(timer);


// turn the pin off:
digitalWrite(red[i], LOW);
delay (timer2);

}
 // loop from the highest pin to the lowest:
 
for (int i = pinCount2 - 1; i >= 0; i--) {
//turn the pin on:
digitalWrite(red[i], HIGH);
delay(timer);
// turn the pin off:
digitalWrite(red[i], LOW);}
delay(timer2);
if (timer>=20){
  timer=timer-10;
  c=c+1;}
  else
  {timer=20;
  c=c+1;} 
}
c=0;
timer=150;
while (c<=50){
  for (int i = 0; i < pinCount2; i++) {
 // turn the pin on:
digitalWrite(blue[i], HIGH);
delay(timer);


// turn the pin off:
digitalWrite(blue[i], LOW);
delay (timer2);

}
 // loop from the highest pin to the lowest:
 
for (int i = pinCount2 - 1; i >= 0; i--) {
//turn the pin on:
digitalWrite(blue[i], HIGH);
delay(timer);
// turn the pin off:
digitalWrite(blue[i], LOW);}
delay(timer2);
if (timer>=20){
  timer=timer-10;
  c=c+1;}
  else
  {timer=20;
  c=c+1;} 
}
goto here;
}
 

Programa que imprime valores numericos con macros (Hexadecimales y decimales)

Sintaxis

include 'emu8086.inc'

Mostrar Macro Mensaje
    LEA DX,Mensaje ;mandamos el mensaje a leer 
    MOV AH,9 ;usamos el servicio para mostrar en pantalla
    INT 21H
endM       

Terminar Macro
    MOV AX,4C00H
    INT 21H
endM

DATOS SEGMENT
    ENCABEZADO DB 13,10,13,09h,09h,"==============================="
    DB 13,10,13,09h,09h,"PROGRAMA QUE IMPRIME VALORES NUMERICOS DEC Y HEXA "
    DB 13,10,13,09h,09h,"================================",13,10,"$"  
    ALINEAR DB 13,10,13,09h,09h
    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,"$"
DATOS ENDS


valores Macro   
    Mostrar ALINEAR
    Mostrar VALOR_1
    Mostrar VALOR_2
    Mostrar VALOR_3
    Mostrar VALOR_4
    Mostrar VALOR_5
    Mostrar VALOR_6    
    Mostrar VALOR_7
    Mostrar VALOR_8
    Mostrar VALOR_9
    Mostrar VALOR_10
endM

Titulo Macro
    Mostrar ENCABEZADO
endm

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

MOV AX,DATOS
MOV DS,AX

Titulo
valores


Main ENDP   
Terminar
CODIGO ENDS 
END Main

Corrida en pantalla

Programa con cuadros de colores (3 cuadros)

Sintaxis del programa

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 "A",'$'
M2 DB "B",'$'
M3 DB "C",'$'


datos ends
cincocuadros macro

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

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

cuadro 41,1,60,5,99
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

Corrida en pantalla

Programas en turbo assembler

En esta ocasión, dejare las quince practicas realizadas en clase con el programa de Turbo Assembler.

Sintaxis 1: Hola mundo

CR EQU 13
LF EQU 0Ah

DATOS SEGMENT
    MENSAJE DB CR,LF, 'Hola mundo este programa fue compilado por mi', 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

Corrida en pantalla:

Sintaxis 2: Uso de constantes para imprimir un mensaje

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

DATOS SEGMENT
    TEXTO DB 'EJEMPLO DE 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
    

Corrida en pantalla

Sintaxis 3: Uso de funciones

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

Corrida en pantalla

Sintaxis 4: Impresión de mensajes con una función

CR EQU 13
LF EQU 10

DATOS SEGMENT
    LINEA1 DB CR,LF,'Carolina Sauceda',CR,LF,'$'
    LINEA2 DB 'Tecnologico de matamoros',CR,LF,'$'
    LINEA3 DB 'ING. SISTEMAS COMPUTACIONALES',CR,LF,'$'
    LINEA4 DB 'ES COMPLICADO ;-;',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

Corrida en pantalla:

Sintaxis 5: 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
    MOV DX,484FH
    INT BIOS_10H
    RET
    LIMPIA_PANTALLA ENDP
    
CODIGO ENDS
END CLS

Corrida en pantalla

Sintaxis 6: Mensaje en posicion X,Y

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: Hola mundo',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

Corrida en pantalla

Sintaxis 7: Mensaje en posicion X,Y y limpia pantalla

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: Hola mundo'
            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

Corrida en pantalla

Sintaxis 8: Captura e impresion de 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             

Corrida en pantalla

Sintaxis 9: Colores en un mensaje

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             

Corrida en pantalla

Sintaxis 10: Impresion de un valor binario dado

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

Corrida en pantalla

Sintaxis 11: Impresion de valores numericos (decimales y hexadecimales)

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 XD"
    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

Corrida en pantalla

Sintaxis 12: Conversion de letras en ascii 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,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
 

Corrida en pantalla

Sintaxis 13: Programa de impresion de numeros 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,10,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 '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
 

Corrida en pantalla

Sintaxis 14: Conversion de ASCII a binario (dado por el programador)

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,10,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 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
 

Corrida en pantalla

Sintaxis 15: Conversio de ASCII a binario (capturado)

EQU 13
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 DB 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,0064H,03E8H,2710H,"$"
DATOS ENDS
PILA SEGMENT STACK 'STACK'
    DW 128 DUP('P')
PILA ENDS
CODIGO SEGMENT
    CAPT PROC NEAR
    ASSUME CS:CODIGO,SS:PILA,DS:DATOS
    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

Corrida en pantalla

Cambiando el color de pantalla y texto con ensamblador

En esta entrada, veremos lo basico para poder modificar el fondo de la consola de video de ensamblador, asi como el color del texto de cualquier mensaje que enviemos a ella.

Primeramente, debemos saber un poco sobre la interrupcion que usaremos para ello:
Interrupción 10h: Nos permite invocar servicios de video de la ROM BIOS, manipulando algunas de sus funciones.

Los servicios que nos permiten hacer este tipo de cambio de colores son:

• 02h: nos permite controlar la posicion de nuestro cursor en la pantalla. Los registros BH,DH y DL son los que usaremos para indicar la posicion en donde debe estar el cursor.
• 06h:Permite inicializar la ventana de video o desplazar su contenido. En este servicio el registro CX indica el pixel donde va a comenzar a cambiar el color y el registro DX indica donde terminara.

Como siguiente punto, debemos saber como es que se representan los colores dentro de emulador.

Cada uno de estos colores al momento de ingresarlos al emulador, podemos representarlo por su parte hexadecimal o binaria:

Los primeros 4 numeros  representan el color que sera para el color de letra, los siguientes 3 representan el color del fondo , el ultimo bit solo es un indicador, si esta en 1 el texto completo en pantalla estara parpadeando.

01011110

0: indicador que nos hara que el texto parpade o no

101: Color de fondo de la pantalla

1110: color del texto en la pantalla.

Ejemplo en un programa:

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: Hola mundo'
            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,01011110b ;color que se modifico
            MOV CX,000H
            MOV DX,484FH
            INT BIOS_10H
            RET
            LIMPIA_PANTALLA ENDP
            
            POSICIONA_CURSOR PROC NEAR
            MOV AH,02 ;Posicion del cursor
            MOV BH,00 ;Pagina en 0,es decir que usara esa pantalla y no otra
            MOV DH,RENGLON ; coordenadas de la pagina por renglon
            MOV DL,COLUMNA ;coordenadas de la pagina por columna
            INT BIOS_10H
            RET
            POSICIONA_CURSOR ENDP
            
        CODIGO ENDS
        END CLSP

Corrida en pantalla.

Programa de multiplicacion de numeros de dos digitos con emu8086.inc

En esta ocasion,volvemos a ver el mismo programa que antes ya he explicado de multiplicacion con unas cuantas modificaciones utilizando la libreria emu8086.inc para ahorrarnos un poco de codigo.

Sintaxis

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
   
   printn 'Bienvenido al programa de multiplicacion. Por favor, ingresa dos numeros de dos digitos.'
   printn 'Entre numeros, presione un enter y espere a que se muestren los simbolos correspondientes:'      
   call scan_num
   mov al,cl
   mov ah,00h
   aam
   mov chr1,ah
   mov chr2,al
   
   gotoxy 2,4
   putc '*' 
   
   mov ax,0000h
   mov cx,0000h
   call scan_num
   mov al,cl
   mov ah,00h
   aam
   mov chr3,ah
   mov chr4,al
   
   gotoxy 5,4
   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 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 

define_scan_num
DEFINE_PRINT_NUM
DEFINE_PRINT_NUM_UNS 
DEFINE_PRINT_STRING
end   

Corrida en pantalla

Multiplicación de dos cifras en ensamblador

En esta ocasión, les muestro la explicacion del siguiente programa que hace la multiplicacion de dos numeros de dos cifras.

Sintaxis

.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  

Bueno,vamos a comenzar con la explicacion parte por parte de esta sintaxis. Ya tenemos algunos comentarios que nos pueden ser de utilidad por parte del autor original del programa que estamos analizando.

La primera parte de la sintaxis que tenemos arriba, es la tipica para iniciar cualquier programa en ensamblador.
En el apartado de .code, comenzamos a declarar las variables que usaremos a lo largo de todo el programa. 4 variables para los caracteres que se van a multiplicar, 4 resultados y 2 acarreos.

Despues de la parte de declaracion, comenzamos con la captura de valores. Comenzamos inicializando las funciones de video para poder ingresar variables desde teclado y que es programa los reciba.
Posteriormente usamos la interrupcion 21h con el servicio 01h que sirve para la entrada de caracteres desde teclado, para ingresar nuestros primeros dos numeros a multiplicar.
Si ves, al momento de ingresar dicho numero(en este ejemplo usaremos la multiplicacion que se habia mostrado en la foto anterior) se le resta 30h. Esto para convertir el valor hexadecimal que nos guarda el ensamblador a su valor decimal.

Valor de 2 al ingresarlo al ensamblador: 32
Valor de 2 despues de la resta:2

Este procedimiento lo repite con ambos numeros y los guarda en chr1 y chr2. Posteriormente, imprime el caracter * con el servicio 02 de la interrupcion 21h que sirve para salida de caracter unico.

 Continuamos con el mismo proceso de ingresar y convertir a decimal con los otros dos numeros, solo que estos iran a las variables chr3 y chr4. Finalmente, en esta parte imprime el caracter = y en pantalla vemos algo como lo que aparece en la foto.
Si revisas tu apartado de variables, deberias tener los valores de los numeros en cada una de tus variables de caracter como esta en la foto(valores ya decimales).

Siguiendo con el ejemplo, hasta ahora tenemos algo parecido a lo que vemos en la foto. Sabemos que cada uno de los numeros esta dentro de una variable chr, pero..como se hara lo demas??

Aqui en donde comenzamos a realizar la operacion, tomamos el numero en chr4  y el primer numero a multiplicar. En si, lo que estamos haciendo es una multiplicacion paso a paso, como comunmente hacemos a mano.

Esos dos valores iran a los registros al y bl, una vez ahi se multiplicaran y el resultado quedara en el registro al.

Como se puede apreciar, el resultado de la multiplicacion es 10, en hexadecimal A. Para poder guardar por separado ambos numeros(ya que en si, no podemos guardar el 10 como resultado final) limpiamos la parte alta del registro AX, para hacer lo siguiente:

Aplicamos la funcion aam, y lo que hara es separarnos las unidades de las decenas en la parte alta y baja del registro.

En la tercera foto de los registro de la imagen de arriba podemos ver como, en al tenemos 0 y en ah tenemos 1.

Asi que, el resultado que deberia ir abajo como una multiplicacion comun se guardara en r4, mientras que nuestro acarrero(lo que conocemos como el numero que "se lleva") que es 1, se guardara en ac1.

Aqui realizamos la misma operacion, pero al momento de guardar nuestro resultado en r3, tambien le sumaremos ese numero de acarreo que antes habiamos sacado en la operacion anterior. Ya que, ese numero afecta al resultado de nuestra siguiente operacion.
Finalmente, volvemos a hacer la separacion de acarreo y resultado, para tener nuestro resultado en r3 y el nuevo acarreo guardarlo nuevamente en ac1.

Entonces, hasta ahorita nuestras variables se ven de la siguiente forma. Deberíamos tener todas las variables de caracteres ocupadas por los números que usamos al inicio, y los resultados 4 y 3,junto con el acarreo 1.

El paso siguiente en la sintaxis, es volver a hacer el mismo proceso que hicimos con chr4, pero ahora con chr3.
No dare mucha explicacion, ya que es el mismo proceso que el anterior. Solo que aqui, el acarreo que vayamos teniendo se guardara ahora en ac.

Hasta este punto, todas nuestras variables estan ocupadas por los siguientes valores(puedes confirmarlo siguiendo el diagrama de la imagen con la mulltiplicacion que normalmente hacemos)

La siguiente parte de nuestro programa comienza a realizar la suma de los resultados que ya tenemos. Iniciamos limpiando el registro AX para realizar las sumas necesarias.
Posteriormente, comenzamos moviendo a la parte alta del registro ax, nuestro r3. En la parte alta del registro bx, movemos r2.
Despues de estos movimientos, sumamos ambos registros y el resultado lo guardaremos en r3.
Si ves, antes de esto se realiza lo mismo de la funcion aam, por si acaso hay un acarreo. Lo cual se guardaria ahora en r2, el cual sera nuestro nuevo acarreo en la suma que estamos haciendo.
R4 solo baja como en la imagen sin mover su valor a ningun lado o sumarse porque al igual como realizamos la suma final de la multiplicacion, este numero baja sin ser afectado por algo.

Hasta ahora tenemos las unidades y decenas de nuestro resultado final.

Posteriormente, tomamos los valores de r1 y ac1 para la siguiente suma en los registros.
Hacemos la suma de ac1 con nuestro nuevo acarreo, r2 y posteriormente sumamos lo que hay en r1.
Volvemos a limpiar la parte alta de ax por si hay algo en ella, para posteriormente realizar la función que separa unidades de decenas para guardar nuestro nuevo acarreo.

 Finalmente, sumamos lo que tenemos en ac y en nuestro nuevo acarreo de la suma pasada r2. El resultado de esta suma lo tendremos guardado en ac.

En esta parte, el programa ira imprimiendo el resultado de dicha multiplicación que hemos realizado.
Si vez, es orden que sacamos en donde iba guardando los resultados el programa, es el mismo orden en como los ira imprimiendo en pantalla.

Al momento de ir imprimiendo o cargando los datos, le suma ese 30h que anteriormente le restamos para que pueda imprimir el carácter con ese valor en hexadecimal, y muestre correctamente el resultado.

Programa con loopz. Video

Sintaxis del programa

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

Si bien, al correr el programa es algo confusa su ejecucion.
Ya que se esperaria que se imprima 10 veces la letra si es una S mayuscula(o al menos ese fue mi caso)

Pero no, el programa no saldra de la funcion de input a menos que se le ingrese una letra diferente a la S mayuscula.

Aqui tenemos un ejemplo de ello, si ingresamos una sola letra a en este caso..

El programa al registrar esa letra, termina automáticamente el programa

En cambio, si ingresamos la letra S mayuscula, veremos lo siguiente..

El programa reconoce la letra y nos permite escribir solo 10 veces la letra, ya que esa fue la condición que se dio

En caso de que se revisen las banderas, solo la bandera IF se enciende en todos los casos porque es la que indica si se ignora o procesa una entrada desde teclado.

Programa de comparacion de cadenas. Si se encuentra dentro de la cadena a comparar

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:
  
 mov di,1
 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
  jmp fin  
  
final:    
lea dx,msg4
mov ah,9
int 21h 

fin:
ret   

msg db "zoologico$"
msg2 db "zuo$"
msg4 db "No se encuentra$"
msg3 db "Si se encuentra$"

Comparamos las palabras ZOOLOGICO con ZUO

Comparamos las palabras ZOOLOGICO con ZOO

Programas implementando la instruccion de LOOP

En esta entrada, veremos diferentes formas de utilizar la instrucción LOOP y sus otras versiones dentro de nuestro emu8086.
Originalmente, loop se utiliza para que un ciclo se realice diferentes veces. Sin embargo,existen otras formas en que loop puede ser implementado.

Sintaxis 1

.model tiny
name "Bucle"

.data
    dato db 10,13 ,'Letrero $'
    
.code
    Inicio:
    mov cx,50
    comienzo:
    mov dx,OFFSET dato
    mov ah,09
    int 21h  
    ;inc cx
   loop comienzo
ret

Sintaxis 2 :Uso de loop con la libreria emu8086

org 100h         
include 'emu8086.inc'
  
  mov cx,10   ;Vueltas que va a dar el programa
  
  comienzo:
  printn 'letrero'
  
 loop comienzo


ret

Sintaxis 3: Uso de variantes del loop
En este ejemplo, utilizamos la instrucción loopne en donde, el loop lo comenzara a realizar solo si cx no es igual a cero(algo parecido a lo que hace normalmente loop)

.model tiny
name "Bucle"

.data
    dato db 10,13 ,'Letrero $'    
.code
    Inicio:
    mov cx,10
    comienzo:
    ;mov dx,OFFSET dato
    mov ah,09   
    lea dx,dato
    int 21h  
    ;inc cx
   loopne comienzo
ret

Con el siguiente ejemplo, aquí ya cambia un poco su funcionamiento. jcxz es un tipo de salto condicional que solo se hará si en nuestro registro cx tenemos un cero.
Así es como, al correr este programa se realiza la impresión una sola vez del mensaje en la pantalla, porque al momento de comparar la instrucción con el registro cx ve que tenemos guardado un 10 en el.
Por lo tanto, no volverá a donde se encuentra la instrucción comienzo.

.model tiny
name "Bucle"

.data
    dato db 10,13 ,'Letrero $'
    
.code
    Inicio:
    mov cx,10
    comienzo:
    ;mov dx,OFFSET dato
    mov ah,09   
    lea dx,dato
    int 21h  
    ;inc cx
   jcxz comienzo ;Solo hara el ciclo cuando cx sea 0


ret

Nota:En varios de estos programas podemos ver que hay un comentario en la linea de un incremento en CX. Esto es porque, si dejamos el incremento dentro del ciclo nunca terminara con su ejecucion aun y que tenga un 1 dentro de cx, con ese incremento no permitira que cx llegue a 0 nunca.
Al iniciar tendriamos en este ultimo programa un 10 en CX, con el incremento sube a 11. Al pasar por el LOOP lo baja a 10,y todo lo anterior vuelve a repetirse en consecuencia, nunca se va a llegar al 0 y siempre se mantendrá entre ese 10 y 11

Ciclos condicionales : Programas

En esta entrada dejare varios ejemplos de programas que utilizan ciclos condicionales en su estructura, para recalcar un poco mas de la investigación que antes ya había documentado en una entrada pasada.

Sintaxis 1 

org    100h
include 'emu8086.inc'

mov    al, 25     ; asigna 25 a al 
mov    bl, 10     ; asigna 10 a bl

cmp    al, bl     ; compara al con bl 

je     equal      ; salta si al = bl (zf = 1). 

putc   'n'        ; si llega aqui, entonces bl y al no son iguales 
jmp    stop       ; asi que imprime 'n' y salta a stop 

equal:            ; si llega aqui,
putc   'y'        ; entonces al=bl e imprime y 

stop:

ret               ; llega aqui sin importar nada 

Se asignan los valores a los registros

Como los numeros son diferentes, nos imprime la letra n

En caso de modificar y hacer a ambos numeros iguales

Nos mandara a pantalla la letra "y" 

Sintaxis 2

include 'emu8086.inc'
.model small
.stack
.data
    num1 db 8
    num2 db 8
    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   ;Brinca si es mayor el numero 2
    jz igual    ;Salta si es igual
    jnz Mayor1  ;Brinca si es mayor el numero 1
    
.exit

igual:
    mov ah,09h
    lea dx ,msg1
    int 21h   
    ;printn 'Los numeros son iguales'
.exit 

Mayor1:
    mov ah,09h
    lea dx, msg2
    int 21h
    ;printn 'El numero 1 es mayor'
.exit

Mayor2:
    mov ah,09h
    lea dx, msg3
    int 21h
    ;print 'El numero 2 es mayor'
.exit
end

En si, lo que realiza este ultimo programa es la comparación de dos números mediante la instrucción cmp, al momento de compararlos tenemos tres lineas de brincos condicionales; jc,jz y jnz. Cada una dará un salto hacia la etiqueta que se le tiene asignada siempre y cuando cumpla con la condición que tiene cada una de ellas.

Finalmente, aqui muestro los tres posibles mensajes que puede darte el programa cuando se cumplan las condiciones de las instrucciones;Si los números son iguales, si el primer numero es mayor que el segundo o si el segundo numero es mayor al primer numero.