Diff: IRsensor.cpp

Revision:

2:35b3dd6f7f17

Parent:

1:fe97d826508d

Child:

3:26e2cfa5a983

--- a/IRsensor.cpp	Tue Jun 25 08:45:06 2019 +0000
+++ b/IRsensor.cpp	Thu Aug 22 06:09:57 2019 +0000
@@ -1,56 +1,88 @@
 #include "IRsensor.h"
 
-IRsensor::IRsensor(PinName pin):a_in(pin)
+IRsensor::IRsensor(PinName pin):
+    a_in(pin)
 {
+    thread_get_distance.start(callback(this, &IRsensor::threadloop_get_distance));
 }
 
-float IRsensor::getInputvoltage(){
-    float voltage = a_in.read()*3.3;
-    return voltage;
+void IRsensor::threadloop_get_distance()
+{
+    while(true){
+        compute_distance();
+    }
 }
 
-float IRsensor::getDistance(int n){
-    float distance_sum=0;
-    for(int i=0;i<n;i++){
-        distance_sum += changeVtoD(getInputvoltage());
-    }  
-    return distance_sum / n;    
+void IRsensor::compute_distance(){
+    getInputvoltage();
+    changeVtoD();
+}
+
+void IRsensor::getInputvoltage(){
+    voltage = a_in.read()*3.3f;
 }
 
-float IRsensor::changeVtoD(float voltage)
+void IRsensor::changeVtoD()
 {
-    float distance;
     if (voltage > 2.285f) {
-        distance = 0.0f;
+        originaldistance = 0.0f;
     } else if (voltage > 1.645f) {
-        distance = -7.8125f * voltage + 27.8515f;
+        originaldistance = -7.8125f * voltage + 27.8515f;
     } else if (voltage > 1.305f) {
-        distance = -14.7058f * voltage + 39.1911f;
+        originaldistance = -14.7058f * voltage + 39.1911f;
     } else if (voltage > 1.08f) {
-        distance = -22.222f * voltage + 49.0f;
+        originaldistance = -22.222f * voltage + 49.0f;
     } else if (voltage > 0.928f) {
-        distance = -32.89473f * voltage + 60.526f;
+        originaldistance = -32.89473f * voltage + 60.526f;
     } else if (voltage > 0.835f) {
-        distance = -53.7634f * voltage + 79.89247f;
+        originaldistance = -53.7634f * voltage + 79.89247f;
     } else if (voltage > 0.737f) {
-        distance = -51.02040f * voltage + 77.60204f;
+        originaldistance = -51.02040f * voltage + 77.60204f;
     } else if (voltage > 0.673f) {
-        distance = -78.12500f * voltage + 97.57812f;
+        originaldistance = -78.12500f * voltage + 97.57812f;
     } else if (voltage > 0.608f) {
-        distance = -76.92307f * voltage + 96.76923f;
+        originaldistance = -76.92307f * voltage + 96.76923f;
     } else if (voltage > 0.562f) {
-        distance = -108.6956f * voltage + 116.0869f;
+        originaldistance = -108.6956f * voltage + 116.0869f;
     } else if (voltage > 0.515f) {
-        distance = -106.3829f * voltage + 114.7872f;
+        originaldistance = -106.3829f * voltage + 114.7872f;
     } else if (voltage > 0.474f) {
-        distance = -121.9512f * voltage + 122.8048f;
+        originaldistance = -121.9512f * voltage + 122.8048f;
     } else if (voltage > 0.447f) {
-        distance = -185.1851f * voltage + 152.7777f;
+        originaldistance = -185.1851f * voltage + 152.7777f;
     } else if (voltage > 0.432f) {
-        distance = -333.333f * voltage + 219.0f;
+        originaldistance = -333.333f * voltage + 219.0f;
     } else {
-        distance = 9999.9f;
+        originaldistance = 9999.9f;
     }
- 
-    return distance;
+}
+
+void IRsensor::startAveraging(uint8_t averaging_range)
+{
+    bufferSize = averaging_range;
+    data = new float[bufferSize+1];
+    thread_averaging_distance.start(callback(this, &IRsensor::threadloop_averaging_distance));
+}
+void IRsensor::threadloop_averaging_distance()
+{
+    while(true){
+        computeaverage();
+    }    
 }
+void IRsensor::computeaverage()
+{
+    bufferpoint++;
+    data[bufferpoint % bufferSize] = originaldistance;
+    distance_sum = 0;
+    for(int i = 0;i<bufferSize;i++)
+        distance_sum += data[i];
+    distance_average = distance_sum / bufferSize;
+}
+float IRsensor::getDistance()
+{
+    return originaldistance;   
+}
+float IRsensor::get_Averagingdistance()
+{
+    return distance_average;    
+}