src/channels/basechannel.hpp

   1 /*
   2  * This file is part of the SmuView project.
   3  *
   4  * Copyright (C) 2012 Joel Holdsworth <joel@airwebreathe.org.uk>
   5  * Copyright (C) 2016 Soeren Apel <soeren@apelpie.net>
   6  * Copyright (C) 2016-2021 Frank Stettner <frank-stettner@gmx.net>
   7  *
   8  * This program is free software: you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation, either version 3 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #ifndef CHANNELS_BASECHANNEL_HPP
  23 #define CHANNELS_BASECHANNEL_HPP
  24
  25 #include <memory>
  26 #include <set>
  27 #include <string>
  28 #include <vector>
  29
  30 #include <QObject>
  31 #include <QSettings>
  32 #include <QString>
  33
  34 #include "src/data/datautil.hpp"
  35
  36 using std::map;
  37 using std::set;
  38 using std::shared_ptr;
  39 using std::string;
  40 using std::vector;
  41 using sv::data::measured_quantity_t;
  42
  43 namespace sigrok {
  44 class Channel;
  45 }
  46
  47 namespace sv {
  48
  49 namespace data {
  50 class AnalogTimeSignal;
  51 class BaseSignal;
  52 }
  53
  54 namespace devices {
  55 class BaseDevice;
  56 }
  57
  58 namespace channels {
  59
  60 enum class ChannelType {
  61         /**
  62          * Channels with analog data (Power supplies, loads, DMMs)
  63          */
  64         AnalogChannel,
  65         /**
  66          * Virtual channel for calculated data
  67          */
  68         MathChannel,
  69         /**
  70          * Virtual channel for user generated data (e.g. scripts)
  71          */
  72         UserChannel
  73 };
  74
  75 class BaseChannel :
  76         public QObject,
  77         public std::enable_shared_from_this<BaseChannel>
  78 {
  79         Q_OBJECT
  80
  81 public:
  82         BaseChannel(
  83                 shared_ptr<sigrok::Channel> sr_channel,
  84                 shared_ptr<devices::BaseDevice> parent_device,
  85                 const set<string> &channel_group_names,
  86                 double channel_start_timestamp);
  87         virtual ~BaseChannel();
  88
  89 public:
  90         /**
  91          * Return the underlying sigrok channel.
  92          *
  93          * HardwareChannels always have a sigrok channel, UserChannels only have a
  94          * sigrok channel when created in a UserDevice!
  95          */
  96         shared_ptr<sigrok::Channel> sr_channel() const;
  97
  98         /**
  99          * Get the name of this channel, i.e. how the device calls it.
 100          */
 101         string name() const;
 102
 103         /**
 104          * Set the name of the signal.
 105          */
 106         void set_name(const string &name);
 107
 108         /**
 109          * Get the display name of this channel.
 110          */
 111         QString display_name() const;
 112
 113         /**
 114          * Get the index number of this channel, i.e. a unique ID assigned by
 115          * the device driver.
 116          */
 117         unsigned int index() const;
 118
 119         /**
 120          * Get the type of this channel.
 121          */
 122         ChannelType type() const;
 123
 124         /**
 125          * Return enabled status of this channel.
 126          */
 127         bool enabled() const;
 128
 129         /**
 130          * Set the enabled status of this channel.
 131          */
 132         void set_enabled(bool enabled);
 133
 134         /**
 135          * Does this channel have just one signal, thats quantity doesn't change?
 136          */
 137         bool fixed_signal() const;
 138
 139         /**
 140          * Set if this channel has just one signal, thats quantity doesn't change
 141          */
 142         void set_fixed_signal(bool fixed_signal);
 143
 144         /**
 145          * Return the device, this channel belongs to.
 146          */
 147         shared_ptr<devices::BaseDevice> parent_device();
 148
 149         /**
 150          * Get the channel group name, the channel is in. Returns "" if the channel
 151          * is not in a channel group.
 152          */
 153         set<string> channel_group_names() const;
 154
 155         /**
 156          * Add a channel group name
 157          */
 158         void add_channel_group_name(const string &channel_group_name);
 159
 160         /**
 161          * Add a signal to the channel. For now only AnalogTimeSignals
 162          * are supported.
 163          */
 164         void add_signal(shared_ptr<data::AnalogTimeSignal> signal);
 165
 166         /**
 167          * Add a signal by its quantity, quantity_flags and unit.
 168          */
 169         shared_ptr<data::BaseSignal> add_signal(
 170                 data::Quantity quantity,
 171                 set<data::QuantityFlag> quantity_flags,
 172                 data::Unit unit,
 173                 string custom_name = "");
 174
 175         /**
 176          * Get the actual signal
 177          */
 178         shared_ptr<data::BaseSignal> actual_signal();
 179
 180         /**
 181          * Get all signals for this channel. Normaly a measurement quantity only
 182          * has one corresponding signal, but for user channels this can be
 183          * different.
 184          */
 185         map<measured_quantity_t, vector<shared_ptr<data::BaseSignal>>> signal_map();
 186
 187         /**
 188          * Get all signals for this channel.
 189          * This function is especially for the Python bindings.
 190          */
 191         vector<shared_ptr<data::BaseSignal>> signals();
 192
 193         /**
 194          * Delete all signals from this channel
 195          */
 196         void clear_signals();
 197
 198         virtual void save_settings(QSettings &settings) const;
 199         virtual void restore_settings(QSettings &settings);
 200
 201 protected:
 202         static const size_t size_of_double_ = sizeof(double);
 203
 204         /** The corresponding sigrok channel object. */
 205         shared_ptr<sigrok::Channel> sr_channel_;
 206         /** Name of this channel. */
 207         string name_;
 208         /** Index of this channel. */
 209         unsigned int index_;
 210         /** Type of this channel. */
 211         ChannelType type_;
 212         /** Timestamp when this channel was created/started. */
 213         double channel_start_timestamp_;
 214
 215         /** The device this channel belongs to. */
 216         shared_ptr<devices::BaseDevice> parent_device_;
 217         /** The channel group names this channel belongs to. */
 218         set<string> channel_group_names_;
 219
 220         bool fixed_signal_;
 221         shared_ptr<data::BaseSignal> actual_signal_;
 222         map<measured_quantity_t, vector<shared_ptr<data::BaseSignal>>> signal_map_;
 223
 224 public Q_SLOTS:
 225         void on_aquisition_start_timestamp_changed(double timestamp);
 226
 227 Q_SIGNALS:
 228         void channel_start_timestamp_changed(double timestamp);
 229         void enabled_changed(const bool enabled);
 230         void name_changed(const std::string &name);
 231         void signal_added(shared_ptr<sv::data::BaseSignal> signal);
 232         void signal_changed(shared_ptr<sv::data::BaseSignal> signal);
 233
 234 };
 235
 236 } // namespace channels
 237 } // namespace sv
 238
 239 #endif // CHANNELS_BASECHANNEL_HPP