Programación en C del módulo receptor de infrarrojos basado en 51 microcontroladores
#includelt; reg52.hgt; //El archivo de encabezado que contiene los registros del microcontrolador
#includelt;intrins.hgt; //El archivo de encabezado que contiene la definición de la función _nop_()
p>
sbit IR=P3^2; //Definir el bit IR como el pin P3.2
sbit RS=P2^0; defina el bit RS como pin P2 .0
sbit RW=P2^1 //Lea y escriba el bit de selección, defina el bit RW como pin P2.1
sbit E=P2; ^2; //Habilitar bit de señal, definir bit E como pin P2.2
sbit BF=P0^7; //Bit de indicador de ocupado, definir bit BF como pin P0.7
sbit BEEP = P3^6; //Puerto de control del zumbador P36
indicador de caracteres sin firmar;
cadena de código de caracteres sin firmar[ ]= {"1602IR-CODE TEST "}; /p>
unsigned char a[4]; //Almacena el código de usuario, el código inverso de usuario y el código de datos clave, el código inverso de datos clave
unsigned int LowTime, HighTime // Almacena el ancho de niveles altos y bajos
/************************************ **** ***************
Función: retardo 1ms
**************** * ***************************************/
retraso anulado 1 ms ( )
{
char sin firmar i, j
for(i=0; ilt; 10; i )
for ( j=0;jlt;33;j)
;
}
/************** ** ************************************
Función: Retardo Número de milisegundos
Parámetro de entrada: n
****************************** * ********************/
retraso nulo (carácter n sin firmar)
{
carácter sin firmar i
for(i=0; ilt; n; i )
delay1ms();
}
/ ********************************************** ** ******/
void beep() //Función de pitido del zumbador
{
unsigned char i;
para (i=0; ilt; 100; i )
{
delay1ms();
BEEP=!BEEP; //BEEP Negar
}
BEEP=1; //Cerrar abeja
Beeper
demora(250); //Retraso
}
/****************** ***********************************
Función: Determinar el módulo LCD Estado de ocupado
Valor de retorno: resultado.
resultado=1, ocupado; resultado=0, no ocupado
******************************* ***** *************************/
carácter sin firmar BusyTest(void)
{
resultado del bit;
RS=0; //Según las regulaciones, cuando RS es de nivel bajo y RW es de nivel alto, se puede leer el estado
RW=1;
E=1; //E=1, se permite lectura y escritura
_nop_() //Sin operación
_nop_ ();
_nop_( );
_nop_(); //Cuatro ciclos de máquina sin operación para dar el tiempo de reacción del hardware
result=BF ; //Asigna el nivel de indicador de ocupado al resultado
E=0
return result
}
/***; ************* *************************************
Función: Establecer el modo Escribe el comando o dirección de visualización en el módulo LCD
Parámetro de entrada: dictar
********** ************** ****************************/
nulo WriteInstruction (dictado de carácter sin firmar)
{
while(BusyTest()==1); //Espera si está ocupado
RS=0; según las regulaciones, cuando RS y R/W tienen un nivel bajo al mismo tiempo, se pueden escribir instrucciones
RW=0
E=0 //E se establece en bajo; nivel (de acuerdo con la Tabla 8-6, al escribir instrucciones, E es un pulso alto,
// Esto es para hacer que E haga una transición positiva de 0 a 1, por lo que se debe establecer "0" primero
_nop_();
_nop_(); / /Sin operación durante dos ciclos de la máquina para dar el tiempo de reacción del hardware
P0=dictar; datos al puerto P0, es decir, escribir instrucciones o direcciones
_nop_();
_nop_()
_nop_();
_nop_(); //No hay operación durante cuatro ciclos de la máquina para dar tiempo de reacción al hardware
E=1; //E está configurado en nivel alto
_nop_(); ;
_nop_();
_nop_();
_nop_(); //Cuatro ciclos de máquina sin operación para dar tiempo de respuesta al hardware
E=0; //Cuando E salta del nivel alto al nivel bajo, el módulo de cristal líquido comienza a ejecutar Comando
}
/***** ******************************* ******************* *
Función: Especificar la visualización de caracteres
Dirección real
Parámetro de entrada: x
****************************** **** ************************/
dirección de escritura nula (carácter x sin firmar)
{
WriteInstruction(x|0x80); //El método para determinar la posición de visualización es "código de dirección 80H x"
}
/*** ********* ******************************************* **
Función: escribir datos (código de caracteres ASCII estándar) en el módulo LCD
Parámetro de entrada: y (constante de carácter)
**** ************ **************************************** ****/
void WriteData (carácter sin firmar y)
{
while(BusyTest()==1
RW=0;
E=0; a nivel bajo (de acuerdo con la Tabla 8-6, al escribir instrucciones, E es un pulso alto,
//Es para hacer que E haga una transición positiva de 0 a 1, por lo que "0" debería configurarse primero
P0=y //Enviar datos al puerto P0, es decir, escribir datos en el módulo LCD
_nop_()
_nop_; ();
_nop_();
_nop_( ); //Cuatro ciclos de máquina sin operación, lo que da tiempo de reacción del hardware
E=1; //E está configurado en nivel alto
_nop_();
_nop_();
_nop_();
_nop_( ); //Cuatro ciclos de máquina sin operación para darle tiempo de reacción al hardware
E=0 ; //Cuando E salta del nivel alto al nivel bajo, el módulo LCD comienza a ejecutar comandos
}
/****************** ********************** ********************
Funciones funcionales: Inicializar el modo de visualización LCD
******** ******************************** ****************/
void LcdInitiate(void)
{
delay(15); / /Retraso 15 ms, se debe dar a la pantalla LCD un tiempo de respuesta más largo al escribir instrucciones para el primera vez
WriteInstruction(0x38); //Configuración del modo de visualización: pantalla de 16 × 2, matriz de puntos de 5 × 7, interfaz de datos de 8 bits
retraso (5); Retraso 5 ms
WriteInstruction(0x38);
retraso(5);
WriteInstruction (0x38);
retraso(5);
Escribir
struction(0x0C); //Configuración del modo de visualización: visualización encendida, cursor, parpadeando
delay(5);
WriteInstruction(0x06); //Configuración del modo de visualización: cursor hacia la derecha , los caracteres no se moverán
delay(5);
WriteInstruction(0x01); //Comando borrar pantalla, borra el contenido de la pantalla anterior
delay (5); );
}
/***************************** ** **************************
Función: código de usuario de 4 bytes y clave Decodifica el código de datos
Nota: Si la decodificación es correcta, se devolverá 1; de lo contrario, se devolverá 0
Parámetro de exportación: dat
********** ************************************************** * */
bit DeCode(void)
{
unsigned char i, j
unsigned char temp; decodificar datos de salida
for(i=0;ilt;4;i) //Leer continuamente 4 códigos de usuario y códigos de datos clave
{
for( j=0;jlt;8;j) //Cada código tiene 8 dígitos
{
temp=tempgt;gt;1; //Cada código en temp Los bits de datos son se desplazó un bit hacia la derecha, porque los datos de bits altos se leen primero
TH0=0; //El temporizador se pone a 0
TL0=0; borrado a 0
TR0=1; //Activar el temporizador T0
while(IR==0) //Si está bajo, esperar
; //Tiempo de nivel bajo
TR0=0; //Cerrar temporizador T0
LowTime=TH0*256 TL0 //Guardar ancho de nivel bajo
TH0= 0; // Borrar el temporizador a 0
TL0=0; // Borrar el temporizador a 0
TR0=1 // Activar el temporizador T0
while (IR==1) //Si es nivel alto, espera
;
TR0=0; //Cerrar temporizador T0
HighTime =TH0 *256 TL0; //Guarda el ancho del nivel alto
if((LowTimelt;370)||(LowTimegt;640))
return 0; longitud del nivel Si no está dentro de un rango razonable, se considera un error y se detiene la decodificación
if((HighTimegt; 420)amp; amp; (HighTimelt; 620)) //Si es alto. El tiempo de nivel es de aproximadamente 560 microsegundos, cuenta 560/
1.085＝516 veces
temp=tempamp;0x7f; //(520-100=420, 520 100=620), entonces este bit es 0
if((HighTimegt;1300 )amp;amp;(HighTimelt;1800)) //Si el tiempo de nivel alto es de alrededor de 1680 microsegundos, es decir, contando 1680/1.085=1548 veces
temp=temp|0x80; - 250=1300, 1550 250=1800), entonces el bit es 1
}
a[i]=temp; //Almacena el valor del byte decodificado en a[i]
}
if(a[2]=~a[3]) //Verifica si el código de datos clave y su código inverso son iguales. Generalmente, no es necesario. verificar el código de usuario
return 1; //Decodificado correctamente, devolver 1
}
/*----------- ----- --Convierte código binario a código BCD comprimido y muestra---------------*/
void two_2_bcd(fecha de carácter sin firmar)
{
temperatura de carácter sin firmar;
temp=date;
dateamp;=0xf0;
dategt;gt; =4; //Desplaza cuatro bits hacia la derecha para obtener los cuatro bits superiores del código
dateamp =0x0f; //Asegúrate de que los cuatro bits superiores sean 0 con 0x0f
{
WriteData(0x30 date); //la pantalla LCD muestra los cuatro dígitos superiores del valor clave
}
else
{
fecha=fecha-0x09
WriteData(0x40 fecha
}
fecha=temp;
p>fechaamp;=0x0f;
if(datelt;=0x09)
{
WriteData(0x30 fecha); //la pantalla LCD muestra un valor bajo de cuatro dígitos
}
else
{
fecha =fecha-0x09;
WriteData(0x40 fecha);
}
WriteData(0x48); //Mostrar carácter 'H'
}
/**** ************************************* *************** ******
Función: Pantalla 1602LCD
********** ***********
*******************************************/
void Disp(void)
{
WriteAddress(0x40); //Establece la posición de visualización en la primera palabra de la primera línea
two_2_bcd(a). [0 ]);
WriteData(0x20);
two_2_bcd(a[1]); > two_2_bcd (a[2]);
WriteData(0x20);
two_2_bcd(a[3]);
}
/ ************************************************ *** **********
Función función: función principal
****************** ****** *******************************************/
void main ()
{
unsigned char i;
LcdInitiate() //Llamar a la función de inicialización de LCD
delay(10);
WriteInstruction(0x01); //Borrar pantalla: borrar instrucción de pantalla
WriteAddress(0x00); palabra de la primera línea
i = 0;
while(string[i] != '\0') //'\0' es el final del array
{ //Muestra el carácter www .RICHMCU.COM
WriteData(string[i]);
i
}
EA=1; //Abrir interrupción total
EX0=1; //Habilitar interrupción externa 0
ET0=1 //Interrupción del temporizador T0 habilitada
IT0=1; //Interrupción externa activada por el flanco descendente de la interrupción
TMOD=0x01; //Usa el modo 1 del temporizador T0
TR0=0 ; //El temporizador T0 se apaga
mientras (1); //Esperando la interrupción generada por la señal infrarroja
}
/*** ******************* ******************************* *****
Función: Disparador por infrarrojos Controlador de interrupciones externo
************************ ******************* *************************/
nulo Int0(void) interrupción 0
{
EX0=0; // Desactiva la interrupción externa 0, ya no recibe interrupciones de señales infrarrojas secundarias y solo decodifica la señal infrarroja actual
TH0=0; //Borrar los 8 bits altos del temporizador T0 0
TL0=0;
/Borrar los 8 bits inferiores del temporizador T0 a 0
TR0=1; //Activar el temporizador T0
while(IR==0); , Espere y cronometre el nivel bajo del código de arranque
TR0=0; //Cerrar el temporizador T0
LowTime=TH0*256 TL0 //Guarde el tiempo de nivel bajo
p >
TH0=0; //Borrar los 8 bits altos del temporizador T0 a 0
TL0=0; //Borrar los 8 bits bajos del temporizador T0 a 0
TR0= 1; //Activar el temporizador T0
while(IR==1); //Si es de nivel alto, esperar y cronometrar el código de arranque de nivel alto
TR0. =0 ; //Cerrar el temporizador T0
HighTime=TH0*256 TL0; //Guardar la longitud de alto nivel del código de arranque
if((LowTimegt;7800)amp; amp;( LowTimelt;8800)amp;amp;(HighTimegt;3600)amp;amp;(HighTimelt;4700))
{
//Si es un código de arranque, comience a decodificar; de lo contrario, abandone, sincronización de bajo nivel del código de arranque
//Número de veces=9000us/1.085=8294, intervalo de evaluación: 8300-500=7800, 830500=8800.
if(DeCode( )==1) //Ejecutar la función de decodificación del control remoto
{
Disp() //Llamar a la función de visualización 1602LCD
beep(); //Bip El timbre suena una vez para indicar que la decodificación se realizó correctamente
}
}
EX0=1; EX0
}