As5047p magnetic encoder wrong velocity

Laurenz_Kaml · May 9, 2023, 4:52pm

Hi there,

So standing still the as5047p encoder sends velocities via SPI which are wrong. Has anyone ever had similar problems / encoders which don’t have this problem ?

The angle is correct.

Thanks for the response,

Owen_Williams · May 13, 2023, 4:55am

It would be good to see your code to see what you are doing.
I suspect you are calling getVelocity() on sensor.
It is worth looking at the implementation for that function:

github.com

simplefoc/Arduino-FOC/blob/05954cb9691534dd478407505d810a68f1673a5e/src/common/base_classes/Sensor.cpp#

#include "Sensor.h"
#include "../foc_utils.h"
#include "../time_utils.h"



void Sensor::update() {
    float val = getSensorAngle();
    angle_prev_ts = _micros();
    float d_angle = val - angle_prev;
    // if overflow happened track it as full rotation
    if(abs(d_angle) > (0.8f*_2PI) ) full_rotations += ( d_angle > 0 ) ? -1 : 1; 
    angle_prev = val;
}


 /** get current angular velocity (rad/s) */
float Sensor::getVelocity() {
    // calculate sample time
    float Ts = (angle_prev_ts - vel_angle_prev_ts)*1e-6;

This file has been truncated. show original

The velocity isn’t coming from the sensor (over SPI) but is calculated in software. It works it out as (newAngle - oldAngle) / time since last angle measured.

Some observations.

You are sampling at a very high frequency.
You are showing your angle to 1 decimal place

If you were to show your angle to 4dp you’d see the angle is fluctuating between (for example) 4.2125 and 4.2159. i.e newAngle - oldAngle is constantly changing a small amount and this amount is ‘noise’.

If you are sampling at 1khz your time delays is 0.001.

The function is doing something like
v=(4.2159-4.2125)/0.001=3.4

I’d print angle more accurately and ignore or compensate for noise (e.g low pass filter). If you sample at 100hz, you’d see less velocity noise. I think you get a low pass filter for free if you use motor.shaftVelocity()

github.com

simplefoc/Arduino-FOC/blob/05954cb9691534dd478407505d810a68f1673a5e/src/common/base_classes/FOCMotor.cpp#L67


      
            current_sense = _current_sense;
          }
          
          
// shaft angle calculation
          float FOCMotor::shaftAngle() {
            // if no sensor linked return previous value ( for open loop )
            if(!sensor) return shaft_angle;
            return sensor_direction*LPF_angle(sensor->getAngle()) - sensor_offset;
          }
          // shaft velocity calculation
          float FOCMotor::shaftVelocity() {
            // if no sensor linked return previous value ( for open loop )
            if(!sensor) return shaft_velocity;
            return sensor_direction*LPF_velocity(sensor->getVelocity());
          }
          
          
float FOCMotor::electricalAngle(){
            // if no sensor linked return previous value ( for open loop )
            if(!sensor) return electrical_angle;
            return  _normalizeAngle( (float)(sensor_direction * pole_pairs) * sensor->getMechanicalAngle()  - zero_electric_angle );
          }

runger · May 13, 2023, 7:23am

Hey, you’re right @Owen_Williams, but depending on how all this is being used, I would not call motor.shaftVelocity()
This is because the LPF is not stateless, it remembers the last time it was called. motor.move() already calls motor.shaftVelocity() so calling it again from your own code will result in a very short time interval.
Better to use the field motor.shaft_velocity which contains the last LPF-smoothed velocity value as calculated by motor.move()… you can read that field as often as you like and it won’t affect the calculation.