sensor precision fix - refactored API

Author: runger1101001

src/common/base_classes/Sensor.cpp

@@ -3,8 +3,9 @@
 #include "../time_utils.h"
 
 
-float Sensor::getAngle() {
-    float val = getShaftAngle();
+
+float Sensor::updateSensor() {
+    float val = getSensorAngle();
     angle_prev_ts = _micros();
     float d_angle = val - angle_prev;
     // if overflow happened track it as full rotation
@@ -14,7 +15,6 @@ float Sensor::getAngle() {
 }
 
 
-
  /** get current angular velocity (rad/s)*/
 float Sensor::getVelocity() {
     // calculate sample time
@@ -30,14 +30,19 @@ float Sensor::getVelocity() {
 }
 
 
+float Sensor::getShaftAngle() {
+    return angle_prev;
+}
+
+
 
-float Sensor::getPosition(){
+float Sensor::getAngle(){
     return (float)full_rotations * _2PI + angle_prev;
 }
 
 
 
-double Sensor::getPrecisePosition() {
+double Sensor::getPreciseAngle() {
     return (double)full_rotations * (double)_2PI + (double)angle_prev;
 }
 

src/common/base_classes/Sensor.h

@@ -32,7 +32,7 @@ enum Pullup{
  * method. getAngle() returns a float value, in radians, representing the current shaft angle in the
  * range 0 to 2*PI (one full turn). 
  * 
- * To function correctly, the sensor class getAngle() method has to be called sufficiently quickly. Normally,
+ * To function correctly, the sensor class updateSensor() method has to be called sufficiently quickly. Normally,
  * the BLDCMotor's loopFOC() function calls it once per iteration, so you must ensure to call loopFOC() quickly
  * enough, both for correct motor and sensor operation.
  * 
@@ -43,17 +43,26 @@ enum Pullup{
  */
 class Sensor{
     public:
-        /** 
-         * Get current shaft angle, as a float in radians, in the range 0 to 2PI.
+        /**
+         * Get shaft angle in the range 0 to 2PI. This value will be as precise as possible with
+         * the hardware.
+         */
+        virtual float getShaftAngle();
+
+        /**
+         * Get current position (in rad) including full rotations and shaft angle
+         * Note that this value has limited precision as the number of rotations increases,
+         * because the limited precision of float can't capture the large angle of the full 
+         * rotations and the small angle of the shaft angle at the same time.
          */
         virtual float getAngle();
+        
         /** 
-         * Get current shaft angle, as a float in radians, in the range 0 to 2PI.
-         * This method is pure virtual and must be implemented in subclasses.
-         * Calling this method directly does not update the base-class internal fields.
-         * Use getAngle() when calling from other code.
+         * On architectures supporting it, this will return a double precision position value,
+         * which should have improved precision for large position values.
          */
-        virtual float getShaftAngle()=0;
+        virtual double getPreciseAngle();
+
         /** 
          * Get current angular velocity (rad/s)
          * Can be overridden in subclasses. Base implementation uses the values 
@@ -62,22 +71,23 @@ class Sensor{
         virtual float getVelocity();
 
         /**
-         * Get current position (in rad) including full rotations and shaft angle
-         * Note that this value has limited precision as the number of rotations increases,
-         * as the limited precision of float can't capture the large angle of the full rotations
-         * and the small angle of the shaft angle at the same time.
-         */
-        virtual float getPosition();
-
-        /** 
-         * On architectures supporting it, this will return a double precision position value
+         * Get the number of full rotations
          */
-        virtual double getPrecisePosition();
+        virtual int32_t getFullRotations();
 
         /**
-         * Get the number of full rotations
+         * Updates the sensor values by reading the hardware sensor.
+         * Some implementations may work with interrupts, and not need this.
+         * The base implementation calls getSensorAngle(), and updates internal
+         * fields for angle, timestamp and full rotations.
+         * This method must be called frequently enough to guarantee that full
+         * rotations are not "missed" due to infrequent polling.
+         * Override in subclasses if alternative behaviours are required for your
+         * sensor hardware.
+         * 
+         * Returns the current value of getShaftAngle()
          */
-        virtual int32_t getFullRotations();
+        virtual float updateSensor();
 
         /** 
          * returns 0 if it does need search for absolute zero
@@ -86,6 +96,16 @@ class Sensor{
          */
         virtual int needsSearch();
     protected:
+        /** 
+         * Get current shaft angle from the sensor hardware, and 
+         * return it as a float in radians, in the range 0 to 2PI.
+         * 
+         * This method is pure virtual and must be implemented in subclasses.
+         * Calling this method directly does not update the base-class internal fields.
+         * Use updateSensor() when calling from outside code.
+         */
+        virtual float getSensorAngle()=0;
+
         // velocity calculation variables
         float angle_prev=0; // result of last call to getAngle, used for full rotations and velocity
         long angle_prev_ts=0; // timestamp of last call to getAngle, used for velocity

src/sensors/Encoder.cpp

@@ -101,23 +101,22 @@ void Encoder::handleIndex() {
 /*
 	Shaft angle calculation
 */
-float Encoder::getAngle(){
+float Encoder::getSensorAngle(){
+  return getShaftAngle();
+}
+float Encoder::getShaftAngle(){
   return  _2PI * (pulse_counter % (int)cpr);
 }
 
-float Encoder::getPosition(){
+float Encoder::getAngle(){
   return  _2PI * (pulse_counter) / ((float)cpr);
 }
-double Encoder::getPrecisePosition(){
+double Encoder::getPreciseAngle(){
   return  _2PI * (pulse_counter) / ((double)cpr);
 }
 int32_t Encoder::getFullRotations(){
   return  pulse_counter / (int)cpr;
 }
-float Encoder::getShaftAngle(){
-  return  getAngle();
-}
-
 
 
 

src/sensors/Encoder.h

@@ -60,12 +60,12 @@ class Encoder: public Sensor{
 
     // Abstract functions of the Sensor class implementation
     /** get current angle (rad) */
+    float getSensorAngle() override;
     float getShaftAngle() override;
-    float getAngle() override;
     /**  get current angular velocity (rad/s) */
     float getVelocity() override;
-    float getPosition() override;
-    double getPrecisePosition() override;
+    float getAngle() override;
+    double getPreciseAngle() override;
     int32_t getFullRotations() override;
 
     /**

src/sensors/HallSensor.cpp

@@ -92,11 +92,19 @@ void HallSensor::attachSectorCallback(void (*_onSectorChange)(int sector)) {
   onSectorChange = _onSectorChange;
 }
 
+
+
+float HallSensor::getSensorAngle() {
+  return getShaftAngle();
+}
+
+
+
 /*
 	Shaft angle calculation
 */
-float HallSensor::getAngle() {
-  return getShaftAngle();
+float HallSensor::getShaftAngle() {
+  return (float)((electric_rotations * 6 + electric_sector) % cpr) * _2PI ;
 }
 
 /*
@@ -114,17 +122,12 @@ float HallSensor::getVelocity(){
 
 
 
-float HallSensor::getShaftAngle() {
-  return (float)((electric_rotations * 6 + electric_sector) % cpr) * _2PI ;
-}
-
-
-float HallSensor::getPosition() {
+float HallSensor::getAngle() {
   return ((float)(electric_rotations * 6 + electric_sector) / (float)cpr) * _2PI ;
 }
 
 
-double HallSensor::getPrecisePosition() {
+double HallSensor::getPreciseAngle() {
   return ((double)(electric_rotations * 6 + electric_sector) / (double)cpr) * (double)_2PI ;
 }
 

src/sensors/HallSensor.h

@@ -54,12 +54,12 @@ class HallSensor: public Sensor{
 
     // Abstract functions of the Sensor class implementation
     /** get current angle (rad) */
+    float getSensorAngle() override;
     float getShaftAngle() override;
     float getAngle() override;
     /**  get current angular velocity (rad/s) */
     float getVelocity() override;
-    float getPosition() override;
-    double getPrecisePosition() override;
+    double getPreciseAngle() override;
     int32_t getFullRotations() override;
 
     // whether last step was CW (+1) or CCW (-1).  

src/sensors/MagneticSensorAnalog.cpp

@@ -28,7 +28,7 @@ void MagneticSensorAnalog::init(){
 
 //  Shaft angle calculation
 //  angle is in radians [rad]
-float MagneticSensorAnalog::getShaftAngle(){
+float MagneticSensorAnalog::getSensorAngle(){
   // raw data from the sensor
   raw_count = getRawCount();   
   return ( (float) (raw_count) / (float)cpr) * _2PI;

src/sensors/MagneticSensorAnalog.h

@@ -29,7 +29,7 @@ class MagneticSensorAnalog: public Sensor{
 
     // implementation of abstract functions of the Sensor class
     /** get current angle (rad) */
-    float getShaftAngle() override;
+    float getSensorAngle() override;
     /** raw count (typically in range of 0-1023), useful for debugging resolution issues */
     int raw_count;
 

src/sensors/MagneticSensorI2C.cpp

@@ -68,7 +68,7 @@ void MagneticSensorI2C::init(TwoWire* _wire){
 
 //  Shaft angle calculation
 //  angle is in radians [rad]
-float MagneticSensorI2C::getShaftAngle(){
+float MagneticSensorI2C::getSensorAngle(){
   // (number of full rotations)*2PI + current sensor angle 
   return  ( getRawCount() / (float)cpr) * _2PI ;
 }

src/sensors/MagneticSensorI2C.h

@@ -46,7 +46,7 @@ class MagneticSensorI2C: public Sensor{
 
     // implementation of abstract functions of the Sensor class
     /** get current angle (rad) */
-    float getShaftAngle() override;
+    float getSensorAngle() override;
 
     /** experimental function to check and fix SDA locked LOW issues */
     int checkBus(byte sda_pin = SDA, byte scl_pin = SCL);