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