PROGRAMAS EMU8086

Programa Hola Mundo


CR EQU 13    

LF EQU 0Ah

DATOS SEGMENT
       MENSAJE DB CR, LF, 'Hola mundo Mario ', 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 








Programa Usando Constantes 


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

DATOS SEGMENT
    TEXTO DB 'Ejemplo 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, PIN
    INT DOS
CODIGO ENDS
END INICIO







Programa Suma de Dos Numeros:


include "emu8086.inc"
org 100h

.data
suma db 2 dup (?)  ;Creamos un arreglo llamado suma de 2 espacios de tipo byte

.code
Sumas proc      ;Se crea un proceso de sumas y se piden los numeros
    printn " "
    print "Introduce el primer numero ==>"
    call scan_num
    mov suma[0],cl   ;guarda el valor en cl,y lo manda al arreglo
    printn " "
    print "Introduce el segundo numero ==>"
    call scan_num   ;
    mov suma[1],cl
    printn " "
    xor ax,ax     ;se limpia el registro ax
    add al,suma[0] ;se manda la suma al registro al
    add al,suma[1] ;se manda para poder imprimir
    printn " "
    print "La suma es: "
    call print_num
Sumas endp
exit:
    printn " "
    printn " "
    print "Presiona enter para salir..";etiqueta con instruccion para salir del programa
    mov ah,0
    int 16h
    ret
   define_print_string   ;apartado de definicion de comandos emu8086.inc
   define_print_num
   define_print_num_uns
   define_scan_num           
   end




En la seccion de datos, se va a declarar un arreglo llamado suma de dos espacios de tipo byte,despues de ello iniciamos con el codigo de nuestro programa.
Iniciamos creando un procedimiento llamado suma y comenzamos a pedir los numeros.
Mandamos a imprimir mensajes por medio de la instruccion print, posteriormente por medio de una llamada, usamos la funcion scan_num que funciona para la obtencion de datos ingresados por el usuario.
Guardamos el valor en la parte alta del registro cx, y posteriormente lo mandamos al arreglo que habiamos creado en un inicio. (Hacemos lo mismo con el segundo numero a ingresar).
Una vez que tenemos nuestros dos valores en el arreglo, limpiamos el registro ax que utilizaremos para poder realizar la suma. Mandamos lo que hay en la posicion 0 de nuestro arreglo suma a la parte alta de ax para que se sume con lo que hay en el(como se limpio, por ende no debe haber nada), y posteriormente hacemos lo mismo con la posicion 1 de nuestro arreglo.
Finalmente mandamos a imprimir el resultado de nuestra suma con la funcion print_num que nos imprime en pantalla el contenido del registro ax.(se termina el procedimiento).




Programa que resta 2 números
.model small
.stack 64
.data
  
;declarando variables globales
numero1 db 0
numero2 db 0

resta db 0

msjn1 db 10,13, "INGRESE EL PRIMER NUMERO A RESTAR=  ",'$';ingrese n1
msjn2 db 10,13, "INGRESE EL SEGUNDO NUMERO A RESTAR=  ",'$';ingrese n2

;mensaje para mostrar los resultados
 

msjnR db 10,13, "LA RESTA DE LA OPERACION DADA ES=  ",'$'
 

.code
begin proc far   
    
    
    ;direccionamiento del procedimiento
    mov ax, @data
    mov ds,ax   
    
    
    ;solicitar del teclado numero 1
    
    mov ah, 09
    lea dx, msjn1
    int 21h
    mov ah, 01
    int 21h
    sub al, 30h
    mov numero1,al   
    
    
    ;solicitar del teclado numero 2
    
    mov ah, 09
    lea dx, msjn2
    int 21h
    mov ah, 01
    int 21h
    sub al, 30h
    mov numero2,al
    
    ;operaciones aritmeticas
                  
    
    ;RESTA
    mov al,numero1
    sub al,numero2
    mov resta,al
    
 
    ;mostrando la resta
    mov ah,09
    lea dx,msjnR
    int 21h
    mov dl,resta
    add dl,30h 
    mov ah,02
    int 21h
   
  
    ;cierre del programa
    mov ah,4ch
    int 21h
    
    begin endp
end



Programa con librerias emu8086.inc
 include 'emu8086.inc'

ORG    100h

LEA    SI, msg1       ; pregunta por el numero
CALL   print_string   ;
CALL   scan_num       ; guarda el numero en CX

MOV    AX, CX         ; Copia el numero a AX

; Imprime la siguiente cadena
CALL   pthis
DB  13, 10, 'Es el numero ', 0

CALL   print_num      ; Imprime el numero en AX

RET                   

msg1   DB  'Introduce numero ', 0

DEFINE_SCAN_NUM
DEFINE_PRINT_STRING
DEFINE_PRINT_NUM
DEFINE_PRINT_NUM_UNS  
DEFINE_PTHIS

END         












Programa que multiplica dos numeros usando libreria


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 '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   






































Programa usando LOOP









.model tiny



name "Bucle"







.data



    dato db 10,13 ,'Mario $'



    



.code



    Inicio:



    mov cx,50



    comienzo:



    mov dx,OFFSET dato



    mov ah,09



    int 21h  



    ;inc cx



   loop comienzo



ret

































:Uso de loop con la libreria emu8086


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


ret






























Programa con Ciclos




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 






























Programa; Mayor ,Menor Iguales




















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






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.


























Programa que imprime valores numéricos con Macros














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
























Programa Cuadros con Macros










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













Programa que cambia de color la pantalla con enter







Pila segment stack 'stack' ;Segmento de la pila



     db 100h dup (?)       ; A partir de la direccion 100 de la pila.



Pila ends







  datos segment



    



      titulo db 13,10,'  CAMBIAR FONDO DE PANTALLA  ',13,10,'$'



      mensaje db 'Presione ENTER si quiere la pantalla azul ' , ' Si quiere morado, presione 2 ',13,10,' Para salir ', ' Presione cualquier tecla',13,10,'$'







  datos ends







codigo segment ;segmento de codigo



       



       assume cs:codigo, ss:pila, ds:datos







Inicio:



           ;****************************** PREPARAR PANTALLA



   mov ah,0



       mov al,3h ; Modo Texto



       int 10h   ; Interrupcion de Video



       



       mov ax,0600h ; Limpiar Pantalla



       mov bh,0fh   ; O Color de fondo negro, el color de letra blanco



       mov cx,0000h



       mov dx,184Fh



       int 10h



       



       mov ah,02h



       mov bh,00



       mov dh,00



       mov dl,00



       int 10h



       



           ;****************************** MOSTRAR MENSAJE







       mov ax,datos



       mov ds,ax



       



       lea dx,titulo



       mov ah,9h



       int 21h



       



       lea dx,mensaje



       mov ah,9h



       int 21h



       



           ;****************************** CAPTURA DE TECLAS







       mov ah,08           ; Pausa y captura de datos db espera que el usuario presiona una tecla



       int 21h







       cmp al,13           ; Verifica al presionar ENTER, el cual tiene un codigo ascii



       je llamarAzul       ; Salto Condicional jump equals opcion 1 saltar si es igual a la opcion 1



       



       



       cmp al,50           ; Ascii 50 = numero 2 compara lo que tiene el regisro ah con el ascii 50 en el reg a1



       je llamarMorado



       



       jmp fin             ; Si no escoge ni ENTER ni 2, Sale del programa







       fin:                ; Saca el mensaje por pantalla







       mov ax,4c00h



       int 21h



       



llamarAzul:



      CALL AZULPROC



      



llamarMorado:



      CALL MORADOPROC



      



           ;****************************** STORE PROCEDURE AZUL







AZULPROC PROC NEAR







         mov ah,0



         mov al,3h ; Modo Texto



         int 10h   ; Interrupcion de video



         



         mov ax,0600h ; Limpiar Pantalla



         mov bh,0fh   ; Color de fondo negro, f color de letra blanco



         mov cx,0000h



         mov dx,184Fh



         int 10h



        



         mov ah,02h



         mov bh,00



         mov dh,00



         mov dl,00



         int 10h



         



;//////////////////////////////////////         







      mov ah,06h



      mov bh,1fh     ;2fh



      mov cx,0000h



      mov dx,184fh



      int 10h



      



      mov ax,4c00h



      int 21h



RET







AZULPROC ENDP







;*****************************************STORED PROCEDURE MORADO







MORADOPROC PROC NEAR







           mov ah,06h



           mov bh,5fh        ;2fh;3 para azul, 4 para guinda, 5 morado



           mov cx,0000h



           mov dx,184fh



           int 10h



           



           mov ax,4c00h



           int 21h



           



RET







































Programa que califica si aprobaste o reprobaste el curso










.model small
.stack 64

.data ;seccion de variables  
   msg1 db "Dame una calificacion (Seguida de un enter):.$"
   aprobado db 13,10,"Aprobado.$"
   reprobado db 13,10,"Reprobado.$"
   VAR1 dw ?,"$"
   VAR2 dw ?,"$"
   VAR3 dw ?,"$"
   
   
.code ;inicia el segmento del programa
RESULTADO PROC FAR
    MOV AX,@DATA ;Inicio del programa
    MOV DS,AX
    ;Desplegar primer mensaje
    
    MOV AH,09
    lea DX,msg1
    int 21h
    ;Pedir un numero
    MOV AH,01
    int 21h
    MOV VAR1,AX
    ;Pedir un segundo numero
    MOV AH,01
    int 21h
    MOV VAR2,AX
    ;Pedir un tercer numero
    MOV AH,01
    int 21h
    MOV VAR3,AX
    ;Momento de evaluar la calificacion
    
    CMP AL,13           ;Comparacion
    JE CONTINUE   ;Salta si es igual
    JMP MAYOR      ;salto incondicional
    ;Inicia funcion
    CONTINUE:
        MOV AX,VAR1
        CMP AL,037h  ;7 es 37 en ascii
        JGE MAYOR   ;salta si es mayor o igual
        JMP MENOR   ;salto incondicional
        
    MAYOR:
        MOV AH,09
        lea dx,aprobado
        int 21h 
        JMP SALIR
        
    MENOR:
        MOV AH,09
        lea dx,reprobado
        int 21h
        JMP SALIR
        
    SALIR:
        MOV AX,4CH
        int 21h
        
    RESULTADO ENDP
END RESULTADO























Programa que dado un numero imprime a binario











  







data segment



  



      NN db 0



   dig db 0



   aux db 0







  



  



ends







stack segment



    dw   128  dup(0)



ends







code segment



start:



; set segment registers:



    mov ax, data



    mov ds, ax



    mov es, ax







    bucle:



      call leer3 ; en dig esta el numero ascii



      cmp dig,0Dh



      je salir



      sub dig, 30h



      mov al,1010b



      mul NN



     



      add al,dig



      mov NN,al



   



      jmp bucle



        



    mov ax, 4c00h ; exit to operating system.



    int 21h



   



    ;PROCESOS



       



    salir:



       call mostrar3



       mov ax, 4c00h



       int 21h



    ret



   



    mostrar3:



      mov cx,08h



      bucle2:



        rol nn,01h



        adc aux,00h



       



        mov dl, aux



        add dl,30h



        mov ah,02h



        int 21h



        mov aux,00h



        loop bucle2



    ret



       



    leer3:



      mov ah, 01h



      int 21h



      mov dig,al



    ret 







   



   



ends







end start ; set entry point and s































Uso de registros en emu8086



El registro AX se usa para almacenar resultados, lectura o escritura desde o hacia los puertos.
El registro BX sirve como apuntador base o indice.
El registro CX se utiliza en operaciones de iteracion, como un contador que se va incrementado o decrementa de acuerdo con el tipo de instrucción dada. Mas comúnmente, utilizado en algún ciclo.
El registro DX se usa como puente para el acceso de datos.










;uso del registro cx
org 100h
    MOV DL, "A" ;se transfiere la letra A al registro (valor en hexadecimal del assembler 8086"dar clic al codigo ascii")
    MOV CX, 26 ;se asigna el 26 al registro cx
  imprime: ;va a imprimir hasta acabar las 26
    MOV AH, 02 ;se va a tranferir el 02 al acumulador de byte
    INT 21h ;dato ascii leido desde el teclado
    INC DL  ;incrementa dl
   LOOP imprime ;continua









































































Comentarios











Publicar un comentario
























Entradas populares de este blog




























 Unidad III: Modularización        Introducción:  la programación modular es uno de los métodos de diseño mas flexibles y poderosos para el mejoramiento de la productividad de un programa. Usando la programación modular el problema se divide en módulos, donde cada una de los cuales ejecuta una única actividad o tarea y se codifican independientemente de otros modulo. Cada uno de estos módulos se analiza, se codifica y se prueba de preferencia por separado. al trabajr conlenguaje ensamblador, la necesidad de la estructura es, si cabe, aún es más vital, puesto que cualquier tarea, por encilla que parezca, puede requerir una gran lista de sentencias ejecutables. Todo programa contiene un módulo denominado programa principal que controla todo llo que sucede; si se transfiere el control a un submódul, este ejecuta su función y una vez que la termina, regresa el control al módulo desde donde fue llamado. En mucho casos es el modulo principal. Si la tarea asignada a cada submódulo es demasiad...








Leer más










Resumen de Lenguaje ensamblador del procesador




















Imagen







  REGISTROS INTERNOS DEL MICROPROCESADOR     La U nidad C entral de P roceso ( CPU , por sus siglas en inglés ) tiene 14  registros in-ternos cada uno de  16  bits. Los primeros cuatro,  AX ,  BX ,  CX  y  DX , son de uso general  y se pueden usar también como registros de 8  bits. Es decir, AX  se puede dividir en AH  y AL  ( AH  es el byte alto, high , y AL  es el byte bajo, low ) Lo mismo es aplicable a los otros tres ( BX  en BH  y BL , CX  en CH  y CL  y DX  en DH  y DL )     Estos son los únicos registros que pueden usarse de modo dual (en 8  o 16  bits)     Los registros  de la CPU  son conocidos por sus nombres propios, que son:     ·     AX                 ( a cumulador)   ·          BX ( r egistro b ase)     ·          CX ( r egistro c ontador)     ·          DX ( r egis...








Leer más




























Imagen







  Unidad 2 – Programación básica     Competencia específica   Conocer y utilizar las principales instrucciones del lenguaje ensamblador, para realizar determinadas aplicaciones de interfaz. Listar las principales instrucciones de programación en lenguaje ensamblador.      2.1 Ensamblador (y ligador) a utilizar.     Aunque la sintaxis entre ensambladores es parecida, es necesario mencionar que los ejemplos de este manual están hechos para las siguientes herramientas:   Turbo Assembler   Turbo Assembler o TASM es un ensamblador desarrollado por Borland el cual además de permitir ensamblar código MASM (Microsoft Macro Assembler) en su modo de compatibilidad, es capaz de soportar programación orientada a objetos desde la versión 3.0 y de generar código para 16 o 32 bits.   La característica más importante de Turbo Assembler es que es compatible con lenguajes de alto nivel, por ejemplo: Turbo Pascal, Turbo Basic, Turbo C, Turbo C++.   Turbo Linker   Turbo Linker o T-Link es el enla...








Leer más