Temario 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
Í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 1
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
2
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 3
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: 4
... 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.
5
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.
6
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. 7
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.
8
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. 9
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.
10
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) 11
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). 12
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 13
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. 14
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 15
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 16
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
17
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: 18
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.
19
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
20
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 21
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.
22
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 23
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
24
Figura 1. 4 Función para mostrar el conjunto de caracteres ASCII
25
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. 26
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. 27
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. 28
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 29
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 30
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:
31
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
32
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 33
•
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).
34
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.
35
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).
36
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: 37
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: 38
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 39
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.
40
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.
41
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 42
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.
43
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. 44
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.
45
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 46
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
push push
47
r sector a leer> push SEG push OFFSET 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
48
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.
49
Características del puerto serial COM
En el ámbito de la electrónica comercial se le denomina como conector DB9 ("Dsubminiature 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. 50
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: 51
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.
52
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.
53
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
54
; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ 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 55
; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ 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 56
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 57
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 58
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 59
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
60
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 61
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:
; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
62
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 :"))
63
.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 ====> ") 64
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 65
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 ; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ 66
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:
; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
67
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
68
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
69
; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
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:
; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
70
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
71
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
72
; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ 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 73
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
74
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")
75
.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
; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
76
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
numero
dd
0
sumatoria
dd
0
0
.data item dd 0
.code
77
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 78
; 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 79
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
80
includelib \masm32\lib\masm32.lib includelib \masm32\lib\gdi32.lib includelib \masm32\lib\user32.lib includelib \masm32\lib\kernel32.lib
.data incrementar numero resultado
dd dd
dd
0
0
0
.code
start : mov eax, sval(input("Ingrese el numero: ")) mov numero, eax
mov ax, 0
ciclo:
inc eax mov incrementar, eax
81
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
82
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 83
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:")) 84
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 85
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: 86
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. ----------------------------------------------------- *
87
.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 88
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 89
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
90
