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

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

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

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

• 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

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

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

#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

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

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

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

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

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

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

+= 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

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

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