static void rx_phase_rotation_set(GtkSpinButton *spinbutton, gpointer user_data) { glong offset = (glong) user_data; struct iio_channel *out0, *out1; gdouble val, phase; val = gtk_spin_button_get_value(spinbutton); phase = val * 2 * M_PI / 360.0; if (offset == 2) { out0 = iio_device_find_channel(cap, "voltage2", false); out1 = iio_device_find_channel(cap, "voltage3", false); } else { out0 = iio_device_find_channel(cap, "voltage0", false); out1 = iio_device_find_channel(cap, "voltage1", false); } if (out1 && out0) { iio_channel_attr_write_double(out0, "calibscale", (double) cos(phase)); iio_channel_attr_write_double(out0, "calibphase", (double) (-1 * sin(phase))); iio_channel_attr_write_double(out1, "calibscale", (double) cos(phase)); iio_channel_attr_write_double(out1, "calibphase", (double) sin(phase)); } }
static void fastlock_clicked(GtkButton *btn, gpointer data) { int profile; switch ((uintptr_t) data) { case 1: /* RX Store */ iio_widget_save(&rx_widgets[rx_lo]); profile = gtk_combo_box_get_active(GTK_COMBO_BOX(rx_fastlock_profile)); write_int(iio_device_find_channel(dev, "altvoltage0", true), rx_fastlock_store_name, profile); break; case 2: /* TX Store */ iio_widget_save(&tx_widgets[tx_lo]); profile = gtk_combo_box_get_active(GTK_COMBO_BOX(tx_fastlock_profile)); write_int(iio_device_find_channel(dev, "altvoltage1", true), tx_fastlock_store_name, profile); break; case 3: /* RX Recall */ profile = gtk_combo_box_get_active(GTK_COMBO_BOX(rx_fastlock_profile)); write_int(iio_device_find_channel(dev, "altvoltage0", true), rx_fastlock_recall_name, profile); iio_widget_update(&rx_widgets[rx_lo]); break; case 4: /* TX Recall */ profile = gtk_combo_box_get_active(GTK_COMBO_BOX(tx_fastlock_profile)); write_int(iio_device_find_channel(dev, "altvoltage1", true), tx_fastlock_recall_name, profile); iio_widget_update(&tx_widgets[tx_lo]); break; } }
/* finds AD9361 streaming IIO channels */ static bool get_ad9361_stream_ch(struct iio_context *ctx, enum iodev d, struct iio_device *dev, int chid, struct iio_channel **chn) { *chn = iio_device_find_channel(dev, get_ch_name("voltage", chid), d == TX); if (!*chn) *chn = iio_device_find_channel(dev, get_ch_name("altvoltage", chid), d == TX); return *chn != NULL; }
static void updn_converter_lo_freq_changed_cb(GtkSpinButton *button, int data) { struct iio_channel *ad9361_ch, *updn_ch; double target_freq, ad9361_lo, updn_pll, center_freq; int ret; if (data == UPDN_RX) { ad9361_ch = iio_device_find_channel(dev, "altvoltage0", true); updn_ch = iio_device_find_channel(udc_rx, "altvoltage0", true); center_freq = RX_CENTER_FREQ; } else if (data == UPDN_TX) { ad9361_ch = iio_device_find_channel(dev, "altvoltage1", true); updn_ch = iio_device_find_channel(udc_tx, "altvoltage0", true); center_freq = TX_CENTER_FREQ; } else { return; } target_freq = gtk_spin_button_get_value(button); split_target_lo_freq(target_freq, &updn_pll, &ad9361_lo, updn_freq_span, center_freq); ret = iio_channel_attr_write_longlong(ad9361_ch, freq_name, (long long)MHZ_TO_HZ(ad9361_lo)); if (ret < 0) fprintf(stderr,"Write to %s attribute of %s device: %s\n", freq_name, PHY_DEVICE, strerror(-ret)); ret = iio_channel_attr_write_longlong(updn_ch, "frequency", (long long)MHZ_TO_HZ(updn_pll)); if (ret < 0) fprintf(stderr,"Write to %s attribute of %s device: %s\n", "frequency", (UPDN_TX) ? UDC_TX_DEVICE : UDC_RX_DEVICE, strerror(-ret)); rx_freq_info_update(); }
static void rx_phase_rotation(struct iio_device *dev, gdouble val) { struct iio_channel *out0, *out1; gdouble phase; unsigned offset; DBG("%s %f\n", iio_device_get_name(dev), val); phase = val * 2 * M_PI / 360.0; /* Set both RX1 and RX2 */ for (offset = 0; offset <= 2; offset += 2) { if (offset == 2) { out0 = iio_device_find_channel(dev, "voltage2", false); out1 = iio_device_find_channel(dev, "voltage3", false); } else { out0 = iio_device_find_channel(dev, "voltage0", false); out1 = iio_device_find_channel(dev, "voltage1", false); } if (out1 && out0) { iio_channel_attr_write_double(out0, "calibscale", (double) cos(phase)); iio_channel_attr_write_double(out0, "calibphase", (double) (-1 * sin(phase))); iio_channel_attr_write_double(out1, "calibscale", (double) cos(phase)); iio_channel_attr_write_double(out1, "calibphase", (double) sin(phase)); } } }
static void rx_phase_rotation_update() { struct iio_channel *out[4]; gdouble val[4]; int i, d = 0; out[0] = iio_device_find_channel(cap, "voltage0", false); out[1] = iio_device_find_channel(cap, "voltage1", false); if (is_2rx_2tx) { out[2] = iio_device_find_channel(cap, "voltage2", false); out[3] = iio_device_find_channel(cap, "voltage3", false); d = 2; } for (i = 0; i <= d; i += 2) { iio_channel_attr_read_double(out[i], "calibscale", &val[0]); iio_channel_attr_read_double(out[i], "calibphase", &val[1]); iio_channel_attr_read_double(out[i + 1], "calibscale", &val[2]); iio_channel_attr_read_double(out[i + 1], "calibphase", &val[3]); val[0] = acos(val[0]) * 360.0 / (2.0 * M_PI); val[1] = asin(-1.0 * val[1]) * 360.0 / (2.0 * M_PI); val[2] = acos(val[2]) * 360.0 / (2.0 * M_PI); val[3] = asin(val[3]) * 360.0 / (2.0 * M_PI); if (val[1] < 0.0) val[0] *= -1.0; if (val[3] < 0.0) val[2] *= -1.0; if (val[1] < -90.0) val[0] = (val[0] * -1.0) - 180.0; if (val[3] < -90.0) val[0] = (val[0] * -1.0) - 180.0; if (fabs(val[0]) > 90.0) { if (val[1] < 0.0) val[1] = (val[1] * -1.0) - 180.0; else val[1] = 180 - val[1]; } if (fabs(val[2]) > 90.0) { if (val[3] < 0.0) val[3] = (val[3] * -1.0) - 180.0; else val[3] = 180 - val[3]; } if (round(val[0]) != round(val[1]) && round(val[0]) != round(val[2]) && round(val[0]) != round(val[3])) { printf("error calculating phase rotations\n"); val[0] = 0.0; } else val[0] = (val[0] + val[1] + val[2] + val[3]) / 4.0; gtk_spin_button_set_value(GTK_SPIN_BUTTON(rx_phase_rotation[i/2]), val[0]); } }
/* finds AD9361 phy IIO configuration channel with id chid */ static bool get_phy_chan(struct iio_context *ctx, enum iodev d, int chid, struct iio_channel **chn) { switch (d) { case RX: *chn = iio_device_find_channel(get_ad9361_phy(ctx), get_ch_name("voltage", chid), false); return *chn != NULL; case TX: *chn = iio_device_find_channel(get_ad9361_phy(ctx), get_ch_name("voltage", chid), true); return *chn != NULL; default: assert(0); return false; } }
/* finds AD9361 local oscillator IIO configuration channels */ static bool get_lo_chan(struct iio_context *ctx, enum iodev d, struct iio_channel **chn) { switch (d) { // LO chan is always output, i.e. true case RX: *chn = iio_device_find_channel(get_ad9361_phy(ctx), get_ch_name("altvoltage", 0), true); return *chn != NULL; case TX: *chn = iio_device_find_channel(get_ad9361_phy(ctx), get_ch_name("altvoltage", 1), true); return *chn != NULL; default: assert(0); return false; } }
static void mcs_cb (GtkWidget *widget, gpointer data) { unsigned step; struct iio_channel *tx_sample_master, *tx_sample_slave; long long tx_sample_master_freq, tx_sample_slave_freq; char temp[40], ensm_mode[40]; unsigned tmp; static int fix_slave_tune = 1; tx_sample_master = iio_device_find_channel(dev, "voltage0", true); tx_sample_slave = iio_device_find_channel(dev_slave, "voltage0", true); iio_channel_attr_read_longlong(tx_sample_master, "sampling_frequency", &tx_sample_master_freq); iio_channel_attr_read_longlong(tx_sample_slave, "sampling_frequency", &tx_sample_slave_freq); if (tx_sample_master_freq != tx_sample_slave_freq) { printf("tx_sample_master_freq != tx_sample_slave_freq\nUpdating...\n"); iio_channel_attr_write_longlong(tx_sample_slave, "sampling_frequency", tx_sample_master_freq); } if (fix_slave_tune) { iio_device_reg_read(dev, 0x6, &tmp); iio_device_reg_write(dev_slave, 0x6, tmp); iio_device_reg_read(dev, 0x7, &tmp); iio_device_reg_write(dev_slave, 0x7, tmp); fix_slave_tune = 0; } iio_device_attr_read(dev, "ensm_mode", ensm_mode, sizeof(ensm_mode)); /* Move the parts int ALERT for MCS */ iio_device_attr_write(dev, "ensm_mode", "alert"); iio_device_attr_write(dev_slave, "ensm_mode", "alert"); for (step = 1; step <= 5; step++) { sprintf(temp, "%d", step); /* Don't change the order here - the master controls the SYNC GPIO */ iio_device_debug_attr_write(dev_slave, "multichip_sync", temp); iio_device_debug_attr_write(dev, "multichip_sync", temp); sleep(0.1); } iio_device_attr_write(dev, "ensm_mode", ensm_mode); iio_device_attr_write(dev_slave, "ensm_mode", ensm_mode); #if 0 iio_device_debug_attr_write(dev, "multichip_sync", "6"); iio_device_debug_attr_write(dev_slave, "multichip_sync", "6"); #endif }
void filter_fir_enable(GtkToggleButton *button, gpointer data) { bool rx, tx, rxtx, disable; if (gtk_toggle_button_get_active(button)) return; rx = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (enable_fir_filter_rx)); tx = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (fir_filter_en_tx)); rxtx = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (enable_fir_filter_rx_tx)); disable = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (disable_all_fir_filters)); if (rxtx || disable) { iio_device_attr_write_bool(dev, "in_out_voltage_filter_fir_en", rxtx); } else { struct iio_channel *chn; if (rx) { chn = iio_device_find_channel(dev, "voltage0", true); if (chn) iio_channel_attr_write_bool(chn, "filter_fir_en", tx); chn = iio_device_find_channel(dev, "voltage0", false); if (chn) iio_channel_attr_write_bool(chn, "filter_fir_en", rx); } if (tx) { chn = iio_device_find_channel(dev, "voltage0", false); if (chn) iio_channel_attr_write_bool(chn, "filter_fir_en", rx); chn = iio_device_find_channel(dev, "voltage0", true); if (chn) iio_channel_attr_write_bool(chn, "filter_fir_en", tx); } } filter_fir_update(); glb_settings_update_labels(); update_widgets(); rx_freq_info_update(); }
int ad9361_set_trx_fir_enable(struct iio_device *dev, int enable) { int ret = iio_device_attr_write_bool(dev, "in_out_voltage_filter_fir_en", !!enable); if (ret < 0) ret = iio_channel_attr_write_bool(iio_device_find_channel(dev, "out", false), "voltage_filter_fir_en", !!enable); return ret; }
static void trx_phase_rotation(struct iio_device *dev, gdouble val) { struct iio_channel *out0, *out1; gdouble phase, vcos, vsin; unsigned offset; bool output = (dev == dev_dds_slave) || (dev == dev_dds_master); DBG("%s %f\n", iio_device_get_name(dev), val); phase = val * 2 * M_PI / 360.0; vcos = cos(phase); vsin = sin(phase); if (output) { gdouble corr; corr = 1.0 / fmax(fabs(sin(phase) + cos(phase)), fabs(cos(phase) - sin(phase))); vcos *= corr; vsin *= corr; } /* Set both RX1 and RX2 */ for (offset = 0; offset <= 2; offset += 2) { if (offset == 2) { out0 = iio_device_find_channel(dev, "voltage2", output); out1 = iio_device_find_channel(dev, "voltage3", output); } else { out0 = iio_device_find_channel(dev, "voltage0", output); out1 = iio_device_find_channel(dev, "voltage1", output); } if (out1 && out0) { iio_channel_attr_write_double(out0, "calibscale", (double) vcos); iio_channel_attr_write_double(out0, "calibphase", (double) (-1.0 * vsin)); iio_channel_attr_write_double(out1, "calibscale", (double) vcos); iio_channel_attr_write_double(out1, "calibphase", (double) vsin); } } }
static int buffer_open(unsigned int length) { struct iio_device *trigger = iio_context_find_device(ctx, "hrtimer-1"); struct iio_channel *ch0 = iio_device_find_channel(dev, "voltage0", true); iio_device_set_trigger(dev, trigger); iio_channel_enable(ch0); dac_buff = iio_device_create_buffer(dev, IIO_BUFFER_SIZE, false); return (dac_buff) ? 0 : 1; }
void filter_fir_update(void) { bool rx = false, tx = false, rxtx = false; struct iio_channel *chn; iio_device_attr_read_bool(dev, "in_out_voltage_filter_fir_en", &rxtx); chn = iio_device_find_channel(dev, "voltage0", false); if (chn) iio_channel_attr_read_bool(chn, "filter_fir_en", &rx); chn = iio_device_find_channel(dev, "voltage0", true); if (chn) iio_channel_attr_read_bool(chn, "filter_fir_en", &tx); if (rxtx) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (enable_fir_filter_rx_tx), rxtx); } else if (!rx && !tx) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (disable_all_fir_filters), true); } else { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (enable_fir_filter_rx), rx); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (fir_filter_en_tx), tx); } }
int ad9361_get_trx_fir_enable(struct iio_device *dev, int *enable) { bool value; int ret = iio_device_attr_read_bool(dev, "in_out_voltage_filter_fir_en", &value); if (ret < 0) ret = iio_channel_attr_read_bool(iio_device_find_channel(dev, "out", false), "voltage_filter_fir_en", &value); if (!ret) *enable = value; return ret; }
static void rssi_update_label(GtkWidget *label, bool is_tx) { char buf[1024]; int ret; /* don't update if it is hidden (to quiet down SPI) */ if (!gtk_widget_is_drawable(GTK_WIDGET(label))) return; ret = iio_channel_attr_read( iio_device_find_channel(dev, "voltage0", is_tx), "rssi", buf, sizeof(buf)); if (ret > 0) gtk_label_set_text(GTK_LABEL(label), buf); else gtk_label_set_text(GTK_LABEL(label), "<error>"); }
static int get_dds_channels(void) { struct iio_device *dev; int i, j; char name[16]; for (i = 0; i < 2; i++) { dev = i ? dev_dds_master : dev_dds_slave; for (j = 0; j < 8; j++) { snprintf(name, sizeof(name), "altvoltage%d", j); dds_out[i][j] = iio_device_find_channel(dev, name, true); if (!dds_out[i][j]) return -errno; } } return 0; }
int ad9361_set_bb_rate(struct iio_device *dev, unsigned long rate) { struct iio_channel *chan; long long current_rate; int dec, taps, ret, i, enable, len = 0; int16_t *fir; char *buf; if (rate <= 20000000UL) { dec = 4; taps = 128; fir = fir_128_4; } else if (rate <= 40000000UL) { dec = 2; fir = fir_128_2; taps = 128; } else if (rate <= 53333333UL) { dec = 2; fir = fir_96_2; taps = 96; } else { dec = 2; fir = fir_64_2; taps = 64; } chan = iio_device_find_channel(dev, "voltage0", true); if (chan == NULL) return -ENODEV; ret = iio_channel_attr_read_longlong(chan, "sampling_frequency", ¤t_rate); if (ret < 0) return ret; ret = ad9361_get_trx_fir_enable(dev, &enable); if (ret < 0) return ret; if (enable) { if (current_rate <= (25000000 / 12)) iio_channel_attr_write_longlong(chan, "sampling_frequency", 3000000); ret = ad9361_set_trx_fir_enable(dev, false); if (ret < 0) return ret; } buf = malloc(FIR_BUF_SIZE); if (!buf) return -ENOMEM; len += snprintf(buf + len, FIR_BUF_SIZE - len, "RX 3 GAIN -6 DEC %d\n", dec); len += snprintf(buf + len, FIR_BUF_SIZE - len, "TX 3 GAIN 0 INT %d\n", dec); for (i = 0; i < taps; i++) len += snprintf(buf + len, FIR_BUF_SIZE - len, "%d,%d\n", fir[i], fir[i]); len += snprintf(buf + len, FIR_BUF_SIZE - len, "\n"); ret = iio_device_attr_write_raw(dev, "filter_fir_config", buf, len); free (buf); if (ret < 0) return ret; if (rate <= (25000000 / 12)) { ret = ad9361_set_trx_fir_enable(dev, true); if (ret < 0) return ret; ret = iio_channel_attr_write_longlong(chan, "sampling_frequency", rate); if (ret < 0) return ret; } else { ret = iio_channel_attr_write_longlong(chan, "sampling_frequency", rate); if (ret < 0) return ret; ret = ad9361_set_trx_fir_enable(dev, true); if (ret < 0) return ret; } return 0; }
static GtkWidget * daq2_init(GtkWidget *notebook, const char *ini_fn) { GtkBuilder *builder; GtkWidget *daq2_panel; GtkWidget *dds_container; GtkTextBuffer *adc_buff, *dac_buff; struct iio_channel *ch0, *ch1; ctx = osc_create_context(); if (!ctx) return NULL; dac = iio_context_find_device(ctx, DAC_DEVICE); adc = iio_context_find_device(ctx, ADC_DEVICE); dac_tx_manager = dac_data_manager_new(dac, NULL, ctx); if (!dac_tx_manager) { osc_destroy_context(ctx); return NULL; } builder = gtk_builder_new(); if (!gtk_builder_add_from_file(builder, "daq2.glade", NULL)) gtk_builder_add_from_file(builder, OSC_GLADE_FILE_PATH "daq2.glade", NULL); daq2_panel = GTK_WIDGET(gtk_builder_get_object(builder, "daq2_panel")); 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); if (ini_fn) load_profile(ini_fn); /* Bind the IIO device files to the GUI widgets */ char attr_val[256]; long long val; double tx_sampling_freq; /* Rx Widgets */ ch0 = iio_device_find_channel(adc, "voltage0", false); ch1 = iio_device_find_channel(adc, "voltage1", false); if (iio_channel_attr_read_longlong(ch0, "sampling_frequency", &val) == 0) snprintf(attr_val, sizeof(attr_val), "%.2f", (double)(val / 1000000ul)); else snprintf(attr_val, sizeof(attr_val), "%s", "error"); adc_buff = gtk_text_buffer_new(NULL); gtk_text_buffer_set_text(adc_buff, attr_val, -1); gtk_text_view_set_buffer(GTK_TEXT_VIEW(gtk_builder_get_object(builder, "text_view_adc_freq")), adc_buff); iio_combo_box_init_from_builder(&rx_widgets[num_rx++], adc, ch0, "test_mode", "test_mode_available", builder, "ch0_test_mode", NULL); iio_combo_box_init_from_builder(&rx_widgets[num_rx++], adc, ch1, "test_mode", "test_mode_available", builder, "ch1_test_mode", NULL); /* Tx Widgets */ ch0 = iio_device_find_channel(dac, "altvoltage0", true); if (iio_channel_attr_read_longlong(ch0, "sampling_frequency", &val) == 0) { tx_sampling_freq = (double)(val / 1000000ul); snprintf(attr_val, sizeof(attr_val), "%.2f", tx_sampling_freq); } else { snprintf(attr_val, sizeof(attr_val), "%s", "error"); tx_sampling_freq = 0; } dac_buff = gtk_text_buffer_new(NULL); gtk_text_buffer_set_text(dac_buff, attr_val, -1); gtk_text_view_set_buffer(GTK_TEXT_VIEW(gtk_builder_get_object(builder, "text_view_dac_freq")), dac_buff); make_widget_update_signal_based(rx_widgets, num_rx); make_widget_update_signal_based(tx_widgets, num_tx); dac_data_manager_freq_widgets_range_update(dac_tx_manager, tx_sampling_freq / 2); tx_update_values(); rx_update_values(); dac_data_manager_update_iio_widgets(dac_tx_manager); dac_data_manager_set_buffer_chooser_current_folder(dac_tx_manager, OSC_WAVEFORM_FILE_PATH); block_diagram_init(builder, 4, "AD9680_11752-001.svg", "AD9144_11675-002.svg", "AD9523_09278-020.svg", "AD-FMCDAQ2-EBZ.jpg"); can_update_widgets = true; return daq2_panel; }
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 void __cal_switch_ports_enable_cb (unsigned val) { unsigned lp_slave, lp_master, sw; char *rx_port, *tx_port; /* * 0 DISABLE * 1 TX1B_B (HPC) -> RX1C_B (HPC) : BIST_LOOPBACK on A * 2 TX1B_A (LPC) -> RX1C_B (HPC) : BIST_LOOPBACK on A * 3 TX1B_B (HPC) -> RX1C_A (LPC) : BIST_LOOPBACK on B * 4 TX1B_A (LPC) -> RX1C_A (LPC) : BIST_LOOPBACK on B * */ switch (val) { default: case 0: lp_slave = 0; lp_master = 0; sw = 0; tx_port = "A"; rx_port = "A_BALANCED"; break; case 1: case 2: lp_slave = 0; lp_master = 1; sw = val - 1; tx_port = "B"; rx_port = "C_BALANCED"; break; case 3: case 4: lp_slave = 1; lp_master = 0; sw = val - 1; tx_port = "B"; rx_port = "C_BALANCED"; break; } #if 0 iio_device_debug_attr_write_bool(dev, "loopback", lp_master); iio_device_debug_attr_write_bool(dev_slave, "loopback", lp_slave); #else near_end_loopback_ctrl(0, lp_slave); /* HPC */ near_end_loopback_ctrl(1, lp_slave); /* HPC */ near_end_loopback_ctrl(4, lp_master); /* LPC */ near_end_loopback_ctrl(5, lp_master); /* LPC */ #endif iio_device_debug_attr_write_longlong(dev, "calibration_switch_control", sw); iio_channel_attr_write(iio_device_find_channel(dev, "voltage0", false), "rf_port_select", rx_port); iio_channel_attr_write(iio_device_find_channel(dev, "voltage0", true), "rf_port_select", tx_port); if (dev_slave) { iio_channel_attr_write(iio_device_find_channel(dev_slave, "voltage0", false), "rf_port_select", rx_port); iio_channel_attr_write(iio_device_find_channel(dev_slave, "voltage0", true), "rf_port_select", tx_port); } return; }
static void calibrate (gpointer button) { GtkProgressBar *calib_progress; double rx_phase_lpc, rx_phase_hpc, tx_phase_hpc; struct iio_channel *in0 = NULL, *in0_slave = NULL; 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; auto_calibrate = -1; goto calibrate_fail; } if (!cf_ad9361_lpc || !cf_ad9361_hpc) { printf("could not find capture cores\n"); ret = -ENODEV; auto_calibrate = -1; goto calibrate_fail; } if (!dev_dds_master || !dev_dds_slave) { printf("could not find dds cores\n"); ret = -ENODEV; auto_calibrate = -1; 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"); auto_calibrate = -1; 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 %u cal_freq %u 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(); iio_channel_attr_write(in0, "in_voltage_quadrature_tracking_en", "0"); iio_channel_attr_write(in0_slave, "in_voltage_quadrature_tracking_en", "0"); 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\n"); auto_calibrate = -1; 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\n"); auto_calibrate = -1; 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\n"); auto_calibrate = -1; 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, "in_voltage_quadrature_tracking_en", "1"); iio_channel_attr_write(in0_slave, "in_voltage_quadrature_tracking_en", "1"); } gdk_threads_enter(); reload_settings(); create_blocking_popup(GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE, "FMCOMMS5", "Calibration finished %s", ret ? "with Error" : "Successfully"); auto_calibrate = 1; osc_plot_destroy(plot_xcorr_4ch); if (button) gtk_widget_show(GTK_WIDGET(button)); gdk_threads_leave(); 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 GtkWidget * AD7303_init(GtkWidget *notebook, const char *ini_fn) { struct iio_channel *ch0, *ch1; GtkBuilder *builder; GtkWidget *AD7303_panel; GtkWidget *table; ctx = osc_create_context(); if (!ctx) return NULL; thread_ctx = osc_create_context(); dev = iio_context_find_device(thread_ctx, "ad7303"); builder = gtk_builder_new(); if (!gtk_builder_add_from_file(builder, "AD7303.glade", NULL)) gtk_builder_add_from_file(builder, OSC_GLADE_FILE_PATH "AD7303.glade", NULL); AD7303_panel = GTK_WIDGET(gtk_builder_get_object(builder, "tablePanelAD7303")); btn_sine = GTK_WIDGET(gtk_builder_get_object(builder, "togBtnSine")); btn_square = GTK_WIDGET(gtk_builder_get_object(builder, "togBtnSquare")); btn_triangle = GTK_WIDGET(gtk_builder_get_object(builder, "togBtnTriangle")); btn_sawtooth = GTK_WIDGET(gtk_builder_get_object(builder, "togBtnSawth")); scale_ampl = GTK_WIDGET(gtk_builder_get_object(builder, "vscaleAmpl")); scale_offset = GTK_WIDGET(gtk_builder_get_object(builder, "vscaleOff")); scale_freq = GTK_WIDGET(gtk_builder_get_object(builder, "vscaleFreq")); radio_single_val = GTK_WIDGET(gtk_builder_get_object(builder, "radioSingleVal")); radio_waveform = GTK_WIDGET(gtk_builder_get_object(builder, "radioWaveform")); preview_graph = GTK_WIDGET(gtk_builder_get_object(builder, "vboxDatabox")); ch0 = iio_device_find_channel(dev, "voltage0", true); ch1 = iio_device_find_channel(dev, "voltage1", true); /* Bind the IIO device files to the GUI widgets */ iio_spin_button_init_from_builder(&tx_widgets[num_tx++], dev, ch0, "raw", builder, "spinbuttonValueCh0", NULL); iio_spin_button_init_from_builder(&tx_widgets[num_tx++], dev, ch1, "raw", builder, "spinbuttonValueCh1", NULL); iio_toggle_button_init_from_builder(&tx_widgets[num_tx++], dev, ch0, "powerdown", builder, "checkbuttonPwrDwn0", 0); iio_toggle_button_init_from_builder(&tx_widgets[num_tx++], dev, ch1, "powerdown", builder, "checkbuttonPwrDwn1", 0); g_signal_connect(btn_sine, "toggled", G_CALLBACK(wave_param_changed), NULL); g_signal_connect(btn_square, "toggled", G_CALLBACK(wave_param_changed), NULL); g_signal_connect(btn_triangle, "toggled", G_CALLBACK(wave_param_changed), NULL); g_signal_connect(btn_sawtooth, "toggled", G_CALLBACK(wave_param_changed), NULL); g_signal_connect(scale_ampl, "value-changed", G_CALLBACK(wave_param_changed), NULL); g_signal_connect(scale_offset, "value-changed", G_CALLBACK(wave_param_changed), NULL); g_signal_connect(scale_freq, "value-changed", G_CALLBACK(wave_param_changed), NULL); g_builder_connect_signal(builder, "buttonSave", "clicked", G_CALLBACK(save_button_clicked), NULL); /* Create a GtkDatabox widget */ gtk_databox_create_box_with_scrollbars_and_rulers(&databox, &table, TRUE, TRUE, TRUE, TRUE); gtk_container_add(GTK_CONTAINER(preview_graph), table); gtk_widget_modify_bg(databox, GTK_STATE_NORMAL, &color_background); gtk_widget_set_size_request(table, 450, 300); gtk_widget_show_all(AD7303_panel); tx_update_values(); rx_update_values(); return AD7303_panel; }
static void glb_settings_update_labels(void) { float rates[6]; char tmp[160], buf[1024]; ssize_t ret; ret = iio_device_attr_read(dev, "ensm_mode", buf, sizeof(buf)); if (ret > 0) gtk_label_set_text(GTK_LABEL(ensm_mode), buf); else gtk_label_set_text(GTK_LABEL(ensm_mode), "<error>"); ret = iio_device_attr_read(dev, "calib_mode", buf, sizeof(buf)); if (ret > 0) gtk_label_set_text(GTK_LABEL(calib_mode), buf); else gtk_label_set_text(GTK_LABEL(calib_mode), "<error>"); ret = iio_device_attr_read(dev, "trx_rate_governor", buf, sizeof(buf)); if (ret > 0) gtk_label_set_text(GTK_LABEL(trx_rate_governor), buf); else gtk_label_set_text(GTK_LABEL(trx_rate_governor), "<error>"); ret = iio_channel_attr_read( iio_device_find_channel(dev, "voltage0", false), "gain_control_mode", buf, sizeof(buf)); if (ret > 0) gtk_label_set_text(GTK_LABEL(rx_gain_control_rx1), buf); else gtk_label_set_text(GTK_LABEL(rx_gain_control_rx1), "<error>"); if (is_2rx_2tx) { ret = iio_channel_attr_read( iio_device_find_channel(dev, "voltage1", false), "gain_control_mode", buf, sizeof(buf)); if (ret > 0) gtk_label_set_text(GTK_LABEL(rx_gain_control_rx2), buf); else gtk_label_set_text(GTK_LABEL(rx_gain_control_rx2), "<error>"); } ret = iio_device_attr_read(dev, "rx_path_rates", buf, sizeof(buf)); if (ret > 0) { sscanf(buf, "BBPLL:%f ADC:%f R2:%f R1:%f RF:%f RXSAMP:%f", &rates[0], &rates[1], &rates[2], &rates[3], &rates[4], &rates[5]); sprintf(tmp, "BBPLL: %4.3f ADC: %4.3f R2: %4.3f R1: %4.3f RF: %4.3f RXSAMP: %4.3f", rates[0] / 1e6, rates[1] / 1e6, rates[2] / 1e6, rates[3] / 1e6, rates[4] / 1e6, rates[5] / 1e6); gtk_label_set_text(GTK_LABEL(rx_path_rates), tmp); } else { gtk_label_set_text(GTK_LABEL(rx_path_rates), "<error>"); } ret = iio_device_attr_read(dev, "tx_path_rates", buf, sizeof(buf)); if (ret > 0) { sscanf(buf, "BBPLL:%f DAC:%f T2:%f T1:%f TF:%f TXSAMP:%f", &rates[0], &rates[1], &rates[2], &rates[3], &rates[4], &rates[5]); sprintf(tmp, "BBPLL: %4.3f DAC: %4.3f T2: %4.3f T1: %4.3f TF: %4.3f TXSAMP: %4.3f", rates[0] / 1e6, rates[1] / 1e6, rates[2] / 1e6, rates[3] / 1e6, rates[4] / 1e6, rates[5] / 1e6); gtk_label_set_text(GTK_LABEL(tx_path_rates), tmp); } else { gtk_label_set_text(GTK_LABEL(tx_path_rates), "<error>"); } iio_widget_update(&rx_widgets[rx1_gain]); if (is_2rx_2tx) iio_widget_update(&rx_widgets[rx2_gain]); }