DSView/DSLogic-gui/pv/sigsession.h
2014-04-14 17:46:11 +08:00

266 lines
7.1 KiB
C++

/*
* This file is part of the DSLogic-gui project.
* DSLogic-gui is based on PulseView.
*
* Copyright (C) 2012 Joel Holdsworth <joel@airwebreathe.org.uk>
* Copyright (C) 2013 DreamSourceLab <dreamsourcelab@dreamsourcelab.com>
*
* 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 DSLOGIC_PV_SIGSESSION_H
#define DSLOGIC_PV_SIGSESSION_H
#include <boost/function.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
#include <boost/thread.hpp>
#include <string>
#include <utility>
#include <vector>
#include <QObject>
#include <QString>
#include <QLine>
#include <QVector>
#include <QMap>
#include <QVariant>
#include <libsigrok4DSLogic/libsigrok.h>
#include <libusb.h>
namespace pv {
class DeviceManager;
namespace data {
class Analog;
class AnalogSnapshot;
class Dso;
class DsoSnapshot;
class Logic;
class LogicSnapshot;
class Group;
class GroupSnapshot;
}
namespace view {
class Signal;
}
namespace decoder {
class Decoder;
class DecoderFactory;
}
class SigSession : public QObject
{
Q_OBJECT
private:
static const float Oversampling;
public:
enum capture_state {
Init,
Stopped,
Running
};
public:
SigSession(DeviceManager &device_manager);
~SigSession();
struct sr_dev_inst* get_device() const;
/**
* Sets device instance that will be used in the next capture session.
*/
int set_device(struct sr_dev_inst *sdi);
void release_device(struct sr_dev_inst *sdi);
void load_file(const std::string &name,
boost::function<void (const QString)> error_handler);
void save_file(const std::string &name);
capture_state get_capture_state() const;
void start_capture(uint64_t record_length,
boost::function<void (const QString)> error_handler);
void stop_capture();
std::vector< boost::shared_ptr<view::Signal> >
get_signals();
std::vector< boost::shared_ptr<view::Signal> >
get_pro_signals();
int get_logic_probe_cnt(const struct sr_dev_inst *sdi);
int get_dso_probe_cnt(const struct sr_dev_inst *sdi);
int get_analog_probe_cnt(const struct sr_dev_inst *sdi);
void init_signals(const struct sr_dev_inst *sdi);
void update_signals(const struct sr_dev_inst *sdi);
void add_group();
void del_group();
void add_protocol(std::list<int> probe_index_list, decoder::Decoder *decoder);
void del_protocol(int protocol_index);
void del_signal(std::vector< boost::shared_ptr<view::Signal> >::iterator i);
boost::shared_ptr<data::Logic> get_data();
void* get_buf(int& unit_size, uint64_t& length);
quint64 get_last_sample_rate() const;
quint64 get_total_sample_len() const;
void set_total_sample_len(quint64 length);
QVector<std::pair<decoder::Decoder *, std::list<int> > > get_decoders() const;
void add_protocol_analyzer(int decoder_index, std::list<int> _sel_probes,
QMap<QString, QVariant> &_options, QMap<QString, int> _options_index);
void rst_protocol_analyzer(int rst_index, std::list<int> _sel_probes,
QMap<QString, QVariant> &_options, QMap<QString, int> _options_index);
void del_protocol_analyzer(int protocol_index);
std::list<int> get_decode_probes(int decode_index);
QMap<QString, int> get_decode_options_index(int decode_index);
void start_hotplug_proc(boost::function<void (const QString)> error_handler);
void stop_hotplug_proc();
void register_hotplug_callback();
void deregister_hotplug_callback();
void set_adv_trigger(bool adv_trigger);
private:
void set_capture_state(capture_state state);
private:
void load_thread_proc(const std::string name,
boost::function<void (const QString)> error_handler);
void sample_thread_proc(struct sr_dev_inst *sdi,
uint64_t record_length,
boost::function<void (const QString)> error_handler);
void feed_in_header(const sr_dev_inst *sdi);
void feed_in_meta(const sr_dev_inst *sdi,
const sr_datafeed_meta &meta);
void feed_in_trigger(const ds_trigger_pos &trigger_pos);
void feed_in_logic(const sr_datafeed_logic &logic);
void feed_in_dso(const sr_datafeed_dso &dso);
void feed_in_analog(const sr_datafeed_analog &analog);
void data_feed_in(const struct sr_dev_inst *sdi,
const struct sr_datafeed_packet *packet);
static void data_feed_in_proc(const struct sr_dev_inst *sdi,
const struct sr_datafeed_packet *packet, void *cb_data);
void hotplug_proc(boost::function<void (const QString)> error_handler);
static int hotplug_callback(struct libusb_context *ctx, struct libusb_device *dev,
libusb_hotplug_event event, void *user_data);
private:
DeviceManager &_device_manager;
/**
* The device instance that will be used in the next capture session.
*/
struct sr_dev_inst *_sdi;
mutable boost::mutex _sampling_mutex;
capture_state _capture_state;
mutable boost::mutex _signals_mutex;
std::vector< boost::shared_ptr<view::Signal> > _signals;
decoder::DecoderFactory *_decoderFactory;
QVector< std::pair<decoder::Decoder* , std::list<int> > > _decoders;
std::vector< boost::shared_ptr<view::Signal> > _protocol_signals;
mutable boost::mutex _data_mutex;
boost::shared_ptr<data::Logic> _logic_data;
boost::shared_ptr<data::LogicSnapshot> _cur_logic_snapshot;
boost::shared_ptr<data::Dso> _dso_data;
boost::shared_ptr<data::DsoSnapshot> _cur_dso_snapshot;
boost::shared_ptr<data::Analog> _analog_data;
boost::shared_ptr<data::AnalogSnapshot> _cur_analog_snapshot;
boost::shared_ptr<data::Group> _group_data;
boost::shared_ptr<data::GroupSnapshot> _cur_group_snapshot;
int _group_cnt;
int _protocol_cnt;
std::auto_ptr<boost::thread> _sampling_thread;
quint64 _last_sample_rate;
quint64 _total_sample_len;
libusb_hotplug_callback_handle _hotplug_handle;
std::auto_ptr<boost::thread> _hotplug;
bool _hot_attach;
bool _hot_detach;
bool _adv_trigger;
signals:
void capture_state_changed(int state);
void signals_changed();
void data_updated();
void sample_rate_changed(quint64 sample_rate);
void receive_data(quint64 length);
void device_attach();
void device_detach();
void test_data_error();
void receive_trigger(quint64 trigger_pos);
public slots:
private:
// TODO: This should not be necessary. Multiple concurrent
// sessions should should be supported and it should be
// possible to associate a pointer with a ds_session.
static SigSession *_session;
};
} // namespace pv
#endif // DSLOGIC_PV_SIGSESSION_H