Kuhnya Changed IP for MQTT. Added JLed

KorMYS/.pio/libdeps/uno/RunningMedian/.arduino-ci.yml

@@ -0,0 +1,7 @@
+compile:
+  # Choosing to run compilation tests on 2 different Arduino platforms
+  platforms:
+    - uno
+    - leonardo
+    - due
+    - zero

KorMYS/.pio/libdeps/uno/RunningMedian/.github/workflows/arduino_test_runner.yml

@@ -0,0 +1,13 @@
+---
+name: Arduino CI
+
+on: [push, pull_request]
+
+jobs:
+  arduino_ci:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: Arduino-CI/action@master
+          #   Arduino-CI/action@v0.1.1

KorMYS/.pio/libdeps/uno/RunningMedian/.piopm

@@ -0,0 +1 @@
+{"type": "library", "name": "RunningMedian", "version": "0.3.3", "spec": {"owner": "robtillaart", "id": 1361, "name": "RunningMedian", "requirements": null, "url": null}}

KorMYS/.pio/libdeps/uno/RunningMedian/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2011-2021 Rob Tillaart
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

KorMYS/.pio/libdeps/uno/RunningMedian/README.md

@@ -0,0 +1,79 @@
+
+[![Arduino CI](https://github.com/RobTillaart/RunningMedian/workflows/Arduino%20CI/badge.svg)](https://github.com/marketplace/actions/arduino_ci)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/RobTillaart/RunningMedian/blob/master/LICENSE)
+[![GitHub release](https://img.shields.io/github/release/RobTillaart/RunningMedian.svg?maxAge=3600)](https://github.com/RobTillaart/RunningMedian/releases)
+
+
+# RunningMedian
+
+Arduino library to determine the running median by means of a circular buffer.
+
+
+## Description
+
+Running Median looks like a running average with a small but important twist.
+Running average averages the last N samples while the running median takes 
+the last N samples, sort them and take the middle one, or the average of the 
+middle two in case the internal buffer size is even.
+
+Important differences between running average and running median:
+- Running median will return real data (e.g. a real sample from a sensor) 
+if one uses an odd size of the buffer (therefor preferred).
+Running average may return a value that is never sampled.
+- Running median will give zero weight to outliers, and 100% to the middle sample, 
+whereas running average gives the same weight to all samples.
+- Running median will give often constant values for some time.
+- As one knows the values in the buffer one can predict the maximum change of 
+the running median in the next steps in advance.
+- Running median is slower as one needs to keep the values in timed order 
+to remove the oldest and keep them sorted to be able to select the median.
+
+
+#### Note MEDIAN_MAX_SIZE
+
+The maximum size of the internal buffer is defined by **MEDIAN_MAX_SIZE** and is 
+set to 255 (since version 0.3.1). The memory allocated currently is in the order
+of 5 bytes per element plus some overhead, so 255 elements take ~1300 bytes.
+For an UNO this is quite a bit.
+
+With larger sizes the performance penalty to keep the internal array sorted 
+is large. For most applications a value much lower e.g. 19 is working well, and 
+is performance wise O(100x) faster in sorting than 255 elements.
+
+
+## Interface
+
+
+### Constructor
+
+- **RunningMedian(const uint8_t size)** Constructor, dynamically allocates memory.
+- **~RunningMedian()** Destructor
+- **uint8_t getSize()** returns size of internal array
+- **uint8_t getCount()** returns current used elements, getCount() <= getSize()
+- **bool isFull()** returns true if the internal buffer is 100% filled.
+
+
+### Base functions
+
+- **clear()** resets internal buffer and variables, effectively emptird thr buffer.
+- **add(const float value) ** adds a new value to internal buffer, optionally replacing the oldest element if the buffer is full
+- **float getMedian()** returns the median == middle element
+- **float getAverage()** returns average of **all** the values in the internal buffer
+- **float getAverage(uint8_t nMedian)** returns average of **the middle n** values. 
+This effectively removes noise from the outliers in the samples.
+- **float getHighest()** get the largest values in the buffer.
+- **float getLowest()** get the smallest value in the buffer.
+- **float getQuantile(const float q)** returns the Quantile value from the buffer. 
+This value is often interpolated.
+
+
+### Less used functions
+
+- **float getElement(const uint8_t n)** returns the n'th element from the values in time order.
+- **float getSortedElement(const uint8_t n)** returns the n'th element from the values in size order (sorted ascending)
+- **float predict(const uint8_t n)** predict the max change of median after n additions, n should be smaller than **getSize()/2**
+
+
+## Operation
+
+See examples

KorMYS/.pio/libdeps/uno/RunningMedian/RunningMedian.cpp

@@ -0,0 +1,205 @@
+//
+//    FILE: RunningMedian.cpp
+//  AUTHOR: Rob Tillaart
+// VERSION: 0.3.3
+// PURPOSE: RunningMedian library for Arduino
+//
+//  HISTORY:
+//  0.1.00  2011-02-16  initial version
+//  0.1.01  2011-02-22  added remarks from CodingBadly
+//  0.1.02  2012-03-15  added
+//  0.1.03  2013-09-30  added _sorted flag, minor refactor
+//  0.1.04  2013-10-17  added getAverage(uint8_t) - kudo's to Sembazuru
+//  0.1.05  2013-10-18  fixed bug in sort; removes default constructor; dynamic memory
+//  0.1.06  2013-10-19  faster sort, dynamic arrays, replaced sorted float array with indirection array
+//  0.1.07  2013-10-19  add correct median if _count is even.
+//  0.1.08  2013-10-20  add getElement(), add getSottedElement() add predict()
+//  0.1.09  2014-11-25  float to double (support ARM)
+//  0.1.10  2015-03-07  fix clear
+//  0.1.11  2015-03-29  undo 0.1.10 fix clear
+//  0.1.12  2015-07-12  refactor constructor + const
+//  0.1.13  2015-10-30  fix getElement(n) - kudos to Gdunge
+//  0.1.14  2017-07-26  revert double to float - issue #33
+//  0.1.15  2018-08-24  make runningMedian Configurable #110
+//  0.2.0   2020-04-16  refactor.
+//  0.2.1   2020-06-19  fix library.json
+//  0.2.2   2021-01-03  add Arduino-CI + unit tests
+//  0.3.0   2021-01-04  malloc memory as default storage
+//  0.3.1   2021-01-16  Changed size parameter to 255 max
+//  0.3.2   2021-01-21  replaced bubbleSort by insertionSort 
+//                      --> better performance for large arrays.
+//  0.3.3   2021-01-22  better insertionSort (+ cleanup test code)
+
+
+#include "RunningMedian.h"
+
+
+RunningMedian::RunningMedian(const uint8_t size)
+{
+  _size = size;
+  if (_size < MEDIAN_MIN_SIZE) _size = MEDIAN_MIN_SIZE;
+  // if (_size > MEDIAN_MAX_SIZE) _size = MEDIAN_MAX_SIZE;
+
+#ifdef RUNNING_MEDIAN_USE_MALLOC
+  _values = (float *) malloc(_size * sizeof(float));
+  _sortIdx  = (uint8_t *) malloc(_size * sizeof(uint8_t));
+#endif
+  clear();
+}
+
+
+RunningMedian::~RunningMedian()
+{
+  #ifdef RUNNING_MEDIAN_USE_MALLOC
+  free(_values);
+  free(_sortIdx);
+  #endif
+}
+
+
+// resets all internal counters
+void RunningMedian::clear()
+{
+  _count = 0;
+  _index = 0;
+  _sorted = false;
+  for (uint8_t i = 0; i < _size; i++)
+  {
+    _sortIdx[i] = i;
+  }
+}
+
+
+// adds a new value to the data-set
+// or overwrites the oldest if full.
+void RunningMedian::add(float value)
+{
+  _values[_index++] = value;
+  if (_index >= _size) _index = 0; // wrap around
+  if (_count < _size) _count++;
+  _sorted = false;
+}
+
+
+float RunningMedian::getMedian()
+{
+  if (_count == 0) return NAN;
+
+  if (_sorted == false) sort();
+
+  if (_count & 0x01)  // is it odd sized?
+  {
+    return _values[_sortIdx[_count / 2]];
+  }
+  return (_values[_sortIdx[_count / 2]] + _values[_sortIdx[_count / 2 - 1]]) / 2;
+}
+
+
+float RunningMedian::getQuantile(float q)
+{
+  if (_count == 0) return NAN;
+  
+  if ((q < 0) || (q > 1)) return NAN;
+
+  if (_sorted == false) sort();
+  
+  const float id = (_count - 1) * q;
+  const uint8_t lo = floor(id);
+  const uint8_t hi = ceil(id);
+  const float qs = _values[_sortIdx[lo]];
+  const float h  = (id - lo);
+
+  return (1.0 - h) * qs + h * _values[_sortIdx[hi]];
+}
+
+
+float RunningMedian::getAverage()
+{
+  if (_count == 0) return NAN;
+
+  float sum = 0;
+  for (uint8_t i = 0; i < _count; i++)
+  {
+    sum += _values[i];
+  }
+  return sum / _count;
+}
+
+
+float RunningMedian::getAverage(uint8_t nMedians)
+{
+  if ((_count == 0) || (nMedians == 0)) return NAN;
+
+  if (_count < nMedians) nMedians = _count;     // when filling the array for first time
+  uint8_t start = ((_count - nMedians) / 2);
+  uint8_t stop = start + nMedians;
+
+  if (_sorted == false) sort();
+
+  float sum = 0;
+  for (uint8_t i = start; i < stop; i++)
+  {
+    sum += _values[_sortIdx[i]];
+  }
+  return sum / nMedians;
+}
+
+
+float RunningMedian::getElement(const uint8_t n)
+{
+  if ((_count == 0) || (n >= _count)) return NAN;
+
+  uint8_t pos = _index + n;
+  if (pos >= _count) // faster than %
+  {
+    pos -= _count;
+  }
+  return _values[pos];
+}
+
+
+float RunningMedian::getSortedElement(const uint8_t n)
+{
+  if ((_count == 0) || (n >= _count)) return NAN;
+
+  if (_sorted == false) sort();
+  return _values[_sortIdx[n]];
+}
+
+
+// n can be max <= half the (filled) size
+float RunningMedian::predict(const uint8_t n)
+{
+  uint8_t mid = _count / 2;
+  if ((_count == 0) || (n >= mid)) return NAN;
+
+  float med = getMedian();  // takes care of sorting !
+  if (_count & 0x01)        // odd # elements
+  {
+    return max(med - _values[_sortIdx[mid - n]], _values[_sortIdx[mid + n]] - med);
+  }
+  // even # elements
+  float f1 = (_values[_sortIdx[mid - n]] + _values[_sortIdx[mid - n - 1]]) / 2;
+  float f2 = (_values[_sortIdx[mid + n]] + _values[_sortIdx[mid + n - 1]]) / 2;
+  return max(med - f1, f2 - med) / 2;
+}
+
+
+void RunningMedian::sort()
+{
+  // insertSort 
+  for (uint16_t i = 1; i < _count; i++)
+  {
+    uint16_t z = i;
+    uint16_t temp = _sortIdx[z];
+    while ((z > 0) && (_values[temp] < _values[_sortIdx[z - 1]]))
+    {
+      _sortIdx[z] = _sortIdx[z - 1];
+      z--;
+    }
+    _sortIdx[z] = temp;
+  }
+  _sorted = true;
+}
+
+// -- END OF FILE --

KorMYS/.pio/libdeps/uno/RunningMedian/RunningMedian.h

@@ -0,0 +1,94 @@
+#pragma once
+//
+//    FILE: RunningMedian.h
+//  AUTHOR: Rob Tillaart
+// PURPOSE: RunningMedian library for Arduino
+// VERSION: 0.3.3
+//     URL: https://github.com/RobTillaart/RunningMedian
+//     URL: http://arduino.cc/playground/Main/RunningMedian
+// HISTORY: See RunningMedian.cpp
+//
+
+
+#include "Arduino.h"
+
+#define RUNNING_MEDIAN_VERSION        (F("0.3.3"))
+
+
+// fall back to fixed storage for dynamic version => remove true
+#define RUNNING_MEDIAN_USE_MALLOC     true
+
+
+// MEDIAN_MIN_SIZE  should at least be 3 to be practical,
+#define MEDIAN_MIN_SIZE               3
+
+
+#ifdef RUNNING_MEDIAN_USE_MALLOC
+// max 250 to not overflow uint8_t internal vars
+#define MEDIAN_MAX_SIZE               255
+#else
+// using fixed memory will be limited to 19 elements.
+#define MEDIAN_MAX_SIZE               19
+#endif
+
+
+class RunningMedian
+{
+public:
+  // # elements in the internal buffer
+  // odd sizes results in a 'real' middle element and will be a bit faster.
+  // even sizes takes the average of the two middle elements as median
+  explicit RunningMedian(const uint8_t size);
+  ~RunningMedian();
+
+  // resets internal buffer and var
+  void    clear();
+  // adds a new value to internal buffer, optionally replacing the oldest element.
+  void    add(const float value);
+  // returns the median == middle element
+  float   getMedian();
+  
+  // returns the Quantile
+  float   getQuantile(const float q);
+
+  // returns average of the values in the internal buffer
+  float   getAverage();
+  // returns average of the middle nMedian values, removes noise from outliers
+  float   getAverage(uint8_t nMedian);
+
+  float   getHighest() { return getSortedElement(_count - 1); };
+  float   getLowest()  { return getSortedElement(0); };
+
+  // get n'th element from the values in time order
+  float   getElement(const uint8_t n);
+  // get n'th element from the values in size order
+  float   getSortedElement(const uint8_t n);
+  // predict the max change of median after n additions
+  float   predict(const uint8_t n);
+
+  uint8_t getSize()    { return _size; };
+  // returns current used elements, getCount() <= getSize()
+  uint8_t getCount()   { return _count; };
+  bool    isFull()     { return (_count == _size); }
+
+
+protected:
+  boolean   _sorted;    // _sortIdx{} is up to date
+  uint8_t   _size;      // max number of values
+  uint8_t   _count;     // current number of values
+  uint8_t   _index;     // next index to add.
+
+
+  // _values holds the elements themself
+  // _p  holds the index for sorted 
+#ifdef RUNNING_MEDIAN_USE_MALLOC
+  float *   _values;
+  uint8_t * _sortIdx;
+#else
+  float   _values[MEDIAN_MAX_SIZE];
+  uint8_t _p[MEDIAN_MAX_SIZE];
+#endif
+  void sort();
+};
+
+// END OF FILE

KorMYS/.pio/libdeps/uno/RunningMedian/examples/RunningMedian/RunningMedian.ino

@@ -0,0 +1,50 @@
+//
+//    FILE: RunningMedian.ino
+//  AUTHOR: Rob Tillaart ( kudos to Sembazuru)
+// VERSION: 0.1.2
+// PURPOSE: demo basic usage
+//    DATE: 2013-10-17
+//     URL: https://github.com/RobTillaart/RunningMedian
+//
+
+#include <RunningMedian.h>
+
+RunningMedian samples = RunningMedian(5);
+
+void setup()
+{
+  Serial.begin(115200);
+  Serial.print("Running Median Version: ");  
+  Serial.println(RUNNING_MEDIAN_VERSION);
+}
+
+void loop()
+{
+  test1();
+}
+
+void test1()
+{
+  int x = analogRead(A0);
+  
+  samples.add(x);
+  long l = samples.getLowest();
+  long m = samples.getMedian();
+  long a = samples.getAverage();
+  long h = samples.getHighest();
+  
+  Serial.print(millis());
+  Serial.print("\t");  
+  Serial.print(x);
+  Serial.print("\t");
+  Serial.print(l);
+  Serial.print("\t");
+  Serial.print(a);
+  Serial.print("\t");
+  Serial.print(m);
+  Serial.print("\t");
+  Serial.println(h);
+  delay(100);
+}
+
+// -- END OF FILE --

KorMYS/.pio/libdeps/uno/RunningMedian/examples/RunningMedian2/RunningMedian2.ino

@@ -0,0 +1,78 @@
+//
+//    FILE: RunningMedian2.ino
+//  AUTHOR: Rob Tillaart ( kudos to Sembazuru)
+// VERSION: 0.1.2
+// PURPOSE: demo most functions
+//    DATE: 2013-10-17
+//     URL: https://github.com/RobTillaart/RunningMedian
+//
+
+#include "RunningMedian.h"
+
+RunningMedian samples = RunningMedian(100);
+
+long count = 0;
+
+void setup()
+{
+  Serial.begin(115200);
+  Serial.print(F("Running Median Version: "));
+  Serial.println(RUNNING_MEDIAN_VERSION);
+}
+
+void loop()
+{
+  test1();
+}
+
+void test1()
+{
+  if (count % 20 == 0) 
+  {
+    Serial.println(F("\nmsec \tAnR \tSize \tCnt \tLow \tAvg \tAvg(7) \tAvg(3) \tMed \tHigh \tPre(1) \tPre(2)"));
+  }
+  count++;
+
+  long x = analogRead(A0);
+
+  samples.add(x);
+
+  float l = samples.getLowest();
+  float m = samples.getMedian();
+  float a = samples.getAverage();
+  float a7 = samples.getAverage(7);
+  float a3 = samples.getAverage(3);
+  float h = samples.getHighest();
+  int s = samples.getSize();
+  int c = samples.getCount();
+  float p1 = samples.predict(1);
+  float p2 = samples.predict(2);
+
+  Serial.print(millis());
+  Serial.print('\t');
+  Serial.print(x);
+  Serial.print('\t');
+  Serial.print(s);
+  Serial.print('\t');
+  Serial.print(c);
+  Serial.print('\t');
+  Serial.print(l);
+  Serial.print('\t');
+  Serial.print(a, 2);
+  Serial.print('\t');
+  Serial.print(a7, 2);
+  Serial.print('\t');
+  Serial.print(a3, 2);
+  Serial.print('\t');
+  Serial.print(m);
+  Serial.print('\t');
+  Serial.print(h);
+  Serial.print('\t');
+  Serial.print(p1, 2);
+  Serial.print('\t');
+  Serial.println(p2, 2);
+
+  delay(100);
+}
+
+

KorMYS/.pio/libdeps/uno/RunningMedian/examples/RunningMedianQuantileTest/RunningMedianQuantileTest.ino

@@ -0,0 +1,40 @@
+//
+//    FILE: RunningMedianQuantileTest.ino
+//  AUTHOR: f-s ( derived from Rob Tillaart )
+// VERSION: 0.1.2
+// PURPOSE: demo basic quantile usage
+//    DATE: 2020-09-02
+//     URL: https://github.com/RobTillaart/RunningMedian
+//
+
+#include <RunningMedian.h>
+
+RunningMedian samples = RunningMedian(5);
+
+void setup()
+{
+  Serial.begin(115200);
+  Serial.print("Running Median Version: ");  
+  Serial.println(RUNNING_MEDIAN_VERSION);
+}
+
+void loop()
+{
+  test1();
+}
+
+void test1()
+{
+  int x = analogRead(A0);
+  
+  samples.add(x);
+  // calculate the 5% quantile => 0.05
+  long q = samples.getQuantile(0.05);
+  
+  Serial.print(millis());
+  Serial.print("\t");  
+  Serial.println(q);
+  delay(100);
+}
+
+// -- END OF FILE --

KorMYS/.pio/libdeps/uno/RunningMedian/examples/RunningMedianTest1/RunningMedianTest1.ino

@@ -0,0 +1,163 @@
+//
+//    FILE: runningMedianTest1.ino
+//  AUTHOR: Rob Tillaart
+// VERSION: 0.1.1
+// PURPOSE: test functionality
+//    DATE: 2013-10-28
+//     URL: https://github.com/RobTillaart/RunningMedian
+//
+
+#include <RunningMedian.h>
+
+const int sourceData[] =
+{ // 50 consecutive samples from Sharp distance sensor model GP2Y0A710K0F while stationary.
+  300, 299, 296, 343, 307, 304, 303, 305, 300, 340,
+  308, 305, 300, 304, 311, 304, 300, 300, 304, 304,
+  284, 319, 306, 304, 300, 302, 305, 310, 306, 304,
+  308, 300, 299, 304, 300, 305, 307, 303, 326, 311,
+  306, 304, 305, 300, 300, 307, 302, 305, 296, 300
+};
+const int sourceSize = (sizeof(sourceData)/sizeof(sourceData[0]));
+
+RunningMedian samples = RunningMedian(sourceSize);
+
+void setup()
+{
+  Serial.begin(115200);
+  while (!Serial); // Wait for serial port to connect. Needed for Leonardo only.
+  delay(1000); // Simply to allow time for the ERW versions of the IDE time to automagically open the Serial Monitor. 1 second chosen arbitrarily.
+  Serial.print(F("Running Median Version: "));
+  Serial.println(RUNNING_MEDIAN_VERSION);
+
+
+#ifdef RUNNING_MEDIAN_USE_MALLOC
+  Serial.println(F("Dynamic version using malloc() enabled"));
+#else
+  Serial.print(F("Static version, will always allocate an array of "));
+  Serial.print(MEDIAN_MAX_SIZE, DEC);
+  Serial.println(F(" floats."));
+#endif
+
+  test1();
+
+  Serial.println("\ndone..\n");
+}
+
+void loop()
+{
+}
+
+void test1()
+{
+  uint32_t start = 0;
+  uint32_t stop = 0;
+  float result = 0;
+
+  Serial.print(F("Requested median array size = "));
+  Serial.println(sourceSize);
+  Serial.print(F("      Actual allocated size = "));
+  Serial.println(samples.getSize());
+  Serial.println();
+
+  // 50 iterations !!
+  for (uint8_t i = 0; i <= (sourceSize - 1); i++)
+  {
+    Serial.print(F("Loop number : "));
+    Serial.println(i + 1);
+
+    start = micros();
+    samples.add(sourceData[i]);
+    stop = micros();
+    Serial.print(F("Time to add the next element to the array = "));
+    Serial.println(stop - start);
+
+
+    Serial.println(F("Cumulative source data added:"));
+    Serial.print(F("    "));
+    for (uint8_t j = 0; j <= i; j++)
+    {
+      Serial.print(sourceData[j]);
+      Serial.print(F(" "));
+    }
+    Serial.println();
+
+
+    Serial.println(F("Unsorted accumulated array:"));
+    Serial.print(F("    "));
+    for (uint8_t j = 0; j < samples.getCount(); j++)
+    {
+      Serial.print(samples.getElement(j));
+      Serial.print(F(" "));
+    }
+    Serial.println();
+
+
+    start = micros();
+    result = samples.getSortedElement(0);
+    stop = micros();
+    Serial.print(F("Time to sort array and return element number zero = "));
+    Serial.println(stop - start);
+
+
+    Serial.println(F("Sorted accumulated array:"));
+    Serial.print(F("    "));
+    for (uint8_t j = 0; j < samples.getCount(); j++)
+    {
+      Serial.print(samples.getSortedElement(j));
+      Serial.print(F(" "));
+    }
+    Serial.println();
+
+
+    start = micros();
+    result = samples.getMedian();
+    stop = micros();
+    Serial.print(F("getMedian() result = "));
+    Serial.println(result);
+    Serial.print(F("Time to execute getMedian() = "));
+    Serial.println(stop - start);
+
+
+    start = micros();
+    result = samples.getAverage();
+    stop = micros();
+    Serial.print(F("getAverage() result = "));
+    Serial.println(result);
+    Serial.print(F("Time to execute getAverage() = "));
+    Serial.println(stop - start);
+
+
+    Serial.println(F("getAverage(x) results where:"));
+    for (uint8_t j = 1; j <= samples.getCount(); j++)
+    {
+      start = micros();
+      result = samples.getAverage(j);
+      stop = micros();
+      Serial.print(F("  x = "));
+      Serial.print(j);
+      Serial.print(F(" => "));
+      Serial.print(result);
+      Serial.print(F(" Time to execute = "));
+      Serial.println(stop - start);
+    }
+
+    Serial.println(F("predict(x) results where:"));
+    for (uint8_t j = 1; j <= (samples.getCount() / 2); j++)
+    {
+      start = micros();
+      result = samples.predict(j);
+      stop = micros();
+      Serial.print(F("  x = "));
+      Serial.print(j);
+      Serial.print(F(" => "));
+      Serial.print(result);
+      Serial.print(F(" Time to execute = "));
+      Serial.println(stop - start);
+    }
+
+    Serial.println();
+    Serial.println();
+  }
+}
+
+// -- END OF FILE -- 

KorMYS/.pio/libdeps/uno/RunningMedian/examples/RunningMedian_large/RunningMedian_large.ino

@@ -0,0 +1,66 @@
+//
+//    FILE: RunningMedian_large.ino
+//  AUTHOR: Rob Tillaart
+// VERSION: 0.1.3
+// PURPOSE: demo most functions
+//    DATE: 2013-10-17
+//     URL: https://github.com/RobTillaart/RunningMedian
+//
+
+#include "RunningMedian.h"
+
+
+RunningMedian samples = RunningMedian(255);
+
+
+long count = 0;
+
+uint32_t start, dur1, dur2, dur3;
+
+
+void setup()
+{
+  Serial.begin(115200);
+  Serial.print(F("Running Median Version: "));
+  Serial.println(RUNNING_MEDIAN_VERSION);
+
+  Serial.println(samples.getSize());
+}
+
+
+void loop()
+{
+  if (count < 255)
+  {
+    start = micros();
+    samples.add(256 - count);
+    dur1 = micros() - start;
+    start = micros();
+    count = samples.getCount();
+    dur2 = micros() - start;
+    start = micros();
+    float value = samples.getMedian();
+    dur3 = micros() - start;
+
+    Serial.print(count);
+    Serial.print('\t');
+    Serial.print(dur1);
+    Serial.print('\t');
+    Serial.print(dur2);
+    Serial.print('\t');
+    Serial.print(dur3);
+    Serial.print('\t');
+    Serial.println();
+  }
+
+  if (count == 255)
+  {
+    for (int i = 0; i < 255; i++)
+    {
+      Serial.println(samples.getSortedElement(i));
+    }
+  }
+  count++;
+}
+
+// -- END OF FILE --

KorMYS/.pio/libdeps/uno/RunningMedian/keywords.txt

@@ -0,0 +1,23 @@
+# Syntax Coloring Map for RunningMedian
+
+# Datatypes (KEYWORD1)
+RunningMedian	KEYWORD1
+
+# Methods and Functions (KEYWORD2)
+add	KEYWORD2
+clear	KEYWORD2
+getMedian	KEYWORD2
+getQuantile KEYWORD2
+getAverage	KEYWORD2
+getHighest	KEYWORD2
+getLowest	KEYWORD2
+getSize	KEYWORD2
+getCount	KEYWORD2
+getElement	KEYWORD2
+getSortedElement	KEYWORD2
+predict	KEYWORD2
+getStatus	KEYWORD2
+
+# Constants (LITERAL1)
+OK	LITERAL1
+NOK	LITERAL1

KorMYS/.pio/libdeps/uno/RunningMedian/library.json

@@ -0,0 +1,21 @@
+{
+  "name": "RunningMedian",
+  "keywords": "running, moving, median, average, outliers",
+  "description": "The library stores the last N individual values in a buffer to select the median. It filters outliers.",
+  "authors":
+  [
+    {
+      "name": "Rob Tillaart",
+      "email": "Rob.Tillaart@gmail.com",
+      "maintainer": true
+    }
+  ],
+  "repository":
+  {
+    "type": "git",
+    "url": "https://github.com/RobTillaart/RunningMedian.git"
+  },
+  "version":"0.3.3",
+  "frameworks": "arduino",
+  "platforms": "*"
+}

KorMYS/.pio/libdeps/uno/RunningMedian/library.properties

@@ -0,0 +1,11 @@
+name=RunningMedian
+version=0.3.3
+author=Rob Tillaart <rob.tillaart@gmail.com>
+maintainer=Rob Tillaart <rob.tillaart@gmail.com>
+sentence=The library stores the last N individual values in a buffer to select the median.
+paragraph=This will filter outliers in a chain of samples very well.
+category=Data Processing
+url=https://github.com/RobTillaart/RunningMedian
+architectures=*
+includes=RunningMedian.h
+depends=

KorMYS/.pio/libdeps/uno/RunningMedian/test/unit_test_001.cpp

@@ -0,0 +1,123 @@
+//
+//    FILE: unit_test_001.cpp
+//  AUTHOR: Rob Tillaart
+//    DATE: 2021-01-03
+// PURPOSE: unit tests for the RunningMedian
+//          https://github.com/RobTillaart/RunningMedian
+//          https://github.com/Arduino-CI/arduino_ci/blob/master/REFERENCE.md
+//
+
+// supported assertions
+// ----------------------------
+// assertEqual(expected, actual);               // a == b
+// assertNotEqual(unwanted, actual);            // a != b
+// assertComparativeEquivalent(expected, actual);    // abs(a - b) == 0 or (!(a > b) && !(a < b))
+// assertComparativeNotEquivalent(unwanted, actual); // abs(a - b) > 0  or ((a > b) || (a < b))
+// assertLess(upperBound, actual);              // a < b
+// assertMore(lowerBound, actual);              // a > b
+// assertLessOrEqual(upperBound, actual);       // a <= b
+// assertMoreOrEqual(lowerBound, actual);       // a >= b
+// assertTrue(actual);
+// assertFalse(actual);
+// assertNull(actual);
+
+// // special cases for floats
+// assertEqualFloat(expected, actual, epsilon);    // fabs(a - b) <= epsilon
+// assertNotEqualFloat(unwanted, actual, epsilon); // fabs(a - b) >= epsilon
+// assertInfinity(actual);                         // isinf(a)
+// assertNotInfinity(actual);                      // !isinf(a)
+// assertNAN(arg);                                 // isnan(a)
+// assertNotNAN(arg);                              // !isnan(a)
+
+#include <ArduinoUnitTests.h>
+
+
+#include "Arduino.h"
+#include "RunningMedian.h"
+
+
+
+unittest_setup()
+{
+}
+
+unittest_teardown()
+{
+}
+
+
+unittest(test_constructor)
+{
+  fprintf(stderr, "VERSION: %s\n", RUNNING_MEDIAN_VERSION);
+
+  RunningMedian samples = RunningMedian(5);
+  assertEqual(5, samples.getSize());
+  assertEqual(0, samples.getCount());
+
+  // TODO default values?
+}
+
+
+unittest(test_basic_add)
+{
+  fprintf(stderr, "VERSION: %s\n", RUNNING_MEDIAN_VERSION);
+
+  RunningMedian samples = RunningMedian(5);
+
+  int cnt = 0;
+  for (int i = 0, cnt = 0; i < 50; i+=10)
+  {
+    samples.add(i);
+    cnt++;
+    assertEqual(cnt, samples.getCount());
+  }
+  assertEqual(5, samples.getSize());
+  assertEqualFloat(20, samples.getMedian(), 0.0001);
+  assertEqualFloat(20, samples.getAverage(), 0.0001);
+  assertEqualFloat(00, samples.getLowest(), 0.0001);
+  assertEqualFloat(40, samples.getHighest(), 0.0001);
+  
+  samples.add(100);  // 6th element
+  assertEqual(5, samples.getSize());
+  assertEqual(5, samples.getCount());
+
+  assertEqualFloat(30, samples.getMedian(), 0.0001);
+  assertEqualFloat(40, samples.getAverage(), 0.0001);
+  assertEqualFloat(10, samples.getLowest(), 0.0001);
+  assertEqualFloat(100, samples.getHighest(), 0.0001);
+  
+  samples.clear();
+  assertEqual(5, samples.getSize());
+  assertEqual(0, samples.getCount());
+}
+
+
+unittest(test_big)
+{
+  fprintf(stderr, "VERSION: %s\n", RUNNING_MEDIAN_VERSION);
+
+  RunningMedian samples = RunningMedian(100);
+  assertEqual(100, samples.getSize());
+  assertEqual(0, samples.getCount());
+
+  for (int i = 0; i < 110; i++)
+  {
+    samples.add(i);
+  }
+  assertEqual(100, samples.getSize());
+  assertEqual(100, samples.getCount());
+
+  assertEqualFloat(59.5, samples.getMedian(), 0.0001);
+  assertEqualFloat(59.5, samples.getAverage(), 0.0001);
+  assertEqualFloat(10, samples.getLowest(), 0.0001);
+  assertEqualFloat(109, samples.getHighest(), 0.0001);
+
+  samples.clear();
+  assertEqual(100, samples.getSize());
+  assertEqual(0, samples.getCount());
+}
+
+
+unittest_main()
+
+// --------

KorMYS/.pio/libdeps/uno/SoftwareSerial/.piopm

@@ -0,0 +1 @@
+{"type": "library", "name": "SoftwareSerial", "version": "1.0.0", "spec": {"owner": "featherfly", "id": 7212, "name": "SoftwareSerial", "requirements": null, "url": null}}

KorMYS/.pio/libdeps/uno/SoftwareSerial/SoftwareSerial.cpp

@@ -0,0 +1,677 @@
+/*
+SoftwareSerial.cpp (formerly NewSoftSerial.cpp) - 
+Multi-instance software serial library for Arduino/Wiring
+-- Interrupt-driven receive and other improvements by ladyada
+   (http://ladyada.net)
+-- Tuning, circular buffer, derivation from class Print/Stream,
+   multi-instance support, porting to 8MHz processors,
+   various optimizations, PROGMEM delay tables, inverse logic and 
+   direct port writing by Mikal Hart (http://www.arduiniana.org)
+-- Pin change interrupt macros by Paul Stoffregen (http://www.pjrc.com)
+-- 20MHz processor support by Garrett Mace (http://www.macetech.com)
+-- ATmega1280/2560 support by Brett Hagman (http://www.roguerobotics.com/)
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+The latest version of this library can always be found at
+http://arduiniana.org.
+*/
+
+// When set, _DEBUG co-opts pins 11 and 13 for debugging with an
+// oscilloscope or logic analyzer.  Beware: it also slightly modifies
+// the bit times, so don't rely on it too much at high baud rates
+#define _DEBUG 0
+#define _DEBUG_PIN1 11
+#define _DEBUG_PIN2 13
+// 
+// Includes
+// 
+#include <avr/interrupt.h>
+#include <avr/pgmspace.h>
+#include <Arduino.h>
+#include <SoftwareSerial.h>
+
+
+#if defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MKL26Z64__) || defined(__MK64FX512__) || defined(__MK66FX1M0__) || defined(__IMXRT1052__) || defined(__IMXRT1062__)
+
+SoftwareSerial::SoftwareSerial(uint8_t rxPin, uint8_t txPin, bool inverse_logic /* = false */)
+{
+	buffer_overflow = false;
+	#if defined(__IMXRT1052__) || defined(__IMXRT1062__)
+	if (rxPin == 0 && txPin == 1) {
+		port = &Serial1;
+		return;
+	} else if (rxPin == 6 && txPin == 7) {
+		port = &Serial2;
+		return;
+	} else if (rxPin == 14 && txPin == 15) {
+		port = &Serial3;
+		return;
+	} else if (rxPin == 16 && txPin == 17) {
+		port = &Serial4;
+		return;
+	} else if (rxPin == 21 && txPin == 20) {
+		port = &Serial5;
+		return;
+	} else if (rxPin == 25 && txPin == 24) {
+		port = &Serial6;
+		return;
+	} else if (rxPin == 28 && txPin == 29) {
+		port = &Serial7;
+		return;
+	}	
+	#else
+	if (rxPin == 0 && txPin == 1) {
+		port = &Serial1;
+		return;
+	} else if (rxPin == 9 && txPin == 10) {
+		port = &Serial2;
+		return;
+	} else if (rxPin == 7 && txPin == 8) {
+		port = &Serial3;
+		return;
+	}
+	#endif
+	port = NULL;
+	pinMode(txPin, OUTPUT);
+	pinMode(rxPin, INPUT_PULLUP);
+	txpin = txPin;
+	rxpin = rxPin;
+	txreg = portOutputRegister(digitalPinToPort(txPin));
+	rxreg = portInputRegister(digitalPinToPort(rxPin));
+	cycles_per_bit = 0;
+}
+
+void SoftwareSerial::begin(unsigned long speed)
+{
+	if (port) {
+		port->begin(speed);
+	} else {
+		cycles_per_bit = (uint32_t)(F_CPU + speed / 2) / speed;
+		ARM_DEMCR |= ARM_DEMCR_TRCENA;
+		ARM_DWT_CTRL |= ARM_DWT_CTRL_CYCCNTENA;
+	}
+}
+
+void SoftwareSerial::end()
+{
+	if (port) {
+		port->end();
+		port = NULL;
+	} else {
+		pinMode(txpin, INPUT);
+		pinMode(rxpin, INPUT);
+	}
+	cycles_per_bit = 0;
+}
+
+// The worst case expected length of any interrupt routines.  If an
+// interrupt runs longer than this number of cycles, it can disrupt
+// the transmit waveform.  Increasing this number causes SoftwareSerial
+// to hog the CPU longer, delaying all interrupt response for other
+// libraries, so this should be made as small as possible but still
+// ensure accurate transmit waveforms.
+#define WORST_INTERRUPT_CYCLES 360
+
+static void wait_for_target(uint32_t begin, uint32_t target)
+{
+	if (target - (ARM_DWT_CYCCNT - begin) > WORST_INTERRUPT_CYCLES+20) {
+		uint32_t pretarget = target - WORST_INTERRUPT_CYCLES;
+		//digitalWriteFast(12, HIGH);
+		interrupts();
+		while (ARM_DWT_CYCCNT - begin < pretarget) ; // wait
+		noInterrupts();
+		//digitalWriteFast(12, LOW);
+	}
+	while (ARM_DWT_CYCCNT - begin < target) ; // wait
+}
+
+size_t SoftwareSerial::write(uint8_t b)
+{
+	elapsedMicros elapsed;
+	uint32_t target;
+	uint8_t mask;
+	uint32_t begin_cycle;
+
+	// use hardware serial, if possible
+	if (port) return port->write(b);
+	if (cycles_per_bit == 0) return 0;
+	ARM_DEMCR |= ARM_DEMCR_TRCENA;
+	ARM_DWT_CTRL |= ARM_DWT_CTRL_CYCCNTENA;
+	// start bit
+	target = cycles_per_bit;
+	noInterrupts();
+	begin_cycle = ARM_DWT_CYCCNT;
+	*txreg = 0;
+	wait_for_target(begin_cycle, target);
+	// 8 data bits
+	for (mask = 1; mask; mask <<= 1) {
+		*txreg = (b & mask) ? 1 : 0;
+		target += cycles_per_bit;
+		wait_for_target(begin_cycle, target);
+	}
+	// stop bit
+	*txreg = 1;
+	interrupts();
+	target += cycles_per_bit;
+	while (ARM_DWT_CYCCNT - begin_cycle < target) ; // wait
+	return 1;
+}
+
+void SoftwareSerial::flush()
+{
+	if (port) port->flush();
+}
+
+// TODO implement reception using pin change DMA capturing
+// ARM_DWT_CYCCNT and the bitband mapped GPIO_PDIR register
+// to a circular buffer (8 bytes per event... memory intensive)
+
+int SoftwareSerial::available()
+{
+	if (port) return port->available();
+	return 0;
+}
+
+int SoftwareSerial::peek()
+{
+	if (port) return port->peek();
+	return -1;
+}
+
+int SoftwareSerial::read()
+{
+	if (port) return port->read();
+	return -1;
+}
+
+#else
+
+//
+// Lookup table
+//
+typedef struct _DELAY_TABLE
+{
+  long baud;
+  unsigned short rx_delay_centering;
+  unsigned short rx_delay_intrabit;
+  unsigned short rx_delay_stopbit;
+  unsigned short tx_delay;
+} DELAY_TABLE;
+
+#if F_CPU == 16000000
+
+static const DELAY_TABLE PROGMEM table[] = 
+{
+  //  baud    rxcenter   rxintra    rxstop    tx
+  { 115200,   1,         17,        17,       12,    },
+  { 57600,    10,        37,        37,       33,    },
+  { 38400,    25,        57,        57,       54,    },
+  { 31250,    31,        70,        70,       68,    },
+  { 28800,    34,        77,        77,       74,    },
+  { 19200,    54,        117,       117,      114,   },
+  { 14400,    74,        156,       156,      153,   },
+  { 9600,     114,       236,       236,      233,   },
+  { 4800,     233,       474,       474,      471,   },
+  { 2400,     471,       950,       950,      947,   },
+  { 1200,     947,       1902,      1902,     1899,  },
+  { 600,      1902,      3804,      3804,     3800,  },
+  { 300,      3804,      7617,      7617,     7614,  },
+};
+
+const int XMIT_START_ADJUSTMENT = 5;
+
+#elif F_CPU == 8000000
+
+static const DELAY_TABLE table[] PROGMEM = 
+{
+  //  baud    rxcenter    rxintra    rxstop  tx
+  { 115200,   1,          5,         5,      3,      },
+  { 57600,    1,          15,        15,     13,     },
+  { 38400,    2,          25,        26,     23,     },
+  { 31250,    7,          32,        33,     29,     },
+  { 28800,    11,         35,        35,     32,     },
+  { 19200,    20,         55,        55,     52,     },
+  { 14400,    30,         75,        75,     72,     },
+  { 9600,     50,         114,       114,    112,    },
+  { 4800,     110,        233,       233,    230,    },
+  { 2400,     229,        472,       472,    469,    },
+  { 1200,     467,        948,       948,    945,    },
+  { 600,      948,        1895,      1895,   1890,   },
+  { 300,      1895,       3805,      3805,   3802,   },
+};
+
+const int XMIT_START_ADJUSTMENT = 4;
+
+#elif F_CPU == 20000000
+
+// 20MHz support courtesy of the good people at macegr.com.
+// Thanks, Garrett!
+
+static const DELAY_TABLE PROGMEM table[] =
+{
+  //  baud    rxcenter    rxintra    rxstop  tx
+  { 115200,   3,          21,        21,     18,     },
+  { 57600,    20,         43,        43,     41,     },
+  { 38400,    37,         73,        73,     70,     },
+  { 31250,    45,         89,        89,     88,     },
+  { 28800,    46,         98,        98,     95,     },
+  { 19200,    71,         148,       148,    145,    },
+  { 14400,    96,         197,       197,    194,    },
+  { 9600,     146,        297,       297,    294,    },
+  { 4800,     296,        595,       595,    592,    },
+  { 2400,     592,        1189,      1189,   1186,   },
+  { 1200,     1187,       2379,      2379,   2376,   },
+  { 600,      2379,       4759,      4759,   4755,   },
+  { 300,      4759,       9523,      9523,   9520,   },
+};
+
+const int XMIT_START_ADJUSTMENT = 6;
+
+#else
+
+#error This version of SoftwareSerial supports only 20, 16 and 8MHz processors
+
+#endif
+
+//
+// Statics
+//
+SoftwareSerial *SoftwareSerial::active_object = 0;
+char SoftwareSerial::_receive_buffer[_SS_MAX_RX_BUFF]; 
+volatile uint8_t SoftwareSerial::_receive_buffer_tail = 0;
+volatile uint8_t SoftwareSerial::_receive_buffer_head = 0;
+
+//
+// Debugging
+//
+// This function generates a brief pulse
+// for debugging or measuring on an oscilloscope.
+inline void DebugPulse(uint8_t pin, uint8_t count)
+{
+#if _DEBUG
+  volatile uint8_t *pport = portOutputRegister(digitalPinToPort(pin));
+
+  uint8_t val = *pport;
+  while (count--)
+  {
+    *pport = val | digitalPinToBitMask(pin);
+    *pport = val;
+  }
+#endif
+}
+
+//
+// Private methods
+//
+
+/* static */ 
+inline void SoftwareSerial::tunedDelay(uint16_t delay) { 
+  uint8_t tmp=0;
+
+  asm volatile("sbiw    %0, 0x01 \n\t"
+    "ldi %1, 0xFF \n\t"
+    "cpi %A0, 0xFF \n\t"
+    "cpc %B0, %1 \n\t"
+    "brne .-10 \n\t"
+    : "+r" (delay), "+a" (tmp)
+    : "0" (delay)
+    );
+}
+
+// This function sets the current object as the "listening"
+// one and returns true if it replaces another 
+bool SoftwareSerial::listen()
+{
+  if (active_object != this)
+  {
+    _buffer_overflow = false;
+    uint8_t oldSREG = SREG;
+    cli();
+    _receive_buffer_head = _receive_buffer_tail = 0;
+    active_object = this;
+    SREG = oldSREG;
+    return true;
+  }
+
+  return false;
+}
+
+//
+// The receive routine called by the interrupt handler
+//
+void SoftwareSerial::recv()
+{
+
+#if GCC_VERSION < 40302
+// Work-around for avr-gcc 4.3.0 OSX version bug
+// Preserve the registers that the compiler misses
+// (courtesy of Arduino forum user *etracer*)
+  asm volatile(
+    "push r18 \n\t"
+    "push r19 \n\t"
+    "push r20 \n\t"
+    "push r21 \n\t"
+    "push r22 \n\t"
+    "push r23 \n\t"
+    "push r26 \n\t"
+    "push r27 \n\t"
+    ::);
+#endif  
+
+  uint8_t d = 0;
+
+  // If RX line is high, then we don't see any start bit
+  // so interrupt is probably not for us
+  if (_inverse_logic ? rx_pin_read() : !rx_pin_read())
+  {
+    // Wait approximately 1/2 of a bit width to "center" the sample
+    tunedDelay(_rx_delay_centering);
+    DebugPulse(_DEBUG_PIN2, 1);
+
+    // Read each of the 8 bits
+    for (uint8_t i=0x1; i; i <<= 1)
+    {
+      tunedDelay(_rx_delay_intrabit);
+      DebugPulse(_DEBUG_PIN2, 1);
+      uint8_t noti = ~i;
+      if (rx_pin_read())
+        d |= i;
+      else // else clause added to ensure function timing is ~balanced
+        d &= noti;
+    }
+
+    // skip the stop bit
+    tunedDelay(_rx_delay_stopbit);
+    DebugPulse(_DEBUG_PIN2, 1);
+
+    if (_inverse_logic)
+      d = ~d;
+
+    // if buffer full, set the overflow flag and return
+    if ((_receive_buffer_tail + 1) % _SS_MAX_RX_BUFF != _receive_buffer_head) 
+    {
+      // save new data in buffer: tail points to where byte goes
+      _receive_buffer[_receive_buffer_tail] = d; // save new byte
+      _receive_buffer_tail = (_receive_buffer_tail + 1) % _SS_MAX_RX_BUFF;
+    } 
+    else 
+    {
+#if _DEBUG // for scope: pulse pin as overflow indictator
+      DebugPulse(_DEBUG_PIN1, 1);
+#endif
+      _buffer_overflow = true;
+    }
+  }
+
+#if GCC_VERSION < 40302
+// Work-around for avr-gcc 4.3.0 OSX version bug
+// Restore the registers that the compiler misses
+  asm volatile(
+    "pop r27 \n\t"
+    "pop r26 \n\t"
+    "pop r23 \n\t"
+    "pop r22 \n\t"
+    "pop r21 \n\t"
+    "pop r20 \n\t"
+    "pop r19 \n\t"
+    "pop r18 \n\t"
+    ::);
+#endif
+}
+
+void SoftwareSerial::tx_pin_write(uint8_t pin_state)
+{
+  if (pin_state == LOW)
+    *_transmitPortRegister &= ~_transmitBitMask;
+  else
+    *_transmitPortRegister |= _transmitBitMask;
+}
+
+uint8_t SoftwareSerial::rx_pin_read()
+{
+  return *_receivePortRegister & _receiveBitMask;
+}
+
+//
+// Interrupt handling
+//
+
+/* static */
+inline void SoftwareSerial::handle_interrupt()
+{
+  if (active_object)
+  {
+    active_object->recv();
+  }
+}
+
+#if defined(PCINT0_vect)
+ISR(PCINT0_vect)
+{
+  SoftwareSerial::handle_interrupt();
+}
+#endif
+
+#if defined(PCINT1_vect)
+ISR(PCINT1_vect)
+{
+  SoftwareSerial::handle_interrupt();
+}
+#endif
+
+#if defined(PCINT2_vect)
+ISR(PCINT2_vect)
+{
+  SoftwareSerial::handle_interrupt();
+}
+#endif
+
+#if defined(PCINT3_vect)
+ISR(PCINT3_vect)
+{
+  SoftwareSerial::handle_interrupt();
+}
+#endif
+
+//
+// Constructor
+//
+SoftwareSerial::SoftwareSerial(uint8_t receivePin, uint8_t transmitPin, bool inverse_logic /* = false */) : 
+  _rx_delay_centering(0),
+  _rx_delay_intrabit(0),
+  _rx_delay_stopbit(0),
+  _tx_delay(0),
+  _buffer_overflow(false),
+  _inverse_logic(inverse_logic)
+{
+  setTX(transmitPin);
+  setRX(receivePin);
+}
+
+//
+// Destructor
+//
+SoftwareSerial::~SoftwareSerial()
+{
+  end();
+}
+
+void SoftwareSerial::setTX(uint8_t tx)
+{
+  pinMode(tx, OUTPUT);
+  digitalWrite(tx, HIGH);
+  _transmitBitMask = digitalPinToBitMask(tx);
+  uint8_t port = digitalPinToPort(tx);
+  _transmitPortRegister = portOutputRegister(port);
+}
+
+void SoftwareSerial::setRX(uint8_t rx)
+{
+  pinMode(rx, INPUT);
+  if (!_inverse_logic)
+    digitalWrite(rx, HIGH);  // pullup for normal logic!
+  _receivePin = rx;
+  _receiveBitMask = digitalPinToBitMask(rx);
+  uint8_t port = digitalPinToPort(rx);
+  _receivePortRegister = portInputRegister(port);
+}
+
+//
+// Public methods
+//
+
+void SoftwareSerial::begin(long speed)
+{
+  _rx_delay_centering = _rx_delay_intrabit = _rx_delay_stopbit = _tx_delay = 0;
+
+  for (unsigned i=0; i<sizeof(table)/sizeof(table[0]); ++i)
+  {
+    long baud = pgm_read_dword(&table[i].baud);
+    if (baud == speed)
+    {
+      _rx_delay_centering = pgm_read_word(&table[i].rx_delay_centering);
+      _rx_delay_intrabit = pgm_read_word(&table[i].rx_delay_intrabit);
+      _rx_delay_stopbit = pgm_read_word(&table[i].rx_delay_stopbit);
+      _tx_delay = pgm_read_word(&table[i].tx_delay);
+      break;
+    }
+  }
+
+  // Set up RX interrupts, but only if we have a valid RX baud rate
+  if (_rx_delay_stopbit)
+  {
+    if (digitalPinToPCICR(_receivePin))
+    {
+      *digitalPinToPCICR(_receivePin) |= _BV(digitalPinToPCICRbit(_receivePin));
+      *digitalPinToPCMSK(_receivePin) |= _BV(digitalPinToPCMSKbit(_receivePin));
+    }
+    tunedDelay(_tx_delay); // if we were low this establishes the end
+  }
+
+#if _DEBUG
+  pinMode(_DEBUG_PIN1, OUTPUT);
+  pinMode(_DEBUG_PIN2, OUTPUT);
+#endif
+
+  listen();
+}
+
+void SoftwareSerial::end()
+{
+  if (digitalPinToPCMSK(_receivePin))
+    *digitalPinToPCMSK(_receivePin) &= ~_BV(digitalPinToPCMSKbit(_receivePin));
+}
+
+
+// Read data from buffer
+int SoftwareSerial::read()
+{
+  if (!isListening())
+    return -1;
+
+  // Empty buffer?
+  if (_receive_buffer_head == _receive_buffer_tail)
+    return -1;
+
+  // Read from "head"
+  uint8_t d = _receive_buffer[_receive_buffer_head]; // grab next byte
+  _receive_buffer_head = (_receive_buffer_head + 1) % _SS_MAX_RX_BUFF;
+  return d;
+}
+
+int SoftwareSerial::available()
+{
+  if (!isListening())
+    return 0;
+
+  return (_receive_buffer_tail + _SS_MAX_RX_BUFF - _receive_buffer_head) % _SS_MAX_RX_BUFF;
+}
+
+size_t SoftwareSerial::write(uint8_t b)
+{
+  if (_tx_delay == 0) {
+    setWriteError();
+    return 0;
+  }
+
+  uint8_t oldSREG = SREG;
+  cli();  // turn off interrupts for a clean txmit
+
+  // Write the start bit
+  tx_pin_write(_inverse_logic ? HIGH : LOW);
+  tunedDelay(_tx_delay + XMIT_START_ADJUSTMENT);
+
+  // Write each of the 8 bits
+  if (_inverse_logic)
+  {
+    for (byte mask = 0x01; mask; mask <<= 1)
+    {
+      if (b & mask) // choose bit
+        tx_pin_write(LOW); // send 1
+      else
+        tx_pin_write(HIGH); // send 0
+    
+      tunedDelay(_tx_delay);
+    }
+
+    tx_pin_write(LOW); // restore pin to natural state
+  }
+  else
+  {
+    for (byte mask = 0x01; mask; mask <<= 1)
+    {
+      if (b & mask) // choose bit
+        tx_pin_write(HIGH); // send 1
+      else
+        tx_pin_write(LOW); // send 0
+    
+      tunedDelay(_tx_delay);
+    }
+
+    tx_pin_write(HIGH); // restore pin to natural state
+  }
+
+  SREG = oldSREG; // turn interrupts back on
+  tunedDelay(_tx_delay);
+  
+  return 1;
+}
+
+void SoftwareSerial::flush()
+{
+  if (!isListening())
+    return;
+
+  uint8_t oldSREG = SREG;
+  cli();
+  _receive_buffer_head = _receive_buffer_tail = 0;
+  SREG = oldSREG;
+}
+
+int SoftwareSerial::peek()
+{
+  if (!isListening())
+    return -1;
+
+  // Empty buffer?
+  if (_receive_buffer_head == _receive_buffer_tail)
+    return -1;
+
+  // Read from "head"
+  return _receive_buffer[_receive_buffer_head];
+}
+
+#endif

KorMYS/.pio/libdeps/uno/SoftwareSerial/SoftwareSerial.h

@@ -0,0 +1,150 @@
+/*
+SoftwareSerial.h (formerly NewSoftSerial.h) - 
+Multi-instance software serial library for Arduino/Wiring
+-- Interrupt-driven receive and other improvements by ladyada
+   (http://ladyada.net)
+-- Tuning, circular buffer, derivation from class Print/Stream,
+   multi-instance support, porting to 8MHz processors,
+   various optimizations, PROGMEM delay tables, inverse logic and 
+   direct port writing by Mikal Hart (http://www.arduiniana.org)
+-- Pin change interrupt macros by Paul Stoffregen (http://www.pjrc.com)
+-- 20MHz processor support by Garrett Mace (http://www.macetech.com)
+-- ATmega1280/2560 support by Brett Hagman (http://www.roguerobotics.com/)
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+The latest version of this library can always be found at
+http://arduiniana.org.
+*/
+
+#ifndef SoftwareSerial_h
+#define SoftwareSerial_h
+
+#include <inttypes.h>
+#include <Stream.h>
+#include <HardwareSerial.h>
+
+/******************************************************************************
+* Definitions
+******************************************************************************/
+
+#define _SS_MAX_RX_BUFF 64 // RX buffer size
+#ifndef GCC_VERSION
+#define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
+#endif
+
+#if defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MKL26Z64__) || defined(__MK64FX512__) || defined(__MK66FX1M0__) || defined(__IMXRT1052__) || defined(__IMXRT1062__)
+
+class SoftwareSerial : public Stream
+{
+public:
+	SoftwareSerial(uint8_t rxPin, uint8_t txPin, bool inverse_logic = false);
+	~SoftwareSerial() { end(); }
+	void begin(unsigned long speed);
+	void end();
+	bool listen() { return true; }
+	bool isListening() { return true; }
+	bool overflow() { bool ret = buffer_overflow; buffer_overflow = false; return ret; }
+	virtual int available();
+	virtual int read();
+	int peek();
+	virtual void flush();
+	virtual size_t write(uint8_t byte);
+	using Print::write;
+private:
+	HardwareSerial *port;
+	uint32_t cycles_per_bit;
+	#if defined(__IMXRT1052__) || defined(__IMXRT1062__)
+	volatile uint32_t *txreg;
+	volatile uint32_t *rxreg;
+	#else
+	volatile uint8_t *txreg;
+	volatile uint8_t *rxreg;
+	#endif
+	bool buffer_overflow;
+	uint8_t txpin;
+	uint8_t rxpin;
+};
+
+#else
+class SoftwareSerial : public Stream
+{
+private:
+  // per object data
+  uint8_t _receivePin;
+  uint8_t _receiveBitMask;
+  volatile uint8_t *_receivePortRegister;
+  uint8_t _transmitBitMask;
+  volatile uint8_t *_transmitPortRegister;
+
+  uint16_t _rx_delay_centering;
+  uint16_t _rx_delay_intrabit;
+  uint16_t _rx_delay_stopbit;
+  uint16_t _tx_delay;
+
+  uint16_t _buffer_overflow:1;
+  uint16_t _inverse_logic:1;
+
+  // static data
+  static char _receive_buffer[_SS_MAX_RX_BUFF]; 
+  static volatile uint8_t _receive_buffer_tail;
+  static volatile uint8_t _receive_buffer_head;
+  static SoftwareSerial *active_object;
+
+  // private methods
+  void recv();
+  uint8_t rx_pin_read();
+  void tx_pin_write(uint8_t pin_state);
+  void setTX(uint8_t transmitPin);
+  void setRX(uint8_t receivePin);
+
+  // private static method for timing
+  static inline void tunedDelay(uint16_t delay);
+
+
+public:
+  // public methods
+  SoftwareSerial(uint8_t receivePin, uint8_t transmitPin, bool inverse_logic = false);
+  ~SoftwareSerial();
+  void begin(long speed);
+  bool listen();
+  void end();
+  bool isListening() { return this == active_object; }
+  bool overflow() { bool ret = _buffer_overflow; _buffer_overflow = false; return ret; }
+  int peek();
+
+  virtual size_t write(uint8_t byte);
+  virtual int read();
+  virtual int available();
+  virtual void flush();
+  
+  using Print::write;
+
+  // public only for easy access by interrupt handlers
+  static inline void handle_interrupt();
+};
+
+// Arduino 0012 workaround
+#undef int
+#undef char
+#undef long
+#undef byte
+#undef float
+#undef abs
+#undef round
+
+#endif
+
+#endif

KorMYS/.pio/libdeps/uno/SoftwareSerial/examples/SoftwareSerialExample/SoftwareSerialExample.ino

@@ -0,0 +1,55 @@
+/*
+  Software serial multple serial test
+ 
+ Receives from the hardware serial, sends to software serial.
+ Receives from software serial, sends to hardware serial.
+ 
+ The circuit: 
+ * RX is digital pin 10 (connect to TX of other device)
+ * TX is digital pin 11 (connect to RX of other device)
+ 
+ Note:
+ Not all pins on the Mega and Mega 2560 support change interrupts, 
+ so only the following can be used for RX: 
+ 10, 11, 12, 13, 50, 51, 52, 53, 62, 63, 64, 65, 66, 67, 68, 69
+ 
+ Not all pins on the Leonardo support change interrupts, 
+ so only the following can be used for RX: 
+ 8, 9, 10, 11, 14 (MISO), 15 (SCK), 16 (MOSI).
+ 
+ created back in the mists of time
+ modified 25 May 2012
+ by Tom Igoe
+ based on Mikal Hart's example
+ 
+ This example code is in the public domain.
+ 
+ */
+#include <SoftwareSerial.h>
+
+SoftwareSerial mySerial(10, 11); // RX, TX
+
+void setup()  
+{
+  // Open serial communications and wait for port to open:
+  Serial.begin(57600);
+  while (!Serial) {
+    ; // wait for serial port to connect. Needed for Leonardo only
+  }
+
+
+  Serial.println("Goodnight moon!");
+
+  // set the data rate for the SoftwareSerial port
+  mySerial.begin(4800);
+  mySerial.println("Hello, world?");
+}
+
+void loop() // run over and over
+{
+  if (mySerial.available())
+    Serial.write(mySerial.read());
+  if (Serial.available())
+    mySerial.write(Serial.read());
+}
+

KorMYS/.pio/libdeps/uno/SoftwareSerial/examples/TwoPortReceive/TwoPortReceive.ino

@@ -0,0 +1,93 @@
+/*
+  Software serial multple serial test
+ 
+ Receives from the two software serial ports, 
+ sends to the hardware serial port. 
+ 
+ In order to listen on a software port, you call port.listen(). 
+ When using two software serial ports, you have to switch ports
+ by listen()ing on each one in turn. Pick a logical time to switch
+ ports, like the end of an expected transmission, or when the 
+ buffer is empty. This example switches ports when there is nothing
+ more to read from a port
+ 
+ The circuit: 
+ Two devices which communicate serially are needed.
+ * First serial device's TX attached to digital pin 2, RX to pin 3
+ * Second serial device's TX attached to digital pin 4, RX to pin 5
+ 
+ Note:
+ Not all pins on the Mega and Mega 2560 support change interrupts, 
+ so only the following can be used for RX: 
+ 10, 11, 12, 13, 50, 51, 52, 53, 62, 63, 64, 65, 66, 67, 68, 69
+ 
+ Not all pins on the Leonardo support change interrupts, 
+ so only the following can be used for RX: 
+ 8, 9, 10, 11, 14 (MISO), 15 (SCK), 16 (MOSI).
+ 
+ created 18 Apr. 2011
+ modified 25 May 2012
+ by Tom Igoe
+ based on Mikal Hart's twoPortRXExample
+ 
+ This example code is in the public domain.
+ 
+ */
+
+#include <SoftwareSerial.h>
+// software serial #1: TX = digital pin 10, RX = digital pin 11
+SoftwareSerial portOne(10,11);
+
+// software serial #2: TX = digital pin 8, RX = digital pin 9
+// on the Mega, use other pins instead, since 8 and 9 don't work on the Mega
+SoftwareSerial portTwo(8,9);
+
+void setup()
+{
+ // Open serial communications and wait for port to open:
+  Serial.begin(9600);
+   while (!Serial) {
+    ; // wait for serial port to connect. Needed for Leonardo only
+  }
+
+
+  // Start each software serial port
+  portOne.begin(9600);
+  portTwo.begin(9600);
+}
+
+void loop()
+{
+  // By default, the last intialized port is listening.
+  // when you want to listen on a port, explicitly select it:
+  portOne.listen();
+  Serial.println("Data from port one:");
+  // while there is data coming in, read it
+  // and send to the hardware serial port:
+  while (portOne.available() > 0) {
+    char inByte = portOne.read();
+    Serial.write(inByte);
+  }
+
+  // blank line to separate data from the two ports:
+  Serial.println();
+
+  // Now listen on the second port
+  portTwo.listen();
+  // while there is data coming in, read it
+  // and send to the hardware serial port:
+  Serial.println("Data from port two:");
+  while (portTwo.available() > 0) {
+    char inByte = portTwo.read();
+    Serial.write(inByte);
+  }
+
+  // blank line to separate data from the two ports:
+  Serial.println();
+}
+
+
+
+
+
+

KorMYS/.pio/libdeps/uno/SoftwareSerial/keywords.txt

@@ -0,0 +1,30 @@
+#######################################
+# Syntax Coloring Map for SoftwareSerial
+# (formerly NewSoftSerial)
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+SoftwareSerial	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+begin	KEYWORD2
+end	KEYWORD2
+read	KEYWORD2
+write	KEYWORD2
+available	KEYWORD2
+isListening	KEYWORD2
+overflow	KEYWORD2
+flush	KEYWORD2
+listen	KEYWORD2
+peek	KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################
+

KorMYS/.pio/libdeps/uno/SoftwareSerial/library.json

@@ -0,0 +1,31 @@
+{
+    "name": "SoftwareSerial",
+    "keywords": "SoftwareSerial",
+    "description": "The SoftwareSerial library has been developed to allow serial communication, using software to replicate the functionality of the hardware UART. It is possible to have multiple software serial ports with speeds up to 115200 bps. On 32 bit Teensy boards, SoftwareSerial uses the real hardware serial ports (and is restricted to only those pins), but allows compatibility with programs that depend on SoftwareSerial.",
+    "repository":
+    {
+      "type": "git",
+      "url": "https://github.com/featherfly/SoftwareSerial.git"
+    },
+    "authors":
+    [
+      {
+        "name": "Arduino",
+        "maintainer": true,
+        "url": "https://www.arduino.cc"
+      },
+      {
+        "name": "Paul Stoffregen",
+        "maintainer": true
+      },
+      {
+        "name": "yufei",
+        "email": "featherfly@foxmail.com"
+      }
+    ],
+    "dependencies": [
+    ],
+    "version": "1.0",
+    "frameworks": "arduino",
+    "platforms": "*"
+  }

KorMYS/.pio/libdeps/uno/SoftwareSerial/library.properties

@@ -0,0 +1,10 @@
+name=SoftwareSerial
+version=1.0
+author=Arduino
+maintainer=Paul Stoffregen
+sentence=Enables serial communication on any digital pin.
+paragraph=The SoftwareSerial library has been developed to allow serial communication, using software to replicate the functionality of the hardware UART. It is possible to have multiple software serial ports with speeds up to 115200 bps. On 32 bit Teensy boards, SoftwareSerial uses the real hardware serial ports (and is restricted to only those pins), but allows compatibility with programs that depend on SoftwareSerial.
+category=Communication
+url=http://www.arduino.cc/en/Reference/SoftwareSerial
+architectures=*
+

KorMYS/.pio/libdeps/uno/SoftwareSerial/libray.json

@@ -0,0 +1,31 @@
+{
+    "name": "SoftwareSerial",
+    "keywords": "SoftwareSerial",
+    "description": "The SoftwareSerial library has been developed to allow serial communication, using software to replicate the functionality of the hardware UART. It is possible to have multiple software serial ports with speeds up to 115200 bps. On 32 bit Teensy boards, SoftwareSerial uses the real hardware serial ports (and is restricted to only those pins), but allows compatibility with programs that depend on SoftwareSerial.",
+    "repository":
+    {
+      "type": "git",
+      "url": "https://github.com/featherfly/SoftwareSerial.git"
+    },
+    "authors":
+    [
+      {
+        "name": "Arduino",
+        "maintainer": true,
+        "url": "https://www.arduino.cc"
+      },
+      {
+        "name": "Paul Stoffregen",
+        "maintainer": true
+      },
+      {
+        "name": "yufei",
+        "email": "featherfly@foxmail.com"
+      }
+    ],
+    "dependencies": [
+    ],
+    "version": "1.0",
+    "frameworks": "arduino",
+    "platforms": "*"
+  }

KorMYS/.pio/libdeps/uno/integrity.dat

@@ -0,0 +1,2 @@
+robtillaart/RunningMedian @ ^0.3.3
+featherfly/SoftwareSerial @ ^1.0