Embedded/DSView
1
0
Fork 0
mirror of https://github.com/DreamSourceLab/DSView.git synced 2025-01-13 13:32:53 +08:00
Code Issues Projects Releases Wiki Activity

Merge branch 'dev-1.3'

Browse Source
This commit is contained in:
dreamsourcelabTAI 2022-10-11 14:55:07 +08:00
commit 83631c9d65
165 changed files with 10420 additions and 9289 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
CMakeLists.txt
View File

@ -31,9 +31,9 @@ set(DS_TITLE DSView)
set(DS_DESCRIPTION "A GUI for instruments of DreamSourceLab")
set(DS_VERSION_MAJOR 1)
set(DS_VERSION_MINOR 2)
set(DS_VERSION_MICRO 1)
set(DS_VERSION_STRING ${DS_VERSION_MAJOR}.${DS_VERSION_MINOR}.${DS_VERSION_MICRO} )
set(DS_VERSION_MINOR 3)
set(DS_VERSION_MICRO 0)
set(DS_VERSION_STRING ${DS_VERSION_MAJOR}.${DS_VERSION_MINOR}.${DS_VERSION_MICRO}-dev )
configure_file (
${PROJECT_SOURCE_DIR}/DSView/config.h.in
@ -235,7 +235,6 @@ set(DSView_SOURCES
DSView/pv/log.cpp
DSView/pv/sigsession.cpp
DSView/pv/mainwindow.cpp
DSView/pv/devicemanager.cpp
DSView/pv/data/snapshot.cpp
DSView/pv/data/signaldata.cpp
DSView/pv/data/logicsnapshot.cpp
@ -290,14 +289,9 @@ set(DSView_SOURCES
DSView/pv/widgets/decodermenu.cpp
DSView/pv/widgets/decodergroupbox.cpp
DSView/pv/prop/string.cpp
DSView/pv/device/sessionfile.cpp
DSView/pv/device/inputfile.cpp
DSView/pv/device/file.cpp
DSView/pv/device/devinst.cpp
DSView/pv/dialogs/storeprogress.cpp
DSView/pv/storesession.cpp
DSView/pv/view/devmode.cpp
DSView/pv/device/device.cpp
DSView/pv/dialogs/waitingdialog.cpp
DSView/pv/dialogs/dsomeasure.cpp
DSView/pv/dialogs/calibration.cpp
@ -350,6 +344,7 @@ set(DSView_SOURCES
DSView/pv/dialogs/decoderoptionsdlg.cpp
DSView/pv/utility/encoding.cpp
DSView/pv/utility/path.cpp
DSView/pv/deviceagent.cpp
)
set(DSView_HEADERS
@ -388,7 +383,6 @@ set(DSView_HEADERS
DSView/pv/widgets/decodermenu.h
DSView/pv/widgets/decodergroupbox.h
DSView/pv/prop/string.h
DSView/pv/device/devinst.h
DSView/pv/dialogs/storeprogress.h
DSView/pv/storesession.h
DSView/pv/view/devmode.h
@ -441,6 +435,7 @@ set(DSView_HEADERS
DSView/pv/dialogs/decoderoptionsdlg.h
DSView/pv/utility/encoding.h
DSView/pv/utility/path.h
DSView/pv/deviceagent.h
)
#===============================================================================
@ -450,7 +445,6 @@ set(libsigrok4DSL_SOURCES
libsigrok4DSL/version.c
libsigrok4DSL/strutil.c
libsigrok4DSL/std.c
libsigrok4DSL/session_file.c
libsigrok4DSL/session_driver.c
libsigrok4DSL/session.c
libsigrok4DSL/log.c
@ -475,11 +469,11 @@ set(libsigrok4DSL_SOURCES
libsigrok4DSL/hardware/DSL/dscope.c
libsigrok4DSL/hardware/DSL/command.c
libsigrok4DSL/hardware/DSL/dsl.c
libsigrok4DSL/lib_main.c
)
set(libsigrok4DSL_HEADERS
libsigrok4DSL/version.h
libsigrok4DSL/proto.h
libsigrok4DSL/libsigrok-internal.h
libsigrok4DSL/libsigrok.h
libsigrok4DSL/config.h

6
DSView/config.h
View File

@ -28,8 +28,8 @@
/* DSView version information */
#define DS_VERSION_MAJOR 1
#define DS_VERSION_MINOR 2
#define DS_VERSION_MICRO 1
#define DS_VERSION_STRING "1.2.1"
#define DS_VERSION_MINOR 3
#define DS_VERSION_MICRO 0
#define DS_VERSION_STRING "1.3.0-dev"
#endif

10
DSView/main.cpp
View File

@ -33,7 +33,7 @@
#include "pv/config/appconfig.h"
#include "config.h"
#include "pv/appcontrol.h"
#include "pv/log.h"
#include "pv/log.h"
#ifdef _WIN32
#include <windows.h>
@ -49,14 +49,14 @@ void usage()
"Help Options:\n"
" -l, --loglevel Set log level, value between 0 to 5\n"
" -v, -V, --version Show release version\n"
" -s, --storelog save log to locale file\n"
" -s, --storelog Save log to locale file\n"
" -h, -?, --help Show help option\n"
"\n", DS_BIN_NAME, DS_DESCRIPTION);
}
int main(int argc, char *argv[])
{
//return main2();
int ret = 0;
const char *open_file = NULL;
int logLevel = -1;
@ -208,7 +208,7 @@ bool bHighScale = true;
//----------------------run
dsv_info("----------------- version: %s-----------------", DS_VERSION_STRING);
dsv_info("Qt:%s", QT_VERSION_STR);
//init core
if (!control->Init()){
dsv_err("%s", "init error!");
@ -222,8 +222,8 @@ bool bHighScale = true;
try
{
pv::MainFrame w;
control->Start();
pv::MainFrame w; //Initialise the main frame
w.show();
w.readSettings();
w.show_doc(); //to show the dailog for open help document

52
DSView/pv/appcontrol.cpp
View File

@ -21,14 +21,12 @@
#include "appcontrol.h"
#include "libsigrok.h"
#include "libsigrokdecode.h"
#include <libsigrok.h>
#include <libsigrokdecode.h>
#include <QDir>
#include <QCoreApplication>
#include <QWidget>
#include <string>
#include "devicemanager.h"
#include "sigsession.h"
#include "dsvdef.h"
#include "config/appconfig.h"
@ -38,11 +36,8 @@
AppControl::AppControl()
{
sr_ctx = NULL;
_topWindow = NULL;
_device_manager = new pv::DeviceManager();
_session = new pv::SigSession(_device_manager);
_topWindow = NULL;
_session = new pv::SigSession();
}
AppControl::AppControl(AppControl &o)
@ -51,8 +46,7 @@ AppControl::AppControl(AppControl &o)
}
AppControl::~AppControl()
{
DESTROY_OBJECT(_device_manager);
{
DESTROY_OBJECT(_session);
}
@ -70,24 +64,12 @@ void AppControl::Destroy(){
}
bool AppControl::Init()
{
pv::encoding::init();
sr_log_set_context(dsv_log_context());
srd_log_set_context(dsv_log_context());
// Initialise libsigrok
if (sr_init(&sr_ctx) != SR_OK)
{
m_error = "DSView run ERROR: libsigrok init failed.";
return false;
}
_session->set_sr_context(sr_ctx);
{
_session->init();
// firmware resource directory
QString resdir = GetResourceDir();
std::string res_path = pv::path::ToUnicodePath(resdir);
sr_set_firmware_resource_dir(res_path.c_str());
pv::encoding::init();
srd_log_set_context(dsv_log_context());
#if defined(_WIN32) && defined(DEBUG_INFO)
//able run debug with qtcreator
@ -105,7 +87,7 @@ bool AppControl::Init()
QString dir = GetDecodeScriptDir();
strcpy(path, dir.toUtf8().data());
dsv_info("decode script path: \"%s\"", dir.toUtf8().data());
dsv_info("Decode script files directory:\"%s\"", dir.toUtf8().data());
// Initialise libsigrokdecode
if (srd_init(path) != SRD_OK)
@ -126,15 +108,13 @@ bool AppControl::Init()
bool AppControl::Start()
{
_session->Open();
_device_manager->initAll(sr_ctx);
_session->Open();
return true;
}
void AppControl::Stop()
{
_session->Close();
_device_manager->UnInitAll();
_session->Close();
}
void AppControl::UnInit()
@ -142,11 +122,7 @@ void AppControl::UnInit()
// Destroy libsigrokdecode
srd_exit();
if (sr_ctx)
{
sr_exit(sr_ctx);
sr_ctx = NULL;
}
_session->uninit();
}
const char *AppControl::GetLastError()

13
DSView/pv/appcontrol.h
View File

@ -26,8 +26,7 @@
struct sr_context;
class QWidget;
namespace pv{
class DeviceManager;
namespace pv{
class SigSession;
}
@ -55,11 +54,7 @@ public:
inline pv::SigSession* GetSession(){
return _session;
}
inline pv::DeviceManager& GetDeviceManager(){
return *_device_manager;
}
}
inline void SetTopWindow(QWidget *w){
_topWindow = w;
@ -75,9 +70,7 @@ public:
std::string _open_file_name;
private:
std::string m_error;
struct sr_context *sr_ctx;
pv::DeviceManager *_device_manager;
std::string m_error;
pv::SigSession *_session;
QWidget *_topWindow;
};

3
DSView/pv/data/analogsnapshot.cpp
View File

@ -92,6 +92,7 @@ void AnalogSnapshot::clear()
free_data();
free_envelop();
init_all();
_have_data = false;
}
void AnalogSnapshot::first_payload(const sr_datafeed_analog &analog, uint64_t total_sample_count, GSList *channels)
@ -173,6 +174,8 @@ void AnalogSnapshot::append_payload(
// Generate the first mip-map from the data
if (analog.num_samples != 0) // guarantee new samples to compute
append_payload_to_envelope_levels();
_have_data = true;
}
void AnalogSnapshot::append_data(void *data, uint64_t samples, uint16_t pitch)

3
DSView/pv/data/analogsnapshot.h
View File

@ -24,8 +24,7 @@
#ifndef DSVIEW_PV_DATA_ANALOGSNAPSHOT_H
#define DSVIEW_PV_DATA_ANALOGSNAPSHOT_H
#include "libsigrok.h"
#include <libsigrok.h>
#include "snapshot.h"
#include <utility>

2
DSView/pv/data/decode/annotation.cpp
View File

@ -20,7 +20,7 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "libsigrokdecode.h"
#include <libsigrokdecode.h>
#include <vector>
#include <assert.h>

3
DSView/pv/data/decode/annotationrestable.cpp
View File

@ -212,8 +212,7 @@ const char* AnnotationResTable::format_to_string(const char *hex_str, int fmt)
sprintf(g_number_tmp_64, "%c", (char)lv);
return g_number_tmp_64;
}
}
char * const wr_buf = g_number_tmp_64;
}
g_number_tmp_64[0] = '[';
strcpy(g_number_tmp_64 + 1, data);
g_number_tmp_64[len+1] = ']';

3
DSView/pv/data/decode/decoder.cpp
View File

@ -20,8 +20,7 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "libsigrokdecode.h"
#include <libsigrokdecode.h>
#include "decoder.h"
#include <assert.h>

2
DSView/pv/data/decode/row.cpp
View File

@ -21,7 +21,7 @@
#include "row.h"
#include "libsigrokdecode.h"
#include <libsigrokdecode.h>
#include <assert.h>
namespace pv {

2
DSView/pv/data/decodermodel.cpp
View File

@ -19,7 +19,7 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "libsigrokdecode.h"
#include <libsigrokdecode.h>
#include "decode/annotation.h"
#include "decode/rowdata.h"

2
DSView/pv/data/decoderstack.h
View File

@ -23,7 +23,7 @@
#ifndef DSVIEW_PV_DATA_DECODERSTACK_H
#define DSVIEW_PV_DATA_DECODERSTACK_H
#include "libsigrokdecode.h"
#include <libsigrokdecode.h>
#include <list>
#include <boost/optional.hpp>
#include <QObject>

3
DSView/pv/data/dsosnapshot.cpp
View File

@ -95,6 +95,7 @@ void DsoSnapshot::clear()
free_data();
free_envelop();
init_all();
_have_data = false;
}
void DsoSnapshot::first_payload(const sr_datafeed_dso &dso, uint64_t total_sample_count,
@ -166,6 +167,8 @@ void DsoSnapshot::append_payload(const sr_datafeed_dso &dso)
// Generate the first mip-map from the data
if (_envelope_en)
append_payload_to_envelope_levels(dso.samplerate_tog);
_have_data = true;
}
}

2
DSView/pv/data/dsosnapshot.h
View File

@ -27,7 +27,7 @@
#include <vector>
#include <map>
#include "libsigrok.h"
#include <libsigrok.h>
#include "snapshot.h"
namespace DsoSnapshotTest {

3
DSView/pv/data/logicsnapshot.cpp
View File

@ -99,6 +99,7 @@ void LogicSnapshot::clear()
std::lock_guard<std::mutex> lock(_mutex);
free_data();
init_all();
_have_data = false;
}
void LogicSnapshot::capture_ended()
@ -228,6 +229,8 @@ void LogicSnapshot::append_payload(const sr_datafeed_logic &logic)
append_cross_payload(logic);
else if (logic.format == LA_SPLIT_DATA)
append_split_payload(logic);
_have_data = true;
}
void LogicSnapshot::append_cross_payload(const sr_datafeed_logic &logic)

2
DSView/pv/data/logicsnapshot.h
View File

@ -24,7 +24,7 @@
#ifndef DSVIEW_PV_DATA_LOGICSNAPSHOT_H
#define DSVIEW_PV_DATA_LOGICSNAPSHOT_H
#include "libsigrok.h"
#include <libsigrok.h>
#include "snapshot.h"
#include <QString>
#include <utility>

1
DSView/pv/data/snapshot.cpp
View File

@ -43,6 +43,7 @@ Snapshot::Snapshot(int unit_size, uint64_t total_sample_count, unsigned int chan
assert(_unit_size > 0);
_unit_bytes = 1;
_unit_pitch = 0;
_have_data = false;
}
Snapshot::~Snapshot()

6
DSView/pv/data/snapshot.h
View File

@ -73,10 +73,15 @@ public:
return _channel_num;
}
inline bool have_data(){
return _have_data;
}
virtual void capture_ended();
virtual bool has_data(int index) = 0;
virtual int get_block_num() = 0;
virtual uint64_t get_block_size(int block_index) = 0;
protected:
virtual void free_data();
@ -105,6 +110,7 @@ protected:
uint16_t _unit_pitch;
bool _memory_failed;
bool _last_ended;
bool _have_data;
};
} // namespace data

99
DSView/pv/device/device.cpp
View File

@ -1,99 +0,0 @@
/*
* This file is part of the DSView project.
* DSView is based on PulseView.
*
* Copyright (C) 2014 Joel Holdsworth <joel@airwebreathe.org.uk>
*
* 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
*/
#include <sstream>
#include <assert.h>
#include "device.h"
using std::ostringstream;
using std::string;
namespace pv {
namespace device {
Device::Device(sr_dev_inst *sdi) :
_sdi(sdi)
{
assert(_sdi);
}
Device::~Device()
{
}
sr_dev_inst* Device::dev_inst()
{
return _sdi;
}
void Device::use(SigSession *owner)
{
DevInst::use(owner);
sr_session_new();
sr_dev_open(_sdi);
_usable = (_sdi->status == SR_ST_ACTIVE);
if (sr_session_dev_add(_sdi) != SR_OK)
throw QString(tr("Failed to use device."));
}
void Device::release()
{
if (_owner) {
DevInst::release();
sr_session_destroy();
}
sr_dev_close(_sdi);
}
QString Device::format_device_title()
{
ostringstream s;
if (_sdi->model && _sdi->model[0]) {
s << _sdi->model;
if (_sdi->version && _sdi->version[0])
s << ' ';
}
if (_sdi->version && _sdi->version[0])
s << _sdi->version;
return QString::fromStdString(s.str());
}
bool Device::is_trigger_enabled()
{
for (const GSList *l = _sdi->channels; l; l = l->next) {
const sr_channel *const p = (const sr_channel *)l->data;
assert(p);
if (p->trigger && p->trigger[0] != '\0')
return true;
}
return false;
}
} // device
} // pv

54
DSView/pv/device/device.h
View File

@ -1,54 +0,0 @@
/*
* This file is part of the DSView project.
* DSView is based on PulseView.
*
* Copyright (C) 2014 Joel Holdsworth <joel@airwebreathe.org.uk>
*
* 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 DSVIEW_PV_DEVICE_DEVICE_H
#define DSVIEW_PV_DEVICE_DEVICE_H
#include "devinst.h"
namespace pv {
namespace device {
class Device : public DevInst
{
public:
Device(sr_dev_inst *dev_inst);
~Device();
sr_dev_inst* dev_inst();
void use(SigSession *owner);
void release();
QString format_device_title();
bool is_trigger_enabled();
private:
sr_dev_inst *const _sdi;
};
} // device
} // pv
#endif // DSVIEW_PV_DEVICE_DEVICE_H

226
DSView/pv/device/devinst.cpp
View File

@ -1,226 +0,0 @@
/*
* This file is part of the DSView project.
* DSView is based on PulseView.
*
* Copyright (C) 2014 Joel Holdsworth <joel@airwebreathe.org.uk>
*
* 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
*/
#include <cassert>
#include "devinst.h"
#include "../sigsession.h"
#include "../log.h"
namespace pv {
namespace device {
DevInst::DevInst() :
_owner(NULL),
_usable(true)
{
_id = malloc(1);
_is_file = false;
}
DevInst::~DevInst()
{
assert(_id);
free(_id);
}
void* DevInst::get_id()
{
assert(_id);
return _id;
}
void DevInst::use(SigSession *owner)
{
assert(owner);
_owner = owner;
}
void DevInst::release()
{
if (_owner) {
_owner->release_device(this);
}
}
SigSession* DevInst::owner()
{
return _owner;
}
GVariant* DevInst::get_config(const sr_channel *ch, const sr_channel_group *group, int key)
{
GVariant *data = NULL;
assert(_owner);
sr_dev_inst *const sdi = dev_inst();
assert(sdi);
if (sr_config_get(sdi->driver, sdi, ch, group, key, &data) != SR_OK)
return NULL;
return data;
}
bool DevInst::set_config(sr_channel *ch, sr_channel_group *group, int key, GVariant *data)
{
assert(_owner);
sr_dev_inst *const sdi = dev_inst();
assert(sdi);
if(sr_config_set(sdi, ch, group, key, data) == SR_OK) {
config_changed();
return true;
}
return false;
}
GVariant* DevInst::list_config(const sr_channel_group *group, int key)
{
GVariant *data = NULL;
assert(_owner);
sr_dev_inst *const sdi = dev_inst();
assert(sdi);
if (sr_config_list(sdi->driver, sdi, group, key, &data) != SR_OK)
return NULL;
return data;
}
void DevInst::enable_probe(const sr_channel *probe, bool enable)
{
assert(_owner);
sr_dev_inst *const sdi = dev_inst();
assert(sdi);
for (const GSList *p = sdi->channels; p; p = p->next)
if (probe == p->data) {
const_cast<sr_channel*>(probe)->enabled = enable;
config_changed();
return;
}
// Probe was not found in the device
assert(0);
}
uint64_t DevInst::get_sample_limit()
{
uint64_t sample_limit;
GVariant* gvar = get_config(NULL, NULL, SR_CONF_LIMIT_SAMPLES);
if (gvar != NULL) {
sample_limit = g_variant_get_uint64(gvar);
g_variant_unref(gvar);
} else {
sample_limit = 0U;
}
return sample_limit;
}
uint64_t DevInst::get_sample_rate()
{
uint64_t sample_rate;
GVariant* gvar = get_config(NULL, NULL, SR_CONF_SAMPLERATE);
if (gvar != NULL) {
sample_rate = g_variant_get_uint64(gvar);
g_variant_unref(gvar);
} else {
sample_rate = 0U;
}
return sample_rate;
}
uint64_t DevInst::get_time_base()
{
uint64_t time_base;
GVariant* gvar = get_config(NULL, NULL, SR_CONF_TIMEBASE);
if (gvar != NULL) {
time_base = g_variant_get_uint64(gvar);
g_variant_unref(gvar);
} else {
time_base = 0U;
}
return time_base;
}
double DevInst::get_sample_time()
{
uint64_t sample_rate = get_sample_rate();
uint64_t sample_limit = get_sample_limit();
double sample_time;
if (sample_rate == 0)
sample_time = 0;
else
sample_time = sample_limit * 1.0 / sample_rate;
return sample_time;
}
const GSList* DevInst::get_dev_mode_list()
{
assert(_owner);
sr_dev_inst *const sdi = dev_inst();
assert(sdi);
return sr_dev_mode_list(sdi);
}
QString DevInst::name()
{
sr_dev_inst *const sdi = dev_inst();
assert(sdi);
return QString::fromLocal8Bit(sdi->driver->name);
}
bool DevInst::is_trigger_enabled()
{
return false;
}
void DevInst::start()
{
if (sr_session_start() != SR_OK)
throw tr("Failed to start session.");
//assert(false);
}
void DevInst::run()
{
dsv_info("%s", "session run loop start");
int ret = sr_session_run();
if (ret != SR_OK){
dsv_err("%s", "start session error!");
}
dsv_info("%s", "session run loop end");
}
void DevInst::stop()
{
sr_session_stop();
}
bool DevInst::is_usable()
{
return _usable;
}
void DevInst::destroy(){
release();
//delete this; //do not to destroy
}
} // device
} // pv

150
DSView/pv/device/devinst.h
View File

@ -1,150 +0,0 @@
/*
* This file is part of the DSView project.
* DSView is based on PulseView.
*
* Copyright (C) 2014 Joel Holdsworth <joel@airwebreathe.org.uk>
*
* 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 DSVIEW_PV_DEVICE_DEVINST_H
#define DSVIEW_PV_DEVICE_DEVINST_H
#include <QObject>
#include <string>
#include <glib.h>
#include <stdint.h>
#include "libsigrok.h"
struct sr_dev_inst;
struct sr_channel;
struct sr_channel_group;
namespace pv {
class SigSession;
namespace device {
class DevInst : public QObject
{
Q_OBJECT
protected:
DevInst();
virtual ~DevInst();
public:
SigSession* owner();
GVariant* get_config(const sr_channel *ch, const sr_channel_group *group, int key);
bool set_config(sr_channel *ch, sr_channel_group *group, int key, GVariant *data);
GVariant* list_config(const sr_channel_group *group, int key);
void enable_probe(const sr_channel *probe, bool enable = true);
/**
* @brief Gets the sample limit from the driver.
*
* @return The returned sample limit from the driver, or 0 if the
* sample limit could not be read.
*/
uint64_t get_sample_limit();
/**
* @brief Gets the sample rate from the driver.
*
* @return The returned sample rate from the driver, or 0 if the
* sample rate could not be read.
*/
uint64_t get_sample_rate();
/**
* @brief Gets the sample time from the driver.
*
* @return The returned sample time from the driver, or 0 if the
* sample time could not be read.
*/
double get_sample_time();
/**
* @brief Gets the time base from the driver.
*
* @return The returned time base from the driver, or 0 if the
* time base could not be read.
*/
uint64_t get_time_base();
/**
* @brief Gets the device mode list from the driver.
*
* @return The returned device mode list from the driver, or NULL if the
* mode list could not be read.
*/
const GSList *get_dev_mode_list();
/**
* @brief Get the device name from the driver
*
* @return device name
*/
QString name();
bool is_usable();
void destroy();
inline bool is_file(){
return _is_file;
}
public:
virtual void start();
virtual void run();
virtual void stop();
virtual void* get_id();
virtual sr_dev_inst* dev_inst() = 0;
virtual void use(SigSession *owner);
virtual void release();
virtual bool is_trigger_enabled();
virtual QString format_device_title() = 0;
signals:
void device_updated();
void config_changed();
protected:
SigSession *_owner;
void *_id;
bool _usable;
bool _is_file;
};
} // device
} // pv
#endif // DSVIEW_PV_DEVICE_DEVINST_H

129
DSView/pv/device/file.cpp
View File

@ -1,129 +0,0 @@
/*
* This file is part of the DSView project.
* DSView is based on PulseView.
*
* Copyright (C) 2014 Joel Holdsworth <joel@airwebreathe.org.uk>
*
* 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
*/
#include "file.h"
#include "inputfile.h"
#include "sessionfile.h"
#include <QFileInfo>
#include <assert.h>
#include "../utility/path.h"
#include <stdlib.h>
#include "../ZipMaker.h"
#include "../log.h"
namespace pv {
namespace device {
File::File(QString path)
:_path(path)
{
}
File::~File(){
}
QString File::format_device_title()
{
QFileInfo fi(_path);
return fi.fileName();
}
File* File::create(QString name)
{
auto f_name = path::ConvertPath(name);
if (sr_session_load(f_name.c_str()) == SR_OK) {
GSList *devlist = NULL;
sr_session_dev_list(&devlist);
sr_session_destroy();
if (devlist) {
sr_dev_inst *const sdi = (sr_dev_inst*)devlist->data;
g_slist_free(devlist);
if (sdi) {
sr_dev_close(sdi);
sr_dev_clear(sdi->driver);
return new SessionFile(name);
}
}
}
return new InputFile(name);
}
QJsonArray File::get_decoders()
{
QJsonArray dec_array;
QJsonParseError error;
/* read "decoders" */
auto f_name = path::ConvertPath(_path);
ZipReader rd(f_name.c_str());
auto *data = rd.GetInnterFileData("decoders");
if (data != NULL){
QByteArray raw_bytes = QByteArray::fromRawData(data->data(), data->size());
QString jsonStr(raw_bytes.data());
QByteArray qbs = jsonStr.toUtf8();
QJsonDocument sessionDoc = QJsonDocument::fromJson(qbs, &error);
if (error.error != QJsonParseError::NoError){
QString estr = error.errorString();
dsv_err("File::get_decoders(), parse json error:\"%s\"!", estr.toUtf8().data());
}
dec_array = sessionDoc.array();
rd.ReleaseInnerFileData(data);
}
return dec_array;
}
QJsonDocument File::get_session()
{
QJsonDocument sessionDoc;
QJsonParseError error;
auto f_name = path::ConvertPath(_path);
ZipReader rd(f_name.c_str());
auto *data = rd.GetInnterFileData("session");
if (data != NULL){
QByteArray raw_bytes = QByteArray::fromRawData(data->data(), data->size());
QString jsonStr(raw_bytes.data());
QByteArray qbs = jsonStr.toUtf8();
sessionDoc = QJsonDocument::fromJson(qbs, &error);
if (error.error != QJsonParseError::NoError){
QString estr = error.errorString();
dsv_err("File::get_session(), parse json error:\"%s\"!", estr.toUtf8().data());
}
rd.ReleaseInnerFileData(data);
}
return sessionDoc;
}
} // device
} // pv

58
DSView/pv/device/file.h
View File

@ -1,58 +0,0 @@
/*
* This file is part of the DSView project.
* DSView is based on PulseView.
*
* Copyright (C) 2014 Joel Holdsworth <joel@airwebreathe.org.uk>
*
* 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 DSVIEW_PV_DEVICE_FILE_H
#define DSVIEW_PV_DEVICE_FILE_H
#include <QJsonArray>
#include <QJsonDocument>
#include <QFile>
#include <string.h>
#include "devinst.h"
namespace pv {
namespace device {
class File : public DevInst
{
protected:
File(QString path);
public:
~File();
static File* create(QString name);
QJsonArray get_decoders();
QJsonDocument get_session();
public:
QString format_device_title();
protected:
const QString _path;
};
} // device
} // pv
#endif // DSVIEW_PV_DEVICE_FILE_H

139
DSView/pv/device/inputfile.cpp
View File

@ -1,139 +0,0 @@
/*
* This file is part of the DSView project.
* DSView is based on PulseView.
*
* Copyright (C) 2014 Joel Holdsworth <joel@airwebreathe.org.uk>
*
* 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
*/
#include <cassert>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include "inputfile.h"
using std::string;
namespace pv {
namespace device {
InputFile::InputFile(QString path) :
File(path),
_input(NULL)
{
_is_file = true;
}
sr_dev_inst* InputFile::dev_inst()
{
assert(_input);
return _input->sdi;
}
void InputFile::use(SigSession *owner)
{
(void)owner;
assert(!_input);
// only *.dsl file is valid
// don't allow other types of file input
throw tr("Not a valid DSView data file.");
return;
}
void InputFile::release()
{
if (!_owner)
return;
assert(_input);
File::release();
sr_dev_close(_input->sdi);
sr_session_destroy();
_input = NULL;
}
sr_input_format* InputFile::determine_input_file_format(const QString filename)
{
int i;
/* If there are no input formats, return NULL right away. */
sr_input_format *const *const inputs = sr_input_list();
if (!inputs) {
g_critical("No supported input formats available.");
return NULL;
}
/* Otherwise, try to find an input module that can handle this file. */
for (i = 0; inputs[i]; i++) {
if (inputs[i]->format_match(filename.toUtf8().data()))
break;
}
/* Return NULL if no input module wanted to touch this. */
if (!inputs[i]) {
g_critical("Error: no matching input module found.");
return NULL;
}
return inputs[i];
}
sr_input* InputFile::load_input_file_format(const QString filename,
sr_input_format *format)
{
struct stat st;
sr_input *in;
if (!format && !(format =
determine_input_file_format(filename))) {
/* The exact cause was already logged. */
throw tr("Failed to load file");
}
if (stat(filename.toUtf8().data(), &st) == -1)
throw tr("Failed to load file");
/* Initialize the input module. */
if (!(in = new sr_input)) {
throw tr("Failed to allocate input module.");
}
in->format = format;
in->param = NULL;
if (in->format->init &&
in->format->init(in, filename.toUtf8().data()) != SR_OK) {
throw tr("Failed to load file");
}
return in;
}
void InputFile::start()
{
}
void InputFile::run()
{
assert(_input);
assert(_input->format);
assert(_input->format->loadfile);
_input->format->loadfile(_input, _path.toUtf8().data());
}
} // device
} // pv

69
DSView/pv/device/inputfile.h
View File

@ -1,69 +0,0 @@
/*
* This file is part of the DSView project.
* DSView is based on PulseView.
*
* Copyright (C) 2014 Joel Holdsworth <joel@airwebreathe.org.uk>
*
* 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 DSVIEW_PV_DEVICE_INPUTFILE_H
#define DSVIEW_PV_DEVICE_INPUTFILE_H
#include "file.h"
#include <string>
struct sr_input;
struct sr_input_format;
namespace pv {
namespace device {
class InputFile : public File
{
public:
InputFile(QString path);
sr_dev_inst* dev_inst();
virtual void use(SigSession *owner);
virtual void release();
virtual void start();
virtual void run();
private:
/**
* Attempts to autodetect the format. Failing that
* @param filename The filename of the input file.
* @return A pointer to the 'struct sr_input_format' that should be used,
* or NULL if no input format was selected or auto-detected.
*/
static sr_input_format* determine_input_file_format(
const QString filename);
static sr_input* load_input_file_format(const QString filename,
sr_input_format *format);
private:
sr_input *_input;
};
} // device
} // pv
#endif // DSVIEW_PV_DEVICE_INPUTFILE_H

85
DSView/pv/device/sessionfile.cpp
View File

@ -1,85 +0,0 @@
/*
* This file is part of the DSView project.
* DSView is based on PulseView.
*
* Copyright (C) 2014 Joel Holdsworth <joel@airwebreathe.org.uk>
*
* 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
*/
#include "sessionfile.h"
#include <assert.h>
#include "../utility/path.h"
namespace pv {
namespace device {
SessionFile::SessionFile(QString path) :
File(path)
{
_sdi = NULL;
_is_file = true;
}
sr_dev_inst* SessionFile::dev_inst()
{
return _sdi;
}
void SessionFile::use(SigSession *owner)
{
if (_sdi){
release_source();
}
auto f_name = path::ConvertPath(_path);
if (sr_session_load(f_name.c_str()) != SR_OK)
throw tr("Failed to open file.\n");
GSList *devlist = NULL;
sr_session_dev_list(&devlist);
if (!devlist || !devlist->data) {
if (devlist)
g_slist_free(devlist);
throw tr("Failed to start session.");
}
_sdi = (sr_dev_inst*)devlist->data;
g_slist_free(devlist);
File::use(owner);
}
void SessionFile::release()
{
release_source();
File::release();
}
void SessionFile::release_source()
{
if (_sdi != NULL)
{
sr_dev_close(_sdi);
sr_dev_clear(_sdi->driver);
sr_session_destroy();
_sdi = NULL;
}
}
} // device
} // pv

48
DSView/pv/device/sessionfile.h
View File

@ -1,48 +0,0 @@
/*
* This file is part of the DSView project.
* DSView is based on PulseView.
*
* Copyright (C) 2014 Joel Holdsworth <joel@airwebreathe.org.uk>
*
* 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 DSVIEW_PV_DEVICE_SESSIONFILE_H
#define DSVIEW_PV_DEVICE_SESSIONFILE_H
#include "file.h"
namespace pv {
namespace device {
class SessionFile : public File
{
public:
SessionFile(QString path);
sr_dev_inst* dev_inst();
virtual void use(SigSession *owner);
virtual void release();
private:
void release_source();
private:
sr_dev_inst *_sdi;
};
} // device
} // pv
#endif // DSVIEW_PV_DEVICE_SESSIONFILE_H

352
DSView/pv/deviceagent.cpp Normal file
View File

@ -0,0 +1,352 @@
/*
* This file is part of the DSView project.
* DSView is based on PulseView.
*
* Copyright (C) 2022 DreamSourceLab <support@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
*/
#include "deviceagent.h"
#include <assert.h>
#include "log.h"
DeviceAgent::DeviceAgent()
{
_dev_handle = NULL_HANDLE;
_di = NULL;
_dev_type = 0;
_callback = NULL;
_is_new_device = false;
}
void DeviceAgent::update()
{
_dev_handle = NULL_HANDLE;
_dev_name = "";
_path = "";
_di = NULL;
_dev_type = 0;
struct ds_device_full_info info;
if (ds_get_actived_device_info(&info) == SR_OK)
{
_dev_handle = info.handle;
_dev_type = info.dev_type;
_di = info.di;
_dev_name = QString::fromLocal8Bit(info.name);
_driver_name = QString::fromLocal8Bit(info.driver_name);
if (info.path[0] != '\0'){
_path = QString::fromLocal8Bit(info.path);
}
if (is_in_history(_dev_handle) == false){
_is_new_device = true;
}
else{
_is_new_device = false;
}
}
}
sr_dev_inst* DeviceAgent::inst()
{
assert(_dev_handle);
return _di;
}
GVariant* DeviceAgent::get_config(const sr_channel *ch, const sr_channel_group *group, int key)
{
assert(_dev_handle);
GVariant *data = NULL;
if (ds_get_actived_device_config(ch, group, key, &data) != SR_OK)
{
if (is_hardware())
dsv_warn("%s%d", "WARNING: Failed to get value of config id:", key);
else
dsv_detail("%s%d", "WARNING: Failed to get value of config id:", key);
}
return data;
}
bool DeviceAgent::set_config(sr_channel *ch, sr_channel_group *group, int key, GVariant *data)
{
assert(_dev_handle);
if (ds_set_actived_device_config(ch, group, key, data) != SR_OK)
{
if (is_hardware())
dsv_warn("%s%d", "WARNING: Failed to set value of config id:", key);
else
dsv_detail("%s%d", "WARNING: Failed to set value of config id:", key);
return false;
}
config_changed();
return true;
}
GVariant* DeviceAgent::get_config_list(const sr_channel_group *group, int key)
{
assert(_dev_handle);
GVariant *data = NULL;
if (ds_get_actived_device_config_list(group, key, &data) != SR_OK){
dsv_warn("%s%d", "WARNING: Failed to get config list, key:", key);
if (data != NULL){
dsv_warn("%s%d", "WARNING: Failed to get config list, but data is not null. key:", key);
}
data = NULL;
}
return data;
}
bool DeviceAgent::enable_probe(const sr_channel *probe, bool enable)
{
assert(_dev_handle);
if (ds_enable_device_channel(probe, enable) == SR_OK){
config_changed();
return true;
}
return false;
}
bool DeviceAgent::enable_probe(int probe_index, bool enable)
{
assert(_dev_handle);
if (ds_enable_device_channel_index(probe_index, enable) == SR_OK){
config_changed();
return true;
}
return false;
}
bool DeviceAgent::set_channel_name(int ch_index, const char *name)
{
assert(_dev_handle);
if (ds_set_device_channel_name(ch_index, name) == SR_OK){
config_changed();
return true;
}
return false;
}
uint64_t DeviceAgent::get_sample_limit()
{
assert(_dev_handle);
uint64_t v;
GVariant* gvar = NULL;
ds_get_actived_device_config(NULL, NULL, SR_CONF_LIMIT_SAMPLES, &gvar);
if (gvar != NULL) {
v = g_variant_get_uint64(gvar);
g_variant_unref(gvar);
}
else {
v = 0U;
}
return v;
}
uint64_t DeviceAgent::get_sample_rate()
{
assert(_dev_handle);
uint64_t v;
GVariant* gvar = NULL;
ds_get_actived_device_config(NULL, NULL, SR_CONF_SAMPLERATE, &gvar);
if (gvar != NULL) {
v = g_variant_get_uint64(gvar);
g_variant_unref(gvar);
}
else {
v = 0U;
}
return v;
}
uint64_t DeviceAgent::get_time_base()
{
assert(_dev_handle);
uint64_t v;
GVariant* gvar = NULL;
ds_get_actived_device_config(NULL, NULL, SR_CONF_TIMEBASE, &gvar);
if (gvar != NULL) {
v = g_variant_get_uint64(gvar);
g_variant_unref(gvar);
}
else {
v = 0U;
}
return v;
}
double DeviceAgent::get_sample_time()
{
assert(_dev_handle);
uint64_t sample_rate = get_sample_rate();
uint64_t sample_limit = get_sample_limit();
double sample_time;
if (sample_rate == 0)
sample_time = 0;
else
sample_time = sample_limit * 1.0 / sample_rate;
return sample_time;
}
const GSList* DeviceAgent::get_device_mode_list()
{
assert(_dev_handle);
return ds_get_actived_device_mode_list();
}
bool DeviceAgent::is_trigger_enabled()
{
assert(_dev_handle);
if (ds_trigger_is_enabled() > 0){
return true;
}
return false;
}
bool DeviceAgent::start()
{
assert(_dev_handle);
if (ds_start_collect() == SR_OK){
return true;
}
return false;
}
bool DeviceAgent::stop()
{
assert(_dev_handle);
if (ds_stop_collect() == SR_OK){
return true;
}
return false;
}
void DeviceAgent::release()
{
ds_release_actived_device();
}
bool DeviceAgent::have_enabled_channel()
{
assert(_dev_handle);
return ds_channel_is_enabled() > 0;
}
bool DeviceAgent::get_status(struct sr_status &status, gboolean prg)
{
assert(_dev_handle);
if (ds_get_actived_device_status(&status, prg) == SR_OK){
return true;
}
return false;
}
void DeviceAgent::config_changed()
{
if (_callback != NULL){
_callback->DeviceConfigChanged();
}
}
//---------------device config-----------/
int DeviceAgent::get_work_mode()
{
return ds_get_actived_device_mode();
}
const struct sr_config_info *DeviceAgent::get_config_info(int key)
{
return ds_get_actived_device_config_info(key);
}
const struct sr_config_info *DeviceAgent::get_config_info_by_name(const char *optname)
{
return ds_get_actived_device_config_info_by_name(optname);
}
bool DeviceAgent::get_device_status(struct sr_status &status, gboolean prg)
{
if (ds_get_actived_device_status(&status, prg) == SR_OK)
{
return true;
}
return false;
}
struct sr_config *DeviceAgent::new_config(int key, GVariant *data)
{
return ds_new_config(key, data);
}
void DeviceAgent::free_config(struct sr_config *src)
{
ds_free_config(src);
}
bool DeviceAgent::is_collecting()
{
return ds_is_collecting() > 0;
}
GSList *DeviceAgent::get_channels()
{
assert(_dev_handle);
return ds_get_actived_device_channels();
}
bool DeviceAgent::is_in_history(ds_device_handle dev_handle)
{
for(ds_device_handle h : _history_handles){
if (h == dev_handle){
return true;
}
}
_history_handles.push_back(dev_handle);
return false;
}
//---------------device config end -----------/

198
DSView/pv/deviceagent.h Normal file
View File

@ -0,0 +1,198 @@
/*
* This file is part of the DSView project.
* DSView is based on PulseView.
*
* Copyright (C) 2022 DreamSourceLab <support@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 DEVICE_AGENT_H
#define DEVICE_AGENT_H
#include <glib.h>
#include <stdint.h>
#include <libsigrok.h>
#include <QString>
#include <vector>
class IDeviceAgentCallback
{
public:
virtual void DeviceConfigChanged()=0;
};
class DeviceAgent
{
public:
DeviceAgent();
void update();
inline bool have_instance(){
return _dev_handle != NULL_HANDLE;
}
inline QString name(){
return _dev_name;
}
inline QString path(){
return _path;
}
inline QString driver_name(){
return _driver_name;
}
inline ds_device_handle handle(){
return _dev_handle;
}
struct sr_dev_inst* inst();
inline bool is_file(){
return _dev_type == DEV_TYPE_FILELOG;
}
inline bool is_demo(){
return _dev_type == DEV_TYPE_DEMO;
}
inline bool is_hardware(){
return _dev_type == DEV_TYPE_USB;
}
inline void set_callback(IDeviceAgentCallback *callback){
_callback = callback;
}
GVariant* get_config(const sr_channel *ch, const sr_channel_group *group, int key);
bool set_config(sr_channel *ch, sr_channel_group *group, int key, GVariant *data);
GVariant* get_config_list(const sr_channel_group *group, int key);
bool enable_probe(const sr_channel *probe, bool enable);
bool enable_probe(int probe_index, bool enable);
bool set_channel_name(int ch_index, const char *name);
/**
* @brief Gets the sample limit from the driver.
*
* @return The returned sample limit from the driver, or 0 if the
* sample limit could not be read.
*/
uint64_t get_sample_limit();
/**
* @brief Gets the sample rate from the driver.
*
* @return The returned sample rate from the driver, or 0 if the
* sample rate could not be read.
*/
uint64_t get_sample_rate();
/**
* @brief Gets the time base from the driver.
*
* @return The returned time base from the driver, or 0 if the
* time base could not be read.
*/
uint64_t get_time_base();
/**
* @brief Gets the sample time from the driver.
*
* @return The returned sample time from the driver, or 0 if the
* sample time could not be read.
*/
double get_sample_time();
/**
* @brief Gets the device mode list from the driver.
*
* @return The returned device mode list from the driver, or NULL if the
* mode list could not be read.
*/
const GSList *get_device_mode_list();
/**
* Check whether the trigger exists
*/
bool is_trigger_enabled();
bool have_enabled_channel();
bool get_status(struct sr_status &status, gboolean prg);
GSList* get_channels();
/**
* Start collect data.
*/
bool start();
/**
* Stop collect
*/
bool stop();
/**
* Stop and close.
*/
void release();
bool is_collecting();
inline bool is_new_device(){
return _is_new_device;
}
private:
void config_changed();
bool is_in_history(ds_device_handle dev_handle);
//---------------device config-----------/
public:
int get_work_mode();
const struct sr_config_info* get_config_info(int key);
const struct sr_config_info* get_config_info_by_name(const char *optname);
bool get_device_status(struct sr_status &status, gboolean prg);
struct sr_config* new_config(int key, GVariant *data);
void free_config(struct sr_config *src);
private:
ds_device_handle _dev_handle;
int _dev_type;
QString _dev_name;
QString _driver_name;
QString _path;
bool _is_new_device;
struct sr_dev_inst *_di;
std::vector<ds_device_handle> _history_handles;
IDeviceAgentCallback *_callback;
};
#endif

191
DSView/pv/devicemanager.cpp
View File

@ -1,191 +0,0 @@
/*
* This file is part of the DSView project.
* DSView is based on PulseView.
*
* Copyright (C) 2012 Joel Holdsworth <joel@airwebreathe.org.uk>
* Copyright (C) 2013 DreamSourceLab <support@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
*/
#include "devicemanager.h"
#include "device/devinst.h"
#include "device/device.h"
#include "sigsession.h"
#include <cassert>
#include <sstream>
#include <stdexcept>
#include <string>
#include <QObject>
#include <QDir>
#include "config/appconfig.h"
using std::list;
using std::map;
using std::ostringstream;
using std::runtime_error;
using std::string;
namespace pv {
DeviceManager::DeviceManager()
{
_sr_ctx = NULL;
}
DeviceManager::DeviceManager(DeviceManager &o)
{
(void)o;
}
DeviceManager::~DeviceManager()
{
}
void DeviceManager::initAll(struct sr_context *sr_ctx)
{
_sr_ctx = sr_ctx;
init_drivers();
scan_all_drivers();
}
void DeviceManager::UnInitAll()
{
release_devices();
}
void DeviceManager::add_device(DevInst *device)
{
assert(device);
auto it = std::find(_devices.begin(), _devices.end(), device);
if (it ==_devices.end()){
_devices.push_front(device);
}
}
void DeviceManager::del_device(DevInst *device)
{
assert(device);
auto it = std::find(_devices.begin(), _devices.end(), device);
if (it !=_devices.end()){
_devices.erase(it); //remove from list
device->destroy();
}
}
void DeviceManager::driver_scan(
std::list<DevInst*> &driver_devices,
struct sr_dev_driver *const driver,
GSList *const drvopts)
{
assert(driver);
// Remove any device instances from this driver from the device
// list. They will not be valid after the scan.
auto i = _devices.begin();
while (i != _devices.end()) {
if ((*i)->dev_inst() && (*i)->dev_inst()->driver == driver) {
(*i)->release();
i = _devices.erase(i);
} else {
i++;
}
}
// Clear all the old device instances from this driver
sr_dev_clear(driver);
//release_driver(driver);
// Check If DSL hardware driver
if (strncmp(driver->name, "virtual", 7)) {
QDir dir(GetResourceDir());
if (!dir.exists())
return;
}
// Do the scan
GSList *const devices = sr_driver_scan(driver, drvopts);
for (GSList *l = devices; l; l = l->next){
Device *dev = new device::Device((sr_dev_inst*)l->data); //create new device
driver_devices.push_front(dev);
}
g_slist_free(devices);
// append the scanned devices to the main list
_devices.insert(_devices.end(), driver_devices.begin(), driver_devices.end());
}
void DeviceManager::init_drivers()
{
// Initialise all libsigrok drivers
sr_dev_driver **const drivers = sr_driver_list();
for (sr_dev_driver **driver = drivers; *driver; driver++) {
if (sr_driver_init(_sr_ctx, *driver) != SR_OK) {
throw runtime_error(
string("Failed to initialize driver ") +
string((*driver)->name));
}
}
}
void DeviceManager::release_devices()
{
// Release all the used devices
for (DevInst *dev : _devices) {
dev->release();
}
// Clear all the drivers
sr_dev_driver **const drivers = sr_driver_list();
for (sr_dev_driver **driver = drivers; *driver; driver++)
sr_dev_clear(*driver);
}
void DeviceManager::scan_all_drivers()
{
// Scan all drivers for all devices.
struct sr_dev_driver **const drivers = sr_driver_list();
for (struct sr_dev_driver **driver = drivers; *driver; driver++){
std::list<DevInst*> driver_devices;
driver_scan(driver_devices, *driver);
}
}
void DeviceManager::release_driver(struct sr_dev_driver *const driver)
{
for (DevInst *dev : _devices) {
if(dev->dev_inst()->driver == driver)
dev->release();
}
// Clear all the old device instances from this driver
sr_dev_clear(driver);
}
bool DeviceManager::compare_devices(DevInst *a, DevInst *b)
{
assert(a);
assert(b);
return a->format_device_title().compare(b->format_device_title()) <= 0;
}
} // namespace pv

93
DSView/pv/devicemanager.h
View File

@ -1,93 +0,0 @@
/*
* This file is part of the DSView project.
* DSView is based on PulseView.
*
* Copyright (C) 2012 Joel Holdsworth <joel@airwebreathe.org.uk>
* Copyright (C) 2013 DreamSourceLab <support@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 DSVIEW_PV_DEVICEMANAGER_H
#define DSVIEW_PV_DEVICEMANAGER_H
#include <glib.h>
#include <list>
#include <map>
#include <string>
#include <QObject>
#include <QString>
struct sr_context;
struct sr_dev_driver;
struct sr_dev_inst;
namespace pv {
class SigSession;
namespace device {
class DevInst;
}
using namespace pv::device;
class DeviceManager
{
private:
DeviceManager(DeviceManager &o);
public:
DeviceManager();
~DeviceManager();
inline const std::list<DevInst*>& devices(){
return _devices;
}
void add_device(DevInst *device);
void del_device(DevInst *device);
void driver_scan(
std::list<DevInst*> &driver_devices,
struct sr_dev_driver *const driver=NULL,
GSList *const drvopts=NULL);
void initAll(struct sr_context *sr_ctx);
void UnInitAll();
private:
void init_drivers();
void release_devices();
void scan_all_drivers();
void release_driver(struct sr_dev_driver *const driver);
static bool compare_devices(DevInst *a, DevInst *b);
private:
struct sr_context* _sr_ctx;
std::list<DevInst*> _devices;
};
} // namespace pv
#endif // DSVIEW_PV_DEVICEMANAGER_H

63
DSView/pv/dialogs/calibration.cpp
View File

@ -31,6 +31,8 @@
#include "../view/trace.h"
#include "../dialogs/dsmessagebox.h"
#include "../dsvdef.h"
#include "../appcontrol.h"
#include "../sigsession.h"
using namespace std;
@ -59,7 +61,8 @@ Calibration::Calibration(QWidget *parent) :
this->setWindowOpacity(0.7);
this->setModal(false);
_dev_inst = NULL;
_device_agent = AppControl::Instance()->GetSession()->get_device();
_save_btn = new QPushButton(this);
_abort_btn = new QPushButton(this);
_reset_btn = new QPushButton(this);
@ -120,10 +123,11 @@ void Calibration::retranslateUi()
setTitle(tr("Manual Calibration"));
}
void Calibration::set_device(DevInst *dev_inst)
{
assert(dev_inst);
_dev_inst = dev_inst;
void Calibration::update_device_info()
{
if (_device_agent->have_instance()){
assert(false);
}
for(std::list<QSlider *>::const_iterator i = _slider_list.begin();
i != _slider_list.end(); i++) {
@ -131,6 +135,7 @@ void Calibration::set_device(DevInst *dev_inst)
_flayout->removeWidget((*i));
delete (*i);
}
_slider_list.clear();
for(std::list<QLabel *>::const_iterator i = _label_list.begin();
i != _label_list.end(); i++) {
@ -140,23 +145,23 @@ void Calibration::set_device(DevInst *dev_inst)
}
_label_list.clear();
for (const GSList *l = _dev_inst->dev_inst()->channels; l; l = l->next) {
for (const GSList *l = _device_agent->get_channels(); l; l = l->next) {
sr_channel *const probe = (sr_channel*)l->data;
assert(probe);
uint64_t vgain = 0, vgain_default = 0;
uint16_t vgain_range = 0;
GVariant* gvar = _dev_inst->get_config(probe, NULL, SR_CONF_PROBE_VGAIN);
GVariant* gvar = _device_agent->get_config(probe, NULL, SR_CONF_PROBE_VGAIN);
if (gvar != NULL) {
vgain = g_variant_get_uint64(gvar);
g_variant_unref(gvar);
}
gvar = _dev_inst->get_config(probe, NULL, SR_CONF_PROBE_VGAIN_DEFAULT);
gvar = _device_agent->get_config(probe, NULL, SR_CONF_PROBE_VGAIN_DEFAULT);
if (gvar != NULL) {
vgain_default = g_variant_get_uint64(gvar);
g_variant_unref(gvar);
}
gvar = _dev_inst->get_config(probe, NULL, SR_CONF_PROBE_VGAIN_RANGE);
gvar = _device_agent->get_config(probe, NULL, SR_CONF_PROBE_VGAIN_RANGE);
if (gvar != NULL) {
vgain_range = g_variant_get_uint16(gvar);
g_variant_unref(gvar);
@ -174,12 +179,12 @@ void Calibration::set_device(DevInst *dev_inst)
uint64_t voff = 0;
uint16_t voff_range = 0;
gvar = _dev_inst->get_config(probe, NULL, SR_CONF_PROBE_PREOFF);
gvar = _device_agent->get_config(probe, NULL, SR_CONF_PROBE_PREOFF);
if (gvar != NULL) {
voff = g_variant_get_uint16(gvar);
g_variant_unref(gvar);
}
gvar = _dev_inst->get_config(probe, NULL, SR_CONF_PROBE_PREOFF_MARGIN);
gvar = _device_agent->get_config(probe, NULL, SR_CONF_PROBE_PREOFF_MARGIN);
if (gvar != NULL) {
voff_range = g_variant_get_uint16(gvar);
g_variant_unref(gvar);
@ -195,14 +200,14 @@ void Calibration::set_device(DevInst *dev_inst)
_label_list.push_back(off_label);
bool comb_comp_en = false;
gvar = _dev_inst->get_config(NULL, NULL, SR_CONF_PROBE_COMB_COMP_EN);
gvar = _device_agent->get_config(NULL, NULL, SR_CONF_PROBE_COMB_COMP_EN);
if (gvar != NULL) {
comb_comp_en = g_variant_get_boolean(gvar);
g_variant_unref(gvar);
}
if (comb_comp_en) {
int16_t comb_comp = 0;
gvar = _dev_inst->get_config(probe, NULL, SR_CONF_PROBE_COMB_COMP);
gvar = _device_agent->get_config(probe, NULL, SR_CONF_PROBE_COMB_COMP);
if (gvar != NULL) {
comb_comp = g_variant_get_int16(gvar);
g_variant_unref(gvar);
@ -229,14 +234,14 @@ void Calibration::set_device(DevInst *dev_inst)
void Calibration::accept()
{
using namespace Qt;
_dev_inst->set_config(NULL, NULL, SR_CONF_CALI, g_variant_new_boolean(false));
_device_agent->set_config(NULL, NULL, SR_CONF_CALI, g_variant_new_boolean(false));
QDialog::accept();
}
void Calibration::reject()
{
using namespace Qt;
_dev_inst->set_config(NULL, NULL, SR_CONF_CALI, g_variant_new_boolean(false));
_device_agent->set_config(NULL, NULL, SR_CONF_CALI, g_variant_new_boolean(false));
QDialog::reject();
}
@ -244,25 +249,25 @@ void Calibration::set_value(int value)
{
QSlider* sc = dynamic_cast<QSlider *>(sender());
for (const GSList *l = _dev_inst->dev_inst()->channels; l; l = l->next) {
for (const GSList *l = _device_agent->get_channels(); l; l = l->next) {
sr_channel *const probe = (sr_channel*)l->data;
assert(probe);
if (sc->objectName() == VGAIN+probe->index) {
uint64_t vgain_default;
GVariant* gvar = _dev_inst->get_config(probe, NULL, SR_CONF_PROBE_VGAIN_DEFAULT);
GVariant* gvar = _device_agent->get_config(probe, NULL, SR_CONF_PROBE_VGAIN_DEFAULT);
if (gvar != NULL) {
vgain_default = g_variant_get_uint64(gvar);
g_variant_unref(gvar);
_dev_inst->set_config(probe, NULL, SR_CONF_PROBE_VGAIN,
_device_agent->set_config(probe, NULL, SR_CONF_PROBE_VGAIN,
g_variant_new_uint64(value+vgain_default));
}
break;
} else if (sc->objectName() == VOFF+probe->index) {
_dev_inst->set_config(probe, NULL, SR_CONF_PROBE_PREOFF,
_device_agent->set_config(probe, NULL, SR_CONF_PROBE_PREOFF,
g_variant_new_uint16(value));
break;
} else if (sc->objectName() == VCOMB+probe->index) {
_dev_inst->set_config(probe, NULL, SR_CONF_PROBE_COMB_COMP,
_device_agent->set_config(probe, NULL, SR_CONF_PROBE_COMB_COMP,
g_variant_new_int16(value));
break;
}
@ -275,7 +280,7 @@ void Calibration::on_save()
QFuture<void> future;
future = QtConcurrent::run([&]{
//QTime dieTime = QTime::currentTime().addSecs(1);
_dev_inst->set_config(NULL, NULL, SR_CONF_ZERO_SET,
_device_agent->set_config(NULL, NULL, SR_CONF_ZERO_SET,
g_variant_new_boolean(true));
//while( QTime::currentTime() < dieTime );
});
@ -301,7 +306,7 @@ void Calibration::on_abort()
QFuture<void> future;
future = QtConcurrent::run([&]{
//QTime dieTime = QTime::currentTime().addSecs(1);
_dev_inst->set_config(NULL, NULL, SR_CONF_ZERO_LOAD,
_device_agent->set_config(NULL, NULL, SR_CONF_ZERO_LOAD,
g_variant_new_boolean(true));
reload_value();
//while( QTime::currentTime() < dieTime );
@ -324,23 +329,23 @@ void Calibration::on_abort()
void Calibration::reload_value()
{
for (const GSList *l = _dev_inst->dev_inst()->channels; l; l = l->next) {
for (const GSList *l = _device_agent->get_channels(); l; l = l->next) {
sr_channel *const probe = (sr_channel*)l->data;
assert(probe);
uint64_t vgain = 0, vgain_default = 0;
uint16_t vgain_range = 0;
GVariant* gvar = _dev_inst->get_config(probe, NULL, SR_CONF_PROBE_VGAIN);
GVariant* gvar = _device_agent->get_config(probe, NULL, SR_CONF_PROBE_VGAIN);
if (gvar != NULL) {
vgain = g_variant_get_uint64(gvar);
g_variant_unref(gvar);
}
gvar = _dev_inst->get_config(probe, NULL, SR_CONF_PROBE_VGAIN_DEFAULT);
gvar = _device_agent->get_config(probe, NULL, SR_CONF_PROBE_VGAIN_DEFAULT);
if (gvar != NULL) {
vgain_default = g_variant_get_uint64(gvar);
g_variant_unref(gvar);
}
gvar = _dev_inst->get_config(probe, NULL, SR_CONF_PROBE_VGAIN_RANGE);
gvar = _device_agent->get_config(probe, NULL, SR_CONF_PROBE_VGAIN_RANGE);
if (gvar != NULL) {
vgain_range = g_variant_get_uint16(gvar);
g_variant_unref(gvar);
@ -348,12 +353,12 @@ void Calibration::reload_value()
uint64_t voff = 0;
uint16_t voff_range = 0;
gvar = _dev_inst->get_config(probe, NULL, SR_CONF_PROBE_PREOFF);
gvar = _device_agent->get_config(probe, NULL, SR_CONF_PROBE_PREOFF);
if (gvar != NULL) {
voff = g_variant_get_uint16(gvar);
g_variant_unref(gvar);
}
gvar = _dev_inst->get_config(probe, NULL, SR_CONF_PROBE_PREOFF_MARGIN);
gvar = _device_agent->get_config(probe, NULL, SR_CONF_PROBE_PREOFF_MARGIN);
if (gvar != NULL) {
voff_range = g_variant_get_uint16(gvar);
g_variant_unref(gvar);
@ -382,7 +387,7 @@ void Calibration::on_reset()
msg.mBox()->addButton(tr("Cancel"), QMessageBox::RejectRole);
msg.mBox()->setIcon(QMessageBox::Warning);
if (msg.exec()) {
_dev_inst->set_config(NULL, NULL, SR_CONF_ZERO_DEFAULT,
_device_agent->set_config(NULL, NULL, SR_CONF_ZERO_DEFAULT,
g_variant_new_boolean(true));
reload_value();
}

14
DSView/pv/dialogs/calibration.h
View File

@ -30,14 +30,13 @@
#include <QSlider>
#include <list>
#include "../device/devinst.h"
#include "../toolbars/titlebar.h"
#include "dsdialog.h"
using namespace pv::device;
class DeviceAgent;
namespace pv {
namespace dialogs {
class Calibration : public DSDialog
@ -53,7 +52,8 @@ public:
Calibration(QWidget *parent);
~Calibration();
void set_device(DevInst *dev_inst);
void update_device_info();
protected:
void accept();
void reject();
@ -69,9 +69,7 @@ private slots:
void on_reset();
void reload_value();
private:
DevInst *_dev_inst;
private:
QPushButton *_save_btn;
QPushButton *_abort_btn;
QPushButton *_reset_btn;
@ -79,6 +77,8 @@ private:
QFormLayout *_flayout;
std::list <QSlider *> _slider_list;
std::list<QLabel *> _label_list;
DeviceAgent *_device_agent;
};
} // namespace dialogs

2
DSView/pv/dialogs/decoderoptionsdlg.cpp
View File

@ -20,7 +20,7 @@
*/
#include "decoderoptionsdlg.h"
#include "libsigrokdecode.h"
#include <libsigrokdecode.h>
#include <QScrollArea>
#include <QDialogButtonBox>
#include <assert.h>

87
DSView/pv/dialogs/deviceoptions.cpp
View File

@ -35,6 +35,8 @@
#include "../prop/property.h"
#include "../dsvdef.h"
#include "../config/appconfig.h"
#include "../appcontrol.h"
#include "../sigsession.h"
using namespace boost;
using namespace std;
@ -43,7 +45,7 @@ ChannelLabel::ChannelLabel(IChannelCheck *check, QWidget *parent, int chanIndex)
: QWidget(parent)
{
_checked = check;
_index = chanIndex;
_index = chanIndex;
this->setFixedSize(30, 40);
@ -76,10 +78,8 @@ void ChannelLabel::on_checked()
namespace pv {
namespace dialogs {
DeviceOptions::DeviceOptions(QWidget *parent, DevInst *dev_inst) :
DSDialog(parent),
_dev_inst(dev_inst),
_device_options_binding(_dev_inst->dev_inst())
DeviceOptions::DeviceOptions(QWidget *parent) :
DSDialog(parent)
{
_scroll_panel = NULL;
_container_panel = NULL;
@ -91,6 +91,9 @@ DeviceOptions::DeviceOptions(QWidget *parent, DevInst *dev_inst) :
_container_lay = NULL;
_isBuilding = false;
SigSession *session = AppControl::Instance()->GetSession();
_device_agent = session->get_device();
this->setTitle(tr("Device Options"));
this->SetTitleSpace(0);
this->layout()->setSpacing(0);
@ -135,7 +138,7 @@ DeviceOptions::DeviceOptions(QWidget *parent, DevInst *dev_inst) :
auto button_box = new QDialogButtonBox(QDialogButtonBox::Ok, Qt::Horizontal, this);
this->layout()->addWidget(button_box);
GVariant* gvar = _dev_inst->get_config(NULL, NULL, SR_CONF_OPERATION_MODE);
GVariant* gvar = _device_agent->get_config(NULL, NULL, SR_CONF_OPERATION_MODE);
if (gvar != NULL) {
_mode = QString::fromUtf8(g_variant_get_string(gvar, NULL));
g_variant_unref(gvar);
@ -144,8 +147,7 @@ DeviceOptions::DeviceOptions(QWidget *parent, DevInst *dev_inst) :
try_resize_scroll();
connect(&_mode_check, SIGNAL(timeout()), this, SLOT(mode_check()));
connect(button_box, SIGNAL(accepted()), this, SLOT(accept()));
connect(_dev_inst, SIGNAL(device_updated()), this, SLOT(reject()));
connect(button_box, SIGNAL(accepted()), this, SLOT(accept()));
_mode_check.setInterval(100);
_mode_check.start();
@ -167,10 +169,10 @@ void DeviceOptions::accept()
}
// Commit the probes
if (_dev_inst->dev_inst()->mode == LOGIC ||
_dev_inst->dev_inst()->mode == ANALOG) {
int mode = _device_agent->get_work_mode();
if (mode == LOGIC || mode == ANALOG) {
int index = 0;
for (const GSList *l = _dev_inst->dev_inst()->channels; l; l = l->next) {
for (const GSList *l = _device_agent->get_channels(); l; l = l->next) {
sr_channel *const probe = (sr_channel*)l->data;
assert(probe);
probe->enabled = _probes_checkBox_list.at(index)->isChecked();
@ -255,13 +257,16 @@ void DeviceOptions::logic_probes(QVBoxLayout &layout)
_probes_checkBox_list.clear();
//channel count checked
if (_dev_inst->dev_inst()->mode == LOGIC) {
if (_device_agent->get_work_mode()== LOGIC) {
GVariant *gvar_opts;
gsize num_opts;
if (sr_config_list(_dev_inst->dev_inst()->driver, _dev_inst->dev_inst(), NULL, SR_CONF_CHANNEL_MODE,
&gvar_opts) == SR_OK) {
gvar_opts = _device_agent->get_config_list(NULL, SR_CONF_CHANNEL_MODE);
if (gvar_opts != NULL)
{
const char **const options = g_variant_get_strv(gvar_opts, &num_opts);
GVariant* gvar = _dev_inst->get_config(NULL, NULL, SR_CONF_CHANNEL_MODE);
GVariant* gvar = _device_agent->get_config(NULL, NULL, SR_CONF_CHANNEL_MODE);
if (gvar != NULL) {
QString ch_mode = QString::fromUtf8(g_variant_get_string(gvar, NULL));
g_variant_unref(gvar);
@ -284,7 +289,7 @@ void DeviceOptions::logic_probes(QVBoxLayout &layout)
}
}
GVariant *gvar = _dev_inst->get_config(NULL, NULL, SR_CONF_VLD_CH_NUM);
GVariant *gvar = _device_agent->get_config(NULL, NULL, SR_CONF_VLD_CH_NUM);
if (gvar != NULL) {
vld_ch_num = g_variant_get_int16(gvar);
g_variant_unref(gvar);
@ -293,7 +298,7 @@ void DeviceOptions::logic_probes(QVBoxLayout &layout)
// channels
QHBoxLayout *line_lay = NULL;
for (const GSList *l = _dev_inst->dev_inst()->channels; l; l = l->next) {
for (const GSList *l = _device_agent->get_channels(); l; l = l->next) {
sr_channel *const probe = (sr_channel*)l->data;
assert(probe);
@ -373,7 +378,7 @@ void DeviceOptions::enable_max_probes() {
cur_ch_num++;
}
GVariant* gvar = _dev_inst->get_config(NULL, NULL, SR_CONF_VLD_CH_NUM);
GVariant* gvar = _device_agent->get_config(NULL, NULL, SR_CONF_VLD_CH_NUM);
if (gvar == NULL)
return;
@ -391,7 +396,7 @@ void DeviceOptions::enable_max_probes() {
void DeviceOptions::enable_all_probes()
{
GVariant* gvar = _dev_inst->get_config(NULL, NULL, SR_CONF_STREAM);
GVariant* gvar = _device_agent->get_config(NULL, NULL, SR_CONF_STREAM);
if (gvar != NULL) {
bool stream_mode = g_variant_get_boolean(gvar);
g_variant_unref(gvar);
@ -423,9 +428,9 @@ void DeviceOptions::zero_adj()
msg.mBox()->setIcon(QMessageBox::Information);
if (msg.exec()) {
_dev_inst->set_config(NULL, NULL, SR_CONF_ZERO, g_variant_new_boolean(true));
_device_agent->set_config(NULL, NULL, SR_CONF_ZERO, g_variant_new_boolean(true));
} else {
_dev_inst->set_config(NULL, NULL, SR_CONF_ZERO, g_variant_new_boolean(false));
_device_agent->set_config(NULL, NULL, SR_CONF_ZERO, g_variant_new_boolean(false));
}
}
@ -433,7 +438,7 @@ void DeviceOptions::on_calibration()
{
using namespace Qt;
QDialog::accept();
_dev_inst->set_config(NULL, NULL, SR_CONF_CALI, g_variant_new_boolean(true));
_device_agent->set_config(NULL, NULL, SR_CONF_CALI, g_variant_new_boolean(true));
}
void DeviceOptions::mode_check()
@ -443,7 +448,7 @@ void DeviceOptions::mode_check()
bool test;
QString mode;
GVariant* gvar = _dev_inst->get_config(NULL, NULL, SR_CONF_OPERATION_MODE);
GVariant* gvar = _device_agent->get_config(NULL, NULL, SR_CONF_OPERATION_MODE);
if (gvar != NULL) {
mode = QString::fromUtf8(g_variant_get_string(gvar, NULL));
g_variant_unref(gvar);
@ -455,7 +460,7 @@ void DeviceOptions::mode_check()
}
}
gvar = _dev_inst->get_config(NULL, NULL, SR_CONF_TEST);
gvar = _device_agent->get_config(NULL, NULL, SR_CONF_TEST);
if (gvar != NULL) {
test = g_variant_get_boolean(gvar);
g_variant_unref(gvar);
@ -476,7 +481,7 @@ void DeviceOptions::channel_check()
text.remove('&');
if(sc != NULL){
_dev_inst->set_config(NULL, NULL, SR_CONF_CHANNEL_MODE, g_variant_new_string(text.toUtf8().data()));
_device_agent->set_config(NULL, NULL, SR_CONF_CHANNEL_MODE, g_variant_new_string(text.toUtf8().data()));
}
build_dynamic_panel();
@ -487,11 +492,11 @@ void DeviceOptions::analog_channel_check()
{
QCheckBox* sc=dynamic_cast<QCheckBox*>(sender());
if(sc != NULL) {
for (const GSList *l = _dev_inst->dev_inst()->channels; l; l = l->next) {
for (const GSList *l = _device_agent->get_channels(); l; l = l->next) {
sr_channel *const probe = (sr_channel*)l->data;
assert(probe);
if (sc->property("index").toInt() == probe->index)
_dev_inst->set_config(probe, NULL, SR_CONF_PROBE_MAP_DEFAULT,
_device_agent->set_config(probe, NULL, SR_CONF_PROBE_MAP_DEFAULT,
g_variant_new_boolean(sc->isChecked()));
}
}
@ -502,12 +507,12 @@ void DeviceOptions::analog_channel_check()
void DeviceOptions::channel_enable()
{
if (_dev_inst->dev_inst()->mode == LOGIC) {
if (_device_agent->get_work_mode() == LOGIC) {
QCheckBox* sc=dynamic_cast<QCheckBox*>(sender());
if (sc == NULL || !sc->isChecked())
return;
GVariant* gvar = _dev_inst->get_config(NULL, NULL, SR_CONF_STREAM);
GVariant* gvar = _device_agent->get_config(NULL, NULL, SR_CONF_STREAM);
if (gvar == NULL)
return;
@ -523,7 +528,7 @@ void DeviceOptions::channel_enable()
cur_ch_num++;
}
gvar = _dev_inst->get_config(NULL, NULL, SR_CONF_VLD_CH_NUM);
gvar = _device_agent->get_config(NULL, NULL, SR_CONF_VLD_CH_NUM);
if (gvar == NULL)
return;
@ -540,7 +545,7 @@ void DeviceOptions::channel_enable()
sc->setChecked(false);
}
}
else if (_dev_inst->dev_inst()->mode == ANALOG) {
else if (_device_agent->get_work_mode() == ANALOG) {
QCheckBox* sc=dynamic_cast<QCheckBox*>(sender());
if (sc != NULL) {
QGridLayout *const layout = (QGridLayout *)sc->property("Layout").value<void *>();
@ -568,7 +573,7 @@ void DeviceOptions::analog_probes(QGridLayout &layout)
tabWidget->setUsesScrollButtons(false);
//layout.setContentsMargins(0,20, 0, 10);
for (const GSList *l = _dev_inst->dev_inst()->channels; l; l = l->next) {
for (const GSList *l = _device_agent->get_channels(); l; l = l->next) {
sr_channel *const probe = (sr_channel*)l->data;
assert(probe);
@ -589,7 +594,7 @@ void DeviceOptions::analog_probes(QGridLayout &layout)
probe_layout->addWidget(probe_checkBox, 0, 1, 1, 3);
pv::prop::binding::ProbeOptions *probe_options_binding =
new pv::prop::binding::ProbeOptions(_dev_inst->dev_inst(), probe);
new pv::prop::binding::ProbeOptions(probe);
const auto &properties = probe_options_binding->properties();
int i = 1;
@ -607,7 +612,7 @@ void DeviceOptions::analog_probes(QGridLayout &layout)
} else {
if (probe_checkBox->isChecked() && p->name().contains("Map")) {
bool map_default = true;
GVariant* gvar = _dev_inst->get_config(probe, NULL, SR_CONF_PROBE_MAP_DEFAULT);
GVariant* gvar = _device_agent->get_config(probe, NULL, SR_CONF_PROBE_MAP_DEFAULT);
if (gvar != NULL) {
map_default =g_variant_get_boolean(gvar);
g_variant_unref(gvar);
@ -637,16 +642,18 @@ void DeviceOptions::ChannelChecked(int index)
channel_enable();
}
QString DeviceOptions::dynamic_widget(QLayout *lay) {
QString DeviceOptions::dynamic_widget(QLayout *lay)
{
int mode = _device_agent->get_work_mode();
if (_dev_inst->dev_inst()->mode == LOGIC) {
if (mode == LOGIC) {
QVBoxLayout *grid = dynamic_cast<QVBoxLayout*>(lay);
assert(grid);
logic_probes(*grid);
return tr("Channels");
}
else if (_dev_inst->dev_inst()->mode == DSO) {
GVariant* gvar = _dev_inst->get_config(NULL, NULL, SR_CONF_HAVE_ZERO);
else if (mode == DSO) {
GVariant* gvar = _device_agent->get_config(NULL, NULL, SR_CONF_HAVE_ZERO);
if (gvar != NULL) {
bool have_zero = g_variant_get_boolean(gvar);
g_variant_unref(gvar);
@ -670,7 +677,7 @@ QString DeviceOptions::dynamic_widget(QLayout *lay) {
}
}
}
else if (_dev_inst->dev_inst()->mode == ANALOG) {
else if (mode == ANALOG) {
QGridLayout *grid = dynamic_cast<QGridLayout*>(lay);
assert(grid);
analog_probes(*grid);
@ -693,7 +700,7 @@ void DeviceOptions::build_dynamic_panel()
_dynamic_panel = new QGroupBox("group", _dynamic_panel);
_container_lay->addWidget(_dynamic_panel);
if (_dev_inst->dev_inst()->mode == LOGIC)
if (_device_agent->get_work_mode() == LOGIC)
_dynamic_panel->setLayout(new QVBoxLayout());
else
_dynamic_panel->setLayout(new QGridLayout());

15
DSView/pv/dialogs/deviceoptions.h
View File

@ -24,6 +24,7 @@
#ifndef DSVIEW_PV_DEVICEOPTIONS_H
#define DSVIEW_PV_DEVICEOPTIONS_H
#include <libsigrok.h>
#include <QDialog>
#include <QDialogButtonBox>
#include <QGroupBox>
@ -36,10 +37,7 @@
#include <QRadioButton>
#include <QTimer>
#include <QWidget>
#include <vector>
#include "libsigrok.h"
#include "../device/devinst.h"
#include <vector>
#include "../prop/binding/deviceoptions.h"
#include "../prop/binding/probeoptions.h"
#include "../toolbars/titlebar.h"
@ -72,9 +70,10 @@ private:
int _index;
};
using namespace pv::device;
class DeviceAgent;
namespace pv {
namespace dialogs {
class DeviceOptions : public DSDialog, public IChannelCheck
@ -82,7 +81,7 @@ class DeviceOptions : public DSDialog, public IChannelCheck
Q_OBJECT
public:
DeviceOptions(QWidget *parent, DevInst *dev_inst);
DeviceOptions(QWidget *parent);
~DeviceOptions();
@ -116,8 +115,7 @@ private slots:
void on_calibration();
void channel_enable();
private:
DevInst *_dev_inst;
private:
std::vector<QCheckBox *> _probes_checkBox_list;
std::vector<QLayout *> _sub_lays;
@ -133,6 +131,7 @@ private:
int _groupHeight1;
int _groupHeight2;
volatile bool _isBuilding;
DeviceAgent *_device_agent;
pv::prop::binding::DeviceOptions _device_options_binding;
QVector <pv::prop::binding::ProbeOptions *> _probe_options_binding_list;

2
DSView/pv/dialogs/dsdialog.h
View File

@ -29,7 +29,7 @@
#include <QDialogButtonBox>
#include "../toolbars/titlebar.h"
#include "../interface/uicallback.h"
#include "../interface/icallbacks.h"
class QDialogButtonBox;

3
DSView/pv/dialogs/dsomeasure.cpp
View File

@ -20,7 +20,6 @@
*/
#include "dsomeasure.h"
#include "../device/devinst.h"
#include "../sigsession.h"
#include "../view/view.h"
@ -77,7 +76,7 @@ DsoMeasure::DsoMeasure(SigSession *session, View &parent,
connect(_button_box.button(QDialogButtonBox::Cancel), SIGNAL(clicked()), this, SLOT(reject()));
connect(_button_box.button(QDialogButtonBox::Reset), SIGNAL(clicked()), this, SLOT(reset()));
connect(_session->get_device(), SIGNAL(device_updated()), this, SLOT(reject()));
connect(_session->device_event_object(), SIGNAL(device_updated()), this, SLOT(reject()));
}
DsoMeasure::~DsoMeasure(){

9
DSView/pv/dialogs/fftoptions.cpp
View File

@ -220,7 +220,7 @@ FftOptions::FftOptions(QWidget *parent, SigSession *session) :
connect(&_button_box, SIGNAL(rejected()), this, SLOT(reject()));
connect(_window_combobox, SIGNAL(currentIndexChanged(int)), this, SLOT(window_changed(int)));
connect(_len_combobox, SIGNAL(currentIndexChanged(int)), this, SLOT(len_changed(int)));
connect(_session->get_device(), SIGNAL(device_updated()), this, SLOT(reject()));
connect(_session->device_event_object(), SIGNAL(device_updated()), this, SLOT(reject()));
}
FftOptions::~FftOptions(){
@ -243,12 +243,13 @@ void FftOptions::accept()
spectrumTraces->get_spectrum_stack()->set_sample_interval(_interval_combobox->currentData().toInt());
spectrumTraces->get_spectrum_stack()->set_windows_index(_window_combobox->currentData().toInt());
spectrumTraces->set_view_mode(_view_combobox->currentData().toUInt());
//spectrumTraces->init_zoom();
spectrumTraces->set_dbv_range(_dbv_combobox->currentData().toInt());
spectrumTraces->set_enable(_en_checkbox->isChecked());
if (_session->get_capture_state() == SigSession::Stopped &&
spectrumTraces->enabled())
if (_session->is_stopped_status() && spectrumTraces->enabled()){
spectrumTraces->get_spectrum_stack()->calc_fft();
}
}
}
}

2
DSView/pv/dialogs/fftoptions.h
View File

@ -29,8 +29,6 @@
#include <QLabel>
#include <QCheckBox>
#include "../device/devinst.h"
#include "../toolbars/titlebar.h"
#include "dsdialog.h"
#include "../ui/dscombobox.h"

26
DSView/pv/dialogs/interval.cpp
View File

@ -26,9 +26,8 @@
namespace pv {
namespace dialogs {
Interval::Interval(SigSession *session, QWidget *parent) :
Interval::Interval(QWidget *parent) :
DSDialog(parent),
_session(session),
_button_box(QDialogButtonBox::Ok,
Qt::Horizontal, this)
{
@ -36,6 +35,7 @@ Interval::Interval(SigSession *session, QWidget *parent) :
_interval_spinBox = NULL;
_interval_slider = NULL;
_bSetting = false;
_bDone = false;
setMinimumWidth(300);
_interval_label = new QLabel(tr("Interval(s): "), this);
@ -46,9 +46,6 @@ Interval::Interval(SigSession *session, QWidget *parent) :
_interval_slider = new QSlider(Qt::Horizontal, this);
_interval_slider->setRange(0, 10);
_interval_slider->setValue((int)_session->get_repeat_intvl());
_interval_spinBox->setValue(_session->get_repeat_intvl());
QGridLayout *glayout = new QGridLayout(this);
glayout->addWidget(_interval_label, 0, 0);
glayout->addWidget(_interval_spinBox, 0, 1);
@ -66,7 +63,7 @@ Interval::Interval(SigSession *session, QWidget *parent) :
void Interval::accept()
{
using namespace Qt;
_session->set_repeat_intvl(_interval_spinBox->value());
_bDone = true;
QDialog::accept();
}
@ -77,14 +74,24 @@ void Interval::reject()
QDialog::reject();
}
void Interval::set_interval(double value)
{
_interval_slider->setValue((int)value);
_interval_spinBox->setValue(value);
}
double Interval::get_interval()
{
return _interval_spinBox->value();
}
void Interval::on_slider_changed(int value)
{
if (!_bSetting){
_bSetting = true;
_interval_spinBox->setValue((double)value);
_bSetting = false;
}
}
}
void Interval::on_inputbox_changed(double value)
@ -93,8 +100,7 @@ void Interval::on_inputbox_changed(double value)
_bSetting = true;
_interval_slider->setValue((int)value);
_bSetting = false;
}
}
}
} // namespace dialogs

16
DSView/pv/dialogs/interval.h
View File

@ -40,25 +40,31 @@ class Interval : public DSDialog
Q_OBJECT
public:
Interval(SigSession *session, QWidget *parent);
Interval(QWidget *parent);
void set_interval(double value);
double get_interval();
inline bool is_done(){
return _bDone;
}
protected:
void accept();
void reject();
void reject();
private Q_SLOTS:
void on_slider_changed(int value);
void on_inputbox_changed(double value);
private:
SigSession *_session;
QLabel *_interval_label;
QDoubleSpinBox *_interval_spinBox;
QSlider *_interval_slider;
QDialogButtonBox _button_box;
bool _bSetting;
bool _bDone;
};
} // namespace dialogs

1
DSView/pv/dialogs/lissajousoptions.cpp
View File

@ -20,7 +20,6 @@
*/
#include "lissajousoptions.h"
#include "../device/devinst.h"
#include "../sigsession.h"
#include "../view/view.h"
#include "../view/lissajoustrace.h"

1
DSView/pv/dialogs/mathoptions.cpp
View File

@ -20,7 +20,6 @@
*/
#include "mathoptions.h"
#include "../device/devinst.h"
#include "../sigsession.h"
#include "../view/view.h"
#include "../view/mathtrace.h"

2
DSView/pv/dialogs/protocolexp.cpp
View File

@ -97,7 +97,7 @@ ProtocolExp::ProtocolExp(QWidget *parent, SigSession *session) :
connect(&_button_box, SIGNAL(accepted()), this, SLOT(accept()));
connect(&_button_box, SIGNAL(rejected()), this, SLOT(reject()));
connect(_session->get_device(), SIGNAL(device_updated()), this, SLOT(reject()));
connect(_session->device_event_object(), SIGNAL(device_updated()), this, SLOT(reject()));
}

1
DSView/pv/dialogs/protocolexp.h
View File

@ -30,7 +30,6 @@
#include <QRadioButton>
#include <QString>
#include "../device/devinst.h"
#include "../prop/binding/deviceoptions.h"
#include "../toolbars/titlebar.h"
#include "dsdialog.h"

2
DSView/pv/dialogs/protocollist.cpp
View File

@ -90,7 +90,7 @@ ProtocolList::ProtocolList(QWidget *parent, SigSession *session) :
connect(&_button_box, SIGNAL(accepted()), this, SLOT(accept()));
connect(_protocol_combobox, SIGNAL(currentIndexChanged(int)), this, SLOT(set_protocol(int)));
set_protocol(_protocol_combobox->currentIndex());
connect(_session->get_device(), SIGNAL(device_updated()), this, SLOT(reject()));
connect(_session->device_event_object(), SIGNAL(device_updated()), this, SLOT(reject()));
}

1
DSView/pv/dialogs/protocollist.h
View File

@ -29,7 +29,6 @@
#include <QLabel>
#include <QCheckBox>
#include "../device/devinst.h"
#include "../prop/binding/deviceoptions.h"
#include "../toolbars/titlebar.h"
#include "dsdialog.h"

3
DSView/pv/dialogs/regionoptions.cpp
View File

@ -24,7 +24,6 @@
#include "../sigsession.h"
#include "../view/cursor.h"
#include "../view/view.h"
#include "../device/devinst.h"
using namespace boost;
using namespace std;
@ -73,7 +72,7 @@ RegionOptions::RegionOptions(view::View *view, SigSession *session, QWidget *par
setTitle(tr("Region"));
connect(&_button_box, SIGNAL(accepted()), this, SLOT(set_region()));
connect(_session->get_device(), SIGNAL(device_updated()), this, SLOT(reject()));
connect(_session->device_event_object(), SIGNAL(device_updated()), this, SLOT(reject()));
}

1
DSView/pv/dialogs/search.cpp
View File

@ -85,7 +85,6 @@ Search::Search(QWidget *parent, SigSession *session, std::map<uint16_t, QString>
connect(&search_buttonBox, SIGNAL(accepted()), this, SLOT(accept()));
connect(&search_buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
connect(_session->get_device(), SIGNAL(device_updated()), this, SLOT(reject()));
}
Search::~Search()

1
DSView/pv/dialogs/search.h
View File

@ -32,7 +32,6 @@
#include "../sigsession.h"
#include "../toolbars/titlebar.h"
#include "dsdialog.h"
#include "../device/devinst.h"
namespace pv {
namespace dialogs {

16
DSView/pv/dialogs/storeprogress.cpp
View File

@ -30,6 +30,8 @@
#include <QRadioButton>
#include "../ui/msgbox.h"
#include "../config/appconfig.h"
#include "../interface/icallbacks.h"
#include "../log.h"
namespace pv {
namespace dialogs {
@ -122,8 +124,10 @@ void StoreProgress::reject()
{
using namespace Qt;
_store_session.cancel();
save_done();
_store_session.session()->set_saving(false);
save_done();
DSDialog::reject();
_store_session.session()->broadcast_msg(DSV_MSG_SAVE_COMPLETE);
}
void StoreProgress::accept()
@ -157,7 +161,8 @@ void StoreProgress::accept()
//start done
if (_isExport){
if (_store_session.export_start()){
QTimer::singleShot(100, this, SLOT(timeout()));
_store_session.session()->set_saving(true);
QTimer::singleShot(100, this, SLOT(timeout()));
}
else{
save_done();
@ -167,7 +172,8 @@ void StoreProgress::accept()
}
else{
if (_store_session.save_start()){
QTimer::singleShot(100, this, SLOT(timeout()));
_store_session.session()->set_saving(true);
QTimer::singleShot(100, this, SLOT(timeout()));
}
else{
save_done();
@ -248,9 +254,11 @@ void StoreProgress::show_error()
}
void StoreProgress::closeEvent(QCloseEvent* e)
{
{
_store_session.cancel();
_store_session.session()->set_saving(false);
DSDialog::closeEvent(e);
_store_session.session()->broadcast_msg(DSV_MSG_SAVE_COMPLETE);
}
void StoreProgress::on_progress_updated()

20
DSView/pv/dialogs/waitingdialog.cpp
View File

@ -49,7 +49,8 @@ WaitingDialog::WaitingDialog(QWidget *parent, SigSession *session, int key) :
_button_box(QDialogButtonBox::Abort,
Qt::Horizontal, this)
{
_dev_inst = _session->get_device();
_device_agent = _session->get_device();
this->setFixedSize((GIF_WIDTH+2*TIP_WIDTH)*1.2, (GIF_HEIGHT+2*TIP_HEIGHT)*4);
this->setWindowOpacity(0.7);
@ -78,8 +79,7 @@ WaitingDialog::WaitingDialog(QWidget *parent, SigSession *session, int key) :
connect(timer, SIGNAL(timeout()), this, SLOT(changeText()));
connect(&_button_box, SIGNAL(accepted()), this, SLOT(accept()));
connect(&_button_box, SIGNAL(rejected()), this, SLOT(reject()));
connect(_dev_inst, SIGNAL(device_updated()), this, SLOT(stop()));
connect(_session->device_event_object(), SIGNAL(device_updated()), this, SLOT(stop()));
QVBoxLayout *mlayout = new QVBoxLayout();
mlayout->addWidget(warning_tips, Qt::AlignHCenter);
@ -100,7 +100,7 @@ void WaitingDialog::accept()
QFuture<void> future;
future = QtConcurrent::run([&]{
_dev_inst->set_config(NULL, NULL, SR_CONF_ZERO_SET,
_device_agent->set_config(NULL, NULL, SR_CONF_ZERO_SET,
g_variant_new_boolean(true));
});
Qt::WindowFlags flags = Qt::CustomizeWindowHint;
@ -128,8 +128,8 @@ void WaitingDialog::reject()
QFuture<void> future;
future = QtConcurrent::run([&]{
_dev_inst->set_config(NULL, NULL, _key, g_variant_new_boolean(false));
_dev_inst->set_config(NULL, NULL, SR_CONF_ZERO_LOAD,
_device_agent->set_config(NULL, NULL, _key, g_variant_new_boolean(false));
_device_agent->set_config(NULL, NULL, SR_CONF_ZERO_LOAD,
g_variant_new_boolean(true));
});
Qt::WindowFlags flags = Qt::CustomizeWindowHint;
@ -174,12 +174,12 @@ void WaitingDialog::changeText()
bool comb_comp_en = false;
bool zero_fgain = false;
gvar = _dev_inst->get_config(NULL, NULL, SR_CONF_PROBE_COMB_COMP_EN);
gvar = _device_agent->get_config(NULL, NULL, SR_CONF_PROBE_COMB_COMP_EN);
if (gvar != NULL) {
comb_comp_en = g_variant_get_boolean(gvar);
g_variant_unref(gvar);
if (comb_comp_en) {
gvar = _dev_inst->get_config(NULL, NULL, SR_CONF_ZERO_COMB_FGAIN);
gvar = _device_agent->get_config(NULL, NULL, SR_CONF_ZERO_COMB_FGAIN);
if (gvar != NULL) {
zero_fgain = g_variant_get_boolean(gvar);
g_variant_unref(gvar);
@ -192,13 +192,13 @@ void WaitingDialog::changeText()
dsoSig->set_enable(dsoSig->get_index() == 0);
}
std::this_thread::sleep_for(std::chrono::milliseconds(100));
_dev_inst->set_config(NULL, NULL, SR_CONF_ZERO_COMB, g_variant_new_boolean(true));
_device_agent->set_config(NULL, NULL, SR_CONF_ZERO_COMB, g_variant_new_boolean(true));
}
}
}
}
gvar = _dev_inst->get_config(NULL, NULL, _key);
gvar = _device_agent->get_config(NULL, NULL, _key);
if (gvar != NULL) {
bool zero = g_variant_get_boolean(gvar);
g_variant_unref(gvar);

6
DSView/pv/dialogs/waitingdialog.h
View File

@ -29,13 +29,13 @@
#include <QMovie>
#include "../sigsession.h"
#include "../device/devinst.h"
#include "../toolbars/titlebar.h"
#include "dsdialog.h"
using namespace pv::device;
class DeviceAgent;
namespace pv {
namespace dialogs {
class WaitingDialog : public DSDialog
@ -67,7 +67,6 @@ private slots:
private:
int _key;
SigSession *_session;
DevInst* _dev_inst;
toolbars::TitleBar *_titlebar;
QDialogButtonBox _button_box;
@ -76,6 +75,7 @@ private:
QMovie *movie;
QTimer *timer;
QLabel *tips;
DeviceAgent *_device_agent;
};
} // namespace dialogs

1
DSView/pv/dock/dsotriggerdock.cpp
View File

@ -21,7 +21,6 @@
#include "dsotriggerdock.h"
#include "../sigsession.h"
#include "../device/devinst.h"
#include "../dialogs/dsmessagebox.h"
#include "../view/dsosignal.h"

13
DSView/pv/dock/measuredock.cpp
View File

@ -30,10 +30,7 @@
#include "../view/ruler.h"
#include "../view/logicsignal.h"
#include "../data/signaldata.h"
#include "../data/snapshot.h"
#include "../devicemanager.h"
#include "../device/device.h"
#include "../device/file.h"
#include "../data/snapshot.h"
#include "../dialogs/dsdialog.h"
#include "../dialogs/dsmessagebox.h"
@ -53,10 +50,8 @@ MeasureDock::MeasureDock(QWidget *parent, View &view, SigSession *session) :
QScrollArea(parent),
_session(session),
_view(view)
{
_widget = new QWidget(this);
//_widget->setSizePolicy();
{
_widget = new QWidget(this);
_mouse_groupBox = new QGroupBox(_widget);
_fen_checkBox = new QCheckBox(_widget);
@ -211,7 +206,7 @@ void MeasureDock::refresh()
void MeasureDock::reload()
{
if (_session->get_device()->dev_inst()->mode == LOGIC)
if (_session->get_device()->get_work_mode() == LOGIC)
_edge_groupBox->setVisible(true);
else
_edge_groupBox->setVisible(false);

4
DSView/pv/dock/measuredock.h
View File

@ -41,7 +41,7 @@
#include <vector>
#include "../ui/dscombobox.h"
#include "../ui/dscombobox.h"
namespace pv {
@ -77,8 +77,6 @@ private:
DsComboBox* create_probe_selector(QWidget *parent);
void update_probe_selector(DsComboBox *selector);
signals:
private slots:
void goto_cursor();

15
DSView/pv/dock/protocoldock.cpp
View File

@ -22,7 +22,6 @@
#include "protocoldock.h"
#include "../sigsession.h"
#include "../view/decodetrace.h"
#include "../device/devinst.h"
#include "../data/decodermodel.h"
#include "../data/decoderstack.h"
#include "../dialogs/protocollist.h"
@ -360,13 +359,8 @@ void ProtocolDock::on_add_protocol()
}
bool ProtocolDock::add_protocol_by_id(QString id, bool silent, std::list<pv::data::decode::Decoder*> &sub_decoders)
{
if (_session->is_device_re_attach() == true){
dsv_info("%s", "Keep current decoders, cancel add new.");
return true;
}
if (_session->get_device()->dev_inst()->mode != LOGIC) {
{
if (_session->get_device()->get_work_mode() != LOGIC) {
dsv_info("%s", "Protocol Analyzer\nProtocol Analyzer is only valid in Digital Mode!");
return false;
}
@ -431,7 +425,7 @@ bool ProtocolDock::add_protocol_by_id(QString id, bool silent, std::list<pv::dat
void ProtocolDock::del_all_protocol()
{
if (_protocol_lay_items.size() > 0 && _session->is_device_re_attach() == false)
if (_protocol_lay_items.size() > 0)
{
_session->clear_all_decoder();
@ -1002,7 +996,6 @@ bool ProtocolDock::protocol_sort_callback(const DecoderInfoItem *o1, const Decod
_selected_protocol_id = QString(dec->id);
this->on_add_protocol();
}
}
}
} // namespace dock
} // namespace pv

18
DSView/pv/dock/protocoldock.h
View File

@ -23,7 +23,7 @@
#ifndef DSVIEW_PV_PROTOCOLDOCK_H
#define DSVIEW_PV_PROTOCOLDOCK_H
#include "libsigrokdecode.h"
#include <libsigrokdecode.h>
#include <QDockWidget>
#include <QPushButton>
@ -44,7 +44,7 @@
#include "../data/decodermodel.h"
#include "protocolitemlayer.h"
#include "keywordlineedit.h"
#include "searchcombobox.h"
#include "searchcombobox.h"
struct DecoderInfoItem{
void *_data_handle; //srd_decoder* type
@ -88,13 +88,14 @@ private:
void changeEvent(QEvent *event);
void retranslateUi();
void reStyle();
protected:
int get_protocol_index_by_id(QString id);
static QString parse_protocol_id(const char *id);
int get_output_protocol_by_id(QString id);
private:
static int decoder_name_cmp(const void *a, const void *b);
void resize_table_view(data::DecoderModel *decoder_model);
static bool protocol_sort_callback(const DecoderInfoItem *o1, const DecoderInfoItem *o2);
//IProtocolItemLayerCallback
void OnProtocolSetting(void *handle);
void OnProtocolDelete(void *handle);
@ -104,7 +105,7 @@ private:
void BeginEditKeyword();
//ISearchItemClick
void OnItemClick(void *sender, void *data_handle);
void OnItemClick(void *sender, void *data_handle);
signals:
void protocol_updated();
@ -127,11 +128,6 @@ private slots:
void search_changed();
void search_update();
void show_protocol_select();
private:
static int decoder_name_cmp(const void *a, const void *b);
void resize_table_view(data::DecoderModel *decoder_model);
static bool protocol_sort_callback(const DecoderInfoItem *o1, const DecoderInfoItem *o2);
private:
SigSession *_session;

13
DSView/pv/dock/searchdock.cpp
View File

@ -28,7 +28,6 @@
#include "../dialogs/search.h"
#include "../data/snapshot.h"
#include "../data/logicsnapshot.h"
#include "../device/devinst.h"
#include "../dialogs/dsmessagebox.h"
#include <QObject>
@ -51,12 +50,7 @@ SearchDock::SearchDock(QWidget *parent, View &view, SigSession *session) :
QWidget(parent),
_session(session),
_view(view)
{
connect(&_pre_button, SIGNAL(clicked()),
this, SLOT(on_previous()));
connect(&_nxt_button, SIGNAL(clicked()),
this, SLOT(on_next()));
{
_search_button = new QPushButton(this);
_search_button->setFixedWidth(_search_button->height());
_search_button->setDisabled(true);
@ -85,6 +79,9 @@ SearchDock::SearchDock(QWidget *parent, View &view, SigSession *session) :
setLayout(layout);
retranslateUi();
connect(&_pre_button, SIGNAL(clicked()), this, SLOT(on_previous()));
connect(&_nxt_button, SIGNAL(clicked()),this, SLOT(on_next()));
}
SearchDock::~SearchDock()
@ -248,6 +245,8 @@ void SearchDock::on_next()
void SearchDock::on_set()
{
dialogs::Search dlg(this, _session, _pattern);
connect(_session->device_event_object(), SIGNAL(device_updated()), &dlg, SLOT(reject()));
if (dlg.exec()) {
std::map<uint16_t, QString> new_pattern = dlg.get_pattern();

1
DSView/pv/dock/searchdock.h
View File

@ -67,6 +67,7 @@ public:
~SearchDock();
void paintEvent(QPaintEvent *);
private:
void changeEvent(QEvent *event);
void retranslateUi();

82
DSView/pv/dock/triggerdock.cpp
View File

@ -21,7 +21,6 @@
#include "triggerdock.h"
#include "../sigsession.h"
#include "../device/devinst.h"
#include "../dialogs/dsmessagebox.h"
#include "../view/view.h"
@ -34,8 +33,10 @@
#include <QInputMethodEvent>
#include <QApplication>
#include <math.h>
#include "libsigrok.h"
#include <libsigrok.h>
#include "../config/appconfig.h"
#include "../deviceagent.h"
#include "../view/logicsignal.h"
namespace pv {
namespace dock {
@ -46,8 +47,9 @@ TriggerDock::TriggerDock(QWidget *parent, SigSession *session) :
QScrollArea(parent),
_session(session)
{
_cur_ch_num = 16;
if (_session->get_device()) {
if (_session->get_device()->have_instance()) {
GVariant *gvar = _session->get_device()->get_config(NULL, NULL, SR_CONF_TOTAL_CH_NUM);
if (gvar != NULL) {
_cur_ch_num = g_variant_get_int16(gvar);
@ -252,11 +254,13 @@ void TriggerDock::device_updated()
uint8_t maxRange;
uint64_t sample_limits;
GVariant *gvar = _session->get_device()->get_config(NULL, NULL, SR_CONF_HW_DEPTH);
int mode = _session->get_device()->get_work_mode();
if (gvar != NULL) {
hw_depth = g_variant_get_uint64(gvar);
g_variant_unref(gvar);
if (_session->get_device()->dev_inst()->mode == LOGIC) {
if (mode == LOGIC) {
gvar = _session->get_device()->get_config(NULL, NULL, SR_CONF_STREAM);
if (gvar != NULL) {
@ -303,8 +307,9 @@ bool TriggerDock::commit_trigger()
// trigger mode update
if (_simple_radioButton->isChecked()) {
ds_trigger_set_mode(SIMPLE_TRIGGER);
return 0;
} else {
return false;
}
else {
ds_trigger_set_en(true);
if (_adv_tabWidget->currentIndex() == 0)
ds_trigger_set_mode(ADV_TRIGGER);
@ -396,7 +401,7 @@ bool TriggerDock::commit_trigger()
_serial_bits_comboBox->currentText().toInt() - 1,
0);
}
return 1;
return true;
}
}
@ -884,5 +889,66 @@ void TriggerDock::lineEdit_highlight(QLineEdit *dst) {
QCoreApplication::sendEvent(dst, &event);
}
void TriggerDock::try_commit_trigger()
{
AppConfig &app = AppConfig::Instance();
int num = 0;
int mode = _session->get_device()->get_work_mode();
bool bInstant = _session->is_instant();
ds_trigger_reset();
if (mode != LOGIC || bInstant){
return;
}
if (commit_trigger() == false)
{
/* simple trigger check trigger_enable */
for(auto &s : _session->get_signals())
{
assert(s);
view::LogicSignal *logicSig = NULL;
if ((logicSig = dynamic_cast<view::LogicSignal*>(s))) {
if (logicSig->commit_trig())
num++;
}
}
if (app._appOptions.warnofMultiTrig && num > 1) {
dialogs::DSMessageBox msg(this);
msg.mBox()->setText(tr("Trigger"));
msg.mBox()->setInformativeText(tr("Trigger setted on multiple channels! "
"Capture will Only triggered when all setted channels fullfill at one sample"));
msg.mBox()->setIcon(QMessageBox::Information);
QPushButton *noMoreButton = msg.mBox()->addButton(tr("Not Show Again"), QMessageBox::ActionRole);
QPushButton *cancelButton = msg.mBox()->addButton(tr("Clear Trig"), QMessageBox::ActionRole);
msg.mBox()->addButton(tr("Continue"), QMessageBox::ActionRole);
msg.exec();
if (msg.mBox()->clickedButton() == cancelButton) {
for(auto &s : _session->get_signals())
{
assert(s);
view::LogicSignal *logicSig = NULL;
if ((logicSig = dynamic_cast<view::LogicSignal*>(s))) {
logicSig->set_trig(view::LogicSignal::NONTRIG);
logicSig->commit_trig();
}
}
}
if (msg.mBox()->clickedButton() == noMoreButton)
{
app._appOptions.warnofMultiTrig = false;
app.SaveApp();
}
}
}
}
} // namespace dock
} // namespace pv

26
DSView/pv/dock/triggerdock.h
View File

@ -42,7 +42,7 @@
#include <vector>
#include "../ui/dscombobox.h"
#include "../ui/dscombobox.h"
namespace pv {
@ -68,12 +68,10 @@ public:
QJsonObject get_session();
void set_session(QJsonObject ses);
/*
* commit trigger setting
* return 0: simple trigger
* 1: advanced trigger
*/
bool commit_trigger();
void device_updated();
void try_commit_trigger();
private:
void changeEvent(QEvent *event);
void retranslateUi();
@ -82,18 +80,20 @@ private:
void setup_adv_tab();
void lineEdit_highlight(QLineEdit *dst);
signals:
/*
* commit trigger setting
* return 0: simple trigger
* 1: advanced trigger
*/
bool commit_trigger();
public slots:
void simple_trigger();
void adv_trigger();
void widget_enable(int index);
void value_changed();
void device_updated();
private:
void value_changed();
private:
SigSession *_session;

14
DSView/pv/dstimer.cpp
View File

@ -36,9 +36,17 @@ void DsTimer::TimeOut(int millsec, CALLBACL_FUNC f)
{
_call = f;
QTimer::singleShot(millsec, this, SLOT(on_timeout()));
}
}
void DsTimer::Start(int millsec, CALLBACL_FUNC f)
void DsTimer::TimeOut(int millsec)
{
if (_call == NULL){
assert(false);
}
QTimer::singleShot(millsec, this, SLOT(on_timeout()));
}
void DsTimer::Start(int millsec, CALLBACL_FUNC f)
{
if (_isActived)
return;
@ -53,7 +61,7 @@ void DsTimer::TimeOut(int millsec, CALLBACL_FUNC f)
_timer.start(millsec);
_isActived = true;
_beginTime = high_resolution_clock::now();
}
}
void DsTimer::SetCallback(CALLBACL_FUNC f)
{

2
DSView/pv/dstimer.h
View File

@ -42,6 +42,8 @@ public:
void TimeOut(int millsec, CALLBACL_FUNC f);
void TimeOut(int millsec);
void SetCallback(CALLBACL_FUNC f);
void Start(int millsec, CALLBACL_FUNC f);

4
DSView/pv/eventobject.cpp
View File

@ -23,4 +23,8 @@
EventObject::EventObject(){
}
DeviceEventObject::DeviceEventObject()
{
}

16
DSView/pv/eventobject.h
View File

@ -36,8 +36,6 @@ signals:
void show_error(QString error);
void capture_state_changed(int state);
void data_updated();
void device_attach();
void device_detach();
void session_error();
void signals_changed();
@ -48,6 +46,20 @@ signals:
void decode_done();
void receive_data_len(quint64 len);
void cur_snap_samplerate_changed();
void trigger_message(int msg);
};
class DeviceEventObject : public QObject
{
Q_OBJECT
public:
DeviceEventObject();
signals:
void device_updated();
};
#endif

52
DSView/pv/interface/icallbacks.h
View File

@ -23,22 +23,17 @@
#ifndef _I_CALLBACKS_
#define _I_CALLBACKS_
class ISessionCallback
{
public:
virtual void show_error(QString error)=0;
virtual void session_error()=0;
virtual void capture_state_changed(int state)=0;
virtual void device_attach()=0;
virtual void device_detach()=0;
virtual void session_save()=0;
virtual void data_updated()=0;
virtual void repeat_resume()=0;
virtual void update_capture()=0;
virtual void cur_snap_samplerate_changed()=0;
virtual void device_setted()=0;
virtual void cur_snap_samplerate_changed()=0;
virtual void signals_changed()=0;
virtual void receive_trigger(quint64 trigger_pos)=0;
virtual void frame_ended()=0;
@ -52,7 +47,7 @@ public:
virtual void receive_header()=0;
virtual void data_received()=0;
virtual void trigger_message(int msg)=0;
};
class ISessionDataGetter
@ -61,4 +56,45 @@ public:
virtual bool genSessionData(std::string &str) = 0;
};
class IDlgCallback
{
public:
virtual void OnDlgResult(bool bYes)=0;
};
class IMainForm{
public:
virtual void switchLanguage(int language)=0;
};
#define DSV_MSG_START_COLLECT_WORK_PREV 5001
#define DSV_MSG_START_COLLECT_WORK 5002
#define DSV_MSG_COLLECT_START 5003
#define DSV_MSG_COLLECT_END 5004
#define DSV_MSG_END_COLLECT_WORK_PREV 5005
#define DSV_MSG_END_COLLECT_WORK 5006
#define DSV_MSG_DEVICE_LIST_UPDATED 6000
#define DSV_MSG_BEGIN_DEVICE_OPTIONS 6001 //Begin show device options dialog.
#define DSV_MSG_END_DEVICE_OPTIONS 6002
#define DSV_MSG_DEVICE_OPTIONS_UPDATED 6003
#define DSV_MSG_DEVICE_DURATION_UPDATED 6004
#define DSV_MSG_DEVICE_MODE_CHANGED 6005
#define DSV_MSG_CURRENT_DEVICE_CHANGE_PREV 6006
#define DSV_MSG_CURRENT_DEVICE_CHANGED 6007
#define DSV_MSG_NEW_USB_DEVICE 6008
#define DSV_MSG_CURRENT_DEVICE_DETACHED 6009
#define DSV_MSG_DEVICE_CONFIG_UPDATED 6010
#define DSV_MSG_TRIG_NEXT_COLLECT 7001
#define DSV_MSG_SAVE_COMPLETE 7002
class IMessageListener
{
public:
virtual void OnMessage(int msg)=0;
};
#endif

33
DSView/pv/interface/uicallback.h
View File

@ -1,33 +0,0 @@
/*
* This file is part of the DSView project.
* DSView is based on PulseView.
*
* Copyright (C) 2021 DreamSourceLab <support@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
*/
#pragma once
class IDlgCallback
{
public:
virtual void OnDlgResult(bool bYes)=0;
};
class IMainForm{
public:
virtual void switchLanguage(int language)=0;
};

2892
DSView/pv/mainwindow.cpp
View File

File diff suppressed because it is too large Load Diff

79
DSView/pv/mainwindow.h
View File

@ -29,8 +29,8 @@
#include <QTranslator>
#include "dialogs/dsmessagebox.h"
#include "interface/icallbacks.h"
#include "eventobject.h"
#include "interface/uicallback.h"
#include "eventobject.h"
#include <QJsonDocument>
class QAction;
class QMenuBar;
@ -43,8 +43,11 @@ class QDockWidget;
class AppControl;
class DeviceAgent;
namespace pv {
class SigSession;
namespace toolbars {
class SamplingBar;
@ -68,12 +71,15 @@ class View;
namespace device{
class DevInst;
}
using namespace pv::device;
//The mainwindow,referenced by MainFrame
//TODO: create graph view,toolbar,and show device list
class MainWindow : public QMainWindow, public ISessionCallback, public IMainForm, public ISessionDataGetter
class MainWindow :
public QMainWindow,
public ISessionCallback,
public IMainForm,
public ISessionDataGetter,
public IMessageListener
{
Q_OBJECT
@ -88,7 +94,8 @@ private:
void setup_ui();
void retranslateUi();
bool eventFilter(QObject *object, QEvent *event);
bool load_session_json(QJsonDocument json, bool file_dev,bool bDecoder=true);
bool load_session_json(QJsonDocument json, bool &haveDecoder);
QString genSessionFileName();
public slots:
void switchTheme(QString style);
@ -96,15 +103,10 @@ public slots:
private slots:
void on_load_file(QString file_name);
void on_open_doc();
void on_device_updated_reload();
void update_device_list();
void on_run_stop();
void on_instant_stop();
void on_open_doc();
void on_protocol(bool visible);
void on_trigger(bool visible);
void commit_trigger(bool instant);
void on_measure(bool visible);
void on_search(bool visible);
@ -113,16 +115,9 @@ private slots:
void on_export();
bool on_load_session(QString name);
bool on_store_session(QString name);
void device_detach_post();
void device_changed(bool close);
void on_device_selected();
void on_capture_state_changed(int state);
bool on_store_session(QString name);
void on_data_updated();
void on_device_attach();
void on_device_detach();
void on_show_error(QString str);
void on_session_error();
void on_signals_changed();
void on_receive_trigger(quint64 trigger_pos);
@ -131,6 +126,7 @@ private slots:
void on_decode_done();
void on_receive_data_len(quint64 len);
void on_cur_snap_samplerate_changed();
void on_trigger_message(int msg);
signals:
void prgRate(int progress);
@ -143,24 +139,21 @@ public:
public:
void session_save();
//ISessionDataGetter
private:
bool genSessionData(std::string &str);
//ISessionCallback
void check_usb_device_speed();
void reset_all_view();
bool confirm_to_store_data();
void update_toolbar_view_status();
private:
//ISessionCallback
void show_error(QString error);
void session_error();
void capture_state_changed(int state);
void device_attach();
void device_detach();
void data_updated();
void repeat_resume();
void update_capture();
void cur_snap_samplerate_changed();
void device_setted();
void signals_changed();
void receive_trigger(quint64 trigger_pos);
void frame_ended();
@ -173,14 +166,20 @@ private:
void receive_data_len(quint64 len);
void receive_header();
void data_received();
void trigger_message(int msg);
//------private
//ISessionDataGetter
bool genSessionData(std::string &str);
bool gen_session_json(QJsonObject &sessionVar);
void check_session_file_version();
void load_device_config();
QJsonDocument get_session_json_from_file(QString file);
QJsonArray get_decoder_json_from_file(QString file);
private:
AppControl *_control;
bool _hot_detach;
//IMessageListener
void OnMessage(int msg);
private:
pv::view::View *_view;
dialogs::DSMessageBox *_msg;
@ -220,8 +219,10 @@ private:
QTranslator _qtTrans;
QTranslator _myTrans;
EventObject _event;
bool _bFirstLoad;
EventObject _event;
SigSession *_session;
DeviceAgent *_device_agent;
bool _is_auto_switch_device;
};
} // namespace pv

2
DSView/pv/prop/binding/decoderoptions.cpp
View File

@ -19,7 +19,7 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "libsigrokdecode.h"
#include <libsigrokdecode.h>
#include "decoderoptions.h"
#include <boost/bind.hpp>

102
DSView/pv/prop/binding/deviceoptions.cpp
View File

@ -31,6 +31,9 @@
#include "../int.h"
#include "../../config/appconfig.h"
#include "../../log.h"
#include "../../appcontrol.h"
#include "../../sigsession.h"
#include "../../deviceagent.h"
using namespace std;
@ -38,41 +41,43 @@ namespace pv {
namespace prop {
namespace binding {
DeviceOptions::DeviceOptions(struct sr_dev_inst *sdi) :
_sdi(sdi)
DeviceOptions::DeviceOptions()
{
GVariant *gvar_opts, *gvar_list;
gsize num_opts;
if ((sr_config_list(sdi->driver, sdi, NULL, SR_CONF_DEVICE_OPTIONS,
&gvar_opts) != SR_OK))
SigSession *session = AppControl::Instance()->GetSession();
_device_agent = session->get_device();
gvar_opts = _device_agent->get_config_list(NULL, SR_CONF_DEVICE_OPTIONS);
if (gvar_opts == NULL)
/* Driver supports no device instance options. */
return;
const int *const options = (const int32_t *)g_variant_get_fixed_array(
gvar_opts, &num_opts, sizeof(int32_t));
for (unsigned int i = 0; i < num_opts; i++) {
const struct sr_config_info *const info =
sr_config_info_get(options[i]);
_device_agent->get_config_info(options[i]);
if (!info)
continue;
const int key = info->key;
if(sr_config_list(_sdi->driver, _sdi, NULL, key, &gvar_list) != SR_OK)
gvar_list = NULL;
gvar_list = _device_agent->get_config_list(NULL, key);
const QString name(info->name);
char *label_char = info->label;
GVariant *gvar_tmp = NULL;
if (sr_config_get(_sdi->driver, _sdi, NULL, NULL, SR_CONF_LANGUAGE, &gvar_tmp) == SR_OK) {
if (gvar_tmp != NULL) {
int language = g_variant_get_int16(gvar_tmp);
GVariant *gvar_tmp = _device_agent->get_config(NULL, NULL, SR_CONF_LANGUAGE);
if (gvar_tmp != NULL) {
int language = g_variant_get_int16(gvar_tmp);
if (language == LAN_CN)
label_char = info->label_cn;
g_variant_unref(gvar_tmp);
}
g_variant_unref(gvar_tmp);
}
const QString label(label_char);
@ -143,30 +148,25 @@ DeviceOptions::DeviceOptions(struct sr_dev_inst *sdi) :
g_variant_unref(gvar_opts);
}
GVariant* DeviceOptions::config_getter(
const struct sr_dev_inst *sdi, int key)
{
GVariant *data = NULL;
if (sr_config_get(sdi->driver, sdi, NULL, NULL, key, &data) != SR_OK) {
dsv_warn("%s%d", "WARNING: Failed to get value of config id:", key);
return NULL;
}
return data;
GVariant* DeviceOptions::config_getter(int key)
{
SigSession *session = AppControl::Instance()->GetSession();
DeviceAgent *_device_agent = session->get_device();
return _device_agent->get_config(NULL, NULL, key);
}
void DeviceOptions::config_setter(
struct sr_dev_inst *sdi, int key, GVariant* value)
void DeviceOptions::config_setter(int key, GVariant* value)
{
if (sr_config_set(sdi, NULL, NULL, key, value) != SR_OK){
dsv_warn("%s%d", "WARNING: Failed to set value of config id:", key);
}
SigSession *session = AppControl::Instance()->GetSession();
DeviceAgent *_device_agent = session->get_device();
_device_agent->set_config(NULL, NULL, key, value);
}
void DeviceOptions::bind_bool(const QString &name, const QString label, int key)
{
_properties.push_back(
new Bool(name, label, bind(config_getter, _sdi, key),
bind(config_setter, _sdi, key, _1)));
new Bool(name, label, bind(config_getter, key),
bind(config_setter, key, _1)));
}
void DeviceOptions::bind_enum(const QString &name, const QString label, int key,
@ -184,8 +184,8 @@ void DeviceOptions::bind_enum(const QString &name, const QString label, int key,
_properties.push_back(
new Enum(name, label, values,
bind(config_getter, _sdi, key),
bind(config_setter, _sdi, key, _1)));
bind(config_getter, key),
bind(config_setter, key, _1)));
}
void DeviceOptions::bind_int(const QString &name, const QString label, int key, QString suffix,
@ -193,8 +193,8 @@ void DeviceOptions::bind_int(const QString &name, const QString label, int key,
{
_properties.push_back(
new Int(name, label, suffix, range,
bind(config_getter, _sdi, key),
bind(config_setter, _sdi, key, _1)));
bind(config_getter, key),
bind(config_setter, key, _1)));
}
void DeviceOptions::bind_double(const QString &name, const QString label, int key, QString suffix,
@ -203,16 +203,17 @@ void DeviceOptions::bind_double(const QString &name, const QString label, int ke
{
_properties.push_back(
new Double(name, label, decimals, suffix, range, step,
bind(config_getter, _sdi, key),
bind(config_setter, _sdi, key, _1)));
bind(config_getter, key),
bind(config_setter, key, _1)));
}
QString DeviceOptions::print_gvariant(GVariant *const gvar)
{
QString s;
if (g_variant_is_of_type(gvar, G_VARIANT_TYPE("s")))
if (g_variant_is_of_type(gvar, G_VARIANT_TYPE("s"))){
s = QString::fromUtf8(g_variant_get_string(gvar, NULL));
}
else
{
gchar *const text = g_variant_print(gvar, FALSE);
@ -244,8 +245,8 @@ void DeviceOptions::bind_samplerate(const QString &name, const QString label,
new Double(name, label, 0, QObject::tr("Hz"),
make_pair((double)elements[0], (double)elements[1]),
(double)elements[2],
bind(samplerate_double_getter, _sdi),
bind(samplerate_double_setter, _sdi, _1)));
bind(samplerate_double_getter),
bind(samplerate_double_setter, _1)));
g_variant_unref(gvar_list_samplerates);
}
@ -267,10 +268,9 @@ QString DeviceOptions::print_samplerate(GVariant *const gvar)
return qstring;
}
GVariant* DeviceOptions::samplerate_double_getter(
const struct sr_dev_inst *sdi)
GVariant* DeviceOptions::samplerate_double_getter()
{
GVariant *const gvar = config_getter(sdi, SR_CONF_SAMPLERATE);
GVariant *const gvar = config_getter(SR_CONF_SAMPLERATE);
if(!gvar)
return NULL;
@ -283,12 +283,11 @@ GVariant* DeviceOptions::samplerate_double_getter(
return gvar_double;
}
void DeviceOptions::samplerate_double_setter(
struct sr_dev_inst *sdi, GVariant *value)
void DeviceOptions::samplerate_double_setter(GVariant *value)
{
GVariant *const gvar = g_variant_new_uint64(
g_variant_get_double(value));
config_setter(sdi, SR_CONF_SAMPLERATE, gvar);
config_setter(SR_CONF_SAMPLERATE, gvar);
}
QString DeviceOptions::print_timebase(GVariant *const gvar)
@ -315,12 +314,11 @@ void DeviceOptions::bind_bandwidths(const QString &name, const QString label, in
assert(gvar_list);
GVariant *gvar_tmp = NULL;
if (sr_config_get(_sdi->driver, _sdi, NULL, NULL, SR_CONF_BANDWIDTH, &gvar_tmp) == SR_OK) {
if (gvar_tmp != NULL) {
bw_limit = g_variant_get_boolean(gvar_tmp);
g_variant_unref(gvar_tmp);
}
GVariant *gvar_tmp = _device_agent->get_config(NULL, NULL, SR_CONF_BANDWIDTH);
if (gvar_tmp != NULL) {
bw_limit = g_variant_get_boolean(gvar_tmp);
g_variant_unref(gvar_tmp);
}
if (!bw_limit)
@ -332,8 +330,8 @@ void DeviceOptions::bind_bandwidths(const QString &name, const QString label, in
_properties.push_back(
new Enum(name, label, values,
bind(config_getter, _sdi, key),
bind(config_setter, _sdi, key, _1)));
bind(config_getter, key),
bind(config_setter, key, _1)));
}
} // binding

41
DSView/pv/prop/binding/deviceoptions.h
View File

@ -28,30 +28,32 @@
#include <boost/optional.hpp>
#include <QString>
#include <libsigrok.h>
#include "binding.h"
#include "libsigrok.h"
#include "binding.h"
class DeviceAgent;
namespace pv {
namespace prop {
namespace binding {
class DeviceOptions : public Binding
{
public:
DeviceOptions(struct sr_dev_inst *sdi);
DeviceOptions();
private:
static GVariant* config_getter(
const struct sr_dev_inst *sdi, int key);
static void config_setter(
struct sr_dev_inst *sdi, int key, GVariant* value);
static GVariant* config_getter(int key);
static void config_setter(int key, GVariant* value);
void bind_bool(const QString &name, const QString label, int key);
void bind_enum(const QString &name, const QString label, int key,
GVariant *const gvar_list,
void bind_enum(const QString &name, const QString label, int key, GVariant *const gvar_list,
boost::function<QString (GVariant*)> printer = print_gvariant);
void bind_int(const QString &name, const QString label, int key, QString suffix,
boost::optional< std::pair<int64_t, int64_t> > range);
@ -61,23 +63,24 @@ private:
static QString print_gvariant(GVariant *const gvar);
void bind_samplerate(const QString &name, const QString label,
GVariant *const gvar_list);
void bind_samplerate(const QString &name, const QString label,GVariant *const gvar_list);
static QString print_samplerate(GVariant *const gvar);
static GVariant* samplerate_double_getter(
const struct sr_dev_inst *sdi);
static void samplerate_double_setter(
struct sr_dev_inst *sdi, GVariant *value);
static GVariant* samplerate_double_getter();
static void samplerate_double_setter(GVariant *value);
static QString print_timebase(GVariant *const gvar);
static QString print_vdiv(GVariant *const gvar);
void bind_bandwidths(const QString &name, const QString label, int key,
GVariant *const gvar_list,
void bind_bandwidths(const QString &name, const QString label, int key,GVariant *const gvar_list,
boost::function<QString (GVariant*)> printer = print_gvariant);
protected:
struct sr_dev_inst *const _sdi;
private:
DeviceAgent *_device_agent;
};
} // binding

71
DSView/pv/prop/binding/probeoptions.cpp
View File

@ -29,6 +29,8 @@
#include "../int.h"
#include "../../config/appconfig.h"
#include "../../log.h"
#include "../../appcontrol.h"
#include "../../sigsession.h"
using namespace std;
@ -36,43 +38,45 @@ namespace pv {
namespace prop {
namespace binding {
ProbeOptions::ProbeOptions(struct sr_dev_inst *sdi, struct sr_channel *probe) :
Binding(),
_sdi(sdi),
ProbeOptions::ProbeOptions(struct sr_channel *probe) :
Binding(),
_probe(probe)
{
{
GVariant *gvar_opts, *gvar_list;
gsize num_opts;
if ((sr_config_list(sdi->driver, sdi, NULL, SR_CONF_PROBE_CONFIGS,
&gvar_opts) != SR_OK))
SigSession *session = AppControl::Instance()->GetSession();
_device_agent = session->get_device();
gvar_opts = _device_agent->get_config_list(NULL, SR_CONF_PROBE_CONFIGS);
if (gvar_opts != NULL){
/* Driver supports no device instance options. */
return;
}
const int *const options = (const int32_t *)g_variant_get_fixed_array(
gvar_opts, &num_opts, sizeof(int32_t));
for (unsigned int i = 0; i < num_opts; i++) {
const struct sr_config_info *const info =
sr_config_info_get(options[i]);
_device_agent->get_config_info(options[i]);
if (!info)
continue;
const int key = info->key;
if(sr_config_list(_sdi->driver, _sdi, NULL, key, &gvar_list) != SR_OK)
gvar_list = NULL;
gvar_list = _device_agent->get_config_list(NULL, key);
const QString name(info->name);
char *label_char = info->label;
GVariant *gvar_tmp = NULL;
if (sr_config_get(_sdi->driver, _sdi, NULL, NULL, SR_CONF_LANGUAGE, &gvar_tmp) == SR_OK) {
if (gvar_tmp != NULL) {
GVariant *gvar_tmp = _device_agent->get_config(NULL, NULL, SR_CONF_LANGUAGE);
if (gvar_tmp != NULL) {
int language = g_variant_get_int16(gvar_tmp);
if (language == LAN_CN)
label_char = info->label_cn;
g_variant_unref(gvar_tmp);
}
}
const QString label(label_char);
@ -111,32 +115,25 @@ ProbeOptions::ProbeOptions(struct sr_dev_inst *sdi, struct sr_channel *probe) :
g_variant_unref(gvar_opts);
}
GVariant* ProbeOptions::config_getter(
const struct sr_dev_inst *sdi,
const struct sr_channel *probe, int key)
{
GVariant *data = NULL;
if (sr_config_get(sdi->driver, sdi, probe, NULL, key, &data) != SR_OK) {
dsv_warn("%s%d", "WARNING: Failed to get value of config id:", key);
return NULL;
}
return data;
GVariant* ProbeOptions::config_getter(const struct sr_channel *probe, int key)
{
SigSession *session = AppControl::Instance()->GetSession();
DeviceAgent *_device_agent = session->get_device();
return _device_agent->get_config(probe, NULL, key);
}
void ProbeOptions::config_setter(
struct sr_dev_inst *sdi,
struct sr_channel *probe, int key, GVariant* value)
void ProbeOptions::config_setter(struct sr_channel *probe, int key, GVariant* value)
{
if (sr_config_set(sdi, probe, NULL, key, value) != SR_OK){
dsv_warn("%s", "WARNING: Failed to set value of sample rate");
}
SigSession *session = AppControl::Instance()->GetSession();
DeviceAgent *_device_agent = session->get_device();
_device_agent->set_config(probe, NULL, key, value);
}
void ProbeOptions::bind_bool(const QString &name, const QString label, int key)
{
_properties.push_back(
new Bool(name, label, bind(config_getter, _sdi, _probe, key),
bind(config_setter, _sdi, _probe, key, _1)));
new Bool(name, label, bind(config_getter, _probe, key),
bind(config_setter, _probe, key, _1)));
}
void ProbeOptions::bind_enum(const QString &name, const QString label, int key,
@ -154,8 +151,8 @@ void ProbeOptions::bind_enum(const QString &name, const QString label, int key,
_properties.push_back(
new Enum(name, label, values,
bind(config_getter, _sdi, _probe, key),
bind(config_setter, _sdi, _probe, key, _1)));
bind(config_getter, _probe, key),
bind(config_setter, _probe, key, _1)));
}
void ProbeOptions::bind_int(const QString &name, const QString label, int key, QString suffix,
@ -163,8 +160,8 @@ void ProbeOptions::bind_int(const QString &name, const QString label, int key, Q
{
_properties.push_back(
new Int(name, label, suffix, range,
bind(config_getter, _sdi, _probe, key),
bind(config_setter, _sdi, _probe, key, _1)));
bind(config_getter, _probe, key),
bind(config_setter, _probe, key, _1)));
}
void ProbeOptions::bind_double(const QString &name, const QString label, int key, QString suffix,
@ -173,8 +170,8 @@ void ProbeOptions::bind_double(const QString &name, const QString label, int key
{
_properties.push_back(
new Double(name, label, decimals, suffix, range, step,
bind(config_getter, _sdi, _probe, key),
bind(config_setter, _sdi, _probe, key, _1)));
bind(config_getter, _probe, key),
bind(config_setter, _probe, key, _1)));
}
void ProbeOptions::bind_vdiv(const QString &name, const QString label,

13
DSView/pv/prop/binding/probeoptions.h
View File

@ -27,10 +27,11 @@
#include <boost/optional.hpp>
#include <QString>
#include "libsigrok.h"
#include <libsigrok.h>
#include "binding.h"
class DeviceAgent;
namespace pv {
namespace prop {
namespace binding {
@ -38,16 +39,14 @@ namespace binding {
class ProbeOptions : public Binding
{
public:
ProbeOptions(struct sr_dev_inst *sdi,
struct sr_channel *probe);
ProbeOptions(struct sr_channel *probe);
private:
static GVariant* config_getter(
const struct sr_dev_inst *sdi,
const struct sr_channel *probe, int key);
static void config_setter(
struct sr_dev_inst *sdi,
struct sr_channel *probe, int key, GVariant* value);
void bind_bool(const QString &name, const QString label, int key);
@ -72,8 +71,8 @@ private:
static QString print_coupling(GVariant *const gvar);
protected:
struct sr_dev_inst *const _sdi;
struct sr_channel *const _probe;
DeviceAgent *_device_agent;
};
} // binding

3591
DSView/pv/sigsession.cpp
View File

File diff suppressed because it is too large Load Diff

397
DSView/pv/sigsession.h
View File

@ -36,7 +36,9 @@
#include "data/mathstack.h"
#include "interface/icallbacks.h"
#include "dstimer.h"
#include "libsigrok.h"
#include <libsigrok.h>
#include "deviceagent.h"
#include "eventobject.h"
struct srd_decoder;
@ -47,8 +49,6 @@ typedef std::lock_guard<std::mutex> ds_lock_guard;
namespace pv {
class DeviceManager;
namespace data {
class SignalData;
class Snapshot;
@ -82,10 +82,12 @@ class LissajousTrace;
class MathTrace;
}
using namespace pv::device;
using namespace pv::data;
//created by MainWindow
class SigSession
class SigSession:
public IMessageListener,
public IDeviceAgentCallback
{
private:
static constexpr float Oversampling = 2.0f;
@ -96,18 +98,7 @@ public:
static const int FeedInterval = 50;
static const int WaitShowTime = 500;
public:
enum capture_state {
Init,
Stopped,
Running
};
enum run_mode {
Single,
Repetitive
};
public:
enum error_state {
No_err,
Hw_err,
@ -118,30 +109,42 @@ public:
Data_overflow
};
enum device_status_type{
ST_INIT = 0,
ST_RUNNING = 1,
ST_STOPPED = 2,
};
private:
SigSession(SigSession &o);
public:
explicit SigSession(DeviceManager *device_manager);
explicit SigSession();
~SigSession();
DevInst* get_device();
inline DeviceAgent* get_device(){
return &_device_agent;
}
/**
* Sets device instance that will be used in the next capture session.
*/
void set_device(DevInst *dev_inst);
void set_file(QString name);
void close_file(DevInst *dev_inst);
void set_default_device();
void release_device(DevInst *dev_inst);
capture_state get_capture_state();
bool init();
void uninit();
void Open();
void Close();
bool set_default_device();
bool set_device(ds_device_handle dev_handle);
bool set_file(QString name);
void close_file(ds_device_handle dev_handle);
bool start_capture(bool instant);
void stop_capture();
uint64_t cur_samplerate();
uint64_t cur_snap_samplerate();
uint64_t cur_samplelimits();
inline uint64_t cur_samplelimits(){
return _cur_samplelimits;
}
double cur_sampletime();
double cur_snap_sampletime();
@ -149,42 +152,62 @@ public:
void set_cur_snap_samplerate(uint64_t samplerate);
void set_cur_samplelimits(uint64_t samplelimits);
void set_session_time(QDateTime time);
QDateTime get_session_time();
uint64_t get_trigger_pos();
inline void set_session_time(QDateTime time){
_session_time = time;
}
inline QDateTime get_session_time(){
return _session_time;
}
inline uint64_t get_trigger_pos(){
return _trigger_pos;
}
bool get_capture_status(bool &triggered, int &progress);
void container_init();
std::set<data::SignalData*> get_data();
std::vector<view::Signal*>& get_signals();
std::vector<view::GroupSignal*>& get_group_signals();
bool add_decoder(srd_decoder *const dec, bool silent, DecoderStatus *dstatus,
std::list<pv::data::decode::Decoder*> &sub_decoders);
std::list<pv::data::decode::Decoder*> &sub_decoders);
int get_trace_index_by_key_handel(void *handel);
void remove_decoder(int index);
void remove_decoder_by_key_handel(void *handel);
std::vector<view::DecodeTrace*>& get_decode_signals();
inline std::vector<view::DecodeTrace*>& get_decode_signals(){
return _decode_traces;
}
void rst_decoder(int index);
void rst_decoder_by_key_handel(void *handel);
pv::data::DecoderModel* get_decoder_model();
std::vector<view::SpectrumTrace*>& get_spectrum_traces();
view::LissajousTrace* get_lissajous_trace();
view::MathTrace* get_math_trace();
inline pv::data::DecoderModel* get_decoder_model(){
return _decoder_model;
}
inline std::vector<view::SpectrumTrace*>& get_spectrum_traces(){
return _spectrum_traces;
}
inline view::LissajousTrace* get_lissajous_trace(){
return _lissajous_trace;
}
inline view::MathTrace* get_math_trace(){
return _math_trace;
}
void init_signals();
void add_group();
void del_group();
void start_hotplug_work();
void stop_hotplug_work();
uint16_t get_ch_num(int type);
bool get_instant();
bool get_data_lock();
uint16_t get_ch_num(int type);
inline bool get_data_lock(){
return _data_lock;
}
void data_auto_lock(int lock);
void data_auto_unlock();
bool get_data_auto_lock();
@ -198,74 +221,153 @@ public:
data::MathStack::MathType type);
void math_disable();
bool trigd();
uint8_t trigd_ch();
inline bool trigd(){
return _trigger_flag;
}
inline uint8_t trigd_ch(){
return _trigger_ch;
}
data::Snapshot* get_snapshot(int type);
error_state get_error();
void set_error(error_state state);
inline error_state get_error(){
return _error;
}
inline void set_error(error_state state){
_error = state;
}
void clear_error();
uint64_t get_error_pattern();
run_mode get_run_mode();
void set_run_mode(run_mode mode);
double get_repeat_intvl();
void set_repeat_intvl(double interval);
inline uint64_t get_error_pattern(){
return _error_pattern;
}
bool isRepeating();
bool repeat_check();
inline double get_repeat_intvl(){
return _repeat_intvl;
}
inline void set_repeat_intvl(double interval){
_repeat_intvl = interval;
}
int get_repeat_hold();
int get_map_zoom();
void set_save_start(uint64_t start);
void set_save_end(uint64_t end);
uint64_t get_save_start();
uint64_t get_save_end();
bool get_saving();
inline void set_save_start(uint64_t start){
_save_start = start;
}
void set_saving(bool saving);
void set_stop_scale(float scale);
float stop_scale();
inline uint64_t get_save_start(){
return _save_start;
}
inline void set_save_end(uint64_t end){
_save_end = end;
}
inline uint64_t get_save_end(){
return _save_end;
}
inline void set_stop_scale(float scale){
_stop_scale = scale;
}
inline float stop_scale(){
return _stop_scale;
}
void exit_capture();
sr_dev_inst* get_dev_inst_c();
void Open();
void Close();
void clear_all_decoder(bool bUpdateView = true);
inline bool is_closed(){
return _bClose;
}
inline bool is_instant(){
return _is_instant;
}
inline void set_callback(ISessionCallback *callback){
_callback = callback;
}
public:
inline void capture_state_changed(int state){
_callback->capture_state_changed(state);
inline bool is_working(){
return _is_working;
}
inline bool is_init_status(){
return _device_status == ST_INIT;
}
// The collect thread is running.
inline bool is_running_status(){
return _device_status == ST_RUNNING;
}
inline bool is_stopped_status(){
return _device_status == ST_STOPPED;
}
void set_repeat_mode(bool repeat);
inline bool is_repeat_mode(){
return _is_repeat_mode;
}
inline bool is_repeating(){
return _is_repeat_mode && !_is_instant;
}
inline void session_save(){
_callback->session_save();
}
inline void repeat_resume(){
_callback->repeat_resume();
_callback->session_save();
}
inline void show_region(uint64_t start, uint64_t end, bool keep){
_callback->show_region(start, end, keep);
}
inline void decode_done(){
inline void decode_done(){
_callback->decode_done();
}
}
inline void set_sr_context(struct sr_context *ctx){
_sr_ctx = ctx;
}
inline bool is_saving(){
return _is_saving;
}
inline void set_saving(bool flag){
_is_saving = flag;
}
inline DeviceEventObject* device_event_object(){
return &_device_event;
}
void reload();
void refresh(int holdtime);
void check_update();
inline void set_map_zoom(int index){
_map_zoom = index;
}
inline int get_map_zoom(){
return _map_zoom;
}
void auto_end();
bool have_hardware_data();
struct ds_device_base_info* get_device_list(int &out_count, int &actived_index);
void add_msg_listener(IMessageListener *ln);
void broadcast_msg(int msg);
bool switch_work_mode(int mode);
private:
bool exec_capture();
void exit_capture();
inline void data_updated(){
_callback->data_updated();
}
@ -276,27 +378,28 @@ private:
inline void receive_data(quint64 len){
_callback->receive_data_len(len);
}
private:
void set_capture_state(capture_state state);
void register_hotplug_callback();
void deregister_hotplug_callback();
}
void add_decode_task(view::DecodeTrace *trace);
void remove_decode_task(view::DecodeTrace *trace);
void clear_all_decode_task(int &runningDex);
void clear_all_decode_task(int &runningDex);
view::DecodeTrace* get_decoder_trace(int index);
void decode_task_proc();
view::DecodeTrace* get_top_decode_task();
void capture_init();
void data_lock();
void data_unlock();
void nodata_timeout();
void feed_timeout();
void repeat_update();
void container_init();
void init_signals();
//IMessageListener
void OnMessage(int msg);
//IDeviceAgentCallback
void DeviceConfigChanged();
private:
/**
@ -306,8 +409,7 @@ private:
* used, or NULL if no input format was selected or
* auto-detected.
*/
static sr_input_format* determine_input_file_format(const std::string &filename);
void sample_thread_proc(DevInst *dev_inst);
static sr_input_format* determine_input_file_format(const std::string &filename);
// data feed
void feed_in_header(const sr_dev_inst *sdi);
@ -318,62 +420,33 @@ private:
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);
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);
static void data_feed_callback(const struct sr_dev_inst *sdi,
const struct sr_datafeed_packet *packet);
// thread for hotplug
void hotplug_proc();
static void device_lib_event_callback(int event);
void on_device_lib_event(int event);
static void hotplug_callback(void *ctx, void *dev, int event, void *user_data);
void on_hotplug_event(void *ctx, void *dev, int event, void *user_data);
public:
void reload();
void refresh(int holdtime);
void start_capture(bool instant);
void stop_capture();
void check_update();
void set_repeating(bool repeat);
void set_map_zoom(int index);
void auto_end();
inline bool is_device_re_attach(){
return _is_device_reattach;
}
Snapshot* get_signal_snapshot();
void repeat_capture_wait_timeout();
void repeat_wait_prog_timeout();
private:
DeviceManager *_device_manager;
/**
* The device instance that will be used in the next capture session.
*/
DevInst *_dev_inst;
mutable std::mutex _sampling_mutex;
mutable std::mutex _data_mutex;
mutable std::mutex _decode_task_mutex;
std::thread _hotplug_thread;
std::thread _sampling_thread;
mutable std::mutex _decode_task_mutex;
std::thread _decode_thread;
volatile bool _bHotplugStop;
volatile bool _bDecodeRunning;
capture_state _capture_state;
bool _instant;
volatile bool _is_decoding;
uint64_t _cur_snap_samplerate;
uint64_t _cur_samplelimits;
std::vector<view::Signal*> _signals;
std::vector<view::GroupSignal*> _group_traces;
std::vector<view::DecodeTrace*> _decode_traces;
std::vector<view::DecodeTrace*> _decode_tasks;
pv::data::DecoderModel *_decoder_model;
std::vector<view::SpectrumTrace*> _spectrum_traces;
view::LissajousTrace *_lissajous_trace;
view::MathTrace *_math_trace;
@ -383,12 +456,11 @@ private:
data::Analog *_analog_data;
data::Group *_group_data;
int _group_cnt;
bool _hot_attach;
bool _hot_detach;
DsTimer _feed_timer;
DsTimer _out_timer;
DsTimer _repeat_timer;
DsTimer _repeat_wait_prog_timer;
int _noData_cnt;
bool _data_lock;
bool _data_updated;
@ -402,28 +474,27 @@ private:
error_state _error;
uint64_t _error_pattern;
run_mode _run_mode;
double _repeat_intvl;
bool _repeating;
int _repeat_hold_prg;
int _map_zoom;
uint64_t _save_start;
uint64_t _save_end;
bool _saving;
int _map_zoom;
bool _dso_feed;
float _stop_scale;
bool _bClose;
struct sr_context *_sr_ctx;
volatile bool _is_wait_reattch;
volatile int _wait_reattch_times;
bool _is_device_reattach;
QString _last_device_name;
bool _bClose;
uint64_t _save_start;
uint64_t _save_end;
bool _is_working;
bool _is_repeat_mode;
double _repeat_intvl; // The progress wait timer interval.
int _repeat_hold_prg; // The time sleep progress
int _repeat_wait_prog_step;
bool _is_saving;
bool _is_instant;
int _device_status;
ISessionCallback *_callback;
DeviceAgent _device_agent;
std::vector<IMessageListener*> _msg_listeners;
DeviceEventObject _device_event;
private:
// TODO: This should not be necessary. Multiple concurrent

93
DSView/pv/storesession.cpp
View File

@ -38,7 +38,6 @@
#include "view/logicsignal.h"
#include "view/dsosignal.h"
#include "view/decodetrace.h"
#include "device/devinst.h"
#include "dock/protocoldock.h"
#include <QFileDialog>
@ -55,13 +54,12 @@
#include <QTextCodec>
#endif
#include "libsigrokdecode.h"
#include <libsigrokdecode.h>
#include "config/appconfig.h"
#include "dsvdef.h"
#include "utility/encoding.h"
#include "utility/path.h"
#include "log.h"
#include <QDebug>
namespace pv {
@ -113,7 +111,7 @@ QList<QString> StoreSession::getSuportedExportFormats(){
while(*supportedModules){
if(*supportedModules == NULL)
break;
if (_session->get_device()->dev_inst()->mode != LOGIC &&
if (_session->get_device()->get_work_mode() != LOGIC &&
strcmp((*supportedModules)->id, "csv"))
break;
QString format((*supportedModules)->desc);
@ -353,23 +351,22 @@ bool StoreSession::meta_gen(data::Snapshot *snapshot, std::string &str)
struct sr_status status;
const sr_dev_inst *sdi = NULL;
char meta[300] = {0};
sdi = _session->get_device()->dev_inst();
sprintf(meta, "%s", "[version]\n"); str += meta;
sprintf(meta, "version = %d\n", File_Version); str += meta;
sprintf(meta, "%s", "[header]\n"); str += meta;
if (sdi->driver) {
sprintf(meta, "driver = %s\n", sdi->driver->name); str += meta;
sprintf(meta, "device mode = %d\n", sdi->mode); str += meta;
}
int mode = _session->get_device()->get_work_mode();
/* metadata */
if (true) {
sprintf(meta, "driver = %s\n", _session->get_device()->driver_name().toLocal8Bit().data()); str += meta;
sprintf(meta, "device mode = %d\n", mode); str += meta;
}
sprintf(meta, "capturefile = data\n"); str += meta;
sprintf(meta, "total samples = %" PRIu64 "\n", snapshot->get_sample_count()); str += meta;
if (sdi->mode != LOGIC) {
if (mode != LOGIC) {
sprintf(meta, "total probes = %d\n", snapshot->get_channel_num()); str += meta;
sprintf(meta, "total blocks = %d\n", snapshot->get_block_num()); str += meta;
}
@ -377,7 +374,7 @@ bool StoreSession::meta_gen(data::Snapshot *snapshot, std::string &str)
data::LogicSnapshot *logic_snapshot = NULL;
if ((logic_snapshot = dynamic_cast<data::LogicSnapshot*>(snapshot))) {
uint16_t to_save_probes = 0;
for (l = sdi->channels; l; l = l->next) {
for (l = _session->get_device()->get_channels(); l; l = l->next) {
probe = (struct sr_channel *)l->data;
if (probe->enabled && logic_snapshot->has_data(probe->index))
to_save_probes++;
@ -390,7 +387,7 @@ bool StoreSession::meta_gen(data::Snapshot *snapshot, std::string &str)
sprintf(meta, "samplerate = %s\n", s); str += meta;
if (sdi->mode == DSO) {
if (mode == DSO) {
gvar = _session->get_device()->get_config(NULL, NULL, SR_CONF_TIMEBASE);
if (gvar != NULL) {
uint64_t tmp_u64 = g_variant_get_uint64(gvar);
@ -427,9 +424,11 @@ bool StoreSession::meta_gen(data::Snapshot *snapshot, std::string &str)
sprintf(meta, "ref max = %d\n", tmp_u32); str += meta;
g_variant_unref(gvar);
}
} else if (sdi->mode == LOGIC) {
}
else if (mode == LOGIC) {
sprintf(meta, "trigger time = %lld\n", _session->get_session_time().toMSecsSinceEpoch()); str += meta;
} else if (sdi->mode == ANALOG) {
}
else if (mode == ANALOG) {
data::AnalogSnapshot *analog_snapshot = NULL;
if ((analog_snapshot = dynamic_cast<data::AnalogSnapshot*>(snapshot))) {
uint8_t tmp_u8 = analog_snapshot->get_unit_bytes();
@ -452,17 +451,17 @@ bool StoreSession::meta_gen(data::Snapshot *snapshot, std::string &str)
probecnt = 0;
for (l = sdi->channels; l; l = l->next) {
for (l = _session->get_device()->get_channels(); l; l = l->next) {
probe = (struct sr_channel *)l->data;
if (!snapshot->has_data(probe->index))
continue;
if (sdi->mode == LOGIC && !probe->enabled)
if (mode == LOGIC && !probe->enabled)
continue;
if (probe->name)
{
int sigdex = (sdi->mode == LOGIC) ? probe->index : probecnt;
int sigdex = (mode == LOGIC) ? probe->index : probecnt;
sprintf(meta, "probe%d = %s\n", sigdex, probe->name);
str += meta;
}
@ -472,7 +471,7 @@ bool StoreSession::meta_gen(data::Snapshot *snapshot, std::string &str)
str += meta;
}
if (sdi->mode == DSO)
if (mode == DSO)
{
sprintf(meta, " enable%d = %d\n", probecnt, probe->enabled);
str += meta;
@ -487,7 +486,7 @@ bool StoreSession::meta_gen(data::Snapshot *snapshot, std::string &str)
sprintf(meta, " vTrig%d = %d\n", probecnt, probe->trig_value);
str += meta;
if (sr_status_get(sdi, &status, false) == SR_OK)
if (_session->get_device()->get_device_status(status, false))
{
if (probe->index == 0)
{
@ -553,7 +552,7 @@ bool StoreSession::meta_gen(data::Snapshot *snapshot, std::string &str)
}
}
}
else if (sdi->mode == ANALOG)
else if (mode == ANALOG)
{
sprintf(meta, " enable%d = %d\n", probecnt, probe->enabled);
str += meta;
@ -669,7 +668,7 @@ void StoreSession::export_proc(data::Snapshot *snapshot)
struct sr_output output;
output.module = (sr_output_module*) _outModule;
output.sdi = _session->get_device()->dev_inst();
output.sdi = _session->get_device()->inst();
output.param = NULL;
if(_outModule->init)
_outModule->init(&output, params);
@ -686,12 +685,14 @@ void StoreSession::export_proc(data::Snapshot *snapshot)
struct sr_datafeed_meta meta;
struct sr_config *src;
src = sr_config_new(SR_CONF_SAMPLERATE,
g_variant_new_uint64(_session->cur_snap_samplerate()));
src = _session->get_device()->new_config(SR_CONF_SAMPLERATE,
g_variant_new_uint64(_session->cur_snap_samplerate()));
meta.config = g_slist_append(NULL, src);
src = sr_config_new(SR_CONF_LIMIT_SAMPLES,
g_variant_new_uint64(snapshot->get_sample_count()));
src = _session->get_device()->new_config(SR_CONF_LIMIT_SAMPLES,
g_variant_new_uint64(snapshot->get_sample_count()));
meta.config = g_slist_append(meta.config, src);
GVariant *gvar;
@ -702,19 +703,24 @@ void StoreSession::export_proc(data::Snapshot *snapshot)
g_variant_unref(gvar);
}
gvar = _session->get_device()->get_config(NULL, NULL, SR_CONF_REF_MIN);
if (gvar != NULL) {
src = sr_config_new(SR_CONF_REF_MIN, gvar);
src = _session->get_device()->new_config(SR_CONF_REF_MIN, gvar);
g_variant_unref(gvar);
} else {
src = sr_config_new(SR_CONF_REF_MIN, g_variant_new_uint32(1));
}
else {
src = _session->get_device()->new_config(SR_CONF_REF_MIN, g_variant_new_uint32(1));
}
meta.config = g_slist_append(meta.config, src);
gvar = _session->get_device()->get_config(NULL, NULL, SR_CONF_REF_MAX);
if (gvar != NULL) {
src = sr_config_new(SR_CONF_REF_MAX, gvar);
src = _session->get_device()->new_config(SR_CONF_REF_MAX, gvar);
g_variant_unref(gvar);
} else {
src = sr_config_new(SR_CONF_REF_MAX, g_variant_new_uint32((1 << bits) - 1));
}
else {
src = _session->get_device()->new_config(SR_CONF_REF_MAX, g_variant_new_uint32((1 << bits) - 1));
}
meta.config = g_slist_append(meta.config, src);
@ -729,7 +735,7 @@ void StoreSession::export_proc(data::Snapshot *snapshot)
}
for (GSList *l = meta.config; l; l = l->next) {
src = (struct sr_config *)l->data;
sr_config_free(src);
_session->get_device()->free_config(src);
}
g_slist_free(meta.config);
@ -963,16 +969,16 @@ bool StoreSession::json_decoders(QJsonArray &array)
return true;
}
bool StoreSession::load_decoders(dock::ProtocolDock *widget, QJsonArray dec_array)
bool StoreSession::load_decoders(dock::ProtocolDock *widget, QJsonArray &dec_array)
{
if (_session->get_device()->dev_inst()->mode != LOGIC)
if (_session->get_device()->get_work_mode() != LOGIC)
{
dsv_info("%s", "StoreSession::load_decoders(), is not LOGIC mode.");
return false;
}
if (dec_array.empty()){
dsv_info("%s", "StoreSession::load_decoders(), json object is array empty.");
if (dec_array.isEmpty()){
dsv_info("%s", "StoreSession::load_decoders(), json object array is empty.");
return false;
}
@ -1203,10 +1209,10 @@ QString StoreSession::MakeSaveFile(bool bDlg)
default_name = _root + "/" + _session->get_device()->name() + "-";
}
for (const GSList *l = _session->get_device()->get_dev_mode_list();
l; l = l->next) {
for (const GSList *l = _session->get_device()->get_device_mode_list(); l; l = l->next)
{
const sr_dev_mode *mode = (const sr_dev_mode *)l->data;
if (_session->get_device()->dev_inst()->mode == mode->mode) {
if (_session->get_device()->get_work_mode() == mode->mode) {
default_name += mode->acronym;
break;
}
@ -1261,10 +1267,9 @@ QString StoreSession::MakeExportFile(bool bDlg)
default_name = _root + "/" + _session->get_device()->name() + "-";
}
for (const GSList *l = _session->get_device()->get_dev_mode_list();
l; l = l->next) {
for (const GSList *l = _session->get_device()->get_device_mode_list(); l; l = l->next) {
const sr_dev_mode *mode = (const sr_dev_mode *)l->data;
if (_session->get_device()->dev_inst()->mode == mode->mode) {
if (_session->get_device()->get_work_mode() == mode->mode) {
default_name += mode->acronym;
break;
}

4
DSView/pv/storesession.h
View File

@ -27,7 +27,7 @@
#include <string>
#include <thread>
#include <QObject>
#include "libsigrok.h"
#include <libsigrok.h>
#include "interface/icallbacks.h"
@ -80,7 +80,7 @@ private:
public:
bool json_decoders(QJsonArray &array);
bool load_decoders(dock::ProtocolDock *widget, QJsonArray dec_array);
bool load_decoders(dock::ProtocolDock *widget, QJsonArray &dec_array);
QString MakeSaveFile(bool bDlg);
QString MakeExportFile(bool bDlg);

38
DSView/pv/toolbars/filebar.cpp
View File

@ -26,7 +26,6 @@
#include <QApplication>
#include "filebar.h"
#include "../device/devinst.h"
#include "../ui/msgbox.h"
#include "../config/appconfig.h"
#include "../utility/path.h"
@ -36,7 +35,6 @@ namespace toolbars {
FileBar::FileBar(SigSession *session, QWidget *parent) :
QToolBar("File Bar", parent),
_enable(true),
_session(session),
_file_button(this)
{
@ -136,6 +134,13 @@ void FileBar::on_actionOpen_triggered()
//open data file
AppConfig &app = AppConfig::Instance();
if (_session->have_hardware_data()){
if (MsgBox::Confirm(tr("Save captured data?"))){
sig_save();
return;
}
}
// Show the dialog
const QString file_name = QFileDialog::getOpenFileName(
this,
@ -154,21 +159,6 @@ void FileBar::on_actionOpen_triggered()
}
}
void FileBar::session_error(
const QString text, const QString info_text)
{
QMetaObject::invokeMethod(this, "show_session_error",
Qt::QueuedConnection, Q_ARG(QString, text),
Q_ARG(QString, info_text));
}
void FileBar::show_session_error(
const QString text, const QString info_text)
{
(void)text;
MsgBox::Show(NULL, info_text.toStdString().c_str(), this);
}
void FileBar::on_actionLoad_triggered()
{
//load session file
@ -200,7 +190,7 @@ void FileBar::on_actionDefault_triggered()
}
QString driver_name = _session->get_device()->name();
QString mode_name = QString::number(_session->get_device()->dev_inst()->mode);
QString mode_name = QString::number(_session->get_device()->get_work_mode());
int language = LAN_EN;
GVariant *gvar_tmp = _session->get_device()->get_config(NULL, NULL, SR_CONF_LANGUAGE);
if (gvar_tmp != NULL) {
@ -247,14 +237,12 @@ void FileBar::on_actionCapture_triggered()
QTimer::singleShot(100, this, SIGNAL(sig_screenShot()));
}
void FileBar::enable_toggle(bool enable)
void FileBar::update_view_status()
{
_file_button.setDisabled(!enable);
}
void FileBar::set_settings_en(bool enable)
{
_menu_session->setDisabled(!enable);
bool bEnable = _session->is_working() == false;
bool is_hardware = _session->get_device()->is_hardware();
_file_button.setEnabled(bEnable);
_menu_session->setEnabled(bEnable && is_hardware);
}
} // namespace toolbars

21
DSView/pv/toolbars/filebar.h
View File

@ -28,7 +28,7 @@
#include <QAction>
#include <QMenu>
#include "../sigsession.h"
#include "../sigsession.h"
namespace pv {
namespace toolbars {
@ -42,19 +42,12 @@ class FileBar : public QToolBar
public:
explicit FileBar(SigSession *session, QWidget *parent = 0);
void enable_toggle(bool enable);
void set_settings_en(bool enable);
void update_view_status();
private:
void changeEvent(QEvent *event);
void retranslateUi();
void reStyle();
void session_error(
const QString text, const QString info_text);
void show_session_error(
const QString text, const QString info_text);
void reStyle();
signals:
void sig_load_file(QString);
@ -72,18 +65,14 @@ private slots:
void on_actionCapture_triggered();
private:
bool _enable;
SigSession* _session;
QToolButton _file_button;
QMenu *_menu;
QMenu *_menu_session; //when the hardware device is connected,it will be enable
QMenu *_menu;
QMenu *_menu_session; //when the hardware device is connected,it will be enable
QAction *_action_load;
QAction *_action_store;
QAction *_action_default;
QAction *_action_open;
QAction *_action_save;
QAction *_action_export;

19
DSView/pv/toolbars/logobar.cpp
View File

@ -170,25 +170,6 @@ void LogoBar::dsl_connected(bool conn)
_logo_button.setIcon(QIcon(iconPath+"/logo_noColor.svg"));
}
void LogoBar::session_error(
const QString text, const QString info_text)
{
QMetaObject::invokeMethod(this, "show_session_error",
Qt::QueuedConnection, Q_ARG(QString, text),
Q_ARG(QString, info_text));
}
void LogoBar::show_session_error(
const QString text, const QString info_text)
{
dialogs::DSMessageBox msg(this);
msg.mBox()->setText(text);
msg.mBox()->setInformativeText(info_text);
msg.mBox()->setStandardButtons(QMessageBox::Ok);
msg.mBox()->setIcon(QMessageBox::Warning);
msg.exec();
}
void LogoBar::on_actionEn_triggered()
{
_language->setIcon(QIcon::fromTheme("file",

9
DSView/pv/toolbars/logobar.h
View File

@ -27,10 +27,10 @@
#include <QToolButton>
#include <QAction>
#include <QMenu>
#include "libsigrok.h"
#include <libsigrok.h>
#include "../sigsession.h"
#include "../interface/uicallback.h"
#include "../interface/icallbacks.h"
namespace pv {
@ -59,11 +59,6 @@ private:
void retranslateUi();
void reStyle();
void session_error(
const QString text, const QString info_text);
void show_session_error(
const QString text, const QString info_text);
signals:
//post event message to open user help document, MainWindow class receive it
void sig_open_doc();

2018
DSView/pv/toolbars/samplingbar.cpp
View File

File diff suppressed because it is too large Load Diff

86
DSView/pv/toolbars/samplingbar.h
View File

@ -33,12 +33,16 @@
#include <QAction>
#include <QMenu>
#include "../ui/dscombobox.h"
#include <QDialog>
struct st_dev_inst;
class QAction;
struct ds_device_info;
class DeviceAgent;
namespace pv
{
{
class SigSession;
namespace device
@ -69,47 +73,36 @@ namespace pv
static const QString RLEString;
static const QString DIVString;
static const uint64_t ZeroTimeBase = SR_US(2);
public:
SamplingBar(SigSession *session, QWidget *parent);
void set_device_list(const std::list<DevInst*> &devices, DevInst* selected);
DevInst *get_selected_device();
SamplingBar(SigSession *session, QWidget *parent);
double hori_knob(int dir);
double get_hori_res();
void update_device_list();
void reload();
void update_view_status();
void config_device();
ds_device_handle get_next_device_handle();
void update_sample_rate_selector();
void set_sampling(bool sampling);
bool get_sampling();
bool get_instant();
void enable_toggle(bool enable);
void enable_run_stop(bool enable);
void enable_instant(bool enable);
double hori_knob(int dir);
double commit_hori_res();
double get_hori_res();
public slots:
void set_sample_rate(uint64_t sample_rate);
signals:
void sig_run_stop();
void sig_instant_stop();
void sig_device_selected();
void sig_device_updated();
void sig_duration_changed();
void sig_show_calibration();
void sig_hide_calibration();
void sig_store_session_data();
private:
private:
void changeEvent(QEvent *event);
void retranslateUi();
void reStyle();
void set_sample_rate(uint64_t sample_rate);
double commit_hori_res();
void update_sample_rate_selector_value();
void update_sample_count_selector();
void update_sample_count_selector_value();
void commit_settings();
void setting_adj();
void enable_toggle(bool enable);
private slots:
void on_mode();
@ -118,43 +111,40 @@ namespace pv
void on_device_selected();
void on_samplerate_sel(int index);
void on_samplecount_sel(int index);
void show_session_error(
const QString text, const QString info_text);
public slots:
void on_configure();
void zero_adj();
void reload();
private:
SigSession *_session;
mutable std::mutex _sampling_mutex;
bool _enable;
bool _sampling;
QToolButton _device_type;
DsComboBox _device_selector;
std::map<const void *, DevInst*> _device_selector_map;
bool _updating_device_selector;
QToolButton _configure_button;
DsComboBox _sample_count;
DsComboBox _sample_rate;
DsComboBox _device_selector;
DsComboBox _sample_count;
DsComboBox _sample_rate;
bool _updating_sample_rate;
bool _updating_sample_count;
bool _updating_device_list;
QToolButton _device_type;
QToolButton _configure_button;
QToolButton _run_stop_button;
QToolButton _instant_button;
QToolButton _mode_button;
QAction *_run_stop_action;
QAction *_instant_action;
QAction *_mode_action;
QToolButton _mode_button;
QMenu *_mode_menu;
QAction *_action_repeat;
QAction *_action_single;
bool _instant;
DeviceAgent *_device_agent;
ds_device_handle _last_device_handle;
ds_device_handle _next_switch_device;
int _last_device_index;
bool _is_run_as_instant;
};
} // namespace toolbars

45
DSView/pv/toolbars/trigbar.cpp
View File

@ -26,7 +26,6 @@
#include <QEvent>
#include "../sigsession.h"
#include "../device/devinst.h"
#include "../dialogs/fftoptions.h"
#include "../dialogs/lissajousoptions.h"
#include "../dialogs/mathoptions.h"
@ -241,21 +240,6 @@ void TrigBar::search_clicked()
AppConfig::Instance().SaveFrame();
}
void TrigBar::enable_toggle(bool enable)
{
_trig_button.setDisabled(!enable);
_protocol_button.setDisabled(!enable);
_measure_button.setDisabled(!enable);
_search_button.setDisabled(!enable);
_function_button.setDisabled(!enable);
_setting_button.setDisabled(!enable);
}
void TrigBar::enable_protocol(bool enable)
{
_protocol_button.setDisabled(!enable);
}
void TrigBar::close_all()
{
if (_trig_button.isChecked()) {
@ -280,7 +264,9 @@ void TrigBar::reload()
{
close_all();
if (_session->get_device()->dev_inst()->mode == LOGIC) {
int mode = _session->get_device()->get_work_mode();
if (mode == LOGIC) {
_trig_action->setVisible(true);
_protocol_action->setVisible(true);
_measure_action->setVisible(true);
@ -289,7 +275,7 @@ void TrigBar::reload()
_action_lissajous->setVisible(false);
_action_dispalyOptions->setVisible(true);
} else if (_session->get_device()->dev_inst()->mode == ANALOG) {
} else if (mode == ANALOG) {
_trig_action->setVisible(false);
_protocol_action->setVisible(false);
_measure_action->setVisible(true);
@ -298,7 +284,7 @@ void TrigBar::reload()
_action_lissajous->setVisible(false);
_action_dispalyOptions->setVisible(false);
} else if (_session->get_device()->dev_inst()->mode == DSO) {
} else if (mode == DSO) {
_trig_action->setVisible(true);
_protocol_action->setVisible(false);
_measure_action->setVisible(true);
@ -308,8 +294,8 @@ void TrigBar::reload()
_action_dispalyOptions->setVisible(false);
}
enable_toggle(true);
update();
update_view_status();
update();
}
void TrigBar::on_actionFft_triggered()
@ -355,7 +341,6 @@ void TrigBar::on_actionLissajous_triggered()
void TrigBar::restore_status()
{
DockOptions *opt = getDockOptions();
int mode = _session->get_device()->dev_inst()->mode;
if (opt->decodeDoc){
_protocol_button.setChecked(true);
@ -381,9 +366,9 @@ void TrigBar::restore_status()
DockOptions* TrigBar::getDockOptions()
{
AppConfig &app = AppConfig::Instance();
int mode = _session->get_device()->dev_inst()->mode;
int mode = _session->get_device()->get_work_mode();
if (mode == LOGIC)
if (mode == LOGIC)
return &app._frameOptions._logicDock;
else if (mode == DSO)
return &app._frameOptions._dsoDock;
@ -391,5 +376,17 @@ void TrigBar::restore_status()
return &app._frameOptions._analogDock;
}
void TrigBar::update_view_status()
{
bool bEnable = _session->is_working() == false;
_trig_button.setEnabled(bEnable);
_protocol_button.setEnabled(bEnable);
_measure_button.setEnabled(bEnable);
_search_button.setEnabled(bEnable);
_function_button.setEnabled(bEnable);
_setting_button.setEnabled(bEnable);
}
} // namespace toolbars
} // namespace pv

6
DSView/pv/toolbars/trigbar.h
View File

@ -27,6 +27,7 @@
#include <QToolButton>
#include <QAction>
#include <QMenu>
class DockOptions;
@ -45,16 +46,15 @@ class TrigBar : public QToolBar
public:
explicit TrigBar(SigSession *session, QWidget *parent = 0);
void enable_toggle(bool enable);
void enable_protocol(bool enable);
void close_all();
void reload();
void update_view_status();
private:
void changeEvent(QEvent *event);
void retranslateUi();
void reStyle();
DockOptions* getDockOptions();
DockOptions* getDockOptions();
signals:
void sig_setTheme(QString style);

48
DSView/pv/view/analogsignal.cpp
View File

@ -25,7 +25,6 @@
#include "../data/analog.h"
#include "../data/analogsnapshot.h"
#include "../view/view.h"
#include "../device/devinst.h"
#include "../dsvdef.h"
#include "../log.h"
@ -45,9 +44,8 @@ const QColor AnalogSignal::SignalColours[4] = {
const float AnalogSignal::EnvelopeThreshold = 16.0f;
AnalogSignal::AnalogSignal(DevInst *dev_inst,data::Analog *data,
sr_channel *probe) :
Signal(dev_inst, probe),
AnalogSignal::AnalogSignal(data::Analog *data, sr_channel *probe) :
Signal(probe),
_data(data),
_rects(NULL),
_hover_en(false),
@ -60,7 +58,7 @@ AnalogSignal::AnalogSignal(DevInst *dev_inst,data::Analog *data,
GVariant *gvar;
// channel bits
gvar = _dev_inst->get_config(NULL, NULL, SR_CONF_UNIT_BITS);
gvar = session->get_device()->get_config(NULL, NULL, SR_CONF_UNIT_BITS);
if (gvar != NULL) {
_bits = g_variant_get_byte(gvar);
g_variant_unref(gvar);
@ -70,14 +68,14 @@ AnalogSignal::AnalogSignal(DevInst *dev_inst,data::Analog *data,
dsv_warn("%s%d", "Warning: config_get SR_CONF_UNIT_BITS failed, set to %d(default).", DefaultBits);
}
gvar = _dev_inst->get_config(NULL, NULL, SR_CONF_REF_MIN);
gvar = session->get_device()->get_config(NULL, NULL, SR_CONF_REF_MIN);
if (gvar != NULL) {
_ref_min = g_variant_get_uint32(gvar);
g_variant_unref(gvar);
} else {
_ref_min = 1;
}
gvar = _dev_inst->get_config(NULL, NULL, SR_CONF_REF_MAX);
gvar = session->get_device()->get_config(NULL, NULL, SR_CONF_REF_MAX);
if (gvar != NULL) {
_ref_max = g_variant_get_uint32(gvar);
g_variant_unref(gvar);
@ -86,7 +84,7 @@ AnalogSignal::AnalogSignal(DevInst *dev_inst,data::Analog *data,
}
// -- vpos
gvar = _dev_inst->get_config(_probe, NULL, SR_CONF_PROBE_OFFSET);
gvar = session->get_device()->get_config(_probe, NULL, SR_CONF_PROBE_OFFSET);
if (gvar != NULL) {
_zero_offset = g_variant_get_uint16(gvar);
g_variant_unref(gvar);
@ -155,7 +153,7 @@ double AnalogSignal::get_ref_max()
int AnalogSignal::get_hw_offset()
{
int hw_offset = 0;
GVariant *gvar = _dev_inst->get_config(_probe, NULL, SR_CONF_PROBE_HW_OFFSET);
GVariant *gvar = session->get_device()->get_config(_probe, NULL, SR_CONF_PROBE_HW_OFFSET);
if (gvar != NULL) {
hw_offset = g_variant_get_uint16(gvar);
g_variant_unref(gvar);
@ -168,23 +166,23 @@ int AnalogSignal::commit_settings()
int ret;
// -- enable
ret = _dev_inst->set_config(_probe, NULL, SR_CONF_PROBE_EN,
ret = session->get_device()->set_config(_probe, NULL, SR_CONF_PROBE_EN,
g_variant_new_boolean(enabled()));
// -- vdiv
ret = _dev_inst->set_config(_probe, NULL, SR_CONF_PROBE_VDIV,
ret = session->get_device()->set_config(_probe, NULL, SR_CONF_PROBE_VDIV,
g_variant_new_uint64(_probe->vdiv));
// -- coupling
ret = _dev_inst->set_config(_probe, NULL, SR_CONF_PROBE_COUPLING,
ret = session->get_device()->set_config(_probe, NULL, SR_CONF_PROBE_COUPLING,
g_variant_new_byte(_probe->coupling));
// -- offset
ret = _dev_inst->set_config(_probe, NULL, SR_CONF_PROBE_OFFSET,
ret = session->get_device()->set_config(_probe, NULL, SR_CONF_PROBE_OFFSET,
g_variant_new_uint16(_probe->offset));
// -- trig_value
_dev_inst->set_config(_probe, NULL, SR_CONF_TRIGGER_VALUE,
session->get_device()->set_config(_probe, NULL, SR_CONF_TRIGGER_VALUE,
g_variant_new_byte(_probe->trig_value));
return ret;
@ -196,7 +194,7 @@ bool AnalogSignal::measure(const QPointF &p)
if (!enabled())
return false;
if (_view->session().get_capture_state() != SigSession::Stopped)
if (_view->session().is_stopped_status() == false)
return false;
const QRectF window = get_view_rect();
@ -285,7 +283,7 @@ QPointF AnalogSignal::get_point(uint64_t index, float &value)
uint64_t AnalogSignal::get_vdiv()
{
uint64_t vdiv = 0;
GVariant* gvar = _dev_inst->get_config(_probe, NULL, SR_CONF_PROBE_VDIV);
GVariant* gvar = session->get_device()->get_config(_probe, NULL, SR_CONF_PROBE_VDIV);
if (gvar != NULL) {
vdiv = g_variant_get_uint64(gvar);
g_variant_unref(gvar);
@ -296,7 +294,7 @@ uint64_t AnalogSignal::get_vdiv()
uint8_t AnalogSignal::get_acCoupling()
{
uint64_t coupling = 0;
GVariant* gvar = _dev_inst->get_config(_probe, NULL, SR_CONF_PROBE_COUPLING);
GVariant* gvar = session->get_device()->get_config(_probe, NULL, SR_CONF_PROBE_COUPLING);
if (gvar != NULL) {
coupling = g_variant_get_byte(gvar);
g_variant_unref(gvar);
@ -307,7 +305,7 @@ uint8_t AnalogSignal::get_acCoupling()
bool AnalogSignal::get_mapDefault()
{
bool isDefault = true;
GVariant* gvar = _dev_inst->get_config(_probe, NULL, SR_CONF_PROBE_MAP_DEFAULT);
GVariant* gvar = session->get_device()->get_config(_probe, NULL, SR_CONF_PROBE_MAP_DEFAULT);
if (gvar != NULL) {
isDefault = g_variant_get_boolean(gvar);
g_variant_unref(gvar);
@ -318,7 +316,7 @@ bool AnalogSignal::get_mapDefault()
QString AnalogSignal::get_mapUnit()
{
QString unit;
GVariant* gvar = _dev_inst->get_config(_probe, NULL, SR_CONF_PROBE_MAP_UNIT);
GVariant* gvar = session->get_device()->get_config(_probe, NULL, SR_CONF_PROBE_MAP_UNIT);
if (gvar != NULL) {
unit = g_variant_get_string(gvar, NULL);
g_variant_unref(gvar);
@ -329,7 +327,7 @@ QString AnalogSignal::get_mapUnit()
double AnalogSignal::get_mapMin()
{
double min = -1;
GVariant* gvar = _dev_inst->get_config(_probe, NULL, SR_CONF_PROBE_MAP_MIN);
GVariant* gvar = session->get_device()->get_config(_probe, NULL, SR_CONF_PROBE_MAP_MIN);
if (gvar != NULL) {
min = g_variant_get_double(gvar);
g_variant_unref(gvar);
@ -340,7 +338,7 @@ double AnalogSignal::get_mapMin()
double AnalogSignal::get_mapMax()
{
double max = 1;
GVariant* gvar = _dev_inst->get_config(_probe, NULL, SR_CONF_PROBE_MAP_MAX);
GVariant* gvar = session->get_device()->get_config(_probe, NULL, SR_CONF_PROBE_MAP_MAX);
if (gvar != NULL) {
max = g_variant_get_double(gvar);
g_variant_unref(gvar);
@ -352,7 +350,7 @@ uint64_t AnalogSignal::get_factor()
{
GVariant* gvar;
uint64_t factor;
gvar = _dev_inst->get_config(_probe, NULL, SR_CONF_PROBE_FACTOR);
gvar = session->get_device()->get_config(_probe, NULL, SR_CONF_PROBE_FACTOR);
if (gvar != NULL) {
factor = g_variant_get_uint64(gvar);
g_variant_unref(gvar);
@ -405,11 +403,11 @@ int AnalogSignal::get_zero_vpos()
void AnalogSignal::set_zero_ratio(double ratio)
{
if (_view->session().get_capture_state() == SigSession::Running)
if (_view->session().is_running_status())
return;
_zero_offset = ratio2value(ratio);
_dev_inst->set_config(_probe, NULL, SR_CONF_PROBE_OFFSET,
session->get_device()->set_config(_probe, NULL, SR_CONF_PROBE_OFFSET,
g_variant_new_uint16(_zero_offset));
}
@ -558,7 +556,7 @@ void AnalogSignal::paint_fore(QPainter &p, int left, int right, QColor fore, QCo
fore.setAlpha(View::ForeAlpha);
if(enabled()) {
// Paint measure
if (_view->session().get_capture_state() == SigSession::Stopped)
if (_view->session().is_stopped_status())
paint_hover_measure(p, fore, back);
}
}

2
DSView/pv/view/analogsignal.h
View File

@ -52,7 +52,7 @@ private:
static const uint8_t DefaultBits = 8;
public:
AnalogSignal(DevInst* dev_inst, pv::data::Analog *data,
AnalogSignal(pv::data::Analog *data,
sr_channel *probe);
AnalogSignal(view::AnalogSignal* s, pv::data::Analog *data, sr_channel *probe);

1
DSView/pv/view/cursor.cpp
View File

@ -24,7 +24,6 @@
#include "ruler.h"
#include "view.h"
#include "../device/device.h"
#include <QBrush>
#include <QPainter>

9
DSView/pv/view/decodetrace.cpp
View File

@ -20,10 +20,8 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "libsigrokdecode.h"
#include "../dsvdef.h"
#include <libsigrokdecode.h>
#include "../dsvdef.h"
#include <boost/functional/hash.hpp>
#include <QAction>
#include <QFormLayout>
@ -47,7 +45,6 @@
#include "../view/view.h"
#include "../widgets/decodergroupbox.h"
#include "../widgets/decodermenu.h"
#include "../device/devinst.h"
#include "../view/cursor.h"
#include "../toolbars/titlebar.h"
#include "../dsvdef.h"
@ -569,7 +566,7 @@ void DecodeTrace::on_new_decode_data()
}
decoded_progress(_progress);
if (_view && _view->session().get_capture_state() == SigSession::Stopped)
if (_view && _view->session().is_stopped_status())
_view->data_updated();
if (_totalHeight/_view->get_signalHeight() != rows_size())
_view->signals_changed();

117
DSView/pv/view/devmode.cpp
View File

@ -22,9 +22,7 @@
#include "devmode.h"
#include "view.h"
#include "trace.h"
#include "../sigsession.h"
#include "../device/devinst.h"
#include "../device/file.h"
#include "../sigsession.h"
#include <assert.h>
#include <QStyleOption>
@ -35,17 +33,28 @@
#include "../config/appconfig.h"
#include "../ui/msgbox.h"
#include "../log.h"
static const struct dev_mode_name dev_mode_name_list[] =
{
{LOGIC, "Logic Analyzer", "逻辑分析仪", "la.svg"},
{ANALOG, "Data Acquisition", "数据记录仪", "daq.svg"},
{DSO, "Oscilloscope", "示波器", "osc.svg"},
};
namespace pv {
namespace view {
DevMode::DevMode(QWidget *parent, SigSession *session) :
QWidget(parent),
_session(session)
QWidget(parent)
{
_bFile = false;
QHBoxLayout *layout = new QHBoxLayout(this);
_session = session;
_device_agent = session->get_device();
QHBoxLayout *layout = new QHBoxLayout(this);
layout->setSpacing(0);
layout->setContentsMargins(2, 0, 0, 0);
@ -93,8 +102,10 @@ void DevMode::changeEvent(QEvent *event)
void DevMode::set_device()
{
DevInst* dev_inst = _session->get_device();
assert(dev_inst);
if (_device_agent->have_instance() == false){
dsv_detail("%s", "DevMode::set_device, Have no device.");
return;
}
_bFile = false;
@ -115,35 +126,37 @@ void DevMode::set_device()
QString iconPath = GetIconPath() + "/";
for (const GSList *l = dev_inst->get_dev_mode_list(); l; l = l->next)
auto dev_mode_list = _device_agent->get_device_mode_list();
for (const GSList *l = dev_mode_list; l; l = l->next)
{
const sr_dev_mode *mode = (const sr_dev_mode *)l->data;
QString icon_name = QString::fromLocal8Bit(mode->icon);
auto *mode_name = get_mode_name(mode->mode);
QString icon_name = QString::fromLocal8Bit(mode_name->_logo);
QAction *action = new QAction(this);
action->setIcon(QIcon(iconPath + "square-" + icon_name));
if (lan == LAN_CN)
action->setText(mode->name_cn);
action->setText(mode_name->_name_cn);
else
action->setText(mode->name);
action->setText(mode_name->_name_en);
connect(action, SIGNAL(triggered()), this, SLOT(on_mode_change()));
_mode_list[action] = mode;
if (dev_inst->dev_inst()->mode == _mode_list[action]->mode)
if (_device_agent->get_work_mode() == _mode_list[action]->mode)
{
QString icon_fname = iconPath + icon_name;
_mode_btn->setIcon(QIcon(icon_fname));
if (lan == LAN_CN)
_mode_btn->setText(mode->name_cn);
_mode_btn->setText(mode_name->_name_cn);
else
_mode_btn->setText(mode->name);
_mode_btn->setText(mode_name->_name_en);
}
_pop_menu->addAction(action);
}
if ((dynamic_cast<File *>(dev_inst)))
{
if (_device_agent->is_file()){
_close_button->setDisabled(false);
_close_button->setIcon(QIcon(iconPath + "/close.svg"));
_bFile = true;
@ -164,11 +177,15 @@ void DevMode::paintEvent(QPaintEvent*)
void DevMode::on_mode_change()
{
DevInst* dev_inst = _session->get_device();
assert(dev_inst);
if (_device_agent->have_instance() == false){
assert(false);
}
QAction *action = qobject_cast<QAction *>(sender());
if (dev_inst->dev_inst()->mode == _mode_list[action]->mode)
if (_device_agent->get_work_mode() == _mode_list[action]->mode){
return;
}
QString iconPath = GetIconPath();
AppConfig &app = AppConfig::Instance();
@ -176,40 +193,41 @@ void DevMode::on_mode_change()
for(auto i = _mode_list.begin();i != _mode_list.end(); i++)
{
if ((*i).first == action) {
if (dev_inst->dev_inst()->mode != (*i).second->mode) {
_session->set_run_mode(SigSession::Single);
_session->set_repeating(false);
_session->stop_capture();
_session->capture_state_changed(SigSession::Stopped);
_session->session_save();
dev_inst->set_config(NULL, NULL,
SR_CONF_DEVICE_MODE,
g_variant_new_int16((*i).second->mode));
if ((*i).first == action){
QString icon_fname = iconPath + "/" + QString::fromLocal8Bit((*i).second->icon);
_mode_btn->setIcon(QIcon(icon_fname));
if (lan == LAN_CN)
_mode_btn->setText((*i).second->name_cn);
else
_mode_btn->setText((*i).second->name);
dev_changed(false);
int mode = (*i).second->mode;
if (_device_agent->get_work_mode() == mode){
dsv_info("%s", "Current mode is set.");
break;
}
_session->stop_capture();
_session->set_repeat_mode(false);
_session->session_save();
_session->switch_work_mode(mode);
break;
}
auto *mode_name = get_mode_name(mode);
QString icon_fname = iconPath + "/" + QString::fromLocal8Bit(mode_name->_logo);
_mode_btn->setIcon(QIcon(icon_fname));
if (lan == LAN_CN)
_mode_btn->setText(mode_name->_name_cn);
else
_mode_btn->setText(mode_name->_name_en);
break;
}
}
}
void DevMode::on_close()
{
DevInst *dev_inst = _session->get_device();
assert(dev_inst);
if (_device_agent->have_instance() == false){
assert(false);
}
if (_bFile && MsgBox::Confirm(tr("are you sure to close the device?"))){
_session->close_file(dev_inst);
dev_changed(true);
if (_bFile && MsgBox::Confirm(tr("Are you sure to close the device?"))){
_session->close_file(_device_agent->handle());
}
}
@ -238,5 +256,14 @@ void DevMode::leaveEvent(QEvent*)
update();
}
const struct dev_mode_name* DevMode::get_mode_name(int mode)
{
for(auto &o : dev_mode_name_list)
if (mode == o._mode){
return &o;
}
assert(false);
}
} // namespace view
} // namespace pv

18
DSView/pv/view/devmode.h
View File

@ -34,8 +34,17 @@
#include <QToolButton>
#include <QLabel>
#include "libsigrok.h"
#include <libsigrok.h>
struct dev_mode_name{
int _mode;
const char *_name_en;
const char *_name_cn;
const char *_logo;
};
class DeviceAgent;
namespace pv {
namespace device{
@ -65,8 +74,8 @@ private:
void mouseReleaseEvent(QMouseEvent *event);
void mouseMoveEvent(QMouseEvent *event);
void leaveEvent(QEvent *event);
void changeEvent(QEvent *event);
const dev_mode_name* get_mode_name(int mode);
public slots:
void set_device();
@ -75,8 +84,7 @@ public slots:
private slots:
signals:
void dev_changed(bool close);
private:
SigSession *_session;
@ -86,6 +94,8 @@ private:
QPoint _mouse_point;
QToolButton *_close_button;
bool _bFile;
DeviceAgent *_device_agent;
};
} // namespace view

237
DSView/pv/view/dsosignal.cpp
View File

@ -29,9 +29,9 @@
#include "../dsvdef.h"
#include "../data/dso.h"
#include "../data/dsosnapshot.h"
#include "../sigsession.h"
#include "../device/devinst.h"
#include "../sigsession.h"
#include "../log.h"
#include "../appcontrol.h"
using namespace std;
@ -53,10 +53,9 @@ const QColor DsoSignal::SignalColours[4] = {
const float DsoSignal::EnvelopeThreshold = 256.0f;
DsoSignal::DsoSignal(DevInst *dev_inst,
data::Dso *data,
DsoSignal::DsoSignal(data::Dso *data,
sr_channel *probe):
Signal(dev_inst, probe),
Signal(probe),
_data(data),
_scale(0),
_en_lock(false),
@ -75,12 +74,17 @@ DsoSignal::DsoSignal(DevInst *dev_inst,
{
QVector<uint64_t> vValue;
QVector<QString> vUnit;
for(uint64_t i = 0; i < vDialUnitCount; i++)
for(uint64_t i = 0; i < vDialUnitCount; i++){
vUnit.append(vDialUnit[i]);
}
GVariant *gvar_list, *gvar_list_vdivs;
if (sr_config_list(dev_inst->dev_inst()->driver, dev_inst->dev_inst(),
NULL, SR_CONF_PROBE_VDIV, &gvar_list) == SR_OK) {
gvar_list = session->get_device()->get_config_list(NULL, SR_CONF_PROBE_VDIV);
if (gvar_list != NULL)
{
assert(gvar_list);
if ((gvar_list_vdivs = g_variant_lookup_value(gvar_list,
"vdivs", G_VARIANT_TYPE("at")))) {
@ -117,7 +121,7 @@ pv::data::Dso* DsoSignal::dso_data()
void DsoSignal::set_scale(int height)
{
_scale = height / (_ref_max - _ref_min) * _view->session().stop_scale();
_scale = height / (_ref_max - _ref_min) * session->stop_scale();
}
float DsoSignal::get_scale()
@ -146,15 +150,15 @@ int DsoSignal::get_name_width()
}
void DsoSignal::set_enable(bool enable)
{
if (_dev_inst->name() == "DSLogic" &&
get_index() == 0)
{
if (session->get_device()->name() == "DSLogic" && get_index() == 0){
return;
}
_en_lock = true;
GVariant* gvar;
bool cur_enable;
gvar = _dev_inst->get_config(_probe, NULL, SR_CONF_PROBE_EN);
gvar = session->get_device()->get_config(_probe, NULL, SR_CONF_PROBE_EN);
if (gvar != NULL) {
cur_enable = g_variant_get_boolean(gvar);
g_variant_unref(gvar);
@ -170,20 +174,24 @@ void DsoSignal::set_enable(bool enable)
}
bool running = false;
if (_view->session().get_capture_state() == SigSession::Running) {
if (session->is_running_status()) {
running = true;
_view->session().stop_capture();
session->stop_capture();
}
while(_view->session().get_capture_state() == SigSession::Running)
while(session->is_running_status())
QCoreApplication::processEvents();
set_vDialActive(false);
_dev_inst->set_config(_probe, NULL, SR_CONF_PROBE_EN,
session->get_device()->set_config(_probe, NULL, SR_CONF_PROBE_EN,
g_variant_new_boolean(enable));
_view->update_hori_res();
if (running) {
_view->session().repeat_resume();
session->stop_capture();
session->start_capture(false);
}
_view->set_update(_viewport, true);
@ -203,29 +211,34 @@ void DsoSignal::set_vDialActive(bool active)
}
bool DsoSignal::go_vDialPre(bool manul)
{
{
if (_autoV && manul)
autoV_end();
autoV_end();
if (enabled() && !_vDial->isMin())
{
if (session->is_running_status())
session->refresh(RefreshShort);
if (enabled() && !_vDial->isMin()) {
if (_view->session().get_capture_state() == SigSession::Running)
_view->session().refresh(RefreshShort);
const double pre_vdiv = _vDial->get_value();
_vDial->set_sel(_vDial->get_sel() - 1);
_dev_inst->set_config(_probe, NULL, SR_CONF_PROBE_VDIV,
session->get_device()->set_config(_probe, NULL, SR_CONF_PROBE_VDIV,
g_variant_new_uint64(_vDial->get_value()));
if (_view->session().get_capture_state() == SigSession::Stopped) {
_view->session().set_stop_scale(_view->session().stop_scale() * (pre_vdiv/_vDial->get_value()));
if (session->is_stopped_status()) {
session->set_stop_scale(session->stop_scale() * (pre_vdiv/_vDial->get_value()));
set_scale(get_view_rect().height());
}
_dev_inst->set_config(_probe, NULL, SR_CONF_PROBE_OFFSET,
session->get_device()->set_config(_probe, NULL, SR_CONF_PROBE_OFFSET,
g_variant_new_uint16(_zero_offset));
_view->vDial_updated();
_view->set_update(_viewport, true);
_view->update();
return true;
} else {
}
else {
if (_autoV && !_autoV_over)
autoV_end();
return false;
@ -235,27 +248,32 @@ bool DsoSignal::go_vDialPre(bool manul)
bool DsoSignal::go_vDialNext(bool manul)
{
if (_autoV && manul)
autoV_end();
autoV_end();
if (enabled() && !_vDial->isMax())
{
if (session->is_running_status())
session->refresh(RefreshShort);
if (enabled() && !_vDial->isMax()) {
if (_view->session().get_capture_state() == SigSession::Running)
_view->session().refresh(RefreshShort);
const double pre_vdiv = _vDial->get_value();
_vDial->set_sel(_vDial->get_sel() + 1);
_dev_inst->set_config(_probe, NULL, SR_CONF_PROBE_VDIV,
session->get_device()->set_config(_probe, NULL, SR_CONF_PROBE_VDIV,
g_variant_new_uint64(_vDial->get_value()));
if (_view->session().get_capture_state() == SigSession::Stopped) {
_view->session().set_stop_scale(_view->session().stop_scale() * (pre_vdiv/_vDial->get_value()));
if (session->is_stopped_status()) {
session->set_stop_scale(session->stop_scale() * (pre_vdiv/_vDial->get_value()));
set_scale(get_view_rect().height());
}
_dev_inst->set_config(_probe, NULL, SR_CONF_PROBE_OFFSET,
session->get_device()->set_config(_probe, NULL, SR_CONF_PROBE_OFFSET,
g_variant_new_uint16(_zero_offset));
_view->vDial_updated();
_view->set_update(_viewport, true);
_view->update();
return true;
} else {
}
else {
if (_autoV && !_autoV_over)
autoV_end();
return false;
@ -264,10 +282,10 @@ bool DsoSignal::go_vDialNext(bool manul)
bool DsoSignal::load_settings()
{
GVariant* gvar;
GVariant* gvar;
// dso channel bits
gvar = _dev_inst->get_config(NULL, NULL, SR_CONF_UNIT_BITS);
gvar = session->get_device()->get_config(NULL, NULL, SR_CONF_UNIT_BITS);
if (gvar != NULL) {
_bits = g_variant_get_byte(gvar);
g_variant_unref(gvar);
@ -276,17 +294,17 @@ bool DsoSignal::load_settings()
_bits = DefaultBits;
dsv_warn("%s%d", "Warning: config_get SR_CONF_UNIT_BITS failed, set to %d(default).", DefaultBits);
if (strncmp(_dev_inst->name().toUtf8().data(), "virtual", 7))
if (strncmp(session->get_device()->name().toUtf8().data(), "virtual", 7))
return false;
}
gvar = _dev_inst->get_config(NULL, NULL, SR_CONF_REF_MIN);
gvar = session->get_device()->get_config(NULL, NULL, SR_CONF_REF_MIN);
if (gvar != NULL) {
_ref_min = g_variant_get_uint32(gvar);
g_variant_unref(gvar);
} else {
_ref_min = 1;
}
gvar = _dev_inst->get_config(NULL, NULL, SR_CONF_REF_MAX);
gvar = session->get_device()->get_config(NULL, NULL, SR_CONF_REF_MAX);
if (gvar != NULL) {
_ref_max = g_variant_get_uint32(gvar);
g_variant_unref(gvar);
@ -297,7 +315,7 @@ bool DsoSignal::load_settings()
// -- vdiv
uint64_t vdiv;
uint64_t vfactor;
gvar = _dev_inst->get_config(_probe, NULL, SR_CONF_PROBE_VDIV);
gvar = session->get_device()->get_config(_probe, NULL, SR_CONF_PROBE_VDIV);
if (gvar != NULL) {
vdiv = g_variant_get_uint64(gvar);
g_variant_unref(gvar);
@ -306,7 +324,7 @@ bool DsoSignal::load_settings()
dsv_err("%s", "ERROR: config_get SR_CONF_PROBE_VDIV failed.");
return false;
}
gvar = _dev_inst->get_config(_probe, NULL, SR_CONF_PROBE_FACTOR);
gvar = session->get_device()->get_config(_probe, NULL, SR_CONF_PROBE_FACTOR);
if (gvar != NULL) {
vfactor = g_variant_get_uint64(gvar);
g_variant_unref(gvar);
@ -320,7 +338,7 @@ bool DsoSignal::load_settings()
_vDial->set_factor(vfactor);
// -- coupling
gvar = _dev_inst->get_config(_probe, NULL, SR_CONF_PROBE_COUPLING);
gvar = session->get_device()->get_config(_probe, NULL, SR_CONF_PROBE_COUPLING);
if (gvar != NULL) {
_acCoupling = g_variant_get_byte(gvar);
g_variant_unref(gvar);
@ -331,7 +349,7 @@ bool DsoSignal::load_settings()
}
// -- vpos
gvar = _dev_inst->get_config(_probe, NULL, SR_CONF_PROBE_OFFSET);
gvar = session->get_device()->get_config(_probe, NULL, SR_CONF_PROBE_OFFSET);
if (gvar != NULL) {
_zero_offset = g_variant_get_uint16(gvar);
g_variant_unref(gvar);
@ -342,7 +360,7 @@ bool DsoSignal::load_settings()
}
// -- trig_value
gvar = _dev_inst->get_config(_probe, NULL, SR_CONF_TRIGGER_VALUE);
gvar = session->get_device()->get_config(_probe, NULL, SR_CONF_TRIGGER_VALUE);
if (gvar != NULL) {
_trig_value = g_variant_get_byte(gvar);
_trig_delta = get_trig_vrate() - get_zero_ratio();
@ -350,7 +368,7 @@ bool DsoSignal::load_settings()
}
else {
dsv_err("%s", "ERROR: config_get SR_CONF_TRIGGER_VALUE failed.");
if (strncmp(_dev_inst->name().toUtf8().data(), "virtual", 7))
if (strncmp(session->get_device()->name().toUtf8().data(), "virtual", 7))
return false;
}
@ -364,26 +382,27 @@ bool DsoSignal::load_settings()
int DsoSignal::commit_settings()
{
int ret;
// -- enable
ret = _dev_inst->set_config(_probe, NULL, SR_CONF_PROBE_EN,
ret = session->get_device()->set_config(_probe, NULL, SR_CONF_PROBE_EN,
g_variant_new_boolean(enabled()));
// -- vdiv
ret = _dev_inst->set_config(_probe, NULL, SR_CONF_PROBE_VDIV,
ret = session->get_device()->set_config(_probe, NULL, SR_CONF_PROBE_VDIV,
g_variant_new_uint64(_vDial->get_value()));
ret = _dev_inst->set_config(_probe, NULL, SR_CONF_PROBE_FACTOR,
ret = session->get_device()->set_config(_probe, NULL, SR_CONF_PROBE_FACTOR,
g_variant_new_uint64(_vDial->get_factor()));
// -- coupling
ret = _dev_inst->set_config(_probe, NULL, SR_CONF_PROBE_COUPLING,
ret = session->get_device()->set_config(_probe, NULL, SR_CONF_PROBE_COUPLING,
g_variant_new_byte(_acCoupling));
// -- offset
ret = _dev_inst->set_config(_probe, NULL, SR_CONF_PROBE_OFFSET,
ret = session->get_device()->set_config(_probe, NULL, SR_CONF_PROBE_OFFSET,
g_variant_new_uint16(_zero_offset));
// -- trig_value
_dev_inst->set_config(_probe, NULL, SR_CONF_TRIGGER_VALUE,
session->get_device()->set_config(_probe, NULL, SR_CONF_TRIGGER_VALUE,
g_variant_new_byte(_trig_value));
return ret;
@ -412,8 +431,8 @@ uint8_t DsoSignal::get_acCoupling()
void DsoSignal::set_acCoupling(uint8_t coupling)
{
if (enabled()) {
_acCoupling = coupling;
_dev_inst->set_config(_probe, NULL, SR_CONF_PROBE_COUPLING,
_acCoupling = coupling;
session->get_device()->set_config(_probe, NULL, SR_CONF_PROBE_COUPLING,
g_variant_new_byte(_acCoupling));
}
}
@ -439,8 +458,8 @@ double DsoSignal::pos2ratio(int pos)
}
double DsoSignal::get_trig_vrate()
{
if (_dev_inst->name() == "DSLogic")
{
if (session->get_device()->name() == "DSLogic")
return value2ratio(_trig_value - ratio2value(0.5)) + get_zero_ratio();
else
return value2ratio(_trig_value);
@ -456,8 +475,9 @@ void DsoSignal::set_trig_vpos(int pos, bool delta_change)
void DsoSignal::set_trig_ratio(double ratio, bool delta_change)
{
double delta = ratio;
if (_dev_inst->name() == "DSLogic") {
double delta = ratio;
if (session->get_device()->name() == "DSLogic") {
delta = delta - get_zero_ratio();
delta = min(delta, 0.5);
delta = max(delta, -0.5);
@ -470,7 +490,7 @@ void DsoSignal::set_trig_ratio(double ratio, bool delta_change)
_trig_value = std::min(std::max(_trig_value, margin), (ratio2value(1) - margin));
if (delta_change)
_trig_delta = get_trig_vrate() - get_zero_ratio();
_dev_inst->set_config(_probe, NULL, SR_CONF_TRIGGER_VALUE,
session->get_device()->set_config(_probe, NULL, SR_CONF_TRIGGER_VALUE,
g_variant_new_byte(_trig_value));
}
@ -486,8 +506,9 @@ double DsoSignal::get_zero_ratio()
int DsoSignal::get_hw_offset()
{
int hw_offset = 0;
GVariant *gvar = _dev_inst->get_config(_probe, NULL, SR_CONF_PROBE_HW_OFFSET);
int hw_offset = 0;
GVariant *gvar = session->get_device()->get_config(_probe, NULL, SR_CONF_PROBE_HW_OFFSET);
if (gvar != NULL) {
hw_offset = g_variant_get_uint16(gvar);
g_variant_unref(gvar);
@ -505,8 +526,8 @@ void DsoSignal::set_zero_vpos(int pos)
void DsoSignal::set_zero_ratio(double ratio)
{
_zero_offset = ratio2value(ratio);
_dev_inst->set_config(_probe, NULL, SR_CONF_PROBE_OFFSET,
_zero_offset = ratio2value(ratio);
session->get_device()->set_config(_probe, NULL, SR_CONF_PROBE_OFFSET,
g_variant_new_uint16(_zero_offset));
}
@ -514,8 +535,9 @@ void DsoSignal::set_factor(uint64_t factor)
{
if (enabled()) {
GVariant* gvar;
uint64_t prefactor = 0;
gvar = _dev_inst->get_config(_probe, NULL, SR_CONF_PROBE_FACTOR);
uint64_t prefactor = 0;
gvar = session->get_device()->get_config(_probe, NULL, SR_CONF_PROBE_FACTOR);
if (gvar != NULL) {
prefactor = g_variant_get_uint64(gvar);
g_variant_unref(gvar);
@ -525,7 +547,7 @@ void DsoSignal::set_factor(uint64_t factor)
return;
}
if (prefactor != factor) {
_dev_inst->set_config(_probe, NULL, SR_CONF_PROBE_FACTOR,
session->get_device()->set_config(_probe, NULL, SR_CONF_PROBE_FACTOR,
g_variant_new_uint64(factor));
_vDial->set_factor(factor);
_view->set_update(_viewport, true);
@ -537,8 +559,9 @@ void DsoSignal::set_factor(uint64_t factor)
uint64_t DsoSignal::get_factor()
{
GVariant* gvar;
uint64_t factor;
gvar = _dev_inst->get_config(_probe, NULL, SR_CONF_PROBE_FACTOR);
uint64_t factor;
gvar = session->get_device()->get_config(_probe, NULL, SR_CONF_PROBE_FACTOR);
if (gvar != NULL) {
factor = g_variant_get_uint64(gvar);
g_variant_unref(gvar);
@ -706,11 +729,12 @@ void DsoSignal::paint_prepare()
if (!snapshot->has_data(get_index()))
return;
const uint16_t enabled_channels = snapshot->get_channel_num();
if (_view->session().trigd()) {
if (get_index() == _view->session().trigd_ch()) {
const uint16_t enabled_channels = snapshot->get_channel_num();
if (session->trigd()) {
if (get_index() == session->trigd_ch()) {
uint8_t slope = DSO_TRIGGER_RISING;
GVariant *gvar = _view->session().get_device()->get_config(NULL, NULL, SR_CONF_TRIGGER_SLOPE);
GVariant *gvar = session->get_device()->get_config(NULL, NULL, SR_CONF_TRIGGER_SLOPE);
if (gvar != NULL) {
slope = g_variant_get_byte(gvar);
g_variant_unref(gvar);
@ -751,7 +775,7 @@ void DsoSignal::paint_back(QPainter &p, int left, int right, QColor fore, QColor
int i, j;
const int height = get_view_rect().height();
const int width = right - left;
const int width = right - left;
fore.setAlpha(View::BackAlpha);
@ -764,8 +788,9 @@ void DsoSignal::paint_back(QPainter &p, int left, int right, QColor fore, QColor
// draw zoom region
fore.setAlpha(View::ForeAlpha);
p.setPen(fore);
const uint64_t sample_len = _view->session().cur_samplelimits();
const double samplerate = _view->session().cur_snap_samplerate();
const uint64_t sample_len = session->cur_samplelimits();
const double samplerate = session->cur_snap_samplerate();
const double samples_per_pixel = samplerate * _view->scale();
const double shown_rate = min(samples_per_pixel * width * 1.0 / sample_len, 1.0);
const double start = _view->offset() * samples_per_pixel;
@ -851,8 +876,8 @@ void DsoSignal::paint_mid(QPainter &p, int left, int right, QColor fore, QColor
const uint16_t enabled_channels = snapshot->get_channel_num();
const double pixels_offset = offset;
const double samplerate = _data->samplerate();
//const double samplerate = _dev_inst->get_sample_rate();
//const double samplerate = _view->session().cur_snap_samplerate();
//const double samplerate = session->get_device()->get_sample_rate();
//const double samplerate = session->cur_snap_samplerate();
const int64_t last_sample = max((int64_t)(snapshot->get_sample_count() - 1), (int64_t)0);
const double samples_per_pixel = samplerate * scale;
const double start = offset * samples_per_pixel - _view->trig_hoff();
@ -876,8 +901,9 @@ void DsoSignal::paint_mid(QPainter &p, int left, int right, QColor fore, QColor
pixels_offset, samples_per_pixel, enabled_channels);
}
sr_status status;
if (sr_status_get(_dev_inst->dev_inst(), &status, false) == SR_OK) {
sr_status status;
if (session->get_device()->get_device_status(status, false)) {
_mValid = true;
if (status.measure_valid) {
_min = (index == 0) ? status.ch0_min : status.ch1_min;
@ -890,7 +916,7 @@ void DsoSignal::paint_mid(QPainter &p, int left, int right, QColor fore, QColor
const uint32_t count = (index == 0) ? status.ch0_cyc_cnt : status.ch1_cyc_cnt;
const bool plevel = (index == 0) ? status.ch0_plevel : status.ch1_plevel;
const bool startXORend = (index == 0) ? (status.ch0_cyc_llen == 0) : (status.ch1_cyc_llen == 0);
const uint16_t total_channels = g_slist_length(_dev_inst->dev_inst()->channels);
const uint16_t total_channels = g_slist_length(session->get_device()->get_channels());
const double tfactor = (total_channels / enabled_channels) * SR_GHZ(1) * 1.0 / samplerate;
double samples = (index == 0) ? status.ch0_cyc_tlen : status.ch1_cyc_tlen;
@ -925,7 +951,7 @@ void DsoSignal::paint_fore(QPainter &p, int left, int right, QColor fore, QColor
if (!_show)
return;
assert(_view);
assert(_view);
fore.setAlpha(View::BackAlpha);
QPen pen(fore);
@ -999,7 +1025,7 @@ void DsoSignal::paint_fore(QPainter &p, int left, int right, QColor fore, QColor
p.drawText(label_rect, Qt::AlignCenter | Qt::AlignVCenter, "T");
// Paint measure
if (_view->session().get_capture_state() == SigSession::Stopped)
if (session->is_stopped_status())
paint_hover_measure(p, fore, back);
// autoset
@ -1117,7 +1143,7 @@ void DsoSignal::paint_envelope(QPainter &p,
}
void DsoSignal::paint_type_options(QPainter &p, int right, const QPoint pt, QColor fore)
{
{
p.setRenderHint(QPainter::Antialiasing, true);
QColor foreBack = fore;
@ -1158,7 +1184,7 @@ void DsoSignal::paint_type_options(QPainter &p, int right, const QPoint pt, QCol
p.drawText(acdc_rect, Qt::AlignCenter | Qt::AlignVCenter, (_acCoupling == SR_GND_COUPLING) ? tr(strings[2]):
(_acCoupling == SR_DC_COUPLING) ? tr(strings[3]) : tr(strings[4]));
if (!_dev_inst->name().contains("virtual")) {
if (session->get_device()->is_hardware()) {
p.setPen(Qt::transparent);
p.setBrush(enabled() ? (auto_rect.contains(pt) ? _colour.darker() : _colour) : foreBack);
p.drawRect(auto_rect);
@ -1169,7 +1195,7 @@ void DsoSignal::paint_type_options(QPainter &p, int right, const QPoint pt, QCol
// paint the probe factor selector
GVariant* gvar;
uint64_t factor;
gvar = _dev_inst->get_config(_probe, NULL, SR_CONF_PROBE_FACTOR);
gvar = session->get_device()->get_config(_probe, NULL, SR_CONF_PROBE_FACTOR);
if (gvar != NULL) {
factor = g_variant_get_uint64(gvar);
g_variant_unref(gvar);
@ -1196,7 +1222,7 @@ void DsoSignal::paint_type_options(QPainter &p, int right, const QPoint pt, QCol
}
bool DsoSignal::mouse_press(int right, const QPoint pt)
{
{
int y = get_y();
const QRectF vDial_rect = get_rect(DSO_VDIAL, y, right);
const QRectF chEn_rect = get_rect(DSO_CHEN, y, right);
@ -1207,7 +1233,7 @@ bool DsoSignal::mouse_press(int right, const QPoint pt)
const QRectF x100_rect = get_rect(DSO_X100, y, right);
if (chEn_rect.contains(pt)) {
if (_dev_inst->name() != "virtual-session" &&
if (session->get_device()->name() != "virtual-session" &&
!_en_lock) {
set_enable(!enabled());
}
@ -1218,14 +1244,14 @@ bool DsoSignal::mouse_press(int right, const QPoint pt)
go_vDialNext(true);
else
go_vDialPre(true);
} else if (_dev_inst->name() != "virtual-session" &&
} else if (session->get_device()->name() != "virtual-session" &&
acdc_rect.contains(pt)) {
if (_dev_inst->name() == "DSLogic")
if (session->get_device()->name() == "DSLogic")
set_acCoupling((get_acCoupling()+1)%2);
else
set_acCoupling((get_acCoupling()+1)%2);
} else if (auto_rect.contains(pt)) {
if (!_dev_inst->name().contains("virtual"))
if (!session->get_device()->name().contains("virtual"))
auto_start();
} else if (x1_rect.contains(pt)) {
set_factor(1);
@ -1357,20 +1383,21 @@ void DsoSignal::paint_hover_measure(QPainter &p, QColor fore, QColor back)
}
void DsoSignal::auto_set()
{
if (_view->session().get_capture_state() == SigSession::Stopped) {
{
if (session->is_stopped_status()) {
if (_autoV)
autoV_end();
if (_autoH)
autoH_end();
} else {
}
else {
if (_autoH && _autoV && get_zero_ratio() != 0.5) {
set_zero_ratio(0.5);
}
if (_mValid && !_view->session().get_data_auto_lock()) {
if (_mValid && !session->get_data_auto_lock()) {
if (_autoH) {
bool roll = false;
GVariant *gvar = _dev_inst->get_config(NULL, NULL, SR_CONF_ROLL);
GVariant *gvar = session->get_device()->get_config(NULL, NULL, SR_CONF_ROLL);
if (gvar != NULL) {
roll = g_variant_get_boolean(gvar);
g_variant_unref(gvar);
@ -1414,7 +1441,7 @@ void DsoSignal::auto_set()
}
}
if (_autoH || _autoV)
_view->session().data_auto_lock(AutoLock);
session->data_auto_lock(AutoLock);
}
}
}
@ -1446,11 +1473,12 @@ void DsoSignal::auto_end()
}
void DsoSignal::auto_start()
{
{
if (_autoV || _autoH)
return;
if (_view->session().get_capture_state() == SigSession::Running) {
_view->session().data_auto_lock(AutoLock);
if (session->is_running_status()) {
session->data_auto_lock(AutoLock);
_autoV = true;
_autoH = true;
_view->auto_trig(get_index());
@ -1459,12 +1487,13 @@ void DsoSignal::auto_start()
}
bool DsoSignal::measure(const QPointF &p)
{
{
_hover_en = false;
if (!enabled() || !show())
return false;
if (_view->session().get_capture_state() != SigSession::Stopped)
if (session->is_stopped_status() == false)
return false;
const QRectF window = get_view_rect();
@ -1569,7 +1598,7 @@ QString DsoSignal::get_time(double t)
}
void DsoSignal::call_auto_end(){
_view->session().auto_end();
session->auto_end();
}
} // namespace view

2
DSView/pv/view/dsosignal.h
View File

@ -85,7 +85,7 @@ private:
static const uint16_t MS_RectHeight = 25;
public:
DsoSignal(DevInst* dev_inst, pv::data::Dso *data,
DsoSignal(pv::data::Dso *data,
sr_channel *probe);
virtual ~DsoSignal();

42
DSView/pv/view/header.cpp
View File

@ -40,7 +40,6 @@
#include "groupsignal.h"
#include "decodetrace.h"
#include "../sigsession.h"
#include "../device/devinst.h"
#include "../dsvdef.h"
@ -101,7 +100,8 @@ int Header::get_nameEditWidth()
pv::view::Trace* Header::get_mTrace(int &action, const QPoint &pt)
{
const int w = width();
const auto &traces = _view.get_traces(ALL_VIEW);
std::vector<Trace*> traces;
_view.get_traces(ALL_VIEW, traces);
for(auto &t : traces)
{
@ -124,7 +124,8 @@ void Header::paintEvent(QPaintEvent*)
style()->drawPrimitive(QStyle::PE_Widget, &o, &painter, this);
const int w = width();
const auto &traces = _view.get_traces(ALL_VIEW);
std::vector<Trace*> traces;
_view.get_traces(ALL_VIEW, traces);
const bool dragging = !_drag_traces.empty();
QColor fore(QWidget::palette().color(QWidget::foregroundRole()));
@ -143,7 +144,9 @@ void Header::mouseDoubleClickEvent(QMouseEvent *event)
{
assert(event);
const auto &traces = _view.get_traces(ALL_VIEW);
std::vector<Trace*> traces;
_view.get_traces(ALL_VIEW, traces);
if (event->button() & Qt::LeftButton) {
_mouse_down_point = event->pos();
@ -166,10 +169,12 @@ void Header::mousePressEvent(QMouseEvent *event)
{
assert(event);
const auto &traces = _view.get_traces(ALL_VIEW);
std::vector<Trace*> traces;
_view.get_traces(ALL_VIEW, traces);
int action;
const bool instant = _view.session().get_instant();
if (instant && _view.session().get_capture_state() == SigSession::Running) {
const bool instant = _view.session().is_instant();
if (instant && _view.session().is_running_status()) {
return;
}
@ -235,7 +240,8 @@ void Header::mouseReleaseEvent(QMouseEvent *event)
_view.signals_changed();
_view.set_all_update(true);
const auto &traces = _view.get_traces(ALL_VIEW);
std::vector<Trace*> traces;
_view.get_traces(ALL_VIEW, traces);
for(auto &t : traces){
t->select(false);
@ -287,7 +293,8 @@ void Header::wheelEvent(QWheelEvent *event)
if (isVertical)
{
const auto &traces = _view.get_traces(ALL_VIEW);
std::vector<Trace*> traces;
_view.get_traces(ALL_VIEW, traces);
// Vertical scrolling
double shift = 0;
@ -415,19 +422,6 @@ void Header::contextMenuEvent(QContextMenuEvent *event)
if (!t || !t->selected() || action != Trace::LABEL)
return;
/*
* disable group function for v0.97 temporarily
*/
// QMenu menu(this);
// if (t->get_type() == SR_CHANNEL_LOGIC)
// menu.addAction(_action_add_group);
// else if (t->get_type() == SR_CHANNEL_GROUP)
// menu.addAction(_action_del_group);
// _context_trace = t;
// menu.exec(event->globalPos());
// _context_trace.r-eset();
}
void Header::on_action_set_name_triggered()
@ -440,7 +434,9 @@ void Header::on_action_set_name_triggered()
context_Trace->set_name(nameEdit->text());
if (context_Trace->get_type() == SR_CHANNEL_LOGIC ||
context_Trace->get_type() == SR_CHANNEL_ANALOG)
sr_dev_probe_name_set(_view.session().get_device()->dev_inst(), context_Trace->get_index(), nameEdit->text().toUtf8().constData());
{
_view.session().get_device()->set_channel_name(context_Trace->get_index(), nameEdit->text().toUtf8());
}
}
nameEdit->hide();

1
DSView/pv/view/lissajoustrace.cpp
View File

@ -29,7 +29,6 @@
#include "../data/dso.h"
#include "../data/dsosnapshot.h"
#include "../sigsession.h"
#include "../device/devinst.h"
using namespace std;

Some files were not shown because too many files have changed in this diff Show More