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]);
}
