void abort_move(int pos) { // {{{
aborting = true;
//debug("abort pos %d", pos);
//debug("abort; cf %d rf %d first %d computing_move %d fragments, regenerating %d ticks", current_fragment, running_fragment, first_fragment, computing_move, pos);
//debug("try aborting move");
current_fragment = running_fragment;
//debug("current abort -> %x", current_fragment);
restore_settings();
#ifdef DEBUG_MOVE
debug("move no longer prepared");
#endif
//debug("free abort reset");
current_fragment_pos = 0;
//if (spaces[0].num_axes > 0)
// fcpdebug(0, 0, "starting hwpos %x", spaces[0].motor[0]->settings.current_pos + avr_pos_offset[0]);
computing_move = true;
//debug("restoring position for fragment %d to position %d", current_fragment, pos);
while (computing_move && current_fragment_pos < pos) {
//debug("tick %d %d %d", current_fragment_pos, settings.hwtime, current_fragment);
apply_tick();
//if (spaces[0].num_axes > 0)
// fcpdebug(0, 0, "current hwpos %x time %d", spaces[0].motor[0]->settings.current_pos + avr_pos_offset[0], settings.hwtime);
}
//if (spaces[0].num_axes > 0)
// fcpdebug(0, 0, "ending hwpos %x", spaces[0].motor[0]->settings.current_pos + avr_pos_offset[0]);
//debug("done restoring position");
// Copy settings back to previous fragment.
store_settings();
computing_move = false;
prepared = false;
current_fragment_pos = 0;
//if (spaces[0].num_axes > 0)
// fcpdebug(0, 0, "final hwpos %x", spaces[0].motor[0]->settings.current_pos + avr_pos_offset[0]);
//debug("curf3 %d", current_fragment);
for (uint8_t s = 0; s < 2; ++s) {
Space &sp = spaces[s];
sp.settings.dist[0] = NAN;
sp.settings.dist[1] = NAN;
for (uint8_t a = 0; a < sp.num_axes; ++a) {
//debug("setting axis %d source to %f", a, sp.axis[a]->settings.current);
sp.axis[a]->settings.source = sp.axis[a]->settings.current;
sp.axis[a]->settings.dist[0] = NAN;
sp.axis[a]->settings.dist[1] = NAN;
}
for (uint8_t m = 0; m < sp.num_motors; ++m) {
sp.motor[m]->settings.last_v = 0;
//debug("setting motor %d pos to %d", m, sp.motor[m]->settings.current_pos);
}
}
//debug("aborted move");
aborting = false;
} // }}}
void abort_move(int pos) { // {{{
aborting = true;
//debug("abort pos %d", pos);
//debug("abort; cf %d rf %d first %d computing_move %d fragments, regenerating %d ticks", current_fragment, running_fragment, first_fragment, computing_move, pos);
//debug("try aborting move");
current_fragment = running_fragment;
//debug("current_fragment = running_fragment; %d", current_fragment);
//debug("current abort -> %x", current_fragment);
while (pos < 0) {
if (current_fragment == first_fragment) {
pos = 0;
}
else {
current_fragment = (current_fragment + FRAGMENTS_PER_BUFFER - 1) % FRAGMENTS_PER_BUFFER;
//debug("current_fragment = (current_fragment + FRAGMENTS_PER_BUFFER - 1) %% FRAGMENTS_PER_BUFFER; %d", current_fragment);
pos += SAMPLES_PER_FRAGMENT;
running_fragment = current_fragment;
}
}
restore_settings();
//debug("free abort reset");
current_fragment_pos = 0;
computing_move = true;
while (computing_move && current_fragment_pos < unsigned(pos)) {
//debug("abort reconstruct %d %d", current_fragment_pos, pos);
apply_tick();
}
if (spaces[0].num_axes > 0)
cpdebug(0, 0, "ending hwpos %f", arch_round_pos(0, 0, spaces[0].motor[0]->settings.current_pos) + avr_pos_offset[0]);
// Flush queue.
settings.queue_start = 0;
settings.queue_end = 0;
settings.queue_full = false;
// Copy settings back to previous fragment.
store_settings();
computing_move = false;
current_fragment_pos = 0;
for (int s = 0; s < NUM_SPACES; ++s) {
Space &sp = spaces[s];
sp.settings.dist[0] = 0;
sp.settings.dist[1] = 0;
for (int a = 0; a < sp.num_axes; ++a) {
//debug("setting axis %d source to %f", a, sp.axis[a]->settings.current);
if (!std::isnan(sp.axis[a]->settings.current))
sp.axis[a]->settings.source = sp.axis[a]->settings.current;
sp.axis[a]->settings.dist[0] = NAN;
sp.axis[a]->settings.dist[1] = NAN;
}
}
mdebug("aborted move");
aborting = false;
} // }}}
int main(void)
{
init_ports();
init_timer();
restore_settings(); /** restore source and volume settings, must be done after port initialisation */
sei(); /** global enabling of interrupts */
while(1)
{
//TODO:: Please write your application code
}
}
/*******************************************************************************
initScene
*******************************************************************************/
void SettingsScene::initScene()
{
// create pages
m_pages[SETTINGS::GENERAL] = new PageGeneral(parentView());
m_pages[SETTINGS::PLAYER] = new PagePlayer(parentView());
m_pages[SETTINGS::LIBRARY] = new PageLibrary(parentView());
m_pages[SETTINGS::SHORTCUT] = new PageShortcut(parentView());
m_pages[SETTINGS::SCROBBLER] = new PageScrobbler(parentView());
m_pages[SETTINGS::SONGINFO] = new PageSongInfo(parentView());
/* first init => always restore settings */
restore_settings();
/* layout */
m_layout = new QGraphicsLinearLayout(Qt::Vertical);
m_layout->setSpacing(10);
m_layout->addItem( m_pages.value(SETTINGS::GENERAL) );
m_layout->addItem( m_pages.value(SETTINGS::PLAYER) );
m_layout->addItem( m_pages.value(SETTINGS::LIBRARY) );
m_layout->addItem( m_pages.value(SETTINGS::SHORTCUT) );
m_layout->addItem( m_pages.value(SETTINGS::SONGINFO) );
m_layout->addItem( m_pages.value(SETTINGS::SCROBBLER) );
m_container = new QGraphicsWidget();
m_container->setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
m_container->setLayout(m_layout);
m_container->setPos(0,0);
this->addItem(m_container);
/* il faut interdire la modification des parametres de collection si un database builder est en cours */
connect(ThreadManager::instance(), SIGNAL(dbBuildStart()), this, SLOT(slot_dbBuilder_stateChange()));
connect(ThreadManager::instance(), SIGNAL(dbBuildFinished()), this, SLOT(slot_dbBuilder_stateChange()));
connect(Database::instance(), SIGNAL(settingsChanged()), this, SLOT(slot_database_settingsChanged()));
connect(MainLeftWidget::instance(), SIGNAL(dbNameChanged()), this, SLOT(slot_database_settingsChanged()));
connect(MainLeftWidget::instance(), SIGNAL(settings_save_clicked()), this, SLOT(slot_apply_settings()));
connect(MainLeftWidget::instance(), SIGNAL(settings_cancel_clicked()), this, SLOT(slot_cancel_settings()));
connect(m_pages[SETTINGS::GENERAL], SIGNAL(layout_changed()), this, SLOT(populateScene()));
connect(m_pages[SETTINGS::PLAYER], SIGNAL(layout_changed()), this, SLOT(populateScene()));
connect(m_pages[SETTINGS::LIBRARY], SIGNAL(layout_changed()), this, SLOT(populateScene()));
connect(m_pages[SETTINGS::SHORTCUT], SIGNAL(layout_changed()), this, SLOT(populateScene()));
connect(m_pages[SETTINGS::SCROBBLER], SIGNAL(layout_changed()), this, SLOT(populateScene()));
connect(m_pages[SETTINGS::SONGINFO], SIGNAL(layout_changed()), this, SLOT(populateScene()));
setInit(true);
}
/*******************************************************************************
initScene
*******************************************************************************/
void SettingsScene::initScene()
{
// create pages
m_pages[SETTINGS::GENERAL] = new PageGeneral(parentView());
m_pages[SETTINGS::PLAYER] = new PagePlayer(parentView());
m_pages[SETTINGS::LIBRARY] = new PageLibrary(parentView());
m_pages[SETTINGS::SHORTCUT] = new PageShortcut(parentView());
m_pages[SETTINGS::SCROBBLER] = new PageScrobbler(parentView());
m_pages[SETTINGS::SONGINFO] = new PageSongInfo(parentView());
connect(m_pages[SETTINGS::GENERAL], SIGNAL(layout_changed()), this, SLOT(populateScene()));
connect(m_pages[SETTINGS::PLAYER], SIGNAL(layout_changed()), this, SLOT(populateScene()));
connect(m_pages[SETTINGS::LIBRARY], SIGNAL(layout_changed()), this, SLOT(populateScene()));
connect(m_pages[SETTINGS::SHORTCUT], SIGNAL(layout_changed()), this, SLOT(populateScene()));
connect(m_pages[SETTINGS::SCROBBLER], SIGNAL(layout_changed()), this, SLOT(populateScene()));
connect(m_pages[SETTINGS::SONGINFO], SIGNAL(layout_changed()), this, SLOT(populateScene()));
m_header = new HeaderItem(qobject_cast<QGraphicsView*> (parentView())->viewport());
m_header->setText( tr("Settings") );
/* bottom widget */
m_bottomWidget = new BottomWidget();
connect(m_bottomWidget, SIGNAL(save_clicked()), this, SLOT(slot_apply_settings()));
connect(m_bottomWidget, SIGNAL(cancel_clicked()), this, SLOT(slot_cancel_settings()));
this->addItem(m_header);
this->addItem(m_pages.value(SETTINGS::GENERAL));
this->addItem(m_pages.value(SETTINGS::PLAYER));
this->addItem(m_pages.value(SETTINGS::LIBRARY));
this->addItem(m_pages.value(SETTINGS::SHORTCUT));
this->addItem(m_pages.value(SETTINGS::SCROBBLER));
this->addItem(m_pages.value(SETTINGS::SONGINFO));
/* first init => always restore settings */
restore_settings();
/* il faut interdire la modification des parametres de collection si un database builder est en cours */
connect(ThreadManager::instance(), SIGNAL(dbBuildStart()), this, SLOT(slot_dbBuilder_stateChange()));
connect(ThreadManager::instance(), SIGNAL(dbBuildFinished()), this, SLOT(slot_dbBuilder_stateChange()));
setInit(true);
}
int calibrate_dc(struct cli_state *s, unsigned int ops)
{
int retval = 0;
int status = BLADERF_ERR_UNEXPECTED;
struct settings rx_settings, tx_settings;
bladerf_loopback loopback;
int16_t dc_i, dc_q;
if (IS_RX_CAL(ops)) {
status = backup_and_update_settings(s->dev, BLADERF_MODULE_RX,
&rx_settings);
if (status != 0) {
s->last_lib_error = status;
return CLI_RET_LIBBLADERF;
}
}
if (IS_TX_CAL(ops)) {
status = backup_and_update_settings(s->dev, BLADERF_MODULE_TX,
&tx_settings);
if (status != 0) {
s->last_lib_error = status;
return CLI_RET_LIBBLADERF;
}
}
status = bladerf_get_loopback(s->dev, &loopback);
if (status != 0) {
s->last_lib_error = status;
return CLI_RET_LIBBLADERF;
}
if (IS_RX_CAL(ops)) {
status = set_rx_dc(s->dev, 0, 0);
if (status != 0) {
goto error;
}
status = bladerf_enable_module(s->dev, BLADERF_MODULE_RX, true);
if (status != 0) {
goto error;
}
}
if (IS_TX_CAL(ops)) {
status = bladerf_enable_module(s->dev, BLADERF_MODULE_RX, true);
if (status != 0) {
goto error;
}
status = bladerf_set_loopback(s->dev, BLADERF_LB_BB_TXVGA1_RXVGA2);
if (status != 0) {
goto error;
}
status = bladerf_enable_module(s->dev, BLADERF_MODULE_TX, true);
if (status != 0) {
goto error;
}
status = dummy_tx(s->dev);
if (status != 0) {
goto error;
}
status = bladerf_enable_module(s->dev, BLADERF_MODULE_TX, false);
if (status != 0) {
goto error;
}
}
status = bladerf_set_loopback(s->dev, BLADERF_LB_NONE);
if (status != 0) {
goto error;
}
putchar('\n');
if (IS_CAL(CAL_DC_LMS_TUNING, ops)) {
printf(" Calibrating LMS LPF tuning module...\n");
status = bladerf_calibrate_dc(s->dev, BLADERF_DC_CAL_LPF_TUNING);
if (status != 0) {
goto error;
} else {
struct bladerf_lms_dc_cals dc_cals;
status = bladerf_lms_get_dc_cals(s->dev, &dc_cals);
if (status != 0) {
goto error;
}
printf(" LPF tuning module: %d\n\n", dc_cals.lpf_tuning);
}
}
if (IS_CAL(CAL_DC_LMS_TXLPF, ops)) {
printf(" Calibrating LMS TX LPF modules...\n");
status = bladerf_calibrate_dc(s->dev, BLADERF_DC_CAL_TX_LPF);
if (status != 0) {
goto error;
} else {
struct bladerf_lms_dc_cals dc_cals;
status = bladerf_lms_get_dc_cals(s->dev, &dc_cals);
if (status != 0) {
goto error;
}
printf(" TX LPF I filter: %d\n", dc_cals.tx_lpf_i);
printf(" TX LPF Q filter: %d\n\n", dc_cals.tx_lpf_q);
}
}
if (IS_CAL(CAL_DC_LMS_RXLPF, ops)) {
printf(" Calibrating LMS RX LPF modules...\n");
status = bladerf_calibrate_dc(s->dev, BLADERF_DC_CAL_RX_LPF);
if (status != 0) {
goto error;
} else {
struct bladerf_lms_dc_cals dc_cals;
status = bladerf_lms_get_dc_cals(s->dev, &dc_cals);
if (status != 0) {
goto error;
}
printf(" RX LPF I filter: %d\n", dc_cals.rx_lpf_i);
printf(" RX LPF Q filter: %d\n\n", dc_cals.rx_lpf_q);
}
}
if (IS_CAL(CAL_DC_LMS_RXVGA2, ops)) {
printf(" Calibrating LMS RXVGA2 modules...\n");
status = bladerf_calibrate_dc(s->dev, BLADERF_DC_CAL_RXVGA2);
if (status != 0) {
goto error;
} else {
struct bladerf_lms_dc_cals dc_cals;
status = bladerf_lms_get_dc_cals(s->dev, &dc_cals);
if (status != 0) {
goto error;
}
printf(" RX VGA2 DC reference module: %d\n", dc_cals.dc_ref);
printf(" RX VGA2 stage 1, I channel: %d\n", dc_cals.rxvga2a_i);
printf(" RX VGA2 stage 1, Q channel: %d\n", dc_cals.rxvga2a_q);
printf(" RX VGA2 stage 2, I channel: %d\n", dc_cals.rxvga2b_i);
printf(" RX VGA2 stage 2, Q channel: %d\n\n", dc_cals.rxvga2b_q);
}
}
if (IS_CAL(CAL_DC_AUTO_RX, ops)) {
int16_t avg_i, avg_q;
status = calibrate_dc_rx(s, &dc_i, &dc_q, &avg_i, &avg_q);
if (status != 0) {
goto error;
} else {
printf(" RX DC I Setting = %d, error ~= %d\n", dc_i, avg_i);
printf(" RX DC Q Setting = %d, error ~= %d\n\n", dc_q, avg_q);
}
}
if (IS_CAL(CAL_DC_AUTO_TX, ops)) {
float error_i, error_q;
status = calibrate_dc_tx(s, &dc_i, &dc_q, &error_i, &error_q);
if (status != 0) {
goto error;
} else {
printf(" TX DC I Setting = %d, error ~= %f\n", dc_i, error_i);
printf(" TX DC Q Setting = %d, error ~= %f\n\n", dc_q, error_q);
}
}
error:
retval = status;
if (IS_RX_CAL(ops)) {
status = restore_settings(s->dev, BLADERF_MODULE_RX, &rx_settings);
retval = first_error(retval, status);
}
if (IS_TX_CAL(ops)) {
status = restore_settings(s->dev, BLADERF_MODULE_TX, &tx_settings);
retval = first_error(retval, status);
}
status = bladerf_enable_module(s->dev, BLADERF_MODULE_RX, false);
retval = first_error(retval, status);
status = bladerf_enable_module(s->dev, BLADERF_MODULE_TX, false);
retval = first_error(retval, status);
status = bladerf_set_loopback(s->dev, loopback);
retval = first_error(retval, status);
if (retval != 0) {
s->last_lib_error = retval;
retval = CLI_RET_LIBBLADERF;
}
return retval;
}
/* See libbladeRF's dc_cal_table.c for the packed table data format */
int calibrate_dc_gen_tbl(struct cli_state *s, bladerf_module module,
const char *filename, unsigned int f_low,
unsigned f_inc, unsigned int f_high)
{
int retval, status;
size_t off;
struct bladerf_lms_dc_cals lms_dc_cals;
unsigned int f;
struct settings settings;
bladerf_loopback loopback_backup;
struct bladerf_image *image = NULL;
const uint16_t magic = HOST_TO_LE16(0x1ab1);
const uint32_t reserved = HOST_TO_LE32(0x00000000);
const uint32_t tbl_version = HOST_TO_LE32(0x00000001);
const size_t lms_data_size = 10; /* 10 uint8_t register values */
const uint32_t n_frequencies = (f_high - f_low) / f_inc + 1;
const uint32_t n_frequencies_le = HOST_TO_LE32(n_frequencies);
const size_t entry_size = sizeof(uint32_t) + /* Frequency */
2 * sizeof(int16_t); /* DC I and Q valus */
const size_t table_size = n_frequencies * entry_size;
const size_t data_size = sizeof(magic) + sizeof(reserved) +
sizeof(tbl_version) + sizeof(n_frequencies_le) +
lms_data_size + table_size;
assert(data_size <= UINT_MAX);
status = backup_and_update_settings(s->dev, module, &settings);
if (status != 0) {
return status;
}
status = bladerf_get_loopback(s->dev, &loopback_backup);
if (status != 0) {
return status;
}
status = bladerf_lms_get_dc_cals(s->dev, &lms_dc_cals);
if (status != 0) {
goto out;
}
if (module == BLADERF_MODULE_RX) {
image = bladerf_alloc_image(BLADERF_IMAGE_TYPE_RX_DC_CAL,
0xffffffff, (unsigned int) data_size);
} else {
image = bladerf_alloc_image(BLADERF_IMAGE_TYPE_TX_DC_CAL,
0xffffffff, (unsigned int) data_size);
}
if (image == NULL) {
status = BLADERF_ERR_MEM;
goto out;
}
status = bladerf_get_serial(s->dev, image->serial);
if (status != 0) {
goto out;
}
if (module == BLADERF_MODULE_RX) {
status = bladerf_set_loopback(s->dev, BLADERF_LB_NONE);
if (status != 0) {
goto out;
}
}
off = 0;
memcpy(&image->data[off], &magic, sizeof(magic));
off += sizeof(magic);
memcpy(&image->data[off], &reserved, sizeof(reserved));
off += sizeof(reserved);
memcpy(&image->data[off], &tbl_version, sizeof(tbl_version));
off += sizeof(tbl_version);
memcpy(&image->data[off], &n_frequencies_le, sizeof(n_frequencies_le));
off += sizeof(n_frequencies_le);
image->data[off++] = (uint8_t)lms_dc_cals.lpf_tuning;
image->data[off++] = (uint8_t)lms_dc_cals.tx_lpf_i;
image->data[off++] = (uint8_t)lms_dc_cals.tx_lpf_q;
image->data[off++] = (uint8_t)lms_dc_cals.rx_lpf_i;
image->data[off++] = (uint8_t)lms_dc_cals.rx_lpf_q;
image->data[off++] = (uint8_t)lms_dc_cals.dc_ref;
image->data[off++] = (uint8_t)lms_dc_cals.rxvga2a_i;
image->data[off++] = (uint8_t)lms_dc_cals.rxvga2a_q;
image->data[off++] = (uint8_t)lms_dc_cals.rxvga2b_i;
image->data[off++] = (uint8_t)lms_dc_cals.rxvga2b_q;
putchar('\n');
for (f = f_low; f <= f_high; f += f_inc) {
const uint32_t frequency = HOST_TO_LE32((uint32_t)f);
int16_t dc_i, dc_q;
printf(" Calibrating @ %u Hz...", f);
status = bladerf_set_frequency(s->dev, module, f);
if (status != 0) {
goto out;
}
if (module == BLADERF_MODULE_RX) {
int16_t error_i, error_q;
status = calibrate_dc_rx(s, &dc_i, &dc_q, &error_i, &error_q);
printf(" I=%-4d (avg: %-4d), Q=%-4d (avg: %-4d)\r",
dc_i, error_i, dc_q, error_q);
} else {
float error_i, error_q;
status = calibrate_dc_tx(s, &dc_i, &dc_q, &error_i, &error_q);
printf(" I=%-4d (avg: %3.3f), Q=%-4d (avg: %3.3f)\r",
dc_i, error_i, dc_q, error_q);
}
if (status != 0) {
goto out;
}
fflush(stdout);
dc_i = HOST_TO_LE16(dc_i);
dc_q = HOST_TO_LE16(dc_q);
memcpy(&image->data[off], &frequency, sizeof(frequency));
off += sizeof(frequency);
memcpy(&image->data[off], &dc_i, sizeof(dc_i));
off += sizeof(dc_i);
memcpy(&image->data[off], &dc_q, sizeof(dc_q));
off += sizeof(dc_q);
}
status = bladerf_image_write(image, filename);
printf("\n Done.\n\n");
out:
retval = status;
if (module == BLADERF_MODULE_RX) {
status = bladerf_set_loopback(s->dev, loopback_backup);
retval = first_error(retval, status);
}
status = bladerf_enable_module(s->dev, BLADERF_MODULE_RX, false);
retval = first_error(retval, status);
status = restore_settings(s->dev, module, &settings);
retval = first_error(retval, status);
bladerf_free_image(image);
return retval;
}
/*******************************************************************************
slot_cancel_settings
*******************************************************************************/
void SettingsScene::slot_cancel_settings()
{
//Debug::debug() << " [SettingsScene] slot_cancel_settings";
restore_settings();
}
/* See libbladeRF's dc_cal_table.c for the packed table data format */
int calibrate_dc_gen_tbl(struct cli_state *s, bladerf_module module,
const char *filename, unsigned int f_low,
unsigned f_inc, unsigned int f_high)
{
int retval, status;
size_t off;
struct bladerf_lms_dc_cals lms_dc_cals;
unsigned int f;
struct settings settings;
bladerf_loopback loopback_backup;
struct bladerf_image *image = NULL;
FILE *write_check;
const uint16_t magic = HOST_TO_LE16(0x1ab1);
const uint32_t reserved = HOST_TO_LE32(0x00000000);
const uint32_t tbl_version = HOST_TO_LE32(0x00000001);
const size_t lms_data_size = 10; /* 10 uint8_t register values */
const uint32_t n_frequencies = (f_high - f_low) / f_inc + 1;
const uint32_t n_frequencies_le = HOST_TO_LE32(n_frequencies);
const size_t entry_size = sizeof(uint32_t) + /* Frequency */
2 * sizeof(int16_t); /* DC I and Q valus */
const size_t table_size = n_frequencies * entry_size;
const size_t data_size = sizeof(magic) + sizeof(reserved) +
sizeof(tbl_version) + sizeof(n_frequencies_le) +
lms_data_size + table_size;
assert(data_size <= UINT_MAX);
/* This operation may take a bit of time, so let's make sure we
* actually have write access before kicking things off. Note that
* access is checked later when the file is actually written.
*/
write_check = fopen(filename, "wb");
if (write_check == NULL) {
if (errno == EACCES) {
return BLADERF_ERR_PERMISSION;
} else {
return BLADERF_ERR_IO;
}
} else {
fclose(write_check);
/* Not much we care to do if this fails. Throw away the return value
* to make this explicit to our static analysis tools */
(void) remove(filename);
}
status = backup_and_update_settings(s->dev, module, &settings);
if (status != 0) {
return status;
}
status = bladerf_get_loopback(s->dev, &loopback_backup);
if (status != 0) {
return status;
}
status = bladerf_lms_get_dc_cals(s->dev, &lms_dc_cals);
if (status != 0) {
goto out;
}
if (module == BLADERF_MODULE_RX) {
image = bladerf_alloc_image(BLADERF_IMAGE_TYPE_RX_DC_CAL,
0xffffffff, (unsigned int) data_size);
} else {
image = bladerf_alloc_image(BLADERF_IMAGE_TYPE_TX_DC_CAL,
0xffffffff, (unsigned int) data_size);
}
if (image == NULL) {
status = BLADERF_ERR_MEM;
goto out;
}
status = bladerf_get_serial(s->dev, image->serial);
if (status != 0) {
goto out;
}
if (module == BLADERF_MODULE_RX) {
status = bladerf_set_loopback(s->dev, BLADERF_LB_NONE);
if (status != 0) {
goto out;
}
}
off = 0;
memcpy(&image->data[off], &magic, sizeof(magic));
off += sizeof(magic);
memcpy(&image->data[off], &reserved, sizeof(reserved));
off += sizeof(reserved);
memcpy(&image->data[off], &tbl_version, sizeof(tbl_version));
off += sizeof(tbl_version);
memcpy(&image->data[off], &n_frequencies_le, sizeof(n_frequencies_le));
off += sizeof(n_frequencies_le);
image->data[off++] = (uint8_t)lms_dc_cals.lpf_tuning;
image->data[off++] = (uint8_t)lms_dc_cals.tx_lpf_i;
image->data[off++] = (uint8_t)lms_dc_cals.tx_lpf_q;
image->data[off++] = (uint8_t)lms_dc_cals.rx_lpf_i;
image->data[off++] = (uint8_t)lms_dc_cals.rx_lpf_q;
image->data[off++] = (uint8_t)lms_dc_cals.dc_ref;
image->data[off++] = (uint8_t)lms_dc_cals.rxvga2a_i;
image->data[off++] = (uint8_t)lms_dc_cals.rxvga2a_q;
image->data[off++] = (uint8_t)lms_dc_cals.rxvga2b_i;
image->data[off++] = (uint8_t)lms_dc_cals.rxvga2b_q;
putchar('\n');
for (f = f_low; f <= f_high; f += f_inc) {
const uint32_t frequency = HOST_TO_LE32((uint32_t)f);
int16_t dc_i, dc_q;
printf(" Calibrating @ %u Hz...", f);
status = bladerf_set_frequency(s->dev, module, f);
if (status != 0) {
goto out;
}
if (module == BLADERF_MODULE_RX) {
int16_t error_i, error_q;
status = calibrate_dc_rx(s, &dc_i, &dc_q, &error_i, &error_q);
printf(" I=%-4d (avg: %-4d), Q=%-4d (avg: %-4d)\r",
dc_i, error_i, dc_q, error_q);
} else {
float error_i, error_q;
status = calibrate_dc_tx(s, &dc_i, &dc_q, &error_i, &error_q);
printf(" I=%-4d (avg: %3.3f), Q=%-4d (avg: %3.3f)\r",
dc_i, error_i, dc_q, error_q);
}
if (status != 0) {
goto out;
}
fflush(stdout);
dc_i = HOST_TO_LE16(dc_i);
dc_q = HOST_TO_LE16(dc_q);
memcpy(&image->data[off], &frequency, sizeof(frequency));
off += sizeof(frequency);
memcpy(&image->data[off], &dc_i, sizeof(dc_i));
off += sizeof(dc_i);
memcpy(&image->data[off], &dc_q, sizeof(dc_q));
off += sizeof(dc_q);
}
status = bladerf_image_write(image, filename);
printf("\n Done.\n\n");
out:
retval = status;
if (module == BLADERF_MODULE_RX) {
status = bladerf_set_loopback(s->dev, loopback_backup);
retval = first_error(retval, status);
}
status = bladerf_enable_module(s->dev, BLADERF_MODULE_RX, false);
retval = first_error(retval, status);
status = restore_settings(s->dev, module, &settings);
retval = first_error(retval, status);
bladerf_free_image(image);
return retval;
}
Settings::Settings(BaseObjectType* cobject, const Glib::RefPtr<Gnome::Glade::Xml>& refGlade) :
Gtk::Window(cobject),
m_refGlade(refGlade) {
// dicom settings
m_refGlade->get_widget("local_aet", m_local_aet);
m_refGlade->get_widget("local_port", m_local_port);
Gtk::HBox* hbox_characterset;
m_refGlade->get_widget("hbox_characterset",hbox_characterset);
m_characterset = manage(new Gtk::ComboBoxText);
m_characterset->append_text("ISO_IR 6");
m_characterset->append_text("ISO_IR 100");
m_characterset->append_text("ISO_IR 101");
m_characterset->append_text("ISO_IR 109");
m_characterset->append_text("ISO_IR 110");
m_characterset->append_text("ISO_IR 144");
m_characterset->append_text("ISO_IR 127");
m_characterset->append_text("ISO_IR 126");
m_characterset->append_text("ISO_IR 138");
m_characterset->append_text("ISO_IR 148");
m_characterset->append_text("ISO_IR 192");
m_characterset->show();
hbox_characterset->pack_start(*m_characterset);
// server details
m_refGlade->get_widget("server_detail_server", m_server_detail_server);
m_server_detail_server->signal_changed().connect(sigc::mem_fun(*this, &Settings::on_server_apply));
m_refGlade->get_widget("server_detail_aet", m_server_detail_aet);
m_server_detail_aet->signal_changed().connect(sigc::mem_fun(*this, &Settings::on_server_apply));
m_refGlade->get_widget("server_detail_port", m_server_detail_port);
m_server_detail_port->signal_changed().connect(sigc::mem_fun(*this, &Settings::on_server_apply));
m_refGlade->get_widget("server_detail_group", m_server_detail_group);
m_server_detail_group->get_entry()->signal_changed().connect(sigc::mem_fun(*this, &Settings::on_server_apply));
m_refGlade->get_widget("server_detail_description", m_server_detail_description);
m_server_detail_description->signal_changed().connect(sigc::mem_fun(*this, &Settings::on_server_apply));
m_refGlade->get_widget("server_detail_lossy", m_server_detail_lossy);
m_server_detail_lossy->signal_toggled().connect(sigc::mem_fun(*this, &Settings::on_server_apply));
m_refGlade->get_widget("server_detail_relational", m_server_detail_relational);
m_server_detail_relational->signal_toggled().connect(sigc::mem_fun(*this, &Settings::on_server_apply));
m_refGlade->get_widget("server_detail_echo", m_server_detail_echo);
m_server_detail_echo->signal_clicked().connect(sigc::mem_fun(*this, &Settings::on_echotest));
m_refGlade->get_widget("server_detail_echostatus", m_server_detail_echostatus);
// disable server detail
set_server_detail_sensitive(false);
// connect buttons
m_refGlade->get_widget("settings_ok", m_settings_ok);
m_settings_ok->signal_clicked().connect(sigc::mem_fun(*this, &Settings::on_settings_save));
Gtk::Button* button;
m_refGlade->get_widget("settings_cancel", button);
button->signal_clicked().connect(sigc::mem_fun(*this, &Settings::on_settings_cancel));
m_refGlade->get_widget("servers_add", button);
button->signal_clicked().connect(sigc::mem_fun(*this, &Settings::on_server_add));
m_refGlade->get_widget("servers_remove", button);
button->signal_clicked().connect(sigc::mem_fun(*this, &Settings::on_server_remove));
// create server list
m_refGlade->get_widget("serverlist", m_list_servers);
m_refTreeModel = Gtk::ListStore::create(m_Columns);
m_refTreeModel->set_sort_column(m_Columns.m_name, Gtk::SORT_ASCENDING);
m_list_servers->set_model(m_refTreeModel);
m_list_servers->append_column(gettext("Name"), m_Columns.m_name);
m_list_servers->append_column(gettext("AET"), m_Columns.m_aet);
m_list_servers->append_column_numeric(gettext("Port"), m_Columns.m_port, "%i");
m_list_servers->append_column(gettext("Hostname"), m_Columns.m_hostname);
m_list_servers->append_column(gettext("Group"), m_Columns.m_group);
m_list_servers->get_column(0)->set_sort_column(m_Columns.m_name);
m_list_servers->get_column(0)->property_sort_indicator().set_value(true);
m_list_servers->get_column(0)->set_sort_order(Gtk::SORT_ASCENDING);
m_list_servers->get_column(1)->set_sort_column(m_Columns.m_aet);
m_list_servers->get_column(2)->set_sort_column(m_Columns.m_port);
m_list_servers->get_column(3)->set_sort_column(m_Columns.m_hostname);
m_list_servers->get_column(3)->set_sort_column(m_Columns.m_group);
Glib::RefPtr<Gtk::TreeSelection> refTreeSelection = m_list_servers->get_selection();
refTreeSelection->signal_changed().connect(sigc::mem_fun(*this, &Settings::on_server_activated));
// presets - windowlevel
m_refGlade->get_widget("presets_windowlevels_modality", m_presets_windowlevels_modality);
m_presets_windowlevels_modality->signal_changed().connect(sigc::mem_fun(*this, &Settings::on_windowlevels_modality_changed));
m_refGlade->get_widget("presets_windowlevels", m_presets_windowlevels);
m_refWindowLevelModel = Gtk::ListStore::create(m_WindowLevelColumns);
m_refTreeModel->set_sort_column(m_WindowLevelColumns.m_description, Gtk::SORT_ASCENDING);
m_presets_windowlevels->set_model(m_refWindowLevelModel);
m_presets_windowlevels->append_column_editable(gettext("Description"), m_WindowLevelColumns.m_description);
m_presets_windowlevels->append_column_numeric_editable(gettext("Center"), m_WindowLevelColumns.m_center, "%i");
m_presets_windowlevels->append_column_numeric_editable(gettext("Width"), m_WindowLevelColumns.m_width, "%i");
m_presets_windowlevels->get_column(0)->set_sort_column(m_WindowLevelColumns.m_description);
m_presets_windowlevels->get_column(0)->property_sort_indicator().set_value(true);
m_presets_windowlevels->get_column(0)->set_sort_order(Gtk::SORT_ASCENDING);
m_presets_windowlevels->get_column(1)->set_sort_column(m_WindowLevelColumns.m_center);
m_presets_windowlevels->get_column(2)->set_sort_column(m_WindowLevelColumns.m_width);
m_refGlade->get_widget("presets_windowlevels_add", button);
button->signal_clicked().connect(sigc::mem_fun(*this, &Settings::on_windowlevels_add));
m_refGlade->get_widget("presets_windowlevels_remove", button);
button->signal_clicked().connect(sigc::mem_fun(*this, &Settings::on_windowlevels_remove));
if(m_presets_windowlevels_modality->get_active_row_number() == -1) {
m_presets_windowlevels_modality->set_active(0);
}
restore_settings();
}
void Settings::on_settings_cancel() {
restore_settings();
hide();
}
void Settings::on_show() {
Gtk::Window::on_show();
restore_settings();
}
