Pic16f877a despertador digital basado en microcontrolador

La Revolución digital iniciada en 1950 transforma todas las estructuras electrónicas analógicas y mecánicas existentes en computadoras digitales. Dado que el crecimiento de la electrónica digital ha sido exponencial, hoy en día es casi imposible que una persona se resista a utilizar cualquier equipo electrónico. Desde el despertador que te despierta y la tostadora que te sirve el desayuno, todo es un aporte de la electrónica digital. Pensando en todo esto, es realmente emocionante programar nuestras propias cosas que podrían hacer tareas simples pero útiles, como el despertador que vamos a construir en este proyecto con el microcontrolador PIC. Anteriormente hemos construido un reloj despertador con otros microcontroladores:

Despertador Raspberry Pi con módulo RTC DS1307
Reloj digital basado en Arduino con alarma
Despertador con microcontrolador ATmega32

Este reloj despertador tendrá una pantalla LCD de 16x2 que mostrará la hora actual y la hora establecida. Usaremos algunos botones para configurar la hora de la alarma cuando sea necesario. La hora actual se mantendrá al día usando el módulo RTC DS3231 y usaremos la comunicación IIC para obtener estos valores del módulo RTC. Ya hemos aprendido sobre el módulo RTC y cómo conectarlo con PIC. Por lo tanto, se recomienda leer ese tutorial, omitiremos la mayor parte de la información cubierta en ese tutorial.

Materiales necesarios:

Tabla de pan - 2Nos
PIC16F877A
Fuente de alimentación de 5 V - Módulo de alimentación
Cristal de 20 MHz
Condensador 33pf - 2Nos
Módulo RTC DS3231
Módulo de pantalla LCD 16 * 2
BOTE 10K
Resistencia de 10k y 1K
Botones pulsadores - 5Nos
Zumbador
Cables de conexión

Prerrequisitos:

Este proyecto requiere que conozca algunos conceptos básicos sobre el microcontrolador PIC y cómo programarlo. Usaremos GPIO, pantalla LCD y módulo RTC para este proyecto. Por tanto, es mejor aprender a utilizar estos módulos de antemano. Los siguientes enlaces te ayudarán a aprender lo mismo

Escribiendo su primer programa con PIC Microcontroller
Interfaz LCD con PIC
Comunicación I2C mediante PIC
Interfaz DS3231 RTC con PIC

Diagrama de circuito:

A continuación se muestra el diagrama de circuito para este proyecto de reloj despertador basado en PIC, que se creó utilizando el software proteus. También se utilizará para la simulación más en este proyecto.

Los cinco pulsadores actuarán como una entrada para configurar la alarma durante el tiempo requerido. Por lo tanto, un extremo de todos los botones pulsadores está conectado a tierra y los otros extremos están conectados al pin PORTB, se utilizará una resistencia pull-up interna en estos pines para evitar que floten. El Buzzer actuará como una salida y nos dará un pitido cuando la alarma se active y se conecte al pin PORT S. El módulo DS3231 RTC siempre mantiene el seguimiento de la hora actual desde el cual el PIC recibe los datos a través del bus I2C, por lo que los pines SCL y SDA del módulo RTC se conectan al pin SCL y SDA del controlador PIC. Se adjunta una pantalla LCD al PORTD del PIC que se utiliza para mostrar la hora actual y la hora establecida. Obtenga más información sobre el uso del módulo DS3231 RTC con PIC aquí.

El circuito completo se puede construir sobre una placa de pruebas. Dado que hay un par de docenas de cables para conectar, tenga paciencia y asegúrese de que las conexiones sean correctas. Mi configuración de hardware se veía así a continuación una vez que terminé con las conexiones

He usado un módulo de tablero y un adaptador de 12V para alimentar el módulo. Esta es mi fuente de voltaje de suministro de + 5V. También tengo que usar dos protoboards para mantener limpio el circuito. También puede soldar todo el circuito a una placa de perforación si está buscando hacer un proyecto más robusto.

Programación para reloj despertador:

El programa PIC completo para este proyecto de despertador se puede encontrar en la parte inferior de esta página. Este proyecto también requiere tres bibliotecas para usar LCD, I2C y RTC con PIC. El código completo con los archivos de encabezado se puede descargar del archivo ZIP aquí y se puede abrir usando MPLABX después de extraerlo. Más abajo, solo estoy explicando el archivo c principal como pequeños fragmentos. Puede recurrir a los tutoriales mencionados anteriormente si desea saber cómo funcionan los archivos de encabezado.

Antes de entrar en el programa principal, tenemos que definir los pines que hemos usado con un nombre más significativo. De esta forma será fácil utilizarlos durante la programación. Los pines definidos en nuestro programa se muestran a continuación

// Definir los pines del LCD # definir RS RD2 // Restablecer el pin del LCD # definir EN RD3 // Activar pin del LCD # definir D4 RD4 // Bit de datos 0 del LCD # definir D5 RD5 // Bit de datos 1 del LCD # definir D6 RD6 // Bit de datos 2 de LCD #define D7 RD7 // Bit de datos 3 de LCD // Definir botones #define MB RB1 // El botón central #define LB RB0 // Botón izquierdo #define RB RB2 // Botón derecho # define UB RB3 // Botón superior #define BB RB4 // Botón inferior // Define Buzz #define BUZZ RD1 // Buzzer está conectado a RD1

Dentro de la función principal comenzamos declarando los pines de entrada y salida. En nuestro proyecto, el PORTB se usa para botones pulsadores, que es un dispositivo de entrada, por lo que configuramos sus pines como entradas y PORTD se usa para LCD y zumbador, por lo que configuramos sus pines como Salida. Además, un pin nunca debe dejarse flotando, lo que significa que los pines de E / S siempre deben estar conectados a tierra o al voltaje de + 5V. En nuestro caso, para los botones pulsadores, los pines no estarán conectados a nada cuando no se presione el botón, por lo que usamos una resistencia pull-up interna que establece el pin en Alto cuando no está en uso. Esto se hace usando los registros de control como se muestra a continuación.

TRISD = 0x00; // Convierta los pines del puerto D como salida para la interfaz LCD TRISB = 0xFF; // Los interruptores se declaran como pines de entrada OPTION_REG = 0b00000000; // Habilite pull up Resistor en el puerto B para conmutadores BUZZ = 0; // Gire el timbre

Dado que tenemos el archivo de encabezado LCD e I2C vinculado con el programa principal, podemos iniciar la inicialización del LCD llamando a una función simple. También se puede hacer lo mismo para la inicialización I2C. Aquí estamos iniciando la comunicación I2C a 100kHz ya que el módulo RTC trabaja con 100kHz.

Lcd_Start (); // Inicializar el módulo LCD I2C_Initialize (100); // Inicializar I2C Master con un reloj de 100 KHz

La siguiente función se utiliza para configurar la hora y la fecha en el módulo RTC, una vez configurada la hora y la fecha, elimine esta línea. De lo contrario, cada vez que inicie el programa, la hora y la fecha se establecerán una y otra vez.

// Elimine la línea de abajo una vez que la hora y la fecha estén configuradas por primera vez. Set_Time_Date (); // establecer la hora y la fecha en el módulo RTC

Para indicar que el programa se está iniciando, mostramos una pequeña pantalla de introducción que muestra el nombre del proyecto y el nombre del sitio web como se muestra a continuación.

// Dar un mensaje de introducción en la pantalla LCD Lcd_Clear (); Lcd_Set_Cursor (1,1); Lcd_Print_String ("Reloj despertador"); Lcd_Set_Cursor (2,1); Lcd_Print_String ("-Circuit Digest"); __delay_ms (1500);

A continuación en el interior del tiempo de bucle tenemos que leer la hora y fecha actuales del módulo RTC, esto se puede hacer con sólo llamar el siguiente función.

Update_Current_Date_Time (); // Leer la fecha y hora actuales del módulo RTC

Llamar a la función anterior actualizará las variables seg, min y hora con el valor actual. Para mostrarlos en la pantalla LCD , tenemos que dividirlos en caracteres individuales usando el código a continuación.

// Divide el en char para mostrarlo en lcd char sec_0 = sec% 10; char sec_1 = (seg / 10); char min_0 = min% 10; char min_1 = min / 10; char hour_0 = hora% 10; char hour_1 = hora / 10;

A continuación, actualizamos los valores en la pantalla LCD. La hora actual se mostrará en la primera línea y la hora configurada a la que debe activarse la alarma se mostrará en la segunda línea. El código que hace lo mismo se muestra a continuación.

// Muestra la hora actual en la pantalla LCD Lcd_Clear (); Lcd_Set_Cursor (1, 1); Lcd_Print_String ("HORA:"); Lcd_Print_Char (hora_1 + '0'); Lcd_Print_Char (hora_0 + '0'); Lcd_Print_Char (':'); Lcd_Print_Char (min_1 + '0'); Lcd_Print_Char (min_0 + '0'); Lcd_Print_Char (':'); Lcd_Print_Char (sec_1 + '0'); Lcd_Print_Char (sec_0 + '0'); // Muestra la fecha en la pantalla LCD Lcd_Set_Cursor (2, 1); Lcd_Print_String ("Alarma:"); Lcd_Print_Char (alarm_val + '0'); Lcd_Print_Char (alarm_val + '0'); Lcd_Print_Char (':'); Lcd_Print_Char (alarm_val + '0 '); Lcd_Print_Char (alarm_val + '0');

Ahora, mostramos la hora y la configuramos en la pantalla LCD, tenemos que verificar si el usuario está tratando de configurar la hora de la alarma. Para hacer esto, el usuario debe presionar el botón central, por lo que verificaremos si el botón central está presionado y cambiaremos una variable para ingresar al modo de configuración de alarma. Se volverá a pulsar el mismo botón para confirmar que los valores están configurados y en ese caso tenemos que salir del modo de configuración de alarma. Entonces usamos la siguiente línea de código para cambiar el estado de la variable set_alarm .

// Use el botón central para verificar si la alarma debe configurarse si (MB == 0 && set_alarm == 0) {// Si se presiona el botón central y la alarma no está activada mientras (! MB); // Esperar hasta que se suelte el botón set_alarm = 1; // comenzar a configurar el valor de la alarma } if (MB == 0 && set_alarm == 1) {// Si se presiona el botón central y la alarma no se apaga mientras (! MB); // Esperar hasta que se suelte el botón set_alarm = 0; // dejar de configurar el valor de la alarma }

Si el usuario ha presionado el botón central, significa que está tratando de configurar la hora de la alarma. En este caso, el programa entra en modo de configuración de alarma utilizando el código anterior. Dentro del modo de configuración de alarma, si el usuario presiona el botón izquierdo o derecho, significa que tenemos que mover el cursor hacia la izquierda o hacia la derecha. Para hacer esto, simplemente incrementamos o disminuimos el valor de la posición en la que se debe colocar el cursor

if (LB == 0) {// Si se presiona el botón izquierdo mientras (! LB); // Esperar hasta que se suelte el botón pos--; // Luego mueva el cursor hacia la izquierda } if (RB == 0) {// Si se presiona el botón derecho while (! RB); // Esperar hasta que se suelte el botón pos ++; // Mover el cursor a la derecha }

Al usar un botón pulsador con un microcontrolador o microprocesador, hay un problema común que abordar. Este problema se denomina rebote del interruptor. Es decir, cuando se presiona el botón, puede dar pulsos ruidosos a la MCU / MPU que pueden falsificar la MCU para múltiples entradas. Este problema se puede resolver agregando un capacitor a través del interruptor o usando una función de retardo tan pronto como se detecte la presión del botón. Este tipo de solución se llama eliminación de rebotes. Aquí hemos utilizado un tiempo de bucle para mantener el programa en su lugar hasta que se suelta el botón. Esta no es la mejor solución para eliminar los rebotes, pero para nosotros funcionará bien.

mientras (! RB);

Similar al botón izquierdo y derecho, también tenemos los botones superior e inferior que se pueden usar para aumentar o disminuir el valor de la hora de alarma. El código para hacer lo mismo se muestra a continuación. Observe que cada carácter de la hora de alarma establecida se direcciona mediante el valor de índice de la matriz. Así podemos acceder fácilmente al carácter requerido cuyos valores deben cambiarse.

if (UB == 0) {// Si se presiona el botón superior mientras (! UB); // Espere hasta que se suelte el botón alarm_val ++; // Incrementa ese valor de carácter particular } if (BB == 0) {// Si se presiona el botón inferior while (! UB); // Espere hasta que se suelte el botón alarm_val--; // Disminuye ese valor de char en particular }

Una vez configurada la hora de la alarma, el usuario volverá a presionar el botón central. Entonces podemos comenzar a comparar la hora actual con la hora establecida. La comparación verificando si cada carácter de la hora actual es igual al carácter de la hora establecida. Si los valores son iguales, activamos la alarma configurando la variable trigger_alarm; de lo contrario, simplemente comparamos hasta que se iguale.

// SI la alarma está configurada Verifique si el valor configurado es igual al valor actual si (set_alarm == 0 && alarm_val == hour_1 && alarm_val == hour_0 && alarm_val == min_1 && alarm_val == min_0) trigger_alarm = 1; // Enciende el gatillo si el valor coincide

Si la alarma está configurada, debemos hacer sonar un pitido para alertar al usuario de la alarma. Esto se puede hacer simplemente alternando el zumbador a intervalos regulares como se muestra a continuación.

if (trigger_alarm) {// Si se dispara la alarma // Emite un pitido BUZZ = 1; __delay_ms (500); BUZZ = 0; __delay_ms (500); }

Simulación:

Este programa también se puede simular utilizando el software proteus. Simplemente vuelva a crear el circuito que se muestra arriba y cargue el archivo hexadecimal en el PIC. El código hexadecimal de este proyecto se puede encontrar en el archivo ZIP que está vinculado aquí. A continuación se muestra una captura de pantalla tomada durante la simulación.

La simulación se vuelve muy útil cuando intentas agregar nuevas funciones al proyecto. También puede utilizar el módulo depurador I2C para comprobar qué datos entran y salen a través del bus I2C. Puede intentar presionar los botones y también configurar la hora de la alarma. Cuando la hora establecida es igual a la hora actual, el zumbador se activará.

Funcionamiento del reloj despertador digital con PIC16F877A:

Construya el circuito en la placa, obtenga el código del enlace de descarga y compílelo usando el compilador MplabX y XC8. Si ha descargado el código del archivo ZIP proporcionado aquí, entonces no debería tener problemas para compilarlo, ya que los archivos de encabezado ya están adjuntos.

Después de compilar, cargue el programa en su hardware usando el programador PicKit3. La conexión para conectar el programador pickit al PIC IC también se muestra en el diagrama del circuito. Después de que se cargue el programa, debería ver la pantalla de introducción y luego la hora que se muestra puede usar los botones para configurar la hora de la alarma. Mi configuración de hardware cuando se enciende se ve así a continuación.

Cuando la hora de la alarma coincida con la hora actual, el zumbador comenzará a sonar para alarmar al usuario. El trabajo completo se puede encontrar en el video a continuación. El proyecto tiene una gran cantidad de opciones sobre las que construir. El módulo RTC puede realizar un seguimiento de cualquier fecha y hora, por lo que puede realizar una tarea programada en cualquier fecha / hora requerida. También puede conectar un aparato de CA como un ventilador o una luz y programarlo para que se encienda o apague cuando sea necesario. Todavía hay mucho más que puedes construir sobre este proyecto, déjame saber qué idea te viene a la mente como una actualización de este proyecto y estaré feliz de saber de ti.

Espero que haya entendido el proyecto y haya aprendido algo útil del proceso. Si tiene alguna duda sobre este proyecto, utilice la sección de comentarios para publicarlas o utilice los foros para obtener ayuda técnica.

El código PIC completo con archivos de encabezado se puede encontrar aquí