fix attempt at full set of device functions

11 files changed, 4492 insertions, 270 deletions

diff --git a/bus.h b/bus.h
index d9ec330..e8bfa3a 100644
--- a/bus.h
+++ b/bus.h
@@ -10,6 +10,13 @@
 
 #include <stdint.h>
 
+#define out_DATA_LINE 0         /* out data signaled on 0 output of decoder */
+#define out_CLOCK_LINE 1        /* out clock signaled on 1 output of decoder */
+#define out_STROBE_LINE 2       /* out latch strobe on 2 output of decoder */
+#define O_GATE 3                /* gates output */
+#define OUTPUT_RELAY 4          /* output enable/disable relay */
+#define PW_ENABLE 5             /* TTL enable/disable output */
+
 #define GPIOPIN0BASE 0
 #define GPIOPIN1BASE 0
 #define GPIOPIN2BASE 0
diff --git a/device-functions.c b/device-functions.c
index 5f3ebc4..002bfe8 100644
--- a/device-functions.c
+++ b/device-functions.c
@@ -1,14 +1,15 @@
 #include "device-functions.h"
+#include "dummy_functions.h"
 #include "globals.h"
 #include "version.h"
 #include "error_utils.h"
+#include "i2c.h"
+#include "bus.h"
+#include "lcd.h"
+#include <math.h>
 #include <glib.h>
 
 
-/*** BeginHeader idn_string */
-void idn_string(gchar** response);
-/*** EndHeader */
-/*----------------------------------------------------------------------------------------------------------*/
 void idn_string(gchar** response)
 {
 	*response = g_strdup_printf ("AVTECH ELECTROSYSTEMS,%s,%s,%s",
@@ -18,41 +19,11 @@ void idn_string(gchar** response)
 }
 
 
-/*----------------------------------------------------------------------------------------------------------*/
-int Set_frequency(int check_possible_only,int word_override,int range_override,int channel,float set_freq)
-{
-	// keep, but ignore, the first 3 parameters for now
-
-	// all this does right now is check the frequency range,
-	// and store the set value.
-
-	/* abandon if high channel selected by user but not enabled by firmware */
-	if (channel && !globals.Flash.ChanKey_frequency) {
-		return InvalidChannel;
-	}
-
-        if (!check_possible_only) {
-		int i, check_valid;
-                for (i=0; i<max_channels; ++i) {
-                        TestState[i]=globals.ChannelState[i];
-                }
-                TestState[channel].frequency=set_freq;
-                if ((check_valid=Error_check(TestState))) {
-                        return check_valid;
-                }
-        }
-
-	globals.ChannelState[channel].frequency=set_freq;
-
-	return OK;
-}
-
-
 void Main_Rst (void)
 {
 	int i;
 
-	globals.extended_ampl_min_max=NO;
+	globals.Flags.extended_ampl_min_max=NO;
 
 	// go backwards, so channel 0 overrides everything
 	for (i=globals.Flash.channels-1; i>=0; --i) {
@@ -99,55 +70,4280 @@ void Main_Rst (void)
 		globals.ChannelState[i].vlogic = 0.0;
 		globals.ChannelState[i].slew = globals.Flash.min_slew[i];
 
-		globals.do_check_settings=NO;   /* don't check for conflicting settings */
-		/* FIXME - implement Set_* functions!
-				Set_Pw(0,0,0,i,globals.ChannelState[i].pw,0);
-
-				Set_Route(i,ROUTE_PRIMARY,globals.ChannelState[i].route_primary);
-				Set_Route(i,ROUTE_SECONDARY,globals.ChannelState[i].route_secondary);
-
-				Set_frequency(0,0,0,i,globals.ChannelState[i].frequency);
-				Set_Delay(0,0,0,i,globals.ChannelState[i].delay);
-				Set_Double(i,globals.ChannelState[i].double_pulse);
-				Set_Pwmode(i,globals.ChannelState[i].ab_mode);
-				Set_Func(i,globals.ChannelState[i].func_mode);
-				Set_Pol(i,globals.ChannelState[i].polarity);
-				Set_Gate_Sync(i,globals.ChannelState[i].gate_type);
-				Set_Gate_Level(i,globals.ChannelState[i].gate_level);
-				Set_EA(i,globals.ChannelState[i].amp_mode);
-				Set_EO(i,globals.ChannelState[i].os_mode);
-				if (globals.Flash.switchable_zout[i]) {
-					Set_zout(i,globals.ChannelState[i].zout,1);
+		globals.Flags.do_check_settings=NO;   /* don't check for conflicting settings */
+		Set_Pw(0,0,0,i,globals.ChannelState[i].pw,0);
+
+		Set_Route(i,ROUTE_PRIMARY,globals.ChannelState[i].route_primary);
+		Set_Route(i,ROUTE_SECONDARY,globals.ChannelState[i].route_secondary);
+
+		Set_frequency(0,0,0,i,globals.ChannelState[i].frequency);
+		Set_Delay(0,0,0,i,globals.ChannelState[i].delay);
+		Set_Double(i,globals.ChannelState[i].double_pulse);
+		Set_Pwmode(i,globals.ChannelState[i].ab_mode);
+		Set_Func(i,globals.ChannelState[i].func_mode);
+		Set_Pol(i,globals.ChannelState[i].polarity);
+		Set_Gate_Sync(i,globals.ChannelState[i].gate_type);
+		Set_Gate_Level(i,globals.ChannelState[i].gate_level);
+		Set_EA(i,globals.ChannelState[i].amp_mode);
+		Set_EO(i,globals.ChannelState[i].os_mode);
+		if (globals.Flash.switchable_zout[i]) {
+			Set_zout(i,globals.ChannelState[i].zout,1);
+		}
+
+		Set_Load(i,globals.ChannelState[i].load_type);
+		Set_Logic_Level(i,globals.ChannelState[i].logic_level);
+		Set_rise_time(0,0,0,i,globals.ChannelState[i].rise_time);
+		Set_slew(0,0,0,i,globals.ChannelState[i].slew);
+		Set_current_limit(0,i,globals.ChannelState[i].soft_current_limit);
+
+		if (globals.Flash.max_burst_count[i]>1) {
+			Set_Burst_Count(i,globals.ChannelState[i].burst_count,globals.ChannelState[i].burst_time);
+		}
+
+		Set_Trig_Source(i,globals.ChannelState[i].trigger_source);
+
+		Set_Amplitude(0,0,0,0,0,0,i,globals.ChannelState[i].amplitude,0);
+		Set_Offset(0,0,0,0,i,globals.ChannelState[i].offset);
+		Set_Output_State(i,globals.ChannelState[i].output_state);
+
+		Set_current_limit(0,i,globals.ChannelState[i].soft_current_limit);
+
+		Set_avrq_ampl(0,0,0,2,globals.ChannelState[i].vcc1);
+		Set_avrq_ampl(0,0,0,3,globals.ChannelState[i].vcc2);
+		Set_avrq_ampl(0,0,0,4,globals.ChannelState[i].vlogic);
+		globals.Flags.do_check_settings=YES;  /* check for conflicting settings */
+	}
+
+	// establishes min/max values for queries, but reports no errors
+	Error_check(globals.ChannelState);
+	globals.Changes.update_whole_main_menu=YES;
+
+	Ctrl_PRF_Limiter(1);
+
+	globals.Timers.normal_relay_bounce_time_in_milliseconds=1.0e3 * globals.Flash.relay_delay_in_sec;
+	globals.Timers.Relay_Switching_Delay_in_Milliseconds=globals.Timers.normal_relay_bounce_time_in_milliseconds;
+
+	// FIXME - check which misc globals should be reset here!
+
+	Menu_Clear_Buttons();
+}
+
+
+int set_dac(int dac, int word)
+{
+	/* allows dacs to be disabled (using dac=-1, for example) */
+	if ((dac >= 0) && (dac < 8)) {
+		globals.Registers.parallel_DAC_reg[dac]=word;
+	}
+}
+
+
+int Set_Amplitude(int check_possible_only,int pol_override,int override_on,int word_override,int range_override,
+                  int switch_range_only,int channel,float new_ampl,int called_from_set_pw)
+{
+	int word_out;	  /* what is sent to the DAC */
+	int relay_range,old_range,old_actual_pol;	  /* selects relay range */
+	int i;
+	int error_num;
+	int UseNegData;	/* if polarity is negative and separate piece-wise linear data is available for neg */
+	int point_found;
+	long mask;
+	int entry;
+	int status;
+	int actual_pol;
+
+	if (globals.Flash.enable_avrq_extra_ampls && channel) {
+		return Set_avrq_ampl(check_possible_only,word_override,range_override,channel,new_ampl);
+	}
+	if (globals.Flash.enable_avrq_extra_ampls && !channel) {
+		if ((new_ampl>=0.0) && (new_ampl<globals.Flash.ampl_zero_equiv[channel])) {
+			new_ampl=globals.Flash.ampl_zero_equiv[channel];
+		}
+		if ((new_ampl<0.0) && (new_ampl>-globals.Flash.ampl_zero_equiv[channel])) {
+			new_ampl=-globals.Flash.ampl_zero_equiv[channel];
+		}
+	}
+
+	if (!globals.Flash.voltage_enabled[channel] && !globals.Flash.current_enabled[channel]) {
+		return Unrecognized;
+	}
+
+	/* abandon if high channel selected by user but not enabled by firmware */
+	if (channel && !globals.Flash.ChanKey_amplitude) {
+		return InvalidChannel;
+	}
+
+	/* keep "-0" in negative area, to avoid using zeroed positive data */
+	if (	new_ampl<=smallest_allowed_number
+	                && new_ampl>=-smallest_allowed_number
+	                && !(globals.Flash.max_ampl[channel]>0) 	) {
+		new_ampl=-smallest_allowed_number;
+	}
+
+	/* Check for min abs value, step size */
+	if (globals.Flash.ampl_min_abs_value[channel] > 0.0) {
+		if ((new_ampl < 0.0) &&
+		                (new_ampl > -globals.Flash.ampl_min_abs_value[channel])) {
+			new_ampl = -globals.Flash.ampl_min_abs_value[channel];
+		}
+		if ((new_ampl >= 0.0) &&
+		                (new_ampl < globals.Flash.ampl_min_abs_value[channel])) {
+			new_ampl = globals.Flash.ampl_min_abs_value[channel];
+		}
+	}
+
+	/* For units with large amplitude step sizes (AVRQ-2-B-PN-EVE) */
+	if (globals.Flash.ampl_step_size[channel] > 0.0) {
+		new_ampl = ((int) (new_ampl / globals.Flash.ampl_step_size[channel])) * globals.Flash.ampl_step_size[channel];
+	}
+
+	if (!check_possible_only) {
+		for (i=0; i<max_channels; ++i) {
+			TestState[i]=globals.ChannelState[i];
+		}
+		TestState[channel].amplitude=new_ampl;
+		if ((error_num=Error_check(TestState))) {
+			return error_num;
+		}
+
+		/* determine the previous relay range */
+		Set_VI_Control(pwl_ampl_values,channel,globals.ChannelState[channel].amplitude,&point_found,
+		               &old_range,&UseNegData,&entry,&word_out,&old_actual_pol);
+	}
+
+	word_out = -1;
+	relay_range = 0;
+
+
+	/* find appropriate range/fine settings from piece-wise linear data in flash memory */
+
+	if (override_on) {
+		word_out=word_override;
+		relay_range=range_override;
+		actual_pol=pol_override;
+	} else {
+		/* set the amplitude controls now. */
+		if ((status=Set_VI_Control(pwl_ampl_values,channel,new_ampl,&point_found,
+		                           &relay_range,&UseNegData,&entry,&word_out,&actual_pol))) {
+			return status;
+		}
+	}
+
+	if (check_possible_only) {
+		if (point_found) {
+			return OK;
+		} else {
+			return CalibrationMinMaxError;
+		}
+	}
+
+	/* when switching to EA mode, need to switch range but keep DAC voltage zero */
+	if (switch_range_only) {
+		word_out=0;
+	}
+
+
+	/* if switching to a higher range with the same polarity, an extended delay may be needed to allow */
+	/* capacitor banks to discharge (1011, 1015 series especially) */
+	if ((relay_range>old_range) && (actual_pol==old_actual_pol) ) {
+		globals.Timers.Relay_Switching_Delay_in_Milliseconds=(long) (1000L * globals.Flash.extended_relay_delay_in_sec);
+	}
+
+
+	set_dac(globals.Flash.ampl_DAC[channel],word_out);
+
+
+	if (!channel) {
+		if (!globals.Flash.ampl_ranges_for_ch2_only) {
+			if ((globals.Flash.ChanKey_amplitude?globals.Flash.channels:1)<=1) {
+				/* for regular, single-channel units use AMPL RANGE pins 0-4 */
+				globals.Registers.shift_reg_out[3] = ((long)(globals.Registers.shift_reg_out[3] & 0xff07f)) | ((long)(1<<(relay_range+7)));
+			} else {
+				/* for CH1 of dual-channel units, use AMPL RANGE pin 0-2 for CH1, and 3-4 for CH2 */
+				globals.Registers.shift_reg_out[3] = ((long)(globals.Registers.shift_reg_out[3] & 0xffc7f)) | ((long)(1<<(relay_range+7)));
+			}
+		}
+
+		if (	(!actual_pol && globals.Flash.pol_relay_high_for_pos[channel])
+		                ||	(actual_pol && !globals.Flash.pol_relay_high_for_pos[channel])	) {
+			globals.Registers.shift_reg_out[3] |= (long)(0x02000);    /* set O.POL line high to switch pol relay to +, normally */
+		} else {
+			globals.Registers.shift_reg_out[3] &= (long)(0xfffff-0x02000);    /* set O.POL line low to switch pol relay to -, normally */
+		}
+
+	} else {
+
+		if (!globals.Flash.ampl_ranges_for_ch2_only) {
+			/* for CH2 of dual-channel units, use AMPL RANGE pin 2-3 */
+			globals.Registers.shift_reg_out[3] = ((long)(globals.Registers.shift_reg_out[3] & 0xff3ff)) | ((long)(1<<(relay_range+10)));
+		} else {
+			/* sometimes CH2 can use pins 0-4 */
+			globals.Registers.shift_reg_out[3] = ((long)(globals.Registers.shift_reg_out[3] & 0xff07f)) | ((long)(1<<(relay_range+7)));
+		}
+
+		mask = ((long)	1) << (globals.Flash.polarity_xtra_rly[channel]+14);
+		if (new_ampl<0.0) {
+			globals.Registers.shift_reg_out[2] &= (long)(0xfffff-mask);    /* set O.POL line low to switch pol relay to - */
+		} else {
+			globals.Registers.shift_reg_out[2] |= mask;    /* set O.POL line high to switch pol relay to + */
+		}
+	}
+
+	globals.Changes.update_amp=YES;
+
+	globals.ChannelState[channel].amplitude=new_ampl;
+	Set_Update_Chans();
+
+	if ((relay_range!=old_range) && (globals.ChannelState[channel].output_state==output_on)) {
+		globals.Flags.force_output_fully_off=YES;
+	}
+
+	/* update offset */
+	if (globals.Flash.ampl_os_ranges_related[channel] && !globals.Changes.update_os) {
+		Set_Offset(0,0,0,0,channel,globals.ChannelState[channel].offset);
+	}
+
+	/* ampl / pw tweaks */
+	if (!called_from_set_pw) {
+		Set_Pw(0,0,0,channel,globals.ChannelState[channel].pw,1);
+	}
+
+	/* ampl / delay tweaks */
+	Set_Delay(0,0,0,channel,globals.ChannelState[channel].delay);
+	Set_rise_time(0,0,0,channel,globals.ChannelState[channel].rise_time);
+
+	return OK;
+}
+
+
+int Set_Pw(int check_possible_only,int word_override,int range_override,int channel,float set_pw,int called_from_set_ampl)
+{
+	int word_out;  /* what is sent to the DAC */
+	int cap_range_control;
+	int point_found,relay_range,UseNegData,entry;
+	int i;
+	int check_valid;
+	int status,actual_pol;
+
+	/* abandon if high channel selected by user but not enabled by firmware */
+	if (channel && !globals.Flash.ChanKey_pw) {
+		return InvalidChannel;
+	}
+
+	/* for fixed PW units, set actual trigger PW to a reasonable minimum */
+	if (globals.Flash.fixed_pw[channel]
+	                && !check_possible_only
+	                && !word_override
+	                && !range_override
+	                && (globals.Flash.fully_programmed==All_Programmed)) {
+		set_pw=globals.Flash.min_pw[channel];
+	}
+
+	if (!check_possible_only) {
+		for (i=0; i<max_channels; ++i) {
+			TestState[i]=globals.ChannelState[i];
+		}
+		TestState[channel].pw=set_pw;
+		if ((check_valid=Error_check(TestState))) {
+			return check_valid;
+		}
+	}
+
+
+	/* find appropriate range/fine settings from piece-wise linear data in flash memory */
+	if (word_override) {
+		word_out=word_override;
+		relay_range=range_override;
+	} else {
+		/* set the pw controls now. */
+		if ((status=Set_VI_Control(pwl_pw_values,channel,set_pw,&point_found,
+		                           &relay_range,&UseNegData,&entry,&word_out,&actual_pol))) {
+			return status;
+		}
+	}
+
+
+	if (check_possible_only) {
+		if (point_found) {
+			return OK;
+		} else {
+			return CalibrationMinMaxError;
+		}
+	}
+
+	if (relay_range==0) {
+		cap_range_control=0;
+	} else {
+		cap_range_control = 1 << (relay_range-1);
+	}
+
+	/* if this is for CH1, use the standard output chain */
+	if (channel==0) {
+		if (globals.Flash.special_pw_range_minimum[channel] > 0.0) {
+			if (set_pw > globals.Flash.special_pw_range_minimum[channel]) {
+				globals.Registers.shift_reg_out[2] = ((long) (globals.Registers.shift_reg_out[2] & 0xeffff)) | (long) 1<<16;
+			} else {
+				globals.Registers.shift_reg_out[2] = ((long) (globals.Registers.shift_reg_out[2] & 0xeffff));
+			}
+		}
+
+		/* AVPP-style: lower PW range is voltage-controlled */
+		if (globals.Flash.volt_ctrl_pw[channel]) {
+			/* use DAC8420 to control PW in lowest PW range */
+			if (!relay_range) {
+				set_dac(globals.Flash.pw_dac[channel],word_out);
+				word_out=globals.Flash.fix_pw_dac_val[channel];
+				/* Set to fixed value. */
+				/* Isn't actually used to control PW in this mode, but may trigger following stages */
+
+				/* Zout hardware/software is used in AVPP to control PW ranges, not Zout */
+				Set_zout(channel,globals.Flash.zout_min[channel],0);
+			} else {
+				Set_zout(channel,globals.Flash.zout_max[channel],0);
+
+				/* In AVPP units, the bottom range is voltage-controlled, and the upper range(s) are
+					PWin=PWout. Therefore, shift the relay used by the upper ranges by one, to avoid
+					changing capacitors. */
+
+				if (relay_range==1) {
+					cap_range_control=0;
+				} else {
+					cap_range_control = 1 << (relay_range-2);
+				}
+			}
+		}
+
+		/* set fine controls */
+		set_dac(4,word_out);
+
+		/* set ranges */
+		globals.Registers.shift_reg_out[3] = ((long)(globals.Registers.shift_reg_out[3] & 0xfff80)) | ((long)(cap_range_control));
+	}
+
+	if (channel==1) {
+		/* if this is for CH2, use the standard 1021D dual-PW board, which has a PCF8574 for I/O, */
+		/* unless it is a voltage-controlled scheme like the ISI units. */
+		if (!globals.Flash.volt_ctrl_pw[channel]) {
+			control_pcb107(Second_PW_Port,globals.Flash.pw_dac[channel],word_out,relay_range);
+		} else {
+			/* ISI-style units have voltage-controlled PW and two ranges */
+			set_dac(globals.Flash.pw_dac[channel],word_out);
+
+			/* two ranges controlled by XTRA-RLY2 line */
+			globals.Registers.shift_reg_out[2] = ((long) (globals.Registers.shift_reg_out[2] & 0xeffff)) | (long) (((long) (relay_range&1))<<16);
+		}
+	}
+
+	/* need a center-frequency control voltage for monocycle generators, to space the + and - parts of the monocycle. */
+	/* use CH2 calibration to do this */
+	if (globals.Flash.is_monocycle[0] && channel==0) {
+		if ((status=Set_VI_Control(pwl_pw_values,1,set_pw,&point_found,
+		                           &relay_range,&UseNegData,&entry,&word_out,&actual_pol))) {
+			return status;
+		}
+		set_dac(globals.Flash.monocycle_dac[0],word_out);
+	}
+
+	if (set_pw!=globals.ChannelState[channel].pw) {
+		globals.Changes.update_pw=YES;
+	}
+
+	globals.ChannelState[channel].pw=set_pw;
+	Set_Update_Chans();
+
+	if (!called_from_set_ampl) {
+		Set_Amplitude(0,0,0,0,0,0,channel,globals.ChannelState[channel].amplitude,1);
+	}
+
+	return OK;
+}
+
+
+int Set_Offset(int check_possible_only,int override_on,int word_override,int range_override,int channel,float new_offset)
+{
+	int word_out;	  /* what is sent to the DAC */
+	int i;
+	int error_num;
+	int point_found;
+	int entry,dummy1,dummy2,dummy3;
+	int status,actual_pol;
+	int old_range,relay_range;
+
+	if (!globals.Flash.voltage_offset_enabled[channel] && !globals.Flash.current_offset_enabled[channel]) {
+		return Unrecognized;
+	}
+
+	/* abandon if high channel selected by user but not enabled by firmware */
+	if (channel && !globals.Flash.ChanKey_offset) {
+		return InvalidChannel;
+	}
+
+	word_out = -1;
+	point_found = 0;
+
+	if (!check_possible_only) {
+		for (i=0; i<max_channels; ++i) {
+			TestState[i]=globals.ChannelState[i];
+		}
+		TestState[channel].offset=new_offset;
+		if ((error_num=Error_check(TestState))) {
+			return error_num;
+		}
+
+		/* determine the previous relay range */
+		Set_VI_Control(pwl_os_values,channel,globals.ChannelState[channel].offset,&point_found,
+		               &old_range,&dummy1,&dummy2,&word_out,&dummy3);
+	}
+
+	if (override_on) {
+		relay_range=range_override;
+		word_out=word_override;
+	} else {
+		if ((status=Set_VI_Control(pwl_os_values,channel,new_offset,&point_found,
+		                           &relay_range,&dummy2,&entry,&word_out,&actual_pol))) {
+			return status;
+		}
+	}
+
+	if (check_possible_only) {
+		if (point_found) {
+			return OK;
+		} else {
+			return CalibrationMinMaxError;
+		}
+	}
+
+	set_dac(globals.Flash.os_DAC[channel],word_out);
+
+	globals.Changes.update_os=YES;
+
+	globals.ChannelState[channel].offset=new_offset;
+	Set_Update_Chans();
+
+	if ((relay_range!=old_range) && (globals.ChannelState[channel].output_state==output_on)) {
+		globals.Flags.force_output_fully_off=YES;
+	}
+
+	if ((globals.Flash.ampl_coupled_to_os[channel] || globals.Flash.ampl_os_ranges_related[channel]) && !globals.Changes.update_amp) {
+		Set_Amplitude(0,0,0,0,0,0,channel,globals.ChannelState[channel].amplitude,0);
+	}
+
+	/* change amplitude range if required for calibration */
+	if (override_on) {
+		Set_Amplitude(0,0,1,0,relay_range,0,channel,0.0,0);
+	}
+
+	/* increase PW if required to compensate for series output diode turn-on time */
+	if (globals.Flash.distort_Y[channel] != 0.0) {
+		Set_Pw(0,0,0,channel,globals.ChannelState[channel].pw,0);
+	}
+
+	return OK;
+}
+
+
+int Set_frequency(int check_possible_only,int word_override,int range_override,int channel,float set_freq)
+{
+	int cap_range_control;	/* what's actually sent to SR */
+	int i;
+	int check_valid;
+	float new_pw;
+	int status;
+	int point_found,relay_range,UseNegData,entry,actual_pol,old_range;
+	int word_out;	/* what is sent to the DAC */
+
+	/* abandon if high channel selected by user but not enabled by firmware */
+	if (channel && !globals.Flash.ChanKey_frequency) {
+		return InvalidChannel;
+	}
+
+	word_out = -1;
+
+	/* check new duty cycle, if pw fixed */
+	if (globals.ChannelState[channel].hold_setting==hold_width) {
+		new_pw=globals.ChannelState[channel].pw;
+	} else {
+		new_pw=globals.ChannelState[channel].pw * globals.ChannelState[channel].frequency/set_freq;
+	}
+
+	if (!check_possible_only) {
+		for (i=0; i<max_channels; ++i) {
+			TestState[i]=globals.ChannelState[i];
+		}
+		TestState[channel].pw=new_pw;
+		TestState[channel].frequency=set_freq;
+		if ((check_valid=Error_check(TestState))) {
+			return check_valid;
+		}
+
+		/* added Feb 23/05 */
+		/* determine the previous relay range */
+		Set_VI_Control(pwl_period_values,channel,1.0/globals.ChannelState[channel].frequency,&point_found,
+		               &old_range,&UseNegData,&entry,&word_out,&actual_pol);
+	}
+
+	/* find appropriate range/fine settings from piece-wise linear data in flash memory */
+	if (word_override) {
+		word_out=word_override;
+		relay_range=range_override;
+	} else {
+		/* set the amplitude controls now. */
+		if ((status=Set_VI_Control(pwl_period_values,channel,1.0/set_freq,&point_found,
+		                           &relay_range,&UseNegData,&entry,&word_out,&actual_pol))) {
+			return status;
+		}
+	}
+
+	if (check_possible_only) {
+		if (point_found) {
+			return OK;
+		} else {
+			return CalibrationMinMaxError;
+		}
+	}
+
+	if (globals.Flash.is_func_gen[channel]) {
+		set_dac(globals.Flash.freq_dac[channel],word_out);
+
+		/* Function generator PRF range controlled by XTRA-RLY 1-3 lines. */
+		/* Range=0 disables oscillator, for amplifier mode. */
+
+		if (globals.ChannelState[channel].func_mode==amp_mode_on) {
+			relay_range=0;
+		}
+
+		globals.Registers.shift_reg_out[2] = ((long) (globals.Registers.shift_reg_out[2] & 0xc7fff)) | (long) (((long) (relay_range & 0x07))<<15);
+
+		if ((relay_range!=old_range) && (globals.ChannelState[channel].output_state==output_on)) {
+			globals.Flags.force_output_fully_off=YES;
+		}
+	}
+
+	else {
+		if (relay_range==0) {
+			cap_range_control=0;
+		} else {
+			cap_range_control = 1 << (relay_range-1);
+		}
+
+		set_dac(globals.Flash.freq_dac[channel],word_out);
+		globals.Registers.shift_reg_out[2] = ((long)(globals.Registers.shift_reg_out[2] & 0xfff00)) | ((long)cap_range_control);		 /* bottom 8 bits of 20 bits */
+	}
+
+	if (set_freq!=globals.ChannelState[channel].frequency) {
+		globals.Changes.update_freq=YES;
+	}
+
+	globals.ChannelState[channel].frequency=set_freq;
+
+	Set_Pw(0,0,0,channel,new_pw,0);
+	Set_Update_Chans();
+
+	return OK;
+}
+
+
+int Set_Delay(int check_possible_only,int word_override,int range_override,int channel,float set_delay)
+{
+	int word_out;  /* what is sent to the DAC */
+	int cap_range_control;	/* what is actually sent to shift register */
+	float setting;
+	int i;
+	int check_valid;
+	int status;
+	int point_found,relay_range,UseNegData,entry,actual_pol;
+
+	/* abandon if high channel selected by user but not enabled by firmware */
+	if (channel && !globals.Flash.ChanKey_delay) {
+		return InvalidChannel;
+	}
+
+	if (!check_possible_only) {
+		for (i=0; i<max_channels; ++i) {
+			TestState[i]=globals.ChannelState[i];
+		}
+		TestState[channel].delay=set_delay;
+		if ((check_valid=Error_check(TestState))) {
+			return check_valid;
+		}
+	}
+
+	setting=set_delay-globals.Flash.propagation_delay[channel];
+
+	/* tweak depending on polarity */
+	if (globals.ChannelState[channel].amplitude<0.0) {
+		setting -= globals.Flash.delay_pol_tweak[channel][1];
+	} else {
+		setting -= globals.Flash.delay_pol_tweak[channel][0];
+	}
+
+	if (setting >= 0.0) {
+		Set_AdvDel(channel,to_Advance);
+	} else {
+		Set_AdvDel(channel,to_Delay);
+		setting *= -1;
+	}
+
+	setting=setting+globals.Flash.delay_shrink[channel];
+
+	/* protect against impossible settings during first turn-on */
+	if (setting<zero_equiv_timing) {
+		return HardwareError;
+	}
+
+	/* find appropriate range/fine settings from piece-wise linear data in flash memory */
+	if (word_override) {
+		word_out=word_override;
+		relay_range=range_override;
+	} else {
+		/* set the amplitude controls now. */
+		if ((status=Set_VI_Control(pwl_delay_values,channel,setting,&point_found,
+		                           &relay_range,&UseNegData,&entry,&word_out,&actual_pol))) {
+			return status;
+		}
+	}
+
+	if (check_possible_only) {
+		if (point_found) {
+			return OK;
+		} else {
+			return CalibrationMinMaxError;
+		}
+	}
+
+
+	if (relay_range==0) {
+		cap_range_control=0;
+	} else {
+		cap_range_control = 1 << (relay_range-1);
+	}
+
+	if (channel==0) {
+		set_dac(globals.Flash.delay_dac[channel],word_out);
+		globals.Registers.shift_reg_out[2] = ((long)(globals.Registers.shift_reg_out[2] & 0xf80ff)) | ((long)cap_range_control<<8);
+	}
+
+	if (channel==1) {
+		control_pcb107(Second_Dly_Port,globals.Flash.delay_dac[channel],word_out,relay_range);
+	}
+
+	if (set_delay!=globals.ChannelState[channel].delay) {
+		globals.Changes.update_delay=YES;
+	}
+
+	globals.ChannelState[channel].delay=set_delay;
+	Set_Update_Chans();
+
+	return OK;
+}
+
+
+int Set_Double(int channel,int new_setting)
+{
+	int error_num;
+	int i;
+
+	/* abandon if high channel selected by user but not enabled by firmware */
+	if (channel && !globals.Flash.ChanKey_double_pulse) {
+		return InvalidChannel;
+	}
+
+	for (i=0; i<max_channels; ++i) {
+		TestState[i]=globals.ChannelState[i];
+	}
+	TestState[channel].double_pulse=new_setting;
+	if ((error_num=Error_check(TestState))) {
+		return error_num;
+	}
+
+	if (new_setting == double_off) {
+		globals.Registers.shift_reg_out[0] &= 0xdf;	 /* turn double-pulse off */
+	} else {
+		globals.Registers.shift_reg_out[0] |= 0x20;		/* turn double-pulse on */
+	}
+
+	if (globals.ChannelState[channel].double_pulse!=new_setting) {
+		globals.Changes.update_delay=YES;
+	}
+
+	globals.ChannelState[channel].double_pulse=new_setting;
+	Set_Update_Chans();
+
+	return OK;
+}
+
+
+void Ctrl_PRF_Limiter(int enable)
+{
+	if (enable && globals.Flash.prf_limiter) {
+		globals.Registers.shift_reg_out[0] |= 0x80;	 /* turn prf limiter on */
+	} else {
+		globals.Registers.shift_reg_out[0] &= 0x7f;	 /* turn prf limiter off */
+	}
+
+	Main_update_shift_registers();
+
+	return;
+}
+
+
+int Set_Mux(int channel)
+{
+	int mux_out;
+
+	if (globals.ChannelState[channel].func_mode==dc_mode_on && globals.ChannelState[channel].polarity==pol_norm) {
+		mux_out=4;
+	} else if (globals.ChannelState[channel].func_mode==dc_mode_on && globals.ChannelState[channel].polarity!=pol_norm) {
+		mux_out=5;
+	} else if (globals.ChannelState[channel].ab_mode==pw_normal && globals.ChannelState[channel].polarity==pol_norm) {
+		mux_out=2;
+	} else if (globals.ChannelState[channel].ab_mode==pw_normal && globals.ChannelState[channel].polarity!=pol_norm) {
+		mux_out=3;
+	} else if (globals.ChannelState[channel].polarity==pol_norm) {
+		mux_out=0;
+	} else if (globals.ChannelState[channel].polarity!=pol_norm) {
+		mux_out=1;
+	}
+
+	if (globals.ChannelState[channel].test_delay_mode==YES) {
+		mux_out=6;
+	}
+
+	globals.Registers.shift_reg_out[1] = (globals.Registers.shift_reg_out[1] & 0xf8) + mux_out;
+}
+
+
+int Set_Func(int channel,int mode)
+{
+	int i;
+	int check_valid;
+
+	/* abandon if high channel selected by user but not enabled by firmware */
+	if (channel && !globals.Flash.ChanKey_func_mode) {
+		return InvalidChannel;
+	}
+
+	if ( (mode==dc_mode_on) && !globals.Flash.dc_mode_allowed[channel]) {
+		return SyntaxError;
+	}
+
+	/* some modes are for function generators only */
+	if ( ((mode==sin_mode_on) || (mode==squ_mode_on) || (mode==tri_mode_on) || (mode==amp_mode_on))
+	                && !globals.Flash.is_func_gen[channel]) {
+		return SyntaxError;
+	}
+
+	for (i=0; i<max_channels; ++i) {
+		TestState[i]=globals.ChannelState[i];
+	}
+	TestState[channel].func_mode=mode;
+	if ((check_valid=Error_check(TestState))) {
+		return check_valid;
+	}
+
+	if (globals.Flash.is_func_gen[channel]) {
+		/* set sin, tri, squ lines */
+		globals.Registers.shift_reg_out[3] = ((long) (globals.Registers.shift_reg_out[3] & 0x1ffff))
+		                                     | (long) (((long) (mode & 0x07))<<17);
+
+		/* set amplify mode line */
+
+		globals.Registers.shift_reg_out[2] = ((long) (globals.Registers.shift_reg_out[2] & 0xbffff))
+		                                     | (long) (((long) (mode & 0x08))	<< (globals.Flash.ext_amplify_xtra_rly[channel]+11));
+
+		globals.Changes.update_func=YES;
+	}
+
+
+	/* reset pulse width and delay to safe values */
+	if (globals.ChannelState[channel].func_mode!=mode) {
+		globals.ChannelState[channel].func_mode=mode;
+
+		Set_Pw(0,0,0,channel,globals.Flash.min_pw[channel],0);
+		Set_Delay(0,0,0,channel,globals.Flash.min_delay[channel]);
+
+		/* update frequency, to reset func gen control lines */
+		Set_frequency(0,0,0,channel,globals.ChannelState[channel].frequency);
+
+		Set_current_limit(0,channel,globals.ChannelState[channel].soft_current_limit);
+	}
+
+	Set_Mux(channel);
+	Set_Update_Chans();
+
+	return OK;
+}
+
+
+int Set_Pol(int channel,int mode)
+{
+	int error_num, i;
+
+	/* abandon if high channel selected by user but not enabled by firmware */
+	if (channel && !globals.Flash.ChanKey_polarity) {
+		return InvalidChannel;
+	}
+
+	/* duty cycle check */
+	for (i=0; i<max_channels; ++i) {
+		TestState[i]=globals.ChannelState[i];
+	}
+	TestState[channel].polarity=mode;
+	if ((error_num=Error_check(TestState))) {
+		return error_num;
+	}
+
+	if (globals.ChannelState[channel].polarity!=mode) {
+		globals.Changes.update_inv=YES;
+	}
+
+	globals.ChannelState[channel].polarity=mode;
+
+	Set_Mux(channel);
+	Set_Update_Chans();
+
+	return OK;
+}
+
+
+int Set_Hold(int channel,int mode)
+{
+	/* abandon if high channel selected by user but not enabled by firmware */
+	if (channel && !globals.Flash.ChanKey_hold_setting) {
+		return InvalidChannel;
+	}
+
+	if (globals.ChannelState[channel].hold_setting!=mode) {
+		globals.Changes.update_pw=YES;
+	}
+
+	globals.ChannelState[channel].hold_setting=mode;
+	Set_Update_Chans();
+
+	return OK;
+}
+
+
+int Set_Output_State(int channel,int mode)
+{
+	int i, error_num;
+
+	/* abandon if high channel selected by user but not enabled by firmware */
+	if (channel && !globals.Flash.ChanKey_output_state) {
+		return InvalidChannel;
+	}
+
+	for (i=0; i<max_channels; ++i) {
+		TestState[i]=globals.ChannelState[i];
+	}
+	TestState[channel].output_state=mode;
+	if ((error_num=Error_check(TestState))) {
+		return error_num;
+	}
+
+	/* suppress triggering during relay bounce */
+	/* set gate bit high, if not already high */
+
+	for (i=0; i<(globals.Flash.ChanKey_frequency?globals.Flash.channels:1); ++i)
+		if (globals.ChannelState[i].trigger_source!=source_hold) {
+			bus_setpin(O_GATE, 1);
+		}
+
+	if (mode==output_on || !globals.Flash.on_off_used) {
+		/* do not permit enabling of output during overload condition */
+		if ( (I2C_Read(PCF8574A+Button_Press_Port) & 0x40) == 0) {
+			return Overload_Detected;
+		}
+
+		bus_setpin(OUTPUT_RELAY, 1);	 /* turn output on */
+		bus_setpin(PW_ENABLE, 1);	  /* enable PW circuit */
+		globals.Timers.last_activity_at[channel] = sec_timer();
+	} else {
+		bus_setpin(PW_ENABLE, 0);	 /* disable PW circuit */
+		bus_setpin(OUTPUT_RELAY, 0);	 /* turn output off */
+		globals.Timers.last_activity_at[channel] = 0L;
+	}
+
+	if (globals.ChannelState[channel].output_state!=mode) {
+		globals.Changes.update_output=YES;
+	}
+
+	globals.ChannelState[channel].output_state=mode;
+	Set_Update_Chans();
+
+
+	/* keep trigger suppressed during output relay update */
+	/* trigger gate will be released at end of following Main_update_shift_registers(); */
+
+	return OK;
+}
+
+
+int Set_Trig_Source(int channel,int mode)
+{
+	int gate_mode;
+	int i;
+	int error_num;
+	int use_ab_mode;
+	int reset_freq;
+	float use_freq;
+
+	/* abandon if high channel selected by user but not enabled by firmware */
+	if (channel && !globals.Flash.ChanKey_trigger_source) {
+		return InvalidChannel;
+	}
+
+	use_ab_mode = globals.ChannelState[channel].ab_mode;
+	use_freq = globals.ChannelState[channel].frequency;
+	reset_freq = 0;
+
+	if (globals.ChannelState[channel].trigger_source!=mode) {
+		for (i=0; i<max_channels; ++i) {
+			TestState[i]=globals.ChannelState[i];
+		}
+		TestState[channel].trigger_source = mode;
+
+		if ((globals.ChannelState[channel].trigger_source != source_hold) && (mode != source_hold)) {
+			reset_freq = 1;
+			use_freq = globals.Flash.min_freq[channel];
+			use_ab_mode = pw_normal;
+		}
+
+		TestState[channel].ab_mode = use_ab_mode;
+		TestState[channel].frequency = use_freq;
+
+		if ((error_num=Error_check(TestState))) {
+			return error_num;
+		}
+
+		if (reset_freq) {
+			Set_frequency(0,0,0,channel,use_freq);
+			Set_Pwmode(channel,use_ab_mode);
+		}
+
+		globals.Changes.update_freq=YES;
+	}
+
+	globals.ChannelState[channel].trigger_source=mode;
+	Set_Update_Chans();
+
+
+	/* Function generator operate in the "external" mode only. The internal oscillator is never used. */
+	if (globals.Flash.is_func_gen[channel]) {
+		mode=source_external;
+	}
+
+
+	if (mode==source_internal) {
+		gate_mode=0;
+		/* frequency is automatically lowered if pw or delay have been changed to conflicting */
+		/* settings while in a non-internal mode */
+		globals.Registers.shift_reg_out[0] = (globals.Registers.shift_reg_out[0] & 0xe3) | 0;
+	} else if (mode==source_external) {
+		gate_mode=0;
+		globals.ChannelState[channel].hold_setting=hold_width;
+		globals.Registers.shift_reg_out[0] = (globals.Registers.shift_reg_out[0] & 0xe3) | 3<<2;
+	} else if (mode==source_manual) {
+		gate_mode=0;
+		globals.ChannelState[channel].hold_setting=hold_width;
+		globals.Registers.shift_reg_out[0] = (globals.Registers.shift_reg_out[0] & 0xe3) | 1<<2;
+	} else if (mode==source_hold) {
+		gate_mode=1;
+	} else if (mode==source_immediate) {
+		if (gate_mode==1) {
+			globals.Registers.shift_reg_out[0] = (globals.Registers.shift_reg_out[0] & 0xe3) | 4<<2;
+			Main_update_shift_registers();
+			gate_mode=0; /* allow triggering */
+			bus_setpin(O_GATE, gate_mode);
+			globals.Registers.shift_reg_out[0] = (globals.Registers.shift_reg_out[0] & 0xe3) | 7<<2;
+		} else {
+			globals.Registers.shift_reg_out[0] = (globals.Registers.shift_reg_out[0] & 0xe3) | 4<<2;
+			Main_update_shift_registers();
+			globals.Registers.shift_reg_out[0] = (globals.Registers.shift_reg_out[0] & 0xe3) | 7<<2;
+		}
+	}
+
+	Main_update_shift_registers();
+	bus_setpin(O_GATE, gate_mode);	/* change gate only after new source set */
+
+	return OK;
+}
+
+
+int Set_Gate_Sync(int channel,int mode)
+{
+	/* abandon if high channel selected by user but not enabled by firmware */
+	if (channel && !globals.Flash.ChanKey_gate_type) {
+		return InvalidChannel;
+	}
+
+	if (mode==gate_sync) {
+		globals.Registers.shift_reg_out[0] = (globals.Registers.shift_reg_out[0] & 0xfe) | 0;
+	} else {
+		globals.Registers.shift_reg_out[0] = (globals.Registers.shift_reg_out[0] & 0xfe) | 1;
+	}
+
+	if (globals.ChannelState[channel].gate_type!=mode) {
+		globals.Changes.update_gate=YES;
+	}
+
+	globals.ChannelState[channel].gate_type=mode;
+	Set_Update_Chans();
+
+	return OK;
+}
+
+
+int Set_Gate_Level(int channel,int mode)
+{
+	/* abandon if high channel selected by user but not enabled by firmware */
+	if (channel && !globals.Flash.ChanKey_gate_level) {
+		return InvalidChannel;
+	}
+
+	if (mode==0) {
+		globals.Registers.shift_reg_out[0] = (globals.Registers.shift_reg_out[0] & 0xfd) | 0x02;
+	} else {
+		globals.Registers.shift_reg_out[0] = (globals.Registers.shift_reg_out[0] & 0xfd) | 0;
+	}
+
+	if (globals.ChannelState[channel].gate_level!=mode) {
+		globals.Changes.update_gate=YES;
+	}
+
+	globals.ChannelState[channel].gate_level=mode;
+	Set_Update_Chans();
+
+	return OK;
+}
+
+
+int start_gate_override ()
+{
+	/* just set gate bit high, if not already high */
+	int i;
+	for (i=0; i<(globals.Flash.ChanKey_frequency?globals.Flash.channels:1); ++i)
+		if (globals.ChannelState[i].trigger_source!=source_hold) {
+			bus_setpin(O_GATE, 1);
+		}
+}
+
+
+int stop_gate_override ()
+{
+	/* release gate (if not in hold mode) */
+	int i;
+	for (i=0; i<(globals.Flash.ChanKey_frequency?globals.Flash.channels:1); ++i)
+		if (globals.ChannelState[i].trigger_source!=source_hold) {
+			bus_setpin(O_GATE, 0);
+		}
+}
+
+
+int Set_zout(int channel,int setting,int really_for_zout)
+{
+	int update_zout_slowly;
+
+	/* abandon if high channel selected by user but not enabled by firmware */
+	if (channel && !globals.Flash.ChanKey_zout) {
+		return InvalidChannel;
+	}
+
+	update_zout_slowly=NO;
+
+	/* The Zout hardware and software is controlled by PW commands in the AVPP. */
+	/* This mode is signalled by really_for_zout=0 */
+
+	/* first channel uses dedicated Zout line */
+	if (channel==0) {
+		if (setting!=globals.Flash.zout_max[channel]) {
+			globals.Registers.shift_reg_out[3] |= (long)0x01000;    /* power zout relay */
+		} else {
+			globals.Registers.shift_reg_out[3] &= (long)0xfefff;    /* de-power zout relay */
+		}
+	}
+
+	/* second channel uses dedicated xtra-rly2 line */
+	if (channel==1) {
+		if (setting!=globals.Flash.zout_max[channel]) {
+			globals.Registers.shift_reg_out[2] |= (long)0x10000;			/* power zout relay */
+		} else {
+			globals.Registers.shift_reg_out[2] &= (long)0xeffff;			/* de-power zout relay */
+		}
+	}
+
+	if (setting!=globals.ChannelState[channel].zout) {
+		globals.Changes.update_zout=YES;
+
+		/* allow extra time for cap banks to discharge if going from
+			50 Ohms to 2 Ohm Zout */
+		if (setting<globals.ChannelState[channel].zout) {
+			update_zout_slowly=YES;
+		}
+	}
+
+	globals.ChannelState[channel].zout=setting;
+	Set_Update_Chans();
+
+	/* Skip this stuff if this is actually for AVPP PW control */
+	if (really_for_zout) {
+		if (globals.Changes.update_zout) {
+			/* change of Zout may require change in amplitude controls */
+			Set_Amplitude(0,0,0,0,0,0,channel,globals.ChannelState[channel].amplitude,0);
+		}
+
+		if (update_zout_slowly) {
+			globals.Timers.Relay_Switching_Delay_in_Milliseconds=(long) (1000L * globals.Flash.extended_relay_delay_in_sec);
+		}
+	}
+
+	return OK;
+}
+
+
+int Set_Load(int channel, float value)
+{
+	int error_num;
+
+	/* abandon if high channel selected by user but not enabled by firmware */
+	if (channel && !globals.Flash.ChanKey_load_type) {
+		return InvalidChannel;
+	}
+
+	if (globals.Flash.enable_avrq_extra_ampls) {
+		return Set_avrq_res(0,0,0,channel,value);
+	}
+
+	/* duty cycle check */
+	int i;
+	for (i=0; i<max_channels; ++i) {
+		TestState[i]=globals.ChannelState[i];
+	}
+	TestState[channel].load_type=value;
+	if ((error_num=Error_check(TestState))) {
+		return error_num;
+	}
+
+	if (globals.ChannelState[channel].load_type!=value) {
+		globals.Changes.update_load=YES;
+	}
+
+	globals.ChannelState[channel].load_type=value;
+	Set_Update_Chans();
+
+	if (globals.Changes.update_load) {
+		/* change of load may require change in amplitude controls */
+		Set_Amplitude(0,0,0,0,0,0,channel,globals.ChannelState[channel].amplitude,0);
+	}
+
+	return OK;
+}
+
+
+int Set_EA(int channel,int mode)
+{
+	long amplify_mask, ea_mask;
+	char set_DAC_to_zero;
+
+	/* abandon if high channel selected by user but not enabled by firmware */
+	if (channel && !globals.Flash.ChanKey_amplitude) {
+		return InvalidChannel;
+	}
+
+	if (!(globals.Flash.ea_enabled[channel]) && (mode==amp_mode_ea) ) {
+		return SyntaxError;
+	}
+	if (!(globals.Flash.ext_amplify_enabled[channel]) && (mode==amp_mode_amplify) ) {
+		return SyntaxError;
+	}
+
+	set_DAC_to_zero=YES;
+	if (mode==amp_mode_amplify) {
+		set_DAC_to_zero=NO;
+	}
+
+	/* set to max amplitude range when switching from normal to EA or Ext Amplify */
+	if ( (globals.ChannelState[channel].amp_mode==amp_mode_normal) && (mode!=amp_mode_normal) ) {
+		if (globals.ChannelState[channel].amplitude<0.0)
+			Set_Amplitude(0,0,0,0,0,set_DAC_to_zero,channel,
+			              globals.ChannelState[channel].amplitude=globals.Flash.min_ampl[channel],0); /* most negative */
+		else
+			Set_Amplitude(0,0,0,0,0,set_DAC_to_zero,channel,
+			              globals.ChannelState[channel].amplitude=globals.Flash.max_ampl[channel],0); /* most positive */
+	}
+
+
+	/* protect when switching from EA or Ext Amplify back to normal */
+	if ( (globals.ChannelState[channel].amp_mode!=amp_mode_normal) && (mode==amp_mode_normal) ) {
+		if (globals.ChannelState[channel].amplitude<0.0) {
+			Set_Amplitude(0,0,0,0,0,0,channel,globals.ChannelState[channel].amplitude=-smallest_allowed_number,0);
+		} else {
+			Set_Amplitude(0,0,0,0,0,0,channel,globals.ChannelState[channel].amplitude=smallest_allowed_number,0);
+		}
+	}
+
+
+	if (globals.Flash.ea_enabled[channel]) {
+		int ea_reg;
+
+		if (!channel) {
+			ea_mask = 0x10000;
+			ea_reg = 3;
+		} else {
+			ea_mask = ((long)	1) << (globals.Flash.ea_xtra_rly[channel]+14);
+			ea_reg = 2;
+		}
+
+		if (mode==amp_mode_ea) {
+			globals.Registers.shift_reg_out[ea_reg] |= ea_mask;
+		} else {
+			globals.Registers.shift_reg_out[ea_reg] &= ((long)(0xfffff - ea_mask));
+		}
+	}
+
+
+	if (globals.Flash.ext_amplify_enabled[channel]) {
+		amplify_mask = ((long)	1) << (globals.Flash.ext_amplify_xtra_rly[channel]+14);
+
+		if (mode==amp_mode_amplify) {
+			globals.Registers.shift_reg_out[2] |= amplify_mask;
+		} else {
+			globals.Registers.shift_reg_out[2] &= ((long)(0xfffff - amplify_mask));
+		}
+	}
+
+
+	if (globals.ChannelState[channel].amp_mode!=mode) {
+		globals.Changes.update_amp=YES;
+	}
+
+	globals.ChannelState[channel].amp_mode=mode;
+	Set_Update_Chans();
+
+	return OK;
+}
+
+
+int Set_AdvDel(int channel,int setting)
+{
+	if (setting==to_Advance) {
+		globals.Registers.shift_reg_out[0] |= 64L;    /* turn advance on */
+	} else {
+		globals.Registers.shift_reg_out[0] &= 255L-64L;    /* turn delay on */
+	}
+
+	Set_Update_Chans();
+
+	return OK;
+}
+
+
+int Set_Pwmode(int channel,int mode)
+{
+	/* abandon if high channel selected by user but not enabled by firmware */
+	if (channel && !globals.Flash.ChanKey_pw) {
+		return InvalidChannel;
+	}
+
+	if (!(globals.Flash.ab_mode_allowed[channel]) && (mode==pw_in_out)) {
+		return SyntaxError;
+	}
+
+	if ((mode==pw_in_out) && (globals.ChannelState[channel].trigger_source!=source_external)) {
+		return AB_Mode_Error;
+	}
+
+	if (globals.ChannelState[channel].ab_mode!=mode) {
+		globals.Changes.update_pw=YES;
+	}
+
+	globals.ChannelState[channel].ab_mode=mode;
+
+	Set_Mux(0);
+	Set_Update_Chans();
+
+	return OK;
+}
+
+
+int Set_Update_Chans(void)
+{
+	int num_of_chan;
+
+	num_of_chan=globals.Flash.channels;
+	if (num_of_chan==0) {
+		num_of_chan=1;
+	}
+
+	if (num_of_chan>1) {
+		int i;
+		if (!globals.Flash.ChanKey_frequency) for (i=1; i<num_of_chan; ++i) {
+				globals.ChannelState[i].frequency=globals.ChannelState[0].frequency;
+			}
+		if (!globals.Flash.ChanKey_delay) for (i=1; i<num_of_chan; ++i) {
+				globals.ChannelState[i].delay=globals.ChannelState[0].delay;
+			}
+		if (!globals.Flash.ChanKey_pw) for (i=1; i<num_of_chan; ++i) {
+				globals.ChannelState[i].pw=globals.ChannelState[0].pw;
+			}
+		if (!globals.Flash.ChanKey_amplitude) for (i=1; i<num_of_chan; ++i) {
+				globals.ChannelState[i].amplitude=globals.ChannelState[0].amplitude;
+			}
+		if (!globals.Flash.ChanKey_offset) for (i=1; i<num_of_chan; ++i) {
+				globals.ChannelState[i].offset=globals.ChannelState[0].offset;
+			}
+
+		if (!globals.Flash.ChanKey_Curr_Mon_value) for (i=1; i<num_of_chan; ++i) {
+				globals.ChannelState[i].Curr_Mon_value=globals.ChannelState[0].Curr_Mon_value;
+			}
+		if (!globals.Flash.ChanKey_Curr_Mon_offset) for (i=1; i<num_of_chan; ++i) {
+				globals.ChannelState[i].Curr_Mon_offset=globals.ChannelState[0].Curr_Mon_offset;
+			}
+
+		if (!globals.Flash.ChanKey_zout) for (i=1; i<num_of_chan; ++i) {
+				globals.ChannelState[i].zout=globals.ChannelState[0].zout;
+			}
+		if (!globals.Flash.ChanKey_hold_setting) for (i=1; i<num_of_chan; ++i) {
+				globals.ChannelState[i].hold_setting=globals.ChannelState[0].hold_setting;
+			}
+		if (!globals.Flash.ChanKey_double_pulse) for (i=1; i<num_of_chan; ++i) {
+				globals.ChannelState[i].double_pulse=globals.ChannelState[0].double_pulse;
+			}
+		if (!globals.Flash.ChanKey_ab_mode) for (i=1; i<num_of_chan; ++i) {
+				globals.ChannelState[i].ab_mode=globals.ChannelState[0].ab_mode;
+			}
+		if (!globals.Flash.ChanKey_func_mode) for (i=1; i<num_of_chan; ++i) {
+				globals.ChannelState[i].func_mode=globals.ChannelState[0].func_mode;
+			}
+		if (!globals.Flash.ChanKey_polarity) for (i=1; i<num_of_chan; ++i) {
+				globals.ChannelState[i].polarity=globals.ChannelState[0].polarity;
+			}
+		if (!globals.Flash.ChanKey_output_state) for (i=1; i<num_of_chan; ++i) {
+				globals.ChannelState[i].output_state=globals.ChannelState[0].output_state;
+			}
+		if (!globals.Flash.ChanKey_gate_type) for (i=1; i<num_of_chan; ++i) {
+				globals.ChannelState[i].gate_type=globals.ChannelState[0].gate_type;
+			}
+		if (!globals.Flash.ChanKey_trigger_source) for (i=1; i<num_of_chan; ++i) {
+				globals.ChannelState[i].trigger_source=globals.ChannelState[0].trigger_source;
+			}
+		if (!globals.Flash.ChanKey_amp_mode) for (i=1; i<num_of_chan; ++i) {
+				globals.ChannelState[i].amp_mode=globals.ChannelState[0].amp_mode;
+			}
+		if (!globals.Flash.ChanKey_gate_level) for (i=1; i<num_of_chan; ++i) {
+				globals.ChannelState[i].gate_level=globals.ChannelState[0].gate_level;
+			}
+		if (!globals.Flash.ChanKey_load_type) for (i=1; i<num_of_chan; ++i) {
+				globals.ChannelState[i].load_type=globals.ChannelState[0].load_type;
+			}
+		if (!globals.Flash.ChanKey_test_delay_mode) for (i=1; i<num_of_chan; ++i) {
+				globals.ChannelState[i].test_delay_mode=globals.ChannelState[0].test_delay_mode;
+			}
+		if (!globals.Flash.ChanKey_os_mode) for (i=1; i<num_of_chan; ++i) {
+				globals.ChannelState[i].os_mode=globals.ChannelState[0].os_mode;
+			}
+		if (!globals.Flash.ChanKey_Burst_Count) for (i=1; i<num_of_chan; ++i) {
+				globals.ChannelState[i].burst_count=globals.ChannelState[0].burst_count;
+			}
+		if (!globals.Flash.ChanKey_Burst_Time) for (i=1; i<num_of_chan; ++i) {
+				globals.ChannelState[i].burst_time=globals.ChannelState[0].burst_time;
+			}
+		if (!globals.Flash.ChanKey_rise_time) for (i=1; i<num_of_chan; ++i) {
+				globals.ChannelState[i].rise_time=globals.ChannelState[0].rise_time;
+			}
+		if (!globals.Flash.ChanKey_slew) for (i=1; i<num_of_chan; ++i) {
+				globals.ChannelState[i].slew=globals.ChannelState[0].slew;
+			}
+
+		for (i=1; i<num_of_chan; ++i) {
+			globals.ChannelState[i].vcc1=globals.ChannelState[0].vcc1;
+			globals.ChannelState[i].vcc2=globals.ChannelState[0].vcc2;
+			globals.ChannelState[i].vlogic=globals.ChannelState[0].vlogic;
+		}
+
+	}
+
+	return OK;
+}
+
+
+int Set_Amp_Calib(int channel,float meas_ampl)
+{
+	float change_ratio;
+	int i,status;
+	int point_found,relay_range,UseNegData,entry,word_out,actual_pol;
+	int eprom_loc;
+
+	/* use for all channels */
+
+	/* get current range and polarity settings */
+	Set_VI_Control(pwl_ampl_values,channel,globals.ChannelState[channel].amplitude,&point_found,
+	               &relay_range,&UseNegData,&entry,&word_out,&actual_pol);
+
+	if (fabs(globals.ChannelState[channel].amplitude)<globals.Flash.ampl_zero_equiv[channel]) {
+		return NeedNonZeroAmpl;
+	}
+
+	change_ratio = meas_ampl/globals.ChannelState[channel].amplitude;
+
+	if (change_ratio>1.3 || change_ratio < 0.7) {
+		return CalibrationPercentError;
+	}
+
+	for (i=0; i<10; ++i)
+		globals.Flash.ampl_pwl_amp[channel][relay_range][UseNegData][i]=
+		        globals.Flash.ampl_pwl_amp[channel][relay_range][UseNegData][i]*change_ratio;
+
+
+	/* see if new data prevents min/max from being obtained */
+	status=Check_MinMax_Cal(channel,pwl_ampl_values);
+
+	if (status) {
+		/* revert to original calibration */
+		for (i=0; i<10; ++i)
+			globals.Flash.ampl_pwl_amp[channel][relay_range][UseNegData][i]=
+			        globals.Flash.ampl_pwl_amp[channel][relay_range][UseNegData][i]/change_ratio;
+	}
+
+	eprom_loc = (char *) &(globals.Flash.ampl_pwl_amp) - (char *) &(globals.Flash.flash_start);
+	writeUserBlock(eprom_loc,&globals.Flash.flash_start + eprom_loc,sizeof(globals.Flash.ampl_pwl_amp));
+
+	return status;
+}
+
+
+int Set_Mon_Calib(int channel,float meas_ampl)
+{
+	float change_ratio;
+	int point_found,relay_range,UseNegData,entry,word_out,actual_pol,eprom_loc;
+
+	/* use for all channels */
+
+	/* get current range and polarity settings */
+	Set_VI_Control(pwl_ampl_values,channel,globals.ChannelState[channel].amplitude,&point_found,
+	               &relay_range,&UseNegData,&entry,&word_out,&actual_pol);
+
+	if (fabs(globals.ChannelState[channel].Curr_Mon_value)< (5.0 * globals.Flash.monitor_step[channel])) {
+		return NeedNonZeroAmpl;
+	}
+
+	if (globals.Flash.sep_posneg_mon_ratio[channel] && globals.ChannelState[channel].amplitude<0.0) {
+		UseNegData=1;
+	} else {
+		UseNegData=0;
+	}
+
+	change_ratio = meas_ampl/globals.ChannelState[channel].Curr_Mon_value;
+
+	if (change_ratio>1.3 || change_ratio < 0.7) {
+		return CalibrationPercentError;
+	}
+
+	globals.Flash.mon_vi_ratio[channel][relay_range][UseNegData]=globals.Flash.mon_vi_ratio[channel][relay_range][UseNegData]/change_ratio;
+
+	eprom_loc = (char *) &(globals.Flash.mon_vi_ratio) - (char *) &(globals.Flash.flash_start);
+	writeUserBlock(eprom_loc,&globals.Flash.flash_start + eprom_loc,sizeof(globals.Flash.mon_vi_ratio));
+
+	return OK;
+}
+
+
+int Set_Logic_Level(int channel,int mode)
+{
+	/* first channel uses dedicated Zout line */
+	if (channel==0) {
+		if (mode==logic_ecl) {
+			globals.Registers.shift_reg_out[3] |= (long)0x04000;    /* power zout relay */
+		} else {
+			globals.Registers.shift_reg_out[3] &= (long)0xfbfff;    /* de-power zout relay */
+		}
+	}
+
+	/* second channel uses xtra-rly3 */
+	if (channel==1) {
+		if (mode==logic_ecl) {
+			globals.Registers.shift_reg_out[2] |= (long)0x20000;			/* power zout relay */
+		} else {
+			globals.Registers.shift_reg_out[2] &= (long)0xdffff;			/* de-power zout relay */
+		}
+	}
+
+
+	if (globals.ChannelState[channel].logic_level!=mode) {
+		globals.Changes.update_logic_level=YES;
+	}
+
+	globals.ChannelState[channel].logic_level=mode;
+	Set_Update_Chans();
+
+	return OK;
+}
+
+
+int Set_OS_Calib(int channel,float meas_ampl)
+{
+	float change_ratio;
+	int i,status,eprom_loc;
+
+	if (fabs(globals.ChannelState[channel].offset)<globals.Flash.ampl_zero_equiv[channel]) {
+		return NeedNonZeroAmpl;
+	}
+
+	change_ratio = meas_ampl/globals.ChannelState[channel].offset;
+
+	if (change_ratio>1.3 || change_ratio < 0.7) {
+		return CalibrationPercentError;
+	}
+
+	for (i=0; i<10; ++i) {
+		globals.Flash.os_pwl_amp[channel][0][0][i]=globals.Flash.os_pwl_amp[channel][0][0][i]*change_ratio;
+	}
+
+
+	/* see if new data prevents min/max from being obtained */
+	status=Check_MinMax_Cal(channel,pwl_os_values);
+
+	if (status) {
+		/* revert to original calibration */
+		for (i=0; i<10; ++i) {
+			globals.Flash.os_pwl_amp[channel][0][0][i]=globals.Flash.os_pwl_amp[channel][0][0][i]/change_ratio;
+		}
+	}
+
+	eprom_loc = (char *) &(globals.Flash.os_pwl_amp) - (char *) &(globals.Flash.flash_start);
+	writeUserBlock(eprom_loc,&globals.Flash.flash_start + eprom_loc,sizeof(globals.Flash.os_pwl_amp));
+
+	return status;
+}
+
+
+float Get_PW_shift(int channel)
+{
+	int UseNegData;
+
+	UseNegData = 0;
+	if (globals.ChannelState[channel].amplitude < 0.0) {
+		UseNegData = 1;
+	}
+
+	return globals.Flash.pulse_width_pol_tweak[channel][UseNegData];
+}
+
+
+int Set_PW_shift(int channel,float new_shift)
+{
+	float orig_shift;
+	int UseNegData, status, eprom_loc;
+
+	UseNegData = 0;
+	if (globals.ChannelState[channel].amplitude < 0.0) {
+		UseNegData = 1;
+	}
+
+	orig_shift = globals.Flash.pulse_width_pol_tweak[channel][UseNegData];
+	globals.Flash.pulse_width_pol_tweak[channel][UseNegData] = new_shift;
+
+	status=Check_MinMax_Cal(channel,pwl_pw_values);
+
+	if	(status) {
+		globals.Flash.pulse_width_pol_tweak[channel][UseNegData] = orig_shift;
+		return status;
+	}
+
+	eprom_loc = (char *) &(globals.Flash.pulse_width_pol_tweak[channel][UseNegData]) - (char *) &(globals.Flash.flash_start);
+	writeUserBlock(eprom_loc,&globals.Flash.flash_start + eprom_loc,sizeof(globals.Flash.pulse_width_pol_tweak[channel][UseNegData]));
+
+	return Set_Pw(0,0,0,channel,globals.ChannelState[channel].pw,0);
+}
+
+
+int Set_Route(int channel, int module, int mode)
+{
+	int error_num;
+	int word_out;
+
+	if (channel && !globals.Flash.ChanKey_route) {
+		return InvalidChannel;
+	}
+
+	if (!globals.Flash.routing_required[channel]) {
+		return Unrecognized;
+	}
+
+	if (module >= globals.Flash.routing_required[channel]) {
+		return IllegalParameter;
+	}
+
+	if ((mode < 1) || (mode > globals.Flash.routing_max_pins[channel])) {
+		return OutOfRange;
+	}
+
+	int i;
+	for (i=0; i<max_channels; ++i) {
+		TestState[i]=globals.ChannelState[i];
+	}
+
+	if (globals.Flash.routing_max_pins[channel] > 2) {
+		if (module == ROUTE_PRIMARY) {
+			TestState[channel].route_primary=mode;
+			if ((error_num=Error_check(TestState))) {
+				return error_num;
+			}
+
+			if (mode!=globals.ChannelState[channel].route_primary) {
+				globals.Changes.update_routes=YES;
+				globals.ChannelState[channel].route_primary=mode;
+			}
+		}
+
+		if (module == ROUTE_SECONDARY) {
+			TestState[channel].route_secondary=mode;
+			if ((error_num=Error_check(TestState))) {
+				return error_num;
+			}
+
+			if (mode!=globals.ChannelState[channel].route_secondary) {
+				globals.Changes.update_routes=YES;
+				globals.ChannelState[channel].route_secondary=mode;
+			}
+		}
+		word_out =  (globals.ChannelState[channel].route_primary-1) |
+		            ((globals.ChannelState[channel].route_secondary-1) << 4);
+		I2C_Write(PCF8574+Second_PW_Port,word_out);
+	} else {
+		/* AVD-D2-B */
+		if (mode==2) {
+			globals.Registers.shift_reg_out[2] |= (long)0x08000;			/* power zout relay */
+		} else {
+			globals.Registers.shift_reg_out[2] &= (long)0xf7fff;			/* de-power zout relay */
+		}
+		globals.ChannelState[channel].route_primary=mode;
+	}
+
+	Set_Update_Chans();
+
+	return OK;
+}
+
+
+int Set_EO(int channel,int mode)
+{
+	/* abandon if high channel selected by user but not enabled by firmware */
+	if (channel && !globals.Flash.ChanKey_offset) {
+		return InvalidChannel;
+	}
+
+	if (!globals.Flash.eo_enabled[channel]) {
+		return SyntaxError;
+	}
+
+	if (globals.ChannelState[channel].os_mode != mode) {
+		Set_Offset(0,0,0,0,channel,0.0);
+	}
+
+	if (mode) {
+		globals.Registers.shift_reg_out[2] |= (long)0x40000;
+	} else {
+		globals.Registers.shift_reg_out[2] &= ((long)(0xfffff - 0x40000));
+	}
+
+	if (globals.ChannelState[channel].os_mode!=mode) {
+		globals.Changes.update_os=YES;
+	}
+
+	globals.ChannelState[channel].os_mode=mode;
+	Set_Update_Chans();
+	Main_update_shift_registers();
+
+	return OK;
+}
+
+
+int Set_Dly_Shr_Nom(int channel,int calibration_point_number)
+{
+	float temp1, temp2, ampl;
+
+	Main_Rst();
+	Main_update_shift_registers();
+
+	Set_frequency(0,0,0,globals.Flash.ChanKey_frequency?channel:0,5.0e0);
+
+	if (globals.Flash.max_ampl[channel] > 0.0) {
+		ampl = globals.Flash.max_ampl[channel];
+	} else {
+		ampl = globals.Flash.min_ampl[channel];
+	}
+	Set_Amplitude(0,0,0,0,0,0,channel,ampl,0);
+
+
+	/* Set delay constants to zero, temporarily, for nulling purposes. */
+	/* Restore the constants after the delay is set, so that the unit */
+	/* will not suffer from an interrupted calibration. */
+
+	temp1=globals.Flash.propagation_delay[channel];
+	temp2=globals.Flash.delay_shrink[channel];
+	globals.Flash.propagation_delay[channel]=0.0;
+	globals.Flash.delay_shrink[channel]=0.0;
+
+	if (calibration_point_number==1) {
+		Set_Delay(0,0,0,channel,75e-9);
+	} else {
+		Set_Delay(0,0,0,channel,-75e-9);
+	}
+
+	/* user must set output on, when ready */
+
+	globals.Flash.propagation_delay[channel]=temp1;
+	globals.Flash.delay_shrink[channel]=temp2;
+
+	Main_update_shift_registers();
+
+	Menu_Update_Display();
+
+	return OK;
+}
+
+
+int Set_Dly_Shr_Cal(int channel,int calibration_point_number,float cal_point)
+{
+	int eprom_loc;
+	float delay1,delay2;
+
+	delay1=globals.Flash.propagation_delay[channel]-globals.Flash.delay_shrink[channel]+75e-9;
+	delay2=globals.Flash.propagation_delay[channel]+globals.Flash.delay_shrink[channel]-75e-9;
+
+	if (calibration_point_number==1) {
+		delay1=cal_point;
+	} else {
+		delay2=cal_point;
+	}
+
+	if (delay1>50e-6 || delay2>50e-6) {
+		return CalibrationPercentError;
+	}
+
+	globals.Flash.propagation_delay[channel]=(delay1+delay2)/2;
+	globals.Flash.delay_shrink[channel]=( (150e-9)-delay1+delay2)/2;
+
+	eprom_loc = (char *) &(globals.Flash.propagation_delay) - (char *) &(globals.Flash.flash_start);
+	writeUserBlock(eprom_loc,&globals.Flash.flash_start + eprom_loc,sizeof(globals.Flash.propagation_delay));
+
+	eprom_loc = (char *) &(globals.Flash.delay_shrink) - (char *) &(globals.Flash.flash_start);
+	writeUserBlock(eprom_loc,&globals.Flash.flash_start + eprom_loc,sizeof(globals.Flash.delay_shrink));
+
+	return OK;
+}
+
+
+
+int Set_Cal_Nom(int channel,int calibration_point_number,int parameter, float *nom_val)
+{
+	int nominal_wordout,polarity,range,entry,status,num_in_range,num_of_ranges;
+	float nominal_val,other_setting,temp1,temp2;
+	int reset_state;
+	int disable_errors;
+	int true_channel;
+
+	true_channel=channel;
+
+	Get_VI_Rng_Info(parameter,channel,calibration_point_number,&range,&polarity,&entry,&num_in_range,&num_of_ranges);
+	status=reset_state=disable_errors=0;
+
+	switch (parameter) {
+	case (pwl_ampl_values):
+		nominal_val=globals.Flash.ampl_pwl_amp[channel][range][polarity][entry];
+		if (polarity) {
+			nominal_val=-nominal_val;
+		}
+		nominal_wordout=globals.Flash.ampl_pwl_Vc_norm4095[channel][range][polarity][entry];
+		if (Set_Amplitude(0,0,0,0,0,0,channel,globals.Flash.min_ampl[channel],0) || Set_Amplitude(0,0,0,0,0,0,channel,globals.Flash.max_ampl[channel],0)) {
+			/* confirm that timing settings can support min/max ampl settings */
+			return CalibrationTimingProblem;
+		}
+		/* auto-set output impedance, as required */
+		if (globals.Flash.switchable_zout[channel]) {
+			/* if the cal point is in the top used range, then set Zout to min */
+			if (range==num_of_ranges) {
+				Set_zout(channel,globals.Flash.zout_min[channel],1);
+			} else {
+				Set_zout(channel,globals.Flash.zout_max[channel],1);
+			}
+		}
+		break;
+	case (pwl_os_values):
+		nominal_val=globals.Flash.os_pwl_amp[channel][range][polarity][entry];
+		nominal_wordout=globals.Flash.os_pwl_Vc_norm4095[channel][range][polarity][entry];
+		break;
+	case pwl_pw_values:
+		nominal_val=globals.Flash.pw_pwl_time[channel][range][polarity][entry];
+		nominal_wordout=globals.Flash.pw_pwl_Vc_norm4095[channel][range][polarity][entry];
+		reset_state=disable_errors=1;
+		break;
+	case pwl_delay_values:
+		nominal_val=globals.Flash.delay_pwl_time[channel][range][polarity][entry];
+		nominal_wordout=globals.Flash.delay_pwl_Vc_norm4095[channel][range][polarity][entry];
+		reset_state=disable_errors=1;
+		break;
+	case pwl_period_values:
+		nominal_val=globals.Flash.period_pwl_time[channel][range][polarity][entry];
+		nominal_wordout=globals.Flash.period_pwl_Vc_norm4095[channel][range][polarity][entry];
+		reset_state=disable_errors=1;
+		break;
+	case pwl_burst_values:
+		nominal_val=globals.Flash.burst_pwl_time[channel][range][polarity][entry];
+		nominal_wordout=globals.Flash.burst_pwl_Vc_norm4095[channel][range][polarity][entry];
+		reset_state=disable_errors=1;
+		break;
+	case pwl_rise_time_values:
+		nominal_val=globals.Flash.rise_time_pwl_time[channel][range][polarity][entry];
+		nominal_wordout=globals.Flash.rise_time_pwl_Vc_norm4095[channel][range][polarity][entry];
+		reset_state=disable_errors=1;
+		break;
+	case pwl_slew_values:
+		nominal_val=globals.Flash.slew_pwl_time[channel][range][polarity][entry];
+		nominal_wordout=globals.Flash.slew_pwl_Vc_norm4095[channel][range][polarity][entry];
+		break;
+	case pwl_vcc1_values:
+		nominal_val=globals.Flash.vcc1_pwl_amp[0][0][0][entry];
+		nominal_wordout=globals.Flash.vcc1_pwl_Vc_norm4095[0][0][0][entry];
+		true_channel=0;
+		break;
+	case pwl_vcc2_values:
+		nominal_val=globals.Flash.vcc2_pwl_amp[0][0][0][entry];
+		nominal_wordout=globals.Flash.vcc2_pwl_Vc_norm4095[0][0][0][entry];
+		true_channel=0;
+		break;
+	case pwl_load_type_values:
+		nominal_val=globals.Flash.load_type_pwl_time[channel][range][polarity][entry];
+		nominal_wordout=globals.Flash.load_type_pwl_Vc_norm4095[channel][range][polarity][entry];
+		reset_state=0;
+		disable_errors=1;
+		break;
+	}
+
+	/* just get nominal value, don't activate */
+	if (nom_val) {
+		*nom_val = nominal_val;
+		return OK;
+	}
+
+	/* For timing parameters, turn off output and error-checking, and change prf/pw */
+	/* For ampl/os parameters, use existing timing and output state, and use error-checking */
+
+	if (reset_state) {
+		Main_Rst();
+		Set_Output_State(true_channel,output_off);
+		Main_update_shift_registers();
+		bus_setpin(PW_ENABLE, 1);	/* enable PW circuit (but output relay still off) */
+	}
+
+	if (disable_errors) {
+		globals.Flash.fully_programmed=Being_Programmed;    /* disable error-checking */
+		Ctrl_PRF_Limiter(0);						/* re-enables after *rst */
+	}
+
+	globals.Flags.extended_ampl_min_max=YES;
+	globals.ChannelState[true_channel].test_delay_mode=NO;
+
+	switch (parameter) {
+	case (pwl_ampl_values):
+		status=Set_Amplitude(0,polarity,1,nominal_wordout,range,0,channel,nominal_val,0);
+		break;
+	case (pwl_os_values):
+		status=Set_Offset(0,1,nominal_wordout,range,channel,nominal_val);
+		break;
+	case pwl_pw_values:
+		other_setting=0.08/nominal_val;
+		if (other_setting > 500e3) {
+			other_setting=500e3;
+		}
+
+		Set_Pol(channel,pol_norm);
+
+		status=Set_frequency(0,0,0,globals.Flash.ChanKey_frequency?channel:0,other_setting);
+
+		if (!status) {
+			status=Set_Pw(0,nominal_wordout,range,channel,nominal_val,0);
+		}
+		break;
+	case pwl_delay_values:
+		other_setting=0.08/nominal_val;
+		if (other_setting > 500e3) {
+			other_setting=500e3;
+		}
+
+		/* set delay constants to zero, temporarily */
+		temp1=globals.Flash.propagation_delay[channel];
+		temp2=globals.Flash.delay_shrink[channel];
+		globals.Flash.propagation_delay[channel]=0.0;
+		globals.Flash.delay_shrink[channel]=0.0;
+
+		globals.ChannelState[channel].test_delay_mode=YES;
+
+		status=Set_frequency(0,0,0,globals.Flash.ChanKey_frequency?channel:0,other_setting);
+		if (!status) {
+			status=Set_Delay(0,nominal_wordout,range,channel,nominal_val);
+		}
+
+		globals.Flash.propagation_delay[channel]=temp1;
+		globals.Flash.delay_shrink[channel]=temp2;
+
+		break;
+	case pwl_period_values:
+		other_setting=0.4*nominal_val;
+		if (other_setting>1.0) {
+			other_setting=1.0;    /* reduce pulse width if required */
+		}
+
+		status=Set_frequency(0,nominal_wordout,range,channel,1.0/nominal_val);
+
+		if (!status) {
+			status=Set_Pw(0,0,0,globals.Flash.ChanKey_pw?channel:0,other_setting,0);
+		}
+		break;
+
+	case pwl_burst_values:
+		other_setting=20.0*nominal_val;
+
+		if (other_setting>10.0) {
+			other_setting=10.0;    /* reduce pulse width if required */
+		}
+		status=Set_frequency(0,0,0,channel,1.0/other_setting);
+		Main_update_shift_registers();
+
+		if (!status) {
+			status=Set_Pw(0,0,0,globals.Flash.ChanKey_pw?channel:0,nominal_val,0);
+		}
+		if (!status) {
+			status=Set_Burst_Count(channel,4,nominal_val);
+		}
+		if (!status) {
+			status=Set_Burst_Time(0,nominal_wordout,range,channel,nominal_val);
+		}
+
+		break;
+
+	case pwl_rise_time_values:
+		other_setting=10;	/* reduce test frequency if required */
+		status=Set_frequency(0,0,0,globals.Flash.ChanKey_frequency?channel:0,other_setting);
+		if (!status) {
+			status=Set_rise_time(0,nominal_wordout,range,channel,nominal_val);
+		}
+		break;
+
+	case pwl_slew_values:
+		other_setting=10;	/* reduce test frequency if required */
+		status=Set_frequency(0,0,0,globals.Flash.ChanKey_frequency?channel:0,other_setting);
+		if (!status) {
+			status=Set_slew(0,nominal_wordout,range,channel,nominal_val);
+		}
+		break;
+
+	case pwl_load_type_values:
+		Set_avrq_res(0,nominal_wordout,range,channel,nominal_val);
+		break;
+
+	case pwl_vcc1_values:
+		status=Set_Amplitude(0,polarity,1,nominal_wordout,range,0,channel,nominal_val,0);
+		break;
+
+	case pwl_vcc2_values:
+		status=Set_Amplitude(0,polarity,1,nominal_wordout,range,0,channel,nominal_val,0);
+		break;
+
+	}
+
+	/* enables or disables delay diagnostic mode */
+	Set_Mux(true_channel);
+
+	Main_update_shift_registers();
+	Menu_Update_Display();
+
+	/* re-enable error-checking */
+	globals.Flash.fully_programmed=All_Programmed;
+
+	/* rise time requires more values to be set before it can be measured */
+	if (parameter != pwl_rise_time_values) {
+		globals.Flags.extended_ampl_min_max=NO;
+	}
+
+	return status;
+}
+
+
+int Set_VI_Cal_Pnt(int parameter,int channel,int calibration_point_number,float cal_point)
+{
+	int polarity,range,entry,status,num_in_range,num_of_ranges,eprom_loc;
+	float nom_ampl;
+	int index;
+	int max_points,max_polarity,max_ranges;
+	float *pwl_amp;
+	int true_channel;
+
+	true_channel=channel;
+
+	Get_VI_Rng_Info(parameter,channel,calibration_point_number,&range,&polarity,&entry,&num_in_range,&num_of_ranges);
+
+	max_points=points_in_range;
+	switch (parameter) {
+	case (pwl_ampl_values):
+		max_polarity=ampl_polarities;
+		max_ranges=ampl_ranges;
+		pwl_amp=&globals.Flash.ampl_pwl_amp[0][0][0][0];
+		break;
+	case (pwl_os_values):
+		max_polarity=os_polarities;
+		max_ranges=os_ranges;
+		pwl_amp=&globals.Flash.os_pwl_amp[0][0][0][0];
+		break;
+	case pwl_pw_values:
+		max_polarity=timing_polarities;
+		max_ranges=timing_ranges;
+		pwl_amp=&globals.Flash.pw_pwl_time[0][0][0][0];
+		break;
+	case pwl_delay_values:
+		max_polarity=timing_polarities;
+		max_ranges=timing_ranges;
+		pwl_amp=&globals.Flash.delay_pwl_time[0][0][0][0];
+		break;
+	case pwl_period_values:
+		max_polarity=timing_polarities;
+		max_ranges=timing_ranges;
+		pwl_amp=&globals.Flash.period_pwl_time[0][0][0][0];
+		break;
+	case pwl_burst_values:
+		max_polarity=timing_polarities;
+		max_ranges=timing_ranges;
+		pwl_amp=&globals.Flash.burst_pwl_time[0][0][0][0];
+		break;
+	case pwl_rise_time_values:
+		max_polarity=ampl_polarities;
+		max_ranges=ampl_ranges;
+		pwl_amp=&globals.Flash.rise_time_pwl_time[0][0][0][0];
+		break;
+	case pwl_slew_values:
+		max_polarity=timing_polarities;
+		max_ranges=timing_ranges;
+		pwl_amp=&globals.Flash.slew_pwl_time[0][0][0][0];
+		break;
+	case pwl_vcc1_values:
+		max_polarity=1;
+		max_ranges=1;
+		true_channel=0;
+		pwl_amp=&globals.Flash.vcc1_pwl_amp[0][0][0][0];
+		break;
+	case pwl_vcc2_values:
+		max_polarity=1;
+		max_ranges=1;
+		true_channel=0;
+		pwl_amp=&globals.Flash.vcc2_pwl_amp[0][0][0][0];
+		break;
+	case pwl_load_type_values:
+		max_polarity=load_type_polarities;
+		max_ranges=load_type_ranges;
+		pwl_amp=&globals.Flash.load_type_pwl_time[0][0][0][0];
+		break;
+	}
+	index=true_channel*max_ranges*max_polarity*max_points
+	      +range*max_polarity*max_points
+	      +polarity*max_points
+	      +entry;
+
+	nom_ampl=pwl_amp[index];
+
+	switch (parameter) {
+	case (pwl_ampl_values):
+		if (globals.ChannelState[channel].amplitude<0.0) {
+			nom_ampl=-nom_ampl;
+		}
+		if ( (cal_point>0.0 && nom_ampl<0.0) || (cal_point<0.0 && nom_ampl>0.0)) {
+			return CalibrationPolarityError;
+		}
+		if (fabs(nom_ampl) < smallest_allowed_number) {
+			return CalibrationZeroError;
+		}
+		if (fabs( (cal_point-nom_ampl)/nom_ampl) >0.3) {
+			return CalibrationPercentError;
+		}
+		break;
+
+	case (pwl_os_values):
+		/* check for divide-by-zero error */
+		if (fabs(nom_ampl) > smallest_allowed_number) {
+			/* exclude relative changes of 30% or more */
+			if (fabs( (cal_point-nom_ampl)/nom_ampl) > 0.3) {
+				return CalibrationPercentError;
+			}
+		}
+		/* exclude changes greater than 20% of entire range */
+		if (fabs(cal_point-nom_ampl) > (0.2*fabs(globals.Flash.max_offset[channel]-globals.Flash.min_offset[channel]))) {
+			return CalibrationPercentError;
+		}
+		break;
+
+	case pwl_pw_values:
+	case pwl_period_values:
+	case pwl_burst_values:
+	case pwl_rise_time_values:
+	case pwl_slew_values:
+	case pwl_load_type_values:
+		/* exclude relative changes of 45% or more unless < 15 ns */
+		if ( (fabs(cal_point-nom_ampl)/nom_ampl > 0.45) && (fabs(cal_point-nom_ampl)>15e-9)) {
+			return CalibrationPercentError;
+		}
+		if (cal_point<0.0) {
+			return Negative_Not_Allowed;
+		}
+		break;
+
+	case pwl_delay_values:
+		/* exclude relative changes of 45% or more unless < 15 ns */
+		if ( (fabs(cal_point-nom_ampl)/nom_ampl > 0.45) && (fabs(cal_point-nom_ampl)>15e-9)) {
+			return CalibrationPercentError;
+		}
+		break;
+
+	case pwl_vcc1_values:
+	case pwl_vcc2_values:
+		if (fabs(nom_ampl) > smallest_allowed_number) {
+			/* exclude relative changes of 30% or more */
+			if (fabs( (cal_point-nom_ampl)/nom_ampl) > 0.3) {
+				return CalibrationPercentError;
+			}
+		}
+		break;
+	}
+
+
+
+	status=OK;
+	globals.Flags.extended_ampl_min_max=YES;
+
+	if (parameter==pwl_ampl_values) {
+		cal_point=fabs(cal_point);
+	}
+
+	*(float *)(&pwl_amp[index])=cal_point;
+
+	/* see if new point prevents min/max from being obtained */
+	status=Check_MinMax_Cal(channel,parameter);
+
+	if	(status) {
+		/* revert to original value if required */
+		*(float *)(&pwl_amp[index])=nom_ampl;
+	}
+
+	Set_Cal_Nom(channel,calibration_point_number,parameter,NULL);
+
+	Main_update_shift_registers();
+	Menu_Update_Display();
+
+	eprom_loc = (char *) (&pwl_amp[index]) - (char *) &(globals.Flash.flash_start);
+	writeUserBlock(eprom_loc,&globals.Flash.flash_start + eprom_loc,sizeof(nom_ampl));
+
+	globals.Flags.extended_ampl_min_max=NO;
+	return status;
+}
+
+
+int Set_VI_Del_Cal(int parameter,int channel,int calibration_point_number)
+{
+	int polarity,range,entry,status,i,num_in_range,num_of_ranges;
+	float temp1[10];
+	int temp2[10];
+	int index;
+	int max_points,max_polarity,max_ranges;
+	int *pointer_int1;
+	float *pointer_float1;
+	int eprom_loc,size_of_float1,size_of_int1;
+	int true_channel;
+
+	true_channel=channel;
+
+	max_points=points_in_range;
+
+	switch (parameter) {
+	case (pwl_ampl_values):
+		max_polarity=ampl_polarities;
+		max_ranges=ampl_ranges;
+		pointer_int1=&globals.Flash.ampl_pwl_Vc_norm4095[0][0][0][0];
+		pointer_float1=&globals.Flash.ampl_pwl_amp[0][0][0][0];
+		size_of_int1=sizeof(globals.Flash.ampl_pwl_Vc_norm4095);
+		size_of_float1=sizeof(globals.Flash.ampl_pwl_amp);
+		break;
+	case (pwl_os_values):
+		max_polarity=os_polarities;
+		max_ranges=os_ranges;
+		pointer_int1=&globals.Flash.os_pwl_Vc_norm4095[0][0][0][0];
+		pointer_float1=&globals.Flash.os_pwl_amp[0][0][0][0];
+		size_of_int1=sizeof(globals.Flash.os_pwl_Vc_norm4095);
+		size_of_float1=sizeof(globals.Flash.os_pwl_amp);
+		break;
+	case pwl_pw_values:
+		max_polarity=timing_polarities;
+		max_ranges=timing_ranges;
+		pointer_int1=&globals.Flash.pw_pwl_Vc_norm4095[0][0][0][0];
+		pointer_float1=&globals.Flash.pw_pwl_time[0][0][0][0];
+		size_of_int1=sizeof(globals.Flash.pw_pwl_Vc_norm4095);
+		size_of_float1=sizeof(globals.Flash.pw_pwl_time);
+		break;
+	case pwl_delay_values:
+		max_polarity=timing_polarities;
+		max_ranges=timing_ranges;
+		pointer_int1=&globals.Flash.delay_pwl_Vc_norm4095[0][0][0][0];
+		pointer_float1=&globals.Flash.delay_pwl_time[0][0][0][0];
+		size_of_int1=sizeof(globals.Flash.delay_pwl_Vc_norm4095);
+		size_of_float1=sizeof(globals.Flash.delay_pwl_time);
+		break;
+	case pwl_period_values:
+		max_polarity=timing_polarities;
+		max_ranges=timing_ranges;
+		pointer_int1=&globals.Flash.period_pwl_Vc_norm4095[0][0][0][0];
+		pointer_float1=&globals.Flash.period_pwl_time[0][0][0][0];
+		size_of_int1=sizeof(globals.Flash.period_pwl_Vc_norm4095);
+		size_of_float1=sizeof(globals.Flash.period_pwl_time);
+		break;
+	case pwl_burst_values:
+		max_polarity=timing_polarities;
+		max_ranges=timing_ranges;
+		pointer_int1=&globals.Flash.burst_pwl_Vc_norm4095[0][0][0][0];
+		pointer_float1=&globals.Flash.burst_pwl_time[0][0][0][0];
+		size_of_int1=sizeof(globals.Flash.burst_pwl_Vc_norm4095);
+		size_of_float1=sizeof(globals.Flash.burst_pwl_time);
+		break;
+	case pwl_rise_time_values:
+		max_polarity=ampl_polarities;
+		max_ranges=ampl_ranges;
+		pointer_int1=&globals.Flash.rise_time_pwl_Vc_norm4095[0][0][0][0];
+		pointer_float1=&globals.Flash.rise_time_pwl_time[0][0][0][0];
+		size_of_int1=sizeof(globals.Flash.rise_time_pwl_Vc_norm4095);
+		size_of_float1=sizeof(globals.Flash.rise_time_pwl_time);
+		break;
+	case pwl_slew_values:
+		max_polarity=timing_polarities;
+		max_ranges=timing_ranges;
+		pointer_int1=&globals.Flash.slew_pwl_Vc_norm4095[0][0][0][0];
+		pointer_float1=&globals.Flash.slew_pwl_time[0][0][0][0];
+		size_of_int1=sizeof(globals.Flash.slew_pwl_Vc_norm4095);
+		size_of_float1=sizeof(globals.Flash.slew_pwl_time);
+		break;
+	case pwl_vcc1_values:
+		max_polarity=1;
+		max_ranges=1;
+		pointer_int1=&globals.Flash.vcc1_pwl_Vc_norm4095[0][0][0][0];
+		pointer_float1=&globals.Flash.vcc1_pwl_amp[0][0][0][0];
+		size_of_int1=sizeof(globals.Flash.vcc1_pwl_Vc_norm4095);
+		size_of_float1=sizeof(globals.Flash.vcc1_pwl_amp);
+		true_channel=0;
+		break;
+	case pwl_vcc2_values:
+		max_polarity=1;
+		max_ranges=1;
+		pointer_int1=&globals.Flash.vcc2_pwl_Vc_norm4095[0][0][0][0];
+		pointer_float1=&globals.Flash.vcc2_pwl_amp[0][0][0][0];
+		size_of_int1=sizeof(globals.Flash.vcc2_pwl_Vc_norm4095);
+		size_of_float1=sizeof(globals.Flash.vcc2_pwl_amp);
+		true_channel=0;
+		break;
+	case pwl_load_type_values:
+		max_polarity=load_type_polarities;
+		max_ranges=load_type_ranges;
+		pointer_int1=&globals.Flash.load_type_pwl_Vc_norm4095[0][0][0][0];
+		pointer_float1=&globals.Flash.load_type_pwl_time[0][0][0][0];
+		size_of_int1=sizeof(globals.Flash.load_type_pwl_Vc_norm4095);
+		size_of_float1=sizeof(globals.Flash.load_type_pwl_time);
+		break;
+	}
+
+	Get_VI_Rng_Info(parameter,channel,calibration_point_number,&range,&polarity,&entry,&num_in_range,&num_of_ranges);
+
+	index=true_channel*max_ranges*max_polarity*max_points
+	      +range*max_polarity*max_points
+	      +polarity*max_points;
+
+
+	/* can not delete top or bottom of a range */
+	if ((entry==0) || (entry==(num_in_range-1))) {
+		return CalibrationRangeError;
+	}
+
+	/* backup calibration values */
+	for (i=0; i<max_points; i++) {
+		temp1[i]=pointer_float1[index+i];
+		temp2[i]=pointer_int1[index+i];
+	}
+
+	/* move the data, overwriting the deleted point */
+	for (i=entry; i<max_points-1; i++) {
+		*(float *)(&pointer_float1[index+i])=pointer_float1[index+i+1];
+		*(int *)(&pointer_int1[index+i])=pointer_int1[index+i+1];
+	}
+
+	*(float *)(&pointer_float1[index+points_in_range-1])=0.0;
+	*(int *)(&pointer_int1[index+points_in_range-1])=0;
+
+	/* see if new point prevents min/max from being obtained */
+	status=Check_MinMax_Cal(channel,parameter);
+
+	if (status) {
+		/* revert to original calibration */
+		for (i=0; i<max_points; i++) {
+			*(float *)(&pointer_float1[index+i])=temp1[i];
+			*(int *)(&pointer_int1[index+i])=temp2[i];
+		}
+	}
+
+	Set_Amplitude(0,0,0,0,0,0,channel,0.0,0);
+	Main_update_shift_registers();
+
+	Set_Offset(0,0,0,0,channel,0.0);
+	Main_update_shift_registers();
+
+	Menu_Update_Display();
+
+	eprom_loc = (char *) pointer_int1 - (char *) &(globals.Flash.flash_start);
+	writeUserBlock(eprom_loc,&globals.Flash.flash_start + eprom_loc,size_of_int1);
+
+	eprom_loc = (char *) pointer_float1 - (char *) &(globals.Flash.flash_start);
+	writeUserBlock(eprom_loc,&globals.Flash.flash_start + eprom_loc,size_of_float1);
+
+	return status;
+}
+
+
+int Set_VI_Control(int parameter,int channel,float new_ampl,int *point_found,int *relay_range,
+                   int *UseNegData,int *entry,int *word_out,int *actual_pol)
+{
+	float use_ampl,tweaked_use_ampl,fraction;
+	int i;
+	float min_os_in_range,max_os_in_range;
+	float min_ampl_in_range,max_ampl_in_range;
+
+	int max_points,max_polarity,max_ranges;
+	float *pwl_amp;
+	int *pwl_vc;
+	int index,use_range;
+	int range_i,entry_i;
+	float inverse_word_out;
+	int timing_extrapolation_allowed;
+	int pw_polarity;
+
+	float pw_distort_val;
+	float ampl_for_distort_calc;
+
+
+	int top_range_only;
+	int starting_range;
+
+	int decreasing_values_allowed;
+	int reciprocal_relationship;
+
+	int true_channel;
+
+	true_channel=channel;
+
+	top_range_only=0;
+	starting_range=0;
+	max_points=points_in_range;
+	timing_extrapolation_allowed=NO;
+	reciprocal_relationship=NO;
+	decreasing_values_allowed=NO;
+	min_os_in_range=max_os_in_range=0.0;
+	min_ampl_in_range=max_ampl_in_range=0.0;
+
+
+	switch (parameter) {
+	case pwl_ampl_values:
+
+		if (globals.Flash.ampl_coupled_to_os[channel]) {
+			new_ampl+=globals.ChannelState[channel].offset;	/* for 1011-style offset circuit */
+		}
+
+		max_polarity=ampl_polarities;
+		max_ranges=ampl_ranges;
+		pwl_vc=&globals.Flash.ampl_pwl_Vc_norm4095[0][0][0][0];
+		pwl_amp=&globals.Flash.ampl_pwl_amp[0][0][0][0];
+		if (new_ampl<0.0) {
+			*actual_pol=1;
+			*UseNegData=1;
+		} else {
+			*actual_pol=0;
+			*UseNegData=0;
+		}
+		if (globals.Flash.use_pos_ampl_data_only[channel] && new_ampl<0.0) {
+			*UseNegData=0;
+		}
+		use_ampl=fabs(new_ampl);
+
+		/* use top amplitude range in AV-1011 if Zout=2 */
+		top_range_only = globals.Flash.switchable_zout[channel]
+		                 && (globals.ChannelState[channel].zout==globals.Flash.zout_min[channel]);
+
+		/* if high_impedance_mode the relay range is automatically set to 3 (for 1011, 1015 only),
+		   if such a range exists */
+
+		if ( globals.Flash.switchable_load[channel] &&
+		                (globals.ChannelState[channel].load_type>globals.Flash.low_load_type[channel]) &&
+		                globals.Flash.ampl_pwl_Vc_norm4095[channel][3][*actual_pol][1] > 0) {
+			starting_range=3;
+			top_range_only=0;
+		}
+
+		/* if 1011-OT offset is non-zero, the relay range is automatically set to 3 or 4 (for 1011, 1015 only) */
+
+		if (globals.Flash.ampl_coupled_to_os[channel]
+		                && globals.Flash.switchable_zout[channel]
+		                && (fabs(globals.ChannelState[channel].offset)>(globals.Flash.max_offset[channel]/max_v_dymanic_range))) {
+			starting_range=3;
+		}
+
+		/* for AVMP-4-B: lower ampl range used for first PW range only */
+		if (globals.Flash.use_high_ampl_ranges_for_high_pw_ranges[channel] &&
+		                ((globals.Registers.shift_reg_out[3] & 0x7f) > 0)) {
+			top_range_only=1;
+		}
+
+		break;
+	case pwl_os_values:
+		decreasing_values_allowed=YES;		/* allows Vc=0 to corresponds to most + OS, and Vc=10V to give most - OS */
+		max_polarity=os_polarities;
+		max_ranges=os_ranges;
+		pwl_vc=&globals.Flash.os_pwl_Vc_norm4095[0][0][0][0];
+		pwl_amp=&globals.Flash.os_pwl_amp[0][0][0][0];
+		*UseNegData=0;
+		use_ampl=new_ampl;
+		break;
+	case pwl_pw_values:
+		max_polarity=timing_polarities;
+		max_ranges=timing_ranges;
+		pwl_vc=&globals.Flash.pw_pwl_Vc_norm4095[0][0][0][0];
+		pwl_amp=&globals.Flash.pw_pwl_time[0][0][0][0];
+		*UseNegData=0;
+		use_ampl=new_ampl;
+
+		/* increase PW if required to compensate for series output diode turn-on time */
+		if (		(globals.Flash.fully_programmed != Being_Programmed)
+		                &&	(globals.Flash.distort_Y[channel] != 0.0)
+		                && (fabs(globals.ChannelState[channel].offset)<fabs(globals.Flash.distort_max_os[channel]))	) {
+
+			ampl_for_distort_calc = fabs(globals.ChannelState[channel].amplitude);
+
+			/* clamping distortion above a certain amplitude */
+			if (ampl_for_distort_calc > globals.Flash.distort_max_ampl[channel]) {
+				ampl_for_distort_calc = globals.Flash.distort_max_ampl[channel];
+			}
+
+			/* clamping distortion below "zero equiv" amplitude */
+			if (ampl_for_distort_calc < globals.Flash.ampl_zero_equiv[channel]) {
+				ampl_for_distort_calc = globals.Flash.ampl_zero_equiv[channel];
+			}
+
+			/* prohit values of Y that would cause divide-by-zero error */
+			if ( (-globals.Flash.distort_Y[channel]) > globals.Flash.ampl_zero_equiv[channel]) {
+				return PW_Distort_Error;
+			}
+
+			pw_distort_val=globals.Flash.distort_Z[channel] +
+			               globals.Flash.distort_X[channel] / (ampl_for_distort_calc+globals.Flash.distort_Y[channel]);
+
+			/* calculate new actual PW */
+			use_ampl=use_ampl+pw_distort_val;
+		}
+
+		/* tweak depending on polarity */
+		if (globals.ChannelState[channel].amplitude<0.0) {
+			pw_polarity = 1;
+			use_ampl=use_ampl+globals.Flash.pulse_width_pol_tweak[channel][pw_polarity];
+		} else {
+			pw_polarity = 0;
+			use_ampl=use_ampl+globals.Flash.pulse_width_pol_tweak[channel][pw_polarity];
+		}
+
+		/* tweak depending on amplitude range (steps, not gradual like distort params */
+
+		if (fabs(globals.ChannelState[channel].amplitude) <= globals.Flash.pw_shift_below_this_ampl[channel]) {
+			use_ampl=use_ampl+globals.Flash.pw_shift_below_ampl_by[channel];
+		}
+
+		reciprocal_relationship=YES;
+		timing_extrapolation_allowed=YES;
+		break;
+	case pwl_delay_values:
+		max_polarity=timing_polarities;
+		max_ranges=timing_ranges;
+		pwl_vc=&globals.Flash.delay_pwl_Vc_norm4095[0][0][0][0];
+		pwl_amp=&globals.Flash.delay_pwl_time[0][0][0][0];
+		*UseNegData=0;
+		use_ampl=new_ampl;
+		reciprocal_relationship=YES;
+		timing_extrapolation_allowed=YES;
+		break;
+	case pwl_period_values:
+		max_polarity=timing_polarities;
+		max_ranges=timing_ranges;
+		pwl_vc=&globals.Flash.period_pwl_Vc_norm4095[0][0][0][0];
+		pwl_amp=&globals.Flash.period_pwl_time[0][0][0][0];
+		*UseNegData=0;
+		use_ampl=new_ampl;
+		timing_extrapolation_allowed=YES;
+		reciprocal_relationship=YES;
+		break;
+	case pwl_burst_values:
+		max_polarity=timing_polarities;
+		max_ranges=timing_ranges;
+		pwl_vc=&globals.Flash.burst_pwl_Vc_norm4095[0][0][0][0];
+		pwl_amp=&globals.Flash.burst_pwl_time[0][0][0][0];
+		*UseNegData=0;
+		use_ampl=new_ampl;
+		reciprocal_relationship=YES;
+		timing_extrapolation_allowed=YES;
+		break;
+	case pwl_rise_time_values:
+		max_polarity=ampl_polarities;
+		max_ranges=ampl_ranges;
+		pwl_vc=&globals.Flash.rise_time_pwl_Vc_norm4095[0][0][0][0];
+		pwl_amp=&globals.Flash.rise_time_pwl_time[0][0][0][0];
+		if (globals.ChannelState[channel].amplitude<0.0) {
+			*actual_pol=*UseNegData=1;
+		} else {
+			*actual_pol=*UseNegData=0;
+		}
+		use_ampl=new_ampl;
+		reciprocal_relationship=NO;
+		timing_extrapolation_allowed=NO;
+		break;
+	case pwl_slew_values:
+		max_polarity=timing_polarities;
+		max_ranges=timing_ranges;
+		pwl_vc=&globals.Flash.slew_pwl_Vc_norm4095[0][0][0][0];
+		pwl_amp=&globals.Flash.slew_pwl_time[0][0][0][0];
+		*UseNegData=0;
+		use_ampl=new_ampl;
+		reciprocal_relationship=NO;
+		timing_extrapolation_allowed=NO;
+		top_range_only=YES; /* higher drive voltage = lower ripple in slew */
+		break;
+	case pwl_vcc1_values:
+		max_polarity=1;
+		max_ranges=1;
+		pwl_vc=&globals.Flash.vcc1_pwl_Vc_norm4095[0][0][0][0];
+		pwl_amp=&globals.Flash.vcc1_pwl_amp[0][0][0][0];
+		*UseNegData=0;
+		use_ampl=new_ampl;
+		true_channel=0;
+		break;
+	case pwl_vcc2_values:
+		max_polarity=1;
+		max_ranges=1;
+		pwl_vc=&globals.Flash.vcc2_pwl_Vc_norm4095[0][0][0][0];
+		pwl_amp=&globals.Flash.vcc2_pwl_amp[0][0][0][0];
+		*UseNegData=0;
+		use_ampl=new_ampl;
+		true_channel=0;
+		break;
+	case pwl_load_type_values:
+		max_polarity=load_type_polarities;
+		max_ranges=load_type_ranges;
+		pwl_vc=&globals.Flash.load_type_pwl_Vc_norm4095[0][0][0][0];
+		pwl_amp=&globals.Flash.load_type_pwl_time[0][0][0][0];
+		*UseNegData=0;
+		use_ampl=new_ampl;
+		reciprocal_relationship=YES;
+		timing_extrapolation_allowed=YES;
+		break;
+	}
+
+
+	/* if top_range_only=false, the first match (i.e. in the lowest range) is used. */
+	/* if top_range_only=true, the last match (i.e. in the highest range) is used. */
+
+	*point_found=*relay_range=*entry=0;
+	*word_out=-1;
+
+	tweaked_use_ampl = use_ampl;
+
+	for (range_i=starting_range; (range_i<max_ranges) && (!*point_found || top_range_only); ++range_i) {	/* use non-all-zero ranges */
+//printf ("range_i %d\r\n",range_i);
+		/* apply pw ampl/pol tweaks */
+		if (parameter == pwl_pw_values) {
+			tweaked_use_ampl = use_ampl + globals.Flash.pw_range_pol_tweaks[channel][range_i][pw_polarity];
+		}
+
+		for (entry_i=0; (entry_i<max_points-1) && (!*point_found || top_range_only); ++entry_i) {
+//printf ("entry_i %d\r\n",entry_i);
+
+			index=true_channel*max_ranges*max_polarity*max_points
+			      +(range_i)*max_polarity*max_points
+			      +(*UseNegData)*max_points
+			      +(entry_i);
+
+			if ( (fabs(pwl_amp[index]-pwl_amp[index+1])>smallest_allowed_number)
+			                &&
+			                (	((tweaked_use_ampl>=pwl_amp[index]) &&	(tweaked_use_ampl<=pwl_amp[index+1]))
+			                        ||
+			                        (decreasing_values_allowed && (tweaked_use_ampl<=pwl_amp[index]) &&	(tweaked_use_ampl>=pwl_amp[index+1]))  /* for OS only */
+			                )
+			   ) {
+				*point_found=1;
+
+				if ((parameter==pwl_ampl_values) && globals.Flash.ampl_os_ranges_related[channel]) {
+					for (i=0; i<points_in_range; i++) {
+						if (max_os_in_range<globals.Flash.os_pwl_amp[channel][range_i][0][i]) {
+							max_os_in_range=globals.Flash.os_pwl_amp[channel][range_i][0][i];
+						}
+						if (min_os_in_range>globals.Flash.os_pwl_amp[channel][range_i][0][i]) {
+							min_os_in_range=globals.Flash.os_pwl_amp[channel][range_i][0][i];
+						}
+					}
+					if ((globals.ChannelState[channel].offset<min_os_in_range) || (globals.ChannelState[channel].offset>max_os_in_range)) {
+						*point_found=0;	/* try higher range if can't satisfy os and ampl both in this range */
+					}
 				}
 
-				Set_Load(i,globals.ChannelState[i].load_type);
-				Set_Logic_Level(i,globals.ChannelState[i].logic_level);
-				Set_rise_time(0,0,0,i,globals.ChannelState[i].rise_time);
-				Set_slew(0,0,0,i,globals.ChannelState[i].slew);
-				Set_current_limit(0,i,globals.ChannelState[i].soft_current_limit);
+				if ((parameter==pwl_os_values) && globals.Flash.ampl_os_ranges_related[channel]) {
+					for (i=0; i<points_in_range; i++) {
+						if (max_ampl_in_range<globals.Flash.ampl_pwl_amp[channel][range_i][*UseNegData][i]) {
+							max_ampl_in_range=globals.Flash.ampl_pwl_amp[channel][range_i][*UseNegData][i];
+						}
+						if (min_ampl_in_range>globals.Flash.ampl_pwl_amp[channel][range_i][*UseNegData][i]) {
+							min_ampl_in_range=globals.Flash.ampl_pwl_amp[channel][range_i][*UseNegData][i];
+						}
+					}
+					if ((fabs(globals.ChannelState[channel].amplitude)<min_ampl_in_range) || (fabs(globals.ChannelState[channel].amplitude)>max_ampl_in_range)) {
+						*point_found=0;	/* try higher range if can't satisfy os and ampl both in this range */
+					}
+				}
+
+				fraction = (tweaked_use_ampl-pwl_amp[index]) / (pwl_amp[index] - pwl_amp[index+1]);
+				*relay_range=range_i;
+				*entry=entry_i;
+
+				/* check for linear voltage-controlled PW */
+				if (	(parameter==pwl_pw_values)
+				                && globals.Flash.volt_ctrl_pw[channel]
+				                && (pwl_vc[index] < pwl_vc[index+1])) {
+					reciprocal_relationship=NO;
+				}
 
-				if (globals.Flash.max_burst_count[i]>1) {
-					Set_Burst_Count(i,globals.ChannelState[i].burst_count,globals.ChannelState[i].burst_time);
+				if (reciprocal_relationship) {
+					inverse_word_out = fraction * (1.0/((float) pwl_vc[index]) - 1.0/((float) pwl_vc[index+1]));
+					inverse_word_out+=1/((float) pwl_vc[index]);
+					*word_out=(int) (1.0/inverse_word_out);
+				} else {
+					*word_out = (int) ( fraction * (float) (pwl_vc[index] - pwl_vc[index+1]) );
+					*word_out+=pwl_vc[index];
 				}
+			}
+		}
+	}
+
+	/* The amplitude/os settings must lie within the calibration points. */
+	/* However, the timing data is allowed to lie outside the upper end, */
+	/* because the reciprocal relationship allows an asymptotic extension to infinity, */
+	/* at the expense of lower resolution */
+
+	if (*word_out<0 && timing_extrapolation_allowed) {
+		*point_found=0;
+		use_range=-1;
+
+		tweaked_use_ampl = use_ampl;
 
-				Set_Trig_Source(i,globals.ChannelState[i].trigger_source);
+		/* identify highest range that starts with a cal point less than the setting */
+		for (range_i=0; range_i<max_ranges; ++range_i) {	/* use non-all-zero ranges */
+			if (parameter == pwl_pw_values) {
+				tweaked_use_ampl = use_ampl + globals.Flash.pw_range_pol_tweaks[channel][range_i][pw_polarity];
+			}
 
-				Set_Amplitude(0,0,0,0,0,0,i,globals.ChannelState[i].amplitude,0);
-				Set_Offset(0,0,0,0,i,globals.ChannelState[i].offset);
-				Set_Output_State(i,globals.ChannelState[i].output_state);
+			index=true_channel*max_ranges*max_polarity*max_points
+			      +(range_i)*max_polarity*max_points
+			      +(*UseNegData)*max_points;
+			if (pwl_amp[index]>smallest_allowed_number && pwl_amp[index]<tweaked_use_ampl) {
+				use_range=range_i;
+			}
+		}
+
+		if (use_range<0) {
+			return HardwareError;
+		}
 
-				Set_current_limit(0,i,globals.ChannelState[i].soft_current_limit);
+		for (entry_i=max_points-2; (entry_i>=0) && (!*point_found); --entry_i) {
+			index=true_channel*max_ranges*max_polarity*max_points
+			      +(use_range)*max_polarity*max_points
+			      +(*UseNegData)*max_points
+			      +(entry_i);
 
-				Set_avrq_ampl(0,0,0,2,globals.ChannelState[i].vcc1);
-				Set_avrq_ampl(0,0,0,3,globals.ChannelState[i].vcc2);
-				Set_avrq_ampl(0,0,0,4,globals.ChannelState[i].vlogic);
-		*/
-		globals.do_check_settings=YES;  /* check for conflicting settings */
+			/* find the last two non-zero entries, and extrapolate from them */
+			if (		(fabs(pwl_amp[index])>smallest_allowed_number)
+			                && (fabs(pwl_amp[index+1])>smallest_allowed_number)
+			                && (fabs(pwl_amp[index]-pwl_amp[index+1])>smallest_allowed_number)	) {
+				*point_found=1;
+
+				fraction = (tweaked_use_ampl-pwl_amp[index]) / (pwl_amp[index] - pwl_amp[index+1]);
+				*relay_range=use_range;
+				*entry=entry_i;
+
+				inverse_word_out = fraction * (1.0/((float) pwl_vc[index]) - 1.0/((float) pwl_vc[index+1]));
+				inverse_word_out+=1/((float) pwl_vc[index]);
+				*word_out=(int) (1.0/inverse_word_out);
+			}
+		}
 	}
 
+	if (*word_out<0) {
+		*word_out=0;
+		return HardwareError;
+	}
+
+	/* check for 12 or 13 bit overflow */
+	if (*word_out>dac_max) {
+		*word_out=dac_max;	/* just to prevent wandering bits */
+		return HardwareError;
+	}
 
-//	Error_check(globals.ChannelState);      /* establishes min/max values for queries, but reports no errors */
-//	update_whole_main_menu=YES;
-//	Ctrl_PRF_Limiter(1);
-//	Menu_Clear_Buttons();
+	return OK;
 }
+
+
+int Set_VI_Add_Cal(int parameter,int channel,float cal_point)
+{
+	int point_found,range,polarity,entry,word_out,total;
+	int i;
+	float max_in_range;
+	float least_integrated_error,integrated_error;
+	float interp_ampl,fraction;
+	int delete_point;
+	float old_val;
+	float abs_cal_point;
+	int max_points,max_polarity,max_ranges;
+
+	float temp_y_float[points_in_range+1];
+	float temp_x_float[points_in_range+1];
+	int temp_x_int[points_in_range+1];
+
+	int index,actual_pol;
+	float *pointer_y_float;
+	int *pointer_x_int;
+
+	int eprom_loc,size_of_y_float,size_of_x_int;
+
+	int true_channel;
+
+	true_channel = channel;
+
+	range=polarity=0;
+
+	max_points=points_in_range;
+
+	abs_cal_point=cal_point;
+
+	switch (parameter) {
+	case (pwl_ampl_values):
+		max_polarity=ampl_polarities;
+		max_ranges=ampl_ranges;
+
+		pointer_x_int=&globals.Flash.ampl_pwl_Vc_norm4095[0][0][0][0];
+		pointer_y_float=&globals.Flash.ampl_pwl_amp[0][0][0][0];
+		size_of_x_int=sizeof(globals.Flash.ampl_pwl_Vc_norm4095);
+		size_of_y_float=sizeof(globals.Flash.ampl_pwl_amp);
+
+		Set_VI_Control(pwl_ampl_values,channel,globals.ChannelState[channel].amplitude,&point_found,
+		               &range,&polarity,&entry,&word_out,&actual_pol);
+		old_val=globals.ChannelState[channel].amplitude;
+		abs_cal_point=fabs(cal_point);	/* ampl data is positive always */
+
+		/* special amplitude polarity check */
+
+		if ( (cal_point>0.0 && old_val<0.0) || (cal_point<0.0 && old_val>0.0)) {
+			return CalibrationPolarityError;
+		}
+
+		break;
+	case (pwl_os_values):
+		max_polarity=os_polarities;
+		max_ranges=os_ranges;
+		pointer_x_int=&globals.Flash.os_pwl_Vc_norm4095[0][0][0][0];
+		pointer_y_float=&globals.Flash.os_pwl_amp[0][0][0][0];
+		size_of_x_int=sizeof(globals.Flash.os_pwl_Vc_norm4095);
+		size_of_y_float=sizeof(globals.Flash.os_pwl_amp);
+
+		old_val=globals.ChannelState[channel].offset;
+		Set_VI_Control(pwl_os_values,channel,old_val,&point_found,
+		               &range,&polarity,&entry,&word_out,&actual_pol);
+		break;
+	case pwl_pw_values:
+		max_polarity=timing_polarities;
+		max_ranges=timing_ranges;
+		pointer_x_int=&globals.Flash.pw_pwl_Vc_norm4095[0][0][0][0];
+		pointer_y_float=&globals.Flash.pw_pwl_time[0][0][0][0];
+		size_of_x_int=sizeof(globals.Flash.pw_pwl_Vc_norm4095);
+		size_of_y_float=sizeof(globals.Flash.pw_pwl_time);
+		old_val=globals.ChannelState[channel].pw;
+		Set_VI_Control(pwl_pw_values,channel,old_val,&point_found,
+		               &range,&polarity,&entry,&word_out,&actual_pol);
+		break;
+	case pwl_delay_values:
+		max_polarity=timing_polarities;
+		max_ranges=timing_ranges;
+		pointer_x_int=&globals.Flash.delay_pwl_Vc_norm4095[0][0][0][0];
+		pointer_y_float=&globals.Flash.delay_pwl_time[0][0][0][0];
+		size_of_x_int=sizeof(globals.Flash.delay_pwl_Vc_norm4095);
+		size_of_y_float=sizeof(globals.Flash.delay_pwl_time);
+		old_val=globals.ChannelState[channel].delay;
+		Set_VI_Control(pwl_delay_values,channel,old_val,&point_found,
+		               &range,&polarity,&entry,&word_out,&actual_pol);
+		break;
+	case pwl_period_values:
+		max_polarity=timing_polarities;
+		max_ranges=timing_ranges;
+		pointer_x_int=&globals.Flash.period_pwl_Vc_norm4095[0][0][0][0];
+		pointer_y_float=&globals.Flash.period_pwl_time[0][0][0][0];
+		size_of_x_int=sizeof(globals.Flash.period_pwl_Vc_norm4095);
+		size_of_y_float=sizeof(globals.Flash.period_pwl_time);
+		old_val=1.0/globals.ChannelState[channel].frequency;
+		Set_VI_Control(pwl_period_values,channel,old_val,&point_found,
+		               &range,&polarity,&entry,&word_out,&actual_pol);
+		break;
+	case pwl_burst_values:
+		max_polarity=timing_polarities;
+		max_ranges=timing_ranges;
+		pointer_x_int=&globals.Flash.burst_pwl_Vc_norm4095[0][0][0][0];
+		pointer_y_float=&globals.Flash.burst_pwl_time[0][0][0][0];
+		size_of_x_int=sizeof(globals.Flash.burst_pwl_Vc_norm4095);
+		size_of_y_float=sizeof(globals.Flash.burst_pwl_time);
+		old_val=globals.ChannelState[channel].burst_time;
+		Set_VI_Control(pwl_burst_values,channel,old_val,&point_found,
+		               &range,&polarity,&entry,&word_out,&actual_pol);
+		break;
+	case pwl_rise_time_values:
+		max_polarity=ampl_polarities;
+		max_ranges=ampl_ranges;
+		pointer_x_int=&globals.Flash.rise_time_pwl_Vc_norm4095[0][0][0][0];
+		pointer_y_float=&globals.Flash.rise_time_pwl_time[0][0][0][0];
+		size_of_x_int=sizeof(globals.Flash.rise_time_pwl_Vc_norm4095);
+		size_of_y_float=sizeof(globals.Flash.rise_time_pwl_time);
+		old_val=globals.ChannelState[channel].rise_time;
+		Set_VI_Control(pwl_rise_time_values,channel,old_val,&point_found,
+		               &range,&polarity,&entry,&word_out,&actual_pol);
+		break;
+	case pwl_slew_values:
+		max_polarity=timing_polarities;
+		max_ranges=timing_ranges;
+		pointer_x_int=&globals.Flash.slew_pwl_Vc_norm4095[0][0][0][0];
+		pointer_y_float=&globals.Flash.slew_pwl_time[0][0][0][0];
+		size_of_x_int=sizeof(globals.Flash.slew_pwl_Vc_norm4095);
+		size_of_y_float=sizeof(globals.Flash.slew_pwl_time);
+		old_val=globals.ChannelState[channel].slew;
+		Set_VI_Control(pwl_slew_values,channel,old_val,&point_found,
+		               &range,&polarity,&entry,&word_out,&actual_pol);
+		break;
+	case pwl_vcc1_values:
+		max_polarity=1;
+		max_ranges=1;
+		true_channel=0;
+		pointer_x_int=&globals.Flash.vcc1_pwl_Vc_norm4095[0][0][0][0];
+		pointer_y_float=&globals.Flash.vcc1_pwl_amp[0][0][0][0];
+		size_of_x_int=sizeof(globals.Flash.vcc1_pwl_Vc_norm4095);
+		size_of_y_float=sizeof(globals.Flash.vcc1_pwl_amp);
+		old_val=globals.ChannelState[true_channel].vcc1;
+		Set_VI_Control(pwl_vcc1_values,channel,old_val,&point_found,
+		               &range,&polarity,&entry,&word_out,&actual_pol);
+		break;
+	case pwl_vcc2_values:
+		max_polarity=1;
+		max_ranges=1;
+		true_channel=0;
+		pointer_x_int=&globals.Flash.vcc2_pwl_Vc_norm4095[0][0][0][0];
+		pointer_y_float=&globals.Flash.vcc2_pwl_amp[0][0][0][0];
+		size_of_x_int=sizeof(globals.Flash.vcc2_pwl_Vc_norm4095);
+		size_of_y_float=sizeof(globals.Flash.vcc2_pwl_amp);
+		old_val=globals.ChannelState[true_channel].vcc2;
+		Set_VI_Control(pwl_vcc2_values,channel,old_val,&point_found,
+		               &range,&polarity,&entry,&word_out,&actual_pol);
+		break;
+	case pwl_load_type_values:
+		max_polarity=load_type_polarities;
+		max_ranges=load_type_ranges;
+		pointer_x_int=&globals.Flash.load_type_pwl_Vc_norm4095[0][0][0][0];
+		pointer_y_float=&globals.Flash.load_type_pwl_time[0][0][0][0];
+		size_of_x_int=sizeof(globals.Flash.load_type_pwl_Vc_norm4095);
+		size_of_y_float=sizeof(globals.Flash.load_type_pwl_time);
+		old_val=globals.ChannelState[channel].load_type;
+		Set_VI_Control(pwl_load_type_values,channel,old_val,&point_found,
+		               &range,&polarity,&entry,&word_out,&actual_pol);
+		break;
+
+	}
+
+	temp_y_float[max_points]=0.0;		/* Adding a cal point may temporarily result in 11 data points. */
+	temp_x_float[max_points]=0.0;		/* One is eventually discarded. */
+	temp_x_int[max_points]=0;
+
+
+	index=true_channel*max_ranges*max_polarity*max_points
+	      +range*max_polarity*max_points
+	      +polarity*max_points;
+
+
+	/* make a copy of the calibration data in this range */
+	for (i=0; i<max_points; i++) {
+		temp_y_float[i]=pointer_y_float[index+i];		/* work on this data */
+		temp_x_int[i]=pointer_x_int[index+i];
+	}
+
+
+	/* check range for maximum value, and number of points */
+	max_in_range=0.0;
+	total=max_points;
+	for (i=max_points-1; i>=0; --i) {
+		if ( 	fabs(temp_y_float[i])<smallest_allowed_number && (total==i+1)) {
+			--total;
+		}
+		if (fabs(temp_y_float[i])>max_in_range) {
+			max_in_range=fabs(temp_y_float[i]);
+		}
+	}
+
+
+	/*	check for excessive deviation between old and new amplitudes at this range/word combination */
+	if (fabs(cal_point-old_val) > max_in_range/3.0) {
+		return CalibrationPercentError;
+	}
+	/* check for overly-close data points */
+	if ( word_out==temp_x_int[entry] ) {
+		return CalibrationClosenessError;
+	}
+	if ( word_out==temp_x_int[entry+1]) {
+		return CalibrationClosenessError;
+	}
+
+
+
+	/* move old data over */
+	for (i=max_points-1; i>entry; i--) {
+		temp_y_float[i+1]=temp_y_float[i];
+		temp_x_int[i+1]=temp_x_int[i];
+	}
+
+
+	/*	add the new data */
+	temp_y_float[entry+1]=abs_cal_point;
+	temp_x_int[entry+1]=word_out;
+	for (i=0; i<=max_points; ++i) {
+		temp_x_float[i]=(float) temp_x_int[i];
+	}
+
+
+	/* delete a point, if required */
+	if (total==max_points) {
+		least_integrated_error=1e18;
+
+		for (i=1; i<max_points; i++) {	/* end points are not considered for deletion */
+			/* calculate interpolated amplitude, if this cal point was deleted */
+			fraction = 	(temp_x_float[i]-temp_x_float[i-1]) / (temp_x_float[i+1]-temp_x_float[i-1]);
+			interp_ampl = temp_y_float[i-1] + (fraction * (temp_y_float[i+1]-temp_y_float[i-1]));
+
+			/* calculate percent error at interpolated point */
+			integrated_error = fabs( (interp_ampl-temp_y_float[i])/temp_y_float[i]);
+
+			/* calculate intergrated error */
+			integrated_error *= fabs( temp_y_float[i+1] - temp_y_float[i-1] );
+
+			if (integrated_error<least_integrated_error) {
+				delete_point=i;
+				least_integrated_error=integrated_error;
+			}
+		}
+
+		/* delete the point that is most linear with the two around it */
+		for (i=delete_point; i<max_points; i++) {
+			temp_y_float[i]=temp_y_float[i+1];
+			temp_x_float[i]=temp_x_float[i+1];
+			temp_x_int[i]=temp_x_int[i+1];
+		}
+	}
+
+
+	/* store new calibration data for this range */
+	for (i=0; i<max_points; i++) {
+		*(float *)(&pointer_y_float[index+i])=temp_y_float[i];
+		*(int *)(&pointer_x_int[index+i])=temp_x_int[i];
+	}
+
+	eprom_loc = (char *) pointer_x_int - (char *) &(globals.Flash.flash_start);
+	writeUserBlock(eprom_loc,&globals.Flash.flash_start + eprom_loc,size_of_x_int);
+
+	eprom_loc = (char *) pointer_y_float - (char *) &(globals.Flash.flash_start);
+	writeUserBlock(eprom_loc,&globals.Flash.flash_start + eprom_loc,size_of_y_float);
+
+	globals.Flags.extended_ampl_min_max=NO;
+
+	/* update output */
+	switch (parameter) {
+	case (pwl_ampl_values):
+	case (pwl_vcc1_values):
+	case (pwl_vcc2_values):
+		Set_Amplitude(0,0,0,0,0,0,channel,cal_point,0);
+		break;
+
+	case (pwl_os_values):
+		Set_Offset(0,0,0,0,channel,cal_point);
+		break;
+
+	case pwl_pw_values:
+		Set_Pw(0,0,0,channel,cal_point,0);
+		break;
+
+	case pwl_delay_values:
+		Set_Delay(0,0,0,channel,cal_point);
+		break;
+
+	case pwl_period_values:
+		Set_frequency(0,0,0,channel,cal_point);
+		break;
+
+	case pwl_burst_values:
+		Set_Burst_Time(0,0,0,channel,cal_point);
+		break;
+
+	case pwl_rise_time_values:
+		Set_rise_time(0,0,0,channel,cal_point);
+		break;
+
+	case pwl_slew_values:
+		Set_slew(0,0,0,channel,cal_point);
+		break;
+
+	case pwl_load_type_values:
+		Set_avrq_res(0,0,0,channel,cal_point);
+		break;
+	}
+
+	return OK;
+}
+
+
+int Get_VI_Num_Pnts(int parameter,int channel)
+{
+	int dummy1,dummy2,dummy3,num_in_range,num_of_ranges;
+
+	return Get_VI_Rng_Info(parameter,channel,0,&dummy1,&dummy2,&dummy3,&num_in_range,&num_of_ranges);
+}
+
+
+
+int Get_VI_Rng_Info(int parameter, int channel, int calibration_point_number, int *range,
+                    int *polarity, int *entry, int *num_in_range, int *num_of_ranges)
+{
+	int x_polarity,x_range,x_entry,total;
+	int num_in_current_range;
+	int max_polarity,max_points,max_ranges;
+	float *pwl;
+	int index;
+	int true_channel;
+
+	true_channel=channel;
+
+	*polarity=0;
+	*range=0;
+	*entry=0;
+	*num_in_range=0;
+
+	/* determine array structure */
+	max_points=points_in_range;
+
+	switch (parameter) {
+	case pwl_ampl_values:
+		max_polarity=ampl_polarities;
+		max_ranges=ampl_ranges;
+		pwl=&globals.Flash.ampl_pwl_amp[0][0][0][0];
+		break;
+	case pwl_os_values:
+		max_polarity=os_polarities;
+		max_ranges=os_ranges;
+		pwl=&globals.Flash.os_pwl_amp[0][0][0][0];
+		break;
+	case pwl_pw_values:
+		max_polarity=timing_polarities;
+		max_ranges=timing_ranges;
+		pwl=&globals.Flash.pw_pwl_time[0][0][0][0];
+		break;
+	case pwl_delay_values:
+		max_polarity=timing_polarities;
+		max_ranges=timing_ranges;
+		pwl=&globals.Flash.delay_pwl_time[0][0][0][0];
+		break;
+	case pwl_period_values:
+		max_polarity=timing_polarities;
+		max_ranges=timing_ranges;
+		pwl=&globals.Flash.period_pwl_time[0][0][0][0];
+		break;
+	case pwl_burst_values:
+		max_polarity=timing_polarities;
+		max_ranges=timing_ranges;
+		pwl=&globals.Flash.burst_pwl_time[0][0][0][0];
+		break;
+	case pwl_rise_time_values:
+		max_polarity=ampl_polarities;
+		max_ranges=ampl_ranges;
+		pwl=&globals.Flash.rise_time_pwl_time[0][0][0][0];
+		break;
+	case pwl_slew_values:
+		max_polarity=timing_polarities;
+		max_ranges=timing_ranges;
+		pwl=&globals.Flash.slew_pwl_time[0][0][0][0];
+		break;
+	case pwl_vcc1_values:
+		max_polarity=1;
+		max_ranges=1;
+		pwl=&globals.Flash.vcc1_pwl_amp[0][0][0][0];
+		true_channel=0;
+		break;
+	case pwl_vcc2_values:
+		max_polarity=1;
+		max_ranges=1;
+		pwl=&globals.Flash.vcc2_pwl_amp[0][0][0][0];
+		true_channel=0;
+		break;
+	case pwl_load_type_values:
+		max_polarity=load_type_polarities;
+		max_ranges=load_type_ranges;
+		pwl=&globals.Flash.load_type_pwl_time[0][0][0][0];
+		break;
+	}
+
+
+
+	total=0;
+	*num_of_ranges=0;
+
+	for (x_polarity=0; x_polarity<max_polarity; x_polarity++)
+		for (x_range=0; x_range<max_ranges; x_range++) {
+
+			/* determine number of data points in range */
+			/* do this by counting number of zeroes at top end of array */
+			num_in_current_range=max_points;
+			for (x_entry=max_points-1; x_entry>=0; --x_entry) {
+				/* pwl is a pointer to either the amplitude or offset control array. */
+				/* Multidimensional pointer arrays are not possible, since the array size */
+				/* is unknown at compilation time. Thus, the index offset has to be calculated manually. */
+				index=true_channel*max_ranges*max_polarity*max_points
+				      +x_range*max_polarity*max_points
+				      +x_polarity*max_points
+				      +x_entry;
+				if ( 	fabs(pwl[index])<smallest_allowed_number && (num_in_current_range==x_entry+1)) {
+					--num_in_current_range;
+				}
+			}
+
+			if (num_in_current_range) {
+				*num_of_ranges=x_range;
+
+				for (x_entry=0; x_entry<num_in_current_range; x_entry++) {
+					++total;
+					if (total==calibration_point_number) {
+						calibration_point_number=0;  /* to prevent further matches */
+						*range=x_range;
+						*polarity=x_polarity;
+						*entry=x_entry;
+						*num_in_range=num_in_current_range;
+					}
+				}
+			}
+		}
+
+	return total;
+}
+
+
+int Check_MinMax_Cal(int channel,int parameter)
+{
+	int status;
+
+	status=OK;
+
+	/* see if new point prevents zero, min, max, or current value from being obtained */
+	switch (parameter) {
+	case (pwl_ampl_values):
+		status=Set_Amplitude(1,0,0,0,0,0,channel,globals.Flash.min_ampl[channel],0)
+		       || Set_Amplitude(1,0,0,0,0,0,channel,globals.Flash.max_ampl[channel],0)
+		       || Set_Amplitude(1,0,0,0,0,0,channel,0.0,0);
+		break;
+
+	case (pwl_os_values):
+		status=Set_Offset(1,0,0,0,channel,globals.Flash.min_offset[channel])
+		       || Set_Offset(1,0,0,0,channel,globals.Flash.max_offset[channel])
+		       || Set_Offset(1,0,0,0,channel,0.0);
+		break;
+
+	case pwl_pw_values:
+		status=Set_Pw(1,0,0,channel,globals.Flash.min_pw[channel],0)
+		       || Set_Pw(1,0,0,channel,globals.Flash.max_pw[channel],0);
+		break;
+
+	case pwl_delay_values:
+		status=Set_Delay(1,0,0,channel,globals.Flash.min_delay[channel])
+		       || Set_Delay(1,0,0,channel,globals.Flash.max_delay[channel]);
+		break;
+
+	case pwl_period_values:
+		status=Set_frequency(1,0,0,channel,globals.Flash.min_freq[channel])
+		       || Set_frequency(1,0,0,channel,globals.Flash.max_freq[channel]);
+		break;
+
+	case pwl_burst_values:
+		status=Set_Burst_Time(1,0,0,channel,globals.Flash.min_burst_gap[channel])
+		       || Set_Burst_Time(1,0,0,channel,globals.Flash.max_burst_gap[channel]);
+		break;
+
+	case pwl_rise_time_values:
+		status=Set_rise_time(1,0,0,channel,globals.Flash.min_rise_time[channel])
+		       || Set_rise_time(1,0,0,channel,globals.Flash.max_rise_time[channel]);
+		break;
+
+	case pwl_slew_values:
+		status=Set_slew(1,0,0,channel,globals.Flash.min_slew[channel])
+		       || Set_slew(1,0,0,channel,globals.Flash.max_slew[channel]);
+		break;
+
+	case (pwl_vcc1_values):
+		status=Set_Amplitude(1,0,0,0,0,0,channel,0.0,0)
+		       || Set_Amplitude(1,0,0,0,0,0,channel,globals.Flash.vcc1_max[0],0);
+		break;
+
+	case (pwl_vcc2_values):
+		status=Set_Amplitude(1,0,0,0,0,0,channel,0.0,0)
+		       || Set_Amplitude(1,0,0,0,0,0,channel,globals.Flash.vcc2_max[0],0);
+		break;
+
+	case pwl_load_type_values:
+		status=Set_avrq_res(1,0,0,channel,globals.Flash.low_load_type[channel])
+		       || Set_avrq_res(1,0,0,channel,globals.Flash.high_load_type[channel]);
+		break;
+	}
+
+	if (status) {
+		/* change the error code to a calibration-related one */
+		status=CalibrationMinMaxError;
+	}
+
+	return status;
+}
+
+
+int control_pcb107(int address, int dac, int word, int range)
+{
+	/* reset all lines */
+	I2C_Write(PCF8574+address,0);
+
+	set_dac(dac,word);
+
+	/* send and load range data */
+	I2C_Write(PCF8574+address,(range << 3));
+	I2C_Write(PCF8574+address,(range << 3) | 0x80);
+
+	/* clear the lines */
+	I2C_Write(PCF8574+address,0);
+
+	return OK;
+}
+
+
+int Set_Burst_Count(int channel,int count,float new_burst_time)
+{
+	int check_valid;
+	int hextext_out;
+
+	if (globals.Flash.max_burst_count[channel]<=1) {
+		return Unrecognized;
+	}
+
+	/* abandon if high channel selected by user but not enabled by firmware */
+	if (channel && !globals.Flash.ChanKey_Burst_Count) {
+		return InvalidChannel;
+	}
+
+	/* check duty cycle */
+	int i;
+	for (i=0; i<max_channels; ++i) {
+		TestState[i]=globals.ChannelState[i];
+	}
+	TestState[channel].burst_count=count;
+	if ((check_valid=Error_check(TestState))) {
+		return check_valid;
+	}
+
+	/* update variables if OK */
+	if (count!=globals.ChannelState[channel].burst_count) {
+		globals.Changes.update_burst_count=YES;
+	}
+
+	globals.ChannelState[channel].burst_count = count;
+	Set_Update_Chans();
+
+	if (!globals.Flash.burst_func[channel]) {
+		/* Call update routine for pulse generator burst mode. */
+		/* Update pulse separation at the same time. This routine does the actual changes. */
+		Set_Burst_Time(0,0,0,channel,new_burst_time);
+	} else {
+		/* reset all lines */
+		I2C_Write(PCF8574+Second_PW_Port,0);
+
+		/* send first hextet */
+		hextext_out=globals.ChannelState[channel].burst_count & 0x003f;
+
+		I2C_Write(PCF8574+Second_PW_Port, hextext_out);
+		/* load hextet */
+		I2C_Write(PCF8574+Second_PW_Port, hextext_out | 0x40 );
+
+		/* send second hextet */
+		if (globals.ChannelState[channel].burst_count > 0) {
+			/* set "not_reset" bit high to enable burst mode for N > 0 */
+			hextext_out = ((globals.ChannelState[channel].burst_count >> 6) & 0x07) | 0x08;
+		} else {
+			hextext_out = 0;
+		}
+
+		I2C_Write(PCF8574+Second_PW_Port, hextext_out);
+		/* load hextet */
+		I2C_Write(PCF8574+Second_PW_Port, hextext_out | 0x80 );
+
+		/* clear the lines */
+		I2C_Write(PCF8574+Second_PW_Port,0);
+
+	}
+
+	return OK;
+}
+
+
+int Set_Burst_Time(int check_possible_only,int word_override,int range_override,int channel,float new_burst_time)
+{
+	int check_valid;
+	int count_word_out;
+	int hextext_out;
+	int status,point_found,relay_range,UseNegData,entry,actual_pol,word_out;
+
+	if (globals.Flash.max_burst_count[channel]<=1) {
+		return Unrecognized;
+	}
+
+	/* abandon if high channel selected by user but not enabled by firmware */
+	if (channel && !globals.Flash.ChanKey_Burst_Time) {
+		return InvalidChannel;
+	}
+
+	if (!check_possible_only) {
+		/* check duty cycle */
+		int i;
+		for (i=0; i<max_channels; ++i) {
+			TestState[i]=globals.ChannelState[i];
+		}
+		TestState[channel].burst_time=new_burst_time;
+		if ((check_valid=Error_check(TestState))) {
+			return check_valid;
+		}
+	}
+
+	/* tweak count based on actual circuit */
+	count_word_out = globals.ChannelState[channel].burst_count - 1;
+
+	/* find appropriate range/fine settings from piece-wise linear data in flash memory */
+	if (word_override) {
+		word_out=word_override;
+		relay_range=range_override;
+	} else {
+		if ((status=Set_VI_Control(pwl_burst_values,channel,new_burst_time,&point_found,
+		                           &relay_range,&UseNegData,&entry,&word_out,&actual_pol))) {
+			return status;
+		}
+	}
+
+	if (check_possible_only) {
+		if (point_found) {
+			return OK;
+		} else {
+			return CalibrationMinMaxError;
+		}
+	}
+
+	start_gate_override ();
+
+	/* update DAC */
+	set_dac(6,word_out);
+
+
+	/* update range and burst count */
+
+	/* reset all lines */
+	I2C_Write(PCF8574+Second_PW_Port,0);
+
+	/* send first hextet */
+	hextext_out=count_word_out & 0x003f;
+
+	I2C_Write(PCF8574+Second_PW_Port, hextext_out);
+	/* load hextet */
+	I2C_Write(PCF8574+Second_PW_Port, hextext_out | 0x40 );
+
+	/* send second hextet */
+	hextext_out=	((count_word_out >> 6) & 0x07) | ((relay_range	 << 3) & 0x0038);
+
+	I2C_Write(PCF8574+Second_PW_Port, hextext_out);
+	/* load hextet */
+	I2C_Write(PCF8574+Second_PW_Port, hextext_out | 0x80 );
+
+	/* clear the lines */
+	I2C_Write(PCF8574+Second_PW_Port,0);
+
+	if (globals.Registers.last_relay_driver_settings[2] != relay_range) {
+		g_usleep (1e3 * globals.Timers.normal_relay_bounce_time_in_milliseconds);
+	}
+	stop_gate_override ();
+
+	globals.Registers.last_relay_driver_settings[2] = relay_range;
+
+	/* update variables if OK */
+	if (new_burst_time!=globals.ChannelState[channel].burst_time) {
+		globals.Changes.update_burst_time=YES;
+	}
+
+	globals.ChannelState[channel].burst_time = new_burst_time;
+
+	Set_Update_Chans();
+
+	return OK;
+}
+
+
+int Set_rise_time(int check_possible_only,int word_override,int range_override,int channel,float new_rise_time)
+{
+	int check_valid;
+	int status,point_found,relay_range,UseNegData,entry,actual_pol,word_out;
+	char range_control;
+
+	if (globals.Flash.fixed_rise_time[channel]) {
+		return Unrecognized;
+	}
+
+	/* abandon if high channel selected by user but not enabled by firmware */
+	if (channel && !globals.Flash.ChanKey_rise_time) {
+		return InvalidChannel;
+	}
+
+	if (!check_possible_only) {
+		/* check duty cycle */
+		int i;
+		for (i=0; i<max_channels; ++i) {
+			TestState[i]=globals.ChannelState[i];
+		}
+		TestState[channel].rise_time=new_rise_time;
+		if ((check_valid=Error_check(TestState))) {
+			return check_valid;
+		}
+	}
+
+	/* find appropriate range/fine settings from piece-wise linear data in flash memory */
+	if (word_override) {
+		word_out=word_override;
+		relay_range=range_override;
+	} else {
+		if ((status=Set_VI_Control(pwl_rise_time_values,channel,new_rise_time,&point_found,
+		                           &relay_range,&UseNegData,&entry,&word_out,&actual_pol))) {
+			return status;
+		}
+	}
+
+	if (check_possible_only) {
+		if (point_found) {
+			return OK;
+		} else {
+			return CalibrationMinMaxError;
+		}
+	}
+
+	set_dac(globals.Flash.rise_time_dac[channel],word_out);
+
+	if (!globals.Flash.pcb_203a_rise_time[channel]) {
+		/* original AVRQ PCB */
+		switch (relay_range) {
+		case 0:
+			range_control = (char) 0x01;
+			break;
+		case 1:
+			range_control = (char) 0x08;
+			break;
+		case 2:
+			range_control = (char) 0x10;
+			break;
+		case 3:
+			range_control = (char) 0x20;
+			break;
+		case 4:
+			range_control = (char) 0x40;
+			break;
+		case 5:
+			range_control = (char) 0x80;
+			break;
+		case 6:
+		case 7:
+			return HardwareError;
+			break;
+		}
+	} else {
+		/* PCB 203A */
+		switch (relay_range) {
+		case 0:
+			range_control = (char) 0x0f;
+			break;
+		case 1:
+			range_control = (char) 0x02;
+			break;
+		case 2:
+			range_control = (char) 0x04;
+			break;
+		case 3:
+			range_control = (char) 0x08;
+			break;
+		case 4:
+			range_control = (char) 0x10;
+			break;
+		case 5:
+		case 6:
+		case 7:
+			return HardwareError;
+			break;
+		}
+	}
+
+
+
+	if (globals.Registers.last_rise_time_relay_setting != range_control) {
+		/* update range hardware */
+		if (globals.ChannelState[channel].trigger_source!=source_hold) {
+			bus_setpin(O_GATE, 1);
+		}
+
+		if (!globals.Flash.pcb_203a_rise_time[channel]) {
+			I2C_Write(PCF8574A+rise_time_port,range_control);
+		} else {
+			globals.Registers.avrq_reg = (range_control & 0x1f) |
+			                             (globals.Registers.avrq_reg & 0xe0);
+			I2C_Write(PCF8574A+rise_time_port,globals.Registers.avrq_reg);
+		}
+		g_usleep (5e5);
+
+		if (globals.ChannelState[channel].trigger_source!=source_hold) {
+			bus_setpin(O_GATE, 0);
+		}
+	}
+
+	/* update variables if OK */
+	if (new_rise_time!=globals.ChannelState[channel].rise_time) {
+		globals.Changes.update_rise_time=YES;
+	}
+
+	globals.ChannelState[channel].rise_time = new_rise_time;
+	globals.Registers.last_rise_time_relay_setting = range_control;
+
+	Set_Update_Chans();
+
+	return OK;
+}
+
+
+int Set_current_limit(int check_possible_only,int channel,float new_adj_current_limit)
+{
+	int check_valid;
+	float limit;
+	int word_out;
+
+	if (!globals.Flash.hard_current_limit_enabled[channel]) {
+		return Unrecognized;
+	}
+
+	/* abandon if high channel selected by user but not enabled by firmware */
+	if (channel && !globals.Flash.ChanKey_current_limit) {
+		return InvalidChannel;
+	}
+
+	if (!check_possible_only) {
+		int i;
+		for (i=0; i<max_channels; ++i) {
+			TestState[i]=globals.ChannelState[i];
+		}
+		TestState[channel].soft_current_limit=new_adj_current_limit;
+		if ((check_valid=Error_check(TestState))) {
+			return check_valid;
+		}
+	}
+
+	if (globals.ChannelState[channel].func_mode==dc_mode_on) {
+		limit=globals.Flash.current_limit_dc_mode[channel];
+	} else {
+		limit=globals.Flash.current_limit_pulse_mode[channel];
+	}
+
+	if (globals.Flash.soft_current_limit_enabled[channel] && (new_adj_current_limit<limit)) {
+		limit=new_adj_current_limit;
+	}
+
+	word_out = (int) ( ((float) dac_max) * (limit/globals.Flash.current_limit_full_scale[channel]) );
+	set_dac(globals.Flash.current_limit_dac[channel],word_out);
+
+	/* update variables if OK */
+	if (limit!=globals.ChannelState[channel].soft_current_limit) {
+		globals.Changes.update_soft_current_limit=YES;
+	}
+
+	globals.ChannelState[channel].soft_current_limit=limit;
+
+	return OK;
+}
+
+
+int Set_avrq_res(int check_possible_only,int word_override,int range_override,int channel,float new_res)
+{
+	int check_valid;
+	int status,point_found,relay_range,UseNegData,entry,actual_pol,word_out;
+
+	float compensated_new_res;
+
+	if (!globals.Flash.switchable_load[channel]) {
+		return Unrecognized;
+	}
+
+	/* abandon if high channel selected by user but not enabled by firmware */
+	if (channel && !globals.Flash.ChanKey_load_type) {
+		return InvalidChannel;
+	}
+
+	if (!check_possible_only) {
+		int i;
+		for (i=0; i<max_channels; ++i) {
+			TestState[i]=globals.ChannelState[i];
+		}
+		TestState[channel].load_type=new_res;
+		if ((check_valid=Error_check(TestState))) {
+			return check_valid;
+		}
+	}
+
+	/* find appropriate range/fine settings from piece-wise linear data in flash memory */
+	if (word_override) {
+		word_out=word_override;
+		relay_range=range_override;
+	} else {
+		/* ugly hack - fix me?
+		   CH2 = opto VCC
+		   Calibrate res at 3.0V
+		   Compensate for >3.0V */
+		if (globals.ChannelState[0].vcc2 > 0.0) {
+			compensated_new_res = new_res * 3.0/globals.ChannelState[0].vcc2;
+		} else {
+			return amplitude_lower_limit;
+		}
+
+		if ((status=Set_VI_Control(pwl_load_type_values,channel,compensated_new_res,&point_found,
+		                           &relay_range,&UseNegData,&entry,&word_out,&actual_pol))) {
+			return status;
+		}
+	}
+
+	if (check_possible_only) {
+		if (point_found) {
+			return OK;
+		} else {
+			return CalibrationMinMaxError;
+		}
+	}
+
+	set_dac(globals.Flash.load_type_dac[channel],word_out);
+
+	/* no ranges are used */
+
+	/* update variables if OK */
+	if (new_res!=globals.ChannelState[channel].load_type) {
+		globals.Changes.update_load=YES;
+	}
+
+	globals.ChannelState[channel].load_type = new_res;
+
+	Set_Update_Chans();
+
+	return OK;
+}
+
+
+int Set_slew(int check_possible_only,int word_override,int range_override,int channel,float new_slew)
+{
+	int check_valid;
+	int status,point_found,relay_range,UseNegData,entry,actual_pol,word_out;
+	char range_control;
+
+	if (!globals.Flash.curr_slew[channel]) {
+		return Unrecognized;
+	}
+
+	/* abandon if high channel selected by user but not enabled by firmware */
+	if (channel && !globals.Flash.ChanKey_slew) {
+		return InvalidChannel;
+	}
+
+	if (!check_possible_only) {
+		/* check duty cycle */
+		int i;
+		for (i=0; i<max_channels; ++i) {
+			TestState[i]=globals.ChannelState[i];
+		}
+		TestState[channel].slew=new_slew;
+		if ((check_valid=Error_check(TestState))) {
+			return check_valid;
+		}
+	}
+
+	/* find appropriate range/fine settings from piece-wise linear data in flash memory */
+	if (word_override) {
+		word_out=word_override;
+		relay_range=range_override;
+	} else {
+		if ((status=Set_VI_Control(pwl_slew_values,channel,new_slew,&point_found,
+		                           &relay_range,&UseNegData,&entry,&word_out,&actual_pol))) {
+			return status;
+		}
+	}
+
+	if (check_possible_only) {
+		if (point_found) {
+			return OK;
+		} else {
+			return CalibrationMinMaxError;
+		}
+	}
+
+	set_dac(globals.Flash.slew_dac[channel],word_out);
+
+	switch (relay_range) {
+	case 0:
+		range_control = 0x0f;
+		break;
+	case 1:
+		range_control = 0x07;
+		break;
+	case 2:
+		range_control = 0x03;
+		break;
+	case 3:
+		range_control = 0x01;
+		break;
+	case 4:
+	default:
+		range_control = 0x00;
+		break;
+	}
+
+	I2C_Write(PCF8574,range_control);
+
+	/* update variables if OK */
+	if (new_slew!=globals.ChannelState[channel].slew) {
+		globals.Changes.update_slew=YES;
+	}
+
+	globals.ChannelState[channel].slew = new_slew;
+
+	Set_Update_Chans();
+
+	return OK;
+}
+
+
+int Set_avrq_ampl(int check_possible_only,int word_override,int range_override,int channel,float new_avrq_ampl)
+{
+	int check_valid;
+	int status,point_found,relay_range,UseNegData,entry,actual_pol,word_out;
+	int true_channel;
+	int use_pwl;
+
+	if (!globals.Flash.enable_avrq_extra_ampls) {
+		return Unrecognized;
+	}
+
+	/* check channels */
+	if ((channel < 1) || (channel>4)) {
+		return InvalidChannel;
+	}
+
+	if (channel == 1) {
+		true_channel = 1;
+	} else {
+		true_channel = 0;
+	}
+
+	if (!check_possible_only) {
+		/* check duty cycle */
+		int i;
+		for (i=0; i<max_channels; ++i) {
+			TestState[i]=globals.ChannelState[i];
+		}
+		switch (channel) {
+		case 1:
+			TestState[true_channel].amplitude=new_avrq_ampl;
+			break;
+		case 2:
+			TestState[true_channel].vcc1=new_avrq_ampl;
+			if (TestState[true_channel].vlogic >= smallest_allowed_number) {
+				TestState[true_channel].vlogic = new_avrq_ampl;
+			}
+			break;
+		case 3:
+			TestState[true_channel].vcc2=new_avrq_ampl;
+			break;
+		case 4:
+			TestState[true_channel].vlogic=new_avrq_ampl;
+			break;
+		}
+		if ((check_valid=Error_check(TestState))) {
+			return check_valid;
+		}
+	}
+
+	/* find appropriate range/fine settings from piece-wise linear data in flash memory */
+	if (word_override) {
+		word_out=word_override;
+		relay_range=range_override;
+	} else {
+		switch (channel) {
+		case 1:
+			use_pwl = pwl_ampl_values;
+			break;
+		case 2:
+			use_pwl = pwl_vcc1_values;
+			break;
+		case 3:
+			use_pwl = pwl_vcc2_values;
+			break;
+		case 4:
+			use_pwl = pwl_vlogic_values;
+			if (new_avrq_ampl > 0.0) {
+				new_avrq_ampl = globals.ChannelState[true_channel].vcc1;
+			}
+			break;
+		}
+
+		if (use_pwl != pwl_vlogic_values)
+			if ((status=Set_VI_Control(use_pwl,channel,new_avrq_ampl,&point_found,&relay_range,&UseNegData,&entry,&word_out,&actual_pol))) {
+				return status;
+			}
+
+	}
+
+	if (check_possible_only) {
+		if (point_found) {
+			return OK;
+		} else {
+			return CalibrationMinMaxError;
+		}
+	}
+
+
+	/* update variables if OK */
+	switch (channel) {
+	case 1:
+		Set_avrq_ampl(0,0,0,4,0.0);
+
+		set_dac(1,word_out);
+
+		globals.Registers.avrq_reg = globals.Registers.avrq_reg & 0x3f;
+		I2C_Write(PCF8574A+rise_time_port,globals.Registers.avrq_reg);
+
+		if (new_avrq_ampl!=globals.ChannelState[true_channel].amplitude) {
+			globals.Changes.update_amp=YES;
+		}
+		globals.ChannelState[true_channel].amplitude=new_avrq_ampl;
+		break;
+	case 2:
+		set_dac(1,word_out);
+
+		globals.Registers.avrq_reg = 0x40 | (globals.Registers.avrq_reg & 0xbf);
+		I2C_Write(PCF8574A+rise_time_port,globals.Registers.avrq_reg);
+
+		if (new_avrq_ampl!=globals.ChannelState[true_channel].vcc1) {
+			globals.Changes.update_amp=YES;
+		}
+		globals.ChannelState[true_channel].vcc1=new_avrq_ampl;
+		break;
+	case 3:
+		set_dac(0,word_out);
+		if (new_avrq_ampl!=globals.ChannelState[true_channel].vcc2) {
+			globals.Changes.update_amp=YES;
+		}
+		globals.ChannelState[true_channel].vcc2=new_avrq_ampl;
+
+		/* update ampl-dependent load resistance */
+		Set_avrq_res(0,0,0,0,globals.ChannelState[0].load_type);
+
+		break;
+	case 4:
+		if (new_avrq_ampl >= smallest_allowed_number) {
+			relay_range = 0x80;
+		} else {
+			relay_range = 0x0;
+		}
+		globals.Registers.avrq_reg = relay_range | (globals.Registers.avrq_reg & 0x7f);
+		I2C_Write(PCF8574A+rise_time_port,globals.Registers.avrq_reg);
+
+		if (new_avrq_ampl!=globals.ChannelState[true_channel].vlogic) {
+			globals.Changes.update_amp=YES;
+		}
+		globals.ChannelState[true_channel].vlogic=new_avrq_ampl;
+		break;
+	}
+
+
+	/* reduce vlogic based on vcc1, if required */
+	if (channel == 2) {
+		if (globals.ChannelState[true_channel].vlogic > smallest_allowed_number) {
+			Set_avrq_ampl(0,0,0,4,globals.ChannelState[true_channel].vcc1);
+		} else {
+			Set_avrq_ampl(0,0,0,4,0.0);
+		}
+	}
+
+	/* reduce vcc1 if ibias is active, because they share a DAC */
+	if ((channel == 1) && (globals.ChannelState[true_channel].amplitude > smallest_allowed_number)) {
+		globals.ChannelState[0].vcc1=0.0;
+	}
+
+	/* reduce vcc1 if ibias is active, because they share a DAC */
+	if ((channel == 2) && (globals.ChannelState[true_channel].vcc1 > smallest_allowed_number)) {
+		globals.ChannelState[1].amplitude=0.0;
+	}
+
+	Set_Update_Chans();
+
+	return OK;
+}
+
+
+int go_cal(CalStruct *caldata)
+{
+	int i, status, points;
+	float meas, nom_val, change;
+	float min_val, max_val, chk_val;
+	char lcd_msg[LCD_cols+1];
+	char prefix[LCD_cols+1];
+
+	points = Get_VI_Num_Pnts(caldata->cal_type,caldata->channel);
+
+	caldata->count = 0;
+	caldata->error = 0;
+	caldata->max_change = 0.0;
+	caldata->avg_change = 0.0;
+
+	min_val = 100e-6;
+	if (caldata->cal_type == pwl_period_values) {
+		max_val = 4.0 / globals.Flash.min_freq[caldata->channel];
+		chk_val = 0.25 / globals.Flash.max_freq[caldata->channel];
+		if (chk_val > min_val) {
+			min_val = chk_val;
+		}
+	} else if (caldata->cal_type == pwl_pw_values) {
+		max_val = 4.0 * globals.Flash.max_pw[caldata->channel];
+		chk_val = 0.25 * globals.Flash.min_pw[caldata->channel];
+		if (chk_val > min_val) {
+			min_val = chk_val;
+		}
+	} else if (caldata->cal_type == pwl_delay_values) {
+		max_val = 4.0 * globals.Flash.max_delay[caldata->channel];
+	}
+
+	for (i=1; i<=points; i++) {
+		Set_Cal_Nom(caldata->channel,i,caldata->cal_type,&nom_val);
+		if ( (nom_val >= min_val) && (nom_val <= max_val) ) {
+			Set_Cal_Nom(caldata->channel,i,caldata->cal_type,NULL);
+
+			LCD_clear();
+			LCD_write(0,0,"Self-calibration in progress.");
+
+			if (caldata->cal_type == pwl_period_values) {
+				sprintf (prefix, "CH%d PER %d:",caldata->channel+1,i);
+			} else if (caldata->cal_type == pwl_pw_values) {
+				sprintf (prefix, "CH%d PW %d:",caldata->channel+1,i);
+			} else if (caldata->cal_type == pwl_delay_values) {
+				sprintf (prefix, "CH%d DLY %d:",caldata->channel+1,i);
+			}
+			sprintf (lcd_msg, "%s %.3e",prefix,nom_val);
+			LCD_write(2,0,lcd_msg);
+
+			if (caldata->cal_type == pwl_period_values) {
+				I2C_Self_Cal (caldata->channel, MEAS_PRF, &meas, 1.0 / globals.ChannelState[caldata->channel].frequency);
+			} else if (caldata->cal_type == pwl_pw_values) {
+				I2C_Self_Cal (caldata->channel, MEAS_PW, &meas, globals.ChannelState[caldata->channel].pw);
+			} else {
+				I2C_Self_Cal (caldata->channel, MEAS_PW, &meas, globals.ChannelState[caldata->channel].delay);
+			}
+
+			change = 100.0 * (meas-nom_val)/nom_val;
+			status = Set_VI_Cal_Pnt(caldata->cal_type,caldata->channel,i,meas);
+			if (status) {
+				++caldata->error;
+			} else {
+				++caldata->count;
+				if (fabs(change)>caldata->max_change) {
+					caldata->max_change = change;
+				}
+				caldata->avg_change = ((caldata->avg_change * (((float) caldata->count) - 1.0)) + change) / caldata->count;
+			}
+
+			LCD_clear();
+			LCD_write(0,0,"Self-calibration in progress.");
+			sprintf (lcd_msg, "%s %.3e -> %.3e",prefix,nom_val,meas);
+			LCD_write(2,0,lcd_msg);
+			sprintf (lcd_msg, "changed %6.2f%%, err: %d",change,status);
+			LCD_write(3,0,lcd_msg);
+			g_usleep (2e6);
+		}
+	}
+
+	return OK;
+}
+
+
+int cal_string(char *parameter, CalStruct *caldata)
+{
+	char string[max_output_length];
+
+	sprintf(string,"CH%d %s cal: %d errors. Adj: %6.2f%% max, %6.2f%% avg.\n\r", caldata->channel+1,parameter, caldata->error, caldata->max_change, caldata->avg_change);
+	strcat (caldata->response, string);
+}
+
+
+int self_cal()
+{
+	CalStruct caldata;
+	return do_full_self_cal(&caldata);
+}
+
+
+int do_full_self_cal(CalStruct *caldata)
+{
+	char string[LCD_cols+1];
+	long start_timer, diff_timer;
+	int eprom_loc;
+
+	Menu_Clear_Buttons();
+	LCD_clear();              /*0123456789012345678901234567890123456789*/
+	LCD_write(0,0,"Self-calibration in progress.");
+	/*0123456789012345678901234567890123456789*/
+	sprintf(string,"Typical run time: %d min, %d sec.", globals.Flash.self_cal_typical_time_min, globals.Flash.self_cal_typical_time_sec);
+	LCD_write(1,0,string);
+
+	while ((sec_timer() - globals.Timers.startup_timer_value) < (long)globals.Flash.self_cal_pause) {
+		/*0123456789012345678901234567890123456789*/
+		sprintf (string, "Min warm-up is %ds, on for %lds.", globals.Flash.self_cal_pause, sec_timer() - globals.Timers.startup_timer_value);
+		LCD_write(3,0,string);
+		g_usleep (2e5);
+	}
+
+	start_timer = sec_timer();
+	caldata->response[0] = 0;
+	caldata->total_errors = 0;
+	caldata->total_max_change = 0.0;
+
+	caldata->cal_type = pwl_pw_values;
+	for (caldata->channel=0; caldata->channel<(globals.Flash.ChanKey_pw?globals.Flash.channels:1); ++caldata->channel) {
+		go_cal(caldata);
+		cal_string("PW", caldata);
+		caldata->total_errors += caldata->error;
+		if (fabs(caldata->total_max_change) < fabs(caldata->max_change)) {
+			caldata->total_max_change = caldata->max_change;
+		}
+	}
+
+	caldata->cal_type = pwl_delay_values;
+	for (caldata->channel=0; caldata->channel<(globals.Flash.ChanKey_delay?globals.Flash.channels:1); ++caldata->channel) {
+		go_cal(caldata);
+		cal_string("Delay", caldata);
+		caldata->total_errors += caldata->error;
+		if (fabs(caldata->total_max_change) < fabs(caldata->max_change)) {
+			caldata->total_max_change = caldata->max_change;
+		}
+	}
+
+	caldata->cal_type = pwl_period_values;
+	for (caldata->channel=0; caldata->channel<(globals.Flash.ChanKey_frequency?globals.Flash.channels:1); ++caldata->channel) {
+		go_cal(caldata);
+		cal_string("Period", caldata);
+		caldata->total_errors += caldata->error;
+		if (fabs(caldata->total_max_change) < fabs(caldata->max_change)) {
+			caldata->total_max_change = caldata->max_change;
+		}
+	}
+
+	Main_Rst();
+
+	LCD_clear();              /*0123456789012345678901234567890123456789*/
+	LCD_write(0,0,"Self-calibration complete.");
+	sprintf (string, "%d errors. Max change: %6.2f%%", caldata->total_errors, caldata->total_max_change);
+	LCD_write(1,0,string);
+	LCD_write(2,0,"More details are provided by \"cal?\"");
+	g_usleep (3e6);
+
+	Menu_Update_Display();
+
+	diff_timer = sec_timer() - start_timer;
+
+	globals.Flash.self_cal_typical_time_min = (int) (diff_timer / 60);
+	globals.Flash.self_cal_typical_time_sec = (int) (diff_timer % 60);
+
+	sprintf(string,"Completed in %d minutes and %d seconds\n\r", globals.Flash.self_cal_typical_time_min, globals.Flash.self_cal_typical_time_sec);
+	strcat (caldata->response, string);
+
+	eprom_loc = (char *) &(globals.Flash.self_cal_typical_time_min) - (char *) &(globals.Flash.flash_start);
+	writeUserBlock(eprom_loc,&globals.Flash.flash_start + eprom_loc,sizeof(globals.Flash.self_cal_typical_time_min));
+	eprom_loc = (char *) &(globals.Flash.self_cal_typical_time_sec) - (char *) &(globals.Flash.flash_start);
+	writeUserBlock(eprom_loc,&globals.Flash.flash_start + eprom_loc,sizeof(globals.Flash.self_cal_typical_time_sec));
+
+	if (caldata->total_errors) {
+		return SelfCalError;
+	}
+}
+
+int I2C_Self_Cal(int channel, int meas_mode, float *meas, float target_time)
+{
+#define MAX_TRIES 35
+#define AVG_TRIES 4
+
+	int word, buffer, ch_mode;
+	long count;
+	float measuring_time;
+	float min_time;
+	float avg, max_error, this, this_error;
+	int iter, stable,i;
+	float prev[AVG_TRIES];
+
+	for (i=0; i<AVG_TRIES; i++) {
+		prev[i]=0.0;
+	}
+
+	*meas = 0.0;
+	stable = 0;
+
+	if (channel) {
+		ch_mode = MEAS_CH2;
+	} else {
+		ch_mode = MEAS_CH1;
+	}
+
+	measuring_time = 1.0;
+
+	min_time = globals.ChannelState[channel].pw * 3.0;
+	if (min_time > measuring_time) {
+		measuring_time = min_time;
+	}
+
+	min_time = (1.0/globals.ChannelState[channel].frequency);
+	if (min_time > measuring_time) {
+		measuring_time = min_time;
+	}
+
+	if (meas_mode == MEAS_PRF) {
+		min_time = (1.0/globals.ChannelState[channel].frequency) * 3.0;
+		if (min_time > measuring_time) {
+			measuring_time = min_time;
+		}
+	}
+
+	min_time = fabs(globals.ChannelState[channel].delay) * 3.0;
+	if (min_time > measuring_time) {
+		measuring_time = min_time;
+	}
+
+	for (iter = 1; (iter <= MAX_TRIES) && !stable; iter++) {
+
+		if (iter <= LCD_cols) {
+			LCD_write(3,(iter-1) % 35,". ");
+		}
+
+		if (meas_mode == MEAS_PW) {
+			start_gate_override ();
+			// delay to let oscillator reset, within 20% of a period?
+			g_usleep((gulong) (2.0e5 / globals.ChannelState[channel].frequency));
+		}
+
+		// reset counters
+		word = NOT_ENABLE_COUNT | NOT_LOAD_BUFFERS_CLK | CLR_COUNTERS | meas_mode | ch_mode | COUNTER_BYTE_0;
+		I2C_Write(PCF8574+To_Self_Cal_Port,word);
+		word = NOT_ENABLE_COUNT | NOT_LOAD_BUFFERS_CLK | NOT_CLR_COUNTERS | meas_mode | ch_mode | COUNTER_BYTE_0;
+		I2C_Write(PCF8574+To_Self_Cal_Port,word);
+
+		// arm flip-flops
+		word = ENABLE_COUNT | NOT_LOAD_BUFFERS_CLK | NOT_CLR_COUNTERS | meas_mode | ch_mode | COUNTER_BYTE_0;
+		I2C_Write(PCF8574+To_Self_Cal_Port,word);
+		word = NOT_ENABLE_COUNT | NOT_LOAD_BUFFERS_CLK | NOT_CLR_COUNTERS | meas_mode | ch_mode | COUNTER_BYTE_0;
+		I2C_Write(PCF8574+To_Self_Cal_Port,word);
+
+		if (meas_mode == MEAS_PW) {
+			stop_gate_override ();
+		}
+
+		// time to measure
+		g_usleep((gulong) (measuring_time * 1.0e6));
+
+		// latch into buffers
+		word = NOT_ENABLE_COUNT | LOAD_BUFFERS_CLK | NOT_CLR_COUNTERS | meas_mode | ch_mode | COUNTER_BYTE_0;
+		I2C_Write(PCF8574+To_Self_Cal_Port,word);
+		word = NOT_ENABLE_COUNT | NOT_LOAD_BUFFERS_CLK | NOT_CLR_COUNTERS | meas_mode | ch_mode | COUNTER_BYTE_0;
+		I2C_Write(PCF8574+To_Self_Cal_Port,word);
+
+		// read buffers
+		buffer = I2C_Read (PCF8574+From_Self_Cal_Port);
+		count = (long) buffer;
+
+		word = NOT_ENABLE_COUNT | NOT_LOAD_BUFFERS_CLK | NOT_CLR_COUNTERS | meas_mode | ch_mode | COUNTER_BYTE_1;
+		I2C_Write(PCF8574+To_Self_Cal_Port,word);
+		buffer = I2C_Read (PCF8574+From_Self_Cal_Port);
+		count = count | ((long) buffer << 8);
+
+		word = NOT_ENABLE_COUNT | NOT_LOAD_BUFFERS_CLK | NOT_CLR_COUNTERS | meas_mode | ch_mode | COUNTER_BYTE_2;
+		I2C_Write(PCF8574+To_Self_Cal_Port,word);
+		buffer = I2C_Read (PCF8574+From_Self_Cal_Port);
+		count = count | ((long) buffer << 16);
+
+		word = NOT_ENABLE_COUNT | NOT_LOAD_BUFFERS_CLK | NOT_CLR_COUNTERS | meas_mode | ch_mode | COUNTER_BYTE_3;
+		I2C_Write(PCF8574+To_Self_Cal_Port,word);
+		buffer = I2C_Read (PCF8574+From_Self_Cal_Port);
+		count = count | ((long) buffer << 24);
+
+		if (count < 100) {
+			//return SelfCalError;
+			if (iter <= LCD_cols) {
+				LCD_write(3,iter-1,"x");
+			}
+			continue;
+		}
+
+		this = count * 100e-9;
+		max_error = 0.001;
+		avg = 0.0;
+
+		for (i=0; i<(AVG_TRIES-1); i++) {
+			prev[i]=prev[i+1];
+		}
+		prev[AVG_TRIES-1] = this;
+		for (i = 0; i<AVG_TRIES; i++) {
+			avg += (prev[i]/AVG_TRIES);
+		}
+
+		this_error = fabs ((this - avg) / avg);
+		if (this_error < max_error) {
+			stable = 1;
+		}
+	}
+
+	if (!stable) {
+		return SelfCalError;
+	}
+
+	*meas = this;
+	return OK;
+}
+
diff --git a/device-functions.h b/device-functions.h
index f3a28ba..d31cfa9 100644
--- a/device-functions.h
+++ b/device-functions.h
@@ -10,4 +10,60 @@ void idn_string(gchar** response);
 int Set_frequency(int check_possible_only,int word_override,int range_override,int channel,float set_freq);
 void Main_Rst(void);
 
+int set_dac(int dac, int word);
+int Set_Amplitude(int check_possible_only,int pol_override,int override_on,int word_override,int range_override,
+                  int switch_range_only,int channel,float new_ampl,int called_from_set_pw);
+int Set_Pw(int check_possible_only,int word_override,int range_override,int channel,float set_pw,int called_from_set_ampl);
+int Set_Offset(int check_possible_only,int override_on,int word_override,int range_override,int channel,float new_offset);
+int Set_Delay(int check_possible_only,int word_override,int range_override,int channel,float set_delay);
+int Set_Double(int channel,int new_setting);
+void Ctrl_PRF_Limiter(int enable);
+int Set_Mux(int channel);
+int Set_Func(int channel,int mode);
+int Set_Pol(int channel,int mode);
+int Set_Hold(int channel,int mode);
+int Set_Output_State(int channel,int mode);
+int Set_Trig_Source(int channel,int mode);
+int Set_Gate_Sync(int channel,int mode);
+int Set_Gate_Level(int channel,int mode);
+int Set_zout(int channel,int setting,int really_for_zout);
+int Set_Load(int channel, float value);
+int Set_EA(int channel,int mode);
+int Set_AdvDel(int channel,int setting);
+int Set_Pwmode(int channel,int mode);
+int Set_Update_Chans(void);
+int Set_Amp_Calib(int channel,float meas_ampl);
+int Set_Mon_Calib(int channel,float meas_ampl);
+int Set_Logic_Level(int channel,int mode);
+int Set_OS_Calib(int channel,float meas_ampl);
+float Get_PW_shift(int channel);
+int Set_PW_shift(int channel,float meas_ampl);
+int Set_Route(int channel,int module,int mode);
+int Set_EO(int channel,int mode);
+int Set_Dly_Shr_Nom(int channel,int calibration_point_number);
+int Set_Dly_Shr_Cal(int channel,int calibration_point_number,float cal_point);
+int Set_Cal_Nom(int channel,int calibration_point_number,int parameter, float *nom_val);
+int Set_VI_Cal_Pnt(int parameter,int channel,int calibration_point_number,float cal_point);
+int Set_VI_Del_Cal(int parameter,int channel,int calibration_point_number);
+int Set_VI_Control(int parameter,int channel,float new_ampl,int *point_found,int *relay_range,
+                   int *UseNegData,int *entry,int *word_out,int *actual_pol);
+int Set_VI_Add_Cal(int parameter,int channel,float cal_point);
+int Get_VI_Num_Pnts(int parameter,int channel);
+int Get_VI_Rng_Info(int parameter, int channel, int calibration_point_number, int *range,
+                    int *polarity, int *entry, int *num_in_range, int *num_of_ranges);
+int Check_MinMax_Cal(int channel,int parameter);
+int control_pcb107(int address, int dac, int word, int range);
+int Set_Burst_Count(int channel,int count,float new_burst_time);
+int Set_Burst_Time(int check_possible_only,int word_override,int range_override,int channel,float new_burst_time);
+int Set_rise_time(int check_possible_only,int word_override,int range_override,int channel,float new_burst_time);
+int Set_current_limit(int check_possible_only,int channel,float adj_current_limit);
+int Set_avrq_res(int check_possible_only,int word_override,int range_override,int channel,float new_res);
+int Set_slew(int check_possible_only,int word_override,int range_override,int channel,float new_burst_time);
+int Set_avrq_ampl(int check_possible_only,int word_override,int range_override,int channel,float new_avrq_ampl);
+int go_cal(CalStruct *caldata);
+int cal_string(char *parameter, CalStruct *caldata);
+int self_cal();
+int do_full_self_cal(CalStruct *caldata);
+int I2C_Self_Cal(int channel, int meas_mode, float *meas, float target_time);
+
 #endif
diff --git a/dummy_functions.c b/dummy_functions.c
index b370578..95bb7c0 100644
--- a/dummy_functions.c
+++ b/dummy_functions.c
@@ -25,57 +25,3 @@ void Main_update_shift_registers() { }
 
 int Set_Sav(int setting_num) {}
 int Set_Rcl(int setting_num) {}
-int set_dac(int dac, int word) {}
-int Set_Amplitude(int check_possible_only,int pol_override,int override_on,int word_override,int range_override,
-                  int switch_range_only,int channel,float new_ampl,int called_from_set_pw) {}
-int Set_Pw(int check_possible_only,int word_override,int range_override,int channel,float set_pw,int called_from_set_ampl) {}
-int Set_Offset(int check_possible_only,int override_on,int word_override,int range_override,int channel,float new_offset) {}
-int Set_Delay(int check_possible_only,int word_override,int range_override,int channel,float set_delay) {}
-int Set_Double(int channel,int new_setting) {}
-void Ctrl_PRF_Limiter(int enable) {}
-int Set_Mux(int channel) {}
-int Set_Func(int channel,int mode) {}
-int Set_Pol(int channel,int mode) {}
-int Set_Hold(int channel,int mode) {}
-int Set_Output_State(int channel,int mode) {}
-int Set_Trig_Source(int channel,int mode) {}
-int Set_Gate_Sync(int channel,int mode) {}
-int Set_Gate_Level(int channel,int mode) {}
-int Set_zout(int channel,int setting,int really_for_zout) {}
-int Set_Load(int channel, float value) {}
-int Set_EA(int channel,int mode) {}
-int Set_AdvDel(int channel,int setting) {}
-int Set_Pwmode(int channel,int mode) {}
-int Set_Update_Chans(void) {}
-int Set_Amp_Calib(int channel,float meas_ampl) {}
-int Set_Mon_Calib(int channel,float meas_ampl) {}
-int Set_Logic_Level(int channel,int mode) {}
-int Set_OS_Calib(int channel,float meas_ampl) {}
-float Get_PW_shift(int channel) {}
-int Set_PW_shift(int channel,float meas_ampl) {}
-int Set_Route(int channel,int module,int mode) {}
-int Set_EO(int channel,int mode) {}
-int Set_Dly_Shr_Nom(int channel,int calibration_point_number) {}
-int Set_Dly_Shr_Cal(int channel,int calibration_point_number,float cal_point) {}
-int Set_Cal_Nom(int channel,int calibration_point_number,int parameter, float *nom_val) {}
-int Set_VI_Cal_Pnt(int parameter,int channel,int calibration_point_number,float cal_point) {}
-int Set_VI_Del_Cal(int parameter,int channel,int calibration_point_number) {}
-int Set_VI_Control(int parameter,int channel,float new_ampl,int *point_found,int *relay_range,
-                   int *UseNegData,int *entry,int *word_out,int *actual_pol) {}
-int Set_VI_Add_Cal(int parameter,int channel,float cal_point) {}
-int Get_VI_Num_Pnts(int parameter,int channel) {}
-int Get_VI_Rng_Info(int parameter, int channel, int calibration_point_number, int *range,
-                    int *polarity, int *entry, int *num_in_range, int *num_of_ranges) {}
-int Check_MinMax_Cal(int channel,int parameter) {}
-int control_pcb107(int address, int dac, int word, int range) {}
-int Set_Burst_Count(int channel,int count,float new_burst_time) {}
-int Set_Burst_Time(int check_possible_only,int word_override,int range_override,int channel,float new_burst_time) {}
-int Set_rise_time(int check_possible_only,int word_override,int range_override,int channel,float new_burst_time) {}
-int Set_current_limit(int check_possible_only,int channel,float adj_current_limit) {}
-int Set_avrq_res(int check_possible_only,int word_override,int range_override,int channel,float new_res) {}
-int Set_slew(int check_possible_only,int word_override,int range_override,int channel,float new_burst_time) {}
-int Set_avrq_ampl(int check_possible_only,int word_override,int range_override,int channel,float new_avrq_ampl) {}
-int go_cal(CalStruct *caldata) {}
-int cal_string(char *parameter, CalStruct *caldata) {}
-int self_cal() {}
-int do_full_self_cal(CalStruct *caldata) {}
diff --git a/dummy_functions.h b/dummy_functions.h
index 78aa8d5..aefe276 100644
--- a/dummy_functions.h
+++ b/dummy_functions.h
@@ -27,60 +27,6 @@ void Main_update_shift_registers();
 
 int Set_Sav(int setting_num);
 int Set_Rcl(int setting_num);
-int set_dac(int dac, int word);
-int Set_Amplitude(int check_possible_only,int pol_override,int override_on,int word_override,int range_override,
-                  int switch_range_only,int channel,float new_ampl,int called_from_set_pw);
-int Set_Pw(int check_possible_only,int word_override,int range_override,int channel,float set_pw,int called_from_set_ampl);
-int Set_Offset(int check_possible_only,int override_on,int word_override,int range_override,int channel,float new_offset);
-int Set_Delay(int check_possible_only,int word_override,int range_override,int channel,float set_delay);
-int Set_Double(int channel,int new_setting);
-void Ctrl_PRF_Limiter(int enable);
-int Set_Mux(int channel);
-int Set_Func(int channel,int mode);
-int Set_Pol(int channel,int mode);
-int Set_Hold(int channel,int mode);
-int Set_Output_State(int channel,int mode);
-int Set_Trig_Source(int channel,int mode);
-int Set_Gate_Sync(int channel,int mode);
-int Set_Gate_Level(int channel,int mode);
-int Set_zout(int channel,int setting,int really_for_zout);
-int Set_Load(int channel, float value);
-int Set_EA(int channel,int mode);
-int Set_AdvDel(int channel,int setting);
-int Set_Pwmode(int channel,int mode);
-int Set_Update_Chans(void);
-int Set_Amp_Calib(int channel,float meas_ampl);
-int Set_Mon_Calib(int channel,float meas_ampl);
-int Set_Logic_Level(int channel,int mode);
-int Set_OS_Calib(int channel,float meas_ampl);
-float Get_PW_shift(int channel);
-int Set_PW_shift(int channel,float meas_ampl);
-int Set_Route(int channel,int module,int mode);
-int Set_EO(int channel,int mode);
-int Set_Dly_Shr_Nom(int channel,int calibration_point_number);
-int Set_Dly_Shr_Cal(int channel,int calibration_point_number,float cal_point);
-int Set_Cal_Nom(int channel,int calibration_point_number,int parameter, float *nom_val);
-int Set_VI_Cal_Pnt(int parameter,int channel,int calibration_point_number,float cal_point);
-int Set_VI_Del_Cal(int parameter,int channel,int calibration_point_number);
-int Set_VI_Control(int parameter,int channel,float new_ampl,int *point_found,int *relay_range,
-                   int *UseNegData,int *entry,int *word_out,int *actual_pol);
-int Set_VI_Add_Cal(int parameter,int channel,float cal_point);
-int Get_VI_Num_Pnts(int parameter,int channel);
-int Get_VI_Rng_Info(int parameter, int channel, int calibration_point_number, int *range,
-                    int *polarity, int *entry, int *num_in_range, int *num_of_ranges);
-int Check_MinMax_Cal(int channel,int parameter);
-int control_pcb107(int address, int dac, int word, int range);
-int Set_Burst_Count(int channel,int count,float new_burst_time);
-int Set_Burst_Time(int check_possible_only,int word_override,int range_override,int channel,float new_burst_time);
-int Set_rise_time(int check_possible_only,int word_override,int range_override,int channel,float new_burst_time);
-int Set_current_limit(int check_possible_only,int channel,float adj_current_limit);
-int Set_avrq_res(int check_possible_only,int word_override,int range_override,int channel,float new_res);
-int Set_slew(int check_possible_only,int word_override,int range_override,int channel,float new_burst_time);
-int Set_avrq_ampl(int check_possible_only,int word_override,int range_override,int channel,float new_avrq_ampl);
-int go_cal(CalStruct *caldata);
-int cal_string(char *parameter, CalStruct *caldata);
-int self_cal();
-int do_full_self_cal(CalStruct *caldata);
 
 #endif
 
diff --git a/error_utils.c b/error_utils.c
index 6f9d85c..14b7684 100644
--- a/error_utils.c
+++ b/error_utils.c
@@ -81,11 +81,11 @@ void queue_error(int error_num)
 	}
 
 	set_gpib_error_flags (error_num);
-	if (globals.number_of_errors<error_queue_length) {
-		++globals.number_of_errors;
-		globals.error_queue[globals.number_of_errors]=error_num;
+	if (globals.Errors.number_of_errors<error_queue_length) {
+		++globals.Errors.number_of_errors;
+		globals.Errors.error_queue[globals.Errors.number_of_errors]=error_num;
 	} else {
-		globals.error_queue[globals.number_of_errors]=queue_overflow;
+		globals.Errors.error_queue[globals.Errors.number_of_errors]=queue_overflow;
 	}
 
 	return;
@@ -154,10 +154,10 @@ void queue_and_broadcast_sensor_alarm(int error_num)
 void Error_Remove_From_Queue(void)
 {
 	int i;
-	for (i=1; i<globals.number_of_errors; ++i) {
-		globals.error_queue[i]=globals.error_queue[i+1];
+	for (i=1; i<globals.Errors.number_of_errors; ++i) {
+		globals.Errors.error_queue[i]=globals.Errors.error_queue[i+1];
 	}
-	--globals.number_of_errors; 	/* error reported, so remove it from the error queue */
+	--globals.Errors.number_of_errors; 	/* error reported, so remove it from the error queue */
 }
 
 
@@ -628,14 +628,14 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 
 	for (i=0; i<num_of_chan; ++i) {
 		/* Must be changing a setting */
-		globals.last_activity_at[i] = sec_timer ();
+		globals.Timers.last_activity_at[i] = sec_timer ();
 
 		/* ignore errors if it is in programming mode */
 		if (globals.Flash.fully_programmed != All_Programmed) {
 			return OK;
 		}
 
-		if (globals.do_check_settings==NO) {
+		if (globals.Flags.do_check_settings==NO) {
 			return OK;
 		}
 
@@ -645,7 +645,7 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 		}
 
 		if (ChannelStateToTest[i].pw<smallest_allowed_number
-		        && globals.Flash.min_pw[i]>0.0) {
+		                && globals.Flash.min_pw[i]>0.0) {
 			return pw_lower_limit;
 		}
 
@@ -662,14 +662,14 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 		}
 
 		if (globals.Flash.duty_ampl_mid1[i]>0.0 &&
-		        (fabs(ChannelStateToTest[i].amplitude)<= globals.Flash.duty_ampl_mid1[i]) &&
-		        (globals.Flash.max_duty_mid1[i] > max_duty_this_ampl)) {
+		                (fabs(ChannelStateToTest[i].amplitude)<= globals.Flash.duty_ampl_mid1[i]) &&
+		                (globals.Flash.max_duty_mid1[i] > max_duty_this_ampl)) {
 			max_duty_this_ampl = globals.Flash.max_duty_mid1[i];
 		}
 
 		if (globals.Flash.duty_ampl_mid2[i]>0.0 &&
-		        (fabs(ChannelStateToTest[i].amplitude)<= globals.Flash.duty_ampl_mid2[i]) &&
-		        (globals.Flash.max_duty_mid2[i] > max_duty_this_ampl)) {
+		                (fabs(ChannelStateToTest[i].amplitude)<= globals.Flash.duty_ampl_mid2[i]) &&
+		                (globals.Flash.max_duty_mid2[i] > max_duty_this_ampl)) {
 			max_duty_this_ampl = globals.Flash.max_duty_mid2[i];
 		}
 
@@ -690,8 +690,8 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 			duty_scale = 200.0;
 		}
 		if (	(ChannelStateToTest[i].burst_count>1)
-		        && (globals.Flash.max_burst_count[i]>1)
-		        && !globals.Flash.burst_func[i]) {
+		                && (globals.Flash.max_burst_count[i]>1)
+		                && !globals.Flash.burst_func[i]) {
 			duty_scale *= (float) ChannelStateToTest[i].burst_count;
 		}
 
@@ -745,8 +745,8 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 				}
 
 				if (		(ChannelStateToTest[i].burst_count>1)
-				            && (globals.Flash.max_burst_count[i]>1)
-				            && !globals.Flash.burst_func[i]) {
+				                && (globals.Flash.max_burst_count[i]>1)
+				                && !globals.Flash.burst_func[i]) {
 					temp=1/(ChannelStateToTest[i].burst_count * (ChannelStateToTest[i].pw+ChannelStateToTest[i].burst_time));
 					if (temp<globals.Constraints.err_max_freq[i]) {
 						globals.Constraints.err_max_freq[i]=temp;
@@ -806,7 +806,7 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 		globals.Constraints.err_min_pw[i]=globals.Flash.min_pw[i];
 
 		if (   (globals.Constraints.err_min_pw[i]>=0.0 && ChannelStateToTest[i].pw<(0.999*globals.Constraints.err_min_pw[i]))
-		        || (globals.Constraints.err_min_pw[i]<0.0 && ChannelStateToTest[i].pw<(1.001*globals.Constraints.err_min_pw[i])) ) {
+		                || (globals.Constraints.err_min_pw[i]<0.0 && ChannelStateToTest[i].pw<(1.001*globals.Constraints.err_min_pw[i])) ) {
 			report_error=pw_lower_limit;
 		}
 
@@ -862,8 +862,8 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 			}
 
 			if (		(ChannelStateToTest[i].burst_count>1)
-			            && (globals.Flash.max_burst_count[i]>1)
-			            && !globals.Flash.burst_func[i]) {
+			                && (globals.Flash.max_burst_count[i]>1)
+			                && !globals.Flash.burst_func[i]) {
 				temp=(1/ChannelStateToTest[i].frequency)/ChannelStateToTest[i].burst_count - ChannelStateToTest[i].burst_time;
 				if (temp<globals.Constraints.err_max_pw[i]) {
 					globals.Constraints.err_max_pw[i]=temp;
@@ -932,7 +932,7 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 		}
 
 		if ( (globals.Constraints.err_min_delay[i]>=0.0 && ChannelStateToTest[i].delay<(0.999*globals.Constraints.err_min_delay[i]))
-		        || (globals.Constraints.err_min_delay[i]<0.0 && ChannelStateToTest[i].delay<(1.001*globals.Constraints.err_min_delay[i])) ) {
+		                || (globals.Constraints.err_min_delay[i]<0.0 && ChannelStateToTest[i].delay<(1.001*globals.Constraints.err_min_delay[i])) ) {
 			report_error=delay_lower_limit;
 		}
 
@@ -941,7 +941,7 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 			if (temp>globals.Constraints.err_min_delay[i]) {
 				globals.Constraints.err_min_delay[i]=temp;
 				if ( (globals.Constraints.err_min_delay[i]>=0.0 && ChannelStateToTest[i].delay<(0.999*globals.Constraints.err_min_delay[i]))
-				        || (globals.Constraints.err_min_delay[i]<0.0 && ChannelStateToTest[i].delay<(1.001*globals.Constraints.err_min_delay[i])) ) {
+				                || (globals.Constraints.err_min_delay[i]<0.0 && ChannelStateToTest[i].delay<(1.001*globals.Constraints.err_min_delay[i])) ) {
 					report_error=Delay_Exceeds_95Period;
 				}
 			}
@@ -952,7 +952,7 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 			if (temp>globals.Constraints.err_min_delay[i]) {
 				globals.Constraints.err_min_delay[i]=temp;
 				if ( (globals.Constraints.err_min_delay[i]>=0.0 && ChannelStateToTest[i].delay<(0.999*globals.Constraints.err_min_delay[i]))
-				        || (globals.Constraints.err_min_delay[i]<0.0 && ChannelStateToTest[i].delay<(1.001*globals.Constraints.err_min_delay[i])) ) {
+				                || (globals.Constraints.err_min_delay[i]<0.0 && ChannelStateToTest[i].delay<(1.001*globals.Constraints.err_min_delay[i])) ) {
 					report_error=PW_Exceeds_Double_Separation;
 				}
 			}
@@ -963,7 +963,7 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 		globals.Constraints.err_max_delay[i]=globals.Flash.max_delay[i];
 
 		if ( (globals.Constraints.err_max_delay[i]>=0.0 && ChannelStateToTest[i].delay>(1.001*globals.Constraints.err_max_delay[i]))
-		        || (globals.Constraints.err_max_delay[i]<0.0 && ChannelStateToTest[i].delay>(0.999*globals.Constraints.err_max_delay[i])) ) {
+		                || (globals.Constraints.err_max_delay[i]<0.0 && ChannelStateToTest[i].delay>(0.999*globals.Constraints.err_max_delay[i])) ) {
 			report_error=delay_upper_limit;
 		}
 
@@ -972,7 +972,7 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 			if (temp<globals.Constraints.err_max_delay[i]) {
 				globals.Constraints.err_max_delay[i]=temp;
 				if ( (globals.Constraints.err_max_delay[i]>=0.0 && ChannelStateToTest[i].delay>(1.001*globals.Constraints.err_max_delay[i]))
-				        || (globals.Constraints.err_max_delay[i]<0.0 && ChannelStateToTest[i].delay>(0.999*globals.Constraints.err_max_delay[i])) ) {
+				                || (globals.Constraints.err_max_delay[i]<0.0 && ChannelStateToTest[i].delay>(0.999*globals.Constraints.err_max_delay[i])) ) {
 					report_error=Delay_Exceeds_95Period;
 				}
 			}
@@ -982,7 +982,7 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 				if (temp<globals.Constraints.err_max_delay[i]) {
 					globals.Constraints.err_max_delay[i]=temp;
 					if ( (globals.Constraints.err_max_delay[i]>=0.0 && ChannelStateToTest[i].delay>(1.001*globals.Constraints.err_max_delay[i]))
-					        || (globals.Constraints.err_max_delay[i]<0.0 && ChannelStateToTest[i].delay>(0.999*globals.Constraints.err_max_delay[i])) ) {
+					                || (globals.Constraints.err_max_delay[i]<0.0 && ChannelStateToTest[i].delay>(0.999*globals.Constraints.err_max_delay[i])) ) {
 						report_error=Double_Separation_Too_Large;
 					}
 				}
@@ -991,7 +991,7 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 		/* ------------------------------- */
 
 		/* disable amplitude checks if amplitude calibration is in progress */
-		if (!globals.extended_ampl_min_max) {
+		if (!globals.Flags.extended_ampl_min_max) {
 
 			globals.Constraints.err_max_vcc1[i]=globals.Flash.vcc1_max[i];
 			globals.Constraints.err_max_vcc2[i]=globals.Flash.vcc2_max[i];
@@ -1023,7 +1023,7 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 			globals.Constraints.err_min_ampl[i]=globals.Flash.min_ampl[i];
 
 			if ( (globals.Constraints.err_min_ampl[i]>=0.0 && ChannelStateToTest[i].amplitude<(0.999*globals.Constraints.err_min_ampl[i]))
-			        || (globals.Constraints.err_min_ampl[i]<0.0 && ChannelStateToTest[i].amplitude<(1.001*globals.Constraints.err_min_ampl[i])) ) {
+			                || (globals.Constraints.err_min_ampl[i]<0.0 && ChannelStateToTest[i].amplitude<(1.001*globals.Constraints.err_min_ampl[i])) ) {
 				report_error=amplitude_lower_limit;
 			}
 
@@ -1031,7 +1031,7 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 			if (temp>globals.Constraints.err_min_ampl[i]) {
 				globals.Constraints.err_min_ampl[i]=temp;
 				if ( (globals.Constraints.err_min_ampl[i]>=0.0 && ChannelStateToTest[i].amplitude<(0.999*globals.Constraints.err_min_ampl[i]))
-				        || (globals.Constraints.err_min_ampl[i]<0.0 && ChannelStateToTest[i].amplitude<(1.001*globals.Constraints.err_min_ampl[i])) ) {
+				                || (globals.Constraints.err_min_ampl[i]<0.0 && ChannelStateToTest[i].amplitude<(1.001*globals.Constraints.err_min_ampl[i])) ) {
 					report_error=ampl_plus_os_lower_limit;
 				}
 			}
@@ -1043,8 +1043,8 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 			if (globals.Flash.ampl_min_max_only[i])
 
 				if ( 	!(fabs(ChannelStateToTest[i].amplitude - globals.Flash.min_ampl[i] ) < globals.Flash.ampl_zero_equiv[i] )
-				        &&
-				        !(fabs(ChannelStateToTest[i].amplitude - globals.Flash.max_ampl[i]) < globals.Flash.ampl_zero_equiv[i] )
+				                &&
+				                !(fabs(ChannelStateToTest[i].amplitude - globals.Flash.max_ampl[i]) < globals.Flash.ampl_zero_equiv[i] )
 				   )
 
 				{
@@ -1057,7 +1057,7 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 			/* --- check maximum amplitude --- */
 			globals.Constraints.err_max_ampl[i]=globals.Flash.max_ampl[i];
 			if ( (globals.Constraints.err_max_ampl[i]>=0.0 && ChannelStateToTest[i].amplitude>(1.001*globals.Constraints.err_max_ampl[i]))
-			        || (globals.Constraints.err_max_ampl[i]<0.0 && ChannelStateToTest[i].amplitude>(0.999*globals.Constraints.err_max_ampl[i])) ) {
+			                || (globals.Constraints.err_max_ampl[i]<0.0 && ChannelStateToTest[i].amplitude>(0.999*globals.Constraints.err_max_ampl[i])) ) {
 				report_error=amplitude_upper_limit;
 			}
 
@@ -1091,7 +1091,7 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 			if (temp<globals.Constraints.err_max_ampl[i]) {
 				globals.Constraints.err_max_ampl[i]=temp;
 				if ( (globals.Constraints.err_max_ampl[i]>=0.0 && ChannelStateToTest[i].amplitude>(1.001*globals.Constraints.err_max_ampl[i]))
-				        || (globals.Constraints.err_max_ampl[i]<0.0 && ChannelStateToTest[i].amplitude>(0.999*globals.Constraints.err_max_ampl[i])) ) {
+				                || (globals.Constraints.err_max_ampl[i]<0.0 && ChannelStateToTest[i].amplitude>(0.999*globals.Constraints.err_max_ampl[i])) ) {
 					report_error=ampl_plus_os_upper_limit;
 				}
 			}
@@ -1103,7 +1103,7 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 					if (temp<globals.Constraints.err_max_ampl[i]) {
 						globals.Constraints.err_max_ampl[i]=temp;
 						if ( (globals.Constraints.err_max_ampl[i]>=0.0 && ChannelStateToTest[i].amplitude>(1.001*globals.Constraints.err_max_ampl[i]))
-						        || (globals.Constraints.err_max_ampl[i]<0.0 && ChannelStateToTest[i].amplitude>(0.999*globals.Constraints.err_max_ampl[i])) ) {
+						                || (globals.Constraints.err_max_ampl[i]<0.0 && ChannelStateToTest[i].amplitude>(0.999*globals.Constraints.err_max_ampl[i])) ) {
 							report_error=Average_Amplitude_Too_High;
 						}
 					}
@@ -1122,9 +1122,9 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 					if (temp<globals.Constraints.err_max_ampl[i]) {
 						globals.Constraints.err_max_ampl[i]=temp;
 						if (	(		(globals.Constraints.err_max_ampl[i]>=0.0 && ChannelStateToTest[i].amplitude>(1.001*globals.Constraints.err_max_ampl[i]))
-						                || (globals.Constraints.err_max_ampl[i]<0.0 && ChannelStateToTest[i].amplitude>(0.999*globals.Constraints.err_max_ampl[i]))
+						                        || (globals.Constraints.err_max_ampl[i]<0.0 && ChannelStateToTest[i].amplitude>(0.999*globals.Constraints.err_max_ampl[i]))
 						     )
-						        && (duty_cycle > 1.001*(100.0*max_duty_high_ampl/duty_scale))
+						                && (duty_cycle > 1.001*(100.0*max_duty_high_ampl/duty_scale))
 						   ) {
 							report_error=duty_cycle_upper_limit;
 						}
@@ -1141,7 +1141,7 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 				globals.Constraints.err_min_offset[i]=globals.Flash.min_offset[i];
 
 				if ( (globals.Constraints.err_min_offset[i]>=0.0 && ChannelStateToTest[i].offset<(0.999*globals.Constraints.err_min_offset[i]))
-				        || (globals.Constraints.err_min_offset[i]<0.0 && ChannelStateToTest[i].offset<(1.001*globals.Constraints.err_min_offset[i])) ) {
+				                || (globals.Constraints.err_min_offset[i]<0.0 && ChannelStateToTest[i].offset<(1.001*globals.Constraints.err_min_offset[i])) ) {
 					report_error=offset_lower_limit;
 				}
 
@@ -1149,7 +1149,7 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 				if (temp>globals.Constraints.err_min_offset[i]) {
 					globals.Constraints.err_min_offset[i]=temp;
 					if ( (globals.Constraints.err_min_offset[i]>=0.0 && ChannelStateToTest[i].offset<(0.999*globals.Constraints.err_min_offset[i]))
-					        || (globals.Constraints.err_min_offset[i]<0.0 && ChannelStateToTest[i].offset<(1.001*globals.Constraints.err_min_offset[i])) ) {
+					                || (globals.Constraints.err_min_offset[i]<0.0 && ChannelStateToTest[i].offset<(1.001*globals.Constraints.err_min_offset[i])) ) {
 						report_error=ampl_plus_os_lower_limit;
 					}
 				}
@@ -1175,7 +1175,7 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 				globals.Constraints.err_max_offset[i]=globals.Flash.max_offset[i];
 
 				if ( (globals.Constraints.err_max_offset[i]>=0.0 && ChannelStateToTest[i].offset>(1.001*globals.Constraints.err_max_offset[i]))
-				        || (globals.Constraints.err_max_offset[i]<0.0 && ChannelStateToTest[i].offset>(0.999*globals.Constraints.err_max_offset[i])) ) {
+				                || (globals.Constraints.err_max_offset[i]<0.0 && ChannelStateToTest[i].offset>(0.999*globals.Constraints.err_max_offset[i])) ) {
 					report_error=offset_upper_limit;
 				}
 
@@ -1183,7 +1183,7 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 				if (temp<globals.Constraints.err_max_offset[i]) {
 					globals.Constraints.err_max_offset[i]=temp;
 					if ( (globals.Constraints.err_max_offset[i]>=0.0 && ChannelStateToTest[i].offset>(1.001*globals.Constraints.err_max_offset[i]))
-					        || (globals.Constraints.err_max_offset[i]<0.0 && ChannelStateToTest[i].offset>(0.999*globals.Constraints.err_max_offset[i])) ) {
+					                || (globals.Constraints.err_max_offset[i]<0.0 && ChannelStateToTest[i].offset>(0.999*globals.Constraints.err_max_offset[i])) ) {
 						report_error=ampl_plus_os_upper_limit;
 					}
 				}
@@ -1208,8 +1208,8 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 
 		/* --- check for nonsensical negatives ------ */
 		if (	ChannelStateToTest[i].frequency<0.0
-		        || ((ChannelStateToTest[i].pw<0.0) && (globals.Flash.min_pw[i] > 0.0))
-		        || ChannelStateToTest[i].zout<0) {
+		                || ((ChannelStateToTest[i].pw<0.0) && (globals.Flash.min_pw[i] > 0.0))
+		                || ChannelStateToTest[i].zout<0) {
 			report_error=Negative_Not_Allowed;
 		}
 		/* ------------------------------- */
@@ -1222,8 +1222,8 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 
 			/* --- check minimum setting --- */
 			if ( (!globals.Flash.burst_func[i] && ChannelStateToTest[i].burst_count<1)
-			        ||
-			        (globals.Flash.burst_func[i] &&  ChannelStateToTest[i].burst_count<0)) {
+			                ||
+			                (globals.Flash.burst_func[i] &&  ChannelStateToTest[i].burst_count<0)) {
 				report_error=IllegalParameter;
 			}
 
@@ -1244,7 +1244,7 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 					if (temp < (float) globals.Constraints.err_max_burst_count[i]) {
 						globals.Constraints.err_max_burst_count[i] = (int) temp;
 						if (		(ChannelStateToTest[i].burst_count>globals.Constraints.err_max_burst_count[i])
-						            && (ChannelStateToTest[i].burst_count>1)) {
+						                && (ChannelStateToTest[i].burst_count>1)) {
 							report_error=max_burst_count_error;
 						}
 					}
@@ -1256,7 +1256,7 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 					if (temp < (float) globals.Constraints.err_max_burst_count[i]) {
 						globals.Constraints.err_max_burst_count[i] = (int) temp;
 						if (		(ChannelStateToTest[i].burst_count>globals.Constraints.err_max_burst_count[i])
-						            &&	(ChannelStateToTest[i].burst_count>1)) {
+						                &&	(ChannelStateToTest[i].burst_count>1)) {
 							report_error=Burst_Exceeds_Period;
 						}
 					}
@@ -1267,7 +1267,7 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 
 				globals.Constraints.err_min_burst_time[i]=globals.Flash.min_burst_gap[i];
 				if (		(ChannelStateToTest[i].burst_count>1)
-				            && (ChannelStateToTest[i].burst_time<(0.999*globals.Constraints.err_min_burst_time[i]))) {
+				                && (ChannelStateToTest[i].burst_time<(0.999*globals.Constraints.err_min_burst_time[i]))) {
 					report_error=min_burst_gap_error;
 				}
 
@@ -1279,7 +1279,7 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 					if (temp > globals.Constraints.err_min_burst_time[i]) {
 						globals.Constraints.err_min_burst_time[i] = temp;
 						if (		(ChannelStateToTest[i].burst_count>1)
-						            && (ChannelStateToTest[i].burst_time<(0.999*globals.Constraints.err_min_burst_time[i]))) {
+						                && (ChannelStateToTest[i].burst_time<(0.999*globals.Constraints.err_min_burst_time[i]))) {
 							report_error=min_burst_period_error;
 						}
 					}
@@ -1289,7 +1289,7 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 					if (temp > globals.Constraints.err_min_burst_time[i]) {
 						globals.Constraints.err_min_burst_time[i] = temp;
 						if (		(ChannelStateToTest[i].burst_time<(0.999*globals.Constraints.err_min_burst_time[i]))
-						            && (ChannelStateToTest[i].burst_count>1)) {
+						                && (ChannelStateToTest[i].burst_count>1)) {
 							report_error=burst_duty_error;
 						}
 					}
@@ -1299,7 +1299,7 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 
 				globals.Constraints.err_max_burst_time[i]=globals.Flash.max_burst_gap[i];
 				if (		(ChannelStateToTest[i].burst_count>1)
-				            &&	(ChannelStateToTest[i].burst_time>(1.001*globals.Constraints.err_max_burst_time[i]))) {
+				                &&	(ChannelStateToTest[i].burst_time>(1.001*globals.Constraints.err_max_burst_time[i]))) {
 					report_error=max_burst_gap_error;
 				}
 
@@ -1309,7 +1309,7 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 		/* --- check rise time settings --- */
 		/* disable amplitude checks if calibration is in progress */
 		if (!globals.Flash.fixed_rise_time[i])
-			if (!globals.extended_ampl_min_max) {
+			if (!globals.Flags.extended_ampl_min_max) {
 				globals.Constraints.err_min_rise_time[i]=globals.Flash.min_rise_time[i];
 				if (ChannelStateToTest[i].rise_time<(0.999*globals.Constraints.err_min_rise_time[i])) {
 					report_error=min_rise_time_error;
@@ -1324,7 +1324,7 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 		/* --- check slew settings --- */
 		/* disable amplitude checks if calibration is in progress */
 		if (globals.Flash.curr_slew[i])
-			if (!globals.extended_ampl_min_max) {
+			if (!globals.Flags.extended_ampl_min_max) {
 				globals.Constraints.err_min_slew[i]=globals.Flash.min_slew[i];
 				if (ChannelStateToTest[i].slew<(0.999*globals.Constraints.err_min_slew[i])) {
 					report_error=min_slew_error;
diff --git a/flash.c b/flash.c
index a2fcdc3..48e180e 100644
--- a/flash.c
+++ b/flash.c
@@ -290,7 +290,7 @@ void writeUserBlock(FlashStruct *mem, int addr, int numbytes)
 	// *** that the main file is valid before backing it up I guess...  ***
 	// *** but I don't think this situation should arise.				***
 
-	if (!globals.flash_writes_suspended) {
+	if (!globals.Flags.flash_writes_suspended) {
 
 		// backup the main copy of the file
 		if (persistence_copyfile(MAINFILE, BACKUPFILE)) {
diff --git a/globals.c b/globals.c
index 86ea2e8..8f60930 100644
--- a/globals.c
+++ b/globals.c
@@ -2,14 +2,8 @@
 #include <time.h>
 
 GlobalStruct globals = {
-	.error_queue = {0},
-	.number_of_errors = 0,
-	.Flash.fully_programmed = Not_Programmed,
-	.extended_ampl_min_max = 0,
-	.do_check_settings = 1,
-	.oper_enable_register = 0,
-	.ques_enable_register = 0,
-	.flash_writes_suspended = 0
+	.Flags.do_check_settings = 1,
+	.Registers.last_rise_time_relay_setting = 99
 };
 
 
diff --git a/globals.h b/globals.h
index c892b37..66281c0 100644
--- a/globals.h
+++ b/globals.h
@@ -92,7 +92,6 @@
 #define NO      0
 
 
-#define error_queue_length 512
 #define max_commands_in_input 12
 #define max_output_length 512
 #define max_channels 2
@@ -206,6 +205,31 @@
 
 
 #define smallest_allowed_number 1.0e-18
+#define zero_equiv_timing 	1e-10
+#define max_v_dymanic_range 	1e6
+
+
+// self-cal configs
+#define NOT_ENABLE_COUNT 0x01
+#define ENABLE_COUNT 0x00
+
+#define NOT_LOAD_BUFFERS_CLK 0x00
+#define LOAD_BUFFERS_CLK 0x02
+
+#define NOT_CLR_COUNTERS 0x04
+#define CLR_COUNTERS 0x00
+
+#define MEAS_PW 0x08
+#define MEAS_PRF 0x00
+
+#define MEAS_CH1 0x00
+#define MEAS_CH2 0x10
+
+#define COUNTER_BYTE_0 0x00
+#define COUNTER_BYTE_1 0x20
+#define COUNTER_BYTE_2 0x40
+#define COUNTER_BYTE_3 0x60
+
 
 
 long sec_timer (void);
@@ -224,6 +248,40 @@ typedef struct {
 
 
 typedef struct {
+	int parallel_DAC_reg[8];
+	long shift_reg_out[num_out_SRs];
+	long last_relay_driver_settings[3];
+	int oper_enable_register;       /* for stat:enable command */
+	int ques_enable_register;       /* for stat:enable command */
+	int avrq_reg;
+	int last_rise_time_relay_setting;
+} HWregStruct;
+
+
+typedef struct {
+	int update_freq;
+	int update_func;
+	int update_delay;
+	int update_pw;
+	int update_amp;
+	int update_os;
+	int update_zout;
+	int update_load;
+	int update_output;
+	int update_inv;
+	int update_gate;
+	int update_logic_level;
+	int update_routes;
+	int update_burst_count;
+	int update_burst_time;
+	int update_rise_time;
+	int update_soft_current_limit;
+	int update_slew;
+	int update_whole_main_menu;
+} ChangeStruct;
+
+
+typedef struct {
 	int baud;
 	int parity;
 	int stopbits;
@@ -663,25 +721,43 @@ typedef struct {
 } ConstraintsStruct;
 
 
+#define error_queue_length 512
 typedef struct {
-	ConstraintsStruct Constraints;
-	ChannelStruct ChannelState[max_channels];
-	FlashStruct Flash;
-	GpibStruct GPIB;
-	Rs232Struct RS232;
-
 	int error_queue[error_queue_length+1];
-	int number_of_errors;	/* how many errors are in the error queue */
+	int number_of_errors;
+} ErrorStruct;
+
+
+typedef struct {
 	int extended_ampl_min_max;
 	int do_check_settings;
-	int oper_enable_register;       /* for stat:enable command */
-	int ques_enable_register;       /* for stat:enable command */
 	int flash_writes_suspended;
+	int force_output_fully_off;
+} FlagStruct;
+
+
+typedef struct {
 	long startup_timer_value;
 	long last_activity_at[max_channels];
+	long normal_relay_bounce_time_in_milliseconds;
+	long Relay_Switching_Delay_in_Milliseconds;
+} TimeStruct;
+
 
+typedef struct {
+	ConstraintsStruct Constraints;
+	ChannelStruct ChannelState[max_channels];
+	FlashStruct Flash;
+	GpibStruct GPIB;
+	Rs232Struct RS232;
+	HWregStruct Registers;
+	ChangeStruct Changes;
+	ErrorStruct Errors;
+	FlagStruct Flags;
+	TimeStruct Timers;
 } GlobalStruct;
 
+
 extern GlobalStruct globals;
 
 
diff --git a/instr-daemon.c b/instr-daemon.c
index 6c2905e..3bc4a57 100644
--- a/instr-daemon.c
+++ b/instr-daemon.c
@@ -251,9 +251,9 @@ int main(int argc, char **argv)
 	/* start-up delay */
 	LCD_write(3,0,"Warming up, please wait... ");
 
-	globals.startup_timer_value = sec_timer ();
+	globals.Timers.startup_timer_value = sec_timer ();
 	long timer_count;
-	while ((timer_count=sec_timer()-globals.startup_timer_value) < (long)globals.Flash.turn_on_dly) {
+	while ((timer_count=sec_timer()-globals.Timers.startup_timer_value) < (long)globals.Flash.turn_on_dly) {
 		message = g_strdup_printf ("%ld ", (long) globals.Flash.turn_on_dly - timer_count);
 		LCD_write(3,27,message);
 		g_free (message);
diff --git a/parser.c b/parser.c
index 9edd7e5..f2439ad 100644
--- a/parser.c
+++ b/parser.c
@@ -9,6 +9,7 @@ SUPPORT LIB'S:
 END DESCRIPTION **********************************************************/
 
 
+#include "error_utils.h"
 #include "parser.h"
 #include "flash.h"
 #include "nicutils.h"
@@ -1614,10 +1615,10 @@ static int Go_syst_err_11(gchar** response, int channel, char *parameter,char *u
 {
 	switch (command_type) {
 	case query_simple:
-		if (globals.number_of_errors==0) {
+		if (globals.Errors.number_of_errors==0) {
 			get_error_text(response, OK);
 		} else {
-			get_error_text(response,globals.error_queue[1]);
+			get_error_text(response,globals.Errors.error_queue[1]);
 			Error_Remove_From_Queue();
 		}
 		return OK;
@@ -1633,7 +1634,7 @@ static int Go_syst_errcnt66(gchar** response, int channel, char *parameter,char
 {
 	switch (command_type) {
 	case query_simple:
-		return query_int (response, globals.number_of_errors);
+		return query_int (response, globals.Errors.number_of_errors);
 		break;
 
 	default:
@@ -2393,7 +2394,7 @@ static int Go_cls_1(gchar** response, int channel, char *parameter,char *units,i
 	switch (command_type) {
 	case command_simple:
 		GPIB_clear_events();
-		globals.number_of_errors=0;
+		globals.Errors.number_of_errors=0;
 		return OK;
 		break;
 
@@ -2494,12 +2495,12 @@ static int Go_oper_enable15(gchar** response, int channel, char *parameter,char
 		if (status = process_int_range (parameter, &value, 0, 255)) {
 			return status;
 		}
-		globals.oper_enable_register=value;
+		globals.Registers.oper_enable_register=value;
 		return OK;
 		break;
 
 	case query_simple:
-		return query_int (response, globals.oper_enable_register);
+		return query_int (response, globals.Registers.oper_enable_register);
 		break;
 
 	default:
@@ -2518,12 +2519,12 @@ static int Go_ques_enable18(gchar** response, int channel, char *parameter,char
 		if (status = process_int_range (parameter, &value, 0, 255)) {
 			return status;
 		}
-		globals.ques_enable_register=value;
+		globals.Registers.ques_enable_register=value;
 		return OK;
 		break;
 
 	case query_simple:
-		return query_int (response, globals.ques_enable_register);
+		return query_int (response, globals.Registers.ques_enable_register);
 		break;
 
 	default:
@@ -2537,8 +2538,8 @@ static int Go_preset_19(gchar** response, int channel, char *parameter,char *uni
 {
 	switch (command_type) {
 	case command_simple:
-		globals.oper_enable_register=0;
-		globals.ques_enable_register=0;
+		globals.Registers.oper_enable_register=0;
+		globals.Registers.ques_enable_register=0;
 		return OK;
 		break;
 
@@ -3694,9 +3695,9 @@ static int Go_eprom_sus_93(gchar** response, int channel, char *parameter,int co
 	switch (command_type) {
 	case command_withparam:
 		if (!strcmp(parameter,"1")) {
-			globals.flash_writes_suspended=1;
+			globals.Flags.flash_writes_suspended=1;
 		} else if (!strcmp(parameter,"0")) {
-			globals.flash_writes_suspended=0;
+			globals.Flags.flash_writes_suspended=0;
 			writeUserBlock(&globals.Flash,0,sizeof(globals.Flash));
 		} else {
 			return SyntaxError;
@@ -3707,7 +3708,7 @@ static int Go_eprom_sus_93(gchar** response, int channel, char *parameter,int co
 		break;
 
 	case query_simple:
-		return query_int (response, globals.flash_writes_suspended);
+		return query_int (response, globals.Flags.flash_writes_suspended);
 		break;
 
 	default: