How to identify transfer function of a motor with IODelay?

I have a measurement series containing RPM measurements and their specific timestamps.

I tried to measure a step response, so the motors were starting from idle state.

My step was a setpoint of -250 RPM.

Looking at my measurement series I can see the first changes in RPM values after 117 samples (following the recorded timestamps a period of ~932ms)

Here you can look at the curve progression of the actual RPM:

Now I have done three different things to get my transfer function using tfest:

1. cutting off all samples before first change could be seen (deleting the first 115 samples)
2. using complete measurement series and adding an IODelay to tfest (115 as it is a discrete system)
3. letting matlab decide on my iodelay by using NaN as IODelay

I received three different transfer functions.

First result:

I received a transfer function that seems to behave linear.

I am not sure if this is correct to use since I cut off the first samples.

However I'd like to see this as correct since the behaviour is linear.

Additionally I am concerned because of the results of my third approach - more on this later.

Second result:

I am not sure if I understood the documentation correctly but I thought giving the number of samples as input delay works.

Obviously this is not what you want to receive as a transfer function

Third result:

This seems to fit to my measurement series relating to the IODelay.

Somehow the behaviour turned nonlinear.

The IODelay is at about 0.23s. Actually this is what I wanted to see since I expect a delay of 200ms because of some mechanism in the code.

However I am really worried about the nonlinear behaviour and how MATLAB decided to use a IODelay of 0.23s since my measurement series shows first measureable reactions to the RPM at around 932ms.

This is the short snippet I used:

motor_right = iddata(right, right_setpoint, 0.008);

data_est = set(motor_right, 'InputName', 'u2', 'OutputName', 'y2');

tf_motor_right = tfest(data_est, 2, 1); %tfest(data_est, 2, 1, 115); tfest(data_est, 2, 1, NaN);

motor_right_zpk = zpk(tf_motor_right);

If you want to see the equations for the tf please let me know.

Now I dont really know how to trust my results.

Can anyone please help me evaluating these different results?

Thank you alot in advance!

[Paul]

Hi Erik,

If you're willing, you should attach the data file (.mat file is fine) using the paperclip icon in the Insert menu. That way others can try to recreate and then modify your results.

I think you meant non-minimum phase, rather than nonlinear.

[Erik Batschkun]

I added a .mat and a short matlab script to this answer.

I am not really sure how to name it.

The poles and zeros are not in or on the unit circle, so it could be a non-minimum phase system.

I meant nonlinear because of the following two tfs I got from some other measurements.

These are both tfs I generated using the same script.

Maybe I did some mistake and thats why it came out like this but I dont know about that yet.

The step was -500 RPM for both diagrams below. For both I cut off the leading zeros in my measurements.

Answer 1

[Paul]

Hi Erik,

Here's what I tried:

Load the data

load forum.mat

Run the script so I can operate on the same variables. Take note of the warnings ...

identify_motor_behaviour

Warning: For transient data (step or impulse experiment), make sure that the change in input signal does not happen too early relative to the order of the desired model. You can achieve this by prepending sufficient number of zeros (equilibrium values) to the input and output signals. For example, a step input must be represented as [zeros(nx,1); ones(N,1)] rather than ones(N,1), such that nx > model order.

Warning: For transient data (step or impulse experiment), make sure that the change in input signal does not happen too early relative to the order of the desired model. You can achieve this by prepending sufficient number of zeros (equilibrium values) to the input and output signals. For example, a step input must be represented as [zeros(nx,1); ones(N,1)] rather than ones(N,1), such that nx > model order.

Assign a time vector using the sampling period, Ts, used to create the iddata objects

t = (0:numel(right_setpoint)-1)*0.008;

Here is the object created by tfest (after changing to zpk form). Note that it is a continous-time system

motor_right_zpk

motor_right_zpk =
 
  From input "u2" to output "y2":
    -2.9206 (s-2.224)
  ----------------------
  (s^2 + 3.158s + 6.543)
 
Continuous-time zero/pole/gain model.

Try tfest again, but specify the delay. Use the 116th element of the t vector. Might want to revisit the setpoint vector based on the warning, but we'll leave it for now.

motor_right_zpk_new = zpk(tfest(data_est,2,1,t(116)))

Warning: For transient data (step or impulse experiment), make sure that the change in input signal does not happen too early relative to the order of the desired model. You can achieve this by prepending sufficient number of zeros (equilibrium values) to the input and output signals. For example, a step input must be represented as [zeros(nx,1); ones(N,1)] rather than ones(N,1), such that nx > model order.

motor_right_zpk_new =
 
  From input "u2" to output "y2":
                    11.735 (s+22.61)
  exp(-0.92*s) * ----------------------
                 (s^2 + 12.49s + 266.2)
 
Continuous-time zero/pole/gain model.

Simulate output for original and new systems

y = lsim(motor_right_zpk,right_setpoint,t);
ynew = lsim(motor_right_zpk_new,right_setpoint,t);

Plot and compare

figure
plot(t,right,t,y,t,ynew)
xline(t(116))
legend('data','y','ynew')

ynew looks pretty good.

Again, I'll note that y is NOT the output of a nonlinear system (after all, a zpk object is a representation of a linear system, by definition). It is the output of nonminimum phase system, i.e., motor_right_zpk as a zero in the righthalf plane, which casues the initial "wrong way" response in y.

[Erik Batschkun]

Thanks alot for clarification!

As the delay differs in all my measurements I am going to delete all leading zero samples.

Sadly I cant tell where the measurement actually started (even though I set the start for all measurements on the same condition)

Why is it that there is no inverted response behaviour if I cut off the leading zeros?

[Paul]

If the system to be modeled is known to not have a delay, then it probably makes sense to delete all of the leading zeros.

It's worth pointing out that the tfest does have an option to allow the delay to be estimated, rather than provided by the user.

load forum.mat
identify_motor_behaviour

Warning: For transient data (step or impulse experiment), make sure that the change in input signal does not happen too early relative to the order of the desired model. You can achieve this by prepending sufficient number of zeros (equilibrium values) to the input and output signals. For example, a step input must be represented as [zeros(nx,1); ones(N,1)] rather than ones(N,1), such that nx > model order.

Warning: For transient data (step or impulse experiment), make sure that the change in input signal does not happen too early relative to the order of the desired model. You can achieve this by prepending sufficient number of zeros (equilibrium values) to the input and output signals. For example, a step input must be represented as [zeros(nx,1); ones(N,1)] rather than ones(N,1), such that nx > model order.

t = (0:numel(right_setpoint)-1)*0.008;
motor_right_zpk_new = zpk(tfest(data_est,2,1,t(116)))

Warning: For transient data (step or impulse experiment), make sure that the change in input signal does not happen too early relative to the order of the desired model. You can achieve this by prepending sufficient number of zeros (equilibrium values) to the input and output signals. For example, a step input must be represented as [zeros(nx,1); ones(N,1)] rather than ones(N,1), such that nx > model order.

motor_right_zpk_new =
 
  From input "u2" to output "y2":
                    11.735 (s+22.61)
  exp(-0.92*s) * ----------------------
                 (s^2 + 12.49s + 266.2)
 
Continuous-time zero/pole/gain model.

motor_right_zpk_new2 = zpk(tfest(data_est,2,1,nan))

Warning: For transient data (step or impulse experiment), make sure that the change in input signal does not happen too early relative to the order of the desired model. You can achieve this by prepending sufficient number of zeros (equilibrium values) to the input and output signals. For example, a step input must be represented as [zeros(nx,1); ones(N,1)] rather than ones(N,1), such that nx > model order.

motor_right_zpk_new2 =
 
  From input "u2" to output "y2":
                   -4.0703 (s-2.609)
  exp(-0.23*s) * ----------------------
                 (s^2 + 4.036s + 10.69)
 
Continuous-time zero/pole/gain model.

Here, we see the estimated delay is T = 0.23 s, as compared to the "by-eye" estimate

t(116)

ans = 0.9200

and we see that the estimated transfer function still has a right-half plane zero, and therefore will exhibit the initial wrong-way, or inverted, response. Don't know why tfest can't do better than that.

y = lsim(motor_right_zpk,right_setpoint,t);
ynew = lsim(motor_right_zpk_new,right_setpoint,t);
ynew2 = lsim(motor_right_zpk_new2,right_setpoint,t);
figure
plot(t,right,t,y,t,ynew,t,ynew2)
xline(t(116))
legend('data','y','ynew','ynew2')

Why is it that there is no inverted response behaviour if I cut off the leading zeros?

If you do cut off the leading zeros, then the the input/output behavior as seen by tfest shows the output responding is the same direction as the input as soon as the input is applied. So tfest comes up with a model that reflects that behavior. However, when the leading zeros are NOT chopped off the output stays at zero in reponse to a non-zero input. That can't mathematically happen in the absence of a transport delay in the model, so tfest does the best that it can. I don't know the criteria that tfest uses to come up with the model, but, whatever it is, the output of the model (with no delay) will have to start being something when the input is applied, and for this problem the criterion resuts in the inverted response.

Let's see what happens if we change the input of the identified model so that the setpoint jumps at t(116) and the output follows the input.

newdata_est = data_est;
newdata_est.InputData(t<=t(116)) = 0;
motor_right_zpk_new3 = zpk(tfest(newdata_est,2,1))  % no IODelay

motor_right_zpk_new3 =
 
  From input "u2" to output "y2":
     15.062 (s+17.83)
  ----------------------
  (s^2 + 13.84s + 269.5)
 
Continuous-time zero/pole/gain model.

Note that zero in the left-half plane, so we won't see an inverted response. Also, it's interesting that the poles and zeros here are slightly different than in motor_right_zpk_new. Anyway ...

ynew3 = lsim(motor_right_zpk_new3,newdata_est.InputData,t);  % simulate with the new input signal
figure
plot(t,right,t,ynew3)
legend('data','ynew3')

the simulated response looks pretty good.

[Erik Batschkun]

The system to be modeled should have no delay (even though there must be some inertia delay that is motor/system specific but as I already explained I am not able to find out about it).

I do have some other step responses measured.

I did the following thing to all measurements:

Cut off leading zeros and add 3 leading zero samples at the beginning of all measurement series.

After that I used tfest with no iodelay.

This was my result:

• 14 zeros being positive (right half plane)
• 7 zeros being negative (left half plane)

Neither zeros nor poles are on or in the unit circle.

Poles are always complex conjugate in left half plane.

Does this still mean that my motors are nonminimum phase systems?

[Paul]

If your models from tfest are continous-time models, e.g., transfer functions in s, then we shouldn't be talking about the unit circle.

If your models from tfest are discrete-time models, e.g., transfer functions in z, then we shouldn't be talking aobut the left(right)-half plane.

But since you mention both, I'm not sure how to respond. Your original code returned a continuous-time model. Is that not still the case?

Also, your original code specifice a model with two poles and one zero. I guess you changed that?

[Erik Batschkun]

Maybe I messed up the tfest inputs.

As i measured the RPM I guess it should be a discrete system.

Should I use tfest(right_setpoint, rpm_right, 2, 1, 'Ts', 0.008) for the estimation?

I do have different datasets with different setpoints to identify the motor behaviour.

Thats why I have that many poles and zeros. I just summed up all results.

For the system to be stable I need all poles and zeros in or on the unit circle, am I right?

[Paul]

Hi Erik,

Responding to the following statements:

The system to be modeled should have no delay (even though there must be some inertia delay that is motor/system specific

I'm not familiar with the term "inertia delay" but from it sounds like it's referring to lag in motor motion due to its inertia and the inertia of the mechanical load (if there is one). However, that effect is captured in the model of the dynamics of the system and is not the same thing as a transport delay. The effect of static friction could look like a transport delay, i.e., the motor is stuck at zero until the applied torque is large enough to overcome the friction, but that type of effect would vary based on the magnituded of the input.

As i measured the RPM I guess it should be a discrete system.

How the data is measured does not affect the fundamental characteristics of the system. A motor is (typically?) an electro-mechanical system that has continuous-time dynamics. One can, of course, approximately model those dynamics as a discrete-time system if it makes sense to do so

Should I use tfest(right_setpoint, rpm_right, 2, 1, 'Ts', 0.008) for the estimation?

Yes, I believe that command would yield a discrete-time model, if that's what you want.

I do have different datasets with different setpoints to identify the motor behaviour.

If you want to estimate a single model based on multiple data sets, you might be interested in Create Multiexperiment Data at the Command Line.

Thats why I have that many poles and zeros. I just summed up all results.

Well, you can't really sum the results of multiple calls to tfest. I assume you really meant that you're reporting on the aggregate of the zero locations from 21 separate models, each with one zero (and two poles)

For the system to be stable I need all poles and zeros in or on the unit circle, am I right?

For a discrete-time system to be bounded-input-bounded-output (BIBO) stable all the poles of its transfer function have to be inside (not on) the unit circle (assuming no pole-zero cancellation in the transfer function, and assuming the system is causal as should be the case for a motor). The zero locations do not affect BIBO stability of a discrete-time system, or a continuous-time system for that matter (again, assuming no pole-zero cancellation).

[Erik Batschkun]

Tank you very much for all your help!

I do have a question that may not directly fit to my question but I would be very happy to know about it.

Maybe I am able to recover the actual number of leading zero samples.

If i am:

The motors are drives for a vehicle.

Is it somehow possible to derive the inertia of the whole system/(mechanical load) from the count of leading zero samples?

I also have some other variables measured (regarding the positioning of the system) so I could maybe use them aswell.

[Paul]

You're quite welcome.

I'm afraid I can't offer any insight into deriving the inertia.

Good luck with your project!