Programacion c microcontroladores

Programación en C para microcontroladores.

Introducción.
C es un lenguaje bastante conciso y en ocasiones desconcertante. Considerado ampliamente como un
lenguaje de alto nivel, posee muchas características importantes, tales como: programación
estructurada, un método definido para llamada a funciones y para paso de parámetros, potentes
estructuras de control, etc.
Sin embargo gran parte de la potencia de C reside en su habilidad para combinar comandos simples
de bajo nivel, en complicadas funciones de alto nivel, y en permitir el acceso a los bytes y words del
procesador. En cierto modo, C puede considerarse como una clase de lenguaje ensamblador
universal. La mayor parte de los programadores familiarizados con C, lo han utilizado para programar
grandes máquinas que corren Unix, MS-DOS, e incluso Windows (programación de drivers). En estas
máquinas el tamaño del programa no es importante, y el interface con el mundo real se realiza a través
de llamadas a funciones o mediante interrupciones DOS. Así el programador en C sólo debe
preocuparse en la manipulación de variables, cadenas, matrices, etc.
Con los modernos microcontroladores de 8 bits, la situación es algo distinta. Tomando como
ejemplo el 8051, el tamaño total del programa debe ser inferior a los 4 u 8K (dependiendo del tamaño
de la EEPROM), y debe usarse menos de 128 o 256 bytes de RAM. Idealmente, los dispositivos reales
y los registros de funciones especiales deben ser direccionados desde C. Las interrupciones, que
requieren vectores en direcciones absolutas también deben ser atendidas desde C. Además, se debe
tener un cuidado especial con las rutinas de ubicación de datos para evitar la sobre escritura de datos
existentes.
Uno de los fundamentos de C es que los parámetros (variables de entrada) se pasan a las funciones
(subrutinas) en la pila, y los resultados se devuelven también en la pila. Así las funciones pueden ser
llamadas desde las interrupciones y desde el programa principal sin temor a que las variables locales
sean sobre escritas.
Una seria restricción de la familia 8051 es la carencia de una verdadera pila. En un procesador como
el 8086, el apuntador de la pila tiene al menos 16 bits. Además del apuntador de pila, hay otros
registros que pueden actuar como apuntadores a datos en la pila, tal como el BP (Base Pointer). En C,
la habilidad para acceder a los datos en la pila es crucial. Como ya ha sido indicado, la familia 8051
está dotada de una pila que realmente sólo es capaz de manejar direcciones de retorno. Con 256 bytes
disponibles, como máximo, para la pila no se pueden pasar muchos parámetros y realizar llamadas a
muchas funciones.
De todo ello, puede pensarse que la implementación de un lenguaje que como C haga un uso
intensivo de la pila, es imposible en un 8051. Hasta hace poco así ha sido. El 8051, hace tiempo que
dispone de compiladores C, que en su mayor parte han sido adaptados de micros más potentes, tal
como el 68000. Por ello la aproximación al problema de la pila se ha realizado creando pilas
artificiales por software. Típicamente se ha apartado un área de RAM externa para que funcione como
una pila, con la ayuda de rutinas que manejan la pila cada vez que se realizan llamadas a funciones.
Este método funciona y proporciona capacidad de repetir variables locales a distintos niveles sin sobre
escritura, pero a costa de hacer los programas muy lentos. Por lo tanto, con la familia 8051, la
programación en lenguaje ensamblador ha sido la única alternativa real para el desarrollo de pequeños
sistemas en los que el tiempo es un factor crítico.
Sin embargo, en 1980, Intel proporcionó una solución parcial al problema al permitir la
programación del 8051 en un lenguaje de alto nivel llamado PLM51. Este compilador no era perfecto,
había sido adaptado del PLM85 (8085), pero Intel fue lo suficientemente realista para evitar el uso de
un lenguaje totalmente dependiente del uso de la pila.
La solución adoptada fue sencillamente pasar los parámetros en áreas definidas de memoria. Así
cada función o procedure tenía su propia área de memoria en la que recibía los parámetros, y devolvía
los resultados. Si se utilizaba la RAM interna para el paso de parámetros, la sobrecarga de las llamadas
1

a funciones era muy pequeña. Incluso utilizando RAM externa, siempre más lenta que la RAM
interna, se consigue mayor velocidad que con una pila artificial.
El problema que tiene esta especie de "pila compilada" es que la sobrecarga de variables no es
posible. Esta aparentemente seria omisión, en la práctica no tiende a causar problemas con los típicos
programas del 8051. Sin embargo las últimas versiones de C51 permiten la sobrecarga de variables
selectiva, es decir permiten que unas pocas funciones críticas tengan sobrecarga, sin comprometer la
eficiencia de todo el programa.
Otras consideraciones dignas de destacar para el C en un microcontrolador son:
• Control de los periféricos internos y externos del chip.
• Servicio de las interrupciones.
• Hacer el mejor uso de los limitados conjuntos de instrucciones.
• Soportar diferentes configuraciones de ROM/RAM.
• Un alto nivel de optimización para conservar el espacio de código.
• Control de la conmutación de registros.
• Soporte para los derivados de la familia (87C751, 80C517 etc.).
El compilador Keil C51 contiene todas las extensiones para el uso del lenguaje C con
microcontroladores. Este compilador C utiliza todas las técnicas apuntadas por Intel con su PLM51,
pero añade características propias tales como la aritmética en coma flotante, la entrada/salida (I/O) con
formato, etc. Se trata de la implementación del estándar ANSI C específico para los procesadores
8051.

Configuración de memoria del 8051

Localización física de los espacios de memoria
Inicialmente la cosa más confusa sobre el 8051 es quizás la existencia de varios espacios de
memoria, que comienzan en la misma dirección.
Otros µC, tales como el 68HC11, tienen una configuración de memoria mucho más sencilla, en la
que solo existe un área de memoria de tipo Von Neuman, residente en uno o en varios chips.
Dentro del 8051 hay un espacio de RAM llamado DATA. Este espacio comienza en la dirección
D:00 (el prefijo 'D:' indica segmento DATA) y termina en la dirección 0x7F (127 en decimal). Este
área RAM puede utilizarse para almacenar las variables del programa. Se trata de una región
direccionable directamente en la que pueden utilizarse instrucciones como 'MOV A,direcc'. Por
encima de la dirección 0x7F se encuentran los registros de funciones especiales (SFR), que también
son accesibles mediante direccionamiento directo. Sin embargo, en algunos derivados del 8051 existe
otro espacio de memoria entre las direcciones 0x80 y 0xFF, llamado IDATA (Indirect DATA), que
sólo resulta accesible por direccionamiento indirecto (MOV A,@Ri). Para esta región que se solapa
con los SFR se utiliza el prefijo 'I:'. El 8051 carece de estos 128 bytes del espacio IDATA, que se
añadieron cuando apareció el 8052. Esta región resulta adecuada para la pila a la que siempre se
accede indirectamente a través del apuntador de pila SP (Stack Pointer). Y para hacer las cosas más
confusas, resulta que los 128 bytes de RAM comprendidos en las direcciones 0..0x7F también pueden
ser accedidos indirectamente con la instrucción MOV A,@Ri

2

Fig.1. - Los espacios de memoria del 8051.

Un tercer espacio de memoria, el segmento CODE, también comienza en la dirección cero, pero está
reservado para el programa o para almacenar valores constantes, ya que el µC no puede escribir en
esta región. Se extiende desde C:0000 hasta C:0xFFFF (65536 bytes); parte de este área puede residir
dentro del µC y la otra parte, si es necesaria, debe residir en chips externos de memoria EPROM o
FLASH. El acceso al contenido del segmento CODE se realiza mediante el contador de programa PC
(Program Counter) en los ciclos de búsqueda de instrucciones y con el DPTR (Data Pointer) para la
lectura de los datos constantes.
La cuarta región de memoria, llamada XDATA reside en una RAM externa al µC. Comienza en
X:0000 y se extiende hasta X:0xFFFF (65536 bytes). El acceso a esta región se realiza mediante el
registro de 16 bits DPTR (Data Pointer). En esta región se puede seleccionar un pequeño espacio de
256 bytes, llamado PDATA (acceso paginado), al que se accede con un apuntador de 8 bits (registros
R0 o R1). La dirección inicial de esta región PDATA viene dada por 16 bits, siendo los 8 bits de
mayor peso los contenidos en el SFR P2, estando a 0 los 8 bits restantes.
Una pregunta inmediata es: "¿Cómo evita el 8051 que el acceso a un dato en D:00, realice también
un acceso al dato X:0000?
La respuesta reside en el hardware del 8051: Cuando la CPU intenta acceder a D:00, habilita la
RAM interna mediante una señal READ interna, que no provoca cambios en la patilla /RD, utilizada
para leer la RAM externa.

MOV A,40H ; Lleva el valor de la dirección D:0x40 al acumulador.

Este modo de direccionamiento (directo) se utiliza en el modelo de memoria SMALL.
MOV R0,#0A0H
MOV A,@R0 ; Lleva el valor de la dirección I:0xA0 al acumulador

Este modo de direccionamiento se utiliza para acceder a la región de RAM interna de acceso indirecto
situada por encima de la dirección 0x7F, aunque también es una forma alternativa de acceso a los 128
bytes situados debajo de la dirección 0x80.
Una variación de DATA es BDATA (bit data). Esta es un área de 16 bytes (128 bits) que se extiende
desde D:0x20 hasta D:0x2F. Se trata de una región muy útil que permite el acceso normal a los bytes
con las instrucciones MOV, y también permite el acceso a los bits mediante instrucciones
especialmente orientadas al bit, como las siguientes:
SETB 20H.0 ; Pone a uno el bit 0 de la dirección D:0x20
CLR 20H.2 ; Pone a cero el bit 2 de la dirección D:0x20
El dispositivo externo EPROM o FLASH de memoria CODE no se habilita durante los accesos a la
RAM. De echo, la memoria externa de tipo CODE sólo se habilita cuando una patilla del 8051 llamada
PSEN (Program Store Enable) se pone a nivel bajo. El nombre CODE indica que la principal función
de la EPROM o FLASH es almacenar el programa.

3

No existe colisión entre los accesos a la RAM XDATA y la EPROM-FLASH CODE, ya que el
dispositivo externo XDATA sólo se activa a petición de dos patillas del 8051 llamadas /RD y /WR
(Read & Write), mientras que el dispositivo externo CODE se activa exclusivamente cuando la patilla
PSEN se pone a nivel bajo. Lógicamente el 8051 nunca activa a la vez las patillas PSEN y /RD o /WR.
Para acceder a la RAM XDATA existen instrucciones especiales (MOVX)

MOV DPTR,#08000H
MOVX A,@DPTR ; "Lleva al acumulador el contenido de la posición de
; RAM externa cuya dirección está en DPTR (8000H)".
Este modo de direccionamiento se utiliza en el modelo de memoria LARGE.
MOV R0,#080H ;
MOVX A,@R0 ;
Este es un modo de acceso alternativo a la RAM externa que se utiliza en el modelo de memoria
COMPACT. La dirección realmente accedida es 0xYY80 siendo YY el contenido del SFR P2.
Un punto importante a recordar es que la patilla PSEN se activa durante la fase de búsqueda de
instrucción, y con las instrucciones MOVC...(Move Code) usadas para la lectura de los datos
constantes residentes en memoria de código. Por otro lado, las instrucciones MOVX... (Move
eXternal) activan las patillas /RD o /WR, según que el movimiento sea hacia la CPU (lectura), o desde
la CPU (escritura). La 'X' indica que la dirección no está dentro del 8051, sino que está contenida en
un dispositivo eXterno que se habilita con las patillas /RD y /WR.

Posibles modelos de memoria
Así como el programador de PC tiene que elegir entre los modelos de memoria tiny, small, medium,
compact, large y huge para definir la segmentación de la RAM, el programador de 8051 tiene que
decidir el modelo de memoria a utilizar, el cual determina el lugar de residencia del programa y de los
datos.
C51 soporta actualmente las siguientes configuraciones de memoria:
ROM: el tamaño máximo del programa que permite generar C51 es de 64K, sin embargo es posible
aumentarlo hasta 1MB mediante el modelo BANKED descrito más abajo. Todos los elementos que se
deseen almacenar en la EPROM/ROM, tales como constantes, tablas etc., deben declararse como
code.
RAM: Se admiten tres modelos de memoria, SMALL, COMPACT y LARGE

1. SMALL: todas las variables y segmentos de paso de parámetros se guardan en RAM interna.
2. COMPACT: las variables se almacenan en una región de RAM externa de acceso paginado y
de tamaño máximo 256 bytes. El acceso a las mismas se hace indirectamente por medio de
instrucciones "MOVX A,@R0". Los registros internos del 8051 se usan para variables locales
y parámetros de función.
3. LARGE: las variables se almacenan en memoria externa, y se accede a ellas con instrucciones
"MOVX A,@DPTR", lo que permite disponer de un espacio máximo de 64Kbytes para las
variables. Los registros internos del 8051 se usan para variables locales y parámetros de
función.

Modelo BANKED: Con este modelo el código puede ocupar hasta 1MB utilizando algunas patillas
de un puerto del 8051, o un latch mapeado en memoria. Estos hilos se utilizan para paginar la
memoria por encima de la dirección 0xFFFF. Dentro de cada bloque de 64KB debe existir un bloque
común (COMMON) para hacer posibles las llamadas a funciones que se encuentren en bancos
distintos.

Además de la elección del modelo de RAM, es posible utilizar un modelo globalmente y forzar que
ciertas variables y objetos residan en otros espacios de memoria.

4

Cada tipo de memoria tiene sus pros y sus contras. Aquí se ofrecen algunas recomendaciones para
hacer el mejor uso de los mismos.

DATA: 128 bytes; área utilizada por el modelo SMALL

• El mejor para: Datos a los que se accede con frecuencia, variables usadas por rutinas de
interrupción, variables de rutinas re-entrantes.
• El peor para: Arrays y estructuras de tamaño de medio a grande.

IDATA; No dependiente del modelo utilizado

• El mejor para: Acceso rápido a arrays y estructuras de tamaño medio (unos 32 bytes cada uno,
sin sobrepasar los 64 bytes). Ya que el acceso a este tipo de datos suele realizarse
indirectamente, mediante punteros, éste tipo de memoria es el mejor para los mismos. También
es un buen lugar para la pila, a la que siempre se accede indirectamente.
• El peor para: Grandes arrays de datos.

CODE: 64K bytes

• El mejor para: Constantes y grandes tablas, además de para el código del programa, ¡No
faltaba más!
• El peor para: ¡Variables!

PDATA: 256 bytes; área utilizada por el modelo COMPACT

• El mejor para: Accesos a datos que requieran una velocidad intermedia, así como a matrices y
estructuras de tamaño moderado.
• El peor para: Arrays y estructuras cuyo tamaño supere los 256 bytes. Datos a los que se
accede con mucha frecuencia, etc..

XDATA; área utilizada por el modelo LARGE

• El mejor para: Arrays y estructuras cuyo tamaño supere los 256 bytes. Variables a las que se
accede con poca frecuencia.
• El peor para: Datos a los que se accede con mucha frecuencia, etc..

Selección del modelo de memoria - Uso de #Pragma

La selección del tipo de memoria global se realiza incluyendo la línea #pragma SMALL (o
COMPACT o LARGE) como primera línea de un fichero C. El compilador C51 utiliza por omisión de
la directiva #pragma, el modelo SMALL. Este modelo puede utilizarse en casi el 100% de las
aplicaciones, si se tiene la precaución de forzar las variables de tamaño grande, y las variables a las
que se accede rara vez, en las áreas PDATA y XDATA.

Nota sobre el uso del modelo COMPACT
El modelo COMPACT hace ciertas suposiciones sobre el estado del puerto P2. El espacio XDATA
se direcciona mediante instrucciones MOVX que ponen los 16 bits del registro DPTR en los puertos
P2 y P0. El modelo COMPACT utiliza el registro R0 como un apuntador de 8 bits, cuyo contenido se
pone en el puerto P0 cuando se ejecuta la instrucción MOVX A,@R0. El puerto P2 queda bajo control
del usuario para el acceso paginado a la RAM externa. El compilador no tiene información sobre P2, y
a menos que se le asigne explícitamente un valor, su contenido será indefinido, aunque generalmente

5

será 0xFF. El linker tiene la tarea de combinar las variables XDATA y PDATA, y si no se le informa
adecuadamente, coloca el área PDATA en dirección 0. Por lo tanto el programa COMPACT no
funcionará.
Es por tanto esencial asignar a PPAGE en el fichero "startup.a51" el valor adecuado para P2, y poner
PPAGEENABLE a 1 para habilitar el modo paginado. La asignación del valor de PPAGE también
puede hacerse por medio del control PDATA(ADDR) al realizar la llamada al linker como en:
L51 module1.obj, module2.obj to exec.abs PDATA(0)XDATA(100H)
Notar que el área normal XDATA comienza ahora en 0x100, por encima de la página cero usada
para PDATA.

Especificación local del modelo de memoria.
C51 permite asignar modelos de memoria a funciones individuales. Dentro de un mismo módulo, las
funciones pueden declararse como SMALL, COMPACT o LARGE así:
#pragma COMPACT
/* Una función con modelo SMALL */
void fsmall(void) small {
printf("HELLO") ;
}
/* Una función con modelo LARGE */
void flarge(void) large {
printf("HELLO") ;
}
main() {
fsmall() ; // Llamada a función small.
flarge() ; // Llamada a función large.
}

Un aspecto a vigilar en proyectos multi-modelo
Supongamos que un programa C51 utiliza el modelo COMPACT para todas sus funciones excepto
para las funciones de interrupción, para las que se desea utilizar el modelo SMALL que resulta más
rápido. En estos casos, de no actuar correctamente, el linker puede emitir mensajes del tipo
MULTIPLE PUBLIC DEFINITION refiriéndose por ejemplo a la función putchar().
Ello se debe a que en los módulos compilados como COMPACT, C51 crea referencias a funciones
de la librería COMPACT, mientras que los módulos SMALL acceden a las funciones de la librería
SMALL. De esta forma el linker L51 puede encontarse con dos putchars() de distintas librerías.
La solución en este caso consiste en utilizar globalmente el modelo de memoria COMPACT y
seleccionar localmente un modelo diferente para ciertas funciones.
Ejemplo:
#pragma COMPACT
void fast_func(void) small{
/* código */
}

Declaración de constantes y variables
Constantes
Un requisito básico para la escritura de cualquier programa, es conocer la ubicación de los datos del
mismo. Las constantes son las más sencillas de ubicar, deben residir en el área de código (EPROM), o
como constantes en RAM, inicializadas en tiempo de ejecución, cuyo valor lógicamente no debe
cambiar mientras dure el programa.
El último caso es la situación habitual con los programas para PC generados con Microsoft C o
Borland C, sin embargo en las aplicaciones con el 8051, lo más adecuado es colocar las constantes en
ROM, con lo cual se ahorra espacio en RAM. Ejemplos de constantes en EPROM son:

6

unsigned char code temperat = 0x02 ;
unsigned char code tabla[5] = {'1','2','3','4''} ;
unsigned int code presión = 4 ;
Notar que const no significa code. Los objectos declarados const residirán en el área de memoria de
datos correspondiente al modelo de memoria utilizado.
Para colocar una tabla grande en el área CODE, la declaración debe ser:
unsigned char code TABLA_2[] = {
0x00,0x00,0x00,0x09,0x41,0x80,0xC0,0xFF,
0x00,0x00,0x13,0x1A,0x26,0x33,0x80,0xFF,
0x00,0x00,0x00,0x09,0x41,0x80,0x66,0x66,
0x00,0x00,0x00,0x09,0x41,0x80,0x66,0x66,
0x00,0x00,0x00,0x00,0x4D,0x63,0x66,0x66,
0x00,0x00,0x00,0x02,0x4D,0x63,0x66,0x66,
0x00,0x00,0x00,0x05,0x4A,0x46,0x40,0x40,
0x00,0x00,0x00,0x08,0x43,0x43,0x3D,0x3A,
0x00,0x00,0x00,0x00,0x2D,0x4D,0x56,0x4D,
0x00,0x00,0x00,0x00,0x21,0x56,0x6C,0x6F
} ;
Con objetos grandes como el de arriba es preciso controlar el espacio de memoria. En particular
cuando se trabaja con el modelo SMALL es muy fácil llenar toda la RAM interna con una sola tabla.
La definición de constantes en RAM puede realizarse así:
unsigned char factor_de_escala = 128 ;
unsigned int constante_de_fuel = 0xFD34 ;
En este caso es mejor hablar de variables inicializadas en lugar de constantes, ya que su valor puede
modificarse a lo largo del programa

Variables
Variables no inicializadas
La directiva '#pragma SMALL' determina el modelo de memoria global. En este caso, todas las
variables se colocan en RAM interna. Sin embargo, se puede forzar la residencia de algunas variables
en áreas específicas de memoria, como sigue:
#pragma SMALL
.
.
unsigned char xdata velocidad_motor ;
char xdata gran_array_de_variables[192] ;
Ahora la variable velocidad_motor se coloca en RAM externa. En el caso del array, no es posible
colocarlo en RAM interna, debido a que el tamaño máximo de la misma es de 128 bytes.
Otro ejemplo es:
.
#pragma LARGE
.
.
.
función(unsigned char data para1)
{
unsigned char data variable_local ;
.
.
.
}
Aquí, los parámetros de la función se colocan en RAM interna para reducir el tiempo de llamada a la
función. En caso de omitir la palabra 'data', los parámetros de la función residirían en XDATA, tal
como corresponde al modelo de memoria LARGE.

7

En este caso puede ser mejor declarar la función como SMALL, aunque en el resto del programa se
utilice el modelo LARGE. Esta técnica se utiliza para producir unas pocas funciones muy rápidas en
programas grandes obtenidos con el modelo LARGE.
Si el sistema dispone de RAM externa paginada en el puerto P0, la directiva apropiada es pdata.

Inicialización de Variables
El lenguaje C garantiza que en ausencia de una inicialización explícita, sólo las variables externas y
las estáticas toman valor inicial cero. Si se desea un valor distinto a cero, o se quiere forzar un valor
inicial para una variable que no sea externa, ni estática, es muy útil declarar e inicializar las variables
al mismo tiempo, tal como se muestra a continuación:
unsigned int velocidad_motor = 0x20 ;

función()
{
.
.
}
Aquí se escribe el valor 0x20 en la variable antes de que cualquier función tenga acceso a la misma.
Para lograrlo, el compilador reúne todos los valores iniciales de las variables en una tabla, y pasa el
control del programa al módulo "startup.obj", que copia los valores de la tabla en las direcciones
apropiadas de RAM, llamando seguidamente a la función main().
Es responsabilidad del usuario modificar el fichero en ensamblador "startup.a51" para informar al
compilador del tamaño y dirección inicial de la memoria RAM disponible en su sistema hardware. Si
se utiliza el modelo de memoria LARGE los parámetros a cambiar en "startup.a51" son:
XDATASTART y XDATALEN.

Variables en C51
Tipos de datos
Los tipos de datos admitidos por C51 son:
TIPO TAMAÑO RANGO DE VALORES
bit = 1 bit 0 ó 1
char = 8 bits -128 a +127
unsigned char = 8 bits 0 a 255
int = 16 bits -32768 a +32767
unsigned int = 16 bits 0 a 65535
long = 32 bits -2147483648 a +2147483647
unsigned long = 32 bits 0 a 4294967295
float = 32 bits +/-1.175494E-38 a +/-3.402823E+38
puntero = 24/16/8 bits Dirección de una variable

Son declaraciones típicas las siguientes:
unsigned char xdata tensión_batería ;
int idata factor_de_corrección ;
bit flag_1 ;
Para un procesador como el 8086, el tipo int es el más común, ya que al tratarse de un procesador de
16 bits, obtiene el máximo de eficiencia cuando trabaja con valores de 16 bits. Sin embargo, con el
8051, el tipo de dato a utilizar debe ser lógicamente el char. Por otro lado, ya que el 8051 no dispone
de instrucciones para la aritmética con signo, es conveniente trabajar, siempre que ello sea posible, con
tipos unsigned en lugar de con tipos signed. Si no se siguen estas reglas, los programas resultantes
tendrán mayor tamaño y funcionarán con mayor lentitud.
El µC Siemens 80C537 dispone de un co-procesador matemático integrado, que le permite realizar
instrucciones con números enteros y operaciones complejas como la división de un número de 32 bits,
entre un número de 16 bits. El compilador Keil C51 dispone de una librería específica para el 80C537
que saca partido de las características especiales de este procesador.

8

Bits de funciones especiales
El programador en lenguaje ensamblador del 8051, encuentra que el lenguaje ANSI C no le ofrece
facilidades para operar con los bits del área BDATA, y le obliga a trabajar con máscaras para
comprobar el estado de los bits. Sin embargo, el compilador C51 permite ubicar variables en el área de
RAM interna de acceso a nivel de bit y a nivel de byte, y manejar directamente desde C las
instrucciones de manipulación de bits del 8051.
Veamos como ejemplo la comprobación del bit de signo de un char.
En primer lugar, se fuerza la residencia del char en el área "bdata":
char bdata test ;
el bit de signo se define como sigue:

sbit signo = test ^ 7 ;

Y se usa así:

void main(void) {
test = -1 ;
if(test & 0x80) { //Comprobación convencional con máscara&
test = 1 ; //tratamiento si número negativo
}
if(signo == 1) { //Uso del bit de signo
test = 1 ; //tratamiento si número negativo
}
}

Resultado en ensamblador:

RSEG ?BA?T2
test: DS 1
signo EQU (test+0).7

; void main(void) {

main:
; test = -1 ;
MOV test,#0FFH
; if(test & 0x80) {//Comprobación convencional con máscara&
MOV A,test
JNB ACC.7,?C0001
; test = 1 ; // tratamiento si número negativo
MOV test,#01H
; }
?C0001:
; if(signo == 1) { // Uso del bit de signo
JNB signo,?C0003
; test = 1 ; // tratamiento si número negativo
MOV test,#01H
; }
; }
?C0003:
RET
La definición del bit de signo mediante la extensión sbit, hace que el compilador utilice la
instrucción JNB, lo cual proporciona mayor rapidez que el uso de máscaras &.
En en supuesto que se desee comprobar el signo de un valor int, se debe tener en cuenta que el el
8051 almacena el byte alto en la dirección de memoria más baja. Por ello, el bit 7 es el bit de mayor
peso del byte alto, mientras que el bit 15 es el bit de mayor peso del byte bajo de la variable int.

Conversión entre tipos

Una de las principales fuentes de error en C, consiste en ignorar las implicaciones de los tipos de
datos en los cálculos y comparaciones. En el siguiente ejemplo:

9

unsigned char x, y, z ;

x = 10 ;
y = 5 ;
z = x * y ;

El resultado es z = 50

Sin embargo:
x = 10 ;
y = 50 ;
z = x * y ;

hace que z = 244. La solución verdadera 500 (0x1F4) no se logra, debido a que z no puede
almacenarla. La solución consiste en hacer que z sea un unsigned int. Sin embargo, siempre es una
buena idea hacer explícito el forzado de tipo (casting) de los operandos unsigned char a int así:

unsigned char x, y, z ;

z = (unsigned int) x * (unsigned int) y ;

Aunque C51 promueve automáticamente los char a int, lo mejor es no confiar en ello, ya que en un
pequeño microcontrolador siempre hay que cuidar el tamaño exacto de los datos.

Una solución no-ANSI para la comprobación de valores
Una situación muy corriente se produce cuando se suman dos bytes y se limita el resultado máximo
de la suma al valor 255. Ya se ha comentado que con el 8051, si se desea conseguir la máxima
velocidad conviene evitar el uso de variables int. Por otro lado, si la suma de los dos bytes supera el
valor 255, es necesario utilizar enteros.
Seguidamente se presentan dos ejemplos. En el primero se utiliza un enfoque ANSI, y puede verse el
buen trabajo realizado por el compilador C51. En el segundo ejemplo, mucho más rápido se emplea
una solución no ANSI:
; #include <reg51.h>
; unsigned char x, y, z ;
;
; /***Sumar dos bytes y comprobar resultado supera el valor 255***/
;
; void main(void) {

RSEG ?PR?main?T2
USING 0
main:
; if(((unsigned int)x + (unsigned int)y) > 0xff)
MOV A,x
ADD A,y
MOV R7,A
CLR A
RLC A
MOV R6,A
SETB C
MOV A,R7
SUBB A,#0FFH
MOV A,R6
SUBB A,#00H
JC ?C0002
; z = 0xff ; // versión ANSI C
MOV z,#0FFH
; }
?C0002:
RET

10

En este segundo ejemplo, se comprueba el valor del flag de acarreo CY, eliminando la necesidad de
realizar operaciones con enteros, ya que si el resultado supera el valor 255, el bit CY toma valor 1. Por
supuesto, se trata de una solución no conforme al estándar ANSI C.
; #include <reg51.h>
;
; unsigned char x, y, z ;
;
; /*** Sumar dos bytes y comprobar si el resultado supera el valor 255 ***/
; void main(void) {
main:
; z = x + y;
MOV A,x
ADD A,y
MOV z,A
; if (CY == 1)
JNB CY,?C0002
; z = 0xff ; // Solución con el flag CY del 8051
MOV z,#0FFH
; }
?C0002:
RET

Si se suman dos enteros y se desea comparar si el resultado supera el valor 65535 (0xffff), la
situación se complica ya que hay que utilizar valores long, que ocupan 32 bits. Aún en este caso, se
puede comprobar el valor del bit CY después de realizar la suma de los bytes altos de los dos enteros.
En sistemas de altas prestaciones con el 8051, la pérdida de portabilidad puede tolerarse.
Desafortunadamente la portabilidad de los programas siempre compromete las prestaciones de los
mismos.

Reparto de tareas
Aplicaciones con el 8051
Muchas personas han empezado a programar utilizando el lenguaje BASIC en un PC o máquina
similar. Los programas que realizan inicialmente no suelen ser muy complicados. Empiezan a correr
cuando se teclea "RUN" y terminan en un END o STOP. Mientras tanto, el PC se dedica totalmente a
la ejecución del típico programa "HELLO WORLD". Cuando el programa termina, se retorna al
editor BASIC, o al entorno de trabajo utilizado.
La experiencia es muy buena y el nuevo programador cree que ya sabe programar. Sin embargo,
cuando se escribe un programa para un microcontrolador como el 8051, el problema del comienzo y
final del programa se presenta rápidamente. Típicamente, el software de un sistema basado en el 8051
está formado por múltiples programas individuales, que ejecutados conjuntamente, contribuyen a la
consecución del objetivo final. Entonces, un problema fundamental es asegurarse de que todas las
partes del programa se ejecutan.

Sistemas sencillos con el 8051
El enfoque más sencillo es llamar a cada una de las sub-funciones del programa de una forma
secuencial, de tal forma que después de un cierto tiempo, cada parte se habrá ejecutado el mismo
número de veces. Esto constituye el bucle de fondo (background loop), o programa principal. En
primer plano (foreground) aparecen las funciones de interrupción, iniciadas por sucesos producidos en
tiempo real, tales como señales de entrada o desbordamiento de temporizadores.
El intercambio de datos entre las interrupciones y el programa principal se realiza usualmente a
través de variables globales y flags. Este tipo de programas puede funcionar correctamente si se tiene
cuidado en el orden y frecuencia de ejecución de cada sección.
Las funciones llamadas por el programa principal deben escribirse de tal forma que en cada llamada
se ejecute una sección particular de su código. Así al entrar en esta función, se toma la decisión de la

11

tarea que le toca ejecutar, se ejecuta esa parte y se sale de la función, cambiando posiblemente algunos
flags que indicarán la tarea a realizar en la siguiente llamada. De esta forma, cada bloque funcional
debe mantener su propio sistema de control que asegure la ejecución del código adecuado en cada
entrada al mismo.
En un sistema de este tipo, todos los bloques funcionales tienen la misma importancia, y no se entra
en un nuevo bloque hasta que no le toque su turno dentro del programa principal. Sólo las rutinas de
interrupción pueden romper este orden, aunque también están sujetas a un sistema de prioridades. Si
un bloque necesita una cierta señal de entrada, o se queda a la espera de la misma impidiendo que
otros bloques puedan ejecutarse, o cede el control hasta que le vuelva a tocar su turno dentro del bucle
principal. En este último caso se corre el riesgo de que el suceso esperado se produzca y no tenga una
respuesta, o que la respuesta llegue demasiado tarde. No obstante, los sistemas de este tipo funcionan
bien en programas en las que no hay secciones que tengan exigencias críticas en los tiempos de
respuesta.
Los llamados sistemas en tiempo real no son de este tipo. Típicamente contienen código cuya
ejecución origina o es originada por sucesos del mundo real, que trabajan con datos procedentes de
otras partes del sistema, cuyas entradas pueden cambiar lenta o rápidamente.
El código que contribuye en mayor medida a la funcionalidad del sistema, debe tener precedencia
sobre las secciones cuyos objetivos no son críticos respecto al objetivo final. Sin embargo, muchas de
las aplicaciones con el 8051 tienen partes con grandes exigencias de tiempo de respuesta, que suelen
estar asociadas a interrupciones. La necesidad de atender a las interrupciones tan rápido como sea
posible, requiere que el tiempo de ejecución de las mismas sea muy corto, ya que el sistema dejará de
funcionar si el tiempo de respuesta a cada interrupción supera al intervalo de tiempo en la que las
interrupciones se producen.
Por regla general se consigue un nivel aceptable de prestaciones si las funciones complejas se llevan
al programa principal, y se reservan las interrupciones para las secciones con exigencias de tiempo
críticas. En cualquier caso, aparece el problema de la comunicación entre el programa principal y las
rutinas de interrupción.
Este sencillo sistema de reparto de tareas trata a todas ellas de igual forma. Cuando la CPU se
encuentra muy cargada de trabajo por tener que atender a entradas que cambian con rapidez, puede
ocurrir que el programa principal no corra con la suficiente frecuencia y la respuesta transitoria del
mismo se degrade.

Reparto de tareas simple - Una solución parcial
Los problemas de los sistemas de bucle simple pueden solucionarse parcialmente, controlando el
orden y la frecuencia de las llamadas a funciones. Una posible solución pasa por asignar una prioridad
a cada función y establecer un mecanismo que permita a cada función especificar la siguiente función
a ejecutar. Las funciones de interrupción no deben seguir este orden y deben ser atendidas con rapidez.
Los sistemas de este tipo pueden resultar útiles, si el tiempo de ejecución de las funciones no es
excesivo.
Una solución alternativa consiste en utilizar un temporizador, que asigne un tiempo de ejecución a
cada trabajo a realizar. Cada vez que el tiempo asignado se supere, la tarea en curso se suspende y
comienza otra tarea.
Desafortunadamente todas estas posibilidades suelen intentarse tarde, cuando los tiempos de
respuesta se alargan en exceso. En estos casos, lo que había sido un programa bien estructurado
termina degenerando en código spaghetti, plagado de ajustes y modos especiales, tendentes a superar
las diferencias entre las demandas de los sucesos del mundo real, y la respuesta del sistema. En
muchos casos, los mecanismos de control de las funciones llamadas generan una sobrecarga que
acentúa aún más el desfase entre las exigencias y la respuesta.
La realidad es que los sucesos del mundo real no siguen ningún orden ni pueden predecirse. Algunos
trabajos son más importantes que otros, pero el mundo real produce sucesos a los que hay que
responder inmediatamente.

12

Un enfoque práctico
Si no se recurre a un sistema operativo en tiempo real como RTX51, ¿Qué se puede hacer?
Un mecanismo sencillo para controlar el programa principal, puede ser una sentencia switch, con la
variable switch controlada por algún suceso externo en tiempo real. Idealmente, éste debe ser la rutina
de interrupción de mayor prioridad. Las tareas del programa principal con mayor prioridad se colocan
en los case de menor valor numérico, y las de menor prioridad en los case con mayor valor numérico.
Cada vez que se ejecuta una tarea, se incrementa la variable switch, permitiendo que se ejecuten las
tareas de menor prioridad. Si se produce la interrupción, se asigna a la variable switch el valor
correspondiente a la tarea de mayor prioridad. Pero si la interrupción tarda bastante en producirse
nuevamente, la variable switch permitirá la ejecución de la tarea de menor prioridad, para después
comenzar automáticamente con la de mayor prioridad.
Si la interrupción se produce en el case de nivel 2, la variable switch se pone a 0 y así
sucesivamente. En este caso las tareas de menor prioridad se ignoran. El sistema no es obviamente
ideal, ya que solo la tarea de mayor nivel se ejecuta con la suficiente frecuencia. Sin embargo, bajo
condiciones normales puede ser una forma útil de asegurar que las tareas de baja prioridad no se
ejecuten con mucha frecuencia. Por ejemplo, no tiene mucho sentido medir la temperatura ambiente
más de una vez cada segundo. En un sistema de este tipo, la tarea encargada de medir la temperatura
ambiente estaría situada a nivel 100, en el sistema de reparto de tareas.
Este método falla cuando una tarea de baja prioridad tiene un tiempo de ejecución muy largo.
Incluso si se produce la interrupción que exige que el bucle regrese a la tarea de mayor prioridad, el
salto a la misma no se producirá mientras no termine la tarea en curso. Para que se produzca la
situación deseada se necesita de un mecanismo de rebanado de tiempo (time-slice).
Un truco útil consiste en utilizar una interrupción libre para garantizar que la tarea de alta prioridad
se ejecute a tiempo. Para ello se asigna la tarea de alta prioridad a la rutina de servicio de la
interrupción libre o sobrante. Así cuando se produzca la interrupción en tiempo real, y justo antes de
salir de la rutina de servicio de la misma, se pondrá a uno el flag de petición de la interrupción libre,
con lo cual, tras el RETI comenzará la ejecución de la tarea de alta prioridad. Por supuesto, la
interrupción libre debe ser de baja prioridad.
Hay que tener en cuenta que en estos casos el factor más importante es conseguir el menor tiempo de
ejecución posible, y particularmente en las rutinas de interrupción. Ello significa que se debe hacer un
uso completo de las extensiones de C51, tales como los punteros específicos, los bits de funciones
especiales y las variables locales de tipo register.

Extensiones del leguaje C para 8051
Introducción
La programación del 8051 trata principalmente con accesos a dispositivos reales en direcciones
específicas, además de proporcionar servicio a las interrupciones. C51 dispone de muchas extensiones
al lenguaje C, con el fin de conseguir una eficiencia del código próxima a la del lenguaje ensamblador
del 8051. Los aspectos centrales de estas extensiones se tratan seguidamente.

Acceso a periféricos internos del 8051
En las aplicaciones de control típicas con mucha frecuencia se producen operaciones tales como:
lectura y escritura de datos en un puerto, asignación de valor a los registros de un timer, lectura de
valores de registros captura, etc. El compilador C51 dispone de tipos de datos especiales como sfr y
sbit, para realizar estas operaciones sin necesidad de acudir al lenguaje ensamblador.
Algunas declaraciones típicas son:
sfr P0 = 0x80;

13

sfr P1 = 0x90;
sfr ADCON = 0xC5;
sbit EA = 0xAF;

Muchas de estas declaraciones residen en ficheros cabecera tales como reg51.h en el caso del 8051,
o en reg552.h para el 80C552. Son precisamente estas declaraciones las que adaptan el compilador a
un derivado del 8051. Con ellas, el acceso a los sfr resulta muy sencillo:
{
ADCON = 0x08 ; /* Escritura de un dato en un registro */
P1 = 0xFF ; /* Escritura de un dato en un puerto */
io_estado = P0 ; /* Lectura del estado de un puerto */
EA = 1 ; /* Poner a 1 un bit (enable all interrupts) */
}
No todos los registros especiales de un microcontrolador son direccionables a nivel bit. La regla es
que sólo los sfr cuya dirección es divisible por 8 son direccionables a nivel bit. Si ello no sucede, el
acceso a un bit debe hacerse mediante instrucciones de byte y utilizando máscaras.
Consultar el manual de usuario del procesador para verificar si un sfr es direccionable a nivel de
bit.

Interrupciones
Las interrupciones juegan un papel importante en muchas aplicaciones del 8051. Cuando se atiende
a una interrupción se debe tener en cuenta diversos factores:

• Para cada interrupción debe generarse un vector, que dirija al procesador a la rutina de servicio
apropiada. El compilador C51 realiza este trabajo de forma automática.
• Las variables locales de la rutina de servicio de la interrupción no deben compartirse con las
variables locales del programa principal.
• Las rutinas de servicio a las interrupciones no deben modificar ningún registro ni variable que
sea utilizado por el programa principal.
• Las rutinas de servicio a las interrupciones deben ser lo más cortas posibles.

Funciones de interrupción
Para definir una función de interrupción en C, se utiliza un tipo especial interrupt:
timer0_int() interrupt 1 using 2
{
unsigned char temp1;
unsigned char temp2;
siguen las sentencias C ejecutables;
}

En primer lugar, para cada función de interrupción se genera un vector en la dirección de memoria
de código (8*n+3), donde n es el argumento de interrupt (n=1 en el ejemplo anterior). En este caso en
la dirección 0BH de memoria de código, el compilador C51 coloca un "LJMP timer0_int". Además el
linker se ocupa de no solapar las variables locales de la función de interrupción, con las variables
locales del programa principal.
En la siguiente tabla se muestran todas las interrupciones del Cynal 8051. La n se corresponde con el
“Priority Order”.

14

Las funciones de interrupción no son llamadas por el usuario, se llaman de forma automática cuando
se produce la interrupción. Por ello estas funciones no reciben parámetros ni devuelven valores. El
compilador se encarga de guardar en la pila los registros que utilice la función de interrupción, en
cuanto se entra en ella. También se ocupa de sacar de la pila los valores guardados, justo antes de salir
de la función. Además C51 hace que las funciones de interrupción terminen en un RETI, en lugar del
RET con el que terminan las funciones normales.

El control using
El control using n ordena al compilador que utilice el banco de registros n. El compilador C51 hace
un uso intensivo de los registros R0...R7 del 8051. Normalmente se utiliza el banco de registros 0. Sin
embargo, como puede apreciarse en la sección 5.2.1. se puede hacer que una función de interrupción
utilice otro banco de registros diferente al utilizado por el programa principal. De esta forma el tiempo
utilizado por las interrupciones se reduce, ya que no necesita empilar y desempilar los registros cada
vez que se atienden.
Dos interrupciones de la misma prioridad pueden utilizar el mismo banco de registros debido a que
no es posible que una de ellas interrumpa a la otra.

15

Si el tiempo de ejecución de las funciones de interrupción no es crítico, puede omitirse el uso del
control using, en este caso C51 examina los registros que utiliza la interrupción, los guarda en la pila
al entrar y los saca de la pila al salir. Esto lógicamente aumenta el tiempo utilizado por las funciones
de interrupción.

Interrupts, USING, Registerbanks, NOAREGS en C51

Las interrupciones juegan un papel importante en la mayoría de las aplicaciones del 8051, y
afortunadamente C51 permite escribir las funciones de interrupción enteramente en C. Aunque es
perfectamente posible escribir código que funcione, respetando el estándar ANSI C, si se quiere
mejorar la eficacia del código es conveniente comprender la utilidad de los siguientes controles:

• INTERRUPT
• USING
• NOAREGS
• RE-ENTRANT
• REGISTERBANK

El atributo básico de las funciones de interrupción
Para que una función de interrupción pueda ser alcanzada es necesario generar el vector de
interrupción adecuado. El compilador C51 lo hace de forma automática, basándose en el argumento de
la palabra interrupt. Posteriormente, el linker impide que las variables locales de las funciones de
interrupción se solapen con las del programa principal, creando secciones especiales en RAM.
Ejemplo:
/* Rutina de atención a la interrupción por desbordamiento del Timer 0*/

timer0_int() interrupt 1
{
unsigned char temp1 ;

/* Sentencias C ejecutables ; */
}

• La palabra interrupt n genera un vector de interrupción en la dirección (8*n+3). En este caso
se coloca un "LJMP timer0_int" en la dirección 0BH de memoria de código.
• Las variables locales declaradas en la función no se solapan con las variables del programa
principal (trabajo del linker).
• El compilador añade el código necesario para empilar los registros utilizados (ACC, B, DPTR,
PSW, R0-R7) a comienzo de la función.
• Al salir de la función se desempilan los registros anteriores y se inserta un RETI en lugar de
un RET.

El truco del direccionamiento absoluto de registros en detalle

El 8051 no dispone de la instrucción MOV Reg,Reg, por ello Keil utiliza el truco de considerar un
registro como una dirección data absoluta:

Simulación de la instrucción MOV Reg,Reg:

En el banco de registros 0 - MOV R0,AR7, es idéntica a - MOV R0,07H.

16

Este truco solo puede utilizarse cuando el compilador conoce el banco de registros que se está
utilizando. Cuando se utiliza el control USING, pueden surgir problemas. Véanse las siguientes
secciones...

El control USING
El control using n ordena al compilador que utilice el banco de registros n. De esta forma las rutinas
de interrupción con exigencias de tiempo muy críticas pueden cambiar de "contexto", con mayor
rapidez que empilando los registros. Además las funciones de interrupción de igual prioridad pueden
compartir el mismo banco de registros, al no existir el riesgo de que se interrumpan entre ellas.
Direcciones de base de los bancos de registros del 8051
Los registros R0...R7 ocupan direcciones consecutivas en la RAM interna del 8051, siendo la
dirección base, o dirección correspondiente al registro R0, variable en función del banco de registros
que se encuentre activo. Así la dirección base puede ser: 0x00, 0x08, 0x10, o 0x18 según que el banco
de registros activo sea el: 0, 1, 2, o 3.
Si a una función de interrupción se le añade el control "USING 1", se sustituye el empilado de los
registros por la instrucción "MOV PSW,#08H" que conmuta el banco de registros. El tiempo de
entrada a la interrupción disminuye considerablemente, pero puede fallar el direccionamiento absoluto
de registros si no se tiene cuidado. Si la función de interrupción no hace uso de registros, y no llama a
ninguna otra función, el optimizador elimina el código de banco de registros.

Notas sobre llamadas a funciones desde las interrupciones
C51 utiliza un cierto grado de inteligencia al entrar en las funciones de interrupción. Además de
sustituir el RET del final de la función por un RETI, automáticamente empila los registros que utilice
la función.
Sin embargo, hay algunos aspectos a considerar:

• Si la función de interrupción llama a cualquier función, C51 empila todos los registros Ri,
independientemente de que sea necesario o no. El tiempo utilizado por los 8 PUSH y los 8 POP
es de 32 µs a 12 MHz, que puede ser inaceptable en algunos casos. Por lo tanto, o se evita la
llamada a funciones o se utiliza el control USING. Puesto que al empilar los 8 registros se
utilizan 8 posiciones de RAM interna, y el cambio de banco de registros utiliza también 8
posiciones de RAM interna, no existe diferencia en cuanto al uso de RAM.
• Las variables declaradas dentro de una función de interrupción no deben solaparse con las
variables del programa principal, ni con las utilizadas por otras interrupciones.
• Nunca se debe llamar a una función de interrupción desde el programa principal. A veces ello
resulta tentador, sobre todo en la fase de inicialización de un programa. Esto puede producir
confusión en el linker, con lo que podrían sobre-escribirse las variables del programa principal.
• Si las funciones llamadas por una función de interrupción utilizan menos de 8 registros, el uso
del control USING utiliza más RAM que si se empilaran los registros. Ello sin embargo no es
razón suficiente para evitar el uso del control USING.
• Las interrupciones de la misma prioridad pueden utilizar el mismo banco de registros, ya que
no es posible que se interrumpan entre ellas mismas.

Cuando usar el control USING

• En interrupciones en las que el tiempo de respuesta es más importante que la cantidad de RAM
utilizada.
• En las interrupciones que llaman a otras funciones.

17

El #pragma NOAREGS
Direccionamiento absoluto de registros con C51.
Ya se ha comentado que el 8051 no dispone de la instrucción MOV Reg,Reg, por lo que C51 utiliza
MOV R1,AR7 donde AR7 es la dirección absoluta del registro R7 en uso. Para que la sustitución
funcione correctamente el compilador debe conocer el banco de registros que está utilizando. Si una
función se llama desde una interrupción que utiliza el control USING, hay dos posibilidades:

• No usar direccionamiento absoluto de registros, poniendo #pragma NOAREGS antes de la
función, y #pragma RESTORE o #pragma AREGS después de la función.
• Indicar a C51 el banco de registros apropiado con #pragma REGISTERBANK(n).

Las funciones compiladas con NOAREGS sirven siempre, independientemente del banco de
registros que se utilice, aunque pueden ser más lentas que las que utilicen un banco de registros
definido.

El control REGISTERBANK como alternativa a NOAREGS
El control #pragma REGISTERBANK(n) informa a C51 sobre el banco de registros utilizado,
haciendo posible el direccionamiento absoluto de registros.

EJEMPLO:
/* Rutina de atención a la interrupción por desbordamiento del Timer 0 */
timer0_int() interrupt 1 USING 1 {
/* Sentencias C ejecutables ; */
}

Función llamada por timer0_int:
#pragma SAVE // Recuerda el banco de registros actual
#pragma REGISTERBANK(1) // Informa a C51 sobre el nuevo banco de registros
void sys_interp(char x) {// Función llamada desde interrupción con "using 1"
/* Código */
}
#pragma RESTORE // Repone el banco de registros original

Al utilizar #pragma REGISTERBANK(1) con sys_interp() se restaura el direccionamiento absoluto
de registros ya que C51 conoce el banco de registros utilizado.
Nota: Utilícese siempre el control REGISTERBANK(n) para las funciones llamadas desde
interrupciones con USING n.
Código de entrada de sys_interp() con REGISTERBANK(n)
; unsigned char sys_interp(unsigned char x_value,
RSEG ?PR?_sys_interp?INTERP
USING 1
_sys_interp:
MOV y_value?10,R5
MOV map_base?10,R2
MOV map_base?10+01H,R3;--
Variable 'x_value?10' assigned to Register 'R1' --
MOV R1,AR7

Resumen de USING y REGISTERBANK

Expresado en pseudo-código

18

if(interrupt routine = USING 1){
las funciones llamadas desde aquí deben usar #pragma REGISTERBANK(1)
}

Nota: las funciones llamadas por la interrupción, sólo pueden llamadas desde funciones que utilicen el
banco de registros 1.

Reglas generales a seguir
Las siguientes reglas permiten que el compilador haga el mejor uso de los recursos del procesador.
En general, la aproximación a C desde el punto de vista del programador en ensamblador no es dañina
en absoluto.
Regla 1
Utilizar siempre que sea posible variables de 8 bit. El 8051 es una máquina de 8 bits que procesa los
char con mayor eficacia que los int.
Regla 2
Utilizar siempre que sea posible variables unsigned. El 8051 no tiene instrucciones para las
operaciones aritméticas con signo, por lo cual las operaciones con signo siempre añaden más
instrucciones del 8051.
Regla 3
Procurar eliminar las divisiones salvo que sean entre números de 8 bits. El 8051 tiene una sola
instrucción para dividir dos números de 8 bits. Dividir números de 32 bits entre números de 16 bits
puede resultar muy lento, salvo que se utilice un 80C537.
Regla 4
Evitar el uso de estructuras de bit que producen código lento e ineficaz. En su lugar declarar bits
individualmente, utilizando la clase de almacenamiento "bit".
Regla 5
El estándar ANSI dice que el producto de dos cantidades de 8 bits (char) es también un char. En
consecuencia, cualquier unsigned char que al ser multiplicado pueda producir un resultado superior a
255 debe declararse como unsigned int.
Pero tal como señala la regla 15.1 no debe utilizarse un int, cuando pueda servir un char. La solución
es convertir temporalmente (cast) el char a int. En el siguiente ejemplo el producto potencialmente
puede tener 16 bits, pero el resultado es siempre de 8 bits. El cast o forzado de tipo "(unsigned int)"
asegura que el C51 realice una multiplicación de 16 bits.
{
unsigned char z ;
unsigned char x ;
unsigned char y ;
z = ((unsigned int) y * (unsigned int) x) >> 8 ;
}
Aquí se multiplican dos números de 8 bits, y el resultado se divide entre 256. El resultado intermedio
tiene 16 bits debido a que los números x e y, han sido cargados por la rutina de multiplicación de la
librería como ints.
Regla 6
Los cálculos con operandos enteros que, debido a un cuidadoso escalado, siempre producen
resultados de 8 bits siempre funcionarán. En:
unsigned int x, y ;
unsigned char z ;
z = x*y/256 ;
C51 igualará z al byte de dirección más alta (menos significativo) del resultado entero. Este
resultado es independiente de la máquina utilizada, ya que viene impuesto por el estándar ANSI. En

19

este caso C51 accede al byte menos significativo directamente, ahorrando código, ya que la división
no se realiza.

Números en coma flotante
En las operaciones con números en coma flotante, un operando siempre se mete en la pila aritmética
de RAM interna. En el modelo SMALL se usa la pila del 8051, pero en los otros modelos se crea un
segmento fijo en la primera dirección disponible por encima del área del banco de registros. En las
aplicaciones en las que sea necesario ahorrar espacio en RAM interna, no debería utilizarse
matemática de coma flotante. La coma fija es una alternativa más real.

Conclusión
Lo visto en este curso habrá proporcionado una ligera idea de cómo el compilador C51 puede
utilizarse en el desarrollo de programas reales. Su gran ventaja es que elimina la necesidad de ser un
experto en ensamblador del 8051 para producir programas eficaces.
Realmente, C51 puede considerarse como un lenguaje universal de nivel entre medio y bajo, al que
pueden acceder fácilmente tanto los programadores en ensamblador, como los programadores en
lenguaje C. Facilita el acceso a los periféricos internos y externos del 8051, haciendo innecesario la
escritura en ensamblador de drivers para dispositivos periféricos.
Permite construir programas bien estructurados evitando los goto y los LJMP. De hecho, la mayor
parte del código extra generado por C51 se emplea en asegurar una buena estructura para los
programas, y no en un uso ineficiente del set de instrucciones del 8051.
Ofrece verdadera portabilidad desde el 8051 hacia otros procesadores, y a la inversa. Así las
funciones existentes puede re-utilizarse, lo cual contribuye a reducir el tiempo de desarrollo de las
aplicaciones.

20

Programacion c microcontroladores

Más contenido relacionado

La actualidad más candente (17)

Similar a Programacion c microcontroladores (20)

Programacion c microcontroladores