Lenguaje esamblador y emu8086

Programa hola mundo

	.model small
	.data
	saludo db "Hola Mundo"."$"
	.code
	programa:
	mov ax,seg saludo
	mov ds,ax
	mov ah,09h
	lea dx,saludo
	int 21h
	mov ax, 4c00h
	int 21h
	end programa

view raw Hola_mundo.asm hosted with ❤ by GitHub

De decimal a binario

	name "Decimal a Binario"
	org 100h
	jmp start
	;mensaje en pantalla:
	msg1 db 0Dh,0Ah, "Ingrese cualquier numero de -32768 a 65535, o presione cero para salir: $"
	msg2 db 0Dh,0Ah, "El numero binario es: $"
	;buffer para int 21/0ah
	;primer byte es en el tamano del buffer,
	;segundo byte es el numero de chars actualmente leidos (establecer por int 21h/0ah).
	buffer db 7,?,5dup (0), 0, 0
	;para resultados
	binary dw ?
	start:
	; imprime mensaje de bienvenida:
	mov dx, offset msg1
	mov ah, 9
	int 21h
	; input string:
	mov dx, offset buffer
	mov ah, 0ah
	int 21h
	;presionar 0 para terminar:
	mov bx, 0
	mov bl, buffer[1]
	mov buffer[bx+2], 0
	lea si, buffer + 2 ; buffer inicia el 3er byte.
	call tobin
	; el numero se guarda en el registro cx.
	; de '-1234' it's 0fb2eh
	mov binary, cx
	jcxz stop
	; imprime el pre resultado:
	mov dx, offset msg2
	mov ah, 9
	int 21h
	;imprime en forma binaria
	mov bx, binary
	mov cx, 16
	print: mov ah, 2 ;imprime funcion
	mov dl, '0'
	test bx, 1000000000000000b ;teste el primer byte.
	jz zero
	mov dl, '1'
	zero: int 21h
	shl bx, 1
	loop print
	; imprime el suffix:
	mov dl, 'b'
	int 21h
	jmp start ; loop
	stop:
	ret ; regresar el sistema del control.
	; este procedimiento convierte un numero a string a
	; numero binario. el numero puede tener el signo ('-').
	; el resultado esta guardado en el registro cx.
	; parametros:
	; si - direccion de numero string (cero terminado).
	tobin proc near
	push dx
	push ax
	push si
	jmp process
	; === variables locales ===
	make_minus db ? ; usando como una bandera.
	ten dw 10 ; usando un multiplier.
	;=========================
	process:
	; reiniciar el acumulador:
	mov cx, 0
	; resetear la bandera:
	mov cs: make_minus, 0
	next_digit:
	; leer char a al y
	; apuntar a el siguiente byte:
	mov al,[si]
	inc si
	; checar el final del string:
	cmp al, 0 ;termina el string?
	jne not_end
	jmp stop_input
	not_end:
	; chequeo para el minimo:
	cmp al, '-'
	jne ok_digit
	mov cs:make_minus, 1 ;establecer bandera!
	jmp next_digit
	ok_digit:
	; multiplicar cx por 10 (primera vez que el resultado es cero)
	push ax
	mov ax, cx
	mul cs:ten ; dx:ax = ax*10
	mov cx, ax
	pop ax
	; es asumido que dx is cero - overflox no cheacado
	; convertir de codigo ascill :
	sub al, 30h
	; agregar al to cx:
	mov ah, 0
	mov dx, cx ; respaldo, en caso que el resultado sea muy grande.
	add cx, ax
	; agregar - overflow no checado
	jmp next_digit
	stop_input:
	;checar bandera, si numero string tenia '-'
	; estar seguro que el resultado es negativo:
	cmp cs:make_minus, 0
	je not_minus
	neg cx
	not_minus:
	pop si
	pop ax
	pop dx
	ret
	tobin endp

view raw Decimal_a_binario.asm hosted with ❤ by GitHub

Suma de dos digitos

	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

view raw Suma_de_dos_digitos.asm hosted with ❤ by GitHub

contador de números positivos, negativos y 0s

	; La longitud del blosque esta en la localidad 0203, el bloque inicia en la localidad 0204. En la localidad 0200 deposite el numero de
	; elementos negativos, en la 0201 el numero de elementos ceros y en la 0202 el numero de elementos positivos
	INICIO:
	MOV AL,00h ; Mover 00h al registro AL
	MOV [200],AL ; Mover AL a la localidad 200
	MOV [201],AL ; Mover AL a la localidad 201
	MOV [202],AL ; Mover AL a la localidad 202
	MOV CH,AL ; Mover AL al registro CH
	MOV CL,[203] ; Mover la localidad 203 al registro CL
	MOV BX,0204 ; Mover 0204 al registro BX
	MOV AL,[BX] ; Mover BX a AL
	RETORNO:
	CMP AL,00h ; Comparar 00h a AL
	JGE SII ; Salto condicional a SII
	INC [200] ; Incrementa a 1 la localidad 200
	SIGUE:
	INC BX ; Incrementa a 1 el registro BX
	LOOPNZ RETORNO ; Repite mientras no sea igual a cero
	FIN:
	RET
	SII:
	JNZ NO ; Salto condicional a NO
	INC [201] ; Incrementa en 1 la localidad 201
	JMP SIGUE ; Salta a SIGUE
	NO:
	INC [202] ; Incrementa en 1 la localidad 202
	JMP SIGUE ; Salta a SIGUE

view raw Contador_de_numeros.asm hosted with ❤ by GitHub

Verificador de 2 cadenas, para determinar si son iguales

	org 100h
	comienzo:
	mov si, x
	mov al, msg2[si]
	cmp msg[si], al ;comparar letra por letra las cadenas, si uno no coincide manda directamente a fin y termina el programa
	jne fin:
	cmp msg[si], "$" ;si es el final y el programa llega aca, quiere decir que son iguales
	jz final:
	inc x
	loop comienzo
	final:
	mov dx, offset msg3
	mov ah, 9
	int 21h
	fin:
	ret
	msg db "hello world $" ;Este es el primer mensaje que compara
	msg2 db "hello world $" ;Este es el seguundo mensaje que compara
	msg3 db "Son iguales $" ; Mostrara este mensaje en pantalla si es que los dos mensajes son iguales en caso de que no sean iguales no mostrara nada
	x dw 0

view raw verificador.asm hosted with ❤ by GitHub

Buscador del menor

	; La longitud del bloque esta en la localidad 4001 y el bloque inicia en
	; la localidad 4002. Almacene el resultado en la localidad 4000, considerando
	; numeros sin signo
	MENOR:
	MOV DI,4002 ; Mueve 4002 a DI
	MOV AL,[DI] ; Mueve DI a AL
	MOV CL,[4001] ; Mueve 4001 a CL
	MOV CH,0 ; Mueve 0 a CH
	X:
	INC DI ; Incremente a 1 a DI
	CMP AL,[DI] ; Compara AL con DI
	JB Y ; Salta a Y si la condicion se cumple
	MOV AL,[DI] ; Mueve DI a AL
	Y:
	LOOP X ; Loop a X
	MOV [4000],AL ; Mueve AL a 4000
	END

view raw Buscador.asm hosted with ❤ by GitHub

Verificador de subcadenas

	org 100h
	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
	cmp msg[si], al ;comparar si encuentra la primera letra de la cadena
	jne seguir
	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 aca quiere decir que la cadena es parte de la palabra
	jz resultado
	loop comprobar ;bucle para recorrer cadena
	seguir:
	inc si ;para seguir recorriendo la palabra
	loop comienzo ;bucle principal para recorrer palabra
	resultado:
	mov dx, offset msg3 ;copiar msg3 a dx
	mov ah, 9 ;preparar ah con 9 para la interrupcion 21h
	int 21h ;mostrar contenido en dx
	final:
	ret
	msg db "Instituto Tecnologico de Matamoros$"
	msg2 db "olo$"
	msg3 db "Si es subcadena$"

view raw verificador_subcadena.asm hosted with ❤ by GitHub

Uso de registro

	;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

view raw Uso_registro.asm hosted with ❤ by GitHub

Decartador de caracteres no numerales.

	ORG 100H
	mov si, 0
	lectura:
	mov ah,1
	int 21h
	cmp al,13
	jz resultado:
	cmp al, 57 ;si tecla es mayor a 57 entonces ir a fin3 (tecla > 57)
	ja fin3
	cmp al,47 ;si tecla no es mayor a 47 ir a fin3 (tecla <= 47)
	jng fin3
	mov bx[si], al ;si es un digito entonces guardo en bx
	inc si ;incrementa si
	fin3:
	jmp lectura
	resultado:
	mov ah,00h ;limpia la pantalla
	mov al,03h
	int 10h
	mov bx[si], "$"
	mov dx, offset bx
	mov ah, 9 ;preparar ah con 9 para la interrupcion 21h
	int 21h ;mostrar contenido en dx
	ret

view raw Descartador.asm hosted with ❤ by GitHub

Ejemplo de libreria

	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

view raw Ejemplo_libreria.asm hosted with ❤ by GitHub

Arreglos

	name "arreglo"
	org 100h
	;un areglo se puede acceder a travez de []
	mov cx, 9 ;cuantos elementos voy a recorrer, empezamos con el 9
	inicio:
	mov si, cx
	mov dl, v[si]
	cmp dl, mayor
	jng siguiente:
	mov mayor,dl
	siguiente:
	loop inicio
	ret
	v db 1,32,64,32,98,12,5,21,91,38
	mayor db 0

view raw arreglos.asm hosted with ❤ by GitHub

Interrupciones

	name "int01"
	org 100h
	mov ah, 1 ;Leer un caracter de la entrada estandar
	int 21h ;Llamada al sistema operativo (DOS)
	mov tecla, al
	mov ah, 2 ;imprime un simbolo a la consola
	mov dl, simbolo ;el caracter a mostrar, en este caso la E
	int 21h ;Llamada al DOS
	inc tecla
	mov ah, 7 ;NO imprime un simbolo a la consola
	mov dl, tecla ;
	int 21h ;Llamada al DOS
	ret
	;Variables
	tecla db 0
	simbolo db 45H
	;ah que queres hacer
	;ah = 1 guarda caracter en al
	;ah = 2 escribe un caracter en la consola. El ascii del cacacter a imprimir se pone el dl
	;AH = 7 es igual a el ah=2 pero el resultado no se ve en pantalla
	;ah = 9 imprime una cadena en la consola. Considera el caracter $ como fin de cadena.
	;La direccion de la cadena se expresa en DX

view raw Interrupciones.asm hosted with ❤ by GitHub

Cambio de caracteres de minúsculas a mayúsculas

	name "int02"
	ORG 100H
	lectura:
	mov ah,7
	int 21h
	mov tecla, al
	cmp al,13
	jz fin:
	cmp tecla, 122 ;si tecla es mayor a 122 entonces ir a fin3 (tecla > 122)
	ja fin3
	cmp tecla,96 ;si tecla no es mayor a 96 ir a fin3 (tecla <= 96)
	jng fin3
	sub tecla, 32 ;si es 'a' hasta 'z' entonces restarle 32
	fin3:
	mov ah,2
	mov dl,tecla
	int 21h
	jmp lectura
	fin:
	ret
	tecla db 0

view raw cambio_a_mayúsculas.asm hosted with ❤ by GitHub

Loop

	.model tiny
	name "Bucle"
	.data
	dato db 10,13 ,'Lenguaje de interfaz $'
	.code
	Inicio:
	mov cx,50
	comienzo:
	mov dx,OFFSET dato
	mov ah,09
	int 21h
	;inc cx
	loop comienzo
	ret

view raw Loop.asm hosted with ❤ by GitHub

Loop con librerías

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

view raw loop_con_librerias.asm hosted with ❤ by GitHub

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

view raw Ciclos.asm hosted with ❤ by GitHub

Suma de una serie de 16 bits

	; La longitud de la serie esta en la localidad de memoria 0202 y la serie
	; empieza en la localidad de memoria 0203. Almacenar la suma en las localidades
	; de memoria 0200 y 0201.
	INICIO: CLC ; clear carry flag
	MOV CH,0 ; mover 0 a CL
	MOV CL,[202] ; mover la localidad 202 al registro CL
	MOV BX,203 ; mover 203 a BX
	MOV AX,0 ; mover 0 a AX
	RETORNO:
	ADC AX,[BX] ; Add with carry BX a AX
	INC BX ; incrementa BX
	LOOP RETORNO ; loop a retorno
	MOV [200],AX ; mueve AX a la localidad 200
	END

view raw Suma_de_una_serie_de_16_bits.asm hosted with ❤ by GitHub

Uso del registro CX

	; Uso el registro CX como contador. Vamos a mover los 8 bits menos
	; significativos del registro BL al registro BH
	; BX = BH y BL = 43A6h
	; Se usara la instruccion RCL BX,1 8 veces. Para este tipo de interrupciones
	; usaremos al registro CX como contador.
	ROTA8: MOV BX, 43A6h ; Mueve el valor 43A6h hexadecimal a BX
	MOV CX, 08 ; Mueve 08 al registro CX
	OTRAVEZ:
	RCL BX,1h ; Rota a la izquierda el valor BX 1 vez
	LOOP OTRAVEZ ; Te manda otra vez a OTRAVEZ
	MOV AH,4CH ;
	INT 21H

view raw Uso_del_registro_CX_como_contador.asm hosted with ❤ by GitHub

Impresión de caracteres 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

view raw Impresión_de_caracteres_numéricos_con_Macros.asm hosted with ❤ by GitHub