static dir_profile_t *get_profile(const char *profile_name)
{
dir_profile_t *profile = NULL;
switch_mutex_lock(globals.mutex);
if (!(profile = switch_core_hash_find(globals.profile_hash, profile_name))) {
profile = load_profile(profile_name);
}
if (profile) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "[%s] rwlock\n", profile->name);
switch_thread_rwlock_rdlock(profile->rwlock);
}
switch_mutex_unlock(globals.mutex);
return profile;
}
int main(int argc, char *argv[])
{
char ch;
char pathname[256];
if (1 == argc) {
print_usage();
return -1;
} else {
while (-1 != (ch = getopt(argc, argv, "c:hv"))) {
switch (ch) {
case 'c':
snprintf(pathname, sizeof(pathname), "%s", optarg);
break;
case 'h':
print_usage();
return 0;
break;
case 'v':
fprintf(stderr, "%s\n", VERSION_INFO);
return 0;
break;
default:
return -1;
break;
}
}
}
if (-1 == load_profile(pathname))
return -1;
print_param(&g_confvalue);
if (-1 == create_dir(g_confvalue.log_path, 0644))
return -1;
snprintf(g_log_path, sizeof(g_log_path), "%s", g_confvalue.log_path);
//process();
daemon_server();
return 0;
}
int main(int argc, char **argv)
{
if (argc < 2) {
printf("Usage: ./interpolation <filename>\n");
return -1;
}
char *filename;
filename = argv[1];
struct profile p;
int i;
strncpy(p.filename, filename, 128);
load_profile(&p);
printf("-----------\n");
for (i=0; i<=p.samples_no; i++)
printf("%d %d\n", i, p.samples[i]);
printf("-----------\n");
return 0;
}
/* reload the profile, adding read/write file specified by fn if it is not
* NULL.
*/
static int
reload_profile(virSecurityManagerPtr mgr,
virDomainDefPtr def,
const char *fn,
bool append)
{
int rc = -1;
char *profile_name = NULL;
virSecurityLabelDefPtr secdef = virDomainDefGetSecurityLabelDef(
def, SECURITY_APPARMOR_NAME);
if (!secdef)
return rc;
if (secdef->norelabel)
return 0;
if ((profile_name = get_profile_name(def)) == NULL)
return rc;
/* Update the profile only if it is loaded */
if (profile_loaded(secdef->imagelabel) >= 0) {
if (load_profile(mgr, secdef->imagelabel, def, fn, append) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("cannot update AppArmor profile "
"\'%s\'"),
secdef->imagelabel);
goto cleanup;
}
}
rc = 0;
cleanup:
VIR_FREE(profile_name);
return rc;
}
static HRESULT WINAPI ColorContext_InitializeFromFilename(IWICColorContext *iface,
LPCWSTR wzFilename)
{
ColorContext *This = impl_from_IWICColorContext(iface);
BYTE *profile;
UINT len;
HRESULT hr;
TRACE("(%p,%s)\n", iface, debugstr_w(wzFilename));
if (This->type != WICColorContextUninitialized && This->type != WICColorContextProfile)
return WINCODEC_ERR_WRONGSTATE;
if (!wzFilename) return E_INVALIDARG;
hr = load_profile(wzFilename, &profile, &len);
if (FAILED(hr)) return hr;
HeapFree(GetProcessHeap(), 0, This->profile);
This->profile = profile;
This->profile_len = len;
This->type = WICColorContextProfile;
return S_OK;
}
static GtkWidget * fmcomms2adv_init(GtkWidget *notebook, const char *ini_fn)
{
GtkWidget *fmcomms2adv_panel;
ctx = osc_create_context();
if (!ctx)
return NULL;
dev = iio_context_find_device(ctx, PHY_DEVICE);
dev_slave = iio_context_find_device(ctx, PHY_SLAVE_DEVICE);
if (dev_slave) {
cf_ad9361_lpc = iio_context_find_device(ctx, CAP_DEVICE_ALT);
cf_ad9361_hpc = iio_context_find_device(ctx, CAP_SLAVE_DEVICE);
dev_dds_master = iio_context_find_device(ctx, DDS_DEVICE);
dev_dds_slave = iio_context_find_device(ctx, DDS_SLAVE_DEVICE);
if (get_dds_channels())
return NULL;
}
if (ini_fn) {
load_profile(ini_fn);
calibrate_from_ini(ini_fn);
}
builder = gtk_builder_new();
nbook = GTK_NOTEBOOK(notebook);
if (!gtk_builder_add_from_file(builder, "fmcomms2_adv.glade", NULL))
gtk_builder_add_from_file(builder, OSC_GLADE_FILE_PATH "fmcomms2_adv.glade", NULL);
fmcomms2adv_panel = GTK_WIDGET(gtk_builder_get_object(builder, "fmcomms2adv_panel"));
connect_widgets(builder);
gtk_combo_box_set_active(GTK_COMBO_BOX(
GTK_WIDGET(gtk_builder_get_object(builder, "bist_tone"))), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(
GTK_WIDGET(gtk_builder_get_object(builder, "bist_tone_frequency"))), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(
GTK_WIDGET(gtk_builder_get_object(builder, "tone_level"))), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(
GTK_WIDGET(gtk_builder_get_object(builder, "bist_prbs"))), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(
GTK_WIDGET(gtk_builder_get_object(builder, "loopback"))), 0);
g_builder_connect_signal(builder, "bist_tone", "changed",
G_CALLBACK(bist_tone_cb), builder);
g_builder_connect_signal(builder, "bist_tone_frequency", "changed",
G_CALLBACK(bist_tone_cb), builder);
g_builder_connect_signal(builder, "tone_level", "changed",
G_CALLBACK(bist_tone_cb), builder);
g_builder_connect_signal(builder, "c2q", "toggled",
G_CALLBACK(bist_tone_cb), builder);
g_builder_connect_signal(builder, "c1q", "toggled",
G_CALLBACK(bist_tone_cb), builder);
g_builder_connect_signal(builder, "c2i", "toggled",
G_CALLBACK(bist_tone_cb), builder);
g_builder_connect_signal(builder, "c1i", "toggled",
G_CALLBACK(bist_tone_cb), builder);
if (dev_slave) {
g_builder_connect_signal(builder, "mcs_sync", "clicked",
G_CALLBACK(mcs_cb), builder);
gtk_combo_box_set_active(
GTK_COMBO_BOX(gtk_builder_get_object(builder, "calibration_switch_control")), 0);
__cal_switch_ports_enable_cb(0);
g_builder_connect_signal(builder, "calibration_switch_control", "changed",
G_CALLBACK(cal_switch_ports_enable_cb), builder);
g_builder_connect_signal(builder, "tx_phase", "value-changed",
G_CALLBACK(tx_phase_hscale_value_changed), 0);
g_builder_connect_signal(builder, "do_fmcomms5_cal", "clicked",
G_CALLBACK(do_calibration), gtk_builder_get_object(builder, "do_fmcomms5_cal"));
g_builder_connect_signal(builder, "undo_fmcomms5_cal", "clicked",
G_CALLBACK(undo_calibration), NULL);
g_object_bind_property(gtk_builder_get_object(builder, "silent_calibration"), "active",
gtk_builder_get_object(builder, "progress_calibration"), "visible", G_BINDING_DEFAULT);
} else {
gtk_widget_hide(GTK_WIDGET(gtk_builder_get_object(builder, "mcs_sync")));
gtk_widget_hide(GTK_WIDGET(gtk_builder_get_object(builder, "frame_fmcomms5")));
}
g_builder_connect_signal(builder, "notebook1", "switch-page",
G_CALLBACK(change_page_cb),
GTK_WIDGET(gtk_builder_get_object(builder, "initialize")));
return fmcomms2adv_panel;
}
/*----------------------------------------------------------------------------
* Edit level properties.
*----------------------------------------------------------------------------*/
int
properties(char *path)
{
int i;
int ret = 1;
int keep_going = 1;
char *path_end = path + strlen(path);
SDL_Surface *tmp;
SDL_Rect rect;
SDL_Event event;
SDL_EnableUNICODE(1);
SDL_BlitSurface(media.surface_frame, NULL, media.canvas, NULL);
sepia_surface(media.canvas);
while (keep_going) {
SDL_BlitSurface(media.surface_properties, NULL, media.canvas, NULL);
if ((tmp = TTF_RenderUTF8_Blended(media.font_input, path, color_black))) {
rect.x = 195;
rect.y = 315;
SDL_BlitSurface(tmp, NULL, media.canvas, &rect);
SDL_FreeSurface(tmp);
}
if ((tmp =
TTF_RenderUTF8_Blended(media.font_button, lang.menusave[0],
color_marker))) {
rect.x = 220 - tmp->w / 2;
rect.y = 540 - tmp->h / 2;
SDL_BlitSurface(tmp, NULL, media.canvas, &rect);
SDL_FreeSurface(tmp);
}
if ((tmp =
TTF_RenderUTF8_Blended(media.font_button, lang.menusave[1],
color_marker))) {
rect.x = 580 - tmp->w / 2;
rect.y = 540 - tmp->h / 2;
SDL_BlitSurface(tmp, NULL, media.canvas, &rect);
SDL_FreeSurface(tmp);
}
rect.x = 580 - 360 * ret - media.surface_circle->w / 2;
rect.y = 540 - media.surface_circle->h / 2;
SDL_BlitSurface(media.surface_circle, NULL, media.canvas, &rect);
while (SDL_PollEvent(&event) != 0) {
switch (event.type) {
case SDL_MOUSEMOTION:
if (abs(event.motion.y - 540) < 50) {
ret =
abs(event.motion.x - 220) <
50 ? 1 : abs(event.motion.x - 580) < 50 ? 0 : ret;
}
break;
case SDL_MOUSEBUTTONDOWN:
if (abs(event.motion.y - 540) < 50) {
i = abs(event.motion.x - 220) <
50 ? 1 : abs(event.motion.x - 580) < 50 ? 0 : -1;
if (i >= 0) {
keep_going = 0;
ret = i;
}
}
break;
case SDL_KEYDOWN:
switch (event.key.keysym.sym) {
case SDLK_ESCAPE:
ret = 0;
keep_going = 0;
break;
case SDLK_RETURN:
if (ret == 0 || path_end != path) {
Mix_PlayChannel(2, media.chunk_keystroke, 0);
load_profile(path);
keep_going = 0;
}
break;
case SDLK_BACKSPACE:
if (path_end != path) {
Mix_PlayChannel(2, media.chunk_keystroke, 0);
--path_end;
*path_end = 0;
}
break;
case SDLK_LEFT:
case SDLK_RIGHT:
ret ^= 1;
break;
default:
if (path_end != path + PATH_LEN &&
isprint(event.key.keysym.unicode)) {
Mix_PlayChannel(2, media.chunk_keystroke, 0);
*path_end = event.key.keysym.unicode;
++path_end;
*path_end = 0;
}
break;
}
break;
case SDL_QUIT:
exit(0);
default:
break;
}
}
media_sync();
}
SDL_EnableUNICODE(0);
return ret;
}
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;
}
//simple demo:
int main (int argc, char *argv[])
{
//issue
printf("\n -=[ Hello, and welcome to RollCageX version %s ]=-\n\n", VERSION);
printf(" Copyright (C) 2009, This program comes with ABSOLUTELY NO WARRANTY; see\n \"license.txt\" for details\n\n");
printf(" This is free software, and you are welcome to redistribute it and/or modify\n it under the GNU General Public License as published by the Free Software\n Foundation, version 3 or (at your option) later\n\n");
printf("= Credits (nicknames refers to usernames on the gorcx.net forum):\n");
printf(" \"MaAkaJon\"\t\tproject creator\n");
printf(" \"Soul Slinger\"\tcoder (created this and the earlier versions)\n");
printf(" All of you on the planetrollcage.com and gorcx.net forums!\n\n");
printf("* Projects that made RCX possible:\n");
printf(" GNU\t\t\t\tdefines computer freedom itself... :-)\n");
printf(" Simple DirectMedia Layer\twindow handling, input/outputs\n");
printf(" Open Dynamics Engine\trigid body dynamics\n");
printf("= End of credits\n\n");
printf(" Default controls (can be changed in profile):\n");
printf(" > Arrow keys: Steering and throttling\n");
printf(" > Spacebar: Drifting break\n");
printf(" > Left Alt: Soft breaks\n");
printf(" > Q and E: change camera distance along Z axis\n");
printf(" > A and D: change camera distance along X axis\n");
printf(" > W and S: change camera distance along Y axis\n");
printf(" > F1 to F4: change camera settings\n");
printf(" > F5: spawn box\n");
printf(" > F6: spawn box (10s above ground)\n\n");
//end of issue
if (argc != 1)
printf("(Passing arguments - not supported)\n\n");
//printlog needs internal.verbosity, set it to default value
printf("(verbosity level is assumed \"1\" until read from internal conf)\n");
internal.verbosity = 1;
//check if program was called with another pwd (got '/' in "name")
int count;
for (count = strlen(argv[0]); count != -1; --count)
if (argv[0][count] == '/')
{
char pwd[count+2]; //1 for \0 and 1 for [0]
strncpy (pwd, argv[0], count+1);
pwd[count+1] = '\0';
printf ("(changing pwd: %s)\n", pwd);
chdir (pwd);
break;
}
if (load_conf ((char *)"data/internal.conf", (char *)&internal, internal_index))
return -1;
if (graphics_init())
return -1;
//<insert menu here>
profile *prof = load_profile ((char *)"data/profiles/default");
if (!prof)
return -1;
venom = load_car((char *)"data/teams/Nemesis/cars/Venom");
if (!venom)
emergency_quit();
prof->car = venom;
camera.car = venom;
//menu done, race selected, starting race...
if (physics_init())
{
graphics_quit();
return -1;
}
if (load_track((char *)"data/worlds/Sandbox/tracks/Box"))
emergency_quit();
//load box for online spawning
box = load_object((char *)"data/objects/misc/box");
sphere = load_object((char *)"data/objects/misc/sphere");
if (!box)
emergency_quit();
spawn_car (venom, track.start[0], track.start[1], track.start[2]);
focused_car = venom;
//single-thread function
//WARNING: Don't run the game constantly for more than around 49 days!
//(or the realtime will wrap, and the timing solution will go crazy)
Uint32 simtime = SDL_GetTicks(); //set simulated time to realtime
Uint32 realtime; //real time (with possible delay since last update)
Uint32 stepsize_ms = internal.stepsize*1000+0.0001; //calculate stepsize from s to ms (append 0.0001 for correct conversion)
printlog (0, "\n-> Starting Race\n");
runlevel = running;
while (runlevel == running)
{
event_step(stepsize_ms); //always check for events
physics_step();
simtime += stepsize_ms;
//if realtime is larger than simtime (and graphics threshold)
if (SDL_GetTicks()+internal.threshold > simtime)
{
printlog(2, "\nWarning: simtime less than realtime (to low stepsize), dropping frame..\n\n");
++stepsize_warnings;
}
else //we got time left to draw frame on
{
graphics_step(stepsize_ms);
realtime = SDL_GetTicks();
if (simtime > realtime)
{
SDL_Delay (simtime - realtime);
}
else
{
printlog(2, "\nWarning: (not sleeping, realtime became to high (to low treshold?))\n");
++threshold_warnings;
}
}
}
printlog(0, "-> Race done!\n");
free_all();
physics_quit();
//race done
//<insert menu here>
//menu done, quit selected, ending graphics and terminating program
graphics_quit();
printlog(0, "\n<-- Some basic info: -->\n");
printlog(0, "(does not interest most people)\n");
printlog(0, "Race time (ms): %i\n", simtime);
printlog(0, "Stepsize-to-low (framedrop) warnings: %i\n", stepsize_warnings);
printlog(0, "Graphics-threshold-to-low warnings: %i\n", threshold_warnings);
printlog(0, "\nBye!\n\n");
return 0;
}
static switch_status_t load_config(switch_bool_t reload)
{
switch_status_t status = SWITCH_STATUS_SUCCESS;
switch_xml_t cfg, xml = NULL, settings, param, x_profiles, x_profile;
switch_cache_db_handle_t *dbh = NULL;
if (!(xml = switch_xml_open_cfg(global_cf, &cfg, NULL))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Open of %s failed\n", global_cf);
return SWITCH_STATUS_TERM;
}
switch_mutex_lock(globals.mutex);
if ((settings = switch_xml_child(cfg, "settings"))) {
for (param = switch_xml_child(settings, "param"); param; param = param->next) {
char *var = (char *) switch_xml_attr_soft(param, "name");
char *val = (char *) switch_xml_attr_soft(param, "value");
if (!strcasecmp(var, "odbc-dsn") && !zstr(val)) {
if (switch_odbc_available()) {
switch_set_string(globals.odbc_dsn, val);
if ((globals.odbc_user = strchr(globals.odbc_dsn, ':'))) {
*globals.odbc_user++ = '\0';
if ((globals.odbc_pass = strchr(globals.odbc_user, ':'))) {
*globals.odbc_pass++ = '\0';
}
}
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ODBC IS NOT AVAILABLE!\n");
}
} else if (!strcasecmp(var, "dbname") && !zstr(val)) {
globals.dbname = switch_core_strdup(globals.pool, val);
}
if (!strcasecmp(var, "debug")) {
globals.debug = atoi(val);
}
}
}
if ((x_profiles = switch_xml_child(cfg, "profiles"))) {
for (x_profile = switch_xml_child(x_profiles, "profile"); x_profile; x_profile = x_profile->next) {
load_profile(switch_xml_attr_soft(x_profile, "name"));
}
}
if (zstr(globals.odbc_dsn) && zstr(globals.dbname)) {
globals.dbname = switch_core_sprintf(globals.pool, "directory");
}
dbh = directory_get_db_handle();
if (dbh) {
if (!reload) {
switch_cache_db_test_reactive(dbh, "delete from directory_search where uuid != '' and name_visible != '' ", "drop table directory_search", dir_sql);
}
switch_cache_db_release_db_handle(&dbh);
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Cannot open DB!2\n");
status = SWITCH_STATUS_TERM;
goto end;
}
end:
switch_mutex_unlock(globals.mutex);
switch_xml_free(xml);
return status;
}
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;
}
