Chip temporizador programable
#incluye & ltAT89X52. H & gt
//Definición de macro
#Definir uchar carácter sin signo
#Definir uint entero sin signo
#Definir ulong Largo sin signo entero
/****************************************** * *****************************************
* TH0 y TL0 son el contador alto de 8 bits y bajo de 8 bits del contador 0. El método de cálculo es TL0 = (65536-C)% 256; *
* TH0=(65536-C) /256, donde C es el número de conteos, es decir, la frecuencia de interrupciones; TMOD es el contador *
* selección del modo de trabajo, 0x001 indica el modo de selección 1, tiene un contador de 16 bits. , el pulso de conteo máximo es 65536, el tiempo máximo *
*El intervalo de tiempo es 1 milisegundo* 65536 = 65,536 milisegundos*
*********** ******************* ********************************** ****************** ***/
#Definición v_tmod 0x 001//Modo de trabajo 1
#Definición v_th00x3c/ /Constante de retardo de 50ms C=50000 //0XDC
#Definición v_tl00xb0//Constante de retardo de 50ms C=50000/0X58
//#Definición v_th10xff//Constante de retardo de 50ms C=5000 //0XDC.
//#Definir v_tl10xfb//Constante de retardo de 5 ms C=5000/0X58.
#Definir v_th10xdc//Constante de retardo de 1ms C=1000 //0XDC.
#Definir v_tl1x58//Constante de retardo de 1ms C=1000/0X58.
#Definir diversión máxima 6//Cambio de funciones, indicando los estados más funcionales.
sbit k10=p1^0;
//sbit beep = p3^7; //Línea de accionamiento del zumbador: cambie a sbit beep = P0 4;
p>
uchar bee; //Interruptor del zumbador 01
tecla uchar; //¿Secuencia de teclas?
uchar fun = 10; //Estado de la función,
uchar it0=0, it 1; //Recuento de interrupciones del temporizador 0
uchar text = 0; //Número
//uchar text_ctrl[4]={0xFE, 0xFD, 0xFB, 0xf 7}; //Valor del bit estroboscópico, 11111111165438. 11111011, 11110111
uchar text_ctrl[ 4]={0xE, 0xD, 0xB, 0x 7}; //Valor de bit estroboscópico, 0001110, 00001, 0000101011, 0000065438.
//uchar text_code[11]= {0x 28, 0x7E, 0xA2, 0x62, 0x74, 0x61, 0x21, 0x7A, 0x20, 0x60, 0x ff}; , 4, 5, 6, 7, 8, 9, pantalla apagada, instrumento de tubo digital, alto nivel activo.
//uchar text _ code[17]= { 0x 28, 0x7e, 0xa2, 0x62, 0x74, 0x61, 0x21, 0x7a, 0x20, 0x60, 0x30, 0x25, 0xa9, 0x26, 0xa1, 0xb 1 }; //Código de tubo digital
uchar text _ code[11]= {0x fc, 0x60, 0xDA, 0xF2, 0x66, 0xB6, 0xBE, 0xE0, 0xFE, 0xF6, 0x ff};/ /0, 1, 2, 3, 4, 5, 6, 7, 8, 9, pantalla apagada, instrumento de tubo digital, alto nivel efectivo.
uchar text_index = 0; //¿Cuál se muestra actualmente?
uchar dis_buf[4]; //Mostrar caché
uchar refresco = 0; //Actualizar sin timbre T1
uchar min = 0 ;//minutos
uchar seg = 0; //s conds
uchar horas = 0; //s conds
uchar en configuración = 0;
uchar keydown0=0, keydown 1 = 0;
uchar data PWM = 0xFf//A medida que el valor //PWM aumenta, el ciclo de trabajo disminuye y la luz LED se vuelve más oscura.
/****************************************** ***********/
//Subrutina de retardo
/****************** * ***********************************/
retraso nulo 0(uchar x ) //x * 0,14 ms
{
Uchar I;
mientras(x -)
for(I = 0 ; i<13;i++) {}
}
/****************************** **************************/
//Zumbador T1
/ ** ************************************************* * **/
Anular pitido 1()
{
if(refresh>0)
{
Actualizar++ ;
abeja=! abeja;
if(refresh>=30)
refresh=0;
}
}
/ ********************************************** ** ***/
//Salida de texto
/*************************** *** *******************************/
salida de texto nula()
{
//P0 = 0x ff; //Apague todos los tubos digitales primero.
P2 = dis_buf[text_index]; //Código del número de la persona que llama
bee = bee & lt& lt4;
P0 = text_ctrl [text_index]| //Seleccionar bit
//P0 = bee; //Seleccionar bit
text_index++ //Siguiente.
if(text_index & gt;=4)
text_index = 0;
}
/*** **** *********************************************** /
//Subrutina de escaneo de claves
/****************************** **** *********************/
Escaneo de clave vacía (vacío)
{
temperatura uchar;
tecla =-1; //No presione la tecla
p 1 = 0x0F; //Ingreso de cuatro dígitos inferiores
retraso 0 ( 12);
temp = p 1; //Leer puerto P1
Temperatura = temperatura & amp0x0F
temp = ~(temp | 0xf 0) ;
si(temp==1)
clave = 0;
si no(temp==2)
clave = 1;
si no(temp==4)
clave = 2;
si no(temp==8)
clave = 3;
Otros
clave = 16;
p 1 = 0xf 0; //entrada alta de cuatro dígitos
retraso 0( 12);
temp = p 1; //Leer puerto P1
Temperatura = temperatura & amp0xF0
temp = ~((temp & gt ;& gt4 )| 0xf 0);
si(temp==1)
tecla = tecla+0;
si no(temp==2 )
tecla = tecla+4;
si no(temp==4)
tecla = tecla+8;
si no(temp==4)
tecla = tecla+8;
si no(temp ==8)
clave = clave+12;
Otros
clave = 16;
if (clave! = -1 )
Fun=key;
//key = 0;
//dis_buf = text_code[key];// Encuentra el valor clave de la tabla
}
/************************************ **********************/
//Determina si el botón está presionado.
/****************************************** ***********/
int keydown(no válido)
{
p 1 = 0xf 0;
if(P1!=0xF0)
{
escaneo de teclas();
//retraso 0(250);
Return 1;
//
//beep();
// while (P1!= 0xf 0); //Espera la clave para ser liberado
}
Devuelve 0;
}
/*************** ***** *************************************/
//Establecer caché de visualización
/*************************************** ***** *************/
void settext(uchar text0, uchar text1, uchar text2, uchar text3)
{
dis_buf[0]= texto_código[texto 0];
dis_buf[1]= texto_código[texto 1];
dis_buf[2]= código_texto[texto 2];
dis_buf[3]= código_texto[texto 3];
}
/*** * ************************************************* /
//fun10
//Cronómetro mm: segundos
/****************** **** **********************************/
void fun10()
{
it+;
if(it0 = = 20)//1s
{
it0 = 0;
seg++;
si (segundos == 60)
{
seg = 0;
min++;
if(valor mínimo==60)
{
min = 0;
}
}
Actualizar = 1;
dis_buf[1]= código_texto[min % 10];
dis_buf[0]= código_texto[min /10];
dis_buf[3]= código_texto[seg % 10];
dis_buf[2]= código_texto[seg/ 10];
}
}
/****************************** **** **************************/
//fun11
// Reloj hh:mm
/****************************************** ***************/
void fun11()
{
it+;
si(it0 = = 20)//1s
{
it0 = 0;
seg++;
si (segundos = =60)
<p>{
seg = 0;
min++;
if(valor mínimo==60)
{
min = 0;
hora++;
si(hora==12)
{
hora = 0;
}
//dis _ buf[1]= texto _ código[hora % 10]
//dis _ buf[0]= texto _; código[hora/10];
}
refresh = 1;
} dis_buf[1]= text_code[hora % 10];
dis_buf[0]= texto_código[hora/10];
dis_buf[3]= texto_código[min % 10];
dis_buf [2]= código_texto[min/10];
}
}
/******* ******** **************************************/
// fun12
//Cuenta atrás
/****************************** * ***************************/
void fun12()
{
it+;
if(it0 = = 20)//0.1s
{
it0 = 0;
seg-;//seg debe>=1
si (segundos==0)
{
seg = 60
min -;
//dis_buf[1]= código_texto[min % 10];
//dis_buf[0]= código_texto[ min/10];
if(min==0)
{
min = 60
}
}
Actualizar =1;
dis_buf[1]= código_texto[min % 10];
dis_buf[0] = código_texto[min/10];
dis_buf[ 3]= código_texto[seg % 10];
dis_buf[2]= código_texto [seg/10];
}
}
/************************ ************************* ********/
//fun13
//Establecer hora: horas: minutos
/******** **************************** ********************** /
void fun13()
{
en configuración = 1;
seg = 0; min = 0;
horas = 0;
dis_buf[1]= texto_código[min % 10]; texto_código[min/10];
dis_buf[3]= texto_código[seg % 10];
dis_buf[2]= texto_código[s
ce/10];
}
/****************************** ***** **********************/
//fun3
//Establecer hora: horas: minutos
/*************************************** *** *************/
void fun130()
{
if( keydown1!= keydown0)
{
keydown 0 = keydown 1;
if(keydown1==0) regresa; //botón emergente
if(onsetup==1)
Hora = clave * 10
else if(onsetup==2)
Hora += clave;
else if(onsetup==3)
min = clave * 10;
else if(onsetup==4)
min+= clave ;
en configuración++;
dis_buf[1]= text_code[hora % 10];
dis_buf[0]= text_code[hora/10] <; /p>
dis_buf[3]= texto_código[min % 10];
dis_buf[2]= texto_código[min/10]; p>}
}
/****************************** * ************************/
//fun14
//Configuración
/************************************************ * *****/
void fun14()
{
seg = 0;
min = 0;
Horas = 0;
}
/*************************** * **************************/
//El temporizador 0 interrumpe el programa de servicio de escaneo dinámico del digital tubo.
//Temporizador T0, excitación de 50 ms, salida una vez cada 1 segundo (requiere 20 veces).
/****************************************** ************/
Temporizador no válido 0() interrupción 1
{
//tr 1 = 0;
TH0 = V_TH0//Constante de retardo de 1 milisegundo
TL0 = V_TL0//Ajuste de frecuencia
//th 1 = PWM;
//tr 1 = 1;
keydown 1 = keydown();
//if( keydown1!= keydown0)
{
Si (divertido<=9)
divertido 130();
Otro
Cambiar (divertido)
{
caso 10:diversión 10();descanso;
caso 11:diversión 11();descanso;
caso 12:diversión 12( ) ; romper;
Caso 13: diversión 13(); ruptura
Caso 14: diversión 14(); > p>
}
}
}
/********************* * *********************************/
//Rutina de servicio de interrupción del temporizador 1 para digital El tubo realiza un escaneo dinámico.
//Temporizador T1, estimula una vez cada 5ms y emite una vez cada 5ms.
/****************************************** ***********/
Temporizador no válido 1() interrupción 3
{
//tr 1 = 0;< / p>
//th 1 = PWM;
//Procesar una fila
th 1 = V _ th 1
TL 1 = V _ TL 1;
it 1++;
//if( it1==200)
{
it 1 = 0;
pitido 1();
salida de texto();
}
}
/* ************************************************** * **/
//Inicialización del sistema
//Función: inicializa el sistema, incluida la inicialización del temporizador y la inicialización de variables*/
/**** * ***********************************************/
Inicialización de vacío (void)
{
//Inicialización de variable
bee = 1;
P0 = 0xFF
P2 = 0x ff;
text_index = 0;
dis_buf[0]= text_code[0];
dis_buf [1]= código_texto[0];
dis_buf[2]= código_texto[0];
dis_buf[ 3]= código_texto[0];
//Inicialización del temporizador/
TMOD = TMOD;
TH0 = V _ TH0//Constante de retardo
TL0 = V _ TL0//Constante de retardo
th 1 = PWM; //Ajuste del ancho de pulso
TL 1 = 0;
IE = 0x82
ET0 = 1; //Permitir interrupción del temporizador/contador T0
et 1 = 1; //Permitir interrupción del temporizador/contador T1
TR0 = 1 //Inicia T0
tr 1 = 1; //T1 inicio */
}
/***** ******************* ******************************/
//Programa principal
/ /Se agregó rebote de claves al procesar claves.
/****************************************** ************/
Administrador no válido (no válido)
{
init() //Inicialización del sistema
while(1);
//Ya ni siquiera existe run().
}