Modelling Equations For A DC Motor

And PV Position Controller

©  2008 Quanser Consulting Inc.

URL: http://www.quanser.com

Description

Worksheet Initialization

>    restart: interface( imaginaryunit=j ):

>    with(inttrans):

theta[l]  = first load angular position [rad]

>    alias( Theta[1] = laplace( theta[1](t), t, s ) ):

T[l]  = Torque produced by the motor at the load gear

>    alias( T[1] = laplace( tq[1](t), t, s ) ):

>   

DC Motor System Definition - Laplace Representation: G(s)

This section models the motor system to be controlled.

motor transfer function (in the Laplace domain)

>    G[j1] := 'Theta[1] / I[1]';

G[j1] := Theta[1]/I[1]

Newton's second law of motion (i.e. equation of motion in the time domain):

>    NEWTON_EQ_DT := J[eq1] * diff( theta[1](t), t$2 ) = tq[1]( t ) - B[eq1] * diff( theta[1](t), t );

NEWTON_EQ_DT := J[eq1]*diff(theta[1](t),`$`(t,2)) = tq[1](t)-B[eq1]*diff(theta[1](t),t)

>    NEWTON_EQ_S := laplace( NEWTON_EQ_DT, t, s );

NEWTON_EQ_S := J[eq1]*(s*(s*Theta[1]-theta[1](0))-D(theta[1])(0)) = T[1]-B[eq1]*(s*Theta[1]-theta[1](0))

the initial conditions are null

>    IC := { theta[1](0) = 0, D(theta[1])(0) = 0 }:

>    NEWTON_EQ_S := subs( IC, NEWTON_EQ_S );

NEWTON_EQ_S := J[eq1]*s^2*Theta[1] = T[1]-B[eq1]*s*Theta[1]

Torque generated by the DC motor

>    T[1] := K[t] * I[1];

T[1] := K[t]*I[1]

Back-ElectroMotive-Force Voltage:

>    E[emf] := 'K[m] * Omega[m]';

E[emf] := K[m]*Omega[m]

>    Omega[l] := Theta[1] * s;

Omega[l] := s*Theta[1]

>    NEWTON_EQ_S := collect( NEWTON_EQ_S, { s, Theta[1] } );

NEWTON_EQ_S := J[eq1]*s^2*Theta[1] = K[t]*I[1]-B[eq1]*s*Theta[1]

>    Theta[1] := solve( NEWTON_EQ_S, Theta[1] );

Theta[1] := K[t]*I[1]/s/(J[eq1]*s+B[eq1])

>    G[j1] := sort( G[j1], s );

G[j1] := K[t]/(J[eq1]*s+B[eq1])/s

and J[eq] := J[l]+eta[g]*K[g]^2*J[m]

Open Loop (i.e. SRV02) Transfer Function

>    'G[j1]' = G[j1];

G[j1] = K[t]/(J[eq1]*s+B[eq1])/s

Position Controller Characterisation

PD Position Control

Control Law: I[m] = K[p]*(theta[l_d]-theta[l])-K[d]*(omega[l_d]-omega[l])

where omega[l] = Diff(theta[l],t)

>    G[c] := 'K[p] + K[d] * s';

G[c] := K[p]+K[d]*s

unity feedback

>    H := '1';

H := 1

>    T[pd] := G[c] * G[j1] / ( 1 + G[c] * G[j1] * H );

T[pd] := (K[p]+K[d]*s)*K[t]/(J[eq1]*s+B[eq1])/s/(1+(K[p]+K[d]*s)*K[t]/(J[eq1]*s+B[eq1])/s)

>    T[pd] := simplify( T[pd] );

T[pd] := (K[p]+K[d]*s)*K[t]/(J[eq1]*s^2+B[eq1]*s+K[t]*K[p]+K[t]*K[d]*s)

>    char_eqn[pd] := collect( denom( T[pd] ), s );

char_eqn[pd] := J[eq1]*s^2+(B[eq1]+K[t]*K[d])*s+K[t]*K[p]

Same characteristic equation as with a PV controller (as seen below: char_eqn[pd] == char_eqn[pv]).

However, a PD controller introduces an unaccounted zero in the closed-loop transfer function (see T[pd]).

PV Position Control

  • Control Law: I[m] = K[p]*(theta[l_d]-theta[l])-K[v]*Diff(theta[l],t)
  •  Block Diagram:

  [Maple Bitmap]

K[p] = K[p](zeta,omega[n])  and K[v] = K[v](zeta,omega[n])  Determination

Determine the PV controller gains: K[p]  and K[v] .

unassign variables

>    G[c] := 'G[c]': H := 'H': K[p] := 'K[p]':

Controller TF in the forward loop

>    G[c] := 'K[p]';

G[c] := K[p]

Feedback loop equivalent block (through block reduction)

>    H := 'K[v] / K[p] * s +1';

H := K[v]/K[p]*s+1

Closed Loop Transfer Function: T[pv] = Theta[l]/Theta[l_d]

>    T[pv] := G[c] * G[j1] / ( 1 + G[c] * G[j1] * H );

T[pv] := K[p]*K[t]/(J[eq1]*s+B[eq1])/s/(1+K[p]*K[t]/(J[eq1]*s+B[eq1])/s*(K[v]/K[p]*s+1))

>    T[pv] := simplify( T[pv] );

T[pv] := K[t]*K[p]/(J[eq1]*s^2+B[eq1]*s+K[t]*K[v]*s+K[t]*K[p])

>    char_eqn[pv] := collect( denom( T[pv] ), s );

char_eqn[pv] := J[eq1]*s^2+(B[eq1]+K[t]*K[v])*s+K[t]*K[p]

normalize the characteristic equation

>    char_eqn[pv] := collect( char_eqn[pv] / coeff( char_eqn[pv], s^2), s );

char_eqn[pv] := s^2+(B[eq1]+K[t]*K[v])/J[eq1]*s+K[t]*K[p]/J[eq1]

>    char_eqn[std] := s^2 + 2 * zeta * omega[n] * s + omega[n]^2;

char_eqn[std] := s^2+2*zeta*omega[n]*s+omega[n]^2

>    ID_EQ := char_eqn[pv] = char_eqn[std];

ID_EQ := s^2+(B[eq1]+K[t]*K[v])/J[eq1]*s+K[t]*K[p]/J[eq1] = s^2+2*zeta*omega[n]*s+omega[n]^2

solving ID_EQ by identification

>    EQ_KP := coeff( rhs( ID_EQ ), s, 0 ) = coeff( lhs( ID_EQ ), s, 0 );

EQ_KP := omega[n]^2 = K[t]*K[p]/J[eq1]

>    K[p] := solve( EQ_KP, K[p] );

K[p] := omega[n]^2/K[t]*J[eq1]

>    EQ_KV := coeff( rhs( ID_EQ ), s ) = coeff( lhs( ID_EQ ), s );

EQ_KV := 2*zeta*omega[n] = (B[eq1]+K[t]*K[v])/J[eq1]

>    K[v] := solve( EQ_KV, K[v] );

K[v] := (2*zeta*omega[n]*J[eq1]-B[eq1])/K[t]

  zeta = zeta(K[p],K[v])  and omega[n] = omega[n](K[p],K[v])  Determination

unassign variables

>    K[p] := 'K[p]': K[v] := 'K[v]':

assume( J[eq]>0, R[m]>0, eta[g]>0, K[g]>0, eta[m]>0, K[p]>0, omega[n]>0 );

>    solns := [ solve( EQ_KP, omega[n] ) ];

solns := [1/J[eq1]*(J[eq1]*K[t]*K[p])^(1/2), -1/J[eq1]*(J[eq1]*K[t]*K[p])^(1/2)]

however: 0 < omega[n]

>    omega[n] := solns[1];

omega[n] := 1/J[eq1]*(J[eq1]*K[t]*K[p])^(1/2)

>    zeta := solve( EQ_KV, zeta );

zeta := 1/2*(B[eq1]+K[t]*K[v])/(J[eq1]*K[t]*K[p])^(1/2)

>   

K[p] = K[p](zeta,omega[n])  and K[v] = K[v](zeta,omega[n])  Standard Calculations for a Second-Order System

Determine the general formula to calculate the gains K[p]  and K[v]  of a PV controller from the system standard open loop transfer function G[std] .

unassign variables

>    G[c] := 'G[c]': H := 'H': K[p] := 'K[p]': K[v] := 'K[v]':
omega[n] := 'omega[n]': zeta := 'zeta':

Standard form of the system transfer function

>    G[std] := 'G[num0] / ( G[den2] * s^2 + G[den1] * s + G[den0] )';

G[std] := G[num0]/(G[den2]*s^2+G[den1]*s+G[den0])

Controller TF in the forward loop

>    G[c] := 'K[p]';

G[c] := K[p]

Feedback loop equivalent block (through block reduction)

>    H := 'K[v] / K[p] * s +1';

H := K[v]/K[p]*s+1

Closed Loop Transfer Function (standard form): T[pv_std] = Theta[l]/Theta[l_d]

>    T[pv_std] := G[c] * G[std] / ( 1 + G[c] * G[std] * H );

T[pv_std] := K[p]*G[num0]/(G[den2]*s^2+G[den1]*s+G[den0])/(1+K[p]*G[num0]/(G[den2]*s^2+G[den1]*s+G[den0])*(K[v]/K[p]*s+1))

>    T[pv_std] := simplify( T[pv_std] );

T[pv_std] := G[num0]*K[p]/(G[den2]*s^2+G[den1]*s+G[den0]+G[num0]*K[v]*s+G[num0]*K[p])

>    char_eqn[pv_std] := collect( denom( T[pv_std] ), s );

char_eqn[pv_std] := G[den2]*s^2+(G[den1]+G[num0]*K[v])*s+G[num0]*K[p]+G[den0]

normalize the characteristic equation

>    char_eqn[pv_std] := collect( char_eqn[pv_std] / coeff( char_eqn[pv_std], s^2 ), s );

char_eqn[pv_std] := s^2+(G[den1]+G[num0]*K[v])/G[den2]*s+(G[num0]*K[p]+G[den0])/G[den2]

>    ID_EQ_STD := char_eqn[pv_std] = char_eqn[std];

ID_EQ_STD := s^2+(G[den1]+G[num0]*K[v])/G[den2]*s+(G[num0]*K[p]+G[den0])/G[den2] = s^2+2*zeta*omega[n]*s+omega[n]^2

solving Eq. ID_EQ_STD by identification

>    EQ_KP_STD := coeff( rhs( ID_EQ_STD ), s, 0 ) = coeff( lhs( ID_EQ_STD ), s, 0 ):

>    K[p] := solve( EQ_KP_STD, K[p] );

K[p] := (omega[n]^2*G[den2]-G[den0])/G[num0]

>    EQ_KV_STD := coeff( rhs( ID_EQ_STD ), s, 1 ) = coeff( lhs( ID_EQ_STD ), s, 1 ):

>    K[v] := solve( EQ_KV_STD, K[v] );

K[v] := (2*zeta*omega[n]*G[den2]-G[den1])/G[num0]

zeta = zeta(K[p],K[v])  and omega[n] = omega[n](K[p],K[v])  Standard Calculations for a Second-Order System

unassign variables

>    K[p] := 'K[p]': K[v] := 'K[v]': omega[n] := 'omega[n]': zeta := 'zeta':

>    solns := { solve( EQ_KP_STD, omega[n] ) };

solns := {-1/G[den2]*(G[den2]*(G[num0]*K[p]+G[den0]))^(1/2), 1/G[den2]*(G[den2]*(G[num0]*K[p]+G[den0]))^(1/2)}

assuming: 0 < G[den2]

>    omega[n] := solns[1];

omega[n] := -1/G[den2]*(G[den2]*(G[num0]*K[p]+G[den0]))^(1/2)

>    zeta := solve( EQ_KV_STD, zeta );

zeta := -1/2*(G[den1]+G[num0]*K[v])/(G[den2]*(G[num0]*K[p]+G[den0]))^(1/2)

>   

DC Motor System Definition: State-Space Representation

Xdot_ss = A_ss . X_ss + B_ss . U_ss

Y_ss = C_ss . X_ss + D_ss . U_ss

Y_ss = output vector; U_ss = input vector; X_ss = state vector

unassign variables

>    Theta[1] := 'Theta[1]': theta[1] := 'theta[1]': I[1] := 'I[1]':

Standard State-Space Representation

Standard Laplace Transfer Function

>    TF_EQ_S := G[std] = Theta[1] / I[1];

TF_EQ_S := G[num0]/(G[den2]*s^2+G[den1]*s+G[den0]) = Theta[1]/I[1]

>    TF_EQ_S := I[1] = solve( TF_EQ_S, I[1] );

TF_EQ_S := I[1] = Theta[1]*(G[den2]*s^2+G[den1]*s+G[den0])/G[num0]

initial conditions are null

>    TF_EQ_T := I[1] = subs( IC, invlaplace( rhs( TF_EQ_S ), s, t ) );

TF_EQ_T := I[1] = 1/G[num0]*(G[den2]*diff(theta[1](t),`$`(t,2))+G[den1]*diff(theta[1](t),t)+G[den0]*theta[1](t))

>    TF_EQ_T := diff( theta[1](t), t$2 ) = expand( solve( TF_EQ_T, diff( theta[1](t), t$2 ) ) );

TF_EQ_T := diff(theta[1](t),`$`(t,2)) = 1/G[den2]*G[num0]*I[1]-1/G[den2]*G[den1]*diff(theta[1](t),t)-1/G[den2]*G[den0]*theta[1](t)

state vector

>    X_ss := matrix( 2, 1 ):

>    X_ss[1,1] := theta[1](t): X_ss[2,1] := diff( theta[1](t), t):

>    'X_ss' = evalm( X_ss );

X_ss = matrix([[theta[1](t)], [diff(theta[1](t),t)]])

>    Xdot_ss := map( diff, X_ss, t );

Xdot_ss := matrix([[diff(theta[1](t),t)], [diff(theta[1](t),`$`(t,2))]])

>    U_ss := I[1];

U_ss := I[1]

according to Eq. TF_EQ_T

>    A_ss := matrix( [ [0, 1], [- G[den0] / G[den2], - G[den1] / G[den2]] ] );

A_ss := matrix([[0, 1], [-G[den0]/G[den2], -G[den1]/G[den2]]])

>    B_ss := matrix( [ [0], [G[num0] / G[den2]] ] );

B_ss := matrix([[0], [G[num0]/G[den2]]])

>    C_ss := Matrix( 2, 2, shape=identity ); D_ss := array( [ [0], [0] ] );

C_ss := Matrix(%id = 2741512)

D_ss := matrix([[0], [0]])

>    Y_ss = evalm( C_ss &* X_ss + D_ss * U_ss );

Y_ss = matrix([[theta[1](t)], [diff(theta[1](t),t)]])

>   

DC Motor State-Space Representation

>    G_num0 := numer( G[j1] ):

>    denom( G[j1] ):

>    G_den2 := coeff( denom( G[j1] ), s^2 ):

>    G_den1 := coeff( denom( G[j1] ), s ):

>    G_den0 := coeff( denom( G[j1] ), s, 0 ):

>    std_subs := { G[num0] = G_num0, G[den2] = G_den2, G[den1] = G_den1, G[den0] = G_den0 }:

>    A_J1 := matrix( 2, 2 ):

>    for i from 1 to 2 do
  for k from 1 to 2 do
    A_J1[i,k] := subs( std_subs, A_ss[i,k] );
  end do:
end do:

>    'A_J1' = evalm( A_J1 );

A_J1 = matrix([[0, 1], [0, -B[eq1]/J[eq1]]])

>    B_J1 := matrix( [ [0], [subs( std_subs, B_ss[2,1] )] ] );

B_J1 := matrix([[0], [K[t]/J[eq1]]])

>    C_SRV02 := C_ss;

C_SRV02 := Matrix(%id = 2741512)

>    D_SRV02:= evalm( D_ss );

D_SRV02 := matrix([[0], [0]])

>   

Click here to go back to top: Description Section.