HAHA! commit

code/libs/mmmath/ExpMovAvg.h

@@ -0,0 +1,16 @@
+#pragma once
+
+class ExpMovAvg {
+public:	
+	 ExpMovAvg(int* in_i, int* out_o, float lambda = 0.5) : _in_ptr(in_i), _out_ptr(out_o), _lambda(lambda) {;}
+
+	 inline void calculate() {
+	 	_ema = _lambda * (float)(*_in_ptr) + (1 - _lambda) * _ema;
+	 	 *_out_ptr = _ema;
+	 }
+
+	int *_in_ptr, *_out_ptr;
+	int _ema;
+	float _lambda;
+
+};

code/libs/mmmath/MinMaxLerp.cpp

@@ -0,0 +1,55 @@
+#include "MinMaxLerp.h"
+
+#include "Arduino.h"
+
+	MinMaxLerp::MinMaxLerp(int* in_i, int base_min, int base_max, long update_interval_ms, int nbr_steps) :
+	_in_ptr(in_i), _base_min(base_min), _base_max(base_max), _cur_min(base_min), _cur_max(base_max), 
+	_tick_min(0), _tick_max(0), _update_interval(update_interval_ms)
+{
+    _tick_time = (float)update_interval_ms / (float) nbr_steps;
+}
+
+	void MinMaxLerp::lerp_min_max() {
+    
+    static float m_min = 1;
+    static float m_max = 1;
+    static int t_min = 0;
+    static int t_max = 0;
+
+    int _ema = *_in_ptr;
+    
+    if(_ema < _cur_min) {
+        _cur_min = _ema;
+        _min = _ema;
+        _tick_min = millis();
+        t_min = millis();
+        
+        // calculate new slope
+        int dy = _base_min - _min;
+        m_min = (float) dy / (float)_update_interval; // linear
+    } else {
+        long t = millis() - _tick_min;
+        if(t < _update_interval && (t_min - millis()) > _tick_time) {
+            t_min = millis();
+            _cur_min = _min + m_min * t;            
+        }
+    }
+    
+    if(_ema > _cur_max) {
+        _cur_max = _ema;
+        _max = _ema;
+        _tick_max = millis();
+        t_max = millis();
+        
+        // calculate new slope
+        int dy = _base_max - _max;
+        m_max = (float) dy / (float)_update_interval; // linear
+    } else {
+        long t = millis() - _tick_max;
+        if(t < _update_interval && (t_max - millis()) > _tick_time) {
+            t_max = millis();
+            _cur_max = _max + m_max * t;
+        }
+    }
+
+	}

code/libs/mmmath/MinMaxLerp.h

@@ -0,0 +1,26 @@
+#pragma once
+
+class MinMaxLerp {
+public:
+	MinMaxLerp(int* in_i, int base_min, int base_max, long update_interval_ms = 1000, int nbr_steps = 100);
+
+	void lerp_min_max();
+
+	inline int lmin() { return _cur_min; }
+	inline int lmax() { return _cur_max; }
+
+protected:
+
+  int _base_min;
+  int _base_max;
+  int _min;
+  int _max;
+	int _cur_min;
+	int _cur_max;
+    
+	long _tick_min, _tick_max, _tick_time;
+  long _update_interval;
+	
+	int* _in_ptr;
+
+};

code/libs/mmmath/SpringMassDamper.cpp

@@ -0,0 +1,23 @@
+#include "SpringMassDamper.h"
+
+#include "Arduino.h"
+
+SpringMassDamper::SpringMassDamper(float m, float k, float d, float* out) : 
+		_m(m), _k(k), _d(d), _out(out)  {}
+
+float SpringMassDamper::position(int x) {
+  
+  float dt = (millis() - _tick) / 1000.0f;          
+  
+  F = _k * (x - X) - (_d * V);
+  V += (F / _m) * dt;
+  X += V * dt;
+
+  _tick = millis();
+
+  if(_out != NULL) 
+  	*_out = X;       
+
+  return X;  	
+
+}

code/libs/mmmath/SpringMassDamper.h

@@ -0,0 +1,16 @@
+#include "Arduino.h"
+
+#pragma once
+
+class SpringMassDamper {
+public:
+	SpringMassDamper(float m, float k, float d, float* out = NULL);
+
+	float position(int x);
+
+  float X, V, F;    
+  float _m, _k, _d;
+  long _tick;
+  float* _out;
+
+};