Motor Record Device Support

typedef union
{
    unsigned long All;
    struct {
      unsigned int na               :17;/* N/A bits  */
      unsigned int RA_HOMED       :1; /* Axis has been homed.*/
        unsigned int RA_MINUS_LS    :1; /* minus limit switch has been hit */
        unsigned int CNTRL_COMM_ERR :1; /* Controller communication error. */
        unsigned int GAIN_SUPPORT   :1; /* Motor supports closed-loop position control. */
        unsigned int RA_MOVING      :1; /* non-zero velocity present */
        unsigned int RA_PROBLEM     :1; /* driver stopped polling */
        unsigned int EA_PRESENT     :1; /* encoder is present */
        unsigned int EA_HOME        :1; /* encoder home signal on */
        unsigned int EA_SLIP_STALL  :1; /* slip/stall detected */
        unsigned int EA_POSITION    :1; /* position maintenence enabled */
        unsigned int EA_SLIP        :1; /* encoder slip enabled */
        unsigned int RA_HOME        :1; /* The home signal is on */
        unsigned int RA_PLUS_LS     :1; /* plus limit switch has been hit */
        unsigned int RA_DONE        :1; /* a motion is complete */
        unsigned int RA_DIRECTION   :1; /* (last) 0=Negative, 1=Positive */d
    } Bits;
} msta_field;

struct hardware {
  epicsInt32 pos; /* signed */
  double vel;

  epicsInt32 lim_h_val;
  epicsInt32 lim_l_val;
  int lim_h:1;
  int lim_l:1;

  int moving:1;
  epicsInt32 remaining;

  epicsTimeStamp last;
};

enum {max_targs=2};

typedef void (*trans_proc_t)();

/* List entry to hold transactions */
struct trans {
  ELLNODE node; /* Must be first */
  size_t nargs;
  double args[max_targs];

  trans_proc_t trans_proc;
};

struct devsim {
  ELLNODE node;

  struct hardware hw;

  int id;

  double rate; /* poll rate */

  int updateReady;
  CALLBACK updatecb;

  ELLLIST transaction; /* list of struct trans */
};

static
long init_record(motorRecord *pmr)
{
  struct motor_dset *dset=(struct motor_dset*)(pmr->dset);
  msta_field stat;
  double val;
  long ret=0;
  struct devsim *priv=getDev(pmr->out.value.vmeio.card);

  if(!priv){
    printf("Invalid id %d\n",pmr->out.value.vmeio.card);
    ret=S_dev_noDevice;
    goto error;
  }
  pmr->dpvt=priv;

  callbackSetUser(pmr, &priv->updatecb);

  stat.All=0;

  stat.Bits.RA_DONE=1;

  pmr->msta=stat.All;

  if( pmr->mres !=0.0 ){
    /* Restore position counter.  Needed for autosave */
    val = pmr->dval / pmr->mres;
    (*dset->start_trans)(pmr);
    (*dset->build_trans)(LOAD_POS, &val, pmr);
    (*dset->end_trans)(pmr);
  }

  return 0;
error:
  pmr->pact=TRUE;
  return ret;
}

static
void inithooks(initHookState state)
{
        ELLNODE *node;
        struct devsim *cur;
        /* as of 3.14.11 initHookAtEnd is deprecated and initHookAfterIocRunning is proper */
        if(state!=initHookAtEnd)
                return;

        for(node=ellFirst(&devices); node; node=ellNext(node))
        {
                cur=(struct devsim*)node;

                callbackRequestDelayed(&cur->updatecb, 1.0/cur->rate);
        }
}

static
void timercb(CALLBACK* cb)
{
        motorRecord *pmr=NULL;
        struct rset* rset=NULL;
        struct devsim *priv=NULL;

        callbackGetUser(pmr,cb);
        priv=pmr->dpvt;
        rset=(struct rset*)pmr->rset;

        dbScanLock((dbCommon*)pmr);

        callbackRequestDelayed(&priv->updatecb, 1.0/priv->rate);

        update_motor(&priv->hw);
        priv->updateReady=1;

        (*rset->process)(pmr);

        dbScanUnlock((dbCommon*)pmr);
}

static
CALLBACK_VALUE update_values(motorRecord *pmr)
{
        struct devsim *priv=pmr->dpvt;
        msta_field modsts;

        if(!priv->updateReady)
                return NOTHING_DONE;
        priv->updateReady=0;

        modsts.All=pmr->msta;

        modsts.Bits.RA_PLUS_LS = priv->hw.lim_h;
        modsts.Bits.RA_MINUS_LS = priv->hw.lim_l;
        modsts.Bits.RA_DONE = !priv->hw.moving;

        pmr->msta=modsts.All;

        pmr->rmp = (double)priv->hw.pos;

        return CALLBACK_DATA;
}

static
long start_trans(struct motorRecord *pmr)
{
        struct devsim *priv=pmr->dpvt;
        ELLNODE *node, *next;
        struct trans *cur;

        for(node=ellFirst(&priv->transaction), next = node ? ellNext(node) : NULL;
                node;
                node=next, next=next ? ellNext(next) : NULL )
        {
                cur=(struct trans*)node;

                ellDelete(&priv->transaction,node);
                free(cur);
        }

        return 0;
}

static
RTN_STATUS build_trans(motor_cmnd cmd, double *val, struct motorRecord *pmr)
{
        struct devsim *priv=pmr->dpvt;
        struct trans *t=callocMustSucceed(1,sizeof(struct trans), "build_trans");

        switch(cmd){
        case MOVE_ABS:
                t->nargs=1;
                t->args[0]=*val;
                t->trans_proc=&move_abs;
                break;
        case MOVE_REL:
                t->nargs=1;
                t->args[0]=*val;
                t->trans_proc=&move_rel;
                break;
        case LOAD_POS:
                t->nargs=1;
                t->args[0]=*val;
                t->trans_proc=&load_pos;
                break;
        case SET_VELOCITY:
                t->nargs=1;
                t->args[0]=*val;
                t->trans_proc=&set_velocity;
                break;
        case GO:
                t->nargs=0;
                t->trans_proc=&go;
                break;
        case STOP_AXIS:
                t->nargs=0;
                t->trans_proc=&stop;
                break;
        case SET_HIGH_LIMIT:
        case SET_LOW_LIMIT:
                /* TODO */
        case SET_VEL_BASE:
        case GET_INFO:
                free(t);
                return OK;
        default:
                printf("Unknown command %d\n",cmd);
                free(t);
                return OK;
        }

        ellAdd(&priv->transaction, &t->node);

        return OK;
}

static
RTN_STATUS end_trans(struct motorRecord *pmr)
{
        struct devsim *priv=pmr->dpvt;
        ELLNODE *node, *next;
        struct trans *cur;

        for(node=ellFirst(&priv->transaction), next = node ? ellNext(node) : NULL;
                node;
                node=next, next= next ? ellNext(next) : NULL )
        {
                cur=(struct trans*)node;

                switch(cur->nargs){
                case 0:
                        (*cur->trans_proc)(pmr);
                        break;
                case 1:
                        (*cur->trans_proc)(pmr,
                                cur->args[0]);
                        break;
                case 2:
                        (*cur->trans_proc)(pmr,
                                cur->args[0],
                                cur->args[1]);
                default:
                        printf("Internal Logic error: too many arguments\n");
                        return ERROR;
                }

                ellDelete(&priv->transaction, node);
                free(cur);
        }

        return OK;
}