X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fsigsession.cpp;h=94867959f184fcb547b40463e84f97fccbfea5f6;hp=adad2c5ee0cc51304f928e92445471d7ef88c2d8;hb=4d5d5d6aeb7d936fb6b939f6c6531b3f054dac1f;hpb=949f80503dff6502f9624aae8fa1ba26f2ea6b6c diff --git a/pv/sigsession.cpp b/pv/sigsession.cpp index adad2c5e..94867959 100644 --- a/pv/sigsession.cpp +++ b/pv/sigsession.cpp @@ -20,14 +20,17 @@ #include "sigsession.h" -#include "logicdata.h" -#include "logicdatasnapshot.h" +#include "data/analog.h" +#include "data/analogsnapshot.h" +#include "data/logic.h" +#include "data/logicsnapshot.h" +#include "view/analogsignal.h" #include "view/logicsignal.h" -#include - #include +#include + using namespace boost; using namespace std; @@ -55,11 +58,13 @@ SigSession::~SigSession() _session = NULL; } -void SigSession::load_file(const string &name) +void SigSession::load_file(const string &name, + function error_handler) { stop_capture(); _sampling_thread.reset(new boost::thread( - &SigSession::load_thread_proc, this, name)); + &SigSession::load_thread_proc, this, name, + error_handler)); } SigSession::capture_state SigSession::get_capture_state() const @@ -69,14 +74,29 @@ SigSession::capture_state SigSession::get_capture_state() const } void SigSession::start_capture(struct sr_dev_inst *sdi, - uint64_t record_length, uint64_t sample_rate) + uint64_t record_length, + function error_handler) { stop_capture(); + // Check that at least one probe is enabled + const GSList *l; + for (l = sdi->probes; l; l = l->next) { + sr_probe *const probe = (sr_probe*)l->data; + assert(probe); + if (probe->enabled) + break; + } + + if (!l) { + error_handler(tr("No probes enabled.")); + return; + } + // Begin the session _sampling_thread.reset(new boost::thread( &SigSession::sample_thread_proc, this, sdi, - record_length, sample_rate)); + record_length, error_handler)); } void SigSession::stop_capture() @@ -98,7 +118,7 @@ vector< shared_ptr > SigSession::get_signals() return _signals; } -boost::shared_ptr SigSession::get_data() +boost::shared_ptr SigSession::get_data() { return _logic_data; } @@ -110,17 +130,18 @@ void SigSession::set_capture_state(capture_state state) capture_state_changed(state); } -void SigSession::load_thread_proc(const string name) +void SigSession::load_thread_proc(const string name, + function error_handler) { if (sr_session_load(name.c_str()) != SR_OK) { - qDebug() << "Failed to load file."; + error_handler(tr("Failed to load file.")); return; } sr_session_datafeed_callback_add(data_feed_in_proc); if (sr_session_start() != SR_OK) { - qDebug() << "Failed to start session."; + error_handler(tr("Failed to start session.")); return; } @@ -133,33 +154,32 @@ void SigSession::load_thread_proc(const string name) } void SigSession::sample_thread_proc(struct sr_dev_inst *sdi, - uint64_t record_length, uint64_t sample_rate) + uint64_t record_length, + function error_handler) { + assert(sdi); + assert(error_handler); + sr_session_new(); sr_session_datafeed_callback_add(data_feed_in_proc); if (sr_session_dev_add(sdi) != SR_OK) { - qDebug() << "Failed to use device."; + error_handler(tr("Failed to use device.")); sr_session_destroy(); return; } - if (sr_dev_config_set(sdi, SR_HWCAP_LIMIT_SAMPLES, - &record_length) != SR_OK) { - qDebug() << "Failed to configure time-based sample limit."; - sr_session_destroy(); - return; - } - - if (sr_dev_config_set(sdi, SR_HWCAP_SAMPLERATE, - &sample_rate) != SR_OK) { - qDebug() << "Failed to configure samplerate."; + // Set the sample limit + if (sr_config_set(sdi, SR_CONF_LIMIT_SAMPLES, + g_variant_new_uint64(record_length)) != SR_OK) { + error_handler(tr("Failed to configure " + "time-based sample limit.")); sr_session_destroy(); return; } if (sr_session_start() != SR_OK) { - qDebug() << "Failed to start session."; + error_handler(tr("Failed to start session.")); return; } @@ -171,49 +191,124 @@ void SigSession::sample_thread_proc(struct sr_dev_inst *sdi, set_capture_state(Stopped); } -void SigSession::feed_in_meta_logic(const struct sr_dev_inst *sdi, - const sr_datafeed_meta_logic &meta_logic) +void SigSession::feed_in_header(const sr_dev_inst *sdi) { - using view::LogicSignal; + shared_ptr signal; + GVariant *gvar; + uint64_t sample_rate = 0; + unsigned int logic_probe_count = 0; + unsigned int analog_probe_count = 0; + + // Detect what data types we will receive + for (const GSList *l = sdi->probes; l; l = l->next) { + const sr_probe *const probe = (const sr_probe *)l->data; + if (!probe->enabled) + continue; + + switch(probe->type) { + case SR_PROBE_LOGIC: + logic_probe_count++; + break; + + case SR_PROBE_ANALOG: + analog_probe_count++; + break; + } + } + + // Read out the sample rate + assert(sdi->driver); + const int ret = sr_config_get(sdi->driver, SR_CONF_SAMPLERATE, + &gvar, sdi); + assert(ret == SR_OK); + sample_rate = g_variant_get_uint64(gvar); + g_variant_unref(gvar); + + // Create data containers for the coming data snapshots { - lock_guard lock(_data_mutex); + lock_guard data_lock(_data_mutex); - // Create an empty LogicData for coming data snapshots - _logic_data.reset(new LogicData(meta_logic)); - assert(_logic_data); - if (!_logic_data) - return; + if (logic_probe_count != 0) { + _logic_data.reset(new data::Logic( + logic_probe_count, sample_rate)); + assert(_logic_data); + } + + if (analog_probe_count != 0) { + _analog_data.reset(new data::Analog(sample_rate)); + assert(_analog_data); + } } + // Make the logic probe list { lock_guard lock(_signals_mutex); - // Add the signals - for (int i = 0; i < meta_logic.num_probes; i++) { + _signals.clear(); + + for (const GSList *l = sdi->probes; l; l = l->next) { const sr_probe *const probe = - (const sr_probe*)g_slist_nth_data( - sdi->probes, i); - if (probe->enabled) { - shared_ptr signal( - new LogicSignal(probe->name, + (const sr_probe *)l->data; + assert(probe); + if (!probe->enabled) + continue; + + switch(probe->type) { + case SR_PROBE_LOGIC: + signal = shared_ptr( + new view::LogicSignal(probe->name, _logic_data, probe->index)); - _signals.push_back(signal); + break; + + case SR_PROBE_ANALOG: + signal = shared_ptr( + new view::AnalogSignal(probe->name, + _analog_data, probe->index)); + break; } + + _signals.push_back(signal); } signals_changed(); } } +void SigSession::feed_in_meta(const sr_dev_inst *sdi, + const sr_datafeed_meta &meta) +{ + (void)sdi; + + for (const GSList *l = meta.config; l; l = l->next) { + const sr_config *const src = (const sr_config*)l->data; + switch (src->key) { + case SR_CONF_SAMPLERATE: + /// @todo handle samplerate changes + /// samplerate = (uint64_t *)src->value; + break; + default: + // Unknown metadata is not an error. + break; + } + } +} + void SigSession::feed_in_logic(const sr_datafeed_logic &logic) { lock_guard lock(_data_mutex); + + if (!_logic_data) + { + qDebug() << "Unexpected logic packet"; + return; + } + if (!_cur_logic_snapshot) { // Create a new data snapshot - _cur_logic_snapshot = shared_ptr( - new LogicDataSnapshot(logic)); + _cur_logic_snapshot = shared_ptr( + new data::LogicSnapshot(logic)); _logic_data->push_snapshot(_cur_logic_snapshot); } else @@ -225,6 +320,31 @@ void SigSession::feed_in_logic(const sr_datafeed_logic &logic) data_updated(); } +void SigSession::feed_in_analog(const sr_datafeed_analog &analog) +{ + lock_guard lock(_data_mutex); + + if(!_analog_data) + { + qDebug() << "Unexpected analog packet"; + return; // This analog packet was not expected. + } + + if (!_cur_analog_snapshot) + { + // Create a new data snapshot + _cur_analog_snapshot = shared_ptr( + new data::AnalogSnapshot(analog)); + _analog_data->push_snapshot(_cur_analog_snapshot); + } + else + { + // Append to the existing data snapshot + _cur_analog_snapshot->append_payload(analog); + } + + data_updated(); +} void SigSession::data_feed_in(const struct sr_dev_inst *sdi, const struct sr_datafeed_packet *packet) @@ -234,16 +354,13 @@ void SigSession::data_feed_in(const struct sr_dev_inst *sdi, switch (packet->type) { case SR_DF_HEADER: - { - lock_guard lock(_signals_mutex); - _signals.clear(); + feed_in_header(sdi); break; - } - case SR_DF_META_LOGIC: + case SR_DF_META: assert(packet->payload); - feed_in_meta_logic(sdi, - *(const sr_datafeed_meta_logic*)packet->payload); + feed_in_meta(sdi, + *(const sr_datafeed_meta*)packet->payload); break; case SR_DF_LOGIC: @@ -251,11 +368,17 @@ void SigSession::data_feed_in(const struct sr_dev_inst *sdi, feed_in_logic(*(const sr_datafeed_logic*)packet->payload); break; + case SR_DF_ANALOG: + assert(packet->payload); + feed_in_analog(*(const sr_datafeed_analog*)packet->payload); + break; + case SR_DF_END: { { lock_guard lock(_data_mutex); _cur_logic_snapshot.reset(); + _cur_analog_snapshot.reset(); } data_updated(); break;