---

simdio.c

Go to the documentation of this file.

/*
  simio.c

  Simulated external digital IO interface

  Modification history:

  27-Jul-2000 WPS added compile-switched stat'ing of switch files using
  USE_STAT_FILES
  20-Mar-2000 WPS added unused attribute to ident to avoid 'defined but not used' compiler warning
  21-Sep-1999  WPS eliminate sscanf and printf calls not supported under CE.
  15-Sep-1999  FMP bracketed printing with check for EMC_DEBUG &
  EMC_DEBUG_IO_POINTS
  7-Aug-1998  FMP created from simio.c
  */

/* Define this if you want to test limit switches, home switches by
   touching files and having stat() look for them. On an NFS file system,
   this can generate lots of traffic.
   Otherwise, the functions will just return "normal" status. */
#if !defined(rtlinux) && !defined(rtai)
#define USE_STAT_FILES
#define NAMELEN 8               /* length of stat file names */
#endif

#if !defined(rtlinux) && !defined(rtai)
#include <stdlib.h>             /* strtod */
#endif
#if !defined(rtlinux) && !defined(rtai)
#ifndef UNDER_CE
#include <stdio.h>              /* printf() */
#endif
#ifdef USE_STAT_FILES
#include <string.h>
#include <sys/stat.h>
#endif
#include "rcs_prnt.hh"          /* rcs_print() */
#include "emcglb.h"             /* EMC_DEBUG, EMC_DEBUG_IO_POINTS */
#endif
#include "sim.h"                /* these decls */

/* ident tag */
#ifndef __GNUC__
#ifndef __attribute__
#define __attribute__(x)
#endif
#endif

static char __attribute__((unused))  ident[] = "$Id: simdio.c,v 1.9 2001/06/29 20:27:29 wshackle Exp $";

/*
  digital IO model

  Provides for simulated digital ins, outs
  */

#define SIM_DIO_INPUT_BYTES 4   /* bytes of digital ins */
#define SIM_DIO_OUTPUT_BYTES 4  /* bytes of digital outs */

#define SIM_DIO_MAX_INPUTS (SIM_DIO_INPUT_BYTES * 8)
#define SIM_DIO_MAX_OUTPUTS (SIM_DIO_OUTPUT_BYTES * 8)

/* the actual digital ins, outs */

static unsigned char simDioInputs[SIM_DIO_INPUT_BYTES];
static unsigned char simDioOutputs[SIM_DIO_OUTPUT_BYTES];

#define SIM_MAX_POS_FIELDS 20

#ifndef SIM_MAX_AXIS
#define SIM_MAX_AXIS 8
#endif

struct sim_dio_position_field {
  int start_axis_flags; // Which fields to compare/ignore in end pos
  int end_axis_flags; // Which fields to compare/ignore in end pos
  double start_pos[SIM_MAX_AXIS];
  double end_pos[SIM_MAX_AXIS];
};


struct sim_dio_config {
  int use_stat_file;
  int use_pos_fields;
  int number_of_position_fields;
  int polarity;
  struct sim_dio_position_field pos_field[SIM_MAX_POS_FIELDS];
};


#if !defined(rtlinux) && !defined(rtai)
 
static struct sim_dio_config dio_config[SIM_DIO_MAX_INPUTS];


#include "inifile.h"

static int btostr(char * s, unsigned char b)
{
  int t;

  for (t = 7; t >= 0; t--) {
    s[t] = b % 2 ? '1' : '0';
    b >>= 1;
  }
  s[8] = 0;                     /* null terminate */

  return 0;
}


static const char *posDelimiters=" \t\r\n";

static int readPositionFile(int index, const char *filename)
{
  FILE *f;
  int pos_fields_read;
  int axis;
  char *token;
  char linebuf[256];

  f = fopen(filename,"r");
  if(NULL == f)
    {
      return -1;
    }

  pos_fields_read = 0;
  while(!feof(f) && pos_fields_read < SIM_MAX_POS_FIELDS)
    {
      dio_config[index].pos_field[pos_fields_read].start_axis_flags = 0;
      dio_config[index].pos_field[pos_fields_read].end_axis_flags = 0;
      
      fgets(linebuf,256,f);
      while(NULL != strchr("#;\r\n \t",linebuf[0]))
        {
          fgets(linebuf,256,0);
          if(feof(f))
            {
            break;
            }
        }
      token = strtok(linebuf,posDelimiters);
      for(axis = 0; NULL != token && axis < SIM_MAX_AXIS;
          axis++,  token = strtok(NULL,posDelimiters) )
        {
          if(!strcmp(token,"*"))
            {
              continue;
            }
          dio_config[index].pos_field[pos_fields_read].start_pos[axis] =
            strtod(token,NULL);
          dio_config[index].pos_field[pos_fields_read].start_axis_flags |= (1 << axis);
        }
      fgets(linebuf,256,f);
      while(NULL != strchr("#;\r\n \t",linebuf[0]))
        {
          fgets(linebuf,256,0);
          if(feof(f))
            {
            break;
            }
        }
      token = strtok(linebuf,posDelimiters);
      for(axis = 0; NULL != token && axis < SIM_MAX_AXIS;
          axis++,  token = strtok(NULL,posDelimiters) )
        {
          if(!strcmp(token,"*"))
            {
              continue;
            }
          dio_config[index].pos_field[pos_fields_read].end_pos[axis] =
            strtod(token,NULL);
          dio_config[index].pos_field[pos_fields_read].end_axis_flags |= (1 << axis);
        }
      pos_fields_read++;
    }

  dio_config[index].number_of_position_fields = pos_fields_read;
  dio_config[index].use_pos_fields =1;
  fclose(f);

  return 0;
}

static int simDioIniLoad(const char *filename)
{
  FILE *f;
  const char *inistring;
  char section[40];
  int i;
  int byte;
  unsigned char mask = 0x01;

  // open it
  if(  (f = fopen(filename,"r")) == NULL) {
    return -1;
  }

  for( i = 0; i < SIM_DIO_MAX_INPUTS; i++)
    {
      sprintf(section,"SIM_DIO_%d",i);

      dio_config[i].use_stat_file = 0;
      dio_config[i].use_pos_fields = 0;      
      dio_config[i].polarity = 0;      

      if (NULL != (inistring = iniFind(f,"POLARITY", section))) 
        {
          if (1 != sscanf(inistring, "%i", &dio_config[i].polarity)) 
            {
            dio_config[i].polarity = 0;
            }
          byte = i / 8;
          mask <<= i % 8;
          if(dio_config[i].polarity)
            {
              simDioInputs[byte] |= mask;
            }
          else
            {
              simDioInputs[byte] &= ~mask;
            }
        }
      
      if (NULL != (inistring = iniFind(f,"USE_STAT_FILE", section))) 
        {
          // copy to global
          if (1 != sscanf(inistring, "%i", &dio_config[i].use_stat_file)) 
            {
              dio_config[i].use_stat_file = 0;
            }
        }
      if (NULL != (inistring = iniFind(f,"POSITION_FILE", section))) 
        {
          readPositionFile(i,inistring);
        }
      
    }

  fclose(f);

  return 0;
}



#endif

static void printDioOutputs(void)
{
#if !defined(rtlinux) && !defined(rtai)
  int t;
  char byteString[9];

  if (EMC_DEBUG & EMC_DEBUG_IO_POINTS) {
    for (t = SIM_DIO_OUTPUT_BYTES - 1; t >= 0; t--) {
      btostr(byteString, simDioOutputs[t]);
      rcs_print("%s ", byteString);
    }
  rcs_print("\n");
  }
#endif
}

int simDioInit(const char * filename)
{
#if !defined(rtlinux) && !defined(rtai)
  printf("simDioInit(%s)\n",filename);
  simDioIniLoad(filename);
#endif

  return 0;
}

int simDioQuit()
{
  return 0;
}

int simDioMaxInputs()
{
  return SIM_DIO_MAX_INPUTS;
}

int simDioMaxOutputs()
{
  return SIM_DIO_MAX_OUTPUTS;
}

#ifdef USE_STAT_FILES
static int current_pos_in_field(int index)
{
  int i,j;
  int in_this_field;

  if (index < 0 ||
      index >= SIM_DIO_MAX_INPUTS) 
    {
      return -1;
    }
  
  if( dio_config[index].number_of_position_fields > SIM_MAX_POS_FIELDS)
    {
      dio_config[index].number_of_position_fields = SIM_MAX_POS_FIELDS;
      return -1;
    }

      
  for(j = 0; j < dio_config[index].number_of_position_fields; j++)
    {
      in_this_field = 1;
      for( i = 0; i < SIM_MAX_AXIS; i++)
        {
          if(
             simPos[i] < dio_config[index].pos_field[j].start_pos[i] &&
             (dio_config[index].pos_field[j].start_axis_flags & (1 << i))
             )
            {
              in_this_field = 0;
              break;
            }
          if(
             simPos[i] > dio_config[index].pos_field[j].end_pos[i] &&
             (dio_config[index].pos_field[j].end_axis_flags & (1 << i))
             )
            {
              in_this_field = 0;
              break;
            }
        }
      if(in_this_field)
        {
          return 1;
        }
    }
  return 0;
}
#endif


int simDioRead(int index, int *value)
{
  int byte;
  unsigned char mask = 0x01;
#ifdef USE_STAT_FILES
  struct stat buf;
  char diFile[NAMELEN];
#endif

  if (index < 0 ||
      index >= SIM_DIO_MAX_INPUTS) {
    return -1;
  }

  byte = index / 8;
  mask <<= index % 8;

#ifdef USE_STAT_FILES
  if(dio_config[index].use_stat_file) {
    /* to test Digital IO logic, this code tests for the existence
       of file "di<n>" for home switch on axis n.
       During controller debug, touch these files to create them
       and the controller should see the corresponding input go high. */
    
#ifndef UNDER_CE
    sprintf(diFile, "di%d", index);
#else
    strcpy(diFile,"di");
    _itoa(index, diFile+2,10);
#endif
    
    if (0 == stat(diFile, &buf) == dio_config[index].polarity)
      {
        /* file exists */
      simDioInputs[byte] |= mask;
      }
    else
      {
        simDioInputs[byte] &= ~mask;
      }
  }
  else if(dio_config[index].use_pos_fields) {
    if(current_pos_in_field(index) == dio_config[index].polarity)
      {
        simDioInputs[byte] |= mask;
      }
    else
      {
        simDioInputs[byte] &= ~mask;
      }
  }
#endif


  *value = (simDioInputs[byte] & mask) == 0 ? 0 : 1;

  return 0;
}

int simDioWrite(int index, int value)
{
  int byte;
  unsigned char mask = 0x01;

  if (index < 0 ||
      index >= SIM_DIO_MAX_OUTPUTS) {
    return -1;
  }

  byte = index / 8;
  mask <<= index % 8;

  if (value) {
    simDioOutputs[byte] |= mask;
  }
  else {
    simDioOutputs[byte] &= ~mask;
  }

  printDioOutputs();

  return 0;
}

int simDioCheck(int index, int *value)
{
  int byte;
  unsigned char mask = 0x01;

  if (index < 0 ||
      index >= SIM_DIO_MAX_INPUTS) {
    return -1;
  }

  byte = index / 8;
  mask <<= index % 8;

  *value = (simDioOutputs[byte] & mask) == 0 ? 0 : 1;

  return 0;
}

int simDioByteRead(int index, unsigned char *byte)
{
  if (index < 0 ||
      index >= SIM_DIO_INPUT_BYTES) {
    return -1;
  }

  *byte = simDioInputs[index];

  return 0;
}

int simDioShortRead(int index, unsigned short *sh)
{
  index *= sizeof(unsigned short); /* convert to byte index */

  if (index < 0 ||
      index >= SIM_DIO_INPUT_BYTES) {
    return -1;
  }

  *sh = *((unsigned short *) &simDioInputs[index]);

  return 0;
}

int simDioWordRead(int index, unsigned int *word)
{
  index *= sizeof(unsigned int); /* convert to byte index */

  if (index < 0 ||
      index >= SIM_DIO_INPUT_BYTES) {
    return -1;
  }

  *word = *((unsigned int *) &simDioInputs[index]);

  return 0;
}

int simDioByteWrite(int index, unsigned char byte)
{
  if (index < 0 ||
      index >= SIM_DIO_INPUT_BYTES) {
    return -1;
  }

  simDioInputs[index] = byte;

  printDioOutputs();

  return 0;
}

int simDioShortWrite(int index, unsigned short sh)
{
  index *= sizeof(unsigned short); /* convert to byte index */

  if (index < 0 ||
      index >= SIM_DIO_INPUT_BYTES) {
    return -1;
  }

  *((unsigned short *) &simDioInputs[index]) = sh;

  printDioOutputs();

  return 0;
}

int simDioWordWrite(int index, unsigned int word)
{
  index *= sizeof(unsigned int); /* convert to byte index */

  if (index < 0 ||
      index >= SIM_DIO_INPUT_BYTES) {
    return -1;
  }

  *((unsigned int *) &simDioInputs[index]) = word;

  printDioOutputs();

  return 0;
}

int simDioByteCheck(int index, unsigned char *byte)
{
  if (index < 0 ||
      index >= SIM_DIO_OUTPUT_BYTES) {
    return -1;
  }

  *byte = simDioOutputs[index];

  return 0;
}

int simDioShortCheck(int index, unsigned short *sh)
{
  index *= sizeof(unsigned short); /* convert to byte index */

  if (index < 0 ||
      index >= SIM_DIO_OUTPUT_BYTES) {
    return -1;
  }

  *sh = * ((unsigned short *) &simDioOutputs[index]);

  return 0;
}

int simDioWordCheck(int index, unsigned int *word)
{
  index *= sizeof(unsigned int); /* convert to byte index */

  if (index < 0 ||
      index >= SIM_DIO_OUTPUT_BYTES) {
    return -1;
  }

  *word = * ((unsigned int *) &simDioOutputs[index]);

  return 0;
}

---