lenguaje de interfaz - temas
TRANSCRIPT
Lenguaje de interfaz
Instituto Tecnológico de Lázaro Cárdenas
Profesor:
Ing. Pablo Reynaldo
Materia:
Lenguaje de interfaz
Elaborado por:
Carlos Héctor Cruz López
Temario
1
Índice
Unidad 1 Introducción al lenguaje ensamblador .............................................................. 3
1.1 Importancia de la programación en lenguaje ensamblador .......................................... 3
1.2 El procesador y sus registros internos ........................................................................... 4
1.3 La memoria principal (RAM) ..................................................................................... 11
1.4 El concepto de interrupciones ..................................................................................... 12
1.5 Llamadas a servicios del sistema ................................................................................ 17
1.6 Modos de direccionamiento ........................................................................................ 18
1.7 Proceso de ensamblado y ligado ................................................................................. 23
1.8 Desplegado de mensajes en el monitor ....................................................................... 24
Unidad 2 Programación básica ......................................................................................... 26
2.1 Ensamblador (y ligador) a utilizar .............................................................................. 26
2.2 Ciclos numéricos ......................................................................................................... 27
2.3 Captura de cadenas ..................................................................................................... 28
2.4 Comparación y prueba ................................................................................................ 29
2.5 Saltos ........................................................................................................................... 30
2.6 Ciclos condicionales ................................................................................................... 31
2.7 Incremento y decremento ............................................................................................ 32
2.8 Captura de cadenas con formato ................................................................................. 33
2.9 Instrucciones aritméticas ............................................................................................. 33
2.10 Manipulación de la pila ............................................................................................. 34
2.11 Obtención de cadena con representación decimal .................................................... 35
2.12 Instrucciones lógicas ................................................................................................. 36
2.13 Desplazamiento y rotación ........................................................................................ 36
2.14 Obtención de una cadena con la representación hexadecimal .................................. 37
2
2.15 Captura y almacenamiento de datos numéricos ........................................................ 39
2.16 Operaciones básicas sobre archivos de disco ........................................................... 41
Unidad 3 Modularización .................................................................................................. 44
3.1 Procedimientos ............................................................................................................ 44
3.2 Macros ........................................................................................................................ 45
Unidad 4 Programación de dispositivos ........................................................................... 46
4.1 El buffer de video en modo texto ................................................................................ 46
4.2 Acceso A Discos En Lenguaje Ensamblador ............................................................. 47
4.3 Programación Del Puerto Serial ................................................................................. 49
4.4 Programación Del Puerto Paralelo .............................................................................. 50
4.5 Programación Híbrida ................................................................................................. 51
4.6 Programación De Puerto USB (Universal Serial Bus) ............................................... 52
Programas ........................................................................................................................... 54
3
Unidad 1 Introducción al lenguaje ensamblador
1.1 Importancia de la programación en lenguaje ensamblador
El lenguaje ensamblador es un tipo de lenguaje de bajo nivel utilizado para escribir
programas informáticos, y constituye la representación más directa del código máquina
específico para cada arquitectura de microprocesador.
La importancia del lenguaje ensamblador es principalmente que se trabaja directamente con
el microprocesador; por lo cual se debe de conocer el funcionamiento interno de este, tiene
la ventaja de que en él se puede realizar cualquier tipo de programas que en los lenguajes
de alto nivel no lo pueden realizar. Otro punto sería que los programas en ensamblador
ocupan menos espacio en memoria.
Para programar en ensamblador debes conocer algunos aspectos extra: debes comprender
no sólo las instrucciones que vas a usar sino también la arquitectura de la máquina,
necesitas saber cómo se almacenan los datos, como el procesador manipula los datos, etc.
Cuando programas en lenguajes de bajo nivel debes hacer más que solo describir la
solución formal del programa, debes dividir el programa en pasos pequeños y básicos.
Estos pasos le dirán al procesador que hacer, una instrucción a la vez.
La recompensa de aprender y practicar con el lenguaje ensamblador es desarrollar una idea
sólida de cómo opera una computadora, además de escribir programas rápidos y pequeños
para ejecutar tareas que no son prácticas (demasiado lentas) o no son posibles o demasiado
complejas en lenguajes de alto nivel.
A pesar del hecho de que codificar en un lenguaje de alto nivel es más productivo, alguna
de las ventajas de codificar en lenguaje ensamblador son:
Proporciona más control sobre el manejo particular de los requerimientos de
hardware.
Genera módulos ejecutables más pequeños y más compactos.
Con mayor probabilidad tiene una ejecución más rápida
Uso y aplicaciones del lenguaje ensamblador
4
El uso del lenguaje ensamblador le permite al programador indicarle al computador
exactamente cómo llevar a cabo una tarea específica usando la menor cantidad de
instrucciones. Aun cuando el código generado por los compiladores con opción de
optimización es eficiente, la optimización manual puede resultar en una mejora sustancial
en términos de rendimiento y consumo de memoria. El lenguaje ensamblador es
usualmente utilizado en las siguientes circunstancias:
Mejorar la eficiencia de una rutina específica que se ha transformado en un cuello
de botella.
Obtener acceso a funciones de bajo nivel del procesador para realizar tareas que no
son soportadas por los lenguajes de alto nivel.
Escribir manejadores de dispositivos para comunicarse directamente con hardware
especial tales como tarjetas de red.
Trabajar en ambientes con recursos limitados puede requerir el uso del lenguaje
ensamblador pues el código ejecutable puede ser menor que el generado por el
compilador.
Los lenguajes ensamblador tienen sus aplicaciones muy reducidas, se centran
básicamente en aplicaciones de tiempo real, control de procesos y de dispositivos
electrónicos.
1.2 El procesador y sus registros internos
Debe parecer un poco lento el que el procesador trabaje sólo con la memoria primaria, cada
byte a ser usado debe ser transferido y regresado. Sin embargo hay una pequeña cantidad de
memoria construida dentro del procesador. Esta memoria consiste de 14 palabras de
memoria read-write. Cada una de estas palabras es llamada un registro y cada registro tiene
su propio nombre y propósito.
Los registros del procesador se emplean para controlar instrucciones en ejecución, manejar
direccionamiento de memoria y proporcionar capacidad aritmética. Son áreas del
almacenamiento dentro del procesador, usadas para almacenar datos con los cuales está
trabajando el procesador en un momento dado de la ejecución de una instrucción. Los
registros son direccionables por medio de un nombre. Los bits por convención, se numeran
de derecha a izquierda, como en:
5
... 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
Algunas características de los Registros internos
Cada Procesador contiene cierto número de estos.
Los registros son la memoria más rápida de la PC.
La mayoría de las operaciones se realizan en los registros.
El ancho de los registros (en bits), determina cuanta información puede manejar.
El tamaño del procesador está ligado a los registros internos.
Los registros internos del procesador se pueden clasificar en 6 tipos diferentes:
Registros de segmento.
Registros de propósito general.
Registros de apuntadores.
Registros de banderas.
Registros de Puntero de instrucción.
Registros de Pila.
Registros de segmento
Un registro de segmento tiene 16 bits de longitud y facilita un área de memoria para
direccionamiento conocida como el segmento actual.
Registro CS. El DOS almacena la dirección inicial del segmento de código de un programa
en el registro CS. Esta dirección de segmento, más un valor de desplazamiento en el
registro apuntador de instrucción (IP), indica la dirección de una instrucción que es buscada
para su ejecución.
Registro DS. La dirección inicial de un segmento de datos de programa es almacenada en
el registro DS. En términos sencillos, esta dirección, más un valor de desplazamiento en
una instrucción, genera una referencia a la localidad de un byte especifico en el segmento
de datos.
6
Registro SS. El registro SS permite la colocación en memoria de una pila, para
almacenamiento temporal de direcciones y datos. El DOS almacena la dirección de inicio
del segmento de pila de un programa en el registro SS. Esta dirección de segmento, más un
valor de desplazamiento en el registro del apuntador de pila (SP), indica la palabra actual en
la pila que está siendo direccionada.
Registro ES. Algunas operaciones con cadenas de caracteres (datos de caracteres) utilizan
el registro extra de segmento para manejar el direccionamiento de memoria. En este
contexto, el registro ES está asociado con el registro DI (índice). Un programa que requiere
el uso del registro ES puede inicializarlo con una dirección de segmento apropiada.
Registros FS y GS. Son registros extra de segmento en los procesadores 80386 y
posteriores.
Registros de propósito general
Los registros de propósito general AX, BX, CX y DX son los caballos de batalla del
sistema. Son únicos en el sentido de que se puede direccionarlos como una palabra o como
una parte de un byte. El último byte de la izquierda es la parte "alta", y el último byte de la
derecha es la parte "baja". Por ejemplo, el registro CX consta de una parte CH (alta) y una
parte Cl (baja), y usted puede referirse a cualquier parte por su nombre.
Registro AX. El registro AX, el acumulador principal, es utilizado para operaciones que
implican entrada/salida y la mayor parte de la aritmética. Por ejemplo, las instrucciones
para multiplicar, dividir y traducir suponen el uso del AX. También, algunas operaciones
generan código más eficiente si se refieren al AX en lugar de a los otros registros.
Registro BX. El BX es conocido como el registro base ya que es el único registro de
propósito general que puede ser índice para direccionamiento indexado. También es común
emplear el BX para cálculos.
Registro DX. El DX es conocido como l registro de datos. Algunas operaciones de
entrada/salida requieren uso, y las operaciones de multiplicación y división con cifras
grandes suponen al DX y al AX trabajando juntos.
7
Registro de Apuntador de Instrucciones
El registro apuntador de instrucciones (IP) de 16 bits contiene el desplazamiento de
dirección de la siguiente instrucción que se ejecuta. El IP está asociado con el registro CS
en el sentido de que el IP indica la instrucción actual dentro del segmento de código que se
está ejecutando actualmente. Los procesadores 80386 y posteriores tienen un IP ampliado
de 32 bits, llamado EIP.
Registros Apuntadores
Los registros SP (apuntador de la pila) Y BP (apuntador de base) están asociados con el
registro SS y permiten al sistema accesar datos en el segmento de la pila.
Registro SP. El apuntador de la pila de 16 bits está asociado con el registro SS y
proporciona un valor de desplazamiento que se refiere a la palabra actual que está siendo
procesada en la pila. Los procesadores 80386 y posteriores tienen un apuntador de pila de
32 bits, el registro ESP. El sistema maneja de forma automática estos registros.
En el ejemplo siguiente, el registro SS contiene la dirección de segmento 27B3[0]H y el SP
el desplazamiento 312H. Para encontrar la palabra actual que está siendo procesada en la
pila, la computadora combina las direcciones en el SS y el SP:
Registro BP. El BP de 16 bits facilita la referencia de parámetros, los cuales son datos y
direcciones transmitidos vía pila. Los procesadores 80386 y posteriores tienen un BP
ampliado de 32 bits llamado el registro EBP.
Registros Índice
Los registros SI y DI están disponibles para direccionamiento indexado y para sumas y
restas.
Registro SI. El registro índice fuente de 16 bits es requerido por algunas operaciones con
cadenas (de caracteres). En este contexto, el SI está asociado con el registro DS. Los
procesadores 80386 y posteriores permiten el uso de un registro ampliado de 32 bits, el
ESI.
8
Registro DI. El registro índice destino también es requerido por algunas operaciones con
cadenas de caracteres. En este contexto, el DI está asociado con el registro ES. Los
procesadores 80386 y posteriores permiten el uso de un registro ampliado de 32 bits, el
EDI.
Registro de Banderas
De los 16 bits del registro de banderas, nueve son comunes a toda la familia de
procesadores 8086, y sirven para indicar el estado actual de la máquina y el resultado del
procesamiento. Muchas instrucciones que piden comparaciones y aritmética cambian el
estado de las banderas, algunas cuyas instrucciones pueden realizar pruebas para determinar
la acción subsecuente. En resumen, los bits de las banderas comunes son como sigue:
OF (Overflow, desbordamiento). Indica desbordamiento de un bit de orden alto (mas a la
izquierda) después de una operación aritmética.
DF (dirección). Designa la dirección hacia la izquierda o hacia la derecha para mover o
comparar cadenas de caracteres.
IF (interrupción). Indica que una interrupción externa, como la entrada desde el teclado,
sea procesada o ignorada.
TF (trampa). Permite la operación del procesador en modo de un paso. Los programas
depuradores, como el DEBUG, activan esta bandera de manera que usted pueda avanzar en
la ejecución de una sola instrucción a un tiempo, para examinar el efecto de esa instrucción
sobre los registros de memoria.
SF (signo). Contiene el signo resultante de una operación aritmética (0 = positivo y 1 =
negativo).
ZF (cero). Indica el resultado de una operación aritmética o de comparación (0 = resultado
diferente de cero y 1 = resultado igual a cero).
AF (acarreo auxiliar). Contiene un acarreo externo del bit 3 en un dato de 8 bits para
aritmética especializada.
9
PF (paridad). Indica paridad par o impar de una operación en datos de 8 bits de bajo orden
(mas a la derecha).
CF (acarreo). Contiene el acarreo de orden más alto (más a la izquierda) después de una
operación aritmética; también lleva el contenido del ultimo bit en una operación de
corrimiento o de rotación. Las banderas están en el registro de banderas en las siguientes
posiciones:
Las banderas más importantes para la programación en ensamblador son O, S, Z y C, para
operaciones de comparación y aritméticas, y D para operaciones de cadenas de caracteres.
Los procesadores 80286 y posteriores tienen algunas banderas usadas para propósitos
internos, en especial las que afectan al modo protegido.
Registros de PILA
La pila es un área de memoria importante y por ello tiene, en vez de uno, dos registros que
se usan como desplazamiento (offset) para apuntar a su contenido. Se usan como
complemento al registro y son:
SP- Stack Pointer: Se traduce como puntero de pila y es el que se reserva el
procesador para uso propio en instrucciones de manipulado de pila. Por lo general,
el programador no debe alterar su contenido.
BP- Base pointer: Se usa como registro auxiliar. El programador puede usarlo para
su provecho.
Indicadores (flags)
Hay nueve indicadores de un bit en este registro de 16 bits. Los cuatro bits más
significativos están indefinidos, mientras que hay tres bits con valores determinados: los
bits 5 y 3 siempre valen cero y el bit 1 siempre vale uno (esto también ocurría en los
procesadores anteriores).
CF (Carry Flag, bit 0): Si vale 1, indica que hubo "arrastre" (en caso de suma) hacia, o
"préstamo" (en caso de resta) desde el bit de orden más significativo del resultado. Este
indicador es usado por instrucciones que suman o restan números que ocupan varios bytes.
10
Las instrucciones de rotación pueden aislar un bit de la memoria o de un registro
poniéndolo en el CF.
PF (Parity Flag, bit 2): Si vale uno, el resultado tiene paridad par, es decir, un número par
de bits a 1. Este indicador se puede utilizar para detectar errores en transmisiones.
AF (Auxiliary carry Flag, bit 4): Si vale 1, indica que hubo "arrastre" o "préstamo" del
nibble (cuatro bits) menos significativo al nibble más significativo. Este indicador se usa
con las instrucciones de ajuste decimal.
ZF (Zero Flag, bit 6): Si este indicador vale 1, el resultado de la operación es cero.
SF (Sign Flag, bit 7): Refleja el bit más significativo del resultado. Como los números
negativos se representan en la notación de complemento a dos, este bit representa el signo:
0 si es positivo, 1 si es negativo.
TF (Trap Flag, bit 8): Si vale 1, el procesador está en modo paso a paso. En este modo, la
CPU automáticamente genera una interrupción interna después de cada instrucción,
permitiendo inspeccionar los resultados del programa a medida que se ejecuta instrucción
por instrucción.
IF (Interrupt Flag, bit 9): Si vale 1, la CPU reconoce pedidos de interrupción externas
enmascarables (por el pin INTR). Si vale 0, no se reconocen tales interrupciones. Las
interrupciones no enmascarables y las internas siempre se reconocen independientemente
del valor de IF. DF (Direction Flag, bit 10): Si vale 1, las instrucciones con cadenas sufrirán
"auto-decremento", esto es, se procesarán las cadenas desde las direcciones más altas de
memoria hacia las más bajas. Si vale 0, habrá "auto-incremento", lo que quiere decir que las
cadenas se procesarán de "izquierda a derecha".
OF (Overflow flag, bit 11): Si vale 1, hubo un desborde en una operación aritmética con
signo, esto es, un dígito significativo se perdió debido a que tamaño del resultado es mayor
que el tamaño del destino.
11
1.3 La memoria principal (RAM)
Se denomina Memoria a los circuitos que permiten almacenar y recuperar la información.
En un sentido más amplio, puede referirse también a sistemas externos de almacenamiento,
como las unidades de disco o de cinta. Memoria de acceso aleatorio o RAM (Random
Access Memory) es la memoria basada en semiconductores que puede ser leída y escrita
por el microprocesador u otros dispositivos de hardware.
La memoria RAM (Random Access Memory) o memoria de acceso aleatorio de
lectura/escritura volátil, se dispone como una _hoja de trabajo_ para almacenamiento
temporal y ejecución de programas. En la memoria de acceso aleatorio (RAM), las celdas
de la memoria pueden accesarse para la transferencia de información en cualquier posición
aleatoria deseada. Esto es, el proceso de ubicar una palabra en la memoria es igual y
requiere la misma cantidad de tiempo, sin importar la ubicación física de las celdas en la
memoria.
Existen dos tipos de memorias RAM: Las RAM estáticas o SRAM y las RAM dinámicas o
DRAM. En una RAM estática (SRAM) el valor almacenado en una celda se mantiene
mediante un par de inversores y, mientras se suministre electricidad, el valor puede
mantenerse indefinidamente. En una RAM dinámica (DRAM), el valor almacenado en una
celda se mantiene como una carga en un condensador. Para acceder a la carga almacenada
se usa sólo un transistor, tanto para leer el valor como para sobrescribirlo. Debido a que las
DRAMs sólo usan un transistor por bit de almacenamiento, son mucho más densas y el
precio por bit es menor. En comparación, las SRAMs requieren entre cuatro y seis
transistores por bit. En las DRAMs la carga se almacena en un condensador, por lo tanto no
puede mantenerse indefinidamente y debe refrescarse periódicamente.
Características de la memoria principal (RAM)
Un sistema de memoria se puede clasificar en función de muy diversas características.
Entre ellas podemos destacar las siguientes: localización de la memoria, capacidad, método
de acceso y velocidad de acceso. En el caso de la memoria RAM (también denominada
memoria principal o primaria) se puede realizar la siguiente clasificación:
Localización: Interna (se encuentra en la placa base)
12
Capacidad: Hoy en día no es raro encontrar ordenadores PC equipados con 64, 128
ó 256 Mb de memoria RAM.
Método de acceso: La RAM es una memoria de acceso aleatorio. Esto significa que
una palabra o byte se puede encontrar de forma directa, sin tener en cuenta los bytes
almacenados antes o después de dicha palabra (al contrario que las memorias en
cinta, que requieren de un acceso secuencial). Además, la RAM permite el acceso
para lectura y escritura de información.
Velocidad de acceso: Actualmente se pueden encontrar sistemas de memoria RAM
capaces de realizar transferencias a frecuencias del orden de los Gbps (gigabits por
segundo).
También es importante anotar que la RAM es una memoria volátil, es decir, requiere de
alimentación eléctrica para mantener la información. En otras palabras, la RAM pierde toda
la información al desconectar el ordenador. En la actualidad hemos de disponer de la mayor
cantidad posible de ésta, ya que estamos supeditados al funcionamiento más rápido o más
lento de nuestras aplicaciones diarias. La memoria RAM hace unos años era muy cara, pero
hoy en día su precio ha bajado considerablemente.
1.4 El concepto de interrupciones
Una interrupción no es más que un evento que genera la ruptura de la ejecución de un
programa para pasar a ejecutar otro relacionado con el evento causante de la interrupción.
La interrupción, desde el punto de vista del mecanismo que la activa, puede ser de tipo:
Hardware
Software
Las interrupciones de hardware, están asociadas generalmente a un dispositivo físico (reloj
del sistema, periférico) y consisten en la activación de una línea para dar a conocer a la
UCP la Aparición del evento asociado.
Las interrupciones de software consisten en instrucciones cuyo efecto es la ejecución de
una rutina de servicio de interrupción (se suelen usar para llamadas al sistema operativo
porque aíslan software de usuario y de sistema).
13
Tabla de servicio de interrupción
Cuando la computadora se enciende, el BIOS y el DOS establecen una tabla de servicios
de interrupción en las localidades de memoria 000H-3FFH. La tabla permite el uso de 256
(100H) interrupciones, cada una con un desplazamiento: segmento relativo de cuatro bytes
en la forma IP:CS.
El operando de una instrucción de interrupción como INT 05H identifica el tipo de
solicitud. Como existen 256 entradas, cada una de cuatro bytes, la tabla ocupa los primeros
1, 024 bytes de memoria, desde 000H hasta 3FFH. Cada dirección en la tabla relaciona a
una ruina de BIOS o del DOS para un tipo específico de interrupción. Por lo tanto los bytes
0-3 contienen la dirección para la interrupción 0, los bytes 4-7 para la interrupción 1, y así
sucesivamente:
Eventos de una interrupción
Una interrupción guarda en la pila el contenido del registro de banderas, el CS, y el IP. Por
ejemplo, la dirección en la tabla de INT 05H (que imprime la que se encuentra en la
pantalla cuando el usuario presiona Ctrl + PrtSC) es 0014H (05H x 4 = 14H). La operación
extrae la dirección de cuatro bytes de la posición 0014H y almacena dos bytes en el IP y
dos en el CS.
La dirección CS: IP entonces apunta al inicio de la rutina en el área del BIOS, que ahora se
ejecuta. La interrupción regresa vía una instrucción IRET (regreso de interrupción), que
saca de la pila el IP, CS y las banderas y regresa el control a la instrucción que sigue al
INT.
Tipos de interrupciones
Las interrupciones se dividen en dos tipos las cuales son: Externas y Internas. Una
interrupción externa es provocada por un dispositivo externo al procesador. Las dos líneas
14
que pueden señalar interrupciones externas son la línea de interrupción no enmascarable
(NMI) y la línea de petición de interrupción (INTR).
La línea NMI reporta la memoria y errores de paridad de E/S. El procesador siempre actúa
sobre esta interrupción, aun si emite un CLI para limpiar la bandera de interrupción en un
intento por deshabilitar las interrupciones externas. La línea INTR reporta las peticiones
desde los dispositivos externos, en realidad, las interrupciones 05H a la 0FH, para
cronometro, el teclado, los puertos seriales, el disco duro, las unidades de disco flexibles y
los puertos paralelos.
Una interrupción interna ocurre como resultado de la ejecución de una instrucción INT o
una operación de división que cause desbordamiento, ejecución en modo de un paso o una
petición para una interrupción externa, tal como E/S de disco. Los programas por lo común
utilizan interrupciones internas, que no son enmascarables, para accesar los procedimientos
del BIOS y del DOS.
Interrupción de BIOS
El BIOS contiene un extenso conjunto de rutinas de entrada/salida y tablas que indican el
estado de los dispositivos del sistema. El dos y los programas usuarios pueden solicitar
rutinas del BIOS para la comunicación con los dispositivos conectados al sistema. El
método para realizar la interfaz con el BIOS es el de las interrupciones de software. A
continuación se listan algunas interrupciones del BIOS.
INT 00H: División entre cero. Llamada por un intento de dividir entre cero. Muestra un
mensaje y por lo regular se cae el sistema.
INT 01H: Un solo paso. Usado por DEBUG y otros depuradores para permitir avanzar por
paso a través de la ejecución de un programa.
INT 02H: Interrupción no enmascarare. Usada para condiciones graves de hardware, tal
como errores de paridad, que siempre están habilitados. Por lo tanto un programa que emite
una instrucción CLI (limpiar interrupciones) no afecta estas condiciones.
INT 03H: Punto de ruptura. Usado por depuración de programas para detener la ejecución.
15
INT 04H: Desbordamiento. Puede ser causado por una operación aritmética, aunque por lo
regular no realiza acción alguna.
INT 05H: Imprime pantalla. Hace que el contenido de la pantalla se imprima. Emita la INT
05H para activar la interrupción internamente, y presione las teclas Cltr + PrtSC para
activarla externamente. La operación permite interrupciones y guarda la posición del
cursor.
INT 08H: Sistema del cronometro. Una interrupción de hardware que actualiza la hora del
sistema y (si es necesario) la fecha. Un chip temporizador programable genera una
interrupción cada 54.9254 milisegundos, casi 18.2 veces por segundo.
INT 09H: Interrupción del teclado. Provocada por presionar o soltar una tecla en el teclado.
INT OBH, INT OCH: Control de dispositivo serial. Controla los puertos COM1 y COM2,
respectivamente.
INT 0DH, INT OFH: Control de dispositivo paralelo. Controla los puertos LPT1 y LPT2,
respectivamente.
INT 0EH: Control de disco flexible. Señala actividad de disco flexible, como la
terminación de una operación de E/S.
INT 10H: Despliegue en vídeo. Acepta el número de funciones en el AH para el modo de
pantalla, colocación del cursor, recorrido y despliegue.
INT 11H: Determinación del equipo. Determina los dispositivos opcionales en el sistema y
regresa el valor en la localidad 40:10H del BIOS al AX. (A la hora de encender el equipo,
el sistema ejecuta esta operación y almacena el AX en la localidad 40:10H).
INT 12H: Determinación del tamaño de la memoria. En el AX, regresa el tamaño de la
memoria de la tarjeta del sistema, en términos de kilobytes contiguos.
INT 13H: Entrada/salida de disco. Acepta varias funciones en el AH para el estado del
disco, sectores leídos, sectores escritos, verificación, formato y obtener diagnóstico.
Interrupción del DOS
16
Los dos módulos del DOS, IO.SYS y MSDOS.SYS, facilitan el uso del BIOS. Ya que
proporcionan muchas de las pruebas adicionales necesarias, las operaciones del DOS por lo
general son más fáciles de usar que sus contrapartes del BIOS y por lo común son
independientes de la maquina.
IO.SYS es una interfaz de nivel bajo con el BIOS que facilita la lectura de datos desde la
memoria hacia dispositivos externos.
MSDOS.SYS contiene un administrador de archivos y proporciona varios servicios. Por
ejemplo, cuando un programa usuario solicita la INT 21H, la operación envía información
al MSDOS.SYS por medio del contenido de los registros. Para completar la petición,
MSDOS.SYS puede traducir la información a una o más llamadas a IO.SYS, el cual a su
vez llama al BIOS. Las siguientes son las relaciones implícitas:
Interrupciones del DOS
Las interrupciones desde la 20H hasta la 3FH están reservadas para operaciones del DOS.
A continuación se mencionan algunas de ellas.
INT 20H: Termina programa. Finaliza la ejecución de un programa .COM, restaura las
direcciones para Cltr + Break y errores críticos, limpia los búfer de registros y regresa el
control al DOS. Esta función por lo regular seria colocada en el procedimiento principal y
al salir de el, CS contendría la dirección del PSP. La terminación preferida es por medio de
la función 4CH de la INT 21H.
INT 21H: Petición de función al DOS. La principal operación del DOS necesita una
función en el AH.
INT 22H: Dirección de terminación. Copia la dirección de esta interrupción en el PSP del
programa (en el desplazamiento 0AH) cuando el DOS carga un programa para ejecución. A
17
la terminación del programa, el DOS transfiere el control a la dirección de la interrupción.
Sus programas no deben de emitir esta interrupción.
INT 23H: Dirección de Cltr + Break. Diseñada para transferir el control a una rutina del
DOS (por medio del PSP desplazamiento 0EH) cuando usted presiona Ctlt + Break o Ctlr +
c. La rutina finaliza la ejecución de un programa o de un archivo de procesamiento por
lotes. Sus programas no deben de emitir esta interrupción.
INT 24H: Manejador de error crítico. Usada por el dos para transferir el control (por medio
del PSP desplazamiento 12H) cuando reconoce un error critico (a veces una operación de
disco o de la impresora).Sus programas no deben de emitir esta interrupción.
INT 25H: Lectura absoluta de disco. Lee el contenido de uno o más sectores de disco.
INT 26H: Escritura absoluta de disco. Escribe información desde la memoria a uno o más
sectores de disco.
INT 27H: Termina pero permanece residente (reside en memoria). Hace que un programa
.COM al salir permanezca residente en memoria.
INT 2FH: Interrupción de multiplexion. Implica la comunicación entre programas, como la
comunicación del estado de un spooler de la impresora, la presencia de un controlador de
dispositivo o un comando del DOS tal como ASSIGN o APPEND.
INT 33H: Manejador del ratón. Proporciona servicios para el manejo del ratón.
1.5 Llamadas a servicios del sistema
La interfaz entre el sistema operativo y los programas de usuarios está definida por el
conjunto de llamadas al sistema ofrecidas por el sistema operativo. Las llamadas al sistema
con que cuenta la interfaz varían de un sistema operativo a otro. Puesto que el mecanismo
real para emitir una llamada al sistema depende mucho de la máquina y muchas veces debe
de expresarse en código ensamblador, se proporciona una biblioteca de procedimientos que
permite hacer llamadas al sistema desde programas en C y también desde otros lenguajes.
En cierto sentido, efectuar una llamada al sistema es como efectuar una llamada a un
18
procedimiento especial, solo que las llamadas al sistema entran al kernel y las llamadas a
procedimientos no.
Se trata de que una aplicación ejecute una rutina del sistema operativo, con objeto de que la
rutina le preste un servicio. Por ejemplo, cuando un programa desea abrir un fichero de
disco, llama a un servicio del sistema que le permite llevar a cabo ésta tarea. Debe tenerse
en cuenta que una aplicación no puede acceder directamente al disco, y debe hacerlo a
través del sistema operativo.
Hay dos tipos de instrucciones relacionados con la llamada a servicios del sistema
operativo:
Syscall. Instrucción de llamada a un servicio del sistema operativo, a través de su
API. Cuando una tarea ejecuta esta instrucción pasa el control al sistema operativo.
Sysret. Instrucción de retorno de un servicio. El sistema operativo ejecuta esta
instrucción justo antes de devolver el control a la tarea que solicitó el servicio. Entre
la ejecución de las instrucciones Syscall y Sysret, el sistema operativo accede al
espacio de memoria de la tarea. Por ejemplo, el sistema operativo escribe en una
estructura de datos de la tarea asociada a un fichero si la apertura del _chero se ha
completado con éxito o no. Después de ejecutar la instrucción Sysret, se ejecuta la
instrucción siguiente a la Syscall.
1.6 Modos de direccionamiento
El campo de operación de una instrucción especifica la operación que se va a ejecutar. Esta
operación debe realizarse sobre algunos datos almacenados en registros de computadora o
en palabras de memoria. La manera en que eligen los operandos durante la ejecución del
programa depende del modo de direccionamiento de la instrucción. El modo de
direccionamiento especifica una regla para interpretar o modificar el campo de dirección de
la instrucción antes de que se haga la referencia real al operando. Las computadoras utilizan
técnicas de modo de direccionamiento para acomodar una o las dos siguientes
consideraciones:
19
Proporcionar al usuario versatilidad de programación al ofrecer facilidades como
apuntadores a memoria, contadores para control de ciclo, indexación de datos y
reubicación de datos.
Reducir la cantidad de bits en el campo de direccionamiento de la instrucción.
La disponibilidad de los modos de direccionamiento proporciona al programador con
experiencia en lenguaje ensamblador la flexibilidad para escribir programas más eficientes
en relación con la cantidad de instrucciones y el tiempo de ejecución.
Para comprender los diferentes modos de direccionamiento que se presentaran en esta
sección, es imperativo entender el ciclo de operación básico de la computadora. La unidad
de control de una computadora está diseñada para recorrer un ciclo de instrucciones que se
divide en tres fases principales:
Búsqueda de la instrucción de la memoria.
Decodificar la instrucción.
Ejecutar la instrucción.
Hay un registro en la computadora llamado contador de programa o PC, que lleva un
registro de las instrucciones del programa almacenado en la memoria. Pc contiene la
dirección de la siguiente instrucción que se va a ejecutar y se incrementa cada vez que se
recupera una instrucción de la memoria. La decodificación realizada en el paso 2 determina
la operación que se va a ejecutar, el modo de direccionamiento de la instrucción y la
posición de los operandos.
Después la computadora ejecuta la instrucción y regresa al paso 1 para hacer la búsqueda
de la siguiente instrucción en secuencia.
En algunas computadoras el modo de direccionamiento de la instrucción se especifica con
un código binario distinto, como se hace con el código de operación. Otras computadoras
utilizan un código binario único que representa la operación y el modo de la instrucción.
Pueden definirse instrucciones con diversos modos de direccionamiento y, en ocasiones, se
combinan dos o más modos de direccionamiento en una instrucción.
20
Aunque la mayoría de los modos de direccionamiento modifican el campo de dirección de
la instrucción, hay dos modos que no necesitan el campo de dirección. Son los modos
implícito e inmediato.
Modo implícito
En este modo se especifican los operandos en forma implícita en la definición de la
instrucción. Por ejemplo, la instrucción "complementar acumulador" es una instrucción de
modo implícito porque el operando en el registro de acumulador está implícito en la
definición de la instrucción. De hecho todas las instrucciones de referencia a registro que
utilizan un acumulador son instrucciones de modo implícito.
Las instrucciones de dirección cero en una computadora organizada con pila son
instrucciones de modo implícito porque está implícito que los operandos están en la parte
superior de la pila.
Modo inmediato
En este modo se especifica el operando en la instrucción misma. En otras palabras, una
instrucción de modo inmediato tiene un campo operando, en lugar de una campo de
dirección. Un campo de operando contiene el operando real que se va a usar junto con la
operación especificada en la instrucción. Las instrucciones de modo inmediato son útiles
para inicializar registros en un valor constante.
Se mencionó antes que el campo de dirección de una instrucción puede especificar una
palabra de memoria o un registro de procesador. Cuando el campo de dirección especifica
un registro de procesador se dice que la instrucción está en modo de registro.
Modo de registro
En este modo, los operandos están en registros que residen dentro de la CPU. Se selecciona
el registro particular de un campo de registro en la instrucción. Un campo k bits puede
especificar cualquiera de 2 a la k registros.
Modo indirecto por registro
21
En este modo la instrucción especifica un registro en la CPU cuyo contenido proporciona la
dirección del operando en la memoria. En otras palabras, el registro seleccionado contiene
la dirección del operando en lugar del operando mismo. Antes de utilizar una instrucción de
modo indirecto por registro, el programador debe asegurarse de que la dirección de
memoria del operando está colocada en el registro del procesador con una instrucción
previa. Entonces una referencia al registro es equivalente a especificar una dirección de
memoria. La ventaja de una instrucción de modo de registro indirecto es que el campo de
dirección de la instrucción utiliza menos bits para seleccionar un registro de los que
necesitaría para especificar una dirección de memoria en forma directa.
Modo de direccionamiento directo
En este modo la dirección efectiva es igual a la parte de dirección de la instrucción. El
operando reside en memoria y su dirección la proporciona en forma directa el campo de
dirección de la instrucción. En una instrucción de tipo brinco el campo de dirección
especifica la dirección de transferencia de control del programa real.
Modo de direccionamiento indirecto
En este modo, el campo de dirección de la instrucción proporciona la dirección en que se
almacena la dirección efectiva en la memoria. El control recupera la instrucción de la
memoria y utiliza su parte de dirección para accesar la memoria una vez más con el fin de
leer la dirección efectiva.
Unos cuantos modos de direccionamiento requieren que el campo de dirección de la
instrucción se sume al contenido de un registro específico en la CPU. En estos modos la
dirección efectiva se obtiene del cálculo siguiente:
Dirección efectiva = Parte de la instrucción + El contenido de registro CPU.
EL registro de CPU utilizado en el cálculo puede ser el contador de programa, un registro
de índice o un registro base. En cualquier caso tenemos un modo de direccionamiento
diferente que se utiliza para una aplicación distinta.
Modo de direccionamiento indexado
22
En este modo el contenido de un registro índice se suma a la parte de dirección de la
instrucción para obtener la dirección efectiva. El registro índice es un registro CPU especial
que contiene un valor índice. Un campo de dirección de la instrucción define la dirección
inicial del arreglo de datos en la memoria. Cada operando del arreglo se almacena en la
memoria en relación con la dirección inicial.
La distancia entre la dirección inicial y la dirección del operando es el valor del índice
almacenado en el registro de índice. Cualquier operando en el arreglo puede accesarse con
la misma instrucción siempre y cuando el registro índice contenga el valor de índice
correcto. El registro índice puede incrementarse para facilitar el acceso a operandos
consecutivos. Nótese que si una instrucción de tipo índice no incluye un campo de
dirección en su formato, la instrucción se convierte al modo de operación de indirecto por
registro.
Algunas computadoras dedican un registro de CPU para que funcione exclusivamente
como un registro índice. De manera implícita este registro participa cuando se utiliza una
instrucción de modo índice. En las computadoras con muchos registros de procesador,
cualquiera de los registros de la CPU puede contener el número de índice. En tal caso, el
registro debe estar especificado en forma explícita en un campo de registro dentro del
formato de instrucción.
Modo de direccionamiento de registro base
En este modo, el contenido de un registro base se suma a la parte de dirección de la
instrucción para obtener la dirección efectiva. Esto es similar al modo de direccionamiento
indexado, excepto en que el registro se denomina ahora registro base, en lugar de registro
índice. La diferencia entre los dos modos está en la manera en que se usan más que en la
manera en que se calculan. Se considera que un registro base contiene una dirección base y
que el campo de dirección de la instrucción proporciona un desplazamiento en relación con
esta dirección base. El modo de direccionamiento de registro base se utiliza en las
computadoras para facilitar la localización de los programas en memoria.
23
1.7 Proceso de ensamblado y ligado
Para crear un programa ejecutable utilizando lenguaje ensamblador es necesario realizar la
serie de pasos, conocida como ciclo de desarrollo de programas, que se muestra en la
figura.
Figura 1. 1 Proceso para el ciclo de desarrollo de programas
Un ensamblador es el programa que convierte un listado de código fuente, escrito en un
fichero de texto, en código objeto, es decir, lenguaje máquina (el que finalmente
interpretará el procesador) en el que sólo le faltan las referencias a rutinas externas.
El código fuente es un fichero que contiene la secuencia de instrucciones en lenguaje
ensamblador que forma el programa, así como ciertas directivas o comandos para el propio
ensamblador, que ha sido creado utilizando un editor de texto.
El código objeto consta del código en lenguaje máquina y de la información necesaria para
enlazarlo con otros módulos objeto.
Proceso de ligado Al construir un programa algunos de sus módulos pueden colocarse en el
mismo módulo fuente y ensamblarse juntos, otros pueden estar en módulos diferentes y ser
ensamblados separadamente. En cualquier caso, los módulos objeto resultantes, algunos de
24
los cuales pueden estar agrupados en librerías, deben ser enlazados para formar el módulo
de carga, antes de que se pueda ejecutar el programa. Además de dar como salida el módulo
de carga, el linker o enlazador imprime un mapa de memoria que indica donde serán
cargados los módulos objeto en la memoria.
Después de crearse el módulo de carga, éste es cargado por el cargador en la memoria del
ordenador y comienza la ejecución.
Figura 1. 2 Proceso de ligado
1.8 Desplegado de mensajes en el monitor
La pantalla es una malla de posiciones direccionables, en cualquiera de las cuales se puede
colocar el cursor. El sistemas proporcionara espacio en la memoria para un are de
despliegue de video, o búfer. El área de despliegue monocromático inicia en la localidad
BISOS B000[0]H y permite utilizar 4K bytes de memoria: 2KB disponibles para caracteres
y 2K para atributos de cada carácter, como video inverso, intermitencia, intensidad y
subrayado.
Figura 1. 3 Funciones predefinidas de la BIOS
25
Figura 1. 4 Función para mostrar el conjunto de caracteres ASCII
26
Unidad 2 Programación básica
2.1 Ensamblador (y ligador) a utilizar
El lenguaje ensamblador, o assembler (assembly language en inglés), es un lenguaje de
programación de bajo nivel para los computadores, microprocesadores, microcontroladores
y otros circuitos integrados programables. Implementa una representación simbólica de los
códigos de máquina binarios y otras constantes necesarias para programar una arquitectura
dada de CPU y constituye la representación más directa del código máquina específico para
cada arquitectura legible por un programador.
Un ensamblador es el programa que convierte un listado de código fuente, escrito en un
fichero de texto, en código objeto, es decir, lenguaje máquina (el que finalmente
interpretará el procesador) en el que sólo le faltan las referencias a rutinas externas. El
código fuente es un fichero que contiene la secuencia de instrucciones en lenguaje
ensamblador que forma el programa, así como ciertas directivas o comandos para el propio
ensamblador, que ha sido creado utilizando un editor de texto. El código objeto consta del
código en lenguaje máquina y de la información necesaria para enlazarlo con otros módulos
objeto. Con TASM el proceso de ensamblado se realiza escribiendo lo siguiente en la
ventana de comandos:
tasm /zi /l nombre donde nombre es el nombre del fichero .asm con el código fuente. La
extensión no es necesaria ponerla y los parámetros /zi y /l sólo son útiles si queremos hacer
un proceso de depuración (debug) con el Turbo Debugger. Tras la ejecución de esta línea se
nos creará un fichero “nombre.obj”.
Linkado y montado
Al construir un programa algunos de sus módulos pueden colocarse en el mismo módulo
fuente y ensamblarse juntos, otros pueden estar en módulos diferentes y ser ensamblados
separadamente. En cualquier caso, los módulos objeto resultantes, algunos de los cuales
pueden estar agrupados en librerías, deben ser enlazados para formar el módulo de carga,
antes de que se pueda ejecutar el programa. Además de dar como salida el módulo de carga,
el linker o enlazador imprime un mapa de memoria que indica donde serán cargados los
módulos objeto en la memoria.
27
Después de crearse el módulo de carga, éste es cargado por el cargador en la memoria del
ordenador y comienza la ejecución. Para linkar con TASM escribimos:
tlink /v nombre Tras esto se nos creará el fichero ejecutable (.exe o .com) que el sistema
operativo se encargará de cargar en memoria
Cuando lo ejecutemos. De nuevo, la extensión no es necesaria ponerla y el parámetro /v
sólo es útil para el Turbo Debugger.
Figura 2. 1 Proceso de Linkado
2.2 Ciclos numéricos
El lenguaje ensamblador cuenta con una instrucción muy poderosa que permite la
programación de ciclos finitos, la instrucción LOOP. Esta instrucción trabaja en forma
conjunta con el registro contador CX. El formato general de esta instrucción es:
Mov CX, Numero_Veces
Etiqueta:
Instrucciones a realizar
Loop Etiqueta
La instrucción Loop ejecuta las instrucciones que se encuentran entre la Etiqueta: y Loop
Etiqueta el número de veces que indique el campo No_Veces.
Por ejemplo, el siguiente grupo de instrucciones incrementa en 1 el registro
AX, esto lo repite 100 veces.
28
Mov CX,100 ;100 veces
repetir: Nombre de la etiqueta
Inc AX ;AX = AX + 1
Loop repetir Regresa a la etiqueta y compara el ciclo
La instrucción Loop decrementa el registro CX en cada iteración y se detiene cuando CX es
igual a cero.
Un bucle es un grupo de instrucciones que se ejecutan cíclicamente un número concreto de
veces. Para construir bucles disponemos de las siguientes instrucciones:
Éstas posibilitan el grupo de control más elemental de nuestros programas. Un bucle es un
bloque de código que se ejecuta varias veces. Hay 4 tipos de bucles básicos: o Bucles sin
fin o Bucles por conteo, Bucles hasta o Bucles mientras. Las instrucciones de control de
bucles son las siguientes:
• INC incrementar.
• DEC decrementar.
• LOOP realizar un bucle.
• LOOPZ, LOOPE realizar un bucle si es cero.
• LOOPNZ,LOOPNE realizar un bucle si no es cero
• JCXZ salta si CX es cero
2.3 Captura de cadenas
En el lenguaje ensamblador el tipo de dato cadena (string) no está definido, pero para fines
de programación, una cadena es definida como un conjunto de localidades de memoria
consecutivas que se reservan bajo el nombre de una variable.
Instrucciones para el manejo de strings
Instrucciones para el manejo de strings El lenguaje ensamblador cuenta con cinco
instrucciones para el manejo de cadenas:
MOVS: Mueve un byte o palabra desde una localidad de memoria a otra.
29
LODS: Carga desde la memoria un byte en AL o una palabra en AX.
STOS: Almacena el contenido del registro AL o AX en la memoria.
CMPS: Compara localidades de memoria de un byte o palabra.
SCAS: Compara el contenido de AL o AX con el contenido de alguna localidad de
memoria.
Las instrucciones para cadenas trabajan en conjunto con la instrucción CLD, la cual permite
establecer que el sentido en el que las cadenas serán procesadas será de izquierda a derecha.
Otra instrucción importante es el prefijo de repetición REP, el cual permite que una
instrucción para manejo de cadenas pueda ser repetida un número determinado de veces.
Los registros índice juegan un papel importante en el procesamiento de cadenas de datos, el
par de registros CS: SI indican la dirección de la cadena original que será procesada, y el
par ES:DI contienen la dirección donde las cadenas pueden ser almacenadas.
2.4 Comparación y prueba
Existen dos instrucciones especiales en el microprocesador 8086: CMP y TEST. CMP
(Comparar) compara si dos valores son iguales o diferentes. Su funcionamiento es similar
al de la instrucción SUB (restar), sólo que no modifica el operando de destino, solamente
modifica las banderas de signo (SF), de cero (ZF) y de acarreo (CF).
Por ejemplo:
CMP AX, 33 Esta instrucción compara si el valor almacenado en el registro AX es igual
que el valor 33 en decimal.
Por otro lado, la instrucción TEST realiza la operación AND de los operandos
especificados sin que el resultado se almacene en algún registro, modificando únicamente
ciertas banderas. Su aplicación más común es la de probar si algún bit es cero.
Por ejemplo:
Test AL, 1 Esta instrucción prueba si el bit menos significativo de AL es 1 y
30
Test AL, 128 prueba si el bit más significativo de AL es 1.
Por lo general estas instrucciones van seguidas de alguna de las instrucciones de salto.
2.5 Saltos
En lenguaje ensamblador existen diferentes tipos de saltos que nos ayudan a saltar a una
línea especificada de código. A continuación se muestran los diferentes tipos de saltos:
• JMP salta
• JE, JZ salta si es igual a cero
• JNE, JNZ salta si no igual a cero
• JS salta si signo negativo
• JNS salta si signo no negativo
• JP, JPE salta si paridad par
• JNP, JOP salta si paridad impar
• JO salta si hay capacidad excedida
• JNO salta si no hay capacidad excedida
• JB, JNAE salta si por abajo (no encima o igual)
• JNB, JAE salta si no está por abajo (encima o igual)
• JBE, JNA salta si por abajo o igual (no encima)
• JNBE, JA salta si no por abajo o igual (encima)
• JL, JNGE salta si menor que (no mayor o igual)
• JNL, JGE salta si no menor que (mayor o igual)
• JLE, JNG salta si menor que o igual (no mayor)
• JNLE, JG salta si no menor que o igual (mayor)
JMP (Salto)
Sintaxis: JMP dirección o JMP SHORT dirección
Transfiere el control incondicionalmente a la dirección indicada en el operando. La
bifurcación puede ser también directa o indirecta como anteriormente vimos, pero además
puede ser corta (tipo SHORT) con un desplazamiento comprendido entre-128 y 127; o
larga, con un desplazamiento de dos bytes con signo. Si se hace un JMP SHORT y no llega
31
el salto (porque está demasiado alejada esa etiqueta) el ensamblador dará error. Los buenos
ensambladores (como TASM) cuando dan dos pasadas colocan allí donde es posible un
salto corto, para economizar memoria, sin que el programador tenga que ocuparse de poner
short. Si el salto de dos bytes, que permite desplazamientos de 64 Kb en la memoria sigue
siendo insuficiente, se puede indicar con far que es largo (salto a otro segmento).
Ejemplos:
JMP ETIQUETA
JMP FAR PTR ETIQUETA
2.6 Ciclos condicionales
Existen dos tipos de instrucciones de salto: las instrucciones de salto condicional y las de
salto incondicional. Las instrucciones de salto condicional, revisan si ha ocurrido alguna
situación para poder transferir el control del programa a otra sección, por ejemplo:
CMP AX, 0 JEotro
:::::::::::
otro:
::::::::::
End
En este ejemplo, la instrucción JE (Salta si es igual) revisa si la prueba implícita en la
instrucción anterior resultó positiva, es decir, si la comparación de AX con 0 fue cierta. En
caso de que AX sea igual a 0, JE transfiere el control del programa a las instrucciones que
se encuentran después de la etiqueta "otro". En caso contrario ejecuta las instrucciones
siguientes a JE.
La siguiente es una lista de las instrucciones de salto condicional y su descripción:
32
JA o JNBE: Salta si está arriba o salta si no está por debajo o si no es igual (jump if above
or jump if not below or equal). El salto se efectúa si la bandera de CF=0 o si la bandera
ZF=0.
JAE o JNB: Salta si está arriba o es igual o salta si no está por debajo (jump if above or
equal or jump if not below). El salto se efectúa si CF=0.
JB o JNAE: Salta si está por debajo o salta si no está por arriba o es igual (jump if below
or jump if not above or equal). El salto se efectúa si CF=1.
JBE o JNA: Salta si está por debajo o es igual o salta si no está por arriba (jump if below
or equal or jump if not above). El salto se efectúa si CF=1 o ZF=1.
JE o JZ: Salta si es igual o salta si es cero (jump if equal or jump if zero). El salto se
efectúa si ZF=1.
JNE o JNZ: Salta si no es igual o salta si no es cero (jump if not equal or jump if not zero).
El salto se efectúa si ZF=0.
JG o JNLE: Salta si es mayor o salta si no es menor o igual (jump if greater or jump if not
less or equal). El salto se efectúa si ZF=0 u OF=SF.
JGE o JNL: Salta si es mayor o igual o salta si no es menor (jump if greater or equal or
jump if not less). El salto se efectúa si SF=OF.
2.7 Incremento y decremento
Las instrucciones INC y DEC permiten incrementar los contenidos de los registros.
Ejemplos:
INC AX ;AX=AX+1
INC VAR1 ;VAR1=VAR1+1
DEC AX ;AX=AX-1
33
DEC VAR1 ;VAR1=VAR1-1 y de las variables almacenadas en memoria.
2.8 Captura de cadenas con formato
Permiten el movimiento, comparación o búsqueda rápida en bloques de datos:
• MOVC transferir carácter de una cadena.
• MOVW transferir palabra de una cadena.
• CMPC comparar carácter de una cadena.
• CMPW comparar palabra de una cadena.
• SCAC buscar carácter de una cadena.
• SCAW buscar palabra de una cadena.
• LODC cargar carácter de una cadena.
• LODW cargar palabra de una cadena.
• STOC guardar carácter de una cadena.
• STOW guardar palabra de una cadena.
• REP repetir.
• CLD poner a 0 el indicador de dirección.
• STD poner a 1 el indicador de dirección.
2.9 Instrucciones aritméticas
Instrucciones Aritméticas. Estas instrucciones son las que realiza directamente el
8086/8088
a. Grupo de adición:
• ADD suma
• ADC suma con acarreo
• AAA ajuste ASCII para la suma
• DAA ajuste decimal para la suma
b. Grupo de sustracción:
• SUB resta
• SBB resta con acarreo negativo
• AAS ajuste ASCII para la resta
34
• DAS ajuste decimal para la resta
c. Grupo de multiplicación:
• MUL multiplicación
• IMUL multiplicación entera
• AAM ajuste ASCII para la multiplicación
d. Grupo de división:
• DIV división
• IDIV división entera
• AAD ajuste ASCII para la división
e. Conversiones:
• CBW pasar octeto a palabra
• CWD pasar palabra a doble palabra
• NEG negación
Ejemplos:
ADD AX,BX ;AX=AX+BX
ADD AX,10 ;AX=AX+10
SUB AX,BX ;AX=AX-BX
SUB AX,10 ;AX=AX-10
En las operaciones de suma y resta el resultado siempre es almacenado en el operando de
destino, el cual puede ser un registro o una variable.
2.10 Manipulación de la pila
La pila es un grupo de localidades de memoria que se reservan con la finalidad de
proporcionar un espacio para el almacenamiento temporal de información. La pila de los
programas es del tipo LIFO (Last In First Out, Último en entrar, Primero en salir).
35
Para controlar la pila el microprocesador cuenta con dos instrucciones básicas:
• Push (Meter)
• Pop (sacar)
El formato de estas instrucciones es el siguiente:
Push operando
Pop operando
Cuando se ejecuta la instrucción Push, el contenido del operando se almacena en la última
posición de la pila.
Por ejemplo:
Si AX se carga previamente con el valor 5, una instrucción Push AX almacenaría el valor 5
en la última posición de la pila.
Por otro lado la instrucción Pop saca el último dato almacenado en la pila y lo coloca en el
operando.
Siguiendo el ejemplo anterior, la instrucción Pop BX obtendría el número 5 y lo
almacenaría en el registro BX.
2.11 Obtención de cadena con representación decimal
En las computadoras el formato natural para la aritmética es el binario. La representación
del número decimal 1; 527 en los tres formatos decimales:
• ASCII 31 35 32 37 (cuatro bytes)
• BCD desempaquetado 01 05 02 07 (cuatro bytes)
• BCD empaquetado 15 27 (dos bytes)
El procesador realiza aritmética en valores ASCII y BCD un dígito a la vez. Ya que los
datos son ingresados desde un teclado significan que están en formato ASCII, la
representación en memoria de un número decimal ingresado tal como 1234 es 31323334H.
36
Pero realizar aritmética sobre tal número implica un tratamiento especial. Las instrucciones
AAA y AAS realizan aritmética de manera directa sobre números ASCCI.
2.12 Instrucciones lógicas
Son operaciones bit a bit que trabajan sobre octetos o palabras completas:
• NOT negación
• AND producto lógico
• OR suma lógica
• XOR suma lógica exclusiva
Las instrucciones que se enlistan antes requieren dos operandos, a excepción de la
operación NOT que sólo requiere uno.
La operación OR establece el resultado a 1 si cualquiera de los dos operandos es 1, de lo
contrario el resultado será 0.
La instrucción XOR coloca en 0 el resultado si los operandos son iguales, de lo contrario
establece 1.
Finalmente, la instrucción NOT cambia de estado todos los bits del operando, los unos por
ceros y los ceros por unos.
La principal aplicación de estas instrucciones es el enmascaramiento de información. La
operación AND nos permite poner a cero cualquier bit de un dato; la operación OR nos
permite poner a uno cualquier bit de un dato y la operación XOR permite borrar el
contenido de algún registro o localidad de memoria, así como para negar algún bit.
2.13 Desplazamiento y rotación
El microprocesador cuenta con un conjunto de instrucciones que permiten la manipulación
de las posiciones individuales de los bits dentro de un registro o localidad de memoria,
estas instrucciones se encuentran divididas en dos grupos: instrucciones de rotación e
instrucciones de desplazamiento (también conocidas como instrucciones para
corrimientos).
37
Las instrucciones para rotación son cuatro y nos permiten mover de forma cíclica los bits
que forman parte de un registro o localidad de memoria, estas instrucciones son ROL,
ROR, RCL, RCR.
ROL y ROR funcionan de forma muy semejante; al ejecutar una instrucción ROL, el bit
más significativo del dato es desplazado hacia la bandera de acarreo y también hacia la
posición del bit memos significativo, por lo cual todos los bits restantes son rotados o
movidos hacia la izquierda. La instrucción ROR funciona igual, sólo que ésta trabaja hacia
la derecha.
Las instrucciones RCL y RCR permiten la rotación de los bits de una localidad de
memoria o registro, considerando también el contenido de la bandera de acarreo. En el caso
de RCL, el bit más significativo pasa hacia la bandera de acarreo, el bit que se encontraba
en la bandera de acarreo pasa al bit menos significativo y finalmente los bits restantes son
rotados hacia la izquierda. La instrucción RCR funciona igual, pero aplica su rotación hacia
la derecha.
2.14 Obtención de una cadena con la representación hexadecimal
Procesos de Control
NOP (Operación nula).
Sintaxis:
NOP
Indicadores:
Realiza una operación nula, es decir, el microprocesador decodifica la instrucción y pasa a
la siguiente. Realmente se trata de la instrucción XCHG AX,AX.
ESC (Salida a un coprocesador).
Sintaxis:
38
ESC código_operación, origen
Indicadores:
Se utiliza en combinación con procesadores externos, tales como los coprocesadores de
coma flotante o de E/S, y abre al dispositivo externo el acceso a las direcciones y operandos
requeridos. Al mnemónico ESC le siguen los códigos de operación apropiados para el
coprocesador así como la instrucción y la dirección del operando necesario.
Ejemplo:
ESC 21,AX
HLT (Parada hasta interrupción o reset).
Sintaxis:
HLT
Indicadores:
El procesador se detiene hasta que se restaura el sistema o se recibe una interrupción. Como
en los PC se producen normalmente 18,2 interrupciones de tipo 8 por segundo (del
temporizador) algunos programadores utilizan HLT para hacer pausas y bucles de retardo.
Sin embargo, el método no es preciso y puede fallar con ciertos controladores de memoria.
LOCK (Bloquea los buses).
Sintaxis:
LOCK
Indicadores:
39
Es una instrucción que se utiliza en aplicaciones de recursos compartidos para asegurar que
no accede simultáneamente a la memoria más de un procesador. Cuando una instrucción va
precedida por LOCK, el procesador bloquea inmediatamente el bus, introduciendo una
señal por la patilla LOCK.
2.15 Captura y almacenamiento de datos numéricos
Modelos de memoria
Los modelos de memoria constituyen las diversas maneras de acceder a la memoria por
parte de los compiladores de C. En el caso del Turbo C se pueden distinguir los siguientes:
TINY: Se emplea en los programas donde es preciso apurar el consumo de memoria hasta
el último byte. Los 4 registros de segmento (CS, DS, ES, SS) están asignados a la misma
dirección, por lo que existe un total de 64 Kb donde se mezclan código, datos y pila. Los
programas de este tipo pueden convertirse a formato COM.
SMALL: Se utiliza en aplicaciones pequeñas. Los segmentos de código y datos son
diferentes y no se solapan. Por ello, hay 64 kb para código y otros 64 Kb a repartir entre
datos y pila.
MEDIUM: Este modelo es ideal para programas largos que no manejan demasiados datos.
Se utilizan punteros largos para el código (que puede extenderse hasta 1 Mb) y cortos para
los datos: la pila y los datos juntos no pueden exceder de 64 Kb.
COMPACT: Al contrario que el anterior, este modelo es el apropiado para los programas
pequeños que emplean muchos datos. Por ello, el programa no puede exceder de 64 Kb
aunque los datos que controla pueden alcanzar el Mb, ya que los punteros de datos son de
tipo far por defecto.
LARGE: Empleado en las aplicaciones grandes y también por los programadores de
sistemas que no tienen paciencia para andar forzando continuamente el tipo de los punteros
(para rebasar el límite de 64 Kb). Tanto los datos como el código pueden alcanzar el Mb,
aunque no se admite que los datos estáticos ocupen más de 64 Kb. Este modo es el que
40
menos problemas da para manejar la memoria, no siendo quizá tan lento y pesado como
indica el fabricante.
HUGE: Similar al anterior, pero con algunas ventajas: por un lado, todos los punteros son
normalizados automáticamente y se admiten datos estáticos de más de 64 Kb. Por otro, y
gracias a esto último, es factible manipular bloques de datos de más de 64 Kb cada uno, ya
que los segmentos de los punteros se actualizan correctamente. Sin embargo, este modelo
es el más costoso en tiempo de ejecución de los programas.
Usando la pila
Una sección de la memoria del programa es reservado para el uso de una pila. La Intel
80386 y procesadores superiores contienen un registro llamado puntero a la pila, esp, el
cual almacena la dirección del tope de la pila, la figura 1 de abajo muestra 3 valores
enteros, 49, 30 y 72, almacenados en la pila(cada entero ocupando 4 bytes) con el registro
esp apuntando a la dirección del tope de la pila.
A diferencia de una pila creciendo hacia arriba, en las máquinas Intel crecen hacia abajo.
En la Figura 2 muestra las capas de la pila después de la ejecución pushl $15.
El puntero de la pila es decrementado de cuatro en cuatro y el número 15 es almacenando
como lugares de 4 bytes, 1988, 1989, 1990 y 1991.
41
La instrucción popl %eax copia el valor del tope de la pila(4 bytes) a eax e incrementa esp
en 4. Qué sucede si no quieres copiar el valor del tope de la pila a un registro?. Puedes
ejecutar la instrucción addl $4, %esp el cual simplemente incrementa el puntero de la pila.
#Listing 3
.globl main
main:
movl $10, %eax
call foo
ret
foo:
addl $5, %eax
ret
En Listing 3, la instrucción call foo pone la dirección de la instrucción después de call en la
llamada al programa sobre la pila y va hacia foo. La subrutina termina con ret, el cual
transfiere el control a la instrucción cuya dirección se toma desde el tope de la pila.
Obviamente el tope de la pila debe contener una dirección válida.
2.16 Operaciones básicas sobre archivos de disco
Entrada y salida
Funciones que realiza
Vamos a señalar las funciones que debe realizar un computador para ejecutar trabajos de
entrada/salida:
Direccionamiento o selección del dispositivo que debe llevar a cabo la operación
de E/S.
42
Transferencia de los datos entre el procesador y el dispositivo (en uno u otro
sentido).
Sincronización y coordinación de las operaciones.
Esta última función es necesaria debido a la deferencia de velocidades entre los dispositivos
y la CPU y a la independencia que debe existir entre los periféricos y la CPU (por ejemplo,
suelen tener relojes diferentes).
Se define una transferencia elemental de información como la transmisión de una sola
unidad de información (normalmente un byte) entre el procesador y el periférico o
viceversa. Para efectuar una transferencia elemental de información son precisas las
siguientes funciones:
Establecimiento de una comunicación física entre el procesador y el periférico
para la transmisión de la unidad de información.
Control de los periféricos, en que se incluyen operaciones como prueba y
modificación del estado del periférico. Para realizar estas funciones la CPU
gestionará las líneas de control necesarias.
Definiremos una operación de E/S como el conjunto de acciones necesarias para la
transferencia de un conjunto de datos (es decir, una transferencia completa de datos). Para
la realización de una operación de E/S se deben efectuar las siguientes funciones:
Recuento de las unidades de información transferidas (normalmente bytes)
para reconocer el fin de operación. - Sincronización de velocidad entre la CPU y
el periférico.
Detección de errores (e incluso corrección) mediante la utilización de los
códigos necesarios (bits de paridad, códigos de redundancia cíclica, etc.)
Almacenamiento temporal de la información. Es más eficiente utilizar un
buffer temporal específico para las operaciones de E/S que utilizan el área de
datos del programa.
Conversión de códigos, conversión serie/paralelo, etc.
Dispositivos externos
43
Una de las funciones básicas del ordenador es comunicarse con los dispositivos exteriores,
es decir, el ordenador debe ser capaz de enviar y recibir datos desde estos dispositivos. Sin
esta función, el ordenador no sería operativo porque sus cálculos no serían visibles desde el
exterior.
Existe una gran variedad de dispositivos que pueden comunicarse con un ordenador, desde
los dispositivos clásicos (terminales, impresoras, discos, cintas, etc.) hasta convertidores
A/D y D/A para aplicaciones de medida y control de procesos, De todos los posibles
periféricos, algunos son de lectura, otros de escritura y otros de lectura y escritura (es
importante resaltar que este hecho siempre se mira desde el punto de vista del proceso). Por
otra parte, existen periféricos de almacenamiento también llamados memorias auxiliares o
masivas.
La mayoría de los periféricos están compuestos por una parte mecánica y otra parte
electrónica. Estas partes suelen separarse claramente para dar una mayor modularidad. A la
componente electrónica del periférico se le suele denominar controlador del dispositivo o,
también, adaptador del dispositivo. Si el dispositivo no tiene parte mecánica (como, por
ejemplo, la pantalla de un terminal), el controlador estará formado por la parte digital del
circuito. Frecuentemente los controladores de los dispositivos están alojados en una placa
de circuito impreso diferenciada del resto del periférico. En este caso es bastante habitual
que un mismo controlador pueda dar servicio a dispositivos de características similares.
El principal problema planteado por los periféricos es su gran variedad que también afecta a
las velocidades de transmisión. Por tanto, el mayor inconveniente que encontramos en los
periféricos es la diferencia entre sus velocidades de transmisión y la diferencia entre éstas y
la velocidad de operación del ordenador.
44
Unidad 3 Modularización
3.1 Procedimientos
Un procedimiento es un conjunto de instrucciones que tienen la finalidad de ejecutar una
tarea específica dentro de un programa. Los procedimientos son muy similares a las
macros.
Un procedimiento es un conjunto de instrucciones a los que podemos dirigir el flujo de
nuestro programa, y una vez terminada la ejecución de dichas instrucciones se devuelve el
control a la siguiente línea a procesar del código que mando llamar al procedimiento. Un
procedimiento se declara una sola vez en el código fuente y cuando el programa se
ensambla y ejecuta, el procedimiento se coloca en memoria para que pueda ser utilizado
por el programa. Los procedimientos nos ayudan a crear programas legibles y fáciles de
modificar. Sintaxis de un procedimiento Existen dos tipos de procedimientos, los
intrasegmentos, que se encuentran en el mismo segmento de instrucciones y los
intersegmentos que pueden ser almacenados en diferentes segmentos de memoria.
Las partes que componen a un procedimiento son:
Declaración del procedimiento
Código del procedimiento
Directiva de regreso
Terminación del procedimiento
Las principales ventajas en el uso de procedimientos son: permiten una codificación más
limpia y compacta, es decir el código fuente es más pequeño; también permiten el ahorro de
memoria, esto es porque un mismo procedimiento puede ser llamado varias veces en el
mismo programa y sólo requiere memoria una vez.
Los procedimientos tienen la desventaja de que reducen la velocidad de ejecución de los
programas, esto se debe a la forma en que los procedimientos se ejecutan. A continuación
se presentan los pasos necesarios para ejecutar un procedimiento:
1. Se encuentra la llamada Call.
45
2. El microprocesador almacena en la Pila el contenido del IP.
3. Se coloca en el IP el valor del desplazamiento correspondiente al Procedimiento.
4. El microprocesador ejecuta las instrucciones del procedimiento.
5. El procedimiento termina cuando se encuentra la instrucción Ret.
6. Se saca de la pila el valor original del IP y se continúa el flujo del programa.
3.2 Macros
Una macro es un grupo de instrucciones repetitivas en un programa que se codifican solo
una vez y pueden utilizarse cuantas veces sea necesario. La principal diferencia entre una
macro y un procedimiento es que en la macro se hace posible el paso de parámetros y en el
procedimiento no (esto es aplicable solo para el TASM, hay otros lenguajes de
programación que si lo permiten). Al momento de ejecutarse la macro cada parámetro es
sustituido por el nombre o valor especificado al momento de llamarla.
Podemos decir entonces que un procedimiento es una extensión de un determinado
programa, mientras que la macro es un módulo con funciones específicas que puede ser
utilizado por diferentes programas. Otra diferencia entre una macro y un procedimiento es
la forma de llamar a cada uno, para llamar a un procedimiento se requiere el uso de una
directiva, en cambio la llamada a las macros se realiza como si se tratara de una instrucción
del ensamblador.
46
Unidad 4 Programación de dispositivos
4.1 El buffer de video en modo texto
Buffer: Es la ubicación de la memoria de un dispositivo digital o una computadora que está
reservada para el almacenamiento temporal de información. Mientras los datos están en el
buffer, aguardan para ser procesados.
Un ejemplo de buffer tiene lugar cuando se intenta ejecutar aplicaciones de audio o video
directamente desde Internet, sin descargarlas a la computadora. Esta práctica, conocida
como streaming, requiere de la utilización de un buffer para reducir el riesgo de que se
corte la reproducción ante problemas en el ancho de banda.
Ejemplo:
Abarcando los aspectos más importantes del modo de video:
ENDP
prepararPantalla proc near
mov ah, 06h;funcion de limpiar pantalla
mov bh, 80h;Atributos de color de fondo
mov al, 00h;cantidad de Filas a Borrar Enrollar
mov cx, 00h;columna inicial en Ch, Columna Inicial en Cl
mov dx, 30a0h;columna Final en Dh,Columna Final en Dl
int 10h
ret
prepararPantalla endp
Para llamarlo debes hacerlo así:
call prepararPantalla
47
En los atributos de color de fondo puedes ver un 80h, el primer número es el color del
fondo ( el 8) y el segundo es el color del texto ( el 0).
4.2 Acceso A Discos En Lenguaje Ensamblador
Para leer o escribir en un disco, no se realiza byte a byte, sino más bien en bloques de bytes,
debido a que el acceso a disco implica movimientos mecánicos además de que el acceso se
da por sectores; en este proceso no intervienen el CPU, puesto que solo envía los comandos
a la interface que maneja la unidad de disco y ésta es la que se encarga de leer o escribir
información de un área especial de memoria, llamada DMA; este proceso es conocido
como acceso directo a memoria.
Ejemplo:
El sistema de almacenamiento en disco constituye el soporte externo de la información. Los
datos se registran sobre la superficie del disco en una serie de circunferencias concéntricas
llamadas pistas (track).
Varias pistas, una por cada cara del disco (generalmente 2), componen un Clúster. Cada
pista está dividida en porciones iguales llamadas sectores (unidad básica de
almacenamiento en disco). El tamaño de un sector se mide en bytes, y depende de las
características del disco. En esta sección se presentan 3 rutinas que permiten lectura y
escritura absoluta de sectores, así como la determinación del espacio libre disponible en un
disco.
Rutina _AbsoluteRead: Transfiere el contenido de uno ó más sectores del disco al buffer
especificado, accesando directamente a los sectores lógicos. En caso de error, se enciende
el bit de acarreo y AX contiene el código del error.
Invocación:
push <unidad de disco>
push <número de sectores a leer>
push <prime
48
r sector a leer>
push SEG <buffer>
push OFFSET <buffer>
call _AbsoluteRead
PUBLIC _AbsoluteRead
_AbsoluteRead PROC NEAR
ARG Buffer:DWORD,Start:WORD,NumSect:WORD,Drive:BYTE= ArgLen
push bp
; salvar BP
mov bp,sp
; permitir acceso a los argumentos
push bx
; salvar registros
push cx
push dx
push ds
mov al,Drive
; lectura absoluta de disco
mov cx,NumSect
mov dx,Start
lds bx,Buffer
49
int 25h
pop bx
pop ds
; recuperar registros
pop dx
pop cx
pop bx
pop bp
ret ArgLen
_AbsoluteRead ENDP
4.3 Programación Del Puerto Serial
Puerto serial, puerto COM, puerto de comunicaciones y puerto RS-232 ("Recomendad
Standard-232"), hacen referencia al mismo puerto. Se le llama serial, porque permite el
envío de datos, uno detrás de otro. El puerto serie nos permite la facilidad de conectar
nuestro ordenador personal a cualquier desarrollo realizado con microcontrolador.
Puerto Serial para la comunicación en puerto serial debemos tomar en cuenta que existe un
dispositivo transmisor y un dispositivo receptor el cual se encuentra comunicado a través de
una sola línea de comunicación, por lo tanto los números binarios que se transmiten se
codifican a través de un tren de pulsos. Dicha codificación de los pulsos deberá ser
interpretado por el dispositivo receptor, para ello se deben establecer parámetros de
hardware por los que se deberá de transmitir la señal. De manera general en MATLAB se
deben realizar 2 procedimientos para configurar y manipular el puerto serial. El primer paso
es la configuración y el segundo es abrir el puerto serial.
50
Características del puerto serial COM
En el ámbito de la electrónica comercial se le denomina como conector DB9 ("D-
subminiature type B, 9 pin"), esto es D-subminiatura tipo B, con 9 pines.
Se utilizaba principalmente para la conexión del ratón (Mouse), algunos tipos
antiguos de escáneres y actualmente para dispositivos como PDA´s ("Personal
Digital Assistant") ó asistentes personales digitales.
Cada puerto, permite conectar solamente 1 dispositivo.
Para conectar y desconectar los dispositivos, así como para que la computadora los
reconozca de manera correcta, es necesario apagar y reiniciar la computadora.
4.4 Programación Del Puerto Paralelo
Conocido también con el nombre de CENTRONICS INTERFACE transmite los datos en
paralelo mediante un bus de 8 líneas más las líneas de control del protocolo y del estado de
la impresora, esto nos permite disponer de varias líneas digitales que podremos controlar
independientemente y de forma inmediata mediante las instrucciones de control de puertos
(por ejemplo: outportb(), inportb() en C++). Esto hace que podamos, de forma muy
sencilla, controlar directamente dispositivos electrónicos como pueden ser Leds,
microreles, pulsadores, etc...
El puerto paralelo tiene dos inconvenientes fundamentales; el primero es que cada vez
menos PC los llevan incorporado y el segundo es que cuando trabajamos con un sistema
operativo Windows XP, NT y 2000, necesitamos un driver que nos permita acceder a los
puertos.
Descripción Física Del Conector.
51
El puerto paralelo del pc dispone de un conector subD de 25 pines hembra al que
normalmente conectamos un cable Centronics de impresora que en un extremo tiene el
conector SubD 25 pines macho y por el otro un conector Centronics de 36 pines. La
asignación de pines, tanto en el conector D-25 como en el Centronics es la siguiente:
4.5 Programación Híbrida
La programación híbrida proporciona un mecanismo por medio del cual podemos
aprovechar las ventajas del lenguaje ensamblador y los lenguajes de alto nivel, todo esto
con el fin escribir programas más rápidos y eficientes.
En esta sección se mostrará la forma para crear programas híbridos utilizando el lenguaje
ensamblador y Turbo Pascal. Turbo Pascal permite escribir procedimientos y funciones en
código ensamblador e incluirlas como parte de los programas en lenguaje Pascal; para esto,
Turbo Pascal cuenta con dos palabras reservadas: Assembler y Asm.
Assembler permite indicarle a Turbo Pascal que la rutina o procedimiento que se está
escribiendo está totalmente escrita en código ensamblador.
Procedimiento híbrido:
52
Procedure Limpia_Pantalla;
Assembler;
AsmMov AX,0600h
Mov BH,18h
Mov CX,0000h
Mov DX,184Fh
Int 10h
End;
El procedimiento del listado 23 utiliza la función 06h de la Int 10h del BIOS para limpiar la
pantalla, este procedimiento es análogo al procedimiento ClrScr de la unidad CRT de Turbo
Pascal.
4.6 Programación De Puerto USB (Universal Serial Bus)
Línea serial universal de transporte de datos. Es un conector rectangular de 4 terminales
que permite la transmisión de datos entre una gran gama de dispositivos externos
(periféricos) con la computadora; por ello es considerado puerto; mientras que la definición
de la Real Academia Española de la lengua es "toma de conexión universal de uso
frecuente en las computadoras".
Características del puerto USB
La versión USB 1.0 Aparece en el mercado, junto con el lanzamiento del
microprocesador Intel® Pentium II en 1997.
Cada puerto, permite conectar hasta 127 dispositivos externos, pero solo se
recomiendan como máximo 8, porque se satura la línea del puerto y se ralentiza el
sistema al tener que administrarse todos simultáneamente.
Cuenta con tecnología "Plug&Play" la cual permite conectar, desconectar y
reconocer dispositivos sin necesidad de reiniciar ó apagar la computadora.
53
Las versiones USB 1.X y USB 2.0 transmiten en un medio unidireccional los datos,
esto es solamente se envía o recibe datos en un sentido a la vez, mientras que la
versión USB 3 cuenta con un medio Duplex que permite enviar y recibir datos de
manera simultánea.
A pesar de que el puerto USB 3, está actualmente integrado ya en algunas placas de
nueva generación, aún no hay dispositivos comerciales/populares para esta
tecnología.
54
Programas Programa que calcula el area de un triangulo.
; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
include \masm32\include\masm32rt.inc
; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
comment * -----------------------------------------------------
Alumno: Carlos Hector Cruz Lopez
Fecha: 25/03/2014
Descripción: Programa que calcula el area de un triangulo.
----------------------------------------------------- *
.data?
value dd ?
base dd ?
altura dd ?
.data
item dd 0
multi dd 0
rdiv dd 0
resultadodiv dd 0
.code
start:
; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
call main
inkey
exit
55
; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
main proc
cls
mov EAX, sval(input("Introduzca la base del triangulo :"))
mov base, EAX
mov EAX, sval(input("introduzca la altura del triangulo :"))
mov altura, EAX
mov EAX, base
mov EBX, altura
mul EBX
mov multi, EAX
mov eax,multi
mov ebx,2
xor edx,edx
div ebx
mov rdiv,edx
mov resultadodiv,eax ; Promedio
print chr$(" ")
print chr$(" ")
print chr$(" El area del triangulo es ====> ")
print str$(resultadodiv)
print chr$(" ")
ret
main endp
56
; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
end start
-----------------------------------------------------------------------------------------------------------------------
Programa 2: Programa que pide 5 números y los suma, resta, multiplica y promedia.
; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
include \masm32\include\masm32rt.inc
; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
comment * -----------------------------------------------------
Alumno: Carlos Hector Cruz Lopez
Fecha: 25/03/2014
Descripcion: Programa que pide 5 numeros y los suma, resta, multiplica y promedia.
----------------------------------------------------- *
.data?
value dd ?
num1 dd ?
num2 dd ?
num3 dd ?
num4 dd ?
num5 dd ?
.data
item dd 0
rsuma1 dd 0
57
rsuma2 dd 0
rsuma3 dd 0
rsuma4 dd 0
resta1 dd 0
resta2 dd 0
resta3 dd 0
resta4 dd 0
multi1 dd 0
rdiv dd 0
resultadodiv dd 0
.code
start
; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
call main
inkey
exit
; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
main proc
cls
mov EAX, sval(input("Introduzca el primer numero :"))
mov num1, EAX
58
mov EAX, sval(input("introduzca el segundo numero :"))
mov num2, EAX
mov EAX, sval(input("introduzca el tercer numero :"))
mov num3, EAX
mov EAX, sval(input("introduzca el cuarto numero :"))
mov num4, EAX
mov EAX, sval(input("introduzca el quinto numero :"))
mov num5, EAX
mov eax, num1
mov ebx, num2
add eax, ebx
mov rsuma1, eax ; suma de primer y segunda calif
mov eax, rsuma1
mov ecx, num3
add eax, ecx
mov rsuma2, eax ; suma de primer , segunda y tercer calif
mov eax, rsuma2
mov ebx, num4
add eax, ebx
mov rsuma3,eax ; suma de primer, segunda, tercer y cuarta
mov eax, rsuma3
mov ebx, num5
59
add eax, ebx
mov rsuma4, eax ; suma de todos los numeros
print chr$(" La suma de los numeros es ====> ")
print str$(rsuma4)
print chr$(" ")
;------------------------------------- DIVISION ------------------------------
mov eax,rsuma4
mov ebx,5
xor edx,edx
div ebx
mov rdiv,edx
mov resultadodiv,eax ; Promedio
print chr$(" ")
print chr$(" El promedio es ====> ")
print str$(resultadodiv)
;--------------------------------------- RESTA ------------------------
mov eax, num1
mov ebx, num2
sub eax, ebx
mov resta1, eax ; resta de primer y segunda calif
mov eax, resta1
60
mov ecx, num3
sub eax, ecx
mov resta2, eax ; resta de primer , segunda y tercer calif
mov eax, resta2
mov ebx, num4
sub eax, ebx
mov resta3,eax ; resta de primer, segunda, tercer y cuarta
mov eax, resta3
mov ebx, num5
sub eax, ebx
mov resta4, eax ; resta de todos los numeros
print chr$(" ")
print chr$(" La resta de los numeros es ====> ")
print str$(resta4)
print chr$(" ")
;--------------------------------------------------------------------------
mov EAX, num1
mov EBX, num2
mul BL
mov EBX, num3
mul BX
61
shl EDX, 16
mov DX, AX
mov ECX, num4
mul CX
mov EDX, num5
mul DX
mov multi1, EAX
print chr$(" ")
print chr$(7,"La multiplicacion es ====> ")
print str$(multi1)
print chr$(" "
ret
main endp
; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
end start
Programa 3: Suma, resta, multiplica y divide dos numeros introducidos ademas de
mostrar un menu de que tipo de operación se quiere realizar con los numeros introducidos.
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
include \masm32\include\masm32rt.inc
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
comment * -----------------------------------------------------
Alumno: Carlos Hector Cruz Lopez
62
Fecha: 25/03/2014
Descripción: Suma, resta, multiplica y divide dos numeros introducidos ademas de
mostrar un menu de que tipo de operación se quiere realizar con los numeros introducidos.
----------------------------------------------------- *
.data?
value dd ?
num1 dd ?
num2 dd ?
.data
item dd 0
suma1 dd 0
resta dd 0
multi dd 0
resultadodiv dd 0
rdiv dd 0
.code
start:
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
63
call main
inkey
exit
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
main proc
cls
mov EBX, sval(input("introduzca el primer numero :"))
mov num1, EBX
mov EBX, sval(input("introduzca el segundo numero :"))
mov num2, EBX
ciclo:
print chr$(" ------------------------------------------- ",10)
print chr$("1 .- SUMAR",10)
print chr$("2 .- RESTAR",10)
print chr$("3 .- MULTIPLICAR",10)
print chr$("4 .- DIVIDIR",10)
print chr$("5 .- SALIR",10)
mov EAX, sval(input("Elija una opcion :"))
64
.if eax == 1
print chr$("SUMAR",10)
mov ebx, num1
mov ecx, num2
add ebx, ecx
mov suma1, ebx ; suma de primer y segundo numero
print chr$(" La suma es ====> ")
print str$(suma1)
print chr$(" ",10)
.elseif eax == 2
print chr$("Restar",10)
mov ebx, num1
mov ecx, num2
sub ebx, ecx
mov resta, ebx ; resta de primer y segundo numero
print chr$(" La resta es ====> ")
65
print str$(resta)
print chr$(" ",10)
.elseif eax == 3
print chr$("Multiplicar",10)
mov EAX, num1
mov EBX, num2
mul BL
mov multi, EAX
print chr$(" La multiplicacion es ====> ")
print str$(multi)
print chr$(" ",10)
.elseif eax == 4
print chr$("DIVIDIR",10)
mov eax,num1
mov ebx,num2
xor edx,edx
div ebx
mov rdiv,edx
mov resultadodiv,eax
66
print chr$(" La division es ====> ")
print str$(resultadodiv)
print chr$(" ",10)
.elseif eax == 5
print chr$("Fin del programa")
print chr$(" ",10)
.endif
cmp eax,4
jle ciclo
ret
main endp
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
end start
Programa 4: programa que lee un numero y forma una piramide numerica.
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
include \masm32\include\masm32rt.inc
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
67
comment * -----------------------------------------------------
Alumno: Carlos Hector Cruz Lopez
Fecha: 25/03/2014
Descripcion: programa que lee un número y forma una piramide numerica.
----------------------------------------------------- *
.data?
value dd ?
numero dd ?
.data
item dd 0
aux dd 0
count dd 0
auxH dd 0
horizontal dd 0
count2 dd 0
.code
start:
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
68
call main
inkey
exit
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
main proc
cls
mov numero,sval(input("ingrese un numero: "))
xor ebx, ebx
mov eax, numero
sub eax, 1
mov numero,eax
ciclo1:
inc ebx
mov auxH, ebx
mov ebx, 0
mov eax, auxH
sub eax, 1
69
mov aux,eax
ciclo2:
inc ebx
mov horizontal, ebx
print str$(horizontal)
cmp ebx, aux
jle ciclo2
print chr$(" ",10)
mov ebx, auxH
cmp ebx, numero
jle ciclo1
ret
main endp
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
end start
Programa 5: Imprime una piramide de numerous.
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
include \masm32\include\masm32rt.inc
70
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
comment * -----------------------------------------------------
Build this console app with
"MAKEIT.BAT" on the PROJECT menu.
----------------------------------------------------- *
.data?
value dd ?
numero dd 0
incrementar dd 0
incrementar2 dd 0
.data
item dd 0
auxiliar dd 0
.code
start:
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
71
call main
inkey
exit
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
main proc
cls
mov EAX,sval(input("Numero : "))
mov numero,EAX
dec numero
mov eax, 0
mov ebx, 0
ciclo:
inc eax
mov incrementar, eax
72
mov ebx, 0
mov auxiliar, eax
dec auxiliar
ciclo2:
inc ebx
mov incrementar2, ebx
print str$(incrementar2)
print chr$(" ")
mov eax, incrementar2
cmp eax, auxiliar
jle ciclo2
print chr$(7,10)
mov eax, incrementar
cmp eax, numero
jle ciclo
ret
main endp
73
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
end start
Programa 5: Lee nombre y calificaciones y determina promedio
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
include \masm32\include\masm32rt.inc
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
comment * -----------------------------------------------------
Build this console app with
"MAKEIT.BAT" on the PROJECT menu.
----------------------------------------------------- *
.data?
value dd ?
nombre dd 0
total dd 0
residuo dd 4
promedio dd 0
.data
item dd 0
.code
74
start:
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
call main
inkey
exit
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
main proc
cls
mov EAX,sval(input("Ingrese su nombre: "))
mov nombre,EAX
mov EAX,sval(input("Ingrese la calificacion en matematicas: "))
add total, eax
mov EAX,sval(input("Ingrese la calificacion en geografia: "))
add total, eax
75
mov EAX,sval(input("Ingrese la calificacion en ingles: "))
add total, eax
mov EAX,sval(input("Ingrese la calificacion en programacion: "))
add total, eax
mov eax,total
mov ebx,4
xor edx,edx
div ebx
mov residuo,edx
mov promedio, eax
print chr$(7,"----------------------------------------- ")
print chr$(7,10)
print chr$(7,10)
.if promedio >= 90 && promedio <= 100
print chr$("El promedio es EXCELENTE")
76
.elseif promedio >= 80 && promedio < 90
print chr$("El promedio es BUENO")
.elseif promedio >= 70 && promedio < 80
print chr$("El promedio es REGULAR")
.elseif promedio >= 0 && promedio < 70
print chr$("El promedio es REPROBADO")
.endif
print chr$(7,10)
print chr$(7,10)
print chr$(7,"Su promedio es: ")
print str$(promedio)
print chr$(7,10)
print chr$(7,10)
ret
main endp
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
77
end start
Programa 6: Sumatoria de numeros pares.
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
include \masm32\include\masm32rt.inc
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
comment * -----------------------------------------------------
Build this console app with
"MAKEIT.BAT" on the PROJECT menu.
----------------------------------------------------- *
.data?
value dd ?
incrementar dd 0
numero dd 0
sumatoria dd 0
.data
item dd 0
.code
78
start:
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
call main
inkey
exit
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
main proc
cls
mov eax, sval(input("Ingrese el numero par: "))
dec eax
mov numero, eax
mov ax, 0
; --------------------------------------------------------------
; 'variable' can be either a a 32 bit memory operand or register
; You can use one (1) or more 'case' statements.
; The 'default' statement if required must be the last statement
79
; before the 'endsw' statement. It can be used only once.
; --------------------------------------------------------------
switch variable
case number
fn MessageBox,hWnd,"test 1","switch block",MB_OK
default
fn MessageBox,hWnd,"default","switch block",MB_OK
endSw
ciclo:
inc eax
inc eax
mov incrementar, eax
mov ecx, sumatoria
mov eax, incrementar
add ecx, eax
mov sumatoria, ecx
mov eax, incrementar
80
cmp eax, numero
jle ciclo
print chr$(10)
print chr$(10)
print chr$("La sumatoria es: ")
print str$(sumatoria)
print chr$(10)
print chr$(10)
ret
main endp
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
end start
Programa 7: Lee un numero e imprime la tabla de multiplicar
386
.model flat, stdcall
option casemap :none
include \masm32\include\masm32rt.inc
81
includelib \masm32\lib\masm32.lib
includelib \masm32\lib\gdi32.lib
includelib \masm32\lib\user32.lib
includelib \masm32\lib\kernel32.lib
.data
incrementar dd 0
numero dd 0
resultado dd 0
.code
start :
mov eax, sval(input("Ingrese el numero: "))
mov numero, eax
mov ax, 0
ciclo:
inc eax
mov incrementar, eax
82
mov eax, numero
mov ebx, incrementar
mul bl
mov resultado, eax
print chr$(10)
print str$(numero)
print chr$(" X ")
print str$(incrementar)
print chr$(" = ")
print str$(resultado)
print chr$(10)
mov eax, incrementar
cmp eax, 9
jle ciclo
inkey
exit
end start
83
Programa 8: Programa que compara 5 numeros e indica el mayor
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
include \masm32\include\masm32rt.inc
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
comment * -----------------------------------------------------
Build this console app with
"MAKEIT.BAT" on the PROJECT menu.
----------------------------------------------------- *
.data?
value dd ?
num1 dd ?
num2 dd ?
num3 dd ?
num4 dd ?
.data
item dd 0
.code
84
start:
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
call main
inkey
exit
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
main proc
cls
; Codigo para ingresar los datos por medio del teclado
mov EAX,sval(input("Ingrese el numero A:"))
mov num1,EAX
mov EAX,sval(input("Ingrese el numero B:"))
mov num2,EAX
mov EAX,sval(input("Ingrese el numero C:"))
85
mov num3,EAX
mov EAX,sval(input("Ingrese el numero D:"))
mov num4,EAX
mov eax,num1
cmp eax,num2
cmp eax,num3
cmp eax,num4
jnb mayor1
mov eax,num2
cmp eax,num1
cmp eax,num3
cmp eax,num4
jnb mayor2
mov eax,num3
cmp eax,num1
86
cmp eax,num2
cmp eax,num4
jnb mayor3
mov eax,num4
cmp eax,num1
cmp eax,num2
cmp eax,num3
jnb mayor4
mayor1:
print chr$(7,"El A es el mayor")
print chr$(10)
ret
mayor2:
print chr$(7,"El B es el mayor")
print chr$(10)
ret
mayor3:
87
print chr$(7,"El C es el mayor")
print chr$(10)
ret
mayor4:
print chr$(7,"El D es el mayor")
print chr$(10)
ret
main endp
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
end start
programa 9: Programa que determina el factorial de un numero
include \masm32\include\masm32rt.inc
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
comment * -----------------------------------------------------
Build this console app with
"MAKEIT.BAT" on the PROJECT menu.
----------------------------------------------------- *
88
.data?
value dd ?
numero dd ?
.data
factorial dd 1
factorial2 dd 1
incrementar dd 0
uno dd 1
original dd 0
.code
start:
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
call main
inkey
exit
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
main proc
89
mov eax, sval(input("Entrada: "))
dec eax
mov numero, eax
mov original, eax
inc original
xor eax, eax ;xor consigo mismo siempre resulta un cero(0)
ciclo:
mov ecx, factorial
inc eax
mov incrementar, eax
mov ebx, uno
mov factorial2, ecx
ciclo2:
inc ebx
add factorial,ecx
cmp ebx, eax
jle ciclo2
mov eax, incrementar
mov ecx, factorial2
mov eax, incrementar
cmp eax, numero
90
jle ciclo ;Salta si es menor o igual o salta si no es mas grande
print chr$(7,"El factorial del numero ")
print str$(original)
print chr$(7," Es: ")
mov ecx, factorial2
print str$(ecx)
print chr$(7,10)
print chr$(7,10)
inkey
exit
ret
main endp
;
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
end start