Buscamos urgentemente un programa c para emisión y decodificación de infrarrojos
(1) Programa de envío
#include lt; reg52.hgt;
bit estático OP; //Encendido y apagado del tubo de emisión de infrarrojos
recuento estático de int unsigned; //Contador de retrasos
recuento estático de int unsigned; //recuento de retrasos de terminación
static unsigned int temp //Presionación de teclas
bandera de char estática sin firmar; //bandera de transmisión por infrarrojos
char num estática sin firmar
sbit ir_in=P3^4;
char iraddr1; /El primer byte de la dirección de dieciséis bits
char iraddr2; //El segundo byte de la dirección de dieciséis bits
tabla de códigos de caracteres sin firmar[]={0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xf8, 2009-8-11lt;brgt;4lt;brgt;Transmisión de datos por infrarrojoslt;brgt;0x80, 0x90, 0x88, 0x83, 0xc6, 0xa1, 0x86, 0x8e } //* ** Tubo digital Yang 0~~f
void SendIRdata(char p_irdata);
retraso vacío(unsigned int
void keycan(); /p>
/******************Función principal****************** ***** ***/
void main(void)
{
num=0
P2=0x3f
;cuenta = 0;
bandera = 0;
OP = 0;
ir_in= 0; ; //Permitir interrupción de CPU
TMOD = 0x11; //Establecer los temporizadores 0 y 1 en el modo 1 de 16 bits
ET0 = 1 //La interrupción del dispositivo de sincronización 0 está habilitada
TH0 = 0xFF;
TL0 = 0xE6; //Establece el valor de tiempo de 0 a 38K, lo que significa interrumpir cada 26us
TR0 = 1; contando
iraddr1=3; //00000011
iraddr2=252; //11111100
do{keyscan(); );
}
/************************Temporizador 0 Manejo de interrupciones**** ******************/
tiempo nulo (nulo) interrupción 1
{
TH0= 0xFF;
TL0=0xE6; //Establece el valor de tiempo en 38K, lo que significa interrumpir cada 26us
contador.
t;
si (bandera==1)
{
OP=~OP
}
{
OP = 0
}
ir_in=
}
ir_in=
}
{
OP = 0 p>
void SendIRdata(char p_irdata)
{ 2009-8-11
5
Transmisión de datos por infrarrojos
int i;
char irdata=p_irdata;
//Enviar código de inicio de 9 ms
endcount=223
flag=1; /p>
count=0;
hacer{}mientras(countlt; endcount
/***************; *** *********Enviar código de resultado de 4,5 ms**********************/
endcount=117 ;
flag=0;
cuenta=0;
hacer{}mientras(countlt;endcount); * *******************Enviar los primeros ocho dígitos de la dirección de dieciséis dígitos********************* ***/
irdata=iraddr1
for(i=0;ilt;8;i)
{
/ *****Envía 0,56 primeros ms de onda infrarroja de 38 KHZ (es decir, 0,56 ms de nivel bajo en codificación) *****/
endcount=10
flag=1;
count=0;
do{} while(countlt;endcount
/************Detener envío); señales infrarrojas (es decir, en codificación de alto nivel) *************/
if(irdata-(irdata/2)*2) //Determinar si el número binario el dígito es 1 o 0
{
endcount=41 //1 es un nivel alto y amplio
}
else
{
endcount=15; //0 es un nivel alto estrecho
}
flag=0; >cuenta=0;
hacer{}mientras(countlt;endcount);
irdata=irdatagt;gt;1; p>/** **********************Enviar los últimos ocho dígitos de la dirección de dieciséis dígitos************ ******/
irdata=iraddr2
for(i=0;ilt;8;i)
{
endcount=10;
flag=1;
count=0;
hacer{}mientras(countlt;endcount); p>if(irdata-(irdata/ 2)*2)
{
endcount=41;
}
else
{ 2009-8-11
6
Transmisión de datos por infrarrojos
endcount=15;
}
flag=0
count=0;
hacer{}mientras(countlt;endcount);
irdata=irdatagt;gt;1;
}
/** ****************Enviar ocho bits de datos****************************** * **/
irdata=p_irdata
for(i=0;ilt;8;i)
{
endcount; = 10;
flag=1;
cuenta=0;
hacer{}mientras(countlt;endcount); ( irdata-(irdata/2)*2)
{
endcount=41
}
else
;{
endcount=15
}
bandera=0; p >hacer{}mientras(countlt;endcount);
irdata=irdatagt;gt;1
}
/******* * ****************Enviar código inverso de datos de ocho bits************************/
irdata=~p_irdata;
for(i=0;ilt;8;i)
{
endcount=10; p>
flag=1;
count=0;
do{} while(countlt;endcount);
if(irdata-(irdata); /2) *2)
{
endcount=41
}
else
{
endcount=15;
}
flag=0
count=0; while(countlt ;endcount);
irdata=irdatagt;gt;1;
}
2009-8-11
7
Transmisión de datos por infrarrojos
endcount=10;
flag=1
count=0; hacer{} while(countlt; endcount);
flag=0;
}
retraso nulo (unsi).
gned int z)
{
unsigned char x, y
for(x=z; xgt; 0; x--)
for(y=110;ygt;0;y--);
}
/**************** ** *****El escaneo de teclado 4×4 emite datos cuando se presiona una tecla************************/
escaneo de teclas nulas( )
{
P1=0xfe
temp=P1
temp=tempamp; p>
mientras(temp!=0xf0)
{
temp=P1
cambiar(temp)
{
caso 0xee: num=1
romper;
caso 0xde: num=2
romper;
caso 0xbe: num=3
ruptura
caso 0x7e: num=4;
mientras(temp!=0xf0)
{
temp=P1
temp=tempamp;0xf0;
}
P2=tabla[núm-1]
SendIRdata(tabla[núm-1]); p>P1= 0xfd;
temp=P1;
temp=0xf0
mientras(temp!=0xf0)
p>
temp=P1
interruptor(temp)
{
caso 0xed: num=5 ;
ruptura ;
caso 0xdd: num=6
ruptura
caso 0xbd: num=7; >
break;
caso 0x7d: num=8; 2009-8-11
8
Transmisión de datos por infrarrojos
romper;
}
mientras(temp!=0xf0)
{
temp=P1; temp=tempamp; 0xf0;
}
P2=tabla[núm-1];
SendIRdata(tabla[núm-1]); >
}
P1=0xfb;
temp=P1;
temp=0xf0
mientras(temp; !=0xf0)
{
temp=P1
cambiar(temp)
{
caso; 0xeb: num=9
descanso
caso 0x;
db: num=10;
caso
0xbb: num=11;
caso 0x7b; 12;
romper;
}
mientras(temp!=0xf0)
{
temp= P1;
temp=tempamp;0xf0;
}
P2=tabla[num-1]
Enviardatos(tabla[ num-1]);
}
P1=0xf7
temp=P1
temp=0xf0; /p>
mientras(temp!=0xf0)
{
temp=P1
cambiar(temp)
{
caso 0xe7: num=13
ruptura;
caso 0xd7: num=14; >
caso 0xb7: num=15
ruptura
caso 0x77: num=16; }
mientras(temp!=0xf0)
{
temp=P1
temp=0xf0; >
} 2009-8-11
9
Transmisión de datos por infrarrojos
P2=table[num-1]
}
}
(2) Programa receptor
#include"reg52 .h"
#define uchar unsigned char
#define uint unsigned int
uchar dis_num, num, num1, num2, num3;
sbit led=P1^0;
tabla de códigos de caracteres sin firmar[]={
0xc0, 0xf9, 0xa4, 0xb0,
0x99, 0x92, 0x82, 0xf8,
0x80, 0x90, 0x88, 0x83,
0xc6, 0xa1, 0x86, 0x8e}; //*** Tubo digital Yang 0~~f
sbit prem =P3^2; //Definir el pin receptor del cabezal de control remoto
uchar ram[4]={0, 0, 0, 0} //Almacenar el 4; recibido Código de dirección de datos Código de clave de 16 bits Código de clave de 8 bits 8 bits invertidos
tiempo de retardo nulo (tiempo uint) //Retraso 90uS
{
uchar a , b;
for(a=tiempo; agt; 0; a--)
{
for(b=40;bgt;0;b--
}
}
void rem(); interrumpir 0 //Función de interrupción
{
uchar ramc=0; //Definir una variable que recibe 4 bytes
uchar count=0; qué variable recibir ahora
uint i=0; //La variable aquí se usa para monitorear continuamente si hay un nivel alto dentro de 9MS.
prem=1; >
for(i=0;ilt;1100;i) //El tiempo de ejecución de la siguiente declaración FOR es de aproximadamente 8 MS
{
if(prem) // Para ingresar al programa de recepción de control remoto, primero ingrese la primera mitad del código de inicio para juzgar, es decir: si hay un nivel bajo de aproximadamente 9MS
return //Salga si el código de inicio es incorrecto;
}
while(prem!=1); //Espera la llegada del inicio de alto nivel de 4.5 MS en la segunda mitad del código de arranque.
delaytime(50); //El retraso es superior a 4,5 MS, cruza la segunda mitad del código de arranque y llega a los datos de control remoto reales de 32 bits
// La primera posición 0,56 MS inicia el pulso de datos
for(ramc=0;ramclt;4;ramc)//Recorre 4 veces para recibir 4 bytes
{ for(count=0 ;countlt ; 8; count ) // Realiza un bucle 8 veces para recibir 8 bits (un byte)
{
while(prem!=1); los datos recibidos son 0 o 1, primero en esta línea de esta oración,
//Asegúrese de que los datos hayan ingresado a la etapa de nivel bajo de 0.56MS
//Esperando el nivel alto de los datos recibidos este nivel de tiempo está llegando.
delaytime(9); //Después de que llega el nivel alto, el nivel alto de datos 0 dura hasta 0,56 MS, mientras que el nivel alto de datos 1 puede durar hasta el 2009-8-11
10
Transmisión de datos por infrarrojos
// Después de que 1,66 MS sea mayor que 0,8 MS, podemos juzgar el nivel del pin receptor del control remoto,
if(prem) / /Si el nivel alto aún continúa en este momento, los datos recibidos se codifican como 1
{
ram[ramc]=(ram [ramc]lt;lt;1) 1; //Coloque el bit 1 de datos recibidos actualmente en el byte correspondiente
delaytime(11); //Si los datos recibidos esta vez son 1, continúe con retrasa 1MS, por lo que solo entonces podemos ingresar el nivel bajo del siguiente código de bits (es decir, los primeros 0.56MS)
//// De lo contrario, lo que se recibe actualmente es la codificación de datos 0
ram[ramc]=ram[ramc]lt;lt;1; //Coloca el bit 0 de datos recibido actualmente en el byte correspondiente
} //Esta recepción finaliza y el Se recibe el siguiente bit. Esta acción de recepción se realiza 32 veces, completando exactamente la recepción de 4 bytes
}
if( ram[2]!=(~(ram[3]). amp; 0x7f))) //Sentencia de este código de recepción
{
for(i=0; ilt; 4; i) //Si no existe tal correspondencia, el la recepción falla y los datos recibidos se borran
ram[i]=0
return
}
dis_num=ram[; 2]; //Asignar los datos clave recibidos a la variable de visualización
}
main()
{
IT0=1 ; //Establece INT0 como disparador de flanco
EX0=1; //Activa la interrupción externa 0
EA=1 //El interruptor de interrupción global está activado
<; p> while(1){
switch(dis_num)
{
caso 0x81: num=0; /p>
caso 0xcf: num=1; descanso
caso 0x92: num=2;
caso 0x86: num=3; >
caso 0xcc: num=4;
caso 0xa4: num=5;
caso 0xa0: num=6; p> caso 0x8f: num=7; descanso
caso 0x80: nu
m=8;
caso 0x84: num=9;
caso 0x88: num=10; 11; romper;
caso 0xb1: num=12;
caso 0xc2: num=13; romper;
caso 0xb8: num=15;
}
P2=tabla[num]; ;
tiempo de retardo(5);
}
}