/********************************************************************
 * Yamatake DSTJ3000 Description
 *
 * Copyright 1999,2000 Yamatake Corporation all rights reserved.
 *
 *      ypress.ddl  08/11/98		by ZEO system
 *	ypres6.ddl 10/15/99		1st. release
 *	ypres7.ddl 12/28/99		add factory use
 *
 ********************************************************************/

#define YES	1
#define NO	0

#define	FACTORY_MENU	NO	/* NO = Release , YES = Factory use */

#include "bi_codes.h"
#include "macros.ddl"

#define FLOAT_DISPLAY_PRECISION ".3f"
#define FLOAT_EDIT_PRECISION	"8.3f"

#define PRESSURE_UNITS  \
		UNITS_CODE (1),			/* InH2O              */ \
		UNITS_CODE (2), 		/* InHg               */ \
		UNITS_CODE (4),			/* mmH2O              */ \
		UNITS_CODE (5),			/* mmHg               */ \
		UNITS_CODE (6),			/* psi                */ \
		UNITS_CODE (7),			/* bar                */ \
		UNITS_CODE (8),			/* mbar               */ \
		UNITS_CODE (9),			/* g_SqCm             */ \
		UNITS_CODE (10),		/* kg_SqCm            */ \
		UNITS_CODE (11),		/* PA                 */ \
		UNITS_CODE (12),		/* kPA                */ \
		UNITS_CODE (237)		/* mega_pascals       */ \

#define DISP_TYP_LIN \
	"%      (Linear);E.UNIT (Linear);%      (Dsp Flow);E.UNIT (Dsp Flow)"

#define DISP_TYP_SQR \
	"%      (Flow);E.UNIT (Flow)"

#define CUT_MOD_SQR \
	"CUT-OFF: DEFAULT;DRP:lin  MOD:def;DRP:lin  MOD:exp;DRP:zero MOD:def;DRP:zero MOD:exp"


MANUFACTURER YAMATAKE, DEVICE_TYPE _YPRESS, DEVICE_REVISION 1, DD_REVISION 2

/********************************************************************
 * Common Tables Configuration
 ********************************************************************/

IMPORT STANDARD _TABLES, DEVICE_REVISION 8, DD_REVISION 1
{
	EVERYTHING;
}

/********************************************************************
 * Universal Commmands Configuration
 ********************************************************************/

IMPORT STANDARD _UNIVERSAL, DEVICE_REVISION 5, DD_REVISION 1
{
	EVERYTHING;

	REDEFINITIONS
	{

		VARIABLE device_type
		{
			REDEFINE TYPE ENUMERATED
			{
				{ 0x02,  "ST3000" }	/* change 99-09-25 */
			}
		}

        VARIABLE manufacturer_id
        {
            REDEFINE TYPE ENUMERATED
            {
                { 54,  "Yamatake Corporation" }
            }
        }
        VARIABLE private_label_distributor
        {
            REDEFINE TYPE ENUMERATED
            {
                { 54,  "Yamatake Corporation" }
            }
        }

		VARIABLE request_preambles{REDEFINE LABEL "Num Req Preams";}
		VARIABLE universal_revision{REDEFINE LABEL "Universal Rev";}
		VARIABLE transmitter_revision{REDEFINE LABEL "Field Device Rev";}
		VARIABLE software_revision{REDEFINE LABEL "Software Rev";}
		VARIABLE hardware_revision{REDEFINE LABEL "Hardware Rev";}
	/*	VARIABLE physical_signaling_code{REDEFINE LABEL [physical_signalling_code];}	*/
	/*	VARIABLE device_flags{REDEFINE LABEL [device_flags];}	*/
		VARIABLE device_id{REDEFINE LABEL "Device ID";}
		VARIABLE polling_address{REDEFINE LABEL "Poll Address";}
		VARIABLE tag{REDEFINE LABEL "Tag";}
		VARIABLE message{REDEFINE LABEL "Message";}
		VARIABLE descriptor{REDEFINE LABEL "Descriptor";}
		VARIABLE date{REDEFINE LABEL "Date";}
	/*	VARIABLE private_label_distributor{REDEFINE LABEL [private_label_distributor];}	*/
		VARIABLE final_assembly_number{REDEFINE LABEL "Final Assembly Number";}

		COMMAND read_dynamic_variables_and_pv_current		/* command 3 */
		{
			REDEFINE TRANSACTION
			{
				REQUEST
				{}

				REPLY
				{
					response_code, device_status,
					PV.ANALOG_VALUE,
					PV.DIGITAL_UNITS, PV.DIGITAL_VALUE,
					SV.DIGITAL_UNITS, SV.DIGITAL_VALUE
				}
			}
		}
	}
}

/********************************************************************
 * Common Practice Commands Configuration
 ********************************************************************/

IMPORT STANDARD _COMMON_PRACTICE, DEVICE_REVISION 7, DD_REVISION 2
{
	VARIABLE eeprom_select;
	VARIABLE xmtr_specific_status_0;
	VARIABLE xmtr_specific_status_1;
	VARIABLE xmtr_specific_status_2;
	VARIABLE xmtr_specific_status_3;

	COMMAND write_pv_damping_value; 				/* command 34 */
	COMMAND write_pv_range_values;					/* command 35 */
	COMMAND set_pv_upper_range_value;				/* command 36 */
	COMMAND set_pv_lower_range_value;				/* command 37 */
	COMMAND eeprom_control;					/* command 39 */
	COMMAND enter_exit_fixed_pv_current_mode;		/* command 40 */
	COMMAND set_pv_zero;							/* command 43 */
	COMMAND write_pv_units;                         /* command 44 */
	COMMAND trim_pv_current_dac_zero;				/* command 45 */
	COMMAND trim_pv_current_dac_gain;				/* command 46 */
	COMMAND write_pv_transfer_function;				/* command 47 */
	COMMAND read_additional_transmitter_status;     /* command 48 */
	COMMAND write_transmitter_variable_units;       /* command 53 */
	COMMAND reset_configuration_change_flag;	/* command 38 */ /* add 99-09-27 */

	METHOD applied_rerange;
	METHOD burn_eeprom;
	METHOD loop_test;
	METHOD dac_trim;
	METHOD scaled_dac_trim;
	METHOD leave_fixed_current_mode;
	METHOD return_to_normal;
	METHOD zero_trim;	/* change 99-09-25 */

	REDEFINITIONS
	{
		VARIABLE xmtr_specific_status_0
		{
			REDEFINE TYPE BIT_ENUMERATED
			{
				{ 0x01, "METER BODY FAULT",		HARDWARE },
				{ 0x02, "CHARA PROM FAULT",		HARDWARE },
				{ 0x04, "SUSPECT INPUT",		HARDWARE },
				{ 0x08, "MDU/DAC COMP FAULT",	HARDWARE },
				{ 0x10, "RAM FAULT",			HARDWARE },
				{ 0x20, "NVM FAULT",			HARDWARE },
				{ 0x40, "ROM FAULT",			HARDWARE },
				{ 0x80, "PAC FAULT",			HARDWARE }
			}
		}

		VARIABLE xmtr_specific_status_1
		{
			REDEFINE TYPE BIT_ENUMERATED
			{
				{ 0x01, "SENSOR OVER TEMP",		HARDWARE },
				{ 0x02, "EXCESS ZERO CORR",		HARDWARE },
				{ 0x04, "EXCESS SPAN CORR",		HARDWARE },
				{ 0x08, "IN OUTPUT MODE",		HARDWARE },
				{ 0x10, "M.B.OVERLOAD OR",		HARDWARE },
				{ 0x20, "METER BODY FAULT",		HARDWARE },
				{ 0x40, "CORRECTS RESET",		HARDWARE },
				{ 0x80, "NO DAC TEMP COMP",		HARDWARE }
			}
		}

		VARIABLE xmtr_specific_status_2
		{
			REDEFINE TYPE BIT_ENUMERATED
			{
				{ 0x01, "EXT.SWITCH FAULT",		HARDWARE },
				{ 0x02, "STATUS 3-1",			HARDWARE },
				{ 0x04, "STATUS 3-2",			HARDWARE },
				{ 0x08, "STATUS 3-3",			HARDWARE },
				{ 0x10, "STATUS 3-4",			HARDWARE },
				{ 0x20, "STATUS 3-5",			HARDWARE },
				{ 0x40, "STATUS 3-6",			HARDWARE },
				{ 0x80, "STATUS 3-7",			HARDWARE }
			}
		}

		VARIABLE xmtr_specific_status_3
		{
			REDEFINE TYPE BIT_ENUMERATED
			{
				{ 0x01, "INVALID DATABASE",		HARDWARE },
				{ 0x02, "STATUS 4-1",			HARDWARE },
				{ 0x04, "STATUS 4-2",			HARDWARE },
				{ 0x08, "STATUS 4-3",			HARDWARE },
				{ 0x10, "STATUS 4-4",			HARDWARE },
				{ 0x20, "STATUS 4-5",			HARDWARE },
				{ 0x40, "STATUS 4-6",			HARDWARE },
				{ 0x80, "STATUS 4-7",			HARDWARE }
			}
		}

		COMMAND  read_additional_transmitter_status		/* command 48 */
		{
			REDEFINE TRANSACTION
			{
				REQUEST
				{}
				REPLY
				{
					response_code, device_status,
					xmtr_specific_status_0,
					xmtr_specific_status_1,
					xmtr_specific_status_2,
					xmtr_specific_status_3
				}
			}
		}

		COMMAND  write_transmitter_variable_units		/* command 53 */
		{
			REDEFINE TRANSACTION
			{
				REQUEST
				{
					1,				/* transmitter variable code (SV) */
					sensor2_units
				}
				REPLY
				{
					response_code, device_status,
					1,				/* transmitter variable code (SV) */
					sensor2_units
				}
			}
		}

		METHOD loop_test{REDEFINE LABEL "Loop Test";	/* add 99-10-18 */}
		METHOD dac_trim{REDEFINE LABEL "D/A Trim";	/* add 99-10-18 */}
		METHOD scaled_dac_trim{REDEFINE LABEL "Scaled D/A Trim";	/* add 99-10-18 */}
		METHOD applied_rerange{REDEFINE LABEL "Apply Values";	/* add 99-10-18 */}
		METHOD zero_trim
		{
			REDEFINE LABEL "Zero Trim";
			REDEFINE DEFINITION
			{
				char status[STATUS_SIZE];
				int retry;
				char disp_string1[60];
				char disp_string2[60];
				int slen1;
				int slen2;
				
				int	type_cd;	/* add */
				float	height_;	/* add */
				float	var_pv,var_url;
		
		
				slen1=60;
				slen2=60;
		
				IGNORE_ALL_RESPONSE_CODES();
		
				get_dictionary_string(remove_loop_from_auto,disp_string1,slen1);
				ACKNOWLEDGE(disp_string1);
				add_abort_method(return_to_normal);
			/** add remote seal check 99-09-25 *****/ 
				send(134,status);
				if(status[STATUS_RESPONSE_CODE]) {
					display_response_status(134,status[STATUS_RESPONSE_CODE]);
					DELAY(3,"Aborting method due to last error");
					process_abort();
				}
				send(178,status);
				if(status[STATUS_RESPONSE_CODE]) {
					display_response_status(178,status[STATUS_RESPONSE_CODE]);
					DELAY(3,"Aborting method due to last error");
					process_abort();
				}
				type_cd = ivar_value(type_code);
				height_ = fvar_value(height);
				if(((type_cd&0x30) == 0x20) && (height_!=0.0))
				{
					DELAY(5,"INVALID REQUEST");
					process_abort();
				}
			/** end of remote seal check **************/
				get_dictionary_string(this_will_affect_snsr_cal,disp_string1,slen1);
				ACKNOWLEDGE(disp_string1);
		
				do {
					get_dictionary_string(apply_0_input_to_snsr,disp_string1,slen1);
					ACKNOWLEDGE(disp_string1);
		
			/**** add input check ****/
					send(1,status);	
					if(status[STATUS_RESPONSE_CODE]) {
						display_response_status(1,status[STATUS_RESPONSE_CODE]);
						DELAY(3,"Aborting method due to last error");
						process_abort();
					}
					send(14,status);	
					if(status[STATUS_RESPONSE_CODE]) {
						display_response_status(14,status[STATUS_RESPONSE_CODE]);
						DELAY(3,"Aborting method due to last error");
						process_abort();
					}
					var_pv=fvar_value(PV.DIGITAL_VALUE);
					var_url=fvar_value(PV.UPPER_SENSOR_LIMIT);
					var_pv=((var_pv)/(var_url));
					if((var_pv>0.05)||(var_pv<-0.05))
					{
						ACKNOWLEDGE("Excess 5% OK?");
					}
			/** end of input check ***********/
		
					get_dictionary_string(snsr_input_stabilizing,disp_string1,slen1);
					DELAY(3,disp_string1);
					send(43,status);
					if ( status[STATUS_RESPONSE_CODE] ) {
						display_response_status(43,status[STATUS_RESPONSE_CODE]);
						if ((status[STATUS_RESPONSE_CODE] != 9)
								&& ( status[STATUS_RESPONSE_CODE] != 10)) {
							get_dictionary_string(abort_last_error,disp_string1,slen1);
							DELAY(2,disp_string1);
							process_abort();
						}
						get_dictionary_string(zero_the_input_and_try_again,disp_string1,slen1);
						get_dictionary_string(yes_no,disp_string2,slen2);
						retry=SELECT_FROM_LIST(disp_string1,disp_string2);
					}
					else {
						get_dictionary_string(snsr_zero_succeeded,disp_string1,slen1);
						DELAY(3,disp_string1);
						process_abort();
					}
				} while ( !retry);
				process_abort();
			}
}
		



	}
}

/********************************************************************
 * Menus Configuration
 ********************************************************************/

IMPORT STANDARD _MENU, DEVICE_REVISION 1, DD_REVISION 1
{
	VARIABLES;
	MENU root_menu;
	MENU device_setup;
	MENU process_variables;
	MENU diag_service;
	MENU basic_setup;
	MENU detailed_setup;
	MENU review;
	MENU status_display;
	MENU calibration;
	MENU device_info;
	MENU signal_conditioning;
	MENU output_conditioning;
	MENU device_revisions;
	MENU analog_output;
	MENU hart_output;
	MENU hot_key;
	/*WRITE_AS_ONE range_wao;*/
	EDIT_DISPLAY rerange; 

	REDEFINITIONS
	{
		MENU root_menu
		{
			REDEFINE ITEMS
			{
			#if FACTORY_MENU
				auto_set,
				conf_de_type(DISPLAY_VALUE),
				conf_bo_type(DISPLAY_VALUE),
				reset_changflg,
				device_setup
			#else
				device_setup,                                       /* menu */
				pv.TOP_DIGITAL_VALUE (DISPLAY_VALUE,READ_ONLY),         /* variable */
				pv.TOP_ANALOG_VALUE (DISPLAY_VALUE,READ_ONLY),          /* variable */
				pv.TOP_LOWER_RANGE_VALUE (DISPLAY_VALUE),	            /* variable */
				pv.TOP_UPPER_RANGE_VALUE (DISPLAY_VALUE)                /* variable */
			#endif
			}
		}

		MENU device_setup
		{
			REDEFINE LABEL "DEVICE SETUP";		/* add 99-10-14 */
			REDEFINE ITEMS
			{
				process_variables,              /* menu */
				diag_service,                   /* menu */
				basic_setup,                    /* menu */
				detailed_setup,                 /* menu */
				review (REVIEW)                 /* menu */
			}
		}

		MENU process_variables
		{
			REDEFINE LABEL "PROCESS VARIABLE";	/* add 99-10-14 */
			REDEFINE ITEMS
			{
				pv.DIGITAL_VALUE (DISPLAY_VALUE,READ_ONLY),     /* variable */
				pv.PERCENT_RANGE (DISPLAY_VALUE,READ_ONLY),     /* variable */
				pv.ANALOG_VALUE (DISPLAY_VALUE,READ_ONLY),      /* variable */
				sv.DIGITAL_VALUE (DISPLAY_VALUE,READ_ONLY)      /* variable */
			}
		}

		MENU diag_service
		{
			REDEFINE LABEL "DIAG/SERVICE";		/* add 99-10-14 */
			REDEFINE ITEMS
			{
				self_test,
				loop_test,                      /* method */
				calibration                    /* menu   */
			}
		}

		MENU basic_setup
		{
			REDEFINE LABEL "BASIC SETUP";		/* add 99-10-14 */
			REDEFINE ITEMS
			{
				tag (DISPLAY_VALUE),                      /* variable */
				pv.DIGITAL_UNITS (DISPLAY_VALUE),         /* variable */
				rerange,                                  /* edit_display */
				device_info,                              /* menu */
				pv.TRANSFER_FUNCTION (DISPLAY_VALUE),     /* variable */
				pv.DAMPING_VALUE (DISPLAY_VALUE),         /* variable */
				meter_type                                /* menu */
			}
		}

		MENU detailed_setup
		{
			REDEFINE LABEL "DETAILED SETUP";	/* add 99-10-14 */
			REDEFINE ITEMS
			{
				pressure_sensor,                /* menu */
				signal_conditioning,            /* menu */
				output_conditioning,            /* menu */
				device_info                     /* menu */
			}
		}

		MENU review
		{
			REDEFINE LABEL "REVIEW";		/* add 99-10-14 */
			REDEFINE ITEMS
			{
				device_type (DISPLAY_VALUE, READ_ONLY),             /* variable */
				type_code (DISPLAY_VALUE, READ_ONLY),               /* variable */
				manufacturer_id (DISPLAY_VALUE, READ_ONLY),         /* variable */
				pv.DIGITAL_UNITS (DISPLAY_VALUE, READ_ONLY),        /* variable */
				pv.UPPER_SENSOR_LIMIT (DISPLAY_VALUE, READ_ONLY),   /* variable */
				pv.LOWER_SENSOR_LIMIT (DISPLAY_VALUE, READ_ONLY),   /* variable */
				pv.DAMPING_VALUE (DISPLAY_VALUE, READ_ONLY),        /* variable */
				pv.PERCENT_RANGE (DISPLAY_VALUE, READ_ONLY),        /* variable */
				pv.TRANSFER_FUNCTION (DISPLAY_VALUE, READ_ONLY),    /* variable */
				pv.UPPER_RANGE_VALUE (DISPLAY_VALUE, READ_ONLY),    /* variable */
				pv.LOWER_RANGE_VALUE (DISPLAY_VALUE, READ_ONLY),    /* variable */
				pv.ANALOG_VALUE (DISPLAY_VALUE, READ_ONLY),         /* variable */
				pv.ALARM_CODE (DISPLAY_VALUE, READ_ONLY),           /* variable */
				pv.SENSOR_SERIAL_NUMBER (DISPLAY_VALUE, READ_ONLY), /* variable */
				prom_id (DISPLAY_VALUE, READ_ONLY),                 /* variable */
				device_id (DISPLAY_VALUE, READ_ONLY),               /* variable */
				tag (DISPLAY_VALUE, READ_ONLY),                     /* variable */
				message (DISPLAY_VALUE, READ_ONLY),                 /* variable */
				universal_revision (DISPLAY_VALUE, READ_ONLY),      /* variable */
				transmitter_revision (DISPLAY_VALUE, READ_ONLY),    /* variable */
				software_revision (DISPLAY_VALUE, READ_ONLY),       /* variable */
				polling_address (DISPLAY_VALUE, READ_ONLY),         /* variable */
				request_preambles (DISPLAY_VALUE, READ_ONLY)        /* variable */
			}
		}

		MENU calibration
		{
			REDEFINE ITEMS
			{
				cal_rerange,          /* menu */
				dac_trim,                        /* method */
				correct_input,          /* menu */
				set_output_method          /* method */
			}
		}

		MENU device_info
		{
			REDEFINE LABEL "Device Information";		/* add 99-10-14 */
			REDEFINE ITEMS
			{
				manufacturer_id (DISPLAY_VALUE,READ_ONLY),		    /* variable */
				device_type (DISPLAY_VALUE,READ_ONLY),              /* variable */
				type_code (DISPLAY_VALUE,READ_ONLY),                /* variable */
				device_id (DISPLAY_VALUE,READ_ONLY),                /* variable */
				tag (DISPLAY_VALUE),                                /* variable */
				date (DISPLAY_VALUE),                               /* variable */
				descriptor (DISPLAY_VALUE),                         /* variable */
				message (DISPLAY_VALUE),                            /* variable */
				pv.SENSOR_SERIAL_NUMBER (DISPLAY_VALUE,READ_ONLY),  /* variable */
				prom_id (DISPLAY_VALUE,READ_ONLY),                  /* variable */
				final_assembly_number (DISPLAY_VALUE),              /* variable */
				device_revisions,                                   /* menu */
				meter_type                                         /* menu */
			}
		}

		MENU signal_conditioning
		{
			REDEFINE LABEL "Signal Condition";		/* add 99-10-14 */
			REDEFINE ITEMS
			{
				pv.DAMPING_VALUE (DISPLAY_VALUE),                 /* variable */
				pv.UPPER_RANGE_VALUE (DISPLAY_VALUE),           /* variable */
				pv.LOWER_RANGE_VALUE (DISPLAY_VALUE),           /* variable */
				pv.TRANSFER_FUNCTION (DISPLAY_VALUE),           /* variable */
				pv.PERCENT_RANGE (DISPLAY_VALUE,READ_ONLY),     /* variable */
				cutoff_mode_method,                             /* method */
				dropout_point (DISPLAY_VALUE),                   /* variable */
				height (DISPLAY_VALUE)                              /* variable */
			}
		}

		MENU output_conditioning
		{
			REDEFINE LABEL "Output Condition";		/* add 99-10-14 */
			REDEFINE ITEMS
			{
				analog_output,              /* menu */
				hart_output,                 /* menu */
				service_setup                                   /* menu */
			}
		}

		MENU device_revisions
		{
			REDEFINE LABEL "Revision Numbers";		/* add 99-10-18 */
			REDEFINE ITEMS
			{
				universal_revision (DISPLAY_VALUE,READ_ONLY),       /* variable */
				transmitter_revision (DISPLAY_VALUE,READ_ONLY),     /* variable */
				software_revision (DISPLAY_VALUE,READ_ONLY)         /* variable */
			}
		}

		MENU analog_output
		{
			REDEFINE LABEL "Analog Output";		/* add 99-10-14 */
			REDEFINE ITEMS
			{
				analog_value (DISPLAY_VALUE,READ_ONLY),         /* variable */
				analog_alarm_code (DISPLAY_VALUE,READ_ONLY),    /* variable */
				loop_test,                                      /* method */
				dac_trim,                                       /* method */
				scaled_dac_trim,                                /* method */
				output_limit                                    /* menu */
			}
		}

		MENU hart_output
		{
			REDEFINE LABEL "HART Output";		/* add 99-10-14 */
			REDEFINE ITEMS
			{
				polling_address (DISPLAY_VALUE),                /* Variable */
				request_preambles (DISPLAY_VALUE,READ_ONLY)     /* Variable */
			}
		}

		EDIT_DISPLAY rerange
		{
			REDEFINE LABEL "Range Values";
			REDEFINE EDIT_ITEMS
			{
				/*range_wao*/
				pv.LOWER_RANGE_VALUE,
				pv.UPPER_RANGE_VALUE
			}
			REDEFINE DISPLAY_ITEMS
			{
				pv.LOWER_SENSOR_LIMIT,
				pv.UPPER_SENSOR_LIMIT
			}
		}
	}
}

MENU pressure_sensor
{
	LABEL "Sensors";
	ITEMS
	{
		pv.DIGITAL_VALUE (DISPLAY_VALUE,READ_ONLY),     /* variable */
		pv.DIGITAL_UNITS (DISPLAY_VALUE),               /* variable */
		pres_sensor_info /*(REVIEW)*/,        /* delete REVIEW 99-09-24*/       /* menu */
		sv.DIGITAL_VALUE (DISPLAY_VALUE,READ_ONLY),     /* variable */
		sv.DIGITAL_UNITS (DISPLAY_VALUE)                /* variable */
	}
}

MENU pres_sensor_info
{
	LABEL "PV Range Limit";			/* change from [sensor_info]; */
	ITEMS
	{
		pv.LOWER_SENSOR_LIMIT (DISPLAY_VALUE,READ_ONLY),    /* variable */
		pv.UPPER_SENSOR_LIMIT (DISPLAY_VALUE,READ_ONLY)     /* variable */
	}
}

MENU meter_type
{
	LABEL "Meter Type";
	ITEMS
	{
		display_type_method,                    /* method */
		eu_lower_value (DISPLAY_VALUE),         /* variable */
		eu_upper_value (DISPLAY_VALUE)          /* variable */
	}
}

MENU output_limit
{
	LABEL "Output Limit";
	ITEMS
	{
		out_lower_limit (DISPLAY_VALUE),        /* variable */
		out_upper_limit (DISPLAY_VALUE)         /* variable */
	}
}

MENU correct_input
{
	LABEL "Correct Input";
	ITEMS
	{
		zero_trim,                  /* method */
		correct_inp_lrv_method,     /* method */
		correct_inp_urv_method,     /* method */
		reset_correct_method       /* method */
	}
}

MENU cal_rerange
{
	LABEL "Rerange";
	ITEMS
	{
		key_pad_rerange,            /* edit_display */
		applied_rerange            /* method */
	}
}

EDIT_DISPLAY service_setup
{
	LABEL "Service Setup";
	EDIT_ITEMS
	{
		conf_de_type,
		conf_bo_type,
		rreset_changflg
	}
	PRE_EDIT_ACTIONS{passwd_check}
	#if 0
	POST_EDIT_ACTIONS{reset_changflg}
	#endif
}



EDIT_DISPLAY key_pad_rerange
{
	LABEL "Enter Values";	/* change from [enter_values] by K.K 99-10-18 */

	/*EDIT_ITEMS { range_wao }*/
	EDIT_ITEMS
	{
		pv.LOWER_RANGE_VALUE,
		pv.UPPER_RANGE_VALUE
	}
	DISPLAY_ITEMS
	{
		pv.LOWER_SENSOR_LIMIT,
		pv.UPPER_SENSOR_LIMIT
	}
}


/********************************************************************
 * Variables Configuration
 ********************************************************************/

VARIABLE rreset_changflg
{
	LABEL "Reset Change Flag";
	CLASS LOCAL;
	HANDLING READ&WRITE;
	TYPE FLOAT
	{
		DISPLAY_FORMAT ".3f";
		EDIT_FORMAT ".3f";
	}
	PRE_EDIT_ACTIONS{reset_changflg}
}

VARIABLE sensor_value
{
	LABEL "Pressure";
	HELP [digital_value_help];
	CLASS CORRECTION & DYNAMIC;
	HANDLING READ;
	TYPE FLOAT
	{
		DISPLAY_FORMAT ".4f";
	}
}

VARIABLE sensor_units
{
	LABEL "Pressure Unit";
	HELP [digital_units_help];
	CLASS CORRECTION;
	HANDLING READ&WRITE;
	TYPE ENUMERATED
	{
		PRESSURE_UNITS
	}
}

VARIABLE sensor_upper_limit
{
	LABEL "PV URL";
	HELP [upper_sensor_limit_help];
	CLASS CORRECTION;
	HANDLING READ;
	TYPE FLOAT
	{
		DISPLAY_FORMAT ".4f";
	}
}

VARIABLE sensor_lower_limit
{
	LABEL "PV LRL";
	HELP [lower_sensor_limit_help];
	CLASS CORRECTION;
	HANDLING READ;
	TYPE FLOAT
	{
		DISPLAY_FORMAT ".4f";
	}
}

VARIABLE sensor_minimum_span
{
	LABEL [pv_minimum_span];
	HELP [minimum_span_help];
	CLASS CORRECTION;
	HANDLING READ;
	TYPE FLOAT
	{
		DISPLAY_FORMAT FLOAT_DISPLAY_PRECISION;
	}
}

VARIABLE sensor_damping_value
{
	LABEL "PV Damping";
	HELP [seconds_damping_value_help];
	CLASS CORRECTION;
	HANDLING READ&WRITE;
	CONSTANT_UNIT [sec];
	TYPE FLOAT
	{
		DISPLAY_FORMAT "4.2f";
		EDIT_FORMAT "4.2f";		/* change 4.1f to 4.2f 99-09-24 */
		MIN_VALUE 0.0;
		MAX_VALUE 128.0;
	}
}

VARIABLE analog_value
{
	LABEL "Analog Output";
	HELP [analog_value_help];
	CLASS ANALOG_OUTPUT & DYNAMIC;
	HANDLING READ&WRITE;
	CONSTANT_UNIT [mA];
	TYPE FLOAT
	{
		DISPLAY_FORMAT ".3f";	/* change 99-11-12 */
		EDIT_FORMAT "6.3f";	/* change 99-11-12 */
	}
}

VARIABLE analog_alarm_code
{
	LABEL "AO Alarm Type";
	HELP [alarm_code_help];
	CLASS ANALOG_OUTPUT;
	HANDLING READ;
	TYPE ENUMERATED
	{
		#if 0
		{0,"UPSCALE"},
		{1,"DOWNSCALE"},
		{251,"NON-B/O"},
		#else			/* fix this type 99-10-13 */
		ALARM_SELECTION_CODE(0),		/* upscale */
		ALARM_SELECTION_CODE(1),		/* downscale */
		ALARM_SELECTION_CODE(251),		/* non-burnout */
		#endif
		ALARM_SELECTION_CODE(252)		/* unknown */
	}
}

VARIABLE input_percent_range
{
	LABEL "PV % Range";
	HELP [percent_of_range_help];
	CLASS INPUT & DYNAMIC;
	HANDLING READ;
	CONSTANT_UNIT [Percent];
	TYPE FLOAT
	{
		DISPLAY_FORMAT ".2f";
	}
}

VARIABLE input_transfer_function
{
	LABEL [transfer_function];
	HELP [transfer_function_help];
	CLASS INPUT;
	HANDLING READ&WRITE;
	TYPE ENUMERATED
	{
		TRANSFER_FUNCTION_CODE (0),     /* Linear */
		TRANSFER_FUNCTION_CODE (1)      /* Square Root */
	}
}

VARIABLE input_range_units
{
	LABEL [pv_range_units];
	HELP [range_units_help];
	CLASS INPUT;
	HANDLING READ;
	TYPE ENUMERATED
	{
		PRESSURE_UNITS
	}
}

VARIABLE input_upper_value
{
	LABEL "URV";	/* change label from [pv_urv] by K.K 99-10-13 */
	HELP [upper_range_value_help];
	CLASS INPUT;
	HANDLING READ&WRITE;
	TYPE FLOAT
	{
		DISPLAY_FORMAT ".3f";
		EDIT_FORMAT ".3f";
	}
}

VARIABLE input_lower_value
{
	LABEL "LRV";	/* change label from [pv_lrv] by K.K 99-10-13 */
	HELP [lower_range_value_help];
	CLASS INPUT;
	HANDLING READ&WRITE;
	TYPE FLOAT
	{
		DISPLAY_FORMAT ".3f";
		EDIT_FORMAT ".3f";
	}
}

VARIABLE sensor_serial_number
{
	LABEL "Sensor Serial Number";
	HELP [sensor_serial_number_help];
	CLASS DEVICE;
	HANDLING READ;
	TYPE UNSIGNED_INTEGER (3)
	{
		DISPLAY_FORMAT  "7d";
	}
}

VARIABLE sensor2_value
{
	LABEL "Sensor Temp";	/* change label from [sv]; by K.K 99-10-14 */
	HELP [digital_value_help];
	CLASS CORRECTION & DYNAMIC;
	HANDLING READ;
	TYPE FLOAT
	{
		DISPLAY_FORMAT ".1f";
	}
}

VARIABLE sensor2_units
{
	LABEL "Temp Unit";
	HELP [digital_units_help];
	CLASS CORRECTION;
	HANDLING READ&WRITE;
	TYPE ENUMERATED
	{
		UNITS_CODE (32),        /* Degrees C */
		UNITS_CODE (33),        /* Degrees F */
		UNITS_CODE (34),        /* Degrees Rankine */
		UNITS_CODE (35)         /* Degrees Kelvin */
	}
}

VARIABLE cutoff_mode
{
	LABEL "Cutoff Mode";
	CLASS ANALOG_OUTPUT;
	HANDLING READ&WRITE;
	TYPE UNSIGNED_INTEGER (1);
}

VARIABLE dropout_point
{
	LABEL "Dropout Point";
	CLASS ANALOG_OUTPUT;
	VALIDITY
		IF ((input_transfer_function == 1) && (cutoff_mode <= 0x03)){
			TRUE;
		} ELSE {
			FALSE;
		}
	HANDLING
		IF ((input_transfer_function == 1) &&
		    (cutoff_mode <= 0x03)){
			READ&WRITE;
		} ELSE {
			READ;
		}
	CONSTANT_UNIT [Percent];
	TYPE FLOAT
	{
		DISPLAY_FORMAT ".1f";
		EDIT_FORMAT "4.1f";
		MIN_VALUE 0.0;
		MAX_VALUE 20.0;
	}
}

VARIABLE display_type
{
	LABEL "Display Type";
	CLASS ANALOG_OUTPUT;
	HANDLING READ&WRITE;
	TYPE UNSIGNED_INTEGER (1);
}

VARIABLE eu_lower_value
{
	LABEL "EU LO";
	CLASS ANALOG_OUTPUT;
	HANDLING
		IF (((type_code & 0x80) == 0x80) && 
			((display_type == 27) || (display_type == 253))) {	/* ENG.UNIT */
			READ&WRITE;
		} ELSE {
			READ;
		}
	TYPE FLOAT
	{
		DISPLAY_FORMAT ".3f";
		EDIT_FORMAT "7.3f";
		MIN_VALUE -19999.0;
		MAX_VALUE 19999.0;
	}
}

VARIABLE eu_upper_value
{
	LABEL "EU HI";
	CLASS ANALOG_OUTPUT;
	HANDLING
		IF (((type_code & 0x80) == 0x80) && 
			((display_type == 27) || (display_type == 253))) {	/* ENG.UNIT */
			READ&WRITE;
		} ELSE {
			READ;
		}
	TYPE FLOAT
	{
		DISPLAY_FORMAT ".3f";
		EDIT_FORMAT "7.3f";
		MIN_VALUE -19999.0;
		MAX_VALUE 19999.0;
	}
}

VARIABLE height
{
	LABEL "Height";
	CLASS INPUT;
	VALIDITY
		IF ((type_code & 0x30) == 0x20) {		/* Remote Seals */
			TRUE;
		} ELSE {
			FALSE;
		}
	HANDLING
		IF ((type_code & 0x30) == 0x20) {		/* Remote Seals */
			READ&WRITE;
		} ELSE {
			READ;
		}
	CONSTANT_UNIT [meter];
	TYPE FLOAT
	{
		DISPLAY_FORMAT ".3f";	/* change 99-11-12 */
		EDIT_FORMAT "7.3f";	/* change 99-11-12 */
		MIN_VALUE -30.00;
		MAX_VALUE 30.00;
	}
}

VARIABLE out_lower_limit
{
	LABEL "Lo Limit";
	VALIDITY
		IF(analog_alarm_code==251){
			FALSE;
		} ELSE {
			TRUE;
		}
	CLASS ANALOG_OUTPUT;
	HANDLING READ&WRITE;
	CONSTANT_UNIT [Percent];
	TYPE FLOAT
	{
		DISPLAY_FORMAT ".3f";	/* change 99-11-12 */
		EDIT_FORMAT "6.3f";	/* change 99-11-12 */
		MIN_VALUE -1.25;
		MAX_VALUE 49.99;
	}
}

VARIABLE out_upper_limit
{
	LABEL "Hi Limit";
	VALIDITY
		IF(analog_alarm_code==251){
			FALSE;
		} ELSE {
			TRUE;
		}
	CLASS ANALOG_OUTPUT;
	HANDLING READ&WRITE;
	CONSTANT_UNIT [Percent];
	TYPE FLOAT
	{
		DISPLAY_FORMAT ".3f";	/* change 99-11-12 */
		EDIT_FORMAT "6.3f";	/* change 99-11-12 */
		MIN_VALUE 50.00;
		MAX_VALUE 105.00;
	}
}

VARIABLE type_code
{
	LABEL "Measurement Type";
	CLASS DEVICE;
	HANDLING READ;
	TYPE ENUMERATED (1)
	{
		{ 0x00, "DP" },		/* Standard Mount DP */
		{ 0x01, "GP" },		/* Standard Mount GP */
		{ 0x02, "AP" },		/* Standard Mount AP */
		{ 0x10, "DP" },		/* Flange Mount DP */
		{ 0x11, "GP" },		/* Flange Mount GP */
		{ 0x12, "AP" },		/* Flange Mount AP */
		{ 0x20, "DP" },		/* Remote Seals DP */
		{ 0x21, "GP" },		/* Remote Seals GP */
		{ 0x22, "AP" },		/* Remote Seals AP */
		{ 0x80, "DP" },		/* Standard Mount DP (Digital Meter) */
		{ 0x81, "GP" },		/* Standard Mount GP (Digital Meter) */
		{ 0x82, "AP" },		/* Standard Mount AP (Digital Meter) */
		{ 0x90, "DP" },		/* Flange Mount DP (Digital Meter) */
		{ 0x91, "GP" },		/* Flange Mount GP (Digital Meter) */
		{ 0x92, "AP" },		/* Flange Mount AP (Digital Meter) */
		{ 0xA0, "DP" },		/* Remote Seals DP (Digital Meter) */
		{ 0xA1, "GP" },		/* Remote Seals GP (Digital Meter) */
		{ 0xA2, "AP" }		/* Remote Seals AP (Digital Meter) */
	}
}

VARIABLE prom_id
{
	LABEL "PROM ID";
	CLASS DEVICE;
	HANDLING READ;
	TYPE ASCII (10);
}

VARIABLE set_output_value
{
	LABEL "Set Output Value";
	/* CLASS LOCAL & DYNAMIC;*/
	CLASS LOCAL;
	HANDLING READ&WRITE;
	TYPE FLOAT
	{
		DISPLAY_FORMAT ".2f";
		EDIT_FORMAT "6.2f";
		MIN_VALUE 0.00;
		MAX_VALUE 100.00;
	}
}

VARIABLE conf_de_type
{
	LABEL "DE Mode";
	CLASS DEVICE;
	HANDLING READ&WRITE;
	TYPE ENUMERATED(1)
	{
		{0,"ENABLE"},
		{1,"DISABLE"}
	}
}

VARIABLE conf_bo_type
{
	LABEL "B/O Direction";
	CLASS DEVICE;
	HANDLING READ&WRITE;
	TYPE ENUMERATED(1)
	{
		#if 0
		{0,"DOWNSCALE"},
		{0x40,"UPSCALE"},
		{0xC0,"NON-B/O"}
		#else
		{0,"Lo"},
		{0x40,"Hi"},
		{0xC0,"None"}
		#endif
	}
}

VARIABLE service_password
{
	LABEL "";
	CLASS LOCAL;
	HANDLING READ&WRITE;
	TYPE INTEGER(2);
}

/********************************************************************
 * Dynamic Variables & Collections Configuration
 ********************************************************************/

ARRAY OF COLLECTION dynamic_variables
{
	ELEMENTS
	{
		PRIMARY,   pv, [pv];
		SECONDARY, sv, [sv];
	}
}

COLLECTION OF VARIABLE pv
{
	/* LABEL [pv]; */
	HELP [primary_variable_help];
	MEMBERS
	{
		/* Sensor Correction Information */
		DIGITAL_UNITS,			sensor_units,			"Pressure Unit",			[digital_units_help];
		DIGITAL_VALUE,			sensor_value,			"Pressure",			[digital_value_help];
		SENSOR_UNITS,			sensor_units,			[sensor_unit],		[digital_units_help];
		UPPER_SENSOR_LIMIT,		sensor_upper_limit,		"PV URL",				[upper_sensor_limit_help];
		LOWER_SENSOR_LIMIT,		sensor_lower_limit,		"PV LRL",				[lower_sensor_limit_help];
		MINIMUM_SPAN,			sensor_minimum_span,	[minimum_span],		[minimum_span_help];
		DAMPING_VALUE,			sensor_damping_value,	"PV Damp",	[seconds_damping_value_help];

		/* Analog Output Information */
		ANALOG_VALUE,			analog_value,			"Analog Output",[analog_value_help];
		ALARM_CODE,				analog_alarm_code,		"AO Alarm Type",		[alarm_code_help];

		/* Input Information */
		PERCENT_RANGE,			input_percent_range,	"PV % Range",	[percent_of_range_help];
		TRANSFER_FUNCTION,		input_transfer_function,"Transfer Function",[transfer_function_help];
		RANGE_UNITS,			input_range_units,		[range_units],		[range_units_help];
		UPPER_RANGE_VALUE,		input_upper_value,		"PV URV",				[upper_range_value_help];
		LOWER_RANGE_VALUE,		input_lower_value,		"PV LRV",				[lower_range_value_help];

		/* Device Information */
		SENSOR_SERIAL_NUMBER,	sensor_serial_number,	"Sensor Serial Number", [sensor_serial_number_help];

		/* Top Menu Information */
		TOP_DIGITAL_VALUE,			sensor_value,			"PV",			[digital_value_help];
		TOP_ANALOG_VALUE,			analog_value,			"AO",[analog_value_help];
		TOP_UPPER_RANGE_VALUE,		input_upper_value,		"URV",				[upper_range_value_help];
		TOP_LOWER_RANGE_VALUE,		input_lower_value,		"LRV",				[lower_range_value_help];
	}
}

COLLECTION OF VARIABLE sv
{
	/* LABEL [sv]; */
	HELP [secondary_variable_help];
	MEMBERS
	{
		/* Sensor Correction Information */
		DIGITAL_UNITS,			sensor2_units,			"Temp Unit",			[digital_units_help];
		DIGITAL_VALUE,			sensor2_value,			"Sensor Temp",			[digital_value_help];
	}
}

ARRAY OF VARIABLE loop_warning_variables
{
	ELEMENTS
	{
		0, sensor_units;
		1, sensor_damping_value;
		2, input_transfer_function;
		3, input_upper_value;
		4, input_lower_value;
		5, sensor2_units;
		6, cutoff_mode;
		7, dropout_point;
		8, display_type;
		9, eu_lower_value;
		10, eu_upper_value;
		11, height;
		12, out_lower_limit;
		13, out_upper_limit;
	}
}

MENU upload_variables
{
	LABEL "";
	ITEMS
	{
		sensor_units,                       /* variable */
		input_lower_value,             		/* variable */
		input_upper_value,             		/* variable */
		input_transfer_function,    		/* variable */
		sensor_damping_value,               /* variable */
		sensor2_units,				/* variable */
		tag,                                /* variable */
		date,                               /* variable */ 
		descriptor,                         /* variable */
		message,                            /* variable */
		final_assembly_number               /* variable */
	}
}


/********************************************************************
 * Relationships Configuration
 ********************************************************************/

UNIT sensor_units_relation
{
	sensor_units:
	sensor_value,
	sensor_upper_limit,
	sensor_lower_limit,
	sensor_minimum_span
}

UNIT input_range_units_relation
{
	input_range_units:
	input_upper_value,
	input_lower_value
}

UNIT sensor2_units_relation
{
	sensor2_units:
	sensor2_value
}

REFRESH pv_unit_refresh
{
	sensor_units:
	input_range_units,
	input_upper_value,
	input_lower_value
}

REFRESH sv_unit_refresh
{
	sensor2_units:
	sensor2_value
}

/********************************************************************
 * Commands Configuration
 ********************************************************************/

COMMAND correct_urv						/* command 130 */
{
	NUMBER 130;
	OPERATION WRITE;

	TRANSACTION
	{
		REQUEST
		{
			sensor_units(INFO),
			input_upper_value(INFO)
		}

		REPLY
		{
			response_code, device_status,
			sensor_units(INFO),
			input_upper_value(INFO)
		}
	}

	RESPONSE_CODES
	{
		0,  SUCCESS,			[no_command_specific_errors];
		3,	DATA_ENTRY_ERROR,	[passed_parameter_too_large];
		4,	DATA_ENTRY_ERROR,	[passed_parameter_too_small];
		5,  MISC_ERROR,			[too_few_data_bytes_recieved];
		6,  MISC_ERROR,			[xmtr_specific_command_error];
		7,  MODE_ERROR,			[in_write_protect_mode];
		16, MODE_ERROR,			[access_restricted];
	}
}

COMMAND correct_lrv						/* command 131 */
{
	NUMBER 131;
	OPERATION WRITE;

	TRANSACTION
	{
		REQUEST
		{
			sensor_units(INFO),
			input_lower_value(INFO)
		}

		REPLY
		{
			response_code, device_status,
			sensor_units(INFO),
			input_lower_value(INFO)
		}
	}

	RESPONSE_CODES
	{
		0,  SUCCESS,			[no_command_specific_errors];
		3,	DATA_ENTRY_ERROR,	[passed_parameter_too_large];
		4,	DATA_ENTRY_ERROR,	[passed_parameter_too_small];
		5,  MISC_ERROR,			[too_few_data_bytes_recieved];
		6,  MISC_ERROR,			[xmtr_specific_command_error];
		7,  MODE_ERROR,			[in_write_protect_mode];
		16, MODE_ERROR,			[access_restricted];
	}
}

COMMAND correct_resets					/* command 133 */
{
	NUMBER 133;
	OPERATION COMMAND;

	TRANSACTION
	{
		REQUEST
		{}

		REPLY
		{
			response_code, device_status
		}
	}

	RESPONSE_CODES
	{
		0,  SUCCESS,		[no_command_specific_errors];
		6,  MISC_ERROR,		[xmtr_specific_command_error];
		7,  MODE_ERROR,		[in_write_protect_mode];
		16, MODE_ERROR,		[access_restricted];
	}
}

COMMAND read_prom_id					/* command 134 */
{
	NUMBER 134;
	OPERATION READ;

	TRANSACTION
	{
		REQUEST {}

		REPLY
		{
			response_code, device_status,
			type_code,
			prom_id
		}
	}

	RESPONSE_CODES
	{
		0,  SUCCESS,		[no_command_specific_errors];
		6,  MISC_ERROR,		[xmtr_specific_command_error];
		16,	MODE_ERROR,		[access_restricted];
	}
}

COMMAND read_low_flow_cut				/* command 176 */
{
	NUMBER 176;
	OPERATION READ;

	TRANSACTION
	{
		REQUEST {}

		REPLY
		{
			response_code, device_status,
			cutoff_mode,
			dropout_point
		}
	}

	RESPONSE_CODES
	{
		0,  SUCCESS,	[no_command_specific_errors];
		6,  MISC_ERROR,	[xmtr_specific_command_error];
		16,	MODE_ERROR,	[access_restricted];
	}
}

COMMAND write_low_flow_cut				/* command 177 */
{
	NUMBER 177;
	OPERATION WRITE;

	TRANSACTION
	{
		REQUEST
		{
			cutoff_mode,
			dropout_point
		}

		REPLY
		{
			response_code, device_status,
			cutoff_mode,
			dropout_point
		}
	}

	RESPONSE_CODES
	{
		0,  SUCCESS,	[no_command_specific_errors];
		5,  MISC_ERROR, [too_few_data_bytes_recieved];
		6,  MISC_ERROR, [xmtr_specific_command_error];
		7,  MODE_ERROR, [in_write_protect_mode];
		16, MODE_ERROR, [access_restricted];
	}
}

COMMAND read_height						/* command 178 */
{
	NUMBER 178;
	OPERATION READ;

	TRANSACTION
	{
		REQUEST {}

		REPLY
		{
			response_code, device_status,
			height
		}
	}

	RESPONSE_CODES
	{
		0,  SUCCESS,	[no_command_specific_errors];
		6,  MISC_ERROR,	[xmtr_specific_command_error];
		16,	MODE_ERROR,	[access_restricted];
	}
}

COMMAND write_height					/* command 179 */
{
	NUMBER 179;
	OPERATION WRITE;

	TRANSACTION
	{
		REQUEST
		{
			height
		}

		REPLY
		{
			response_code, device_status,
			height
		}
	}

	RESPONSE_CODES
	{
		0,  SUCCESS,	[no_command_specific_errors];
		5,  MISC_ERROR, [too_few_data_bytes_recieved];
		6,  MISC_ERROR, [xmtr_specific_command_error];
		7,  MODE_ERROR, [in_write_protect_mode];
		16, MODE_ERROR, [access_restricted];
	}
}

COMMAND read_meter_config				/* command 180 */
{
	NUMBER 180;
	OPERATION READ;

	TRANSACTION
	{
		REQUEST {}

		REPLY
		{
			response_code, device_status,
			display_type,
			eu_lower_value,
			eu_upper_value
		}
	}

	RESPONSE_CODES
	{
		0,  SUCCESS,	[no_command_specific_errors];
		6,  MISC_ERROR,	[xmtr_specific_command_error];
		16,	MODE_ERROR,	[access_restricted];
	}
}

COMMAND write_meter_config				/* command 181 */
{
	NUMBER 181;
	OPERATION WRITE;

	TRANSACTION
	{
		REQUEST
		{
			display_type,
			eu_lower_value,
			eu_upper_value
		}

		REPLY
		{
			response_code, device_status,
			display_type,
			eu_lower_value,
			eu_upper_value
		}
	}

	RESPONSE_CODES
	{
		0,  SUCCESS,	[no_command_specific_errors];
		5,  MISC_ERROR, [too_few_data_bytes_recieved];
		6,  MISC_ERROR, [xmtr_specific_command_error];
		7,  MODE_ERROR, [in_write_protect_mode];
		16, MODE_ERROR, [access_restricted];
	}
}

COMMAND read_limit_value				/* command 182 */
{
	NUMBER 182;
	OPERATION READ;

	TRANSACTION
	{
		REQUEST {}

		REPLY
		{
			response_code, device_status,
			out_lower_limit,
			out_upper_limit
		}
	}

	RESPONSE_CODES
	{
		0,  SUCCESS,	[no_command_specific_errors];
		6,  MISC_ERROR,	[xmtr_specific_command_error];
		16,	MODE_ERROR,	[access_restricted];
	}
}

COMMAND write_limit_value				/* command 183 */
{
	NUMBER 183;
	OPERATION WRITE;

	TRANSACTION
	{
		REQUEST
		{
			out_lower_limit,
			out_upper_limit
		}

		REPLY
		{
			response_code, device_status,
			out_lower_limit,
			out_upper_limit
		}
	}

	RESPONSE_CODES
	{
		0,  SUCCESS,	[no_command_specific_errors];
		5,  MISC_ERROR, [too_few_data_bytes_recieved];
		6,  MISC_ERROR, [xmtr_specific_command_error];
		7,  MODE_ERROR, [in_write_protect_mode];
		16, MODE_ERROR, [access_restricted];
	}
}

COMMAND read_de_conf			/* command 184 */
{
	NUMBER 184;
	OPERATION READ;

	TRANSACTION
	{
		REQUEST {}

		REPLY
		{
			response_code, device_status,
			conf_de_type
		}
	}

	RESPONSE_CODES
	{
		0,  SUCCESS,	[no_command_specific_errors];
		6,  MISC_ERROR,	[xmtr_specific_command_error];
		16,	MODE_ERROR,	[access_restricted];
	}
}

COMMAND write_de_conf	/* command 185 */
{
	NUMBER 185;
	OPERATION WRITE;

	TRANSACTION
	{
		REQUEST
		{
			conf_de_type
		}

		REPLY
		{
			response_code, device_status,
			conf_de_type
		}
	}

	RESPONSE_CODES
	{
		0,  SUCCESS,	[no_command_specific_errors];
		5,  MISC_ERROR, [too_few_data_bytes_recieved];
		6,  MISC_ERROR, [xmtr_specific_command_error];
		7,  MODE_ERROR, [in_write_protect_mode];
		16, MODE_ERROR, [access_restricted];
	}
}

COMMAND read_bo_conf			/* command 186 */
{
	NUMBER 186;
	OPERATION READ;

	TRANSACTION
	{
		REQUEST {}

		REPLY
		{
			response_code, device_status,
			conf_bo_type
		}
	}

	RESPONSE_CODES
	{
		0,  SUCCESS,	[no_command_specific_errors];
		6,  MISC_ERROR,	[xmtr_specific_command_error];
		16,	MODE_ERROR,	[access_restricted];
	}
}

COMMAND write_bo_conf	/* command 187 */
{
	NUMBER 187;
	OPERATION WRITE;

	TRANSACTION
	{
		REQUEST
		{
			conf_bo_type
		}

		REPLY
		{
			response_code, device_status,
			conf_bo_type
		}
	}

	RESPONSE_CODES
	{
		0,  SUCCESS,	[no_command_specific_errors];
		5,  MISC_ERROR, [too_few_data_bytes_recieved];
		6,  MISC_ERROR, [xmtr_specific_command_error];
		7,  MODE_ERROR, [in_write_protect_mode];
		16, MODE_ERROR, [access_restricted];
	}
}


/********************************************************************
 * Methods Configuration
 ********************************************************************/

METHOD	passwd_check
{
	LABEL "CHECK PASSWORD";
	DEFINITION
	{
		int count;
		/*count=0;*/
		
		ACKNOWLEDGE("NOTE:This menu required for PASSWORD NUMBER");
		do
		{
		/*	GET_LOCAL_VAR_VALUE("Enter PASSWORD NUMBER",count);
		*/
			GET_DEV_VAR_VALUE("Enter PASSWORD NUMBER",service_password);
			count = ivar_value(service_password);
			if(count==3000){break;}
			DELAY(3,"Wrong Password");
		}while(1);
			DELAY(3,"Password is OK!\nEnter Special Conf.");
	}
}

METHOD reset_changflg
{
	LABEL "RESET CONF CHANGE FLG";
	
	DEFINITION
	{
		ACKNOWLEDGE("RESET CONFIG CHANGE FLAG?");
		send_command(38);
		process_abort();
	}
	
}


METHOD correct_inp_lrv_method
{
	LABEL "Correct Input LRV";

	DEFINITION
	{
		char status[STATUS_SIZE];
		char disp_string[60];
		int slen;

			int	type_cd;	/* add */
			float	height_;	/* add */
			float	var_pv,var_url,var_lrv;

		slen=60;

		IGNORE_ALL_RESPONSE_CODES();
		IGNORE_ALL_DEVICE_STATUS();
		XMTR_IGNORE_ALL_RESPONSE_CODES();
		XMTR_IGNORE_ALL_DEVICE_STATUS();

		get_dictionary_string(remove_loop_from_auto,disp_string,slen);
		ACKNOWLEDGE(disp_string);
		add_abort_method(return_to_normal);
		/** add remote seal check 99-09-25 *****/ 
			send(134,status);
			if(status[STATUS_RESPONSE_CODE]) {
				display_response_status(134,status[STATUS_RESPONSE_CODE]);
				DELAY(3,"Aborting method due to last error");
				process_abort();
			}
			send(178,status);
			if(status[STATUS_RESPONSE_CODE]) {
				display_response_status(178,status[STATUS_RESPONSE_CODE]);
				DELAY(3,"Aborting method due to last error");
				process_abort();
			}
				type_cd = ivar_value(type_code);
				height_ = fvar_value(height);
				if(((type_cd&0x30) == 0x20) && (height_!=0.0))
				{
					DELAY(5,"INVALID REQUEST");
					process_abort();
				}
		/** end of remote seal check **************/
		ACKNOWLEDGE("Apply LRV pressure.");
		get_dictionary_string(press_ok_when_pressure_stable,disp_string,slen);
		ACKNOWLEDGE(disp_string);
		/**** add input check ****/
			send(1,status);		/* Read primary value */
			if(status[STATUS_RESPONSE_CODE]) {
				display_response_status(1,status[STATUS_RESPONSE_CODE]);
				DELAY(3,"Aborting method due to last error");
				process_abort();
			}
			send(14,status);	/* Read PV sesor information */
			if(status[STATUS_RESPONSE_CODE]) {
				display_response_status(14,status[STATUS_RESPONSE_CODE]);
				DELAY(3,"Aborting method due to last error");
				process_abort();
			}
			send(15,status);		/* Read primary value */
			if(status[STATUS_RESPONSE_CODE]) {
				display_response_status(15,status[STATUS_RESPONSE_CODE]);
				DELAY(3,"Aborting method due to last error");
				process_abort();
			}
					var_pv=fvar_value(PV.DIGITAL_VALUE);
					var_url=fvar_value(PV.UPPER_SENSOR_LIMIT);
					var_lrv=fvar_value(PV.LOWER_RANGE_VALUE);
					var_pv=var_pv-var_lrv;
					var_pv=((var_pv)/(var_url));
					if((var_pv>0.05)||(var_pv<-0.05))
					{
						ACKNOWLEDGE("Excess 5% OK?");
					}
		/** end of input check ***********/
		get_dictionary_string(remove_pressure,disp_string,slen);

		send(131,status);
		DELAY(3,disp_string);
		if(status[STATUS_RESPONSE_CODE]) {
			display_response_status(131,status[STATUS_RESPONSE_CODE]);
			DELAY(3,"Aborting method due to last error");
			process_abort();
		}
		process_abort();
	}
}

METHOD correct_inp_urv_method
{
	LABEL "Correct Input URV";

	DEFINITION
	{
		char status[STATUS_SIZE];
		char disp_string[60];
		int slen;

			int	type_cd;	/* add */
			float	height_;	/* add */
			float	var_pv,var_url,var_lrv;

		slen=60;

		IGNORE_ALL_RESPONSE_CODES();
		IGNORE_ALL_DEVICE_STATUS();
		XMTR_IGNORE_ALL_RESPONSE_CODES();
		XMTR_IGNORE_ALL_DEVICE_STATUS();

		get_dictionary_string(remove_loop_from_auto,disp_string,slen);
		ACKNOWLEDGE(disp_string);
		add_abort_method(return_to_normal);
		/** add remote seal check 99-09-25 *****/ 
			send(134,status);
			if(status[STATUS_RESPONSE_CODE]) {
				display_response_status(134,status[STATUS_RESPONSE_CODE]);
				DELAY(3,"Aborting method due to last error");
				process_abort();
			}
			send(178,status);
			if(status[STATUS_RESPONSE_CODE]) {
				display_response_status(178,status[STATUS_RESPONSE_CODE]);
				DELAY(3,"Aborting method due to last error");
				process_abort();
			}
				type_cd = ivar_value(type_code);
				height_ = fvar_value(height);
				if(((type_cd&0x30) == 0x20) && (height_!=0.0))
				{
					DELAY(5,"INVALID REQUEST");
					process_abort();
				}
		/** end of remote seal check **************/
		ACKNOWLEDGE("Apply URV pressure.");
		get_dictionary_string(press_ok_when_pressure_stable,disp_string,slen);
		ACKNOWLEDGE(disp_string);
		get_dictionary_string(remove_pressure,disp_string,slen);

		send(130,status);
		DELAY(3,disp_string);
		if(status[STATUS_RESPONSE_CODE]) {
			display_response_status(130,status[STATUS_RESPONSE_CODE]);
			DELAY(3,"Aborting method due to last error");
			process_abort();
		}
		process_abort();
	}
}

METHOD reset_correct_method
{
	LABEL "Reset Corrects";

	HELP "Reset to corrections of the transmitter";

	DEFINITION
	{
		char status[STATUS_SIZE];
		char disp_string[60];
		int slen;

		slen=60;

		IGNORE_ALL_RESPONSE_CODES();
		IGNORE_ALL_DEVICE_STATUS();
		XMTR_IGNORE_ALL_RESPONSE_CODES();
		XMTR_IGNORE_ALL_DEVICE_STATUS();

		get_dictionary_string(remove_loop_from_auto,disp_string,slen);
		ACKNOWLEDGE(disp_string);
		add_abort_method(return_to_normal);
		ACKNOWLEDGE("About to Reset corrects");

		send(133,status);
		DELAY(3,"Reset corrects in progress please wait");
		if(status[STATUS_RESPONSE_CODE]) {
			display_response_status(133,status[STATUS_RESPONSE_CODE]);
			DELAY(3,"Aborting method due to last error");
			process_abort();
		}
		ACKNOWLEDGE("Reset corrects OK");
		process_abort();
	}
}


METHOD set_output_method
{
	LABEL "Set Output";

	DEFINITION
	{
		char status[STATUS_SIZE];
		char disp_string[60];
		int slen;
		int choice;
		float set_val, pv_range, pv_val, pv_lrv, pv_urv, new_lrv;
		int pv_xfer;

		slen=60;
		choice=0;

		IGNORE_ALL_RESPONSE_CODES();
		IGNORE_ALL_DEVICE_STATUS();
		XMTR_IGNORE_ALL_RESPONSE_CODES();
		XMTR_IGNORE_ALL_DEVICE_STATUS();

		/** add K.K */
		send(15,status);
		if(status[STATUS_RESPONSE_CODE]) {
			display_response_status(15,status[STATUS_RESPONSE_CODE]);
			DELAY(3,"Aborting method due to last error");
			process_abort();
		}
		pv_xfer = ivar_value(PV.TRANSFER_FUNCTION);

		if (pv_xfer != 0x00) {			/* SQRT */

			ACKNOWLEDGE("Conform is not LINEAR");
			process_abort();
		}

		get_dictionary_string(remove_loop_from_auto,disp_string,slen);
		ACKNOWLEDGE(disp_string);
		add_abort_method(return_to_normal);

		do {
			/* GET_LOCAL_VAR_VALUE("Enter new set output", set_val); */
			GET_DEV_VAR_VALUE("Enter new set output", set_output_value);
			set_val = fvar_value(set_output_value);
			if ((set_val >= 0.0) && (set_val <= 100.0)) {
				choice=1;
			} else {
				DELAY(2,"Value out of range");
			}
		} while(choice == 0);
		ACKNOWLEDGE("About to Set output");

		send(1,status);
		if(status[STATUS_RESPONSE_CODE]) {
			display_response_status(1,status[STATUS_RESPONSE_CODE]);
			DELAY(3,"Aborting method due to last error");
			process_abort();
		}
		send(2,status);
		if(status[STATUS_RESPONSE_CODE]) {
			display_response_status(2,status[STATUS_RESPONSE_CODE]);
			DELAY(3,"Aborting method due to last error");
			process_abort();
		}

		pv_range = fvar_value(PV.PERCENT_RANGE);
		pv_val = fvar_value(PV.DIGITAL_VALUE);
		pv_lrv = fvar_value(PV.LOWER_RANGE_VALUE);
		pv_urv = fvar_value(PV.UPPER_RANGE_VALUE);

		if ((pv_range < -199.96) || (pv_range > 199.96)) {
			new_lrv = pv_val - ((pv_urv - pv_lrv) * set_val / 100.0);
			assign_float(PV.LOWER_RANGE_VALUE, new_lrv);
			assign_float(PV.UPPER_RANGE_VALUE, new_lrv + (pv_urv - pv_lrv));
		} else {
			new_lrv = (pv_range - set_val) * (pv_urv - pv_lrv) / 100.0 + pv_lrv;
			assign_float(PV.LOWER_RANGE_VALUE, new_lrv);
			assign_float(PV.UPPER_RANGE_VALUE, new_lrv + (pv_urv - pv_lrv));
		}

		send(35,status);
		if(status[STATUS_RESPONSE_CODE]) {
			display_response_status(35,status[STATUS_RESPONSE_CODE]);
			DELAY(3,"Aborting method due to last error");
			process_abort();
		}
		process_abort();
	}
}

METHOD display_type_method
{
	LABEL "Display Type";

	DEFINITION
	{
		char status[STATUS_SIZE];
		char disp_string[60];
		int slen;
		int choice;
		int type_cd, pv_xfer, dsp_typ;

		slen=60;
		choice=0;

		IGNORE_ALL_RESPONSE_CODES();
		IGNORE_ALL_DEVICE_STATUS();
		XMTR_IGNORE_ALL_RESPONSE_CODES();
		XMTR_IGNORE_ALL_DEVICE_STATUS();

		send(15,status);
		if(status[STATUS_RESPONSE_CODE]) {
			display_response_status(15,status[STATUS_RESPONSE_CODE]);
			DELAY(3,"Aborting method due to last error");
			process_abort();
		}
		send(180,status);
		if(status[STATUS_RESPONSE_CODE]) {
			display_response_status(180,status[STATUS_RESPONSE_CODE]);
			DELAY(3,"Aborting method due to last error");
			process_abort();
		}

		type_cd = ivar_value(type_code);
		pv_xfer = ivar_value(PV.TRANSFER_FUNCTION);
		dsp_typ = ivar_value(display_type);

		if ((type_cd & 0x80) == 0x80) {
			if (pv_xfer == 0x00) {			/* Linear */

				switch(dsp_typ) {
				case 27:
					choice = SELECT_FROM_LIST("Display type\n E.UNIT (Linear)", DISP_TYP_LIN);
					switch(choice) {
					case 0:
						assign_int(display_type, 29);
						break;
					case 1:
						assign_int(display_type, 27);
						break;
					case 2:
						assign_int(display_type, 255);
						break;
					case 3:
						assign_int(display_type, 253);
						break;
					}
					break;

				case 29:
					choice = SELECT_FROM_LIST("Display type\n %      (Linear)", DISP_TYP_LIN);
					switch(choice) {
					case 0:
						assign_int(display_type, 29);
						break;
					case 1:
						assign_int(display_type, 27);
						break;
					case 2:
						assign_int(display_type, 255);
						break;
					case 3:
						assign_int(display_type, 253);
						break;
					}
					break;

				case 253:
					choice = SELECT_FROM_LIST("Display type\n E.UNIT (Dsp Flow)", DISP_TYP_LIN);
					switch(choice) {
					case 0:
						assign_int(display_type, 29);
						break;
					case 1:
						assign_int(display_type, 27);
						break;
					case 2:
						assign_int(display_type, 255);
						break;
					case 3:
						assign_int(display_type, 253);
						break;
					}
					break;

				case 255:
					choice = SELECT_FROM_LIST("Display type\n %      (Dsp Flow)", DISP_TYP_LIN);
					switch(choice) {
					case 0:
						assign_int(display_type, 29);
						break;
					case 1:
						assign_int(display_type, 27);
						break;
					case 2:
						assign_int(display_type, 255);
						break;
					case 3:
						assign_int(display_type, 253);
						break;
					}
					break;

				default:
					choice = SELECT_FROM_LIST("Display type\n Unknown enumerated", DISP_TYP_LIN);
					switch(choice) {
					case 0:
						assign_int(display_type, 29);
						break;
					case 1:
						assign_int(display_type, 27);
						break;
					case 2:
						assign_int(display_type, 255);
						break;
					case 3:
						assign_int(display_type, 253);
						break;
					}
					break;
				}

			} else {						/* Square Root */

				switch(dsp_typ) {
				case 27:
					choice = SELECT_FROM_LIST("Display type\n E.UNIT (Flow)", DISP_TYP_SQR);
					switch(choice) {
					case 0:
						assign_int(display_type, 29);
						break;
					case 1:
						assign_int(display_type, 27);
						break;
					}
					break;

				case 29:
					choice = SELECT_FROM_LIST("Display type\n %      (Flow)", DISP_TYP_SQR);
					switch(choice) {
					case 0:
						assign_int(display_type, 29);
						break;
					case 1:
						assign_int(display_type, 27);
						break;
					}
					break;

				case 253:
					choice = SELECT_FROM_LIST("Display type\n E.UNIT (Flow)", DISP_TYP_SQR);
					switch(choice) {
					case 0:
						assign_int(display_type, 255);
						break;
					case 1:
						assign_int(display_type, 253);
						break;
					}
					break;

				case 255:
					choice = SELECT_FROM_LIST("Display type\n %      (Flow)", DISP_TYP_SQR);
					switch(choice) {
					case 0:
						assign_int(display_type, 255);
						break;
					case 1:
						assign_int(display_type, 253);
						break;
					}
					break;

				default:
					choice = SELECT_FROM_LIST("Display type\n Unknown enumerated", DISP_TYP_SQR);
					switch(choice) {
					case 0:
						assign_int(display_type, 29);
						break;
					case 1:
						assign_int(display_type, 27);
						break;
					}
					break;
				}
			}
			ACKNOWLEDGE("Write display type");
			send(181,status);
			if(status[STATUS_RESPONSE_CODE]) {
				display_response_status(181,status[STATUS_RESPONSE_CODE]);
				DELAY(3,"Aborting method due to last error");
				process_abort();
			}
		} else {
			ACKNOWLEDGE("Device is not digital meter");
		}
		process_abort();
	}
}

METHOD cutoff_mode_method
{
	LABEL "Cutoff Mode";

	VALIDITY
		IF (input_transfer_function == 0x00){
			FALSE;
		} ELSE {
			TRUE;
		}

	DEFINITION
	{
		char status[STATUS_SIZE];
		char disp_string[60];
		int slen;
		int choice;
		int pv_xfer, cof_mod;

		slen=60;
		choice=0;

		IGNORE_ALL_RESPONSE_CODES();
		IGNORE_ALL_DEVICE_STATUS();
		XMTR_IGNORE_ALL_RESPONSE_CODES();
		XMTR_IGNORE_ALL_DEVICE_STATUS();

		send(15,status);
		if(status[STATUS_RESPONSE_CODE]) {
			display_response_status(15,status[STATUS_RESPONSE_CODE]);
			DELAY(3,"Aborting method due to last error");
			process_abort();
		}
		send(176,status);
		if(status[STATUS_RESPONSE_CODE]) {
			display_response_status(176,status[STATUS_RESPONSE_CODE]);
			DELAY(3,"Aborting method due to last error");
			process_abort();
		}

		pv_xfer = ivar_value(PV.TRANSFER_FUNCTION);
		cof_mod = ivar_value(cutoff_mode);

		if (pv_xfer == 0x00) {			/* Linear */

			ACKNOWLEDGE("Conform is Linear");
			process_abort();

		} else {						/* Square Root */

			switch(cof_mod) {
			case 0xFF:
				choice = SELECT_FROM_LIST("Cutoff mode\n CUT-OFF: DEFAULT", CUT_MOD_SQR);
				switch(choice) {
				case 0:
					assign_int(cutoff_mode, 0xFF);
					break;
				case 1:
					assign_int(cutoff_mode, 0x01);
					break;
				case 2:
					assign_int(cutoff_mode, 0x03);
					break;
				case 3:
					assign_int(cutoff_mode, 0x00);
					break;
				case 4:
					assign_int(cutoff_mode, 0x02);
					break;
				}
				break;

			case 0x01:
				choice = SELECT_FROM_LIST("Cutoff mode\n DRP:lin  MOD:def", CUT_MOD_SQR);
				switch(choice) {
				case 0:
					assign_int(cutoff_mode, 0xFF);
					break;
				case 1:
					assign_int(cutoff_mode, 0x01);
					break;
				case 2:
					assign_int(cutoff_mode, 0x03);
					break;
				case 3:
					assign_int(cutoff_mode, 0x00);
					break;
				case 4:
					assign_int(cutoff_mode, 0x02);
					break;
				}
				break;

			case 0x03:
				choice = SELECT_FROM_LIST("Cutoff mode\n DRP:lin  MOD:exp", CUT_MOD_SQR);
				switch(choice) {
				case 0:
					assign_int(cutoff_mode, 0xFF);
					break;
				case 1:
					assign_int(cutoff_mode, 0x01);
					break;
				case 2:
					assign_int(cutoff_mode, 0x03);
					break;
				case 3:
					assign_int(cutoff_mode, 0x00);
					break;
				case 4:
					assign_int(cutoff_mode, 0x02);
					break;
				}
				break;

			case 0x00:
				choice = SELECT_FROM_LIST("Cutoff mode\n DRP:zero MOD:def", CUT_MOD_SQR);
				switch(choice) {
				case 0:
					assign_int(cutoff_mode, 0xFF);
					break;
				case 1:
					assign_int(cutoff_mode, 0x01);
					break;
				case 2:
					assign_int(cutoff_mode, 0x03);
					break;
				case 3:
					assign_int(cutoff_mode, 0x00);
					break;
				case 4:
					assign_int(cutoff_mode, 0x02);
					break;
				}
				break;

			case 0x02:
				choice = SELECT_FROM_LIST("Cutoff mode\n DRP:zero MOD:exp", CUT_MOD_SQR);
				switch(choice) {
				case 0:
					assign_int(cutoff_mode, 0xFF);
					break;
				case 1:
					assign_int(cutoff_mode, 0x01);
					break;
				case 2:
					assign_int(cutoff_mode, 0x03);
					break;
				case 3:
					assign_int(cutoff_mode, 0x00);
					break;
				case 4:
					assign_int(cutoff_mode, 0x02);
					break;
				}
				break;

			default:
				choice = SELECT_FROM_LIST("Cutoff mode\n Unknown enumerated", CUT_MOD_SQR);
				switch(choice) {
				case 0:
					assign_int(cutoff_mode, 0xFF);
					break;
				case 1:
					assign_int(cutoff_mode, 0x01);
					break;
				case 2:
					assign_int(cutoff_mode, 0x03);
					break;
				case 3:
					assign_int(cutoff_mode, 0x00);
					break;
				case 4:
					assign_int(cutoff_mode, 0x02);
					break;
				}
				break;
			}

		}
		ACKNOWLEDGE("Write cutoff mode");
		send(177,status);
		if(status[STATUS_RESPONSE_CODE]) {
			display_response_status(177,status[STATUS_RESPONSE_CODE]);
			DELAY(3,"Aborting method due to last error");
			process_abort();
		}
		process_abort();
	}
}

METHOD	self_test
{
	LABEL "Status";		/* change "SelfTest" to "Status" 99-11-04 */
	CLASS CORRECTION;           
	DEFINITION
	{
		char status[3];
		char xmtr_status[25];
		long x;

		IGNORE_ALL_RESPONSE_CODES();
		IGNORE_ALL_DEVICE_STATUS();
		XMTR_IGNORE_ALL_RESPONSE_CODES();
		XMTR_IGNORE_ALL_DEVICE_STATUS();

			get_more_status(status,xmtr_status);

		if ( xmtr_status[0] || xmtr_status[1] || xmtr_status[2] || xmtr_status[3] ) {
			for ( x=1; x < 0x100; x <<= 1) {
				if ( xmtr_status[0] & x )
					display_xmtr_status(xmtr_specific_status_0, x);
			}
			for ( x=1; x < 0x100; x <<= 1) {
				if ( xmtr_status[1] & x )
					display_xmtr_status(xmtr_specific_status_1, x);
			}
			for ( x=1; x < 0x100; x <<= 1) {
				if ( xmtr_status[2] & x )
					display_xmtr_status(xmtr_specific_status_2, x);
			}
			for ( x=1; x < 0x100; x <<= 1) {
				if ( xmtr_status[3] & x )
					display_xmtr_status(xmtr_specific_status_3, x);
			}
		}
		else {
			ACKNOWLEDGE("STATUS CHECK = OK");
		}
		process_abort();		/* this will call return_to_normal */
	}
}	

#if FACTORY_MENU
METHOD	auto_set
{
	LABEL "Final Setup";
	CLASS CORRECTION;           
	DEFINITION
	{

				char status[3];
				char disp_string1[60];
				int slen1;

				slen1 =60;

				IGNORE_ALL_RESPONSE_CODES();
				XMTR_IGNORE_ALL_RESPONSE_CODES();
				IGNORE_ALL_DEVICE_STATUS();
				XMTR_IGNORE_ALL_DEVICE_STATUS();

		/* copy sensor_serial_number to final_assembly_number */
		PUT_MESSAGE("STATE 1:\n Write final assembly number");
		vassign(final_assembly_number,sensor_serial_number);
		send(19,status);

		/* disable de communication */
		PUT_MESSAGE("STATE 2:\n Disable DE communication");
		assign_int(conf_de_type,1);
		send(185,status);
		


		/* burn eeprom */
		PUT_MESSAGE("STATE 3:\n Update EEPROM");
				assign_int(eeprom_select,0);
				/* 
				get_dictionary_string(making_changes_permanent,disp_string1,slen1);
				DELAY(3,disp_string1);
				*/
				send(39,status);
				if ( status[STATUS_RESPONSE_CODE] ) {
					   display_response_status(39,status[STATUS_RESPONSE_CODE]);
						get_dictionary_string(previous_err_seen_brn_eeprom,disp_string1,slen1);
					   ACKNOWLEDGE(disp_string1);
				}

		/* reset config change flag */
		PUT_MESSAGE("STATE 4:\n RESET CONFIG CHANGE FLAG");
		send_command(38);	/* Reset Config Change Flag */

		ACKNOWLEDGE("STATE 5:\n Done\n Press OK");

		process_abort();		/* this will call return_to_normal */
	}
}
#endif

/********************************************************************
 * ypress.ddl End of List
 ********************************************************************/