Introducción a la programación de microcontroladores PIC

Los microcontroladores PIC (conocidos simplemente como PIC) son circuitos integrados que pueden ser programados para ejecutar una secuencia de instrucciones automáticamente. El programa se escribe en un computador en un ambiente de programación adecuado (por ejemplo en lenguaje C) y luego se transfiere como código binario a la memoria de programa del microcontrolador para su ejecución en el momento de encendido del dispositivo. Los microcontroladores PIC son fabricados por la empresa Microchip y constan básicamente de una CPU, espacios de memoria para el programa y los datos, y varios periféricos para la interacción con el mundo externo, todo esto encapsulado dentro de un solo chip de silicio.

En este tutorial encontrarás conceptos básicos acerca de la arquitectura y programación de los microcontroladores PIC. Esta página está dirigida a todas las personas que se han preguntado alguna vez qué es un PIC, para qué sirve y cómo puede ser utilizado en la vida real. Con los conceptos básicos aquí presentados tendrás los fundamentos principales para convertirte en un gran programador y diseñar tus propios proyectos para aplicarlos en la solución de problemas prácticos.

¡Descubre el mundo de los microcontroladores PIC y lleva tus habilidades de programación al siguiente nivel! Obtén nuestro eBook y disfruta aprendiendo paso a paso desde cero, podrás realizar proyectos prácticos, encontrar soluciones a problemas comunes y explorar una amplia cobertura de temas desde lo más básico a lo más avanzado. Incluye software y ejemplos resueltos. ¡Cómpralo ahora y libera el increíble potencial de esta poderosa tecnología hoy mismo!

Por qué iniciar nuestro aprendizaje con el PIC16F88, el PIC16F628A y el PIC16F877A? Estos PIC pertenecen a la gama media y pueden ser aplicados en circuitos electrónicos de propósito general. Actualmente son utilizados como modelos en la enseñanza de programación de microcontroladores en las Universidades de todo el mundo. Como ventajas relevantes se pueden destacar las siguientes: bajo precio, gran capacidad de memoria de programa y datos, gran disponibilidad de pines E/S (entrada/salida), oscilador interno (PIC16F88 y PIC16F628A), convertidor A/D (PIC16F88 y PIC16F877A), módulos de comunicación serie y tres temporizadores. Todas estas características los hacen completamente superiores al popular PIC16F84A, y por estas razones fueron seleccionados como modelos para el presente texto. Estos microcontroladores PIC constituyen un grupo muy completo, con características novedosas que los convierten en dispositivos apropiados para multitud de proyectos desde los más simples hasta los de mediana y alta complejidad. Cuando se emplea el oscilador interno el usuario tiene a su disposición dos pines más para utilizarlos como entrada/salida de propósito general. El oscilador interno significa un gran ahorro de recursos y puede ser configurado por el usuario de acuerdo a su conveniencia. La memoria de programa se puede grabar y borrar unas 100.000 veces, la memoria de datos EEPROM 1.000.000 de veces y sus datos permanecen almacenados por más de 40 años. Otras características son la Programación en Serie en el Circuito (ICSP) que requiere un total de 5 pines, acceso del procesador a la memoria de programa, programación en bajo voltaje, depuración en el circuito por medio de 2 pines, perro guardián (WDT) y un rango amplio de voltaje de operación. En la siguiente tabla tenemos un resumen de las principales caracteristicas de estos microcontroladores:

Cuáles son las características del lenguaje C? El lenguaje C es universalmente conocido debido a su gran versatilidad para el desarrollo de aplicaciones y se lo enseña como lenguaje básico de programación en muchas universidades e institutos educativos. En la actualidad es casi un estándar de facto a la hora de enseñar a programar computadoras. Es un lenguaje de alto nivel, lo que lo hace sumamente potente con respecto al popular (y difícil) lenguaje ensamblador. Además, el ambiente de desarrollo mikroC   tiene todas las herramientas (en librerías de funciones) y facilidades necesarias para una rápida y efectiva programación de los microcontroladores PIC.

Qué es un programador (grabador o quemador) de PIC? En el contexto del hardware, es una tarjeta electrónica en la cual se inserta el microcontrolador PIC con el propósito de transferir el código del programa (en formato binario) desde el computador del usuario y grabarlo en la memoria interna del microcontrolador. Esta tarjeta se conecta a un puerto (LPT1, USB, etc.) del computador y por medio del software de control se realiza la transferencia (programación) del código ejecutable *.hex de una determinada aplicación hacia el PIC. Programador también es el nombre que se le da a la persona encargada de escribir un programa en un lenguaje de programación con el fin de dar solución a un determinado problema. El resultado del proceso de programación es una aplicación.

Cuánto tiempo me tomará aprender a programar los PIC? Por supuesto no hay una respuesta exacta, lo que sí se puede afirmar es que mientras más perseverancia y dedicación se pongan de parte del lector, el tiempo necesario para el aprendizaje se reducirá.  Si se dedican unas 2 horas al día el avance será vertiginoso y en unas 4 semanas ya tendrá un dominio aceptable de la programación de PIC en lenguaje C.

Cuáles son los pasos a seguir para realizar una aplicación real con un PIC?

1. Construir o comprar un programador de PIC compatible con los dispositivos a programar y con el sistema operativo disponible.
2. Descargar el software de control (software de programación) del programador e instalarlo: por ejemplo PICkit2 v2.61, etc.
3. Descargar e instalar el ambiente de desarrollo de programación de PIC en lenguaje C (mikroC).
4. Seguir las indicaciones del libro para crear un nuevo proyecto, configurarlo, escribir el código fuente en lenguaje C y compilarlo para obtener el ejecutable *.hex (aplicación).
5. Descargar el fichero ejecutable al PIC por medio del software de programación y del programador conectado a la computadora personal.
6. Retirar el PIC del programador y colocarlo en el circuito de aplicación y, ¡a disfrutar con los maravillosos resultados!. La siguiente figura muestra la secuencia de programación:

Cuáles son las características de los PIC? Microchip® (empresa fabricante de los microcontroladores PIC) ofrece una gran variedad de microcontroladores de 8, 16 y 32 bits, de bajo costo, con una arquitectura potente, varias tecnologías de memoria, herramientas de desarrollo fáciles de usar, documentación técnica completa y una red de ventas y distribución global. Estas son las principales ventajas del uso de microcontroladores PIC:

• Fácil migración y actualizacion de diseños
• Amplio rango de velocidad de operación para satisfacer las múltiples necesidades de las aplicaciones
• Dispositivos con memoria de programa desde 384B a 512 KB para cumplir los requerimientos de código
• Arquitecturas compatibles para preservar la inversión económica en el desarrollo de códigos
• Compatibilidad Pin a Pin en múltiples encapsulados, facilitando así el remplazo
• Menor coste total del sistema con Perifericos Integrados
• Comunicaciones: SPI, I2C ™, UART, CAN, USB, Ethernet, IrDA®, LIN
• Control: captura / comparación, contadores, reloj en tiempo real y PWM
• Módulos Analógicos: Convertidores A / D, comparadores, amplificadores operacionales, Convertidores D / A

Cuáles son las características de mikroC? mikroC PRO para PIC es un compilador con todas las funciones ANSI C para dispositivos PIC de Microchip®. Es la mejor solución para el desarrollo de código para dispositivos PIC. Cuenta con IDE intuitivo, potente compilador con optimizaciones avanzadas, muchas bibliotecas de hardware y software, y herramientas adicionales que le ayudarán en su trabajo. Este Compilador viene con archivos de ayuda integrada y un montón de ejemplos listos para usar, diseñados para que pueda empezar en cualquier momento, sus principales caracteristicas son las siguientes:

• Compilador inteligente y eficiente
• Cuenta con cuatro niveles de optimizacion que pueden reducir el tamaño de su código hasta en un 20%
• Uno de los mejores IDE (Entorno de Desarrollo Integrado) disponibles en la actualidad: intuitivo, rápido y rico en características. Te sentirás muy cómodo durante el trabajo.
• Más de 500 funciones de librerias lo que se traduce en un enorme ahorro de esfuerzo y tiempo

Requisitos básicos para el aprendizaje

Para aprender con rapidez y facilidad los conceptos de la programacion de microcontroladores PIC se requieren conocimientos basicos de:

• Electronica digital
• Computacion basica

Si usted carece de los requisitos nombrados no es aconsejable que siga adelante en la lectura de este documento pues se le dificultara notablemente entender los conceptos explicados.

El software necesario para ejecutar todas las tareas de programación es el siguiente:

• mikroC PRO for PIC: ambiente de desarrollo de programación de microcontroladores PIC en lenguaje C. Puede descargar la version demo del sitio web de mikroelektronika (te servirá para escribir los ejemplos durante la fase de aprendizaje).
• Proteus (opcional): simulador de aplicaciones con microcontroladores PIC
• PICkit2 v2.61: software de administración del programador PICkit2 (también puede emplear otro programador como el PICkit3 con su software correspondiente).

Para los primeros pasos en el estudio de la programación de microcontroladores se necesita el siguiente hardware básico:

• Computador con puerto USB y sistema operativo Windows (recomendamos desde Windows XP hasta Windows 8.1)
• Fuente de corriente directa de 5V
• Microcontrolador PIC
• Programador PICkit2, PICkit3 u otro programador compatible con el PIC que va a ser utilizado
• Elementos electronicos varios que dependen del circuito de aplicacion del microcontrolador PIC

Conceptos básicos

A continuación presentamos una introducción a los principales temas acerca de la programación de microcontroladores PIC en lenguaje C, con el compilador mikroC PRO; los ejemplos propuestos se pueden desarrollar con microcontroladores PIC y dispositivos electrónicos de propósito general disponibles actualmente y de fácil acceso. Los temas que se describen cubren múltiples áreas de aplicación y están organizados de menor a mayor complejidad. Se utiliza el lenguaje C (sintaxis de mikroC PRO for PIC) para la programación y se han añadido los ejemplos necesarios que permitirán al lector comprender rápidamente el uso de los diferentes módulos internos y externos de los microcontroladores PIC. Con los conceptos aquí expuestos, el lector estará en capacidad de emprender el diseño y construcción de sus propios proyectos en diversos campos de aplicación.

Un microcontrolador (abreviado μC, UC o MCU) es un circuito integrado fabricado de Silicio que puede programarse para realizar tareas (ejecutar instrucciones) de forma automática al conectarlo a una fuente de energia. Las instrucciones se almacenan en un espacio de memoria especificamente destinada a ese propósito. En la siguiente imagen se aprecia el patillaje o pinout del popular PIC16F628A:

Un microcontrolador está compuesto de varios bloques funcionales, los cuales cumplen una tarea específica; incluye en su interior las tres principales unidades funcionales de una computadora:

• Unidad central de procesamiento (CPU): se encarga de ejecutar las instrucciones y realizar las operaciones con los datos.
• Memorias: FLASH para las instrucciones del programa, EEPROM (de almacenamiento permanente)  para datos y RAM (de almacenamiento temporal) para datos.
• Periféricos de entrada/salida: permiten la comunicación del microcontrolador con su entorno físico recibiendo y entregando datos en forma de señales electricas. La conexion a los perifericos se realiza por medio de las patillas (alfileres o pines) del circuito integrado que conforma el microcontrolador.

Adicionalmente existe otra terminología que conviene conocer y entender ya que se emplea con mucha frecuencia en el mundo de la programación de microcontroladores: 

• Compilador: Software que se encarga de convertir el codigo escrito en lenguaje C (lenguaje humano) a codigo de maquina (lenguaje de maquina). El codigo en lenguaje C se conoce como codigo fuente mientras que el codigo de maquina se conoce como codigo ejecutable.
• IDE (Integrated Development Environment) Ambiente de desarrollo Integrado: software de computador que sirve para el desarrollo de programas para microcontroladores PIC. mikroC PRO for PIC es un IDE. Basicamente un IDE está conformado por dos partes: a) Un editor de texto para escribir el codigo fuente y b) Un compilador.
• Programador: es un dispositivo de hardware electronico diseñado para transferir el codigo ejecutable (codigo de maquina) desde el computador hacia la memoria de programa del microcontrolador PIC. La conexion entre el computador y el programador se realiza por medio del puerto USB; el proceso se conoce como programacion, grabación o quemado (por esta razon el programador tambien se suele llamar grabador o quemador). También recibe el nombre de programador la persona que se encarga de escribir programas para microcontroladores.
• Pin: cada una de las patillas o alfileres del microcontrolador. Por ejemplo el PIC16F628A tiene 18 pines (encapsulado DIP18).
• Sintaxis: Conjunto de reglas definidas para escribir correctamente un lenguaje de programacion. mikroC PRO para PIC tiene su propia sintaxis que es muy similar a la sintaxis del lenguaje C de computadoras (ANSI C). 
• Programa: Es una secuencia de instrucciones, escritas en un determinado lenguaje de programacion para realizar una tarea específica en un microcontrolador. En este curso se escribiran los programas de acuerdo a la sintaxis propia de mikroC PRO for PIC.

Primer proyecto

Este es el primer ejemplo de como crear un proyecto practico y funcional desde el principio. El proposito es hacer un contador de pulsos desde 0 hasta 9. Se utillizará el popular PIC16F628A, un boton pulsador normalmente abierto para generar los pulsos manualmente y un display de 7 segmentos para mostrar el conteo. Los pasos indicados son los que se deben seguir normalmente para crear otros nuevos proyectos:

1. Iniciar el programa mikroC PRO for PIC (utilizamos la version 4.1 que puedes descargar más arriba en esta misma pagina) y crear un nuevo proyecto: Project > New Project. Clic en Next
2. Seleccionar el PIC16F628A en el campo Device Name. Clic en Next
3. Establecer la frecuencia de trabajo del microcontrolador en Device Clock. Se suele trabajar con una frecuencia de 4MHz y ese es el valor que  usaremos. Clic en Next
4. Crear una carpeta (folder) para el nuevo proyecto; para ello hacer clic en el simbolo al final del campo Project File Name, esto abrirá la ventana New Project Location. Crear una carpeta en una determinada ubicación de su elección haciendo clic en New Folder, la carpeta deberá tener un nombre relacionado con la aplicación que vamos a crear; la llamaremos Contador. Luego de crear la carpeta Contador hacemos doble clic en ella para ubicarnos dentro de la misma y en el campo File Name creamos un nuevo archivo de proyecto, lo llamaremos tambien Contador (la extension propia del archivo de proyecto es .mcppi en mikroC PRO para PIC, no hace falta escribirla porque el sistema la añade automaticamente). Clic en Save y luego en Next.
5. En el siguiente paso solo hacemos clic en Next
6. Aunque en este ejemplo no vamos a emplear ninguna de las librerias de funciones de mikroC PRO, dejamos seleccionada la opcion Include All (por defecto). Clic en Next
7. Un paso absolutamente necesario e imprescindible es establecer los bits de configuracion del microcontrolador PIC. Por lo tanto en este paso seleccionamos el checkbox Open Edit Project Window to set Configuration Bits. Clic en Finish.
8. En la ventana Edit Project establecemos los bits de configuracion de la siguiente manera y hacemos clic en OK:
   Oscillator:    INTOSC: I/O on RA6/OSC2, I/O on RA7/OSC1
   Watchdog Timer: Off
   Power Up Timer: Enabled
   Master Clear Enable: Disabled
   Brown Out Detect: Enabled
   Low Voltage Program: Disabled
   Data EE Read Protect: Disabled
   Code Protect: Off
   Uno de los puntos mas importantes a tener en cuenta es la configuracion del oscilador que es un subsistema encargado de generar la base de tiempo (reloj) para la ejecucion de las instrucciones; con una frecuencia de 4MHz la base de tiempo (llamada ciclo de instruccion) es de 1us. Algunas instrucciones se ejecutan en un ciclo de instruccion, es decir que el microcontrolador se demora  1us en realizar la instruccion; por tanto, la ejecucion de las instrucciones se realiza a alta velocidad. El PIC16F628A incluye un oscilador interno de 4MHz que es utilizado al seleccionar INTOSC: I/O on RA6/OSC2, I/O on RA7/OSC1 para el bit Oscillator; el uso del oscilador interno es recomendable ya que facilita armar el circuito electrico y libera dos pines del microcontrolador, de lo contrario seria necesario agregar un cristal oscilador externo con sus elementos asociados.
   El significado y funcion de los demas bits se irá aclarando a medida que profundice en su estudio de la programacion de microcontroladores PIC.
9. Aparece la ventana del editor de texto, donde escribiremos el codigo fuente de nuestro proyecto:
   

   //Contador.c
   //Macros (simbolos equivalentes)
   #define BOTON RA4_bit  //BOTON es equivalente a RA4_bit
   #define PRESIONADO 0   //PRESIONADO es equivalente a 0
   
   //Función para convertir de Binario a 7 segmentos
   char Bin2_7seg(char digit){
     switch (digit){ 
       case 0: return 0x3F;   //0x3F es el código 7-segmentos del 0.
       case 1: return 0x06;   //0x06 es el código 7-segmentos del 1.
       case 2: return 0x5B;
       case 3: return 0x4F;
       case 4: return 0x66;
       case 5: return 0x6D;
       case 6: return 0x7D;
       case 7: return 0x07;
       case 8: return 0x7F;
       case 9: return 0x67;
     }
   }
   
   //Declaracion de variables
   char contador=0;  //La variable contador es de tipo char y tiene valor inicial de 0.
   
   //Función principal
   void main(){
     PORTB=0x00;  //Estado inicial del puerto B.
     CMCON=0x07;  //Pines RA<3:0> como E/S digital.
     TRISB=0x00;  //Puerto B como salida.
     while (1){
       if (BOTON==PRESIONADO){          //Si se pulsa,
         Delay_ms(10);                   //esperar 10ms,
         if (BOTON==PRESIONADO){         //revisar si el boton sigue pulsado,
           while (BOTON==PRESIONADO);     //y esperar mientras siga presionado.
           contador++;                    //Al soltar incrementar el contador,
           if (contador>9) contador=0; //y reiniciarlo a 0 si supera el valor de 9.
         }
       }
       PORTB=Bin2_7seg(contador);  //Convertir y enviar al puerto B el valor
       //presente en la variable contador.
     }
   }//Fin de la función principal
   

10. Una vez terminada la escritura procedemos con la compilación (la traducción del codigo anterior a codigo de máquina). Este proceso es transparente para nosotros (lo único que observaremos serán unos mensajes durante esta fase en la parte inferior del IDE). Para compilar debemos seleccionar el comando Build > Build. El codigo de máquina o codigo ejecutable (se identifica como Contador.hex) se guarda automaticamente en un archivo en la carpeta Contador que creamos en el paso 4. 

    El codigo anterior es un ejemplo que se puede tomar como plantilla para la escritura de otros proyectos. El microcontrolador PIC ejecuta las instrucciones que se encuentran dentro de la función principal void main(){//Instrucciones...}, las partes restantes sirven como codigo complementario para la ejecución correcta de dichas instrucciones. Los Macros tienen el proposito de facilitar el mantenimiento y comprension del codigo; por ejemplo si se quiere emplear el pin RA7 en lugar del pin RA4 simplemente se tiene que escribir #define BOTON RA7_bit; también es mucho más comprensible BOTON==PRESIONADO que RA4_bit==0.

    Una funcion es una agrupacion de instrucciones que luego se tratan como una nueva instruccion dentro de la funcion principal; así Bin2_7seg(contador); es considerada como una instruccion más y ejecutada de acuerdo a su definicion.

    En mikroC PRO for PIC (así como en otros lenguajes de programación) es obligatorio declarar las variables que se usan en la funcion principal, indicando su tipo y de forma opcional su valor inicial; así char contador=0; es la declaracion de la variable contador como una variable de tipo caracter (puede tomar valores entre 0 y 255) y tiene en este caso un valor inicial de 0.

11. El codigo de maquina Contador.hex tiene que ser grabado en la memoria de programa del microcontrolador PIC de tal forma que al encenderlo ejecute las instrucciones indicadas en dicho codigo, de no ser asi el microcontrolador PIC seria un dispositivo que no serviria para nada ya que su memoria de programa se encuentra en blanco cuando sale de fabrica. El proceso de grabado se realiza por medio de un programador tal como el PICkit2 (todos los detalles los puede encontrar en el articulo Pickit2 Clone: Guia de Usuario).
12. El último paso es armar el circuito electrico del contador, teniendo en cuenta que la fuente de alimentacion debe ser de 5V (este voltaje se puede obtener fácilmente a partir de un regulador 7805).

    

13. Como recomendacion importante se sugiere agregar un condensador ceramico de 0.1uF entre los pines de alimentacion del PIC, lo cual ayudara a eliminar posibles problemas ocasionados por las fluctuaciones rapidas de la fuente de alimentacion. Además, notese que la conexion al display es directa (sin resistencias de por medio), lo que es posible debido a que los microcontroladores PIC están diseñados para suministrar una corriente máxima de 25mA en cada uno de sus pines. Al encender el circuito se observará que el display muestra el numero 0 ya que asi fue programado el PIC. Si se presiona (y se libera) el pulsador el conteo se incrementará en una unidad hasta una cuenta máxima de 9, en la siguiente pulsacion el conteo regresa a 0.

Para profundizar en el aprendizaje de la programación de microcontroladores PIC le recomendamos leer nuestra serie de articulos a continuación, donde se explican los conceptos basicos acompañados con ejemplos practicos y faciles de probar. También puede adquirir el ebook que contiene el fundamento teorico mas detallado y muchos ejemplos reales minuciosamente explicados, asi como las simulaciones en Proteus-ISIS para que pueda verificar su funcionamiento de forma rapida y efectiva.

Ejemplos de ejercicios resueltos

1. Comunicación PIC a PIC

La comunicacion alámbrica entre microcontroladores PIC es de suma importancia pues permite tener sistemas con multiples microcontroladores ejecutando distintas tareas en forma coordinada. La transmision de datos se puede lograr de forma bidireccional usando el modulo USART incorporado o funciones propias del compilador mikroC PRO.

Se describe la comunicación entre dos microcontroladores PIC16F628A usando el módulo USART-Software de mikroC.

Consta de dos proyectos, uno para cada PIC:

1. El proyecto PIC a PIC LCD es utilizado para recibir datos y presentarlos en un LCD 2x16.
2. El proyecto PIC a PIC se utiliza para enviar datos.

Código en mikroC PRO (lenguaje C)

Primer código fuente

//PIC_a_PIC_LCD.c
//Microcontrolador: PIC16F628A
//Oscilador: Interno-4MHz
//Este programa se almacena en uno de los dos microcontroladores (U2) y recibe continuamente un
//dato (la letra 'r') cada 300 ms por el pin de recepción RB6(12). El pin de transmisión es
//RB7(13). El dato recibido se va presentando en el LCD.
//La velocidad de transmisión de 600 Baudios fue seleccionada experimentalmente por un
//procedimiento de ensayo y error. El pin RB0(6) se enciende por 1 segundo en el caso de
//intentar establecer una velocidad de transmisión muy alta o muy baja.

//Declaración de las 12 variables necesarias para la conexión del módulo LCD.
sbit LCD_RS at RA4_bit;
sbit LCD_EN at RA6_bit;
sbit LCD_D4 at RA0_bit;
sbit LCD_D5 at RA1_bit;
sbit LCD_D6 at RA2_bit;
sbit LCD_D7 at RA3_bit;

sbit LCD_RS_Direction at TRISA4_bit;
sbit LCD_EN_Direction at TRISA6_bit;
sbit LCD_D4_Direction at TRISA0_bit;
sbit LCD_D5_Direction at TRISA1_bit;
sbit LCD_D6_Direction at TRISA2_bit;
sbit LCD_D7_Direction at TRISA3_bit;
// Fin de declaración de variables de conexión.

char error, byte_read;
void main(){
CMCON=0x07;                 //Pines RA<3:0> como E/S digital.
PORTB=0x00;
TRISB0_bit=0;
Lcd_Init();                 //Inicializa el LCD.
Lcd_Cmd(_LCD_CLEAR);        //Borra el display.
Lcd_Cmd(_LCD_CURSOR_OFF);   //Apaga el cursor.
error = Soft_UART_Init(&PORTB, 6, 7, 600, 0); //Inicializa el módulo UART-Software a 600 Baudios.
if (error >0){
  RB0_bit=1;
  Delay_ms(1000);
  RB0_bit=0;
  while(1);              //Detiene el programa en caso de error.
}
Delay_ms(100);
while(1) {
  byte_read = Soft_UART_Read(&error); //Recibe un dato y lo guarda en byte_read.
  if (!error)            //Si no hay error.
  Lcd_Chr_CP(byte_read); //Envía el dato recibido hacia el LCD.
  Delay_ms(200);
}
}

Segundo código fuente

//PIC_a_PIC.c
//Microcontrolador: PIC16F628A
//Oscilador: Interno-4MHz
//Este programa se almacena en uno de los dos microcontroladores (U1) y transmite continuamente un
//dato (la letra 'r') cada 300 ms por el pin de transmisión RB6(12). El pin de recepción es
//RB7(13).
//La velocidad de transmisión de 600 Baudios fue seleccionada experimentalmente por un
//procedimiento de ensayo y error. El pin RB0(6) se enciende por 1 segundo en el caso de
//intentar establecer una velocidad de transmisión muy alta o muy baja.

char error;
void main(){
CMCON=0x07;                 //Pines RA<3:0> como E/S digital.
PORTB=0x00;
TRISB0_bit=0;
error = Soft_UART_Init(&PORTB, 7, 6, 600, 0); //Inicializa el módulo UART-Software a 600 Baudios.
if (error >0){
  RB0_bit=1;
  Delay_ms(1000);
  RB0_bit=0;
  while(1);              //Detiene el programa en caso de error.
}
Delay_ms(100);
while (1){
  Soft_UART_Write('r');  //Envía el carácter 'r' cada 300 ms.
  Delay_ms(300);
}
}

Esquema eléctrico de la comunicación PIC a PIC

2. Decodificador DTMF MT8870 con PIC16F628A

El decodificador DTMF MT8870 opera en conjunto con un PIC16F628A configurado para trabajar con su oscilador interno de 4MHz. Se genera una interrupción debida al Timer0 cada 50ms (0,050 segundos) que se toma como base de tiempo para contabilizar los diferentes intervalos necesarios para el funcionamiento del circuito.

Para este ejemplo, el propósito es activar y desactivar el pin RB0 (6) por medio de una clave ingresada por el teclado del teléfono. La clave de activación es 1973, la clave de desactivación es 1974. Si el circuito se apaga por cualquier motivo, al encenderlo nuevamente se restablece el último estado que tenía el pin RB0.

Además, al ingresar la clave 3579 el pin RB1 (7) se activa durante 10 segundos. Al ingresar los dígitos el PIC espera 3 segundos. Si no se ingresa un nuevo dígito el PIC efectúa la tarea correspondiente. Si se ingresan menos o más de 4 dígitos el PIC no efectúa ninguna acción. Para ingresar una nueva clave simplemente hay que esperar más de 3 segundos. Cada 12 horas se enciende el pin RB2 (8) por un lapso de 1 hora.

Para comprobar la correcta operación del DTMF MT8870 se puede armar un circuito muy simple como se indica en el Probador para el MT8870, más abajo en la Información complementaria.

Ejemplo en mikroC PRO con el PIC16F628A

//DTMF.c
//Microcontrolador: PIC16F628A.
//Oscilador interno: 4MHz

char tecla[12], i=0, j, num_cifras, conteo=0, m=0, estado=0, pin=0, p=0;
int k=0, n=0;

//Función principal.
void main(){
  PORTB=0x00;  //Inicialización.
  CMCON=0x07;  //Pines RA<3:0> como E/S digital.
  TRISB=0x00;  //Puerto B como salida.
  OPTION_REG=0b11010111; //Timer0 como temporizador. Prescaler asignado
                        //al Timer0. Prescaler 1:256.
  GIE_bit=1;             //Interrupciones habilitadas.
  T0IE_bit=1;            //Interrupción del Timer0 habilitada.
  RB0_bit=EEPROM_Read(0x00);  //Actualiza el pin RB0 a su último estado.
  //La primera vez que se enciende el PIC, el estado del
  //pin RB0 será 1.
  TMR0=61;               //Valor inicial del TMR0 (interrupción cada 50ms).
  while (1){
    while (RA4_bit==0) ; //Esperar mientras no hay dato disponible.
    while (RA4_bit==1) ; //Dato disponible. Esperar mientras RA4 está en alto.
    i++;
    estado=1;
    num_cifras=i;
    tecla[i]=PORTA;      //Lee el dato disponible y lo almacena.
    conteo=0;
  }
}

void interrupt(void){
  TMR0=61;             //Valor inicial del TMR0.
  conteo++;
  if (conteo==60 && estado==1){
    if (tecla[1]==1 && tecla[2]==9 && tecla[3]==7 && tecla[4]==3 && num_cifras==4){ //Clave:1973
      RB0_bit=1;              //Activa el pin RB0.
      EEPROM_Write(0x00,1);   //Guarda el estado del pin RB0.
    }
    if (tecla[1]==1 && tecla[2]==9 && tecla[3]==7 && tecla[4]==4 && num_cifras==4){ //Clave:1974
      RB0_bit=0;              //Desactiva el pin RB0.
      EEPROM_Write(0x00,0);   //Guarda el estado del pin RB0.
    }
    if (tecla[1]==3 && tecla[2]==5 && tecla[3]==7 && tecla[4]==9 && num_cifras==4){ //Clave:3579
      RB1_bit=1;              //Activa el pin RB1.
      for (j=1;j<=10;j++)     //Espera 10 segundos.
      Delay_1sec();
      RB1_bit=0;              //Desactiva el pin RB1.
    }
    i=0; conteo=0; estado=0;
  }

  if (conteo==60)           //Reinicia la variable conteo si no se ha pulsado tecla alguna
  conteo=0;                //en 3 segundos.  

  k++;
  if (k==28800){            //Contabiliza 12 horas (28.800x30x0,050 segundos).
    k=0;
    m++;
    if (m==30){
      m=0;
      RB2_bit=1;              //Enciende el pin RB2.
      pin=1;                  //Registra el encendido de RB2.
    }
  }

  if (pin==1){             //Contabiliza 1 hora si RB2 está encendido.
    n++;
    if (n==14400){          //Contabiliza 1 hora (14.400x5x0,050 segundos).
      n=0;
      p++;
      if (p==5){
        p=0;
        RB2_bit=0;            //Apaga el pin RB2 luego de 1 hora.
        pin=0;
      }
    }
  }
  T0IF_bit=0;               //Borra la bandera de interrupción.
}

Esquema eléctrico del decodificador DTMF MT8870

Información complementaria

• Probador para el MT8870

3. Discador telefónico DTMF con el PIC16F628A

El ejemplo mostrado intenta describir únicamente el proceso básico de generación de llamadas con el microcontrolador PIC16F628A y el IC W91314A.

El discador telefónico DTMF W91314A de Windbond Electronics es un circuito integrado monolítico que proporciona las señales necesarias para marcación por pulsos o tonos. El circuito integrado W91314A tiene una memoria de redial.

Características

• Discador telefónico conmutable entre tonos DTMF ó pulsos
• 32 dígitos para la memoria de redial
• Tecla de Pulsos a Tonos (P -> T) para el funcionamiento de llamadas de larga distancia
• Utiliza un teclado 4x4 o control electrónico de un microcontrolador
• Fácil manejo con teclas de redial, flash, pausa y P -> T
• Las funciones de Flash, pausa, P -> T (pulso-a- tonos) se pueden almacenar como un dígito en la memoria
• Duración mínima de los tonos de salida: 100 ms
• Pausa mínima entre tonos: 100 ms
• Reset al encendido incorporado en el chip
• Utiliza un cristal o resonador cerámico de 3.579545 MHz
• Envasado en DIP plástico de 18 pines

Los diferentes discadores en la serie W91310 se muestran en la siguiente tabla:

Pinout (patillaje)

R<4:1> - C<4:1> Entradas de Filas-Columnas
La entrada de teclado puede ser tanto del teclado estándar 4x4 o un teclado simple de un solo contacto y bajo costo. También se puede utilizar la entrada electrónica desde un microcontrolador. Una entrada de teclado válida se define como una sola fila conectada a una sola columna.

XT, /XT
Cristal o resonador cerámico de 3.579545 MHz.

MODE (Entrada)
Al conectar el pin MODE a Vss pone al chip en el modo de Tonos. Al conectar el pin MODE a VDD pone al W91314A en el modo de Pulsos (10 pps). Dejando el pin sin conectar pone al W91314A en el modo de Pulsos (20 pps).

/HKS (Entrada)
Entrada del interruptor de Colgado.
/HKS = 1: Estado de Colgado. Chip en modo suspendido, ninguna operación.
/ HKS = 0: Estado de Descolgado. Chip habilitado para operación normal.
El pin /HKS se conecta a VDD por una resistencia interna.

DTMF (Salida)

En el modo de Pulsos, se mantiene en estado bajo en todo momento. En el modo de Tonos, esta salida del discador telefónico emite un tono doble o individual.

VDD, Vss
Pines de alimentación.

B/M (Entrada)
Este pin no cumple función alguna en el modo de Tonos.

Operación con teclado y microcontrolador PIC16F628A

Operación con teclado

Para generar una llamada, simplemente hay que poner al discador telefónico W91314A en el modo de Descolgado (/HKS = 0) y a continuación presionar las teclas correspondientes al número telefónico deseado. Al conectar una fila (R) con una columna (C) se generan simultáneamente los dos tonos indicados en la tabla anterior, los cuales son enviados por el pin DTMF.

Operación con microcontrolador PIC16F628A

Si se utiliza un microcontrolador PIC16F628A para remplazar al teclado, la idea fundamental es la misma: si se desea generar una llamada, se debe poner al W91314A en modo de Descolgado y luego conectar las filas y columnas de acuerdo a cada dígito que se quiere marcar. La técnica consiste en unir los 8 pines R<4:1> - C<4:1> del W91314A a 8 pines del microcontrolador (configurados momentáneamente como salidas) y luego enviar niveles bajos (GND) a los dos pines del PIC que están unidos a los dos pines del W91314A que se quieren juntar. Por ejemplo, para marcar el dígito “8”, se deben poner en nivel bajo los 2 pines del PIC conectados a C2 y R3; de esta forma los pines C2 y R3 quedan conectados a GND lo que equivale a una unión directa C2 - R3. En el siguiente circuito se pueden observar los detalles:

Ejemplo con PIC16F628A en mikroC PRO

En el siguiente código, escrito en mikroC PRO, se debe observar que originalmente los pines del microcontrolador PIC16F628A se encuentran configurados como entradas (por defecto) lo que hace que presenten un estado de alta impedancia. Las parejas de pines se configuran momentáneamente como salidas para enviar el nivel bajo (GND) y luego se restablecen a su configuración inicial de alta impedancia. De otra forma se producirían interconexiones indeseadas de los pines del W91314A.

DiscadorDTMF.c : Genera una llamada al número 0987438877 usando el circuito W91314A como generador DTMF y el PIC16F628A como teclado electrónico. El discador se encuentra en modo Descolgado ya que el pin / HKS está conectado a GND (0).

//DiscadorDTMF.c
//Microcontrolador: PIC16F628A
//Oscilador interno: 4MHz (TCI=1us)

#define R4 RB7_bit
#define R3 RB6_bit
#define R2 RB5_bit
#define R1 RB4_bit

#define R4D TRISB7_bit
#define R3D TRISB6_bit
#define R2D TRISB5_bit
#define R1D TRISB4_bit

#define C4 RA3_bit
#define C3 RA2_bit
#define C2 RA1_bit
#define C1 RA0_bit

#define C4D TRISA3_bit
#define C3D TRISA2_bit
#define C2D TRISA1_bit
#define C1D TRISA0_bit

void main(){
CMCON=0x07;  //Pines RA como E/S digital.
TRISA=0xFF;  //Puerto A como entrada.
TRISB=0xFF;  //Puerto B como entrada.

Delay_ms (2000); //Espera 2 segundos antes de hacer la llamada.

//0
C2=0; R4=0;    //Escribir niveles bajos en los latch de salida.
C2D=0; R4D=0;  //Enviar los niveles bajos a los pines de salida.
Delay_ms(80);  //Generar los tonos durante 80 ms.
C2D=1; R4D=1;  //Restablecer los pines a su estado de alta Z.
Delay_ms(200); //Esperar 200ms antes de enviar el siguiente dígito.

//9
C3=0; R3=0;
C3D=0; R3D=0;
Delay_ms(80);
C3D=1; R3D=1;
Delay_ms(200);

//8
C2=0; R3=0;
C2D=0; R3D=0;
Delay_ms(80);
C2D=1; R3D=1;
Delay_ms(200);

//7
C1=0; R3=0;
C1D=0; R3D=0;
Delay_ms(80);
C1D=1; R3D=1;
Delay_ms(200);

//4
C1=0; R2=0;
C1D=0; R2D=0;
Delay_ms(80);
C1D=1; R2D=1;
Delay_ms(200);

//3
C3=0; R1=0;
C3D=0; R1D=0;
Delay_ms(80);
C3D=1; R1D=1;
Delay_ms(200);

//8
C2=0; R3=0;
C2D=0; R3D=0;
Delay_ms(80);
C2D=1; R3D=1;
Delay_ms(200);

//8
C2=0; R3=0;
C2D=0; R3D=0;
Delay_ms(80);
C2D=1; R3D=1;
Delay_ms(200);

//7
C1=0; R3=0;
C1D=0; R3D=0;
Delay_ms(80);
C1D=1; R3D=1;
Delay_ms(200);

//7
C1=0; R3=0;
C1D=0; R3D=0;
Delay_ms(80);
C1D=1; R3D=1;
Delay_ms(200);
}
   

El ejemplo mostrado intenta describir únicamente el proceso básico de generación de llamadas con el microcontrolador PIC16F628A y el IC W91314A. Se puede mejorar para que la conexión de la línea sea automatizada así como el estado de Descolgado. También se pueden agregar otras opciones a gusto del lector, como el llamado a varios números telefónicos, la generación de llamadas activadas por uno o varios sensores, la transmisión de mensajes de voz grabados, etc.

4. Display POV

El display POV (Persistense Of Vision) opera en base a la persistencia de la visión humana cuando un objeto se mueve rapidamente; la rotación de una columna de LEDs que se encienden en determinada secuencia hace que se forme en la mente del observador una imagen que depende del codigo programado en un microcontrolador PIC.

El display POV consta de un PIC16F88, un regulador de voltaje ajustable ECG1900 para el PIC (para tener control de la corriente que circula por los LEDs),  una columna de 7 LEDs RGB y un motor de CD de 5V, con control de velocidad por variación de voltaje LM317T. Para cada letra el PIC envía secuencialmente 5 grupos de 7 bits, ya sea al puerto A (verde) o al puerto B (rojo). Debido a la rotación de la columna de LEDs en sentido antihorario  y al fenómeno de la persistencia de la visión, se va formando en la mente del observador la imagen correspondiente. El PIC se puede programar con diferentes secuencias para presentar una gran variedad de mensajes.

Código en lenguaje C (mikroC PRO)

 
//POV.c
void main(){
OSCCON=0x70; //Oscilador interno a 8MHz (TCI=0,5 us).
PORTA=0x00;  //Inicialización.
PORTB=0x00;
ANSEL=0x00;  //Pines AN como E/S digital.
TRISA=0x00;  //Puerto A como salida.
TRISB=0x00;  //Puerto B como salida.

//Delay_us(5000);
PORTB=0x7E;Delay_us(500);  //m
PORTB=0x02;Delay_us(900);
PORTB=0x7E;Delay_us(500);
PORTB=0x02;Delay_us(900);
PORTB=0x7C;Delay_us(500);
PORTB=0x00;Delay_us(1500);

PORTA=0xDA;Delay_us(500);  //i
PORTA=0x00;Delay_us(1500);

PORTB=0x3C;Delay_us(500);  //c
PORTB=0x42;Delay_us(1500);
PORTB=0x24;Delay_us(500);
PORTB=0x00;Delay_us(1500);

PORTA=0xDE;Delay_us(500);  //r
PORTA=0x04;Delay_us(500);
PORTA=0x02;Delay_us(1000);
PORTA=0x04;Delay_us(500);
PORTA=0x00;Delay_us(1500);

PORTB=0x3C;Delay_us(500);  //o
PORTB=0x42;Delay_us(1500);
PORTB=0x3C;Delay_us(500);
PORTB=0x00;Delay_us(1500);

PORTA=0x5E;Delay_us(500);  //C
PORTA=0x81;Delay_us(1500);
PORTA=0x42;Delay_us(500);
PORTA=0x00;
}

Información complementaria

• Videotutoriales
• Conceptos básicos de lenguaje C (para computadoras)
• Curso de iniciación al lenguaje C (para computadoras)
• Manual de referencia de la gama media de microcontroladores de Microchip (en Inglés)