added butterworth filter \n added activity rec for baro using butter \n added moduel for walker with activity

sensors/pressure/ActivityButterPressure.h

@@ -0,0 +1,185 @@
+#ifndef ACTIVITYBUTTERPRESSURE_H
+#define ACTIVITYBUTTERPRESSURE_H
+
+#include "../../data/Timestamp.h"
+#include "../../math/filter/Butterworth.h"
+#include "../../math/FixedFrequencyInterpolator.h"
+#include "../../math/MovingAVG.h"
+
+#include "BarometerData.h"
+
+/**
+ * receives pressure measurements, interpolates them to a ficex frequency, lowpass filtering
+ * activity recognition based on a small window given by matlabs diff(window)
+ */
+class ActivityButterPressure {
+
+public:
+
+    enum Activity {DOWN, STAY, UP};
+
+
+
+    struct History {
+        Timestamp ts;
+        BarometerData data;
+        History(const Timestamp ts, const BarometerData data) : ts(ts), data(data) {;}
+    };
+
+    private:
+    //just for debugging and plotting
+    std::vector<History> input;
+    std::vector<History> inputInterp;
+    std::vector<History> output;
+    std::vector<float> sumHist;
+    std::vector<float> mvAvgHist;
+    std::vector<History> actHist;
+
+    Activity currentActivity;
+    MovingAVG<float> mvAvg = MovingAVG<float>(20);
+
+    /** change this values for much success */
+    const bool additionalLowpassFilter = false;
+    const int diffSize = 20; //the number values used for finding the activity.
+    const float threshold = 0.025; // if diffSize is getting smaller, treshold needs to be adjusted in the same direction!
+    Filter::ButterworthLP<float> butter =  Filter::ButterworthLP<float>(10,0.05f,2);
+    Filter::ButterworthLP<float> butter2 =  Filter::ButterworthLP<float>(10,0.1f,2);
+    FixedFrequencyInterpolator<float> ffi = FixedFrequencyInterpolator<float>(Timestamp::fromMS(100));
+
+public:
+
+
+	/** ctor */
+    ActivityButterPressure() : currentActivity(STAY){
+        ;
+	}
+
+
+	/** add new sensor readings that were received at the given timestamp */
+    Activity add(const Timestamp& ts, const BarometerData& baro) {
+
+        //init
+        static bool firstCall = false;
+        if(!firstCall){
+            butter.stepInitialization(baro.hPa);
+            firstCall = true;
+
+            butter2.stepInitialization(0);
+            return STAY;
+        }
+
+        input.push_back(History(ts, baro));
+
+        bool newInterpolatedValues = false;
+
+        //interpolate & butter
+        auto callback = [&] (const Timestamp ts, const float val) {
+            float interpValue = val;
+            inputInterp.push_back(History(ts, BarometerData(interpValue)));
+
+            //butter
+            float butterValue = butter.process(interpValue);
+            output.push_back(History(ts, BarometerData(butterValue)));
+
+            newInterpolatedValues = true;
+
+        };
+        ffi.add(ts, baro.hPa, callback);
+
+        if(newInterpolatedValues == true){
+
+            //getActivity
+            if(output.size() > diffSize){
+                //diff
+                std::vector<float> diff;
+                for(int i = output.size() - diffSize; i < output.size() - 1; ++i){
+
+                    float diffVal = output[i+1].data.hPa - output[i].data.hPa;
+
+                    diff.push_back(diffVal);
+                }
+
+                float sum = 0;
+                for(float val : diff){
+                    sum += val;
+                }
+
+                float actValue = 0;
+                if(additionalLowpassFilter == true){
+                    //additional butter/moving average for the results
+                    //mvAvg.add(sum);
+                    //actValue = mvAvg.get();
+                    actValue = butter2.process(sum);
+                }else{
+                    actValue = sum;
+                }
+                sumHist.push_back(actValue);
+
+                if(actValue > threshold){
+                    currentActivity = DOWN;
+                }
+                else if (actValue < -threshold){
+                    currentActivity = UP;
+                }
+                else{
+                    currentActivity = STAY;
+                }
+            }
+        }
+
+        actHist.push_back(History(ts, BarometerData(currentActivity)));
+
+        return currentActivity;
+
+	}
+
+    /** get the current Activity */
+    Activity getCurrentActivity() {
+        return currentActivity;
+	}
+
+    std::vector<float> getSensorHistory(){
+        std::vector<float> tmp;
+
+        for(History val : input){
+            tmp.push_back(val.data.hPa);
+        }
+
+        return tmp;
+    }
+
+    std::vector<float> getInterpolatedHistory(){
+        std::vector<float> tmp;
+
+        for(History val : inputInterp){
+            tmp.push_back(val.data.hPa);
+        }
+
+        return tmp;
+    }
+
+    std::vector<float> getOutputHistory(){
+
+        std::vector<float> tmp;
+
+        for(History val : output){
+            tmp.push_back(val.data.hPa);
+        }
+
+        return tmp;
+    }
+
+    std::vector<float> getSumHistory(){
+        return sumHist;
+    }
+
+
+    std::vector<History> getActHistory(){
+
+        return actHist;
+    }
+
+
+};
+
+#endif // ACTIVITYBUTTERPRESSURE_H