Problema de programación de microcomputadoras de un solo chip (lenguaje C), pregunta muy introductoria, competencia mañana, ¡urgente! Cualquier cantidad de puntos está bien.
Se han ajustado los siguientes programas y el circuito de visualización de botones es visible:
/%D7%F6%B6%F8%C2%DB%B5%C0/blog/item /ef086222268d4f4eac34de59.html
//MCU: utilice el compatible con la serie 51;
//teclado matricial 4×4: conectado al puerto P1;
//Pantalla digital de dos dígitos: el puerto P0 emite un código de siete segmentos, el puerto P2 emite un código de selección de bits.
/=========================================
//El programa en lenguaje C es el siguiente.
/****************************************** *******************
* Nombre de archivo: KEY_LED.c
* Función: Realizar salida de teclado matricial 4×4 , los dos últimos dígitos del tubo digital muestran el valor clave.
********************************************* *** *******************/
#include
#include
#define uint unsigned int
#define uchar unsigned char
tabla de códigos uchar[10] = {0xC0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xf8, 0x80, 0x90};
uchar seg, t_50ms;
/****************** ******* *******************************************
* Nombre: Delay_1ms()
* Función: subrutina de retraso, el tiempo de retraso es 1 ms * x
* Entrada: x (número de retrasos por un milisegundo)
* Salida: Ninguna
******************************** ********** *******************************/
retraso anulado_1ms (uint x)
{
uint i;
uchar j
for(i = 0; i < x; i++ ) para(j = 0; j <= 148; j++)
}
/***************** ******************* *******************************
* Nombre: Display(uchar k)
* Función: Divide los parámetros en decenas y unidades y los muestra respectivamente
* Entrada: k (valor del teclado)
* Salida: el puerto P0 emite código de siete segmentos, el puerto P2 emite bits Selección de código
********************* *********************** *************************/
void Display(uchar k)
{
P2 = 0; //Blanqueamiento
P0 = tabla[k / 10]; /p>
P2 = 0x02; Delay_1ms(5); //Mostrar dígitos de decenas de 5 ms
P2 = 0; //Blanqueamiento
P0 = tabla[k % 10] ;
P2 = 0x01; Delay_1ms(5); //Mostrar dígitos de unidades de 5 ms
}
/********** *********************** **************************** *
* Nombre: Keyscan()
* Función: P1 está conectado a un botón externo 4×4 y el valor de la clave se lee de acuerdo con el método de escaneo
* Salida: Valor clave 0~15/si no se presiona ninguna tecla, devuelve 16
**** ****************** ******************************** *********/
<p>uchar Keyscan(void)
{
uchar i, j, temp, Buffer[4] = {0xef, 0xdf, 0xbf, 0x7f}; > for(j = 0; j < 4; j++) { //Repetir cuatro veces
P1 = Buffer[j] //Emitir un nivel bajo en los cuatro bits altos de P1
temp = 0x01; //Planifica juzgar el bit P1.0 primero
for(i = 0; i < 4; i++) { //Repetir cuatro veces
if ( !(P1 & temp)) //Trunca 1 bit de los cuatro bits inferiores de P1
return (i + j * 4 //Devuelve el valor clave obtenido
); temp < <= 1; // El bit juzgado se desplaza un bit hacia la izquierda
} }
return 16 // El final juzgado, no se presiona ninguna tecla, regresa a 16
} // Jaja, la declaración sustantiva tiene solo 8 líneas, ¡es muy concisa!
/****************************************** ************************
* Nombre: GetKey()
* Función: Leer claves , elimina la inquietud, esperando la liberación de la tecla
* Salida: valor de la clave 0~15/Si no se presiona ninguna tecla, devuelve 16
********** ******* ******************************************* ****/
uchar GetKey(void)
{
uchar Key_Temp1, Key_Temp2 //Valores clave leídos dos veces
<; p> P1 = 0xff;Key_Temp1 = Keyscan(); //Lee las claves primero
if(Key_Temp1 == 16) return 16; return 16
Display(sec); //Usar visualización en lugar de retraso
Key_Temp2 = Keyscan() //Leer la clave nuevamente
if(Key_Temp1 != Key_Temp2) return 16; //Diferente, devuelve 16
while(Keyscan() < 16) //Espera a que se suelte la tecla
Display(sec); esperando
return Key_Temp1;
}
/************************ *********** *******************************
* Nombre: Main()
* Función: Función principal
****************************** ************** *******************************/
void Principal(void)
{
uchar
Key_Value; //Leer valor clave
seg = 0;
TMOD = 0x01;
TH1 = (65536-50000)/256;
TL1 = (65536-50000)%256;
TR0 = 1;
ET0 = 1;
EA = 1;
p>while(1) {
Mostrar(seg); //Mostrar
if (GetKey() == 10) {
TR0 = 0;
while (TR0 == 0) {
Mostrar(seg); //Mostrar
Key_Value = GetKey();
if (Key_Value < 10) {
seg %= 10;
seg = seg * 10 + Key_Value;
}
if (Key_Value == 10) TR0 = 1;
} } }
}
/*********** * ************************************************* ** *
* Nombre: T0_INT()
* Función: Función de interrupción T0
************** ** *************************************************/
void T0_INT() interrupción 1
{
TH1 = (65536-50000)/256;
TL1 = (65536- 50000) %256;
t_50ms++;
if(t_50ms >= 20) {
t_50ms = 0;
seg++;
seg %= 60;
}
}
/*************** ******* ******************************************* **/