Presentación

Los PIC son una familia de microcontroladores tipo RISC fabricados por Microchip Technology Inc. y derivados del PIC1650, originalmente desarrollado por la división de microelectrónica de General Instrument.

El nombre actual no es un acrónimo. En realidad, el nombre completo es PICmicro, aunque generalmente se utiliza como Peripheral Interface Controller (controlador de interfaz periférico).

El PIC original se diseñó para ser usado con la nueva CPU de 16 bits CP16000. Siendo en general una buena CPU, ésta tenía malas prestaciones de entrada y salida, y el PIC de 8 bits se desarrolló en 1975 para mejorar el rendimiento del sistema quitando peso de E/S a la CPU. El PIC utilizaba microcódigo simple almacenado en ROM para realizar estas tareas; y aunque el término no se usaba por aquel entonces, se trata de un diseño RISC que ejecuta una instrucción cada 4 ciclos del oscilador.

En 1985 la división de microelectrónica de General Instrument se separa como compañía independiente que es incorporada como filial (el 14 de diciembre de 1987 cambia el nombre a Microchip Technology y en 1989 es adquirida por un grupo de inversores) y el nuevo propietario canceló casi todos los desarrollos, que para esas fechas la mayoría estaban obsoletos. El PIC, sin embargo, se mejoró con EPROM para conseguir un controlador de canal programable. Hoy en día multitud de PICs vienen con varios periféricos incluidos (módulos de comunicación serie, UARTs, núcleos de control de motores, etc.) y con memoria de programa desde 512 a 32.000 palabras (una palabra corresponde a una instrucción en lenguaje ensamblador, y puede ser de 12, 14, 16 ó 32 bits, dependiendo de la familia específica de PICmicro).

Diagrama de PICs

PIC 12F629

PIC 16F84

PIC 16F628A

PIC 18F2550

PIC16F877

PIC 18F4550

Variables

¿Qué son las variables? pues sencillamente el poder identificar con un nombre una o varias posiciones de memoria de la RAM de nuestro PIC y de esta manera el poder almacenar allí los datos que va a utilizar nuestro programa.
En C para poder utilizar una variable primeramente hay que declararla siguiendo la siguiente sintaxis:

tipo nombre_variable [=valor];

Lo que va entre corchetes es porque es opcional es decir, las variables se pueden inicializar ó  no al declararlas.
Ejemplo de variable declarada:

int i;
Ejemplo de variable declarada e inicializada:
int i=5;


Los tipos de datos básicos que utiliza nuestro compilador son los siguientes:

Sin embargo  el compilador CCS también admite los siguientes tipos de datos definidos en el estándar C y que son los que normalmente se utilizan a la hora de programar:

Ejemplos

int numero=0;

numero=150;  //decimal

numero=0xFF; //exadecimal

numro=0b01001101; //binario

Parpadeo de Led

Ejemplo 1
#include <16f877a.h>
#use delay(clock = 4M)
#fuses HS,NOWDT,NOLVP
#use fast_IO(B)
void main ()
{
        set_tris_B(0x00);
         while(true)
         {
             output_high(pin_B0) ;
             delay_ms(1000);

            output_low(pin_B0);
            delay_ms(1000);
          }
}

Ejemplo 2
#include <16F877A.h>  //libreria para el manejo del 16F877A
#use delay(clock=4000000) //declara  la frecuencia del cristal

///configura los fusibles
/// HS es la configuraricion del oscilador la cual indica High speed es decir
/// frecuencias altas esto es a partir de 8 Mhz.
/// NOWDT deshabilita el Watch Dog Timer
/// NOPUT deshabilita le reseteo de power up timer
/// NOPROTECT deshabilita la proteccion del codigo del pic.
#fuses HS,NOWDT,NOPUT,NOPROTECT

///  asignamos a variable port_b el espacio memoria 0x06 que es la dir de port_b
#byte port_b=0x06
int contador; //variable global
void main()
{       
   set_tris_b(0);  //declaramos el puerto B como salidas
   port_b=0;
   while (true) {               
        //activa todos los pins del puerto B
        contador=0xff;     
        port_b=contador;
        delay_ms(1000); //Retardo de 1000 milisegundos es decir 1 segundo
        //apaga todos los pins del puerto B
        contador=0x00;
        port_b=contador;
        delay_ms(1000);//Retardo de 1000 milisegundos es decir 1 segundo
   }
}


Ejemplo 3
#include <12F629.h>
#use delay(clock = 4M)
#fuses INTRC_IO,NOWDT,NOMCLR,PUT,BROWNOUT

#use STANDARD_IO(A)
#define s1 PIN_A0
#define f1 PIN_A1


void main()
{
   set_tris_a(0b100000);
   
   while(true){
      output_low(f1);
      delay_ms(1000);
      output_high(f1);
      delay_ms(1000);
      
   }

}

Leds secuenciales

en binario

#include <16F877A.h>
#use delay(clock=4M)
void main()
{
int i=0b10000000;
set_tris_b(0x00);

while (true){
   i=i>>1;
   output_b(i);
   delay_ms(1000);
}
}

en decimal

#include <16F877A.h>

#use delay(clock=4M)

void main()

{

int i=0;

set_tris_b(0x00);

while (true){

   i++; 

   output_b(i);

   delay_ms(1000);

}

}

Ejemplo 1
#include <16f877a.h>
#fuses XT,NOWDT,NOPROTECT,PUT      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use standard_io(B)               //puerto B como salida
#byte  portb= 0x6               //direccion port b

///PROGRAMA
void main(void)
{
   int led_on=0b00000001;            //led a iluminar
   set_tris_b(0x00);            //portb como salida (algunas desactivadas)
   disable_interrupts(GLOBAL);      //todas las interrupciones desactivadas
  
   do{                        //bucle...
     
      do{      //iluminacion hacia izquierda
         portb=led_on;
         rotate_left(&led_on,1);
         delay_ms(300);
         }while(bit_test(led_on,7)==0);
     
      do{      //iluminacion hacia derecha
         portb=led_on;
         rotate_right(&led_on,1);
         delay_ms(300);
         }while(bit_test(led_on,0)==0);
        
      }while(TRUE);            //...infinito
}

Ejemplo 2

#include <16F877A.h>                ///   libreria para el manejo del pic16f877a
#use delay(clock=4000000)          ///   declara  la frecuencia del cristal
#fuses HS,NOWDT,NOPUT,NOLVP,NOBROWNOUT,NOWRT,NOPROTECT

int conteo=0;

#use fast_io(A)
#use fast_io(B)
#use fast_io(C)                     ///   con esta instruccion evitamos que
#use fast_io(D)                     ///   se este configurando cada vez que usamos
#use fast_io(E)                     ///   alguna instruccion de entrada o salida

#byte porta = 5
#byte portb = 6
#byte portc = 7                     /// se definen direcciones de memoria
#byte portd = 8
#byte porte = 9

void main(void)
{
  set_tris_b(0x00);
  while(true)                        //bucle infinito
{
 conteo++;

 if((conteo&0x0f)>9)            // aqui observamos si el primer display llego a 10
                                          // para solo comparar los primeros 4 bit hacemos una
                                          // operacion and con 0x0f
{ 
conteo=conteo+10;            // hacemos que los 4 bits mas significativos  incrementen
conteo=conteo&0xf0; 
}
 if(conteo>99) {conteo=0;}      // verificamos que la cuenta se haga de 0 a 99

 else{ portb=conteo; delay_ms(400);}
}                                   //fin de ciclo while
}                                   //fin de programa
 

Parpadeo de led 18F4550

#include <18F4550.h>
#fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL5,CPUDIV1,VREGEN
#use delay(clock=20M)
#use fast_io(B)

void main()
{
   port_b_pullups(TRUE);
   set_tris_B(0x1);
   output_low(PIN_B1);
while (true){
   output_high(pin_b1);
   delay_ms(200);
   output_low(pin_b1);
   delay_ms(200);
}
}

Pulsador

Ejemplo 1
#include <16f877A.h>
#use delay (clock=4000000)           // Fosc=4Mhz
#fuses xt,nowdt,noprotect              // fusibles
#byte port_a=5                             // declaramos el puerto a en su localidad
#byte port_b=6                             // declaramos el puerto b en su localidad
void main(void)
{
set_tris_a(0b00000001);              // programamos el puerto a para que RA0 sea entrada
set_tris_b(0b00000000);             // programamos el puerto b para q sea salida
port_b=0x00;                            // inicialmente todo el puerto b estara apagado
while (true)                               // bucle infinito,o que el programa se ejecutara infinitamente
{
if (input(pin_a0)==0)                      // preguntamos si RA0 es cero
{
port_b=0b00000001;                    // cuando se cierra el pulsador ejecuta esta tarea
delay_ms(500);                           // la cual es encender un led conectado en RB0
port_b=0b00000000;
}                
}
}

Ejemplo 2

#include <16F877A.h> 
#use delay(clock=4000000)
#fuses HS,NOWDT,NOPUT,NOLVP,NOBROWNOUT,NOWRT,NOPROTECT

#use fast_io(A)             ///   con esta instruccion evitamos que
                                   ///   se este configurando cada vez que usamos 
#use fast_io(B)            ///   alguna instruccion de entrada o salida
               
#byte porta = 0x05            //    se definen las direcciones de memoria
#byte portb = 0x06

void main(void)
{
   set_tris_a(0xff);            // se configura el puerto B como entrada
   set_tris_b(0x00);          // se configura el puerto C como salida

while(true)                       // Bucle infinito
{
   port_b_pullups(true);    // activa las resistencias de pull-up
   portb=porta;   
}
}