[pulseview.git] / pv / data / signalbase.hpp

/*
 * This file is part of the PulseView project.
 *
 * Copyright (C) 2012 Joel Holdsworth <joel@airwebreathe.org.uk>
 * Copyright (C) 2016 Soeren Apel <soeren@apelpie.net>
 *
 * 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, see <http://www.gnu.org/licenses/>.
 */

#ifndef PULSEVIEW_PV_DATA_SIGNALBASE_HPP
#define PULSEVIEW_PV_DATA_SIGNALBASE_HPP

#include <atomic>
#include <deque>
#include <condition_variable>
#include <thread>
#include <vector>

#include <QColor>
#include <QObject>
#include <QSettings>
#include <QString>
#include <QTimer>
#include <QVariant>

#include <libsigrokcxx/libsigrokcxx.hpp>

#include "segment.hpp"

using std::atomic;
using std::condition_variable;
using std::deque;
using std::enable_shared_from_this;
using std::map;
using std::mutex;
using std::pair;
using std::shared_ptr;
using std::vector;

namespace sigrok {
class Channel;
}

namespace pv {
namespace data {

class Analog;
class AnalogSegment;
class DecoderStack;
class Logic;
class LogicSegment;
class Segment;
class SignalBase;
class SignalData;

class SignalGroup : public QObject
{
	Q_OBJECT

public:
	SignalGroup(const QString& name);

	void append_signal(shared_ptr<SignalBase> signal);
	void remove_signal(shared_ptr<SignalBase> signal);
	deque<shared_ptr<SignalBase>> signals() const;
	void clear();

	const QString name() const;

private:
	deque<shared_ptr<SignalBase>> signals_;
	QString name_;
};


class SignalBase : public QObject, public enable_shared_from_this<SignalBase>
{
	Q_OBJECT

public:
	enum ChannelType {
		AnalogChannel = 1, ///< Analog data
		LogicChannel,  ///< Logic data
		DecodeChannel, ///< Protocol Decoder channel using libsigrokdecode
		MathChannel    ///< Virtual channel generated by math operations
	};

	enum ConversionType {
		NoConversion = 0,
		A2LConversionByThreshold = 1,
		A2LConversionBySchmittTrigger = 2
	};

	/**
	 * Conversion presets range from -1 to n, where 1..n are dependent on
	 * the conversion these presets apply to. -1 and 0 have fixed meanings,
	 * however.
	 */
	enum ConversionPreset {
		NoPreset = -1,     ///< Conversion uses custom values
		DynamicPreset = 0  ///< Conversion uses calculated values
	};

private:
	static const int ColorBGAlpha;
	static const uint64_t ConversionBlockSize;
	static const uint32_t ConversionDelay;

public:
	SignalBase(shared_ptr<sigrok::Channel> channel, ChannelType channel_type);
	virtual ~SignalBase();

public:
	/**
	 * Returns the underlying SR channel.
	 * Generated channels don't have a SR channel.
	 */
	shared_ptr<sigrok::Channel> channel() const;

	/**
	 * Returns enabled status of this channel.
	 */
	bool enabled() const;

	/**
	 * Sets the enabled status of this channel.
	 * @param value Boolean value to set.
	 */
	void set_enabled(bool value);

	/**
	 * Gets the type of this channel.
	 */
	ChannelType type() const;

	/**
	 * Gets the index number of this channel, i.e. a unique ID assigned by
	 * the device driver.
	 */
	unsigned int index() const;

	/**
	 * Sets the index number of this channel, i.e. a unique ID assigned by
	 * the device driver or the logic bit index (see below).
	 * Only use immediately after creating the signal and leave it untouched after.
	 */
	void set_index(unsigned int index);

	/**
	 * Returns which bit of a given sample for this signal represents the
	 * signal itself. This is relevant for compound signals like logic,
	 * rather meaningless for everything else but provided in case there
	 * is a conversion active that provides a digital signal using bit #0.
	 */
	unsigned int logic_bit_index() const;

	/**
	 * Sets the signal group this signal belongs to
	 */
	void set_group(SignalGroup* group);

	/**
	 * Returns the signal group this signal belongs to or nullptr if none
	 */
	SignalGroup* group() const;

	/**
	 * Gets the name of this signal.
	 */
	QString name() const;

	/**
	 * Gets the internal name of this signal, i.e. how the device/generator calls it.
	 */
	QString internal_name() const;

	/**
	 * Sets the internal name of this signal, i.e. how the device/generator calls it.
	 * Only use immediately after creating the signal and leave it untouched after.
	 */
	void set_internal_name(QString internal_name);

	/**
	 * Produces a string for this signal that can be used for display,
	 * i.e. it contains one or both of the signal/internal names.
	 */
	QString display_name() const;

	/**
	 * Sets the name of the signal.
	 */
	virtual void set_name(QString name);

	/**
	 * Get the color of the signal.
	 */
	QColor color() const;

	/**
	 * Set the color of the signal.
	 */
	void set_color(QColor color);

	/**
	 * Get the background color of the signal.
	 */
	QColor bgcolor() const;

	/**
	 * Sets the internal data object.
	 */
	void set_data(shared_ptr<pv::data::SignalData> data);

	/**
	 * Clears all sample data and removes all associated segments.
	 */
	void clear_sample_data();

	/**
	 * Get the internal data as analog data object in case of analog type.
	 */
	shared_ptr<pv::data::Analog> analog_data() const;

	/**
	 * Get the internal data as logic data object in case of logic type.
	 */
	shared_ptr<pv::data::Logic> logic_data() const;

	/**
	 * Determines whether a given segment is complete (i.e. end-of-frame has
	 * been seen). It only considers the original data, not the converted data.
	 */
	bool segment_is_complete(uint32_t segment_id) const;

	/**
	 * Determines whether this signal has any sample data at all.
	 */
	bool has_samples() const;

	/**
	 * Returns the sample rate for this signal.
	 */
	virtual double get_samplerate() const;

	/**
	 * Queries the kind of conversion performed on this channel.
	 */
	ConversionType get_conversion_type() const;

	/**
	 * Changes the kind of conversion performed on this channel.
	 *
	 * Restarts the conversion.
	 */
	void set_conversion_type(ConversionType t);

	/**
	 * Returns all currently known conversion options
	 */
	map<QString, QVariant> get_conversion_options() const;

	/**
	 * Sets the value of a particular conversion option
	 * Note: it is not checked whether the option is valid for the
	 * currently conversion. If it's not, it will be silently ignored.
	 *
	 * Does not restart the conversion.
	 *
	 * @return true if the value is different from before, false otherwise
	 */
	bool set_conversion_option(QString key, QVariant value);

	/**
	 * Returns the threshold(s) used for conversions, if applicable.
	 * The resulting thresholds are given for the chosen conversion, so you
	 * can query thresholds also for conversions which aren't currently active.
	 *
	 * If you want the thresholds for the currently active conversion,
	 * call it either with NoConversion or no parameter.
	 *
	 * @param t the type of conversion to obtain the thresholds for, leave
	 *          empty or use NoConversion if you want to query the currently
	 *          used conversion
	 *
	 * @param always_custom ignore the currently selected preset and always
	 *        return the custom values for this conversion, using 0 if those
	 *        aren't set
	 *
	 * @return a list of threshold(s) used by the chosen conversion
	 */
	vector<double> get_conversion_thresholds(
		const ConversionType t = NoConversion, const bool always_custom=false) const;

	/**
	 * Provides all conversion presets available for the currently active
	 * conversion.
	 *
	 * @return a list of description/ID pairs for each preset
	 */
	vector<pair<QString, int> > get_conversion_presets() const;

	/**
	 * Determines the ID of the currently used conversion preset, which is only
	 * valid for the currently available conversion presets. It is therefore
	 * suggested to call @ref get_conversion_presets right before calling this.
	 *
	 * @return the ID of the currently used conversion preset. -1 if no preset
	 *         is used. In that case, a user setting is used instead.
	 */
	ConversionPreset get_current_conversion_preset() const;

	/**
	 * Sets the conversion preset to be used.
	 *
	 * Does not restart the conversion.
	 *
	 * @param id the id of the preset to use
	 */
	void set_conversion_preset(ConversionPreset id);

#ifdef ENABLE_DECODE
	bool is_decode_signal() const;
#endif

	virtual void save_settings(QSettings &settings) const;
	virtual void restore_settings(QSettings &settings);

	void start_conversion(bool delayed_start=false);

private:
	bool conversion_is_a2l() const;

	uint8_t convert_a2l_threshold(float threshold, float value);
	uint8_t convert_a2l_schmitt_trigger(float lo_thr, float hi_thr,
		float value, uint8_t &state);

	void convert_single_segment_range(AnalogSegment *asegment,
		LogicSegment *lsegment, uint64_t start_sample, uint64_t end_sample);
	void convert_single_segment(pv::data::AnalogSegment *asegment,
		pv::data::LogicSegment *lsegment);
	void conversion_thread_proc();

	void stop_conversion();

Q_SIGNALS:
	void enabled_changed(const bool &value);

	void name_changed(const QString &name);

	void color_changed(const QColor &color);

	void conversion_type_changed(const ConversionType t);

	void samples_cleared();

	void samples_added(uint64_t segment_id, uint64_t start_sample,
		uint64_t end_sample);

	void min_max_changed(float min, float max);

private Q_SLOTS:
	void on_samples_cleared();

	void on_samples_added(SharedPtrToSegment segment, uint64_t start_sample,
		uint64_t end_sample);

	void on_min_max_changed(float min, float max);

	void on_capture_state_changed(int state);

	void on_delayed_conversion_start();

protected:
	shared_ptr<sigrok::Channel> channel_;
	ChannelType channel_type_;
	SignalGroup* group_;
	shared_ptr<pv::data::SignalData> data_;
	shared_ptr<pv::data::SignalData> converted_data_;
	ConversionType conversion_type_;
	map<QString, QVariant> conversion_options_;

	float min_value_, max_value_;

	std::thread conversion_thread_;
	atomic<bool> conversion_interrupt_;
	mutex conversion_input_mutex_;
	condition_variable conversion_input_cond_;
	QTimer delayed_conversion_starter_;

	QString internal_name_, name_;
	QColor color_, bgcolor_;
	unsigned int index_;
};

} // namespace data
} // namespace pv

#endif // PULSEVIEW_PV_DATA_SIGNALBASE_HPP
Commit	Line	Data
	1	/*
	2	* This file is part of the PulseView project.
	3	*
	4	* Copyright (C) 2012 Joel Holdsworth <joel@airwebreathe.org.uk>
	5	* Copyright (C) 2016 Soeren Apel <soeren@apelpie.net>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, see <http://www.gnu.org/licenses/>.
	19	*/
	20
	21	#ifndef PULSEVIEW_PV_DATA_SIGNALBASE_HPP
	22	#define PULSEVIEW_PV_DATA_SIGNALBASE_HPP
	23
	24	#include <atomic>
	25	#include <deque>
	26	#include <condition_variable>
	27	#include <thread>
	28	#include <vector>
	29
	30	#include <QColor>
	31	#include <QObject>
	32	#include <QSettings>
	33	#include <QString>
	34	#include <QTimer>
	35	#include <QVariant>
	36
	37	#include <libsigrokcxx/libsigrokcxx.hpp>
	38
	39	#include "segment.hpp"
	40
	41	using std::atomic;
	42	using std::condition_variable;
	43	using std::deque;
	44	using std::enable_shared_from_this;
	45	using std::map;
	46	using std::mutex;
	47	using std::pair;
	48	using std::shared_ptr;
	49	using std::vector;
	50
	51	namespace sigrok {
	52	class Channel;
	53	}
	54
	55	namespace pv {
	56	namespace data {
	57
	58	class Analog;
	59	class AnalogSegment;
	60	class DecoderStack;
	61	class Logic;
	62	class LogicSegment;
	63	class Segment;
	64	class SignalBase;
	65	class SignalData;
	66
	67	class SignalGroup : public QObject
	68	{
	69	Q_OBJECT
	70
	71	public:
	72	SignalGroup(const QString& name);
	73
	74	void append_signal(shared_ptr<SignalBase> signal);
	75	void remove_signal(shared_ptr<SignalBase> signal);
	76	deque<shared_ptr<SignalBase>> signals() const;
	77	void clear();
	78
	79	const QString name() const;
	80
	81	private:
	82	deque<shared_ptr<SignalBase>> signals_;
	83	QString name_;
	84	};
	85
	86
	87	class SignalBase : public QObject, public enable_shared_from_this<SignalBase>
	88	{
	89	Q_OBJECT
	90
	91	public:
	92	enum ChannelType {
	93	AnalogChannel = 1, ///< Analog data
	94	LogicChannel, ///< Logic data
	95	DecodeChannel, ///< Protocol Decoder channel using libsigrokdecode
	96	MathChannel ///< Virtual channel generated by math operations
	97	};
	98
	99	enum ConversionType {
	100	NoConversion = 0,
	101	A2LConversionByThreshold = 1,
	102	A2LConversionBySchmittTrigger = 2
	103	};
	104
	105	/**
	106	* Conversion presets range from -1 to n, where 1..n are dependent on
	107	* the conversion these presets apply to. -1 and 0 have fixed meanings,
	108	* however.
	109	*/
	110	enum ConversionPreset {
	111	NoPreset = -1, ///< Conversion uses custom values
	112	DynamicPreset = 0 ///< Conversion uses calculated values
	113	};
	114
	115	private:
	116	static const int ColorBGAlpha;
	117	static const uint64_t ConversionBlockSize;
	118	static const uint32_t ConversionDelay;
	119
	120	public:
	121	SignalBase(shared_ptr<sigrok::Channel> channel, ChannelType channel_type);
	122	virtual ~SignalBase();
	123
	124	public:
	125	/**
	126	* Returns the underlying SR channel.
	127	* Generated channels don't have a SR channel.
	128	*/
	129	shared_ptr<sigrok::Channel> channel() const;
	130
	131	/**
	132	* Returns enabled status of this channel.
	133	*/
	134	bool enabled() const;
	135
	136	/**
	137	* Sets the enabled status of this channel.
	138	* @param value Boolean value to set.
	139	*/
	140	void set_enabled(bool value);
	141
	142	/**
	143	* Gets the type of this channel.
	144	*/
	145	ChannelType type() const;
	146
	147	/**
	148	* Gets the index number of this channel, i.e. a unique ID assigned by
	149	* the device driver.
	150	*/
	151	unsigned int index() const;
	152
	153	/**
	154	* Sets the index number of this channel, i.e. a unique ID assigned by
	155	* the device driver or the logic bit index (see below).
	156	* Only use immediately after creating the signal and leave it untouched after.
	157	*/
	158	void set_index(unsigned int index);
	159
	160	/**
	161	* Returns which bit of a given sample for this signal represents the
	162	* signal itself. This is relevant for compound signals like logic,
	163	* rather meaningless for everything else but provided in case there
	164	* is a conversion active that provides a digital signal using bit #0.
	165	*/
	166	unsigned int logic_bit_index() const;
	167
	168	/**
	169	* Sets the signal group this signal belongs to
	170	*/
	171	void set_group(SignalGroup* group);
	172
	173	/**
	174	* Returns the signal group this signal belongs to or nullptr if none
	175	*/
	176	SignalGroup* group() const;
	177
	178	/**
	179	* Gets the name of this signal.
	180	*/
	181	QString name() const;
	182
	183	/**
	184	* Gets the internal name of this signal, i.e. how the device/generator calls it.
	185	*/
	186	QString internal_name() const;
	187
	188	/**
	189	* Sets the internal name of this signal, i.e. how the device/generator calls it.
	190	* Only use immediately after creating the signal and leave it untouched after.
	191	*/
	192	void set_internal_name(QString internal_name);
	193
	194	/**
	195	* Produces a string for this signal that can be used for display,
	196	* i.e. it contains one or both of the signal/internal names.
	197	*/
	198	QString display_name() const;
	199
	200	/**
	201	* Sets the name of the signal.
	202	*/
	203	virtual void set_name(QString name);
	204
	205	/**
	206	* Get the color of the signal.
	207	*/
	208	QColor color() const;
	209
	210	/**
	211	* Set the color of the signal.
	212	*/
	213	void set_color(QColor color);
	214
	215	/**
	216	* Get the background color of the signal.
	217	*/
	218	QColor bgcolor() const;
	219
	220	/**
	221	* Sets the internal data object.
	222	*/
	223	void set_data(shared_ptr<pv::data::SignalData> data);
	224
	225	/**
	226	* Clears all sample data and removes all associated segments.
	227	*/
	228	void clear_sample_data();
	229
	230	/**
	231	* Get the internal data as analog data object in case of analog type.
	232	*/
	233	shared_ptr<pv::data::Analog> analog_data() const;
	234
	235	/**
	236	* Get the internal data as logic data object in case of logic type.
	237	*/
	238	shared_ptr<pv::data::Logic> logic_data() const;
	239
	240	/**
	241	* Determines whether a given segment is complete (i.e. end-of-frame has
	242	* been seen). It only considers the original data, not the converted data.
	243	*/
	244	bool segment_is_complete(uint32_t segment_id) const;
	245
	246	/**
	247	* Determines whether this signal has any sample data at all.
	248	*/
	249	bool has_samples() const;
	250
	251	/**
	252	* Returns the sample rate for this signal.
	253	*/
	254	virtual double get_samplerate() const;
	255
	256	/**
	257	* Queries the kind of conversion performed on this channel.
	258	*/
	259	ConversionType get_conversion_type() const;
	260
	261	/**
	262	* Changes the kind of conversion performed on this channel.
	263	*
	264	* Restarts the conversion.
	265	*/
	266	void set_conversion_type(ConversionType t);
	267
	268	/**
	269	* Returns all currently known conversion options
	270	*/
	271	map<QString, QVariant> get_conversion_options() const;
	272
	273	/**
	274	* Sets the value of a particular conversion option
	275	* Note: it is not checked whether the option is valid for the
	276	* currently conversion. If it's not, it will be silently ignored.
	277	*
	278	* Does not restart the conversion.
	279	*
	280	* @return true if the value is different from before, false otherwise
	281	*/
	282	bool set_conversion_option(QString key, QVariant value);
	283
	284	/**
	285	* Returns the threshold(s) used for conversions, if applicable.
	286	* The resulting thresholds are given for the chosen conversion, so you
	287	* can query thresholds also for conversions which aren't currently active.
	288	*
	289	* If you want the thresholds for the currently active conversion,
	290	* call it either with NoConversion or no parameter.
	291	*
	292	* @param t the type of conversion to obtain the thresholds for, leave
	293	* empty or use NoConversion if you want to query the currently
	294	* used conversion
	295	*
	296	* @param always_custom ignore the currently selected preset and always
	297	* return the custom values for this conversion, using 0 if those
	298	* aren't set
	299	*
	300	* @return a list of threshold(s) used by the chosen conversion
	301	*/
	302	vector<double> get_conversion_thresholds(
	303	const ConversionType t = NoConversion, const bool always_custom=false) const;
	304
	305	/**
	306	* Provides all conversion presets available for the currently active
	307	* conversion.
	308	*
	309	* @return a list of description/ID pairs for each preset
	310	*/
	311	vector<pair<QString, int> > get_conversion_presets() const;
	312
	313	/**
	314	* Determines the ID of the currently used conversion preset, which is only
	315	* valid for the currently available conversion presets. It is therefore
	316	* suggested to call @ref get_conversion_presets right before calling this.
	317	*
	318	* @return the ID of the currently used conversion preset. -1 if no preset
	319	* is used. In that case, a user setting is used instead.
	320	*/
	321	ConversionPreset get_current_conversion_preset() const;
	322
	323	/**
	324	* Sets the conversion preset to be used.
	325	*
	326	* Does not restart the conversion.
	327	*
	328	* @param id the id of the preset to use
	329	*/
	330	void set_conversion_preset(ConversionPreset id);
	331
	332	#ifdef ENABLE_DECODE
	333	bool is_decode_signal() const;
	334	#endif
	335
	336	virtual void save_settings(QSettings &settings) const;
	337	virtual void restore_settings(QSettings &settings);
	338
	339	void start_conversion(bool delayed_start=false);
	340
	341	private:
	342	bool conversion_is_a2l() const;
	343
	344	uint8_t convert_a2l_threshold(float threshold, float value);
	345	uint8_t convert_a2l_schmitt_trigger(float lo_thr, float hi_thr,
	346	float value, uint8_t &state);
	347
	348	void convert_single_segment_range(AnalogSegment *asegment,
	349	LogicSegment *lsegment, uint64_t start_sample, uint64_t end_sample);
	350	void convert_single_segment(pv::data::AnalogSegment *asegment,
	351	pv::data::LogicSegment *lsegment);
	352	void conversion_thread_proc();
	353
	354	void stop_conversion();
	355
	356	Q_SIGNALS:
	357	void enabled_changed(const bool &value);
	358
	359	void name_changed(const QString &name);
	360
	361	void color_changed(const QColor &color);
	362
	363	void conversion_type_changed(const ConversionType t);
	364
	365	void samples_cleared();
	366
	367	void samples_added(uint64_t segment_id, uint64_t start_sample,
	368	uint64_t end_sample);
	369
	370	void min_max_changed(float min, float max);
	371
	372	private Q_SLOTS:
	373	void on_samples_cleared();
	374
	375	void on_samples_added(SharedPtrToSegment segment, uint64_t start_sample,
	376	uint64_t end_sample);
	377
	378	void on_min_max_changed(float min, float max);
	379
	380	void on_capture_state_changed(int state);
	381
	382	void on_delayed_conversion_start();
	383
	384	protected:
	385	shared_ptr<sigrok::Channel> channel_;
	386	ChannelType channel_type_;
	387	SignalGroup* group_;
	388	shared_ptr<pv::data::SignalData> data_;
	389	shared_ptr<pv::data::SignalData> converted_data_;
	390	ConversionType conversion_type_;
	391	map<QString, QVariant> conversion_options_;
	392
	393	float min_value_, max_value_;
	394
	395	std::thread conversion_thread_;
	396	atomic<bool> conversion_interrupt_;
	397	mutex conversion_input_mutex_;
	398	condition_variable conversion_input_cond_;
	399	QTimer delayed_conversion_starter_;
	400
	401	QString internal_name_, name_;
	402	QColor color_, bgcolor_;
	403	unsigned int index_;
	404	};
	405
	406	} // namespace data
	407	} // namespace pv
	408
	409	#endif // PULSEVIEW_PV_DATA_SIGNALBASE_HPP