Threshold detection on microphone

.pio/build/project.checksum

@@ -1 +1 @@
-33fbac06369f5bf11a69f69fbfd44d9348159aec
+dccaf109dbb3390bdd324df2834753b42018e721

src/Animation/ProtogenKitFaceAnimation.h

@@ -188,7 +188,7 @@ class ProtogenKitFaceAnimation : public Animation<2> {
         sA.Update();
         sA.SetHueAngle(ratio * 360.0f * 4.0f);
 
-        float mouthMove = sA.GetCurrentValue();
+        float mouthMove = MicrophoneFourier::GetCurrentMagnitude();
 
         if (isBooped){
             Surprised();

src/Filter/DerivativeFilter.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <Arduino.h>
+#include "KalmanFilter.h"
+#include "MinFilter.h"
+#include "..\Math\Mathematics.h"
+
+class DerivativeFilter{
+private:
+    KalmanFilter<10> output = KalmanFilter<10>(0.2f);
+    MinFilter<40> minFilter;
+    float previousReading = 0.0f;
+    float outputValue = 0.0f;
+
+public:
+    DerivativeFilter(){}
+
+    float GetOutput(){
+        return outputValue;
+    }
+
+    float Filter(float value){
+        float amplitude = fabs(value - previousReading);
+        float normalized = output.Filter(amplitude);
+        float minimum = minFilter.Filter(normalized);
+
+        previousReading = value;
+        outputValue = Mathematics::Constrain(normalized - minimum, 0.0f, 1.0f);
+
+        return outputValue;
+    }
+
+};

src/Filter/FFTFilter.h

@@ -7,9 +7,8 @@
 
 class FFTFilter{
 private:
-    KalmanFilter<10> mv = KalmanFilter<10>(0.1f);
     MinFilter<40> minF = MinFilter<40>();
-    KalmanFilter<10> output = KalmanFilter<10>(0.1f);
+    KalmanFilter<5> output = KalmanFilter<5>(0.5f);
     float previousReading = 0.0f;
     float outputValue = 0.0f;
 
@@ -20,17 +19,17 @@ class FFTFilter{
         return outputValue;
     }
 
-    float Update(float value){
+    float Filter(float value){
         float changeRate = value - previousReading;
         float amplitude = fabs(changeRate);//mv.Filter(fabs(changeRate));
         float minimum = minF.Filter(value);
         float normalized = value - amplitude - minimum;
-        float truncate = normalized < 0 ? 0 : output.Filter(normalized);//output.Filter(normalized);
+        float truncate = normalized < 0 ? 0 : normalized;//output.Filter(normalized);
 
         previousReading = value;
         outputValue = Mathematics::Constrain(truncate, 0.0f, 1.0f);
 
         return outputValue;
     }
 
-};
+};

src/Filter/KalmanFilter.h

@@ -7,14 +7,6 @@ class KalmanFilter {
 	float values[memory];
   	uint8_t currentAmount = 0;
 
-	void ShiftArray(float* arr){
-		for(uint8_t i = 0; i < memory; i++){
-			arr[i] = arr[i + 1];
-		}
-
-		arr[memory - 1] = 0.0f;
-	}
-
 public:
 	KalmanFilter() {
 		this->gain = 0.25f;
@@ -37,11 +29,14 @@ class KalmanFilter {
 			values[currentAmount++] = value;
 		}
 		else{
-			ShiftArray(values);//pop first
+			for(uint8_t i = 0; i < memory - 1; i++){
+				values[i] = values[i + 1];
+			}
+
 			values[memory - 1] = value;
 		}
 
-		for(int i = 0; i < currentAmount; i++){
+		for(uint8_t i = 0; i < currentAmount; i++){
 			sum += values[i];
 		}
 

src/Filter/PeakDetection.h

@@ -3,16 +3,16 @@
 #include <Arduino.h>
 #include "..\Math\Mathematics.h"
 
+template <size_t sampleSize>
 class PeakDetection{
 private:
-    const uint8_t sampleSize;
     uint8_t lag;
 
     float threshold;
     float influence;
-    float* filData;
-    float* avg;
-    float* std;
+    float filData[sampleSize];
+    float avg[sampleSize];
+    float std[sampleSize];
 
     void GetStdDev(uint8_t start, uint8_t length, float* data, float& avgRet, float& stdRet){
         float average = 0.0f;
@@ -21,51 +21,43 @@ class PeakDetection{
         for (uint8_t i = 0; i < length; i++){
             average += data[start + i];
         }
+
 
-        average /= length;
+        average /= (float)length;
 
         for (uint8_t i = 0; i < length; i++){
             stdDev += powf(data[start + i] - average, 2.0f);
         }
 
         avgRet = average;
-        stdRet = sqrtf(stdDev / length);
+        stdRet = sqrtf(stdDev / (float)length);
     }
 
 public:
-    PeakDetection(uint8_t sampleSize, uint8_t lag = 7, float threshold = 1.2f, float influence = 0.25f) : sampleSize(sampleSize) {
-        filData = new float[sampleSize];
-        avg = new float[sampleSize];
-        std = new float[sampleSize];
-
+    PeakDetection(uint8_t lag = 12, float threshold = 0.75f, float influence = 0.5f) {
         this->lag = lag;
         this->threshold = threshold;
         this->influence = influence;
-
-        for(uint8_t i = 0; i < sampleSize; i++){
-            filData[i] = 0.0f;
-            avg[i] = 0.0f;
-            std[i] = 0.0f;
-        }
-    }
-
-    ~PeakDetection(){
-        delete avg;
-        delete std;
     }
 
     void Calculate(float* data, float* peaks){
+        float average = 0.0f;
+        float stdDev = 0.0f;
+
         for (uint8_t i = 0; i < sampleSize; i++){
             filData[i] = 0.0f;
             avg[i] = 0.0f;
             std[i] = 0.0f;
         }
 
-        GetStdDev(0, lag, data, avg[lag - 1], std[lag - 1]);
+        GetStdDev(0, lag, data, average, stdDev);
+
+        avg[lag - 1] = average;
+        std[lag - 1] = stdDev;
 
         for(uint8_t i = lag; i < sampleSize - lag; i++){
             if(fabs(data[i] - avg[i - 1]) > threshold * std[i - 1]){
-                if(data[i] > avg[i - 1] && data[i] > 0.05f) peaks[i] = 1.0f;
+                if(data[i] > avg[i - 1]) peaks[i] = 1.0f;
                 //else peaks[i] = -1.0f;
 
                 filData[i] = influence * data[i] + (1.0f - influence) * filData[i - 1];
@@ -76,6 +68,9 @@ class PeakDetection{
             }
 
             GetStdDev(i - lag + 1, i, data, avg[i], std[i]);
+
+            avg[i] = average;
+            std[i] = stdDev;
         }
     }
 };

src/Materials/Animated/SpectrumAnalyzer.h

@@ -54,10 +54,6 @@ class SpectrumAnalyzer : public Material {
         this->material = material;
     }
 
-    float GetCurrentValue(){
-        return MicrophoneFourier::GetCurrentValue();
-    }
-
     float* GetFourierData(){
         if(bounce){
             return bounceData;