Curso Programación MCUs PIC en lenguaje C - Edudevices

Aprendiendo a programar
Microcontroladores PIC en
Lenguaje C con CCS
Los compiladores de lenguaje C hoy son ampliamente utilizados para la creación
de programas con microcontroladores PIC. El compilador que mejor soluciona las
necesidades del programador enmascarando el hardware y simplificando la
implementación de una aplicación es el fabricado por la compañía CCS.
Por Andrés Raúl Bruno Saravia
Entrega Nº 2.
En nuestra entrega anterior aprendimos a crear un proyecto dentro del MPLAB
para escribir nuestro primer código en lenguaje C, hoy crearemos nuestro primer
código y aprenderemos la función que cumplen sus elementos principales .
Creando Nuestro Primer Código
Ya que hemos aprendido a crear nuestro primer proyecto, escribiremos nuestro primer
código, el cual adicionaremos a nuestro proyecto. Para ello nos moveremos con el
Mouse hasta el ícono de New File y haremos clic sobre el mismo:

Y se desplegará una nueva ventana en la cual escribiremos el código de nuestro
programa.
Por ser este nuestro primer programa, simplemente haremos titilar un LED con un
tiempo de flashing de 500ms. La idea es introducirnos de a poco, y muchas veces querer
comenzar con un código demasiado elaborado es complejo.
#include
#use delay(osc=4000000)
//configura fusibles de configuración
#fuses XT //Oscilador a cristal standar
#fuses NOWDT //sin WatchDog Timer
#fuses NOPROTECT //sin proteccion de memoria de programa
#fuses NOPUT //sin PowerUp Timer
#fuses NOBROWNOUT //sin brownout
#fuses NOLVP //sin programación en baja tensión
//rutina principal
void main(void)
{ //abrimos la función principal
Setup_adc_ports(NO_ANALOGS);//configuramos los puertos digitales
while(1) //creamos un bucle infinito
{ //abrimos el bucle
output_high(PIN_B0); //prendemos RB0
delay_ms(500); //esperamos 500 ms
output_low(PIN_B0); //borramos RB0
delay_ms(500); //esperamos 500 ms
} //cerramos el bucle
} //cerramos la función principal
Este código lo hemos escrito en lo que se conoce en la jerga técnica como “codigo en C
nativo” ya que usamos las funciones de control de entrada / salida de CCS
El código inicia siempre en lo que se conoce como “cabecera”, es decir el principio.
En esta cabecera encontraremos instrucciones dirigidas al compilador y no al
microcontrolador, dichas instrucciones se denominan “directivas”. Las directivas se
diferencian de las instrucciones en que:
• Siempre se encuentran en la cabecera del programa
• Todas comienzan con el símbolo del numeral #
En nuestro caso estas son las directivas:
#include
#use delay(crystal=4000000)
//configura fusibles de configuración
#fuses XT //Oscilador a cristal standar
#fuses NOWDT //sin WatchDog Timer
#fuses NOPROTECT //sin proteccion de memoria de programa
#fuses NOPUT //sin PowerUp Timer
#fuses NOBROWNOUT //sin brownout
#fuses NOLVP //sin programación en baja tensión
La directiva : #include nos permite decirle al compilador para que
microcontrolador hemos escrito el código.

Seguidamente con la directiva #use delay(crystal=4000000) le indicamos a que
frecuencia esta funcionando nuestro oscilador.
El orden de las directivas es crucial ya que siempre primero debemos indicarle al
compilador cual es el PIC que estamos usando y luego cual es la frecuencia del
oscilador. Posteriormente podemos agregar el resto de directivas. Si esto no se
respeta podemos tener errores en el proceso de compilación sobre todo cuando
usamos alguna función propia del compilador (llamadas funciones embebidas)
para manejar algún periférico, y que la misma necesita saber la frecuencia del
oscilador.
La directiva puede tener distintas formas ya que amolda la configuración interna a la
frecuencia que le indicamos. Así esta directiva nos permite activar multiplicadores y
divisores internos, o accionar los osciladores internos cuando el microcontrolador los
trae; por ejemplo:
#use delay(crystal=4000000, clock=16000000)
Le indica al compilador que tenemos un cristal externo de 4Mhz, y que la frecuencia
que llega a la CPU es de 16Mhz, por lo tanto el compilador configurará correctamente
el PLL de la CPU para alcanzar los 32Mhz. Otro ejemplo pero usando el reloj interno es
el siguiente:
#use delay(internal=8000000, clock=16000000)
Sin embargo esta directiva debe usarse con precaución ya que el clock que definimos
nunca debe sobrepasar la máxima velocidad de procesamiento del PIC que se esté
usando. Este parámetro se denomina MIPS (Millones de Instrucciones por Segundo) y
se obtiene dividiendo la frecuencia de entrada por cuatro.
MIPS = fosc/4
La directiva #fuse xx nos permite activar o desactivar las características del nucleo,
como ser el circuito de Watch Dog Timer, que reseta al microcontrolador ante un
cuelgue del mismo, el Brown Out Detect, que resetea el microcontrolador ante un fallo
de la alimentación, el tipo de oscilador, etc.
Las etiquetas usadas para activar o desactivar la propiedad, están incluidas en el archivo
de cabecera y deben ser consultadas siempre, ya que las mismas suelen cambiar entre
versiones del compilador o tipos de microcontroladores.
En líneas generales podemos decir que anteponiendo la palabra NO al fusible de
configuración (así se llama al seteo de las propiedades), se le informa al compilador que
el fusible en cuestión está desactivado, mientras que colocando solo el nombre
activamos la propiedad.
Por otra parte para activar o desactivar los distintos fusibles se puede realizar en varias
líneas (como en el ejemplo) o se pueden activar y desactivar en una sola línea separando
cada fusible con comas:
#fuse NOWDT,HS,NOPUT,NOLVP,NOMCLR,NOPROTECT,NOBROWNOUT
La cabecera además puede incorporar redefinición de nombres de pines, definición de
variables y constantes. Y prototipo de funciones. Esto será visto en nuestras próximas
lecciones.

Finalizada la cabecera, continúa el código, que es el que se traducirá en instrucciones al
microcontrolador luego del proceso de compilación. En nuestro caso nuestro código es
bastante sencillo:
void main(void)
{ //abrimos la función principal
setup_adc_ports(NO_ANALOGS);//configuramos los puertos digitales
while(1) //creamos un bucle infinito
{ //abrimos el bucle
output_high(PIN_B0); //prendemos RB0
delay_ms(500); //esperamos 500 ms
output_low(PIN_B0); //borramos RB0
delay_ms(500); //esperamos 500 ms
} //cerramos el bucle
} //cerramos la función principal
Todo programa siempre inicia en una rutina principal. En el lenguaje C las rutinas se
denominan funciones. Las funciones son un conjunto de sentencias u ordenes que
realizan una operación determinada, como lo hacen las rutinas, sin embargo las
funciones tiene una característica extra; a ellas se les puede pasar valores de variables
para que las procesen, y son capaces de devolvernos los resultados de dichos procesos.
Básicamente actúan como las funciones matemáticas.
Todo programa C siempre inicia en la función principal, la cual se denomina main.
Dicho nombre no puede ser distinto, todo programa debe tener una función main, de lo
contrario el compilador nos indicará un error.
La función encierra una serie de sentencias, las cuales forman el bloque de dicha
función. Dicho bloque inicia con una llave { y finaliza con otra llave } .
Entre estas dos llaves se encuentran las sentencias y las estructuras lógicas.
La función main es una función especial ya que no puede recibir ningún valor, ni
tampoco puede devolver uno. Por lo tanto observe que va acompañada por dos palabras
void lo cual en el lenguaje C significa vacío; es decir que no devuelve ningún valor
(primer void) ni puede recibir ningún valor, (segundo void, el cual esta encerrado entre
paréntesis).
void main(void)
{
}
Nuestro código
Nuestro código lo hemos escrito en formato “CCS nativo”. Esto significa que hemos
usado todas las funciones embebidas (incluidas dentro) del compilador para simplificar
la escritura del código y que nos ahorran mucho tiempo.
Debe observarse que cada línea la hemos decalado (separado del origen) por medio del
TABULADOR; esto es una buena práctica para poder advertir a simple vista cuales
sentencias son las que estas anidadas dentro de cada bloque del programa principal.
La primera línea o sentencia le indica al compilador que debe desactivar todos los
puertos analógicos del PIC y que debe configurarlos como puertos digitales:
setup_adc_ports(NO_ANALOGS);

Usamos la función embebida setup_adc_ports, la cual esta embebida en el
compilador, y que se encarga básicamente de setear que puertos van a trabajar como
analógicos y que puertos van a trabajar como digitales. La función configura los bits
PCFG o ANSEL dependiendo con que PIC estemos trabajando y lo realiza de forma
automática.
Observe que hemos escrito entre paréntesis NO_ANALOGS lo cual le dice al
compilador que no hay puertos analógicos. Esta etiqueta la obtenemos del archivo de
cabecera del procesador (16f887.h).
Es importante resaltar que las etiquetas siempre van en mayusculas, mientras que
las instrucciones se escriben en minúscula.
Es muy importante que se respete el orden mayúscula-minúscula pues el
compilador es sensible a ello. Si escribimos una instrucción con mayúscula, NO LA
IDENTIFICARÁ.
Debe observarse también que las sentencias siempre terminan con un punto y coma.
La siguiente sentencia de nuestro código es una instrucción estructural: while
El while es una instrucción condicional la cual determina la ejecución de una o mas
instrucciones en tanto y en cuanto se cumpla una condición, la cual se encierra entre
paréntesis.
En programación, si una condición se cumple, se dice que es verdadera, y esto se
simboliza con el número 1; por el contrario, si la condición no se cumple, es falsa y
se simboliza con el número 0.
En un while, lo que este dentro del bloque del mismo, se ejecutará, siempre que la
condición de verdadera, caso contrario no se ejecutará ninguna sentencia que se
encuentre dentro del while.
En nuestro caso hemos forzado la condición 1, con lo cual el while se ejecutará
eternamente. Es decir que las sentencias encerradas dentro del bloque while (limitado
por las llaves{}), se ejecutaran por siempre.
Observe que dentro del while usamos también funciones embebidas:
output_high(PIN_B0);
output_low(PIN_B0);
Estas son funciones de salida de datos, se encargan de poner en uno o en cero un puerto,
el cual la misma función se encarga de configurar como salida, no debe hacerlo el
programador. Entre paréntesis le indicamos el PIN a encender o apagar. En nuestro caso
es el RB0, al cual CCS lo denomina dentro del archivo de cabecera del
microcontrolador como PIN_B0.
Este formato si bien parece en principio raro porque no se adapta al usado en el data
sheet, es práctico para los programadores NO ELECTRÓNICOS, y es el que ha
adoptado CCS.
Por ejemplo el RA0 CCS lo llama PIN_A0, y al RC6, PIN_C6, y así sucesivamente.
Otra de las sentencias usadas es
delay_ms(500);

La cual es una función de tiempo que nos permite crear un tiempo de espera en
milisegundos. También existe el delay_us que nos permite crear un delay de
microsegundos.
La exactitud de la función delay depende de que hayamos definido correctamente la
frecuencia de clock.
De esta forma hemos hecho falshear un LED en nuestro primer código.
Bueno, esto es todo por ahora , en las próximas entregas iremos descubriendo paso a
paso las utilidades de la programación en lenguaje C y del entorno CCS.
Continuará ......