From: Joel Holdsworth Date: Wed, 3 Dec 2014 22:23:36 +0000 (+0000) Subject: Session: Renamed files to match class name X-Git-Tag: pulseview-0.3.0~410 X-Git-Url: https://sigrok.org/gitaction?a=commitdiff_plain;h=f65cd27bdbf70644052dd43dac4bbe9403f4dfee;p=pulseview.git Session: Renamed files to match class name --- diff --git a/CMakeLists.txt b/CMakeLists.txt index f1e71061..93021a64 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -149,7 +149,7 @@ set(pulseview_SOURCES pv/application.cpp pv/devicemanager.cpp pv/mainwindow.cpp - pv/sigsession.cpp + pv/session.cpp pv/storesession.cpp pv/util.cpp pv/data/analog.cpp @@ -201,7 +201,7 @@ set(pulseview_SOURCES # This list includes only QObject derived class headers. set(pulseview_HEADERS pv/mainwindow.hpp - pv/sigsession.hpp + pv/session.hpp pv/storesession.hpp pv/dialogs/about.hpp pv/dialogs/connect.hpp diff --git a/pv/data/decoderstack.cpp b/pv/data/decoderstack.cpp index 1c470160..c179b24a 100644 --- a/pv/data/decoderstack.cpp +++ b/pv/data/decoderstack.cpp @@ -30,7 +30,7 @@ #include #include #include -#include +#include #include using std::lock_guard; diff --git a/pv/devicemanager.cpp b/pv/devicemanager.cpp index 7a016d1b..9976d3e6 100644 --- a/pv/devicemanager.cpp +++ b/pv/devicemanager.cpp @@ -19,7 +19,7 @@ */ #include "devicemanager.hpp" -#include "sigsession.hpp" +#include "session.hpp" #include #include diff --git a/pv/mainwindow.hpp b/pv/mainwindow.hpp index 8a67c615..35cad3ab 100644 --- a/pv/mainwindow.hpp +++ b/pv/mainwindow.hpp @@ -26,7 +26,7 @@ #include -#include "sigsession.hpp" +#include "session.hpp" struct srd_decoder; diff --git a/pv/popups/channels.cpp b/pv/popups/channels.cpp index f8061d9a..f30ce627 100644 --- a/pv/popups/channels.cpp +++ b/pv/popups/channels.cpp @@ -28,7 +28,7 @@ #include "channels.hpp" #include -#include +#include #include #include diff --git a/pv/session.cpp b/pv/session.cpp new file mode 100644 index 00000000..5e3b492c --- /dev/null +++ b/pv/session.cpp @@ -0,0 +1,660 @@ +/* + * This file is part of the PulseView project. + * + * Copyright (C) 2012-14 Joel Holdsworth + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifdef ENABLE_DECODE +#include +#endif + +#include "session.hpp" + +#include "devicemanager.hpp" + +#include "data/analog.hpp" +#include "data/analogsnapshot.hpp" +#include "data/decoderstack.hpp" +#include "data/logic.hpp" +#include "data/logicsnapshot.hpp" +#include "data/decode/decoder.hpp" + +#include "view/analogsignal.hpp" +#include "view/decodetrace.hpp" +#include "view/logicsignal.hpp" + +#include +#include +#include + +#include + +#include + +#include + +using boost::shared_lock; +using boost::shared_mutex; +using boost::unique_lock; + +using std::dynamic_pointer_cast; +using std::function; +using std::lock_guard; +using std::list; +using std::map; +using std::mutex; +using std::set; +using std::shared_ptr; +using std::string; +using std::vector; + +using sigrok::Analog; +using sigrok::Channel; +using sigrok::ChannelType; +using sigrok::ConfigKey; +using sigrok::DatafeedCallbackFunction; +using sigrok::Device; +using sigrok::Error; +using sigrok::HardwareDevice; +using sigrok::Header; +using sigrok::Logic; +using sigrok::Meta; +using sigrok::Packet; +using sigrok::PacketPayload; +using sigrok::Session; +using sigrok::SessionDevice; + +using Glib::VariantBase; +using Glib::Variant; + +namespace pv { +Session::Session(DeviceManager &device_manager) : + device_manager_(device_manager), + session_(device_manager.context()->create_session()), + capture_state_(Stopped) +{ + set_default_device(); +} + +Session::~Session() +{ + // Stop and join to the thread + stop_capture(); +} + +DeviceManager& Session::device_manager() +{ + return device_manager_; +} + +const DeviceManager& Session::device_manager() const +{ + return device_manager_; +} + +const shared_ptr& Session::session() const +{ + return session_; +} + +shared_ptr Session::device() const +{ + return device_; +} + +void Session::set_device(shared_ptr device) +{ + // Ensure we are not capturing before setting the device + stop_capture(); + + // Are we setting a session device? + auto session_device = dynamic_pointer_cast(device); + // Did we have a session device selected previously? + auto prev_session_device = dynamic_pointer_cast(device_); + + if (device_) { + session_->remove_datafeed_callbacks(); + if (!prev_session_device) { + device_->close(); + session_->remove_devices(); + } + } + + if (session_device) + session_ = session_device->parent(); + + decode_traces_.clear(); + + if (device) { + if (!session_device) + { + session_ = device_manager_.context()->create_session(); + + try { + device->open(); + } catch(const sigrok::Error &e) { + throw QString(e.what()); + } + + session_->add_device(device); + } + + device_ = device; + session_->add_datafeed_callback([=] + (shared_ptr device, shared_ptr packet) { + data_feed_in(device, packet); + }); + update_signals(device); + } else + device_ = nullptr; + + device_selected(); +} + +void Session::set_file(const string &name) +{ + session_ = device_manager_.context()->load_session(name); + device_ = session_->devices()[0]; + decode_traces_.clear(); + session_->add_datafeed_callback([=] + (shared_ptr device, shared_ptr packet) { + data_feed_in(device, packet); + }); + device_manager_.update_display_name(device_); + update_signals(device_); + device_selected(); +} + +void Session::set_default_device() +{ + shared_ptr default_device; + const list< shared_ptr > &devices = + device_manager_.devices(); + + if (!devices.empty()) { + // Fall back to the first device in the list. + default_device = devices.front(); + + // Try and find the demo device and select that by default + for (shared_ptr dev : devices) + if (dev->driver()->name().compare("demo") == 0) { + default_device = dev; + break; + } + + set_device(default_device); + } +} + +Session::capture_state Session::get_capture_state() const +{ + lock_guard lock(sampling_mutex_); + return capture_state_; +} + +void Session::start_capture(function error_handler) +{ + stop_capture(); + + // Check that a device instance has been selected. + if (!device_) { + qDebug() << "No device selected"; + return; + } + + // Check that at least one channel is enabled + auto channels = device_->channels(); + bool enabled = std::any_of(channels.begin(), channels.end(), + [](shared_ptr channel) { return channel->enabled(); }); + + if (!enabled) { + error_handler(tr("No channels enabled.")); + return; + } + + // Begin the session + sampling_thread_ = std::thread( + &Session::sample_thread_proc, this, device_, + error_handler); +} + +void Session::stop_capture() +{ + if (get_capture_state() != Stopped) + session_->stop(); + + // Check that sampling stopped + if (sampling_thread_.joinable()) + sampling_thread_.join(); +} + +set< shared_ptr > Session::get_data() const +{ + shared_lock lock(signals_mutex_); + set< shared_ptr > data; + for (const shared_ptr sig : signals_) { + assert(sig); + data.insert(sig->data()); + } + + return data; +} + +boost::shared_mutex& Session::signals_mutex() const +{ + return signals_mutex_; +} + +const vector< shared_ptr >& Session::signals() const +{ + return signals_; +} + +#ifdef ENABLE_DECODE +bool Session::add_decoder(srd_decoder *const dec) +{ + map > channels; + shared_ptr decoder_stack; + + try + { + lock_guard lock(signals_mutex_); + + // Create the decoder + decoder_stack = shared_ptr( + new data::DecoderStack(*this, dec)); + + // Make a list of all the channels + std::vector all_channels; + for(const GSList *i = dec->channels; i; i = i->next) + all_channels.push_back((const srd_channel*)i->data); + for(const GSList *i = dec->opt_channels; i; i = i->next) + all_channels.push_back((const srd_channel*)i->data); + + // Auto select the initial channels + for (const srd_channel *pdch : all_channels) + for (shared_ptr s : signals_) + { + shared_ptr l = + dynamic_pointer_cast(s); + if (l && QString::fromUtf8(pdch->name). + toLower().contains( + l->name().toLower())) + channels[pdch] = l; + } + + assert(decoder_stack); + assert(!decoder_stack->stack().empty()); + assert(decoder_stack->stack().front()); + decoder_stack->stack().front()->set_channels(channels); + + // Create the decode signal + shared_ptr d( + new view::DecodeTrace(*this, decoder_stack, + decode_traces_.size())); + decode_traces_.push_back(d); + } + catch(std::runtime_error e) + { + return false; + } + + signals_changed(); + + // Do an initial decode + decoder_stack->begin_decode(); + + return true; +} + +vector< shared_ptr > Session::get_decode_signals() const +{ + shared_lock lock(signals_mutex_); + return decode_traces_; +} + +void Session::remove_decode_signal(view::DecodeTrace *signal) +{ + for (auto i = decode_traces_.begin(); i != decode_traces_.end(); i++) + if ((*i).get() == signal) + { + decode_traces_.erase(i); + signals_changed(); + return; + } +} +#endif + +void Session::set_capture_state(capture_state state) +{ + lock_guard lock(sampling_mutex_); + const bool changed = capture_state_ != state; + capture_state_ = state; + if(changed) + capture_state_changed(state); +} + +void Session::update_signals(shared_ptr device) +{ + assert(device); + assert(capture_state_ == Stopped); + + // Clear the decode traces + decode_traces_.clear(); + + // Detect what data types we will receive + auto channels = device->channels(); + unsigned int logic_channel_count = std::count_if( + channels.begin(), channels.end(), + [] (shared_ptr channel) { + return channel->type() == ChannelType::LOGIC; }); + + // Create data containers for the logic data snapshots + { + lock_guard data_lock(data_mutex_); + + logic_data_.reset(); + if (logic_channel_count != 0) { + logic_data_.reset(new data::Logic( + logic_channel_count)); + assert(logic_data_); + } + } + + // Make the Signals list + { + unique_lock lock(signals_mutex_); + + signals_.clear(); + + for (auto channel : device->channels()) { + shared_ptr signal; + + switch(channel->type()->id()) { + case SR_CHANNEL_LOGIC: + signal = shared_ptr( + new view::LogicSignal(*this, device, + channel, logic_data_)); + break; + + case SR_CHANNEL_ANALOG: + { + shared_ptr data( + new data::Analog()); + signal = shared_ptr( + new view::AnalogSignal( + *this, channel, data)); + break; + } + + default: + assert(0); + break; + } + + assert(signal); + signals_.push_back(signal); + } + + } + + signals_changed(); +} + +shared_ptr Session::signal_from_channel( + shared_ptr channel) const +{ + lock_guard lock(signals_mutex_); + for (shared_ptr sig : signals_) { + assert(sig); + if (sig->channel() == channel) + return sig; + } + return shared_ptr(); +} + +void Session::read_sample_rate(shared_ptr device) +{ + const auto keys = device_->config_keys(ConfigKey::DEVICE_OPTIONS); + const auto iter = keys.find(ConfigKey::SAMPLERATE); + const uint64_t sample_rate = (iter != keys.end() && + (*iter).second.find(sigrok::GET) != (*iter).second.end()) ? + VariantBase::cast_dynamic>( + device->config_get(ConfigKey::SAMPLERATE)).get() : 0; + + // Set the sample rate of all data + const set< shared_ptr > data_set = get_data(); + for (shared_ptr data : data_set) { + assert(data); + data->set_samplerate(sample_rate); + } +} + +void Session::sample_thread_proc(shared_ptr device, + function error_handler) +{ + assert(device); + assert(error_handler); + + read_sample_rate(device); + + try { + session_->start(); + } catch(Error e) { + error_handler(e.what()); + return; + } + + set_capture_state(session_->trigger() ? + AwaitingTrigger : Running); + + session_->run(); + set_capture_state(Stopped); + + // Confirm that SR_DF_END was received + if (cur_logic_snapshot_) + { + qDebug("SR_DF_END was not received."); + assert(0); + } +} + +void Session::feed_in_header(shared_ptr device) +{ + read_sample_rate(device); +} + +void Session::feed_in_meta(shared_ptr device, + shared_ptr meta) +{ + (void)device; + + for (auto entry : meta->config()) { + switch (entry.first->id()) { + case SR_CONF_SAMPLERATE: + /// @todo handle samplerate changes + break; + default: + // Unknown metadata is not an error. + break; + } + } + + signals_changed(); +} + +void Session::feed_in_frame_begin() +{ + if (cur_logic_snapshot_ || !cur_analog_snapshots_.empty()) + frame_began(); +} + +void Session::feed_in_logic(shared_ptr logic) +{ + lock_guard lock(data_mutex_); + + if (!logic_data_) + { + qDebug() << "Unexpected logic packet"; + return; + } + + if (!cur_logic_snapshot_) + { + // This could be the first packet after a trigger + set_capture_state(Running); + + // Get sample limit. + const auto keys = device_->config_keys( + ConfigKey::DEVICE_OPTIONS); + const auto iter = keys.find(ConfigKey::LIMIT_SAMPLES); + const uint64_t sample_limit = (iter != keys.end() && + (*iter).second.find(sigrok::GET) != + (*iter).second.end()) ? + VariantBase::cast_dynamic>( + device_->config_get(ConfigKey::LIMIT_SAMPLES)).get() : 0; + + // Create a new data snapshot + cur_logic_snapshot_ = shared_ptr( + new data::LogicSnapshot(logic, sample_limit)); + logic_data_->push_snapshot(cur_logic_snapshot_); + + // @todo Putting this here means that only listeners querying + // for logic will be notified. Currently the only user of + // frame_began is DecoderStack, but in future we need to signal + // this after both analog and logic sweeps have begun. + frame_began(); + } + else + { + // Append to the existing data snapshot + cur_logic_snapshot_->append_payload(logic); + } + + data_received(); +} + +void Session::feed_in_analog(shared_ptr analog) +{ + lock_guard lock(data_mutex_); + + const vector> channels = analog->channels(); + const unsigned int channel_count = channels.size(); + const size_t sample_count = analog->num_samples() / channel_count; + const float *data = analog->data_pointer(); + bool sweep_beginning = false; + + for (auto channel : channels) + { + shared_ptr snapshot; + + // Try to get the snapshot of the channel + const map< shared_ptr, shared_ptr >:: + iterator iter = cur_analog_snapshots_.find(channel); + if (iter != cur_analog_snapshots_.end()) + snapshot = (*iter).second; + else + { + // If no snapshot was found, this means we havn't + // created one yet. i.e. this is the first packet + // in the sweep containing this snapshot. + sweep_beginning = true; + + // Get sample limit. + uint64_t sample_limit; + try { + sample_limit = VariantBase::cast_dynamic>( + device_->config_get(ConfigKey::LIMIT_SAMPLES)).get(); + } catch (Error) { + sample_limit = 0; + } + + // Create a snapshot, keep it in the maps of channels + snapshot = shared_ptr( + new data::AnalogSnapshot(sample_limit)); + cur_analog_snapshots_[channel] = snapshot; + + // Find the annalog data associated with the channel + shared_ptr sig = + dynamic_pointer_cast( + signal_from_channel(channel)); + assert(sig); + + shared_ptr data(sig->analog_data()); + assert(data); + + // Push the snapshot into the analog data. + data->push_snapshot(snapshot); + } + + assert(snapshot); + + // Append the samples in the snapshot + snapshot->append_interleaved_samples(data++, sample_count, + channel_count); + } + + if (sweep_beginning) { + // This could be the first packet after a trigger + set_capture_state(Running); + } + + data_received(); +} + +void Session::data_feed_in(shared_ptr device, shared_ptr packet) +{ + assert(device); + assert(packet); + + switch (packet->type()->id()) { + case SR_DF_HEADER: + feed_in_header(device); + break; + + case SR_DF_META: + feed_in_meta(device, dynamic_pointer_cast(packet->payload())); + break; + + case SR_DF_FRAME_BEGIN: + feed_in_frame_begin(); + break; + + case SR_DF_LOGIC: + feed_in_logic(dynamic_pointer_cast(packet->payload())); + break; + + case SR_DF_ANALOG: + feed_in_analog(dynamic_pointer_cast(packet->payload())); + break; + + case SR_DF_END: + { + { + lock_guard lock(data_mutex_); + cur_logic_snapshot_.reset(); + cur_analog_snapshots_.clear(); + } + frame_ended(); + break; + } + default: + break; + } +} + +} // namespace pv diff --git a/pv/session.hpp b/pv/session.hpp new file mode 100644 index 00000000..c6a317de --- /dev/null +++ b/pv/session.hpp @@ -0,0 +1,190 @@ +/* + * This file is part of the PulseView project. + * + * Copyright (C) 2012-14 Joel Holdsworth + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef PULSEVIEW_PV_SIGSESSION_H +#define PULSEVIEW_PV_SIGSESSION_H + +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include + +struct srd_decoder; +struct srd_channel; + +namespace sigrok { + class Analog; + class Channel; + class Device; + class Logic; + class Meta; + class Packet; + class Session; +} + +namespace pv { + +class DeviceManager; + +namespace data { +class Analog; +class AnalogSnapshot; +class Logic; +class LogicSnapshot; +class SignalData; +} + +namespace view { +class DecodeTrace; +class LogicSignal; +class Signal; +} + +class Session : public QObject +{ + Q_OBJECT + +public: + enum capture_state { + Stopped, + AwaitingTrigger, + Running + }; + +public: + Session(DeviceManager &device_manager); + + ~Session(); + + DeviceManager& device_manager(); + + const DeviceManager& device_manager() const; + + const std::shared_ptr& session() const; + + std::shared_ptr device() const; + + /** + * Sets device instance that will be used in the next capture session. + */ + void set_device(std::shared_ptr device); + + void set_file(const std::string &name); + + void set_default_device(); + + capture_state get_capture_state() const; + + void start_capture(std::function error_handler); + + void stop_capture(); + + std::set< std::shared_ptr > get_data() const; + + boost::shared_mutex& signals_mutex() const; + + const std::vector< std::shared_ptr >& signals() const; + +#ifdef ENABLE_DECODE + bool add_decoder(srd_decoder *const dec); + + std::vector< std::shared_ptr > + get_decode_signals() const; + + void remove_decode_signal(view::DecodeTrace *signal); +#endif + +private: + void set_capture_state(capture_state state); + + void update_signals(std::shared_ptr device); + + std::shared_ptr signal_from_channel( + std::shared_ptr channel) const; + + void read_sample_rate(std::shared_ptr); + +private: + void sample_thread_proc(std::shared_ptr device, + std::function error_handler); + + void feed_in_header(std::shared_ptr device); + + void feed_in_meta(std::shared_ptr device, + std::shared_ptr meta); + + void feed_in_frame_begin(); + + void feed_in_logic(std::shared_ptr logic); + + void feed_in_analog(std::shared_ptr analog); + + void data_feed_in(std::shared_ptr device, + std::shared_ptr packet); + +private: + DeviceManager &device_manager_; + std::shared_ptr session_; + + /** + * The device instance that will be used in the next capture session. + */ + std::shared_ptr device_; + + std::vector< std::shared_ptr > decode_traces_; + + mutable std::mutex sampling_mutex_; + capture_state capture_state_; + + mutable boost::shared_mutex signals_mutex_; + std::vector< std::shared_ptr > signals_; + + mutable std::mutex data_mutex_; + std::shared_ptr logic_data_; + std::shared_ptr cur_logic_snapshot_; + std::map< std::shared_ptr, std::shared_ptr > + cur_analog_snapshots_; + + std::thread sampling_thread_; + +Q_SIGNALS: + void capture_state_changed(int state); + void device_selected(); + + void signals_changed(); + + void frame_began(); + + void data_received(); + + void frame_ended(); +}; + +} // namespace pv + +#endif // PULSEVIEW_PV_SIGSESSION_H diff --git a/pv/sigsession.cpp b/pv/sigsession.cpp deleted file mode 100644 index 84c75896..00000000 --- a/pv/sigsession.cpp +++ /dev/null @@ -1,660 +0,0 @@ -/* - * This file is part of the PulseView project. - * - * Copyright (C) 2012-14 Joel Holdsworth - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA - */ - -#ifdef ENABLE_DECODE -#include -#endif - -#include "sigsession.hpp" - -#include "devicemanager.hpp" - -#include "data/analog.hpp" -#include "data/analogsnapshot.hpp" -#include "data/decoderstack.hpp" -#include "data/logic.hpp" -#include "data/logicsnapshot.hpp" -#include "data/decode/decoder.hpp" - -#include "view/analogsignal.hpp" -#include "view/decodetrace.hpp" -#include "view/logicsignal.hpp" - -#include -#include -#include - -#include - -#include - -#include - -using boost::shared_lock; -using boost::shared_mutex; -using boost::unique_lock; - -using std::dynamic_pointer_cast; -using std::function; -using std::lock_guard; -using std::list; -using std::map; -using std::mutex; -using std::set; -using std::shared_ptr; -using std::string; -using std::vector; - -using sigrok::Analog; -using sigrok::Channel; -using sigrok::ChannelType; -using sigrok::ConfigKey; -using sigrok::DatafeedCallbackFunction; -using sigrok::Device; -using sigrok::Error; -using sigrok::HardwareDevice; -using sigrok::Header; -using sigrok::Logic; -using sigrok::Meta; -using sigrok::Packet; -using sigrok::PacketPayload; -using sigrok::Session; -using sigrok::SessionDevice; - -using Glib::VariantBase; -using Glib::Variant; - -namespace pv { -Session::Session(DeviceManager &device_manager) : - device_manager_(device_manager), - session_(device_manager.context()->create_session()), - capture_state_(Stopped) -{ - set_default_device(); -} - -Session::~Session() -{ - // Stop and join to the thread - stop_capture(); -} - -DeviceManager& Session::device_manager() -{ - return device_manager_; -} - -const DeviceManager& Session::device_manager() const -{ - return device_manager_; -} - -const shared_ptr& Session::session() const -{ - return session_; -} - -shared_ptr Session::device() const -{ - return device_; -} - -void Session::set_device(shared_ptr device) -{ - // Ensure we are not capturing before setting the device - stop_capture(); - - // Are we setting a session device? - auto session_device = dynamic_pointer_cast(device); - // Did we have a session device selected previously? - auto prev_session_device = dynamic_pointer_cast(device_); - - if (device_) { - session_->remove_datafeed_callbacks(); - if (!prev_session_device) { - device_->close(); - session_->remove_devices(); - } - } - - if (session_device) - session_ = session_device->parent(); - - decode_traces_.clear(); - - if (device) { - if (!session_device) - { - session_ = device_manager_.context()->create_session(); - - try { - device->open(); - } catch(const sigrok::Error &e) { - throw QString(e.what()); - } - - session_->add_device(device); - } - - device_ = device; - session_->add_datafeed_callback([=] - (shared_ptr device, shared_ptr packet) { - data_feed_in(device, packet); - }); - update_signals(device); - } else - device_ = nullptr; - - device_selected(); -} - -void Session::set_file(const string &name) -{ - session_ = device_manager_.context()->load_session(name); - device_ = session_->devices()[0]; - decode_traces_.clear(); - session_->add_datafeed_callback([=] - (shared_ptr device, shared_ptr packet) { - data_feed_in(device, packet); - }); - device_manager_.update_display_name(device_); - update_signals(device_); - device_selected(); -} - -void Session::set_default_device() -{ - shared_ptr default_device; - const list< shared_ptr > &devices = - device_manager_.devices(); - - if (!devices.empty()) { - // Fall back to the first device in the list. - default_device = devices.front(); - - // Try and find the demo device and select that by default - for (shared_ptr dev : devices) - if (dev->driver()->name().compare("demo") == 0) { - default_device = dev; - break; - } - - set_device(default_device); - } -} - -Session::capture_state Session::get_capture_state() const -{ - lock_guard lock(sampling_mutex_); - return capture_state_; -} - -void Session::start_capture(function error_handler) -{ - stop_capture(); - - // Check that a device instance has been selected. - if (!device_) { - qDebug() << "No device selected"; - return; - } - - // Check that at least one channel is enabled - auto channels = device_->channels(); - bool enabled = std::any_of(channels.begin(), channels.end(), - [](shared_ptr channel) { return channel->enabled(); }); - - if (!enabled) { - error_handler(tr("No channels enabled.")); - return; - } - - // Begin the session - sampling_thread_ = std::thread( - &Session::sample_thread_proc, this, device_, - error_handler); -} - -void Session::stop_capture() -{ - if (get_capture_state() != Stopped) - session_->stop(); - - // Check that sampling stopped - if (sampling_thread_.joinable()) - sampling_thread_.join(); -} - -set< shared_ptr > Session::get_data() const -{ - shared_lock lock(signals_mutex_); - set< shared_ptr > data; - for (const shared_ptr sig : signals_) { - assert(sig); - data.insert(sig->data()); - } - - return data; -} - -boost::shared_mutex& Session::signals_mutex() const -{ - return signals_mutex_; -} - -const vector< shared_ptr >& Session::signals() const -{ - return signals_; -} - -#ifdef ENABLE_DECODE -bool Session::add_decoder(srd_decoder *const dec) -{ - map > channels; - shared_ptr decoder_stack; - - try - { - lock_guard lock(signals_mutex_); - - // Create the decoder - decoder_stack = shared_ptr( - new data::DecoderStack(*this, dec)); - - // Make a list of all the channels - std::vector all_channels; - for(const GSList *i = dec->channels; i; i = i->next) - all_channels.push_back((const srd_channel*)i->data); - for(const GSList *i = dec->opt_channels; i; i = i->next) - all_channels.push_back((const srd_channel*)i->data); - - // Auto select the initial channels - for (const srd_channel *pdch : all_channels) - for (shared_ptr s : signals_) - { - shared_ptr l = - dynamic_pointer_cast(s); - if (l && QString::fromUtf8(pdch->name). - toLower().contains( - l->name().toLower())) - channels[pdch] = l; - } - - assert(decoder_stack); - assert(!decoder_stack->stack().empty()); - assert(decoder_stack->stack().front()); - decoder_stack->stack().front()->set_channels(channels); - - // Create the decode signal - shared_ptr d( - new view::DecodeTrace(*this, decoder_stack, - decode_traces_.size())); - decode_traces_.push_back(d); - } - catch(std::runtime_error e) - { - return false; - } - - signals_changed(); - - // Do an initial decode - decoder_stack->begin_decode(); - - return true; -} - -vector< shared_ptr > Session::get_decode_signals() const -{ - shared_lock lock(signals_mutex_); - return decode_traces_; -} - -void Session::remove_decode_signal(view::DecodeTrace *signal) -{ - for (auto i = decode_traces_.begin(); i != decode_traces_.end(); i++) - if ((*i).get() == signal) - { - decode_traces_.erase(i); - signals_changed(); - return; - } -} -#endif - -void Session::set_capture_state(capture_state state) -{ - lock_guard lock(sampling_mutex_); - const bool changed = capture_state_ != state; - capture_state_ = state; - if(changed) - capture_state_changed(state); -} - -void Session::update_signals(shared_ptr device) -{ - assert(device); - assert(capture_state_ == Stopped); - - // Clear the decode traces - decode_traces_.clear(); - - // Detect what data types we will receive - auto channels = device->channels(); - unsigned int logic_channel_count = std::count_if( - channels.begin(), channels.end(), - [] (shared_ptr channel) { - return channel->type() == ChannelType::LOGIC; }); - - // Create data containers for the logic data snapshots - { - lock_guard data_lock(data_mutex_); - - logic_data_.reset(); - if (logic_channel_count != 0) { - logic_data_.reset(new data::Logic( - logic_channel_count)); - assert(logic_data_); - } - } - - // Make the Signals list - { - unique_lock lock(signals_mutex_); - - signals_.clear(); - - for (auto channel : device->channels()) { - shared_ptr signal; - - switch(channel->type()->id()) { - case SR_CHANNEL_LOGIC: - signal = shared_ptr( - new view::LogicSignal(*this, device, - channel, logic_data_)); - break; - - case SR_CHANNEL_ANALOG: - { - shared_ptr data( - new data::Analog()); - signal = shared_ptr( - new view::AnalogSignal( - *this, channel, data)); - break; - } - - default: - assert(0); - break; - } - - assert(signal); - signals_.push_back(signal); - } - - } - - signals_changed(); -} - -shared_ptr Session::signal_from_channel( - shared_ptr channel) const -{ - lock_guard lock(signals_mutex_); - for (shared_ptr sig : signals_) { - assert(sig); - if (sig->channel() == channel) - return sig; - } - return shared_ptr(); -} - -void Session::read_sample_rate(shared_ptr device) -{ - const auto keys = device_->config_keys(ConfigKey::DEVICE_OPTIONS); - const auto iter = keys.find(ConfigKey::SAMPLERATE); - const uint64_t sample_rate = (iter != keys.end() && - (*iter).second.find(sigrok::GET) != (*iter).second.end()) ? - VariantBase::cast_dynamic>( - device->config_get(ConfigKey::SAMPLERATE)).get() : 0; - - // Set the sample rate of all data - const set< shared_ptr > data_set = get_data(); - for (shared_ptr data : data_set) { - assert(data); - data->set_samplerate(sample_rate); - } -} - -void Session::sample_thread_proc(shared_ptr device, - function error_handler) -{ - assert(device); - assert(error_handler); - - read_sample_rate(device); - - try { - session_->start(); - } catch(Error e) { - error_handler(e.what()); - return; - } - - set_capture_state(session_->trigger() ? - AwaitingTrigger : Running); - - session_->run(); - set_capture_state(Stopped); - - // Confirm that SR_DF_END was received - if (cur_logic_snapshot_) - { - qDebug("SR_DF_END was not received."); - assert(0); - } -} - -void Session::feed_in_header(shared_ptr device) -{ - read_sample_rate(device); -} - -void Session::feed_in_meta(shared_ptr device, - shared_ptr meta) -{ - (void)device; - - for (auto entry : meta->config()) { - switch (entry.first->id()) { - case SR_CONF_SAMPLERATE: - /// @todo handle samplerate changes - break; - default: - // Unknown metadata is not an error. - break; - } - } - - signals_changed(); -} - -void Session::feed_in_frame_begin() -{ - if (cur_logic_snapshot_ || !cur_analog_snapshots_.empty()) - frame_began(); -} - -void Session::feed_in_logic(shared_ptr logic) -{ - lock_guard lock(data_mutex_); - - if (!logic_data_) - { - qDebug() << "Unexpected logic packet"; - return; - } - - if (!cur_logic_snapshot_) - { - // This could be the first packet after a trigger - set_capture_state(Running); - - // Get sample limit. - const auto keys = device_->config_keys( - ConfigKey::DEVICE_OPTIONS); - const auto iter = keys.find(ConfigKey::LIMIT_SAMPLES); - const uint64_t sample_limit = (iter != keys.end() && - (*iter).second.find(sigrok::GET) != - (*iter).second.end()) ? - VariantBase::cast_dynamic>( - device_->config_get(ConfigKey::LIMIT_SAMPLES)).get() : 0; - - // Create a new data snapshot - cur_logic_snapshot_ = shared_ptr( - new data::LogicSnapshot(logic, sample_limit)); - logic_data_->push_snapshot(cur_logic_snapshot_); - - // @todo Putting this here means that only listeners querying - // for logic will be notified. Currently the only user of - // frame_began is DecoderStack, but in future we need to signal - // this after both analog and logic sweeps have begun. - frame_began(); - } - else - { - // Append to the existing data snapshot - cur_logic_snapshot_->append_payload(logic); - } - - data_received(); -} - -void Session::feed_in_analog(shared_ptr analog) -{ - lock_guard lock(data_mutex_); - - const vector> channels = analog->channels(); - const unsigned int channel_count = channels.size(); - const size_t sample_count = analog->num_samples() / channel_count; - const float *data = analog->data_pointer(); - bool sweep_beginning = false; - - for (auto channel : channels) - { - shared_ptr snapshot; - - // Try to get the snapshot of the channel - const map< shared_ptr, shared_ptr >:: - iterator iter = cur_analog_snapshots_.find(channel); - if (iter != cur_analog_snapshots_.end()) - snapshot = (*iter).second; - else - { - // If no snapshot was found, this means we havn't - // created one yet. i.e. this is the first packet - // in the sweep containing this snapshot. - sweep_beginning = true; - - // Get sample limit. - uint64_t sample_limit; - try { - sample_limit = VariantBase::cast_dynamic>( - device_->config_get(ConfigKey::LIMIT_SAMPLES)).get(); - } catch (Error) { - sample_limit = 0; - } - - // Create a snapshot, keep it in the maps of channels - snapshot = shared_ptr( - new data::AnalogSnapshot(sample_limit)); - cur_analog_snapshots_[channel] = snapshot; - - // Find the annalog data associated with the channel - shared_ptr sig = - dynamic_pointer_cast( - signal_from_channel(channel)); - assert(sig); - - shared_ptr data(sig->analog_data()); - assert(data); - - // Push the snapshot into the analog data. - data->push_snapshot(snapshot); - } - - assert(snapshot); - - // Append the samples in the snapshot - snapshot->append_interleaved_samples(data++, sample_count, - channel_count); - } - - if (sweep_beginning) { - // This could be the first packet after a trigger - set_capture_state(Running); - } - - data_received(); -} - -void Session::data_feed_in(shared_ptr device, shared_ptr packet) -{ - assert(device); - assert(packet); - - switch (packet->type()->id()) { - case SR_DF_HEADER: - feed_in_header(device); - break; - - case SR_DF_META: - feed_in_meta(device, dynamic_pointer_cast(packet->payload())); - break; - - case SR_DF_FRAME_BEGIN: - feed_in_frame_begin(); - break; - - case SR_DF_LOGIC: - feed_in_logic(dynamic_pointer_cast(packet->payload())); - break; - - case SR_DF_ANALOG: - feed_in_analog(dynamic_pointer_cast(packet->payload())); - break; - - case SR_DF_END: - { - { - lock_guard lock(data_mutex_); - cur_logic_snapshot_.reset(); - cur_analog_snapshots_.clear(); - } - frame_ended(); - break; - } - default: - break; - } -} - -} // namespace pv diff --git a/pv/sigsession.hpp b/pv/sigsession.hpp deleted file mode 100644 index c6a317de..00000000 --- a/pv/sigsession.hpp +++ /dev/null @@ -1,190 +0,0 @@ -/* - * This file is part of the PulseView project. - * - * Copyright (C) 2012-14 Joel Holdsworth - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA - */ - -#ifndef PULSEVIEW_PV_SIGSESSION_H -#define PULSEVIEW_PV_SIGSESSION_H - -#include -#include -#include -#include -#include -#include -#include - -#include - -#include -#include - -struct srd_decoder; -struct srd_channel; - -namespace sigrok { - class Analog; - class Channel; - class Device; - class Logic; - class Meta; - class Packet; - class Session; -} - -namespace pv { - -class DeviceManager; - -namespace data { -class Analog; -class AnalogSnapshot; -class Logic; -class LogicSnapshot; -class SignalData; -} - -namespace view { -class DecodeTrace; -class LogicSignal; -class Signal; -} - -class Session : public QObject -{ - Q_OBJECT - -public: - enum capture_state { - Stopped, - AwaitingTrigger, - Running - }; - -public: - Session(DeviceManager &device_manager); - - ~Session(); - - DeviceManager& device_manager(); - - const DeviceManager& device_manager() const; - - const std::shared_ptr& session() const; - - std::shared_ptr device() const; - - /** - * Sets device instance that will be used in the next capture session. - */ - void set_device(std::shared_ptr device); - - void set_file(const std::string &name); - - void set_default_device(); - - capture_state get_capture_state() const; - - void start_capture(std::function error_handler); - - void stop_capture(); - - std::set< std::shared_ptr > get_data() const; - - boost::shared_mutex& signals_mutex() const; - - const std::vector< std::shared_ptr >& signals() const; - -#ifdef ENABLE_DECODE - bool add_decoder(srd_decoder *const dec); - - std::vector< std::shared_ptr > - get_decode_signals() const; - - void remove_decode_signal(view::DecodeTrace *signal); -#endif - -private: - void set_capture_state(capture_state state); - - void update_signals(std::shared_ptr device); - - std::shared_ptr signal_from_channel( - std::shared_ptr channel) const; - - void read_sample_rate(std::shared_ptr); - -private: - void sample_thread_proc(std::shared_ptr device, - std::function error_handler); - - void feed_in_header(std::shared_ptr device); - - void feed_in_meta(std::shared_ptr device, - std::shared_ptr meta); - - void feed_in_frame_begin(); - - void feed_in_logic(std::shared_ptr logic); - - void feed_in_analog(std::shared_ptr analog); - - void data_feed_in(std::shared_ptr device, - std::shared_ptr packet); - -private: - DeviceManager &device_manager_; - std::shared_ptr session_; - - /** - * The device instance that will be used in the next capture session. - */ - std::shared_ptr device_; - - std::vector< std::shared_ptr > decode_traces_; - - mutable std::mutex sampling_mutex_; - capture_state capture_state_; - - mutable boost::shared_mutex signals_mutex_; - std::vector< std::shared_ptr > signals_; - - mutable std::mutex data_mutex_; - std::shared_ptr logic_data_; - std::shared_ptr cur_logic_snapshot_; - std::map< std::shared_ptr, std::shared_ptr > - cur_analog_snapshots_; - - std::thread sampling_thread_; - -Q_SIGNALS: - void capture_state_changed(int state); - void device_selected(); - - void signals_changed(); - - void frame_began(); - - void data_received(); - - void frame_ended(); -}; - -} // namespace pv - -#endif // PULSEVIEW_PV_SIGSESSION_H diff --git a/pv/storesession.cpp b/pv/storesession.cpp index 221804c4..2e90871c 100644 --- a/pv/storesession.cpp +++ b/pv/storesession.cpp @@ -22,7 +22,7 @@ #include "storesession.hpp" -#include +#include #include #include #include diff --git a/pv/toolbars/samplingbar.hpp b/pv/toolbars/samplingbar.hpp index 25ce23ae..436304bc 100644 --- a/pv/toolbars/samplingbar.hpp +++ b/pv/toolbars/samplingbar.hpp @@ -31,7 +31,7 @@ #include #include -#include +#include #include #include diff --git a/pv/view/decodetrace.cpp b/pv/view/decodetrace.cpp index 79058956..0fbd16fd 100644 --- a/pv/view/decodetrace.cpp +++ b/pv/view/decodetrace.cpp @@ -41,7 +41,7 @@ extern "C" { #include "decodetrace.hpp" -#include +#include #include #include #include diff --git a/pv/view/header.cpp b/pv/view/header.cpp index 08b3fdd2..2269849c 100644 --- a/pv/view/header.cpp +++ b/pv/view/header.cpp @@ -35,7 +35,7 @@ #include #include -#include +#include #include using boost::make_filter_iterator; diff --git a/pv/view/logicsignal.cpp b/pv/view/logicsignal.cpp index 22b39bbb..fc81a4a9 100644 --- a/pv/view/logicsignal.cpp +++ b/pv/view/logicsignal.cpp @@ -31,7 +31,7 @@ #include "logicsignal.hpp" #include "view.hpp" -#include +#include #include #include #include diff --git a/pv/view/rowitemiterator.hpp b/pv/view/rowitemiterator.hpp index 110dc574..577b4713 100644 --- a/pv/view/rowitemiterator.hpp +++ b/pv/view/rowitemiterator.hpp @@ -31,7 +31,7 @@ #include -#include +#include namespace pv { namespace view { diff --git a/pv/view/view.cpp b/pv/view/view.cpp index c9606353..a5114027 100644 --- a/pv/view/view.cpp +++ b/pv/view/view.cpp @@ -44,7 +44,7 @@ #include "view.hpp" #include "viewport.hpp" -#include "pv/sigsession.hpp" +#include "pv/session.hpp" #include "pv/data/logic.hpp" #include "pv/data/logicsnapshot.hpp" diff --git a/pv/view/viewport.cpp b/pv/view/viewport.cpp index fbbb52bf..a94ada93 100644 --- a/pv/view/viewport.cpp +++ b/pv/view/viewport.cpp @@ -26,7 +26,7 @@ #include "view.hpp" #include "viewport.hpp" -#include +#include #include diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index c4d4e718..10f26ddc 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -20,7 +20,7 @@ set(pulseview_TEST_SOURCES ${PROJECT_SOURCE_DIR}/pv/devicemanager.cpp - ${PROJECT_SOURCE_DIR}/pv/sigsession.cpp + ${PROJECT_SOURCE_DIR}/pv/session.cpp ${PROJECT_SOURCE_DIR}/pv/storesession.cpp ${PROJECT_SOURCE_DIR}/pv/util.cpp ${PROJECT_SOURCE_DIR}/pv/data/analog.cpp @@ -69,7 +69,7 @@ set(pulseview_TEST_SOURCES # This list includes only QObject derived class headers. set(pulseview_TEST_HEADERS - ${PROJECT_SOURCE_DIR}/pv/sigsession.hpp + ${PROJECT_SOURCE_DIR}/pv/session.hpp ${PROJECT_SOURCE_DIR}/pv/storesession.hpp ${PROJECT_SOURCE_DIR}/pv/popups/channels.hpp ${PROJECT_SOURCE_DIR}/pv/popups/deviceoptions.hpp diff --git a/test/data/decoderstack.cpp b/test/data/decoderstack.cpp index ceb5147f..c169e1ff 100644 --- a/test/data/decoderstack.cpp +++ b/test/data/decoderstack.cpp @@ -25,7 +25,7 @@ #include "../../pv/data/decoderstack.hpp" #include "../../pv/devicemanager.hpp" -#include "../../pv/sigsession.hpp" +#include "../../pv/session.hpp" #include "../../pv/view/decodetrace.hpp" using pv::data::DecoderStack;