Accumulator.h

/*
 * Copyright (c) 2021, 2022 G. R. McDorman
 *
 * 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.
 */
 
#pragma once
 
#include <WString.h>
#include <ArduinoJson.h>
 
#include <algorithm>
#include <numeric>
#include <vector>
 
namespace grmcdorman::device
{
 
        template<typename T, uint8_t N, int unset = 0, int zero = 0>
        class Accumulator
        {
        public:
            static constexpr T unset_value = unset;     
            static constexpr T zero_value = zero;       
            static constexpr uint8_t average_points = N;
            typedef T value_type;                       
 
            T get_last_reading() const
            {
                return last_reading;
            }
            float get_current_average() const
            {
                uint8_t count = std::min(data_read_first, average_points);
                return count == 0 ? unset_value : std::accumulate(&last_reading_set[0], &last_reading_set[count], zero_value) / static_cast<float>(count);
            }
            void new_reading(T new_value)
            {
                last_reading = new_value;
                last_reading_set[current_index] = new_value;
                current_index = (current_index + 1) % N;
                if (data_read_first < N)
                {
                    ++data_read_first;
                }
                last_sample_time = millis();
            }
            bool has_accumulation() const
            {
                return data_read_first > 0;
            }
 
            uint8_t get_sample_count() const
            {
                return data_read_first;
            }
 
            uint32_t get_last_sample_age() const
            {
                return millis() - last_sample_time;
            }
 
            DynamicJsonDocument as_json() const
            {
                static const char average_string[] PROGMEM = "average";
                static const char last_string[] PROGMEM = "last";
                static const char sample_count_string[] PROGMEM = "sample_count";
                static const char sample_age_string[] PROGMEM = "sample_age_ms";
 
                DynamicJsonDocument json(128);
                json[FPSTR(average_string)] = get_current_average();
                json[FPSTR(last_string)] = get_last_reading();
                json[FPSTR(sample_count_string)] = get_sample_count();
                json[FPSTR(sample_age_string)] = get_last_sample_age();
                return json;
            }
 
        private:
            T last_reading = unset_value;           
            T last_reading_set[N];                  
            uint32_t current_index = 0;             
            uint8_t data_read_first = 0;            
            uint32_t last_sample_time = 0;          
        };
}