Motor position control

Introduction

In this exercise, a closed-loop position control system for the DC motor will be developed. The physical system is identical to that of lab 7: as shown in figure 8.12, the optical encoder, the DAC (connected to the motor amplifier), and the periodic timer interrupt will be combined to control the DC motor.

A MATLAB tool will be used to design an appropriate proportional-integral-derivative (PID) controller, shown in figure 8.13. Later, you will evaluate the controller performance for a time-varying position reference path \(\theta_R(t)\).

This project builds on your past work. The program that you write should be structurally similar to that of lab 7, and many of its components can be reused.

PID control design and evaluation

For this lab exercise, you will write two MATLAB scripts: one to design your PID controller and another to compare its performance to an analytical model. Specifically, the first script should design a PIDF controller using the MATLAB Control System toolbox function pidtune(), as introduced in section 8.5. This compensator should be designed to track the reference input and to have control bandwidth of \(10\) Hz. A PIDF controller, described in section 8.4, improves the noise immunity of a PID controller by limiting the high-frequency response of the derivative term. Check your controller design by plotting the closed-loop step response using the plant parameters of your specific T1 target system. For the T1a target system, you can use the values from section 8.5; for other systems, see section A.2.

The script should convert the continuous-time transfer function to discrete-time (c2d(), tf(), and tfdata(), with sample time \(T=0.005\) s), and then use tf2sos() (transfer functions to second-order sections) to break the transfer function into biquads. Finally, use the sos2header() function (see section E.1) to write the biquad filter to a C header file (myPIDF.h). Once copied into your Eclipse workspace, that header can be #included in your myRIO C program (after the biquad struct has been defined).

For example, once the continuous transfer function of the plant has been defined, the MATLAB design can be completed and written to the header file as follows:

%---design PIDF controller
wc      = 2 * pi * 10;  % 10 Hz control bandwidth (gain crossover)
Options = pidtuneOptions('DesignFocus', 'reference-tracking');
Cp      = pidtune(plant, 'pidf', wc, Options)

%---convert controller to discrete-time biquads
Cdp   = c2d(Cp, T, 'tustin');  % discrete controller in parallel form
Cd    = tf(Cdp);               % convert to transfer function
[b,a] = tfdata(Cd, 'v');       % put in vector form
sos   = tf2sos(b, a);          % extract the biquads

%---write controller description to C header
fid = fopen('myPIDF.h', 'W');
  sos2header(fid, sos, 'PIDF', T, 'PIDF position control');
fclose(fid);

As in lab 7, your second script should load the actual response of the position control system (Lab8.mat), and compare it to both the ideal reference displacement and the dynamic model prediction. See the next discussion for more details.

Program description

The program should be similar in structure to that of lab 7, consisting of (1) a Main thread, which initializes the task and calls ctable2() to communicate with the user; and (2) a Timer thread, which maintains timing using an interrupt, implements the position control, and saves the results. Your specific controller definition should be derived from the header file written from your MATLAB script.

double *pref  = &((threadResource->a_table + 0)->value);
double *pact  = &((threadResource->a_table + 1)->value);
double *VDAmV = &((threadResource->a_table + 2)->value);
seg *mySegs = threadResource->profile;
int nseg    = threadResource->nseg;

Functions

Three functions are needed within the ISR loop.

cascade()

The cascade() function, called once from the ISR during each BTI, implements the general-purpose linear difference equation algorithm from lab 6. For this lab, use the same C code that you used in lab 6. In this case, there will be 1 biquad section.

Note that, as in lab 6, all calculations should be made in (double) floating-point arithmetic.

pos()

Write a pos() function to read the encoder counter and return the displacement as a (double) in units of basic displacement increments (BDI) (encoder counts), relative to the first position read.

Sramps()

The C function Sramps() implements the path planning method of section 8.6, and is available from the T1 library. It returns the current input reference position \(\Theta_R\). The function accepts an input array of structures, each describing a separate displacement ramp segment. Called once each cycle of the control loop, Sramps() steps through the segments, and then repeats the complete path indefinitely.

We will initialize the path array in main(), and then pass the array and the number of segments to the Timer thread through the Thread Resource (described previously in the Main thread section).

The segment data type seg describes the characteristics of each ramp segment as follows:

typedef struct {
  double xfa;       // position
  double v;         // velocity limit
  double a;         // acceleration limit
  double d;         // dwell time (s)
} seg;

Add #include "sramps.h" to your code to have access to the seg data type. To test the position control system, initialize an array mySegs of type seg as follows:

double vmax = 25.;   // rev/s
double amax = 30.;   // rev/s^2
double dwell = 1.0;  // s
seg mySegs[8] = {    // rev
    {20.125,    vmax,   amax,   dwell},
    {40.250,    vmax,   amax,   dwell},
    {60.375,    vmax,   amax,   dwell},
    {80.500,    vmax,   amax,   dwell},
    {60.625,    vmax,   amax,   dwell},
    {40.750,    vmax,   amax,   dwell},
    {20.875,    vmax,   amax,   dwell},
    { 0.000,    vmax,   amax,   dwell}
};
int nseg = 8;

Notice that mySegs consists of four increasing ramps of \(20.125\) revolutions each, followed by four similar decreasing ramps that will return the motor to the starting position. All the segments are subject to the same velocity and acceleration limits, and all dwell for 1 s before proceeding to the next segment. See figure 8.14.

The prototype of the Sramps() function from the sramps.h header file is

int Sramps(
  seg *segs,   // segments array
  int nseg,    // number of segments
  int *iseg,   // current segment index
  int *itime,  // current time index
  double T,    // sample period
  double *xa   // next reference positon
);

At the end of the last segment, Sramps() returns the total number of time steps in all the segments. It returns 0 otherwise.

A typical call of Sramps() might be

nsamp = Sramps(mySegs, nseg, &iseg, &itime, T, &Pref);

When Sramps() is called for the first time, set itime = -1 and *iseg = -1 to initialize its operation.

Laboratory exploration and evaluation