Software de control remoto por infrarrojos para portátiles, electrodomésticos y otros electrodomésticos

Actualmente no existe ningún software de control de infrarrojos listo para usar. El alcance efectivo de los infrarrojos es de sólo 40 cm y el puerto de infrarrojos debe estar encendido. Si te resulta práctico, sólo puedes añadir un transmisor de infrarrojos al portátil para aumentar el ángulo y la potencia.

El siguiente es un código de TV de control remoto por infrarrojos C++:

UINT CIrPulse::FindIrPort()

{

//In el registro Consulta el número de puerto IR.

HKEY hKey = NULL

if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,_T("Comm\IrDA"),0,0,& amphKey) == Error_Success )

{

DWORD dwType = 0;

DWORD dw datos = 0;

DWORD dwSize = tamaño de (dw datos). >if (RegQueryValueEx(hKey, _T("Puerto"), NULL y ampdwType, (LPBYTE) & ampdwData & amp;dwSize) == ERROR_SUCCESS)

{

if( dwType == REG _ DWORD & & ampdwSize == sizeof(dwData))

{

RegCloseKey(hKey);

Devuelve datos dw (UINT);

}

}

RegCloseKey(hKey);

}

Devuelve 0;

}

BOOL CIrPulse::Open(UINT uiPort)

{

ASSERT(puerto ui & gt; 0 & amp& ampuiPort & lt= 255 );

cerrar();

//Abrir puerto IRDA

CString strPort

strPort . Formato (_T("COM%d:"), puerto ui);

m _ irPort = crear archivo((LPCTSTR)strPort, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);

if(m _ irPort == INVALID _ HANDLE _ VALUE)

{

Devuelve FALSO

}

//Establece el tamaño de los buffers de entrada y salida.

VERIFY(SetupComm(m_irPort, 2048, 2048));

//Borrar el búfer de lectura y escritura

VERIFY(PurgeComm(m_irPort, PURGE_TXABORT|PURGE_RXABORT) |

PURGE _ tx clear | PURGE _ rx clear));

//Reinicializa todas las configuraciones del puerto IRDA.

DCB dcb

dcb. DCBlength = tamaño de(DCB);

Verify(GetCommState(m_irPort, &dcb));

dcb.

BaudRate = CBR _ 115200;

dcb.fBinary = TRUE

dcb.fParity = TRUE

dcb.fOutxCtsFlow = FALSE

dcb .fOutxDsrFlow = FALSE

dcb .fdtrcontrol = DTR_CONTROL_DISABLE;

dcb.fDsrSensitivity = FALSE

dcb.fTXContinueOnXoff = FALSE

dcb. fOutX = FALSE

dcb.fInX = FALSE

dcb.fErrorChar = FALSE

dcb . f null = FALSE;

dcb. frts CONTROL = RTS_CONTROL_DISABLE;

dcb.fAbortOnError = FALSE

dcb. ByteSize = 8;

dcb. paridad = EVENPARITY

dcb. StopBits = TWOSTOPBITS

Verify(SetCommState(m_irPort, & ampdcb));

//Establece el valor de tiempo de espera para todas las operaciones de lectura y escritura.

Tiempo de espera de COMMTIMEOUTS;

VERIFY(GetCommTimeouts(m_irPort, & amp timeout));

Pausa. ReadIntervalTimeout = MAXDWORD

Pausa. ReadTotalTimeoutMultiplier = 0;

Pausa. ReadTotalTimeoutConstant = 0;

Pausa. WriteTotalTimeoutMultiplier = 0;

Pausa. WriteTotalTimeoutConstant = 0;

VERIFY(SetCommTimeouts(m_irPort, & timeout));

DWORD dwEvent = EV_TXEMPTY

SetCommMask(m_irPort, dw event);

Devolver VERDADERO

}

BOOL cir pulse::enviar código(DWORD lValue)

{

DWORD dwCount

int I = 0;

ASSERT(iDataLength & gt; 0);

//Borrar el buffer de transmisión

VERIFY( PurgeComm(m_irPort, PURGE _ tx abort | PURGE _ rx abort | PURGE _ tx clear | PURGE _ rx clear));

//Establece 6 códigos para cada pulsación de tecla.

for(int x = 0; x & lt6;x++) {

MakeStream(lvalue); //Enviar código

dw count = GetTickCount( ) ;

while(GetTickCount()& lt; DwCount+26) //Retraso 26 milisegundos

i++;

}

Regresar true

} BOOL cir pulse::MakeStream(DWORD lValue){

DWORD dwStreamLength

//Crear un pulso inicial

dwStreamLength = ih pulso/ancho de caracteres;

ASSERT(Write((const char *)b pulse stream.GetData(),

dwStreamLength)= = dwStreamLength);

//************************************

/ /* * * *Retraso por un período de tiempo antes de que llegue el siguiente pulso.

//************************************

//Recorre los bits en el código de manipulación para enviar pulsos.

for(int I = 0; i<iDataLengthi++) {

if(lvalue&1) {

//Crear un pulso 1.

dwStreamLength = I 1 pulso/ancho de carácter;

ASSERT(Write((const char *)b flujo de pulsos.GetData(),

dwStreamLength)= = dwStreamLength);

// *********************************

//* * * Retraso por un período de tiempo antes de que llegue el siguiente pulso.

// **********************************

}

De lo contrario {

//Crear pulso 0

dwStreamLength = i0 pulso/ancho de carácter;

ASSERT(Write((const char *)b flujo de pulsos GetData(),

dwStreamLength)= = dwStreamLength);

// ****************** ***************

//* * Retraso de un tiempo antes de que llegue el siguiente pulso.

// **********************************

}

lValor & gt& gt= 1;

}

Devuelve VERDADERO

}

Referencia:

p>

/ncre 2/CPP/fu Dao/20080418/101230278 html

.