ARREGLOS

DEFINICIÓN

Un arreglo puede definirse como un grupo o una colección finita, homogénea y ordenada de elementos. Los arreglos pueden ser de los siguientes tipos:

• De una dimensión.
• De dos dimensiones.
• De tres o más dimensiones.

Pertenece a los datos estaticos

Los arrays se conocen también como matrices – en matemática – y tablas – en cálculos financieros

CARACTERÍSTICAS

Ordenada: significa que el elemento primero, segundo,.., enésimo de un arreglo puede ser identificado.

Homogénea: Todos los elementos del arreglo deben ser del mismo tipo. Por ejemplo, un arreglo puede tener todos sus elementos de tipo entero, o todos sus elementos de tipo char.

Finito: Ya que tiene un número de elementos limitados.

OPERACIONES

Las operaciones en arreglos pueden clasificarse de la siguiente forma:

• Lectura: este proceso consiste en leer un dato de un arreglo y asignar un valor a cada uno de sus componentes.
• Escritura: Consiste en asignarle un valor a cada elemento del arreglo.
• Asignación: No es posible asignar directamente un valor a todo el arreglo.
• Actualización: Dentro de esta operación se encuentran las operaciones de eliminar, insertar y modificar datos. Para realizar este tipo de operaciones se debe tomar en cuenta si el arreglo está o no ordenado.
• Ordenación: Esta operación permite organizar los elementos de un arreglo ascendente o descendente, esto se hace con el propósito de acceder rápidamente a los elementos del arreglo.
• Búsqueda: Permite consultar los elementos de un arreglo de acuerdo a un valor ingresado. Para esto se recorre el arreglo y se va comparando el valor buscado con los elementos del arreglo hasta encontrar o no el valor buscado.

TIPOS

A) Arrays Unidimensionales (vector/fila)

Es un tipo de datos estructurado compuesto de un número determinado de elementos, de tamaño fijo y elementos homogéneos (del mismo tipo).

B) Arrays bidimensionales (tablas/matrices)
 

El array bidimensional se puede considerar como un vector de vectores. Es, por consiguiente, un conjunto de elementos, todos del mismo tipo, en el cual el orden de los componentes es significativo y en el que se necesita especificar dos subíndices para poder identificar cada elemento del array.

Es un tipo de arreglo que tiene dos índices ( Columnas y Filas).

C) Arrays Multidimensionales

Un array puede ser definido de tres dimensiones, cuatro dimensiones, hasta de n-dimensiones. Los conceptos de rango de subíndices y número de elementos se pueden ampliar directamente desde arrays de una y dos dimensiones a estos arrays de orden más alto. En general, un array de n-dimensiones requiere que los valores de los n subíndices puedan ser especificados a fin de identificar un elemento individual del array. Si cada componente de un array tiene a subíndices, el array se dice que es sólo de n-dimensiones.

Es un arreglo que maneja varios indices por lo tanto varias direcciones.

EJEMPLOS

1) Codifique en un programa que lea un vector de 10 números enteros, y evalué cual es el mayor y el menor dedicho vector.

#include <stdio.h>
#define num 10
void main()
{
int numero[NUM];
int mayor,menor,i;
printf("Programa para determinar el mayor y menor numero de
10 numeros dados\n\n");
for(i=0;i<NUM;i++) //Capturamos y asignamos valores con este
ciclo
{
printf("Ingrese el numero %d:",i+1);
scanf("%d",&numero[i]);
}
mayor=numero[0]; //Asignamos a mayor el primer valor del
arreglo "numero".
menor=numero[0]; //Hacemos lo mismo para la variable menor.
for(i=0;i<NUM;i++)
{
if(numero[i]>mayor)
mayor=numero[i];
if(numero[i]<menor)
menor=numero[i];
}
printf("\n\nEl numero Mayor de los introducidos es %d\n",mayor);
printf("El numero Menor de los introducidos es %d\n\n",menor);
}

2)  INICIO

    .MODEL SMALL

    .STACK 64;16

    .DATA

     ARRAY DB 1,2,3,4,5,6,7,8,9,0

    .CODE

     mov ax,@data ;Inicializar los registros.

     mov ds,ax

     mov cx,10

     Ciclo:

     lea dx,ARRAY ; Coloca el array en el DX para quedar listo para ser impreso en pantalla.

    mov ah,09h ;Servicio del video.

    int 21h ;Interrupcion del D.O.S

    LOOP Ciclo ;Se supone decrementa el CX en 1

    RET

    END

RESUMEN

Arreglos: Un arreglo puede definirse como un grupo o una colección finita, homogénea y ordenada de elementos.

Características:

• Finita
• Homogénea
• Ordenada

Operaciones:

• Lectura
• Escritura
• Asignación
• Actualización: Insertar, borrar y modificar.
• Ordenación
• Búsqueda

Tipos:

• Unidimensional
• Bidimensional
• Multidimensional

SUMMARY

Arrays: An array can be defined as a group or a finite, homogeneous and ordered collection of elements.

Characteristics:

• Finita
• Homogeneous
• Ordered

Operations:

• Reading
• Writing
• Assignment
• Update: Insert, delete and modify.
• Ordination
• Search

Types:

• One-dimensional
• Two Dimensional
• Multidimensional

RECOMENDACIONES

Es necesario seguir una frecuencia gráfica de pasos, o procesos para alcanzar la solución del problema. Se recomienda que la construcción del diagrama esté correcta; al igual que el paso del mismo a un lenguaje de programación. Si está correcto puede resultar relativamente simple para el entendimiento de las personas ajenas a la elaboración del mismo, además permite que el problema se solucione de una manera más eficiente y directa.

Se recomienda la implementación de arreglos cuando se hace referencia a un mismo tema y que necesiten almacenarse en un solo paquete de información.

CONCLUSIONES

En la programación tradicional siempre se manejan dos tipos de arreglos los arreglos tipo listas, vectores o unidimensionales y los arreglos tipo tablas, cuadros, concentrados, matrices o bidimensionales en ambos casos son variables que permiten almacenar un conjunto de datos del mismo tipo a la vez, su diferencia es en la cantidad de columnas que cada uno de estos tipos contiene.

Para concluir en pocas palabras, un arreglo es la mejor solución a la hora de agrupar distintos datos que sean de un mismo tipo, estos datos se almacenan en la memoria y reciben un nombre común para todos.

APRECIACIÓN PERSONAL

Para este tema "ARREGLOS" me fue fácil ya que conté con el material adecuado y además me ayudo mucho la Internet, espero que les sea útil y les sirva esta investigación.

GLOSARIO DE TÉRMINOS

Arreglo: colección finita, homogénea y ordenada.
Para: Denota la finalidad.
Mientras: Va recorrer durante el tiempo.
Inconsistencia: Falta de estabilidad y coherencia en una cosa.

BIBLIOGRÁFICA

http://exa.unne.edu.ar/informatica/programacion1/public_html/archivos/estructuras_arreglos.pdf
http://enriquebarrueto0.tripod.com/algoritmos/cap06.pdf
https://www.ecured.cu/Arreglos_%28Inform%C3%A1tica%29
https://wikipnfi.wikispaces.com/file/view/Arreglo+de+Registro.pdf

Video

Descargar el documento en PDF

Diapositiva "Ciclos"

CICLOS

DEFINICIÓN

Los ciclos repetitivos también son llamados lazos o bucles que permiten repetir una operación o secuencia de operaciones en función de ciertas condiciones. Es un segmento de un algoritmo o programa cuyas instrucciones se repiten un número determinado de veces mientras se cumpla una determinada condición.

Son estructuras que están especialmente diseñadas para todas aquellas aplicaciones en las cuales una operación o conjunto de ellas deben repetirse muchas veces.

Fases de un Programa Cíclico:

1. Entrada de datos e instrucciones previas
2. Lazo o bucle
3. Instrucciones finales o resto del proceso
4. Salida de resultado.

Las estructuras de repetición básicas son:

• Estructura Desde/Para
• Estructura Mientras
• Estructura Hacer

Dentro de los ciclos se utilizan contadores y acumuladores, que regulan que el ciclo llegue a su fin.

A) Contador: Es un tipo de variable que incrementa o decrementa su valor en un valor constante Cuando decimos incrementa estamos sumando. 

Ejemplo: Veces = Veces + 1 Como se puede observar a la variable veces se le está incrementando un valor constante (1); es decir a su contenido le sumas el valor y se vuelve a guardar en la misma variable.

B) Acumulador: Es una variable que incrementa o decrementa su contenido en cantidades variables. 

Ejemplo: Nomina = Nomina + sueldo

INSTRUCCIONES REPETITIVAS LOOP

La instrucción loop decrementa CX en 1, y transfiere el flujo del programa a la etiqueta dada como operando si CX es diferente a 1

Propósito: Generar un ciclo en el programa considerando el estado de ZF

INSTRUCCIONES REPETITIVAS LOOPE

Esta instrucción decrementa CX en 1. Si CX es diferente a cero y ZF es igual a 1, entonces el flujo del programa se transfiere a la etiqueta indicada como operando.

Propósito: Generar un ciclo en el programa, considerando el estado de ZF

INSTRUCCIONES REPETITIVAS LOOPNE

Esta instrucción decrementa en uno a CX y transfiere el flujo del programa solo si ZF es diferente a 0.

Propósito: Decrementar el operando

INSTRUCCIONES REPETITIVAS DEC

Esta operación resta 1 al operando destino y almacena el nuevo valor en el mismo operando.

Propósito: Incrementar el operando.

INSTRUCCIONES REPETITIVAS INC

La instrucción suma 1 al operando destino y guarda el resultado en el mismo operando destino.

Propósito: Comparar los operandos.

INSTRUCCIONES REPETITIVAS WHILE

Es la estructura básica que permite repetir varias veces una secuencia de operaciones, mientras se cumpla una determina condición.

Repetirá el bucle mientras la condición que contiene se verdadera; esto implica que, de alguna forma las instrucciones que componen la sentencia que ejecuta while tienen que modificar la condición para que en algún momento llegue a ser falsa y el programa pueda continuar por la siguiente sentencia o bien romper el bucle implícitamente con break. De la misma forma se puede volver al principio del bucle con continúe.

Repite el cuerpo del bucle mientras la condición determinada sea verdadera.

#include <iostream.h>
int main()
{
int counter = 0;
while(true)
{
counter ++;
if(counter > 10)
break;
}
cout << "Counter: " << counter << "\n";
return 0;

}

INSTRUCCIONES REPETITIVAS DO WHILE

Permite repetir una sentencia un número indeterminado de veces dependiendo de una condición, de forma parecida a while. 

Repetirá el bucle mientras la condición sea verdadera: al igual que while se tiene que modificar la condición para que en algún momento llegue a ser falsa y el programa pueda continuar por la sentencia siguiente a do while.

A diferencia de while, do while garantiza que al menos se ejecutará una iteracción.

La estructura repetir cumple la misma función que la estructura mientras. La diferencia está en que la estructura mientras comprueba la condición al inicio y repetir lo hace al final. Es por ello la estructura repetir se ejecuta por lo menos una vez.

#include <iostream.h>
int main()
{
int counter;
cout << "How many hellos? ";
cin >> counter;
do
{
cout << "Hello\n";
counter--;
}  
        while(counter > 0);
                cout << "Counter is: " << counter << endl;
return 0;

}

INSTRUCCIONES REPETITIVAS FOR

Se utiliza cuando se puede determinar el número de veces que hay que ejecutar las instrucciones.

Este ejecuta las acciones del cuerpo o bucle un número especificado de veces y de modo automático.

#include <iostream.h>
int main()
{
int counter = 0;
while(true)
{
counter ++;
if(counter > 10)
break;
}
cout << "Counter: " << counter << "\n";
return 0;

}

INSTRUCCIONES REPETITIVAS BREAK Y CONTINUE

Hay dos palabras reservadas que pueden ayudar a mejorar las estructuras repetitivas: break y continue.

Break: Obliga a que el ciclo se rompa aunque la condición lógica no se haya cumplido.

Continue: Obliga a que un ciclo vuelva a iterarse. Es preferible que se trate de evitar el uso de break a menos que sea absolutamente necesario, ya que puede causar conflictos y es difícil de debuggear.

#include <iostream.h>
int main()
{
unsigned short small;
unsigned long  large;
unsigned long  skip;
unsigned long target;
const unsigned short MAXSMALL=65535;
cout << "Enter a small number: ";
cin >> small;
cout << "Enter a large number: ";
cin >> large;
cout << "Enter a skip number: ";
cin >> skip;
cout << "Enter a target number: ";
cin >> target;
cout << "\n";
// set up 3 stop conditions for the loop
while(small < large && large > 0 && small < MAXSMALL)
        {
small++;
if (small % skip == 0)  // skip the decrement?
{
cout << "skipping on " << small << endl;
continue;
}
if (large == target)    // exact match for the target?
{
cout << "Target reached!";
break;
}
large-=2;
}                   // end of while loop
cout << "\nSmall: " << small << " Large: " << large << endl;
return 0;

}

EJEMPLO

Sumar la edad de 15 personas

• Pseudocódigo

suma=0
k=0
Mientras (k<10) hacer
Leer: Edad
suma=suma+edad
k=k+1
Fin Mientras
Escribir: suma

• Assembler

;INICIO
.model small
.stack 64
.data

;DECLARACION DE VARIABLES
edad db 0
k db 0
suma dd 0

;DEFINIR MENSAJES
msg1 db 10,30 “Ingrese la Edad ::”, ’$’
msg2 db 10,30 “La suma de edades es::,’$’

;INICIALIZAR EL PROGRAMA
.code
begin proc far
mov ax;@data
mov ds, ax

;PROCESO REPETITIVO
mov k,0
CICLO:
cmp k,15
jae FINCICLO

mov ah,09
lea dx,msg1
int 21h
mov ah,01
int 21h
sub al,30h
mov edad,al
add suma,al
inc k
jmp CICLO
FINCICLO

;MOSTRAR SUMA DE EDADES
mov ah,09
lea dx,msg2
int 21h
mov dl, suma
add dl,30h
mov ah,02
int 21h

;FINALIZAR PROGRAMA
mov ah,4ch
int 21h
begin endp
end

RESUMEN

Un ciclo de CPU es un pulso electromagnético que genera el oscilador de cuarzo presente en todo procesador o microprocesador de computadora. La velocidad de funcionamiento del microprocesador viene determinada por el ritmo de los impulsos de su reloj. Este reloj u oscilador es un circuito electrónico encargado de emitir a un ritmo constante impulsos eléctricos. El funcionamiento de este reloj es comparable con un metrónomo con su péndulo que oscila de izquierda a derecha. El intervalo de tiempo que el péndulo tarda en recorrer esa distancia y regresar a su punto inicial se denomina ciclo.

SUMMARY

A CPU cycle is an electromagnetic pulse that generates the quartz oscillator present in every processor or computer microprocessor. The speed of operation of the microprocessor is determined by the rhythm of the impulses of your watch. This clock or oscillator is an electronic circuit in charge of emitting at a constant rate electrical impulses. The operation of this watch is comparable with a metronome with its pendulum swinging from left to right. The interval of time the pendulum takes to travel that distance and return to its initial point is called the cycle.

RECOMENDACIONES

Para desarrollar un algoritmo se debe tener en cuenta lo siguiente:

• Identificar cada una de las estructuras cíclicas.
• Clasificar las diferentes estructuras repetitivas, para ello elegir que estructura es la adecuada.
• Reconocer las estructuras cuantitativas y acumulativas empleadas al momento de realizar un algoritmo.

CONCLUSIONES

Este tipo de estructuras son parte integral de cualquier lenguaje de programación, ya que se utiliza cuando se quiere que un mismo conjunto de instrucciones se ejecuten un cierto número de veces. Son útiles cuando se quiere hacer la misma operación una y otra vez durante un tiempo determinado, o hasta que alguna condición cambie.

Lo interesante de las estructuras repetitivas es que son eficientes, ya que al reducir tareas complejas a algo tan sencillo como esto, no solo se ahorra código, sino también facilita la solución al problema.

APRECIACIÓN PERSONAL

Para este tema "CICLOS" me fue fácil ya que conté con el material adecuado y además me ayudo mucho la Internet, espero que les sea útil y les sirva esta investigación.

GLOSARIO DE TÉRMINOS

LOOP: Lazo
WHILE: Mientras
DO WHILE: Hacer - Mientras
FOR: Para
ALGORITMO: Conjunto ordenado de operaciones sistemáticas que permite hacer un cálculo y hallar la solución de un tipo de problemas.

BIBLIOGRÁFICA

• http://maxonlineblog.blogspot.pe/2009/08/estructuras-repetitivas-e-iterativas.html
• http://fundaprograprimsem.blogspot.pe/2013/06/ciclos-repetitivos.html
• http://www.pixelesybytes.com/2015/07/bucles-ciclos-do-while.html
• http://michelletorres.mx/estructuras-repetitivas/
• http://moisesrbb.tripod.com/unidad5.htm#u521

Vídeo relacionado al tema

Descargar el documento en PDF

Diapositiva "Ciclos"

SALTO CONDICIONAL

DEFINICIÓN

Los saltos condicionales permiten pasar de una etapa a otra sin ser éstas consecutivas, sin activar las etapas intermedias. Estos saltos pueden darse en sentido evolución del Grafcet como en sentido inverso a la evolución del Grafcet.

Para explicar con ecuaciones estos saltos condicionales utilizaremos el siguiente ejemplo:

En este ejemplo partimos de la etapa E1 y para activar justo a continuación la etapa E7, activaremos la condición de transición Fx y mantendremos desactivado la condición de transición F1.

Las ecuaciones que obtenemos con este ejemplo son las siguientes:

INSTRUCCIONES DE SALTO

Una instrucción de salto produce un cambio en la ejecución del programa pasando a una nueva posición, no secuencial. La dirección del salto se representa con una etiqueta.

CMP: Esta instrucción es considerada como una instrucción Aritmética, ya que sustrae el operando fuente del operando destino, solo que el resultado no se almacena en el operando destino, el resultado se utiliza solo para activar las banderas.

Comparaciones de números sin signo:

• JA o JNBE: Salta si está por arriba de, o lo mismo si no está por debajo o igual de.
• JAE o JNB: Salta si está por arriba o es igual, o lo mismo si no está por debajo de. (CF=0).
• JB o JNAE: Salta si está por debajo de, o salta si no está por arriba ni es igual. (CF=1).
• JBE o JNA: Salta si está por debajo de o es igual, o salta si no está por arriba de. (CF=1 or ZF=1).

Comparaciones para enteros con signo:

• JG o JNLE: Salta si es mayor, lo mismo, salta si no es menor ni igual. (ZF=0 or OF=SF).
• JGE o JNL: Salta si es mayor o igual, lo mismo, salta si no es menor. (SF=OF).
• JL o JNGE: Salta si es menor, lo mismo, salta si no es mayor ni igual. (SF<>OF).
• JLE o JNG: Salta si es menor o igual, lo mismo, salta si no es mayor. (ZF=1 or SF<>OF).

Verificando el estado de las banderas:

• JC: Salta si la bandera del carry es 1 (CF=1).
• JNC: Salta si la bandera del carry es 0 (CF=0).
• JO: Salta si la bandera del overflow es 1 (OF=1).
• JNO: Salta si la bandera del overflow es 0 (OF=0).
• JNP o JPO: Salta si no hay paridad (PF=0). Esto significa paridad par.
• JP o JPE Salta si hay paridad (PF=1). Esto significa paridad impar.
• JS: Salta si la bandera del signo es 1 (SF=1).
• JCXZ: Salta si el contenido de CX es 0.

Hay más de 30 instrucciones de salto, vamos a nombrar las más usadas:

Instrucción	Descripción
jmp etiqueta	Salto incondicional directo
je etiqueta	Salto por igual
jne etiqueta	Salto por no igual
jg etiqueta	Salto por mayor
jng etiqueta	Salto por no mayor
jge etiqueta	Salto por mayor igual
jnge etiqueta	Salto por no mayor igual
jl etiqueta	Salto por menor
jnl etiqueta	Salto por no menor
jle etiqueta	Salto por menor igual
jnle etiqueta	Salto por no menor igual
js etiqueta	Salto negativo

EJEMPLOS

Programa que calcula la expresión x=(a+(b-c))/(c*d) dados los valores a=4, b=5, c=2, d=7 declarados en la sección de datos.

# Programa que calcula x=(a+(b-c))/(c*d)
.section .data
a:	.long 4
b:	.long 5
c:	.long 2
d:	.long 7
x:	.long 0
.section .text
.globl _start
_start:
	movl b, %eax	# %eax=b
	subl c, %eax	# %eax=b-c
	addl a, %eax	# %eax=(b-c)+a
	movl c, %ecx	# %ecx=c
	imull d, %ecx	# %ecx=c*d
	cltd	# %edx=0
	idivl %ecx	# %eax=((b-c)+a)/(c*d) %edx=resto
	movl %eax, x	# guarda el resultado en x
	movl $1, %eax	# fin del programa
	movl $0, %ebx
	int $0x80

Programa que dados tres valores enteros declarados en la sección de datos, determina el mayor y lo guarda en una variable denominada mayor.

# Programa que revisa tres numeros y escoge el mayor
.section .data
a:	.long 4
b:	.long 2
c:	.long 3
mayor:	.long 0
.section .text
.globl _start
_start:
	movl a, %eax
	movl b, %ebx
	movl c, %ecx
	cmpl %ebx, %eax	# compara a con b
	jg amayorb	# si a>b salta a amayorb
	cmpl %ecx, %ebx	# compara b con c
	jl bmenorc	# si b<c salta a mnenorc
	movl %ebx, mayor	# cuando b es el mayor
	jmp fin	# salta a fin
bmenorc:	movl %ecx, mayor	# cuando c es el mayor
	jmp fin	# salta a fin
amayorb:	cmpl %ecx, %eax	# compara a con c
	jl amenorc	# si a<c salta a amenorc
	movl %eax,mayor	# cuando a es el mayor
	jmp fin	# salta a fin
amenorc:	movl %ecx, mayor	# cuando c es el mayor
fin:	movl $1, %eax	# fin del programa
	movl $0, %ebx
	int $0x80

RESUMEN

Las instrucciones de salto condicional hacen que el control de flujo del programa salte a la instrucción cuya dirección está especificada por su operando si se cumple una condición dada. La direccion de saltos se reperesenta con una etiqueta:

Las instrucciones de salto se clasifican en tres grupos: 

• Saltos si la condición es una comparación no signada
• Saltos si la condición es una comparación signada
• Saltos si la condición es un estado de una bandera o el registro CX.

SUMMARY

The conditional jump instructions cause the program flow control to skip to the instruction whose address is specified by its operand if a given condition is met. The direction of jumps is reflected with a label:

The jump instructions are classified into three groups:

• Jumps if the condition is an unnamed comparison
• Jumps if the condition is a signed comparison
• Jumps if the condition is a state of a flag or the CX record.

RECOMENDACIONES

• Se necesita predecir dirección y objetivo de salto. 
• La dirección real solo se conoce después de ejecutar la instrucción. 
• Una predicción incorrecta origina un vaciado total del cauce.

CONCLUSIONES

• Los saltos condicionales son similares a JMP, en la sintaxis pero la diferencia es en el nombre.
• Los saltos condicionales permiten pasar de una etapa a otra sin ser éstas consecutivas, sin activar las etapas intermedias. Estos saltos pueden darse en sentido evolución del Grafcet como en sentido inverso a la evolución del Grafcet.
• Las instrucciones son las siguientes JE o JZ. 
• El objetivo es saltar si la última comparación realizada da igual. 

APRECIACIÓN PERSONAL

Para este tema "SALTO CONDICIONAL" me fue fácil ya que conté con el material adecuado y además me ayudo mucho la Internet, espero que les sea útil y les sirva esta investigación.

GLOSARIO DE TÉRMINOS

CMP: Esta instrucción es considerada como una instrucción Aritmética.

GRAFCET: es un diagrama funcional que describe los procesos a automatizar.

BIBLIOGRÁFIA

• http://www.sc.ehu.es/sbweb/webcentro/automatica/WebCS1/salto_condicional.htm
• http://learnassembler.com/salto.html
• http://lenguajeensamblador2013.blogspot.pe/2013/08/guia-nro-4-saltos-condicionales-y-bucles.html

Video relacionado al tema

Descargar el documento en PDF

Diapositiva "Salto Condicional"

LENGUAJE ENSAMBLADOR

DEFINICIÓN

El lenguaje ensamblador, o assembler (en inglés assembly language y la abreviación asm) es un lenguaje de programación de bajo nivel.

Consiste en un conjunto de mnemónicos que representan instrucciones básicas 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 de procesador y constituye la representación más directa del código máquina específico para cada arquitectura legible por un programador.

Cada arquitectura de procesador tiene su propio lenguaje ensamblador que usualmente es definida por el fabricante de hardware, y está basada en los mnemónicos que simbolizan los pasos de procesamiento (las instrucciones), los registros del procesador, las posiciones de memoria y otras características del lenguaje. Un lenguaje ensamblador es por lo tanto específico de cierta arquitectura de computador física (o virtual).

Fue usado principalmente en los inicios del desarrollo de software, cuando aún no se contaba con potentes lenguajes de alto nivel y los recursos eran limitados. Actualmente se utiliza con frecuencia en ambientes académicos y de investigación, especialmente cuando se requiere la manipulación directa de hardware, alto rendimiento, o un uso de recursos controlado y reducido. 

También es utilizado en el desarrollo de controladores de dispositivo (en inglés, device drivers) y en el desarrollo de sistemas operativos, debido a la necesidad del acceso directo a las instrucciones de la máquina. Muchos dispositivos programables (como los microcontroladores) aún cuentan con el ensamblador como la única manera de ser manipulados.

CARACTERÍSTICAS

• El código escrito en lenguaje ensamblador posee una cierta dificultad de ser entendido ya que su estructura se acerca al lenguaje máquina, es decir, es un lenguaje de bajo nivel.

• Difícilmente portable, es decir, un código escrito para un microprocesador, puede necesitar ser modificado, para poder ser usado en otra máquina distinta. Al cambiar a una máquina con arquitectura diferente, generalmente es necesario reescribirlo completamente.

• Los programas hechos por un programador experto en lenguaje ensamblador son generalmente mucho más rápidos y consumen menos recursos del sistema (memoria RAM y ROM) que el programa equivalente compilado desde un lenguaje de alto nivel. Al programar cuidadosamente en lenguaje ensamblador se pueden crear programas que se ejecutan más rápidamente y ocupan menos espacio que con lenguajes de alto nivel.

• Con el lenguaje ensamblador se tiene un control muy preciso de las tareas realizadas por un microprocesador por lo que se pueden crear segmentos de código difíciles y/o muy ineficientes de programar en un lenguaje de alto nivel, ya que, entre otras cosas, en el lenguaje ensamblador se dispone de instrucciones del CPU que generalmente no están disponibles en los lenguajes de alto nivel.

• También se puede controlar el tiempo en que tarda una rutina en ejecutarse, e impedir que se interrumpa durante su ejecución.

VENTAJAS - DESVENTAJAS

VENTAJAS

• Como trabaja directamente con el microprocesador al ejecutar un programa, pues como este lenguaje es el mas cercano a la máquina la computadora lo procesa mas rápido.

• Eficiencia de tamaño: Un programa en ensamblador no ocupa mucho espacio en memoria porque no tiene que cargan librerías y demás como son los lenguajes de alto nivel

• Flexibilidad: Es flexible porque todo lo que puede hacerse con una máquina, puede hacerse en el lenguaje ensamblador de esta máquina; los lenguajes de alto nivel tienen en una u otra forma limitantes para explotar al máximo los recursos de la máquina. O sea que en lenguaje ensamblador se pueden hacer tareas especificas que en un lenguaje de alto nivel no se pueden llevar acabo porque tienen ciertas limitantes que no se lo permite

DESVENTAJAS

• Tiempo de programación: Como es un lenguaje de bajo nivel requiere más instrucciones para realizar el mismo proceso, en comparación con un lenguaje de alto nivel. Por otro lado, requiere de más cuidado por parte del programador, pues es propenso a que los errores de lógica se reflejen más fuertemente en la ejecución.

• Programas fuente grandes: Por las mismas razones que aumenta el tiempo, crecen los programas fuentes; simplemente requerimos más instrucciones primitivas para describir procesos equivalentes. Esto es una desventaja porque dificulta el mantenimiento de los programas, y nuevamente reduce la productividad de los programadores.

• Peligro de afectar recursos inesperadamente: Que todo error que podamos cometer, o todo riesgo que podamos tener, podemos afectar los recursos de la maquina, programar en este lenguaje lo más común que pueda pasar es que la máquina se bloquee o se reinicie. Porque con este lenguaje es perfectamente posible (y sencillo) realizar secuencias de instrucciones inválidas, que normalmente no aparecen al usar un lenguaje de alto nivel.

• Falta de portabilidad: Porque para cada máquina existe un lenguaje ensamblador; por ello, evidentemente no es una selección apropiada de lenguaje cuando deseamos codificar en una máquina y luego llevar los programas a otros sistemas operativos o modelos de computadoras.

INSTRUCCIONES - REGISTROS

INSTRUCCIONES

ARITMÉTICAS: Se usa para la realizar operaciones aritméticas sobre los operandos.

ADD: Suma los operandos y guarda el resultado en el operando destino.

SUB: Resta el operando fuente del destino.

DIV: El divisor puede ser un byte o palabra y es el operando que se la da instrucción.

IDIV: Consiste basicamente en lo mismo que la instrucción DIV, solo que esta ultima realiza la operación con signo.

MUL: El ensambldor asume que el multiplicando sera del mismo tamaño que el del multiplicador, por lo tanto multiplica el valor almacenado en el registro que se le da como operando por el que se encuentre contenido en AH si el multiplicador es de 8 bits o por AX si el multiplicador es de 16 bits.

LÓGICAS: Son utilizadas para realizar operaciones lógicas sobre los operandos.

AND: Con esta instrucción se lleva a cabo la operación "y" lógica de los dos operandos.

OR: Lleva a cabo, bit por bit, la disyunción inclusiva lógica de los dos operandos .

XOR: Su función efectuar bit por bit la disyunción exclusiva lógica de los dos operandos.

TEST: Realiza una conjunción, bit por bit, de los operandos, pero a diferencia de AND esta instrucción no coloca el resultado en el operando destino, solo tiene efecto sobre el estado de las banderas.

NEG: Esta instrucción genera el complemento a 2 del operando destino y lo almacena en este mismo operando.

NOT: Lleva a cabo la negación bit por bit del operando destino

TRANSFERENCIA: Son utilizadas para mover los contenidos de los operandos. Cada instrucción se puede usar con diferentes modos de direccionamiento.

MOV: Transferencia de datos entre celdas de memoria, registros y acumulador.

MOVS: Mover cadenas de bytes o palabras desde la fuente, direccionada por SI, hasta el destino direccionado por DI.

CARGA: Son instrucciones específicas de los registros. Son usadas para cargar en algún registro bytes o cadenas de bytes.

LODS: Toma la cadena que se encuentre en la dirección especificada por SI, la carga al registro AL (o AX) y suma o resta 1 (segun el estado de DF) a SI si la transferencia es de bytes o 2 si la transferencia es de palabras.

LAHF: Esta instrucción es útil para verificar el estado de las banderas durante la ejecución de nuestro programa.

LDS: El operando fuente debe ser una palabra doble en memoria. La palabra asociada con la dirección mas grande es transferida a DS, o sea que se toma como la dirección del segmento. La palabra asociada con la dirección menor es la dirección del desplazamiento y se deposita en el registro señalado como destino.

LEA: El operando fuente debe estar ubicado en memoria, y se coloca su desplazamiento en el registro índice o apuntador especificado en destino.

LES: El operando fuente debe ser un operando en memoria de palabra doble. El contenido de la palabra con la dirección mayor se interpreta como la dirección del segmento y se coloca en ES. La palabra con la dirección menor es la dirección del desplazamiento y se coloca en el registro especificado en el parámetro destino.

PILA: Estas instruciones permiten el uso de la pila para almacenar y extraer datos.

POP: Esta instrucción transfiere el último valor almacenado en la pila al operando destino, después incrementa en dos el registro SP.
POPF: Este comando transfiere bits de la palabra almacenada en la parte superior de la pila hacia el registro de banderas.
PUSH: La instrucción PUSH decrementa en dos el valor de SP y luego transfiere el contenido del operando fuente a la nueva dirección resultante en el registro recién modificado.
PUSHF: Decrementa en 2 el valor del registro SP y luego se transfiere el contenido del registro de banderas a la pila, en la dirección indicada por SP.

REGISTROS

Registros de uso general
AX: Acumulador (AL:AH)

BX: Registro base (BL:BH)

CX: Registro contador (CL:CH)

DX: Registro de datos (DL:DH)

Registros de segmento (Solo se pueden usar para los usos mencionados a excepción de ES)

DS: Registro del segmento de datos

ES: Registro del segmento extra

SS: Registro del segmento de pila

CS: Registro del segmento de código

Registros punteros (También pueden tener uso general)

BP: Registro de apuntadores base

SI: Registro índice fuente

DI: Registro ìndice destino

Registros especiales (Solo se pueden usar para los usos mencionados)

SP: Registro apuntador de la pila

IP: Registro apuntador de la siguiente instrucción

F: Registro de banderas (8 bits)

Bits del registro de banderas

Overflow
NV (Apagado): No hay desbordamiento
OV (Encendido): Si lo hay

Direction
UP: Hacia adelante
DN: Hacia atras

Interrupts
DI: Desactivadas
EI: Activadas

Sign
PL: Positivo

NG: Negativo

Zero

NZ: No es cero

ZR: Si lo es

Auxilary carry
NA: No hay acarreo auxiliar
AC: Hay acarreo auxiliar

Parity
PO: Impar
PE: Paridad par

Carry
NC: No hay acarreo
CY: Si lo hay

EJEMPLOS

Es un ejemplo del programa clásico Hola mundo escrito para la arquitectura de procesador x86 (bajo el sistema operativo DOS).

; ---------------------------------------------
; Programa que imprime un string en la pantalla
; ---------------------------------------------
	.model small              ; modelo de memoria

	.stack                    ; segmento del stack

	.data                     ; segmento de datos
	Cadena1 DB 'Hola Mundo.$' ; string a imprimir (finalizado en $)

	.code                     ; segmento del código

; ---------------------------------------------
; Inicio del programa
; ---------------------------------------------
	programa:
		; ----------------------------------------------------------------------------------------------------
		; inicia el segmento de datos
		; ----------------------------------------------------------------------------------------------------
		MOV AX, @data          ; carga en AX la dirección del segmento de datos
		MOV DS, AX             ; mueve la dirección al registro de segmento por medio de AX
		
		; ----------------------------------------------------------------------------------------------------
		; Imprime un string en pantalla
		; ----------------------------------------------------------------------------------------------------
		MOV DX, offset Cadena1 ; mueve a DX la dirección del string a imprimir
		MOV AH, 9              ; AH = código para indicar al MS DOS que imprima en la pantalla, el string en DS:DX
		INT 21h                ; llamada al MS DOS para ejecutar la función (en este caso especificada en AH)
		
		; ----------------------------------------------------------------------------------------------------
		; Finaliza el programa
		; ----------------------------------------------------------------------------------------------------
		INT 20h                ; llamada al MS DOS para finalizar el programa

	end programa

RESUMEN

El Lenguaje Ensamblador proporciona las herramientas para tomar control sobre todo lo que la computadora realiza físicamente.

Proporciona un control absoluto sobre la PC. Los programas en ensamblador son rápidos y compactos. Una instrucción mal interpretada o un error de lógica se vuele mas compleja.

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 computadoras legible por un programador.

SUMMARY

Assembler Language provides the tools to take control over everything that computer physically performed.

It provides complete control over the PC. Assembler programs are fast and compact. A misunderstood instruction or a logic error will fly more complex.

It is a type of low-level language used to write computer programs, and is the most direct representation of specific machine code for each computer architecture readable by a programmer.

CONCLUSIONES

El lenguaje ensamblador a pesar de ser mas rápido de cualquier otro lenguaje es también el mas complejo por eso es utilizado para complementar los limitantes de los lenguajes de programación de alto nivel. Pero existen ramas donde es imprescindible el uso de lenguaje ensamblador como lo es la electrónica donde los recursos de los aparatos son limitados y es necesario utilizar lenguaje ensamblador.

GLOSARIO DE TÉRMINOS

ASM: assembly language (Lenguaje emsamblador)

BIBLIOGRAFÍA O LINKOGRAFÍA

• https://es.wikipedia.org/wiki/Lenguaje_ensamblador
• http://www.monografias.com/trabajos14/lenguaje-ensamblador/lenguaje-ensamblador.shtml#ve
• https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_lenguaje_ensamblador/Primeros_conceptos#Registros_de_la_CPU
• http://html.rincondelvago.com/ensamblador.html

Video relacionado al tema

Descargar el documento en PDF

Diapositiva "Lenguaje Ensamblador"