2011

INTRODUCCION A LA PROGRAMACION DE MICROCONTROLADORES PIC EN CCS CPor John Caipa RoldanEste material es una traduccin y actualizacin del libro original de Nigel Gardner titulado "An introduction to programming the Microchip PIC in CCS C", copyright Bluebird Electronics 2002.

Ing. John F. Caipa Roldan Institucin Educativa Politcnico "AGS" 18/02/2011

Tabla de contenidoINTRODUCCION .................................................................................................................................. 4 PORQUE USAR C? ........................................................................................................................... 4 TERMINOLOGIA .............................................................................................................................. 5 RECOMENDACIONES EN LA ESCRITURA DE CODIGO C ................................................................... 7 1. FUNDAMENTOS DE C .................................................................................................................. 8 ESTRUCTURA DEL CODIGO C ........................................................................................................... 8 COMPONENTES DEL CODIGO C ....................................................................................................... 9 #PRAGMA ...................................................................................................................................... 10 MAIN() ........................................................................................................................................... 10 #INCLUDE ...................................................................................................................................... 10 FUNCION PRINTF ........................................................................................................................... 11 VARIABLES ..................................................................................................................................... 12 CONSTANTES ................................................................................................................................. 13 COMENTARIOS .............................................................................................................................. 14 FUNCIONES.................................................................................................................................... 14 COMPATIBILIDAD CON HARDWARE.............................................................................................. 15 PALABRAS CLAVES DE C................................................................................................................. 15 2. VARIABLES ................................................................................................................................ 17 TIPOS DE DATOS ............................................................................................................................ 17 DECLARACION DE VARIABLES........................................................................................................ 18 ASIGNACION DE VALORES A VARIABLES ....................................................................................... 20 ENUMERACION ............................................................................................................................. 21 TYPEDEF......................................................................................................................................... 22 CONVERSION DE TIPO ................................................................................................................... 23 CLASES DE ALMACENAMIENTO PARA VARIABLES ........................................................................ 23 3. FUNCIONES ............................................................................................................................... 25 FUNCIONES.................................................................................................................................... 25 FUNCION PROTOTIPO ................................................................................................................... 25 VOID .............................................................................................................................................. 27 USANDO LOS ARGUMENTOS DE UNA FUNCION ........................................................................... 27 USANDO FUNCIONES QUE RETORNAN VALORES ......................................................................... 28 1

DECLARACION CLASICA Y MODERNA DE FUNCIONES .................................................................. 30 PASANDO CADENAS CONSTANTES A FUNCIONES ........................................................................ 31 4. OPERADORES ............................................................................................................................ 32 OPERADORES ARITMETICOS ......................................................................................................... 32 OPERADORES RELACIONALES ....................................................................................................... 33 OPERADORES LOGICOS ................................................................................................................. 34 OPERADORES DE BIT A BIT ............................................................................................................ 34 OPERADORES INCREMENTALES Y DECREMENTALES .................................................................... 36 PRECEDENCIA DE OPERADORES .................................................................................................... 37 5. DECLARACIONES DE CONTROL DEL PROGRAMA ..................................................................... 39 DECLARACION if .......................................................................................................................... 39 DECLARACION if-else .............................................................................................................. 40 OPERADOR ? ................................................................................................................................. 42 DECLARACION for ....................................................................................................................... 42 DECLARACION while................................................................................................................... 43 DECLARACION do-while ........................................................................................................... 44 DECLARACIONES DE CONTROL ANIDADAS.................................................................................... 45 DECLARACION break................................................................................................................... 46 DECLARACION continue ........................................................................................................... 46 DECLARACION switch ................................................................................................................ 47 DECLARACION null(;) .............................................................................................................. 49 DECLARACION return ................................................................................................................ 50 6. ARREGLOS Y CADENAS ............................................................................................................. 51 ARREGLOS UNIDIMENSIONAL ...................................................................................................... 51 CADENA DE CARACTERES .............................................................................................................. 53 ARREGLOS MULTIDIMENSIONALES ............................................................................................... 54 INICIALIZANDO ARREGLOS ............................................................................................................ 55 ARREGLOS DE CADENAS ................................................................................................................ 56 FUNCIONES PARA MANIPULAR CADENAS .................................................................................... 56 7. PUNTEROS................................................................................................................................. 58 INTRODUCCION A LOS PUNTEROS ................................................................................................ 58

2

RESTRICCIONES PARA PUNTEROS ................................................................................................. 59 PUNTEROS Y ARREGLOS ................................................................................................................ 61 PASANDO PUNTEROS A FUNCIONES ............................................................................................. 62 8. ESTRUCTURAS Y UNIONES........................................................................................................ 64 INTRODUCCION A LAS ESTRUCTURAS ........................................................................................... 64 PUNTEROS A ESTRUCTURAS.......................................................................................................... 67 INTRODUCCION A LAS UNIONES ................................................................................................... 69 9. LENGUAJE C ESPECIFICO PARA PIC ........................................................................................... 71 ENTRADAS Y SALIDAS .................................................................................................................... 71 MEZCLANDO C Y ASSEMBLER ........................................................................................................ 73 MANIPULACION AVANZADA DE BIT .............................................................................................. 75 TEMPORIZADORES ........................................................................................................................ 76

3

INTRODUCCION Un gran avance en la programacin de microcontroladores son las herramientas que utilizan el lenguaje de alto nivel C como es el caso del compilador C de CCS. Con dicha herramienta teniendo algo de conocimiento del lenguaje C facilita mucho el desarrollo de programas y aplicaciones con microcontroladores, en este caso el PIC de Microchip. El lector de este material aunque debe tener las bases de la programacin en el lenguaje Assembler y conocer las caractersticas principales de los microcontroladores PIC no debe preocuparse, ya que el objetivo de este material es presentar los fundamentos del lenguaje C apoyado en algunos ejemplos y ejercicios, con la finalidad de que el lector tenga las bases necesarias para empezar su camino en el desarrollo de aplicaciones con PIC utilizando el compilador C de CCS y el Simulador PROTEUS de Labcenter Electrnics. Para el desarrollo de los ejemplos y ejercicios que se muestran en el transcurso del libro se recomienda sean compilados en Microsoft Visual C++ Express, el cual puede descargarse gratuitamente de la pgina de Microsoft. El Microcontrolador empleado en este material es el PIC16F84A de Microchip, adems los programas ejemplo que utilizan este Microcontrolador se escribieron y compilaron en PIC C Compiler de CCS. PORQUE USAR C? El lenguaje C fue desarrollado en los laboratorios Bell a finales de los 60s por Dennis Ritchie y Brian Kernighan. Una de las primeras plataformas para su implementacin fue PDP-11 que corra bajo el ambiente UNIX. Desde su introduccin, este ha evolucionado, estandarizado y se ha establecido en toda la industria de software como el lenguaje de programacin ms empleado. C es un lenguaje portable desarrollado para tener mnimas modificaciones cuando se transfieran programas de un computador a otro. Esto est bien cuando se trabaja con PCs y capas principales. Pero los Microcontroladores y Microprocesadores son un caso diferente. El flujo del programa principal bsicamente permanece sin cambios, pero las diferentes configuraciones de puertos y control de perifricos son especficos para cada Microcontrolador. Un ejemplo de esto es que los registros de puertos sobre un PIC son configurados 1=Input (entrada) 0=Output (salida), mientras que en H8 son 0=Input (entrada) 1=Output (salida). El uso del lenguaje C en las aplicaciones con Microcontroladores es debido a que provee programas ms complejos con un desarrollo ms fcil y tiempo de diseo ms corto comparado con el lenguaje Assembler, pero con el inconveniente que no es tan eficiente en lo relacionado con memoria de programa.

4

TERMINOLOGIA Comencemos con la terminologa bsica empleada en este contexto. Microcontrolador Es un circuito integrado programable que contiene todos los componentes necesarios para controlar el funcionamiento de una tarea determinada. El Microcontrolador empleado en este libro es el PIC16F84A de Microchip (Fig. 1). I/O Pin de conexin con el mundo exterior que puede ser configurado como entrada o salida. I/O es necesario en la mayora de los casos para permitirle al Microcontrolador comunicarse, controlar y leer informacin. Software La informacin que el Microcontrolador necesita para operar o correr. Este tiene que estar libre errores para una aplicacin exitosa. Puede ser escrito en una variedad de lenguajes como C, Pascal o Assembler. Hardware El Microcontrolador, memorias, perifricos, fuentes de voltaje, y todos los dems componentes conectados a este para hacer que trabaje y se comunique con el mundo exterior. Simulador Aplicacin en la que puede probar y depurar sus diseos de manera interactiva y rpida evitando la programacin del dispositivo real, ejemplo: ISIS PROTEUS . Programador Unidad que permite al programa ser cargado dentro de la memoria del Microcontrolador. Estos vienen en diferentes formas, protocolos de comunicacin y precios, ejemplos: PICSTART PLUS, PICKIT de Microchip. Archivo Fuente Programa escrito en un lenguaje como Assembler o C que usted puede entender. Este archivo tiene que procesarse antes de que el Microcontrolador lo reciba. Compilador Paquete software que convierte al archivo fuente en un archivo objeto. El compilador C que se utiliza en este material es PIC C Compiler de CCS. Archivo Objeto Archivo que se produce despus de compilar el archivo fuente. La extensin es .OBJ o .HEX, y es el archivo que necesita el Simulador y el Microcontrolador para funcionar.

5

(a)

(b) Fig. 1. (a) Diagrama de pines PIC16F84A, (b) Diagrama de bloques PIC16F84A Fuente: http://ww1.microchip.com/downloads/en/devicedoc/35007b.pdf

6

RECOMENDACIONES EN LA ESCRITURA DE CODIGO C La escritura de un programa es como construir una casa, si la base es firme, el resto del cdigo permanecer solido. Pero si la base es dbil, el cdigo perder su firmeza en algn punto. Las siguientes recomendaciones tomadas del estndar C++ han sido adaptadas para el PIC. Etiquetas Defnalas para que identifiquen su funcin Los nombres de las etiquetas son el corazn de la programacin, as que defnalas apropiadamente a su funcin y su uso en el programa. Ejemplo: use ErrorCheck en vez de ERRORCHECK. Corchetes o llaves selas de manera ordenada, ejemplo:if (condicin) { }

Tabulacin e Indentacin Use espaciado en lugar de tabulacin (8 espacios), recuerde que la configuracin de tabulacin de un editor no es la misma en otro, haga el cdigo portable, utilice Indentacin para que su cdigo luzca organizado. Longitud de lnea Mantenga una longitud de lnea de mximo 78 caracteres para mantener compatibilidad entre monitor e impresora. Formato de instruccin else if Se puede incluir una instruccin else extra para decidir cualquier condicin no cubierta por las instrucciones precedentes if, ejemplo:if (condicion1) { } else if (condicin2) { } else { //decide cualquier condicin no cubierta anteriormente }

Inicialice todas las variables Coloque todas las variables en un valor conocido para prevenir condiciones aleatorias o flotantes. Comentarios Los comentarios permiten descifrar la historia que usted est escribiendo. Usted sabe como su programa est funcionando hoy pero en dos semanas o dos aos podr recordar, o puede alguien diferente entender su programa como lo tiene ahora? Use comentarios para marcar reas donde hay que hacer alguna modificacin, errores a depurar o complementos futuros de su cdigo. 7

1. FUNDAMENTOS DE C Este captulo presenta algunos de los aspecto clave del lenguaje de programacin C. Se entregar una vista rpida de cada aspecto. El objetivo es proporcionar al lector un conocimiento bsico de C tal que puede comprender los ejemplos de los siguientes captulos. ESTRUCTURA DEL CODIGO C Todos los programas escritos en C contienen: directivas del preprocesador, declaraciones, definiciones, expresiones, instrucciones y funciones. Directivas del preprocesador Una directiva es un comando del preprocesador de C (el cual es invocado automticamente como el primer paso en la compilacin de un programa). Las directivas ms comunes son la directiva #define, la cual substituye una etiqueta por un identificador especifico, y la directiva #include, la cual incluye funciones de un archivo externo al programa actual. Declaraciones Una declaracin establece el nombre y atributos de las variables, funciones y tipos usados en el programa. Las variables globales son declaradas fuera de las funciones y son visibles desde el final de la declaracin hasta el final del archivo. Una variable local es declarada dentro de una funcin y es visible desde el final de la declaracin hasta el final de la funcin. Definiciones Una definicin establece el contenido de una variable o funcin. Una definicin tambin asigna el espacio de almacenaje necesario para las variables y funciones. Expresiones Una expresin es una combinacin de operadores y operandos que producen un nico valor Instrucciones Controlan el flujo y orden en la ejecucin del programa en un cdigo C. Funciones Una funcin es una coleccin de declaraciones, definiciones, expresiones e instrucciones que desempean una tarea especfica. Los corchetes encierran el cuerpo de una funcin. Las funciones no se pueden anidar en C. Funcin main Todos los programas hechos en C deben incluir una funcin llamada main donde la ejecucin del programa comienza. Los corchetes que encierran la funcin main definen el comienzo y punto de finalizacin del programa. El siguiente ejemplo muestra la estructura general de un programa C escrito en Microsoft Visual C++ Express, el cual puede descargarlo desde la web de Microsoft.#include #define PI 3.142 /* directiva del preprocesador */ /* Incluye el encabezado estndar de C*/ /* define una constante simblica */

8

float area; int cuadrado (int r);

/* declaracin variable global */

void main() { /* Comienza la funcin main */ int radio_alCuadrado; /* declaracin variable local */ int radio = 3; /*declaracin e inicializacin*/ radio_alCuadrado = cuadrado(radio); /*funcin de usuario*/ area = PI * radio_alCuadrado; printf("El area es %6.4f unidades cuadradas\n",area); getchar(); /* funcin de terminacin*/ } /*fin de la funcin main */ int cuadrado(int r) /* encabezado de la funcin*/ { int r_alCuadrado; r_alCuadrado = r * r; return(r_alCuadrado); }

COMPONENTES DEL CODIGO C Todos los programas escritos en C contienen ciertos componentes esenciales tales como instruccin y funciones. Las instrucciones son la parte del programa que realiza las operaciones. Todos los programas en C contienen una o ms funciones. Las funciones son subrutinas, cada una de las cuales contienen una o ms instrucciones y pueden ser llamada por otras partes del programa. Cuando escribe programas con lneas en blanco, usar indentacin y comentarios mejora la visualizacin, no solo para usted en el futuro, sino tambin para aquellas personas interesadas en su trabajo. El siguiente ejemplo muestra algunas de las partes requeridas de un programa en C.#include /* mi 1er codigo en C */ void main() { printf("Hola Mundo!"); getchar(); /* termina el programa oprimiendo ENTER */ }

La sentencia #include le dice al compilador que incluya el archivo fuente llamado stdio.h al programa. La extensin .h pertenece a archivos de encabezado. Un archivo de encabezado contiene informacin acerca de funciones estndar que est usando el programa como printf() y getchar(). El archivo stdio.h (Standard Input and Output), contiene muchas de las funciones de entrada y salida. /* mi 1er cdigo en C */ es un comentario en C. Todos los comentarios estn precedidos por un /* y terminan con un */. Los comentarios son ignorados por el compilador y por consiguiente no afectan la velocidad ni el tamao del cdigo compilado. Todos los programas escritos en C deben tener la funcin main(). Esta funcin es el punto de entrada del programa. Todas las funciones tienen el mismo formato, el cual es el siguiente:

9

TipoFuncion NombreFuncion() { Cdigo; }

Las instrucciones dentro de una funcin son ejecutadas secuencialmente, comenzando con el corchete abierto y terminando con el corchete cerrado. Los corchetes {} muestran el comienzo y el fin de bloques de cdigo en C. Finalmente, printf("Hola Mundo"); representa una instruccin tpica en C. Casi todas las instruccin en C terminan con punto y coma (;). El carcter final de lnea no es reconocido por C como un terminador de lnea. En consecuencia, no hay restricciones sobre la posicin de las instrucciones en una lnea ni del nmero de estas. Todas las lneas tienen un punto y coma (;) al final para informar al compilador que ha alcanzado el final de la instruccin. El error comn de no incluirlo es sealado como error en la lnea siguiente. La excepcin a esta regla es con el comando if donde el punto y coma necesita estar al final de la siguiente lnea, ejemplo:if (EstoEsVerdad) HagaEstaFuncion();

#PRAGMA El comando pragma le informa al compilador que desempee una accin particular al momento de realizar la compilacin como el PIC especifico usado en la aplicacin. Ejemplo:#pragma device PIC16F84A

En CCS C el comando pragma es opcional, el siguiente comando es el que ms se utiliza:#device PIC16F84A

MAIN() Como ya se ha dicho anteriormente todo programa debe incluir una funcin main la cual puede aparecer solo una vez en el programa. Ningn parmetro es necesario dentro de los parntesis (). Como main est clasificada como funcin, todo el cdigo siguiente a esta funcin debe estar dentro de un par de corchetes {}.void main() { Cuerpo del programa }

#INCLUDE El archivo de encabezado, (denotado por la extensin .h) contiene informacin acerca libreras de funciones tales como registros especiales de un PIC especfico, etc. Ejemplo:#include

10

Esta informacin la utiliza el compilador para conectar detalles especficos de hardware y el programa fuente. El siguiente ejemplo es hecho en el compilador C de CCS.#include //definicion del PIC especifico #include #fuses XT,NOWDT, PUT, NOPROTECT //palabra de configuracin #use delay(clock=4000000) //frecuencia del oscilador #use rs232(baud=9600,xmit=PIN_B0,rcv=PIN_B1) void main() { Printf("Escriba caracteres:"); while(TRUE) putc(toupper(getc())); //toupper convierte a maysculas }

Las definiciones de PIN_B0 y PIN_B1 se encuentran en el archivo de encabezado 16F84A.h. La funcin toupper() se encuentra en el archivo de encabezado ctype.h. Ambos archivos deben estar en el programa para que el compilador tenga la informacin acerca de las funciones que usted est usando. Habr notado probablemente que la directiva #include no termina con punto y coma. La razn para esto es que esta directiva no es una palabra clave de C, pero en cambio es una instruccin del compilador. Todo el contenido de la librera incluida es insertado en el archivo fuente en la etapa de compilacin. FUNCION PRINTF Es una funcin estndar contenida en el archivo de encabezado stdio.h. printf() le permite al programa imprimir informacin en pantalla. El formato general para printf() es:printf("Texto de control", Argumentos);

Texto de control es una cadena de caracteres entre comillas dobles. La cadena de caracteres puede ser una combinacin de letras, nmeros y smbolos. Algunos smbolos especiales de formato estn denotados con el smbolo %. Argumentos es una entrada opcional y puede estar compuesto por constantes y variables que utilice el programa y que se quieren imprimir. Los siguientes dos ejemplos muestran a printf() imprimiendo un mensaje e imprimiendo una constante del programa.printf("Hola Mundo!"); printf("Microchip es el #%d!",1);

%d da el formato para la constante que se est imprimiendo. La Tabla 1 muestra todos los especificadores de formato de C y el tipo de datos que afectan.

11

Tabla 1. Especificadores de formato en C. Especificador de formato Tipo de dato que afecta %c Carcter sencillo %uc Carcter sin signo %s Cadena de caracteres %d Enteros decimales con signo %f Punto flotante (notacin decimal) %e Punto flotante (notacin exponencial o cientfica) %g Punto flotante (%f o %e, cualquiera en su formato corto) %u Enteros decimales sin signo %x, %X Enteros hexadecimales sin signo %p Apuntador %o Enteros octales sin signo l Prefijo usado con %d, %u, %x, %o para especificar entero largo

NOTA: Un 0 (cero) seguido del smbolo % dentro de un formato de cadena obliga a imprimir los ceros que estn al comienzo. El siguiente nmero especifica el tamao del campo a imprimir. Ejemplo:printf("El Hex del decimal 12 es %03x\n",12);

Imprime en pantalla lo siguiente:El Hex del decimal 12 es 00c Tabla 2. Caracteres especiales. \n \t \r \f \ \ \\ Smbolos Especiales Lnea nueva Tab horizontal Retorno de carro Formfeed Comilla sencilla Comilla doble Backslash \? \a \b \0 \v \xhhh %% Smbolo de interrogacin Beep Backspace Carcter nulo(null) Tab vertical Inserta cdigo hex hhh Signo de porcentaje

El formato de especificacin puede ser tambin as: %[flags][ancho][.presicion], entonces retomando un ejemplo anterior:printf("El area es %6.4f unidades cuadradas\n",area);

Esta instruccin imprime en pantalla el valor de area en un espacio con ancho de 6 y precisin decimal de 4 posiciones. VARIABLES Una variable es un nombre que se le da a una localizacin especfica de memoria. Esta localizacin de memoria puede guardar varios valores dependiendo de cmo haya sido declarada la variable. En C, todas las variables deben declararse antes de ser usadas. Una declaracin de variables le

12

informa al compilador que tipo de variable est siendo usada. Todas las declaraciones de variables son instrucciones en C y por consiguiente deben finalizar con un punto y coma. Los cinco tipos bsicos de datos que soporta C son: char, int, float, double, void. El formato general para declarar una variable es el siguiente:TipoVariable NombreVariable;

Un ejemplo de declaracin de un variables es: char ch;. El compilador interpreta esta instruccin como la definicin de la variable ch como tipo char (caracter o entero sin signo de 8 bits). CONSTANTES Una constante es un valor fijo que no puede ser alterado por el programa. Por ejemplo, 25 es una constante. Las constantes enteras son especificadas sin ninguna componente fraccional como -100 o 40. Constantes en punto flotante requieren punto decimal seguido por su componente fraccional. El nmero 456.75 es una constante en punto flotante. Los caracteres tambin son constantes y deben estar encerradas por comillas sencillas como 'A' o '&'. Cuando el compilador encuentra una constante en el programa, este decide qu tipo de constante es. El compilador C podr, por defecto, acomodar la constante dentro del tipo de dato ms pequeo que lo pueda contener. As que 15 es un tipo int, 64000 es un tipo long y 105020 es un tipo int32. Una constante es declarada usando la sentencia #define.#define valor

define el nombre que usar a travs del programa, valor es el valor que se le asignara a . Ejemplos:#define VERDADERO 1 #define pi 3.14159265359

Usted puede especificar el tipo de constante usando los siguientes sufijos:F U punto flotante unsigned FL L long double long

C le permite especificar constantes en los formatos hexadecimal y octal. Las constantes hexadecimales deben tener el prefijo '0x'. Por ejemplo 0xA4 es una constante hexadecimal valida. En adicin a las constantes numricas, C soporta constantes tipo string (cadena de caracteres). Las cuales son una serie de caracteres encerrados entre comillas dobles. Las constantes no son almacenadas en memoria, son resueltas en tiempo de compilacin. Para guardar constantes en la memoria ROM del chip, use la palabra clave const en la declaracin de una variable. Por ejemplo:char const id[5]={"1234"};

13

Se estn usando cinco localizaciones de memoria para guardar la cadena porque esta debe terminar con el carcter null (\0) como se explicar ms adelante. COMENTARIOS Los comentarios son empleados para documentar el significado y operacin del cdigo fuente. Todos los comentarios son ignorados por el compilador. Un comentario puede ser puesto en cualquier parte del programa excepto en la mitad de alguna instruccin, nombre de funcin o nombre de variable. Los comentarios pueden abarcar muchas lneas y pueden ser usados para remover temporalmente una lnea de cdigo. Finalmente, los comentarios no se pueden anidar. Los comentarios tienen dos formatos. El primer formato es usado por todos los compiladores de C y es el siguiente:/* Este es un comentario */

El segundo formato es soportado por la mayora de compiladores y es el siguiente:// Este es un comentario

FUNCIONES Las funciones son los bloques de construccin bsicos de un programa en C. todos los programas en C contienen al menos una funcin, main(). La mayora de los programas que usted escribe contendr muchas funciones. El formato para un programa en C con muchas funciones es el siguiente:void main() { } funcion1() { } funcion2() { }

main() es la primera funcin llamada cuando el programa se est ejecutando. Las otras funciones, funcion1() y funcion2(), pueden ser llamadas por cualquier otra funcin en el programa. Tradicionalmente main() no es llamada por ninguna otra funcin, sin embargo, no hay restricciones en C con respecto a esto. El siguiente es un ejemplo de dos funciones en C.#include void main() { printf("Me ");

14

funcion1(); printf("C."); } funcion1() { printf("gusta programar en"); }

Una cuestin que hay que tener en cuenta al escribe sus propias funciones es que cuando el corchete de cierre es alcanzado, el programa continuar ejecutndose una lnea despus del punto en el cual la funcin ha sido originalmente llamada. COMPATIBILIDAD CON HARDWARE El compilador necesita saber acerca del hardware para que el cdigo pueda ser compilado correctamente. Un programa tpico en el compilador C de CCS puede comenzar as:#include #fuses XT,NOWDT, PUT, NOPROTECT #use delay(clock=4000000)

La primera lnea incluye las definiciones especficas del dispositivo tales como nombre de pines, registros especiales, etc. La segunda lnea establece la palabra de configuracin del PIC, para este caso se deja al oscilador de cristal como oscilador del dispositivo, se desactiva el Watch Dog Timer, se habilita el Power-up Timer y se desactiva la proteccin de cdigo. La ltima lnea le informa al compilador la velocidad del oscilador. Las siguientes lneas son otro ejemplo:#use rs232(baud=9600,xmit=PIN_C6,rcv=PIN_C7) #use i2c(master,scl=PIN_B6,sda=PIN_B7) //config. RS232 //config. I2C

En adicin, las variables de C pueden ser creadas y mapeadas a registros del hardware. Estas variables pueden ser bits o bytes. Despus que son definidas, pueden ser utilizadas en un programa como cualquier otra variable. Ejemplo:#bit carry=3.0 #byte portb=6 #byte intcon=11

PALABRAS CLAVES DE C El estndar C ANSI define 32 palabras clave para usar en el lenguaje C. En C, ciertas palabras son reservadas del compilador para definir tipos de datos y para su uso en loops (bucles o lazos). Todas las palabras claves de C deben escribirse en minscula para que el compilador las reconozca. Tpicamente, la mayora de los compiladores de C agregan varias palabras adicionales que toman ventaja de la arquitectura del procesador. La siguiente es una lista de las palabras claves de C:

15

auto break case char const continue default do

double else enum extern float for goto if

int long register return short signed sizeof static

struct switch typedef union unsigned void volatile while

Ejercicios 1. Escriba un programa en Microsoft Visual C++ Express que imprima en pantalla su nombre, su documento de identidad y su email e lneas diferentes. 2. Escriba un programa en Microsoft Visual C++ Express que declare una variable tipo entera llamada year. Esta variable debe entregar el valor del ao actual y luego, usando la funcin printf(), mostrar el valor del ao en pantalla. El resultado de su programa debe parecerse a lo siguiente: El ao es 2011.

16

2. VARIABLES Un aspecto importante del lenguaje C es como este almacena datos. Este captulo examinar ms en detalle cmo se usan las variables en C para almacenar datos. TIPOS DE DATOS El lenguaje de programacin C soporta cinco tipos de datos bsicos (como se haba comentado en el capitulo anterior) y cuatro tipos de modificadores. La Tabla 3 muestra la definicin de los tipos de datos bsicos y el tipo de modificador.Tabla 3. Tipos de datos y modificadores en C. Tipo Significado Carcter Dato carcter Entero Nmeros enteros con signo Flotante Nmeros con punto flotante Doble precisin Nmeros con punto flotante de doble precisin Vacio (void) Sin valor Con signo Nmeros positivos o negativos Sin signo Solo nmeros positivos Largo Duplica el tamao de un nmero corto Mitad del tamao de un nmero

Palabra clave char int float double void signed unsigned long short

Cada tipo de dato representa un rango particular de nmeros, que pueden cambiar dependiendo del modificador usado. La Tabla 4 muestra los posibles rangos de valores para algunos tipos de datos bsicos y los modificadores en CCS C.Tabla 4. Rangos de valores de los tipos de datos en CCS C. Tipo Tamao bit short (int1) 1 int (int8) 8 long (int16) 16 long long (int32) 32 float (float32) 32 char (unsigned int8) 8 void signed int8 8 signed int16 16 signed int32 32 Rango 0 a 1 0 a 255 0 a 65535 0 a 4294967295 -1.5E45 a 3.4E38 0 a 255 Sin valor -128 a 127 -32768 a 32767 -2147483648 a 2147483647

NOTA: revisar la documentacin del compilador C para tipos de datos y rangos numricos actualizados. Todos los tipos, excepto float, por defecto son unsigned. C permite una notacin ms corta para los tipos unsigned int, short int, y long int. Simplemente use las palabras unsigned, short o long sin la palabra int. Para realizar las operaciones aritmticas de una forma sencillas para la CPU, C representa todos los nmeros negativos en el formato complemento a 2. Para encontrar el complemento a 2 de un nmero simplemente invierta todos los bits y sume 1 al resultado. Por ejemplo, para convertir el nmero con signo +29 en complemento a 2 se procede as:

17

00011101= 11100010 + 1 ________ 11100011=

29 se invierten todos los bits se suma 1 -29

Ejercicios 1. Escriba la siguiente declaracin de otra manera. long int i; 2. Para entender la diferencia entre un nmero con signo y uno sin signo, escriba el siguiente programa en Microsoft Visual C++ Express. El entero sin signo 35000 es representado por -30536 en el formato entero con signo.#include void main() { short int i; // entero con signo equiv. a signed int16 en CCS unsigned short int u; // entero sin signo equiv. a int16 en CCS u = 35000; i = u; printf("%d %u\n",i,u); getchar();//detiene la ejecucin hasta oprimir ENTER }

DECLARACION DE VARIABLES Las variables pueden ser declaradas en dos lugares bsicos: dentro de una funcin o por fuera de todas las funciones. Las variables son llamadas locales o globales respectivamente. Las variables son declaradas de la siguiente forma:TipoVariable NombreVariable;

Donde TipoVariable es uno de los tipos de datos validos en C y NombreVariable es el nombre asignado a la variable. Las variables locales (declaradas dentro de una funcin) solo pueden ser usadas por las instrucciones dentro de la funcin donde ha sido declarada. El valor de una variable local no puede ser accesado por otras funciones por fuera de la funcin de origen. La cosa ms importante a recordar acerca de las variables locales es que son creadas al momento de entrar a la funcin y destruidas cuando la funcin ha finalizado. Las variables locales deben declararse al comienzo de la funcin antes de las instrucciones. Es aceptable para variables locales que estas tengan nombres iguales en diferentes funciones. Considere el siguiente ejemplo.#include void f2() { int cont; for (cont=0; contmax || !(max==57) && var>=0

Otra parte de C que emplea los operadores relacionales y lgicos son las instrucciones de control de programa que se estudiarn en el siguiente captulo. Ejercicios 1. Reescriba la siguiente expresin usando cualquier combinacin de operadores relacionales y lgicos.cont == 0; result > expresin

El valor de expresin determina cuantos lugares hacia la izquierda o derecha variable es desplazada. Cada desplazamiento hacia la izquierda causa que todos los bits de corran una posicin de bit a la izquierda, y un cero es insertado sobre el lado derecho. El bit que es desplazado fuera del final de variable se pierde. La nica situacin a resaltar acerca del uso de los desplazamientos es que un desplazamiento hacia la izquierda es equivalente a multiplicar un nmero por 2 y un desplazamiento hacia la derecha es equivalente a dividir un nmero por 2. Los operadores de desplazamiento son casi siempre ms rpidos que su equivalente operacin aritmtica debido a cmo trabaja la CPU. Un ejemplo de todos los operadores bit a bit se muestra a continuacin.AND 00000101 (5) 00000110 (6) -----------00000100 (4) XOR 00000101 (5) 00000110 (6) -----------00000011 (3) DESP IZQ. 00000101 (5) > 2 -----------00000001 (1)

&

|

~

^

NOTA: no realice desplazamientos mas all de los bits que el operando posea, debido a que se obtiene un resultado indefinido.a = b | c; Se convierte en: 0007: 0008: 0009: a = b & c; Se convierte en: 0007: 0008: 0009: a = b >> 3; Se convierte en: 0007: 0008: 0009: 000A: 000B: 000C: 000D: j = ~a;

MOVF IORWF MOVWF

b,W c,W a

;carga b ;opera b OR c ;guarda en a

MOVF ANDWF MOVWF

b,W c,W a

;carga b ;opera b AND c ;guarda en a

MOVF MOVWF RRF RRF RRF MOVLW ANDWF

b,W a a,F a,F a,F 1F a,F

;carga b ;guarda en a ;rota el contenido ;hacia la derecha ;tres veces ;enmascara el contenido ;del registro para a

35

Se convierte en: 0007: 0008: 0009:

MOVF MOVWF COMF

a,W j j,F

;carga a ;guarda en j ;complementa j

Ejercicios 1. Escriba un programa que invierta los bits ms significativos (MSB) de un dato tipo signed char. 2. Escriba un programa que imprima la representacin binaria de un nmero tipo char. OPERADORES INCREMENTALES Y DECREMENTALES Cmo podra usted incrementar o decrementar en una unidad una variable? Probablemente una de dos formas le vendra a la mente. Tal vez las siguientes:a = a + 1; o a = a - 1;

Una vez ms, los creadores de C han llegado con una notacin abreviada para incrementar o decrementar un nmero. Los formatos generales son los siguientes:a++; a--; o o ++a; --a; para incrementar para decrementar

Cuando los signos ++ o -- preceden la variable, la variable es incrementada y despus el valor es usado en una expresin. Cuando los signos ++ o -- van despus de la variable, el valor de la variable se usa en la expresin y luego se incrementa.int j, a = 3; 0007: 0008: j = ++a; 0009: 000A: 000B: j = a++; 000C: 000D: 000E: MOVLW MOVWF INCF MOVF MOVWF MOVF INCF MOVWF 03 a a,F a,W j a,W a,F j

;registro asignado a a ;a = 4 ;carga a en w ;almacena w en j ;carga el valor de a en w ;a = 5 ;almacena w en j, j = 4

NOTA: no utilice la siguiente expresin.a = a++;

Porque se genera el siguiente error en el cdigo generado:MOVF INCF MOVWF a,W a,F a ;valor de a cargado en w ;valor de a incrementado ;el valor previo es recargado sobrescribiendo el ;valor incrementado

36

El siguiente ejemplo ilustra los dos usos.#include void main(void) { int i,j; i = 10; j = i++; printf("i = %d, j = %d\n",i,j); i = 10; j = ++i; printf("i = %d, j = %d\n",i,j); }

El primer printf() imprimir un 11 para i y un 10 para j. el segundo printf() imprimir un 11 para ambos i y j. Mezclando operadoresEscribiendo sum = a+b++ sum = a+b-sum = a+ ++b sum = a+ --b Se obtine sum = a+b sum = a+b b = b+1 b = b-1 b = b = sum sum b+1 b-1 = a+b = a+b

Ejercicios 1. Reescriba los operadores de asignacin en el siguiente programa para incrementar o decrementar las variables.void main(void) { int a, b; a = 1; a = a+1; b = a; b = b-1; printf("a=%d, b=%d\n", a,b); }

2. Cules son los valores de a y b despus de que el siguiente segmento de cdigo se ha ejecutado?a = 0; b = 0; a = ++a + b++; a++; b++; b = --a + ++b;

PRECEDENCIA DE OPERADORES La precedencia se refiere al orden en el cual los operadores son procesados por el compilador C. por ejemplo, si la expresin a+b*c se encontrar en su programa, Qu operacin ocurrira en primer lugar, la suma o la multiplicacin? El lenguaje C mantiene precedencia para todos los operadores. La siguiente lista muestra la precedencia desde la ms alta a la ms baja. 37

Prioridad 1 2 3 4 5 6 7 8 9 10 11 12 13

Operador () ++ -sizeof & * + - ~ ! ++ -* / % + > < > = == != & ^ | && || = *= /= %= += -= = $= ^= |=

Ejemplo (a+b)/c a=-b a%b a+b a=b>>c a>=b a==b a=b&c a=b^c a=b|c a=b&&c a=b||c a+=b

parentesis mas/menos/NOT/complemento incremento/decremento/sizeof multi/dividir/modulo suma/resta Desp izg. o derecho mayor/menor/igual que AND bit a bit XOR bit a bit OR bit a bit AND lgico OR lgico asignacin

Algunos de estos operadores todava no los hemos estudiado, pero no se preocupe, los estudiaremos ms adelante. Los parntesis pueden usarse para fijar el orden especfico en el cual las operaciones se lleven a cabo. Un par de ejemplos del uso del parntesis para clarificar o cambiar la precedencia de una declaracin son los siguientes:10-2*5 = 0 (10-2)*5 = 40 cont*sum+88/val-19%cont (cont*sum) + (88/val) (19%cont)

38

5. DECLARACIONES DE CONTROL DEL PROGRAMA En este captulo aprender acerca de las instrucciones que C usa para controlar el flujo de ejecucin en un programa. Adems aprender como los operadores relacionales y lgicos se usan con estas declaraciones de control. DECLARACION if La declaracin if es una instruccin del tipo condicional. El bloque de cdigo asociado con la instruccin if es ejecutado basado en el resultado de una condicin. Nuevamente, cualquier valor diferente de cero es verdadero y cualquier valor cero es falso. El formato ms sencillo es el siguiente:if (expresion) { . instruccones; . }

Los corchetes {} se usan para encerrar el boque de cdigo. Esto le informa al compilador que si la expresin es verdadera, ejecute el cdigo dentro de los corchetes. Ejemplo:if (cont < 0) { Cont = 0; printf("cuenta descendente\n"); } if (TestMode == 1) { ... Haga esto }

Otros operadores de comparacin usados en la instruccin if son los siguientes:x x x x x x x x == y != y > y < y = y && y || y x igual a y x es diferente a y x es mayor que y x es menor que y x es menor o igual que y x es mayor o igual que y AND lgica OR lgica

Un ejemplo de una de estas funciones convertida en Assembler es el siguiente:int j, a = 3; 0007: 0008: if (j == 2) 0009: 000A: 000B: 000C: { j = a; MOVLW MOVWF MOVLW SUBWF BTFSS GOTO 03 a 02 j,W STATUS,Z 00F ;carga a con 3 ;carga w con 2 ;testeo entre w y j ;si es cero salta ;j no es igual a 2

39

000D: 000E: } 000F:

MOVF MOVWF

a,W j

;como es cero ;carga a en j

Ejercicios 1. Cules de las siguientes expresiones resultan en un valor verdadero?a. b. c. d. e. 0 1 -1 5*5