56 #include <libsigrokcxx/libsigrokcxx.hpp> 59 #include <gstreamermm.h> 60 #include <libsigrokflow/libsigrokflow.hpp> 64 #include <libsigrokdecode/libsigrokdecode.h> 69 using std::dynamic_pointer_cast;
73 using std::lock_guard;
75 using std::make_shared;
81 using std::recursive_mutex;
82 using std::runtime_error;
83 using std::shared_ptr;
86 using std::unique_lock;
88 using std::unique_ptr;
92 using sigrok::Channel;
93 using sigrok::ConfigKey;
94 using sigrok::DatafeedCallbackFunction;
96 using sigrok::InputFormat;
100 using sigrok::Session;
102 using Glib::VariantBase;
106 using Gst::ElementFactory;
121 shutting_down_(false),
122 device_manager_(device_manager),
125 capture_state_(Stopped),
130 setObjectName(
name_);
159 return shared_ptr<sigrok::Session>();
181 setObjectName(
name_);
224 int decode_signal_count = 0;
225 int gen_signal_count = 0;
228 for (
const shared_ptr<data::SignalBase>& base :
signalbases_) {
230 if (base->is_decode_signal()) {
231 settings.beginGroup(
"decode_signal" + QString::number(decode_signal_count++));
232 base->save_settings(settings);
236 if (base->is_generated()) {
237 settings.beginGroup(
"generated_signal" + QString::number(gen_signal_count++));
238 settings.setValue(
"type", base->type());
239 base->save_settings(settings);
242 settings.beginGroup(base->internal_name());
243 base->save_settings(settings);
248 settings.setValue(
"decode_signals", decode_signal_count);
249 settings.setValue(
"generated_signals", gen_signal_count);
254 settings.beginGroup(
"view" + QString::number(i++));
258 for (
const shared_ptr<views::ViewBase>& view :
views_) {
260 settings.beginGroup(
"view" + QString::number(i++));
261 settings.setValue(
"type", view->get_type());
262 view->save_settings(settings);
267 settings.setValue(
"views", i);
271 for (
const shared_ptr<views::ViewBase>& vb : views_) {
274 for (
const shared_ptr<views::trace::TimeItem>& time_item : tv->time_items()) {
276 const shared_ptr<views::trace::Flag> flag =
279 if (!flag->enabled())
282 settings.beginGroup(
"meta_obj" + QString::number(i++));
283 settings.setValue(
"type",
"time_marker");
284 settings.setValue(
"assoc_view", view_id);
286 settings.setValue(
"text", flag->get_text());
291 if (tv->cursors_shown()) {
292 settings.beginGroup(
"meta_obj" + QString::number(i++));
293 settings.setValue(
"type",
"selection");
294 settings.setValue(
"assoc_view", view_id);
295 const shared_ptr<views::trace::CursorPair> cp = tv->cursors();
305 settings.setValue(
"meta_objs", i);
310 map<string, string> dev_info;
311 list<string> key_list;
314 shared_ptr<devices::HardwareDevice> hw_device =
318 settings.setValue(
"device_type",
"hardware");
319 settings.beginGroup(
"device");
321 key_list.emplace_back(
"vendor");
322 key_list.emplace_back(
"model");
323 key_list.emplace_back(
"version");
324 key_list.emplace_back(
"serial_num");
325 key_list.emplace_back(
"connection_id");
329 for (
string& key : key_list) {
330 if (dev_info.count(key))
331 settings.setValue(QString::fromUtf8(key.c_str()),
332 QString::fromUtf8(dev_info.at(key).c_str()));
334 settings.remove(QString::fromUtf8(key.c_str()));
345 settings.setValue(
"device_type",
"sessionfile");
346 settings.beginGroup(
"device");
347 settings.setValue(
"filename", fi.absoluteFilePath());
350 shared_ptr<devices::SessionFile> sessionfile_device =
353 if (sessionfile_device) {
354 settings.setValue(
"device_type",
"sessionfile");
355 settings.beginGroup(
"device");
356 settings.setValue(
"filename", QString::fromStdString(
357 sessionfile_device->full_name()));
361 shared_ptr<devices::InputFile> inputfile_device =
364 if (inputfile_device) {
365 settings.setValue(
"device_type",
"inputfile");
366 settings.beginGroup(
"device");
367 inputfile_device->save_meta_to_settings(settings);
379 for (shared_ptr<data::SignalBase> base :
signalbases_) {
380 settings.beginGroup(base->internal_name());
381 base->restore_settings(settings);
386 int gen_signal_count = settings.value(
"generated_signals").toInt();
388 for (
int i = 0; i < gen_signal_count; i++) {
389 settings.beginGroup(
"generated_signal" + QString::number(i));
390 SignalBase::ChannelType type = (SignalBase::ChannelType)settings.value(
"type").toInt();
391 shared_ptr<data::SignalBase> signal;
393 if (type == SignalBase::MathChannel)
394 signal = make_shared<data::MathSignal>(*this);
396 qWarning() << tr(
"Can't restore generated signal of unknown type %1 (%2)") \
398 .arg(settings.value(
"name").toString());
402 signal->restore_settings(settings);
410 int decode_signal_count = settings.value(
"decode_signals").toInt();
412 for (
int i = 0; i < decode_signal_count; i++) {
413 settings.beginGroup(
"decode_signal" + QString::number(i));
414 shared_ptr<data::DecodeSignal> signal = add_decode_signal();
415 signal->restore_settings(settings);
421 int views = settings.value(
"views").toInt();
423 for (
int i = 0; i <
views; i++) {
424 settings.beginGroup(
"view" + QString::number(i));
429 views_.back()->restore_settings(settings);
437 int meta_objs = settings.value(
"meta_objs").toInt();
439 for (
int i = 0; i < meta_objs; i++) {
440 settings.beginGroup(
"meta_obj" + QString::number(i));
442 shared_ptr<views::ViewBase> vb;
443 shared_ptr<views::trace::View> tv;
444 if (settings.contains(
"assoc_view"))
445 vb =
views_.at(settings.value(
"assoc_view").toInt());
450 const QString type = settings.value(
"type").toString();
452 if ((type ==
"time_marker") && tv) {
454 shared_ptr<views::trace::Flag> flag = tv->add_flag(ts);
455 flag->set_text(settings.value(
"text").toString());
458 if ((type ==
"selection") && tv) {
461 tv->set_cursors(start, end);
471 shared_ptr<devices::Device>
device;
473 const QString device_type = settings.value(
"device_type").toString();
475 if (device_type ==
"hardware") {
476 map<string, string> dev_info;
477 list<string> key_list;
480 settings.beginGroup(
"device");
481 key_list.emplace_back(
"vendor");
482 key_list.emplace_back(
"model");
483 key_list.emplace_back(
"version");
484 key_list.emplace_back(
"serial_num");
485 key_list.emplace_back(
"connection_id");
487 for (
string key : key_list) {
488 const QString k = QString::fromStdString(key);
489 if (!settings.contains(k))
492 const string value = settings.value(k).toString().toStdString();
494 dev_info.insert(make_pair(key, value));
497 if (dev_info.count(
"model") > 0)
510 if ((device_type ==
"sessionfile") || (device_type ==
"inputfile")) {
511 if (device_type ==
"sessionfile") {
512 settings.beginGroup(
"device");
513 filename = settings.value(
"filename").toString();
516 if (QFileInfo(filename).isReadable())
518 filename.toStdString());
521 if (device_type ==
"inputfile") {
522 settings.beginGroup(
"device");
535 qDebug() <<
"Session error:" << infoMessage; });
538 dynamic_pointer_cast<devices::File>(device)->display_name(
device_manager_)));
540 if (!filename.isEmpty()) {
542 if (device_type ==
"sessionfile")
545 set_name(QFileInfo(filename).fileName());
558 }
catch (
const QString &
e) {
580 for (shared_ptr<views::ViewBase> view :
views_) {
581 view->clear_signalbases();
583 view->clear_decode_signals();
585 view->reset_view_state();
592 signal_groups_.clear();
597 all_signal_data_.clear();
602 shared_ptr<sigrok::Channel>(entry.first).reset();
603 shared_ptr<data::AnalogSegment>(entry.second).reset();
614 }
catch (
const QString &
e) {
620 device_->session()->add_datafeed_callback([=]
621 (shared_ptr<sigrok::Device> device, shared_ptr<Packet> packet) {
633 const list< shared_ptr<devices::HardwareDevice> > &devices =
640 const auto iter = find_if(devices.begin(), devices.end(),
641 [] (
const shared_ptr<devices::HardwareDevice> &d) {
642 return d->hardware_device()->driver()->name() ==
"demo"; });
643 set_device((iter == devices.end()) ? devices.front() : *iter);
648 shared_ptr<devices::SessionFile> sessionfile_device =
651 shared_ptr<devices::InputFile> inputfile_device =
654 return (sessionfile_device || inputfile_device);
665 map<string, Glib::VariantBase>
667 map<
string, shared_ptr<Option>> fmt_opts)
669 map<string, Glib::VariantBase> result;
671 for (
auto& entry : user_spec) {
677 size_t pos = entry.find(
"=");
678 if (pos == std::string::npos) {
682 key = entry.substr(0, pos);
683 val = entry.substr(pos + 1);
692 auto found = fmt_opts.find(key);
693 if (found == fmt_opts.end()) {
694 qCritical() <<
"Supplied input option" << QString::fromStdString(key) <<
695 "is not a valid option for this input module, it will be ignored!";
699 shared_ptr<Option> opt = found->second;
700 result[key] = opt->parse_string(val);
707 const string &
format,
const string &setup_file_name)
709 shared_ptr<InputFormat> input_format;
710 map<string, Glib::VariantBase> input_opts;
712 if (!format.empty()) {
713 const map<string, shared_ptr<InputFormat> > formats =
716 string user_name = user_opts.front();
717 user_opts.erase(user_opts.begin());
718 const auto iter = find_if(formats.begin(), formats.end(),
719 [&](
const pair<string, shared_ptr<InputFormat> > f) {
720 return f.first == user_name; });
721 if (iter == formats.end()) {
723 tr(
"Unexpected input format: %1").arg(QString::fromStdString(format)));
726 input_format = (*iter).second;
728 input_format->options());
731 load_file(QString::fromStdString(file_name), QString::fromStdString(setup_file_name),
732 input_format, input_opts);
736 shared_ptr<sigrok::InputFormat>
format,
const map<string, Glib::VariantBase> &
options)
738 const QString errorMessage(
739 QString(
"Failed to load file %1").arg(file_name));
750 file_name.toStdString(),
756 file_name.toStdString())));
765 if (setup_file_name.isEmpty()) {
766 setup_file_name = file_name;
767 setup_file_name.truncate(setup_file_name.lastIndexOf(
'.'));
768 setup_file_name.append(
".pvs");
771 if (QFileInfo::exists(setup_file_name) && QFileInfo(setup_file_name).isReadable()) {
772 QSettings settings_storage(setup_file_name, QSettings::IniFormat);
782 if (dynamic_pointer_cast<devices::SessionFile>(
device_))
785 set_name(QFileInfo(file_name).fileName());
797 error_handler(tr(
"No active device set, can't start acquisition."));
804 const shared_ptr<sigrok::Device> sr_dev =
device_->device();
806 const auto channels = sr_dev->channels();
807 if (!any_of(channels.begin(), channels.end(),
808 [](shared_ptr<Channel> channel) {
809 return channel->enabled(); })) {
810 error_handler(tr(
"No channels enabled."));
824 shared_ptr<devices::HardwareDevice> hw_device =
859 vector< shared_ptr<data::SignalBase> > view_signalbases = view->signalbases();
861 for (
const shared_ptr<data::SignalBase>& signalbase :
signalbases_) {
862 const int sb_exists = count_if(
863 view_signalbases.cbegin(), view_signalbases.cend(),
864 [&](
const shared_ptr<data::SignalBase> &sb) {
865 return sb == signalbase;
870 switch (signalbase->type()) {
874 view->add_signalbase(signalbase);
878 view->add_decode_signal(dynamic_pointer_cast<data::DecodeSignal>(signalbase));
890 [&](shared_ptr<views::ViewBase> v) {
return v == view; }),
903 for (shared_ptr<views::ViewBase>& v :
views_)
912 double samplerate = 0.0;
916 const vector< shared_ptr<pv::data::Segment> > segments =
918 for (
const shared_ptr<pv::data::Segment>& s : segments)
919 samplerate =
max(samplerate, s->samplerate());
922 if (samplerate == 0.0)
948 vector<util::Timestamp> result;
950 for (
const pair<uint32_t, util::Timestamp>& entry :
trigger_list_)
951 if (entry.first == segment_id)
952 result.push_back(entry.second);
965 [&] (shared_ptr<SignalBase> sb) {
return sb->type() == type; });
978 for (shared_ptr<views::ViewBase>& view :
views_)
979 view->add_signalbase(signal);
990 [&](shared_ptr<data::SignalBase> s) {
return s == signal; }),
993 for (shared_ptr<views::ViewBase>& view :
views_)
994 view->remove_signalbase(signal);
1000 shared_ptr<data::DecodeSignal> Session::add_decode_signal()
1002 shared_ptr<data::DecodeSignal> signal;
1006 signal = make_shared<data::DecodeSignal>(*this);
1011 for (shared_ptr<views::ViewBase>& view :
views_)
1012 view->add_decode_signal(signal);
1013 }
catch (runtime_error&
e) {
1014 remove_decode_signal(signal);
1023 void Session::remove_decode_signal(shared_ptr<data::DecodeSignal> signal)
1029 [&](shared_ptr<data::SignalBase> s) {
return s == signal; }),
1032 for (shared_ptr<views::ViewBase>& view :
views_)
1033 view->remove_decode_signal(signal);
1041 bool all_complete =
true;
1043 for (
const shared_ptr<data::SignalBase>& base :
signalbases_)
1044 if (!base->segment_is_complete(segment_id))
1045 all_complete =
false;
1047 return all_complete;
1063 qDebug(
"Acquisition took %.2f s",
acq_time_.elapsed() / 1000.);
1078 for (shared_ptr<views::ViewBase>& view :
views_) {
1079 view->clear_signalbases();
1080 #ifdef ENABLE_DECODE 1081 view->clear_decode_signals();
1089 const shared_ptr<sigrok::Device> sr_dev =
device_->device();
1093 for (shared_ptr<views::ViewBase>& view :
views_) {
1094 view->clear_signalbases();
1095 #ifdef ENABLE_DECODE 1096 view->clear_decode_signals();
1103 auto channels = sr_dev->channels();
1104 unsigned int logic_channel_count = count_if(
1105 channels.begin(), channels.end(),
1106 [] (shared_ptr<Channel> channel) {
1107 return channel->type() == sigrok::ChannelType::LOGIC; });
1111 lock_guard<recursive_mutex> data_lock(
data_mutex_);
1113 if (logic_channel_count == 0) {
1116 logic_data_->num_channels() != logic_channel_count) {
1123 for (
auto channel : sr_dev->channels()) {
1127 [&](
const shared_ptr<SignalBase> &sb) {
return sb->channel() == channel; });
1131 shared_ptr<SignalBase> signalbase;
1132 switch(channel->type()->id()) {
1133 case SR_CHANNEL_LOGIC:
1141 signalbase.get(), SLOT(on_capture_state_changed(
int)));
1144 case SR_CHANNEL_ANALOG:
1150 signalbase->set_data(data);
1153 signalbase.get(), SLOT(on_capture_state_changed(
int)));
1161 for (
auto& entry : sr_dev->channel_groups()) {
1162 const shared_ptr<sigrok::ChannelGroup>& group = entry.second;
1164 if (group->channels().size() <= 1)
1168 for (
const shared_ptr<sigrok::Channel>& channel : group->channels()) {
1170 if (s->channel() == channel) {
1181 for (shared_ptr<views::ViewBase>& viewbase :
views_) {
1182 vector< shared_ptr<SignalBase> > view_signalbases =
1183 viewbase->signalbases();
1186 for (shared_ptr<SignalBase>& session_sb :
signalbases_) {
1187 if (session_sb->type() == SignalBase::DecodeChannel)
1190 const auto iter = find_if(view_signalbases.cbegin(), view_signalbases.cend(),
1191 [&](
const shared_ptr<SignalBase> &sb) {
return sb == session_sb; });
1193 if (iter == view_signalbases.cend())
1194 viewbase->add_signalbase(session_sb);
1198 for (shared_ptr<SignalBase>& view_sb : view_signalbases) {
1199 if (view_sb->type() == SignalBase::DecodeChannel)
1202 const auto iter = find_if(signalbases_.cbegin(), signalbases_.cend(),
1203 [&](
const shared_ptr<SignalBase> &sb) {
return sb == view_sb; });
1205 if (iter == signalbases_.cend())
1206 viewbase->remove_signalbase(view_sb);
1214 shared_ptr<sigrok::Channel> channel)
const 1216 for (shared_ptr<data::SignalBase> sig :
signalbases_) {
1218 if (sig->channel() == channel)
1221 return shared_ptr<data::SignalBase>();
1226 assert(error_handler);
1229 pipeline_ = Pipeline::create();
1231 source_ = ElementFactory::create_element(
"filesrc",
"source");
1232 sink_ = RefPtr<AppSink>::cast_dynamic(ElementFactory::create_element(
"appsink",
"sink"));
1234 pipeline_->add(source_)->add(sink_);
1235 source_->link(sink_);
1237 source_->set_property(
"location", Glib::ustring(
"/tmp/dummy_binary"));
1239 sink_->set_property(
"emit-signals", TRUE);
1240 sink_->signal_new_sample().connect(sigc::mem_fun(*
this, &Session::on_gst_new_sample));
1243 RefPtr<Bus> bus = pipeline_->get_bus();
1244 bus->add_watch(sigc::mem_fun(
this, &Session::on_gst_bus_message));
1247 pipeline_done_interrupt_ =
false;
1248 pipeline_->set_state(Gst::STATE_PLAYING);
1250 unique_lock<mutex> pipeline_done_lock_(pipeline_done_mutex_);
1251 pipeline_done_cond_.wait(pipeline_done_lock_);
1254 pipeline_->set_state(Gst::STATE_NULL);
1262 }
catch (Error&
e) {
1273 sb->clear_sample_data();
1280 }
catch (Error& e) {
1281 error_handler(e.what());
1290 }
catch (Error& e) {
1291 error_handler(e.what());
1294 }
catch (QString& e) {
1304 qDebug() <<
"WARNING: SR_DF_END was not received.";
1311 shared_ptr<devices::File> file_device =
1318 error_handler(tr(
"Out of memory, acquisition stopped."));
1324 const vector< shared_ptr<data::Segment> > segments =
data->segments();
1326 for (
const shared_ptr<data::Segment>& segment : segments)
1327 segment->free_unused_memory();
1333 int new_segment_id = 0;
1340 new_segment_id =
logic_data_->get_segment_count() - 1;
1342 shared_ptr<sigrok::Channel> any_channel =
1348 shared_ptr<data::Analog>
data(base->analog_data());
1351 new_segment_id =
data->get_segment_count() - 1;
1366 for (
const shared_ptr<data::SignalBase>& signalbase :
signalbases_) {
1369 segment_id = signalbase->analog_data()->get_segment_count() - 1;
1374 segment_id = signalbase->logic_data()->get_segment_count() - 1;
1379 if (segment_id >= 0)
1384 bool Session::on_gst_bus_message(
const Glib::RefPtr<Gst::Bus>& bus,
const Glib::RefPtr<Gst::Message>& message)
1388 if ((message->get_source() == pipeline_) && \
1389 ((message->get_message_type() == Gst::MESSAGE_EOS)))
1390 pipeline_done_cond_.notify_one();
1397 Gst::FlowReturn Session::on_gst_new_sample()
1399 RefPtr<Gst::Sample> sample = sink_->pull_sample();
1400 RefPtr<Gst::Buffer> buf = sample->get_buffer();
1402 for (uint32_t block_id = 0; block_id < buf->n_memory(); block_id++) {
1403 RefPtr<Gst::Memory> buf_mem = buf->get_memory(block_id);
1404 Gst::MapInfo mapinfo;
1405 buf_mem->map(mapinfo, Gst::MAP_READ);
1407 shared_ptr<sigrok::Packet> logic_packet =
1408 sr_context->create_logic_packet(mapinfo.get_data(), buf->get_size(), 1);
1411 feed_in_logic(dynamic_pointer_cast<sigrok::Logic>(logic_packet->payload()));
1412 }
catch (bad_alloc&) {
1415 buf_mem->unmap(mapinfo);
1416 return Gst::FLOW_ERROR;
1419 buf_mem->unmap(mapinfo);
1422 return Gst::FLOW_OK;
1433 for (
auto& entry : meta->config()) {
1434 switch (entry.first->id()) {
1435 case SR_CONF_SAMPLERATE:
1439 qDebug() <<
"Received meta data key" << entry.first->id() <<
", ignoring.";
1450 uint64_t sample_count = 0;
1455 uint64_t temp_count = 0;
1457 const vector< shared_ptr<pv::data::Segment> > segments =
1459 for (
const shared_ptr<pv::data::Segment> &s : segments)
1460 temp_count += s->get_sample_count();
1462 if (temp_count > sample_count)
1463 sample_count = temp_count;
1467 uint32_t segment_id = 0;
1504 shared_ptr<data::AnalogSegment> segment = entry.second;
1505 segment->set_complete();
1509 cur_analog_segments_.clear();
1519 if (logic->data_length() == 0) {
1520 qDebug() <<
"WARNING: Received logic packet with 0 samples.";
1524 if (logic->unit_size() > 8)
1525 throw QString(tr(
"Can't handle more than 64 logic channels."));
1530 }
catch (Error&
e) {
1566 if (analog->num_samples() == 0) {
1567 qDebug() <<
"WARNING: Received analog packet with 0 samples.";
1574 }
catch (Error&
e) {
1580 const vector<shared_ptr<Channel>> channels = analog->channels();
1581 bool sweep_beginning =
false;
1583 unique_ptr<float[]>
data(
new float[analog->num_samples() * channels.size()]);
1584 analog->get_data_as_float(
data.get());
1589 float *channel_data =
data.get();
1590 for (
auto& channel : channels) {
1591 shared_ptr<data::AnalogSegment> segment;
1594 const map< shared_ptr<Channel>, shared_ptr<data::AnalogSegment> >::
1597 segment = (*iter).second;
1602 sweep_beginning =
true;
1608 shared_ptr<data::Analog>
data(base->analog_data());
1612 segment = make_shared<data::AnalogSegment>(
1617 data->push_segment(segment);
1625 segment->append_interleaved_samples(channel_data++, analog->num_samples(),
1632 if (sweep_beginning) {
1641 shared_ptr<Packet> packet)
1646 assert(device ==
device_->device());
1649 switch (packet->type()->id()) {
1655 feed_in_meta(dynamic_pointer_cast<Meta>(packet->payload()));
1664 feed_in_logic(dynamic_pointer_cast<Logic>(packet->payload()));
1665 }
catch (bad_alloc&) {
1674 }
catch (bad_alloc&) {
1680 case SR_DF_FRAME_BEGIN:
1684 case SR_DF_FRAME_END:
1699 shared_ptr<data::AnalogSegment> segment = entry.second;
1700 segment->set_complete();
1704 cur_analog_segments_.clear();
1718 #ifdef ENABLE_DECODE 1719 void Session::on_new_decoders_selected(vector<const srd_decoder*> decoders)
1721 assert(decoders.size() > 0);
1723 shared_ptr<data::DecodeSignal> signal = add_decode_signal();
1726 for (
unsigned int i = 0; i < decoders.size(); i++) {
1727 const srd_decoder* d = decoders[i];
1728 signal->stack_decoder(d, !(i < decoders.size() - 1));
shared_ptr< devices::Device > device_
libsigrok allows users to import and export data from files in various formats some of them as generic as others very specific For a list and make sure to check not so common and outright exotic ways to represent data and sigrok tries to suit as many needs as it can To see which formats your version of PulseView just click on the small arrow next to the _Open_ PulseView will ask for the file name to open Once you picked the you may be asked to specify the details of the format
void register_view(shared_ptr< views::ViewBase > view)
vector< shared_ptr< data::SignalBase > > signalbases_
void segment_completed(int segment_id)
void start_capture(function< void(const QString)> error_handler)
void select_device(shared_ptr< devices::Device > device)
const vector< shared_ptr< data::SignalBase > > signalbases() const
void session_error_raised(const QString text, const QString info_text)
void save_settings(QSettings &settings) const
vector< std::pair< uint32_t, util::Timestamp > > trigger_list_
trigger_list_ contains pairs of <segment_id, timestamp> values
Glib::DateTime get_acquisition_start_time() const
static map< string, Glib::VariantBase > input_format_options(vector< string > user_spec, map< string, shared_ptr< Option >> fmt_opts)
void restore_setup(QSettings &settings)
std::thread sampling_thread_
void feed_in_logic(shared_ptr< sigrok::Logic > logic)
shared_ptr< pv::toolbars::MainBar > main_bar() const
void set_device(shared_ptr< devices::Device > device)
const shared_ptr< devices::HardwareDevice > find_device_from_info(const map< string, string > search_info)
void set_main_bar(shared_ptr< pv::toolbars::MainBar > main_bar)
void load_init_file(const string &file_name, const string &format, const string &setup_file_name)
uint32_t get_next_signal_index(data::SignalBase::ChannelType type)
void capture_state_changed(int state)
void signal_new_segment()
const shared_ptr< sigrok::Context > & context() const
void signal_segment_completed()
void sample_thread_proc(function< void(const QString)> error_handler)
Session(DeviceManager &device_manager, QString name)
const list< shared_ptr< devices::HardwareDevice > > & devices() const
shared_ptr< sigrok::Session > session() const
static pv::util::Timestamp restore_timestamp(QSettings &settings, const char *name)
T value(details::expression_node< T > *n)
void restore_settings(QSettings &settings)
unordered_set< shared_ptr< data::SignalData > > all_signal_data_
map< uint8_t, uint32_t > next_index_list_
MetadataObjManager metadata_obj_manager_
static shared_ptr< sigrok::Context > sr_context
shared_ptr< data::LogicSegment > cur_logic_segment_
QString save_path() const
void add_view(ViewType type, Session *session)
MetadataObjManager * metadata_obj_manager()
const map< string, string > get_device_info(const shared_ptr< devices::Device > device)
Mac OS X or Android For some we provide binary for others we provide installers and for others we provide AppImage containers that you can run without the need to install anything Check the the usual way to install PulseView is to install the packages provided by your distro s package manager sometimes only outdated packages are made available to you In that you have two options
void feed_in_meta(shared_ptr< sigrok::Meta > meta)
void add_generated_signal(shared_ptr< data::SignalBase > signal)
shared_ptr< pv::toolbars::MainBar > main_bar_
int32_t highest_segment_id_
void data_feed_in(shared_ptr< sigrok::Device > device, shared_ptr< sigrok::Packet > packet)
Virtual channel generated by math operations.
void deregister_view(shared_ptr< views::ViewBase > view)
T max(const T v0, const T v1)
shared_ptr< devices::Device > device() const
Glib::DateTime acq_start_time_
uint32_t get_highest_segment_id() const
vector< string > split_string(string text, string separator)
void feed_in_frame_begin()
double get_samplerate() const
map< shared_ptr< sigrok::Channel >, shared_ptr< data::AnalogSegment > > cur_analog_segments_
void new_segment(int new_segment_id)
DeviceManager & device_manager()
static void store_timestamp(QSettings &settings, const char *name, const pv::util::Timestamp &ts)
void free_unused_memory()
void set_save_path(QString path)
void append_signal(shared_ptr< SignalBase > signal)
shared_ptr< data::Logic > logic_data_
recursive_mutex data_mutex_
shared_ptr< views::ViewBase > main_view() const
capture_state get_capture_state() const
uint64_t get_segment_sample_count(uint32_t segment_id) const
uint32_t get_signal_count(data::SignalBase::ChannelType type) const
void set_name(QString name)
DeviceManager & device_manager_
void trigger_event(int segment_id, util::Timestamp location)
deque< data::SignalGroup * > signal_groups_
vector< util::Timestamp > get_triggers(uint32_t segment_id) const
shared_ptr< pv::views::ViewBase > main_view_
static void show_session_error(const QString text, const QString info_text)
shared_ptr< data::SignalBase > signalbase_from_channel(shared_ptr< sigrok::Channel > channel) const
vector< shared_ptr< views::ViewBase > > views_
Protocol Decoder channel using libsigrokdecode.
void remove_generated_signal(shared_ptr< data::SignalBase > signal)
void set_default_device()
boost::multiprecision::number< boost::multiprecision::cpp_dec_float< 24 >, boost::multiprecision::et_off > Timestamp
Timestamp type providing yoctosecond resolution.
void feed_in_analog(shared_ptr< sigrok::Analog > analog)
void set_capture_state(capture_state state)
capture_state capture_state_
bool using_file_device() const
bool all_segments_complete(uint32_t segment_id) const
void load_file(QString file_name, QString setup_file_name=QString(), shared_ptr< sigrok::InputFormat > format=nullptr, const map< string, Glib::VariantBase > &options=map< string, Glib::VariantBase >())
const vector< shared_ptr< views::ViewBase > > views() const
vector< uint64_t > segment_sample_count_
bool has_view(shared_ptr< views::ViewBase > view)
mutex sampling_mutex_
Protects access to capture_state_.
void save_setup(QSettings &settings) const