fxanalyse: FXAnalyse.c comparison

comparison FXAnalyse.c @ 269:3f395eab72eb

Whitespace

author	Daniele Nicolodi <daniele.nicolodi@obspm.fr>
date	Fri, 10 Jul 2015 13:40:36 +0200
parents	ec4462c7f8b7
children	a451d4618dbf

comparison

equal deleted inserted replaced

-:ec4462c7f8b7
+:3f395eab72eb
 #include <zmq.h>
 #include <tcpsupp.h>
 #include <utility.h>
 #include <ansi_c.h>
 #include <lowlvlio.h>
 #include <cvirte.h>
 #include <userint.h>
 #include <formatio.h>
 #include <inifile.h>
 #include <string.h>
 #include "FXAnalyse.h"
 #include "Plot.h"
 #include "Allan.h"
 #include "ad9912.h"
 #include "ad9956.h"
 #include "muParserDLL.h"
 #include "utils.h"
 #include "stat.h"
 #include "future.h"
 #include "data-provider.h"
 // ZMQ
 void *zmqcontext;
 void *zmqsocket;
 // utility function to send data through ZMQ socket framed by an envelope
 // see "Pub-Sub Message Envelopes" in chapter 2 "Sockets and Patterns"
 // of "ZMQ The Guide" http://zguide.zeromq.org/page:all#toc49
 int zmq_xpub(void *socket, char *envelope, void *data, size_t len)
 {
 	int r;
 	r = zmq_send(socket, envelope, strlen(envelope), ZMQ_SNDMORE);
 	if (r < 0)
 		return zmq_errno();
 	r = zmq_send(socket, data, len, 0);
 	if (r < 0)
 		return zmq_errno();
 	return 0;
 }
 struct event ev;
 double utc;
 #define Ch1 ev.data[0]
 #define Ch2 ev.data[1]
 static int ad9956_set_w(struct ad9956 *d, double f, double s)
 {
 	int r;
 	r = ad9956_sweep_stop(d);
 	if (r) {
 		logmessage(ERROR, "ad9956 sweep stop error=%d", -r);
 		return r;
 	}
 	r = ad9956_set_frequency(d, f);
 	if (r) {
 		logmessage(ERROR, "ad9956 set frequency error=%d", -r);
 		return r;
 	}
 	r = ad9956_set_sweep_rate(d, s);
 	if (r) {
 		logmessage(ERROR, "ad9956 set sweep rate error=%d", -r);
 		return r;
 	}
 	r = ad9956_sweep_start(d);
 	if (r) {
 		logmessage(ERROR, "ad9956 sweep start error=%d", -r);
 		return r;
 	}
 	return 0;
 }
 enum {
 	NONE = -1,
 double t1, t2, t3;
 double f_rep_slope, f_beat_slope;
 double f_rep_plus, f_rep_minus;
 double f_beat_plus, f_beat_minus;
 double f0_DDS[4] = { 110000000.0, 0.0, 0.0, 0.0 };
 double df_DDS3 = 0.0;
 int nobs = 0;
 int settling = 0;
 // Beatnote sign determination is done stepping the repetition rate by
 // stepping the comb phase-lock offset frequency f_lock generated by
 // DDS1.  A lock frequency step delta_f_lock determines a change in the
 // repetition rate given by:
 //
 //   abs(delta_f_rep) = Ndiv * delta_f_lock / N1
 //
 // where Ndiv = 8 and N1 ~= 8 x 10^5 obtaining that
 //
 //   abs(delta_f_rep) ~= delta_f_lock / 10^5
 //
 // For the determination of the comb locking beatnote sign we detect
 // the sign of delta_f_rep caused by a positive delta_f_lock. f_rep is
 // measured should be small enough to do not exceed the 200x PLL
 // bandwidth but still be clearly identified.
 //
 // For the optical beatnotes we detect the sign of delta_f_beat caused
 // by a positive delta_f_lock thus we need to take into account the
 // sign of the comb locking beatnote.  The optical beatnote frequency
 // change is given by
 //
 //   abs(delta_f_beat) = abs(delta_f_rep) * Nx
 //
 // where Nx ~= 10^6 obtaining that
 //
 //   abs(delta_f_beat) ~= delta_f_lock * 10
 //
 // this need to do not exceed the beatnote filters bandwidth.  Given
 // those contraints the following f_lock steps are chosen:
 void dedrift_update_enable()
 {
 	logmsg("dedrift: automatic slope update enabled");
 	dedrift.enabled = TRUE;
 	dedrift.t0 = utc;
 	stat_zero(&dedrift.stat);
 	dedrift.stat.previous = NaN;
 }
 	}
 }
 void dedrift_update(double f)
 {
 	if (! dedrift.enabled)
 		return;
 	// update measurement
 	stat_accumulate_resilient(&dedrift.stat, f, dedrift.threshold, &dedrift.badcount);
 	if (dedrift.badcount) {
 		// bad data point detected
 		logmsg("dedrift: bad data point detected");
 		// too many consecutive bad data points detected
 		if (dedrift.safety && (dedrift.badcount > dedrift.badcountmax)) {
 			logmsg("dedrift: maximum number of consecutive bad data points exceeded");
 			dedrift_update_disable();
 		}
 	}
 	// check if the previous check disabled slope update
 	if (! dedrift.enabled)
 		return;
 	// update display
 	SetCtrlVal(MainPanel, PANEL_SLOPE_MEASURED, dedrift.stat.slope);
 	// update applied slope
 	if ((utc - dedrift.t0) > dedrift.interval) {
 		// target frequency
 		if (dedrift.f0 == 0.0)
 			dedrift.f0 = dedrift.stat.mean;
 		// compute correction
 		double dt = utc - dedrift.t0;
 		double corr = dedrift.stat.slope \
 			+ dedrift.proportional * ((dedrift.stat.mean - dedrift.f0) / dt + 0.5 * dedrift.stat.slope);
 		// update
 		dedrift.applied += dedrift.sign * corr * (dedrift.x2 ? 2 : 1);
 		ad9956_set_sweep_rate_w(&ad9956, dedrift.applied);
 		SetCtrlVal(MainPanel, PANEL_SLOPE_APPLIED, dedrift.applied);
 		logmsg("dedrift: update correction=%+3e slope=%+3e", corr, dedrift.applied);
 		// start over. keep track of the last updated data point to
 		// avoid gaps in the detectrion of bad data points based on
 		// threshold on the difference between current data point and
 		// previous one
 		double prev = dedrift.stat.previous;
 int recenter_enabled()
 {
 	if (! recenter.active)
 		return FALSE;
 	for (int i = 0; i < NBEATNOTES; i++)
 		if (recenter.enabled[i])
 			return TRUE;
 	return FALSE;
 void recenter_update()
 {
 	if (! recenter_enabled())
 		return;
 	rollmean_accumulate(&rollmean_ch2, Ch2);
 	rollmean_accumulate(&rollmean_ch3, Ch3);
 	rollmean_accumulate(&rollmean_ch4, Ch4);
 	if ((utc - recenter.t0) > recenter.interval) {
 		if (recenter.enabled[LO]) {
 			// adjust DDS2 frequency to keep Ch4 reading at 275 kHz
 			double freq = ad9912.frequency[1];
 			double adj = 275000.0 - rollmean_ch4.mean;
 			if (fabs(adj) > recenter.threshold[LO]) {
 				ad9912_set_frequency_w(&ad9912, 1, freq);
 				SetCtrlVal(MainPanel, PANEL_DDS2, ad9912.frequency[1]);
 				logmsg("recenter ch4 to 275 kHz: DDS2 adjustment=%+3e", adj);
 			}
 		}
 		if (recenter.enabled[HG]) {
 			// adjust DDS3 frequency to keep Ch2 reading at 10 kHz
 			double freq = ad9912.frequency[2];
 			double adj = 10000 - rollmean_ch2.mean;
 			if (fabs(adj) > recenter.threshold[HG]) {
 				ad9912_set_frequency_w(&ad9912, 2, freq);
 				SetCtrlVal(MainPanel, PANEL_DDS3, ad9912.frequency[2]);
 				logmsg("recenter Hg beatnote (ch2) to 10 kHz: DDS3 adjustment=%+3e", adj);
 			}
 		}
 		if (recenter.enabled[SR]) {
 			// adjust DDS4 frequency to keep Ch3 reading at 10 kHz
 			double freq = ad9912.frequency[3];
 			double adj = 10000 - rollmean_ch3.mean;
 			if (fabs(adj) > recenter.threshold[SR]) {
 				ad9912_set_frequency_w(&ad9912, 3, freq);
 				SetCtrlVal(MainPanel, PANEL_DDS4, ad9912.frequency[3]);
 				logmsg("recenter Sr beatnote (ch3) to 10 kHz: DDS4 adjustment=%+3e", adj);
 			}
 		}
 		recenter.t0 = utc;
 		rollmean_zero(&rollmean_ch2);
 		rollmean_zero(&rollmean_ch3);
 		rollmean_zero(&rollmean_ch4);
 	}
 	DATAFILE("Ex", &Math5, 1, PANEL_SAVE_EXTRA, FALSE),
 	{ NULL, }
 };
 static void write_data(const char *folder, const char *name, const char *id,
 		const char *timestr, double utc, double *v, int nchan)
 {
 	int i, fd, len;
 	char line[1024];
 	char filename[FILENAME_MAX];
 	// construct filename in the form folder\\id-name.txt
 	snprintf(filename, sizeof(filename), "%s\\%s-%s.txt", folder, id, name);
 	fd = open(filename, O_CREAT|O_WRONLY|O_APPEND, S_IRUSR|S_IWUSR|S_IRGRP);
 	if (fd < 0) {
 		logmessage(ERROR, "open data file %s: %s", filename, strerror(errno));
 		return;
 	}
 	// timestamp
 	len = snprintf(line, sizeof(line), "%s\t%.3f", timestr, utc);
 	// data channels
 	for (i = 0; i < nchan; i++)
 		len += snprintf(line + len, sizeof(line) - len, "\t%.16e", v[i]);
 	// newline
 	line[len++] = '\r';
 	line[len++] = '\n';
 	// write to file
 	write(fd, line, len);
 	close(fd);
 }
 static inline void datafile_append(struct datafile *d, char *id, char *timestr)
 static void * muParserNew()
 {
 	void *parser = mupCreate();
 	mupDefineOprtChars(parser, "abcdefghijklmnopqrstuvwxyz�"
 	   "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 	   "+-*^/?<>=#!$%&|~'_");
 	mupDefineVar(parser, "Ch1", &Ch1);
 	mupDefineVar(parser, "Ch2", &Ch2);
 	mupDefineVar(parser, "Ch3", &Ch3);
 	mupDefineVar(parser, "Ch4", &Ch4);
 	mupDefineVar(parser, "DDS1", &(ad9912.frequency[0]));
 	mupDefineVar(parser, "N3", &N3);
 	mupDefineVar(parser, "Sign1", &Sign1);
 	mupDefineVar(parser, "Sign2", &Sign2);
 	mupDefineVar(parser, "Sign3", &Sign3);
 	mupDefineVar(parser, "Ndiv", &Ndiv);
 	mupDefinePostfixOprt(parser, "P", &Peta,  1);
 	mupDefinePostfixOprt(parser, "T", &Tera,  1);
 	mupDefinePostfixOprt(parser, "G", &Giga,  1);
 	mupDefinePostfixOprt(parser, "M", &Mega,  1);
 	mupDefinePostfixOprt(parser, "k", &kilo,  1);
 	mupDefinePostfixOprt(parser, "u", &micro, 1);
 	mupDefinePostfixOprt(parser, "�", &micro, 1);
 	mupDefinePostfixOprt(parser, "n", &nano,  1);
 	mupDefinePostfixOprt(parser, "p", &pico,  1);
 	mupDefinePostfixOprt(parser, "f", &femto, 1);
 	return parser;
 }
 void CVICALLBACK DataAvailableCB (CmtTSQHandle queueHandle, unsigned int event,
 	if ((EstimateNPanel = LoadPanel (MainPanel, "FXAnalyse.uir", ESTIMATEN)) < 0)
 		return -1;
 	// logging
 	logger_init(&onerror);
 	// load configuration file
 	char path[MAX_PATHNAME_LEN];
 	GetIniFilePath(path);
 	IniText configuration = Ini_New(TRUE);
 	Ini_ReadFromFile(configuration, path);
 	rv = Ini_GetInt(configuration, "KK", "nchan", &nchan);
 	if (rv < 1)
 		nchan = 4;
 	// update number of channels to save to disk
 	datafiles[0].nchan = nchan;
 	// data folder
 	rv = Ini_GetStringCopy(configuration, "data", "folder", &datafolder);
 	if (rv > 0) {
 		logmessage(INFO, "writing data files in '%s'", datafolder);
 	} else {
 		logmessage(ERROR, "data folder not configured in %s", path);
 		// do not allow to start the acquisition
 		SetCtrlAttribute(MainPanel, PANEL_STARTBUTTON, ATTR_DIMMED, TRUE);
 	}
 	// ad9956 configuration parameters
 	rv = Ini_GetStringIntoBuffer(configuration, "AD9956", "host", host, sizeof(host));
 	if (! rv)
 		return -1;
 	rv = Ini_GetDouble(configuration, "AD9956", "clock", &clock);
 	if (! rv)
 		return -1;
 	// initialize AD9956 dedrift DDS
 	rv = ad9956_init(&ad9956, host, clock);
 	if (rv)
 		logmessage(ERROR, "ad9956 init erorr=%d", -rv);
 	ad9956_set_w(&ad9956, dedrift.fDDS, dedrift.applied);
 	// AD9912 configuration parameters
 	rv = Ini_GetStringIntoBuffer(configuration, "AD9912", "host", host, sizeof(host));
 	if (! rv)
 		return -1;
 	rv = Ini_GetDouble(configuration, "AD9912", "clock", &clock);
 	if (! rv)
 		return -1;
 	// initialize AD9912 DDS box
 	rv = ad9912_init(&ad9912, host, clock);
 	if (rv)
 		logmessage(ERROR, "ad9912 init erorr=%d", -rv);
 	// try to read back current frequency from DDS
 	for (i = 0; i < 4; i++) {
 		rv = ad9912_get_frequency(&ad9912, i, &frequency);
 		if ((rv) || (frequency == 0.0)) {
 			logmessage(WARNING, "reset DDS%d frequency to default value", i + 1);
 	zmqsocket = zmq_socket(zmqcontext, ZMQ_PUB);
 	rv = zmq_bind(zmqsocket, socket);
 	if (rv)
 		logmessage(ERROR, "cannot bind ZMQ socket '%s': %s", socket, zmq_strerror(zmq_errno()));
 	free(socket);
 	// dispose configuration
 	Ini_Dispose(configuration);
 	// Sr data logger
 	sr_datalogger_init(&datalogger);
 	GetCtrlVal(MainPanel, PANEL_N1, &N1);
 	GetCtrlVal(MainPanel, PANEL_N2, &N2);
 	GetCtrlVal(MainPanel, PANEL_N3, &N3);
 	MathParser1 = muParserNew();
 	GetCtrlVal(MainPanel, PANEL_MATHSTRING1, expr);
 	mupSetExpr(MathParser1, expr);
 	MathParser2 = muParserNew();
 	mupDefineVar(MathParser2, "Math1", &Math1);
 	GetCtrlVal(MainPanel, PANEL_MATHSTRING2, expr);
 	mupSetExpr(MathParser2, expr);
 	MathParser3 = muParserNew();
 	mupDefineVar(MathParser3, "Math1", &Math1);
 	mupDefineVar(MathParser3, "Math2", &Math2);
 	GetCtrlVal(MainPanel, PANEL_MATHSTRING3, expr);
 	mupSetExpr(MathParser3, expr);
 	MathParser4 = muParserNew();
 	mupDefineVar(MathParser4, "Math1", &Math1);
 	mupDefineVar(MathParser4, "Math2", &Math2);
 	mupDefineVar(MathParser4, "Math3", &Math3);
 	GetCtrlVal(MainPanel, PANEL_MATHSTRING4, expr);
 	mupSetExpr(MathParser4, expr);
 	MathParser5 = muParserNew();
 	mupDefineVar(MathParser5, "Math1", &Math1);
 	mupDefineVar(MathParser5, "Math2", &Math2);
 	mupDefineVar(MathParser5, "Math3", &Math3);
 	mupDefineVar(MathParser5, "Math4", &Math4);
 	GetCtrlVal(MainPanel, PANEL_MATHSTRING5, expr);
 	mupSetExpr(MathParser5, expr);
 	// data queue
 	CmtNewTSQ(128, sizeof(struct event), 0, &dataQueue);
 	// register callback to execute when data will be in the data queue
 	CmtInstallTSQCallback(dataQueue, EVENT_TSQ_ITEMS_IN_QUEUE, 1,
 		DataAvailableCB, NULL, CmtGetCurrentThreadID(), NULL);
 	DisplayPanel(MainPanel);
 	RunUserInterface();
 	DiscardPanel(MainPanel);
 	return 0;
 }
 int CVICALLBACK QuitCallback (int panel, int control, int event,
 int CVICALLBACK CB_OnEventMain(int panel, int event,
 		void *callbackData, int eventData1, int eventData2)
 {
 	int control, index;
 	double step;
 #define do_arrow(__DDS, __STEP)										\
 	do {															\
 		GetCtrlIndex(panel, __STEP, &index);						\
 		if ((eventData1 == VAL_RIGHT_ARROW_VKEY) && (index < 14))	\
 			SetCtrlIndex(panel, __STEP, index + 1);					\
 		if ((eventData1 == VAL_LEFT_ARROW_VKEY) && (index > 0))		\
 			SetCtrlIndex(panel, __STEP, index - 1);					\
 		GetCtrlVal(panel, __STEP, &step);							\
 		SetCtrlAttribute(panel, __DDS, ATTR_INCR_VALUE, step);  	\
 	} while (0)
 	switch (event) {
 		case EVENT_KEYPRESS:
 			/* key code */
 			switch (eventData1) {
 				case VAL_RIGHT_ARROW_VKEY:
 				case VAL_LEFT_ARROW_VKEY:
 					control = GetActiveCtrl(panel);
 					switch (control) {
 						case PANEL_DDS1:
 						case PANEL_DDS1STEP:
 							do_arrow(PANEL_DDS1, PANEL_DDS1STEP);
 				break;
 			logmsg("start");
 			SetCtrlAttribute(panel, PANEL_STARTBUTTON, ATTR_DIMMED, TRUE);
 			acquiring = 1;
 			// start data provider thread
 			CmtScheduleThreadPoolFunctionAdv(
 				DEFAULT_THREAD_POOL_HANDLE, DataProvider, NULL,
 				THREAD_PRIORITY_HIGHEST, NULL, 0, NULL, 0, &dataProviderThread);
 {
 	switch (event) {
 		case EVENT_COMMIT:
 			if (! acquiring)
 				break;
 			logmsg("stop");
 			acquiring = 0;
 			// wait for data provider thread to terminate
 			CmtWaitForThreadPoolFunctionCompletion(
 				OPT_TP_PROCESS_EVENTS_WHILE_WAITING);
 			CmtReleaseThreadPoolFunctionID(
 				DEFAULT_THREAD_POOL_HANDLE, dataProviderThread);
 			SetCtrlAttribute(panel, PANEL_STARTBUTTON, ATTR_DIMMED, FALSE);
 			break;
 	}
 	return 0;
 }
 void CVICALLBACK DataAvailableCB (CmtTSQHandle queueHandle, unsigned int event,
 		int value, void *callbackData)
 {
 	int read;
 	switch (event) {
 		case EVENT_TSQ_ITEMS_IN_QUEUE:
 			// read data from the data queue
 			while (value > 0) {
 				read = CmtReadTSQData(queueHandle, &ev, 1, TSQ_INFINITE_TIMEOUT, 0);
 				if (read != 1)
 					logmsg("Error!");
 				value = value - read;
 				// unpack event
 				utc = ev.time.tv_sec + ev.time.tv_usec * 1e-6;
 				// update display
 				SetCtrlVal(MainPanel, PANEL_UTC, utc);
 				SetCtrlVal(MainPanel, PANEL_CH1, Ch1);
 				SetCtrlVal(MainPanel, PANEL_CH2, Ch2);
 				SetCtrlVal(MainPanel, PANEL_CH3, Ch3);
 				SetCtrlVal(MainPanel, PANEL_CH4, Ch4);
 				// compute
 				Math1 = mupEval(MathParser1);
 				Math2 = mupEval(MathParser2);
 				Math3 = mupEval(MathParser3);
 				Math4 = mupEval(MathParser4);
 				Math5 = mupEval(MathParser5);
 				// update display.  numeric controllers do not format values
 				// with a thousands separator: use string controllers and a
 				// custom formatting function
 				char buffer[256];
 				SetCtrlVal(MainPanel, PANEL_MATH1, thousands(buffer, sizeof(buffer), "%.6f", Math1));
 				SetCtrlVal(MainPanel, PANEL_MATH2, thousands(buffer, sizeof(buffer), "%.3f", Math2));
 				SetCtrlVal(MainPanel, PANEL_MATH3, thousands(buffer, sizeof(buffer), "%.3f", Math3));
 					plot_update(plot);
 				// update allan deviation plots
 				for (struct adev *adev = adevs; adev->data; adev++)
 					adev_update(adev);
 				// N measurement
 				switch (n_measurement[LO]) {
 					case N_MEASUREMENT_NONE:
 						// not measuring
 						break;
 					case N_MEASUREMENT_INIT:
 						// initialization step
 						// set DDS1 to nominal frequency
 						ad9912_set_frequency_w(&ad9912, 0, f0_DDS[0]);
 						SetCtrlVal(MainPanel, PANEL_DDS1, ad9912.frequency[0]);
 						// record current DDS frequencies
 						f0_DDS[1] = ad9912.frequency[1];
 						t1 = utc;
 						t2 = t3 = 0.0;
 						nobs = 0;
 						stat_zero(&stat_math1);
 						f_rep_plus = f_rep_minus = 0.0;
 						// next step
 						n_measurement[LO] += 1;
 						break;
 					case N_MEASUREMENT_SLOPE:
 						// slope measurement
 						stat_accumulate(&stat_math1, Math1);
 						if ((utc - t1) > slope_time[LO]) {
 							f_rep_slope = stat_math1.slope;
 							// frep positive step
 							ad9912_ramp_frequency_w(&ad9912, 0, f0_DDS[0] + delta_f_lock[LO], FREP_STEP_SIZE);
 							SetCtrlVal(MainPanel, PANEL_DDS1, ad9912.frequency[0]);
 							// allow counter to settle
 							settling = 3;
 							// next step
 							n_measurement[LO] += 1;
 						}
 						break;
 					case N_MEASUREMENT_ADJUST_FREQ_PLUS:
 					case N_MEASUREMENT_ADJUST_FREQ_MINUS:
 						// adjust DDS frequency to keep beatnote within the bandpass filter
 						if (settling-- > 0)
 							break;
 						double fDDS2 = ad9912.frequency[1];
 						ad9912_set_frequency_w(&ad9912, 1, fDDS2 + 275000 - Ch4);
 						SetCtrlVal(MainPanel, PANEL_DDS2, ad9912.frequency[1]);
 						// allow counter to settle
 						settling = 3;
 						// next step
 						n_measurement[LO] += 1;
 						break;
 					case N_MEASUREMENT_FREP_PLUS:
 						// frep positive step
 						if (settling-- > 0)
 							break;
 						if (t2 == 0.0)
 							t2 = utc;
 						f_rep_plus += Math1 - f_rep_slope * (utc - t2);
 						nobs += 1;
 						if ((utc - t2) > integration_time[LO]) {
 							f_rep_plus = f_rep_plus / nobs;
 							nobs = 0;
 							// frep negative step
 							ad9912_ramp_frequency_w(&ad9912, 0, f0_DDS[0] - delta_f_lock[LO], FREP_STEP_SIZE);
 							SetCtrlVal(MainPanel, PANEL_DDS1, ad9912.frequency[0]);
 							// allow counter to settle
 							settling = 3;
 							// next step
 							n_measurement[LO] += 1;
 						}
 						break;
 					case N_MEASUREMENT_FREP_MINUS:
 						// frep negative step
 						if (settling-- > 0)
 							break;
 						if (t3 == 0.0)
 							t3 = utc;
 						f_rep_minus += Math1 - f_rep_slope * (utc - t2);
 						nobs += 1;
 						if ((utc - t3) > integration_time[LO]) {
 							f_rep_minus = f_rep_minus / nobs;
 							nobs = 0;
 							// compute N1
 							double delta_f_rep = f_rep_minus - f_rep_plus;
 							double measured = Sign1 * 2 * Ndiv * delta_f_lock[LO] / delta_f_rep;
 							SetCtrlVal(CalcNPanel, CALCN_N, measured);
 							// back to nominal frep
 							ad9912_ramp_frequency_w(&ad9912, 0, f0_DDS[0], FREP_STEP_SIZE);
 							ad9912_set_frequency_w(&ad9912, 1, f0_DDS[1]);
 							SetCtrlVal(MainPanel, PANEL_DDS1, ad9912.frequency[0]);
 							SetCtrlVal(MainPanel, PANEL_DDS2, ad9912.frequency[1]);
 							// done
 							n_measurement[LO] = N_MEASUREMENT_NONE;
 						}
 						break;
 				}
 				switch (n_measurement[HG]) {
 					case N_MEASUREMENT_NONE:
 						// not measuring
 						break;
 					case N_MEASUREMENT_INIT:
 						// initialization step
 						// set DDS1 to nominal frequency
 						ad9912_set_frequency_w(&ad9912, 0, f0_DDS[0]);
 						SetCtrlVal(MainPanel, PANEL_DDS1, ad9912.frequency[0]);
 						// record current DDS frequencies
 						f0_DDS[1] = ad9912.frequency[1];
 						f0_DDS[2] = ad9912.frequency[2];
 						t1 = utc;
 						t2 = t3 = 0.0;
 						nobs = 0;
 						stat_zero(&stat_math1);
 						stat_zero(&stat_ch2);
 						f_rep_plus = f_rep_minus = 0.0;
 						f_beat_plus = f_beat_minus = 0.0;
 						// next step
 						n_measurement[HG] += 1;
 						break;
 					case N_MEASUREMENT_SLOPE:
 						// slope measurement
 						stat_accumulate(&stat_math1, Math1);
 						stat_accumulate(&stat_ch2, Ch2);
 						if ((utc - t1) > slope_time[HG]) {
 							f_rep_slope = stat_math1.slope;
 							f_beat_slope = stat_ch2.slope;
 							// frep positive step
 							double fDDS1 = f0_DDS[0] + delta_f_lock[HG];
 							ad9912_ramp_frequency_w(&ad9912, 0, fDDS1, FREP_STEP_SIZE);
 							SetCtrlVal(MainPanel, PANEL_DDS1, ad9912.frequency[0]);
 							// adjust DDS3 to keep beatnote within the bandpass filter. prediction
 							double fDDS3 = f0_DDS[2] + Sign1 * Sign2 * N2/N1 * Ndiv * delta_f_lock[HG];
 							df_DDS3 = fDDS3 - ad9912.frequency[2];
 							ad9912_set_frequency_w(&ad9912, 2, fDDS3);
 							SetCtrlVal(MainPanel, PANEL_DDS3, ad9912.frequency[2]);
 							// allow counter to settle
 							settling = 3;
 							// next step
 							n_measurement[HG] += 1;
 						}
 						break;
 					case N_MEASUREMENT_ADJUST_FREQ_PLUS:
 					case N_MEASUREMENT_ADJUST_FREQ_MINUS:
 						// adjust DDS frequency to keep beatnote within the bandpass filter
 						if (settling-- > 0)
 							break;
 						double fDDS2 = ad9912.frequency[1] + 275000 - Ch4;
 						ad9912_set_frequency_w(&ad9912, 1, fDDS2);
 						SetCtrlVal(MainPanel, PANEL_DDS2, ad9912.frequency[1]);
 						double fDDS3 = ad9912.frequency[2] + 10000 - Ch2;
 						df_DDS3 = df_DDS3 + 10000 - Ch2;
 						ad9912_set_frequency_w(&ad9912, 2, fDDS3);
 						SetCtrlVal(MainPanel, PANEL_DDS3, ad9912.frequency[2]);
 						settling = 3;
 						// next step
 						n_measurement[HG] += 1;
 						break;
 					case N_MEASUREMENT_FREP_PLUS:
 						// frep positive step
 						if (settling-- > 0)
 							break;
 						if (t2 == 0.0)
 							t2 = utc;
 						f_rep_plus += Math1 + 250000000 - f_rep_slope * (utc - t2);
 						f_beat_plus += Ch2 - f_beat_slope * (utc - t2);
 						nobs += 1;
 						if ((utc - t2) > integration_time[HG]) {
 							f_rep_plus = f_rep_plus / nobs;
 							f_beat_plus = f_beat_plus / nobs;
 							nobs = 0;
 							// negative frequency step
 							double fDDS1 = f0_DDS[0] - delta_f_lock[HG];
 							ad9912_ramp_frequency_w(&ad9912, 0, fDDS1, FREP_STEP_SIZE);
 							SetCtrlVal(MainPanel, PANEL_DDS1, ad9912.frequency[0]);
 							// adjust DDS3 to keep beatnote within the bandpass filter. prediction
 							double fDDS3 = f0_DDS[2] - Sign1 * Sign2 * N2/N1 * Ndiv * delta_f_lock[HG];
 							df_DDS3 = fDDS3 - ad9912.frequency[2];
 							ad9912_set_frequency_w(&ad9912, 2, fDDS3);
 							SetCtrlVal(MainPanel, PANEL_DDS3, ad9912.frequency[2]);
 							// allow counter to settle
 							settling = 3;
 							// next step
 							n_measurement[HG] += 1;
 						}
 						break;
 					case N_MEASUREMENT_FREP_MINUS:
 						// frep negative step
 						if (settling-- > 0)
 							break;
 						if (t3 == 0.0)
 							t3 = utc;
 						f_rep_minus += Math1 + 250000000 - f_rep_slope * (utc - t2);
 						f_beat_minus += Ch2 + f_beat_slope * (utc - t2);
 							// compute N2
 							double delta_f_rep_m = f_rep_minus - f_rep_plus;
 							double delta_f_rep = Sign1 * Ndiv * 2.0 * delta_f_lock[HG] / N1;
 							double delta = delta_f_rep_m - delta_f_rep;
 							logmsg("delta frep: measured=%e expected=%e difference=%e rel=%e",
 								delta_f_rep_m, delta_f_rep, delta, delta / delta_f_rep);
 							double measured = -Sign2 * (df_DDS3 + f_beat_minus - f_beat_plus) / delta_f_rep;
 							SetCtrlVal(CalcNPanel, CALCN_N, measured);
 							// back to nominal frequency
 							ad9912_ramp_frequency_w(&ad9912, 0, f0_DDS[0], FREP_STEP_SIZE);
 							ad9912_set_frequency_w(&ad9912, 1, f0_DDS[1]);
 							ad9912_set_frequency_w(&ad9912, 2, f0_DDS[2]);
 							SetCtrlVal(MainPanel, PANEL_DDS1, ad9912.frequency[0]);
 							SetCtrlVal(MainPanel, PANEL_DDS2, ad9912.frequency[1]);
 							SetCtrlVal(MainPanel, PANEL_DDS3, ad9912.frequency[2]);
 							// done
 							n_measurement[HG] = N_MEASUREMENT_NONE;
 						}
 						break;
 				}
 				switch (n_measurement[SR]) {
 					case N_MEASUREMENT_NONE:
 						// not measuring N3
 						break;
 					case N_MEASUREMENT_INIT:
 						// init
 						// set DDS1 to nominal frequency
 						ad9912_set_frequency_w(&ad9912, 0, f0_DDS[0]);
 						SetCtrlVal(MainPanel, PANEL_DDS1, ad9912.frequency[0]);
 						// record current DDS frequencies
 						f0_DDS[1] = ad9912.frequency[1];
 						f0_DDS[3] = ad9912.frequency[3];
 						t1 = utc;
 						t2 = t3 = 0.0;
 						nobs = 0;
 						stat_zero(&stat_math1);
 						stat_zero(&stat_ch3);
 						f_rep_plus = f_rep_minus = 0.0;
 						f_beat_plus = f_beat_minus = 0.0;
 						// next step
 						n_measurement[SR] += 1;
 						break;
 					case N_MEASUREMENT_SLOPE:
 						// slope measurement
 						if (settling-- > 0)
 							break;
 						stat_accumulate(&stat_math1, Math1);
 						stat_accumulate(&stat_ch3, Ch3);
 						if (utc - t1 > slope_time[SR]) {
 							// slope measurement
 							f_rep_slope = stat_math1.slope;
 							f_beat_slope = stat_ch3.slope;
 							logmsg("f_rep_slope=%e Hz/s", f_rep_slope);
 							logmsg("f_beat_slope=%e Hz/s", f_rep_slope);
 							// frep positive step
 							ad9912_ramp_frequency_w(&ad9912, 0, f0_DDS[0] + delta_f_lock[SR], FREP_STEP_SIZE);
 							SetCtrlVal(MainPanel, PANEL_DDS1, ad9912.frequency[0]);
 							// adjust DDS3 to keep beatnote within the bandpass filter
 							double fDDS4 = f0_DDS[3] + Sign1 * Sign3 * N3/N1 * Ndiv * delta_f_lock[SR];
 							ad9912_set_frequency_w(&ad9912, 3, fDDS4);
 							SetCtrlVal(MainPanel, PANEL_DDS4, ad9912.frequency[3]);
 							// allow counter to settle
 							settling = 3;
 							// next step
 							n_measurement[SR] += 1;
 						}
 						break;
 					case N_MEASUREMENT_ADJUST_FREQ_MINUS:
 						// adjust DDS frequency to keep beatnote within the bandpass filter
 						if (settling-- > 0)
 							break;
 						// adjust DDS frequency to keep 55 MHz tracker oscillator locked
 						double fDDS2 = ad9912.frequency[1] + 275000 - Ch4;
 						ad9912_set_frequency_w(&ad9912, 1, fDDS2);
 						SetCtrlVal(MainPanel, PANEL_DDS2, ad9912.frequency[1]);
 						// allow counter to settle
 						settling = 3;
 						// next step
 						n_measurement[SR] += 1;
 						break;
 					case N_MEASUREMENT_FREP_PLUS:
 						// frep positive step
 						if (settling-- > 0)
 							break;
 						if (t2 == 0.0)
 							t2 = utc;
 						f_rep_plus += Math1 + 250000000 - f_rep_slope * (utc - t2);
 						f_beat_plus += Ch3 - f_beat_slope * (utc - t2);
 						nobs += 1;
 						if (utc - t2 > integration_time[SR]) {
 							f_rep_plus = f_rep_plus / nobs;
 							f_beat_plus = f_beat_plus / nobs;
 							nobs = 0;
 							// frep negative step
 							ad9912_ramp_frequency_w(&ad9912, 0, f0_DDS[0] - delta_f_lock[SR], FREP_STEP_SIZE);
 							SetCtrlVal(MainPanel, PANEL_DDS1, ad9912.frequency[0]);
 							// adjust DDS3 to keep beatnote within the bandpass filter
 							double fDDS4 = f0_DDS[3] - Sign1 * Sign3 * N3/N1 * Ndiv * delta_f_lock[SR];
 							ad9912_set_frequency_w(&ad9912, 3, fDDS4);
 							SetCtrlVal(MainPanel, PANEL_DDS4, ad9912.frequency[3]);
 							// allow counter to settle
 							settling = 3;
 							// next step
 							n_measurement[SR] += 1;
 						}
 						break;
 					case N_MEASUREMENT_FREP_MINUS:
 						// frep negative step
 						if (settling-- > 0)
 							break;
 						if (t3 == 0.0)
 							t3 = utc;
 						f_rep_minus += Math1 + 250000000 - f_rep_slope * (utc - t2);
 						f_beat_minus += Ch3 - f_beat_slope * (utc - t2);
 						nobs += 1;
 						if (utc - t3 > integration_time[SR]) {
 							f_rep_minus = f_rep_minus / nobs;
 							f_beat_minus = f_beat_minus / nobs;
 							nobs = 0;
 							// check delta frep
 							double delta_f_rep_m = f_rep_minus - f_rep_plus;
 							double delta_f_rep = Sign1 * Ndiv * 2.0 * delta_f_lock[SR] / N1;
 							double delta = delta_f_rep_m - delta_f_rep;
 							logmsg("delta frep: measured=%e expected=%e difference=%e rel=%e",
 								delta_f_rep_m, delta_f_rep, delta, delta / delta_f_rep);
 							// compute N3
 							double delta_f_beat = f_beat_minus - f_beat_plus + 2.0 * Sign1 * Sign3 * N3/N1 * Ndiv * delta_f_lock[SR];
 							double delta_f_beat_expected = delta_f_rep * N3;
 							logmsg("delta fbeat: measured=%e expected=%e difference=%e",
 								delta_f_beat, delta_f_beat_expected, delta_f_beat - delta_f_beat_expected);
 							double measured = delta_f_beat / delta_f_rep;
 							SetCtrlVal(CalcNPanel, CALCN_N, measured);
 							logmsg("measured N3=%.3f", measured);
 							// back to nominal frep
 							ad9912_ramp_frequency_w(&ad9912, 0, f0_DDS[0], FREP_STEP_SIZE);
 							ad9912_set_frequency_w(&ad9912, 1, f0_DDS[1]);
 							ad9912_set_frequency_w(&ad9912, 3, f0_DDS[3]);
 							SetCtrlVal(MainPanel, PANEL_DDS1, ad9912.frequency[0]);
 							SetCtrlVal(MainPanel, PANEL_DDS2, ad9912.frequency[1]);
 							SetCtrlVal(MainPanel, PANEL_DDS4, ad9912.frequency[3]);
 							// done
 							n_measurement[SR] = N_MEASUREMENT_NONE;
 						}
 						break;
 				}
 				// beatnote sign determination
 				if ((beatsign.measure != NONE) &&
 				    (utc > beatsign.t0 + 2.0)) {
 					int f_beat_sign, f_rep_sign = 0;
 					switch (beatsign.measure) {
 					case LO:
 						f_rep_sign = (Math1 > beatsign.f_rep_zero) ? -1 : 1;
 						Sign1 = f_rep_sign;
 						SetCtrlVal(MainPanel, PANEL_SIGN1, Sign1);
 					ad9912_set_frequency_w(&ad9912, 0, beatsign.f0_DDS);
 					SetCtrlVal(MainPanel, PANEL_DDS1, ad9912.frequency[0]);
 					// measurement done
 					beatsign.measure = NONE;
 					// in the case of the optical beatnotes sign measurement
 					// we induce fairly small steps in f_rep therefore it is
 					// good to check that we get the sign of the comb locking
 					// beatnote right in those cases
 					if (f_rep_sign != Sign1)
 						logmessage(ERROR, "merasured f_rep_sign does not agree with previous determination!");
 				}
 				// select dedrift reference
 				double f = 0.0;
 				switch (dedrift.reference) {
 					case MICROWAVE:
 						f = Math2;
 						break;
 				}
 				// dedrift
 				dedrift_update(f);
 				// recenter
 				recenter_update();
 				struct tm *time = gmtime(&ev.time.tv_sec);
 				// round to milliseconds
 				char timestr[24];
 				int len = strftime(timestr, sizeof(timestr), "%d/%m/%Y %H:%M:%S", time);
 				snprintf(timestr + len, sizeof(timestr) - len, ".%03d", msec);
 				// display local time
 				SetCtrlVal(MainPanel, PANEL_TIME, timestr);
 				// run id derived from current date in the form YYMMDD
 				char id[7];
 				strftime(id, sizeof(id), "%y%m%d", time);
 				// write datafiles
 				for (struct datafile *d = datafiles; d->data; d++)
 					datafile_append(d, id, timestr);
 				// send Sr frequency (Math4) to Sr data logger
 				sr_datalogger_send(&datalogger, utc, Math4);
 				// publish data through ZMQ
 				int r = zmq_xpub(zmqsocket, "RAW", &ev, sizeof(ev));
 				if (r)
 					logmessage(ERROR, "cannot send data through ZMQ socket: %s", zmq_strerror(r));
 			}
 			break;
 	}
 }
 int CVICALLBACK CB_OnFreqPlot (int panel, int control, int event,
 			break;
 	}
 	return 0;
 }
 int  CVICALLBACK CB_ChangeDDSOut (int panel, int control, int event,
 		 void *callbackData, int eventData1, int eventData2)
 {
 	switch (event) {
 		case EVENT_COMMIT:
 			double frequency;
 			break;
 	}
 	return 0;
 }
 int  CVICALLBACK CB_ChangeDDSStep (int panel, int control, int event,
 		 void *callbackData, int eventData1, int eventData2)
 {
 	switch (event)
 	{
 		case EVENT_COMMIT:
 int CVICALLBACK CB_ChangeMath (int panel, int control, int event,
 		void *callbackData, int eventData1, int eventData2)
 {
 	int len;
 	char *string;
 	switch (event)
 	{
 		case EVENT_COMMIT:
 			GetCtrlAttribute(panel, control, ATTR_STRING_TEXT_LENGTH, &len);
 			string = (char *)malloc(sizeof(char) * (len + 1));
 					break;
 				case SR:
 					N3 = round(measured);
 					SetCtrlVal(MainPanel, PANEL_N3, N3);
 					break;
 			}
 			break;
 	}
 	return 0;
 }
 int CVICALLBACK CB_OnNCalculus (int panel, int control, int event,
 		void *callbackData, int eventData1, int eventData2)
 {
 	int visible;
 	switch (event) {
 		case EVENT_COMMIT:
 			switch (control) {
 				case PANEL_N1CALCULUS:
 					GetPanelAttribute(CalcNPanel, ATTR_VISIBLE, &visible);
 						SetCtrlVal(CalcNPanel, CALCN_INTEGRATIONTIME, integration_time[HG]);
 						SetCtrlVal(CalcNPanel, CALCN_SLOPETIME, slope_time[HG]);
 						SetCtrlVal(CalcNPanel, CALCN_DELTAFREQ, delta_f_lock[HG] / 1000.0);
 						SetCtrlVal(CalcNPanel, CALCN_N, 0.0);
 						DisplayPanel(CalcNPanel);
 					}
 					break;
 				case PANEL_N3CALCULUS:
 					GetPanelAttribute(CalcNPanel, ATTR_VISIBLE, &visible);
 					if (! visible) {
 						SetPanelAttribute(CalcNPanel, ATTR_CALLBACK_DATA, INT_TO_PTR(SR));
 int CVICALLBACK CB_OnStartNCalculus (int panel, int control, int event,
 		void *callbackData, int eventData1, int eventData2)
 {
 	void *v;
 	int measuring;
 	switch (event) {
 		case EVENT_COMMIT:
 			GetPanelAttribute(panel, ATTR_CALLBACK_DATA, &v);
 			measuring = PTR_TO_INT(v);
 			switch (measuring) {
 int CVICALLBACK CB_OnNStop (int panel, int control, int event,
 		void *callbackData, int eventData1, int eventData2)
 {
 	void *v;
 	int measuring;
 	switch (event) {
 		case EVENT_COMMIT:
 			HidePanel(CalcNPanel);
 			GetPanelAttribute(panel, ATTR_CALLBACK_DATA, &v);
 			measuring = PTR_TO_INT(v);
 					ad9912_ramp_frequency_w(&ad9912, 0, f0_DDS[0], FREP_STEP_SIZE);
 					ad9912_set_frequency_w(&ad9912, 1, f0_DDS[1]);
 					ad9912_set_frequency_w(&ad9912, 3, f0_DDS[3]);
 					break;
 			}
 			// update DDS frequencies display
 			SetCtrlVal(MainPanel, PANEL_DDS1, ad9912.frequency[0]);
 			SetCtrlVal(MainPanel, PANEL_DDS2, ad9912.frequency[1]);
 			SetCtrlVal(MainPanel, PANEL_DDS3, ad9912.frequency[2]);
 			SetCtrlVal(MainPanel, PANEL_DDS4, ad9912.frequency[3]);
 			break;
 	}
 	return 0;
 }
 int  CVICALLBACK CB_OnFindSign (int panel, int control, int event,
 		void *callbackData, int eventData1, int eventData2)
 {
 	double step = 0.0;
 	switch (event)
 	{
 			break;
 	}
 	return 0;
 }
 int  CVICALLBACK CB_AdjustDDSFreq (int panel, int control, int event,
 		 void *callbackData, int eventData1, int eventData2)
 {
 	double frequency;
 	switch (event)
 	{
 			break;
 	}
 	return 0;
 }
 int  CVICALLBACK CB_OnChangeNdiv (int panel, int control, int event,
 		 void *callbackData, int eventData1, int eventData2)
 {
 	switch (event)
 	{
 		case EVENT_COMMIT:
 			break;
 	}
 	return 0;
 }
 int  CVICALLBACK CB_MeasureSlope (int panel, int control, int event,
 		 void *callbackData, int eventData1, int eventData2)
 {
 	int enable;
 	switch (event)
 	{
 		case EVENT_COMMIT:
 			GetCtrlVal(panel, control, &enable);
 			enable ? dedrift_update_enable() : dedrift_update_disable();
 			break;
 	}
 	return 0;
 }
 int  CVICALLBACK CB_OnResetSlope (int panel, int control, int event,
 		void *callbackData, int eventData1, int eventData2)
 {
 	switch (event)
 	{
 		case EVENT_COMMIT:
 			dedrift.applied = 0.0;
 			SetCtrlVal(panel, PANEL_SLOPE_APPLIED, dedrift.applied);
 			ad9956_set_w(&ad9956, dedrift.fDDS, dedrift.applied);
 			logmsg("dedrift: reset");
 			break;
 	}
 	return 0;
 }
 int  CVICALLBACK CB_ChangeSlopeTime (int panel, int control, int event,
 		void *callbackData, int eventData1, int eventData2)
 {
 	switch (event)
 	{
 		case EVENT_COMMIT:
 			GetCtrlVal(MainPanel, PANEL_SLOPETIME, &dedrift.interval);
 			break;
 	}
 	return 0;
 }
 int  CVICALLBACK CB_OnDedriftSettingsChange (int panel, int control, int event,
 		 void *callbackData, int eventData1, int eventData2)
 {
 	switch (event)
 	{
 		case EVENT_COMMIT:
 			break;
 	}
 	return 0;
 }
 int  CVICALLBACK CB_RecenterEnable (int panel, int control, int event,
 		 void *callbackData, int eventData1, int eventData2)
 {
 	switch (event)
 	{
 		case EVENT_COMMIT:
 			break;
 	}
 	return 0;
 }
 int  CVICALLBACK CB_OnStopSlopeCancellingOnUnlocked (int panel, int control, int event,
 		 void *callbackData, int eventData1, int eventData2)
 {
 	switch (event)
 	{
 		case EVENT_COMMIT:
 		void *callbackData, int eventData1, int eventData2)
 {
 	switch (event)
 	{
 		case EVENT_COMMIT:
 			// stop slope measurement and reset slope
 			dedrift.enabled = FALSE;
 			SetCtrlVal(panel, PANEL_MEASURE_SLOPE, 0);
 			dedrift.applied = 0.0;
 			SetCtrlVal(panel, PANEL_SLOPE_APPLIED, dedrift.applied);
 			// reset DDS
 	return 0;
 }
 //
 // N estimate
 //
 static void estimateN (void)
 {
 	double nu, fbeat, frep, N;
 	int sign;
 	GetCtrlVal(EstimateNPanel, ESTIMATEN_FREQUENCY, &nu);
 	GetCtrlVal(EstimateNPanel, ESTIMATEN_FREP, &frep);
 	GetCtrlVal(EstimateNPanel, ESTIMATEN_FBEAT, &fbeat);
 	GetCtrlVal(EstimateNPanel, ESTIMATEN_SIGN, &sign);
 	N = (nu * 1.0e12 - sign * fbeat) / frep;
 	SetCtrlVal(EstimateNPanel, ESTIMATEN_N, N);
 }
 int CVICALLBACK cb_onEstimateN (int panel, int control, int event,
 		void *callbackData, int eventData1, int eventData2)
 {
 	int visible;
 	switch (event)
 	{
 		case EVENT_COMMIT:
 			// reset N estimate
 			SetCtrlVal(EstimateNPanel, ESTIMATEN_N, 0.0);
 					SetCtrlVal(EstimateNPanel, ESTIMATEN_FDDS, ad9912.frequency[2]);
 					// f_counter
 					SetCtrlVal(EstimateNPanel, ESTIMATEN_FDDS, Ch2);
 					// f_beat
 					SetCtrlVal(EstimateNPanel, ESTIMATEN_FBEAT, ad9912.frequency[2] - Ch2);
 					SetPanelAttribute(EstimateNPanel, ATTR_TITLE, "Estimate N_Hg");
 					SetPanelAttribute(EstimateNPanel, ATTR_CALLBACK_DATA, INT_TO_PTR(HG));
 					break;
 				case PANEL_ESTIMATE_N3:
 					// expected frequency
 					SetPanelAttribute(EstimateNPanel, ATTR_TITLE, "Estimate N_Sr");
 					SetPanelAttribute(EstimateNPanel, ATTR_CALLBACK_DATA, INT_TO_PTR(SR));
 					break;
 			}
 			// display dialog
 			GetPanelAttribute(EstimateNPanel, ATTR_VISIBLE , &visible);
 			if (! visible)
 				DisplayPanel(EstimateNPanel);
 			// compute
 			estimateN();
 			break;
 	}
 	return 0;
 int CVICALLBACK cb_onEstimateNWaveleght (int panel, int control, int event,
 		void *callbackData, int eventData1, int eventData2)
 {
 	double wavelenght, frequency;
 	switch (event)
 	{
 		case EVENT_COMMIT:
 			GetCtrlVal(panel, control, &wavelenght);
 			frequency = SPEED_OF_LIGHT / (wavelenght * 1.0e-9) / 1.0e12;
 int CVICALLBACK cb_onEstimateNFrequency (int panel, int control, int event,
 		void *callbackData, int eventData1, int eventData2)
 {
 	double wavelenght, frequency;
 	switch (event)
 	{
 		case EVENT_COMMIT:
 			GetCtrlVal(panel, control, &frequency);
 			wavelenght = SPEED_OF_LIGHT / (frequency * 1.0e12) / 1.0e-9;
 int CVICALLBACK cb_onEstimateNClose (int panel, int control, int event,
 		void *callbackData, int eventData1, int eventData2)
 {
 	int visible;
 	switch (event)
 	{
 		case EVENT_COMMIT:
 			GetPanelAttribute(panel, ATTR_VISIBLE, &visible);
 			if (visible)
 		void *callbackData, int eventData1, int eventData2)
 {
 	void *v;
 	double n;
 	int estimate = 0;
 	switch (event)
 	{
 		case EVENT_COMMIT:
 			GetPanelAttribute(panel, ATTR_CALLBACK_DATA, &v);
 			estimate = PTR_TO_INT(v);
 			HidePanel(panel);
 			break;
 	}
 	return 0;
 }

Mercurial > hg > fxanalyse

comparison FXAnalyse.c @ 269:3f395eab72eb