void
adjust_sky_frequency (FL_OBJECT *ob, long data)
{
char *p;
char tbuf[128];
p = (char *)fl_get_input (ob);
strcpy (tbuf, p);
if ((p = strchr (tbuf, '\n')) != NULL)
{
*p = '\0';
}
if (strcmp (tbuf, "lock") == 0 ||
strcmp (tbuf, "locked") == 0 ||
strcmp (tbuf, "tuner") == 0 ||
strncmp (tbuf, "----", 4) == 0)
{
char d[128];
sky_locked = 1;
sky_freq = frequency;
sprintf (d, "%f", sky_freq);
fl_set_input (ob, d);
fl_set_button (fd_receiver_main->sky_lock_button, 1);
}
else
{
if (check_float (tbuf) < 0)
{
fl_set_input (ob, "Format Error");
}
else
{
sky_freq = atof(tbuf);
sky_locked = 0;
}
write_rcvr_params ("skyfreq", sky_freq);
}
}
void
set_sky_locked (FL_OBJECT *ob, long data)
{
sky_locked = fl_get_button (ob);
if (sky_locked != 0)
{
fl_deactivate_object (fd_receiver_main->sky_freq_input);
fl_set_input (fd_receiver_main->sky_freq_input, "--------");
write_rcvr_params ("skyfreq", frequency);
}
else
{
fl_activate_object (fd_receiver_main->sky_freq_input);
}
}
static void g3d_create_node_frame(void){
char buffer[10];
g3d_create_frame(&NODE_FRAME,FL_NO_FRAME,120,-1,"",(void**)&PATH_DEFORM_FORM,1);
//add Node
g3d_create_button(&ADD_NODE_BUTTON,FL_NORMAL_BUTTON,55,20,"Add Node",(void**)&NODE_FRAME,0);
fl_set_call_back(ADD_NODE_BUTTON,CB_add_node_button,0);
//Last Node
g3d_create_button(&LAST_NODE_BUTTON,FL_NORMAL_BUTTON,55,20,"Last Node",(void**)&NODE_FRAME,0);
fl_set_call_back(LAST_NODE_BUTTON,CB_last_node_button,0);
//Replot
g3d_create_button(&REPLOT_BUTTON,FL_NORMAL_BUTTON,55,20,"Replot",(void**)&NODE_FRAME,0);
fl_set_call_back(REPLOT_BUTTON,CB_replot_button,0);
//Clear
g3d_create_button(&CLEAR_BUTTON,FL_NORMAL_BUTTON,55,20,"Clear",(void**)&NODE_FRAME,0);
fl_set_call_back(CLEAR_BUTTON,CB_clear_button,0);
//Node counter
g3d_create_counter(&NODE_COUNTER,FL_NORMAL_COUNTER,100,20,"Node",(void**)&NODE_FRAME,0);
fl_set_counter_value(NODE_COUNTER, 0);
if(XYZ_GRAPH != NULL) {
fl_set_counter_bounds(NODE_COUNTER, 0, (double)( XYZ_GRAPH->nnode -1));
} else {
fl_set_counter_bounds(NODE_COUNTER, 0, 0);
}
fl_set_counter_step(NODE_COUNTER, 1, 10);
fl_set_counter_precision(NODE_COUNTER, 0);
fl_set_call_back(NODE_COUNTER,CB_node_counter,0);
//Plot all Check box
g3d_create_checkbutton(&PLOT_ALL_CHECKB,FL_PUSH_BUTTON,-1,20,"Plot all",(void**)&NODE_FRAME,0);
fl_set_object_color(PLOT_ALL_CHECKB,FL_MCOL,FL_GREEN);
fl_set_call_back(PLOT_ALL_CHECKB,CB_plot_all_checkb,0);
if (FLAG_IS_ALLPLOT)
fl_set_button(PLOT_ALL_CHECKB,1);
//Plot all input
g3d_create_input(&PLOT_ALL_INPUT,FL_NORMAL_INPUT,40,20,"",(void**)&NODE_FRAME,0);
sprintf(buffer, "%d", p3d_get_Nstep());
fl_set_input(PLOT_ALL_INPUT, buffer);
fl_set_call_back(PLOT_ALL_INPUT,CB_plot_all_input,0);
//Filter graph
g3d_create_checkbutton(&FILTER_GRAPH_CHECKB,FL_PUSH_BUTTON,-1,20,"Filter graph",(void**)&NODE_FRAME,0);
fl_set_object_color(FILTER_GRAPH_CHECKB,FL_MCOL,FL_GREEN);
fl_set_call_back(FILTER_GRAPH_CHECKB,CB_filter_graph_checkb,0);
if (p3d_get_show_cycle_only())
fl_set_button(FILTER_GRAPH_CHECKB,1);
//Retract strat frame
g3d_create_retract_strat_frame();
}
void adjust_ra(FL_OBJECT *ob, long data)
{
char tbuf[50];
char *p;
strcpy (tbuf, fl_get_input(ob));
p = strchr(tbuf, '\n');
if (p != NULL)
{
*p = '\0';
}
if (check_float (tbuf) < 0)
{
fl_set_input (ob, "Format Error");
}
else
{
ra = atof(tbuf);
}
}
void adjust_pulsar_rate(FL_OBJECT *ob, long data)
{
char tbuf[50];
char *p;
double real_rate;
int int_rate;
double err;
char str[64];
strcpy (tbuf, fl_get_input(ob));
p = strchr(tbuf, '\n');
if (p != NULL)
{
*p = '\0';
}
if ((p = strchr(tbuf, '\r')) != NULL)
{
*p = '\0';
}
if (check_float (tbuf) < 0)
{
fl_set_input (ob, "Format Error");
}
else
{
pulsar_rate = (double)atof(tbuf);
real_rate = (1.0/pulsar_rate)*(double)psr_rate;
int_rate = (int)(real_rate);
err = fabsf(real_rate - int_rate);
err = err / real_rate;
sprintf (str, "%8.2f", err*1.0e6);
fl_set_object_label (fd_receiver_main->phase_display, str);
}
}
void
lmst_update (FL_OBJECT *ob, long data)
{
struct tm *ltp;
time_t now;
unsigned char sid[6];
char lmst_buf[64];
FILE *fp;
int i, j;
FL_Coord x, y;
FL_Coord w, h;
double high, low;
char *p;
int delta;
int hours, mins, secs;
fl_add_timeout (1000.0, (FL_TIMEOUT_CALLBACK)lmst_update, 0);
/*
* Determine current LMST
*/
time (&now);
ltp = gmtime (&now);
get_sid_time (sid, longitude, ltp);
memcpy (current_lmst, sid, 3);
sprintf (lmst_buf, "%02d:%02d:%02d", sid[0], sid[1], sid[2]);
fl_set_object_label(fd_receiver_main->lmst_display, lmst_buf);
delta = now - started_at;
hours = delta / 3600;
mins = (delta - (hours * 3600)) / 60;
secs = (delta - ((hours * 3600) + (mins*60)));
sprintf (lmst_buf, "%02d:%02d:%02d", hours, mins, secs);
fl_set_object_label (fd_receiver_main->runtime_text, lmst_buf);
ra_mode[0] = 0x00;
dec_mode[0] = 0x00;
if ((p = getenv ("RCVR_RA_MODE")) != NULL)
{
strcpy (ra_mode, p);
if (strcmp (p, "transit") == 0)
{
ra = (float)sid[0] + (float)sid[1]/60.0 + (float)sid[2]/3600.0;
sprintf (lmst_buf, "%f", ra);
fl_set_input (fd_receiver_main->ra_input, lmst_buf);
}
else if (strncmp (p, "external", 8) == 0)
{
char keyword[128], filename[128];
sscanf (p, "%s %s", keyword, filename);
if ((fp = fopen (filename, "r")) != NULL)
{
fscanf (fp, "%f", &ra);
sprintf (lmst_buf, "%f", ra);
fl_set_input (fd_receiver_main->ra_input, lmst_buf);
fclose(fp);
}
}
}
if ((p = getenv ("RCVR_DEC_MODE")) != NULL)
{
strcpy (dec_mode, p);
if (strncmp (p, "external", 8) == 0)
{
char keyword[128], filename[128];
sscanf (p, "%s %s", keyword, filename);
if ((fp = fopen (filename, "r")) != NULL)
{
fscanf (fp, "%f", &declination);
sprintf (lmst_buf, "%f", declination);
fl_set_input (fd_receiver_main->declination_input, lmst_buf);
fclose(fp);
}
}
}
dump_params ();
time (&now);
if ((startup_cleared > 0) && (last_io_time > 1000) && ((now - last_io_time) > 30))
{
if (no_more_input == 0)
{
fprintf (stderr, "Leaving from %s\n", __FUNCTION__);
receiver_leave (NULL, -10);
}
}
if (startup_cleared > 0)
{
time (&now);
/*
* We know that the python script has started and can now take
* XMLRPC commands, because it's sending us data, so update
* some variables, *once*.
*/
if (writeback_flag == 0)
{
void write_pushed_variables(void);
writeback_flag = 1;
/*
* Write (via XMLRPC) all our "pushed" variables
* into the Gnu Radio flowgraph.
*/
write_pushed_variables();
write_notches ();
}
/*
* Set the warning levels for I/O lag from Gnu Radio flowgraph
*/
if ((now - last_io_time) <= 1)
{
fl_set_object_color (fd_receiver_main->io_status, FL_GREEN, FL_GREEN);
}
else if ((now - last_io_time) < 8)
{
fl_set_object_color (fd_receiver_main->io_status, FL_YELLOW, FL_YELLOW);
}
else if ((now - last_io_time) >= 8)
{
fl_set_object_color (fd_receiver_main->io_status, FL_RED, FL_RED);
}
}
}
int main(int argc, char *argv[])
{
void lmst_update (FL_OBJECT *, long);
int i;
void dismiss_psr();
void spectrum_hide();
void tp_hide ();
void hide_waterfall();
void hide_interferometer();
void hide_info();
void receiver_leave();
int close_sub ();
int close_main ();
char *p;
char fntstr[128];
char d[128];
int binwidth;
/*
* Init xforms library
*/
fl_initialize(&argc, argv, "Ira", 0, 0);
fl_get_app_resources (NULL, 0);
time (&started_at);
/*
* Create various windows, including the main one
*/
fd_receiver_main = create_form_receiver_main();
fl_set_form_atclose(fd_receiver_main->receiver_main, close_main, 0);
fd_receiver_pulsar = create_form_receiver_pulsar();
fl_set_form_atclose (fd_receiver_pulsar->receiver_pulsar, close_sub, dismiss_psr);
fd_receiver_spectrum = create_form_receiver_spectrum();
fl_set_form_atclose (fd_receiver_spectrum->receiver_spectrum, close_sub, spectrum_hide);
fd_receiver_continuum = create_form_receiver_continuum();
fl_set_form_atclose (fd_receiver_continuum->receiver_continuum, close_sub, tp_hide);
fd_receiver_waterfall = create_form_receiver_waterfall();
fl_set_form_atclose (fd_receiver_waterfall->receiver_waterfall, close_sub, hide_waterfall);
fd_receiver_info = create_form_receiver_info();
fl_set_form_atclose (fd_receiver_info->receiver_info, close_sub, hide_info);
fd_receiver_lproblem = create_form_receiver_lproblem ();
fd_receiver_error = create_form_receiver_error ();
fd_receiver_shutdown = create_form_receiver_shutdown ();
flps_init();
fl_free_pixmap_pixmap(fd_receiver_main->ira_xpm_button);
fl_set_pixmap_data(fd_receiver_main->ira_xpm_button, Ira_xpm);
sprintf (version_info, "Ver: %s (BETA)", VERSION);
/*
* Stuff lines in info window
*/
for (i = 0; ; i++)
{
if (ira_info[i] == NULL)
{
break;
}
fl_add_browser_line (fd_receiver_info->info_browser, ira_info[i]);
}
fl_set_browser_fontsize(fd_receiver_info->info_browser, 14);
/* fill-in form initialization code */
fl_set_object_label (fd_receiver_main->startup_text, "PLEASE WAIT.........");
/* show the first form */
fl_show_form(fd_receiver_main->receiver_main,FL_PLACE_CENTER,FL_FULLBORDER,"IRA Control Panel");
fl_check_forms();
/*
* Now we check a raft of environment variables, and use those to initialize
* various settable values
*/
refmult = 1.0;
if ((p = getenv ("RCVR_REF_MULT")) != NULL)
{
refmult = atof(p);
}
fl_set_slider_value (fd_receiver_main->refmult_slider, refmult);
seti_integ = 15;
if ((p = getenv ("RCVR_SETI_INTEG")) != NULL)
{
seti_integ = (int)atof(p);
}
fl_set_slider_value (fd_receiver_main->seti_integ_slider, (float)seti_integ);
strcpy (datadir, ".");
if ((p = getenv ("RCVR_DATA_DIR")) != NULL)
{
strcpy (datadir, p);
}
/*
* Set the input field for freq, as well as the actual frequency
*/
if ((p = getenv ("RCVR_INITIAL_FREQ")) != NULL)
{
fl_set_input (fd_receiver_main->frequency_input, p);
frequency = atof(p);
sky_freq = frequency;
sky_locked = 1;
}
/*
* Start out with sky_freq unavailable for input
*/
fl_deactivate_object (fd_receiver_main->sky_freq_input);
fl_set_input (fd_receiver_main->sky_freq_input, "--------");
/* If there's a sky_freq parameter, use it, and re-activate the
* sky_freq_input control
*/
if ((p = getenv ("RCVR_SKY_FREQ")) != NULL)
{
if (abs(atof(p) - frequency) > 100.0)
{
sky_locked = 0;
fl_set_input (fd_receiver_main->sky_freq_input, p);
sky_freq = atof(p);
fl_activate_object (fd_receiver_main->sky_freq_input);
fl_set_button (fd_receiver_main->sky_lock_button, 0);
}
else
{
sky_freq = atof(p);
fl_set_button (fd_receiver_main->sky_lock_button, 1);
sky_locked = 1;
}
}
PUSHVAR("ifreq", frequency);
PUSHVAR("skyfreq", sky_freq);
/*
*
* And again for RF gain
*/
if ((p = getenv ("RCVR_RF_GAIN")) != NULL)
{
rf_gain = atoi(p);
}
fl_set_slider_value (fd_receiver_main->rf_gain_slider, rf_gain);
PUSHVAR("igain", rf_gain);
/*
* Gain correction values for A and B sides
*/
if ((p = getenv ("RCVR_COR_A")) != NULL)
{
gc_a = atof(p);
}
sprintf (d, "%f", gc_a);
fl_set_input (fd_receiver_main->gc_a, d);
if ((p = getenv ("RCVR_COR_B")) != NULL)
{
gc_b = atof(p);
}
sprintf (d, "%f", gc_b);
fl_set_input (fd_receiver_main->gc_b, d);
/*
* Set bounds/values for DC gain
*/
if ((p = getenv ("RCVR_DC_GAIN")) != NULL)
{
dc_gain = atof(p);
}
fl_set_slider_value (fd_receiver_main->dc_gain_control, dc_gain);
/*
* And again for DC offset
*/
if ((p = getenv ("RCVR_DC_OFFSET")) != NULL)
{
dc_offset = atof(p);
}
fl_set_slider_value (fd_receiver_main->dc_offset_control, dc_offset);
/*
* Receiver DC Gain multiplier
*/
if ((p = getenv ("RCVR_DC_MULT")) != NULL)
{
int which;
dc_mult = (double)atoi(p);
which = 1;
/*
* It's a choice widget, so we need to set 'which' appropriately
*/
switch ((int)dc_mult)
{
case 1:
which = 1;
break;
case 5:
which = 2;
break;
case 10:
which = 3;
break;
case 15:
which = 4;
break;
case 20:
which = 5;
break;
case 25:
which = 6;
break;
case 30:
which=7;
break;
case 35:
which = 8;
break;
case 40:
which = 9;
break;
}
fl_set_choice (fd_receiver_main->mult_choice, which);
}
/*
* Total power integration value
*/
tp_integration = 5;
if ((p = getenv ("RCVR_TP_INTEG")) != NULL)
{
tp_integration = atoi(p);
}
fl_set_slider_value (fd_receiver_main->continuum_int, (double)atof(getenv("RCVR_TP_INTEG")) );
/*
* Spectral integration
*/
spec_integration = 15;
if ((p = getenv ("RCVR_SPEC_INTEG")) != NULL)
{
spec_integration = atoi(p);
}
fl_set_slider_value (fd_receiver_main->spec_int_slider, (double)atof(getenv("RCVR_SPEC_INTEG")) );
/*
* Sigma_K for SETI analysis
*/
sigma_k = 2.5;
if ((p = getenv ("RCVR_SIGMA_K")) != NULL)
{
sigma_k = atof(p);
}
fl_set_slider_value (fd_receiver_main->sigma_k_slider, sigma_k);
/*
* Check desired receiver mode
*/
if (getenv("RCVR_MODE") != NULL)
{
strcpy (rcvr_mode, getenv("RCVR_MODE"));
}
else
{
strcpy (rcvr_mode, "unknown");
}
/*
* Interferometer? Create the interferometer window
*/
if (strcmp (rcvr_mode, "interferometer") == 0)
{
fd_receiver_interferometer = create_form_receiver_interferometer();
fl_set_form_atclose (fd_receiver_interferometer->receiver_interferometer, close_sub,
hide_interferometer);
}
/*
* Otherwise, delete the "show interferograms" control
*/
else
{
fl_delete_object (fd_receiver_main->interferometer_button);
}
/*
* Various values
*/
declination = -28.3;
if ((p = getenv ("RCVR_DECLINATION")) != NULL)
{
declination = atof(p);
}
fl_set_input (fd_receiver_main->declination_input, getenv("RCVR_DECLINATION"));
longitude = 0.0;
if ((p = getenv ("RCVR_LONGITUDE")) != NULL)
{
longitude = atof(p);
}
seti_size = 500000;
if ((p = getenv ("RCVR_SETI_SIZE")) != NULL)
{
seti_size = atoi (p);
}
bandwidth = 5000000;
if ((p = getenv ("RCVR_BANDWIDTH")) != NULL)
{
bandwidth = atoi (p);
}
psr_rate = 10000;
if ((p = getenv ("RCVR_PSR_RATE")) != NULL)
{
psr_rate = atoi (getenv ("RCVR_PSR_RATE"));
}
for (i = 0; i < NNOTCHES; i++)
{
notches[i] = -1.0;
}
if ((p = getenv ("RCVR_NOTCHES")) != NULL)
{
char *tp;
char pcopy[128];
FILE *fp;
strcpy (pcopy, p);
tp = strtok (pcopy, ",");
notches[0] = atof(tp);
for (i = 1; i < NNOTCHES; i++)
{
tp = strtok (NULL, ",");
if (tp == NULL)
{
break;
}
notches[i] = atof(tp);
}
}
if ((p = getenv ("RCVR_NOTCH_SIZE")) != NULL)
{
notch_length = atoi(p);
fl_set_slider_value (fd_receiver_spectrum->notch_slider, (double)notch_length);
}
if ((p = getenv ("RCVR_DM")) != NULL)
{
pulsar_dm = atof(p);
fl_set_slider_value (fd_receiver_main->dm_input, (double)pulsar_dm);
}
PUSHVAR("idm", pulsar_dm);
if ((p = getenv ("PULSAR_RATE")) != NULL)
{
pulsar_rate = atof(p);
fl_set_input (fd_receiver_main->pulsar_rate_input, p);
}
if ((p = getenv ("PULSAR_FOLDING")) != NULL)
{
pulsar_folding = atoi(p);
fl_set_choice (fd_receiver_main->pulsar_choice, pulsar_folding/5);
}
/*
* Set spec_fft_size based on width of spectral plot display
*/
{
FL_Coord x, y, w, h;
fl_get_object_bbox (fd_receiver_spectrum->spectral_plot, &x, &y, &w, &h);
spec_fft_size = w-130;
}
tp_maxval = 100000;
tp_span = 20000;
/*
* Establish parameters for TP plot
*/
if ((p = getenv("RCVR_TP_MAXVAL")) != NULL)
{
tp_maxval = (double)atoi(p);
}
if ((p = getenv ("RCVR_TP_SPAN")) != NULL)
{
tp_span = (double)atoi(p);
}
tp_minval = tp_maxval - tp_span;
fl_set_slider_value (fd_receiver_continuum->tp_max_slider, (double)tp_maxval);
fl_set_slider_value (fd_receiver_continuum->tp_span_slider, (double)tp_span);
fl_set_xyplot_ybounds(fd_receiver_continuum->tp_chart, (double)tp_minval, (double)tp_maxval);
fl_set_xyplot_ytics(fd_receiver_continuum->tp_chart, 10, 1);
fl_set_xyplot_xgrid (fd_receiver_continuum->tp_chart, FL_GRID_MINOR);
fl_set_xyplot_ygrid (fd_receiver_continuum->tp_chart, FL_GRID_MINOR);
fl_set_object_posthandler(fd_receiver_continuum->tp_chart, continuum_plot_post);
/*
* Set a post handler for inteferometer display
*/
if (strcmp (rcvr_mode, "interferometer") == 0)
{
fl_set_object_posthandler(fd_receiver_interferometer->interferometer_chart, continuum_plot_post);
if ((p = getenv ("RCVR_INT_GAIN")) != NULL)
{
interferometer_gain = atof(p);
}
if ((p = getenv ("RCVR_INT_SPAN")) != NULL)
{
interferometer_span = atof(p);
}
if ((p = getenv ("RCVR_PHCORR")) != NULL)
{
interferometer_phase = atof(p);
}
if ((p = getenv ("RCVR_DELAY")) != NULL)
{
interferometer_delay = atof(p);
}
fl_set_xyplot_ytics (fd_receiver_interferometer->interferometer_chart, 10, 1);
fl_set_xyplot_xgrid (fd_receiver_interferometer->interferometer_chart, FL_GRID_MINOR);
fl_set_xyplot_ygrid (fd_receiver_interferometer->interferometer_chart, FL_GRID_MINOR);
fl_set_slider_value (fd_receiver_interferometer->int_gain_slider, interferometer_gain);
fl_set_slider_value (fd_receiver_interferometer->int_span_slider, interferometer_span);
fl_set_slider_value (fd_receiver_interferometer->phase_adjust, interferometer_phase);
fl_set_slider_value (fd_receiver_interferometer->delay_adjust, interferometer_delay);
fl_set_xyplot_ybounds (fd_receiver_interferometer->interferometer_chart, -1*interferometer_span,
interferometer_span);
}
fl_add_timeout (1000.0, (FL_TIMEOUT_CALLBACK)lmst_update, 0);
/*
* Setup parameters for spectral plot
*/
if ((p = getenv ("RCVR_SPEC_MAX")) != NULL)
{
current_smax = atoi(p);
}
if ((p = getenv ("RCVR_SPEC_SPAN")) != NULL)
{
current_span = atoi(p);
}
if ((p = getenv ("RCVR_SPEC_FLAT")) != NULL)
{
spec_flat_on = atoi(p);
fl_set_button (fd_receiver_spectrum->flaten_button, spec_flat_on);
}
if ((p = getenv ("RCVR_SPEC_METHOD")) != NULL)
{
spec_method = atoi (p);
}
fl_set_xyplot_xgrid(fd_receiver_spectrum->spectral_plot, FL_GRID_MINOR);
fl_set_xyplot_ygrid(fd_receiver_spectrum->spectral_plot, FL_GRID_MINOR);
fl_set_xyplot_ybounds(fd_receiver_spectrum->spectral_plot, (double)(current_smax-current_span), (double)
current_smax);
fl_set_xyplot_ytics(fd_receiver_spectrum->spectral_plot, 10, 1);
fl_set_xyplot_xtics(fd_receiver_spectrum->spectral_plot, 10, 1);
fl_set_object_posthandler(fd_receiver_spectrum->spectral_plot, spectral_plot_post);
fl_set_choice (fd_receiver_spectrum->spec_method_choice, spec_method);
fl_set_choice_fontsize (fd_receiver_spectrum->spec_method_choice, 14);
fl_set_slider_value (fd_receiver_spectrum->spec_max_slider, (double)current_smax);
fl_set_slider_value (fd_receiver_spectrum->spec_span_slider, (double)current_span);
/*
* Set post handler for pulsar display
*/
fl_set_object_posthandler(fd_receiver_pulsar->pulsar_plot, pulsar_plot_post);
/*
* Set parameters for waterfall (SETI) display
*/
{
FL_Coord x, y;
FL_Coord w, h;
fl_get_object_bbox(fd_receiver_waterfall->waterfall_display, &x, &y, &w, &h);
fl_set_slider_bounds (fd_receiver_waterfall->wfall_seg_slider, 1.0, (float)seti_size/w);
fl_set_object_dblbuffer(fd_receiver_waterfall->waterfall_display, 1);
if ((p = getenv ("RCVR_WFALL_SEGMENT")) != NULL)
{
waterfall_segment = atoi(p);
fl_set_slider_value (fd_receiver_waterfall->wfall_seg_slider, (double)waterfall_segment);
}
if ((p = getenv ("RCVR_WFALL_FINE")) != NULL)
{
waterfall_fine = atoi(p);
fl_set_slider_value (fd_receiver_waterfall->fine_segment, waterfall_fine);
}
if ((p = getenv ("RCVR_WFALL_BRIGHTNESS")) != NULL)
{
double w;
w = atof(p);
if (fabsf(w-1.0) < 0.1)
{
fl_set_choice (fd_receiver_waterfall->wfall_brightness, 1);
w = 1.0;
}
if (fabsf(w-0.75) < 0.1)
{
fl_set_choice (fd_receiver_waterfall->wfall_brightness, 2);
w = 0.75;
}
if (fabsf(w-0.66) < 0.1)
{
fl_set_choice (fd_receiver_waterfall->wfall_brightness, 3);
w = 0.66;
}
if (fabsf(w-0.50) < 0.1)
{
fl_set_choice (fd_receiver_waterfall->wfall_brightness, 4);
w = 0.50;
}
waterfall_brightness = (float)w;
}
}
if ((p = getenv ("RCVR_TRANS_THRESH")) != NULL)
{
transient_threshold = atof(p);
fl_set_slider_value (fd_receiver_main->trans_thr_slider, transient_threshold);
}
if ((p = getenv ("RCVR_TRANS_DUR")) != NULL)
{
transient_duration = atof(p);
fl_set_slider_value (fd_receiver_main->trans_dur_slider, transient_duration);
}
/*
* Open various FIFOs--that's where we get our data from
*/
if ((seti_fd = open ("ra_seti_fifo", O_RDONLY|O_NONBLOCK)) > 0)
{
fcntl (seti_fd, F_SETFL, 0);
fl_add_io_callback (seti_fd, FL_READ, (FL_IO_CALLBACK)handle_seti_io, fd_receiver_main);
}
if ((pulsar_fd = open ("ra_psr_fifo", O_RDONLY|O_NONBLOCK)) > 0)
{
fcntl (pulsar_fd, F_SETFL, 0);
fl_add_io_callback (pulsar_fd, FL_READ, (FL_IO_CALLBACK)handle_pulsar_io, fd_receiver_main);
}
if ((dicke_fd = open ("ra_switching_fifo", O_RDONLY|O_NONBLOCK)) > 0)
{
fcntl (dicke_fd, F_SETFL, 0);
fl_set_object_label (fd_receiver_main->dicke_mode, "DICKE: ON");
fl_add_io_callback (dicke_fd, FL_READ, (FL_IO_CALLBACK)handle_dicke_io, fd_receiver_main);
}
if (strcmp (rcvr_mode, "interferometer") == 0)
{
if ((inter_fd = open ("ra_inter_fifo", O_RDONLY|O_NONBLOCK)) > 0)
{
fcntl (inter_fd, F_SETFL, 0);
fl_add_io_callback (inter_fd, FL_READ, (FL_IO_CALLBACK)handle_inter_io, fd_receiver_main);
}
}
if (strcmp (rcvr_mode, "split") == 0)
{
if ((validation_fd = open ("ra_validation_fifo", O_RDONLY|O_NONBLOCK)) > 0)
{
fcntl (validation_fd, F_SETFL, 0);
split_mode = 1;
fl_add_io_callback (validation_fd, FL_READ, (FL_IO_CALLBACK)handle_validation_io, fd_receiver_main);
}
}
fl_set_oneliner_font (FL_FIXEDBOLDITALIC_STYLE, FL_MEDIUM_FONT);
fl_set_oneliner_color (FL_GREEN, FL_BLACK);
while(fl_do_forms())
;
return 0;
}
void uiSetTargetname(char *name) {
fl_set_input(TargetInput, name);
}
void NeoWindow::HandleMainWinObject( FL_OBJECT *obj ) { // Handle command from form on main window
int scale = neo->scale, i;
if ( obj == mainWin->pause ) { // Pause/un-pause
if ( ! neo->setup ) return;
neo->started = true;
neo->paused = ! neo->paused;
Refresh( true );
} else if ( obj == mainWin->step ) { // If paused, update by one timestep
neo->started = true;
if ( neo->paused ) neo->nextStep = true;
} else if ( obj == mainWin->add_food ) { // Add food to world
neo->borrowed_energy -= neo->food_button_increment;
} else if ( obj == mainWin->remove_food ) { // Remove food
neo->borrowed_energy += neo->food_button_increment;
} else if ( obj == mainWin->file_menu ) {
const char *choice = fl_get_menu_text( obj );
if ( ! strcmp( "New", choice ) ) {
neo->started = false;
neo->paused = true;
neo->SetUpRun(); // Set up the run
Refresh( true );
//portal = new NeoPortal( 1115 );
//( portal = new NeoPortal() )->CallServer( "localhost", 1115 );
} else if ( ! strcmp( "Close", choice ) ) {
neo->started = false;
neo->paused = true;
Refresh( true );
} else if ( ! strcmp( "Load", choice ) ) {
const char *output = NULL;
if ( ( output = fl_show_fselector( "Load simulation from file:" , ".", "*",
neo->fileName ) ) != NULL ) {
strcpy( neo->fileName, output );
neo->LoadSimulation();
Refresh( true );
}
} else if ( ! strcmp( "Save", choice ) ) {
const char *output = NULL;
if ( ( output = fl_show_fselector( "Save simulation to file:" , ".", "*",
neo->fileName ) ) != NULL ) {
strcpy( neo->fileName, output );
neo->SaveSimulation();
}
Refresh();
} else if ( ! strcmp( "Print...", choice ) ) {
char tmp[50];
sprintf( tmp, "%s.%08d.ps", neo->fileName, neo->time_step );
const char *output = NULL;
if ( ( output = fl_show_fselector( "Print simulation to PostScript file:" , ".", "*",
tmp ) ) != NULL ) {
fl_object_ps_dump( mainWin->mainCanvas, tmp );
}
} else if ( ! strcmp( "Quit", choice ) ) {
neo->done = true;
neo->started = false;
neo->keepDrawing = false;
}
} else if ( obj == mainWin->other_menu ) {
const char *choice = fl_get_menu_text( obj );
if ( ! strcmp( "Update Display", choice ) ) {
neo->keepDrawing = ! neo->keepDrawing;
Refresh( true ); // Need to update the whole screen
} else if ( ! strcmp( "NNet Window", choice ) ) {
nnet_plot = create_form_neural_net_plot();
fl_add_canvas_handler( nnet_plot->mainCanvas, Expose, expose_callback, (void *) this );
fl_show_form( nnet_plot->neural_net_plot, FL_PLACE_MOUSE, FL_TRANSIENT, "Neural Net Plot" );
RedrawNNetPlot();
} else if ( ! strcmp( "Chart Window", choice ) ) {
chart_wind = create_form_chart_window();
fl_show_form( chart_wind->chart_window, FL_PLACE_MOUSE, FL_TRANSIENT, "Population Statistics" );
} else if ( ! strcmp( "Leave Trails", choice ) ) {
neo->leaveTrails = ! neo->leaveTrails;
if ( ! neo->leaveTrails ) Refresh( true );
} else if ( ! strcmp( "Add Bug", choice ) ) {
const char *output = NULL;
fl_add_fselector_appbutton( "Number", fselector_callback, this );
if ( ( output = fl_show_fselector( "Add creature from file:", ".", "*",
neo->creatureFile ) ) != NULL ) {
for ( int jj = 0; jj < neo->initialBugSeed; jj ++ ) {
strcpy( neo->creatureFile, output );
new Creature( Introduced, neo );
}
}
fl_remove_fselector_appbutton( "Number" );
Draw( true );
} else if ( ! strcmp( "Save Bug", choice ) ) {
if ( neo->output_creature < 0 ) return;
const char *output = NULL;
if ( ( output = fl_show_fselector( "Save creature to file:" , ".", "*",
neo->creatureFile ) ) != NULL ) {
Creature *creature = neo->ppCreatureList[ neo->output_creature ];
if ( creature != NULL ) creature->WriteGenotype( (char *) output );
}
} else if ( ! strcmp( "Options...", choice ) ) {
options_box = create_form_options();
FD_options *box = options_box;
if ( neo->started ) {
fl_deactivate_object( box->initial_parameters_group );
fl_set_object_label( box->initial_params_frame, "Initial Parameters (currently inactive)" );
}
fl_set_slider_value( box->initial_pop, neo->initial_creatures );
fl_set_slider_value( box->initial_plant, neo->num_initial_food_locs );
fl_set_slider_value( box->initial_flesh, neo->num_initial_meat_locs );
fl_set_button( box->give_head_start, neo->bGiveHeadStart );
fl_set_button( box->allow_sex, neo->bAllowSexual );
fl_set_button( box->allow_asex, neo->bAllowAsexual );
char tmp[5];
sprintf( tmp, "%d", neo->terrain_size );
fl_set_choice_text( box->terrain_size, tmp );
fl_set_slider_value( box->scale, neo->scale );
fl_set_slider_value( box->prob_crossover, neo->prob_crossover );
fl_set_slider_value( box->prob_mutation, neo->prob_mutation );
fl_set_slider_value( box->max_pop, neo->maximum_creatures );
fl_set_slider_value( box->min_pop, neo->nMinimumPopulation );
fl_set_slider_value( box->age_factor, neo->age_factor );
fl_set_slider_value( box->carcass_decay_rate, neo->nCarcassDecayRate );
fl_set_slider_value( box->waste_decay_rate, neo->nWasteDecayRate );
fl_set_slider_value( box->poison_decay_rate, neo->nPoisonDecayRate );
fl_set_button( box->give_head_start, neo->bGiveHeadStart );
fl_set_button( box->maintain_min_pop, neo->bKeepMinimumPopulation );
fl_set_button( box->use_survivor, neo->bUseSurvivorForMinimum );
fl_set_slider_value( box->save_every, neo->saveEveryNsteps );
if ( neo->saveEveryNsteps == -1 ) fl_set_button( box->save_sim, 0 );
else fl_set_button( box->save_sim, 1 );
fl_set_input( box->file_name, neo->fileName );
fl_show_form( box->options, FL_PLACE_MOUSE, FL_TRANSIENT, "Key Commands" );
}
}
}
RNG *CreateRNG() {
FL_OBJECT *ap = the_gui->AEntry;
FL_OBJECT *bp = the_gui->BEntry;
FL_OBJECT *cp = the_gui->DistributionChoice;
char buf[80];
char *cdffn;
double a;
double b;
int i;
RNG *r;
switch (fl_get_choice(cp)) {
case Uniform:
a = atof(fl_get_input(ap));
b = atof(fl_get_input(bp));
r = new UniformRNG(a,b);
break;
case Binomial:
a = atof(fl_get_input(ap));
i = atoi(fl_get_input(bp));
r = new BinomialRNG(a,i);
break;
case CDF:
CDFRNG *cdfr;
cdffn = (char *)fl_show_input("PDF File Name","wdist.dat");
if (cdffn == NULL)
return NULL;
cdfr = new CDFRNG(cdffn);
if (cdfr->bad()) {
fl_show_message("Can't open PDF file",cdffn,"");
return NULL;
}
sprintf(buf,"%f",cdfr->min());
fl_set_input(ap,buf);
sprintf(buf,"%f",cdfr->max());
fl_set_input(bp,buf);
r = cdfr;
break;
case Exponential:
r = new ExponentialRNG();
break;
case Gamma:
a = atof(fl_get_input(ap));
b = atof(fl_get_input(bp));
r = new GammaRNG(a,b);
break;
case LogNormal:
a = atof(fl_get_input(ap));
b = atof(fl_get_input(bp));
r = new LogNormalRNG(a,b);
break;
case LogNormalLog:
a = atof(fl_get_input(ap));
b = atof(fl_get_input(bp));
r = new LogNormalLogRNG(a,b);
break;
case Normal:
a = atof(fl_get_input(ap));
b = atof(fl_get_input(bp));
r = new NormalRNG(a,b);
break;
case Poisson:
a = atof(fl_get_input(ap));
r = new PoissonRNG(a);
break;
}
return r;
}
void DistributionChoiceCB(FL_OBJECT *p0, long p1) {
FL_OBJECT *ap = the_gui->AEntry;
FL_OBJECT *bp = the_gui->BEntry;
switch (fl_get_choice(p0)) {
case 0:
cout << "No choice" << endl;
break;
case Uniform: // uniform in the interval [a,b]
fl_set_object_label(ap,"Minimum");
fl_set_input(ap,"10.0");
fl_set_object_label(bp,"Maximum");
fl_set_input(bp,"90.0");
fl_show_object(ap);
fl_show_object(bp);
break;
case Binomial: // binomial
fl_set_object_label(ap,"p");
fl_set_input(ap,"0.5");
fl_set_object_label(bp,"n");
fl_set_input(bp,"10.0");
fl_show_object(ap);
fl_show_object(bp);
break;
case CDF: // CDF -- file will set range in a, b entries
fl_set_object_label(ap,"lo");
fl_set_input(ap,"<>");
fl_set_object_label(bp,"hi");
fl_set_input(bp,"<>");
fl_show_object(ap);
fl_show_object(bp);
break;
case Exponential: // exponential; no params
fl_hide_object(ap);
fl_hide_object(bp);
break;
case Gamma: // Time to wait for N events
fl_set_object_label(ap,"Mean");
fl_set_input(ap,"1");
fl_set_object_label(bp,"Std Dev");
fl_set_input(bp,"1");
fl_show_object(ap);
fl_show_object(bp);
break;
case LogNormal: // lognormal with mean = a and std dev = b
fl_set_object_label(ap,"Mean");
fl_set_input(ap,"50.0");
fl_set_object_label(bp,"Std Dev");
fl_set_input(bp,"10.0");
fl_show_object(ap);
fl_show_object(bp);
break;
case LogNormalLog: // lognormal with mean = exp(a) and std dev = exp(b)
fl_set_object_label(ap,"Log Mean");
fl_set_input(ap,"3.0");
fl_set_object_label(bp,"Log Std Dev");
fl_set_input(bp,"0.5");
fl_show_object(ap);
fl_show_object(bp);
break;
case Normal: // normal with mean = a and std dev = b
fl_set_object_label(ap,"Mean");
fl_set_input(ap,"50.0");
fl_set_object_label(bp,"Std Dev");
fl_set_input(bp,"10.0");
fl_show_object(ap);
fl_show_object(bp);
break;
case Poisson: // poisson with lambda = a
fl_set_object_label(ap,"Lambda");
fl_set_input(ap,"1.0");
fl_show_object(ap);
fl_hide_object(bp);
break;
}
}
