PWM command interferance

[SevitRoy]

Hi there,

I am trying to perform a step response on a HEBI robotic x8-9 actuator for some system identification data. To do this I put the motor in PWM mode and gave it a cmd command of 1 (in documentation effort cmd's are direct PWM cmd's in strategy 1). I have decoupled my system from the load so it can run freely for now. I was expecting to see a maximum acceleration toward the maximum velocity, but a noticed that the PWM signal gets flattened off long before that speed is reached (or the PWM hits a value of 1), checking the alarms however does not reveal any triggers.

Below is an image of the step response, notice how the PWM signal gets manipulated (delayed) from a value of around 0.6, then rises to 0.8, and stabilizes towards a 0.5 probably because the velocity limit has now been reached (not shown in the alarm states however).

I also included a zoom of the pwmCmd signal and the corresponding responses here:

Here is an image of the alarm states.

I am wondering why this PWM modulation happens and what is a proper way to collect system identification data on these actuators?

Kind regards,

Roy

For completeness I also uploaded the full MATLAB code that executes the PWM code and plots the figures here (from some reason i notice that some parts are plotted as clean text and i don't have an immediate idea why that is, apologies for this):

%% Cleanup
clc
clear;
close all;

%% Record a impulse response

sampleFreq = 500;

% Connect to hebi
 app.hebiConnected = false;
                       
 addresses = {
     '10.11.12.255'
 };

HebiLookup.setLookupAddresses(addresses);

disp(HebiLookup);

try
serials = {'X-80926'};
group = HebiLookup.newGroupFromSerialNumbers(serials);
hebiConnected = true;
catch
errordlg('HEBI Module not found!', 'Module Error');
hebiConnected = false;
end

if (hebiConnected == true)

group.setFeedbackFrequency(sampleFreq);
group.setCommandLifetime(0); % Command lifetime of infinite

% Create cmd struct for HEBI modules
cmd=CommandStruct();

% Request full feedback:
fbk = group.getNextFeedbackFull();

foc = FocCommandStruct();

% Move nicely to zero
gains = GainStruct();

gains.positionKp = 50;
gains.positionKi = 5;
gains.positionKd = 0.5;
gains.positionFF = 1;

gains.velocityKp = 0.03;
gains.velocityKi = 0;
gains.velocityKd = 0;
gains.velocityFF = 1;

gains.controlStrategy = 4;
gains.effortKp=0.1;
gains.effortKi=0.01;
gains.effortKd=0.0001;
gains.effortDeadZone=0;
gains.effortIClamp=0.25;
gains.effortPunch=0;
gains.effortFF =1;

% sendSafetyParams;

group.send('gains', gains);

% Move to neutralAngle:

neutralAngle = 0; % Rad/sec

% Setup
trajGen = HebiTrajectoryGenerator();

% Get current position
posHebiStart = fbk.position;
posHebiEnd = neutralAngle * pi /180;

% Create trajectory
positions = [posHebiStart posHebiEnd];

time = [0 3];

trajectory = trajGen.newJointMove(positions, 'time', time);

% execute trajectory

pause(1);

t0 = tic();
t = toc(t0);

while t < trajectory.getDuration()
    
    fbk = group.getNextFeedback();
    
    % Get trajectory state at the current time
    t = toc(t0);
    [pos, vel, ~] = trajectory.getState(t);
    
    % Send the commands
    cmd.position = pos;
    cmd.velocity = vel;
    group.send(cmd);
    
end


cmd.position = posHebiEnd;
cmd.velocity = 0;
cmd.effort = 0;    
group.send('Cmd', cmd);

dfLimit = -2; %-0.75; % rad
pfLimit = 2; %0.45; % rad

% This should put the controller in direct PWM
gains.controlStrategy = 1;

% gains.controlStrategy = ControlStrategyDirectPWM;
group.send('gains', gains);

cmd.effort = 0;
group.send(cmd);

% Start Hebi Log
hebiLogFile = group.startLog('Directory', pwd);  

fbk = group.getNextFeedbackFull();

performDFStep = 0;

if performDFStep
    cmd.effort = -1;
    group.send(cmd);
    
    while fbk.position >= dfLimit
        disp(fbk.position)
        fbk = group.getNextFeedback();    
        cmd.effort = -1;
        group.send(cmd);
    end

else

    cmd.effort = 1;
    group.send(cmd);
    
    while fbk.position <= pfLimit
        disp(fbk.position)
        fbk = group.getNextFeedback();    
        cmd.effort = 1;
        group.send(cmd);
    end

end

cmd.effort = 0;
group.send(cmd);

hebiData = group.stopLog();

matfile = HebiUtils.convertGroupLog(hebiLogFile, 'format', 'mat', 'view', 'Full');

end

%% Load an example Hebi log file and save

% load raw log file

hebiData = load(matfile);
% binaryFile = 'hebiImpulseResponsePos.hebilog';
% matfile = HebiUtils.convertGroupLog(binaryFile, 'format', 'mat', 'view', 'Full');
% dataScopeStepResponse = load(matfile);
%
% hebiData = dataScopeStepResponse;
%threshold = 0;

figurename = "Hebi motor response";
h = figure('Name',figurename,'NumberTitle','on', 'WindowState','maximized');
plot(hebiData.time, hebiData.pwmCmd, 'k:');
hold on;
plot(hebiData.time, hebiData.innerEffortCmd, 'k');

plot(hebiData.time, hebiData.motorCurrent, 'r:');
plot(hebiData.time, hebiData.windingCurrent, 'r.-');
plot(hebiData.time, hebiData.voltage);

plot(hebiData.time, hebiData.motorPosition, 'g:');
plot(hebiData.time, hebiData.motorVelocity, 'g.-');

legend('pwm Cmd', 'inner effort cmd ', 'motorCurrent', 'windingCurrent', 'Voltage', 'motorPosition', 'motorVelocity');
xlabel ('Time (s)');
ylabel ('Values');

figurename = "Hebi output response";
h = figure('Name',figurename,'NumberTitle','on', 'WindowState','maximized');
plot(hebiData.time, hebiData.pwmCmd, 'k:');
hold on;
plot(hebiData.time, hebiData.innerEffortCmd, 'k');

plot(hebiData.time, hebiData.position, 'r');
plot(hebiData.time, hebiData.velocity, 'g');
plot(hebiData.time, hebiData.effort, 'b');

%plot(hebiData.time, hebiData.deflection, 'b:');
%plot(hebiData.time, hebiData.deflectionVelocity, 'b.-');

hold off;

legend('pwm Cmd', 'inner effort cmd ', 'pos Response', 'vel Response', 'torque Response', 'deflection', 'deflection Velocity');
xlabel ('Time (s)');
ylabel ('Values');
%% plot the alarms

figurename = "Hebi alarms";
h = figure('Name',figurename,'NumberTitle','on', 'WindowState','maximized');
plot(hebiData.time, hebiData.commandLockState);
hold on;
plot(hebiData.time, hebiData.resetButtonState);
plot(hebiData.time, hebiData.mStopState);
plot(hebiData.time, hebiData.temperatureState);
plot(hebiData.time, hebiData.positionLimitState);
plot(hebiData.time, hebiData.velocityLimitState);
plot(hebiData.time, hebiData.effortLimitState);
hold off;

ylim([-1.5 1.5])
xlabel('time (s)')
ylabel('state logical')
legend('CMD Lock', 'Reset But', 'motor Stop', 'temp state', 'position state', 'velocity state', 'effort state');

[daverolli]

Roy,

What you're seeing are some of the safety controllers activating that limit the actuators.
http://docs.hebi.us/core_concepts.html#safety_controller

There's a motor velocity safety limit that is a PI controller that keeps the motor under a certain RPM to prevent damage to the geartrain. There's also a motor voltage limit that caps the max voltage that can be applied to the motor. This limit is based on the motor's velocity. So based on the plots above, it looks like:

• First the actuator hits the voltage limit
• Then it raises voltage limit briefly as the motor speeds up
• Then the velocity control engages due to the motor overshooting the max allowable velocity

Of the low-level safety controllers (the 'fixed' controllers in red at the link above), only the temperature limit will show an alarm state or change the status LEDs. We'll get some more information on this added to the documentation.

Since at your voltage the motor reaches its max velocity at about 0.5 PWM you can command that as your step and you should get a response that is a little slower, but doesn't have any of the safety controllers engaging.

Hope this helps,
-Dave

[SevitRoy]

Hi Dave,

Thanks for that reply, it helps indeed.

I did not recognize that the motor would (or could) go above it maximum speed when commanded a PWM signal of 1, I expected it to speed up to it's no load speed...

Anyway, I will apply a PWM value of 0.5.

Kind regards,

Roy

[daverolli]

The no load speeds of these motors if we exposed them to full bus voltage could be well over 40,000RPM. So we use firmware to limit the applied voltage to protect it and the geartrain components. This lets us use a higher bus voltage to keep current draw low externally on the power bus.

Sorry for the initial confusion and let us know if you have any other questions!