TECNOLÓGICO NACIONAL DE MÉXICO
INSTITUTO TECNOLÓGICO DE TLÁHUAC
INGENIERIA EN SISTEMAS COMPUTACIONALES
Sistemas Programables
Prof. Rodrigo Manuel Padilla Salas
Unidad 4.
ESTUDIANTE
Hernández Ramírez Ricardo
GRUPO: 7S2
Introducción.
El microcontrolador ejecuta el programa cargado en la memoria Flash. Esto se denomina
el código ejecutable y está compuesto por una serie de ceros y unos, aparentemente sin
significado. Dependiendo de la arquitectura del microcontrolador, el código binario está
compuesto por palabras de 12, 14 o 16 bits de anchura. Cada palabra se interpreta por la
CPU como una instrucción a ser ejecutada durante el funcionamiento del microcontrolador.
Todas las instrucciones que el microcontrolador puede reconocer y ejecutar se les
denominan colectivamente Conjunto de instrucciones. Como es más fácil trabajar con el
sistema de numeración hexadecimal, el código ejecutable se representa con frecuencia
como una serie de los números hexadecimales denominada código Hex. En los
microcontroladores PIC con las palabras de programa de 14 bits de anchura, el conjunto de
instrucciones tiene 35 instrucciones diferentes.
Página | 1
Tabla de contenido
Introducción. ....................................................................... 1
4.1. Modelo de Programación. ......................................... 4
4.2. Estructura de los registros del CPU......................... 6
4.3. Modos de direccionamiento. ..................................... 9
4.4. Conjunto de Instrucciones. ..................................... 12
4.5. Lenguaje Ensamblador. .......................................... 13
4.6. Codificación............................................................... 17
Conclusión. ....................................................................... 20
Referencias ....................................................................... 21
Página | 2
Ilustración 1 Organigramas ................................................... 4
Ilustración 2 Ejemplo de un MSF .......................................... 5
Ilustración 3 Definición ER del CPU ....................................... 6
Ilustración 4 Registro del CPU ............................................... 8
Ilustración 5 Ejemplo de Direccionamiento Implicito ......... 10
Ilustración 6 Direccionamiento Modo Registro .................. 10
Ilustración 7 Direccionamiento Modo Inmediato ............... 11
Ilustración 8 Direccionamiento Modo Directo .................... 11
Ilustración 9 Ejemplo de la estructura CISC. ....................... 12
Ilustración 10 Ejemplo estructura RISC ............................... 13
Ilustración 11 Entorno WinAsm .......................................... 14
Ilustración 12 Entorno Easy Code ....................................... 15
Ilustración 13 Entorno RadASM .......................................... 15
Ilustración 14Entorno Fresh IDE ......................................... 16
Ilustración 15 Código Fuente .............................................. 18
Ilustración 16 Código Objeto .............................................. 18
Ilustración 17 Codigo Ejecutable ........................................ 19
Página | 3
4.1. Modelo de Programación.
En esta parte, nosotros debemos de llevar una formación o un modelado al programar un
microcontrolador, lo cual también debemos de llevar un orden para así poder desarrollar lo
requerido. En esto debemos de tener en cuenta cada apartado.
• Funciones de un programa de control de procesos:
o Adquisición y acondicionamiento de datos
o Control digital directo
o Supervisión del sistema
o Control de secuencias
• Modelos a estudiar
o Organigramas (diagramas de flujo)
o Máquinas de estado finita (Finite State Machine--FSM)
• Organigramas
o Suelen utilizarse en aplicaciones sencillas o en la planificación de rutinas en
las que se divide una aplicación más compleja.
Ilustración 1 Organigramas
Página | 4
Máquina de estado Finita (MSM)
Una Máquina de Estado Finito (Finite State Machine), llamada también Autómata Finito es
una abstracción computacional que describe el comportamiento de un sistema reactivo
mediante un número determinado de Estados y un número determinado de Transiciones
entre dicho Estados.
Ilustración 2 Ejemplo de un MSF
Las Transiciones de un estado a otro se generan en respuesta a eventos de entrada
externos e internos; a su vez estas transiciones y/o subsecuentes estados pueden generar
otros eventos de salida. Esta dependencia de las acciones (respuesta) del sistema a los
eventos de entrada hace que las Máquinas de Estado Finito (MEF) sean una herramienta
adecuada para el diseño de Sistemas Reactivos y la Programación Conducida por Eventos
(Event Driven Programming), cual es el caso de la mayoría de los sistemas embebidos
basados en microcontroladores o microprocesadores.
Las MEF se describen gráficamente mediante los llamados Diagramas de Estado Finito
(DEF), llamados también Diagramas de Transición de Estados.
La forma de como se lleva este tipo de maquina es de la siguiente manera:
• Estados: Son las diferentes situaciones en las que puede encontrarse el sistema.
• Entradas (señales de transición de estados): Constituyen los acontecimientos que
producen los cambios de estado.
• Salidas: Respuesta del sistema ante los cambios en las entradas.
• Funciones de transición de estado: Descripción detallada, para cada estado, de cuál
es el siguiente estado y la salida del sistema, cuando se producen las distintas
entradas.
Página | 5
4.2. Estructura de los registros del CPU
Ilustración 3 Definición ER del CPU
Para poder hacer estas cosas, es obvio que la CPU necesita almacenar algunos datos
temporalmente. Debe recordar la posición de la última instrucción de forma que sepa dónde
ir a buscar la siguiente. Necesita almacenar instrucciones y datos temporalmente mientras
una instrucción está siendo ejecutada. En otras palabras, la CPU necesita una pequeña
memoria interna. En la estructura interna de la CPU se indican los caminos de transferencia
de datos y de control lógico, que incluyen un elemento con el rótulo bus interno de la CPU.
Este elemento es necesario para transferir datos entre los diversos registros y la ALU, ya
que ésta en realidad sólo opera con datos de la memoria interna de la CPU. La figura
muestra también los elementos básicos típicos de la ALU. Dentro de la CPU hay una
memoria interna compuesta por un conjunto de registros. Los registros de la CPU son:
- Registros visibles al usuario: Permiten al programador de lenguaje de máquina o
ensamblador minimizar las referencias a memoria principal optimizando el uso de los
registros.
- Registros de control: Son utilizados por la unidad de control para controlar el
funcionamiento de la CPU y por programas privilegiados del sistema para controlar la
ejecución de programas.
- Registro de estado: Se utiliza para tomar decisiones en función de operaciones realizadas.
- Registro puntero a pila.
Registros visibles al usuario
Página | 6
Un registro visible al usuario es aquél que puede ser referenciado por medio del lenguaje
máquina que ejecuta la CPU. Prácticamente todos los diseños contemporáneos de CPUs
están provistos de varios registros visibles al usuario, en oposición a disponer de un único
acumulador.
Podemos clasificarlos en:
− Uso General
− Datos
− Direcciones
− Códigos de Condición
Los registros de uso general pueden ser asignados por el programador a diversas
funciones. A veces, su uso dentro del repertorio de instrucciones es para contener el
operando para cualquier código de operación. Esto proporciona una utilización de registros
de auténtico uso general. Con frecuencia, sin embargo, existen restricciones. Por ejemplo,
puede haber registros específicos para operaciones en coma flotante. En algunos casos los
registros de uso general pueden ser utilizados para funciones de direccionamiento. En otros
casos hay una separación clara o parcial entre registros de datos y registros de direcciones.
Los registros de datos pueden ser usados únicamente para contener datos y no se pueden
emplear en el cálculo de una dirección de operando. Los registros de dirección pueden ser
en sí registros de uso más o menos general, o pueden estar dedicados a un modo de
direccionamiento particular. El caso más conocido es el puntero a pila. La cantidad de
registros generales o especializados es una cuestión de diseño. No hay solución óptima,
pero la tendencia parece ir hacia el uso de registros especializados. Otro problema de
diseño es el número de registros, de uso general o de datos más direcciones, que tienen
que incluirse.
A mayor cantidad de registros se requieren mayor cantidad de bits en el campo de
operando. Parece óptimo entre 8 y 32 registros. Menos registros se traducen en más
referencias a memoria; más registros no reducen notablemente las referencias a memoria.
Por último, está la cuestión de la longitud de los registros. Los registros que han de contener
direcciones han de ser lo suficientemente grandes como para albergar la dirección más
grande. Los registros de datos deben ser capaces de contener valores de la mayoría de
tipos de datos. Algunas máquinas permiten que los registros contiguos sean usados como
uno para contener valores de doble longitud. Una categoría final de registros, que es al
menos parcialmente visible al usuario, contiene códigos de condición (también llamados
indicadores o flags).
Los códigos de condición son bits fijados por el hardware de la CPU como resultado de
alguna operación. Por ejemplo, una operación aritmética puede producir un resultado
positivo, negativo o nulo, o con desbordamiento. Además de almacenarse el propio
resultado en un registro o en la memoria, se obtiene también un código de condición. El
código puede ser examinado con posterioridad como parte de una condición de bifurcación
condicional. Los bits de códigos de condición se reúnen en uno o más registros. Por lo
general, forman parte de un registro de control. Comúnmente, las instrucciones de máquina
Página | 7
permiten que estos bits sean leídos por referencia implícita, pero no pueden ser alterados
por el programador. En algunas máquinas, una llamada a subrutina dará lugar a la
salvaguarda automática de todos los registros visibles al usuario, que serán restablecidos
en el retorno de la subrutina.
La CPU lleva a cabo la salvaguarda y restablecimiento como parte de la ejecución de las
instrucciones de llamada y retorno, respectivamente. Esto permite a cada subrutina usar
independientemente los registros visibles al usuario. En otras máquinas, es responsabilidad
del programador guardar los contenidos de los registros visibles al programador relevantes
antes de la llamada a subrutina, teniendo que incluir en el programa instrucciones para este
fin.
Ilustración 4 Registro del CPU
Registro de Control.
Hay diversos registros de la CPU que se pueden emplear para controlar su funcionamiento.
La mayoría de éstos, en la mayor parte de las máquinas, no son visibles al usuario. Algunos
de ellos pueden ser visibles a instrucciones de máquina ejecutadas en un modo de control
o de sistema operativo. Naturalmente, máquinas diferentes tendrán diferentes
organizaciones de registros y usará distinta terminología. Se enumera aquí una lista
razonablemente completa de tipos de registros, con una breve descripción. Son esenciales
cuatro registros para la ejecución de una instrucción: el contador de programa, el registro
de dirección, el registro de instrucción y el registro de datos. El contador de programa
contiene una dirección de instrucción. Típicamente, la CPU actualiza el PC después de
cada captación de instrucción de manera que siempre apunta a la siguiente instrucción a
Página | 8
ejecutar. Una instrucción de bifurcación o salto también modificará el contenido de PC. La
instrucción captada se carga en el registro de instrucción, donde son analizados el código
de operación y los campos de operando. Se intercambian datos con la memoria por medio
de registro de direcciones y el de datos. En un sistema con organización de bus, el de
direcciones se conecta directamente al bus de direcciones, y el de datos directamente al
bus de datos. Los registros visibles al usuario, sucesivamente, intercambian datos con el
de datos. Los cuatro registros que acaban de mencionar se usan para la transferencia de
datos entre la CPU y la memoria. Dentro de la CPU, los datos tienen que ofrecerse a la ALU
para su procesamiento. La ALU puede tener acceso directo al de datos y a los registros
visibles al usuario. Como alternativa, puede haber registros intermedios adicionales en el
límite de la ALU; estos registros sirven como registros de entrada y salida de la ALU e
intercambian datos con el de datos y los registros visibles al usuario.
Registro de estado
Todos los diseños de CPUs incluyen un registro o un conjunto de registros, conocidos a
menudo como palabra de estado de programa "programa status word", PSW), que contiene
información de estado. La PSW contiene típicamente códigos de condición además de otra
información de estado. Entre los campos comunes o indicadores se incluyen los expresados
en la tabla.
Bit de Nombre Descripción
estado
C Acarreo Puesto a uno si una operación da lugar a un acarreo (suma)
o adeudo (resta) de un bit de orden superior.
P Paridad Paridad del resultado de una operación aritmética o lógica.
Un 1 indica paridad par y el 0 paridad impar.
Z Cero Puesto a uno cuando el resultado de una operación
aritmética o lógica es cero.
S Signo Contiene el bit de signo del resultado de la última operación
aritmética.
O Desbordamiento Usado para indicar un desbordamiento aritmético.
I Interrupción Usado para habilitar o inhabilitar interrupciones
4.3. Modos de direccionamiento.
Se les llama modos de direccionamiento a las distintas formas de combinar los operandos
según el acceso que se hace a memoria.
Dicho de otra manera, un modo de direccionamiento será una forma de parámetro para las
instrucciones.
Una instrucción que lleve un parámetro, por lo tanto, usará un modo de direccionamiento,
que dependerá de cómo direccionará (accesará) al parámetro; una instrucción de dos
parámetros, combinará dos modos de direccionamiento.
Página | 9
Direccionamiento implícito
Depende solamente de la instrucción, es decir, la instrucción no lleva parámetros.
Particularmente en instrucciones que no accesan memoria, o bien que tienen una forma
específica de accesarla.
Ejemplos: PUSHF, POPF, NOP
Ilustración 5 Ejemplo de Direccionamiento Implicito
Modo registro
Usa solamente registros como operandos
Es el más rápido, pues minimiza los recursos necesarios (toda la información fluye dentro
del EU del CPU)
Ejemplo:
MOV AX, BX
Ilustración 6 Direccionamiento Modo
Registro
Modo inmediato
Tiene dos operandos: un registro y una constante que se usa por su valor.
El valor constante no se tiene que buscar en memoria, pues ya se obtuvo al hacer el “fetch”
de la instrucción.
Ejemplo:
Página | 10
MOV AH, 9
Ilustración 7 Direccionamiento Modo Inmediato
Modo directo
Uno de los operandos involucra una localidad específica de memoria
El valor constante se tiene que buscar en memoria, en la localidad especificada.
Es más lento que los anteriores, pero es el más rápido para ir a memoria, pues ya “sabe” la
localidad, la toma de la instrucción y no la tiene que calcular.
Ejemplo:
MOV AH, [0000]
MOV AH, Variable
Ilustración 8 Direccionamiento Modo Directo
Estas dos instrucciones serían equivalentes, si Variable está, por ejemplo, en la localidad 0
de memoria. En la forma primitiva del lenguaje de máquina, como el primer ejemplo, se
tiene que indicar “mover a AH el contenido (indicado por los corchetes), de la localidad 0 de
los datos (lo de los datos es implícito). El lenguaje Ensamblador, sin embargo, nos permite
la abstracción del uso de variables, pero como una variable tiene una localidad determinada
en memoria, para el procesador funciona igual. La única diferencia consiste en que el
programador no tiene que preocuparse por la dirección, ese manejo lo hace
automáticamente el Ensamblador.
Página | 11
4.4. Conjunto de Instrucciones.
Conjunto o repertorio de instrucciones, este elemento determina lo que puede hacer el procesador.
Define las operaciones básicas que puede realizar el procesador, que conjugadas y organizadas
forman lo que conocemos como software. El conjunto de instrucciones viene siendo como las letras
del alfabeto, el elemento básico del lenguaje, que organizadas adecuadamente permiten escribir
palabras, oraciones y cuanto programa se le ocurra.
Existen dos tipos básicos de repertorios de instrucciones, que determinan la arquitectura del
procesador: CISC y RISC.
CISC.
CISC, del inglés Complex instruction set computing, Computadora de Conjunto de Instrucciones
Complejo. Los microprocesadores CISC tienen un conjunto de instrucciones que se caracteriza por
ser muy amplio y que permiten realizar operaciones complejas entre operandos situados en la
memoria o en los registros internos.
Este tipo de repertorio dificulta el paralelismo entre instrucciones, por lo que en la actualidad, la
mayoría de los sistemas CISC de alto rendimiento convierten las instrucciones complejas en varias
instrucciones simples del tipo RISC, llamadas generalmente microinstrucciones. Dentro de los
microcontroladores CISC podemos encontrar a la popular familia Intel 8051 y la Z80, aunque
actualmente existen versiones CISC-RISC de estos microcontroladores, que pretenden aprovechar
las ventajas de los procesadores RISC a la vez que se mantiene la compatibilidad hacia atrás con las
instrucciones de tipo CISC.
Ilustración 9 Ejemplo de la estructura CISC.
Página | 12
RISC.
RISC, del inglés Reduced Instruction Set Computer, Computadora con Conjunto de Instrucciones
Reducido. Se centra en la obtención de procesadores con las siguientes características
fundamentales:
• Instrucciones de tamaño fijo.
• Pocas instrucciones.
• Sólo las instrucciones de carga y almacenamiento acceden a la memoria de datos.
• Número relativamente elevado de registros de propósito general.
Ilustración 10 Ejemplo estructura RISC
Una de las características más destacables de este tipo de procesadores es que posibilitan el
paralelismo en la ejecución, y reducen los accesos a memoria. Es por eso que los procesadores más
modernos, tradicionalmente basados en arquitecturas CISC, implementan mecanismos de
traducción de instrucciones CISC a RISC, para aprovechar las ventajas de este tipo de procesadores.
4.5. Lenguaje Ensamblador.
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.
Página | 13
Características
• Ensamblador es directamente traducible al Lenguaje de Máquina, y viceversa.
• La computadora no entiende directamente al Lenguaje Ensamblador; es necesario
traducirle a Lenguaje de Máquina.
• Se utilizan traductores que convierten el código fuente (en Lenguaje Ensamblador)
a código objeto.
La programación en lenguaje ensamblador puede resultar un tanto ardua para el
principiante, pero permite desarrollar programas muy eficientes, ya que otorga al
programador el dominio absoluto del sistema. Los fabricantes suelen proporcionar el
programa ensamblador de forma gratuita y en cualquier caso siempre se puede encontrar
una versión gratuita para los microcontroladores más populares.
El Compilador.
La programación en un lenguaje de alto nivel (como C o Basic) permite disminuir el tiempo
de desarrollo de un producto y si además está familiarizado con C o Basic es una buena
opción. No obstante, cuando el compilador convierta el código del programa a un lenguaje
ensamblado, cada línea de código del programa en lenguaje de alto nivel habrá generado
bastantes más líneas de código en lenguaje ensamblador, normalmente en una relación de
uno a tres. Esto significa que para utilizar un lenguaje de alto nivel necesitaremos un
microcontrolador con una capacidad de memoria relativamente grande.
Distintos IDES o compiladores de Ensamblador.
1. WinAsm
WinAsm Studio es un entorno de desarrollo integrado (IDE) gratuito para desarrollar
programas en Windows 32-bit y DOS 16-bit utilizando Microsoft Macro Assembler
MASM y FASM utilizando el Add-In para FASM. Ha sido escrito por Antonis
Kyprianou (akyprian).
Ilustración 11 Entorno WinAsm
Página | 14
2. Easy Code
Easy Code es el entorno visual de programación en ensamblador hecho para
generar aplicaciones de 32 bits para Windows. La interfaz de Easy Code, muy
parecida a la de Visual Basic, le permite programar una aplicación en ensamblador
de manera rápida y fácil como nunca antes había sido posible.
Ilustración 12 Entorno Easy Code
3. RadASM
RadASM es un IDE gratuito para ensambladores de 32 bits para Windows.
Soporta MASM, TASM, FASM, NASM, GoASM y HLA
Ilustración 13 Entorno RadASM
Página | 15
4. Fresh IDE
Es un IDE visual para el lenguaje ensamblador con un compilador integrado Flat
assembler (FASM). Está escrito en Fresh IDE y es una aplicación independiente
compilable. Es totalmente compatible con FASM y puede ser compilado también
con todas las versiones de FASM. El objetivo principal de Fresh IDE es hacer la
programación en ensamblador tan rápido y eficiente como en los lenguajes de alto
nivel, sin sacrificar el tamaño de una pequeña aplicación que potencia el lenguaje
ensamblador. Se trata de una aplicación Windows, pero se ejecuta en Wine muy
bien y puede crear, compilar, depurar y ejecutar aplicaciones para Windows y Linux
en Windows y Linux.
Ilustración 14Entorno Fresh IDE
5. Assembler IDE
Se trata de un entorno de desarrollo para código ensamblador, cuyo propósito es
automatizar al máximo este proceso integrando el editor de código, el depurador
(debugger) y el desensamblador.
Entre las posibilidades que nos ofrece el entorno Assembler IDE, destacan la
depuración de código (debugging), el editor de código, el desensamblador o la
compilación con NASM, TASM/MASM y FASM.
Como puedes comprobar se trata de una herramienta de lo más completa.
Y no dejes que te intimide el hecho de que el programa Assembler IDE esté
únicamente disponible con los textos que aparecen en pantalla en idioma inglés, ya
que sus desarrolladores han diseñado una interfaz de usuario que resulta muy clara,
Página | 16
sencilla e intuitiva, de tal manera que cualquiera que se ponga a los mandos de esta
aplicación la encontrará de lo más accesible.
Y no queremos poner el punto y final a esta reseña sin mencionar el que, sin lugar
a dudas, será uno de los aspectos más interesantes y atractivos del programa: su
inmejorable precio. Y es que, como estamos ante una aplicación que se distribuye
mediante licencia “freeware”, podremos descargar Assembler IDE.
4.6. Codificación.
Durante esta etapa se realizan las tareas que comúnmente se conocen como
programación; que consiste, esencialmente, en llevar a código fuente, en el lenguaje de
programación elegido, todo lo diseñado en la fase anterior. Esta tarea la realiza el
programador, siguiendo por completo los lineamientos impuestos en el diseño y en
consideración siempre a los requisitos funcionales y no funcionales (ERS) especificados en
la primera etapa.
Es común pensar que la etapa de programación o codificación (algunos la llaman
implementación) es la que insume la mayor parte del trabajo de desarrollo del software; sin
embargo, esto puede ser relativo (y generalmente aplicable a sistemas de pequeño porte)
ya que las etapas previas son cruciales, críticas y pueden llevar bastante más tiempo. Se
suele hacer estimaciones de un 30% del tiempo total insumido en la programación, pero
esta cifra no es consistente ya que depende en gran medida de las características del
sistema, su criticidad y el lenguaje de programación elegido.7 En tanto menor es el nivel
del lenguaje mayor será el tiempo de programación requerido, así por ejemplo se tardaría
más tiempo en codificar un algoritmo en lenguaje ensamblador que el mismo programado
en lenguaje C.
Mientras se programa la aplicación, sistema, o software en general, se realizan también
tareas de depuración, esto es la labor de ir liberando al código de los errores factibles de
ser hallados en esta fase (de semántica, sintáctica y lógica). Hay una suerte de
solapamiento con la fase siguiente, ya que para depurar la lógica es necesario realizar
pruebas unitarias, normalmente con datos de prueba; claro es que no todos los errores
serán encontrados sólo en la etapa de programación, habrá otros que se encontrarán
durante las etapas subsiguientes. La aparición de algún error funcional (mala respuesta a
los requisitos) eventualmente puede llevar a retornar a la fase de diseño antes de continuar
la codificación.
Durante la fase de programación, el código puede adoptar varios estados, dependiendo de
la forma de trabajo y del lenguaje elegido, a saber:
• Código fuente: es el escrito directamente por los programadores en editores de
texto, lo cual genera el programa. Contiene el conjunto de instrucciones codificadas
en algún lenguaje de alto nivel. Puede estar distribuido en paquetes,
procedimientos, bibliotecas fuente, etc.
Página | 17
Ilustración 15 Código Fuente
• Código objeto: es el código binario o intermedio resultante de procesar con un
compilador el código fuente. Consiste en una traducción completa y de una sola vez
de este último. El código objeto no es inteligible por el ser humano (normalmente es
formato binario) pero tampoco es directamente ejecutable por la computadora. Se
trata de una representación intermedia entre el código fuente y el código ejecutable,
a los fines de un enlace final con las rutinas de biblioteca y entre procedimientos o
bien para su uso con un pequeño intérprete intermedio [a modo de distintos ejemplos
véase EUPHORIA, (intérprete intermedio), FORTRAN (compilador puro) MSIL
(Microsoft Intermediate Language) (intérprete) y BASIC (intérprete puro, intérprete
intermedio, compilador intermedio o compilador puro, depende de la versión
utilizada)].
Ilustración 16 Código Objeto
El código objeto no existe si el programador trabaja con un lenguaje a modo de intérprete
puro, en este caso el mismo intérprete se encarga de traducir y ejecutar línea por línea el
código fuente (de acuerdo al flujo del programa), en tiempo de ejecución. En este caso
tampoco existe el o los archivos de código ejecutable. Una desventaja de esta modalidad
es que la ejecución del programa o sistema es un poco más lenta que si se hiciera con un
intérprete intermedio, y bastante más lenta que si existe el o los archivos de código
Página | 18
ejecutable. Es decir no favorece el rendimiento en velocidad de ejecución. Pero una gran
ventaja de la modalidad intérprete puro, es que él está forma de trabajo facilita
enormemente la tarea de depuración del código fuente (frente a la alternativa de hacerlo
con un compilador puro). Frecuentemente se suele usar una forma mixta de trabajo (si el
lenguaje de programación elegido lo permite), es decir inicialmente trabajar a modo de
intérprete puro, y una vez depurado el código fuente (liberado de errores) se utiliza un
compilador del mismo lenguaje para obtener el código ejecutable completo, con lo cual se
agiliza la depuración y la velocidad de ejecución se optimiza.
• Código ejecutable: Es el código binario resultado de enlazar uno o más fragmentos
de código objeto con las rutinas y bibliotecas necesarias. Constituye uno o más
archivos binarios con un formato tal que el sistema operativo es capaz de cargarlo
en la memoria RAM (eventualmente también parte en una memoria virtual), y
proceder a su ejecución directa. Por lo anterior se dice que el código ejecutable es
directamente «inteligible por la computadora». El código ejecutable, también
conocido como código máquina, no existe si se programa con modalidad de
«intérprete puro».
Ilustración 17 Codigo Ejecutable
Página | 19
Conclusión.
Por lo que hemos visto en este documento, ahora ya vemos todo lo que lleva en poder
trabajar y realizar el funcionamiento de los microcontroladores y ver como hay entornos de
trabajo, y además llevar ciertos puntos para trabajar en ello y la manera de como lo
podemos trabajar en dispositivos de cómputo.
Página | 20
Referencias
• (Hardware/Software, s.f.)
• (Arcos, 2017)
• (Arquitectura de Computadoras, s.f.)
• (Sistemas Programables, 2017)
• (Wikipedia.org, 2021)
• (RobledoMorales, 2017)
Página | 21
