Hola, tengo este proyecto (PARTE DEL CODIGO LO ENCONTRE POR AHI) que es un contador de vueltas programable, anda bien!solo necesitaría una mano de como explicarlo, ya que no hace mucho eh iniciado en esto.
#include <16f88.h> //PIC
#fuses nofcmen,noieso,nobrownout //FUSIBLES
#use delay (internal = 8MHz)//USAMOS CLOCK INTERNO 8MHZ
#include <lcd.c>//INCLUIMOS LIBRERIA LCD Por defecto el LCD se conecta al puerto D, si se desea conectar el LCD en el puerto B se incluye esta línea en el encabezado
#define use_portb_kbd true // USAMOS EL PUERTO B PARA EL TECLADO
#include <kbd.c>// INCLUIOS LIBRERIA KBD PARA EL MANEJO DE TECLADO 4X4
//#include <stdlib.h>//Funciones de C estandar
//-Funciones Artitmeticas
//-Numeros Aleatorios
//-Conversion de Cadena "
// Nombres para los pines.
#define pin_relay pin_a1
#define sensor_incr pin_a2
#define pin_buzzer pin_a4
/*****************************************************************************/
// Declaración de variables.
unsigned int8 i; // Propósito general, Entero de 8bits
unsigned int8 valor_adc=0; // Para lectura del ADC, Entero de 8bits
/*****************************************************************************/
// Variables de conteo.
unsigned char digitos[7]; //Tipo de dato para caracteres, símbolos tipográficos como A, d y $
unsigned int32 temp_vueltas,vueltas; //Numeros Enteros sin Signos de 32Bits
unsigned char digito[7];//Tipo de dato para caracteres, símbolos tipográficos como A, d y $
unsigned int8 str_vueltas[7];//Define un número de 8 bits sin signo
/*****************************************************************************/
// Declaración de las funciones utilizadas en el programa.
void leer_cantidad_teclado(void);
void iniciar_conteo(void);
void guardar_vueltas(void);
void conteo (unsigned int32 vueltas);
void buzzer_bips(int8 veces,int16 tiempo);
/*****************************************************************************/
void main(void){
setup_adc_ports(sAN0); // Seleccionar el canal 0
setup_adc(ADC_CLOCK_INTERNAL);// Utilizar el reloj interno para el conversor.
set_adc_channel(0); // Activar el al 0
/*****************************************************************************/
output_low(pin_buzzer); // Poner a 0 el pin RA4 (Buzzer apagado)
output_low(pin_relay); // Poner a 0 el pin RA1 (Relay apagado)
kbd_init(); // Inicializar el teclado.
lcd_init(); // Inicializar la pantalla.
port_b_pullups(true); // Activar las resistencias pull-up del puerto B
/****************************************************************************/
lcd_putc("\fPROYECTO \n 2020");// Escribimos en el LCD.
delay_ms(2000); // Esperamos 2000 ms
if (vueltas == 0){vueltas = 300;} // Esto se puede omitir e iniciar en 0, por defecto iniciamos en 300
// Pusimo 300, ya que son 300 las vuelta que tenemos que contabilizar.
temp_vueltas = vueltas;
// Subrutina para seleccionar ingreso de vueltas o inicio de conteo.
while(true) //Bucle Infinito.
{
lcd_putc("\f* INGRESA CONTEO\n# INICIAR CONTEO");
while(true)
{
digito[0]=kbd_getc(); // Se guarda el valor de la tecla seleccionada.
if(digito[0]!=0)
{
buzzer_bips(1,100); // Activar el buzzer X veces, X tiempo en Ms.
switch (digito[0])
{
case 35: // Tecla #
iniciar_conteo(); // Ir a subrutina para contar las vueltas.
break;
case 42: // Tecla *
leer_cantidad_teclado(); // Ir a subrutina para leer el teclado.
}
}
}
}
}
// Subrutina para activar el buzzer durante X tiempo X veces.
void buzzer_bips(int8 veces,int16 tiempo)
{
int8 x;
for (x=1;x<=veces;x++)//Varie la variable de control de 1 a VECES en incrementos de a 1:
{
output_high(pin_buzzer);
delay_ms(tiempo);
output_low(pin_buzzer);
delay_ms(tiempo);
}
}
// Subrutina de conteo para sensor magenetico.
void conteo (unsigned int32 vueltas)
{
unsigned int32 contador=0,restantes=0;
output_high(pin_relay); // Encender el relevador.
while(true)
{
//*****************************************************************************
// Se utiliza la técnica de Polling. (Leer constantemente las entradas)
while(input(sensor_incr))
{
contador++; // Incrementar el contador cuando Sensor Magnetico pase de 1 a 0
while(input(sensor_incr));
}
if(contador >= vueltas) // Cuando contador >= vueltas...
{
output_low(pin_relay); // Apagar relevador.
lcd_putc("\fCONTEO TERMINADO\n"); // Mostrar conteo finalizado.
printf(lcd_putc,"%07lu VUELTAS",contador);
contador = 0; // Resetear el contador a 0
buzzer_bips(10,100); // Avisar con X bips del buzzer.
break;
}
lcd_gotoxy(1,2);
// Mostrar la cuenta de las vueltas.
printf(lcd_putc,"%07lu VUELTAS",contador);
}
}
// Subrutina previa para iniciar el conteo.
void iniciar_conteo(void)
{
if( vueltas == 0) // Notificar que no se ha ingresado la cantidad de vueltas.
{
lcd_putc("\f ERROR EN CONTEO\n PRESIONE *");
}
else
{
printf(lcd_putc,"\fCONTAR: %07lu\n VUELTAS",vueltas);
delay_ms(2000);
conteo(vueltas); // Ir a la subrutina de conteo.
}
}
// Subrutina para guardar el conteo principal en la memoria EEPROM interna.
void guardar_vueltas(void)
{
write_eeprom(10,0); // Guardar un 0 para indicar cambio de vueltas
sprintf (str_vueltas,"%lu",vueltas);
for (i=0;i<=6;++i)
{
write_eeprom (i,str_vueltas);
delay_ms(10);
}
lcd_putc("\fCONTEO GUARDADO\nEN LA MEMORIA");
buzzer_bips(6,100); // Avisar con X bips del buzzer.
delay_ms(3000);
lcd_putc("\f PRESIONE EL #\n PARA INICIAR");
while(true)
{
digito[0]=kbd_getc();
if(digito[0]!=0)
{
switch (digito[0]){
case 35: // Tecla #
buzzer_bips(1,100); // Avisar con X bips del buzzer.
iniciar_conteo();
}
}
}
}
// Subrutina para leer la cantidad ingresada por el teclado.
void leer_cantidad_teclado(void)
{
releer:
printf(lcd_putc,"\fACTUAL: %07lu\nNUEVO: ",vueltas);
// Iniciar el bucle de lectura de la frecuencia por teclado.
lcd_gotoxy(9,2); //Posicion
lcd_cursor_on(1); // Enciendo el cursor con parpadeo.
while(true)
{
// Leer los valores de las teclas pulsadas.
for (i=0;i<=6;i++)
{
while(true)
{
digitos=kbd_getc(); // Guardar en dígito[i+1] el valor de la tecla pulsada.
if(digitos!='\0') // Si se pulsó una tecla, continuar.
{
if(digitos=='*'){digitos='0';} // Convertir el * (42) en 0 al restar 48.
if(digitos=='#'){digitos='0';} // Convertir el # (35) en 0 al restar 48.
lcd_gotoxy(9+i,2);
printf(lcd_putc,"%c",digitos);
buzzer_bips(1,100); // Activar el buzzer X veces, X tiempo en Ms.
break;
}
}
}
lcd_cursor_on(0); // Apago el parpadeo del cursor.
// Convertir la cantidad de vueltas ingresada por teclado a entero.
vueltas = atoi32(digitos);
buzzer_bips(2,100); // Avisar con X bips del buzzer el fin cantidad.
delay_ms(3000);
if(vueltas>9999999 || vueltas == 0) // Por si no se ingresa conteo o es mayor a 9999999
{
lcd_putc("\f ERROR EN CONTEO\n INGRESE NUEVO");
delay_ms(3000);
vueltas = temp_vueltas;
goto releer;
}
sprintf (str_vueltas,"%lu",vueltas);
vueltas = atoi32(str_vueltas);
lcd_putc("\f* GUARDAR CONTEO\n# INICIAR CONTEO");
while(true)
{
digito[0]=kbd_getc();
if(digito[0]!=0)
{
switch (digito[0]){
case 35: // Tecla #
buzzer_bips(1,100); // Avisar con X bips del buzzer.
iniciar_conteo();
break;
case 42: // Tecla *
guardar_vueltas();
}
}
}
}
}
