Diff: main.cpp

Revision:

24:2637e0160301

Parent:

23:4c66541f00d3

Child:

25:10be3ac71e2f

--- a/main.cpp	Mon Oct 14 10:36:54 2019 +0000
+++ b/main.cpp	Wed Oct 16 12:13:09 2019 +0000
@@ -1,6 +1,7 @@
 #include "mbed.h"
 #include "HIDScope.h"
 #include "BiQuad.h"
+#include "algorithm"
 Serial pc(USBTX, USBRX);
 InterruptIn but1(PTC6);
 
@@ -17,81 +18,172 @@
 AnalogIn    emg1( A1 );
 
 Ticker      sample_timer;
+Ticker      calibrate_emg_timer;
 HIDScope    scope( 3 );
-DigitalOut  led(LED2);
+DigitalOut  led1(LED1);
+DigitalOut  led2(LED2);
+DigitalOut  led3(LED3);
 
 /** Sample function
  * this function samples the emg and sends it to HIDScope
  **/
  
- float sample_max = 0.0f;
- float sample_min = 1.0f;
+ /*
+ double sample_max = 0.0f;
+ double sample_min = 1.0f;
+ int o = 0;
  
     float emg0_value = emg0.read(); 
     float emg1_value = emg1.read();
  
     float filter_value = fabs(bq2.step(fabs(bq1.step(emg0_value - emg1_value))));
+ */
 
+const int length = 1000;
+int i = 0;
+int j = 0;
 
-void calibrate() {
-    if (filter_value > sample_max) {
-        sample_max = filter_value;
-        }
-    if (sample_min > filter_value) {
-        sample_min = filter_value;
-        }
-    filter_value = filter_value-sample_min;
-    filter_value = filter_value/(sample_max-sample_min);
-    pc.printf("Calibrate function has been called\n\r");
-    } 
+float filter_value;
+float filter_value_2;
+float emg0_value;
+float emg1_value;
 
- 
+float emg_mean_array[length] = { };
+float emg_mean;
+
+float filter_max = 0;
+
 void sample()
 {
     /* Set the sampled emg values in channel 0 (the first channel) and 1 (the second channel) in the 'HIDScope' instance named 'scope' */
-    float emg0_value = emg0.read(); 
-    float emg1_value = emg1.read();
+    emg0_value = emg0.read(); 
+    emg1_value = emg1.read();
     
     //double filter_value = bqc.step(emg1_value);
-    float filter_value = fabs(bq2.step(fabs(bq1.step(emg0_value - emg1_value))));
-    //float filter_value = fabs(bq2.step(fabs(bq1.step(emg0_value))));     //alleen emg0 geeft een betere baseline dan emg0 - emg1
+    //filter_value = fabs(bq2.step(fabs(bq1.step(emg0_value - emg1_value))));
+    //float filter_value = fabs(bq2.step(fabs(bq1.step(emg0_value))));                            //alleen emg0 geeft een betere baseline dan emg0 - emg1
+    
+    
     /*
     if (filter_value > sample_max) {
         sample_max = filter_value;
         }
-    if (sample_min > filter_value) {
+    if (filter_value < sample_min) {
         sample_min = filter_value;
         }
-    */
+        
+      
+    //filter_value = filter_value/sample_max;  
     
+    filter_value = filter_value-((sample_max+sample_min)/2);
+    filter_value = filter_value/(sample_max-sample_min);
+    */ 
+    
+    
+    //filter_value = filter_value - filter_mean;
+    //filter_value = filter_value/filter_max;
     
     //but1.mode(PullUp); 
     //but1.rise(&calibrate);
     
-    calibrate();
-    
     
     scope.set(0, emg0.read() );
     scope.set(1, emg1.read() );
-    scope.set(2, filter_value);
     /* Repeat the step above if required for more channels of required (channel 0 up to 5 = 6 channels) 
     *  Ensure that enough channels are available (HIDScope scope( 2 ))
     *  Finally, send all channels to the PC at once */
     scope.send();
     /* To indicate that the function is working, the LED is toggled */
-    led = !led;
+    led2 = !led2;
 }
 
+
+
+
+
+float emg0_value_2;
+float emg1_value_2;
+float emg_mean_corr;
+
+void sample_2() {                                                               // mean corrected emg waarden die worden gebruikt voor de eerste instantie van filter_value.
+    emg0_value_2 = emg0.read();
+    emg1_value_2 = emg1.read();
     
+    emg_mean_corr = (emg0_value_2-emg1_value_2)-emg_mean;
+    
+    filter_value = fabs(bq2.step(fabs(bq1.step(emg_mean_corr))));
+    scope.set(2, filter_value); 
+    }
+    
+
+
+
+float filter_array[length] = { };
+
+void calibration_preparation() {
+        while (i < length) {
+        sample();
+        filter_array [i] = filter_value;
+        i++;
+        }
+        
+    
+    int filter_max = 0;
+    int m;
+    for (m = 0 ; m < length ; m++);
+
+        if (filter_array[m] > filter_max) {
+            filter_max = filter_array[m];
+            }
+}
+
+
+
+
+
+void emg_mean_function() {
+    while (j < length) {
+        sample();
+        emg_mean_array[i] = emg0_value - emg1_value;
+        j++;
+        }
+    float emg_sum = 0;
+    for (int n = 0; n < length; n++) {
+        emg_sum += emg_mean_array[n];
+        }
+        emg_mean = emg_sum/length;
+}
+    
+
+
+
+void sample_3() {
+    
+    filter_value_2 = filter_value/filter_max;
+    
+    scope.set(2, filter_value_2 );
+}
+
 int main()
 {   
+
     pc.baud(115200);
-    bqc.add( &bq1);
+
     /**Attach the 'sample' function to the timer 'sample_timer'.
     * this ensures that 'sample' is executed every... 0.002 seconds = 500 Hz
     */
-    sample_timer.attach(&sample, 0.002);
+    
+    
+    emg_mean_function();
+    sample_2();
+    
+    
+    
+
+    sample_timer.attach(&sample_3, 0.001);
     /*empty loop, sample() is executed periodically*/
+    //pc.printf("The value of sample_min is %f\n\r",sample_min);
+    //pc.printf("The value of sample_max is %f\n\r",sample_max); 
     while(1) {
         }
 }