/* C code for program sncPauFcomPush, generated by snc from ../sncPauFcomPush.stt */
#include <string.h>
#include <stddef.h>
#include <stdio.h>
#include <limits.h>

#include "seq_snc.h"
# line 4 "../sncPauFcomPush.stt"

#define FBCK_OFF  0
#define FBCK_ON   1

# line 11 "../sncPauFcomPush.stt"

#include <cantProceed.h>
#include <epicsTime.h>
#include <epicsPrint.h>
#include <drvPau.h>

typedef struct {
    char       fcomPVName[40];
    FcomID     fcomId;
    FcomBlob   *pBlob;
    int        status;
    double     pushVal;
    unsigned   succCnt;
    unsigned   failCnt;
} usrData_ts;


static usrData_ts * usrAllocate(char *mux_name)
{
      usrData_ts *pUsr  = (usrData_ts*) mallocMustSucceed(sizeof(usrData_ts), mux_name);
      FcomBlob   *pBlob = (FcomBlob *)  mallocMustSucceed(sizeof(FcomBlob), mux_name);

      if(pUsr && pBlob) {
          pUsr->pBlob = pBlob;
          return pUsr;
      }
      else return (usrData_ts *)NULL;
}

static unsigned long initFcom(char *mux_name, int slot)
{
    if(!mux_name) return 0;

    usrData_ts *p = usrAllocate(mux_name);

    if(!p) return 0;

    p->status  = 0;
    p->pushVal = 0.;
    p->succCnt = 0;
    p->failCnt = 0;

    makeFcomPVNamewithSlotNumber(mux_name, p->fcomPVName, slot);
    p->fcomId = fcomLCLSPV2FcomID(p->fcomPVName);


    if(!p->fcomId) return 0;
    else           return (unsigned long) p;
}


static void reportFcom(char *mux_name, unsigned long usrData)
{
    if(!usrData) return;

    usrData_ts *p = (usrData_ts*) usrData;

    epicsPrintf("\tsncPauFcomPush: mux (%s), fcomPV (%s), fcomID (0x%8x), pUsr (%8p), pBlob (%8p)\n",
                 mux_name, p->fcomPVName, (unsigned int) p->fcomId, p, p->pBlob);
    
}


static int pushFcom(unsigned long usrData, double value)
{
    if(!usrData) return -1;
    
    usrData_ts *pUsr  = (usrData_ts *) usrData;
    FcomBlob   *pBlob = pUsr->pBlob;

    epicsTimeStamp    timestamp;
    
    pUsr->pushVal = value;

    epicsTimeGetCurrent(&timestamp); 

    pBlob->fc_vers = FCOM_PROTO_VERSION;
    pBlob->fc_tsHi = timestamp.secPastEpoch;
    pBlob->fc_tsLo = timestamp.nsec;
    pBlob->fc_stat = 0;
    pBlob->fc_type = FCOM_EL_DOUBLE;
    pBlob->fc_nelm = 1;
    pBlob->fc_idnt = pUsr->fcomId;
    pBlob->fc_dbl  = &pUsr->pushVal;

    pUsr->status = fcomPutBlob(pBlob);


    if(!pUsr->status) pUsr->succCnt++;
    else              pUsr->failCnt++;

    return pUsr->status;
}



# line 124 "../sncPauFcomPush.stt"
static const EF_ID ev_data0 = 1;
# line 126 "../sncPauFcomPush.stt"
static const EF_ID ev_data1 = 2;
# line 128 "../sncPauFcomPush.stt"
static const EF_ID ev_data2 = 3;
# line 130 "../sncPauFcomPush.stt"
static const EF_ID ev_data3 = 4;

/* Variable declarations */
struct seqg_vars {
# line 108 "../sncPauFcomPush.stt"
	int i;
# line 109 "../sncPauFcomPush.stt"
	unsigned long userData[4];
# line 110 "../sncPauFcomPush.stt"
	char *muxName;
# line 111 "../sncPauFcomPush.stt"
	char *fcomName;
# line 113 "../sncPauFcomPush.stt"
	int feedback_mode;
# line 117 "../sncPauFcomPush.stt"
	double static_data[4];
};


/* Function declarations */

#define seqg_var (*(struct seqg_vars *const *)seqg_env)

/* Program init func */
static void seqg_init(PROG_ID seqg_env)
{
}

/****** Code for state "init" in state set "fcomPush" ******/

/* Entry function for state "init" in state set "fcomPush" */
static void seqg_entry_fcomPush_0_init(SS_ID seqg_env)
{
# line 140 "../sncPauFcomPush.stt"
	seqg_var->muxName = seq_macValueGet(seqg_env, "MUX_NAME");
# line 141 "../sncPauFcomPush.stt"
	seqg_var->fcomName = seq_macValueGet(seqg_env, "FCOM_NAME");
# line 142 "../sncPauFcomPush.stt"
	if (seqg_var->fcomName)
# line 142 "../sncPauFcomPush.stt"
		seqg_var->muxName = seqg_var->fcomName;
# line 144 "../sncPauFcomPush.stt"
	for (seqg_var->i = 0; seqg_var->i < 4; seqg_var->i++)
	{
# line 145 "../sncPauFcomPush.stt"
		seqg_var->userData[seqg_var->i] = initFcom(seqg_var->muxName, seqg_var->i);
	}
}

/* Exit function for state "init" in state set "fcomPush" */
static void seqg_exit_fcomPush_0_init(SS_ID seqg_env)
{
# line 153 "../sncPauFcomPush.stt"
	for (seqg_var->i = 0; seqg_var->i < 4; seqg_var->i++)
	{
# line 154 "../sncPauFcomPush.stt"
		reportFcom(seqg_var->muxName, seqg_var->userData[seqg_var->i]);
	}
}

/* Event function for state "init" in state set "fcomPush" */
static seqBool seqg_event_fcomPush_0_init(SS_ID seqg_env, int *seqg_ptrn, int *seqg_pnst)
{
# line 149 "../sncPauFcomPush.stt"
	if (seq_delay(seqg_env, 1.))
	{
		*seqg_pnst = 1;
		*seqg_ptrn = 0;
		return TRUE;
	}
	return FALSE;
}

/* Action function for state "init" in state set "fcomPush" */
static void seqg_action_fcomPush_0_init(SS_ID seqg_env, int seqg_trn, int *seqg_pnst)
{
	switch(seqg_trn)
	{
	case 0:
		{
		}
		return;
	}
}

/****** Code for state "deactivate" in state set "fcomPush" ******/

/* Event function for state "deactivate" in state set "fcomPush" */
static seqBool seqg_event_fcomPush_0_deactivate(SS_ID seqg_env, int *seqg_ptrn, int *seqg_pnst)
{
# line 160 "../sncPauFcomPush.stt"
	if (!seqg_var->feedback_mode)
	{
		*seqg_pnst = 2;
		*seqg_ptrn = 0;
		return TRUE;
	}
	return FALSE;
}

/* Action function for state "deactivate" in state set "fcomPush" */
static void seqg_action_fcomPush_0_deactivate(SS_ID seqg_env, int seqg_trn, int *seqg_pnst)
{
	switch(seqg_trn)
	{
	case 0:
		{
		}
		return;
	}
}

/****** Code for state "activate" in state set "fcomPush" ******/

/* Event function for state "activate" in state set "fcomPush" */
static seqBool seqg_event_fcomPush_0_activate(SS_ID seqg_env, int *seqg_ptrn, int *seqg_pnst)
{
# line 166 "../sncPauFcomPush.stt"
	if (seqg_var->feedback_mode)
	{
		*seqg_pnst = 1;
		*seqg_ptrn = 0;
		return TRUE;
	}
# line 170 "../sncPauFcomPush.stt"
	if (seq_efTestAndClear(seqg_env, ev_data0))
	{
		*seqg_pnst = 2;
		*seqg_ptrn = 1;
		return TRUE;
	}
# line 174 "../sncPauFcomPush.stt"
	if (seq_efTestAndClear(seqg_env, ev_data1))
	{
		*seqg_pnst = 2;
		*seqg_ptrn = 2;
		return TRUE;
	}
# line 178 "../sncPauFcomPush.stt"
	if (seq_efTestAndClear(seqg_env, ev_data2))
	{
		*seqg_pnst = 2;
		*seqg_ptrn = 3;
		return TRUE;
	}
# line 182 "../sncPauFcomPush.stt"
	if (seq_efTestAndClear(seqg_env, ev_data3))
	{
		*seqg_pnst = 2;
		*seqg_ptrn = 4;
		return TRUE;
	}
	return FALSE;
}

/* Action function for state "activate" in state set "fcomPush" */
static void seqg_action_fcomPush_0_activate(SS_ID seqg_env, int seqg_trn, int *seqg_pnst)
{
	switch(seqg_trn)
	{
	case 0:
		{
		}
		return;
	case 1:
		{
# line 171 "../sncPauFcomPush.stt"
			pushFcom(seqg_var->userData[0], seqg_var->static_data[0]);
		}
		return;
	case 2:
		{
# line 175 "../sncPauFcomPush.stt"
			pushFcom(seqg_var->userData[1], seqg_var->static_data[1]);
		}
		return;
	case 3:
		{
# line 179 "../sncPauFcomPush.stt"
			pushFcom(seqg_var->userData[2], seqg_var->static_data[2]);
		}
		return;
	case 4:
		{
# line 183 "../sncPauFcomPush.stt"
			pushFcom(seqg_var->userData[3], seqg_var->static_data[3]);
		}
		return;
	}
}

#undef seqg_var

/************************ Tables ************************/

/* Channel table */
static seqChan seqg_chans[] = {
	/* chName, offset, varName, varType, count, eventNum, efId, monitored, queueSize, queueIndex */
	{"{MUX_NAME}:FBCK", offsetof(struct seqg_vars, feedback_mode), "feedback_mode", P_INT, 1, 5, 0, 1, 0, 0},
	{"{MUX_NAME}:SETDATA_0", offsetof(struct seqg_vars, static_data[0]), "static_data[0]", P_DOUBLE, 1, 6, 1, 1, 0, 0},
	{"{MUX_NAME}:SETDATA_1", offsetof(struct seqg_vars, static_data[1]), "static_data[1]", P_DOUBLE, 1, 7, 2, 1, 0, 0},
	{"{MUX_NAME}:SETDATA_2", offsetof(struct seqg_vars, static_data[2]), "static_data[2]", P_DOUBLE, 1, 8, 3, 1, 0, 0},
	{"{MUX_NAME}:SETDATA_3", offsetof(struct seqg_vars, static_data[3]), "static_data[3]", P_DOUBLE, 1, 9, 4, 1, 0, 0},
};

/* Event masks for state set "fcomPush" */
static const seqMask seqg_mask_fcomPush_0_init[] = {
	0x00000000,
};
static const seqMask seqg_mask_fcomPush_0_deactivate[] = {
	0x00000020,
};
static const seqMask seqg_mask_fcomPush_0_activate[] = {
	0x0000003e,
};

/* State table for state set "fcomPush" */
static seqState seqg_states_fcomPush[] = {
	{
	/* state name */        "init",
	/* action function */   seqg_action_fcomPush_0_init,
	/* event function */    seqg_event_fcomPush_0_init,
	/* entry function */    seqg_entry_fcomPush_0_init,
	/* exit function */     seqg_exit_fcomPush_0_init,
	/* event mask array */  seqg_mask_fcomPush_0_init,
	/* state options */     (0)
	},
	{
	/* state name */        "deactivate",
	/* action function */   seqg_action_fcomPush_0_deactivate,
	/* event function */    seqg_event_fcomPush_0_deactivate,
	/* entry function */    0,
	/* exit function */     0,
	/* event mask array */  seqg_mask_fcomPush_0_deactivate,
	/* state options */     (0)
	},
	{
	/* state name */        "activate",
	/* action function */   seqg_action_fcomPush_0_activate,
	/* event function */    seqg_event_fcomPush_0_activate,
	/* entry function */    0,
	/* exit function */     0,
	/* event mask array */  seqg_mask_fcomPush_0_activate,
	/* state options */     (0)
	},
};

/* State set table */
static seqSS seqg_statesets[] = {
	{
	/* state set name */    "fcomPush",
	/* states */            seqg_states_fcomPush,
	/* number of states */  3
	},
};

/* Program table (global) */
seqProgram sncPauFcomPush = {
	/* magic number */      2002004,
	/* program name */      "sncPauFcomPush",
	/* channels */          seqg_chans,
	/* num. channels */     5,
	/* state sets */        seqg_statesets,
	/* num. state sets */   1,
	/* user var size */     sizeof(struct seqg_vars),
	/* param */             "",
	/* num. event flags */  4,
	/* encoded options */   (0 | OPT_CONN | OPT_NEWEF | OPT_REENT),
	/* init func */         seqg_init,
	/* entry func */        0,
	/* exit func */         0,
	/* num. queues */       0
};

/* Register sequencer commands and program */
#include "epicsExport.h"
static void sncPauFcomPushRegistrar (void) {
    seqRegisterSequencerCommands();
    seqRegisterSequencerProgram (&sncPauFcomPush);
}
epicsExportRegistrar(sncPauFcomPushRegistrar);