Go Down

Topic: Dúvida sobre código de projeto de controle de ar condicionado universal (Read 165 times) previous topic - next topic

Mituo-Lucas

 Estou desenvolvendo esse código, que ele deve ser um controle universal, ele cópia comandos dos controles externos, e associa cada  código a um botão, mais durante a execução do código, quando aperto o botão 1 ele entra no laço e fica preso  num loop "pressione para atribuir 4"  que é um dos sinalizadores que coloquei no código para saber onde o código estava rodando, a perto o botão no controle que quero copiar, e aperto o botão no meu controle que vou atribuir, mais ele não entra nas condições do botão(a parte de atribuição), se alguém puder me ajudar com esse problema agradeço imensamente!
código logo abaixo:
Code: [Select]
// This sketch will send out a Nikon D50 trigger signal (probably works with most Nikons)
// See the full tutorial at http://www.ladyada.net/learn/sensors/ir.html
// this code is public domain, please enjoy!
#define IRpin_PIN PIND
#define IRpin 2
#include <SPI.h>
#include <SD.h>
#define MAXPULSE 65000
#define RESOLUTION 20
uint16_t pulses[100][2]; // pair is high and low pulse
uint8_t currentpulse = 0; // index for pulses we're storing

//***********************definição de pinos**********************************************
File myFile;
File power;
File aumentoTemperatura;
File diminuiTemperatura;
const int botao1 =22;
const int botao2 = 3;
const int botao3 = 6;
const int botao4 = 7;
const int botao5 = 8;
int IRledPin =  9;    // LED connected to digital pin 13
boolean estadoBotao1 = 0;
boolean estadoBotao2 = 0;
boolean estadoBotao3 = 0;
boolean estadoBotao4 = 0;
boolean estadoBotao5 = 0;
// The setup() method runs once, when the sketch starts




//************************FUnção PRINTPULSES**********************************************
void printpulses(void) {
myFile = SD.open("copia.txt", FILE_WRITE);
if (myFile) {
Serial.println("\n\r\n\rReceived: \n\r OFF \t ON");
// Gera o codigo da tecla pressionada.
for (uint8_t i = 0; i < currentpulse; i++) {
myFile.println("delayMicroseconds(");
myFile.println(pulses[i][0] * RESOLUTION, DEC);
myFile.println(");\n");
myFile.println("pulseIR(");
myFile.println(pulses[i][1] * RESOLUTION, DEC);
myFile.println(");\n");
 }
 myFile.close();
}
}
//************************FIM FUnção PRINTPULSES**********************************************
void setup()   {
// initialize the IR digital pin as an output:
pinMode(botao1,INPUT);
pinMode(botao2,INPUT);
pinMode(botao3,INPUT);
pinMode(botao4,INPUT);
pinMode(botao5,INPUT);
pinMode(IRledPin, OUTPUT);
 
Serial.begin(9600);
}
 
void loop()
{
  
estadoBotao1 = digitalRead(botao1);
estadoBotao2 = digitalRead(botao2);
estadoBotao3 = digitalRead(botao3);
estadoBotao4 = digitalRead(botao4);
estadoBotao5 = digitalRead(botao5);//criar outros botoes para associar
 
if (estadoBotao1) {
   //código para gravar
Serial.println("pressione o botão para atribuir");
uint16_t highpulse, lowpulse; // temporary storage timing
highpulse = lowpulse = 0; // start out with no pulse length
 
// while (digitalRead(IRpin)) { // this is too slow!
while (IRpin_PIN & _BV(IRpin)) {
  Serial.println("pressione o botão para atribuir 2");
// pin is still HIGH
 
// count off another few microseconds
highpulse++;
delayMicroseconds(RESOLUTION);
 
// If the pulse is too long, we 'timed out' - either nothing
// was received or the code is finished, so print what
// we've grabbed so far, and then reset
if ((highpulse >= MAXPULSE) && (currentpulse != 0)) {
  Serial.println("pressione o botão para atribuir 3");
printpulses();
currentpulse=0;
return;
}
}
// we didn't time out so lets stash the reading
pulses[currentpulse][0] = highpulse;
 
// same as above
while (! (IRpin_PIN & _BV(IRpin))) {
  Serial.println("pressione o botão para atribuir 4");
// pin is still LOW
lowpulse++;
delayMicroseconds(RESOLUTION);
if ((lowpulse >= MAXPULSE) && (currentpulse != 0)) {
  Serial.println("pressione o botão para atribuir 5");
printpulses();
currentpulse=0;
return;
}
}
pulses[currentpulse][1] = lowpulse;
 
// we read one high-low pulse successfully, continue!
currentpulse++;
//high
 
//***********************************************************************

   Serial.println("pressione o botão para atribuir ***");
   if (estadoBotao2){
    myFile = SD.open("copia.txt");
   power = SD.open("Botao2.txt", FILE_WRITE);//Atribuir copia
   power.println(myFile.read());
   Serial.println("Código atribuido ao botão On/off");
    myFile.close();
    power.close();
    SD.remove("copia.txt");
 //mandar o conteudo do aquivo de texto para um novo que estara integrado na função de seu respectivo botão
}
     if (digitalRead(botao3)){
    myFile = SD.open("copia.txt");
   aumentoTemperatura = SD.open("Botao3.txt", FILE_WRITE);//Atribuir copia
    aumentoTemperatura.println(myFile.read());
    myFile.close();
    aumentoTemperatura.close();
 //mandar o conteudo do aquivo de texto para um novo que estara integrado na função de seu respectivo botão
   SD.remove("copia.txt");
   Serial.println("Código atribuído ao botão Volume +");
}
       if (digitalRead(botao4)){
    myFile = SD.open("copia.txt");
   diminuiTemperatura = SD.open("Botao4.txt", FILE_WRITE);//Atribuir copia
    diminuiTemperatura.println(myFile.read());
    myFile.close();
    diminuiTemperatura.close();
 //mandar o conteudo do aquivo de texto para um novo que estara integrado na função de seu respectivo botão
   SD.remove("copia.txt");
   Serial.println("Código atribuído ao botão volume -");
}
  
  }
      
  if (digitalRead(botao2)){  
Serial.println("On/off");
  
SendChannelUpCodePower();
delay(500);
 }
   if (digitalRead(botao3)){  
Serial.println("Aumentar temperatura");
  
SendChannelUpCodeAumento();
delay(500);
 }
   if (digitalRead(botao4)){  
Serial.println("Diminuir temperatura");
  
SendChannelUpCodeDiminui();
delay(500);
 }
   if (digitalRead(botao5)){ //botao de reset
Serial.println("reset power");
if(digitalRead(botao2)){
  
 SD.remove("Botao2.txt");
  }  
  if(digitalRead(botao3)){
  
 SD.remove("Botao3.txt");
  }  
delay(500);
 }
 if(digitalRead(botao4)){
  
 SD.remove("Botao4.txt");
  }  
}
 
// This procedure sends a 38KHz pulse to the IRledPin
// for a certain # of microseconds. We'll use this whenever we need to send codes
void pulseIR(long microsecs) {
// we'll count down from the number of microseconds we are told to wait
 
cli();  // this turns off any background interrupts
 
while (microsecs > 0) {
// 38 kHz is about 13 microseconds high and 13 microseconds low
digitalWrite(IRledPin, HIGH);  // this takes about 3 microseconds to happen
delayMicroseconds(10);         // hang out for 10 microseconds
digitalWrite(IRledPin, LOW);   // this also takes about 3 microseconds
delayMicroseconds(10);         // hang out for 10 microseconds
 
// so 26 microseconds altogether
microsecs -= 26;
}
 
sei();  // this turns them back on
}

void SendChannelUpCodePower() {
 power = SD.open("Botao2.txt");
  if (power) {
    while (power.available()) {
      Serial.write(power.read());
    }
  }
 power.close();
}
void SendChannelUpCodeAumento() {
 aumentoTemperatura = SD.open("Boto3.txt");
  if (aumentoTemperatura) {
    while (aumentoTemperatura.available()) {
      Serial.write(aumentoTemperatura.read());
    }
  }
 aumentoTemperatura.close();
}
void SendChannelUpCodeDiminui() {
diminuiTemperatura  = SD.open("botao4.txt");
  if (diminuiTemperatura) {
    while (diminuiTemperatura.available()) {
      Serial.write(diminuiTemperatura.read());
    }
  }
 diminuiTemperatura.close();
}

rtek1000

Olá,

Você parece estar indo bem, colocar sinalizadores é um bom método para identificar a execução do programa, uma outra abordagem é isolar o bloco problemático em um novo programa, para evitar a confusão com muitas informações adicionais, que as outras rotinas estão realizando.

Quando o programa é muito grande, pode ser interessante utilizar um fluxograma para ilustrar como o programa deveria se comportar, então a visualização de cada etapa se torna mais clara e definida,

Um programa que eu costumo usar, é o editor yEd:

yEd Graph Editor

Veja um exemplo:
Please avoid private messages, your question may be someone's answer in the future!

rtek1000

Eu estava vendo seu código, e notei que no começo da sub loop, você salvou o estado dos botões, mas logo a seguir parou de usar tais variáveis:

Code: [Select]

  estadoBotao1 = digitalRead(botao1);
  estadoBotao2 = digitalRead(botao2);
  estadoBotao3 = digitalRead(botao3);
  estadoBotao4 = digitalRead(botao4);
  estadoBotao5 = digitalRead(botao5);


Code: [Select]
if (estadoBotao1) {

Code: [Select]
if (estadoBotao2) {

Code: [Select]
if (digitalRead(botao3)) {


Uma dica: utilizar a função pull-up nos botões ajuda a economizar no hardware, pois não precisa usar resistores externos, e também deixa o código mais fácil de ser testado em outra placa que está incompleta, como em simuladores.

Code: [Select]
pinMode(botao1, INPUT_PULLUP);

Então a lógica apenas inverte na verificação, (sinal de exclamação antes da variável testada):

Code: [Select]
if (!estadoBotao1) {
Please avoid private messages, your question may be someone's answer in the future!

rtek1000

Notei também que a quantidade de memória RAM livre, está bem pouca:

Quote
Sketch uses 12546 bytes (38%) of program storage space. Maximum is 32256 bytes.
Global variables use 1864 bytes (91%) of dynamic memory, leaving 184 bytes for local variables. Maximum is 2048 bytes.
Low memory available, stability problems may occur.
Para ajudar nisso, você pode declarar o texto desta forma (deixando o texto entre "F( )"):

Quote
F("texto")
Isso faz com que o texto seja armazenado na memória de programa, deixando de usar a memória RAM:

Quote
Sketch uses 13692 bytes (42%) of program storage space. Maximum is 32256 bytes.
Global variables use 1415 bytes (69%) of dynamic memory, leaving 633 bytes for local variables. Maximum is 2048 bytes.
(Observação: os botões foram invertidos no código abaixo)

Code: [Select]
// This sketch will send out a Nikon D50 trigger signal (probably works with most Nikons)
// See the full tutorial at http://www.ladyada.net/learn/sensors/ir.html
// this code is public domain, please enjoy!
#define IRpin_PIN PIND
#define IRpin 2
#include <SPI.h>
#include <SD.h>
#define MAXPULSE 65000
#define RESOLUTION 20
uint16_t pulses[100][2]; // pair is high and low pulse
uint8_t currentpulse = 0; // index for pulses we're storing

//***********************defini��o de pinos**********************************************
File myFile;
File power;
File aumentoTemperatura;
File diminuiTemperatura;
const int botao1 = 22;
const int botao2 = 3;
const int botao3 = 6;
const int botao4 = 7;
const int botao5 = 8;
int IRledPin =  9;    // LED connected to digital pin 13
boolean estadoBotao1 = 0;
boolean estadoBotao2 = 0;
boolean estadoBotao3 = 0;
boolean estadoBotao4 = 0;
boolean estadoBotao5 = 0;
// The setup() method runs once, when the sketch starts




//************************FUn��o PRINTPULSES**********************************************
void printpulses(void) {
  myFile = SD.open("copia.txt", FILE_WRITE);
  if (myFile) {
    Serial.println(F("\n\r\n\rReceived: \n\r OFF \t ON"));
    // Gera o codigo da tecla pressionada.
    for (uint8_t i = 0; i < currentpulse; i++) {
      myFile.println(F("delayMicroseconds("));
      myFile.println(pulses[i][0] * RESOLUTION, DEC);
      myFile.println(F(");\n"));
      myFile.println(F("pulseIR("));
      myFile.println(pulses[i][1] * RESOLUTION, DEC);
      myFile.println(F(");\n"));
    }
    myFile.close();
  }
}
//************************FIM FUn��o PRINTPULSES**********************************************
void setup()   {
  // initialize the IR digital pin as an output:
  pinMode(botao1, INPUT_PULLUP);
  pinMode(botao2, INPUT_PULLUP);
  pinMode(botao3, INPUT_PULLUP);
  pinMode(botao4, INPUT_PULLUP);
  pinMode(botao5, INPUT_PULLUP);
  pinMode(IRledPin, OUTPUT);

  Serial.begin(9600);
}

void loop()
{

  estadoBotao1 = digitalRead(botao1);
  estadoBotao2 = digitalRead(botao2);
  estadoBotao3 = digitalRead(botao3);
  estadoBotao4 = digitalRead(botao4);
  estadoBotao5 = digitalRead(botao5);//criar outros botoes para associar

  if (!estadoBotao1) {
    //c�digo para gravar
    Serial.println(F("pressione o bot�o para atribuir"));
    uint16_t highpulse, lowpulse; // temporary storage timing
    highpulse = lowpulse = 0; // start out with no pulse length

    // while (digitalRead(IRpin)) { // this is too slow!
    while (IRpin_PIN & _BV(IRpin)) {
      Serial.println(F("pressione o bot�o para atribuir 2"));
      // pin is still HIGH

      // count off another few microseconds
      highpulse++;
      delayMicroseconds(RESOLUTION);

      // If the pulse is too long, we 'timed out' - either nothing
      // was received or the code is finished, so print what
      // we've grabbed so far, and then reset
      if ((highpulse >= MAXPULSE) && (currentpulse != 0)) {
        Serial.println(F("pressione o bot�o para atribuir 3"));
        printpulses();
        currentpulse = 0;
        return;
      }
    }
    // we didn't time out so lets stash the reading
    pulses[currentpulse][0] = highpulse;

    // same as above
    while (! (IRpin_PIN & _BV(IRpin))) {
      Serial.println(F("pressione o bot�o para atribuir 4"));
      // pin is still LOW
      lowpulse++;
      delayMicroseconds(RESOLUTION);
      if ((lowpulse >= MAXPULSE) && (currentpulse != 0)) {
        Serial.println(F("pressione o bot�o para atribuir 5"));
        printpulses();
        currentpulse = 0;
        return;
      }
    }
    pulses[currentpulse][1] = lowpulse;

    // we read one high-low pulse successfully, continue!
    currentpulse++;
    //high

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

    Serial.println(F("pressione o bot�o para atribuir ***"));
    if (!estadoBotao2) {
      myFile = SD.open(F("copia.txt"));
      power = SD.open("Botao2.txt", FILE_WRITE);//Atribuir copia
      power.println(myFile.read());
      Serial.println(F("C�digo atribuido ao bot�o On/off"));
      myFile.close();
      power.close();
      SD.remove(F("copia.txt"));
      //mandar o conteudo do aquivo de texto para um novo que estara integrado na fun��o de seu respectivo bot�o
    }
    if (!estadoBotao3) {
      myFile = SD.open(F("copia.txt"));
      aumentoTemperatura = SD.open("Botao3.txt", FILE_WRITE);//Atribuir copia
      aumentoTemperatura.println(myFile.read());
      myFile.close();
      aumentoTemperatura.close();
      //mandar o conteudo do aquivo de texto para um novo que estara integrado na fun��o de seu respectivo bot�o
      SD.remove(F("copia.txt"));
      Serial.println(F("C�digo atribu�do ao bot�o Volume +"));
    }
    if (!estadoBotao4) {
      myFile = SD.open(F("copia.txt"));
      diminuiTemperatura = SD.open("Botao4.txt", FILE_WRITE);//Atribuir copia
      diminuiTemperatura.println(myFile.read());
      myFile.close();
      diminuiTemperatura.close();
      //mandar o conteudo do aquivo de texto para um novo que estara integrado na fun��o de seu respectivo bot�o
      SD.remove(F("copia.txt"));
      Serial.println(F("C�digo atribu�do ao bot�o volume -"));
    }

  }

  if (!estadoBotao2) {
    Serial.println(F("On/off"));

    SendChannelUpCodePower();
    delay(500);
  }
  if (!estadoBotao3) {
    Serial.println(F("Aumentar temperatura"));

    SendChannelUpCodeAumento();
    delay(500);
  }
  if (!estadoBotao4) {
    Serial.println(F("Diminuir temperatura"));

    SendChannelUpCodeDiminui();
    delay(500);
  }
  if (!estadoBotao5) { //botao de reset
    Serial.println(F("reset power"));
    if (!estadoBotao2) {

      SD.remove(F("Botao2.txt"));
    }
    if (!estadoBotao3) {

      SD.remove(F("Botao3.txt"));
    }
    delay(500);
  }
  if (!estadoBotao4) {

    SD.remove(F("Botao4.txt"));
  }
}

// This procedure sends a 38KHz pulse to the IRledPin
// for a certain # of microseconds. We'll use this whenever we need to send codes
void pulseIR(long microsecs) {
  // we'll count down from the number of microseconds we are told to wait

  cli();  // this turns off any background interrupts

  while (microsecs > 0) {
    // 38 kHz is about 13 microseconds high and 13 microseconds low
    digitalWrite(IRledPin, HIGH);  // this takes about 3 microseconds to happen
    delayMicroseconds(10);         // hang out for 10 microseconds
    digitalWrite(IRledPin, LOW);   // this also takes about 3 microseconds
    delayMicroseconds(10);         // hang out for 10 microseconds

    // so 26 microseconds altogether
    microsecs -= 26;
  }

  sei();  // this turns them back on
}

void SendChannelUpCodePower() {
  power = SD.open(F("Botao2.txt"));
  if (power) {
    while (power.available()) {
      Serial.write(power.read());
    }
  }
  power.close();
}
void SendChannelUpCodeAumento() {
  aumentoTemperatura = SD.open(F("Boto3.txt"));
  if (aumentoTemperatura) {
    while (aumentoTemperatura.available()) {
      Serial.write(aumentoTemperatura.read());
    }
  }
  aumentoTemperatura.close();
}
void SendChannelUpCodeDiminui() {
  diminuiTemperatura  = SD.open(F("botao4.txt"));
  if (diminuiTemperatura) {
    while (diminuiTemperatura.available()) {
      Serial.write(diminuiTemperatura.read());
    }
  }
  diminuiTemperatura.close();
}


Um dos meios mais utilizados pelos fabricantes de eletrônicos é a utilização de uma tabela de códigos, para evitar o uso de muitos recursos do microcontrolador.
Please avoid private messages, your question may be someone's answer in the future!

rtek1000

Uma coisa que eu achei interessante, é a forma que o seu código funciona, na verdade, fazendo uso de uma biblioteca grande, a biblioteca de cartão SD, e deixando de usar uma biblioteca menor, a biblioteca IR, e com isso o consumo de recursos se torna maior, além de passar a necessitar do uso do cartão SD.

Existe algum motivo em particular, para deixar de usar a biblioteca IR?

O código de exemplo IRsendDemo, que demonstra o envio de um sinal, utiliza:

Quote
Sketch uses 1734 bytes (5%) of program storage space. Maximum is 32256 bytes.
Global variables use 219 bytes (10%) of dynamic memory, leaving 1829 bytes for local variables. Maximum is 2048 bytes.
Code: [Select]

/*
 * IRremote: IRsendDemo - demonstrates sending IR codes with IRsend
 * An IR LED must be connected to Arduino PWM pin 3.
 * Version 0.1 July, 2009
 * Copyright 2009 Ken Shirriff
 * http://arcfn.com
 */


#include <IRremote.h>

IRsend irsend;

void setup()
{
}

void loop() {
 for (int i = 0; i < 3; i++) {
 irsend.sendSony(0xa90, 12);
 delay(40);
 }
 delay(5000); //5 second delay between each signal burst
}


E o código de exemplo IRrecvDemo, que demonstra a identificação de um sinal, utiliza:

Quote
Sketch uses 7718 bytes (23%) of program storage space. Maximum is 32256 bytes.
Global variables use 441 bytes (21%) of dynamic memory, leaving 1607 bytes for local variables. Maximum is 2048 bytes.
Code: [Select]

/*
 * IRremote: IRrecvDemo - demonstrates receiving IR codes with IRrecv
 * An IR detector/demodulator must be connected to the input RECV_PIN.
 * Version 0.1 July, 2009
 * Copyright 2009 Ken Shirriff
 * http://arcfn.com
 */

#include <IRremote.h>

int RECV_PIN = 11;

IRrecv irrecv(RECV_PIN);

decode_results results;

void setup()
{
  Serial.begin(9600);
  // In case the interrupt driver crashes on setup, give a clue
  // to the user what's going on.
  Serial.println("Enabling IRin");
  irrecv.enableIRIn(); // Start the receiver
  Serial.println("Enabled IRin");
}

void loop() {
  if (irrecv.decode(&results)) {
    Serial.println(results.value, HEX);
    irrecv.resume(); // Receive the next value
  }
  delay(100);
}


Biblioteca: Arduino-IRremote

Please avoid private messages, your question may be someone's answer in the future!

Mituo-Lucas

rtek1000 tinha a biblioteca IRremote anteriormente, eu apaguei e esqueci e colocar dnv, mas obriga pela sua ajuda, vou testar as sugestões! Repasso logo após os resultados

rtek1000

Legal, eu estava testando, e tem o exemplo IRrecvDumpV2 que é muito chique, de uma olhada:

Code: [Select]

//------------------------------------------------------------------------------
// Include the IRremote library header
//
#include <IRremote.h>

//------------------------------------------------------------------------------
// Tell IRremote which Arduino pin is connected to the IR Receiver (TSOP4838)
//
int recvPin = 11;
IRrecv irrecv(recvPin);

//+=============================================================================
// Configure the Arduino
//
void  setup ( )
{
  Serial.begin(9600);   // Status message will be sent to PC at 9600 baud
  irrecv.enableIRIn();  // Start the receiver
}

//+=============================================================================
// Display IR code
//
void  ircode (decode_results *results)
{
  // Panasonic has an Address
  if (results->decode_type == PANASONIC) {
    Serial.print(results->address, HEX);
    Serial.print(":");
  }

  // Print Code
  Serial.print(results->value, HEX);
}

//+=============================================================================
// Display encoding type
//
void  encoding (decode_results *results)
{
  switch (results->decode_type) {
    default:
    case UNKNOWN:      Serial.print("UNKNOWN");       break ;
    case NEC:          Serial.print("NEC");           break ;
    case SONY:         Serial.print("SONY");          break ;
    case RC5:          Serial.print("RC5");           break ;
    case RC6:          Serial.print("RC6");           break ;
    case DISH:         Serial.print("DISH");          break ;
    case SHARP:        Serial.print("SHARP");         break ;
    case JVC:          Serial.print("JVC");           break ;
    case SANYO:        Serial.print("SANYO");         break ;
    case MITSUBISHI:   Serial.print("MITSUBISHI");    break ;
    case SAMSUNG:      Serial.print("SAMSUNG");       break ;
    case LG:           Serial.print("LG");            break ;
    case WHYNTER:      Serial.print("WHYNTER");       break ;
    case AIWA_RC_T501: Serial.print("AIWA_RC_T501");  break ;
    case PANASONIC:    Serial.print("PANASONIC");     break ;
    case DENON:        Serial.print("Denon");         break ;
  }
}

//+=============================================================================
// Dump out the decode_results structure.
//
void  dumpInfo (decode_results *results)
{
  // Check if the buffer overflowed
  if (results->overflow) {
    Serial.println("IR code too long. Edit IRremoteInt.h and increase RAWBUF");
    return;
  }

  // Show Encoding standard
  Serial.print("Encoding  : ");
  encoding(results);
  Serial.println("");

  // Show Code & length
  Serial.print("Code      : ");
  ircode(results);
  Serial.print(" (");
  Serial.print(results->bits, DEC);
  Serial.println(" bits)");
}

//+=============================================================================
// Dump out the decode_results structure.
//
void  dumpRaw (decode_results *results)
{
  // Print Raw data
  Serial.print("Timing[");
  Serial.print(results->rawlen-1, DEC);
  Serial.println("]: ");

  for (int i = 1;  i < results->rawlen;  i++) {
    unsigned long  x = results->rawbuf[i] * USECPERTICK;
    if (!(i & 1)) {  // even
      Serial.print("-");
      if (x < 1000)  Serial.print(" ") ;
      if (x < 100)   Serial.print(" ") ;
      Serial.print(x, DEC);
    } else {  // odd
      Serial.print("     ");
      Serial.print("+");
      if (x < 1000)  Serial.print(" ") ;
      if (x < 100)   Serial.print(" ") ;
      Serial.print(x, DEC);
      if (i < results->rawlen-1) Serial.print(", "); //',' not needed for last one
    }
    if (!(i % 8))  Serial.println("");
  }
  Serial.println("");                    // Newline
}

//+=============================================================================
// Dump out the decode_results structure.
//
void  dumpCode (decode_results *results)
{
  // Start declaration
  Serial.print("unsigned int  ");          // variable type
  Serial.print("rawData[");                // array name
  Serial.print(results->rawlen - 1, DEC);  // array size
  Serial.print("] = {");                   // Start declaration

  // Dump data
  for (int i = 1;  i < results->rawlen;  i++) {
    Serial.print(results->rawbuf[i] * USECPERTICK, DEC);
    if ( i < results->rawlen-1 ) Serial.print(","); // ',' not needed on last one
    if (!(i & 1))  Serial.print(" ");
  }

  // End declaration
  Serial.print("};");  //

  // Comment
  Serial.print("  // ");
  encoding(results);
  Serial.print(" ");
  ircode(results);

  // Newline
  Serial.println("");

  // Now dump "known" codes
  if (results->decode_type != UNKNOWN) {

    // Some protocols have an address
    if (results->decode_type == PANASONIC) {
      Serial.print("unsigned int  addr = 0x");
      Serial.print(results->address, HEX);
      Serial.println(";");
    }

    // All protocols have data
    Serial.print("unsigned int  data = 0x");
    Serial.print(results->value, HEX);
    Serial.println(";");
  }
}

//+=============================================================================
// The repeating section of the code
//
void  loop ( )
{
  decode_results  results;        // Somewhere to store the results

  if (irrecv.decode(&results)) {  // Grab an IR code
    dumpInfo(&results);           // Output the results
    dumpRaw(&results);            // Output the results in RAW format
    dumpCode(&results);           // Output the results as source code
    Serial.println("");           // Blank line between entries
    irrecv.resume();              // Prepare for the next value
  }
}
Please avoid private messages, your question may be someone's answer in the future!

Mituo-Lucas

Achei o código bem legal, porém não sei como colocar o código raw dele no cartão, para envia-lo com o IRSendRawDemo, estou utilizando a biblioteca sd, para poder armazenar o código e depois ler ele e envia-lo

Go Up