lexa/AHome
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Kuhnya Changed IP for MQTT. Added JLed

Browse Source
This commit is contained in:
Lexa
2025-08-21 11:07:47 +03:00
parent 4406739f56
commit c42f26105c
35 changed files with 2279 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
KorMYS/.pio/build/project.checksum Normal file
View File

@@ -0,0 +1 @@
b58b282bd85d9a4528491da8b76afbc5f6cf573c

1
KorMYS/.pio/build/uno/idedata.json Normal file
View File

File diff suppressed because one or more lines are too long

7
KorMYS/.pio/libdeps/uno/RunningMedian/.arduino-ci.yml Normal file
View File

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

13
KorMYS/.pio/libdeps/uno/RunningMedian/.github/workflows/arduino_test_runner.yml vendored Normal file
View File

@@ -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

1
KorMYS/.pio/libdeps/uno/RunningMedian/.piopm Normal file
View File

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

21
KorMYS/.pio/libdeps/uno/RunningMedian/LICENSE Normal file
View File

@@ -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.

79
KorMYS/.pio/libdeps/uno/RunningMedian/README.md Normal file
View File

@@ -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

205
KorMYS/.pio/libdeps/uno/RunningMedian/RunningMedian.cpp Normal file
View File

@@ -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 --

94
KorMYS/.pio/libdeps/uno/RunningMedian/RunningMedian.h Normal file
View File

@@ -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

50
KorMYS/.pio/libdeps/uno/RunningMedian/examples/RunningMedian/RunningMedian.ino Normal file
View File

@@ -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 --

78
KorMYS/.pio/libdeps/uno/RunningMedian/examples/RunningMedian2/RunningMedian2.ino Normal file
View File

@@ -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);
}

40
KorMYS/.pio/libdeps/uno/RunningMedian/examples/RunningMedianQuantileTest/RunningMedianQuantileTest.ino Normal file
View File

@@ -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 --

163
KorMYS/.pio/libdeps/uno/RunningMedian/examples/RunningMedianTest1/RunningMedianTest1.ino Normal file
View File

@@ -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 --

66
KorMYS/.pio/libdeps/uno/RunningMedian/examples/RunningMedian_large/RunningMedian_large.ino Normal file
View File

@@ -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 --

23
KorMYS/.pio/libdeps/uno/RunningMedian/keywords.txt Normal file
View File

@@ -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

21
KorMYS/.pio/libdeps/uno/RunningMedian/library.json Normal file
View File

@@ -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": "*"
}

11
KorMYS/.pio/libdeps/uno/RunningMedian/library.properties Normal file
View File

@@ -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=

123
KorMYS/.pio/libdeps/uno/RunningMedian/test/unit_test_001.cpp Normal file
View File

@@ -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()
// --------

1
KorMYS/.pio/libdeps/uno/SoftwareSerial/.piopm Normal file
View File

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

677
KorMYS/.pio/libdeps/uno/SoftwareSerial/SoftwareSerial.cpp Normal file
View File

@@ -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

150
KorMYS/.pio/libdeps/uno/SoftwareSerial/SoftwareSerial.h Normal file
View File

@@ -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

55
KorMYS/.pio/libdeps/uno/SoftwareSerial/examples/SoftwareSerialExample/SoftwareSerialExample.ino Normal file
View File

@@ -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());
}

93
KorMYS/.pio/libdeps/uno/SoftwareSerial/examples/TwoPortReceive/TwoPortReceive.ino Normal file
View File

@@ -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();
}

30
KorMYS/.pio/libdeps/uno/SoftwareSerial/keywords.txt Normal file
View File

@@ -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)
#######################################

31
KorMYS/.pio/libdeps/uno/SoftwareSerial/library.json Normal file
View File

@@ -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": "*"
}

10
KorMYS/.pio/libdeps/uno/SoftwareSerial/library.properties Normal file
View File

@@ -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=*

31
KorMYS/.pio/libdeps/uno/SoftwareSerial/libray.json Normal file
View File

@@ -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": "*"
}

2
KorMYS/.pio/libdeps/uno/integrity.dat Normal file
View File

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

128
KorMYS/.vscode/c_cpp_properties.json vendored Normal file
View File

@@ -0,0 +1,128 @@
//
// !!! WARNING !!! AUTO-GENERATED FILE!
// PLEASE DO NOT MODIFY IT AND USE "platformio.ini":
// https://docs.platformio.org/page/projectconf/section_env_build.html#build-flags
//
{
"configurations": [
{
"name": "PlatformIO",
"includePath": [
"d:/Projects/Arduino/AHome/KorMYS/include",
"d:/Projects/Arduino/AHome/KorMYS/src",
"C:/Users/lexa-/.platformio/lib/SDS011 sensor Library",
"C:/Users/lexa-/.platformio/lib/MySensors_ID548",
"C:/Users/lexa-/.platformio/packages/framework-arduino-avr/libraries/EEPROM/src",
"C:/Users/lexa-/.platformio/packages/framework-arduino-avr/libraries/SPI/src",
"C:/Users/lexa-/.platformio/packages/framework-arduino-avr/libraries/Wire/src",
"d:/Projects/Arduino/AHome/KorMYS/.pio/libdeps/uno/RunningMedian",
"d:/Projects/Arduino/AHome/KorMYS/.pio/libdeps/uno/SoftwareSerial",
"C:/Users/lexa-/.platformio/packages/framework-arduino-avr/cores/arduino",
"C:/Users/lexa-/.platformio/packages/framework-arduino-avr/variants/standard",
"C:/Users/lexa-/.platformio/lib/Adafruit ADXL343",
"C:/Users/lexa-/.platformio/lib/Adafruit AHTX0",
"C:/Users/lexa-/.platformio/lib/Adafruit BME280 Library",
"C:/Users/lexa-/.platformio/lib/Adafruit BusIO",
"C:/Users/lexa-/.platformio/lib/Adafruit DHT Unified_ID18",
"C:/Users/lexa-/.platformio/lib/Adafruit GFX Library",
"C:/Users/lexa-/.platformio/lib/Adafruit HTU21DF Library_ID566",
"C:/Users/lexa-/.platformio/lib/Adafruit SH110X",
"C:/Users/lexa-/.platformio/lib/Adafruit Unified Sensor",
"C:/Users/lexa-/.platformio/lib/AsyncMqttClient/src",
"C:/Users/lexa-/.platformio/lib/BME280_ID901/src",
"C:/Users/lexa-/.platformio/lib/Bounce2/src",
"C:/Users/lexa-/.platformio/lib/ClosedCube HDC1080_ID805/src",
"C:/Users/lexa-/.platformio/lib/DHT sensor library",
"C:/Users/lexa-/.platformio/lib/DallasTemperature",
"C:/Users/lexa-/.platformio/lib/EEPROMEx",
"C:/Users/lexa-/.platformio/lib/ESP_EEPROM/src",
"C:/Users/lexa-/.platformio/lib/EmonLib_ID116",
"C:/Users/lexa-/.platformio/lib/Encoder",
"C:/Users/lexa-/.platformio/lib/Encoder/utility",
"C:/Users/lexa-/.platformio/lib/I2C_EEPROM",
"C:/Users/lexa-/.platformio/lib/LiquidCrystal_PCF8574/src",
"C:/Users/lexa-/.platformio/lib/MH-Z19/src",
"C:/Users/lexa-/.platformio/lib/MsTimer2_ID137",
"C:/Users/lexa-/.platformio/lib/Nova Fitness Sds dust sensors library/src",
"C:/Users/lexa-/.platformio/lib/OneButton/src",
"C:/Users/lexa-/.platformio/lib/OneWire",
"C:/Users/lexa-/.platformio/lib/PCF8574",
"C:/Users/lexa-/.platformio/lib/PCF8574_ESP",
"C:/Users/lexa-/.platformio/lib/PubSubClient_ID89/src",
"C:/Users/lexa-/.platformio/lib/RotaryEncoder/src",
"C:/Users/lexa-/.platformio/lib/TimerOne",
"C:/Users/lexa-/.platformio/packages/framework-arduino-avr/libraries/HID/src",
"C:/Users/lexa-/.platformio/packages/framework-arduino-avr/libraries/SoftwareSerial/src",
""
],
"browse": {
"limitSymbolsToIncludedHeaders": true,
"path": [
"d:/Projects/Arduino/AHome/KorMYS/include",
"d:/Projects/Arduino/AHome/KorMYS/src",
"C:/Users/lexa-/.platformio/lib/SDS011 sensor Library",
"C:/Users/lexa-/.platformio/lib/MySensors_ID548",
"C:/Users/lexa-/.platformio/packages/framework-arduino-avr/libraries/EEPROM/src",
"C:/Users/lexa-/.platformio/packages/framework-arduino-avr/libraries/SPI/src",
"C:/Users/lexa-/.platformio/packages/framework-arduino-avr/libraries/Wire/src",
"d:/Projects/Arduino/AHome/KorMYS/.pio/libdeps/uno/RunningMedian",
"d:/Projects/Arduino/AHome/KorMYS/.pio/libdeps/uno/SoftwareSerial",
"C:/Users/lexa-/.platformio/packages/framework-arduino-avr/cores/arduino",
"C:/Users/lexa-/.platformio/packages/framework-arduino-avr/variants/standard",
"C:/Users/lexa-/.platformio/lib/Adafruit ADXL343",
"C:/Users/lexa-/.platformio/lib/Adafruit AHTX0",
"C:/Users/lexa-/.platformio/lib/Adafruit BME280 Library",
"C:/Users/lexa-/.platformio/lib/Adafruit BusIO",
"C:/Users/lexa-/.platformio/lib/Adafruit DHT Unified_ID18",
"C:/Users/lexa-/.platformio/lib/Adafruit GFX Library",
"C:/Users/lexa-/.platformio/lib/Adafruit HTU21DF Library_ID566",
"C:/Users/lexa-/.platformio/lib/Adafruit SH110X",
"C:/Users/lexa-/.platformio/lib/Adafruit Unified Sensor",
"C:/Users/lexa-/.platformio/lib/AsyncMqttClient/src",
"C:/Users/lexa-/.platformio/lib/BME280_ID901/src",
"C:/Users/lexa-/.platformio/lib/Bounce2/src",
"C:/Users/lexa-/.platformio/lib/ClosedCube HDC1080_ID805/src",
"C:/Users/lexa-/.platformio/lib/DHT sensor library",
"C:/Users/lexa-/.platformio/lib/DallasTemperature",
"C:/Users/lexa-/.platformio/lib/EEPROMEx",
"C:/Users/lexa-/.platformio/lib/ESP_EEPROM/src",
"C:/Users/lexa-/.platformio/lib/EmonLib_ID116",
"C:/Users/lexa-/.platformio/lib/Encoder",
"C:/Users/lexa-/.platformio/lib/Encoder/utility",
"C:/Users/lexa-/.platformio/lib/I2C_EEPROM",
"C:/Users/lexa-/.platformio/lib/LiquidCrystal_PCF8574/src",
"C:/Users/lexa-/.platformio/lib/MH-Z19/src",
"C:/Users/lexa-/.platformio/lib/MsTimer2_ID137",
"C:/Users/lexa-/.platformio/lib/Nova Fitness Sds dust sensors library/src",
"C:/Users/lexa-/.platformio/lib/OneButton/src",
"C:/Users/lexa-/.platformio/lib/OneWire",
"C:/Users/lexa-/.platformio/lib/PCF8574",
"C:/Users/lexa-/.platformio/lib/PCF8574_ESP",
"C:/Users/lexa-/.platformio/lib/PubSubClient_ID89/src",
"C:/Users/lexa-/.platformio/lib/RotaryEncoder/src",
"C:/Users/lexa-/.platformio/lib/TimerOne",
"C:/Users/lexa-/.platformio/packages/framework-arduino-avr/libraries/HID/src",
"C:/Users/lexa-/.platformio/packages/framework-arduino-avr/libraries/SoftwareSerial/src",
""
]
},
"defines": [
"PLATFORMIO=60105",
"ARDUINO_AVR_UNO",
"F_CPU=16000000L",
"ARDUINO_ARCH_AVR",
"ARDUINO=10808",
"__AVR_ATmega328P__",
""
],
"cStandard": "c11",
"cppStandard": "c++11",
"compilerPath": "C:/Users/lexa-/.platformio/packages/toolchain-atmelavr@1.70300.191015/bin/avr-gcc.exe",
"compilerArgs": [
"-mmcu=atmega328p",
""
]
}
],
"version": 4
}

44
KorMYS/.vscode/launch.json vendored Normal file
View File

@@ -0,0 +1,44 @@
// AUTOMATICALLY GENERATED FILE. PLEASE DO NOT MODIFY IT MANUALLY
//
// PIO Unified Debugger
//
// Documentation: https://docs.platformio.org/page/plus/debugging.html
// Configuration: https://docs.platformio.org/page/projectconf/section_env_debug.html
{
"version": "0.2.0",
"configurations": [
{
"type": "platformio-debug",
"request": "launch",
"name": "PIO Debug",
"executable": "d:/Projects/Arduino/AHome/KorMYS/.pio/build/uno/firmware.elf",
"projectEnvName": "uno",
"toolchainBinDir": "C:/Users/lexa-/.platformio/packages/toolchain-atmelavr@1.70300.191015/bin",
"internalConsoleOptions": "openOnSessionStart",
"preLaunchTask": {
"type": "PlatformIO",
"task": "Pre-Debug"
}
},
{
"type": "platformio-debug",
"request": "launch",
"name": "PIO Debug (skip Pre-Debug)",
"executable": "d:/Projects/Arduino/AHome/KorMYS/.pio/build/uno/firmware.elf",
"projectEnvName": "uno",
"toolchainBinDir": "C:/Users/lexa-/.platformio/packages/toolchain-atmelavr@1.70300.191015/bin",
"internalConsoleOptions": "openOnSessionStart"
},
{
"type": "platformio-debug",
"request": "launch",
"name": "PIO Debug (without uploading)",
"executable": "d:/Projects/Arduino/AHome/KorMYS/.pio/build/uno/firmware.elf",
"projectEnvName": "uno",
"toolchainBinDir": "C:/Users/lexa-/.platformio/packages/toolchain-atmelavr@1.70300.191015/bin",
"internalConsoleOptions": "openOnSessionStart",
"loadMode": "manual"
}
]
}

3
Kuhnya/include/main.h
View File

@@ -14,6 +14,7 @@
#include <EEPROM.h>
#include <Ticker.h>
#include <AsyncMqttClient.h>
#include <jled.h>
//#include <Adafruit_BME280.h>
@@ -36,7 +37,7 @@ uint16_t stat[4];
const char* ssid = "wf-home";
const char* password = "0ndthnrf";
const char* mqtt_server = "192.168.1.111";
const char* mqtt_server = "192.168.1.10";
#define TOPIC "home/"
unsigned long crun;

3
Kuhnya/platformio.ini
View File

@@ -18,5 +18,6 @@ lib_deps =
finitespace/BME280 @ ^3.0.0
milesburton/DallasTemperature @ ^3.9.1
thomasfredericks/Bounce2 @ ^2.55
mathertel/LiquidCrystal_PCF8574 @ ^1.2.0
https://github.com/mathertel/LiquidCrystal_PCF8574.git
marvinroger/AsyncMqttClient @ ^0.8.2
jandelgado/JLed @ ^4.15.0

15
Kuhnya/src/main.cpp
View File

@@ -12,6 +12,7 @@ LiquidCrystal_PCF8574 lcd(0x3F); // set the LCD address to 0x27 for a 16 chars a
WiFiClient espClient;
Bounce butt = Bounce();
auto gLed = JLed(GREEN);
float tempC;
char f[4];
@@ -116,14 +117,16 @@ void setup() {
connectToWifi();
crun = millis();
gLed.Breathe(2000).DelayAfter(1000).MaxBrightness(16).Forever();
}
void loop() {
float tempT(NAN), humT(NAN), pressT(NAN);
static int gint = 1;
static bool gdir = true;
// static int gint = 1;
// static bool gdir = true;
ArduinoOTA.handle();
gLed.Update();
butt.update();
if (butt.rose()){
@@ -135,10 +138,10 @@ void loop() {
crun = millis();
minCount++;
if(gdir) gint += 25;
else gint -= 25;
if((gint > 499) || (gint < 2)) gdir = !gdir;
analogWrite(GREEN, gint);
// if(gdir) gint += 25;
// else gint -= 25;
// if((gint > 499) || (gint < 2)) gdir = !gdir;
// analogWrite(GREEN, gint);
adc = analogRead(A0);
mv = digitalRead(MOVE_S);

3
esp8266-KUH/.vscode/extensions.json vendored
View File

@@ -3,5 +3,8 @@
// for the documentation about the extensions.json format
"recommendations": [
"platformio.platformio-ide"
],
"unwantedRecommendations": [
"ms-vscode.cpptools-extension-pack"
]
}

7
esp8266-KUH/platformio.ini
View File

@@ -15,3 +15,10 @@ framework = arduino
upload_protocol = espota
upload_port = 192.168.1.6
lib_deps =
thomasfredericks/Bounce2 @ ^2.72
mathertel/LiquidCrystal_PCF8574 @ ^2.2.0
milesburton/DallasTemperature @ ^4.0.4
werecatf/PCF8574_ESP @ ^1.0.10
finitespace/BME280 @ ^3.0.0
knolleary/PubSubClient @ ^2.8