---

simctrlintf.cc

Go to the documentation of this file.

#include "simctrlintf.h"
#include "simmot_n.h"
#include "inifile.h"

extern "C" {
#include <gtk/gtk.h>
#include "sc_interface.h"
#include "sc_support.h"
}

static AMPLIFIER_STRUCT amplifier[SIM_MAX_AXIS];
static double ampOutput[SIM_MAX_AXIS];
static DC_MOTOR_STRUCT dcmotor[SIM_MAX_AXIS];
static ENCODER_STRUCT encoder[SIM_MAX_AXIS];

enum TORQUE_UNITS_TYPE_ENUM
{
  TORQUE_UNITS_INVALID = 0, 
  N_M, 
  OZ_IN,
  LB_FT
 };

enum TORQUE_UNITS_TYPE_ENUM torque_units[SIM_MAX_AXIS];

struct widget_pointers
{
  GtkWidget *AxisSpinbutton;
  GtkWidget *AmpGainSpinbutton;
  GtkWidget *AmpMaxOutSpinbutton;
  GtkWidget *AmpLoadResistanceSpinbutton;
  GtkWidget *RaSpinbutton;
  GtkWidget *LaSpinbutton;
  GtkWidget *KbSpinbutton;
  GtkWidget *JmSpinbutton;
  GtkWidget *BmSpinbutton;
  GtkWidget *countsPerRevSpinbutton;
};

static widget_pointers *wp=NULL;

extern GtkWidget *SimCtrlWindow;

static void initwp()
{
  wp = new widget_pointers();
  wp->AxisSpinbutton = lookup_widget(SimCtrlWindow,"AxisSpinbutton");
  wp->AmpGainSpinbutton = lookup_widget(SimCtrlWindow,"AmpGainSpinbutton");
  wp->AmpMaxOutSpinbutton = lookup_widget(SimCtrlWindow,"AmpMaxOutSpinbutton");
  wp->AmpLoadResistanceSpinbutton = lookup_widget(SimCtrlWindow,"AmpLoadResistanceSpinbutton");
  wp->RaSpinbutton = lookup_widget(SimCtrlWindow,"RaSpinbutton");
  wp->LaSpinbutton = lookup_widget(SimCtrlWindow,"LaSpinbutton");
  wp->KbSpinbutton = lookup_widget(SimCtrlWindow,"KbSpinbutton");
  wp->JmSpinbutton = lookup_widget(SimCtrlWindow,"JmSpinbutton");
  wp->BmSpinbutton = lookup_widget(SimCtrlWindow,"BmSpinbutton");
  wp->BmSpinbutton = lookup_widget(SimCtrlWindow,"BmSpinbutton");
  wp->countsPerRevSpinbutton = lookup_widget(SimCtrlWindow,"countsPerRevSpinbutton");
};


int loadSimulationIniFile(const char *filename)
{
  if(NULL == wp)
    {
      initwp();
    }
  int t,retval;
  char sectionString[INIFILE_MAX_LINELEN];

  for (t = 0; t < SIM_MAX_AXIS; t++)
    {
      sprintf(sectionString, "AXIS_%d", t);

      if (0 != amplifierIniLoad(&amplifier[t], filename, sectionString))
        {
          retval = -1;
        }
      ampOutput[t] = 0.0;

      if (0 != dcmotorIniLoad(&dcmotor[t], filename, sectionString))
        {
          retval = -1;
        }

      if (0 != encoderIniLoad(&encoder[t], filename, sectionString))
        {
          retval = -1;
        }
    }
  int axis = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(wp->AxisSpinbutton));
  gtk_spin_button_set_value(GTK_SPIN_BUTTON(wp->AmpGainSpinbutton),amplifier[axis].gain);
  gtk_spin_button_set_value(GTK_SPIN_BUTTON(wp->AmpMaxOutSpinbutton),amplifier[axis].maxOutputCurrent);
  gtk_spin_button_set_value(GTK_SPIN_BUTTON(wp->AmpLoadResistanceSpinbutton),amplifier[axis].loadResistance);
  gtk_spin_button_set_value(GTK_SPIN_BUTTON(wp->RaSpinbutton),dcmotor[axis].Ra);
  gtk_spin_button_set_value(GTK_SPIN_BUTTON(wp->LaSpinbutton),dcmotor[axis].La);
  gtk_spin_button_set_value(GTK_SPIN_BUTTON(wp->KbSpinbutton),dcmotor[axis].Kb);
  gtk_spin_button_set_value(GTK_SPIN_BUTTON(wp->JmSpinbutton),dcmotor[axis].Jm);
  gtk_spin_button_set_value(GTK_SPIN_BUTTON(wp->BmSpinbutton),dcmotor[axis].Bm);
  gtk_spin_button_set_value(GTK_SPIN_BUTTON(wp->countsPerRevSpinbutton),encoder[axis].countsPerRev);

}



int saveSimulationIniFile(const char *filename)
{
#if 0
/*
  Taken from dumpAxis in iniaxis.cc but modified to do Simulation stuff instead.

  dumpSimAxis(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.
 */
  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];
  char *inistring;

  // rename with backup suffix
  strcpy(line, filename);
  strcat(line, ".bak");
  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;
  }

  int ourSection=0;
  int axis = 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 (!strncmp(section, "AXIS_",5)) {
        ourSection = 1;
        axis = section[5]-'0';
        if(axis > 8 || axis < 0)
          {
            axis = 0;
            ourSection = 0;
          }
        /* look up torque units */
        if (NULL != (inistring = iniFind(infp, "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;
  }
      }
      else {
        ourSection = 0;
      }
    }

    if (ourSection) {
      if (iniIsEntry(line, var, val)) {
        if (!strcmp(var, "AMPLIFIER_GAIN")) {
          iniFormatFloat(fmt, var, val);
          fprintf(outfp, fmt, amplifier[axis].gain);
          continue;             // avoid fputs() below, since we wrote it
        }
        else if (!strcmp(var, "MAX_OUTPUT_CURRENT")) {
          iniFormatFloat(fmt, var, val);
          fprintf(outfp, fmt, amplifier[axis].maxOutputCurrent);
          continue;             // avoid fputs() below, since we wrote it
        }
        else if (!strcmp(var, "LOAD_RESISTANCE")) {
          iniFormatFloat(fmt, var, val);
          fprintf(outfp, fmt, amplifier[axis].loadResistance);
          continue;             // avoid fputs() below, since we wrote it
        }
        else if (!strcmp(var, "ARMATURE_RESISTANCE")) {
          iniFormatFloat(fmt, var, val);
          fprintf(outfp, fmt, dcmotor[axis].Ra);
          continue;             // avoid fputs() below, since we wrote it
        }
        else if (!strcmp(var, "ARMATURE_INDUCTANCE")) {
          iniFormatFloat(fmt, var, val);
          fprintf(outfp, fmt, dcmotor[axis].La);
          continue;             // avoid fputs() below, since we wrote it
        }
        else if (!strcmp(var, "BACK_EMF_CONSTANT")) {
          iniFormatFloat(fmt, var, val);
          fprintf(outfp, fmt, dcmotor[axis].Kb);
          continue;             // avoid fputs() below, since we wrote it
        }       
        else if (!strcmp(var, "ROTOR_INERTIA")) {
          iniFormatFloat(fmt, var, val);
          fprintf(outfp, fmt, dcmotor[axis].Jm);
          continue;             // avoid fputs() below, since we wrote it
        }
        else if (!strcmp(var, "DAMPING_FRICTION_COEFFICIENT")) {
          iniFormatFloat(fmt, var, val);
          fprintf(outfp, fmt, dcmotor[axis].Bm);
          continue;             // avoid fputs() below, since we wrote it
        }
      }
    }

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

  fclose(infp);
  fclose(outfp);
#endif  
  return 0;

}

---