Este documento describe los elementos básicos del lenguaje de programación Assembly, incluyendo etiquetas, instrucciones, comentarios y diferentes tipos de directivas como directivas de control, configuración y datos. También explica conceptos como operadores matemáticos e instrucciones condicionales. El lenguaje Assembly es un lenguaje de bajo nivel cercano al lenguaje de la máquina que se usa comúnmente para programar microcontroladores.

1. 1
PROGRAMACIÓN DE
MICROCONTROLADORES
Unidad 2. Análisis estructural y funcional de un
microcontrolador
Un lenguaje de programación consiste en una serie específica de caracteres que permiten dar
instrucciones a un computador o microcontrolador con la finalidad de lograr que ella realice
ciertas acciones en la solución de alguna necesidad.

2. 2
TABLA DE CONTENIDO
Lenguaje de programación.........................................................................................................3
Lenguaje Assembly ASM .............................................................................................................4
Estructura de lenguaje Assembly..............................................................................................6
Etiquetas................................................................................................................................................6
Instrucciones........................................................................................................................................6
Comentarios.........................................................................................................................................6
Directivas...............................................................................................................................................7
Directivas de control.........................................................................................................................7
Directivas de configuración...........................................................................................................9
Directivas de datos......................................................................................................................... 10
Instrucciones de condición ......................................................................................................... 11
Operadores matemáticos............................................................................................................ 14
Ejemplo de lenguaje Assembly................................................................................................16
Enlaces externos.........................................................................¡Error! Marcador no definido.

3. 3
Lenguaje de programación
Cada lenguaje tiene características propias en cuanto a su gramática y sintaxis. A
diferencia del lenguaje humano que permite transmitir múltiples ideas a la vez, los
lenguajes de programación no requieren que comuniquen gran variedad de
pensamientos, es suficiente que permitan la transmisión de solo cuatro pensamientos
básicos. Además, la comunicación a través de estos lenguajes tiene que ser precisa,
clara y sin ambigüedades.
Existen dos niveles de lenguajes de programación dependiendo de qué tan cercanos
estén del lenguaje humano:
Los lenguajes de bajo nivel son una representación simbólica del lenguaje máquina
asociado, lo cual permite una programación menos tediosa que con el lenguaje
máquina correspondiente.
Los lenguajes de alto nivel son más modernos, y presentan una gran facilidad para el
programador en cuanto a la facilidad de realizar programas debido a que poseen
macroinstrucciones.
Estas macroinstrucciones son instrucciones escritas en un lenguaje diferente al de
máquina, que mediante traducción, es convertida en otro grupo de instrucciones en
lenguaje máquina.

4. 4
Lenguaje Assembly ASM
El lenguaje que el microcontrolador y el hombre utilizan para comunicarse entre sí, se
llama "lenguaje Assembly". El hombre puede entender el lenguaje Assembly (ASM),
ya que consta de los signos del alfabeto y las palabras. Un traductor interpreta cada
instrucción escrita en lenguaje ASM como una serie de ceros y unos que tienen un
sentido de la lógica interna en el microcontrolador.
Es un tipo de lenguaje de bajo nivel basado en la escritura de una serie de
instrucciones que corresponden al flujo de órdenes ejecutables que pueden ser
cargadas en la memoria de un sistema basado en microcontrolador. Muchos
dispositivos programables (como los microcontroladores) aún cuentan con el
Assembly como la única manera de ser manipulados.
Características
• Los programas hechos en lenguaje Assembly son generalmente más rápidos y
consumen menos recursos del sistema (memoria RAM y ROM). Al programar
cuidadosamente en lenguaje Assembly se pueden crear programas que se
ejecutan más rápidamente y ocupan menos espacio que con lenguajes de alto
nivel.
• Con el lenguaje Assembly 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 de programar en un lenguaje de alto nivel.
• Posee una cierta dificultad de ser entendido directamente por un ser humano
ya que su estructura se acerca más bien al lenguaje máquina, es decir, lenguaje
de bajo nivel.

5. 5
• Es difícilmente portable, es decir, un código escrito para un microcontrolador
en particular necesita ser modificado muchas veces en su totalidad para poder
ser usado en otro.
Cada arquitectura de microcontrolador tiene su propio lenguaje de máquina, y en
consecuencia su propio lenguaje Assembly ya que este se encuentra muy ligado a la
estructura del hardware para el cual se programa. Los microprocesadores difieren en
el tipo y número de operaciones que soportan; también pueden tener diferente
cantidad de registros, y distinta representación de los tipos de datos en memoria.
Aunque la mayoría de los microcontroladores son capaces de cumplir esencialmente
las mismas funciones, la forma en que lo hacen difiere y los respectivos lenguajes
Assembly reflejan tal diferencia.

6. 6
Estructura de lenguaje Assembly
Etiquetas
Es una designación de texto fácil de leer en una línea de un programa, o una sección
de un programa donde el micro puede saltar a... - o el comienzo de un conjunto de
líneas de un programa. La etiqueta empieza con una letra del alfabeto o con un
subrayado "_". La longitud de la etiqueta puede ser de hasta 32 caracteres. También
es importante que la etiqueta se inicie en la primera columna.
Start
_end
P123
Is it bigger?
Instrucciones
Están ya definidas por el uso de un microcontrolador específico, por lo que sólo nos
queda seguir las instrucciones para su uso en lenguaje ASM. La forma en que
escribimos una instrucción también se denomina "sintaxis".
Comunicación escrita
correctamente
movlw H`01FF`
goto Start
Comentarios
Son una serie de palabras que escribe un programador para hacer el programa más
claro y legible. Se coloca después de una instrucción, y debe comenzar con un punto

7. 7
y coma ";". Los comentarios no hacen parte del programa y no son reconocidos por el
compilador.
#define test
.
Ifdef test ; como la prueba fue definida
......; las instrucciones de estas líneas ejecutarían endif
Directivas
Es similar a una instrucción, pero esta es independiente en el modelo de
microcontrolador, y representa una característica de la lengua propia ASM. En las
Directivas se dan generalmente significados o propósitos a través de variables o
registros.
Directiva usada frecuentemente:
PROCESSOR 16F84
#include "p16f84.inc"
_CONFIG _CP_OFF&_WDT_OFF&_PWRTE_ON&_XT_OSC
Directivas de control
#DEFINE
Intercambios de una parte de texto por otra
Sintaxis: # define <text> [<another text>]
Descripción: Cada vez que <text> aparece en el programa, será
cambiado por el texto <another>.
Ejemplo: # define turned_on 1 # define turned_off 0

8. 8
#INCLUDE
Incluir un archivo adicional en un programa
Sintaxis: # include # include <nombre_de_archivo> "file_name"
Descripción: esta directiva tiene el efecto como si todo el archivo
se copió en un lugar donde la "incluyan". Si el nombre del archivo
se encuentra en los corchetes, se trata de un archivo de sistema y
si está dentro de las comillas se trata de un archivo de usuario. La
directiva "include" contribuye a una mejor distribución del
programa.
Ejemplo: #include<regs.h>
#include "subprog.asm"
CONSTANT
Da un valor numérico constante a la designación
Sintaxis: Constante <nombre> = <valor>
Descripción: Cada vez que <nombre> aparece en el programa,
será sustituido por <valor>.
Ejemplo: constant MAXIMUM=100
constant Lenght=30
VARIABLE
Da un valor numérico variable a la designación
Sintaxis: Variable <nombre> = <valor>
Descripción: Mediante el uso de esta directiva, las designaciones
textuales cambian con un Valor particular. Difiere de la directiva
CONSTANT en que después de la aplicación, el valor de la
designación de texto se puede cambiar.
Ejemplo: variable level=20
variable time=13
SET
Define el sintaxis de variables del ASM
Sintaxis: <name_variable> set <value>
Descripción: Para la variable <name_variable> se añade la
expresión <valor>. La directiva SET es similar a la EQU, pero con el
nombre de directiva SET, la variable puede ser redefinida seguida
de una definición.
Ejemplo: level set 0
length set 12
level set 45

9. 9
EQU
Define la constante del ASM
Sintaxis: <nombre_constante>equ<valor>
Descripción: a el nombre de una constante <name_constant> se
añade un valor <value>
Ejemplo: five equ 5
six equ 6
seven equ 7
ORG
Define la dirección en la memoria del microcontrolador en la cual
el programa está siendo grabado.
Sintaxis: <label>org<value>
Descripción: Esta es la directiva más utilizada. Con la ayuda de
esta directiva definimos que parte del programa será iniciada en la
memoria del programa.
Ejemplo: Start org 0×00
movlw 0xFF
movwf PORTB
END
Termina el programa
Sintaxis: end
Descripción: al final de cada programa es necesario escribir 'end'
para que el traductor de ASM sepa que no hay más instrucciones.
Ejemplo: movlw 0xFF
movwf PORTB
end
Directivas de configuración
_CONFIG
Ajuste de los bits de configuración.
Sintaxis: _config<term> or _config<address>,<term>
Descripción: Oscilador, la aplicación de temporizador de vigilancia
(Watchdog) y circuito de reinicio interno se definen. Antes de
utilizar esta directiva, el procesador debe ser definido usando la
directiva PROCESSOR.
Ejemplo: _CONFIG _CP_OFF&_WDT_OFF&_PWRTE_ON&_XT_OSC

10. 10
PROCESSOR
Define el modelo del microcontrolador.
Sintaxis: Processor <microcontroller_type>
Descripción: la instrucción establece el tipo de microcontrolador
en la programación.
Ejemplo:
processor 16F84
Directivas de datos
CBLOCK
Define un bloque para las constantes nombradas.
Sintaxis: Cblock [<term>]
<label>[:<increment>],<label>[:<increment>]
endc
Descripción: da valor a las constantes nombradas. Cada término
siguiente recibe un valor mayor por 1 que su persecutor. Si el
parámetro <increment> también es dado, entonces el valor dado
en el parámetro <increment> es añadido a las siguientes
constantes.
Valor del parámetro <term> es el valor inicial. Si no es dado, es
considerado cero.
Ejemplo: Cblock 0x02
first, second, third ;first=0x02, second=0x03, third=0x04
Endc
cblock 0x02
first : 4, second : 2, third ;first=0x06, second=0x08, third=0x09
endc
ENDC
Finaliza el bloque de definición constante.
Sintaxis: endc
Descripción: la directiva es usada al final de la definición de un
bloque de constantes para que el traductor de ASM pueda saber
que no hay más constantes.
Ejemplo: cblock 0x02
first : 4, second : 2, third ;first=0x06, second=0x08,
third=0x09
endc

11. 11
DB
Define un byte de datos.
Sintaxis: [<label>]db <term> [, <term>,.....,<term>]
Descripción: reserva un byte en la memoria del programa. Cuando
hay más de un término los cuales necesitan asignárseles un byte
para cada uno, se asignaran uno tras otro.
Ejemplo:
db 't', 0×0f, 'e', 's', 0×12
DE
Definir el byte para la memoria EEPROM
Sintaxis: [<term>] de <term> [, <term>,....., <term>]
Descripción: esta directiva es usada para definir el byte de la
memoria EEPROM. Aunque se puede utilizar para cualquier
locación en cualquier memoria.
Ejemplo:
org H'2100'
de "Version 1.0" , 0
DT
Definir la tabla de dato.
Sintaxis: [<label>] dt <term> [, <term>,........., <term>]
Descripción: Esta directiva genera series de instrucción RETLW,
una instrucción por cada término.
Ejemplo: dt "Message", 0
dt first, second, third
Instrucciones de condición
IF
Programa de salto condicional
Sintaxis: If <conditional_term>
Descripción: Si la condición se cumple en <conditional_term>,
parte del programa que sigue sería ejecutado. Y si no se cumple,
entonces la siguiente parte ELSE o ENDIF de la directiva sería
ejecutado.
Ejemplo:
If level=100
goto FILL
else
goto DISCHARGE
endif

12. 12
ELSE
Es la alternativa de `IF` programa en bloque con términos de
condición.
Sintaxis: else
Descripción: Se utiliza con la Directiva “IF” como una alternativa
si el término condicional no se cumple.
Ejemplo:
If time< 50
goto SPEED UP
else goto SLOW DOWN
endif
ENDIF
Finaliza la sección condicional del programa.
Sintaxis: endif
Descripción: esta directiva se escribe para informar al traductor de
ASM que es el final del bloque de condiciones.
Ejemplo:
If level=100
goto LOADS
else
goto UNLOADS
endif
WHILE
Ejecución de la sección del programa siempre y cuando se cumpla
la condición.
Sintaxis: while<condition>Endw
Descripción: las líneas de programa entre While y ENDW se
ejecutan mientras se cumpla la condición. Si una condición dejó
de ser válida, el programa continuaría ejecutando las instrucciones
hasta la línea ENDW. El número máximo de instrucciones entre
While y ENDW puede ser de 100.
Ejemplo:
While i<10
i=i+1
endw
ENDW
Finaliza la parte de condición del programa.
Sintaxis: endw

13. 13
Descripción: la instrucción es escrita al final de la condición del
bloque WHILE, para que el traductor de ASM sepa que es el final
del bloque de condiciones.
Ejemplo:
while i<10
i=i+1
endw
IFDEF
Ejecución de una parte del programa si el símbolo fue definido.
Sintaxis: ifdef<designation>
Descripción: Si la designación <designation> es previamente
descrita, muy comúnmente por la instrucción #define, las
instrucciones que le siguen serán ejecutadas hasta que las
directivas ELSE o ENDIF no sean alcanzadas.
Ejemplo:
#define test
.
Ifdef test ; como fue definida la prueba
......; las instrucciones de esta línea ejecutarían endif
IFNDEF
Ejecución de parte del programa si el símbolo fue definido.
Sintaxis: ifndef<designation>
Descripción: si la designación <designation> no fue previamente
definida, o si su definición fue borrada con directiva #undefine, las
instrucciones que siguen serán ejecutadas hasta que las directivas
ELSE o ENDIF sean alcanzadas.
Ejemplo:
#define test
..........
#undefine test
..........
ifndef test; como fue definida la prueba
......; las instrucciones de esta línea ejecutarían endif

14. 14
Operadores matemáticos
$ Estado actual del contador del programa goto $ + 3
( Corchete izquierdo 1 + (d * 4)
) Corchete derecho (Length + 1) * 256
! Complemento lógico if ! (a – b)
- Complemento flags = -flags
- Negación (segundo complemento) -1 * Length
high Devuelve el byte más alto movlw high CTR_Table
low Devuelve el byte más inferior movlw low CTR_Table
* Multiplicador a = b * c
/ Divisor a = b / c
% Divisor por módulo entry_len = tot_len % 15
+ Sumando tot_len =entry_len * 3 + 1
- Restando entry_len = (tot – 1) / 8
<< Moviendo a la izquierda val = flags << 1
>> Moviendo a la derecha val = flags >> 1
>= Mayor que o igual if entry_idx > =num_entries
> Mayor que if entry_idx > num_entries
< Menor que if entry_idx < num_entries
<= Menor que, o igual if entry_idx < = num_entries
== Igual if entry_idx = = num_entries
!= No igual if entry_idx ! = num_entries
& Operación AND en los bits flags = flags & ERROR_BIT
Λ
Exclusivo OR en los bits flags = flags
Λ
ERROR_BIT
| Lógica OR sobre bits flags = flags | ERROR_BIT
&& Lógica OR sobre bits if (len ==512) && (b ==c)
|| Lógica OR if (len ==512) || (b ==c)
= Igual entry_index = 0

15. 15
+= Añadir y asignar entry_index +=1
-= Restar y asignar entry_index -=1
*= Multiplicar y asignar entry_index *= entry_length
/= Dividir y asignar entry_index /= entry_length
%= Divide el módulo y asignar entry_index %=1
<<= Mueve a la izquierda y asigna flags << = 3
>>= Mueve a la derecha y asigna flags >> = 3
&= Lógica AND y asigna flags & = ERROR_FLAG
|= Lógica OR y asigna flags | = ERROR_FLAG
Λ
= Exclusivo OR en los bits y asigna flags
Λ
= ERROR_FLAG
++ Incrementa por uno 1++
- Reduce por uno 1-

16. 16
Ejemplo de lenguaje Assembly
El siguiente es un ejemplo de un programa para escribir “Hola mundo” utilizando
la arquitectura de procesador x86 (bajo el sistema operativo DOS).
.model small
.stack
.data
Cadena1 DB 'Hola Mundo.$'
.code
programa:
mov ax, @data
mov ds, ax
mov dx, offset Cadena1
mov ah, 9
int 21h
end programa
La transformación del lenguaje Assembly en código máquina la realiza un programa
Ensamblador, y la traducción inversa la puede efectuar un desensamblador.
A diferencia de los lenguajes de alto nivel, aquí hay usualmente una correspondencia
1 a 1 entre las instrucciones simples del Assembly y el lenguaje de máquina. Sin
embargo, en algunos casos, un Assembly puede proveer "pseudo instrucciones" que
se expanden en un código de máquina más extenso a fin de proveer la funcionalidad
necesaria.
Por ejemplo, para un código máquina condicional como "si X mayor o igual que", un
ensamblador puede utilizar una pseudoinstrucción al grupo "haga si menor que", y "si
= 0" sobre el resultado de la condición anterior.

17. 17
Enlaces externos
• Programación de microcontroladores
 http://www.monografias.com/trabajos12/microco/microco.shtml
 http://r-luis.xbot.es/pic1/pic01.html
 http://www.neoteo.com/tutorial-programacion-de-
microcontroladores.neo
 http://www.neoteo.com/tutorial-programacion-de-microcontroladores-
2366.neo
 http://www.jvmbots.com/viewtopic.php?t=18