use standard functions to do simple positive min/max error checks

1 files changed, 111 insertions, 220 deletions

diff --git a/error_utils.c b/error_utils.c
index 3e2e4fd..08b8a11 100644
--- a/error_utils.c
+++ b/error_utils.c
@@ -44,6 +44,7 @@ void set_gpib_error_flags (int error_num)
 	case obsolete_feature:
 	case config_too_large:
 	case config_cant_be_negative:
+	case invalid_error_check:
 		GPIB_Set_Command_Error();
 		break;
 	case query_error_interrupted:
@@ -604,6 +605,10 @@ void get_error_text(gchar **response, int error_num)
 		format_error_text(response,-200,"Invalid execution path. Programming error.");
 		break;
 
+	case invalid_error_check:
+		format_error_text(response,-200,"Invalid error checking. Needs programming fix.");
+		break;
+
 	case Startup_Not_Finished:
 		format_error_text(response,-300,"Not ready for commands yet. Still booting up.");
 		break;
@@ -627,6 +632,46 @@ void get_error_text(gchar **response, int error_num)
 }
 
 
+void check_starting_pos_max_value (float test_limit, float *running_limit, float proposed_value, int possible_error, int *actual_error) {
+
+	*running_limit = test_limit;
+
+	if (proposed_value > (*running_limit * 1.001)) {
+		*actual_error = possible_error;
+	}
+
+	if (test_limit < 0.0) {
+		*actual_error = invalid_error_check;
+	}
+}
+
+void check_another_pos_max_value (float test_limit, float *running_limit, float proposed_value, int possible_error, int *actual_error) {
+
+	if (test_limit < *running_limit) {
+		check_starting_pos_max_value (test_limit, running_limit, proposed_value, possible_error, actual_error);
+	}
+}
+
+void check_starting_pos_min_value (float test_limit, float *running_limit, float proposed_value, int possible_error, int *actual_error) {
+	*running_limit = test_limit;
+
+	if (proposed_value < (*running_limit * 0.999)) {
+		*actual_error = possible_error;
+	}
+
+	if (test_limit < 0.0) {
+		*actual_error = invalid_error_check;
+	}
+}
+
+void check_another_pos_min_value (float test_limit, float *running_limit, float proposed_value, int possible_error, int *actual_error) {
+
+	if (test_limit > *running_limit) {
+		check_starting_pos_min_value (test_limit, running_limit, proposed_value, possible_error, actual_error);
+	}
+}
+
+
 int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 {
 	static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
@@ -838,112 +883,51 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 
 
 		/* --- check minimum frequency --- */
-		globals.Constraints.err_min_freq[i]=globals.Flash.min_freq[i];
-
-		if (ChannelStateToTest[i].frequency<(0.999*globals.Constraints.err_min_freq[i])) {
-			report_error=freq_lower_limit;
-		}
+		check_starting_pos_min_value (globals.Flash.min_freq[i], &globals.Constraints.err_min_freq[i], ChannelStateToTest[i].frequency, freq_lower_limit, &report_error);
 		/* ------------------------------- */
 
 		/* --- check maximum frequency --- */
-		globals.Constraints.err_max_freq[i]=globals.Flash.max_freq[i];
+		check_starting_pos_max_value (globals.Flash.max_freq[i], &globals.Constraints.err_max_freq[i], ChannelStateToTest[i].frequency, freq_upper_limit, &report_error);
 
-		if (ChannelStateToTest[i].frequency>(1.001*globals.Constraints.err_max_freq[i])) {
-			report_error=freq_upper_limit;
+		if ((globals.Flash.max_freq_for_high_ot[i] > 0.0) && (fabs(ChannelStateToTest[i].offset) > globals.Flash.high_ot[i])) {
+			check_another_pos_max_value (globals.Flash.max_freq_for_high_ot[i], &globals.Constraints.err_max_freq[i], ChannelStateToTest[i].frequency, PRF_limited_by_offset, &report_error);
 		}
 
-		if (	(globals.Flash.max_freq_for_high_ot[i] > 0.0) &&
-			(fabs(ChannelStateToTest[i].offset) > globals.Flash.high_ot[i])) {
-
-			temp = globals.Flash.max_freq_for_high_ot[i];
-			if (temp<globals.Constraints.err_max_freq[i]) {
-				globals.Constraints.err_max_freq[i]=temp;
-				if (ChannelStateToTest[i].frequency>(1.001*globals.Constraints.err_max_freq[i])) {
-					report_error=PRF_limited_by_offset;
-				}
-			}
-		}
-
-		if (fabs(ChannelStateToTest[i].delay)>1.0e-15) {
-			temp=0.95/fabs(ChannelStateToTest[i].delay);
-			if (temp<globals.Constraints.err_max_freq[i]) {
-				globals.Constraints.err_max_freq[i]=temp;
-				if (ChannelStateToTest[i].frequency>(1.001*globals.Constraints.err_max_freq[i])) {
-					report_error=Delay_Exceeds_95Period;
-				}
-			}
-		}
+		check_another_pos_max_value (0.95/fabs(ChannelStateToTest[i].delay), &globals.Constraints.err_max_freq[i], ChannelStateToTest[i].frequency, Delay_Exceeds_95Period, &report_error);
 
 		if (globals.Flash.min_pw[i] > 0.0) {
-			temp=1/ChannelStateToTest[i].pw;
-			if (temp<globals.Constraints.err_max_freq[i]) {
-				globals.Constraints.err_max_freq[i]=temp;
-				if (ChannelStateToTest[i].frequency>(1.001*globals.Constraints.err_max_freq[i])) {
-					report_error=PW_Exceeds_Period;
-				}
-			}
+
+			check_another_pos_max_value (1/ChannelStateToTest[i].pw, &globals.Constraints.err_max_freq[i], ChannelStateToTest[i].frequency, PW_Exceeds_Period, &report_error);
 
 			if (		(ChannelStateToTest[i].burst_count>1)
 			                && (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;
-					if (ChannelStateToTest[i].frequency>(1.001*globals.Constraints.err_max_freq[i])) {
-						report_error=Burst_Exceeds_Period;
-					}
-				}
+				check_another_pos_max_value (1/(ChannelStateToTest[i].burst_count * (ChannelStateToTest[i].pw+ChannelStateToTest[i].burst_time)),
+								&globals.Constraints.err_max_freq[i], ChannelStateToTest[i].frequency, Burst_Exceeds_Period, &report_error);
 			}
 
-			temp=(1/ChannelStateToTest[i].pw)*(ampl_fixed_max_duty/duty_scale);
-			if (temp<globals.Constraints.err_max_freq[i]) {
-				globals.Constraints.err_max_freq[i]=temp;
-				if (ChannelStateToTest[i].frequency>(1.001*globals.Constraints.err_max_freq[i])) {
-					report_error=duty_cycle_upper_limit;
-				}
-			}
+			check_another_pos_max_value ((1/ChannelStateToTest[i].pw)*(ampl_fixed_max_duty/duty_scale),
+							&globals.Constraints.err_max_freq[i], ChannelStateToTest[i].frequency, duty_cycle_upper_limit, &report_error);
 
 			if (ChannelStateToTest[i].double_pulse==double_on) {
 				// pulse sep must be less than one half-period
-				temp = 0.5 / ChannelStateToTest[i].delay;
-				if (temp<globals.Constraints.err_max_freq[i]) {
-					globals.Constraints.err_max_freq[i]=temp;
-					if (ChannelStateToTest[i].frequency>(1.001*globals.Constraints.err_max_freq[i])) {
-						report_error=Double_Separation_Too_Large;
-					}
-				}
+				check_another_pos_max_value (0.5 / ChannelStateToTest[i].delay, &globals.Constraints.err_max_freq[i], ChannelStateToTest[i].frequency, Double_Separation_Too_Large, &report_error);
 			}
 
 			if ((globals.Flash.max_avg_ampl[i]) > 0.0 && (fabs(ChannelStateToTest[i].amplitude)) > 0.0) {
-				temp=100.0 * globals.Flash.max_avg_ampl[i] /
-				     (fabs(ChannelStateToTest[i].amplitude) * ChannelStateToTest[i].pw * duty_scale);
-				if (temp<globals.Constraints.err_max_freq[i]) {
-					globals.Constraints.err_max_freq[i]=temp;
-					if (ChannelStateToTest[i].frequency>(1.001*globals.Constraints.err_max_freq[i])) {
-						report_error=Average_Amplitude_Too_High;
-					}
-				}
+				temp=100.0 * globals.Flash.max_avg_ampl[i] / (fabs(ChannelStateToTest[i].amplitude) * ChannelStateToTest[i].pw * duty_scale);
+				check_another_pos_max_value (temp, &globals.Constraints.err_max_freq[i], ChannelStateToTest[i].frequency, Average_Amplitude_Too_High, &report_error);
 			}
 
 			if ((globals.Flash.hvps_avg_curr_limit[i] > 0.0) && (fabs(ChannelStateToTest[i].amplitude) > 0.0) && (ChannelStateToTest[i].pw > 0.0)) {
 				temp=(100.0 / duty_scale) * globals.Flash.hvps_avg_curr_limit[i] * ChannelStateToTest[i].load_type /
 				     (fabs(ChannelStateToTest[i].amplitude) * ChannelStateToTest[i].pw);
-				if (temp<globals.Constraints.err_max_freq[i]) {
-					globals.Constraints.err_max_freq[i]=temp;
-					if (ChannelStateToTest[i].frequency>(1.001*globals.Constraints.err_max_freq[i])) {
-						report_error=HVPS_Current_Too_High;
-					}
-				}
+				check_another_pos_max_value (temp, &globals.Constraints.err_max_freq[i], ChannelStateToTest[i].frequency, HVPS_Current_Too_High, &report_error);
 			}
 
 			if (globals.Flash.max_avg_power[i] > 0.0) {
 				temp = (globals.Flash.max_avg_power[i] * ChannelStateToTest[i].load_type) / (ChannelStateToTest[i].amplitude * ChannelStateToTest[i].amplitude * ChannelStateToTest[i].pw);
-				if (temp < globals.Constraints.err_max_freq[i]) {
-					globals.Constraints.err_max_freq[i] = temp;
-					if (ChannelStateToTest[i].frequency>(1.001*globals.Constraints.err_max_freq[i])) {
-						report_error=average_power_limit;
-					}
-				}
+				check_another_pos_max_value (temp, &globals.Constraints.err_max_freq[i], ChannelStateToTest[i].frequency, average_power_limit, &report_error);
 			}
 		}
 		/* ------------------------------- */
@@ -960,108 +944,58 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 
 
 		/* --- check maximum pw ---------- */
-		globals.Constraints.err_max_pw[i]=globals.Flash.max_pw[i];
+		check_starting_pos_max_value (globals.Flash.max_pw[i], &globals.Constraints.err_max_pw[i], ChannelStateToTest[i].pw, pw_upper_limit, &report_error);
 
 		/* polarity overrides */
-		if ((ChannelStateToTest[i].amplitude >= 0.0) && (globals.Flash.max_pw_pol[i][0] > 0.0) && (globals.Constraints.err_max_pw[i] > globals.Flash.max_pw_pol[i][0])) {
-			globals.Constraints.err_max_pw[i] = globals.Flash.max_pw_pol[i][0];
-		} else if ((ChannelStateToTest[i].amplitude <0.0) && (globals.Flash.max_pw_pol[i][1] > 0.0) && (globals.Constraints.err_max_pw[i] > globals.Flash.max_pw_pol[i][1])) {
-			globals.Constraints.err_max_pw[i] = globals.Flash.max_pw_pol[i][1];
-		}
-
-		if (ChannelStateToTest[i].pw>(1.001*globals.Constraints.err_max_pw[i])) {
-			report_error=pw_upper_limit;
+		if ((ChannelStateToTest[i].amplitude >= 0.0) && (globals.Flash.max_pw_pol[i][0] > 0.0)) {
+			check_another_pos_max_value (globals.Flash.max_pw_pol[i][0], &globals.Constraints.err_max_pw[i], ChannelStateToTest[i].pw, pw_upper_limit, &report_error);
+		} else if ((ChannelStateToTest[i].amplitude <0.0) && (globals.Flash.max_pw_pol[i][1] > 0.0)) {
+			check_another_pos_max_value (globals.Flash.max_pw_pol[i][1], &globals.Constraints.err_max_pw[i], ChannelStateToTest[i].pw, pw_upper_limit, &report_error);
 		}
 
 		// RC limit, as per AVR-8F-B
-		temp = globals.Flash.cap_for_pw_rc_limit[i] * ChannelStateToTest[i].load_type;
-		if ((temp > 0.0) && (temp<globals.Constraints.err_max_pw[i])) {
-			globals.Constraints.err_max_pw[i]=temp;
-			if (ChannelStateToTest[i].pw>(1.001*globals.Constraints.err_max_pw[i])) {
-				report_error=pw_rc_limit;
-			}
-		}
+		check_another_pos_max_value (globals.Flash.cap_for_pw_rc_limit[i] * ChannelStateToTest[i].load_type, 
+						&globals.Constraints.err_max_pw[i], ChannelStateToTest[i].pw, pw_rc_limit, &report_error);
 
 		if (ChannelStateToTest[i].double_pulse==double_on) {
-			temp = (ChannelStateToTest[i].delay - globals.Flash.double_pulse_extra_deadtime[i]) / (1.0 + globals.Flash.double_pulse_extra_pw_margin[i]);
-			if (temp<globals.Constraints.err_max_pw[i]) {
-				globals.Constraints.err_max_pw[i]=temp;
-				if (ChannelStateToTest[i].pw>(1.001*globals.Constraints.err_max_pw[i])) {
-					report_error=Double_Separation_Too_Small;
-				}
-			}
-
+			check_another_pos_max_value ((ChannelStateToTest[i].delay - globals.Flash.double_pulse_extra_deadtime[i]) / (1.0 + globals.Flash.double_pulse_extra_pw_margin[i]),
+							&globals.Constraints.err_max_pw[i], ChannelStateToTest[i].pw, Double_Separation_Too_Small, &report_error);
 			if (ChannelStateToTest[i].burst_count>1) {
 				report_error=Cant_Do_Burst_and_Double;
 			}
 		}
 
-		temp=(1/ChannelStateToTest[i].frequency) - globals.Flash.dead_time[i];
-		if (temp<globals.Constraints.err_max_pw[i]) {
-			globals.Constraints.err_max_pw[i]=temp;
-			if (ChannelStateToTest[i].pw>(1.001*globals.Constraints.err_max_pw[i])) {
-				report_error=Dead_Time_Error;
-			}
-		}
+		check_another_pos_max_value ((1/ChannelStateToTest[i].frequency) - globals.Flash.dead_time[i],
+						&globals.Constraints.err_max_pw[i], ChannelStateToTest[i].pw, Dead_Time_Error, &report_error);
 
-		temp=1/ChannelStateToTest[i].frequency;
-		if (temp<globals.Constraints.err_max_pw[i]) {
-			globals.Constraints.err_max_pw[i]=temp;
-			if (ChannelStateToTest[i].pw>(1.001*globals.Constraints.err_max_pw[i])) {
-				report_error=PW_Exceeds_Period;
-			}
-		}
+		check_another_pos_max_value (1/ChannelStateToTest[i].frequency, &globals.Constraints.err_max_pw[i], ChannelStateToTest[i].pw, PW_Exceeds_Period, &report_error);
 
 		if (		(ChannelStateToTest[i].burst_count>1)
 		                && (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;
-				if (ChannelStateToTest[i].pw>(1.001*globals.Constraints.err_max_pw[i])) {
-					report_error=Burst_Exceeds_Period;
-				}
-			}
-		}
 
-		temp=(1/ChannelStateToTest[i].frequency)*(ampl_fixed_max_duty/duty_scale);
-		if (temp<globals.Constraints.err_max_pw[i]) {
-			globals.Constraints.err_max_pw[i]=temp;
-			if (ChannelStateToTest[i].pw>(1.001*globals.Constraints.err_max_pw[i])) {
-				report_error=duty_cycle_upper_limit;
-			}
+			check_another_pos_max_value ((1/ChannelStateToTest[i].frequency)/ChannelStateToTest[i].burst_count - ChannelStateToTest[i].burst_time,
+							&globals.Constraints.err_max_pw[i], ChannelStateToTest[i].pw, Burst_Exceeds_Period, &report_error);
 		}
 
+		check_another_pos_max_value ((1/ChannelStateToTest[i].frequency)*(ampl_fixed_max_duty/duty_scale),
+						&globals.Constraints.err_max_pw[i], ChannelStateToTest[i].pw, duty_cycle_upper_limit, &report_error);
+
 		if ((globals.Flash.max_avg_ampl[i]) > 0.0 && (fabs(ChannelStateToTest[i].amplitude)) > 0.0) {
-			temp=100.0 * globals.Flash.max_avg_ampl[i] /
-			     (fabs(ChannelStateToTest[i].amplitude) * ChannelStateToTest[i].frequency * duty_scale);
-			if (temp<globals.Constraints.err_max_pw[i]) {
-				globals.Constraints.err_max_pw[i]=temp;
-				if (ChannelStateToTest[i].pw>(1.001*globals.Constraints.err_max_pw[i])) {
-					report_error=Average_Amplitude_Too_High;
-				}
-			}
+			check_another_pos_max_value (100.0 * globals.Flash.max_avg_ampl[i] / (fabs(ChannelStateToTest[i].amplitude) * ChannelStateToTest[i].frequency * duty_scale),
+							&globals.Constraints.err_max_pw[i], ChannelStateToTest[i].pw, Average_Amplitude_Too_High, &report_error);
 		}
 
 		if ((globals.Flash.hvps_avg_curr_limit[i] > 0.0) && (fabs(ChannelStateToTest[i].amplitude) > 0.0) && (ChannelStateToTest[i].frequency > 0.0)) {
-			temp=(100.0 / duty_scale) * globals.Flash.hvps_avg_curr_limit[i] * ChannelStateToTest[i].load_type /
-			     (fabs(ChannelStateToTest[i].amplitude) * ChannelStateToTest[i].frequency);
-			if (temp<globals.Constraints.err_max_pw[i]) {
-				globals.Constraints.err_max_pw[i]=temp;
-				if (ChannelStateToTest[i].pw>(1.001*globals.Constraints.err_max_pw[i])) {
-					report_error=HVPS_Current_Too_High;
-				}
-			}
+			check_another_pos_max_value ((100.0 / duty_scale) * globals.Flash.hvps_avg_curr_limit[i] * ChannelStateToTest[i].load_type /
+							(fabs(ChannelStateToTest[i].amplitude) * ChannelStateToTest[i].frequency),
+							&globals.Constraints.err_max_pw[i], ChannelStateToTest[i].pw, HVPS_Current_Too_High, &report_error);
 		}
 
 		if (globals.Flash.max_avg_power[i] > 0.0) {
-			temp = globals.Flash.max_avg_power[i] * ChannelStateToTest[i].load_type / (ChannelStateToTest[i].amplitude * ChannelStateToTest[i].amplitude * ChannelStateToTest[i].frequency);
-			if (temp < globals.Constraints.err_max_pw[i]) {
-				globals.Constraints.err_max_pw[i] = temp;
-				if (ChannelStateToTest[i].pw>(1.001*globals.Constraints.err_max_pw[i])) {
-					report_error=average_power_limit;
-				}
-			}
+			check_another_pos_max_value (globals.Flash.max_avg_power[i] * ChannelStateToTest[i].load_type /
+							(ChannelStateToTest[i].amplitude * ChannelStateToTest[i].amplitude * ChannelStateToTest[i].frequency),
+							&globals.Constraints.err_max_pw[i], ChannelStateToTest[i].pw, average_power_limit, &report_error);
 		}
 
 		/* ------------------------------- */
@@ -1233,12 +1167,8 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 			if (globals.Flash.max_avg_power[i] > 0.0) {
 				temp = sqrt(globals.Flash.max_avg_power[i] * ChannelStateToTest[i].load_type / (ChannelStateToTest[i].pw  * ChannelStateToTest[i].frequency));
 				// temp is positive at this point
-				if (temp < globals.Constraints.err_max_ampl[i]) {
-					globals.Constraints.err_max_ampl[i]=temp;
-					if (ChannelStateToTest[i].amplitude>(1.001*globals.Constraints.err_max_ampl[i])) {
-						report_error=average_power_limit;
-					}
-				}
+				check_another_pos_max_value (temp, &globals.Constraints.err_max_ampl[i], ChannelStateToTest[i].amplitude, average_power_limit, &report_error);
+
 				temp = temp * -1.0;	// check negative possibility
 				if (temp > globals.Constraints.err_min_ampl[i]) {
 					globals.Constraints.err_min_ampl[i]=temp;
@@ -1274,12 +1204,8 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 					temp=(100.0 / duty_scale) * globals.Flash.hvps_avg_curr_limit[i] * ChannelStateToTest[i].load_type /
 					     (ChannelStateToTest[i].frequency * ChannelStateToTest[i].pw);
 					// temp is positive at this point
-					if (temp < globals.Constraints.err_max_ampl[i]) {
-						globals.Constraints.err_max_ampl[i]=temp;
-						if (ChannelStateToTest[i].amplitude>(1.001*globals.Constraints.err_max_ampl[i])) {
-							report_error=HVPS_Current_Too_High;
-						}
-					}
+					check_another_pos_max_value (temp, &globals.Constraints.err_max_ampl[i], ChannelStateToTest[i].amplitude, HVPS_Current_Too_High, &report_error);
+
 					temp = temp * -1.0;	// check negative possibility
 					if (temp > globals.Constraints.err_min_ampl[i]) {
 						globals.Constraints.err_min_ampl[i]=temp;
@@ -1464,6 +1390,7 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 
 				/* --- check minimum burst gap settings --- */
 
+				// FIXME - update with new check_ routines, but only report error if count>1
 				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]))) {
@@ -1473,6 +1400,7 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 
 				/* --- check minimum burst period settings --- */
 
+				// FIXME - update with new check_ routines, but only report error if count>1
 				if (globals.Flash.min_pw[i] > 0.0) {
 					temp = globals.Flash.min_burst_per[i] - ChannelStateToTest[i].pw;
 					if (temp > globals.Constraints.err_min_burst_time[i]) {
@@ -1496,12 +1424,7 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 
 				/* --- check maximum burst gap settings --- */
 
-				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]))) {
-					report_error=max_burst_gap_error;
-				}
-
+				check_starting_pos_max_value (globals.Flash.max_burst_gap[i], &globals.Constraints.err_max_burst_time[i], ChannelStateToTest[i].burst_time, max_burst_gap_error, &report_error);
 			}
 		}
 
@@ -1519,35 +1442,22 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 					}
 				}
 
-				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;
-				}
-
-				globals.Constraints.err_max_rise_time[i]=globals.Flash.max_rise_time[i];
-				if (ChannelStateToTest[i].rise_time>(1.001*globals.Constraints.err_max_rise_time[i])) {
-					report_error=max_rise_time_error;
-				}
+				check_starting_pos_min_value (globals.Flash.min_rise_time[i], &globals.Constraints.err_min_rise_time[i], ChannelStateToTest[i].rise_time, min_rise_time_error, &report_error);
+				check_starting_pos_max_value (globals.Flash.max_rise_time[i], &globals.Constraints.err_max_rise_time[i], ChannelStateToTest[i].rise_time, max_rise_time_error, &report_error);
 			}
 
 		/* --- check slew settings --- */
 		/* disable amplitude checks if calibration is in progress */
 		if (globals.Flash.curr_slew[i])
 			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;
-				}
-
-				globals.Constraints.err_max_slew[i]=globals.Flash.max_slew[i];
-				if (ChannelStateToTest[i].slew>(1.001*globals.Constraints.err_max_slew[i])) {
-					report_error=max_slew_error;
-				}
+				check_starting_pos_min_value (globals.Flash.min_slew[i], &globals.Constraints.err_min_slew[i], ChannelStateToTest[i].slew, min_slew_error, &report_error);
+				check_starting_pos_max_value (globals.Flash.max_slew[i], &globals.Constraints.err_max_slew[i], ChannelStateToTest[i].slew, max_slew_error, &report_error);
 			}
 
 		/* --- check resistance settings --- */
 
 		if (globals.Flash.switchable_load[i]) {
+			// FIXME to use new check_ functions
 			globals.Constraints.err_min_load_type[i]=globals.Flash.low_load_type[i];
 			if (duty_cycle > max_duty_this_ampl) {
 				globals.Constraints.err_min_load_type[i] *= duty_cycle / max_duty_this_ampl;
@@ -1558,52 +1468,33 @@ int Error_check(ChannelStruct ChannelStateToTest[max_channels])
 		}
 
 		if (globals.Flash.cap_for_pw_rc_limit[i] > 0.0) {
-			temp = ChannelStateToTest[i].pw / globals.Flash.cap_for_pw_rc_limit[i];
-			if (temp > globals.Constraints.err_min_load_type[i]) {
-				globals.Constraints.err_min_load_type[i] = temp;
-				if (ChannelStateToTest[i].load_type<(0.999*globals.Constraints.err_min_load_type[i])) {
-					report_error=pw_rc_limit;
-				}
-			}
+			check_another_pos_min_value (ChannelStateToTest[i].pw / globals.Flash.cap_for_pw_rc_limit[i], 
+							&globals.Constraints.err_min_load_type[i], ChannelStateToTest[i].load_type, pw_rc_limit, &report_error);
 		}
 
 		if (globals.Flash.hvps_avg_curr_limit[i] > 0.0) {
-			temp=	(duty_scale / 100.0) * fabs(ChannelStateToTest[i].amplitude) * ChannelStateToTest[i].pw * ChannelStateToTest[i].frequency / globals.Flash.hvps_avg_curr_limit[i];
-			if (temp > globals.Constraints.err_min_load_type[i]) {
-				globals.Constraints.err_min_load_type[i]=temp;
-				if (ChannelStateToTest[i].load_type<(0.999*globals.Constraints.err_min_load_type[i])) {
-					report_error=HVPS_Current_Too_High;
-				}
-			}
+			check_another_pos_min_value ((duty_scale / 100.0) * fabs(ChannelStateToTest[i].amplitude) * ChannelStateToTest[i].pw * ChannelStateToTest[i].frequency /
+							globals.Flash.hvps_avg_curr_limit[i],
+							&globals.Constraints.err_min_load_type[i], ChannelStateToTest[i].load_type, HVPS_Current_Too_High, &report_error);
 		}
 
 		if (globals.Flash.max_peak_power[i] > 0.0) {
-			temp = ChannelStateToTest[i].amplitude * ChannelStateToTest[i].amplitude / globals.Flash.max_peak_power[i];
-			if (temp > globals.Constraints.err_min_load_type[i]) {
-				globals.Constraints.err_min_load_type[i] = temp;
-				if (ChannelStateToTest[i].load_type<(0.999*globals.Constraints.err_min_load_type[i])) {
-					report_error=peak_power_limit;
-				}
-			}
+			check_another_pos_min_value (ChannelStateToTest[i].amplitude * ChannelStateToTest[i].amplitude / globals.Flash.max_peak_power[i],
+							&globals.Constraints.err_min_load_type[i], ChannelStateToTest[i].load_type, peak_power_limit, &report_error);
 		}
 
 		if (globals.Flash.max_avg_power[i] > 0.0) {
-			temp = (ChannelStateToTest[i].amplitude * ChannelStateToTest[i].amplitude * ChannelStateToTest[i].pw * ChannelStateToTest[i].frequency) / globals.Flash.max_avg_power[i];
-			if (temp > globals.Constraints.err_min_load_type[i]) {
-				globals.Constraints.err_min_load_type[i] = temp;
-				if (ChannelStateToTest[i].load_type<(0.999*globals.Constraints.err_min_load_type[i])) {
-					report_error=average_power_limit;
-				}
-			}
+			check_another_pos_min_value ((ChannelStateToTest[i].amplitude * ChannelStateToTest[i].amplitude * ChannelStateToTest[i].pw * ChannelStateToTest[i].frequency) /
+							globals.Flash.max_avg_power[i],
+							&globals.Constraints.err_min_load_type[i], ChannelStateToTest[i].load_type, average_power_limit, &report_error);
 		}
 
-		globals.Constraints.err_max_load_type[i]=1.0*globals.Flash.high_load_type[i];
-		if (ChannelStateToTest[i].load_type>(1.001*globals.Constraints.err_max_load_type[i])) {
-			report_error=max_load_type_error;
-		}
+		check_starting_pos_max_value (globals.Flash.high_load_type[i], &globals.Constraints.err_max_load_type[i], ChannelStateToTest[i].load_type, max_load_type_error, &report_error);
 
 		/* --- check soft_current_limit settings --- */
 		if (globals.Flash.soft_current_limit_enabled[i]) {
+			// FIXME to use new check_ functions
+
 			globals.Constraints.err_min_soft_current_limit[i]=globals.Flash.min_soft_current_limit[i];
 			if (ChannelStateToTest[i].soft_current_limit<(0.999*globals.Constraints.err_min_soft_current_limit[i])) {
 				report_error=min_soft_current_limit_error;