src/session.cpp

   1 /*
   2  * This file is part of the SmuView project.
   3  *
   4  * Copyright (C) 2017-2021 Frank Stettner <frank-stettner@gmx.net>
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <cassert>
  21 #include <list>
  22 #include <map>
  23 #include <memory>
  24 #include <string>
  25 #include <utility>
  26 #include <vector>
  27
  28 #include <QDebug>
  29
  30 #include "session.hpp"
  31 #include "config.h"
  32 #include "src/devicemanager.hpp"
  33 #include "src/util.hpp"
  34 #include "src/devices/basedevice.hpp"
  35 #include "src/devices/hardwaredevice.hpp"
  36 #include "src/devices/userdevice.hpp"
  37 #include "src/python/smuscriptrunner.hpp"
  38
  39 using std::list;
  40 using std::make_pair;
  41 using std::make_shared;
  42 using std::map;
  43 using std::shared_ptr;
  44 using std::string;
  45 using std::vector;
  46
  47 namespace sigrok {
  48 class Context;
  49 }
  50
  51 namespace sv {
  52
  53 shared_ptr<sigrok::Context> Session::sr_context;
  54 double Session::session_start_timestamp = .0;
  55
  56 Session::Session(DeviceManager &device_manager) :
  57         device_manager_(device_manager)
  58 {
  59         smu_script_runner_ = make_shared<python::SmuScriptRunner>(*this);
  60         connect(smu_script_runner_.get(), &python::SmuScriptRunner::script_error,
  61                 this, &Session::error_handler);
  62
  63         // Connect devices
  64         for (const auto &device : device_manager.user_spec_devices()) {
  65                 this->add_device(device);
  66         }
  67 }
  68
  69 Session::~Session()
  70 {
  71         for (auto &device_pair_ : device_map_)
  72                 device_pair_.second->close();
  73 }
  74
  75 DeviceManager &Session::device_manager()
  76 {
  77         return device_manager_;
  78 }
  79
  80 const DeviceManager &Session::device_manager() const
  81 {
  82         return device_manager_;
  83 }
  84
  85 map<string, shared_ptr<devices::BaseDevice>> Session::device_map() const
  86 {
  87         return device_map_;
  88 }
  89
  90 list<shared_ptr<devices::HardwareDevice>>
  91         Session::connect_device(const string &conn_string)
  92 {
  93         // Determine the driver name and options (in generic format).
  94         vector<string> driver_opts = sv::util::split_string(conn_string, ":");
  95         string driver_name = driver_opts.front();
  96         driver_opts.erase(driver_opts.begin());
  97
  98         // Scan for the specified driver, passing scan options.
  99         list<shared_ptr<devices::HardwareDevice>> devices =
 100                 device_manager_.driver_scan(driver_name, driver_opts);
 101
 102         for (const auto &device : devices)
 103                 add_device(device);
 104
 105         return devices;
 106 }
 107
 108 void Session::add_device(shared_ptr<devices::BaseDevice> device)
 109 {
 110         assert(device);
 111
 112         try {
 113                 device->open();
 114         }
 115         catch (const QString &e) {
 116                 qCritical() << e;
 117                 device.reset();
 118         }
 119
 120         connect(device.get(), &devices::BaseDevice::device_error,
 121                 this, &Session::error_handler);
 122
 123         device_map_.insert(make_pair(device->id(), device));
 124
 125         Q_EMIT device_added(device);
 126 }
 127
 128 shared_ptr<devices::UserDevice> Session::add_user_device()
 129 {
 130         string vendor = "SmuView";
 131         string model = "User Device";
 132         string version = SV_VERSION_STRING;
 133
 134         auto device = make_shared<devices::UserDevice>(
 135                 sr_context, vendor, model, version);
 136         this->add_device(device);
 137
 138         return device;
 139 }
 140
 141 void Session::remove_device(shared_ptr<devices::BaseDevice> device)
 142 {
 143         if (device) {
 144                 device->close();
 145
 146                 disconnect(device.get(), &devices::BaseDevice::device_error,
 147                         this, &Session::error_handler);
 148
 149                 device_map_.erase(device->id());
 150
 151                 Q_EMIT device_removed(device);
 152         }
 153 }
 154
 155
 156 shared_ptr<python::SmuScriptRunner> Session::smu_script_runner()
 157 {
 158         return smu_script_runner_;
 159 }
 160
 161 void Session::run_smu_script(const string &script_file)
 162 {
 163         smu_script_runner_->run(script_file);
 164 }
 165
 166 void Session::set_main_window(MainWindow *main_window)
 167 {
 168         main_window_ = main_window;
 169 }
 170
 171 MainWindow *Session::main_window() const
 172 {
 173         return main_window_;
 174 }
 175
 176 void Session::error_handler(const std::string &sender, const std::string &msg)
 177 {
 178         qCritical() << QString::fromStdString(sender) <<
 179                 " error: " << QString::fromStdString(msg);
 180 }
 181
 182 } // namespace sv