PROGRAMAR EN PIC C COMPILER [CCS - PIC - C]

Para las personas que estn un poco ms familiarizadas a hacer programas en lenguaje C o sus derivados, en esta seccin les traigo
un manual de como programar un PIC usando el lenguaje C, pero como siempre un poco de teora para que estn familiarizados un
poco.

PIC C Compiler es un compilador C que contienen operadores estndar del lenguaje C y funciones incorporados en bibliotecas que
son especficas a los registros de PIC, proporcionando a los desarrolladores una herramienta poderosa para el acceso al hardware
las funciones del dispositivo desde el nivel de lenguaje C.

El compilador de CCS (Custom Computer Services) contiene ms de 307 funciones integradas que simplifiquen el acceso al
hardware, mientras que la produccin eficiente y altamente optimizado cdigo. Se incluyen funciones de hardware del dispositivo de
caractersticas tales como:

* Temporizadores y mdulos PWM

* Convertidores A / D
* de datos on-chip EEPROM
* LCD controladores
* Memoria externa buses
* Entre otras...
La pagina oficial de CCS nos dice lo siguiente:

CCS desarroll el primer compilador de C para microcontroladores Microchip hace ms de 20 aos y contina ofreciendo soluciones
de software a los desarrolladores de aplicaciones integradas que utilizan dispositivos PIC DSC MCU y dsPIC . Nuestros
productos incluyen la optimizacin del compilador de nivel profesional, la mayor biblioteca de funciones integradas, PIC MCU
poderosos comandos especficos pre-procesador , y programas de ejemplo listos para funcionar de forma rpida poner en marcha
cualquier proyecto. Nuestra base de clientes masiva nos da acceso a la comprensin de las necesidades de nuestros clientes,
mientras que el desarrollo de funciones avanzadas con los lanzamientos frecuentes y raros bugs.

Aunque cada programa de CCS tienen sus limitantes a lo que me refiero es que dependiendo de la versin que tengas podrs
programar algunos tipos de PIC:
Todos CCS compiladores tienen optimizacin de nivel profesional y estn disponibles en configuraciones de software flexibles que se
ajustan a los requisitos del proyecto. Las nuevas licencias incluyen: los derechos iniciales de descarga, renovaciones de
mantenimiento opcionales y libre de tecnologa de apoyo para la vida til del producto. Todos los compiladores son compatibles con
herramientas de terceros, tales como Microchip MPLAB and MPLAB X.

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
FORMATOS DE ARCHIVOS (COMUNES):

.c Este es el archivo de cdigo fuente que contiene el cdigo en C.

.h Se trata de archivos estndar o personalizados de cabecera utilizados para definir pines, registros,funciones y directivas
del procesador.
.hex El compilador genera archivos HEX estndar que son compatibles con todos los programadores.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
PIC
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Esta directiva define al compilador la arquitectura hardware utilizada. Esto determina la memoria RAM y ROM as como el juego de
instrucciones. Para los chips (uC's, memorias, etc) con ms de 256 bytes de RAM se puede seleccionar entre punteros de 8 o 16 bits.
Para usar punteros de 16 bits hay que aadir *=16 despus del nombre del chip (uC, memoria, ...) o en una nueva lnea despus de
la declaracin del chip. Se puede obtener informacion sobre un dispositivo con el programa PICCHIPS.

Ejemplos:
#device PIC16C67 *=16
#device PIC16C74

#device *=16

//-------------------------------------------------------------------
LIBRERIAS EXTERNAS:
Introduccin: en un programa ANSI C para sistemas de microcontrol, existen 2 tipos de archivos .h: el archivo del
microcontrolador particular que se est utilizando, y las libreras del programa. Ambos llevan la terminacin ".h"

El archivo header del microcontrolador contiene las equivalencias que usa el compilador entre los nombres de los puertos, registros,
bits y seales con su direccin fsica en el microcontrolador. Por ejemplo, para el compilador CCS, vea los archivos 16F628A.h,
16F88.h, 16F88ADC.h .

Los archivos ".h" del programa tambin se conocen como "libreras" "bibliotecas". Las que estn siempre integradas en todos los
compiladores ANSI C, como por ejemplo <stdlib.h>, se conocen como "libreras estndar".

En seguida se dan detalles con respecto a ambos tipos de archivos .h

En el caso del compilador CCS, debe incluirse la directiva #include "16F628A.h" "16F88.h". El uso de las comillas dirige al
compilador a buscar ese archivo en la misma carpeta en donde est el proyecto generado desde MPLAB IDE. Si se usa la directiva
#include <16F628A.h>, el compilador busca el archivo en la carpeta "devices" en donde se instalaron originalmente los drivers para
cada microcontrolador.

LIBRERIAS DEL PROGRAMA: tambin llamadas "bibliotecas". Estos archivos header contienen las funciones que habrn de usarse
en el programa principal en alguno de los otros archivos header. No es indispensable tener un archivo "header" separado del
programa principal. Un programa ANSI C puede tener su encabezado, la funcin "main" y las dems necesarias para su
funcionamiento, en un solo archivo con terminacin .c, sin utilizar archivos header libreras adicionales.
Sin embargo, cuando el programador desea separar algunas todas las funciones del programa principal en un archivo archivos
distintos, entonces es indispensable crear nuevos archivos libreras cuyo nombre debe llevar la terminacin .h . De esta manera, el
programa en el archivo "main" se simplifica a un mnimo de lneas, facilitando su comprensin.

Como ventaja adicional para los programadores al crear sus propias libreras, es permitir que esas funciones puedan ser utilizadas
por otros programadores.

Un archivo .h puede contener las llamadas "directivas del preprocesador de C", como #define e #include, as como las funciones.
Puede tambin contener la declaracin de otros archivos .h, que son indispensables para la operacin de algunas de las funciones,
incluyendo las llamadas "libreras estndar" del propio compilador C como son "stdio.h" "string.h".

//-------------------------------------------------------------------

FUSIBLES
Esta directiva define qu fusibles deben activarse en el dispositivo cuando se programe. Esta directiva no afecta a la compilacin; sin
embargo, esta informacin se pone en el archivo de salida. Si los fusibles necesitan estar en formato Parallax, hay que agregar PAR
en opciones. Utilizar la utilidad PICCHIPS para determinar qu opciones son vlidas para cada dispositivo. La opcin SWAP tiene la
funcin especial de intercambiar, los bytes alto y bajo de los datos que no son parte del programa, en el archivo Hex. Esta
informacin es necesaria para algunos programadores de dispositivos. Algunas de las opciones ms usadas son:
LP, XT, HS, RC
WDT, NOWDT
PROTECT, NOPROTECT
PUT, NOPUT (Power Up Timer)
BROWNOUT, NOBROWNOUT
PAR (Parallax Format Fuses)
SWAP
Ejemplo:

#fuses HS,WDT
#FUSES NOLVP

//-------------------------------------------------------------------
DELAY
Esta directiva indica al compilador la frecuencia del procesador, en ciclos por segundo, a la vez que habilita el uso de las funciones
DELAY_MS() y DELAY_US().
Opcionalmente podemos usar la funcin restart_WDT() para que el compilador reinicie el WDT durante el retardo.
Ejemplos:
#use delay (clock=20000000)

#use delay (clock=32000, RESTART_WDT)

//-------------------------------------------------------------------
VARIABLES

Las variables pueden modificar su valor a lo largo de un programa.

En un programa, las variables pueden tomar dos formas: variables locales variables globales. Las variables locales se declaran
adentro de una funcin (despus del signo { ) y solo son vlidas en esa funcin. Su valor y su espacio en memoria son eliminados al
salir de la funcin y por tanto no pueden ser usadas en otra parte del programa. Por tanto, pueden usarse nombres idnticos de
variables locales en distintas funciones sin que esto genere ningn error por parte del compilador.

Los argumentos parmetros de cualquier funcin son siempre variables locales. Por ejemplo, en la funcin sum(int a,int b); las
variables a y b son locales.
En contraste, las variables globales se declaran generalmente arriba de la funcin "main" y su valor puede ser modificado y utilizado
tanto por la funcin "main" como por el resto de las funciones del programa. Es recomendable, para evitar confusiones al programar,
usar nombres de variables globales y locales distintos.

C Standard Type Default Type

short int1
char unsigned int8
int int8
long int16
long long int32
float float32
double N/A

Basic Types Type-Specifier Rango

Size Unsigned Signed Digitos
int1 1 bit number 0 to 1 N/A 1/2
int8 8 bit number 0 to 255 -128 to 127 2-3
int16 16 bit number 0 to 65535 -32768 to 32767 4-5
int32 32 bit number 0 to -2147483648 to 9-10
4294967295 2147483647
float32 32 bit float -1.5 x 1045 to 3.4 x 1038 7-8

Una variable puede ser definida como global con un nombre cualquiera. Las variables globales se declaran antes de la funcin
main( ). Y no es necesario nombrarlas como variables globales

Las variables globales pueden posteriormente ser "pasadas" como argumento a una funcin. En este caso, la variable ingresa a la
funcin con otro nombre y un valor inicial, y posteriormente es automticamente considerada local dentro de esa funcin. El
programador debe evitar confusiones utilizando siempre nombres de variables globales y locales diferentes.

Las variables pueden declararse al mismo tiempo en que son inicializadas. Por ejemplo:

int b=22, char web[5]={23,44,81,92,56}, float flujo=35.23;

Nota: todos los tipos, excepto coma flotante, por defecto estn sin signo; sin embargo, puede ser precedida por firmada o no (excepto
int64 slo puedes suscribir). Short y Long puede tener la palabra clave INT seguirlas sin efecto. Tambin vea # TYPE para cambiar el
tamao predeterminado.

CORTO INT1 es un tipo especial que se utiliza para generar cdigo muy eficiente para operaciones de bits y E / S. Las matrices de
bits de (INT1 o corto) en la memoria RAM son ahora soportados. No se permiten los punteros a bits. Los archivos de cabecera de
dispositivos contienen define para BYTE como int8 y BOOLEAN como int1.

Si TYPEDEF se pone delante de la definicin de un dato, entonces no se asigna espacio de memoria al identificador a menos que
sea utilizado como un especificador de tipo en otras definiciones de datos.

Ejemplos:
int a,b,c,d;
typedef int byte;
typedef short bit;
char *h;
enum boolean {false, true};
boolean j;
byte k = 5;

//-------------------------------------------------------------------
CONSTANTES
Si delante del identificador ponemos CONST entonces, el identificador es tratado como constante. Las constantes deben ser
inicializadas y no pueden cambiar en tiempo de ejecucin.

una constante es un valor fijo que no puede variar durante el programa. Las constantes pueden ser nmeros enteros o reales y se
pueden definir de 2 maneras. La primera es usar la directiva del preprocesador:

#define pi 3.1416

Tambin podemos almacenar las constantes directamente en la memoria FLASH mediante la declaracin:
const float pi=3.1416, const signed int mik=-76;
Si se trata de un arreglo, entonces usamos:
const signed int web[5]={23,44,-81,92,-56}; const char quest[10]={"presion= "};

No estn permitidos punteros a constantes. SHORT es un tipo especial utilizado para generar cdigo muy eficiente para
las operaciones de I/O.

Ejemplos:
byte const SEMANAS = 52;

EXPRESIONES
Constantes
123 Decimal
0123 Octal
 0x123 Hex
0b010010 Binario
'x' Carcter
'\010' Carcter octal
'\x' Carcter especial; x puede ser:
n,t,b,r,f, ', \d,v?
"abcdef" Cadena (el carcter nulo se agrega al
final)
ARRAYS

Ejemplos:
Los arreglos pueden definirse como sucesiones de valores constantes variables que son almacenados en memoria FLASH, o en
RAM respectivamente. Los strings son arreglos formados de caracteres ASCII, y terminados con un caracter "NULL".

const signed int web[5]={23,44,-81,92,-56}; es un arreglo de constantes y se almacenan en memoria FLASH. Su valor no puede
modificarse.

const char wob[30]="LAS CARACTERISTICAS MAS IMPORTANTES DEL DISPOSITIVO SON"; este arreglo se almacena en la
memoria FLASH. Las comillas indican al compilador que se trata de un string. Observe que no es necesario el uso de corchetes.

signed int web[5]={23,44,-81,92,-56}; es un arreglo de variables inicializadas con un valor y se almacenan en RAM, pero pueden
modificarse a lo largo de un programa. Cada elemento del arreglo puede accesarse a travs de su subndice, por ejemplo, en el
arreglo "web": web[0]=23 , web[5]=-56

byte const FACTORES [4] = {8, 16, 64, 128};

No se permiten las arrays de SHORT ni los punteros a SHORT. La siguiente tabla muestra la sintaxis para las definiciones de datos.

//-------------------------------------------------------------------
COMENTARIOS:

Para escribir un comentario en la linea de codigo son la misma manera de hacerlo en C, as que si quieren escribir una linea de un
comentario solo deben poner // y en seguida su comentario
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
OPERADORES MATEMATICOS

Los operadores aritmticos se usan para realizar operaciones matemticas. Se listan

en la siguiente tabla:

Operador Descripcin Ejemplo

+ Suma (enteros o reales) resul = var1 + var2

- Resta (enteros o reales) resul = var1 - var2

* Multiplicacin (enteros o resul = var1 * var2

reales)
/ Divisin (enteros o resul = var1 / var2
reales)
- Cambio de signo en -var1
enteros o reales
% Mdulo; resto de una rango = n [A1]% 256
divisin entera

Los bits de precisin con los que trabajan dependen de los rangos de variables que se ocupan.

OPERADORES DE COMPARACIN

Su misin es comparar dos operandos y dar un resultado entero:

1 (verdadero); 0 (falso).

OPERADOR DESCRIPCIN
== Igual
= Diferente
< Menos que
> Mayor que
<= Menso o igual que
>= Mayor o igual que

OPERADORES LGICOS

Al igual que los operadores relacionales, stos devuelven 1 (verdadero), 0 (falso) tras la
evaluacin de sus operandos.

OPERADOR DESCRIPCIN
&& AND lgico
ll OR lgico
! NO lgico

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
OPERADORES DE ASIGNACIN

En C es muy comn encontrarnos u usar el siguiente tipo de sintaxis i = i + 1; ya sea de crecimiento o decremento, para un contador
o algn uso. Aunque tambin la expresin anterior se puede escribir as i += 1. Ahora dejare en la tabla sig. los dems:

Operador Descripcin
+= Asignacin suma
-= Asignacin resta
*= Asignacin multiplicacin
/= Asignacin divisin
%= Asignacin resto de divisin
<<= Asignacin desplazamiento a la
izquierda
>>= Asignacin desplazamiento a la
derecha
&= Asignacin AND de bits
!= Asignacin OR de bits
^^= Asignacin OR exclusivo de bits
~= Asignacin negacin de bits

OTROS
OPERADOR FUNCION
++ Incremento
-- Decremento
<< Desplazamiento a la Izquierda
>> Desplazamiento a la Derecha
& Operacin AND
| Operacin OR
^^ Operacin OR EXCLUSIVA
 ~ Operacin NOT (Complemento a 1)

//-------------------------------------------------------------------
FUNCIONES
OPERADOR FUNCION
ABS(x) Valor Absoluto* (completo)
ACOS(x) Regresa el arco coseno de un valor. El valor de retorno est en
el rango [0,pi]radianes.
ASIN(x) Regresa el arco seno de un valor. El valor de retorno est en el
rango [- pi/2, pi/2]radianes.
ATAN(x) Regresa el arco seno de un valor. El valor de retorno est en el
rango [- pi/2, pi/2]radianes.
i=ATOI(char Esta funcin convierte la cadena de caracteres apuntada por ptr
*ptr) en un valor de tipo entero. Acepta argumentos en decimal y en
hexadecimal.
i=ATOL(char Esta funcin convierte la cadena de caracteres apuntada por ptr
*ptr) en un nmero entero largo (long). Acepta argumentos en decimal
y en hexadecimal.
CEIL(x) Obtiene el valor entero ms pequeo, mayor que el nmero real
x, es decir, hace un redondeo por exceso del nmero real x.
EXP(x) ^b^i Calcula la funcin exponencial del nmero real x.
FLOOR(x) Calcula el valor entero ms grande, menor que el nmero real x,
es decir, hace un redondeo por defecto del nmero real x.
LABS(x) Obtiene el valor absoluto del entero largo x.
LOG(x) Calcula el logaritmo natural del nmero real x.
LOG10(x) Calcula el logaritmo decimal o base-diez del nmero real x.
SQRT(x) Obtiene la raz cuadrada del nmero real x.

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CONDICIONES
CODICIN EJEMPLO
if (expr) condicion; [else condicin;] if (x==25)
x=0;
else
x=x+1;

while (expr) condicion; while (get_rtcc()!=0)

putc(n);

do condicion while (expr); do {

putc(c=getc());
} while (c!=0);

for (expr1;expr2;expr3) condi; for (i=1;i<=10;++i)

printf(%u\r\n,i);
 switch (expr) { switch (cmd) {
case cexpr: condicion; //uno o mas case 0: printf(cmd 0);break;
casos case 1: printf(cmd 1);break;
[default:condicion] default: printf(bad cmd);break;
... } }

return [expr]; return (5);

goto label; goto loop;

label: stmt; loop: i++;

break; break;

continue; continue;

//-------------------------------------------------------------------
if, if-else
Condiciones para hacer decisin:
if (expr)
stmt-1;
[else
stmt-2;]
Se llevar acabo la primera accin si el if fue correcto sino realizar la segunda expresin
Tambin puede tener una estructura de mltiples decisiones, o un if anidado.
if (expr)
stmt;
[else if (expr)
stmt;]
...
[else
stmt;]
En estos casos de estructura la hara en orden primero ver el primer if si es verdadero sino continuara revisando cada if si son
verdaderos si alguno de ellos si es verdadero entonces ejecutara esa expresin si ninguno es verdadero entonces ejecutara la ultima
expresin con el else.

Ejemplo:
if (x==25)
x=1;
else
x=x+1;
//-------------------------------------------------------------------
while
Condicin que se repetir continuamente hasta que que el usuario lo requiera (o ponga un break en otra condicin). La expresin se
evala y la sentencia se ejecuta hasta que se convierte en falsa en cuyo caso la ejecucin contina despus de la declaracin.
Ejemplo:
while (get_rtcc()!=0)

putc('n');
//-------------------------------------------------------------------
do-while
Difiere de while y for loop en que la condicin de terminacin se comprueba en la parte inferior del loop en lugar de en la parte
superior y por lo que el cuerpo del loop siempre se ejecuta al menos una vez.
Ejemplo:
do
statement

while (expr);
//-------------------------------------------------------------------
for (expr1;expr2;expr3)
Las expresiones son instrucciones de control de loop. expr1 es la inicializacin, expr2 es la comprobacin de la terminacin y expr3
es re-inicializacin. Cualquiera de ellos puede ser omitido.
Ejemplo:
for (i=1;i<=10;++i)

printf("%u\r\n",i);
//-------------------------------------------------------------------
switch
Usado para tomar mltiples decisiones
Sintaxis:
switch (expr) {
case const1: stmt sequence;
break;
...
[default:stmt]
}
Esto pone a prueba si la expresin coincide con uno de los valores y las ramas constantes en consecuencia.

Si ninguno de los casos se cumple se ejecuta el caso predeterminado. La ruptura provoca una salida inmediata, de lo contrario el
control salta al siguiente caso.

Ejemplo:
switch (cmd) {
case 0:printf("cmd 0");
break;
case 1:printf("cmd 1");
break;
default:printf("bad cmd");

break; }
//-------------------------------------------------------------------
Return, continue, break:
return
Una sentencia de retorno permite una salida inmediata de un interruptor o un bucle o funcin y tambin devuelve un valor.
return (5);
continue
La sentencia continue hace que la siguiente iteracin del bucle envolvente (while, for, Do) para comenzar.
Esto hace que la parte de prueba que se ejecutar inmediatamente en caso de hacer y mientras pasa el control y de paso a la re-
inicializacin en caso de for.
continue;
break
Esto hace que el bucle ms interior que encierra (o switch) para ser salido inmediatamente.
break;

//-------------------------------------------------------------------

SUBRUTNA (FUNCIONES)

Para las personas familiarizadas a trabajar en C se les har conocido el termino funcin, y para los que alguna vez trabajaron en un
PIC el termino subrutina es familiar. Pero en CCS es lo mismo, son lineas de codigo que se ocupan varias veces pero para evitar
escribir de ms se mandar a llamar para que se ejecuten y ahorrar el codigo.

No es indipensable que la funcin cuente con argumentos de entrada/salida ni un valor de salida o "return value". Pueden usarse las
funciones que lleven a cabo una tarea especfica, sin dar argumentos de entrada o salida en su formato.

Los argumentos que pueden "pasarse" como entradas de una funcin pueden ser valores constantes, variables, o incluso arreglos o
"strings".

Veamos un ejemplo muy sencillo con una funcin para sumar 2 variables.

int velocidad1,velocidad2; //se declaran 2 variables como valores enteros con signo

int suma(int a,int b); //antes de la funcin "main" es necesario declarar la funcin "suma"
Esta declaracin significa: define una funcin cuyo nombre es "suma" y que cuenta con 2 valores de entrada cuyos nombres son "a" y
"b" y que se almacenarn en memoria, como valores enteros con signo ("int"). Adems, el valor de retorno de la funcin (return
value), declarado del lado izquierdo, es otro valor entero con signo. Observe como al valor de retorno no se le asigna ningn nombre
de variable, debido a que el nombre mismo de la funcin tomar ese valor.

void main(void) { //aqu se declara la funcin principal, que es el inicio del programa.

velocidad1=8; velocidad2=3; //se inicializa el valor de las variables.

PORTB=suma(velocidad1,velocidad2); //los valores de velocidad1=8 y velocidad2=3 "se pasan" a la funcin.

for(;;); //fin del programa, loop sobre s mismo

El programa principal llama a la funcin "suma". El valor de velocidad1 se transfiere a la variable a y velocidad2 se transfiere a la
variable b. Como en este caso existe un valor de retorno, el nombre de la funcin toma ese valor, como se muestra en el ejemplo. El
resultado de la suma (11), se transfiere al Puerto B, y aparece en los LEDS, en formato binario. En seguida se muestra el desarrollo
de la funcin "suma":

int suma(int a,int b){ //este es el inicio de la funcin "suma".

int c; //se declara c como variable local

c=a+b; //aqu se efecta la suma

return (c); } //la funcin regresa al programa principal. La funcin toma el valor de c.
Al llamar a la funcin, las variables pueden tambin llevar el mismo nombre que los argumentos de la funcin. Este ejemplo
funcionara igualmente, llamando a la funcin con los nombres de variables a y b, en lugar de velocidad1 y velocidad2, siempre y
cuando dichos nombres hubiesen sido declarados anteriormente como variables globales. En este caso, las instrucciones utilizadas
seran: a=8; b=3; PORTB=suma(a,b);

La misma funcin opera correctamente si se le llama usando constantes como argumentos. Por ejemplo: suma(10,35). En este caso
el valor de retorno sera 45.

El compilador est limitado a trabajar con parmetros por referencia.

Esto aumenta la legibilidad del cdigo as como la eficacia de algunos procedimientos.
Los dos procedimientos siguientes son iguales pero slo el segundo opera con parmetros por referencia:
funcion_a(int*x,int*y) { / * declaracin de la funcin * /
(*x!=5);
*y=*x+3;
}
funcion_a(&a,&b); /* llamada a la funcin */
funct_b(int&x,int&y) { / * declaracin de la funcin * /
/* paso de parmetros por referencia * /
if(x!=5)
y=x+3;
}

funcion_b(a,b); /* llamada a la funcin */

Los argumentos de entrada/salida usados en cualquier funcin son siempre variables locales, es decir, si fueron previamente
definidas como variables globales, y su valor se modifica adentro de la funcin, al regresar de la funcin la variable permanece con el
mismo valor con el que entr. Por ejemplo: en la funcin bcd(c), la variable "c" ingres a la funcin con un valor de 24. La funcin
modifica este valor y c=4 al terminar la funcin. Sin embargo, en el programa principal, la variable "c" continuar teniendo el valor 24.