El compilador de pic c compiler ha sido desarrollado específicamente para PIC MCU, obteniendo la

máxima optimización del compilador con estos dispositivos. Dispone de una amplia librería de
funciones predefinidas, comandos de preprocesado y ejemplos. Además suministra los
controladores (drivers) para diversos dispositivos como LCD, convertidores AD, relojes en tiempo
real, etc.

Un compilador convierte el lenguaje de alto nivel a instrucciones en código maquinas. El

compilador PIC C COMPILER es un cross-compiler. Los programas son editados y compilados a
instrucciones maquina en el entorno de trabajo del PC, el código maquina puede ser cargado del
PC al sistema PIC mediante el ICD2 o mediante cualquier programador y puede ser depurado
desde el entorno del trabajo del PC.

El PIC C COMPILER es c estándar y, además de las directicas estándar (#include, etc.), suministra
unas directivas específicas para PIC (#device, etc); además incluye funciones específicas (bit_set(),
etc.). Se suministra con un editor que permite controlar la sintaxis del programa.

Estructura de un programa

Para escribir un programa en C con el PIC C COMPILER se debe tener en cuenta una serie de
elementos básicos de su estructura tales como:

 Directivas de preprocesado: controlan la conversión del programa a código maquina por

parte del compilador.
 Programas o funciones: conjunto de instrucciones, en cualquier caso siempre debe haber
uno definido como principal mediante la inclusión de la llamada main ().
 Instrucciones: indica cómo debe comportar el PIC en todo momento.
 Comentarios: permiten describir lo que significa cada línea del programa.

Entorno de trabajo

Definimos el entorno de trabajo como el conjunto de herramientas tanto de software como

hardware que vamos a utilizar para trabajar.

El entorno de trabajo de PIC C COMPILER en PCW Y PCWH permite compilar y también

suministrar una gran variedad de herramientas auxiliares.

Elementos básicos del entorno de trabajo de PIC C COMPILER; existen dos formas de iniciar una
sección: abriendo un fichero de código fuente o creando un proyecto.

Elementos del entorno:

 Comando de manejo de ficheros

 Pestaña del programa
 Barra de ventanas auxiliares
 Macros
 Barra de comandos
 Barra de subcomandos
 Barra de estándar
  Zona de código
 Barra de información

Tipos de datos

PIC C COMPILER acepta los siguientes tipos de datos:

Tipo Tamaño Rango Descripción

Int1 1 bit 0a1 Entero de un bit
Short
Int 8 bit 0 a 255 Entero
Int8
Int16 16 bit 0 a 65.535 Entero de 16 bit
Long
Int32 32 bit 0 a 4.294.967.295 Entero de 32 bit
float 32 bit ±1.175*10 ^-38 a Como flotante
±3.402*10 ^+38
Char 8 bit 0 a 255 Carácter
Void - - Sin valor
Signed Int8 8 bit -128 a 127 Entero con signo
Signed Int16 16 bit -32768 a 32767 Entero largo con
signo
Signed Int32 32 bit -2^31 a (2^31 + 1) Entero 32 bit con
 signo
Las constantes

Las constantes se pueden especificar en decimal, octal, hexadecimal o en binario:

123 Decimal
0123 Octal
0x123 Hexadecimal
0b010010 Binario
¨ x¨ Carácter
¨/010¨ Carácter octal
¨/xA5¨ Carácter hexadecimal

Además, se pueden definir constantes con un sufijo:

Int8 127U
Long 80UL
Signed INT16 80L
Float 3.14F
Char Con comillas simples

También se definen caracteres especiales, algunos como:

\n Cambio de línea
\r Retorno de carro
\t Tabulación
\b Backspace

Variables

Las variables se utilizan para nombrar posiciones de memoria RAM ; se deben declarar,
obligatoriamente, antes de utilizarlas; para ello se debe indicar el nombre el nombre y el tipo de
dato que se manejará. Se definen de la siguiente forma:

TIPO NOMBRE_VARIABLE [=VALOR INICIAL]

TIPO hace referencia a cualquiera de los tipos de datos visto anteriormente. El

NOMBRE_VARIABLE puede ser cualquiera y el valor inicial es opcional.

Ejemplo:

Float temp_limi=500.0;

Las variables definidas en un programa pueden ser de tipo local o global. Las variables locales solo
se utilizan en la función donde se encuentran declaradas; las variables globales se pueden utilizar
en todas las funciones del programa. Ambas deben declararse antes de ser utilizadas y las globales
deben declararse antes de cualquier función y fuera de ellas. Las variables globales son puestas a
cero cuando se inicia la función principal main ().
Ejemplo:

#include < 16f876.h>

#USE DELAY (CLOCK=4000000)

Int16 counter; // variable global

Void FUNCION (void)

Char K, Kant=’0’; // variables locales

Void main ( )

int8 temp; // variable local

Las variables pueden ser definidas con:

 AUTO: (usada por defecto, no hace falta que se indique) donde la variable existe mientras
la función esta activa. Estas variables no se inicializan a cero. Su valor se pierde cuando se
sale de la función.

 STATIC: Una variable local se activa como global, se inicializa a cero y mantiene su valor al
entrar y salir de la función.

 EXTERN: Permite el uso de variables en compiladores múltiples.

Operadores en PIC C COMPILER

Operadores de asignación:

+= Asignación de suma
-= Asignación de resta
*= Asignación de multiplicación
/= Asignación de división
%= Asignación del resto de la división
<<= Asignación de desplazamiento ala izquierda
>>= Asignación de desplazamiento ala derecha
 &= Asignación AND de bits
|= Asignación OR de bits
^= Asignación OR EXCLUSIVA de bits

Operadores aritméticos:

+ Suma
- Resta
* Multiplicación
/ División
% Modulo
-- Incremento
++ Decremento
sizeof Termina el tamaño, en bytes, de un operando

En las operaciones de decremento e incremento, en función de la posición del operador, se

consigue un pre incremento (++A) o un post incremento (A++)

Operadores relacionales

< Menor que

> Mayor que
>= Mayor o igual que
<= Menor igual que
== Igual
!= Distinto
?: Expresión condicional

Operadores lógicos:

! NOT
&& AND
|| OR

Operadores de bits

~ Complemento a 1
& AND
^ OR EXCLUSIVA
| OR
>> Desplazamiento a derechas
<< Desplazamiento a izquierdas
Punteros

& Dirección
* Indireccion
-> Puntero a estructura

Funciones de entrada y salida

Uso de funciones básicas

Estas función son de uso común, son utilizadas para el manejo de datos y configuraciones básicas
del entrada y salida de información.

Los parámetros
Función que se encarga de configurar las
set_tris_x(binario: corresponde a indicar las
entradas y salidas del microcontrolador,
0b00000) entradas o salidas del
configura el registro TRIS. El carácter "x"
set_tris_x(hexadecimal: microcontrolador donde
corresponde al valor de los puesto; a,b,c,d...
0x00) "1" es igual entrada y "0"
Según sea el microcontrolador.
es igual a salida.

Los parámetros
corresponde  a los
Esta función se utiliza para darle valores
output_x(binario: valores iniciales del
iniciales al puesto. El carácter "x"
0b00000) puesto, donde "1"
corresponde al valor de los puesto; a,b,c,d...
output_x(hexadecimal: significa un nivel  alto
Según sea el microcontrolador.
0x00) lógico y "0" nivel bajo
lógico.

Los parámetros configura

Esta función se utiliza para cambiar los
output_bit(pin, value) el PIN ingresado con el
estados del algún PIN.
estado del valor "0" o "1"

Esta función pone la patilla especificada

El parámetro configura
como pin en el modo de entrada. Esto
un PIN especifico para
output_float(pin) permitirá que la patilla esté flotante para
cambiar su configuración
representar un nivel alto en una conexión de
inicial TRIS.
tipo colector abierto.  

El parámetro configura
Pone a "1" el pin indicado. El método de
output_high(pin) un PIN específico para
acceso debe ser salida.
cambiar estado alto.

El parámetro configura
Pone a "0" el pin indicado. El método de
output_low(pin) un PIN específico para
acceso debe ser salida.
cambiar estado bajo.
 El parámetro configura
Pone a "0" o "1" el pin indicado. El método de
output_toggle(pin) un PIN específico para
acceso debe ser salida.
intercambiar el estado.

Esta función activa/desactiva las resistencias

El parámetro puede ser
port_b_pullups(flag) pullups en las entradas del puerto B. Flag
un TRUE o FALSE.
puede ser TRUE (activa) o FALSE (desactiva).

Devuelve el estado "0" o "1" de la patilla

El parámetro configura
indicada en pin. El método de acceso
un PIN especifico para
input(pin) de I/O depende de la última directiva #USE
determinar su estado
*_IO utilizada. El valor de retorno es un
actual.
entero corto.

Esta función devuelve el estado del puerto

input_x() No tiene parámetros. especificado en la x, donde la x corresponde
al puerto a, b, c, d...

Parámetro tiempo en ms
que equivale a
delay_ms(int:time),  Función que realiza una pausa ya sea en MS
microsegundos o us que
delay_us(int:time) (micro-segundos) ó US(nano-segundos).
equivale a
nanosegundos.

Esta función simplemente borra (pone a "0")

el dígito especificado en bit(0-7 o 0-15) del
Parámetro puerto y pin
bit_clear(port,pin) byte o palabra aportado en port. El bit menos
para limpiar.
significativo es el 0. Esta función es
exactamente igual que: var & = ~(1 << bit);

Esta función pone a '1' el dígito especificado

en bit(0-7 o 0-15) del byte o palabra aportado
Parámetro puerto y pin
bit_set(port,pin) en port. El bit menos significativo es el 0. Esta
para ingresar.
función es igual que: var | = (1 <<
bit);                                                    

Esta función examina el dígito especificado

en bit(0-7 o 0-15) del byte o palabra aportado
Parámetro puerto y pin
bit_test(port,bit) en port. Esta función es igual, aunque mucho
para evaluar.
más eficaz que esta otra forma: ((var & (1 <<
bit)) != 0)  

Esta función intercambia el nibble alto con el

swap(byte) nibble bajo del byte dado. Esto es lo 
mismo que: byte = (byte << 4) | (byte >> 4);   
 FUNCIONES DE I/O SERIE RS232

c = GETC ()

c = GETCH ()

c = GETCHAR ()

Estas funciones esperan un carácter por la patilla RCV del dispositivo RS232 y retorna el carácter
recibido.

Es preciso utilizar la directiva #USE RS232 antes de la llamada a esta función para que el
compilador pueda determinar la velocidad de transmisión y la patilla utilizada. La directiva #USE
RS232 permanece efectiva hasta que se encuentre otra que anule la anterior.

Los procedimientos de I/O serie exigen incluir #USE DELAY para ayudar a sincronizar de forma
correcta la velocidad de transmisión. Recordad que es necesario adaptar los niveles de voltaje
antes de conectar el PIC a un dispositivo RS-232.
Ejemplo:

printf("Continuar (s,n)?");

do

{ respuesta=getch();

} while(respuesta!='s'&& respuesta!='n');

GETS(char *string)

Esta función lee caracteres (usando GETC ()) de la cadena (string) hasta que encuentra un retorno
de carro (valor ASCII 13). La cadena se termina con un 0.

PUTC () PUTCHAR ()

Estas funciones envían un carácter a la patilla XMIT del dispositivo RS232. Es preciso utilizar la
directiva #USE RS232 antes de la llamada a esta función para que el compilador pueda determinar
la velocidad de transmisión y la patilla utilizada. La directiva #USE RS232 permanece efectiva hasta
que se encuentre otra que anule la anterior.

Ejemplo:

if (checksum==0)

putchar(ACK);

else putchar(NAK); // NAK carácter de respuesta negativa

PUTS (string)

Esta función envía cada carácter de string a la patilla XMIT del dispositivo RS232. Una vez
concluido el envío de todos los caracteres la función envía un retorno de carro CR o RETURN (ASCII
13) y un avance de línea LF o LINE-FEED (ASCII 10).

Ejemplo:

puts ( " ---------- " );

puts ( " | HOLA |" );

puts ( " ---------- " );

 PRINTF([function], string, [values])

La función de impresión formateada PRINTF saca una cadena de caracteres a la estándar serie RS-
232 o a una función especificada. El formato está relacionado con el argumento que ponemos
dentro de la cadena (string).

Cuando se usan variables, string debe ser una constante. El carácter % se pone dentro de string
para indicar un valor variable, seguido de uno o más caracteres que dan formato al tipo de
información a representar.

Si ponemos %% obtenemos a la salida un solo %. El formato tiene la forma genérica %wt, donde w
es optativo y puede ser 1,2,...,9. Esto es para especificar cuántos carácteres son representados; si
elegimos el formato 01,...,09 indicamos ceros a la izquierda, o también 1.1 a 9.9 para
representación en punto flotante.

KBHIT ()

Esta función devuelve TRUE si el bit que se está enviando al pin RCV de un dispositivo RS232, es el
bit de inicio de un carácter. Es preciso utilizar la directiva #USE RS232 antes de la llamada a esta
función para que el compilador pueda determinar la velocidad en baudios y la patilla utilizada. La
directiva #USE RS232 permanece efectiva hasta que se encuentre otra que anule la anterior.

Ejemplo:

keypress=' ';

while ( keypress!='Q' ) { // entramos al bucle while

if ( kbhit () )

keypress=getc(); // en la variable keypress se guardan los caracteres

if (!input(PIN_B2)) // inicio del envío de un byte

output_high(PIN_B3);

else output_low(PIN_B3)

DIRECTIVAS

Las directivas de pre-procesado comienzan con el símbolo # y continúan con un comando

especifico. La sintaxis depende del comando. Algunos comandos no permiten otros
elementos sintácticos en la misma expresión. Muchas de las directivas utilizadas por este
compilador son extensiones del C estándar.

Estándar c #DEFINE ID STRING #IF expr #NOLIST

#ELSE #IFDEF id #PRAGMA cmd
#ENDIF #LIST #UNDEF id
 #ERROR #INCLUDE “FILENAME”
Cualificadores #INLINE #INT_GLOBAL #SEPARATE
#INT_DEFAULT #INT_xxx
Identificadores _ _ DATE_ _ _ _ LINE_ _ _ _ PCH_ _
_ _ DEVICE_ _ _ _ PCB_ _ _ _TIME_ _
_ _FILE_ _ _ _ PCM_ _ _ _ FILENAME_ _

RTOS #TASK #USE RTOS

Especificación #DEVICE CHIP #ID “filename” #FUSES options
Dispositivos #ID CHECKSUM #ID NUMBER #SERIALIZE
Librerías #USE DELAY CLOCK #USE FIXED_IO #USE RS232
predefinidas #USE FAST_IO #USE 12C #USE SPI
#USE STANDARD_IO
Control de #ASM #BIT id=id #ROM
memoria #BIT id=id.const #ENDASM #TYPE
# BIT id=const.const #FILL_ROM #ZERO_RAM
#BUILD #LOCATE id=const
#BYTE id=const #RESERVE
Control de #CASE #OPT n #PRIORITY
compilador #ORG #IGNORE_WARNINGS

Como ejemplo se puede comentar:

#DEVICE CHIP, permite definir el PIC con el que se realizara la compilación.

# device PIC16F84

#FUSES options, la cual permite definir la palabra de configuración para programar un

PIC.por ejemplo, en el PIC16F84 las opciones posibles son:

LP, XT, HS, RC, NOWDT, WDT, NOPUT, PUT, PROTECT, NOPROTECT.

# device PIC16F84

#fuses XT, NOWDT, PUT, NOPROTECT

#INCLUDE “filename”, permite incluir ficheros en el programa.

#include <16F84.h>

#fuses XT, NOWDT, PUT, NOPROTECT

#USE DELAY( CLOCK=SPEED), permite definir las frecuencias del oscilador del PIC, el
compilador lo utiliza para realizar cálculos de tiempo. Se puede utilizar M, MHZ, K y KHZ
para definir la frecuencia.
 #include <16F877.h>

#use delay (clock=4000000)

Estructuras de control

Las declaraciones de control son usadas para controlar el proceso de ejecución del programa, las
que admite PIC C COMPILER son:

 If – else
 While
 Do – while
 For
 Switch –case.
 Return
 Break, continue y goto.

IF – ELSE

Con la ayuda de if – else se pueden tomar decisiones.

If (expresion)

Sentencia_1;

else

Sentencia_2;

Primero se evalúa la expresión y si es cierta ejecuta la Sentencia_1, en el caso contrario se ejecuta

la Sentencia_2

Pueden anidarse los if – else dando lugar al else– if; esto permite tomar decisiones múltiples.

If (expresion)

Sentencia_1;

Else if (expresion_2)

Sentencia_2;

Else
Sentencia_3;

En este caso las expresiones se evalúan en orden, si algunas de ellas es cierta la sentencia asociada
a ella se ejecutara y se termina la función. En caso contrario se ejecuta la sentencia del else. En
ambos casos si existen varias sentencias para ejecutar se deben utilizar las llaves {}.

SWITCH

Es un caso particular de una decisión múltiple.

Switch (expresion)

Case constante 1:

Sentencias;

Break;

Case constante 2:

Sentencias;

Break;

default:

Sentencias;

Evalúa la expresión y en orden a la constante adecuada realiza las sentencias asociadas. Si ninguno
de los cases corresponde a la constante se ejecuta el default.

El caso break provoca la salida del switch, de lo contrario se ejecuta el siguiente case.

FOR

Se usa para repetir sentencias

For (inicialización; condición de finalización; incremento)

Sentencias;

En las expresiones del for la inicialización es una variable a la cual se le asigna un valor inicial con
el que con el que controlar el bucle. La condición de finalización sirve para evaluar antes de
ejecutar las sentencias si es cierto o no, en el caso de ser cierto se ejecutan las sentencias en caso
contrario se sale del for. Por último, la expresión de incremento o decremento modifica la variable
de control después de ejecutar el bucle.

WHILE

Se utiliza para repetir sentencias

While (expresión)

Sentencias;

La expresión se evalúa y la sentencia se ejecuta mientras la expresión es verdadera, cuando es

falsa se sale del while.

DO WHILE

Se diferencia del while y del for en la condición de finalización, la cual se evalúa al final del bucle,
por lo que las sentencias se ejecutan al menos una vez.

Do

Sentencias;

While (expresión);

Otros:

RETURN

Se emplea para devolver datos en las funciones.

BREAK

Permite salir de un bucle, se utiliza para while, for, do-while y switch.

GOTO

Provoca un salto incondicional.

Funciones

Las funciones son bloques de sentencias; todas las sentencias se deben enmarcar dentro de las
funciones. Al igual que la variable, las funciones deben definirse antes de utilizarse.

Una función puede ser invocada desde una sentencia de otra función. Una función puede devolver
un valor a la sentencia que le ha llamado. El tipo de dato se indica en la definición de la función; en
el caso de no indicarse nada se entiende que es un int8 y en el caso de no devolver un valor se
debe especificar el valor VOID. La función, además de devolver un valor, puede recibir parámetros
o argumentos.

Una característica importante de las funciones, es que pueden recibir parámetros y que pueden
devolver un valor. La misma función nos puede servir para varios casos, con tan solo variar el valor
de los parámetros. El compilador de CCS incluye muchas funciones "built-in" (listas para usarse) en
sus librerías para el control directo de muchos de los recursos del PIC, para utilizarlas sólo
necesitamos saber los parámetros que reciben y los valores que devuelven.

PARTES DE UNA FUNCIÓN

En una función hay que distinguir tres partes:

La declaración (también denominada prototipo).

La definición (o la propia función).

La llamada a la función.

El hecho de que nuestro programa defina una función, no quiere decir que esa función sea
ejecutada. A menos que se produzca una llamada a la función, la función no será ejecutada, sino
tan solo definida. 

Por ejemplo, cuando nosotros incluimos la directiva #USE RS232 que es una directiva asociada a
las bibliotecas pre compiladas, incluimos los prototipos de muchas funciones, pero sólo se
ejecutan aquellas funciones a las que llamamos, como printf. Vamos a ver con más detalle cada
una de estas partes. 

La estructura de una función es

Tipo_dato nombre_función (tipo param1, param2,..)

(Sentencias);

Declaración de una función

La declaración de una función se denomina prototipo de la función.

El prototipo aparece antes del bloque main, o normalmente en los archivos de cabecera (.h)

El prototipo de una función debe aparecer antes de su llamada, y le indica al compilador el

número de parámetros que utiliza una función, y de qué tipo son.

La sintaxis del prototipo es: 

tipo nombre_función(parámetros);  

De donde 

tipo-> es el tipo de dato que va a devolver la función. Si no se indica ningún tipo de dato, por
defecto se asume el tipo int. Si la función no va a devolver ningún dato hay que poner void. 

nombre_ función-> es el identificador de la función, con el que va a ser referenciada.

Parámetros-> es la lista de parámetros (valores) que recibe la función

Definición de una función

La definición es la función en sí, el bloque de sentencias que va a componer esa función. La

sintaxis 
de la definición de una función es: 

tipo nombre_función(parámetros) 
{ 
declaración de datos de la función. 
cuerpo de la función 
} 

La función va encabezada por el prototipo, pero esta vez sin finalizar en punto y coma. Después,
se 
incluye el bloque de sentencias de la función. 

La lista de parámetros puede ser vacía, sin parámetros, si bien los paréntesis de la función deben 
colocarse de igual forma. 

Las definiciones de las funciones es aconsejable escribirlas a continuación de la función main().

Llamada a una función

Para ejecutar una función hay que llamarla. La llamada a una función consta del nombre de la
misma 
y de una lista de argumentos o valores a pasar denominados parámetros actuales, separados por
comas y encerrados entre paréntesis. 
Cuando el programa llama a una función, la ejecución del programa se transfiere a dicha función.
El  
programa retorna a la sentencia posterior a la llamada cuando acaba esa función. La sintaxis de
una 
llamada a una función es: 

nombre (parámetros); 

De dónde

nombre-> es el identificador con que es definida la función a la que queremos llamar. 

Parámetros-> es la lista de valores que se asignan a cada parámetro de la función (en caso de que  
tenga), separados también por comas.

 
RETURN

La función de devolver un valor es mediante la sentencia RETURN:

return (expresión);

return expresión ;

Donde expresión debe manejar el mismo tipo de dato que el indicado en la definición de la
función. En el caso de no devolver nada se finaliza con RETURN, al encontrar esta sentencia el
compilador vuelve a la ejecución de la sentencia de llamada. También se puede finalizar la función
sin RETURN, tan solo con la llave de cierre “}”.

Las funciones pueden agruparse en ficheros de librerías <fichero.h>, que se pueden utilizar
mediante la directiva #include <fichero.h>.

Vamos a ver algunos ejemplos sencillos de utilización de funciones

Encender el LED conectado a RB0 si el switche conectado a RB1 está Activo.

1 #INCLUDE <16f887.h>

2 #USE DELAY(CLOCK=4000000)

3 #FUSES XT,PROTECT,NOWDT,NOBROWNOUT,PUT,NOLVP

4 #DEFINE SW PORTA,1

5 #DEFINE LED PORTB,0

6 #BYTE PORTA= 5

7 #BYTE PORTB= 6

8 MAIN()
9 {

10    SET_TRIS_A(0B10);          //Configura el puerto A

11    SET_TRIS_B(0B11111110);    //Configura el puerto B

12    WHILE(TRUE)                // Haga por siempre

13    {

14       IF(BIT_TEST(SW))        // Si SW esta activado

15       {

16          BIT_SET(LED);        // Active el led

17       }

18       ELSE                    // Sino, es decir si SW esta desactivado

19       {

20          BIT_CLEAR(LED);      // Apagar led

21       }

22    }

23 }

En el siguiente ejemplo, vamos a encender y a apagar un LED conectado a RB0 cada medio
segundo.

1 #INCLUDE <16f887.h>

2 #USE DELAY(CLOCK=4000000)

3 #FUSES XT,NOPROTECT,NOWDT,NOBROWNOUT,PUT,NOLVP

4 #DEFINE LED PORTB,0

5 #BYTE PORTB= 6

6  

7 MAIN()

8 {

9    SET_TRIS_B(0B11111110);    //Configura el puerto B
10    WHILE(TRUE)                // Haga por siempre

11    {

12       BIT_SET(LED);           // Active el led

13       DELAY_MS(500);          // Retardo de 0.5 segundo

14       BIT_CLEAR(LED);         // Apagar el led

15       DELAY_MS(500);          // Retardo de 0.5 segundo

16    }

17 }

Encender led en secuencia

 #include < 16F84A . h >

2: #use delay ( clock = 4000000 )

3: #fuses XT , NOWDT

4: #use standard_io ( B )

5:

6: void main ( void )

7:

8:

9: {

10: Do {

11:

12: OUTPUT_HIGH ( PIN_B0 );

13: delay_ms ( 200 );

14:

15: OUTPUT_HIGH ( PIN_B1 );

16: delay_ms ( 200 );

17:

18: OUTPUT_HIGH ( PIN_B2 );

19: delay_ms ( 200 );

20:
21: OUTPUT_HIGH ( PIN_B3 );

22: delay_ms ( 200 );

23:

24: OUTPUT_HIGH ( PIN_B4 );

25: delay_ms ( 200 );

26:

27: OUTPUT_LOW ( PIN_B0 );

28: delay_ms ( 200 );

29:

30: OUTPUT_LOW ( PIN_B1 );

31: delay_ms ( 200 );

32:

33: OUTPUT_LOW ( PIN_B2 );

34: delay_ms ( 200 );

35:

36: OUTPUT_LOW ( PIN_B3 );

37: delay_ms ( 200 );

38:

39: OUTPUT_LOW ( PIN_B4 );

40: delay_ms ( 200 );

41:

42: }

43:

44: WHILE ( TRUE );

45:

46: }

Encender y apagar una led

 #include <16F84A.h> // Llama al PIC y carga su librería

2                       #use delay(clock=4000000) // Define la velocidad de reloj de 4Mhz

3                       #fuses XT, NOWDT // Define el tipo Reloj(Cristal XT) y desactivo al perro                

guardián

4                       #use standard_io (B) // activo como entrada y salidas al puerto B

5                        

6                       void main (void) // Inicia el Programa

7                        

8                        

9                        {

10                   Do {                                          // Inicia un Bucle

11                   OUTPUT_HIGH(PIN_B0);      // Activo una salida al Puerto B0 (5V)

12                   delay_ms(200);                          // Espera 200ms

13                    

14                   OUTPUT_LOW(PIN_B0); // Desactivo la Salida del Puerto B0 (0V)

15                   delay_ms(200);                       // Espera 200ms

16                   } 

17                    

18                   WHILE(TRUE);                 // Reinicia desde la orden 10.

19                    

20                   }