---

dcmotor2.c

Go to the documentation of this file.

/*
   dcmotor.c

   DC motor simulation

   From Benjamin C. Kuo, "Automatic Control Systems," Fourth Edition,
   pp. 176-186.

   Units are SI for all quantities. Note that back EMF constant Kb is
   identically equal to Torque Constant in SI units, so Ki is omitted
   from interface and replaced with Kb in calculations.

   Modification history:

   23-Oct-2000 WPS split this file from dcmotor.c to provide an algorithm
   based on integrating the differential equations more accurately.
   23-Sep-1999  WPS replaced stdio functions with inet_file functions
   which work under CE.
   23-Sep-1999 WPS initialized suspicious return retval from dcmotorGetParameters
   27-Jan-1999 WPS added "volatile"'s to avoid NT optimization problem.
   23-Mar-1998  FMP included <string.h>, as I should have
   17-Mar-1998  FMP added section arg to dcmotorIniLoad()
   9-Sep-1997  FMP added dcmotorResetState();
   17-Aug-1997  FMP took out etime() call in dcmotorRunCycle-- need to
   add a function to get real time-- etime() in rcs library does this,
   but we don't want to include all of that here
   2-May-1997  FMP fixed bug in dcmotorRunCycle() where I left deltaT
   unset if cycleTime was not <= 0.0. This bug, of course, cost me a week.
   25-Apr-1997  FMP added lastTime and etime() for real-time sim
   24-Apr-1997  FMP added dcmotorIniLoad()
   17-Apr-1997  FMP created from C part of original dcmotor.c
*/

#ifndef NO_STDIO_SUPPORT
#ifdef UNDER_CE
#include "rcs_ce.h"             /* RCS_CE_ATOF() */
#else
#include <stdio.h>
#endif
#include "inetfile.hh"          /* inet_file_open() */
#include "inifile.h"
#include "rcs_prnt.hh"          /* rcs_print() */
#include <string.h>
#include "inifile.h"
#endif
#include "dcmotor2.h"           /* these decls */
#include <math.h>

// Setup __attribute__() macro so that non-gnu compilers still work.
// For gnu compilers the __attribute__((unused)) eliminates the warning
// for unused variables.
#ifndef __GNUC__
#ifndef __attribute__
#define __attribute__(x)
#endif
#endif

/* ident tag */
static char __attribute__((unused)) ident[] = "$Id: dcmotor2.c,v 1.3 2001/01/16 17:35:13 wshackle Exp $";

#define PARAMETERS_SET 0x01
#define CYCLE_TIME_SET 0x02
#define OFFSET_SET 0x04
#define REVS_PER_UNIT_SET 0x08
#define ALL_SET (PARAMETERS_SET | CYCLE_TIME_SET | OFFSET_SET | REVS_PER_UNIT_SET)

/* Conversion factors */
/* oz-in * 0.00708 = newton-meters */
/* foot-pounds * 1.359 = newton-meters */
#define OZ_IN_TO_N_M 0.00708
#define LB_FT_TO_N_M 1.359

int dcmotorInit(DC_MOTOR_STRUCT * dcmotor)
{
  if (0 == dcmotor)
  {
    return -1;
  }

  /* parameters */
  dcmotor->Ra = 0.0;
  dcmotor->La = 0.0;
  dcmotor->Kb = 0.0;
  dcmotor->Jm = 0.0;
  dcmotor->Bm = 0.0;

  /* internal vars */
  dcmotor->configured = 0;
  dcmotor->cycleTime = 0.0;
  dcmotor->offset = 0.0;
  dcmotor->revsPerUnit = 0.0;
  dcmotor->lastTime = -1.0;

  /* state vars */
  return dcmotorResetState(dcmotor);
}

int dcmotorResetState(DC_MOTOR_STRUCT * dcmotor)
{
  /* state vars */
  dcmotor->ia = 0.0;
  dcmotor->dia = 0.0;
  dcmotor->wm = 0.0;
  dcmotor->dwm = 0.0;
  dcmotor->thm = 0.0;
  dcmotor->dthm = 0.0;

  return 0;
}

int dcmotorSetCycleTime(DC_MOTOR_STRUCT * dcmotor, double seconds)
{
  if (0 == dcmotor)
  {
    return -1;
  }

  /* note that seconds <= 0.0 means use real time */
  dcmotor->cycleTime = seconds;
  dcmotor->configured |= CYCLE_TIME_SET;


  if(dcmotor->configured  & PARAMETERS_SET)
    {
      // The sa_time_factor and sb_time_factor probably need to be recalculated.
      dcmotorSetParameters(dcmotor,*dcmotor);
    }

  return 0;
}

double dcmotorGetCycleTime(DC_MOTOR_STRUCT * dcmotor)
{
  if (0 == dcmotor ||
      ! (dcmotor->configured & CYCLE_TIME_SET))
  {
    return 0.0;
  }

  return dcmotor->cycleTime;
}

int dcmotorSetParameters(DC_MOTOR_STRUCT * dcmotor, DC_MOTOR_STRUCT params)
{
  if (0 == dcmotor)
  {
    return -1;
  }

  dcmotor->Ra = params.Ra;
  dcmotor->La = params.La;
  dcmotor->Kb = params.Kb;
  dcmotor->Jm = params.Jm;
  dcmotor->Bm = params.Bm;

  /***
      The simulation is based on two  differential equations.
      From modified version  of Newton's second law the rotor inertia(Jm) * angular accelleration(w') equals the sum of the torques. The torque applied by the motor is  the torque constant(Kb==Ki)*armature current(i). A torque in the opposite direction caused by friction  or the friction coefficent (Bm) * angular velocity(w).

     (1)    Jm*w' + Bm*w + Kb*i = 0.

     From ohms law the sum of all the voltages around a loop must equal zero. The voltages include the externally applied voltage from the amplifier (ea), the voltage across the armature resistance (Ra) * the current (i) , the voltage accross the armature inductance (La) * the derivative of the current(i'), and the voltage caued by back emf or Kb * the angular velocity (w).

     (2)   La*i' + Ra*i + Kb*w  - ea = 0.

     Solving for i from equation (1):

     (3)   i = (Jm*w' + Bm*w)/Kb

     Taking the derivative of both sides of (3):

     (4)   i' = (Jm*w'' + Bm*w')/Kb

     where (w'') is the second derivative of angular velocity.

     Substituting equations (3) and (4) into (2) :

     (5)  La*Jm/Kb * w'' + (Ra*Jm+La*Bm)/Kb * w' + (Ra*Bm/Kb + Kb)* w - ea = 0

     The coefficients of w'',w' and w are calculated below and stored in
     a,b and c respecively.

     If a is not equal to zero, the roots of this differential equation  can be calculated with the quadratic formula. The roots are sa and sb.

     (6) sa = -(b + sqrt(4*a*c-b^2))/(2*a)

     (7) sb = -(b - sqrt(4*a*c-b^2))/(2*a)

     If 4*a*c-b^2 is greater than zero then the real parts of sa and sb (sa_real and sb_real are calculate using (6) and (7), and the imaginary parts are zero. Otherwise both sb_real and sa_real equal -b/(2*a) and the imaginary parts sa_img and sb_img equal sqrt(4*a*c-b^2)/(2*a) and its negative.

     If the cycle time is set and can therefore be considered constant, the time dependant parts of the solution can be calculated ahead of time and hopefully save the CPU bandwidth. If 4*a*c-b^2 is less than zero then the  variable names sa_time_factor and sb_time_factor are a little misleading. They actually correspond to the cos factor (sa_time_factor) and sin factor (sb_time_factor).

     Some degenerate cases to consider:

     if a = 0 then it is only a first order system.

     if b = 0 then any exitation would cause it to oscillate forever, a fairly unrealistic system, not handled here.

     if c = 0 then Kb must be zero and the input voltage will have no effect on
     motor position.

  */
  if (params.Kb > 1E-15)
    {
      dcmotor->a = params.La*params.Jm/params.Kb;
      dcmotor->b = (params.La*params.Bm + params.Ra*params.Jm)/params.Kb;
      dcmotor->c = params.Ra*params.Bm/params.Kb + params.Kb;
      if( dcmotor->a > 1E-15)
        {
          dcmotor->order = 2;
          dcmotor->fourac_minus_b_squared = 4*dcmotor->a*dcmotor->c - dcmotor->b*dcmotor->b;
          if(dcmotor->fourac_minus_b_squared >= 0)
            {
              dcmotor->sa_real = -(dcmotor->b+sqrt(dcmotor->fourac_minus_b_squared))/(2*dcmotor->a);
              dcmotor->sa_img = 0;
              dcmotor->sb_real = -(dcmotor->b+sqrt(dcmotor->fourac_minus_b_squared))/(2*dcmotor->a);
              dcmotor->sb_img = 0;
              if(dcmotor->configured & CYCLE_TIME_SET)
                {
                  dcmotor->sa_time_factor = exp(dcmotor->cycleTime*dcmotor->sa_real);
                  if(dcmotor->fourac_minus_b_squared != 0)
                    {
                      dcmotor->sb_time_factor = exp(dcmotor->cycleTime*dcmotor->sb_real);
                    }
                  else
                    {
                      dcmotor->sb_time_factor = dcmotor->cycleTime*exp(dcmotor->cycleTime*dcmotor->sb_real);
                    }
                }
            }
          else
            {
              dcmotor->sa_real = dcmotor->sb_real = -(dcmotor->b/(2*dcmotor->a));
              dcmotor->sa_img = sqrt(-dcmotor->fourac_minus_b_squared)/(2*dcmotor->a);
              dcmotor->sb_img = -dcmotor->sa_img;
              if(dcmotor->configured & CYCLE_TIME_SET)
                {
                  dcmotor->sa_time_factor = exp(dcmotor->cycleTime*dcmotor->sa_real)*cos(dcmotor->cycleTime*dcmotor->sa_img);
                  dcmotor->sb_time_factor = exp(dcmotor->cycleTime*dcmotor->sa_real)*sin(dcmotor->cycleTime*dcmotor->sa_img);
                }
            }
        }
      else if(dcmotor->b > 1E-15)
        {
          dcmotor->order =1;
          dcmotor->sa_real = -dcmotor->c/dcmotor->b;
          dcmotor->sb_real = dcmotor->sa_img = dcmotor->sb_img = 0;
          if(dcmotor->configured & CYCLE_TIME_SET)
            {
              dcmotor->sa_time_factor = exp(dcmotor->cycleTime*dcmotor->sa_real);
              dcmotor->sb_time_factor = 0;
            }
        }
    }

  dcmotor->configured |= PARAMETERS_SET;

  return 0;
}

DC_MOTOR_STRUCT dcmotorGetParameters(DC_MOTOR_STRUCT * dcmotor)
{
  DC_MOTOR_STRUCT retval;

  if (0 == dcmotor)
  {
     /* parameters */
    retval.Ra=0;                        /* armature resistance, ohms */
    retval.La=0;                        /* armature inductance, henries */
    retval.Kb=0;                        /* back emf constant, V/rad/s, N-m/amp */
    retval.Jm=0;                        /* motor rotor inertia, N-m-s^2 */
    retval.Bm=0;                        /* viscous friction coefficient, N-m/rad/sec */

  /* state vars */
    retval.ia=0;                        /* armature current */
    retval.dia=0;                       /* derivative of above */
    retval.wm=0;                        /* angular velocity of motor */
    retval.dwm=0;                       /* derivative of above */
    retval.thm=0;                       /* angular position of motor */
    retval.dthm=0;                      /* derivative of above */
    retval.lastTime=0;          /* timestamp of last cycle */

  /* internal vars */
    retval.configured=0;
    retval.cycleTime=0;         /* copy of arg to setCycleTime() */
    retval.offset=0;
    retval.revsPerUnit=0;
    return retval;
  }

  return *dcmotor;
}

int dcmotorSetOffset(DC_MOTOR_STRUCT * dcmotor, double _offset)
{
  if (0 == dcmotor)
  {
    return -1;
  }

  dcmotor->offset = _offset;
  dcmotor->configured |= OFFSET_SET;

  return 0;
}

double dcmotorGetOffset(DC_MOTOR_STRUCT * dcmotor)
{
  if (0 == dcmotor ||
      ! (dcmotor->configured & OFFSET_SET))
  {
    return 0.0;
  }

  return dcmotor->offset;
}

int dcmotorSetRevsPerUnit(DC_MOTOR_STRUCT * dcmotor, double _revsPerUnit)
{
  if (0 == dcmotor ||
      _revsPerUnit <= 0.0)
  {
    return -1;
  }

  dcmotor->revsPerUnit = _revsPerUnit;
  dcmotor->configured |= REVS_PER_UNIT_SET;

  return 0;
}

double dcmotorGetRevsPerUnit(DC_MOTOR_STRUCT * dcmotor)
{
  if (0 == dcmotor ||
      ! (dcmotor->configured & REVS_PER_UNIT_SET))
  {
    return 0.0;
  }

  return dcmotor->revsPerUnit;
}

double dcmotorGetOutput(DC_MOTOR_STRUCT * dcmotor)
{
  if (0 == dcmotor ||
      dcmotor->configured != ALL_SET)
  {
    return 0.0;
  }

  return dcmotor->thm + dcmotor->offset;
}

double dcmotorRunCycle(volatile DC_MOTOR_STRUCT * dcm, volatile double ea)
{
  double A,B;
  double delta_thm;

  A=0.0;
  B=0.0;
  delta_thm=0.0;

  if (0 == dcm ||
      dcm->configured != ALL_SET)
    {
      return 0.0;
    }

  if(dcm->order == 2)
    {
      if(dcm->fourac_minus_b_squared > 0 )
      {
        /* The angular velocity  is (w) is controlled by a formula of the
           form:

           (10) w = A* e^(sa*t) + B*e^(sb*t) + ea/c

           sb, sa and c were previously calculated in dcmotorSetParameters.
           (e is ofcourse 2.7182818 ... )


           A and B still need to be calculated from the initial conditions.

           At time t = 0, e^(sa*t) = e^(sb*t) = 1, and w = wo.

           (11) wo = A + B + ea/c

           The derivative of both sides of (10);

           (12) w' = A*sa*e^(sa*t)+ B*sb*e^(sb*t)

           at time t = 0, e^(sa*t) = e^(sb*t) = 1 again, and w`=dwo.

           (13) dwo = A*sa + B*sb

           Once A and B are calculated from (13) and (11)  it is straight forward to calculate the current values of w and w' by substiting t=cycleTime in to equations 10 and 12.

           e^(sa*cycleTime)  and e^(sb*cycleTime)  were previously  calculated in dcmotorSetParameters and stored in sa_time_factor and sb_time_factor.

           To get the change in position or delta_thm, integrate (10) from 0 to time t=cycleTime.

        */

        if( (dcm->sb_real - dcm->sa_real) > 1E-15 ||
           (dcm->sb_real - dcm->sa_real) < -1E-15
         )
        {
          B = (dcm->dwo - dcm->sa_real *(dcm->wo-ea/dcm->c))/(dcm->sb_real - dcm->sa_real);
          A = dcm->wo -ea/dcm->c - B;
        }
        dcm->wo = A*dcm->sa_time_factor + B*dcm->sb_time_factor + ea/dcm->c;
        dcm->dwo = A*dcm->sa_real*dcm->sa_time_factor + B*dcm->sb_real*dcm->sb_time_factor;
        delta_thm = A*(dcm->sa_time_factor-1)/dcm->sa_real + B*(dcm->sb_time_factor -1)/dcm->sb_real + ea/dcm->c*dcm->cycleTime;
      }
      else if (dcm->fourac_minus_b_squared < 0)
      {
        /**
           The angular velocity(w) is controlled by the equation.

           (14) w = A*e^(sa_real*t)*cos(sa_img*t)+ B*e^(sa_real*t)*sin(sa_img*t)+ea/c

           sa_real, sa_img and c were calculated in dcmotorSetParameters()
           (e is ofcourse 2.7182818 ... )

           A and B still need to be calculated from the initial conditions.

           At time t = 0, e^(sa_real)*t = 1, cos(sa_img*t)=1, sin(sa_img*t)=0, and w = wo, so

           (15) wo = A*(1)*(1) + B*(1)*(0) + ea/c

           The derivative of both sides of (14)

           (16) w' = A*sa_real*e^(sa_real*t)*cos(sa_real*t)+
                     -A*sa_img*e^(sa_real*t)*sin(sa_real*t)+
                     B*sa_real*e^(sa_real*t)*sin(sa_real*t)+
                     A*sa_img*e^(sa_real*t)*cos(sa_real*t)

           At time t = 0, e^(sa_real)*t = 1, cos(sa_img*t)=1, sin(sa_img*t)=0, and w' = dwo, so

           (17) dwo = A*sa_real*(1)*(1) +
                      -A*sa_real*(1)*(0) +
                      B*sa_real*(1)*(0) +
                      B*sa_img*(1)*(1)


           Once A and B are calculated from (15) and (17)  it is straight forward to calculate the current values of w and w' by substiting t=cycleTime in to equations (14) and (16).

           e^(sa_real*cycleTime)*cos(sa_img*cycleTime)  and e^(sa_real*cycleTime)*sin(sa_img*cycleTime)  were previously  calculated in dcmotorSetParameters and stored in sa_time_factor and sb_time_factor.

           To get the change in position or delta_thm, integrate (14) from 0 to time t=cycleTime.

        */
        if(
           (dcm->sa_img > 1E-15 || dcm->sa_img < -1E-15 ) &&
           (dcm->c > 1E-15 || dcm->c < -1E-15 ) &&
           (dcm->sa_real > 1E-15 || dcm->sa_real < -1E-15 )
           )
          {
            A = dcm->wo-ea/dcm->c;
            B = (dcm->dwo-dcm->sa_real*A)/dcm->sa_img;
            dcm->wo = A*dcm->sa_time_factor +
              B*dcm->sb_time_factor +
              ea/dcm->c;
            dcm->dwo = A*dcm->sa_real*dcm->sa_time_factor -
              A*dcm->sa_img*dcm->sb_time_factor +
              B*dcm->sb_real*dcm->sb_time_factor +
              B*dcm->sa_img*dcm->sa_time_factor;
            delta_thm =
              A*(dcm->sa_real*dcm->sa_time_factor+
                 dcm->sa_img*dcm->sb_time_factor - dcm->sa_real)/
              (dcm->sa_real*dcm->sa_real + dcm->sa_img*dcm->sa_img) +
              B*(dcm->sa_real*dcm->sb_time_factor-
                 dcm->sa_img*dcm->sa_time_factor + dcm->sa_img)/
              (dcm->sa_real*dcm->sa_real + dcm->sa_img*dcm->sa_img) +
              (ea/dcm->c)*dcm->cycleTime;
          }
      }
      else
        {
          //FINISHME handle the case of fourac_minus_b_squared exactly equal zero.
        }
    }
  dcm->delta_thm = delta_thm;
  dcm->A = A;
  dcm->B = B;
  dcm->last_ea = ea;
  dcm->thm += delta_thm;

  /* return motor position */

  return dcm->thm + dcm->offset;
}

int dcmotorIniLoad(DC_MOTOR_STRUCT * dcmotor, const char * filename, const char *section)
{
#ifndef NO_STDIO_SUPPORT

  DC_MOTOR_STRUCT dcm;
  double cycleTime;
  double offset;
  double revsPerUnit;
  int retval = 0;
  const char *inistring;
  enum {TORQUE_UNITS_INVALID = 0,
        N_M,
        OZ_IN,
        LB_FT
        } torque_units;

#ifndef UNDER_CE
  FILE *fp;

  if (NULL == (fp = fopen(filename, "r")))
  {
    rcs_print_error( "can't open ini file %s\n", filename);
    return -1;
  }
#else
  INET_FILE *fp;

  if (NULL == (fp = inet_file_open(filename, "r")))
  {
    rcs_print_error( "can't open ini file %s\n", filename);
    return -1;
  }
#endif

  /* look up torque units */
  if (NULL != (inistring = iniFind(fp, "TORQUE_UNITS", section)))
  {
    /* found the entry in the ini file */
    if (!strcmp(inistring, "N_M"))
    {
      torque_units = N_M;
    }
    else if (!strcmp(inistring, "LB_FT"))
    {
      torque_units = LB_FT;
    }
    else if (!strcmp(inistring, "OZ_IN"))
    {
      torque_units = OZ_IN;
    }
    else
    {
      torque_units = TORQUE_UNITS_INVALID;
      rcs_print_error( "bad torque units specified in ini file: %s\n",
              inistring);
      retval = -1;
    }
  }
  else
  {
    /* not in ini file-- use default */
    torque_units = N_M;
  }

  if (NULL != (inistring = iniFind(fp, "ARMATURE_RESISTANCE", section)))
  {
#ifndef UNDER_CE
    if (1 != sscanf((char *) inistring, "%lf", &dcm.Ra))
    {
      /* found, but invalid */
      rcs_print_error( "invalid ARMATURE_RESISTANCE: %s\n", inistring);
      retval = -1;
    }
#else
    dcm.Ra = RCS_CE_ATOF(inistring);
#endif
  }
  if (NULL != (inistring = iniFind(fp, "ARMATURE_INDUCTANCE", section)))
  {
#ifndef UNDER_CE
    if (1 != sscanf((char *) inistring, "%lf", &dcm.La))
    {
      /* found, but invalid */
      rcs_print_error( "invalid ARMATURE_INDUCTANCE: %s\n", inistring);
      retval = -1;
    }
#else
    dcm.La = RCS_CE_ATOF(inistring);
#endif
  }
  if (NULL != (inistring = iniFind(fp, "BACK_EMF_CONSTANT", section)))
  {
#ifndef UNDER_CE
    if (1 != sscanf((char *) inistring, "%lf", &dcm.Kb))
    {
      /* found, but invalid */
      rcs_print_error( "invalid BACK_EMF_CONSTANT: %s\n", inistring);
      retval = -1;
    }
#else
    dcm.Kb = RCS_CE_ATOF(inistring);
#endif
  }
  if (NULL != (inistring = iniFind(fp, "ROTOR_INERTIA", section)))
  {
#ifndef UNDER_CE
    if (1 != sscanf((char *) inistring, "%lf", &dcm.Jm))
    {
      /* found, but invalid */
      rcs_print_error( "invalid ROTOR_INERTIA: %s\n", inistring);
      retval = -1;
    }
#else
    dcm.Jm = RCS_CE_ATOF(inistring);
#endif
    switch (torque_units)
    {
    case OZ_IN:
      dcm.Jm *= OZ_IN_TO_N_M;
      break;
    case LB_FT:
      dcm.Jm *= LB_FT_TO_N_M;
      break;
    default:
      break;
    }
  }
  if (NULL != (inistring = iniFind(fp, "DAMPING_FRICTION_COEFFICIENT", section)))
  {
#ifndef UNDER_CE
    if (1 != sscanf((char *) inistring, "%lf", &dcm.Bm))
    {
      /* found, but invalid */
      rcs_print_error( "invalid DAMPING_FRICTION_COEFFICIENT: %s\n", inistring);
      retval = -1;
    }
#else
    dcm.Bm = RCS_CE_ATOF(inistring);
#endif
    switch (torque_units)
    {
    case OZ_IN:
      dcm.Bm *= OZ_IN_TO_N_M;
      break;
    case LB_FT:
      dcm.Bm *= LB_FT_TO_N_M;
      break;
    default:
      break;
    }
  }

  if (retval == 0)
  {
    dcmotorSetParameters(dcmotor, dcm);
  }

  if (NULL != (inistring = iniFind(fp, "CYCLE_TIME", section)))
  {
#ifndef UNDER_CE
    if (1 != sscanf((char *) inistring, "%lf", &cycleTime))
    {
      /* found, but invalid */
      rcs_print_error( "invalid CYCLE_TIME: %s\n", inistring);
      retval = -1;
    }
    else
    {
      dcmotorSetCycleTime(dcmotor, cycleTime);
    }
#else
    cycleTime = RCS_CE_ATOF(inistring);
    dcmotorSetCycleTime(dcmotor, cycleTime);
#endif
  }

  if (NULL != (inistring = iniFind(fp, "SHAFT_OFFSET", section)))
  {
#ifndef UNDER_CE
    if (1 != sscanf((char *) inistring, "%lf", &offset))
    {
      /* found, but invalid */
      rcs_print_error( "invalid OFFSET: %s\n", inistring);
      retval = -1;
    }
    else
    {
      dcmotorSetOffset(dcmotor, offset);
    }
#else
    offset = RCS_CE_ATOF(inistring);
    dcmotorSetOffset(dcmotor, offset);
#endif
  }

  if (NULL != (inistring = iniFind(fp, "REVS_PER_UNIT", section)))
  {
#ifndef UNDER_CE
    if (1 != sscanf((char *) inistring, "%lf", &revsPerUnit))
    {
      /* found, but invalid */
      rcs_print_error( "invalid REVS_PER_UNIT: %s\n", inistring);
      retval = -1;
    }
    else
    {
      dcmotorSetRevsPerUnit(dcmotor, revsPerUnit);
    }
#else
    revsPerUnit = RCS_CE_ATOF(inistring);
    dcmotorSetRevsPerUnit(dcmotor, revsPerUnit);
#endif
  }

  /* close inifile */
#ifndef UNDER_CE
  fclose(fp);
#else
  inet_file_close(fp);
#endif

  return retval;

#else

  return -1;

#endif /* not STDIO_SUPPORT */
}

---