Unable to receive ir signal

[gokhanbarisaker]

I've decode any IR signal (decoded signal not available while looping) using the code below that generates the following output. What could I be doing wrong there?

START /home/pi/Workspace/ir/ir.ino from Mar 30 2024
Using library version 4.3.1
IRremoteInfo - by AnalysIR (http://www.AnalysIR.com/)

• A helper sketch to assist in troubleshooting issues with the library by reviewing the settings within the IRremote library
• Prints out the important settings within the library, which can be configured to suit the many supported platforms
• When seeking on-line support, please post or upload the output of this sketch, where appropriate

IRremote Library Settings

RAW_BUFFER_LENGTH: 112
Timer Error: not defined
IR Send Pin: 4
IR Receive Pin: 15
MCU Clock: 240000000
MCU Platform: ATmega328(P) / (Duemilanove, Diecimila, LilyPad, Mini, Micro, Fio, Nano, etc)
Mark Excess: 20 uSecs
Microseconds per tick: 50 uSecs
Measurement tolerance: 25%
Minimum Gap between IR Signals: 8000 uSecs
Arduino IDE version: 1.6.7
Debug Mode: OFF (Normal)

IR PROTOCOLS SEND DECODE
============= ======== ========
RC5: Enabled
RC6: Enabled
NEC: Enabled
SONY: Enabled
PANASONIC: Enabled
JVC: Enabled
SAMSUNG: Enabled
LG: Enabled
DENON: Enabled
BANG_OLUFSEN: Disabled
BOSEWAVE: Enabled
WHYNTER: Enabled
FAST: Enabled

Notes:

• Most of the settings above can be configured in the following files included as part of the library
• IRremoteInt.h
• IRremote.h
• You can save SRAM by disabling the Decode or Send features for any protocol (Near the top of IRremoteInt.h)
• Some Timer conflicts, with other libraries, can be easily resolved by configuring a different Timer for your platform

DONE!!!

/*
 * IRremote: IRremoteInfo - prints relevant config info & settings for IRremote over serial
 * Intended to help identify & troubleshoot the various settings of IRremote
 * For example, sometimes users are unsure of which pin is used for Tx or the RAW_BUFFER_LENGTH value
 * This example can be used to assist the user directly or with support.
 * Intended to help identify & troubleshoot the various settings of IRremote
 * Hopefully this utility will be a useful tool for support & troubleshooting for IRremote
 * Check out the blog post describing the sketch via http://www.analysir.com/blog/2015/11/28/helper-utility-for-troubleshooting-irremote/
 * Version 1.0 November 2015
 * Original Author: AnalysIR - IR software & modules for Makers & Pros, visit http://www.AnalysIR.com
 */
#include <Arduino.h>

// #define EXCLUDE_EXOTIC_PROTOCOLS // saves around 240 bytes program memory if IrSender.write is used
// #define SEND_PWM_BY_TIMER
// #define USE_NO_SEND_PWM
// #define NO_LED_FEEDBACK_CODE // saves 566 bytes program memory

#include "PinDefinitionsAndMore.h"
#include <IRremote.hpp>

// Function declarations for non Arduino IDE's
void dumpHeader();
void dumpRAW_BUFFER_LENGTH();
void dumpTIMER();
void dumpTimerPin();
void dumpClock();
void dumpPlatform();
void dumpPulseParams();
void dumpSignalParams();
void dumpArduinoIDE();
void dumpDebugMode();
void dumpProtocols();
void dumpFooter();

int ledPin = 21;

void setup()
{
    Serial.begin(115200);
    pinMode (ledPin, OUTPUT);
    IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
    Serial.println("\nDONE!!!\n");
    delay(5000);
#if defined(__AVR_ATmega32U4__) || defined(SERIAL_PORT_USBVIRTUAL) || defined(SERIAL_USB) /*stm32duino*/ || defined(USBCON) /*STM32_stm32*/ || defined(SERIALUSB_PID) || defined(ARDUINO_attiny3217)
    delay(4000); // To be able to connect Serial monitor after reset or power up and before first print out. Do not wait for an attached Serial Monitor!
#endif
    // Just to know which program is running on my Arduino
    Serial.println("START " __FILE__ " from " __DATE__ "\r\nUsing library version " VERSION_IRREMOTE);

    // Runs only once per restart of the Arduino.
    dumpHeader();
    delay(1000);
    dumpRAW_BUFFER_LENGTH();
    delay(1000);
    dumpTIMER();
    delay(1000);
    dumpTimerPin();
    delay(1000);
    dumpClock();
    delay(1000);
    dumpPlatform();
    delay(1000);
    dumpPulseParams();
    delay(1000);
    dumpSignalParams();
    delay(1000);
    dumpArduinoIDE();
    delay(1000);
    dumpDebugMode();
    delay(1000);
    dumpProtocols();
    delay(1000);
    dumpFooter();
    delay(1000);
    Serial.println("\nDONE!!!\n");
}

void loop()
{
    // nothing to do!
    // Serial.println("Looping!");
    // delay(3000);

    /*
     * Check if received data is available and if yes, try to decode it.
     * Decoded result is in the IrReceiver.decodedIRData structure.
     *
     * E.g. command is in IrReceiver.decodedIRData.command
     * address is in command is in IrReceiver.decodedIRData.address
     * and up to 32 bit raw data in IrReceiver.decodedIRData.decodedRawData
     */
    if (IrReceiver.decode())
    {

        /*
         * Print a summary of received data
         */
        if (IrReceiver.decodedIRData.protocol == UNKNOWN)
        {
            Serial.println("Received noise or an unknown (or not yet enabled) protocol");
            // We have an unknown protocol here, print extended info
            IrReceiver.printIRResultRawFormatted(&Serial, true);
            IrReceiver.resume(); // Do it here, to preserve raw data for printing with printIRResultRawFormatted()
        }
        else
        {
            IrReceiver.resume(); // Early enable receiving of the next IR frame
            IrReceiver.printIRResultShort(&Serial);
            IrReceiver.printIRSendUsage(&Serial);
        }
        Serial.println();

        /*
         * Finally, check the received data and perform actions according to the received command
         */
        if (IrReceiver.decodedIRData.command == 0x10)
        {
            // do something
        }
        else if (IrReceiver.decodedIRData.command == 0x11)
        {
            // do something else
        }
    }

    delay(1000);
    digitalWrite (ledPin, HIGH);
    delay(1000);
    digitalWrite (ledPin, LOW);
}

void dumpRAW_BUFFER_LENGTH()
{
    Serial.print("RAW_BUFFER_LENGTH: ");
    Serial.println(RAW_BUFFER_LENGTH);
}

void dumpTIMER()
{
    bool flag = false;
#if defined(IR_USE_TIMER1)
    Serial.print("Timer defined for use: ");
    Serial.println("Timer1");
    flag = true;
#endif
#if defined(IR_USE_TIMER2)
    Serial.print("Timer defined for use: ");
    Serial.println("Timer2");
    flag = true;
#endif
#if defined(IR_USE_TIMER3)
    Serial.print("Timer defined for use: ");
    Serial.println("Timer3");
    flag = true;
#endif
#if defined(IR_USE_TIMER4)
    Serial.print("Timer defined for use: ");
    Serial.println("Timer4");
    flag = true;
#endif
#if defined(IR_USE_TIMER5)
    Serial.print("Timer defined for use: ");
    Serial.println("Timer5");
    flag = true;
#endif
#if defined(IR_USE_TIMER4_HS)
    Serial.print("Timer defined for use: ");
    Serial.println("Timer4_HS");
    flag = true;
#endif
#if defined(IR_USE_TIMER_CMT)
    Serial.print("Timer defined for use: ");
    Serial.println("Timer_CMT");
    flag = true;
#endif
#if defined(IR_USE_TIMER_TPM1)
    Serial.print("Timer defined for use: ");
    Serial.println("Timer_TPM1");
    flag = true;
#endif
#if defined(IR_USE_TIMER_TINY0)
    Serial.print("Timer defined for use: ");
    Serial.println("Timer_TINY0");
    flag = true;
#endif

    if (!flag)
    {
        Serial.print("Timer Error: ");
        Serial.println("not defined");
    }
}

void dumpTimerPin()
{
    Serial.print("IR Send Pin: ");
#if defined(IR_SEND_PIN)
    Serial.println(IR_SEND_PIN);
#else
    Serial.println(IrSender.sendPin);
#endif
    Serial.print("IR Receive Pin: ");
#if defined(IR_RECEIVE_PIN)
    Serial.println(IR_RECEIVE_PIN);
#else
    Serial.println("???");
#endif
}

void dumpClock()
{
#if defined(F_CPU)
    Serial.print("MCU Clock: ");
    Serial.println(F_CPU);
#endif
}

void dumpPlatform()
{
    Serial.print("MCU Platform: ");

#if defined(__AVR_ATmega8__)
    Serial.println("Atmega8");
#elif defined(__AVR_ATmega16__)
    Serial.println("ATmega16");
#elif defined(__AVR_ATmega32__)
    Serial.println("ATmega32");
#elif defined(__AVR_ATmega32U4__)
    Serial.println("Arduino Leonardo / Yun / Teensy 1.0 / ATmega32U4");
#elif defined(__AVR_ATmega48__) || defined(__AVR_ATmega48P__)
    Serial.println("ATmega48");
#elif defined(__AVR_ATmega64__)
    Serial.println("ATmega64");
#elif defined(__AVR_ATmega88__) || defined(__AVR_ATmega88P__)
    Serial.println("ATmega88");
#elif defined(__AVR_ATmega162__)
    Serial.println("ATmega162");
#elif defined(__AVR_ATmega164A__) || defined(__AVR_ATmega164P__)
    Serial.println("ATmega164");
#elif defined(__AVR_ATmega324P__) || defined(__AVR_ATmega324A__) || defined(__AVR_ATmega324PA__)
    Serial.println("ATmega324");

#elif defined(__AVR_ATmega644__) || defined(__AVR_ATmega644P__)
    Serial.println("ATmega644");
#elif defined(__AVR_ATmega1280__)
    Serial.println("Arduino Mega1280");
#elif defined(__AVR_ATmega1281__)
    Serial.println("ATmega1281");
#elif defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)
    Serial.println("ATmega1284");
#elif defined(__AVR_ATmega2560__)
    Serial.println("Arduino Mega2560");
#elif defined(__AVR_ATmega2561__)
    Serial.println("ATmega2561");

#elif defined(__AVR_ATmega8515__)
    Serial.println("ATmega8515");
#elif defined(__AVR_ATmega8535__)
    Serial.println("ATmega8535");

#elif defined(__AVR_AT90USB162__)
    Serial.println("Teensy 1.0 / AT90USB162");
    // Teensy 2.0
#elif defined(__MK20DX128__) || defined(__MK20DX256__)
    Serial.println("Teensy 3.0 / Teensy 3.1 / MK20DX128 / MK20DX256");
#elif defined(__MKL26Z64__)
    Serial.println("Teensy-LC / MKL26Z64");
#elif defined(__AVR_AT90USB646__)
    Serial.println("Teensy++ 1.0 / AT90USB646");
#elif defined(__AVR_AT90USB1286__)
    Serial.println("Teensy++ 2.0 / AT90USB1286");

#elif defined(__AVR_ATtiny84__)
    Serial.println("ATtiny84");
#elif defined(__AVR_ATtiny85__)
    Serial.println("ATtiny85");
#else
    Serial.println("ATmega328(P) / (Duemilanove, Diecimila, LilyPad, Mini, Micro, Fio, Nano, etc)");
#endif
}

void dumpPulseParams()
{
    Serial.print("Mark Excess: ");
    Serial.print(MARK_EXCESS_MICROS);
    ;
    Serial.println(" uSecs");
    Serial.print("Microseconds per tick: ");
    Serial.print(MICROS_PER_TICK);
    ;
    Serial.println(" uSecs");
    Serial.print("Measurement tolerance: ");
    Serial.print(TOLERANCE_FOR_DECODERS_MARK_OR_SPACE_MATCHING);
    Serial.println("%");
}

void dumpSignalParams()
{
    Serial.print("Minimum Gap between IR Signals: ");
    Serial.print(RECORD_GAP_MICROS);
    Serial.println(" uSecs");
}

void dumpDebugMode()
{
    Serial.print("Debug Mode: ");
#if DEBUG
    Serial.println("ON");
#else
    Serial.println("OFF (Normal)");
#endif
}

void dumpArduinoIDE()
{
    Serial.print("Arduino IDE version: ");
    Serial.print(ARDUINO / 10000);
    Serial.write('.');
    Serial.print((ARDUINO % 10000) / 100);
    Serial.write('.');
    Serial.println(ARDUINO % 100);
}

void dumpProtocols()
{

    Serial.println();
    Serial.print("IR PROTOCOLS  ");
    Serial.print("SEND     ");
    Serial.println("DECODE");
    Serial.print("============= ");
    Serial.print("======== ");
    Serial.println("========");
    Serial.print("RC5:          ");
#if defined(DECODE_RC5)
    Serial.println("Enabled");
#else
    Serial.println("Disabled");
#endif

    Serial.print("RC6:          ");
#if defined(DECODE_RC6)
    Serial.println("Enabled");
#else
    Serial.println("Disabled");
#endif

    Serial.print("NEC:          ");
#if defined(DECODE_NEC)
    Serial.println("Enabled");
#else
    Serial.println("Disabled");
#endif

    Serial.print("SONY:         ");
#if defined(DECODE_SONY)
    Serial.println("Enabled");
#else
    Serial.println("Disabled");
#endif

    Serial.print("PANASONIC:    ");
#if defined(DECODE_PANASONIC)
    Serial.println("Enabled");
#else
    Serial.println("Disabled");
#endif

    Serial.print("JVC:          ");
#if defined(DECODE_JVC)
    Serial.println("Enabled");
#else
    Serial.println("Disabled");
#endif

    Serial.print("SAMSUNG:      ");
#if defined(DECODE_SAMSUNG)
    Serial.println("Enabled");
#else
    Serial.println("Disabled");
#endif

    Serial.print("LG:           ");
#if defined(DECODE_LG)
    Serial.println("Enabled");
#else
    Serial.println("Disabled");
#endif

    Serial.print("DENON:        ");
#if defined(DECODE_DENON)
    Serial.println("Enabled");
#else
    Serial.println("Disabled");
#endif

#if !defined(EXCLUDE_EXOTIC_PROTOCOLS) // saves around 2000 bytes program memory

    Serial.print("BANG_OLUFSEN: ");
#if defined(DECODE_BEO)
    Serial.println("Enabled");
#else
    Serial.println("Disabled");
#endif

    Serial.print("BOSEWAVE:     ");
#if defined(DECODE_BOSEWAVE)
    Serial.println("Enabled");
#else
    Serial.println("Disabled");
#endif

    Serial.print("WHYNTER:      ");
#if defined(DECODE_WHYNTER)
    Serial.println("Enabled");
#else
    Serial.println("Disabled");
#endif

    Serial.print("FAST:         ");
#if defined(DECODE_FAST)
    Serial.println("Enabled");
#else
    Serial.println("Disabled");
#endif
#endif
}

void printDecodeEnabled(int flag)
{
    if (flag)
    {
        Serial.println("Enabled");
    }
    else
    {
        Serial.println("Disabled");
    }
}

void dumpHeader()
{
    Serial.println("IRremoteInfo - by AnalysIR (http://www.AnalysIR.com/)");
    Serial.println(

        "- A helper sketch to assist in troubleshooting issues with the library by reviewing the settings within the IRremote library");
    Serial.println(

        "- Prints out the important settings within the library, which can be configured to suit the many supported platforms");
    Serial.println("- When seeking on-line support, please post or upload the output of this sketch, where appropriate");
    Serial.println();
    Serial.println("IRremote Library Settings");
    Serial.println("=========================");
}

void dumpFooter()
{
    Serial.println();
    Serial.println("Notes: ");
    Serial.println("- Most of the settings above can be configured in the following files included as part of the library");
    Serial.println("- IRremoteInt.h");
    Serial.println("- IRremote.h");
    Serial.println(
        "- You can save SRAM by disabling the Decode or Send features for any protocol (Near the top of IRremoteInt.h)");
    Serial.println(

        "- Some Timer conflicts, with other libraries, can be easily resolved by configuring a different Timer for your platform");
}

Pin connection (G15)

Remote controllers

[ArminJo]

Try ReceiveDemo example

[gokhanbarisaker]

Unfortunately that doesn't work either. I have tried with following IR receivers;

• https://www.amazon.nl/dp/B0893BD1V6?psc=1&ref=ppx_yo2ov_dt_b_product_details
• https://www.amazon.nl/dp/B07DDPRH8M?ref=ppx_yo2ov_dt_b_product_details&th=1

On setup, I receive following output;

Using library version 4.3.1
Enabling IRin...
Ready to receive IR signals of protocols: NEC/NEC2/Onkyo/Apple, Panasonic/Kaseikyo, Denon/Sharp, Sony, RC5, RC6, LG, JVC, Samsung, FAST, Whynter, Lego Power Functions, Bosewave , MagiQuest, Universal Pulse Distance Width, Hash at pin 15

If you connect debug pin 16 to ground, raw data is always printed
8000 us is the (minimum) gap, after which the start of a new IR packet is assumed
20 us are subtracted from all marks and added to all spaces for decoding

Other than that, it only outputs bunch of noise messages while I am removing the signal pin (G15);

Received noise or an unknown (or not yet enabled) protocol
rawData[2]:
-9200
+10150
Sum: 10150

[ArminJo]

Please ask for help in a forum, because your wiring is wrong.

[gokhanbarisaker]

Thanks, I'll check.

I was directly wiring sensor to ground, v5 and g15 (receive pin used by this library as per logs on my above) pins of the esp32.

Could you share a link to the forum mentioned above?