home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 15 / 15.iso / s / s300 / 1.ddi / CHAP5 / CNTRL3.C < prev    next >
Encoding:
C/C++ Source or Header  |  1988-05-02  |  22.6 KB  |  747 lines
  1. /***********************************************************************
  2.  
  3. FILE
  4.     cntrl3.c  -  PI Control of Servo Motor Speed for Multiple Motors
  5.  
  6. ENTRY ROUTINES
  7.     control  -  execute control algorithm
  8.     init     -  interpret command line for initialization 
  9.     gain     -  interpret command line for PI gains
  10.     setv     -  interpret command line for setpoint
  11.     setsmp   -  interpret command line for sampling rate
  12.     setmot   -  allocate and initialize motor structures
  13.  
  14. PRIVATE ROUTINES
  15.     pimotor  -  apply motor control
  16.     cpmotor  -  copy motor descriptors
  17.     getv     -  get velocity reading
  18.     mact     -  send controller output to actuator
  19.  
  20. REMARKS
  21.     This version implements multiple motor control; each motor has 
  22.     completely independent sampling interval, control parameters, etc.
  23.  
  24. LAST UPDATE
  25.     20 March 1988
  26.         include ANSI features
  27.     
  28.     Copyright (c) 1984-1988  D.M.Auslander and C.H. Tham
  29.     
  30. ***********************************************************************/
  31.  
  32. /***********************************************************************
  33.                     I M P O R T S
  34. ***********************************************************************/
  35.  
  36. #include <stdio.h>
  37. #include <stdlib.h>
  38. #include <math.h>
  39.  
  40. #include "envir.h"      /* environment definitions */
  41. #include "dash8.h"      /* declarations for dash8.c */
  42. #include "dac2.h"       /* declarations for dac2.c */
  43. #include "time0.h"      /* declarations for time0.c */
  44. #include "cntrl3.h"     /* exported declarations for this module */
  45.  
  46. #ifdef SIMRT
  47. #ifdef ANSI
  48. extern void tstep(void);
  49. extern void sim_init(int);
  50. extern void sim_reset(char *);
  51. #else
  52. extern void tstep();
  53. extern void sim_init();
  54. extern void sim_reset();
  55. #endif
  56. #endif
  57.  
  58. /***********************************************************************
  59.            MODULE  PRIVATE  DATA  STRUCTURES  AND  VARIABLES
  60. ***********************************************************************/
  61.  
  62. #define ADCTOV      1.0         /* ADC units to velocity units */
  63. #define MTODAC      1.0         /* output units to DAC units */
  64.  
  65. #define TIME_GRAIN  0.001       /* left time granularity */
  66.  
  67. /*-----------------------------------------------------------*/
  68. /*  This structure describes the control and configurational */
  69. /*  parameters for velocity control of a d.c. motor.         */
  70. /*-----------------------------------------------------------*/
  71.  
  72. typedef struct motor {
  73.     int ichan;      /* A/D channel number */
  74.     int mchan;      /* D/A channel number */
  75.     double v;       /* velocity */
  76.     double vref;    /* velocity setpoint */
  77.     double kp;      /* proportional gain */
  78.     double ki;      /* integral gain */
  79.     double ival;    /* integrator accumulated value */
  80.     double vcon;    /* constant in control equation */
  81.     double m;       /* controller output */
  82.     double mmin;    /* lower limit for controller output */
  83.     double mmax;    /* upper limit for controller output */
  84.     double tsamp;   /* sample interval */
  85.     double tleft;   /* time left to next sample */
  86. } MOTOR;
  87.  
  88. static MOTOR *pm0;      /* pointer to the structure for motor #0 */
  89. static int nmotors;     /* number of motors */
  90.  
  91. /*----------------------------------------------------------------*/
  92. /*  motdef is a set of default values that is used to initialize  */
  93. /*  newly allocated motor control structure.                      */
  94. /*----------------------------------------------------------------*/
  95.  
  96. static MOTOR motdef = {
  97.           0,    /* A/D channel defaults to 0 */
  98.           0,    /* D/A channel defaults to 0 */
  99.         0.0,    /* zero initial velocity */
  100.      1000.0,    /* default velocity setpoint */
  101.         1.0,    /* kp defaults to 1.0 */
  102.         0.0,    /* no integrator by default, P control by default */
  103.         0.0,    /* zero integration sum */
  104.         0.0,    /* constant term in control equation */
  105.         0.0,    /* no controller output initially */
  106.     -2048.0,    /* lower output limit */
  107.      2047.0,    /* upper output limit */
  108.         0.5,    /* default sampling interval of 0.5 seconds */
  109.        0.0      /* time left to next sample */
  110. };
  111.  
  112. /***********************************************************************
  113.                F O R W A R D    D E C L A R A T I O N S
  114. ***********************************************************************/
  115.  
  116. #ifdef ANSI
  117.  
  118. double  getv(int);
  119. void    mact(int, double);
  120. void    pimotor(MOTOR *, int);
  121. void    cpmotor(MOTOR *, MOTOR *);
  122.  
  123. #else
  124.  
  125. double  getv();
  126. void    mact();
  127. void    pimotor();
  128. void    cpmotor();
  129.  
  130. #endif
  131.  
  132. /***********************************************************************
  133.                     E N T R Y    R O U T I N E S
  134. ***********************************************************************/
  135.  
  136. /*----------------------------------------------------------------------
  137. PROCEDURE
  138.     CONTROL  -  this function does the control
  139.  
  140. SYNOPSIS
  141.     void control(cline)
  142.     char cline[];
  143.  
  144. PARAMETER
  145.     cline  -  user's input line that specifies the number of iterations
  146.               and whether to trace the control action.
  147.  
  148. REMARKS
  149.     The control output is calculated in two parts - first with only P
  150.     action and then with I action added.  The output is limited to what
  151.     the actuator can put out, with provisions against reset windup.
  152.  
  153. LAST UPDATE
  154.     20 March 1988
  155.         use ANSI features
  156. ----------------------------------------------------------------------*/
  157.  
  158. void control(cline)
  159. char *cline;
  160. {
  161.     MOTOR *pm;          /* pointer to motor data structure */
  162.     long nitr;          /* number of control iterations */
  163.     long i;             /* iteration counter */
  164.     int m;              /* motor number index */
  165.     int prnt;           /* if set to 1, print output every iteration */
  166.     double tlmin;       /* minimum time left to next sample */
  167.  
  168.  
  169.     pm = pm0;           /* set pm to point at first motor structure */
  170.  
  171.     for (m = 0; m < nmotors; m++)
  172.     {
  173.         pm->ival = 0.0;     /* initialize the integrator */
  174.         pm++;               /* next motor */
  175.     }
  176.  
  177.     /*  next get user specified iteration limit and print switch  */
  178.  
  179.     sscanf(cline, "%ld %d", &nitr, &prnt);
  180.  
  181. #ifdef DEBUG
  182.     printf("number of iterations = %ld\n", nitr);   /* verify/debug */
  183. #endif
  184.  
  185.     for (i = 0L; i < nitr; i++)  /* main iteration loop */
  186.     {
  187.         pm = pm0;       /* point to first motor structure */
  188.  
  189.         /*-------------------------------------------------------------
  190.             Tlmin is initialized to a large number so we can use it
  191.             to find the task with minimum time left by comparing its
  192.             time left against tlmin and setting tlmin to the minimum
  193.             time left until the motor request control.
  194.         --------------------------------------------------------------*/
  195.  
  196.         tlmin = 1.e+37;     /* 10 to the power of 37 */
  197.  
  198.         /*--------------------------------------------------------
  199.             Check each motor to see how much time is left until
  200.             it will request control.  tlmin is set in this loop.
  201.         ---------------------------------------------------------*/
  202.  
  203.         for (m = 0; m < nmotors; m++)
  204.         {
  205.             double ttest;    /* time to next sample for this motor */
  206.         
  207.             /*--------------------------------------------------------
  208.                 A time-left of zero implies that this is the current
  209.                 sampling instance for the motor.  Hence, the time
  210.                 to next sample from now is the sample interval.
  211.             ---------------------------------------------------------*/
  212.         
  213.             if (pm->tleft <= 0.0)
  214.                 ttest = pm->tsamp;
  215.             else
  216.                 ttest = pm->tleft;
  217.         
  218.             if (ttest < tlmin)      /* update new tlmin */
  219.                 tlmin = ttest;
  220.         
  221.             ++pm;                   /* next motor */
  222.         }
  223.  
  224.         /*-----------------------------------------------------------
  225.             Set timer for next sample interval and adjust tleft's.
  226.             Note that argument to settimer() is in milliseconds.
  227.         ------------------------------------------------------------*/
  228.         
  229.         SetTimer((long)(tlmin * 1000));
  230.         
  231.         /*--------------------------------------------------------------
  232.             Now apply control on any motor requesting it (tleft <= 0).
  233.             The timer should be set before applying control because
  234.             the control action can take a significant amount of time,
  235.             especially if there are many motors to control.
  236.         --------------------------------------------------------------*/
  237.         
  238.         pm = pm0;       /* point at first motor structure */
  239.         
  240.         for (m = 0; m < nmotors; m++)
  241.         {
  242.             if (pm->tleft <= 0.0)
  243.             {
  244.                 pimotor(pm, prnt);      /* perform PI control */
  245.  
  246.                 /*------------------------------------------------
  247.                     Set time-left to the sampling interval to
  248.                     await the next execution instance for this
  249.                     particular motor.
  250.                 ------------------------------------------------*/
  251.  
  252.                 pm->tleft = pm->tsamp;
  253.             }
  254.         
  255.             pm->tleft -= tlmin;     /* subtract timer setting from */
  256.                                     /*   time left for all motors. */
  257.  
  258.             /*----------------------------------------------------------
  259.                 tleft will be compared against 0.0 in the previous
  260.                 for(;;) loop; hence we have to impose a comparison
  261.                 granularity as tleft is a floating point number.
  262.             ----------------------------------------------------------*/
  263.  
  264.             if (fabs(pm->tleft) < TIME_GRAIN)   /* adjust for time */
  265.                 pm->tleft = 0.0;                /*  granularity    */
  266.  
  267.             pm++;                   /* next motor */
  268.         }
  269.         
  270.         if (TimeUp())       /* timeout before calculations were done */
  271.         {
  272.             printf("sampling time constraints violated\n");
  273.             exit(1);
  274.         }
  275.         
  276.         while (!TimeUp())  /* wait for next sampling instance */
  277.         {
  278. #if SIMRT                   /* if this is a simulation, call tstep() */
  279.             tstep();        /*   which advances time and simulates   */
  280. #endif                      /*   the motor plant(s).                 */
  281.         }
  282.     }
  283. } 
  284.  
  285.  
  286.  
  287. /*----------------------------------------------------------------------
  288. PROCEDURE
  289.     INIT  -  process system initialization command
  290.  
  291. SYNOPSIS
  292.     void init(cline)
  293.     char *cline;
  294.  
  295. PARAMETER
  296.     cline  -  data part of input command line, specifying step size
  297.  
  298. REMARKS
  299.     This routine must be called before control() is called.
  300.  
  301. LAST UPDATE
  302.     20 March 1988
  303.         change sim_init()
  304. ----------------------------------------------------------------------*/
  305.  
  306. void init(cline)
  307. char *cline;
  308. {
  309.  
  310.     ad_init();              /* initialize A/D */
  311.     da_init();              /* initialize D/A */
  312.  
  313. #ifdef SIMRT
  314.     sim_reset(cline);
  315. #endif
  316.  
  317. }
  318.  
  319.  
  320.  
  321. /*----------------------------------------------------------------------
  322. PROCEDURE
  323.     GAIN  -  interpret input line for controller gains specification
  324.  
  325. SYNOPSIS
  326.     void gain(cline)
  327.     char *cline;
  328.  
  329. PARAMETER
  330.     cline  -  pointer to null terminated input command line
  331.  
  332. REMARKS
  333.     Note that in gain(), setv() and setsmp(), the input data is put
  334.     into temporary storage first.  This is because the specified
  335.     motor number may be out of range.
  336.  
  337. LAST UPDATE
  338.     20 March 1988
  339.         use ANSI features
  340. ----------------------------------------------------------------------*/
  341.  
  342. void gain(cline)
  343. char *cline;
  344. {
  345.     int mn;                 /* motor number */
  346.     double kp, ki, vcon;    /* temporary gain and constant terms */
  347.  
  348.  
  349.     if (sscanf(cline, "%d %lf %lf %lf", &mn, &kp, &ki, &vcon) == 4)
  350.     {
  351.         if ((mn >= 0) && (mn < nmotors))
  352.         {
  353.             /*
  354.              *  Set the appropriate fields of the motor descriptor.
  355.              *  Note that (pm0 + mn) is a pointer to the descriptor
  356.              *  for the mn-th motor; hence the use of "->" to
  357.              *  dereference the descriptor fields.
  358.              */
  359.  
  360.             (pm0 + mn)->kp = kp;
  361.             (pm0 + mn)->ki = ki;
  362.             (pm0 + mn)->vcon = vcon;
  363.  
  364. #ifdef DEBUG
  365.             printf("<gain> motor = %d, ", mn);
  366.             printf("kp = %lf, ki = %lf, vcon = %lf\n", kp, ki, vcon);
  367. #endif
  368.         }
  369.         else
  370.             printf("gain: invalid motor number: %d\n", mn);
  371.     }
  372.     else
  373.         printf("gain: invalid or insufficient parameters\n");
  374.  
  375. }
  376.  
  377.  
  378.  
  379. /*----------------------------------------------------------------------
  380. PROCEDURE
  381.     SETV  -  get velocity setpoint from command line
  382.  
  383. SYNOPSIS
  384.     void setv(cline)
  385.     char *cline;
  386.  
  387. PARAMETER
  388.     cline  -  pointer to null terminated input command line
  389.  
  390. LAST UPDATE
  391.     20 March 1988
  392.         use ANSI features
  393. ----------------------------------------------------------------------*/
  394.  
  395. void setv(cline)
  396. char *cline;
  397. {
  398.     int mn;         /* motor number */
  399.     double vref;    /* temporary holder for setpoint value */
  400.  
  401.  
  402.     if (sscanf(cline, "%d %lf", &mn ,&vref) == 2)
  403.     {
  404.         if ((mn >= 0) && (mn < nmotors))
  405.         {
  406.             (pm0 + mn)->vref = vref;        /* record velocity reference */
  407.  
  408. #ifdef DEBUG
  409.             printf("<setv> motor = %d, vref = %lf\n", mn, vref);
  410. #endif
  411.         }
  412.         else
  413.             printf("setv: bad motor number: %d\n", mn);
  414.     }
  415.     else
  416.         printf("setv: invalid or insufficient parameters\n");
  417.  
  418. }
  419.  
  420.  
  421.  
  422. /*----------------------------------------------------------------------
  423. PROCEDURE
  424.     SETSMP  -  set sampling interval from command line specification
  425.  
  426. SYNOPSIS
  427.     void setsmp(cline)
  428.     char *cline;
  429.  
  430. PARAMETER
  431.     cline  -  pointer to null terminated input command line
  432.  
  433. LAST UPDATE
  434.     20 March 1988
  435.         use ANSI features
  436. ----------------------------------------------------------------------*/
  437.  
  438. void setsmp(cline)
  439. char *cline;
  440. {
  441.     int mn;             /* motor number */
  442.     double tsamp;       /* temporary holder for sample time */
  443.  
  444.  
  445.     if (sscanf(cline,"%d %lf", &mn, &tsamp) == 2)
  446.     {
  447.         if ((mn >= 0) && (mn < nmotors))
  448.         {
  449.             (pm0 + mn)->tsamp = tsamp;      /* set sample interval */
  450.  
  451. #ifdef DEBUG
  452.             printf("<setsmp> motor = %d, tsamp = %f\n", mn, tsamp);
  453. #endif
  454.         }
  455.         else
  456.             printf("setsmp: bad motor number: %d\n", mn);
  457.     }
  458.     else
  459.         printf("setsmp: invalid or insufficient parameters\n");
  460.  
  461. }
  462.  
  463.  
  464.  
  465. /*----------------------------------------------------------------------
  466. PROCEDURE
  467.     SETMOT  -  allocate and initialize data structures for the number
  468.                 of motors requested by the user.
  469. SYNOPSIS
  470.     void setmot(void)
  471.  
  472. REMARKS
  473.     This routine must be called as the first action of the main program.
  474.  
  475.     Motor descriptors initialized from defaults specified in "motdef"
  476.  
  477. LAST UPDATE
  478.     20 March 1988
  479.         use ANSI features
  480. ----------------------------------------------------------------------*/
  481.  
  482. void setmot()
  483. {
  484.     MOTOR *pm;          /* pointer to motor data structures */
  485.     int nm;             /* number of motors */
  486.     char cbuf[20];      /* input line */
  487.     int damin, damax;   /* D/A output limits */
  488.     int done;           /* flag, if set, o.k. to return */
  489.     int i;              /* loop index */
  490.  
  491.  
  492.     do
  493.     {
  494.         done = 1;
  495.  
  496.         /*
  497.          *  Prompt user and get response line.  Because scanf() does not
  498.          *  remove the newline character at the end of lines, fgets() is
  499.          *  used instead since the newline character may cause trouble
  500.          *  with other console functions.
  501.          */
  502.  
  503.         fputs("How many motors? ", stdout);
  504.         fgets(cbuf, 20, stdin);         /* get at most 19 characters */
  505.  
  506.         if (sscanf(cbuf, "%d", &nm) == 1)   /* decode input */
  507.         {
  508.             da_limits(&damin, &damax);      /* find DAC limits */
  509.  
  510.             motdef.mmin = (double)damin / MTODAC;   /* set output limits */
  511.             motdef.mmax = (double)damax / MTODAC;
  512.  
  513.             /*
  514.              *  Dynamically allocate memory for the required number of
  515.              *  motor structures.  Note that calloc() is used instead of
  516.              *  malloc() since calloc() is suppose to guarantee that the
  517.              *  allocated block of memory has the correct alignment.
  518.              *  Note also the use of "casts" in the allocation statement;
  519.              *  though not strictly necessary, it is recommended as good
  520.              *  programming style.
  521.              */
  522.  
  523.             if ((pm0 = (MOTOR *)calloc(nm, sizeof(MOTOR))) == (MOTOR *)NULL)
  524.             {
  525.                 printf("INSUFFICIENT MEMORY: ");
  526.                 printf("cannot allocate %d motor blocks\n", nm);
  527.                 exit(1);
  528.             }
  529.  
  530.             for (i = 0, pm = pm0; i < nm; i++, pm++)
  531.             {
  532.                 cpmotor(&motdef, pm);   /* init with defaults from motdef */
  533.             
  534.                 pm->ichan = i;  /* set both A/D and D/A channels to i; the */
  535.                 pm->mchan = i;  /*   actual channels depends on your setup */
  536.             }
  537.  
  538.             nmotors = nm;       /* record number of motor descriptors */
  539.  
  540. #ifdef SIMRT
  541.             sim_init(nm);   /* if real-time simulation is to be used, */
  542. #endif                      /*   initialize the simulation module.    */
  543.  
  544.             if (nm == 1)
  545.                 printf("\nmotor 0 has been initialized\n");
  546.             else
  547.                 printf("\nmotors 0 to %d have been initialized\n", nm - 1);
  548.         }
  549.         else
  550.         {
  551.             printf("invalid entry\n");
  552.             done = 0;
  553.         }
  554.     }
  555.     while (!done);
  556.  
  557. }
  558.  
  559.  
  560. /***********************************************************************
  561.                     P R I V A T E    R O U T I N E S 
  562. ***********************************************************************/
  563.  
  564. /*----------------------------------------------------------------------
  565. PROCEDURE
  566.     PIMOTOR  -  apply PI control for motor
  567.  
  568. SYNOPSIS
  569.     static void pimotor(pm, prnt)
  570.     MOTOR *pm;
  571.     int prnt;
  572.  
  573. PARAMETERS
  574.     pm    -  pointer to motor structure requiring control
  575.     prnt  -  if 1, print control output
  576.  
  577. LAST UPDATE
  578.     20 March 1988
  579.         use ANSI features
  580. ----------------------------------------------------------------------*/
  581.  
  582. static void pimotor(pm, prnt)
  583. MOTOR *pm;
  584. int prnt;
  585. {
  586.     double m1;      /* intermediate result in control calculation. */
  587.     double error;   /* error between reference and measured */
  588.  
  589.  
  590.     pm->v = getv(pm->ichan);            /* obtain motor velocity */
  591.  
  592.     error = pm->vref - pm->v;           /* calculate error term */
  593.     pm->ival += error;                  /* update integral of error */
  594.     m1 = pm->kp * error + pm->vcon;     /* do P control first */
  595.  
  596.     /*
  597.      *  Check for actuator limits and apply "reset windup" control.
  598.      *  If the output would exceed actuator limits, set the integral
  599.      *  term to zero to prevent the integral term from dominating
  600.      *  the output and slow down corrective action.
  601.      */
  602.  
  603.     if (m1 > pm->mmax)
  604.     {
  605.         pm->m = pm->mmax;
  606.         pm->ival = 0.0;
  607.     }
  608.     else if (m1 < pm->mmin)
  609.     {
  610.         pm->m = pm->mmin;
  611.         pm->ival = 0.0;
  612.     }
  613.     else    /* output withing actuator limits */
  614.     {
  615.         pm->m = m1 + (pm->ki * pm->ival);   /* now add integral term */
  616.     }
  617.  
  618.     if (prnt)               /* print controller output */
  619.     {
  620.         int mn;             /* motor number */
  621.     
  622.         mn = (pm - pm0);    /* compute motor number for output */
  623.     
  624.         printf("motor = %d, v = %7.3lf, m = %7.3lf\n", mn, pm->v, pm->m);
  625.     }
  626.  
  627.     mact(pm->mchan, pm->m); /* send controller output to actuator */
  628.  
  629. }
  630.  
  631.  
  632.  
  633. /*----------------------------------------------------------------------
  634. PROCEDURE
  635.     CPMOTOR  -  copy one motor descriptor to another
  636.  
  637. SYNOPSIS
  638.     static void cpmotor(from, to)
  639.     MOTOR *from, *to;
  640.  
  641. PARAMETERS
  642.     from  -  pointer to source
  643.     to    -  pointer to destination
  644.  
  645. REMARKS
  646.     Standard (K&R) C does not allow entire structures to be assigned
  647.     (this will change with the proposed ANSI X3J11 standards).  This
  648.     restriction is very inconvenient and this routine gets around this
  649.     by doing a byte-by-byte copy of the descriptor contents.  This
  650.     technique may not work on all computers, but it is reasonably
  651.     robust and is much easier than doing field by field assignments.
  652.  
  653.     If you are using an ANSI conforming C compiler, just do a structure
  654.     assignment.  The compiler will take care of the rest.
  655.  
  656. LAST UPDATE
  657.     20 March 1988
  658.         use ANSI features
  659. ----------------------------------------------------------------------*/
  660.  
  661. static void cpmotor(from, to)
  662. MOTOR *from, *to;
  663. {
  664.  
  665. #ifdef ANSI     /* can do structure assignment */
  666.  
  667.     *to = *from;
  668.  
  669. #else           /* do explicit byte by byte copy */
  670.  
  671.     register char *src, *dst;   /* source and destination pointers */
  672.     unsigned count;             /* byte count */
  673.  
  674.  
  675.     src = (char *)from;     /* make fast copy of source pointer */
  676.     dst = (char *)to;       /* make fast copy of destination pointer */
  677.  
  678.     for (count = 0; count < sizeof(MOTOR); count++)
  679.         *dst++ = *src++;
  680.  
  681. #endif
  682.  
  683. }
  684.  
  685.  
  686.  
  687. /*----------------------------------------------------------------------
  688. FUNCTION
  689.     GETV  -  get current motor velocity
  690.  
  691. SYNOPSIS
  692.     static double getv(channel)
  693.     int channel;
  694.  
  695. PARAMETER
  696.     channel  -  A/D channel from which to read the velocity
  697.  
  698. RETURNS
  699.     current motor velocity
  700.  
  701. REMARKS
  702.     Note that the conversion of raw ADC units to velocity units
  703.     uses the ADCTOV conversion factor.
  704.  
  705. LAST UPDATE
  706.     20 March 1988
  707.         use ANSI features
  708. ----------------------------------------------------------------------*/
  709.  
  710. static double getv(channel)
  711. int channel;
  712. {
  713.  
  714.     return((double)ad_wread(channel) * ADCTOV);
  715. }
  716.  
  717.  
  718.  
  719. /*----------------------------------------------------------------------
  720. PROCEDURE
  721.     mact  -  send controller output to D/A converter
  722.  
  723. SYNOPSIS
  724.     static void mact(channel, output)
  725.     int channel;
  726.     double output;
  727.  
  728. PARAMETERS
  729.     channel -  D/A channel number
  730.     output  -  controller output
  731.  
  732. REMARKS
  733.     Multiply by conversion factor and add 0.5 for rounding.
  734.  
  735. LAST UPDATE
  736.     20 March 1988
  737.         use ANSI features
  738. ----------------------------------------------------------------------*/
  739.  
  740. static void mact(channel, output)
  741. int channel;
  742. double output;
  743. {
  744.     
  745.     da_write(channel, (int)((output * MTODAC) + 0.5));
  746. }
  747.