MANUAL DE USUARIO DEL COMPILADOR PCW DE CCS®

Escrito por Andrés Cánovas López Reeditado para formato PDF por Víctor Dorado

Arreglado por Evelio Granizo

2

ÍNDICE 1.INTRODUCCIÓN............................................................................................................... 3 2.PROGRAMAS DE UTILIDAD ............................................................................................ 3 3.OPERADORES Y EXPRESIONES ..................................................................................... 10 4. DEFINICIÓN DE DATOS ............................................................................................... 14 5. SENTENCIAS DE CONTROL ............................................................................................ 16 6. DEFINICIÓN DE FUNCIÓN ............................................................................................ 17 7. FUNCIONES: PARÁMETROS POR VALOR Y POR REFERENCIA ............................ 18 8. EDICIÓN DE UN PROGRAMA EN C .............................................................................. 18 9. PROTOTIPO DE UNA FUNCIÓN .............................................................................. 18 10. ESTRUCTURA DE UN PROGRAMA EN C ................................................................... 19

3

1. INTRODUCCIÓN Si se quiere realizar la programación de los microcontroladores PIC en un lenguaje como el C, es preciso utilizar un compilador de C. Dicho compilador genera archivos en formato Intel-hexadedimal, que es el necesario para programar (utilizando un programador de PIC) un microcontrolador de 6, 8, 18 ó 40 patillas. El compilador de C que se va a utilizar es el PCW de la casa CCS Inc. A su vez, el compilador tiene un entorno de desarrollo integrado (IDE) que va a permitir desarrollar todas y cada una de las fases que se compone un proyecto, desde la edición hasta la compilación pasando por la depuración de errores. La última fase, a excepción de la depuración y retoques de hardware finales, será programar el PIC. Al igual que el compilador de Turbo C, éste "traduce" el código C del archivo fuente (.C) a lenguaje máquina para los microcontroladores PIC, generando así un archivo en formato hexadecimal (.HEX). Además de éste, también genera otros seis archivos. 2. PROGRAMAS DE UTILIDAD • SIO SIO (Serial Input Output) es un simple programa "terminal no inteligente" que puede ejecutarse desde el DOS para realizar entradas y salidas sobre un puerto serie. SIO es útil ya que muestra todos los caracteres entrantes, excepto los no imprimibles. • PICCHIPS PICCHIPS es un programa de utilidad que lee la base de datos de un dispositivo. El compilador utiliza esta base de datos para determinar las características específicas del dispositivo durante la compilación. Al ejecutar el programa sin ningún parámetro, listará todos los dispositivos (PIC) disponibles. Si e especifica un dispositivo como parámetro p.ej. pic16c84, es decir, se escribe picchips pic16c84, se obtiene información detallada sobre este dispositivo. A modo de ejemplo y para el citado PIC se obtiene la siguiente información: PIC16C84-------------------------------------------------------------- Opcode: 14 bits, ROM: 1024, RAM: 36, I/O: 13 H/W: EEPROM(64) POR TIM0 TRIS RAM: 0C-2F Ports: [A:01234---] [B:01234567] [C:--------] [D:--------] [E:--------] Fuses: LP: 0003/0000 XT: 0003/0001

HS: 0003/0002 RC: 0003/0003 NOWDT: 0004/0000 WDT: 0004/0004 NOPUT: 0008/0000 PUT: 0008/0008 PROTECT: 3FF0/0000 NOPROTECT: 3FF0/3FF0 ID is at 2000 Par Device value: 0084 C Device value: 84, C-Scratch at: 0C

4

• CHIPEDIT ChipEdit es una utilidad de Windows (sólo para PCW) que permite editar la base de datos de un dispositivo. Con esta utilidad se puede agregar dispositivos, modificarlos o eliminarlos de la base de datos. Para agregar un dispositivo, seleccionar de la lista otro equivalente, de caracteríticas similares, y pulsar el botón ADD. Para editar o borrar un dispositivo, seleccionarlo y pulsar el botón EDIT o DELETE. • CONVERT PConvert es una utilidad de Windows (PCW sólo) que permite realizar conversiones de un tipo de datos a otros tipos. Por ejemplo, de decimal en Punto Flotante a Hexadecimal de 4 byte. La utilidad abre una ventana peque¤a para realizar las conversiones y puede permanecer activa durante una sesión con PCW o con MPLAB. Esto puede ser útil durante el proceso de depuración de un programa. • COMPILADORES Los compiladores PCB, PCM, PCH son independientes. PCB es opcodes de 12-bit, PCM es opcodes de 14-bits y PCH es para microcontroladores PIC opcodes de 16-bit. Los tres compiladores tienen muchas similitudes. Estos compiladores están específicamente diseñados para satisfacer las necesidades únicas de los microcontroladores PIC. Esto permite a los desarrolladores que diseñen rápidamente aplicaciones de software de una manera más legible y de alto nivel. Cuando se compara con un compilador C más tradicional, PCB, PCM, y PCH tienen algunas limitaciones. Como un ejemplo de las limitaciones, la recursión de funciones no está permitida. Esto es debido al hecho de que el PIC no tiene pila para empujar las variables en la misma, y también debido a la forma en que los compiladores optimizan el código. Los compiladores pueden implementar con eficacia: las construcciones normales de C, las operaciones de entrada/salida, y operaciones de bits. Todos los tipos normales de datos C son compatibles junto con punteros a los arrays constantes, decimal de punto fijo, y los arrays de bits. Compilador PCW CCS El compilador PCW CCS es una buena opción para elegirlo como compilador de C para programar Microcontroladores PIC. Algunas de las características de este compilador son: • Al compilar genera un código máquina muy compacto y eficiente. • Se integra perfectamente con MPLAB y otros simuladores/emuladores como

PROTEUS para el proceso de depuración. • Incluye una biblioteca muy completa de funciones precompiladas para el acceso al

hardware de los dispositivos (entrada/salida, temporizaciones, conversor A/D, transmisión RS-232,bus I2C….,etc.)

5

• Incorpora drivers para dispositivos externos, tales como pantallas LCD, teclados numéricos, memorias EEPROM, conversores A/D, relojes en tiempo real, etc.(los drivers son pequeños programas que sirven de interfaz entre los dispositivos hardware y nuestro programa).

• Permite insertar partes de código directamente en Ensamblador, manteniendo otras partes del programa en C.

Las características del lenguaje C para este compilador se muestran a continuación: El lenguaje C estándar es independiente de cualquier plataforma, sin embargo, para la programación de microcontroladores es necesario disponer de determinados comandos que se refieran a partes específicas de su hardware, como: el acceso a memoria, temporizadores, etc. Por este motivo, además de los comandos, funciones y datos del lenguaje ANSI C, el compilador PCW incluye bibliotecas que incorporan determinados comandos que no son estándar, sino específicos para la familia de microcontroladores PIC. Éstos son básicamente de dos tipos: directivas del preprocesador y funciones precompiladas, las cuales son diferentes para cada Compilador C, a continuación se describen:

a. Directivas del preprocesador. El compilador PCW dispone de 7 tipos básicos de directivas:

1. Directivas derivadas del estándar de C, que permiten, entre otras funciones, un control básico del código y del flujo en el proceso de compilación:

#DEFINE #ELIF #ELSE #ENDIF #ERROR #IF #IFDEF #IFNDEF #INCLUDE #LIST #NOLIST #PRAGMA #UNDEF

2. Directivas asociadas a las bibliotecas precompiladas, que proporcionan al

compilador información relacionada con estas bibliotecas:

#USE DELAY #USE FAST_IO #USE FIXED_IO #USE I2C #USE RS232 #USE STANDARD_IO

6

3. Directivas relacionadas con la especificación del dispositivo, por un lado, para definir los mapas de memoria y el juego de instrucciones, y por otro, incluir información necesaria para la programación del dispositivo en los archivos de salida de la compilación:

#DEVICE #ID #FUSES #TYPE

4. Directivas de cualificación de funciones, para identificar características especiales de una función:

#INLINE #INT_DEFAULT #INT_GLOBAL #INT_xxxxx #SEPARATE

5. Directivas de control del compilador, para definir opciones referidas a la compilación del código del programa:

#CASE #OPT #ORG #PRIORITY

6. Directivas de control de la memoria del microcontrolador, para gestionar y reservar el uso de determinadas zonas de memoria para variables:

#ASM #BIT #BYTE #ENDASM #LOCATE #RESERVE #ROM #ZERO_RAMç

7. Identificadores predefinidos. Todas las directivas citadas hasta ahora, son comandos destinados a ser interpretados por el compilador, no por el microcontrolador. Dentro del término genérico de directiva se incluyen, además de estos comandos, unas variables que contienen información sobre el proceso de compilación. Estas variables son lo que se denominan identificadores predefinidos del compilador:

__DATE__ __DEVICE__ __PCB__

7

__PCH__ __PCM__

NOTA: En un programa, las directivas se reconocen fácilmente porque

comienzan por el símbolo #, mientras que los identificadores empiezan y acaban por doble subrayado (__).

b. Funciones precompiladas. Existen funciones en C incluidas en el compilador

PCW para manejar los diferentes recursos del microcontrolador, desde el bus I2C hasta el conversor A/D. También, se puede facilitar considerablemente la tarea de programación, construyendo por nosotros mismos aquellas funciones que son de utilización más frecuente, como leer la entrada de un teclado o imprimir un determinado mensaje en una pantalla LCD conectada como salida. El compilador PCW dispone de 16 tipos de funciones:

1. Funciones de I/O serie RS232

GETC() GETCH() GETCHAR() GETS(char *string) PUTC() PUTCHAR() PUTS(string) PRINTF([function],) KBHIT() SET_UART_SPEED(baud)

2. Funciones de I/O con el BUS I2C

I2C_POLL() I2C_READ() I2C_START() I2C_STOP() I2C_WRITE(byte)

3. Funciones de I/O DISCRETA

INPUT(pin) OUTPUT_BIT(pin, value) OUTPUT_FLOAT(pin) OUTPUT_HIGH(pin) OUTPUT_LOW(pin) PORT_B_PULLUPS(flag) SET_TRIS_X(value)

4. Funciones de RETARDOS

DELAY_CYCLES(count) DELAY_MS(time) DELAY_US(time)

8

5. Funciones de CONTROL del PROCESADOR

DISABLE_INTERRUPTS(level) ENABLE_INTERRUPTS(level) EXT_INT_EDGE(edge) READ_BANK(bank, offset) RESTART_CAUSE() SLEEP() WRITE_BANK(bank,offs)

6. CONTADORES/TEMPORIZADORES

i=GET_RTCC() GET_TIMER0() GET_TIMER1() GET_TIMER2() RESTART_WDT() SET_RTCC(value) SET_TIMER0(value) SET_TIMER1(value) SET_TIMER2(value) SETUP_COUNTERS(rtcc_st) SETUP_TIMER_1(mode) SETUP_TIMER_2(mode,per)

7. Funciones de I/O PSP PARALELA

PSP_INPUT_FULL() PSP_OUTPUT_FULL() PSP_OVERFLOW() SETUP_PSP(mode)

8. Funciones de I/O SPI A DOS HILOS

SETUP_SPI(mode) SPI_DATA_IS_IN() SPI_READ() SPI_WRITE(value)

9. Funciones para el LCD

LCD_LOAD(buffer_poin) LCD_SYMBOL(symbol,b7) SETUP_LCD(mode,presc)

10. Funciones del C ESTÁNDAR

ABS(x) ACOS(x) ASIN(x) ATAN(x) ATOI(char *ptr) ATOL(char *ptr) f=CEIL(x)

9

f=EXP(x) f=FLOOR(x) ISALNUM(char) ISALPHA(char) ISDIGIT(char) ISLOWER(char) ISSPACE(char) ISUPPER(char) ISXDIGIT(char) LABS(l) LOG(x) LOG10(x) MEMCPY(dest, source, n) MEMSET(dest, value, n) SQRT(x)

11. Funciones de Manejo de Cadenas

STRICMP(char*s1,char*s2) STRNCMP(char*s1,char*) STRxxxx(char*s1,char) STRCPY(dest, SRC) c=TOLOWER(char) c=TOUPPER(char)

12. Voltaje de Referencia VREF SETUP_VREF(mode)

13. Funciones de ENTRADA A/D

SETUP_ADC(mode) SETUP_ADC_PORTS(value) SET_ADC_CHA NNEL(chan) i=READ_ADC()

14. Funciones CCP

SETUP_CCP1(mode) SETUP_CCP2(mode) SETUP_COMPARATOR(mode) SET_PWM1_DUTY(value) SET_PWM2_DUTY(value)

15. Funciones para la EEPROM interna

READ_CALIBRATION(n) READ_EEPROM(address) WRITE_EEPROM(address,value)

16. Funciones de MANIPULACIÓN DE BITS

BIT_CLEAR(var,bit)

10

BIT_SET(var,bit) BIT_TEST(var,bit) ROTATE_LEFT(addr,byte) ROTATE_RIGHT(addr,byte) SHIFT_LEFT(addr,byte,val) SHIFT_RIGHT(addr,byte,val) SWAP(byte)

3. OPERADORES Y EXPRESIONES • Operadores de asignación

Una expresión de asignación tradicional es de la forma:

expr1 = expr1 operador expr2 Por ejemplo:

i = i + 5 Esta expresión se puede representar por otra forma más corta:

expr1 operador = expr2 Siguiendo con el mismo ejemplo:

i += 5 Es en las expresiones complejas, y no en una tan simple como la del ejemplo, donde se puede apreciar la conveniencia de usar esta notación. La siguiente tabla resume los operadores de asignación compuesta y su significado.

Operador Descripción += Asignación de suma -= Asignación de resta *= Asignación de multiplicación /= Asignación de división

%= Asignación de resto de división << = Asignación de desplazamiento a la izquierda >> = Asignación de desplazamiento a la derecha & = Asignación de AND de bits |= Asignación de OR de bits

^^= Asignación de OR exclusivo de bits ~= Asignación de negación de bits

11

• Operadores aritméticos

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 • Operadores relacionales

Su misión es comparar dos operandos y dar un resultado entero: 1 (verdadero); 0 (falso). La siguiente tabla ilustra estos operadores:

Operador Descripción < Menor que > Mayor que

< = Menor o igual que > = Mayor o igual que == Igual a != Distinto de

• Operadores lógicos

Al igual que los operadores relacionales, éstos devuelven 1 (verdadero), 0 (falso) tras la evaluación de sus operandos. La tabla siguiente ilustra estos operadores.

Operador Descripción ! NO lógico

&& Y lógico || O lógico

• Operadores de manejo de bits

Estos operadores permiten actuar sobre los operandos a nivel de bits y sólo pueden ser de tipo entero (incluyendo el tipo char). Son los que siguen:

12

Operador Descripción ~ Negación de bits (complemento a 1) & Y de bits (AND) ^^ O exclusivo de bits (EXOR) | O de bits (OR)

• Operadores de incremento y decremento

Aunque estos operadores forman parte del grupo de operadores de asignación, se ha preferido separarlos en aras a una mayor claridad. Su comportamiento se asemeja a las instrucciones de incremento incf f,d del ensamblador del µcontrolador PIC 16x84 o inc variable del Intel 8051.

Operador Descripción ++ Incremento -- Decremento

• Operadores de desplazamiento de bits

Los operadores de desplazamiento otorgan al C capacidad de control a bajo nivel similar al lenguaje ensamblador. Estos operadores utilizan dos operandos enteros (tipo int): el primero es el elemento a desplazar y el segundo, el número de posiciones de bits que se desplaza. Se resúmen en la siguiente tabla:

Operador Descripción >> Desplazamiento a la derecha << Desplazamiento a la izquierda

• Operadores de dirección (&) e indirección (*)

Los operadores & y * se utilizan para trabajar con punteros. El lenguaje C está muy influenciado por el uso de punteros. Un puntero es una variable que contiene la dirección de una variable o de una función, es decir, es una variable que apunta a otra variable. Los punteros permiten la manipulación indirecta de datos y códigos. Se dispone de dos operadores; véase la siguiente tabla:

Operador Descripción

& De dirección * De indirección

13

El operador de dirección &, da la dirección de memoria de su operando. El resultado es un puntero al objeto, esto es, a un tipo de datos. Por ejemplo, si se quiere guardar en el puntero p la dirección de memoria de la variable entera contador, se debes hacer lo siguiente:

p = &contador; /* p apunta a la dirección de contador */

El operador de indirección *, da el valor o contenido de la variable cuya dirección está apuntada por el puntero.

p = &contador; /* p apunta a la dirección de contador */ a = *p; /* guarda en a el contenido de la var apuntada por p */

• 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)

Identificadores ABCDE Hasta 32 caracteres (no puede empezar con números) ID[X] Un subíndice

ID[X][X] Múltiples subíndices ID.ID Referencia a una estructura o una unión

ID-->ID Referencia a una estructura o una unión

14

Expresiones en orden descendente de precedencia

(expr)

!expr ~expr ++expr expr++ --expr expr--

(type)expr *expr & value sizeof(type)

expr*expr expr/expr expr%expr

expr+expr expr-expr

expr<<expr expr>>expr

expr<expr expr<=expr expr>expr expr>=expr

expr==expr expr!=expr

expr&expr

expr^expr

expr | expr

expr&& expr

expr || expr

!value ? expr: expr

value=expr value+=expr value-=expr

value*=expr value/=expr value%=expr

value>>=expr value<<=expr value&=expr

value^=expr value|=expr expr,expr

4. DEFINICIÓN DE DATOS

1. Definiciones de Datos

typedef [calificador_tipo] [especificador_tipo] [identificador] static Variable estática e inicializada a 0 (que se puede utilizarla

como global) auto La variable existe mientras el procedimiento está activo

Es el valor por defecto, por eso no es necesario poner auto 2. Especificadores de tipo:

unsigned define un número de 8 bits sin signo unsigned int define un número de 8 bits sin signo int define un número de 8 bits sin signo char define un número de 8 bits sin signo long define un número de 16 bits sin signo long int define un número de 16 bits sin signo signed define un número de 8 bits con signo signed int define un número de 8 bits con signo signed long define un número de 16 bits con signo float define un número de 32 bits en punto flotante short define un bit short int define un bit

15

identificador Identificador de una definición TYPE de tipo enum tipo enumerado, véase sintaxis a continuación struct estructura, véase sintaxis a continuación unión unión, véase sintaxis a continuación

3. Declarador:

[const] [*]identificador [expr._constante][= valor_inicial]

4. Enumerador:

enum [identificador]{ [lista_identificadores[= expresión_constante]]

}

5. Estructura y unión:

struct [identificador] { [calificador_tipo [[*]identificador :expresión_constante [expresión_constante]]]

} Unión. Idéntica a la definición de la estructura

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. Si delante del identificador se pone CONST, entonces el identificador es tratado como constante. Las constantes deben ser inicializadas y no pueden cambiar en tiempo de ejecución. No están permitidos punteros a constantes. SHORT es un tipo de dato especial utilizado para generar código muy eficiente para las operaciones de I/O. No se permiten los arrays de SHORT ni los punteros a SHORT. Los siguientes ejemplos muestran la sintaxis para las definiciones de datos: Ejemplos:

int a,b,c,d;

typedef int byte;

typedef short bit;

bit e,f;

byte g[3][2];

char *h;

16

enum boolean {false, true};

boolean j;

byte k = 5;

byte const SEMANAS = 52;

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

struct registro_datos { byte a [2]; byte b : 2; /* 2 bits */ byte c : 3; /* 3 bits */ int d; };

Ejemplo:

struct lcd_pin_map {

boolean enable;

boolean rs;

boolean rw;

boolean unused;

int data : 4;

} lcd;

Si se pone expresión_constante después de un identificador, determina el número de bits que utilizará dicho identificador. Este número puede ser 1,2, ...8. Se pueden utilizar arrays de dimensión múltiple poniendo los [] que se precisen. También se puede anidar estructuras y uniones. Un identificador después de struct puede usarse en otra struct y las {} no se pueden usar para reutilizar la estructura de la misma forma otra vez. Nota: Recordar que todo lo expresado entre [corchetes] es opcional, es decir, se puede

especificar o no, según convenga. Si la expresión va entre {llaves} entonces indica que debe aparecer una o más veces y en ese caso separado por comas.

El identificador después de enum es un tipo de datos tan grande como la mayor de las constantes de la lista. Cada uno de los identificadores de la lista son creados como una constante. Por defecto, el primer identificador se pone a cero y los siguientes se incrementan en uno. Si se incluye "=expresión_constante" después de un identificador éste tendrá el valor de la expresión_constante y los siguientes se incrementarán en uno. Ejemplo:

enum ADC_SOURCE {an0, an1, an2, an3, bandgap, srefh, srefl, itemp, refa, refb};

5. SENTENCIAS DE CONTROL Las sentencias de control para programar el microcontrolador PIC, son las mismas a las del Lenguaje C estándar, que a continuación se listan:

17

• Sentencias repetitivas:

o Bucle while o Bucle for o Bucle do-while

• Sentencias condicionales:

o Sentencia if o Sentencia if-else o Sentencia switch

Adicionalmente, se tienen a disposición las siguientes sentencias, que también son las mismas a las del Lenguaje C estándar:

• Sentencias: goto, break, continue. 6. DEFINICIÓN DE FUNCIÓN El formato de la definición de una función es como sigue:

[calificador_tipo] identificador ([[especificador_tipo identificador]) {

[cuerpo de la función]

}

El calificador_tipo para una función puede ser: void o un especificador de tipo. La definición de una función puede ir precedida por una de las siguientes directivas del preprocesador (calificadores de función), para identificar una característica especial de la función: #separate #inline #int_... Cuando se utiliza una de las directivas mencionadas y la función tiene un prototipo (declaración anterior a la definición de la función, y colocada al principio del archivo fuente) hay que incluir la misma #directiva en el prototipo y en la definición de la función. Una característica no muy corriente, se ha añadido al compilador para ayudar a evitar los problemas creados por el hecho de que no pueden crearse punteros a constantes de cadenas. Una función que tiene un parámetro de tipo char aceptará una constante de cadena. El compilador generará un bucle que llama a la función una vez para cada carácter de la cadena. Ejemplo:

void lcd_putc(char *c ) { / * declaración de la función * /

// definición de la función

...

}

lcd_putc ("Máquina parada".); /* llamada a la función */

18

7. FUNCIONES: PARÁMETROS POR VALOR Y DIRECCIÓN O REFERENCIA Paso de parámetros por valor. Solo transfiere valores a la función y no retorna ningún valor al programa principal o función que le llama. Paso de parámetros por dirección o referencia. Transfiere valores a la función y retorna un valor al programa principal o función que le llama. 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 hacen lo mismo pero sólo el segundo opera con parámetros por referencia:

1. Paso de parámetros por dirección

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

if (*x!=5)

*y=*x+3;

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

2. Paso de parámetros por referencia

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

if(x!=5)

y=x+3;

}

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

8. PROTOTIPO DE UNA FUNCIÓN El prototipo de una función corresponde a la declaración de una función, indicando: el nombre de la función, el tipo del valor de retorno, el número de parámetros y el tipo de cada parámetro. Los prototipos de las funciones anteriores serian:

void funcion_a(int*,int*);

void funct_b(int&,int&); 9. EDICIÓN DE UN PROGRAMA EN C Para crear un programa hay que seguir los pasos siguientes:

19

1. Especificaciones del programa (qué tiene que hacer) 2. Hacer flujograma 3. Escribir el código fuente (conocer el lenguaje) 4. Compilar + Enlazar (Link) 5. Depurar errores, si los hay

10. ESTRUCTURA DE UN PROGRAMA EN C De forma generalizada, la estructura de un programa en C tiene el siguiente aspecto:

declaraciones globales prototipos de funciones void main(void) { variables locales; bloque de sentencias; llamadas a las funciones; } funcion_1() { variables locales a funcion_1; bloque de sentencias; llamada a otra/s funciones; } funcion_n() {

… }

EJEMPLO DE UN PROGRAMA EN LENGUAJE C

/* parpadeo.c Programa que hace parpadear un led en RB7 cada ms */

#include <16F877.H> /* tipo de PIC */

#use delay( clock = 4000000 ) /* reloj de 4 MHz */

#byte puerto_b = 0x06 /* dirección del puerto B */

void main( void )

{

set_tris_b( 0x00 ); /* puerto B como salida */

puerto_b = 0; /* apaga todos los led */

do{

delay_us( 1000 ); /* retardo de 1mseg. */

bit_set( puerto_b, 7 ); /* enciende el led RB7 */

20

delay_us( 1000 ); /* espera 1 ms*/

bit_clear( puerto_b, 7); /* apaga el led */

} while( TRUE ); /* Repetir siempre */ }