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

Para las personas que están un poco más familiarizadas a hacer programas en lenguaje C o sus derivados, en esta sección les traigo un manual de como programar un PIC usando el lenguaje C, pero como siempre un poco de teoría para que estén familiarizados un poco.

PIC C Compiler es un compilador C que contienen operadores estándar del lenguaje C y funciones incorporados en bibliotecas que son específicas 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 más de 307 funciones integradas que simplifiquen el acceso al hardware, mientras que la producción eficiente y altamente optimizado código. Se incluyen funciones de hardware del dispositivo de características tales como:

* Temporizadores y módulos 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 más de 20 años y continúa ofreciendo soluciones de software a los desarrolladores de aplicaciones integradas que utilizan dispositivos PIC ® DSC MCU y dsPIC ®. Nuestros productos incluyen la optimización del compilador de nivel profesional, la mayor biblioteca de funciones integradas, PIC MCU poderosos comandos específicos pre-procesador ®, y programas de ejemplo listos para funcionar de forma rápida poner en marcha cualquier proyecto. Nuestra base de clientes masiva nos da acceso a la comprensión 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 versión que tengas podrás programar algunos tipos de PIC:

Todos CCS compiladores tienen optimización de nivel profesional y están 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 tecnología 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 código fuente que contiene el código en C.
• .h Se trata de archivos estándar o personalizados de cabecera utilizados para definir pines, registros, funciones y directivas del µprocesador.
• .hex El compilador genera archivos HEX estándar 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 más de 256 bytes de RAM se puede seleccionar entre punteros de 8 o 16 bits. Para usar punteros de 16 bits hay que añadir *=16 después del nombre del chip (uC, memoria, ...) o en una nueva línea después de la declaración del chip. Se puede obtener informaciçon sobre un dispositivo con el programa PICCHIPS.

Ejemplos:

#device PIC16C67 *=16

#device PIC16C74

#device *=16

//-------------------------------------------------------------------
LIBRERIAS EXTERNAS:

Introducción: 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 librerías del programa. Ambos llevan la terminación ".h"

El archivo header del microcontrolador contiene las equivalencias que usa el compilador entre los nombres de los puertos, registros, bits y señales con su dirección física en el microcontrolador. Por ejemplo, para el compilador CCS, vea los archivos 16F628A.h, 16F88.h, 16F88ADC.h . 

Los archivos ".h" del programa también se conocen como "librerías" ó "bibliotecas". Las que están siempre integradas en todos los compiladores ANSI C, como por ejemplo <stdlib.h>, se conocen como "librerías estándar".

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: también llamadas "bibliotecas". Estos archivos header contienen las funciones que habrán 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 función "main" y las demás necesarias para su funcionamiento, en un solo archivo con terminación .c, sin utilizar archivos header ó librerías 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 ó librerías cuyo nombre debe llevar la terminación .h . De esta manera, el programa en el archivo "main" se simplifica a un mínimo de líneas, facilitando su comprensión.

Como ventaja adicional para los programadores al crear sus propias librerías, 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 también contener la declaración de otros archivos .h, que son indispensables para la operación de algunas de las funciones, incluyendo las llamadas "librerías estándar" 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 compilación; sin embargo, esta información 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 válidas para cada dispositivo. La opción SWAP tiene la función especial de intercambiar, los bytes alto y bajo de los datos que no son parte del programa, en el archivo Hex. Esta información es necesaria para algunos programadores de dispositivos. Algunas de las opciones más 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 función 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 función (después del signo { ) y solo son válidas en esa función. Su valor y su espacio en memoria son eliminados al salir de la función y por tanto no pueden ser usadas en otra parte del programa. Por tanto, pueden usarse nombres idénticos de variables locales en distintas funciones sin que esto genere ningún error por parte del compilador.

Los argumentos ó parámetros de cualquier función son siempre variables locales. Por ejemplo, en la función sum(int a,int b); las variables a y b son locales.

En contraste, las variables globales se declaran generalmente arriba de la función "main" y su valor puede ser modificado y utilizado tanto por la función "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 4294967295	-2147483648 to 2147483647	9-10
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 función main( ). Y no es necesario nombrarlas como variables globales

Las variables globales pueden posteriormente ser "pasadas" como argumento a una función. En este caso, la variable ingresa a la función con otro nombre y un valor inicial, y posteriormente es automáticamente considerada local dentro de esa función. 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 están sin signo; sin embargo, puede ser precedida por firmada o no (excepto int64 sólo puedes suscribir). Short y Long puede tener la palabra clave INT seguirlas sin efecto. También vea # TYPE para cambiar el tamaño predeterminado.

CORTO INT1 es un tipo especial que se utiliza para generar código 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 definición 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 ejecución.

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

#define pi 3.1416

También podemos almacenar las constantes directamente en la memoria FLASH mediante la declaración:

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 están permitidos punteros a constantes. SHORT es un tipo especial utilizado para generar código muy eficiente para las operaciones de I/O.

Ejemplos:

byte const SEMANAS = 52;

EXPRESIONES

Constantes
123	Decimal
0123	Octal
0x123	Hex
0b010010	Binario
'x'	Carácter
'\010'	Carácter octal
'\x'	Carácter especial; x puede ser: ¿n,t,b,r,f, ', \d,v?
"abcdef"	Cadena (el carácter 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 través de su subíndice, 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 aritméticos se usan para realizar operaciones matemáticas. Se listan

en la siguiente tabla:

Operador	Descripción	Ejemplo
+	Suma (enteros o reales)	resul = var1 + var2
-	Resta (enteros o reales)	resul = var1 - var2
*	Multiplicación (enteros o reales)	resul = var1 * var2
/	División (enteros o reales)	resul = var1 / var2
-	Cambio de signo en enteros o reales	-var1
%	Módulo; resto de una división entera	rango = n [A1]% 256

Los bits de precisión con los que trabajan dependen de los rangos de variables que se ocupan.

OPERADORES DE COMPARACIÓN

Su misión es comparar dos operandos y dar un resultado entero:

1 (verdadero); 0 (falso).

OPERADOR	DESCRIPCIÓN
==	Igual
¡=	Diferente
<	Menos que
>	Mayor que
<=	Menso o igual que
>=	Mayor o igual que

OPERADORES LÓGICOS

Al igual que los operadores relacionales, éstos devuelven 1 (verdadero), 0 (falso) tras la

evaluación de sus operandos.

OPERADOR	DESCRIPCIÓN
&&	AND lógico
ll	OR lógico
!	NO lógico

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
OPERADORES DE ASIGNACIÓN

En C es muy común encontrarnos u usar el siguiente tipo de sintaxis  i = i + 1; ya sea de crecimiento o decremento, para un contador o algún uso. Aunque también la expresión anterior se puede escribir así i += 1. Ahora dejare en la tabla sig. los demás:

Operador	Descripción
+=	Asignación suma
-=	Asignación resta
*=	Asignación multiplicación
/=	Asignación división
%=	Asignación resto de división
<<=	Asignación desplazamiento a la izquierda
>>=	Asignación desplazamiento a la derecha
&=	Asignación AND de bits
!=	Asignación OR de bits
^^=	Asignación OR exclusivo de bits
~=	Asignación negación de bits

OTROS

OPERADOR	FUNCION
++	Incremento
--	Decremento
<<	Desplazamiento a la Izquierda
>>	Desplazamiento a la Derecha
&	Operación AND
|	Operación OR
^^	Operación OR EXCLUSIVA
~	Operación 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 *ptr)	Esta función convierte la cadena de caracteres apuntada por ptr en un valor de tipo entero. Acepta argumentos en decimal y en hexadecimal.
i=ATOL(char *ptr)	Esta función convierte la cadena de caracteres apuntada por ptr en un número entero largo (long). Acepta argumentos en decimal y en hexadecimal.
CEIL(x)	Obtiene el valor entero más pequeño, mayor que el número real x, es decir, hace un redondeo por exceso del número real x.
EXP(x) ^b^i	Calcula la función exponencial del número real x.
FLOOR(x)	Calcula el valor entero más grande, menor que el número real x, es decir, hace un redondeo por defecto del número real x.
LABS(x)	Obtiene el valor absoluto del entero largo x.
LOG(x)	Calcula el logaritmo natural del número real x.
LOG10(x)	Calcula el logaritmo decimal o base-diez del número real x.
SQRT(x)	Obtiene la raíz cuadrada del número real x.

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CONDICIONES

CODICIÓN	EJEMPLO
if (expr) condicion; [else condición;]	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) { case cexpr: condicion; //uno o mas casos [default:condicion] ... }	switch (cmd) { case 0: printf(“cmd 0”);break; case 1: printf(“cmd 1”);break; 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 decisión:

if (expr)

stmt-1;

[else

stmt-2;] 

Se llevará acabo la primera acción si el if fue correcto sino realizará la segunda expresión

También puede tener una estructura de múltiples 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 expresión si ninguno es verdadero entonces ejecutara la ultima expresión con el else.

Ejemplo:

if (x==25)

x=1;

else

x=x+1;

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

while

Condición que se repetirá continuamente hasta que que el usuario lo requiera (o ponga un break en otra condición). La expresión se evalúa y la sentencia se ejecuta hasta que se convierte en falsa en cuyo caso la ejecución continúa después de la declaración.

Ejemplo:

while (get_rtcc()!=0)

putc('n');

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

do-while 

Difiere de while y for loop en que la condición de terminación 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 inicialización, expr2 es la comprobación de la terminación y expr3 es re-inicialización. Cualquiera de ellos puede ser omitido. 

Ejemplo:

for (i=1;i<=10;++i)

printf("%u\r\n",i);

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

switch

Usado para tomar múltiples decisiones

 Sintaxis:

switch (expr) {

case const1: stmt sequence;

break;

...

[default:stmt]

} 

Esto pone a prueba si la expresión 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 función y también devuelve un valor.

return (5);

continue

La sentencia continue hace que la siguiente iteración 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-inicialización en caso de for.

continue;

break

Esto hace que el bucle más 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 función, 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 más se mandar a llamar para que se ejecuten y ahorrar el codigo.

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

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

Veamos un ejemplo muy sencillo con una función 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 función "main" es necesario declarar la función "suma"

Esta declaración significa: define una función cuyo nombre es "suma" y que cuenta con 2 valores de entrada cuyos nombres son "a" y "b" y que se almacenarán en memoria, como valores enteros con signo ("int"). Además, el valor de retorno de la función (return value), declarado del lado izquierdo, es otro valor entero con signo. Observe como al valor de retorno no se le asigna ningún nombre de variable, debido a que el nombre mismo de la función tomará ese valor.

void main(void) {                                    //aquí se declara la función 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 función.     

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

}    

El programa principal llama a la función "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 función 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 función "suma":   

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

int c;                                                      //se declara c como variable local

c=a+b;                                                 //aquí se efectúa la suma

return (c);    }                                       //la función regresa al programa principal. La función toma el valor de c.

Al llamar a la función, las variables pueden también llevar el mismo nombre que los argumentos de la función. Este ejemplo funcionaría  igualmente, llamando a la función 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 serían: a=8; b=3; PORTB=suma(a,b);

La misma función opera correctamente si se le llama usando constantes como argumentos. Por ejemplo: suma(10,35). En este caso el valor de retorno sería 45.

El compilador está limitado a trabajar con parámetros por referencia.

Esto aumenta la legibilidad del código así como la eficacia de algunos procedimientos.

Los dos procedimientos siguientes son iguales pero sólo el segundo opera con parámetros por referencia:

funcion_a(int*x,int*y) { / * declaración de la función * /

(*x!=5);

*y=*x+3;

}

funcion_a(&a,&b); /* llamada a la función */

funct_b(int&x,int&y) { / * declaración de la función * /

/* paso de parámetros por referencia * /

if(x!=5)

y=x+3;

}

funcion_b(a,b); /* llamada a la función */

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

LINK'S:

http://www.ccsinfo.com/content.php?page=compilers
http://www.ccsinfo.com/content.php?page=mplab_support

PROGRAMA:

http://www.ccsinfo.com/downloads.php#mplabPlugIn


//////////////////////////////////////////////////////////////////////////////////////


PARTE 2 (PRENDER LED):

http://batiz9.blogspot.mx/2014/06/primer-programa-pcw-ccs-pic-c.html