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

#include "seq_snc.h"
# line 6 "../sncFaultBuff.stt"
#include <stdio.h>
# line 7 "../sncFaultBuff.stt"
#include <string.h>
# line 8 "../sncFaultBuff.stt"
#include <epicsTime.h>
# line 10 "../sncFaultBuff.stt"
static char * getBaseName(int i);
# line 11 "../sncFaultBuff.stt"
static int  maxBaseName(void);
# line 12 "../sncFaultBuff.stt"
static void getTimestampString(char *ts_string, int num);
# line 25 "../sncFaultBuff.stt"
static const EF_ID ev_fault = 1;
# line 26 "../sncFaultBuff.stt"
static const EF_ID ev_clear = 2;
# line 33 "../sncFaultBuff.stt"


    static char * base_name[] = { "PIDL", "PIDU", "TSL", "TSU", "RATES", "BEAMREQ", "BEAMNRG01", "BEAMNRG23", "PHWAVELEN", "MPSSTAT",
                                  "MPSCLASS01", "MPSCLASS23", "BSAINITL", "BSAINITU", "BSAACTL", "BSAACTU", "BSAAVGL", "BSAAVGU", "BSADONEL", "BSADONEU",
                                  "CTRLSEQ01", "CTRLSEQ23", "CTRLSEQ45", "CTRLSEQ67", "CTRLSEQ89", "CTRLSEQAB", "CTRLSEQCD", "CTRLSEQEF", "ACVADCA", "ACVADCB",
                                  "ACVADCC"};
                           
    static char * getBaseName(int i)
    {
        if(i<0 && i>= sizeof(base_name)/sizeof(char*)) return (char*) NULL;
        else return (base_name + i);
    }
    
    static int maxBaseName(void)
    {
        return sizeof(base_name)/sizeof(char*);
    }
    
    static char *getPVName(char *dest, char *prefix, char *n, int i)
    {
        sprintf(dest, "%s:%sHSTFLTB%s", prefix, getBaseName(i), n); 
        return dest;
    }

    static void getTimestampString(char *ts_string, int num)
    {
        epicsTimeStamp t;
        epicsTimeGetCurrent(&t);
        epicsTimeToStrftime(ts_string, num, "%Y%m%d_%H%M%S", &t);
    }



/* Variable declarations */
struct seqg_vars {
# line 16 "../sncFaultBuff.stt"
	short fault;
# line 17 "../sncFaultBuff.stt"
	short control;
# line 20 "../sncFaultBuff.stt"
	short bcs;
# line 21 "../sncFaultBuff.stt"
	short mps;
# line 22 "../sncFaultBuff.stt"
	short tag;
# line 23 "../sncFaultBuff.stt"
	short mpstag;
# line 29 "../sncFaultBuff.stt"
	char *nStr;
# line 30 "../sncFaultBuff.stt"
	char *prefixStr;
};


/* 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 "fault_mon" ******/

/* Event function for state "init" in state set "fault_mon" */
static seqBool seqg_event_fault_mon_0_init(SS_ID seqg_env, int *seqg_ptrn, int *seqg_pnst)
{
# line 71 "../sncFaultBuff.stt"
	if (1)
	{
		*seqg_pnst = 1;
		*seqg_ptrn = 0;
		return TRUE;
	}
	return FALSE;
}

/* Action function for state "init" in state set "fault_mon" */
static void seqg_action_fault_mon_0_init(SS_ID seqg_env, int seqg_trn, int *seqg_pnst)
{
	switch(seqg_trn)
	{
	case 0:
		{
# line 72 "../sncFaultBuff.stt"
			seqg_var->prefixStr = seq_macValueGet(seqg_env, "prefix");
# line 73 "../sncFaultBuff.stt"
			seqg_var->nStr = seq_macValueGet(seqg_env, "n");
			
                int i;
                char pv_name[256];
                
                printf("number of pv %d (%p)\n", maxBaseName(), base_name);
                /*
                for(i = 0; i < maxBaseName(); i++) {
                    strcpy (pv_name, getBaseName(i));
                    getPVName(pv_name, pVar->prefixStr, pVar->nStr, i);
                    printf("%s\n", pv_name);
                }
                */
            
		}
		return;
	}
}

/****** Code for state "normal" in state set "fault_mon" ******/

/* Entry function for state "normal" in state set "fault_mon" */
static void seqg_entry_fault_mon_0_normal(SS_ID seqg_env)
{
# line 92 "../sncFaultBuff.stt"
	seqg_var->nStr = seq_macValueGet(seqg_env, "n");
	printf("normal (%s)\n", pVar->nStr);
}

/* Event function for state "normal" in state set "fault_mon" */
static seqBool seqg_event_fault_mon_0_normal(SS_ID seqg_env, int *seqg_ptrn, int *seqg_pnst)
{
# line 95 "../sncFaultBuff.stt"
	if (seqg_var->fault == 1)
	{
		*seqg_pnst = 2;
		*seqg_ptrn = 0;
		return TRUE;
	}
	return FALSE;
}

/* Action function for state "normal" in state set "fault_mon" */
static void seqg_action_fault_mon_0_normal(SS_ID seqg_env, int seqg_trn, int *seqg_pnst)
{
	switch(seqg_trn)
	{
	case 0:
		{
# line 96 "../sncFaultBuff.stt"
			seq_efSet(seqg_env, ev_fault);
		}
		return;
	}
}

/****** Code for state "fault" in state set "fault_mon" ******/

/* Entry function for state "fault" in state set "fault_mon" */
static void seqg_entry_fault_mon_0_fault(SS_ID seqg_env)
{
# line 104 "../sncFaultBuff.stt"
	seqg_var->nStr = seq_macValueGet(seqg_env, "n");
	printf("fault (%s)\n", pVar->nStr);
}

/* Event function for state "fault" in state set "fault_mon" */
static seqBool seqg_event_fault_mon_0_fault(SS_ID seqg_env, int *seqg_ptrn, int *seqg_pnst)
{
# line 107 "../sncFaultBuff.stt"
	if (seqg_var->fault == 0)
	{
		*seqg_pnst = 1;
		*seqg_ptrn = 0;
		return TRUE;
	}
	return FALSE;
}

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

/****** Code for state "st_save" in state set "fault_save" ******/

/* Event function for state "st_save" in state set "fault_save" */
static seqBool seqg_event_fault_save_1_st_save(SS_ID seqg_env, int *seqg_ptrn, int *seqg_pnst)
{
# line 117 "../sncFaultBuff.stt"
	if (seq_efTestAndClear(seqg_env, ev_fault))
	{
		*seqg_pnst = 0;
		*seqg_ptrn = 0;
		return TRUE;
	}
	return FALSE;
}

/* Action function for state "st_save" in state set "fault_save" */
static void seqg_action_fault_save_1_st_save(SS_ID seqg_env, int seqg_trn, int *seqg_pnst)
{
	switch(seqg_trn)
	{
	case 0:
		{
# line 119 "../sncFaultBuff.stt"
			seq_efSet(seqg_env, ev_clear);
		}
		return;
	}
}

/****** Code for state "st_clear" in state set "fault_clear" ******/

/* Event function for state "st_clear" in state set "fault_clear" */
static seqBool seqg_event_fault_clear_2_st_clear(SS_ID seqg_env, int *seqg_ptrn, int *seqg_pnst)
{
# line 129 "../sncFaultBuff.stt"
	if (seq_efTestAndClear(seqg_env, ev_clear))
	{
		*seqg_pnst = 0;
		*seqg_ptrn = 0;
		return TRUE;
	}
	return FALSE;
}

/* Action function for state "st_clear" in state set "fault_clear" */
static void seqg_action_fault_clear_2_st_clear(SS_ID seqg_env, int seqg_trn, int *seqg_pnst)
{
	switch(seqg_trn)
	{
	case 0:
		{
# line 130 "../sncFaultBuff.stt"
			seqg_var->control = 1;
# line 130 "../sncFaultBuff.stt"
			seq_pvPutTmo(seqg_env, 1/*control*/, DEFAULT, DEFAULT_TIMEOUT);
# line 131 "../sncFaultBuff.stt"
			epicsThreadSleep(.5);
# line 132 "../sncFaultBuff.stt"
			seqg_var->control = 0;
# line 132 "../sncFaultBuff.stt"
			seq_pvPutTmo(seqg_env, 1/*control*/, DEFAULT, DEFAULT_TIMEOUT);
		}
		return;
	}
}

#undef seqg_var

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

/* Channel table */
static seqChan seqg_chans[] = {
	/* chName, offset, varName, varType, count, eventNum, efId, monitored, queueSize, queueIndex */
	{"{prefix}:FLTBUFMLATCH{n}", offsetof(struct seqg_vars, fault), "fault", P_SHORT, 1, 3, 0, 1, 0, 0},
	{"{prefix}:FLTBUFCLR{n}", offsetof(struct seqg_vars, control), "control", P_SHORT, 1, 4, 0, 0, 0, 0},
	{"{prefix}:FLTBUFBCSLATCH{n}", offsetof(struct seqg_vars, bcs), "bcs", P_SHORT, 1, 5, 0, 1, 0, 0},
	{"{prefix}:FLTBUFMPSLATCH{n}", offsetof(struct seqg_vars, mps), "mps", P_SHORT, 1, 6, 0, 1, 0, 0},
	{"{prefix}:FLTBUFTAG{n}", offsetof(struct seqg_vars, tag), "tag", P_SHORT, 1, 7, 0, 1, 0, 0},
	{"{prefix}:FLTBUFMPSTAG{n}", offsetof(struct seqg_vars, mpstag), "mpstag", P_SHORT, 1, 8, 0, 1, 0, 0},
};

/* Event masks for state set "fault_mon" */
static const seqMask seqg_mask_fault_mon_0_init[] = {
	0x00000000,
};
static const seqMask seqg_mask_fault_mon_0_normal[] = {
	0x00000008,
};
static const seqMask seqg_mask_fault_mon_0_fault[] = {
	0x00000008,
};

/* State table for state set "fault_mon" */
static seqState seqg_states_fault_mon[] = {
	{
	/* state name */        "init",
	/* action function */   seqg_action_fault_mon_0_init,
	/* event function */    seqg_event_fault_mon_0_init,
	/* entry function */    0,
	/* exit function */     0,
	/* event mask array */  seqg_mask_fault_mon_0_init,
	/* state options */     (0)
	},
	{
	/* state name */        "normal",
	/* action function */   seqg_action_fault_mon_0_normal,
	/* event function */    seqg_event_fault_mon_0_normal,
	/* entry function */    seqg_entry_fault_mon_0_normal,
	/* exit function */     0,
	/* event mask array */  seqg_mask_fault_mon_0_normal,
	/* state options */     (0)
	},
	{
	/* state name */        "fault",
	/* action function */   seqg_action_fault_mon_0_fault,
	/* event function */    seqg_event_fault_mon_0_fault,
	/* entry function */    seqg_entry_fault_mon_0_fault,
	/* exit function */     0,
	/* event mask array */  seqg_mask_fault_mon_0_fault,
	/* state options */     (0)
	},
};

/* Event masks for state set "fault_save" */
static const seqMask seqg_mask_fault_save_1_st_save[] = {
	0x00000002,
};

/* State table for state set "fault_save" */
static seqState seqg_states_fault_save[] = {
	{
	/* state name */        "st_save",
	/* action function */   seqg_action_fault_save_1_st_save,
	/* event function */    seqg_event_fault_save_1_st_save,
	/* entry function */    0,
	/* exit function */     0,
	/* event mask array */  seqg_mask_fault_save_1_st_save,
	/* state options */     (0)
	},
};

/* Event masks for state set "fault_clear" */
static const seqMask seqg_mask_fault_clear_2_st_clear[] = {
	0x00000004,
};

/* State table for state set "fault_clear" */
static seqState seqg_states_fault_clear[] = {
	{
	/* state name */        "st_clear",
	/* action function */   seqg_action_fault_clear_2_st_clear,
	/* event function */    seqg_event_fault_clear_2_st_clear,
	/* entry function */    0,
	/* exit function */     0,
	/* event mask array */  seqg_mask_fault_clear_2_st_clear,
	/* state options */     (0)
	},
};

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

	{
	/* state set name */    "fault_save",
	/* states */            seqg_states_fault_save,
	/* number of states */  1
	},

	{
	/* state set name */    "fault_clear",
	/* states */            seqg_states_fault_clear,
	/* number of states */  1
	},
};

/* Program table (global) */
seqProgram sncFaultBuff = {
	/* magic number */      2002004,
	/* program name */      "sncFaultBuff",
	/* channels */          seqg_chans,
	/* num. channels */     6,
	/* state sets */        seqg_statesets,
	/* num. state sets */   3,
	/* user var size */     sizeof(struct seqg_vars),
	/* param */             "",
	/* num. event flags */  2,
	/* 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 sncFaultBuffRegistrar (void) {
    seqRegisterSequencerCommands();
    seqRegisterSequencerProgram (&sncFaultBuff);
}
epicsExportRegistrar(sncFaultBuffRegistrar);