diff --git a/SampleSrc/IRRecv.ino b/SampleSrc/IRRecv.ino new file mode 100644 index 0000000..5abc648 --- /dev/null +++ b/SampleSrc/IRRecv.ino @@ -0,0 +1,182 @@ +/* + * 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 + +// ==================== 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 = 36; // 14 on a ESP32-C3 causes a boot loop. +#else // ARDUINO_ESP32C3_DEV +const uint16_t kRecvPin = 36; +#endif // ARDUINO_ESP32C3_DEV + +// 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 +} + +// 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) + } +} diff --git a/SampleSrc/serial03.ino b/SampleSrc/serial03.ino new file mode 100644 index 0000000..f4cb992 --- /dev/null +++ b/SampleSrc/serial03.ino @@ -0,0 +1,46 @@ +// シリアル入力サンプル src/serial03.ino + +// 使い方 +// 1.このスケッチ（serial03.ino）をM5StickC Plusに書き込む（"./Upload.sh serial03.ino"などを実行） +// 2.Visual Studio Code（以下VSCode）を起動し、M5StickC PlusをPCに接続する +// 3.VSCodeの右下のusbserialをクリックしてシリアルポートを設定する（Windowsなら"COM3"など Macなら"/dev/tty.usbserial-XXXXXXXXXX"など） +// 4.シリアルモニタを起動する（VSCodeの右下コンセント🔌マークを押す） +// 5.キーボードのF1キーを押して"Arduino: Send Text to Serial Port"を選択（キーボードで"Arduino"と入力すると絞り込める） +// 6.送りたい文字を入力してEnterキーを押す +// 7.入力した文字がLCD画面とシリアルモニタに表示されれば成功 + +#include + +int line = 0; // LCD画面から文字が見切れないように文字数が一定以上になったら画面を初期化する処理に使用 +String text; // PCから送られてきたシリアル入力を格納する + +void setup() +{ + M5.begin(); // M5StickCPlusの初期化処理 + M5.Lcd.setRotation(3); // Aボタンが左側になる向きで画面を使用するよう設定 + M5.Lcd.fillScreen(BLACK); // 画面を黒く塗りつぶす + M5.Lcd.setCursor(0, 0, 2); // 左から0,上から0ピクセルの位置にフォントサイズ2の文字を出力するよう設定 + M5.Lcd.println("Serial Input Test"); + M5.Lcd.println("--------------------------------------"); + Serial.begin(115200); // シリアル通信を開始する +} + +void loop() +{ + if(Serial.available()) // シリアルが使用可能なら + { + text = Serial.readString(); // PCから送られてきたシリアル入力を text に格納する + if (line >= 5) // LCD画面から文字が見切れないように文字数が一定以上になったら画面を初期化する + { + M5.Lcd.fillScreen(BLACK); + M5.Lcd.setCursor(0, 0, 2); + M5.Lcd.println("Serial Input Test"); + M5.Lcd.println("--------------------------------------"); + line = 0; + } + M5.Lcd.print("From PC : " + text + "\0"); // \0（ヌル文字）を文字列の最後につけて終端処理をする + Serial.print("Recieved : " + text + "\0"); //送られてきた文字をPCのシリアルモニタにも出力 + line++; + } + delay(1); // delayをloop内につけることで負荷の軽減を図る +}