Este documento describe variables y constantes en lenguaje C para PICs. Las variables son números que cambian de valor durante la ejecución del programa, mientras que las constantes son valores fijos que no cambian. Tanto las variables como las constantes deben declararse antes de usarse, indicando su tipo. Las constantes se almacenan en memoria flash para ahorrar espacio en RAM.

1. Lenguaje C para PICs
Variables y Constantes

2. VARIABLES
• Cualquier número que cambia su valor
durante la operación del programa se llama
variable.
• Si un programa suma dos numeros (NUM1 +
NUM2), es necesario tener un valor que
represente lo que en la vida diaria se
denomina SUMA.
• En éste caso NUM1, NUM2 y SUMA son
variables.

3. Declarando Variables
• Un nombre de variable puede incluir cualquier caracter
alfabetico A – Z (a – z), los digitos 0 – 9 y el caracter guion
bajo “_”.
• El compilador es sensitivo por lo que diferencia las
mayúsculas de las minúsculas.
• Los nombres de funciones y variables generalmente
contienen letras minúsculas, mientras que los nombres de
constantes contienen letras mayúsculas.
• Los nombres de variables no deben comenzar con dígitos.
• Nombres reservados para el compilador (key words) no
deben usarse como variables.
• El compilador microC reconoce “key words” siguientes.

5. Declaración de Variables
 Cada variable debe ser declarada antes de ser utilizada en el programa.
 Como las variables se almacenan en la memoria RAM, es necesario
reservar el espacio para ellas (uno, dos o más bytes).
 Al escribir un programa, usted sabe qué tipo de datos quiere utilizar y qué
tipo de datos espera como resultado de una operación, mientras que el
compilador no lo sabe.
 No se olvide de que el programa maneja las variables con los nombres
asignados. El compilador las reconoce como números en la memoria RAM
sin conocer su tamaño y formato.
 Para mejorar la legibilidad de código, las variables se declaran con
frecuencia al principio de las funciones:
 <tipo> variable;
 Es posible declarar más de una variable de una vez si tienen el mismo tipo.
 <tipo> variable1, variable2, variable3;

6. Declaración de Variables
 Aparte del nombre y del tipo, a las variables se les asignan con frecuencia los valores
iniciales justamente enseguida de su declaración. Esto no es un paso obligatorio, sino
‘una cuestión de buenas costumbres’. Se parece a lo siguiente:
 unsigned int peso; // Declarar una variable llamada peso
 peso = 20; // Asignar el valor 20 a la variable peso
 Un método más rápido se le denomina declaración con inicialización (asignación de los
valores iniciales):
 unsigned int peso = 20; // peso está declarado y su valor es 20
 Si hay varias variables con el mismo valor inicial asignado, el proceso se puede
simplificar:
 unsigned int peso1 = peso2 = peso3 = 20;
 Tenga cuidado de no declarar la misma variable otra vez dentro de la misma función.
 Puede modificar el contenido de una variable al asignarle un nuevo valor tantas veces
que quiera
 Al declarar una variable, siempre piense en los valores que la variable tendrá que
contener durante la ejecución de programa. En el ejemplo anterior, peso1 no se puede
representar con un número con punto decimal o un número con valor negativo.

7. Más sobre variables
• char var1; // variable var1 es un byte de
//valores positivos.
En este caso si no se antepone prefijo por defecto
es tipo sin signo.
• signed char var2; // variable var2 es byte con
//signo (positivo o negativo).
• Si por olvido no se declara el tipo de la variable,
entonces el compilador automáticamente lo
considera entero con signo. Esto significa que la
variable ocupará dos bytes en memoria, con
valores en el rango -32768 a +32767.

8. CONSTANTES
Una constante o caracter es un valor fijo que
no cambia durante la ejecución del programa.
A diferencia de las variables, las constantes se
almacenan en la memoria de programa (flash)
con la finalidad de ahorrar espacio valioso en
la memoria RAM.
El compilador las reconoce por su nombre y
por el prefijo const.

9. Declaración de Constantes
 Similar a las variables, las constantes deben ser declaradas antes de ser
utilizadas en el programa.
 En mikroC, no es obligatorio especificar el tipo de constante al declararla.
 Por otra parte, las constantes deben ser inicializadas a la vez que se
declaran.
 El compilador reconoce las constantes por su prefijo const utilizado en la
declaración. Las dos siguientes declaraciones son equivalentes:
 const int MINIMUM = -100; // Declarar constante MINIMUM
 const MINIMUM = -100; // Declarar constante MINIMUM
 Las constantes pueden ser de cualquier tipo, incluyendo cadenas:
 const T_MAX = 3.260E1; // constante de punto flotante T_MAX
 const I_CLASS = 'A'; // constante carácter I_CLASS
 const Mensaje = "Presione el botón IZQUIERDA"; // constante de cadena
Mensaje

10. CONSTANTES ENTERAS
• Las constantes enteras pueden ser: decimales,
hexadecimales, octales o binarias.
• El compilador reconoce su formato basándose en un
prefijo.
• Si el número no tiene prefijo, se lo considera decimal por
defecto. El tipo de una constante es automáticamente
reconocido por su tamaño.
• En el siguiente ejemplo la constante MINIMUM sera
automaticámente considerada un entero con signo y
almacenada en dos bytes (16 bits) de memoria flash.
• const MINIMUM = -100; // declara constante MINIMUM

11. CONSTANTES ENTERAS

12. Constantes de Punto Flotante
 Las constantes de punto flotante consisten de
una parte entera, de punto, una parte
fraccionaria y una e ó E opcional seguido de un
exponente entero con signo.
const float T_MAX = 32.60; // declara
temperature //T_MAX
const float T_MAX = 3.260E1; // declara la misma
//constante
En ambos casos se declara una constante T_MAX
que tiene el valor 32.60.

13. Constantes “Character” (ASCII)
Una constante “character” es un caracter
encerrado entre apóstrofes.
const I_CLASS = 'A'; // declara constant e
//I_CLASS
const II_CLASS = 'B'; // declara constante
//II_CLASS
Ejecutando comandos que transfieran estas
constantes a una pantalla LCD, se visualizará el
carácter A y B respectivamente.

14. Constantes tipo “string”
 Es una constante que consiste en una cadena de
caracteres.
 Las constantes string se encierran entre comillas.
 const Mensage_1 = “Aprete botón de Inicio”; // Mensage
1 para LCD
 const Mensage_2 = “Aprete boton derecho”; // Mensage 2
para LCD
 const Mensage_3 = “Aprete boton izquierdo”; // Mensage
3 para LCD
 En este ejemplo, enviando la constante Mensaje_1 a la
pantalla LCD, se visualiza el mensaje “Aprete botón Inicio”.

15. Constantes Enumeradas
 Las constantes de enumeración son un tipo especial de constantes enteras que
hace un programa más comprensible al asignar los números ordinales a las
constantes. Por defecto, el valor 0 se asigna automáticamente a la primera
constante entre llaves, el valor 1 a la segunda, el valor 2 a la tercera etc.
 enum surtidores {AGUA,GASÓLEO,CLORO}; // AGUA = 0;GASÓLEO= 1;CLORO = 2
 Es posible introducir directamente el valor de una constante dentro de la lista
de enumeraciones. El incremento se detiene al asignar un valor a un elemento
de matriz, después se reinicia a partir del valor asignado. Vea el siguiente
ejemplo:
 enum surtidores {AGUA,GASÓLEO=0,CLORO}; //AGUA= 0;GÁSOLEO=0;CLORO=1
 Las constantes de enumeración se utilizan de la siguiente manera:
 int Velocidad_ascensor;
 enum motor_ascensor {PARADA,INICIO,NORMAL,MÁXIMO};
 Velocidad_ascensor = NORMAL; // Velocidad_ascensor = 2

16. Acceso individual de bits
 mikroC te permite acceso individual en variables de 8
bits (char and unsigned short). Simplemente usando el
selector (.) seguido de uno de los identificadores F0,
F1, … , F7. Siendo F7 el bit mas significativo.
 Ejemplo:
PORTC.F0 = 1;
PORTD.F5 = 0;
PORTB.F7 = 1;
 Los identificadores F0–F7 no se reconocen en minúsculas.
NOTA: Entre dos accesos a bits se debe tener un retardo mínimo
de 2 microsegundos.