---

iniaxis.cc

Go to the documentation of this file.

/*
  iniaxis.cc

  INI file initialization routines for axis NML

  Modification history:

  10-Aug-2000  FMP added emcAxisLoadComp() call from COMP_FILE
  20-Apr-2000 WPS changed rcs_print(ourAxisSection, "AXIS_%d", axis) to
  sprintf(...);
  24-Feb-2000  FMP added deadband
  23-Feb-2000  FMP added [AXIS_#] MAX_VELOCITY
  5-Oct-1999  FMP added min ferror
  1-Oct-1999  FMP added printing of [AXIS_#] section in error messages
  29-Sep-1999  FMP added HOME_OFFSET
  21-Sep-1999  WPS eliminate sscanf and printf calls not supported under CE.
  30-Aug-1999  FMP moved emcAxisActivate() to the end of the configuration
  9-Aug-1999  FMP added emcAxisSetHome()
  3-Aug-1999  FMP added emcAxisActivate()
  15-Jun-1999  FMP added bracketing of debug printing with EMC_DEBUG
  12-Feb-1999  FMP added FERROR for dumpAxis()
  10-Feb-1999  FMP added OUTPUT_SCALE, and iniFormatFloat2(), for dumpAxis()
  31-Jan-1999 FMP added dumpAxis();
  6-Aug-1998  FMP changed setting of retval = -1 to return -1 in loadAxis,
  since it just kept the controller alive longer than it had to since we're
  going to quit on an error anyway
  8-Jan-1998  FMP honored return values from functions
  10-Dec-1997  FMP added rest of INI file params
  25-Nov-1997  FMP created
  */

extern "C" {
#ifndef UNDER_CE
#include <stdio.h>              // NULL
#endif
#include <stdlib.h>             // atol(), _itoa()
#include <string.h>             // strcmp()
#include <ctype.h>              // isdigit()
}

#include "emc.hh"
#include "inifile.h"
#include "iniaxis.hh"           // these decls
#include "emcglb.h"             // EMC_DEBUG
#include "emccfg.h"             // default values for globals

#ifdef UNDER_CE
#include "rcs_ce.h"
#endif

// inifile ref'ed by iniAxes(), loadAxis()
static INIFILE *axisInifile = 0;

/*
  loadAxis(int axis)

  Loads ini file params for axis, axis = 0, ...

  TYPE <LINEAR ANGULAR>        type of axis
  UNITS <float>                units per mm or deg
  HOME <float>                 home position
  MAX_VELOCITY <float>         max vel for axis
  P <float>                    proportional gain
  I <float>                    integral gain
  D <float>                    derivative gain
  FF0 <float>                  0th order feedforward (position)
  FF1 <float>                  1st order feedforward (velocity)
  FF2 <float>                  2nd order feedforward (acceleration)
  MAX_ERROR <float>            max cumulative error
  BACKLASH <float>             backlash
  BIAS <float>                 constant bias
  DEADBAND <float>             error deadband
  CYCLE_TIME <float>           cycle time
  INPUT_SCALE <float> <float>  scale, offset
  OUTPUT_SCALE <float> <float> scale, offset
  MIN_LIMIT <float>            minimum soft position limit
  MAX_LIMIT <float>            maximum soft position limit
  MIN_OUTPUT <float>           minimum output value (voltage, typically)
  MAX_OUTPUT <float>           maximum output value (voltage, typically)
  FERROR <float>               maximum following error, scaled to max vel
  MIN_FERROR <float>           minimum following error
  HOMING_VEL <float>           homing speed, positive
  ENABLE_POLARITY <0, 1>       polarity for amp enable output
  MIN_LIMIT_SWITCH_POLARITY <0, 1> polarity for min limit switch input
  MAX_LIMIT_SWITCH_POLARITY <0, 1> polarity for max limit switch input
  HOME_SWITCH_POLARITY <0, 1>  polarity for home switch input
  HOMING_POLARITY <0, 1>       direction for homing search
  HOME_OFFSET <float>          where to move axis after home
  FAULT_POLARITY <0, 1>        polarity for amp fault input
  COMP_FILE <filename>         file of axis compensation points

  calls:

  emcAxisSetAxis(int axis, unsigned char axisType);
  emcAxisSetUnits(int axis, double units);
  emcAxisSetGains(int axis, double p, double i, double d, double ff0, double ff1, double ff2, double backlash, double bias, double maxError, double deadband);
  emcAxisSetCycleTime(int axis, double cycleTime);
  emcAxisSetInterpolationRate(int axis, int rate);
  emcAxisSetInputScale(int axis, double scale, double offset);
  emcAxisSetOutputScale(int axis, double scale, double offset);
  emcAxisSetMinPositionLimit(int axis, double limit);
  emcAxisSetMaxPositionLimit(int axis, double limit);
  emcAxisSetMinOutputLimit(int axis, double limit);
  emcAxisSetMaxOutputLimit(int axis, double limit);
  emcAxisSetFerror(int axis, double ferror);
  emcAxisSetMinFerror(int axis, double ferror);
  emcAxisSetHomingVel(int axis, double homingVel);
  emcAxisSetEnablePolarity(int axis, int level);
  emcAxisSetMinLimitSwitchPolarity(int axis, int level);
  emcAxisSetMaxLimitSwitchPolarity(int axis, int level);
  emcAxisSetHomeSwitchPolarity(int axis, int level);
  emcAxisSetHomingPolarity(int axis, int level);
  emcAxisSetFaultPolarity(int axis, int level);
  emcAxisActivate(int axis);
  emcAxisDeactivate(int axis);
  emcAxisSetMaxVelocity(int axis, double vel);
  emcAxisLoadComp(int axis, const char * file);
  */

static int loadAxis(int axis)
{
#define AXIS_STRING_LEN 16
  char axisString[AXIS_STRING_LEN];
  const char *inistring;
  unsigned char axisType;
  double units;
  double p, i, d, ff0, ff1, ff2;
  double backlash;
  double bias;
  double maxError;
  double deadband;
  double cycleTime;
  double scale, offset;
  double limit;
  double homingVel;
  double home;
  double maxVelocity;
  int polarity;
  double maxFerror;

  // compose string to match, axis = 0 -> AXIS_1, etc.
#ifndef UNDER_CE
  sprintf(axisString, "AXIS_%d", axis);
#else
  strcpy(axisString,"AXIS_");
  _itoa(axis,axisString+5, 10);
#endif

  // set axis type

  if (NULL != (inistring = axisInifile->find("TYPE", axisString))) {
    if (! strcmp(inistring, "LINEAR")) {
      // found, and valid
      axisType = EMC_AXIS_LINEAR;
    }
    else if (! strcmp(inistring, "ANGULAR")) {
      // found, and valid
      axisType = EMC_AXIS_ANGULAR;
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] TYPE: %s\n", axisString, inistring);
      }
      axisType = EMC_AXIS_LINEAR;       // default is linear
    }
  }
  else {
    // not found at all
    axisType = EMC_AXIS_LINEAR; // default is linear
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] TYPE, using default\n", axisString);
    }
  }
  if (0 != emcAxisSetAxis(axis, axisType)) {
    if (EMC_DEBUG & EMC_DEBUG_CONFIG) {
      rcs_print_error("bad return from emcAxisSetAxis\n");
    }
    return -1;
  }

  // set units

  if (NULL != (inistring = axisInifile->find("UNITS", axisString))) {
#ifndef UNDER_CE
    if (1 == sscanf(inistring, "%lf", &units)) {
      // found, and valid
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] UNITS: %s\n", axisString, inistring);
      }
      units = 1.0;                      // default
    }
#else
    units = RCS_CE_ATOF(inistring);
#endif
  }
  else {
    // not found at all
    units = 1.0;                        // default
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] UNITS, using default\n", axisString);
    }
  }
  if (0 != emcAxisSetUnits(axis, units)) {
    if (EMC_DEBUG & EMC_DEBUG_CONFIG) {
      rcs_print_error("bad return from emcAxisSetUnits\n");
    }
    return -1;
  }

  // set forward gains

  if (NULL != (inistring = axisInifile->find("P", axisString))) {
#ifndef UNDER_CE
    if (1 == sscanf(inistring, "%lf", &p)) {
      // found, and valid
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] P: %s\n", axisString, inistring);
      }
      p = 0;                    // default
    }
#else
    p = RCS_CE_ATOF(inistring);
#endif
  }
  else {
    // not found at all
    p = 0;                      // default
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] P, using default\n", axisString);
    }
  }

  if (NULL != (inistring = axisInifile->find("I", axisString))) {
#ifndef UNDER_CE
    if (1 == sscanf(inistring, "%lf", &i)) {
      // found, and valid
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] I: %s\n", axisString, inistring);
      }
      i = 0;                    // default
    }
#else
    i = RCS_CE_ATOF(inistring);
#endif
  }
  else {
    // not found at all
    i = 0;                      // default
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] I, using default\n", axisString);
    }
  }

  if (NULL != (inistring = axisInifile->find("D", axisString))) {
#ifndef UNDER_CE
    if (1 == sscanf(inistring, "%lf", &d)) {
      // found, and valid
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] D: %s\n", axisString, inistring);
      }
      d = 0;                    // default
    }
#else
    d = RCS_CE_ATOF(inistring);
#endif
  }
  else {
    // not found at all
    d = 0;                      // default
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] D, using default\n", axisString);
    }
  }

  if (NULL != (inistring = axisInifile->find("FF0", axisString))) {
#ifndef UNDER_CE
    if (1 == sscanf(inistring, "%lf", &ff0)) {
      // found, and valid
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] FF0: %s\n", axisString, inistring);
      }
      ff0 = 0;                  // default
    }
#else
    ff0 = RCS_CE_ATOF(inistring);
#endif
  }
  else {
    // not found at all
    ff0 = 0;                    // default
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] FF0, using default\n", axisString);
    }
  }

  if (NULL != (inistring = axisInifile->find("FF1", axisString))) {
#ifndef UNDER_CE
    if (1 == sscanf(inistring, "%lf", &ff1)) {
      // found, and valid
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] FF1: %s\n", axisString, inistring);
      }
      ff1 = 0;                  // default
    }
#else
    ff1 = RCS_CE_ATOF(inistring);
#endif
  }
  else {
    // not found at all
    ff1 = 0;                    // default
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] FF1, using default\n", axisString);
    }
  }

  if (NULL != (inistring = axisInifile->find("FF2", axisString))) {
#ifndef UNDER_CE
    if (1 == sscanf(inistring, "%lf", &ff2)) {
      // found, and valid
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] FF2: %s\n", axisString, inistring);
      }
      ff2 = 0;                  // default
    }
#else
    ff2 = RCS_CE_ATOF(inistring);
#endif
  }
  else {
    // not found at all
    ff2 = 0;                    // default
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] FF2, using default\n", axisString);
    }
  }

  if (NULL != (inistring = axisInifile->find("BACKLASH", axisString))) {
#ifndef UNDER_CE
    if (1 == sscanf(inistring, "%lf", &backlash)) {
      // found, and valid
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] BACKLASH: %s\n", axisString, inistring);
      }
      backlash = 0;                     // default
    }
#else
    backlash = RCS_CE_ATOF(inistring);
#endif
  }
  else {
    // not found at all
    backlash = 0;                       // default
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] BACKLASH, using default\n", axisString);
    }
  }

  if (NULL != (inistring = axisInifile->find("BIAS", axisString))) {
#ifndef UNDER_CE
    if (1 == sscanf(inistring, "%lf", &bias)) {
      // found, and valid
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] BIAS: %s\n", axisString, inistring);
      }
      bias = 0;                 // default
    }
#else
    bias = RCS_CE_ATOF(inistring);
#endif
  }
  else {
    // not found at all
    bias = 0;                   // default
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] BIAS, using default\n", axisString);
    }
  }

  // max cumulative error

  if (NULL != (inistring = axisInifile->find("MAX_ERROR", axisString))) {
#ifndef UNDER_CE
    if (1 == sscanf(inistring, "%lf", &maxError)) {
      // found, and valid
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] MAX_ERROR: %s\n", axisString, inistring);
      }
      maxError = 0;                     // default
    }
#else
    maxError = RCS_CE_ATOF(inistring);
#endif
  }
  else {
    // not found at all
    maxError = 0;                       // default
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] MAX_ERROR, using default\n", axisString);
    }
  }

  // deadband

  if (NULL != (inistring = axisInifile->find("DEADBAND", axisString))) {
#ifndef UNDER_CE
    if (1 == sscanf(inistring, "%lf", &deadband)) {
      // found, and valid
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] DEADBAND: %s\n", axisString, inistring);
      }
      deadband = 0;                     // default
    }
#else
    deadband = RCS_CE_ATOF(inistring);
#endif
  }
  else {
    // not found at all
    deadband = 0;                       // default
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] DEADBAND, using default\n", axisString);
    }
  }

  // now set them

  if (0 != emcAxisSetGains(axis,
                           p, i, d, ff0, ff1, ff2,
                           backlash, bias, maxError, deadband)) {
    if (EMC_DEBUG & EMC_DEBUG_CONFIG) {
      rcs_print_error("bad return from emcAxisSetGains\n");
    }
    return -1;
  }

  // set cycle time

  if (NULL != (inistring = axisInifile->find("CYCLE_TIME", axisString))) {
#ifndef UNDER_CE
    if (1 == sscanf(inistring, "%lf", &cycleTime)) {
      // found, and valid
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] CYCLE_TIME: %s\n", axisString, inistring);
      }
      cycleTime = 1.0;                  // default
    }
#else
    cycleTime = RCS_CE_ATOF(inistring);
#endif
  }
  else {
    // not found at all
    cycleTime = 1.0;                    // default
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] CYCLE_TIME, using default\n", axisString);
    }
  }
  if (0 != emcAxisSetCycleTime(axis, cycleTime)) {
    if (EMC_DEBUG & EMC_DEBUG_CONFIG) {
      rcs_print_error("bad return from emcAxisSetCycleTime\n");
    }
    return -1;
  }

  // set input scale

  if (NULL != (inistring = axisInifile->find("INPUT_SCALE", axisString))) {
#ifndef UNDER_CE
    if (2 == sscanf(inistring, "%lf %lf", &scale, &offset)) {
      // found, and valid
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] INPUT_SCALE: %s\n", axisString, inistring);
      }
      scale = 1.0;                      // default
      offset = 0.0;                     // default
    }
#else
    scale = RCS_CE_ATOF(inistring);
    offset = 0.0;
#endif
  }
  else {
    // not found at all
    scale = 1.0;                        // default
    offset = 0.0;                       // default
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] INPUT_SCALE, using default\n", axisString);
    }
  }


#ifdef UNDER_CE
  if (NULL != (inistring = axisInifile->find("INPUT_OFFSET", axisString))) {
    offset = RCS_CE_ATOF(inistring);
  }
#endif

  if (0 != emcAxisSetInputScale(axis, scale, offset)) {
    if (EMC_DEBUG & EMC_DEBUG_CONFIG) {
      rcs_print_error("bad return from emcAxisSetInputScale\n");
    }
    return -1;
  }

  // set output scale

  if (NULL != (inistring = axisInifile->find("OUTPUT_SCALE", axisString))) {
#ifndef UNDER_CE
    if (2 == sscanf(inistring, "%lf %lf", &scale, &offset)) {
      // found, and valid
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] OUTPUT_SCALE: %s\n", axisString, inistring);
      }
      scale = 1.0;                      // default
      offset = 0.0;                     // default
    }
#else
    scale = RCS_CE_ATOF(inistring);
    offset = 0.0;
#endif
  }
  else {
    // not found at all
    scale = 1.0;                        // default
    offset = 0.0;                       // default
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] OUTPUT_SCALE, using default\n", axisString);
    }
  }

#ifdef UNDER_CE
  if (NULL != (inistring = axisInifile->find("INPUT_OFFSET", axisString))) {
    offset = RCS_CE_ATOF(inistring);
  }
#endif

  if (0 != emcAxisSetOutputScale(axis, scale, offset)) {
    if (EMC_DEBUG & EMC_DEBUG_CONFIG) {
      rcs_print_error("bad return from emcAxisSetOutputScale\n");
    }
    return -1;
  }

  if (NULL != (inistring = axisInifile->find("MIN_LIMIT", axisString))) {
#ifndef UNDER_CE
    if (1 == sscanf(inistring, "%lf", &limit)) {
      // found, and valid
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] MIN_LIMIT: %s\n", axisString, inistring);
      }
      limit = -1;                       // default for min limit
    }
#else
    limit = RCS_CE_ATOF(inistring);
#endif
  }
  else {
    // not found at all
    limit = -1;                 // default for min limit
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] MIN_LIMIT, using default\n", axisString);
    }
  }

  if (0 != emcAxisSetMinPositionLimit(axis, limit)) {
    if (EMC_DEBUG & EMC_DEBUG_CONFIG) {
      rcs_print_error("bad return from emcAxisSetMinPositionLimit\n");
    }
    return -1;
  }

  if (NULL != (inistring = axisInifile->find("MAX_LIMIT", axisString))) {
#ifndef UNDER_CE
    if (1 == sscanf(inistring, "%lf", &limit)) {
      // found, and valid
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] MAX_LIMIT: %s\n", axisString, inistring);
      }
      limit = 1;                        // default for max limit
    }
#else
    limit = RCS_CE_ATOF(inistring);
#endif
  }
  else {
    // not found at all
    limit = 1;                  // default for max limit
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] MAX_LIMIT, using default\n", axisString);
    }
  }
  if (0 != emcAxisSetMaxPositionLimit(axis, limit)) {
    if (EMC_DEBUG & EMC_DEBUG_CONFIG) {
      rcs_print_error("bad return from emcAxisSetMaxPositionLimit\n");
    }
    return -1;
  }

  if (NULL != (inistring = axisInifile->find("MIN_OUTPUT", axisString))) {
#ifndef UNDER_CE
    if (1 == sscanf(inistring, "%lf", &limit)) {
      // found, and valid
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] MIN_OUTPUT: %s\n", axisString, inistring);
      }
      limit = -1;                       // default for min output
    }
#else
    limit = RCS_CE_ATOF(inistring);
#endif
  }
  else {
    // not found at all
    limit = -1;                 // default for min output
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] MIN_OUTPUT, using default\n", axisString);
    }
  }
  if (0 != emcAxisSetMinOutputLimit(axis, limit)) {
    if (EMC_DEBUG & EMC_DEBUG_CONFIG) {
      rcs_print_error("bad return from emcAxisSetMinOutputLimit\n");
    }
    return -1;
  }

  if (NULL != (inistring = axisInifile->find("MAX_OUTPUT", axisString))) {
#ifndef UNDER_CE
    if (1 == sscanf(inistring, "%lf", &limit)) {
      // found, and valid
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] MAX_OUTPUT: %s\n", axisString, inistring);
      }
      limit = 1;                        // default for max output
    }
#else
    limit = RCS_CE_ATOF(inistring);
#endif
  }
  else {
    // not found at all
    limit = 1;                  // default for max output
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] MAX_OUTPUT, using default\n", axisString);
    }
  }
  if (0 != emcAxisSetMaxOutputLimit(axis, limit)) {
    if (EMC_DEBUG & EMC_DEBUG_CONFIG) {
      rcs_print_error("bad return from emcAxisSetMaxOutputLimit\n");
    }
    return -1;
  }

  if (NULL != (inistring = axisInifile->find("FERROR", axisString))) {
#ifndef UNDER_CE
    if (1 == sscanf(inistring, "%lf", &maxFerror)) {
      // found, and valid
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] FERROR: %s\n", axisString, inistring);
      }
      maxFerror = 1;                    // default for max ferror
    }
#else
    maxFerror = RCS_CE_ATOF(inistring);
#endif
  }
  else {
    // not found at all
    maxFerror = 1;                      // default for max ferror
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] FERROR, using default\n", axisString);
    }
  }
  if (0 != emcAxisSetFerror(axis, maxFerror)) {
    if (EMC_DEBUG & EMC_DEBUG_CONFIG) {
      rcs_print_error("bad return from emcAxisSetFerror\n");
    }
    return -1;
  }

  // do MIN_FERROR, if it's there. If not, use value of maxFerror above
  if (NULL != (inistring = axisInifile->find("MIN_FERROR", axisString))) {
#ifndef UNDER_CE
    if (1 == sscanf(inistring, "%lf", &limit)) {
      // found, and valid
    }
    else {
      // found, but invalid
      limit = maxFerror;        // use prev value of max ferror
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] MIN_FERROR: %s, using default %f\n", axisString, inistring, limit);
      }
    }
#else
    limit = RCS_CE_ATOF(inistring);
#endif
  }
  else {
    // not found at all
    limit = maxFerror;  // use prev value of max ferror
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] MIN_FERROR, using default %f\n", axisString, limit);
    }
  }
  if (0 != emcAxisSetMinFerror(axis, limit)) {
    if (EMC_DEBUG & EMC_DEBUG_CONFIG) {
      rcs_print_error("bad return from emcAxisSetMinFerror\n");
    }
    return -1;
  }

  if (NULL != (inistring = axisInifile->find("HOMING_VEL", axisString))) {
#ifndef UNDER_CE
    if (1 == sscanf(inistring, "%lf", &homingVel)) {
      // found, and valid
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] HOMING_VEL: %s\n", axisString, inistring);
      }
      homingVel = 1;                    // default for homing vel
    }
#else
    homingVel = RCS_CE_ATOF(inistring);
#endif
  }
  else {
    // not found at all
    homingVel = 1;
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] HOMING_VEL, using default\n", axisString);
    }
  }
  if (0 != emcAxisSetHomingVel(axis, homingVel)) {
    if (EMC_DEBUG & EMC_DEBUG_CONFIG) {
      rcs_print_error("bad return from emcAxisSetHomingVel\n");
    }
    return -1;
  }

  if (NULL != (inistring = axisInifile->find("HOME", axisString))) {
#ifndef UNDER_CE
    if (1 == sscanf(inistring, "%lf", &home)) {
      // found, and valid
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] HOME: %s\n", axisString, inistring);
      }
      home = 0.0;                       // default
    }
#else
    home = RCS_CE_ATOF(inistring);
#endif
  }
  else {
    // not found at all
    home = 0.0;
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] HOME, using default\n", axisString);
    }
  }
  if (0 != emcAxisSetHome(axis, home)) {
    if (EMC_DEBUG & EMC_DEBUG_CONFIG) {
      rcs_print_error("bad return from emcAxisSetHome\n");
    }
    return -1;
  }

  if (NULL != (inistring = axisInifile->find("MAX_VELOCITY", axisString))) {
#ifndef UNDER_CE
    if (1 == sscanf(inistring, "%lf", &maxVelocity)) {
      // found, and valid
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] MAX_VELOCITY: %s\n", axisString, inistring);
      }
      maxVelocity = DEFAULT_AXIS_MAX_VELOCITY;  // default
    }
#else
    maxVelocity = RCS_CE_ATOF(inistring);
#endif
  }
  else {
    // not found at all
    maxVelocity = DEFAULT_AXIS_MAX_VELOCITY;
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] MAX_VELOCITY, using default\n", axisString);
    }
  }
  if (0 != emcAxisSetMaxVelocity(axis, maxVelocity)) {
    if (EMC_DEBUG & EMC_DEBUG_CONFIG) {
      rcs_print_error("bad return from emcAxisSetMaxVelocity\n");
    }
    return -1;
  }

  if (NULL != (inistring = axisInifile->find("ENABLE_POLARITY", axisString))) {
#ifndef UNDER_CE
    if (1 == sscanf(inistring, "%d", &polarity)) {
      // found, and valid
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] ENABLE_POLARITY: %s\n", axisString, inistring);
      }
      polarity = 1;                     // default for polarities
    }
#else
    polarity = atol(inistring);
#endif
  }
  else {
    // not found at all
    polarity = 1;                       // default for polarities
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] ENABLE_POLARITY, using default\n", axisString);
    }
  }
  if (0 != emcAxisSetEnablePolarity(axis, polarity)) {
    if (EMC_DEBUG & EMC_DEBUG_CONFIG) {
      rcs_print_error("bad return from emcAxisSetEnablePolarity\n");
    }
    return -1;
  }

  if (NULL != (inistring = axisInifile->find("MIN_LIMIT_SWITCH_POLARITY", axisString))) {
#ifndef UNDER_CE
    if (1 == sscanf(inistring, "%d", &polarity)) {
      // found, and valid
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] MIN_LIMIT_SWITCH_POLARITY: %s\n", axisString, inistring);
      }
      polarity = 1;                     // default for polarities
    }
#else
    polarity = atol(inistring);
#endif
  }
  else {
    // not found at all
    polarity = 1;                       // default for polarities
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] MIN_LIMIT_SWITCH_POLARITY, using default\n", axisString);
    }
  }
  if (0 != emcAxisSetMinLimitSwitchPolarity(axis, polarity)) {
    if (EMC_DEBUG & EMC_DEBUG_CONFIG) {
      rcs_print_error("bad return from emcAxisSetMinLimitSwitchPolarity\n");
    }
    return -1;
  }

  if (NULL != (inistring = axisInifile->find("MAX_LIMIT_SWITCH_POLARITY", axisString))) {
#ifndef UNDER_CE
    if (1 == sscanf(inistring, "%d", &polarity)) {
      // found, and valid
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] MAX_LIMIT_SWITCH_POLARITY: %s\n", axisString, inistring);
      }
      polarity = 1;                     // default for polarities
    }
#else
    polarity = atol(inistring);
#endif
  }
  else {
    // not found at all
    polarity = 1;                       // default for polarities
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] MAX_LIMIT_SWITCH_POLARITY, using default\n", axisString);
    }
  }
  if (0 != emcAxisSetMaxLimitSwitchPolarity(axis, polarity)) {
    if (EMC_DEBUG & EMC_DEBUG_CONFIG) {
      rcs_print_error("bad return from emcAxisSetMaxLimitSwitchPolarity\n");
    }
    return -1;
  }

  if (NULL != (inistring = axisInifile->find("HOME_SWITCH_POLARITY", axisString))) {
#ifndef UNDER_CE
    if (1 == sscanf(inistring, "%d", &polarity)) {
      // found, and valid
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] HOME_SWITCH_POLARITY: %s\n", axisString, inistring);
      }
      polarity = 1;                     // default for polarities
    }
#else
    polarity = atol(inistring);
#endif
  }
  else {
    // not found at all
    polarity = 1;                       // default for polarities
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] HOME_SWITCH_POLARITY, using default\n", axisString);
    }
  }
  if (0 != emcAxisSetHomeSwitchPolarity(axis, polarity)) {
    if (EMC_DEBUG & EMC_DEBUG_CONFIG) {
      rcs_print_error("bad return from emcAxisSetHomeSwitchPolarity\n");
    }
    return -1;
  }

  if (NULL != (inistring = axisInifile->find("HOMING_POLARITY", axisString))) {
#ifndef UNDER_CE
    if (1 == sscanf(inistring, "%d", &polarity)) {
      // found, and valid
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] HOMING_POLARITY: %s\n", axisString, inistring);
      }
      polarity = 1;                     // default for polarities
    }
#else
    polarity = atol(inistring);
#endif
  }
  else {
    // not found at all
    polarity = 1;                       // default for polarities
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] HOMING_POLARITY, using default\n", axisString);
    }
  }
  if (0 != emcAxisSetHomingPolarity(axis, polarity)) {
    if (EMC_DEBUG & EMC_DEBUG_CONFIG) {
      rcs_print_error("bad return from emcAxisSetHomingPolarity\n");
    }
    return -1;
  }

  if (NULL != (inistring = axisInifile->find("HOME_OFFSET", axisString))) {
#ifndef UNDER_CE
    if (1 == sscanf(inistring, "%lf", &offset)) {
      // found, and valid
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] HOME_OFFSET: %s\n", axisString, inistring);
      }
      offset = 0.0;
    }
#else
    offset = atol(inistring);
#endif
  }
  else {
    // not found at all
    offset = 0.0;
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] HOME_OFFSET, using default\n", axisString);
    }
  }
  if (0 != emcAxisSetHomeOffset(axis, offset)) {
    if (EMC_DEBUG & EMC_DEBUG_CONFIG) {
      rcs_print_error("bad return from emcAxisSetHomeOffset\n");
    }
    return -1;
  }

  if (NULL != (inistring = axisInifile->find("FAULT_POLARITY", axisString))) {
#ifndef UNDER_CE
    if (1 == sscanf(inistring, "%d", &polarity)) {
      // found, and valid
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [%s] FAULT_POLARITY: %s\n", axisString, inistring);
      }
      polarity = 1;                     // default for polarities
    }
#else
    polarity = atol(inistring);
#endif
  }
  else {
    // not found at all
    polarity = 1;                       // default for polarities
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [%s] FAULT_POLARITY, using default\n", axisString);
    }
  }
  if (0 != emcAxisSetFaultPolarity(axis, polarity)) {
    if (EMC_DEBUG & EMC_DEBUG_CONFIG) {
      rcs_print_error("bad return from emcAxisSetFaultPolarity\n");
    }
    return -1;
  }

  if (NULL != (inistring = axisInifile->find("COMP_FILE", axisString))) {
    if (0 != emcAxisLoadComp(axis, inistring)) {
      if (EMC_DEBUG & EMC_DEBUG_CONFIG) {
        rcs_print_error("bad return from emcAxisLoadComp\n");
      }
      return -1;
    }
  }
  // else not found, so ignore

  // lastly, activate axis. Do this last so that the motion controller
  // won't flag errors midway during configuration
  emcAxisActivate(axis);

  return 0;
}

/*
  iniAxis(int axis, const char *filename)

  Loads ini file parameters for specified axis, [0 .. AXES - 1]

  Looks for AXES in TRAJ section for how many to do, up to
  EMC_AXIS_MAX.
 */
int iniAxis(int axis, const char *filename)
{
  int retval = 0;
  const char *inistring;
  int axes;

  axisInifile = new INIFILE;
  if (-1 == axisInifile->open(filename)) {
    return -1;
  }

  if (NULL != (inistring = axisInifile->find("AXES", "TRAJ"))) {
#ifndef UNDER_CE
    if (1 == sscanf(inistring, "%d", &axes)) {
      // found, and valid
    }
    else {
      // found, but invalid
      if (EMC_DEBUG & EMC_DEBUG_INVALID) {
        rcs_print_error("invalid inifile value for [TRAJ] AXES: %s\n", inistring);
      }
      axes = 0;
    }
#else
    axes = atol(inistring);
#endif
  }
  else {
    // not found at all
    axes = 1;
    if (EMC_DEBUG & EMC_DEBUG_DEFAULTS) {
      rcs_print_error("can't find [TRAJ] AXES, using default %d\n", axes);
    }
  }

  if (axis < 0 ||
      axis >= axes) {
    // requested axis exceeds machine axes
    axisInifile->close();
    delete axisInifile;
    return -1;
  }

  // load its values
  if (0 != loadAxis(axis)) {
    retval = -1;
  }

  // close the inifile
  axisInifile->close();
  delete axisInifile;

  return retval;
}

// WPS -- these functions are needed only by dumpAxis(), there
// is no reasonable way to implement dumpAxis under CE.
#ifndef UNDER_CE

// FIXME-- begin temporary insert of ini file stuff

#define INIFILE_MIN_FLOAT_PRECISION 3
#define INIFILE_BACKUP_SUFFIX ".bak"

/* iniIsEntry(const char *line, char *var, char *val) returns 0 if the
   line is not interpretable as a variable-value ini file entry. If the
   line is interpretable as an ini file entry (i.e., it is of the form
   ``<some nonwhite> = {<value>}'' where <value> is optional), then the
   variable string is copied to 'var', and the value string is copied to
   'val'. Leading and trailing whitespace around 'var' and 'val' are
   omitted. */

static int iniIsEntry(const char *line, char *var, char *val)
{
  const char *ptr = line;
  char *varptr = var;
  char *valptr = val;
  char *lastwhite = NULL;
  int sawEqual = 0;

  // position ptr to first non-white on line
  while (isspace(*ptr)) {
    ptr++;
  }

  if (*ptr == 0 ||
      *ptr == '=') {
    // got to end or '=' before any non-white
    return 0;
  }

  // here's the first non-white, so begin copy to var
  while (*ptr != 0) {
    if (*ptr == '=') {
      sawEqual = 1;
      break;
    }

    // copy it, including any whitespace
    *varptr = *ptr;

    // mark the location of last whitespace, for nulling
    if (isspace(*ptr)) {
      if (lastwhite == NULL) {
        lastwhite = varptr;
      }
    }
    else {
      lastwhite = NULL;
    }

    varptr++;
    ptr++;
  }

  if (! sawEqual) {
    return 0;
  }

  // null-terminate at last whitespace, or end of string if none
  if (lastwhite != NULL) {
    *lastwhite = 0;
  }
  else {
    *varptr = 0;
  }

  // now move to value part

  lastwhite = NULL;
  ptr++;                        // step over '='

  // position ptr to first non-white on line
  while (isspace(*ptr)) {
    ptr++;
  }

  if (*ptr == 0) {
    // got to end before any non-white
    return 0;
  }

  // here's the first non-white, so begin copy to var
  while (*ptr != 0) {
    // copy it, including any whitespace
    *valptr = *ptr;

    // mark the location of last whitespace, for nulling
    if (isspace(*ptr)) {
      if (lastwhite == NULL) {
        lastwhite = valptr;
      }
    }
    else {
      lastwhite = NULL;
    }

    valptr++;
    ptr++;
  }

  // null-terminate at last whitespace, or end of string if none
  if (lastwhite != NULL) {
    *lastwhite = 0;
  }
  else {
    *valptr = 0;
  }

  return 1;
}

/* iniIsSection(const char *line, char *section) returns 0 if the line
   is not interpretable as a section. If the line is interpretable as a
   section (i.e., it has [ <string > ] as the only thing on it), then the
   stuff between the [], not including any leading or trailing
   whitespace, but including any intervening whitespace, is copied to
   'section'. */

static int iniIsSection(const char *line, char *section)
{
  const char *ptr = line;
  char *secptr = section;
  char *lastwhite = NULL;
  int sawClose = 0;

  // position ptr to first non-white on line
  while (isspace(*ptr)) {
    ptr++;
  }

  if (*ptr == 0) {
    // got to end before any non-white
    return 0;
  }

  if (*ptr != '[') {
    // not section format
    return 0;
  }

  // we're on [, so move to next non-white
  ptr++;
  while (isspace(*ptr)) {
    ptr++;
  }

  if (*ptr == 0) {
    // got to end before any non-white
    return 0;
  }

  // here's the first non-white after the [, so begin copy to string
  while (*ptr != 0) {
    if (*ptr == ']') {
      sawClose = 1;
      break;
    }

    // copy it, including any whitespace
    *secptr = *ptr;

    // mark the location of last whitespace, for nulling
    if (isspace(*ptr)) {
      if (lastwhite == NULL) {
        lastwhite = secptr;
      }
    }
    else {
      lastwhite = NULL;
    }

    secptr++;
    ptr++;
  }

  if (! sawClose) {
    // section had a close bracket
    return 0;
  }

  // null-terminate at last whitespace, or end of string if none
  if (lastwhite != NULL) {
    *lastwhite = 0;
  }
  else {
    *secptr = 0;
  }

  // section didn't have a close bracket
  return 1;
}

int iniGetFloatPrec(const char *str)
{
  const char *ptr = str;
  int prec = 0;

  // find '.', return min precision if no decimal point
  while (1) {
    if (*ptr == 0) {
      return INIFILE_MIN_FLOAT_PRECISION;
    }
    if (*ptr == '.') {
      break;
    }
    ptr++;
  }

  // ptr is on '.', so step over
  ptr++;

  // count number of digits until whitespace or end or non-digit
  while (1) {
    if (*ptr == 0) {
      break;
    }
    if (! isdigit(*ptr)) {
      break;
    }
    // else it's a digit
    prec++;
    ptr++;
  }

  return prec > INIFILE_MIN_FLOAT_PRECISION ? prec : INIFILE_MIN_FLOAT_PRECISION;
}

int iniFormatFloat(char *fmt, const char *var, const char *val)
{
  sprintf(fmt, "%s = %%.%df\n", var, iniGetFloatPrec(val));

  return 0;
}

// 'val' in this case is a string with a pair of floats, the first
// which sets the precision
int iniFormatFloat2(char *fmt, const char *var, const char *val)
{
  int prec;

  // FIXME-- should capture each one's float precision; right
  // now we're using the first as the precision for both
  prec = iniGetFloatPrec(val);
  sprintf(fmt, "%s = %%.%df %%.%df\n", var, prec, prec);

  return 0;
}

// end temporary insert of ini file stuff

/// End of UNDER_CE ifdefing out.
#endif

/*
  dumpAxis(int axis, const char *filename, EMC_AXIS_STAT *stat)

  Takes the file name for the ini file, makes a backup copy, opens the
  backup copy, then overwrites the original with a line-by-line version
  of the original, parsing the lines for ones it understands and
  replacing the values with the current ones.
 */
int dumpAxis(int axis, const char *filename, EMC_AXIS_STAT *stat)
{
#ifdef UNDER_CE
  return -1;
#else
  char ourAxisSection[256];
  int ourAxis = 0;
  FILE *infp = NULL;
  FILE *outfp = NULL;
  char line[256];
  char section[256];
  char var[256], val[256];
  char fmt[256];

  // rename with backup suffix
  strcpy(line, filename);
  strcat(line, INIFILE_BACKUP_SUFFIX);
  if (0 != rename(filename, line)) {
    fprintf(stderr, "can't make backup copy of INI file %s\n", filename);
    return -1;
  }

  // open backup for reading
  if (NULL == (infp = fopen(line, "r"))) {
    fprintf(stderr, "can't open backup copy of INI file %s\n", line);
    return -1;
  }

  // open original for writing
  if (NULL == (outfp = fopen(filename, "w"))) {
    fprintf(stderr, "can't open original copy of INI file %s\n", line);
    return -1;
  }

  // set our axis string and flag that we're in that section
  sprintf(ourAxisSection, "AXIS_%d", axis);
  ourAxis = 0;

  while (!feof(infp)) {
    if (NULL == fgets(line, 256, infp)) {
      break;
    }

    if (iniIsSection(line, section)) {
      // if this is "AXIS_0,1,...", it's what we want
      if (!strcmp(section, ourAxisSection)) {
        ourAxis = 1;
      }
      else {
        ourAxis = 0;
      }
    }

    if (ourAxis) {
      if (iniIsEntry(line, var, val)) {
        if (!strcmp(var, "P")) {
          iniFormatFloat(fmt, var, val);
          fprintf(outfp, fmt, stat->p);
          continue;             // avoid fputs() below, since we wrote it
        }
        else if (!strcmp(var, "I")) {
          iniFormatFloat(fmt, var, val);
          fprintf(outfp, fmt, stat->i);
          continue;
        }
        else if (!strcmp(var, "D")) {
          iniFormatFloat(fmt, var, val);
          fprintf(outfp, fmt, stat->d);
          continue;
        }
        else if (!strcmp(var, "FF0")) {
          iniFormatFloat(fmt, var, val);
          fprintf(outfp, fmt, stat->ff0);
          continue;
        }
        else if (!strcmp(var, "FF1")) {
          iniFormatFloat(fmt, var, val);
          fprintf(outfp, fmt, stat->ff1);
          continue;
        }
        else if (!strcmp(var, "FF2")) {
          iniFormatFloat(fmt, var, val);
          fprintf(outfp, fmt, stat->ff2);
          continue;
        }
        else if (!strcmp(var, "BACKLASH")) {
          iniFormatFloat(fmt, var, val);
          fprintf(outfp, fmt, stat->backlash);
          continue;
        }
        else if (!strcmp(var, "BIAS")) {
          iniFormatFloat(fmt, var, val);
          fprintf(outfp, fmt, stat->bias);
          continue;
        }
        else if (!strcmp(var, "MAX_ERROR")) {
          iniFormatFloat(fmt, var, val);
          fprintf(outfp, fmt, stat->maxError);
          continue;
        }
        else if (!strcmp(var, "DEADBAND")) {
          iniFormatFloat(fmt, var, val);
          fprintf(outfp, fmt, stat->deadband);
          continue;
        }
        else if (!strcmp(var, "OUTPUT_SCALE")) {
          // val will be a string with two floats, e.g., "1.0 0.0",
          // and iniFormatFloat2() will set fmt to convert 2 floats
          // at the precision of the first in the string
          iniFormatFloat2(fmt, var, val);
          fprintf(outfp, fmt, stat->outputScale, stat->outputOffset);
          continue;
        }
        else if (!strcmp(var, "FERROR")) {
          iniFormatFloat(fmt, var, val);
          fprintf(outfp, fmt, stat->maxFerror);
          continue;
        }
        else if (!strcmp(var, "MIN_FERROR")) {
          iniFormatFloat(fmt, var, val);
          fprintf(outfp, fmt, stat->minFerror);
          continue;
        }
      }
    }

    // write it out
    fputs(line, outfp);
  }

  fclose(infp);
  fclose(outfp);

  return 0;
#endif
}

---