Grabador de PIC

Cuando la mayoría de la gente está empezando en la programación de PIC, casi siempre opta por comprarse el grabador, y es algo muy razonable ya que si uno no tiene demasiados conocimientos de electrónica y se construye su propio grabador y este tiene algún problema, es mas complicado saber donde está el fallo, si en el grabador, en el PIC, en la programación, etc.

Pero lo que les propongo aquí es la construcción del Programador PIC Pablin II , ya que es muy sencillo y le funciona a la gran mayoría de la gente por no decir que a todos. A este grabador se le conoce un problema y es que a veces no graba al tener poca tensión, yo lo solucioné con las recomendaciones de este artículo Programador PIC Pablin 2 Reloaded de Heli, pero aún así le encontré algunos fallos, no tantos como antes pero si que generaban contratiempos.

Ahora lo que propongo es hacer el mismo circuito, pero obtener 13V exactos a partir de cualquier fuente y para ello utilizaremos dos reguladores de tensión uno de 5V y otro de 8V conectando el GND de este último a la salida del primero.

Lista de componentes:

D1,D2	Diodos 1N4001 al 1N4007 o 1N4148
D3	LED Verde
D4	LED Rojo
R1-R6	Resistencias de 1KΩ
R7, R8	Resistencias de 10KΩ
Q1, Q2	Transistores 2N3904, 2N2222 o BC546 al BC550
IC1	Regulador de voltaje LM7805
IC2	Regulador de voltaje LM7808
IC3	Sextuple Hex inverter 74LS04 o su versión Smith Trigger 74LS14
CN1	Conector para plug de fuente de alimentación
CN2	Conector DB25 Macho
CN3	Tira de pines hembra cortada a 6 pines

El conector del ICSP aunque tenga 6 contactos solo usa 5 para que no se invierta la polaridad por error. En la placa donde se encuentra el PIC a grabar se debe quitar un contacto al conector e introducir un pin macho, soldándolo al PCB y cortarlo al raz y luego al contacto macho del grabador se le debe quitar tal pin para que entre sin problemas.

Estos son los respectivos pinout de los transistores válidos para el diseño:

Mi preferencia particular es hacer un grabador que solamente tenga ICSP (In Circuit Serial Programming) ya que podremos grabar cualquier PIC que este montado en su placa definitiva, y si lo que queremos es grabar el PIC antes de ponerlo en la placa, o la placa definitiva no tiene conector ICSP se puede hacer una placa con los 3 zócalos y agregarle el conector ICSP aparte.

A continuación, el pinout de los respectivos PIC a grabar:

PIC	PGD	PGC	VPP	5V	GND
18 pines	PIN 13	PIN 12	PIN 4	PIN 14	PIN 5
28 pines	PIN 28	PIN 27	PIN 1	PIN 20	PIN 8 y 19
40 pines	PIN 40	PIN 39	PIN 1	PIN 11 y 32	PIN 12 y 31

Personalmente siempre utilicé el programa IC-Prog pero el WinPic800 es notablemente mas rápido; para hacerlo funcionar con cualquiera de los dos programas, se debe configurar como ProPic 2 Programmer.

Generar música con PIC

Antes que nada debo aclarar que no estamos hablando de música con la calidad un CD, ni stereo, ni nada por el estilo, es mas, dudo que tenga alguna calidad, lo digo para no crear falsas expectativas.

En esta ocasión vamos a interpretar alguna melodía utilizando la técnica que vimos en "Generar sonido con PIC" y sólo lo haremos a modo didáctico, ya que es muy útil para comprender como el microcontrolador administra los tiempos y como se utilizan los puertos. Este ejercicio bien podría reemplazar al ya mítico parpadeo de un LED con PIC16F84A ya que es, en teoría, el mismo principio pero con el agregado del control de la frecuencia.

Ahora bien, aquí viene lo mas interesante, investigando un poco me enteré de como es esto de las notas al encontrar este artículo: Frecuencias de las notas musicales , en el que se explica la fórmula para obtener la frecuencia de cada nota musical. Una de las fórmulas, la mas sencilla para llevar a cabo en un programa, es esta:

Con esta fórmula pude sacar las frecuencias para las octavas 0 a la 6, que son las que mejor se ejecutan en el PIC, mas arriba o mas abajo ya es molesto o inaudible. Dichas frecuencias estan en la siguiente tabla:

	0	1	2	3	4	5	6
DO	32,70	65,40	130,81	261,62	523,25	1046,50	2093,00
DO#	34,64	69,29	138,59	277,18	554,36	1108,73	2217,46
RE	36,70	73,41	146,83	293,66	587,32	1174,65	2349,31
RE#	38,89	77,78	155,56	311,12	622,25	1244,50	2489,01
MI	41,20	82,40	164,81	329,62	659,25	1318,51	2637,02
FA	43,65	87,30	174,61	349,22	698,45	1396,91	2793,82
FA#	46,24	92,49	184,99	369,99	739,98	1479,97	2959,95
SOL	48,99	97,99	195,99	391,99	783,99	1567,98	3135,96
SOL#	51,91	103,82	207,65	415,30	830,60	1661,21	3322,43
LA	55,00	110,00	220,00	440,00	880,00	1760,00	3520,00
LA#	58,27	116,54	233,08	466,16	932,32	1864,65	3729,31
SI	61,73	123,47	246,94	493,88	987,76	1975,53	3951,06

Tabla 1. Frecuencia en Hz de cada nota musical.

En esta otra tabla están representadas los microsegundos necesarios entre estado alto y bajo para generar dichas frecuencias:

	0	1	2	3	4	5	6
DO	15289,02	7644,51	3822,25	1911,12	955,56	477,78	238,89
DO#	14430,91	7215,45	3607,72	1803,86	901,93	450,96	225,48
RE	13620,97	6810,48	3405,24	1702,62	851,31	425,65	212,82
RE#	12856,48	6428,24	3214,12	1607,06	803,53	401,76	200,88
MI	12134,90	6067,45	3033,72	1516,86	758,43	379,21	189,60
FA	11453,82	5726,91	2863,45	1431,72	715,86	357,93	178,96
FA#	10810,97	5405,48	2702,74	1351,37	675,68	337,84	168,92
SOL	10204,20	5102,10	2551,05	1275,52	637,76	318,88	159,44
SOL#	9631,48	4815,74	2407,87	1203,93	601,96	300,98	150,49
LA	9090,90	4545,45	2272,72	1136,36	568,18	284,09	142,04
LA#	8580,67	4290,33	2145,16	1072,58	536,29	268,14	134,07
SI	8099,07	4049,53	2024,76	1012,38	506,19	253,09	126,54

Tabla 2. Microsegundos de pausa correspondiente a medio periodo de cada nota musical.

Observando la última tabla con atención se ve que la nota de la octava siguiente es igual a la octava actual dividido por 2, o con la equivalencia en CCS C una rotación a la derecha.
De esto se deduce que teniendo un array con los valores de las diferentes notas se puede ir rotando a la derecha tantas veces como octavas queramos subir para obtener la nota y octava precisas.

En C, la función encargada de hacerlo se ve así:

#define Speaker   PIN_B0

#define nDO     0    // DO
#define nDO_    1    // DO#
#define nRE     2    // RE
#define nRE_    3    // RE#
#define nMI     4    // MI
#define nFA     5    // FA
#define nFA_    6    // FA#
#define nSOL    7    // SOL
#define nSOL_   8    // SOL#
#define nLA     9    // LA
#define nLA_    10   // LA#
#define nSI     11   // SI

int16 FreqNota[12]={  // retardos entre estado alto
                  // y bajo para generar las notas
15289, // DO
14430, // DO#
13620, // RE
12856, // RE#
12134, // MI
11453, // FA
10810, // FA#
10204, // SOL
9631,  // SOL#
9090,  // LA
8580,  // LA#
8099   // SI
};

void Play(int nota, int octava, int16 duracion){
 int16 fn;

 int16 mS_Transcurridos=0;  // Contadores necesarios
                            // para controlar la duración
 int16 CiclosL=0;           // Contandor de uS

 fn=FreqNota[nota];         // Define los retardos para generar
                            // la frecuencia de cada nota
 fn>>=(octava);             // Adapta la frecuencia a la octava actual
                            // haciendo una rotación
                            // a la derecha por octava
do{

    output_high(Speaker);   // Genera la frecuancia
    delay_us(fn);           // con los retardos mientras
    CiclosL+=(fn);          // aumenta el contador de 
                            // ciclos transcurridos
    output_low(Speaker);    // en dos partes para repartir el
    delay_us(fn);           // trabajo entre estado alto y bajo.
    CiclosL+=(fn);          //
    CiclosL+=25;            // Compensador.

    while(CiclosL>999){     // Se queda en el bucle mientras CiclosL
                            // sea menor a 1000 (1 mS)
       CiclosL-=1000;       // Le resta 1000 a CiclosL
       mS_Transcurridos++;  // y le suma 1 a mS_Transcurridos.
       CiclosL+=25;         // Compensador.
    }
 }while (duracion>mS_Transcurridos); // Repite el bucle hasta que haya
                                     // pasado el tiempo indicado.
}

Bueno, sabiendo como ejecutar las notas musicales ahora es tiempo de interpretar una melodía.

Como aclaré antes de música no tengo conocimientos, pero buscando alguna melodía a interpretar en el PIC recordé que en BASIC (el antíguo) había una función llamada PLAY y que interpretaba las notas musicales con el PC Speaker. Buscando en Google encontré un artículo titulado DJ QBASIC donde hay diez canciones conocidas. Ahora lo que resta es adaptar el código BASIC a CCS con la función PLAY para C que vimos en la entrada "Generar sonido con PIC", y es cuando vemos otro pequeño inconveniente, las notas musicales en BASIC están en el sistema de notación musical inglés y nosotros usamos el latino, en la WikiPedia encontré este artículo donde hablan de eso y se muestra la equivalencia: Escala musical .

En base a eso hice este ejemplo que interpreta una melodía según se pulse una tecla, si se pulsa la tecla conectada a RB1 suena "Pop Corn", si se pulsa RB2 suena "Ecuador" y si se pulsa RB3 suena "The lion sleep tonight".

///////////////////////////////////////////////////////////////////////
//                                                                   //
//                       PICMusic v.1.00                             //
//                (c) 2010 Gerardo Ariel Ramírez.                    //
//                                                                   //
///////////////////////////////////////////////////////////////////////
//                                                                   //
//    uControlador: PIC16F876A            Lenguaje: CCS C            //
//            Xtal: 4MHz                                             //
//                                                                   //
///////////////////////////////////////////////////////////////////////


#include <16f876a.h>

#use delay(clock=4000000)
#use fast_io(all)

#fuses HS
#FUSES NOPUT
#FUSES NOBROWNOUT

#define Speaker   PIN_B0

#define nDO     0    // DO
#define nDO_    1    // DO#
#define nRE     2    // RE
#define nRE_    3    // RE#
#define nMI     4    // MI
#define nFA     5    // FA
#define nFA_    6    // FA#
#define nSOL    7    // SOL
#define nSOL_   8    // SOL#
#define nLA     9    // LA
#define nLA_    10   // LA#
#define nSI     11   // SI

int16 FreqNota[12]={  // retardos entre estado alto
                            // y bajo para generar las notas
15289, // DO
14430, // DO#
13620, // RE
12856, // RE#
12134, // MI
11453, // FA
10810, // FA#
10204, // SOL
9631,  // SOL#
9090,  // LA
8580,  // LA#
8099   // SI
};


void Play(int nota,int octava,int16 duracion);
void PlayCancion(int cancion);

void main(){
 
  set_tris_b(14);      // B<3:1>: Pulsadores B0: Speaker
 
  while (true){
     if(input(PIN_B1))PlayCancion(1); //Si pulso switch 1 toca
                            // Pop Corn
     if(input(PIN_B2))PlayCancion(2); //Si pulso switch 2 toca
                            // Ecuador
     if(input(PIN_B3))PlayCancion(3); //Si pulso switch 3 toca
                            // The lion sleep tonight
  }

}

void Play(int nota, int octava, int16 duracion){
     int16 fn;
     int16 mS_Transcurridos=0;
     int16 CiclosL=0;
    
     fn=FreqNota[nota];         // Define los retardos para generar
                                // la frecuencia de cada nota
     fn>>=(octava);             // Adapta la frecuencia
                            // a la octava actual
   
    do{
       
        output_high(Speaker);   // Genera la frecuancia
        delay_us(fn);           // con los retardos mientras
        CiclosL+=(fn);          // aumenta el contador de
                            // ciclos transcurridos
        output_low(Speaker);    // en dos partes para repartir el
        delay_us(fn);           // trabajo entre estado alto y bajo.
        CiclosL+=(fn);          //
        CiclosL+=25;            // Compensador.
       
        while(CiclosL>999){     // Se queda en el bucle mientras
                                // CiclosL sea menor a 1000 (1 mS)
           CiclosL-=1000;       // Le resta 1000 a CiclosL
           mS_Transcurridos++;  // y le suma 1 a mS_Transcurridos.
           CiclosL+=25;         // Compensador.
        }
     }while (duracion>mS_Transcurridos); // Repite el bucle hasta
                                         // que haya pasado el
                                         // tiempo indicado.
    
  
}

void PlayCancion(int cancion){
  switch (cancion){
     case 1:
        //POP CORN
        play (nDO   ,5,166);
        play (nLA_  ,4,166);
        play (nDO   ,5,166);
        play (nSOL  ,4,166);
        play (nRE_  ,4,166);
        play (nSOL  ,4,166);
        play (nDO   ,4,166);
        delay_ms (166);
        play (nDO   ,5,166);
        play (nLA_  ,4,166);
        play (nDO   ,5,166);
        play (nSOL  ,4,166);
        play (nRE_  ,4,166);
        play (nSOL  ,4,166);
        play (nDO   ,4,166);
        delay_ms (166);
        play (nDO   ,5,166);
        play (nRE   ,5,166);
        play (nRE_  ,5,166);
        play (nRE   ,5,166);
        play (nRE_  ,5,166);
        play (nDO   ,5,166);
        play (nRE   ,5,166);
        play (nDO   ,5,166);
        play (nRE   ,5,166);
        play (nLA_  ,4,166);
        play (nDO   ,5,166);
        play (nLA_  ,4,166);
        play (nDO   ,5,166);
        play (nSOL_ ,4,166);
        play (nDO   ,5,166);
     break;
     case 2:  
        //ECUADOR
        play (nLA   ,3,100);
        delay_ms (200);
        play (nMI   ,3,100);
        delay_ms (200);
        play (nDO   ,4,100);
        delay_ms (100);
        play (nSI   ,3,100);
        delay_ms (100);
        play (nRE   ,4,100);
        delay_ms (100);
        play (nSI   ,3,100);
        delay_ms (100);
        play (nSOL  ,3,100);
        delay_ms (100);
        play (nLA   ,3,100);
        delay_ms (200);
        play (nMI   ,3,100);
        delay_ms (200);
        play (nDO   ,4,100);
        delay_ms (100);
        play (nSI   ,3,100);
        delay_ms (100);
        play (nRE   ,4,100);
        delay_ms (100);
        play (nSI   ,3,100);
        delay_ms (100);
        play (nSOL  ,3,100);
        delay_ms (100);
        play (nDO   ,4,100);
        delay_ms (200);
        play (nSOL  ,3,100);
        delay_ms (200);
        play (nMI   ,4,100);
        delay_ms (100);
        play (nRE   ,4,100);
        delay_ms (100);
        play (nMI   ,4,100);
        delay_ms (100);
        play (nRE   ,4,100);
        delay_ms (100);
        play (nSOL  ,3,100);
        delay_ms (100);
        play (nDO   ,4,100);
        delay_ms (200);
        play (nLA   ,3,100);
        delay_ms (200);
        play (nDO   ,4,100);
        delay_ms (100);
        play (nSI   ,3,100);
        delay_ms (100);
        play (nDO   ,4,100);
        delay_ms (100);
        play (nSI   ,3,100);
        delay_ms (100);
        play (nSOL  ,3,100);
     break;
     case 3:
        //The lion sleep tonight
        play (nDO   ,3,125);
        delay_ms (250);
        play (nRE   ,3,125);
        delay_ms (125);
        play (nMI   ,3,125);
        delay_ms (250);
        play (nRE   ,3,125);
        delay_ms (250);
        play (nMI   ,3,125);
        play (nFA   ,3,125);
        delay_ms (250);
        play (nMI   ,3,125);
        delay_ms (125);
        play (nRE   ,3,125);
        delay_ms (250);
        play (nDO   ,3,125);
        delay_ms (250);
        play (nRE   ,3,125);
        play (nMI   ,3,125);
        delay_ms (250);
        play (nRE   ,3,125);
        delay_ms (125);
        play (nDO   ,3,125);
        delay_ms (250);
        delay_ms (125);
        play (nMI   ,3,125);
        delay_ms (125);
        play (nRE   ,3,500);
     break;
  }
}

Si no lo quieres copiar, lo quieres modificar o lo quieres ya compilado, te puedes bajar el proyecto completo haciendo click en este link .

Generar sonido con PIC

En los tiempos que corren estamos acostumbrados a vivir rodeados de tecnología, hoy en día cualquier movil supera en millones de operaciones por segundo al primer ordenador que tuve, hasta un PIC puede funcionar a mas velocidad que un 80286, pero hubo un tiempo en que un teléfono movil no estába al alcance de cualquiera, y en esa época no existían aparatos capaces de brindarnos la experiencia multimedia que hoy damos por sentado de que es así. Y estamos hablando de poco menos de 20 años atras, en esa epoca por lo menos los PC normales, no disponían de una placa de sonido y cualquier juego ejecutaba a duras penas un, a veces, desesperante pitido a modo de música.

Bueno, es por eso que en un arrebato de nostalgia se me ocurrió que podría emular esas "dulces" melodías con un PIC y es por eso que ahora tu estás leyendo esto. Inmediatamente despues me acordé de algo muy importante y es que no tengo ni la mas remota idea de música. Entonces decidí comenzar por el lugar mas obvio, o sea por el principio, fue cuando deduje que para que haya música primero tiene que haber sonido, entonces lo primero que hay que hacer es que el PIC emita algo de sonido controlado, ya habrá tiempo de generar notas musicales.

Primero hay que tener un concepto aunque sea básico de lo que el sonido es, en principio el sonido es un golpe en un medio, en nuestro caso el aire y, dependiendo de la frecuencia de ese "golpe", el sonido producido será mas agudo o mas grave; El oido humano puede percibir sonidos con una frecuencia que está comprendida entre los 20Hz y los 20KHz, en otras palabras que una persona puede escuchar frecuencias de esos golpes desde unas 20 veces por segundo hasta unas 20 mil aproximadamente. Entonces aquí ya tenemos un dato: para generar el sonido con el PIC debemos conectar un altavoz a una salida del microcontrolador y hacer alternar su estado de alto a bajo a una frecuencia determinada. Cuanto mas rápido se varíe el estado mas agudo será el sonido y viceversa.

Para obtener la duración del periodo (estado alto o bajo) para una frecuencia f solo hace falta usar la siguiente formula:

tP =

1 f

Para generar un sonido dentro de los margenes perceptibles, digamos de unos 650Hz realizaremos la siguiente operación:

tP =

1 650

= 0,0015385

El resultado obtenido es el tiempo, en segundos, que debe tardar cada periodo para producir un sonido de 650Hz. En este caso es 1538uS que es la medida que nosotros necesitamos para operar con el PIC, recuerda que un PIC con un cristal corriendo a 4 MHz realiza una operacion cada 1uS.

Cada 1538uS o, lo que es lo mismo, cada 1,538mS se debe producir un cambio de estado del la salida del microcontrolador para producir un sonido a 650Hz, entonces lo que necesitamos ahora es dividir ese valor en 2, una mitad para el estado alto y la otra mitad en estado bajo.

Con todo esto tenemos que: 1538 / 2 = 769, si traducimos esta teoría en lenguaje C quedaría de esta forma:

#include <16f876a.h>          // Tipo de microcontrolador
#use delay(clock=4000000)     // Delay con xtal de 4MHz
#use fast_io(all)             // I/O todas rápidas, de esta forma cuando se
                              // escribe en los puertos, no se configura el tris
                              // acelerando el proceso.  
#fuses HS                     // FUSES cristal HS >=4MHz 
#FUSES NOPUT                  // No power up Timer, no espera a estabilizar la tension 
#FUSES NOBROWNOUT             // No Brown out reset, no se resetea si cae la tension  
#define Speaker   PIN_B0      // Altavoz conectado a RB0  

void main(){
   
   set_tris_b(2); // RB<7:2> Salida RB1 entrada (Pulsador) RB0 Salida (Speaker)
   
   do{                              // Bucle infinito
      
      while(input(PIN_B1)){         // Mientras se presione el
                                    // interruptor conectado a RB1.
                                    
         output_high(Speaker);      // Altavoz encendido
         delay_us(769);             // espera 769 uS
         
         output_low(Speaker);       // Altavoz apagado
         delay_us(769);             // espera 769 uS
      }
      
   }while(true);
}

Este ejemplo lo único que hace es emitir un sonido, ni agudo, ni grave, cuando se activa el pulsador conectado a RB1.

Nuestro PIC acaba de emitir su primer sonido!

Ahora podremos crear una funcion que emita un sonido con la frecuencia y duracion deseados.
El siguiente ejemplo hace sonar una sirena cuando se pulsa un interruptor en RB1.

/////////////////////////////////////////////////////////////////////////////
//                                                                         //
//                            PICSirena 1.00                               //
//                   (c) 2010 Gerardo Ariel Ramírez.                       //
//                                                                         //
/////////////////////////////////////////////////////////////////////////////
//                                                                         //
//       uControlador: PIC16F876A            Lenguaje: CCS C               //
//               Xtal: 4MHz                                                //
//                                                                         //
/////////////////////////////////////////////////////////////////////////////


#include <16f876a.h>          // Tipo de microcontrolador
   
#use delay(clock=4000000)     // Delay con xtal de 4MHz
#use fast_io(all)             // I/O todas rápidas, de esta forma cuando se
                              // escribe en los puertos, no se configura el tris
                              // acelerando el proceso.

#FUSES HS                     // FUSES cristal HS >=4MHz
#FUSES NOPUT                  // No power up Timer, no espera a estabilizar la tension
#FUSES NOBROWNOUT             // No Brown out reset, no se resetea si cae la tension

#define Speaker   PIN_B0      // Altavoz conectado a RB0

void Sound(int16 frecuencia, int16 duracion);

void main(){
   int t;
   set_tris_b(2);
   
   while(true){      //Bucle infinito
   
      if (input(PIN_B1)){                 // Si se activa el pulsador
      
         for (t=0;t<30;t++)               // Bucle ascendente incrementando la
            sound(((int16)t*15)+1600,20); // frecuencia del sonido
         for (t=30;t>0;t--)               // Bucle decrementando
            sound(((int16)t*15)+1600,20); // la frecuencia del sonido
      
      }
   }
}

void Sound(int16 frecuencia, int16 duracion){
   
   int16 mS_Transcurridos=0;
   int16 CiclosL=0;
   int16 uS;
   int32 tmp;
   
   if (frecuencia>=20&&frecuencia<=20000){ //si la frecuancia se encuentra entre
                                           // los margenes de 20Hz y 20 KHz se ejecuta
      tmp=100000;                          // de los contrario no.
      tmp/=frecuencia;           // convierte los Hz a microsegundos para la pausa
      tmp*=5;   
      uS=tmp;
      do{
         output_high(Speaker);   // Genera la frecuancia deseada
         delay_us(uS);           // con los retardos mientras
         CiclosL+=(uS);          // aumenta el contador de ciclos transcurridos
         output_low(Speaker);    // en dos partes para repartir el 
         delay_us(uS);           // trabajo entre estado alto y bajo.
         CiclosL+=(uS);          // 
         CiclosL+=25;            // Compensador.
         
         while(CiclosL>999){     // Se queda en el bucle mientras CiclosL sea
                                 // menor a 1000 (1 mS)
            CiclosL-=1000;       // Le resta 1000 a CiclosL 
            mS_Transcurridos++;  // y le suma 1 a mS_Transcurridos.
            CiclosL+=25;         // Compensador.
         }
      }while (duracion>mS_Transcurridos);// Repite el bucle hasta que haya pasado el
                                         // tiempo indicado.
   }
}

Desde este link te puedes bajar el proyecto y el hex.

Bueno, hasta aquí hemos llegado, ahora resta por hacer que el PIC reproduzca alguna nota musical e interprete alguna canción, pero eso lo veremos en Generar música con PIC.

Probador de PIC16F876

¿Cuantas veces se han visto con la necesidad de probar un firmware que han programado pero no tienen el circuito hecho para probar? Bueno lo que aquí propongo es una placa con todos los componentes para hacer trabajar al PIC, pero con la particularidad de que los puertos están disponibles para el uso que queramos darle.

El diagrama es el siguiente:

A simple vista se ven 5 conectores que 3 corresponden a los puertos del PIC (A,B y C) 1 para la alimentación, y el 5to par el ICSP (In Circuit Serial Programming). Para los que no sepan lo que es esto, les comento que es, como lo indica su nombre en inglés, la programación serial en circuito, o sea que se puede programar (grabar el firmware) directamente en la placa sin necesidad de extraer el integrado en ningún momento.

Aunque también se podría extraer el PIC en cualquier momento gracias a la implementación de un zócalo de 28 pines, dicho sea de paso aconsejo que cada vez que se fabrique un circuito, y sobretodo si está pensado para pruebas, que cualquier integrado que vayamos a utilizar no se suelde directamente a la placa sino que se utilicen zócalos; por económico que sea un integrado no significa que lo tengamos siempre a mano, ni sea fácil de conseguir.

Volviendo a lo que es el circuito en cuestión, es muy sencillo y lo unico que tiene de particular es que facilita la puesta en marcha del PIC, sólo con colocarle los 5volts de alimentación el PIC estaría funcionando, ya que cuenta con un cristal, también se podría utilizar varias velocidades de cristales, por medio de jumpers o zócalos.

Cuenta con protección anti inversión de polaridad, muy útil para cuando estamos haciendo pruebas, como también aislamiento de tensiones para cuando está alimentado y conjuntamente se conecta el ICSP, en tal caso una tensión no interfiere con la otra. Y está incluido el circuito de reset.
Está pensado para utilizarlo en protoboards para lo cual los pines de conexión de alimentación y puertos tendrían que ser de tira de pines acodados a 90º. Por el mismo motivo no se incluyen en el diseño resistencias de pull-up ni pull-down, se supone que el prototipo que se diseñe contendrá las resistencias necesarias.

Puede ser adaptado a cualquier modelo de PIC muy facilmente, solo basta con agragar o quitar pines a los puertos amoldandolos a las necesidades y al modelo del microcontrolador, cada uno puede pensar sus circuitos dependiendo de la necesidad que tenga...

SiLMuP (mi robot Sigue Líneas MultiPropósito)

Les presento a mi primer robot: SiLMuP ( Sigue Líneas MultiPropósito )

Aún en construcción y sin los sensores instalados.

Construcción:

- El cuerpo del robot está construido con ángulos de aluminio, escuadras metálicas y muchos tornillos.

- Los motores y reductoras son del sistema de detección de monedas de máquinas tragaperras, adaptadas.

- Las ruedas son rodillos para papel de impresora HP DeskJet 670C con unos engranajes recortados y pegados ( en la primer imagen). En la siguiente son del primer fascículo del Citroen C4 de la editorial Salvat escala 1:10.

- La tercera rueda es una rueda de mueble (rueda loca)

Con ruedas de radiomodelismo, el sensor de líneas y un servo para regular la distancia al suelo.

Electrónica:

La fuente es la misma que figura en el apartado "Fuente de alimentación y cargador de baterías" esta compuesta por un regulador de voltaje para la lógica (5v) y otro para alimentación de los IRLED (7v); Tiene un LM317 para cargar las 8 baterías de Ni-MH de 1.2v 2500mAh c/u. La energía para mover los motores de tracción la proporciona directamente las baterías.

El microcontrolador es un PIC16F876 de la casa Microchip programado en CCS C.

Integrados:

2 - 74HC165 para la lectura de sensores.
1 - 74HC595 para el manejo del display LCD y teclas de función.
3 - 74HC14 para estabilizar señales procedentes de los sensores.
1 - MAX232 para la comunicación mediante RS232 a PC.
1 - NE555 para generar la señal para los LED's infrarrojos de todos los sensores.

La etapa de potencia esta formada por dos puentes H hechos con transistores BD677 y BD678 principalmente.

Pronto habrá mas noticias...