template<typename T>
-struct sig_sample : public exprtk::igeneric_function<T>
+struct fnc_sample : public exprtk::igeneric_function<T>
{
typedef typename exprtk::igeneric_function<T>::parameter_list_t parameter_list_t;
typedef typename exprtk::igeneric_function<T>::generic_type generic_type;
typedef typename generic_type::scalar_view scalar_t;
typedef typename generic_type::string_view string_t;
- sig_sample(MathSignal& owner) :
+ fnc_sample(MathSignal& owner) :
exprtk::igeneric_function<T>("ST"), // Require channel name and sample number
owner_(owner),
sig_data(nullptr)
const std::string str_sig_name = to_str(exprtk_sig_name);
const double sample_num = exprtk_sample_num();
+ if (sample_num < 0)
+ return 0;
+
if (!sig_data)
sig_data = owner_.signal_from_name(str_sig_name);
- assert(sig_data);
+ if (!sig_data)
+ // There doesn't actually exist a signal with that name
+ return 0;
+
owner_.update_signal_sample(sig_data, current_segment, sample_num);
return T(sig_data->sample_value);
exprtk_symbol_table_(nullptr),
exprtk_expression_(nullptr),
exprtk_parser_(nullptr),
- fnc_sig_sample_(nullptr)
+ fnc_sample_(nullptr)
{
uint32_t sig_idx = session_.get_next_signal_index(MathChannel);
set_name(QString(tr("Math%1")).arg(sig_idx));
MathSignal::~MathSignal()
{
reset_generation();
-
- if (fnc_sig_sample_)
- delete fnc_sig_sample_;
}
void MathSignal::save_settings(QSettings &settings) const
exprtk_unknown_symbol_table_ = nullptr;
}
- if (fnc_sig_sample_) {
- delete fnc_sig_sample_;
- fnc_sig_sample_ = nullptr;
+ if (fnc_sample_) {
+ delete fnc_sample_;
+ fnc_sample_ = nullptr;
}
if (!error_message_.isEmpty()) {
// TODO Emulate noquote()
qDebug().nospace() << name() << ": Error cleared";
}
+
+ generation_chunk_size_ = ChunkLength;
}
void MathSignal::begin_generation()
return;
}
- disconnect(this, SLOT(on_data_received()));
- disconnect(this, SLOT(on_enabled_changed()));
+ disconnect(&session_, SIGNAL(data_received()), this, SLOT(on_data_received()));
+
+ for (const shared_ptr<SignalBase>& sb : session_.signalbases()) {
+ if (sb->analog_data())
+ disconnect(sb->analog_data().get(), nullptr, this, SLOT(on_data_received()));
+ disconnect(sb.get(), nullptr, this, SLOT(on_enabled_changed()));
+ }
- fnc_sig_sample_ = new sig_sample<double>(*this);
+ fnc_sample_ = new fnc_sample<double>(*this);
exprtk_unknown_symbol_table_ = new exprtk::symbol_table<double>();
exprtk_symbol_table_ = new exprtk::symbol_table<double>();
- exprtk_symbol_table_->add_function("sig_sample", *fnc_sig_sample_);
+ exprtk_symbol_table_->add_constant("T", 1 / session_.get_samplerate());
+ exprtk_symbol_table_->add_function("sample", *fnc_sample_);
exprtk_symbol_table_->add_variable("t", exprtk_current_time_);
exprtk_symbol_table_->add_variable("s", exprtk_current_sample_);
exprtk_symbol_table_->add_constants();
signal_data* sig_data = signal_from_name(unknown);
const shared_ptr<SignalBase> signal = (sig_data) ? (sig_data->sb) : nullptr;
if (!signal || (!signal->analog_data())) {
- set_error(MATH_ERR_INVALID_SIGNAL, QString(tr("%1 isn't a valid analog signal")) \
+ set_error(MATH_ERR_INVALID_SIGNAL, QString(tr("\"%1\" isn't a valid analog signal")) \
.arg(QString::fromStdString(unknown)));
} else
sig_data->ref = &(exprtk_unknown_symbol_table_->variable_ref(unknown));
if (error_message_.isEmpty()) {
// Connect to the session data notification if we have no input signals
if (input_signals_.empty())
- connect(&session_, SIGNAL(data_received()),
- this, SLOT(on_data_received()));
+ connect(&session_, SIGNAL(data_received()), this, SLOT(on_data_received()));
gen_interrupt_ = false;
gen_thread_ = std::thread(&MathSignal::generation_proc, this);
}
}
-void MathSignal::generate_samples(uint32_t segment_id, const uint64_t start_sample,
+uint64_t MathSignal::generate_samples(uint32_t segment_id, const uint64_t start_sample,
const int64_t sample_count)
{
+ uint64_t count = 0;
+
shared_ptr<Analog> analog = dynamic_pointer_cast<Analog>(data_);
shared_ptr<AnalogSegment> segment = analog->analog_segments().at(segment_id);
// Keep the math functions segment IDs in sync
- fnc_sig_sample_->current_segment = segment_id;
+ fnc_sample_->current_segment = segment_id;
const double sample_rate = data_->get_samplerate();
double value = exprtk_expression_->value();
sample_data[i] = value;
exprtk_current_sample_ += 1;
+ count++;
+
+ // If during the evaluation of the expression it was found that this
+ // math signal itself is being accessed, the chunk size was reduced
+ // to 1, which means we must stop after this sample we just generated
+ if (generation_chunk_size_ == 1)
+ break;
}
- segment->append_interleaved_samples(sample_data, sample_count, 1);
+ segment->append_interleaved_samples(sample_data, count, 1);
delete[] sample_data;
+
+ return count;
}
void MathSignal::generation_proc()
// Process the samples if necessary...
if (samples_to_process > 0) {
- const uint64_t chunk_sample_count = ChunkLength;
-
uint64_t processed_samples = 0;
do {
const uint64_t start_sample = output_sample_count + processed_samples;
- const uint64_t sample_count =
- min(samples_to_process - processed_samples, chunk_sample_count);
+ uint64_t sample_count =
+ min(samples_to_process - processed_samples, generation_chunk_size_);
- generate_samples(segment_id, start_sample, sample_count);
+ sample_count = generate_samples(segment_id, start_sample, sample_count);
processed_samples += sample_count;
// Notify consumers of this signal's data
signal_data* MathSignal::signal_from_name(const std::string& name)
{
+ // If the expression contains the math signal itself, we must add every sample to
+ // the output segment immediately so that it can be accessed
+ const QString sig_name = QString::fromStdString(name);
+ if (sig_name == this->name())
+ generation_chunk_size_ = 1;
+
// Look up signal in the map and if it doesn't exist yet, add it for future use
auto element = input_signals_.find(name);
return &(element->second);
} else {
const vector< shared_ptr<SignalBase> > signalbases = session_.signalbases();
- const QString sig_name = QString::fromStdString(name);
for (const shared_ptr<SignalBase>& sb : signalbases)
if (sb->name() == sig_name) {
}
}
+ // If we reach this point, no valid signal was found with the supplied name
+ if (error_type_ == MATH_ERR_NONE)
+ set_error(MATH_ERR_INVALID_SIGNAL, QString(tr("\"%1\" isn't a valid analog signal")) \
+ .arg(QString::fromStdString(name)));
+
return nullptr;
}
const shared_ptr<AnalogSegment> segment = analog->analog_segments().at(segment_id);
sig_data->sample_num = sample_num;
- sig_data->sample_value = segment->get_sample(sample_num);
+
+ if (sample_num < segment->get_sample_count())
+ sig_data->sample_value = segment->get_sample(sample_num);
+ else
+ sig_data->sample_value = 0;
// We only have a reference if this signal is used as a scalar;
// if it's used by a function, it's null
projects / pulseview.git / blobdiff