path: root/servers/gpib_server_lin/src/commanalyzer_functions.c

/*
 * Remote Laboratory Instrumentation Server
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * (c) 2009 Timothy Pearson
 * Raptor Engineering
 * http://www.raptorengineeringinc.com
 */

#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <getopt.h>
#include <allegro.h>
#include "parameters.h"
#include "gpib_functions.h"
#include "gpib/ib.h"

char falpha[1024];
double commanalyzer_raw_trace_data[1024];

unsigned long commanalyzerTraceLength (char * commanalyzerType) {
	if (strcmp("HP8924C", commanalyzerType) == 0) {
		return 417;
	}
	else {
		return 1;
	}
}

int commanalyzer_set_date(struct tm * datetime, char * commanalyzerType, int gpibDevice) {
	char datebuffer [80];
	strftime(datebuffer,80,"CONF:DATE %m%d%y",datetime);

	if (strcmp("HP8924C", commanalyzerType) == 0) {
		printf("[INFO] Setting date on communications analyzer\n\r");
		if (strcmp("HP8924C", commanalyzerType) == 0) {
			#ifdef ENABLE_EXTRA_DEBUGGING
			printf("[DEBG] Writing: %s\n\r", datebuffer);
			#endif
			if (gpib_write(gpibDevice, datebuffer) == 0) {
				return 0;
			}
			else {
				return 2;
			}
		}
	}
	else {
		return 1;
	}
}

int commanalyzer_set_time(struct tm * datetime, char * commanalyzerType, int gpibDevice) {
	char timebuffer [80];
	strftime(timebuffer,80,"CONF:TIME +%H.%M",datetime);	// FIXME wrong format

	if (strcmp("HP8924C", commanalyzerType) == 0) {
		printf("[INFO] Setting time on communications analyzer\n\r");
		if (strcmp("HP8924C", commanalyzerType) == 0) {
			#ifdef ENABLE_EXTRA_DEBUGGING
			printf("[DEBG] Writing: %s\n\r", timebuffer);
			#endif
			if (gpib_write(gpibDevice, timebuffer) == 0) {
				return 0;
			}
			else {
				return 2;
			}
		}
	}
	else {
		return 1;
	}
}

int commanalyzer_switch_to_spectrum_analyzer_mode(char * commanalyzerType, int gpibDevice) {
	if (strcmp("HP8924C", commanalyzerType) == 0) {
		printf("[INFO] Setting communications analyzer to spectrum anayzer mode\n\r");
		if (strcmp("HP8924C", commanalyzerType) == 0) {
			sprintf(falpha,"DISP SAN");
			#ifdef ENABLE_EXTRA_DEBUGGING
			printf("[DEBG] Writing: %s\n\r", falpha);
			#endif
			if (gpib_write(gpibDevice, falpha) == 0) {
				return 0;
			}
			else {
				return 2;
			}
		}
	}
	else {
		return 1;
	}
}

int commanalyzer_lock_screen (char * commanalyzerType, int gpibDevice) {
	if (strcmp("HP8924C", commanalyzerType) == 0) {
		printf("[INFO] Locking communications analyzer screen\n\r");
		if (strcmp("HP8924C", commanalyzerType) == 0) {
			sprintf(falpha,"SPEC:DISP 'LOCKED'");
			#ifdef ENABLE_EXTRA_DEBUGGING
			printf("[DEBG] Writing: %s\n\r", falpha);
			#endif
			if (gpib_write(gpibDevice, falpha) == 0) {
				return 0;
			}
			else {
				return 2;
			}
		}
	}
	else {
		return 1;
	}
}

int commanalyzer_spectrum_analyzer_set_generator_mode_tracking (char * commanalyzerType, int gpibDevice) {
	if (strcmp("HP8924C", commanalyzerType) == 0) {
		printf("[INFO] Setting spectrum analyzer generator to tracking mode\n\r");
		if (strcmp("HP8924C", commanalyzerType) == 0) {
			sprintf(falpha,"SAN:RFG 'TRACK'");
			#ifdef ENABLE_EXTRA_DEBUGGING
			printf("[DEBG] Writing: %s\n\r", falpha);
			#endif
			if (gpib_write(gpibDevice, falpha) == 0) {
				return 0;
			}
			else {
				return 2;
			}
		}
	}
	else {
		return 1;
	}
}

int commanalyzer_spectrum_analyzer_set_generator_mode_fixed (char * commanalyzerType, int gpibDevice) {
	if (strcmp("HP8924C", commanalyzerType) == 0) {
		printf("[INFO] Setting spectrum analyzer generator to fixed mode\n\r");
		if (strcmp("HP8924C", commanalyzerType) == 0) {
			sprintf(falpha,"SAN:RFG 'FIXED'");
			#ifdef ENABLE_EXTRA_DEBUGGING
			printf("[DEBG] Writing: %s\n\r", falpha);
			#endif
			if (gpib_write(gpibDevice, falpha) == 0) {
				return 0;
			}
			else {
				return 2;
			}
		}
	}
	else {
		return 1;
	}
}

int commanalyzer_spectrum_analyzer_set_rf_input_dedicated (char * commanalyzerType, int gpibDevice) {
	if (strcmp("HP8924C", commanalyzerType) == 0) {
		printf("[INFO] Setting spectrum analyzer RF input to dedicated connector\n\r");
		if (strcmp("HP8924C", commanalyzerType) == 0) {
			sprintf(falpha,"SAN:INP 'ANT'");
			#ifdef ENABLE_EXTRA_DEBUGGING
			printf("[DEBG] Writing: %s\n\r", falpha);
			#endif
			if (gpib_write(gpibDevice, falpha) == 0) {
				return 0;
			}
			else {
				return 2;
			}
		}
	}
	else {
		return 1;
	}
}

int commanalyzer_spectrum_analyzer_set_rf_input_muxed (char * commanalyzerType, int gpibDevice) {
	if (strcmp("HP8924C", commanalyzerType) == 0) {
		printf("[INFO] Setting spectrum analyzer RF input to multiplexed connector\n\r");
		if (strcmp("HP8924C", commanalyzerType) == 0) {
			sprintf(falpha,"SAN:INP 'RF IN'");
			#ifdef ENABLE_EXTRA_DEBUGGING
			printf("[DEBG] Writing: %s\n\r", falpha);
			#endif
			if (gpib_write(gpibDevice, falpha) == 0) {
				return 0;
			}
			else {
				return 2;
			}
		}
	}
	else {
		return 1;
	}
}

int commanalyzer_spectrum_analyzer_set_generator_output_dedicated (char * commanalyzerType, int gpibDevice) {
	if (strcmp("HP8924C", commanalyzerType) == 0) {
		printf("[INFO] Setting spectrum analyzer generator output to dedicated connector\n\r");
		if (strcmp("HP8924C", commanalyzerType) == 0) {
			sprintf(falpha,"SAN:TGEN:DEST 'DUPL'");
			#ifdef ENABLE_EXTRA_DEBUGGING
			printf("[DEBG] Writing: %s\n\r", falpha);
			#endif
			if (gpib_write(gpibDevice, falpha) == 0) {
				return 0;
			}
			else {
				return 2;
			}
		}
	}
	else {
		return 1;
	}
}

int commanalyzer_spectrum_analyzer_set_generator_output_muxed (char * commanalyzerType, int gpibDevice) {
	if (strcmp("HP8924C", commanalyzerType) == 0) {
		printf("[INFO] Setting spectrum analyzer generator output to multiplexed connector\n\r");
		if (strcmp("HP8924C", commanalyzerType) == 0) {
			sprintf(falpha,"SAN:TGEN:DEST 'RF OUT'");
			#ifdef ENABLE_EXTRA_DEBUGGING
			printf("[DEBG] Writing: %s\n\r", falpha);
			#endif
			if (gpib_write(gpibDevice, falpha) == 0) {
				return 0;
			}
			else {
				return 2;
			}
		}
	}
	else {
		return 1;
	}
}

int commanalyzer_get_spectrum_analyzer_trace(char * commanalyzerType, int gpibDevice) {
	int max_num_bytes = 0;

	unsigned char segarray[4194304];
	unsigned char floatstring[1024];
	long array_pointer;
	long ai;
	long left_char;
	long right_char;

	int x;
	int y;

	if ((strcmp("HP8924C", commanalyzerType) == 0)) {
		// Send request
		printf("[INFO] Getting spectrum analyzer trace [Stage 1]\n\r");
		if (strcmp("HP8924C", commanalyzerType) == 0) {
			sprintf(falpha,"MEAS:SAN:TRACE?");
			#ifdef ENABLE_EXTRA_DEBUGGING
			printf("[DEBG] Writing: %s\n\r", falpha);
			#endif
			if (gpib_write(gpibDevice, falpha) == 0) {
				max_num_bytes = (commanalyzerTraceLength(commanalyzerType)*24);	// Request more bytes than are possible to ensure no bytes are left behind
			}
			else {
				return 2;
			}
		}

		// Read response
		#ifdef ENABLE_EXTRA_DEBUGGING
		printf("[DEBG] Trying to read %i bytes from GPIB device...\n", max_num_bytes);
		#endif
	
		ibtmo(gpibDevice, T30s);
		ibeos(gpibDevice, 0x0);
	
		ai = gpib_read_array(gpibDevice, max_num_bytes, segarray);
		if (ai == -1) {
			return 1;
		}
		else {
			if (strcmp("HP8924C", commanalyzerType) == 0) {
				left_char = 0;
				right_char = 0;
				array_pointer = 0;
				while (left_char < ai) {
					for (right_char=left_char;right_char<ai;right_char++) {
						if (segarray[right_char] == ',') {
							break;
						}
					}
					strncpy(floatstring, segarray+left_char, right_char-left_char);
					floatstring[right_char-left_char] = 0;
					commanalyzer_raw_trace_data[array_pointer] = atof(floatstring);
					array_pointer++;
					left_char = right_char+1;
				}
			}
			else {
				return 2;
			}
		}
	
		ibtmo(gpibDevice, T10s);
	
		#ifdef ENABLE_EXTRA_DEBUGGING
		printf("[DEBG] Read %li bytes from GPIB device\n", array_pointer);
		#endif

		return 0;
	}
}

int commanalyzer_set_spectrum_analyzer_center_frequency(float desired_frequency, char * commanalyzerType, int gpibDevice) {
	if ((strcmp("HP8924C", commanalyzerType) == 0)) {
		printf("[INFO] Setting spectrum analyzer center frequency to %f\n\r", desired_frequency);
		if (strcmp("HP8924C", commanalyzerType) == 0) {
			sprintf(falpha,"SAN:CFR %E", desired_frequency);
			#ifdef ENABLE_EXTRA_DEBUGGING
			printf("[DEBG] Writing: %s\n\r", falpha);
			#endif
			if (gpib_write(gpibDevice, falpha) == 0) {
				return 0;
			}
			else {
				return 2;
			}
		}
	}
	else {
		return 1;
	}
}

int commanalyzer_set_spectrum_analyzer_frequency_span(float desired_frequency, char * commanalyzerType, int gpibDevice) {
	if ((strcmp("HP8924C", commanalyzerType) == 0)) {
		printf("[INFO] Setting spectrum analyzer span frequency to %f\n\r", desired_frequency);
		if (strcmp("HP8924C", commanalyzerType) == 0) {
			sprintf(falpha,"SAN:SPAN %E", desired_frequency);
			#ifdef ENABLE_EXTRA_DEBUGGING
			printf("[DEBG] Writing: %s\n\r", falpha);
			#endif
			if (gpib_write(gpibDevice, falpha) == 0) {
				return 0;
			}
			else {
				return 2;
			}
		}
	}
	else {
		return 1;
	}
}

int commanalyzer_set_spectrum_analyzer_input_attenuation(float desired_attenuation, char * commanalyzerType, int gpibDevice) {
	int instrument_att;

	if ((strcmp("HP8924C", commanalyzerType) == 0)) {
		if (strcmp("HP8924C", commanalyzerType) == 0) {
			// Only three attenuation values are valid
			if (desired_attenuation < 10) {
				instrument_att = 0;
			}
			else if (desired_attenuation < 30) {
				instrument_att = 20;
			}
			else {
				instrument_att = 40;
			}
		}
		printf("[INFO] Setting spectrum analyzer attenuation to %d dB\n\r", instrument_att);
		if (strcmp("HP8924C", commanalyzerType) == 0) {
			sprintf(falpha,"SAN:ATT '%d DB'", instrument_att);
			#ifdef ENABLE_EXTRA_DEBUGGING
			printf("[DEBG] Writing: %s\n\r", falpha);
			#endif
			if (gpib_write(gpibDevice, falpha) == 0) {
				return 0;
			}
			else {
				return 2;
			}
		}
	}
	else {
		return 1;
	}
}

int commanalyzer_set_spectrum_analyzer_scale(float desired_scale, char * commanalyzerType, int gpibDevice) {
	int instrument_scale;

	if ((strcmp("HP8924C", commanalyzerType) == 0)) {
		if (strcmp("HP8924C", commanalyzerType) == 0) {
			// Only three scale values are valid
			if (desired_scale < 1.5) {
				instrument_scale = 1;
			}
			else if (desired_scale < 6) {
				instrument_scale = 2;
			}
			else {
				instrument_scale = 10;
			}
		}
		printf("[INFO] Setting spectrum analyzer scale to %d dB/div\n\r", instrument_scale);
		if (strcmp("HP8924C", commanalyzerType) == 0) {
			sprintf(falpha,"SAN:DISP:SCAL '%d DB/DIV'", instrument_scale);
			#ifdef ENABLE_EXTRA_DEBUGGING
			printf("[DEBG] Writing: %s\n\r", falpha);
			#endif
			if (gpib_write(gpibDevice, falpha) == 0) {
				return 0;
			}
			else {
				return 2;
			}
		}
	}
	else {
		return 1;
	}
}

int commanalyzer_set_spectrum_analyzer_input_attenuator_mode_auto( char * commanalyzerType, int gpibDevice) {
	if ((strcmp("HP8924C", commanalyzerType) == 0)) {
		printf("[INFO] Setting spectrum analyzer attenuation mode to automatic\n\r");
		if (strcmp("HP8924C", commanalyzerType) == 0) {
			sprintf(falpha,"SAN:ATT:MODE 'AUTO'");
			#ifdef ENABLE_EXTRA_DEBUGGING
			printf("[DEBG] Writing: %s\n\r", falpha);
			#endif
			if (gpib_write(gpibDevice, falpha) == 0) {
				return 0;
			}
			else {
				return 2;
			}
		}
	}
	else {
		return 1;
	}
}

int commanalyzer_set_spectrum_analyzer_input_attenuator_mode_fixed( char * commanalyzerType, int gpibDevice) {
	if ((strcmp("HP8924C", commanalyzerType) == 0)) {
		printf("[INFO] Setting spectrum analyzer attenuation mode to fixed\n\r");
		if (strcmp("HP8924C", commanalyzerType) == 0) {
			sprintf(falpha,"SAN:ATT:MODE 'HOLD'");
			#ifdef ENABLE_EXTRA_DEBUGGING
			printf("[DEBG] Writing: %s\n\r", falpha);
			#endif
			if (gpib_write(gpibDevice, falpha) == 0) {
				return 0;
			}
			else {
				return 2;
			}
		}
	}
	else {
		return 1;
	}
}

int commanalyzer_set_spectrum_analyzer_generator_power(float desired_power, char * commanalyzerType, int gpibDevice) {
	if ((strcmp("HP8924C", commanalyzerType) == 0)) {
		printf("[INFO] Setting spectrum analyzer generator power to %f\n\r", desired_power);
		if (strcmp("HP8924C", commanalyzerType) == 0) {
			sprintf(falpha,"SAN:TGEN:AMPL %E", desired_power);
			#ifdef ENABLE_EXTRA_DEBUGGING
			printf("[DEBG] Writing: %s\n\r", falpha);
			#endif
			if (gpib_write(gpibDevice, falpha) == 0) {
				return 0;
			}
			else {
				return 2;
			}
		}
	}
	else {
		return 1;
	}
}

int commanalyzer_set_spectrum_analyzer_generator_frequency(float desired_frequency, char * commanalyzerType, int gpibDevice) {
	if ((strcmp("HP8924C", commanalyzerType) == 0)) {
		printf("[INFO] Setting spectrum analyzer generator frequency to %f\n\r", desired_frequency);
		if (strcmp("HP8924C", commanalyzerType) == 0) {
			sprintf(falpha,"SAN:TGEN:OFR %E", desired_frequency);
			#ifdef ENABLE_EXTRA_DEBUGGING
			printf("[DEBG] Writing: %s\n\r", falpha);
			#endif
			if (gpib_write(gpibDevice, falpha) == 0) {
				return 0;
			}
			else {
				return 2;
			}
		}
	}
	else {
		return 1;
	}
}

int commanalyzer_spectrum_analyzer_set_generator_sweep_ascending (char * commanalyzerType, int gpibDevice) {
	if (strcmp("HP8924C", commanalyzerType) == 0) {
		printf("[INFO] Setting spectrum analyzer generator output sweep to ascending\n\r");
		if (strcmp("HP8924C", commanalyzerType) == 0) {
			sprintf(falpha,"SAN:TGEN:SWE 'NORM'");
			#ifdef ENABLE_EXTRA_DEBUGGING
			printf("[DEBG] Writing: %s\n\r", falpha);
			#endif
			if (gpib_write(gpibDevice, falpha) == 0) {
				return 0;
			}
			else {
				return 2;
			}
		}
	}
	else {
		return 1;
	}
}

int commanalyzer_spectrum_analyzer_set_generator_sweep_descending (char * commanalyzerType, int gpibDevice) {
	if (strcmp("HP8924C", commanalyzerType) == 0) {
		printf("[INFO] Setting spectrum analyzer generator output sweep to descending\n\r");
		if (strcmp("HP8924C", commanalyzerType) == 0) {
			sprintf(falpha,"SAN:TGEN:SWE 'INVERT'");
			#ifdef ENABLE_EXTRA_DEBUGGING
			printf("[DEBG] Writing: %s\n\r", falpha);
			#endif
			if (gpib_write(gpibDevice, falpha) == 0) {
				return 0;
			}
			else {
				return 2;
			}
		}
	}
	else {
		return 1;
	}
}

int commanalyzer_set_spectrum_analyzer_trace_averaging(float desired_avg_samples, char * commanalyzerType, int gpibDevice) {
	if ((strcmp("HP8924C", commanalyzerType) == 0)) {
		int instrument_samples;
		if (strcmp("HP8924C", commanalyzerType) == 0) {
			// Only certain values are valid, and I am interpreting 0 as no pk/avg and -1 as peak hold
			instrument_samples = desired_avg_samples;
			if (desired_avg_samples > 5) {
				if (desired_avg_samples < 5) {
					instrument_samples = desired_avg_samples;
				}
				else if (desired_avg_samples < 7) {
					instrument_samples = 5;
				}
				else if (desired_avg_samples < 15) {
					instrument_samples = 10;
				}
				else if (desired_avg_samples < 35) {
					instrument_samples = 20;
				}
				else if (desired_avg_samples < 75) {
					instrument_samples = 50;
				}
				else {
					instrument_samples = 100;
				}
			}
		}
		printf("[INFO] Setting spectrum analyzer generator trace averaging to %d\n\r", instrument_samples);
		if (strcmp("HP8924C", commanalyzerType) == 0) {
			if (instrument_samples > 0) {
				sprintf(falpha,"SAN:TRAC:MHOL 'AVG %d'", instrument_samples);
			}
			else if (instrument_samples == -1) {
				sprintf(falpha,"SAN:TRAC:MHOL 'PK HOLD'");
			}
			else {
				sprintf(falpha,"SAN:TRAC:MHOL 'NO PK/AVG'");
			}
			#ifdef ENABLE_EXTRA_DEBUGGING
			printf("[DEBG] Writing: %s\n\r", falpha);
			#endif
			if (gpib_write(gpibDevice, falpha) == 0) {
				return 0;
			}
			else {
				return 2;
			}
		}
	}
	else {
		return 1;
	}
}

int commanalyzer_set_spectrum_analyzer_reference_power_level(float desired_reflevel, char * commanalyzerType, int gpibDevice) {
	if ((strcmp("HP8924C", commanalyzerType) == 0)) {
		printf("[INFO] Setting spectrum analyzer generator reference level to %f dBm\n\r", desired_reflevel);
		if (strcmp("HP8924C", commanalyzerType) == 0) {
			sprintf(falpha,"SAN:RLEV %E", desired_reflevel);
			#ifdef ENABLE_EXTRA_DEBUGGING
			printf("[DEBG] Writing: %s\n\r", falpha);
			#endif
			if (gpib_write(gpibDevice, falpha) == 0) {
				return 0;
			}
			else {
				return 2;
			}
		}
	}
	else {
		return 1;
	}
}