10 static const char *
const TAG =
"sensor.filter";
14 ESP_LOGVV(TAG,
"Filter(%p)::input(%f)",
this, value);
20 if (this->
next_ ==
nullptr) {
21 ESP_LOGVV(TAG,
"Filter(%p)::output(%f) -> SENSOR",
this, value);
24 ESP_LOGVV(TAG,
"Filter(%p)::output(%f) -> %p",
this, value, this->
next_);
29 ESP_LOGVV(TAG,
"Filter(%p)::initialize(parent=%p next=%p)",
this, parent, next);
36 : send_every_(send_every), send_at_(send_every - send_first_at), window_size_(window_size) {}
40 if (!std::isnan(value)) {
44 this->
queue_.push_back(value);
45 ESP_LOGVV(TAG,
"MedianFilter(%p)::new_value(%f)",
this, value);
52 if (!this->
queue_.empty()) {
53 std::deque<float> median_queue = this->
queue_;
54 sort(median_queue.begin(), median_queue.end());
56 size_t queue_size = median_queue.size();
58 median = median_queue[queue_size / 2];
60 median = (median_queue[queue_size / 2] + median_queue[(queue_size / 2) - 1]) / 2.0f;
64 ESP_LOGVV(TAG,
"MedianFilter(%p)::new_value(%f) SENDING",
this, median);
77 if (!std::isnan(value)) {
81 this->
queue_.push_back(value);
82 ESP_LOGVV(TAG,
"QuantileFilter(%p)::new_value(%f), quantile:%f",
this, value, this->
quantile_);
89 if (!this->
queue_.empty()) {
90 std::deque<float> quantile_queue = this->
queue_;
91 sort(quantile_queue.begin(), quantile_queue.end());
93 size_t queue_size = quantile_queue.size();
95 ESP_LOGVV(TAG,
"QuantileFilter(%p)::position: %d/%d",
this, position, queue_size);
99 ESP_LOGVV(TAG,
"QuantileFilter(%p)::new_value(%f) SENDING",
this, result);
111 if (!std::isnan(value)) {
115 this->
queue_.push_back(value);
116 ESP_LOGVV(TAG,
"MinFilter(%p)::new_value(%f)",
this, value);
123 if (!this->
queue_.empty()) {
124 std::deque<float>::iterator it = std::min_element(
queue_.begin(),
queue_.end());
128 ESP_LOGVV(TAG,
"MinFilter(%p)::new_value(%f) SENDING",
this, min);
140 if (!std::isnan(value)) {
144 this->
queue_.push_back(value);
145 ESP_LOGVV(TAG,
"MaxFilter(%p)::new_value(%f)",
this, value);
152 if (!this->
queue_.empty()) {
153 std::deque<float>::iterator it = std::max_element(
queue_.begin(),
queue_.end());
157 ESP_LOGVV(TAG,
"MaxFilter(%p)::new_value(%f) SENDING",
this, max);
165 size_t send_first_at)
170 if (!std::isnan(value)) {
175 this->
queue_.push_back(value);
179 if (this->
queue_.empty()) {
184 ESP_LOGVV(TAG,
"SlidingWindowMovingAverageFilter(%p)::new_value(%f) -> %f",
this, value, average);
190 for (
auto v : this->
queue_)
192 average = this->
sum_ / this->queue_.size();
196 ESP_LOGVV(TAG,
"SlidingWindowMovingAverageFilter(%p)::new_value(%f) SENDING",
this, value);
206 if (!std::isnan(value)) {
216 ESP_LOGVV(TAG,
"ExponentialMovingAverageFilter(%p)::new_value(%f) -> %f",
this, value, average);
219 ESP_LOGVV(TAG,
"ExponentialMovingAverageFilter(%p)::new_value(%f) SENDING",
this, value);
232 ESP_LOGVV(TAG,
"ThrottleAverageFilter(%p)::new_value(value=%f)",
this, value);
233 if (!std::isnan(value)) {
241 ESP_LOGVV(TAG,
"ThrottleAverageFilter(%p)::interval(sum=%f, n=%i)",
this, this->
sum_, this->
n_);
260 ESP_LOGVV(TAG,
"LambdaFilter(%p)::new_value(%f) -> %f",
this, value, it.value_or(INFINITY));
279 if (std::isnan(value)) {
286 float accuracy_mult = powf(10.0f, accuracy);
288 float rounded_value = roundf(accuracy_mult * value);
289 if (rounded_filter_out == rounded_value) {
300 const uint32_t now =
millis();
311 if (std::isnan(value))
333 filter->input(value);
340 filter->initialize(parent, &this->
phi_);
347 this->set_timeout(
"debounce", this->time_period_, [
this, value]() { this->
output(value); });
359 ESP_LOGVV(TAG,
"HeartbeatFilter(%p)::new_value(value=%f)",
this, value);
367 ESP_LOGVV(TAG,
"HeartbeatFilter(%p)::interval(has_value=%s, last_input=%f)",
this, YESNO(this->
has_value_),
383 for (
float coefficient : this->coefficients_) {
384 res += x * coefficient;
MultiplyFilter(float multiplier)
optional< float > new_value(float value) override
lambda_filter_t lambda_filter_
void set_quantile(float quantile)
optional< float > new_value(float value) override
void set_interval(const std::string &name, uint32_t interval, std::function< void()> &&f)
Set an interval function with a unique name.
void set_send_every(size_t send_every)
uint32_t min_time_between_inputs_
const lambda_filter_t & get_lambda_filter() const
std::deque< float > queue_
PhiNode(OrFilter *or_parent)
std::vector< Filter * > filters_
optional< float > new_value(float value) override
ThrottleFilter(uint32_t min_time_between_inputs)
void set_send_every(size_t send_every)
std::deque< float > queue_
void set_send_every(size_t send_every)
MaxFilter(size_t window_size, size_t send_every, size_t send_first_at)
Construct a MaxFilter.
void set_window_size(size_t window_size)
float get_setup_priority() const override
optional< float > new_value(float value) override
uint32_t IRAM_ATTR HOT millis()
optional< float > new_value(float value) override
optional< float > new_value(float value) override
virtual optional< float > new_value(float value)=0
This will be called every time the filter receives a new value.
optional< float > new_value(float value) override
OrFilter(std::vector< Filter *> filters)
DebounceFilter(uint32_t time_period)
void set_window_size(size_t window_size)
float value_to_filter_out_
optional< float > new_value(float value) override
HeartbeatFilter(uint32_t time_period)
float get_setup_priority() const override
optional< float > new_value(float value) override
OffsetFilter(float offset)
ThrottleAverageFilter(uint32_t time_period)
void set_alpha(float alpha)
virtual void initialize(Sensor *parent, Filter *next)
Initialize this filter, please note this can be called more than once.
void initialize(Sensor *parent, Filter *next) override
optional< float > new_value(float value) override
void set_lambda_filter(const lambda_filter_t &lambda_filter)
void set_send_every(size_t send_every)
optional< float > new_value(float value) override
optional< float > new_value(float value) override
ExponentialMovingAverageFilter(float alpha, size_t send_every, size_t send_first_at)
optional< float > new_value(float value) override
std::deque< float > queue_
std::deque< float > queue_
LambdaFilter(lambda_filter_t lambda_filter)
void set_window_size(size_t window_size)
const float HARDWARE
For components that deal with hardware and are very important like GPIO switch.
optional< float > new_value(float value) override
std::function< optional< float >(float)> lambda_filter_t
void internal_send_state_to_frontend(float state)
void set_send_every(size_t send_every)
DeltaFilter(float min_delta)
FilterOutValueFilter(float value_to_filter_out)
QuantileFilter(size_t window_size, size_t send_every, size_t send_first_at, float quantile)
Construct a QuantileFilter.
Apply a filter to sensor values such as moving average.
SlidingWindowMovingAverageFilter(size_t window_size, size_t send_every, size_t send_first_at)
Construct a SlidingWindowMovingAverageFilter.
MinFilter(size_t window_size, size_t send_every, size_t send_first_at)
Construct a MinFilter.
int8_t get_accuracy_decimals()
Get the accuracy in decimals, using the manual override if set.
float get_setup_priority() const override
optional< float > new_value(float value) override
CalibrateLinearFilter(float slope, float bias)
Base-class for all sensors.
optional< float > new_value(float value) override
optional< float > new_value(float value) override
void set_window_size(size_t window_size)
optional< float > new_value(float value) override