From 55c568b2776508bce6cd722c790682a33ed6aad1 Mon Sep 17 00:00:00 2001 From: ariel s Date: Fri, 21 Jul 2023 02:54:00 +0300 Subject: [PATCH] ir_recive_demov2 --- platformio.ini | 1 + src/main.cpp | 192 +++++++++++++++++++++++++++++++++++++++++++++---- 2 files changed, 181 insertions(+), 12 deletions(-) diff --git a/platformio.ini b/platformio.ini index 7e1ad8e..2734187 100644 --- a/platformio.ini +++ b/platformio.ini @@ -13,3 +13,4 @@ platform = espressif8266 board = nodemcuv2 framework = arduino lib_deps = crankyoldgit/IRremoteESP8266@^2.8.5 +monitor_speed = 115200 \ No newline at end of file diff --git a/src/main.cpp b/src/main.cpp index cb9fbba..be34d4d 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -1,18 +1,186 @@ +/* + * IRremoteESP8266: IRrecvDumpV2 - dump details of IR codes with IRrecv + * An IR detector/demodulator must be connected to the input kRecvPin. + * + * Copyright 2009 Ken Shirriff, http://arcfn.com + * Copyright 2017-2019 David Conran + * + * Example circuit diagram: + * https://github.com/crankyoldgit/IRremoteESP8266/wiki#ir-receiving + * + * Changes: + * Version 1.2 October, 2020 + * - Enable easy setting of the decoding tolerance value. + * Version 1.0 October, 2019 + * - Internationalisation (i18n) support. + * - Stop displaying the legacy raw timing info. + * Version 0.5 June, 2019 + * - Move A/C description to IRac.cpp. + * Version 0.4 July, 2018 + * - Minor improvements and more A/C unit support. + * Version 0.3 November, 2017 + * - Support for A/C decoding for some protocols. + * Version 0.2 April, 2017 + * - Decode from a copy of the data so we can start capturing faster thus + * reduce the likelihood of miscaptures. + * Based on Ken Shirriff's IrsendDemo Version 0.1 July, 2009, + */ + #include +#include +#include +#include +#include +#include +#include -// put function declarations here: -int myFunction(int, int); +// ==================== start of TUNEABLE PARAMETERS ==================== +// An IR detector/demodulator is connected to GPIO pin 14 +// e.g. D5 on a NodeMCU board. +// Note: GPIO 16 won't work on the ESP8266 as it does not have interrupts. +// Note: GPIO 14 won't work on the ESP32-C3 as it causes the board to reboot. +#ifdef ARDUINO_ESP32C3_DEV +const uint16_t kRecvPin = 10; // 14 on a ESP32-C3 causes a boot loop. +#else // ARDUINO_ESP32C3_DEV +const uint16_t kRecvPin = 14; +#endif // ARDUINO_ESP32C3_DEV -void setup() { - // put your setup code here, to run once: - int result = myFunction(2, 3); +// The Serial connection baud rate. +// i.e. Status message will be sent to the PC at this baud rate. +// Try to avoid slow speeds like 9600, as you will miss messages and +// cause other problems. 115200 (or faster) is recommended. +// NOTE: Make sure you set your Serial Monitor to the same speed. +const uint32_t kBaudRate = 115200; + +// As this program is a special purpose capture/decoder, let us use a larger +// than normal buffer so we can handle Air Conditioner remote codes. +const uint16_t kCaptureBufferSize = 1024; + +// kTimeout is the Nr. of milli-Seconds of no-more-data before we consider a +// message ended. +// This parameter is an interesting trade-off. The longer the timeout, the more +// complex a message it can capture. e.g. Some device protocols will send +// multiple message packets in quick succession, like Air Conditioner remotes. +// Air Coniditioner protocols often have a considerable gap (20-40+ms) between +// packets. +// The downside of a large timeout value is a lot of less complex protocols +// send multiple messages when the remote's button is held down. The gap between +// them is often also around 20+ms. This can result in the raw data be 2-3+ +// times larger than needed as it has captured 2-3+ messages in a single +// capture. Setting a low timeout value can resolve this. +// So, choosing the best kTimeout value for your use particular case is +// quite nuanced. Good luck and happy hunting. +// NOTE: Don't exceed kMaxTimeoutMs. Typically 130ms. +#if DECODE_AC +// Some A/C units have gaps in their protocols of ~40ms. e.g. Kelvinator +// A value this large may swallow repeats of some protocols +const uint8_t kTimeout = 50; +#else // DECODE_AC +// Suits most messages, while not swallowing many repeats. +const uint8_t kTimeout = 15; +#endif // DECODE_AC +// Alternatives: +// const uint8_t kTimeout = 90; +// Suits messages with big gaps like XMP-1 & some aircon units, but can +// accidentally swallow repeated messages in the rawData[] output. +// +// const uint8_t kTimeout = kMaxTimeoutMs; +// This will set it to our currently allowed maximum. +// Values this high are problematic because it is roughly the typical boundary +// where most messages repeat. +// e.g. It will stop decoding a message and start sending it to serial at +// precisely the time when the next message is likely to be transmitted, +// and may miss it. + +// Set the smallest sized "UNKNOWN" message packets we actually care about. +// This value helps reduce the false-positive detection rate of IR background +// noise as real messages. The chances of background IR noise getting detected +// as a message increases with the length of the kTimeout value. (See above) +// The downside of setting this message too large is you can miss some valid +// short messages for protocols that this library doesn't yet decode. +// +// Set higher if you get lots of random short UNKNOWN messages when nothing +// should be sending a message. +// Set lower if you are sure your setup is working, but it doesn't see messages +// from your device. (e.g. Other IR remotes work.) +// NOTE: Set this value very high to effectively turn off UNKNOWN detection. +const uint16_t kMinUnknownSize = 12; + +// How much percentage lee way do we give to incoming signals in order to match +// it? +// e.g. +/- 25% (default) to an expected value of 500 would mean matching a +// value between 375 & 625 inclusive. +// Note: Default is 25(%). Going to a value >= 50(%) will cause some protocols +// to no longer match correctly. In normal situations you probably do not +// need to adjust this value. Typically that's when the library detects +// your remote's message some of the time, but not all of the time. +const uint8_t kTolerancePercentage = kTolerance; // kTolerance is normally 25% + +// Legacy (No longer supported!) +// +// Change to `true` if you miss/need the old "Raw Timing[]" display. +#define LEGACY_TIMING_INFO false +// ==================== end of TUNEABLE PARAMETERS ==================== + +// Use turn on the save buffer feature for more complete capture coverage. +IRrecv irrecv(kRecvPin, kCaptureBufferSize, kTimeout, true); +decode_results results; // Somewhere to store the results + +// This section of code runs only once at start-up. +void setup() +{ +#if defined(ESP8266) + Serial.begin(kBaudRate, SERIAL_8N1, SERIAL_TX_ONLY); +#else // ESP8266 + Serial.begin(kBaudRate, SERIAL_8N1); +#endif // ESP8266 + while (!Serial) // Wait for the serial connection to be establised. + delay(50); + // Perform a low level sanity checks that the compiler performs bit field + // packing as we expect and Endianness is as we expect. + assert(irutils::lowLevelSanityCheck() == 0); + + Serial.printf("\n" D_STR_IRRECVDUMP_STARTUP "\n", kRecvPin); +#if DECODE_HASH + // Ignore messages with less than minimum on or off pulses. + irrecv.setUnknownThreshold(kMinUnknownSize); +#endif // DECODE_HASH + irrecv.setTolerance(kTolerancePercentage); // Override the default tolerance. + irrecv.enableIRIn(); // Start the receiver } -void loop() { - // put your main code here, to run repeatedly: -} - -// put function definitions here: -int myFunction(int x, int y) { - return x + y; +// The repeating section of the code +void loop() +{ + // Check if the IR code has been received. + if (irrecv.decode(&results)) + { + // Display a crude timestamp. + uint32_t now = millis(); + Serial.printf(D_STR_TIMESTAMP " : %06u.%03u\n", now / 1000, now % 1000); + // Check if we got an IR message that was to big for our capture buffer. + if (results.overflow) + Serial.printf(D_WARN_BUFFERFULL "\n", kCaptureBufferSize); + // Display the library version the message was captured with. + Serial.println(D_STR_LIBRARY " : v" _IRREMOTEESP8266_VERSION_STR "\n"); + // Display the tolerance percentage if it has been change from the default. + if (kTolerancePercentage != kTolerance) + Serial.printf(D_STR_TOLERANCE " : %d%%\n", kTolerancePercentage); + // Display the basic output of what we found. + Serial.print(resultToHumanReadableBasic(&results)); + // Display any extra A/C info if we have it. + String description = IRAcUtils::resultAcToString(&results); + if (description.length()) + Serial.println(D_STR_MESGDESC ": " + description); + yield(); // Feed the WDT as the text output can take a while to print. +#if LEGACY_TIMING_INFO + // Output legacy RAW timing info of the result. + Serial.println(resultToTimingInfo(&results)); + yield(); // Feed the WDT (again) +#endif // LEGACY_TIMING_INFO + // Output the results as source code + Serial.println(resultToSourceCode(&results)); + Serial.println(); // Blank line between entries + yield(); // Feed the WDT (again) + } } \ No newline at end of file