Olá foristas!
Estou extendendo um projeto de TCC com a biblioteca IRremote, que envolve receber e armazenar comandos IR e posteriormente emitir estes comandos.
O circuito e o código fonte eu já tenho (fiz algumas adaptações para simplificar o código). A questão é que não estou conseguindo armazenar os códigos IR. Fazendo o debug no código, notei que no IF da linha 69 (irReceptor.decode(&resultadoIR)) o resultado sempre é FALSE.
Criei algumas rotinas pra testar o RX de IR, que está funcionando certinho. Não sei se devo fazer mais algum teste…
Alguém já passou por algo parecido? Não tenho muita experiência com essa biblioteca (e nem muita experiência com Arduino pra ser sincero…)
Obrigado!
#include "IRremote.h"
#include "EEPROM.h"
int ESPACO_RESERVADO_EEPROM = 500; //Espaço que cada comando ocupará
int COMANDO_1 = 0; //Posição da memória em que ficará salvo
long CODE_EEPROM = 112358; //Se esse número estiver na primeira posição, então tem algo salvo lá
//Deve ser conectado um LED IR no pino 9 para MEGA2560
char PIN_BOTAO_1 = 51; //Botão que envia ou grava o sinal 1
char PIN_IR_RECEPTOR = 5; //Pino que irá ouvir os sinais IR
char PIN_BOTAO_APRENDER = 3; //Se pressionado, indica que o dispositivo está no modo aprendizagem
char PIN_IR_STATUS = 7; //Pino para um LED exibir um status
IRrecv irReceptor(PIN_IR_RECEPTOR);
IRsend irEmissor;
decode_results resultadoIR;
int ultimoBotao1Estado;
int ultimoBotaoAprenderEstado;
struct Comando {
int id;
int codeType = -1; // O tipo do código
unsigned long codeValue; // O código quando não utilizado o códido bruto
unsigned int rawCodes[RAWBUF]; // As durações do código quando for bruto
int codeLen; // O tamanho do código
char toggle = 0; // The RC5/6 toggle state
} comando;
void setup() {
Serial.begin(9600);
pinMode(PIN_BOTAO_1, INPUT);
pinMode(PIN_BOTAO_APRENDER, INPUT);
pinMode(PIN_IR_STATUS, OUTPUT);
pinMode(LED_BUILTIN, OUTPUT);
Serial.println("SISTEMA INICIADO");
}
void loop() {
int botao1Estado = digitalRead(PIN_BOTAO_1);
int botaoAprenderEstado = digitalRead(PIN_BOTAO_APRENDER);
// if (!digitalRead(5)) {
// digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level)
// digitalWrite(PIN_IR_STATUS, HIGH);
// delay(200); // wait for a second
// digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW
// digitalWrite(PIN_IR_STATUS, LOW);
// delay(200);
// }
if(botaoAprenderEstado == LOW){ //EMITIR COMANDO
if (ultimoBotaoAprenderEstado == HIGH) {
Serial.println("Busca por sinal IR finalizada");
}
if (ultimoBotao1Estado == LOW && botao1Estado == HIGH) {
Serial.println("Botao 1 foi pressionado");
validarEnviarComando(COMANDO_1);
}
} else { //APRENDER COMANDO
if (ultimoBotaoAprenderEstado == LOW) {
Serial.println("Aguardando sinal IR");
irReceptor.enableIRIn(); // Ativa o receptor IR
}
if (irReceptor.decode(&resultadoIR)) {
//PISCA O LED SE ENTRAR AQUI!
if(botao1Estado == HIGH){
digitalWrite(PIN_IR_STATUS, HIGH);
delay(500);
digitalWrite(PIN_IR_STATUS, LOW);
criarComando(&resultadoIR, COMANDO_1, &comando);
}
irReceptor.resume(); // reinicia receptor
}
}
ultimoBotao1Estado = botao1Estado;
ultimoBotaoAprenderEstado = botaoAprenderEstado;
}
//Convert *resultadoIR em um comando
void criarComando(decode_results *resultadoIR, int comandoId, Comando * comando) {
digitalWrite(PIN_IR_STATUS, HIGH);
Serial.print("Salvando o comando ");
Serial.println(comandoId);
comando->id = comandoId;
comando->codeType = resultadoIR->decode_type;
int count = resultadoIR->rawlen;
int isRawCode = 0;
if (comando->codeType == UNKNOWN) {
Serial.println("Received unknown code, saving as raw");
isRawCode = 1;
} else if (comando->codeType == NEC) {
Serial.print("Received NEC: ");
if (resultadoIR->value == REPEAT) {
// Don't record a NEC repeat value as that's useless.
Serial.println("repeat; ignoring.");
digitalWrite(PIN_IR_STATUS, LOW);
return;
}
Serial.println(resultadoIR->value, HEX);
} else if (comando->codeType == SONY) {
Serial.print("Received SONY: ");
} else if (comando->codeType == PANASONIC) {
Serial.print("Received PANASONIC: ");
} else if (comando->codeType == JVC) {
Serial.print("Received JVC: ");
} else if (comando->codeType == RC5) {
Serial.print("Received RC5: ");
} else if (comando->codeType == RC6) {
Serial.print("Received RC6: ");
} else {
Serial.print("Unexpected codeType ");
Serial.println(comando->codeType, DEC);
comando->codeType = UNKNOWN;
isRawCode = 1;
}
if(isRawCode == 0) {
Serial.println(resultadoIR->value, HEX);
comando->codeValue = resultadoIR->value;
comando->codeLen = resultadoIR->bits;
} else {
comando->codeValue = -1;
comando->codeLen = resultadoIR->rawlen - 1;
// Para armazenar os dados brutos:
// Descartar o primeiro valor;
// converter para microsegundos;
// Deixa as marcas menores e o espaços maiores para diminuir a distorção do receptor
for (int i = 1; i <= comando->codeLen; i++) {
if (i % 2) {
// Mark
comando->rawCodes[i - 1] = resultadoIR->rawbuf[i]*USECPERTICK - MARK_EXCESS;
}
else {
// Space
comando->rawCodes[i - 1] = resultadoIR->rawbuf[i]*USECPERTICK + MARK_EXCESS;
}
}
printCodigoBruto(comando);
}
gravarNoEEPROM(comando);
digitalWrite(PIN_IR_STATUS, LOW);
}
void printCodigoBruto(Comando *command) {
/*for (int i = 1; i <= command->codeLen; i++) {
if (i % 2) {
Serial.print(" m"); // Mark
}
else {
Serial.print(" s"); // Space
}
Serial.print(command->rawCodes[i - 1], DEC);
}
Serial.println("");*/
Serial.print(command->codeLen);
Serial.println(" bytes");
}
//Verifica se é possível enviar o comando e envia
void validarEnviarComando(int comandoId) {
//Verifica se existe comando salvo na memória EEPRON
if(comandoEstaSalvoEEPROM(comandoId)) {
//Busca o comando salvo na memória
carregarComandoEEPROM(comandoId, &comando);
enviarComando(&comando);
}
}
//Envia o comando
void enviarComando(Comando *comando) {
digitalWrite(PIN_IR_STATUS, HIGH);
irEmissor.sendRaw(comando->rawCodes, comando->codeLen, 38);
digitalWrite(PIN_IR_STATUS, LOW);
delay(50);
}