static bool daq2_identify(void)
{
/* Use the OSC's IIO context just to detect the devices */
struct iio_context *osc_ctx = get_context_from_osc();
if (iio_context_find_device(osc_ctx, DAQ1_DAC_DEVICE)) {
daq_board = 1;
ADC_DEVICE = DAQ1_ADC_DEVICE;
DAC_DEVICE = DAQ1_DAC_DEVICE;
daq_sr_attribs = daq1_sr_attribs;
sr_attribs_array_size = ARRAY_SIZE(daq1_sr_attribs);
} else if (iio_context_find_device(osc_ctx, DAQ2_DAC_DEVICE)) {
daq_board = 2;
ADC_DEVICE = DAQ2_ADC_DEVICE;
DAC_DEVICE = DAQ2_DAC_DEVICE;
daq_sr_attribs = daq2_sr_attribs;
sr_attribs_array_size = ARRAY_SIZE(daq2_sr_attribs);
} else if (iio_context_find_device(osc_ctx, DAQ3_DAC_DEVICE)) {
daq_board = 3;
ADC_DEVICE = DAQ3_ADC_DEVICE;
DAC_DEVICE = DAQ3_DAC_DEVICE;
daq_sr_attribs = daq3_sr_attribs;
sr_attribs_array_size = ARRAY_SIZE(daq3_sr_attribs);
} else {
ADC_DEVICE = "";
DAC_DEVICE = "";
}
return !!iio_context_find_device(osc_ctx, DAC_DEVICE) &&
!!iio_context_find_device(osc_ctx, ADC_DEVICE);
}
static bool fmcomms2adv_identify(void)
{
/* Use the OSC's IIO context just to detect the devices */
struct iio_context *osc_ctx = get_context_from_osc();
struct iio_device *osc_dev = iio_context_find_device(
osc_ctx, "ad9361-phy");
if (!osc_dev || !iio_device_get_debug_attrs_count(osc_dev))
return false;
ctx = osc_create_context();
dev = iio_context_find_device(ctx, "ad9361-phy");
dev_slave = iio_context_find_device(ctx, "ad9361-phy-hpc");
if (dev_slave) {
cf_ad9361_lpc = iio_context_find_device(ctx, "cf-ad9361-lpc");
cf_ad9361_hpc = iio_context_find_device(ctx, "cf-ad9361-hpc");
dev_dds_master = iio_context_find_device(ctx, "cf-ad9361-dds-core-lpc");
dev_dds_slave = iio_context_find_device(ctx, "cf-ad9361-dds-core-hpc");
if (!(cf_ad9361_lpc && cf_ad9361_hpc && dev_dds_master && dev_dds_slave))
dev = NULL;
else
if (get_dds_channels())
dev = NULL;
}
if (dev && !iio_device_get_debug_attrs_count(dev))
dev = NULL;
if (!dev)
iio_context_destroy(ctx);
return !!dev;
}
static bool fmcomms2_identify(void)
{
/* Use the OSC's IIO context just to detect the devices */
struct iio_context *osc_ctx = get_context_from_osc();
if (!iio_context_find_device(osc_ctx, PHY_DEVICE)
|| !iio_context_find_device(osc_ctx, DDS_DEVICE))
return false;
/* Check if FMComms5 is used */
return !iio_context_find_device(osc_ctx, "ad9361-phy-B");
}
void dialogs_init(GtkBuilder *builder)
{
const char *name = NULL;
struct iio_context *ctx;
GtkWidget *tmp;
dialogs.builder = builder;
dialogs.about = GTK_WIDGET(gtk_builder_get_object(builder, "About_dialog"));
dialogs.connect = GTK_WIDGET(gtk_builder_get_object(builder, "connect_dialog"));
dialogs.connect_fru = GTK_WIDGET(gtk_builder_get_object(builder, "fru_info"));
dialogs.serial_num = GTK_WIDGET(gtk_builder_get_object(builder, "serial_number_popup"));
dialogs.connect_iio = GTK_WIDGET(gtk_builder_get_object(builder, "connect_iio_devices"));
dialogs.ctx_info = GTK_WIDGET(gtk_builder_get_object(builder, "connect_iio_ctx_info"));
dialogs.load_save_profile = GTK_WIDGET(gtk_builder_get_object(builder, "load_save_profile"));
dialogs.connect_net = GTK_WIDGET(gtk_builder_get_object(builder, "connect_net"));
dialogs.net_ip = GTK_WIDGET(gtk_builder_get_object(builder, "connect_net_IP"));
dialogs.ok_btn = GTK_WIDGET(gtk_builder_get_object(builder, "button3"));
dialogs.latest_version = GTK_WIDGET(gtk_builder_get_object(builder, "latest_version_popup"));
dialogs.ver_progress_window = GTK_WIDGET(gtk_builder_get_object(builder, "progress_window"));
dialogs.ver_progress_bar = GTK_WIDGET(gtk_builder_get_object(builder, "progressbar"));
gtk_builder_connect_signals(builder, &dialogs);
/* Bind some dialogs radio buttons to text/labels */
tmp = GTK_WIDGET(gtk_builder_get_object(builder, "connect_net_label"));
serial_num = GTK_WIDGET(gtk_builder_get_object(builder, "serial_number"));
fru_date = GTK_WIDGET(gtk_builder_get_object(builder, "fru_date"));
fru_file_list = GTK_WIDGET(gtk_builder_get_object(builder, "FRU_files"));
g_object_bind_property(dialogs.connect_net, "active", tmp, "sensitive", 0);
g_object_bind_property(dialogs.connect_net, "active", dialogs.net_ip, "sensitive", 0);
/* Grey out the "local context" option if it is not available */
ctx = get_context_from_osc();
if (ctx)
name = iio_context_get_name(ctx);
if (!name || strcmp(name, "local")) {
ctx = iio_create_local_context();
if (ctx) {
iio_context_destroy(ctx);
} else {
GtkWidget *local = GTK_WIDGET(gtk_builder_get_object(
builder, "connect_local"));
gtk_widget_set_sensitive(local, false);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(dialogs.connect_net), true);
}
}
}
static gint fru_connect_dialog(Dialogs *data, bool load_profile)
{
/* Connect Dialog */
gint ret;
struct iio_context *ctx;
const char *name = NULL;
bool has_context = false;
/* Preload the device list and FRU info only if we can use the local
* backend */
ctx = get_context_from_osc();
if (ctx)
name = iio_context_get_name(ctx);
if (name && !strcmp(name, "local"))
has_context = connect_fillin(data);
while (true) {
gtk_widget_set_sensitive(data->ok_btn, has_context);
ret = gtk_dialog_run(GTK_DIALOG(data->connect));
switch (ret) {
case GTK_RESPONSE_APPLY:
widget_set_cursor(data->connect, GDK_WATCH);
has_context = connect_fillin(data);
widget_use_parent_cursor(data->connect);
continue;
case GTK_RESPONSE_OK:
ctx = get_context(data);
widget_set_cursor(data->connect, GDK_WATCH);
widget_use_parent_cursor(data->connect);
if (!ctx)
continue;
application_reload(ctx, load_profile);
break;
default:
printf("unknown response (%i) in %s(%s)\n", ret, __FILE__, __func__);
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
break;
}
gtk_widget_hide(data->connect);
return ret;
}
}
static bool fmcomms2adv_identify(void)
{
/* Use the OSC's IIO context just to detect the devices */
struct iio_context *osc_ctx = get_context_from_osc();
dev = iio_context_find_device(osc_ctx, PHY_DEVICE);
dev_slave = iio_context_find_device(osc_ctx, PHY_SLAVE_DEVICE);
if (dev_slave) {
cf_ad9361_lpc = iio_context_find_device(osc_ctx, CAP_DEVICE_ALT);
cf_ad9361_hpc = iio_context_find_device(osc_ctx, CAP_SLAVE_DEVICE);
dev_dds_master = iio_context_find_device(osc_ctx, DDS_DEVICE);
dev_dds_slave = iio_context_find_device(osc_ctx, DDS_SLAVE_DEVICE);
}
return !!dev && iio_device_get_debug_attrs_count(dev)
&& (!dev_slave || (!!cf_ad9361_lpc && !!cf_ad9361_hpc &&
!!dev_dds_master && !!dev_dds_slave));
}
static void do_calibration (GtkWidget *widget, gpointer data)
{
struct iio_device *iio_dev;
unsigned num_chs, enabled_chs_mask;
GtkToggleButton *silent_calib;
plot_xcorr_4ch = plugin_get_new_plot();
silent_calib = GTK_TOGGLE_BUTTON(gtk_builder_get_object(builder, "silent_calibration"));
if (gtk_toggle_button_get_active(silent_calib)) {
osc_plot_set_visible(plot_xcorr_4ch, false);
}
/* If channel selection of the plot used in the calibration combined
* with the channel selections of other existing plots is invalid then
* enable all channels. NOTE: remove this implementation once the dma
* starts working with any combination of channels.
*/
iio_dev = iio_context_find_device(get_context_from_osc(), CAP_DEVICE_ALT);
if (iio_dev) {
num_chs = iio_device_get_channels_count(iio_dev);
enabled_chs_mask = global_enabled_channels_mask(iio_dev);
if (!dma_valid_selection(CAP_DEVICE_ALT, enabled_chs_mask | 0x33, num_chs)) {
cap_device_channels_enabled = true;
iio_channels_change_shadow_of_enabled(iio_dev, true);
}
}
if (plot_xcorr_4ch) {
osc_plot_set_channel_state(plot_xcorr_4ch, CAP_DEVICE_ALT, 0, true);
osc_plot_set_channel_state(plot_xcorr_4ch, CAP_DEVICE_ALT, 1, true);
osc_plot_set_channel_state(plot_xcorr_4ch, CAP_DEVICE_ALT, 4, true);
osc_plot_set_channel_state(plot_xcorr_4ch, CAP_DEVICE_ALT, 5, true);
osc_plot_set_domain(plot_xcorr_4ch, XCORR_PLOT);
osc_plot_set_marker_type(plot_xcorr_4ch, MARKER_PEAK);
} else
return;
if (data)
gtk_widget_hide(GTK_WIDGET(data));
g_thread_new("Calibrate_thread", (void *) &calibrate, data);
}
static bool dmm_identify(const struct osc_plugin *plugin)
{
/* Use the OSC's IIO context just to detect the devices */
struct iio_context *osc_ctx = get_context_from_osc();
unsigned int i, num;
bool ret = false;
num = iio_context_get_devices_count(osc_ctx);
for (i = 0; !ret && i < num; i++) {
struct iio_device *dev = iio_context_get_device(osc_ctx, i);
unsigned int j, nch = iio_device_get_channels_count(dev);
for (j = 0; !ret && j < nch; j++) {
struct iio_channel *chn =
iio_device_get_channel(dev, j);
if (is_valid_dmm_channel(chn))
ret = true;
}
}
return ret;
}
static bool pr_config_identify(void)
{
/* Use the OSC's IIO context just to detect the devices */
struct iio_context *osc_ctx = get_context_from_osc();
if (!iio_context_find_device(osc_ctx, PHY_DEVICE) ||
!iio_context_find_device(osc_ctx, DEVICE_NAME_ADC) ||
!iio_context_find_device(osc_ctx, DEVICE_NAME_DAC))
return false;
ctx = osc_create_context();
phy = iio_context_find_device(ctx, PHY_DEVICE);
adc = iio_context_find_device(ctx, DEVICE_NAME_ADC);
dac = iio_context_find_device(ctx, DEVICE_NAME_DAC);
context_is_local = !strncmp(iio_context_get_name(ctx), "local", strlen("local"));
int id;
bool init = true;
if (!phy || !adc || !dac) {
init = false;
} else {
id = getPrId();
if ((id != PR_LOGIC_DEFAULT_ID) &&
(id != PR_LOGIC_BIST_ID) &&
(id != PR_LOGIC_QPSK_ID))
init = false;
}
if (phy && !iio_device_get_debug_attrs_count(phy))
init = false;
if (!init)
iio_context_destroy(ctx);
return init;
}
static bool ad9739a_identify(const struct osc_plugin *plugin)
{
/* Use the OSC's IIO context just to detect the devices */
struct iio_context *osc_ctx = get_context_from_osc();
return !!iio_context_find_device(osc_ctx, DAC_DEVICE);
}
static void calibrate (gpointer button)
{
GtkProgressBar *calib_progress = NULL;
double rx_phase_lpc, rx_phase_hpc, tx_phase_hpc;
struct iio_channel *in0, *in0_slave;
long long cal_tone, cal_freq;
int ret, samples;
in0 = iio_device_find_channel(dev, "voltage0", false);
in0_slave = iio_device_find_channel(dev_slave, "voltage0", false);
if (!in0 || !in0_slave) {
printf("could not find channels\n");
ret = -ENODEV;
goto calibrate_fail;
}
if (!cf_ad9361_lpc || !cf_ad9361_hpc) {
printf("could not find capture cores\n");
ret = -ENODEV;
goto calibrate_fail;
}
if (!dev_dds_master || !dev_dds_slave) {
printf("could not find dds cores\n");
ret = -ENODEV;
goto calibrate_fail;
}
calib_progress = GTK_PROGRESS_BAR(gtk_builder_get_object(builder, "progress_calibration"));
set_calibration_progress(calib_progress, 0.00);
mcs_cb(NULL, NULL);
/*
* set some logical defaults / assumptions
*/
ret = default_dds(get_cal_tone(), CAL_SCALE);
if (ret < 0) {
printf("could not set dds cores\n");
goto calibrate_fail;
}
iio_channel_attr_read_longlong(dds_out[0][0], "frequency", &cal_tone);
iio_channel_attr_read_longlong(dds_out[0][0], "sampling_frequency", &cal_freq);
samples = get_cal_samples(cal_tone, cal_freq);
DBG("cal_tone %lld cal_freq %lld samples %d", cal_tone, cal_freq, samples);
gdk_threads_enter();
osc_plot_set_sample_count(plot_xcorr_4ch, samples);
osc_plot_draw_start(plot_xcorr_4ch);
gdk_threads_leave();
/* Turn off quadrature tracking while the sync is going on */
iio_channel_attr_write(in0, "quadrature_tracking_en", "0");
iio_channel_attr_write(in0_slave, "quadrature_tracking_en", "0");
/* reset any Tx rotation to zero */
trx_phase_rotation(cf_ad9361_lpc, 0.0);
trx_phase_rotation(cf_ad9361_hpc, 0.0);
set_calibration_progress(calib_progress, 0.16);
/*
* Calibrate RX:
* 1 TX1B_B (HPC) -> RX1C_B (HPC) : BIST_LOOPBACK on A
*/
osc_plot_xcorr_revert(plot_xcorr_4ch, true);
__cal_switch_ports_enable_cb(1);
rx_phase_hpc = tune_trx_phase_offset(cf_ad9361_hpc, &ret, cal_freq, cal_tone, 1.0, 0.01, trx_phase_rotation);
if (ret < 0) {
printf("Failed to tune phase : %s:%i\n", __func__, __LINE__);
goto calibrate_fail;
}
set_calibration_progress(calib_progress, 0.40);
DBG("rx_phase_hpc %f", rx_phase_hpc);
/*
* Calibrate RX:
* 3 TX1B_B (HPC) -> RX1C_A (LPC) : BIST_LOOPBACK on B
*/
osc_plot_xcorr_revert(plot_xcorr_4ch, false);
trx_phase_rotation(cf_ad9361_hpc, 0.0);
__cal_switch_ports_enable_cb(3);
rx_phase_lpc = tune_trx_phase_offset(cf_ad9361_lpc, &ret, cal_freq, cal_tone, 1.0, 0.01, trx_phase_rotation);
if (ret < 0) {
printf("Failed to tune phase : %s:%i\n", __func__, __LINE__);
goto calibrate_fail;
}
set_calibration_progress(calib_progress, 0.64);
(void) rx_phase_lpc; /* Avoid compiler warnings */
DBG("rx_phase_lpc %f", rx_phase_lpc);
/*
* Calibrate TX:
* 4 TX1B_A (LPC) -> RX1C_A (LPC) : BIST_LOOPBACK on B
*/
osc_plot_xcorr_revert(plot_xcorr_4ch, false);
trx_phase_rotation(cf_ad9361_hpc, 0.0);
__cal_switch_ports_enable_cb(4);
tx_phase_hpc = tune_trx_phase_offset(dev_dds_slave, &ret, cal_freq, cal_tone, -1.0 , 0.001, trx_phase_rotation);
if (ret < 0) {
printf("Failed to tune phase : %s:%i\n", __func__, __LINE__);
goto calibrate_fail;
}
set_calibration_progress(calib_progress, 0.88);
DBG("tx_phase_hpc %f", tx_phase_hpc);
trx_phase_rotation(cf_ad9361_hpc, rx_phase_hpc);
gtk_range_set_value(GTK_RANGE(GTK_WIDGET(gtk_builder_get_object(builder,
"tx_phase"))), scale_phase_0_360(tx_phase_hpc));
ret = 0;
set_calibration_progress(calib_progress, 1.0);
calibrate_fail:
osc_plot_xcorr_revert(plot_xcorr_4ch, false);
__cal_switch_ports_enable_cb(0);
if (in0 && in0_slave) {
iio_channel_attr_write(in0, "quadrature_tracking_en", "1");
iio_channel_attr_write(in0_slave, "quadrature_tracking_en", "1");
}
gdk_threads_enter();
reload_settings();
if (ret) {
create_blocking_popup(GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE,
"FMCOMMS5", "Calibration failed");
auto_calibrate = -1;
} else {
/* set completed flag for testing */
auto_calibrate = 1;
}
osc_plot_destroy(plot_xcorr_4ch);
if (button)
gtk_widget_show(GTK_WIDGET(button));
gdk_threads_leave();
/* reset progress bar */
gtk_progress_bar_set_fraction(calib_progress, 0.0);
gtk_progress_bar_set_text(calib_progress, "Calibration Progress");
/* Disable the channels that were enabled at the beginning of the calibration */
struct iio_device *iio_dev;
iio_dev = iio_context_find_device(get_context_from_osc(), CAP_DEVICE_ALT);
if (iio_dev && cap_device_channels_enabled) {
iio_channels_change_shadow_of_enabled(iio_dev, false);
cap_device_channels_enabled = false;
}
g_thread_exit(NULL);
}
static GtkWidget * fmcomms2_init(GtkWidget *notebook, const char *ini_fn)
{
GtkBuilder *builder;
GtkWidget *dds_container;
struct iio_channel *ch0, *ch1;
can_update_widgets = false;
ctx = osc_create_context();
if (!ctx)
return NULL;
dev = iio_context_find_device(ctx, PHY_DEVICE);
dds = iio_context_find_device(ctx, DDS_DEVICE);
cap = iio_context_find_device(ctx, CAP_DEVICE);
udc_rx = iio_context_find_device(ctx, UDC_RX_DEVICE);
udc_tx = iio_context_find_device(ctx, UDC_TX_DEVICE);
has_udc_driver = (udc_rx && udc_tx);
ch0 = iio_device_find_channel(dev, "voltage0", false);
ch1 = iio_device_find_channel(dev, "voltage1", false);
dac_tx_manager = dac_data_manager_new(dds, NULL, ctx);
if (!dac_tx_manager) {
iio_context_destroy(ctx);
return NULL;
}
const char *env_freq_span = getenv("OSC_UPDN_FREQ_SPAN");
const char *env_freq_mix_sign = getenv("OSC_UPDN_FREQ_MIX_SIGN");
if(!env_freq_span) {
updn_freq_span = 2;
} else {
errno = 0;
updn_freq_span = g_strtod(env_freq_span, NULL);
if (errno)
updn_freq_span = 2;
}
if(!env_freq_mix_sign) {
updn_freq_mix_sign = 1;
} else {
if (!strncmp(env_freq_mix_sign, "-", 1))
updn_freq_mix_sign = -1;
else
updn_freq_mix_sign = 1;
}
builder = gtk_builder_new();
nbook = GTK_NOTEBOOK(notebook);
if (!gtk_builder_add_from_file(builder, "fmcomms2.glade", NULL))
gtk_builder_add_from_file(builder, OSC_GLADE_FILE_PATH "fmcomms2.glade", NULL);
is_2rx_2tx = ch1 && iio_channel_find_attr(ch1, "hardwaregain");
fmcomms2_panel = GTK_WIDGET(gtk_builder_get_object(builder, "fmcomms2_panel"));
/* Global settings */
ensm_mode = GTK_WIDGET(gtk_builder_get_object(builder, "ensm_mode"));
ensm_mode_available = GTK_WIDGET(gtk_builder_get_object(builder, "ensm_mode_available"));
calib_mode = GTK_WIDGET(gtk_builder_get_object(builder, "calib_mode"));
calib_mode_available = GTK_WIDGET(gtk_builder_get_object(builder, "calib_mode_available"));
trx_rate_governor = GTK_WIDGET(gtk_builder_get_object(builder, "trx_rate_governor"));
trx_rate_governor_available = GTK_WIDGET(gtk_builder_get_object(builder, "trx_rate_governor_available"));
tx_path_rates = GTK_WIDGET(gtk_builder_get_object(builder, "label_tx_path"));
rx_path_rates = GTK_WIDGET(gtk_builder_get_object(builder, "label_rx_path"));
filter_fir_config = GTK_WIDGET(gtk_builder_get_object(builder, "filter_fir_config"));
enable_fir_filter_rx = GTK_WIDGET(gtk_builder_get_object(builder, "enable_fir_filter_rx"));
fir_filter_en_tx = GTK_WIDGET(gtk_builder_get_object(builder, "fir_filter_en_tx"));
enable_fir_filter_rx_tx = GTK_WIDGET(gtk_builder_get_object(builder, "enable_fir_filter_tx_rx"));
disable_all_fir_filters = GTK_WIDGET(gtk_builder_get_object(builder, "disable_all_fir_filters"));
up_down_converter = GTK_WIDGET(gtk_builder_get_object(builder, "checkbox_up_down_converter"));
section_toggle[SECTION_GLOBAL] = GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builder, "global_settings_toggle"));
section_setting[SECTION_GLOBAL] = GTK_WIDGET(gtk_builder_get_object(builder, "global_settings"));
section_toggle[SECTION_TX] = GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builder, "tx_toggle"));
section_setting[SECTION_TX] = GTK_WIDGET(gtk_builder_get_object(builder, "tx_settings"));
section_toggle[SECTION_RX] = GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builder, "rx_toggle"));
section_setting[SECTION_RX] = GTK_WIDGET(gtk_builder_get_object(builder, "rx_settings"));
section_toggle[SECTION_FPGA] = GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builder, "fpga_toggle"));
section_setting[SECTION_FPGA] = GTK_WIDGET(gtk_builder_get_object(builder, "fpga_settings"));
/* Receive Chain */
rf_port_select_rx = GTK_WIDGET(gtk_builder_get_object(builder, "rf_port_select_rx"));
rx_gain_control_rx1 = GTK_WIDGET(gtk_builder_get_object(builder, "gain_control_mode_rx1"));
rx_gain_control_rx2 = GTK_WIDGET(gtk_builder_get_object(builder, "gain_control_mode_rx2"));
rx_gain_control_modes_rx1 = GTK_WIDGET(gtk_builder_get_object(builder, "gain_control_mode_available_rx1"));
rx_gain_control_modes_rx2 = GTK_WIDGET(gtk_builder_get_object(builder, "gain_control_mode_available_rx2"));
rx1_rssi = GTK_WIDGET(gtk_builder_get_object(builder, "rssi_rx1"));
rx2_rssi = GTK_WIDGET(gtk_builder_get_object(builder, "rssi_rx2"));
rx_fastlock_profile = GTK_WIDGET(gtk_builder_get_object(builder, "rx_fastlock_profile"));
/* Transmit Chain */
rf_port_select_tx = GTK_WIDGET(gtk_builder_get_object(builder, "rf_port_select_tx"));
tx_fastlock_profile = GTK_WIDGET(gtk_builder_get_object(builder, "tx_fastlock_profile"));
tx1_rssi = GTK_WIDGET(gtk_builder_get_object(builder, "rssi_tx1"));
tx2_rssi = GTK_WIDGET(gtk_builder_get_object(builder, "rssi_tx2"));
dds_container = GTK_WIDGET(gtk_builder_get_object(builder, "dds_transmit_block"));
gtk_container_add(GTK_CONTAINER(dds_container), dac_data_manager_get_gui_container(dac_tx_manager));
gtk_widget_show_all(dds_container);
rx_phase_rotation[0] = GTK_WIDGET(gtk_builder_get_object(builder, "rx1_phase_rotation"));
rx_phase_rotation[1] = GTK_WIDGET(gtk_builder_get_object(builder, "rx2_phase_rotation"));
gtk_combo_box_set_active(GTK_COMBO_BOX(ensm_mode_available), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(trx_rate_governor_available), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(rx_gain_control_modes_rx1), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(rx_gain_control_modes_rx2), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(rf_port_select_rx), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(rf_port_select_tx), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(rx_fastlock_profile), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(tx_fastlock_profile), 0);
/* Set FMCOMMS2/3 max sampling freq -> 61.44MHz and FMCOMMS4 -> 122.88 */
GtkWidget *sfreq = GTK_WIDGET(gtk_builder_get_object(builder, "sampling_freq_tx"));
GtkAdjustment *sfreq_adj = gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(sfreq));
if (is_2rx_2tx)
gtk_adjustment_set_upper(sfreq_adj, 61.44);
else
gtk_adjustment_set_upper(sfreq_adj, 122.88);
/* Bind the IIO device files to the GUI widgets */
glb_widgets = widgets;
/* Global settings */
iio_combo_box_init(&glb_widgets[num_glb++],
dev, NULL, "ensm_mode", "ensm_mode_available",
ensm_mode_available, NULL);
iio_combo_box_init(&glb_widgets[num_glb++],
dev, NULL, "calib_mode", "calib_mode_available",
calib_mode_available, NULL);
iio_combo_box_init(&glb_widgets[num_glb++],
dev, NULL, "trx_rate_governor", "trx_rate_governor_available",
trx_rate_governor_available, NULL);
dcxo_coarse_num = num_glb;
iio_spin_button_int_init_from_builder(&glb_widgets[num_glb++],
dev, NULL, "dcxo_tune_coarse", builder, "dcxo_coarse_tune",
0);
dcxo_fine_num = num_glb;
iio_spin_button_int_init_from_builder(&glb_widgets[num_glb++],
dev, NULL, "dcxo_tune_fine", builder, "dcxo_fine_tune",
0);
rx_widgets = &glb_widgets[num_glb];
/* Receive Chain */
iio_combo_box_init(&rx_widgets[num_rx++],
dev, ch0, "gain_control_mode",
"gain_control_mode_available",
rx_gain_control_modes_rx1, NULL);
iio_combo_box_init(&rx_widgets[num_rx++],
dev, ch0, "rf_port_select",
"rf_port_select_available",
rf_port_select_rx, NULL);
if (is_2rx_2tx)
iio_combo_box_init(&rx_widgets[num_rx++],
dev, ch1, "gain_control_mode",
"gain_control_mode_available",
rx_gain_control_modes_rx2, NULL);
rx1_gain = num_rx;
iio_spin_button_int_init_from_builder(&rx_widgets[num_rx++],
dev, ch0, "hardwaregain", builder,
"hardware_gain_rx1", NULL);
if (is_2rx_2tx) {
rx2_gain = num_rx;
iio_spin_button_int_init_from_builder(&rx_widgets[num_rx++],
dev, ch1, "hardwaregain", builder,
"hardware_gain_rx2", NULL);
}
rx_sample_freq = num_rx;
iio_spin_button_int_init_from_builder(&rx_widgets[num_rx++],
dev, ch0, "sampling_frequency", builder,
"sampling_freq_rx", &mhz_scale);
iio_spin_button_add_progress(&rx_widgets[num_rx - 1]);
iio_spin_button_int_init_from_builder(&rx_widgets[num_rx++],
dev, ch0, "rf_bandwidth", builder, "rf_bandwidth_rx",
&mhz_scale);
iio_spin_button_add_progress(&rx_widgets[num_rx - 1]);
rx_lo = num_rx;
ch1 = iio_device_find_channel(dev, "altvoltage0", true);
if (iio_channel_find_attr(ch1, "frequency"))
freq_name = "frequency";
else
freq_name = "RX_LO_frequency";
iio_spin_button_s64_init_from_builder(&rx_widgets[num_rx++],
dev, ch1, freq_name, builder,
"rx_lo_freq", &mhz_scale);
iio_spin_button_add_progress(&rx_widgets[num_rx - 1]);
iio_toggle_button_init_from_builder(&rx_widgets[num_rx++],
dev, ch0, "quadrature_tracking_en", builder,
"quad", 0);
iio_toggle_button_init_from_builder(&rx_widgets[num_rx++],
dev, ch0, "rf_dc_offset_tracking_en", builder,
"rfdc", 0);
iio_toggle_button_init_from_builder(&rx_widgets[num_rx++],
dev, ch0, "bb_dc_offset_tracking_en", builder,
"bbdc", 0);
iio_spin_button_init_from_builder(&rx_widgets[num_rx],
dev, ch1, "calibphase",
builder, "rx1_phase_rotation", NULL);
iio_spin_button_add_progress(&rx_widgets[num_rx++]);
ch0 = iio_device_find_channel(dev, "altvoltage0", true);
if (iio_channel_find_attr(ch0, "fastlock_store"))
rx_fastlock_store_name = "fastlock_store";
else
rx_fastlock_store_name = "RX_LO_fastlock_store";
if (iio_channel_find_attr(ch0, "fastlock_recall"))
rx_fastlock_recall_name = "fastlock_recall";
else
rx_fastlock_recall_name = "RX_LO_fastlock_recall";
/* Transmit Chain */
tx_widgets = &rx_widgets[num_rx];
ch0 = iio_device_find_channel(dev, "voltage0", true);
if (is_2rx_2tx)
ch1 = iio_device_find_channel(dev, "voltage1", true);
tx_rssi_available = ch0 && iio_channel_find_attr(ch0, "rssi");
if (is_2rx_2tx)
tx_rssi_available = tx_rssi_available &&
(ch1 && iio_channel_find_attr(ch1, "rssi"));
iio_combo_box_init(&tx_widgets[num_tx++],
dev, ch0, "rf_port_select",
"rf_port_select_available",
rf_port_select_tx, NULL);
iio_spin_button_init_from_builder(&tx_widgets[num_tx++],
dev, ch0, "hardwaregain", builder,
"hardware_gain_tx1", &inv_scale);
if (is_2rx_2tx)
iio_spin_button_init_from_builder(&tx_widgets[num_tx++],
dev, ch1, "hardwaregain", builder,
"hardware_gain_tx2", &inv_scale);
tx_sample_freq = num_tx;
iio_spin_button_int_init_from_builder(&tx_widgets[num_tx++],
dev, ch0, "sampling_frequency", builder,
"sampling_freq_tx", &mhz_scale);
iio_spin_button_add_progress(&tx_widgets[num_tx - 1]);
iio_spin_button_int_init_from_builder(&tx_widgets[num_tx++],
dev, ch0, "rf_bandwidth", builder,
"rf_bandwidth_tx", &mhz_scale);
iio_spin_button_add_progress(&tx_widgets[num_tx - 1]);
tx_lo = num_tx;
ch1 = iio_device_find_channel(dev, "altvoltage1", true);
if (iio_channel_find_attr(ch1, "frequency"))
freq_name = "frequency";
else
freq_name = "TX_LO_frequency";
iio_spin_button_s64_init_from_builder(&tx_widgets[num_tx++],
dev, ch1, freq_name, builder, "tx_lo_freq", &mhz_scale);
iio_spin_button_add_progress(&tx_widgets[num_tx - 1]);
ch1 = iio_device_find_channel(dev, "altvoltage1", true);
if (ini_fn)
load_profile(ini_fn);
/* Update all widgets with current values */
printf("Updating widgets...\n");
update_widgets();
rx_freq_info_update();
printf("Updating FIR filter...\n");
filter_fir_update();
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(disable_all_fir_filters), true);
glb_settings_update_labels();
rssi_update_labels();
dac_data_manager_freq_widgets_range_update(dac_tx_manager,
get_gui_tx_sampling_freq() / 2.0);
dac_data_manager_update_iio_widgets(dac_tx_manager);
/* Widgets bindings */
g_builder_bind_property(builder, "rssi_tx1", "visible",
"label_rssi_tx1", "sensitive", G_BINDING_DEFAULT);
g_builder_bind_property(builder, "rssi_tx2", "visible",
"label_rssi_tx2", "sensitive", G_BINDING_DEFAULT);
/* Connect signals */
if (iio_channel_find_attr(ch1, "fastlock_store"))
tx_fastlock_store_name = "fastlock_store";
else
tx_fastlock_store_name = "TX_LO_fastlock_store";
if (iio_channel_find_attr(ch1, "fastlock_recall"))
tx_fastlock_recall_name = "fastlock_recall";
else
tx_fastlock_recall_name = "TX_LO_fastlock_recall";
g_builder_connect_signal(builder, "rx1_phase_rotation", "value-changed",
G_CALLBACK(rx_phase_rotation_set), (gpointer *)0);
g_builder_connect_signal(builder, "rx2_phase_rotation", "value-changed",
G_CALLBACK(rx_phase_rotation_set), (gpointer *)2);
g_builder_connect_signal(builder, "sampling_freq_tx", "value-changed",
G_CALLBACK(tx_sample_rate_changed), NULL);
g_builder_connect_signal(builder, "fmcomms2_settings_reload", "clicked",
G_CALLBACK(reload_button_clicked), NULL);
g_builder_connect_signal(builder, "filter_fir_config", "file-set",
G_CALLBACK(filter_fir_config_file_set_cb), NULL);
g_builder_connect_signal(builder, "rx_fastlock_store", "clicked",
G_CALLBACK(fastlock_clicked), (gpointer) 1);
g_builder_connect_signal(builder, "tx_fastlock_store", "clicked",
G_CALLBACK(fastlock_clicked), (gpointer) 2);
g_builder_connect_signal(builder, "rx_fastlock_recall", "clicked",
G_CALLBACK(fastlock_clicked), (gpointer) 3);
g_builder_connect_signal(builder, "tx_fastlock_recall", "clicked",
G_CALLBACK(fastlock_clicked), (gpointer) 4);
g_signal_connect_after(section_toggle[SECTION_GLOBAL], "clicked",
G_CALLBACK(hide_section_cb), section_setting[SECTION_GLOBAL]);
g_signal_connect_after(section_toggle[SECTION_TX], "clicked",
G_CALLBACK(hide_section_cb), section_setting[SECTION_TX]);
g_signal_connect_after(section_toggle[SECTION_RX], "clicked",
G_CALLBACK(hide_section_cb), section_setting[SECTION_RX]);
g_signal_connect_after(section_toggle[SECTION_FPGA], "clicked",
G_CALLBACK(hide_section_cb), section_setting[SECTION_FPGA]);
g_signal_connect_after(ensm_mode_available, "changed",
G_CALLBACK(glb_settings_update_labels), NULL);
g_signal_connect_after(calib_mode_available, "changed",
G_CALLBACK(glb_settings_update_labels), NULL);
g_signal_connect_after(trx_rate_governor_available, "changed",
G_CALLBACK(glb_settings_update_labels), NULL);
g_signal_connect_after(rx_gain_control_modes_rx1, "changed",
G_CALLBACK(glb_settings_update_labels), NULL);
g_signal_connect_after(rx_gain_control_modes_rx2, "changed",
G_CALLBACK(glb_settings_update_labels), NULL);
if (tx_rssi_available)
g_signal_connect(rf_port_select_rx, "changed",
G_CALLBACK(rf_port_select_rx_changed_cb), NULL);
g_signal_connect_after(enable_fir_filter_rx, "toggled",
G_CALLBACK(filter_fir_enable), NULL);
g_signal_connect_after(fir_filter_en_tx, "toggled",
G_CALLBACK(filter_fir_enable), NULL);
g_signal_connect_after(enable_fir_filter_rx_tx, "toggled",
G_CALLBACK(filter_fir_enable), NULL);
g_signal_connect_after(disable_all_fir_filters, "toggled",
G_CALLBACK(filter_fir_enable), NULL);
g_signal_connect(up_down_converter, "toggled",
G_CALLBACK(up_down_converter_toggled_cb), NULL);
make_widget_update_signal_based(glb_widgets, num_glb);
make_widget_update_signal_based(rx_widgets, num_rx);
make_widget_update_signal_based(tx_widgets, num_tx);
iio_spin_button_set_on_complete_function(&rx_widgets[rx_sample_freq],
sample_frequency_changed_cb, NULL);
iio_spin_button_set_on_complete_function(&tx_widgets[tx_sample_freq],
sample_frequency_changed_cb, NULL);
iio_spin_button_set_on_complete_function(&rx_widgets[rx_lo],
sample_frequency_changed_cb, NULL);
iio_spin_button_set_on_complete_function(&tx_widgets[tx_lo],
sample_frequency_changed_cb, NULL);
add_ch_setup_check_fct("cf-ad9361-lpc", channel_combination_check);
struct iio_device *adc_dev;
struct extra_dev_info *adc_info;
adc_dev = iio_context_find_device(get_context_from_osc(), CAP_DEVICE);
if (adc_dev) {
adc_info = iio_device_get_data(adc_dev);
if (adc_info)
adc_info->plugin_fft_corr = 20 * log10(1/sqrt(HANNING_ENBW));
}
block_diagram_init(builder, 2, "fmcomms2.svg", "AD_FMCOMM2S2_RevC.jpg");
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(filter_fir_config), OSC_FILTER_FILE_PATH);
dac_data_manager_set_buffer_chooser_current_folder(dac_tx_manager, OSC_WAVEFORM_FILE_PATH);
if (!is_2rx_2tx) {
gtk_widget_hide(GTK_WIDGET(gtk_builder_get_object(builder, "frame_rx2")));
gtk_widget_hide(GTK_WIDGET(gtk_builder_get_object(builder, "frame_fpga_rx2")));
gtk_widget_hide(GTK_WIDGET(gtk_builder_get_object(builder, "table_hw_gain_tx2")));
}
if (!tx_rssi_available) {
gtk_widget_hide(GTK_WIDGET(gtk_builder_get_object(builder, "rssi_tx1")));
gtk_widget_hide(GTK_WIDGET(gtk_builder_get_object(builder, "rssi_tx2")));
gtk_widget_hide(GTK_WIDGET(gtk_builder_get_object(builder, "label_rssi_tx1")));
gtk_widget_hide(GTK_WIDGET(gtk_builder_get_object(builder, "label_rssi_tx2")));
}
gtk_widget_set_visible(up_down_converter, has_udc_driver);
g_timeout_add(1000, (GSourceFunc) update_display, ctx);
can_update_widgets = true;
return fmcomms2_panel;
}
static bool AD7303_identify(void)
{
/* Use the OSC's IIO context just to detect the devices */
struct iio_context *osc_ctx = get_context_from_osc();
return !!iio_context_find_device(osc_ctx, "ad7303");
}
void connect_fillin(Dialogs *data)
{
char eprom_names[128];
unsigned char *raw_input_data = NULL;
FILE *efp, *fp;
GtkTextBuffer *buf;
GtkTextIter iter;
char text[256];
int num, i;
struct stat st;
/* flushes all open output streams */
fflush(NULL);
#if DEBUG
fp = popen("find ./ -name \"fru*.bin\"", "r");
#else
fp = popen("find /sys -name eeprom 2>/dev/null", "r");
#endif
if(fp == NULL) {
fprintf(stderr, "can't execute find\n");
return;
}
buf = gtk_text_buffer_new(NULL);
gtk_text_buffer_get_iter_at_offset(buf, &iter, 0);
num = 0;
while(fgets(eprom_names, sizeof(eprom_names), fp) != NULL){
num++;
/* strip trailing new lines */
if (eprom_names[strlen(eprom_names) - 1] == '\n')
eprom_names[strlen(eprom_names) - 1] = '\0';
/* FRU EEPROMS are exactly 256 */
if(stat(eprom_names, &st) !=0)
continue;
if(st.st_size != 256) {
printf("skipping %s (size == %d)\n", eprom_names, (int)st.st_size);
continue;
}
i = 0;
if (!is_eeprom_fru(eprom_names, buf, &iter)) {
/* Wasn't a FRU file, but is it a blank, writeable EEPROM? */
efp = fopen(eprom_names, "w+");
if (efp) {
i = fread(text, 1, 256, efp);
if (i == 256) {
for (i = 0; i < 256; i++){
if (!(text[i] == 0x00 || text[i] == 0xFF)) {
i = 0;
break;
}
}
}
fclose(efp);
/* dump the info into it */
if (i == 256) {
if (write_fru(eprom_names))
if(!is_eeprom_fru(eprom_names, buf, &iter))
i = 0;
}
} else {
int errsv = errno;
printf("Can't open %s in %s\n%s\n", eprom_names, __func__, strerror(errsv));
}
if (i == 0) {
sprintf(text, "No FRU information in %s\n", eprom_names);
gtk_text_buffer_insert(buf, &iter, text, -1);
}
}
free (raw_input_data);
}
pclose(fp);
if (!num) {
sprintf(text, "No eeprom files found in /sys/\n");
gtk_text_buffer_insert(buf, &iter, text, -1);
}
gtk_text_view_set_buffer(GTK_TEXT_VIEW(data->connect_fru), buf);
g_object_unref(buf);
buf = gtk_text_buffer_new(NULL);
gtk_text_buffer_get_iter_at_offset(buf, &iter, 0);
struct iio_context *ctx;
struct iio_device *dev;
ctx = get_context_from_osc();
if (!ctx)
return;
num = iio_context_get_devices_count(ctx);
if (num > 0) {
for (i = 0; i < num; i++) {
dev = iio_context_get_device(ctx, i);
sprintf(text, "%s\n", iio_device_get_name(dev));
gtk_text_buffer_insert(buf, &iter, text, -1);
}
} else {
sprintf(text, "No iio devices found\n");
gtk_text_buffer_insert(buf, &iter, text, -1);
}
gtk_text_view_set_buffer(GTK_TEXT_VIEW(data->connect_iio), buf);
g_object_unref(buf);
return;
}
