hardbass, ik zoek je moving average filter class

#include <Adafruit_ADS1X15.h>
#include <PID_v1.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels

#define OLED_RESET     -1 // Reset pin # (or -1 if sharing Arduino reset pin)
#define SCREEN_ADDRESS 0x3C ///< See datasheet for Address; 0x3D for 128x64, 0x3C for 128x32
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

// Extra font voor het display
//#include <Fonts/FreeSans9pt7b.h>
// *Extra font voor het display


Adafruit_ADS1115 ads;  /* Use this for the 16-bit version */

// -------------------------------------------------------------------------
//  Filter Classsetup
// -------------------------------------------------------------------------
template <class T>
class Filter 
{
public:
  int N = 0;                                                                          // Aantal te middelen waarde
  float *meetwaardes;                                                                 // Opslag individuele meetwaarden
  float accumulator = 0;                                                              // Optelsom van alle individuele meetwaarden
  int index = 0;                                                                      // Meetwaarden teller

  Filter(const int n)
  {
    meetwaardes = new float[n];
    N = n;
    for(int i = 0; i < n; i++)
    {  
      meetwaardes[i] = 0;
    }
  }

  ~Filter()
  {
    delete[] meetwaardes;
  }

  void AddSample(float NewSample)
  {  
    accumulator -= meetwaardes[index];        
    meetwaardes[index] = NewSample;                                                   // Bewaar nieuwe meetwaarde
    accumulator += meetwaardes[index];                                                // Accumuleer nieuwste meetwaarde
    index++; 
    index %= N;                                                                       // Teller loopt van 0 tot N-1
  }

  float Average()
  {  
    return accumulator/N;                                                             // Bereken de gemmiddelde waarde
  }
};


// Variabelen voor corectiewaarden van temperatuur sensoren
// int corr_pid_float = 0;
// int corr_ref_float = 0;



//=====================================================================
//=====================================================================
void setup(void)
{
  Serial.begin(9600);
  Serial.println("Hello!");

  Wire.begin();
  Wire.setClock(4000000);                                              // Set de i2c bus op 400KHz werkfrequentie

// Setup ads1115 ADC
ads.setGain(GAIN_FOUR);                                               // 4x gain   +/- 1.024V  1 bit = 0.5mV    0.03125mV
ads.setDataRate(3);                                                   // DATA RATE ADS1115


  if (!ads.begin()) {
    Serial.println("Failed to initialize ADS.");
    while (1);
  }

// SSD1306_SWITCHCAPVCC = generate display voltage from 3.3V internally
  if(!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
    Serial.println(F("SSD1306 allocation failed"));
    for(;;); // Don't proceed, loop forever
  }

// Configuration averaging for the ADC inputs
Filter<float> Filter_TMP37_1(32);
Filter<float> Filter_TMP37_2(16); 

}


//=====================================================================
//=====================================================================
void loop(void)
{
   display.clearDisplay();
 
int16_t adc0, adc1;

//Temperatuur van de TMP37_1
	float sample_TMP37_1 = (float)analogRead(A0);
	float TMP37_1_Celcius = sample_TMP37_1 * (1.025/32768 / 0.02);	

//Temperatuur van de TMP37_2


//Samples toevoegen aan het filter.
	Filter_TMP37_1.AddSample(TMP37_1_Celcius);


	//Uitlezen resultaat filters.
	float avg_TMP37_1_Celcius = Filter_TMP37_1.Average();

 // text display tests
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(20,20);
  display.println(avg_TMP37_1_Celcius);
  
  display.setCursor(20,40);
 // display.println(xxxx);
  
  display.drawRect(0, 0, 128, 64, SSD1306_WHITE);
  
  display.display();
  
  delay(10);
}

#include <Adafruit_ADS1X15.h>
#include <PID_v1.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels

#define OLED_RESET     -1 // Reset pin # (or -1 if sharing Arduino reset pin)
#define SCREEN_ADDRESS 0x3C ///< See datasheet for Address; 0x3D for 128x64, 0x3C for 128x32
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

// Extra font voor het display
#include <Fonts/FreeSans9pt7b.h>
// *Extra font voor het display


Adafruit_ADS1115 ads;  /* Use this for the 16-bit version */

//-------------------------------------------------------------------------
// Filter Classsetup
//-------------------------------------------------------------------------
template <class T>
class Filter 
{
public:
  int N = 0;                                                                          // Aantal te middelen waarde
  float *meetwaardes;                                                                 // Opslag individuele meetwaarden
  float accumulator = 0;                                                              // Optelsom van alle individuele meetwaarden
  int index = 0;                                                                      // Meetwaarden teller

  Filter(const int n)
  {
    meetwaardes = new float[n];
    N = n;
    for(int i = 0; i < n; i++)
    {  
      meetwaardes[i] = 0;
    }
  }

  ~Filter()
  {
    delete[] meetwaardes;
  }

  void AddSample(float NewSample)
  {  
    accumulator -= meetwaardes[index];        
    meetwaardes[index] = NewSample;                                                   // Bewaar nieuwe meetwaarde
    accumulator += meetwaardes[index];                                                // Accumuleer nieuwste meetwaarde
    index++; 
    index %= N;                                                                       // Teller loopt van 0 tot N-1
  }

  float Average()
  {  
    return accumulator/N;                                                             // Bereken de gemmiddelde waarde
  }
};


// // Variabelen voor corectiewaarden van temperatuur sensoren
// // int corr_pid_float = 0;
// // int corr_ref_float = 0;

// // Configuration averaging for the ADC inputs
Filter<float> Filter_TMP37_1(8);
Filter<float> Filter_TMP37_2(8); 



//=====================================================================
//=====================================================================
void setup(void)
{
  Serial.begin(9600);
  Serial.println("Hello!");

  Wire.begin();
  Wire.setClock(4000000);                                              // Set de i2c bus op 400KHz werkfrequentie

// Setup ads1115 ADC
ads.setGain(GAIN_FOUR);                                               // 4x gain   +/- 1.024V  1 bit = 0.5mV    0.03125mV
ads.setDataRate(4);                                                   // DATA RATE ADS1115


  if (!ads.begin()) {
    Serial.println("Failed to initialize ADS.");
    while (1);
  }

// SSD1306_SWITCHCAPVCC = generate display voltage from 3.3V internally
  if(!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
    Serial.println(F("SSD1306 allocation failed"));
    for(;;); // Don't proceed, loop forever
  }


}





//=====================================================================
//=====================================================================
void loop(void)
{
   display.clearDisplay();
 
int16_t adc0, adc1;

  adc0 = ads.readADC_SingleEnded(0);                                     // Get value PID sensor input
  adc1 = ads.readADC_SingleEnded(1);                                     // Get value reference sensor input 



//Temperatuur van de TMP37_1
//	float sample_TMP37_1 = (float)analogRead(A0);
	float TMP37_1_Celcius = adc0 * (1.025/32768 / 0.02);	

//Temperatuur van de TMP37_2


//Samples toevoegen aan het filter.
	Filter_TMP37_1.AddSample(TMP37_1_Celcius);


	//Uitlezen resultaat filters.
 float avg_TMP37_1_Celcius = Filter_TMP37_1.Average();

   display.println();
 
 
 
 // text display tests
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(20,20);
 // display.println(TMP37_1_Celcius);
  
  display.setCursor(20,40);
 display.println(avg_TMP37_1_Celcius, 4);
  
  display.drawRect(0, 0, 128, 64, SSD1306_WHITE);
  
  display.display();
  
  delay(1000);
}

template <size_t N>
class Filter
{
    static_assert(N > 0, "Filter size N must be greater than zero");

private:
    float measurements[N]{};
    float accumulator = 0.0f;
    size_t index = 0;

public:
    Filter() = default;

    // Prevent accidental expensive copies
    Filter(const Filter&) = delete;
    Filter& operator=(const Filter&) = delete;

    // Moves are fine (still effectively copies, but intentional)
    Filter(Filter&&) = default;
    Filter& operator=(Filter&&) = default;

    void AddSample(float sample)
    {
        accumulator -= measurements[index];
        measurements[index] = sample;
        accumulator += sample;

        index++;
        if (index >= N)
            index = 0;
    }

    float Average() const
    {
        return accumulator / static_cast<float>(N);
    }

    void Reset()
    {
        for (size_t i = 0; i < N; ++i)
            measurements[i] = 0.0f;

        accumulator = 0.0f;
        index = 0;
    }
};


void Example()
{

    Filter<5> filter_5;
    filter_5.AddSample(10.0f);
    filter_5.AddSample(20.0f);
    filter_5.AddSample(30.0f);
    float avg = filter_5.Average();
    printf("Average of last 5 samples: %.2f\n", avg);

    Filter<3> filter_3;
    filter_3.AddSample(5.0f);
    filter_3.AddSample(15.0f);
    float avg3 = filter_3.Average();
    printf("Average of last 3 samples: %.5f\n", avg3);
}

// 2 filters: kanaal 0 sterk (32), kanaal 1 minder sterk (8)
Filter<32> filter_ch0;
Filter<8>  filter_ch1;

float AdcValueToTemperature(float adcValue)
{
    return adcValue * (1.025/32768 / 0.02);	
}

float ReadTemperatureC(int input)
{
    int16_t rawAdc = ads.readADC_SingleEnded(input);    // Read the raw value from the ADC
    return AdcValueToTemperature(rawAdc);               // Convert it to temperature
}

void setup()
{
    // Hier jou setup code
}

void loop()
{
    // 1) Meten (ongefilterd)
    float temp_ch0_raw = ReadTemperatureC(0);
    float temp_ch1_raw = ReadTemperatureC(1);

    // 2) Meting aan filter toevoegen
    filter_ch0.AddSample(temp_ch0_raw);
    filter_ch1.AddSample(temp_ch1_raw);

    // 3) Gemiddelde (gefilterde waarde) ophalen
    float temp_ch0_avg = filter_ch0.Average();
    float temp_ch1_avg = filter_ch1.Average();

    // 4) Printen voor test (hier kun je ook je display update doen)
    Serial.print("CH0 raw=");
    Serial.print(temp_ch0_raw, 4);
    Serial.print("  avg(32)=");
    Serial.print(temp_ch0_avg, 4);

    Serial.print("    CH1 raw=");
    Serial.print(temp_ch1_raw, 4);
    Serial.print("  avg(8)=");
    Serial.println(temp_ch1_avg, 4);

    delay(1000);
}

template <size_t N>
class Filter
{
    static_assert(N > 0, "Filter size N must be greater than zero");

private:
    float measurements[N]{};
    float accumulator = 0.0f;
    float bigJump = 0.5f;
    size_t index = 0;

public:
    Filter() = default;

    // Prevent accidental expensive copies
    Filter(const Filter&) = delete;
    Filter& operator=(const Filter&) = delete;

    // Moves are fine (still effectively copies, but intentional)
    Filter(Filter&&) = default;
    Filter& operator=(Filter&&) = default;

    void AddSample(float sample)
    {
		if(abs(sample - Average()) > bigJump)
		{
			Preset(sample);
		}	
		else
		{	
			accumulator -= measurements[index];
			measurements[index] = sample;
			accumulator += sample;

			index++;
			if (index >= N)
				index = 0;
		}
    }

    float Average() const
    {
        return accumulator / static_cast<float>(N);
    }

    void Reset()
    {
        for (size_t i = 0; i < N; ++i)
            measurements[i] = 0.0f;

        accumulator = 0.0f;
        index = 0;
    }

    void Preset(float sample)
    {
        for (size_t i = 0; i < N; ++i)
            measurements[i] = sample;

        accumulator = N * sample;
        index = 0;
    }	

};

struct Filter
{
    virtual float next(float value) = 0;
};

template<int N>
struct AverageFilter : public Filter
{
};

template<int ORDER> // nth order low pass filter
struct LowPassFilter : public Filter
{
    void Init(int cutoffFrequency, int sampleRate);
};

// Somehow inject the polynomial coefficients
template<int COOFICIENTS> // nth order
struct IIRFilter : public Filter
{
    void Init(float* aCoefficients, float* bCoefficients, int order);
};

struct DpsController
{
    Filter& filter;
    AnalogInput& input;
    AnalogOutput& output;

    DpsController(Filter& filt, AnalogInput& in, AnalogOutput& out)
        : filter(filt), input(in), output(out)
    {
    }

    void tick()
    {
        float sample = input.read();
        float filtered = filter.next(sample);
        output.write(filtered);
    }
};

// ----------------------
// Start of arduino code
// ----------------------
AnalogInput input;
AnalogOutput output;

LowPassFilter lowPass;
AverageFilter<8> avg;

// This now ties the input to the output through the low pass filter
DpsController controller(lowPass, input, output);

void loop()
{
    controller.tick();
}

// Thermistor Eigenschappen Vishay NTCLE300E3502SB
#define RT0 5000                                                     // NTC weerstand bij 25C
#define B   3977                                                     // K
#define VCC 3.000                                                    // Referentie Spanning van de brug
#define R   2540.00                                                  // Weerstand naar de referentie spanning voor de NTC in Ohm
#define T0  (25 + 273.15)                                            // Temperature T0 from datasheet, conversion from Celsius to kelvin fot the NTC Sensor

  // Temperatuur van de NTC
  float sample_NTC_RAW = (float)analogRead(A8);
  float VRT = 2.4985 * sample_NTC_RAW / 65536.00; 
  float VR = VCC - VRT;
  float RT = VRT * R / VR; 
  float ln = log(RT / RT0);
  float TX = (1 / ((ln / B) + (1 / T0)));                                        
  float sample_NTC_Celcius = TX - 273.15;