friguti_h

/*
**	Copyright 1992, Universities Research Association.  All rights reserved.
*/
/******************************************************************************/
/* friguti.h
**  
**	prototypes and defined constants for argument values for
**	FRIG_xxx routines
**
*/
/******************************************************************************/

#ifndef FRIGUTI_DEFINED				/* do this only once */
#define	FRIGUTI_DEFINED

#include "cnsparam.h"
#include "cns_data_structs.h"
#include "diolib.h"
#include "dbprops.h"

#define	FRIG_HOUSE_NAME_LEN	2		/* length of a house name */

/******************************************************************************/
/* 
**	defined constants for argument values
*/
/******************************************************************************/

#define	FRIG_MICRO		0		/* data source is frig micro */
#define	FRIG_DEFAULT_FILE	2		/* data source is default file */

#define	FRIG_NEXT_HOUSE		0		/* access next house */
#define	FRIG_PREVIOUS_HOUSE	1		/* access previous house */

#define	FRIG_NEXT		0		/* access next value */
#define	FRIG_PREVIOUS		1		/* access previous value */
#define	FRIG_CURRENT		2		/* access current value */

#define	FRIG_RAW_TO_PNAME	0		/* convert raw data to pseudo name */
#define	FRIG_PNAME_TO_RAW	1		/* convert pseudo name to raw data */

#define	FRIG_FLOAT		0		/* specifies float value */
#define	FRIG_LONG		1		/* specifies int integer value */
#define	FRIG_SHORT		2		/* specifies short integer value */

#define	FRIG_INVTYP		-1		/* invalid object type */
enum OBJECT_TYPE {
FRIG_OPER             = 0,   /* operations type */
FRIG_ACTION           = 1,   /* action type */
FRIG_TIMER            = 2,   /* timer type */
FRIG_STORE            = 3,   /* storage type */
FRIG_STATE            = 4,   /* state type */
FRIG_FSM              = 5,   /* finite state machine type */
FRIG_LOOP             = 6,   /* loop type */
FRIG_EVENT            = 7,   /* event type */
FRIG_FILTER           = 8,   /* filter type */
};
#define	FRIG_ACNET_DEVICE	-2		/* ACNET device type */

#define	FRIG_NUM_DATA_TYPES	9		/* number of frig data types */

#define	FRIG_ALL_HOUSES		0		/* access all houses */
#define	FRIG_FRIG_HOUSES	1		/* access normal refrigerator houses only */
#define	FRIG_COMP_HOUSES	2		/* access compressor houses only */

#define	FRIG_AGGREGATE_HOUSE	1		/* access aggregate houses */
#define	FRIG_COMPONENT_HOUSE	2		/* access component houses */
#define	FRIG_STANDALONE_HOUSE	4		/* access standalone houses */

#define	FRIG_UNKNOWN_HOUSE	-1		/* unknown house type */
#define	FRIG_HOUSE		0		/* refrigerator house type */
#define	FRIG_COMP_HOUSE		1		/* compressor house type */

#define	FRIG_MAX_USER_FILES	40		/* maximum number of user files */
#define	FRIG_USER_NAME_LEN	16		/* length of a user file name */
#define	FRIG_USER_COMMENT_LEN	32		/* length of user file comment field */
#define	FRIG_DATE_LEN		4		/* length of a frig date field (in bytes) */

#define	FRIG_DEFAULT_NAME_LEN	9		/* length of a default file name */

#define	FRIG_IS_DEFINED		1		/* structure is defined */
#define	FRIG_IS_ENABLED		2		/* structure is enabled */
#define	FRIG_IS_ACTIVE		4		/* structure is active */
#define	FRIG_IS_SET		8		/* structure is set */
#define	FRIG_HAS_OCCURRED	0x10		/* structure event has occurred */

#define	FRIG_WILD_ALL		0		/* wildcard for all Tevatron houses */
#define	FRIG_WILD_FRIG		1		/* wildcard for Tevatron refrigerator houses */
#define	FRIG_WILD_COMP		2		/* wildcard for Tevatron compressor houses */
#define	FRIG_GLOBAL_ALL		3		/* wildcard for all houses */
#define	FRIG_GLOBAL_FRIG	4		/* wildcard for refrigerator houses */
#define	FRIG_GLOBAL_COMP	5		/* wildcard for compressor houses */

#define	FRIG_NUM_TEV_FRIG_HOUSES	26	/* number of normal Tevatron frig houses */
#define	FRIG_NUM_TEV_COMP_HOUSES	9	/* number of Tevatron compressor houses */
#define	FRIG_NUM_TEV_HOUSES	(FRIG_NUM_TEV_FRIG_HOUSES + FRIG_NUM_TEV_COMP_HOUSES)	/* total number of Tevatron houses */

#define	FRIG_NUM_FRIG_HOUSES	31		/* number of normal frig houses */
#define	FRIG_NUM_COMP_HOUSES	9		/* number of compressor houses */
#define	FRIG_NUM_HOUSES		(FRIG_NUM_FRIG_HOUSES + FRIG_NUM_COMP_HOUSES)	/* total number of houses */

/******************************************************************************/
/* 
**	data structures
*/
/******************************************************************************/

#define	FRIG_NUM_ACTIONS	256		/* number of available actions per refrigerator */
#define	FRIG_NUM_FSMS		32		/* number of available FSMs per refrigerator */
#define	FRIG_NUM_LOOPS		32		/* number of available loops per refrigerator */
#define	FRIG_NUM_OPERATIONS	512		/* number of available operations per refrigerator */
#define	FRIG_NUM_STATES		256		/* number of available states per refrigerator */
#define	FRIG_NUM_STORES		64		/* number of available storages per refrigerator */
#define	FRIG_NUM_TIMERS		64		/* number of available timers per refrigerator */
#define	FRIG_NUM_EVENTS		64		/* number of available events per refrigerator */
#define	FRIG_NUM_FILTERS	50		/* number of available filters per refrigerator */

#define	FRIG_DESCRIPTION_LEN	32		/* length of descriptive text */

struct DEV_DATA
    {
    int	di;				/* device index */
    short	pi;				/* property index */
    union
	{
	char	ssdn[LEN_SSDN];			/* device SSDN */
	float	fcon;			/* float constant */
	int	icon;				/* integer constant */
	} data;
    short	type;				/* data type */
    short	len;				/* length of data */
    short	offset;				/* offset of data */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */;

typedef struct
    {
    union
	{
	float	f_result;			/* float result */
	int	i_result;			/* integer result */
	} result;
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */ OPER_READ;

#define	FRIG_INPUTS_PER_OPERATION	2	/* number of inputs per operation */

struct OPER_SET
    {
    short	defined;			/* defined flag */
    short	status;				/* status of the last read */
    union
	{
	float	f_value;			/* float result */
	int	i_value;			/* integer result */
	} result;				/* result of the last read */
    short	oper_type;			/* operation type */
    short	num_operand;			/* number of operands */
    short	reply_type;			/* type of reply */
    DEV_DATA	input_devices[FRIG_INPUTS_PER_OPERATION];	/* description of input devices */
    char	description[FRIG_DESCRIPTION_LEN];	/* descriptive ASCII text */
    short	user_tag;			/* user assigned tag value */
    int		unused[2];			/* spare storage */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */;

typedef struct
    {
    short	defined;			/* defined flag */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */ OPER_STATUS;

typedef struct
    {
    short	command;			/* clear last result command */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */ OPER_CONTROL;

#define	FRIG_OUTPUTS_PER_ACTION	2		/* number of inputs per operation */

struct ACTION_SET
    {
    short	defined;			/* defined flag */
    short	num_output;			/* number of outputs */
    short	input_type;			/* type of input */
    int	sdi;				/* device index of the primary device */
    DEV_DATA	output_devices[FRIG_OUTPUTS_PER_ACTION];	/* description of output devices */
    short	status;				/* status of last action */
    char	description[FRIG_DESCRIPTION_LEN];	/* descriptive ASCII text */
    short	user_tag;			/* user assigned tag value */
    int		unused[2];			/* spare storage */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */;

typedef struct
    {
    union
	{
	float	f_value;			/* float value */
	int	i_value;			/* integer value */
	} result;
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */ ACTION_VALUE;

typedef struct
    {
    short	defined;			/* defined flag */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */ ACTION_STATUS;

typedef struct
    {
    short	defined;			/* defined flag */
    int	sdi;				/* primary device index */
    short	user_tag;			/* user assigned tag value */
    char	description[FRIG_DESCRIPTION_LEN];	/* descriptive ASCII text */
    short	active;				/* active flag */
    short	unused_word;			/* spare storage */
    int		unused;				/* spare storage */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */ TIMER_SET;

typedef struct
    {
    int		counter;			/* timer counter value */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */ TIMER_VALUE;

typedef struct
    {
    short	defined;			/* defined flag */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */ TIMER_STATUS;

struct STORAGE_SET
    {
    short	defined;			/* defined flag */
    union					/* setting value */
	{
	float	f_value;			/* float value */
	int	i_value;			/* integer value */
	} setting;
    short	type;				/* data type */
    short	user_tag;			/* user assigned tag value */
    char	description[FRIG_DESCRIPTION_LEN];	/* descriptive ASCII text */
    int		unused[2];			/* spare storage */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */;

typedef struct
    {
    union
	{
	float	f_value;			/* float value */
	int	i_value;			/* integer value */
	} setting;
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */ STORAGE_READ;

typedef struct
    {
    short	defined;			/* defined flag */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */ STORAGE_STATUS;

typedef struct
    {
    int	di;				/* device index */
    char	ssdn[LEN_SSDN];			/* device SSDN */
    short	offset;				/* offset of data */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */ OPER_DEF;

struct TRANS_RULE
    {
    DEV_DATA	operation;			/* operation to be fulfilled */
    OPER_DEF	state;				/* state to which transition is to be done */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */;

struct ACT_RULE
    {
    DEV_DATA	setting;			/* setting value */
    DEV_DATA	action;				/* action object */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */;

#define	FRIG_TRANS_RULES_PER_STATE	8	/* number of transition rules per state */
#define	FRIG_ACTION_RULES_PER_STATE	8	/* number of action rules per state */

struct STATE_SET
    {
    short	defined;			/* defined flag */
    short	active;				/* active flag */
    short	num_trans_rules;		/* number of defined transition rules */
    short	num_act_rules;			/* number of defined action rules */
    char	description[FRIG_DESCRIPTION_LEN];	/* descriptive ASCII text */
    short	user_tag;			/* user assigned tag value */
    int		num_fsms;			/* number of FSMs presently using this state */
    int		time_active;			/* number of seconds this state has been active */
    TRANS_RULE	transitions[FRIG_TRANS_RULES_PER_STATE];	/* transitions */
    ACT_RULE	actions[FRIG_ACTION_RULES_PER_STATE];	/* actions */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */;

typedef struct
    {
    short	defined;			/* defined flag */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */ STATE_STATUS;

#define	FRIG_STATES_PER_FSM	16		/* number of states per FSM */

typedef struct
    {
    short	defined;			/* defined flag */
    short	num_states;			/* number of states used */
    short	active;				/* active flag */
    short	enable;				/* enable flag */
    short	initial;			/* initial state */
    short	final;				/* final state */
    char	description[FRIG_DESCRIPTION_LEN];	/* descriptive ASCII text */
    OPER_DEF	states[FRIG_STATES_PER_FSM];	/* state definitions */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */ FSM_SET;

#define	FRIG_HISTORIES_PER_FSM	8		/* number of histories per FSM */

typedef struct
    {
    short	current;			/* current state */
    short	history[FRIG_HISTORIES_PER_FSM];	/* history of states */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */ FSM_READ;

typedef struct
    {
    short	defined;			/* defined flag */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */ FSM_STATUS;

typedef struct
    {
    short	command;			/* activation command */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */ FSM_CONTROL;

typedef struct
    {
    int	di;				/* device index */
    char	ssdn[LEN_SSDN];			/* device SSDN with imbedded offset */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */ DEV_SIMPLE;

struct LOOP_SET
    {
    int		enabled;			/* loop enable flag */
    int		active;				/* loop active flag */
    int		algorithm;			/* loop algorithm */
    DEV_SIMPLE	input_device;			/* loop input device */
    DEV_SIMPLE	output_device;			/* loop output device */
    int		output_sibling;			/* loop output sibling device */
    int		sample_time;			/* loop sample time */
    int		fast_sample_time;		/* loop fast sample time */
    int		fast_sample_active;		/* loop fast sample time active flag */
    float	set_value;			/* loop set value (volts) */
    float	max_output;			/* loop output device maximum value */
    float	min_output;			/* loop output device minimum value */
    float	max_output_change;		/* loop output device maximum change */
    float	min_output_change;		/* loop output device minimum change */
    float	constants[6];			/* loop constants */
    float	error_tol;			/* loop maximum error tolerance */
    float	min_error;			/* loop minimum error (deadband half width) */
    float	e_values[5];
    DEV_SIMPLE	output_read_device;		/* output device reading */
    int		unused;				/* unused data area */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */;

typedef struct
    {
    union
	{
	float	f_value;			/* float value */
	int	i_value;			/* integer value */
	} result;
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */ LOOP_READ;

typedef struct
    {
    short	defined;			/* defined flag */
    unsigned short	ftd;			/* requested event in the form of an FTD */
    unsigned int	delay;			/* delay after event in milliseconds */
    short	user_tag;			/* user assigned tag value */
    char	description[FRIG_DESCRIPTION_LEN];	/* descriptive ASCII text */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */ EVENT_SET;

typedef struct
    {
    short	status;				/* status flag */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */ EVENT_STATUS;

typedef struct
    {
    short	command;			/* switch from event occurred to waiting for event */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */ EVENT_CONTROL;

struct FILTER_INPUT_DEVICE
    {
    int	di;				/* device index */
    int	pi;				/* property index */
    char	ssdn[LEN_SSDN];			/* device SSDN with imbedded offset */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */;

struct FILTER_SMOOTHING_PARAMS
    {
    int	input_depth;			/* depth of the input stack (averaging) */
    float	boundary;			/* boundary for smoothing algorithm */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */;

struct FILTER_BUTTERWORTH_PARAMS
    {
    float	lower_frequency;		/* lower frequency filter parameter */
    float	upper_frequency;		/* upper frequency filter parameter */
    float	lower_gain;			/* lower frequency gain filter parameter */
    float	upper_gain;			/* upper frequency gain filter parameter */
    int	input_depth;			/* depth of the input stack */
    int	output_depth;			/* depth of the output stack */
    float	numerator_coeffs[10];		/* numerator coefficients */
    float denominator_coeffs[10];		/* denominator coefficients */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */;

struct FILTER_SET
    {
    short	defined;			/* defined flag */
    short	algorithm;			/* algorithm (0 -> smoothing, 1 -> Buttterworth) */
    FILTER_INPUT_DEVICE	input_device;		/* filter input device */
    FILTER_SMOOTHING_PARAMS	smoothing;	/* smoothing algorithm parameters */
    FILTER_BUTTERWORTH_PARAMS	butterworth;	/* Butterworth algorithm parameters */
    char	description[FRIG_DESCRIPTION_LEN];	/* descriptive ASCII text */
    short	user_tag;			/* user assigned tag value */
    short	enable;				/* enable flag */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */;

typedef struct
    {
    float	output;				/* filter output */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */ FILTER_READ;

typedef struct
    {
    short	status;				/* status flag (1 -> enabled, 0 -> disabled) */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */ FILTER_STATUS;

typedef struct
    {
    short	command;			/* enable or disable a filter */
    } __attribute__((packed)) /* Added by the PACKINATOR(tm) */ FILTER_CONTROL;


typedef int (*sn_verify_function)(char *text, int *index,int type,int hclass);			
typedef int (*sn_next_function)(char *passed_house, char *next_house, 
                      int direction,int *ret_index,int house_type,int house_class);
typedef int (*sn_menu_function)(int row, int col, char *house, 
                      int *ret_index,int house_type,int house_class);


/******************************************************************************/
/*
**	function prototypes for FRIG_xxx routines
*/
/******************************************************************************/

#ifdef __cplusplus
extern "C" {
#endif

int	frig_activate_fsm_c(char *house, char *name, int initial_state = -1);
int	frig_activate_loop_c(char *house, char *name);
int	frig_build_list_c(int *list_id, int list_length, char *houses,
			  char *names, ACNET_ERR *errors, int *num_entries = (int *) NULL,
                      short ftd = FTD_ONESHOT);
int	frig_build_global_list_c(int *list_id, int list_length, char *names,
				 ACNET_ERR *errors, short ftd = FTD_ONESHOT,int type = FRIG_WILD_FRIG);
int	frig_cancel_get_c(char *house, char *name, int num_entry = 1,short ftd = FTD_ONESHOT);
int	frig_cancel_get_global_c(char *name, short ftd, int type);
int	frig_cancel_list_c(int list_id);
int	frig_deactivate_fsm_c(char *house, char *name);
int	frig_deactivate_loop_c(char *house, char *name);
int	frig_default_delete_c(char *housename, char *genname, int num_entry = 1);
int frig_default_flush_c(void);
int	frig_default_get_c(char *housename, char *genname, char *data_ptr, 
                       int num_entry = 1,
                       unsigned int	*date_ptr = (unsigned int *) NULL);
int	frig_default_menu_c(int row, int column, char *filename, 
                        int *ret_index = (int *) NULL,int file_type = FRIG_ALL_HOUSES);
int	frig_default_put_c(char *housename, char *genname, char *data_ptr, int num_entry = 1);
int	frig_default_version_c(char *housename, int object_type, int row,
			       int column);
int	frig_dev_data_change_house(DEV_DATA *raw_data, char *house);
int	frig_dev_data_to_pname_c(DEV_DATA *raw_data, char *pname,
				 int type, char *house);
int	frig_dev_simple_to_pname_c(DEV_SIMPLE *raw_data, char *pname, int type,
				   char *house, short property, short *ret_offset = (short *) NULL);
int	frig_disable_fsm_c(char *house, char *name);
int	frig_disable_loop_c(char *house, char *name);
extern int frig_download_file_c(char *vms_filename_ptr, char *template_filename_ptr);
void	frig_download_order(int *data_types);
int	frig_enable_fsm_c(char *house, char *name);
int	frig_enable_loop_c(char *house, char *name);
int	frig_file_delete_c(char *binname, char *genname, int num_entry = 1);
int	frig_file_get_c(char *binname, char *genname, char *data_ptr, 
                    int num_entry=1,int *date_data_ptr = NULL);
int	frig_file_put_c(char *binname, char *genname, char *data_ptr, int num_entry = 1);
int	frig_fire_c(char *house, char *name, void *data, int data_type = FRIG_LONG);
int	frig_fsm_current_state_c(char *house, char *name, int *curr_states,
				 unsigned short *status_values, int num_entry);
int	frig_get_c(char *house, char *name, void *data, 
               int num_entry = 1,
               int data_source = FRIG_MICRO,
               short ftd = FTD_ONESHOT);
int	frig_get_global_c(char *name, void *data, ACNET_ERR *errors, 
                      short ftd = FTD_ONESHOT,int type = FRIG_WILD_FRIG);
int	frig_get_global_list_c(int list_id, void *data,ACNET_ERR *wild_err = (ACNET_ERR *) NULL);
int	frig_get_list_c(int list_id, void *data);
int	frig_get_status_c(char *house, char *name, unsigned short *data,
                      int num_entry = 1,short ftd = FTD_ONESHOT);
int	frig_get_value_c(char *house, char *name, void *data, 
                     int num_entry = 1,
                     short pi = PRSET,
                     int data_type = FRIG_LONG,
                     short ftd = FTD_ONESHOT);
int	frig_global_info(int *num_houses, char *house_names = (char *) NULL,
                     int type = FRIG_WILD_FRIG);
int	frig_house_menu_c(int top_row, int left_column, char *house, 
                      int *ret_index = (int *) NULL,
                      int house_type = FRIG_ALL_HOUSES,
                      int house_class = FRIG_ALL_HOUSES);
int	frig_house_select_delete_c(short window_id);
int	frig_house_select_init_c(short window_id, int row, int column,
				             char *house, 
                             int data_source = FRIG_MICRO,int select_type = FRIG_ALL_HOUSES,int house_class = FRIG_ALL_HOUSES);
int	frig_house_select_set_c(short window_id, char *new_house);
int	frig_house_select_update_c(short window_id, char *ret_house, int *house_type = (int *) NULL);
int	frig_house_to_device_prefix(char *house_name,
				    char *device_prefix);
int	frig_house_to_node(char *house_name, int *node);
int	frig_name_to_type_c(char *name, int *type, int *index);
int	frig_next_default_c(char *file_name, char *next_file_name, 
                        int direction = FRIG_NEXT_HOUSE,
                        int *ret_index = (int *) NULL,
                        int file_type = FRIG_ALL_HOUSES);
int	frig_next_house_c(char *house, char *next_house, 
                      int direction = FRIG_NEXT_HOUSE,
                      int *ret_index = (int *) NULL,
                      int house_type = FRIG_ALL_HOUSES,
                      int house_class = FRIG_ALL_HOUSES);
int	frig_next_user_file_c(char *bin_name, char *next_bin_name, 
                          int direction = FRIG_NEXT_HOUSE,
                          int *ret_index = NULL);
int	frig_oper_def_change_house(OPER_DEF *raw_data, char *house);
int	frig_oper_def_to_pname_c(OPER_DEF *raw_data, char *pname, int type,
				 char *house);
int	frig_parse_name_c(char *name, char *gen_name, int modify = FRIG_CURRENT);
int	frig_put_c(char *house, char *name, void *data, int num_entry = 1,int data_source = FRIG_MICRO);
int	frig_type_to_name_c(int type, int index, char *name);
int	frig_user_file_add(char *binname, char *bincomment);
int	frig_user_file_delete(char *binname);
int	frig_user_file_menu_c(int row, int column, char *binname, int *ret_index = NULL);
int	frig_verify_default_c(char *file_name, 
                          int *ret_index = (int *) NULL,
                          int file_type = FRIG_ALL_HOUSES);
int	frig_verify_house_c(char *house, int *ret_index = (int *) NULL,
                        int house_type = FRIG_ALL_HOUSES,int house_class = FRIG_ALL_HOUSES);
int	frig_verify_user_file_c(char *bin_name, int *ret_index = NULL);

int frig_register_c(char *house,int data_source);
int frig_unregister_c(char *house, int data_source);

#ifdef __cplusplus
}
#endif


/******************************************************************************/
/*
**	equivalent name definitions
*/
/******************************************************************************/

#define	FRIG_ACTIVATE_FSM_C		frig_activate_fsm_c
#define	FRIG_ACTIVATE_LOOP_C		frig_activate_loop_c
#define	FRIG_BUILD_LIST_C		frig_build_list_c
#define	FRIG_BUILD_GLOBAL_LIST_C	frig_build_global_list_c
#define	FRIG_CANCEL_GET_C		frig_cancel_get_c
#define	FRIG_CANCEL_GET_GLOBAL_C	frig_cancel_get_global_c
#define	FRIG_CANCEL_LIST_C		frig_cancel_list_c
#define	FRIG_DEACTIVATE_FSM_C		frig_deactivate_fsm_c
#define	FRIG_DEACTIVATE_LOOP_C		frig_deactivate_loop_c
#define	FRIG_DEFAULT_DELETE_C		frig_default_delete_c
#define	FRIG_DEFAULT_GET_C		frig_default_get_c
#define	FRIG_DEFAULT_MENU_C		frig_default_menu_c
#define	FRIG_DEFAULT_PUT_C		frig_default_put_c
#define	FRIG_DEFAULT_VERSION_C		frig_default_version_c
#define	FRIG_DEV_DATA_CHANGE_HOUSE	frig_dev_data_change_house
#define	FRIG_DEV_DATA_TO_PNAME_C	frig_dev_data_to_pname_c
#define	FRIG_DEV_SIMPLE_TO_PNAME_C	frig_dev_simple_to_pname_c
#define	FRIG_DISABLE_FSM_C		frig_disable_fsm_c
#define	FRIG_DISABLE_LOOP_C		frig_disable_loop_c
#define	FRIG_DOWNLOAD_ORDER		frig_download_order
#define	FRIG_ENABLE_FSM_C		frig_enable_fsm_c
#define	FRIG_ENABLE_LOOP_C		frig_enable_loop_c
#define	FRIG_FILE_DELETE_C		frig_file_delete_c
#define	FRIG_FILE_GET_C			frig_file_get_c
#define	FRIG_FILE_PUT_C			frig_file_put_c
#define	FRIG_FIRE_C			frig_fire_c
#define	FRIG_FSM_CURRENT_STATE_C	frig_fsm_current_state_c
#define	FRIG_GET_C			frig_get_c
#define	FRIG_GET_GLOBAL_C		frig_get_global_c
#define	FRIG_GET_GLOBAL_LIST_C		frig_get_global_list_c
#define	FRIG_GET_LIST_C			frig_get_list_c
#define	FRIG_GET_STATUS_C		frig_get_status_c
#define	FRIG_GET_VALUE_C		frig_get_value_c
#define	FRIG_GLOBAL_INFO		frig_global_info
#define	FRIG_HOUSE_MENU_C		frig_house_menu_c
#define	FRIG_HOUSE_SELECT_DELETE_C	frig_house_select_delete_c
#define	FRIG_HOUSE_SELECT_INIT_C	frig_house_select_init_c
#define	FRIG_HOUSE_SELECT_SET_C		frig_house_select_set_c
#define	FRIG_HOUSE_SELECT_UPDATE_C	frig_house_select_update_c
#define	FRIG_HOUSE_TO_DEVICE_PREFIX	frig_house_to_device_prefix
#define	FRIG_HOUSE_TO_NODE		frig_house_to_node
#define	FRIG_NAME_TO_TYPE_C		frig_name_to_type_c
#define	FRIG_NEXT_DEFAULT_C		frig_next_default_c
#define	FRIG_NEXT_HOUSE_C		frig_next_house_c
#define	FRIG_NEXT_USER_FILE_C		frig_next_user_file_c
#define	FRIG_OPER_DEF_CHANGE_HOUSE	frig_oper_def_change_house
#define	FRIG_OPER_DEF_TO_PNAME_C	frig_oper_def_to_pname_c
#define	FRIG_PARSE_NAME_C		frig_parse_name_c
#define	FRIG_PUT_C			frig_put_c
#define	FRIG_TYPE_TO_NAME_C		frig_type_to_name_c
#define	FRIG_USER_FILE_ADD		frig_user_file_add
#define	FRIG_USER_FILE_DELETE		frig_user_file_delete
#define	FRIG_USER_FILE_MENU_C		frig_user_file_menu_c
#define	FRIG_VERIFY_DEFAULT_C		frig_verify_default_c
#define	FRIG_VERIFY_HOUSE_C		frig_verify_house_c
#define	FRIG_VERIFY_USER_FILE_C		frig_verify_user_file_c

#endif