[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
	Q_PROPERTY(QString error_message READ get_error_message)

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
	};

	static const QColor AnalogSignalColors[8];
	static const QColor LogicSignalColors[10];

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 whether this channel is generated or a channel associated with the device.
	 */
	bool is_generated() 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;

	/**
	 * Returns the current error message text.
	 */
	virtual QString get_error_message() 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);

protected:
	virtual void set_error_message(QString msg);

private:
	void stop_conversion();

	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(shared_ptr<AnalogSegment> asegment,
		shared_ptr<LogicSegment> lsegment, uint64_t start_sample, uint64_t end_sample);
	void convert_single_segment(shared_ptr<AnalogSegment> asegment,
		shared_ptr<LogicSegment> lsegment);
	void conversion_thread_proc();

Q_SIGNALS:
	void enabled_changed(const bool &value);
	void name_changed(const QString &name);
	void color_changed(const QColor &color);
	void error_message_changed(const QString &msg);
	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_;

	QString error_message_;
};

} // namespace data
} // namespace pv

Q_DECLARE_METATYPE(shared_ptr<pv::data::SignalBase>);

#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	Q_PROPERTY(QString error_message READ get_error_message)
	91
	92	public:
	93	enum ChannelType {
	94	AnalogChannel = 1, ///< Analog data
	95	LogicChannel, ///< Logic data
	96	DecodeChannel, ///< Protocol Decoder channel using libsigrokdecode
	97	MathChannel ///< Virtual channel generated by math operations
	98	};
	99
	100	enum ConversionType {
	101	NoConversion = 0,
	102	A2LConversionByThreshold = 1,
	103	A2LConversionBySchmittTrigger = 2
	104	};
	105
	106	/**
	107	* Conversion presets range from -1 to n, where 1..n are dependent on
	108	* the conversion these presets apply to. -1 and 0 have fixed meanings,
	109	* however.
	110	*/
	111	enum ConversionPreset {
	112	NoPreset = -1, ///< Conversion uses custom values
	113	DynamicPreset = 0 ///< Conversion uses calculated values
	114	};
	115
	116	static const QColor AnalogSignalColors[8];
	117	static const QColor LogicSignalColors[10];
	118
	119	private:
	120	static const int ColorBGAlpha;
	121	static const uint64_t ConversionBlockSize;
	122	static const uint32_t ConversionDelay;
	123
	124	public:
	125	SignalBase(shared_ptr<sigrok::Channel> channel, ChannelType channel_type);
	126	virtual ~SignalBase();
	127
	128	public:
	129	/**
	130	* Returns the underlying SR channel.
	131	* Generated channels don't have a SR channel.
	132	*/
	133	shared_ptr<sigrok::Channel> channel() const;
	134
	135	/**
	136	* Returns whether this channel is generated or a channel associated with the device.
	137	*/
	138	bool is_generated() const;
	139
	140	/**
	141	* Returns enabled status of this channel.
	142	*/
	143	bool enabled() const;
	144
	145	/**
	146	* Sets the enabled status of this channel.
	147	* @param value Boolean value to set.
	148	*/
	149	void set_enabled(bool value);
	150
	151	/**
	152	* Gets the type of this channel.
	153	*/
	154	ChannelType type() const;
	155
	156	/**
	157	* Gets the index number of this channel, i.e. a unique ID assigned by
	158	* the device driver.
	159	*/
	160	unsigned int index() const;
	161
	162	/**
	163	* Sets the index number of this channel, i.e. a unique ID assigned by
	164	* the device driver or the logic bit index (see below).
	165	* Only use immediately after creating the signal and leave it untouched after.
	166	*/
	167	void set_index(unsigned int index);
	168
	169	/**
	170	* Returns which bit of a given sample for this signal represents the
	171	* signal itself. This is relevant for compound signals like logic,
	172	* rather meaningless for everything else but provided in case there
	173	* is a conversion active that provides a digital signal using bit #0.
	174	*/
	175	unsigned int logic_bit_index() const;
	176
	177	/**
	178	* Sets the signal group this signal belongs to
	179	*/
	180	void set_group(SignalGroup* group);
	181
	182	/**
	183	* Returns the signal group this signal belongs to or nullptr if none
	184	*/
	185	SignalGroup* group() const;
	186
	187	/**
	188	* Gets the name of this signal.
	189	*/
	190	QString name() const;
	191
	192	/**
	193	* Gets the internal name of this signal, i.e. how the device/generator calls it.
	194	*/
	195	QString internal_name() const;
	196
	197	/**
	198	* Sets the internal name of this signal, i.e. how the device/generator calls it.
	199	* Only use immediately after creating the signal and leave it untouched after.
	200	*/
	201	void set_internal_name(QString internal_name);
	202
	203	/**
	204	* Produces a string for this signal that can be used for display,
	205	* i.e. it contains one or both of the signal/internal names.
	206	*/
	207	QString display_name() const;
	208
	209	/**
	210	* Sets the name of the signal.
	211	*/
	212	virtual void set_name(QString name);
	213
	214	/**
	215	* Get the color of the signal.
	216	*/
	217	QColor color() const;
	218
	219	/**
	220	* Set the color of the signal.
	221	*/
	222	void set_color(QColor color);
	223
	224	/**
	225	* Get the background color of the signal.
	226	*/
	227	QColor bgcolor() const;
	228
	229	/**
	230	* Returns the current error message text.
	231	*/
	232	virtual QString get_error_message() const;
	233
	234	/**
	235	* Sets the internal data object.
	236	*/
	237	void set_data(shared_ptr<pv::data::SignalData> data);
	238
	239	/**
	240	* Clears all sample data and removes all associated segments.
	241	*/
	242	void clear_sample_data();
	243
	244	/**
	245	* Get the internal data as analog data object in case of analog type.
	246	*/
	247	shared_ptr<pv::data::Analog> analog_data() const;
	248
	249	/**
	250	* Get the internal data as logic data object in case of logic type.
	251	*/
	252	shared_ptr<pv::data::Logic> logic_data() const;
	253
	254	/**
	255	* Determines whether a given segment is complete (i.e. end-of-frame has
	256	* been seen). It only considers the original data, not the converted data.
	257	*/
	258	bool segment_is_complete(uint32_t segment_id) const;
	259
	260	/**
	261	* Determines whether this signal has any sample data at all.
	262	*/
	263	bool has_samples() const;
	264
	265	/**
	266	* Returns the sample rate for this signal.
	267	*/
	268	virtual double get_samplerate() const;
	269
	270	/**
	271	* Queries the kind of conversion performed on this channel.
	272	*/
	273	ConversionType get_conversion_type() const;
	274
	275	/**
	276	* Changes the kind of conversion performed on this channel.
	277	*
	278	* Restarts the conversion.
	279	*/
	280	void set_conversion_type(ConversionType t);
	281
	282	/**
	283	* Returns all currently known conversion options
	284	*/
	285	map<QString, QVariant> get_conversion_options() const;
	286
	287	/**
	288	* Sets the value of a particular conversion option
	289	* Note: it is not checked whether the option is valid for the
	290	* currently conversion. If it's not, it will be silently ignored.
	291	*
	292	* Does not restart the conversion.
	293	*
	294	* @return true if the value is different from before, false otherwise
	295	*/
	296	bool set_conversion_option(QString key, QVariant value);
	297
	298	/**
	299	* Returns the threshold(s) used for conversions, if applicable.
	300	* The resulting thresholds are given for the chosen conversion, so you
	301	* can query thresholds also for conversions which aren't currently active.
	302	*
	303	* If you want the thresholds for the currently active conversion,
	304	* call it either with NoConversion or no parameter.
	305	*
	306	* @param t the type of conversion to obtain the thresholds for, leave
	307	* empty or use NoConversion if you want to query the currently
	308	* used conversion
	309	*
	310	* @param always_custom ignore the currently selected preset and always
	311	* return the custom values for this conversion, using 0 if those
	312	* aren't set
	313	*
	314	* @return a list of threshold(s) used by the chosen conversion
	315	*/
	316	vector<double> get_conversion_thresholds(
	317	const ConversionType t = NoConversion, const bool always_custom=false) const;
	318
	319	/**
	320	* Provides all conversion presets available for the currently active
	321	* conversion.
	322	*
	323	* @return a list of description/ID pairs for each preset
	324	*/
	325	vector<pair<QString, int> > get_conversion_presets() const;
	326
	327	/**
	328	* Determines the ID of the currently used conversion preset, which is only
	329	* valid for the currently available conversion presets. It is therefore
	330	* suggested to call @ref get_conversion_presets right before calling this.
	331	*
	332	* @return the ID of the currently used conversion preset. -1 if no preset
	333	* is used. In that case, a user setting is used instead.
	334	*/
	335	ConversionPreset get_current_conversion_preset() const;
	336
	337	/**
	338	* Sets the conversion preset to be used.
	339	*
	340	* Does not restart the conversion.
	341	*
	342	* @param id the id of the preset to use
	343	*/
	344	void set_conversion_preset(ConversionPreset id);
	345
	346	#ifdef ENABLE_DECODE
	347	bool is_decode_signal() const;
	348	#endif
	349
	350	virtual void save_settings(QSettings &settings) const;
	351	virtual void restore_settings(QSettings &settings);
	352
	353	void start_conversion(bool delayed_start=false);
	354
	355	protected:
	356	virtual void set_error_message(QString msg);
	357
	358	private:
	359	void stop_conversion();
	360
	361	bool conversion_is_a2l() const;
	362
	363	uint8_t convert_a2l_threshold(float threshold, float value);
	364	uint8_t convert_a2l_schmitt_trigger(float lo_thr, float hi_thr,
	365	float value, uint8_t &state);
	366
	367	void convert_single_segment_range(shared_ptr<AnalogSegment> asegment,
	368	shared_ptr<LogicSegment> lsegment, uint64_t start_sample, uint64_t end_sample);
	369	void convert_single_segment(shared_ptr<AnalogSegment> asegment,
	370	shared_ptr<LogicSegment> lsegment);
	371	void conversion_thread_proc();
	372
	373	Q_SIGNALS:
	374	void enabled_changed(const bool &value);
	375	void name_changed(const QString &name);
	376	void color_changed(const QColor &color);
	377	void error_message_changed(const QString &msg);
	378	void conversion_type_changed(const ConversionType t);
	379
	380	void samples_cleared();
	381	void samples_added(uint64_t segment_id, uint64_t start_sample,
	382	uint64_t end_sample);
	383
	384	void min_max_changed(float min, float max);
	385
	386	private Q_SLOTS:
	387	void on_samples_cleared();
	388
	389	void on_samples_added(SharedPtrToSegment segment, uint64_t start_sample,
	390	uint64_t end_sample);
	391
	392	void on_min_max_changed(float min, float max);
	393
	394	void on_capture_state_changed(int state);
	395
	396	void on_delayed_conversion_start();
	397
	398	protected:
	399	shared_ptr<sigrok::Channel> channel_;
	400	ChannelType channel_type_;
	401	SignalGroup* group_;
	402	shared_ptr<pv::data::SignalData> data_;
	403	shared_ptr<pv::data::SignalData> converted_data_;
	404	ConversionType conversion_type_;
	405	map<QString, QVariant> conversion_options_;
	406
	407	float min_value_, max_value_;
	408
	409	std::thread conversion_thread_;
	410	atomic<bool> conversion_interrupt_;
	411	mutex conversion_input_mutex_;
	412	condition_variable conversion_input_cond_;
	413	QTimer delayed_conversion_starter_;
	414
	415	QString internal_name_, name_;
	416	QColor color_, bgcolor_;
	417	unsigned int index_;
	418
	419	QString error_message_;
	420	};
	421
	422	} // namespace data
	423	} // namespace pv
	424
	425	Q_DECLARE_METATYPE(shared_ptr<pv::data::SignalBase>);
	426
	427	#endif // PULSEVIEW_PV_DATA_SIGNALBASE_HPP