test_sdk/hw/gtl_hw_device.cpp

 #include "gtl_hw_device.h"

namespace gtl
{
    namespace hw
    {
        device::device(QObject *parent)
            : QThread(parent)
//            ,  _default_iepe(false)
            , _is_created_success(true)
            , _rate(0)
            , _state(IDLE)
        {
            _uuid = QUuid::createUuid();

            _device = new gtl::device(NULL);
            connect(_device, &gtl::device::get_type, this, &device::type);

            connect(_device, &gtl::device::start, this, &device::start);
            connect(_device, &gtl::device::stop, this, &device::stop);
            connect(_device, &gtl::device::restart, this, &device::restart);

            connect(_device, &gtl::device::save_device, this, &device::save);
            connect(_device, &gtl::device::load_device, this, &device::load);
            connect(this, &device::received_data, _device, &gtl::device::recieved_data);

            connect(_device, &gtl::device::get_device_parameter, this, &device::get_parameter);
            connect(_device, &gtl::device::set_device_parameter, this, &device::set_parameter);

            connect(this, &QThread::started, _device, &gtl::device::started);
            connect(this, &QThread::finished, _device, &gtl::device::stopped);

        }

        device::~device()
        {
            stop();
            delete _device;
        }

        qreal device::rate() const
        {
            return _rate;
        }

        QString device::id() const
        {
            return _id;
        }

        analog_input *device::ai(int idx)
        {
            gtl::analog_data* input = _device->ai(idx);
            if(input == NULL)
                return NULL;

            return static_cast<analog_input*>(input);
        }

        gtl::device *device::gtl_device() const
        {
            return _device;
        }

        void device::set_config(const QJsonValue &config)
        {
            _config = config;

            emit config_changed();
        }

        const QJsonValue &device::config() const
        {
            return _config;
        }

        device::ADCState device::state() const
        {
            return _state;
        }

        void device::get_parameter(int idx, QVariant &value)
        {

        }

        void device::set_parameter(int /*idx*/, const QVariant &/*value*/)
        {

        }

        void device::clear_ai()
        {
            _device->clear();
        }

        void device::set_ai()
        {
            if(count_ai() != _device->count_ai())
            {
                clear_ai();

                for(int i = 0; i < count_ai(); i++)
                {
                    analog_input* ai_ = create_ai(i);
//                    ai_->set_iepe(_default_iepe);

                    connect(ai_, &analog_input::iepe_changed, this, &device::ai_iepe_changed);
                    connect(ai_, &analog_input::coupling_changed, this, &device::ai_coupling_changed);

                    _device->add_ai(ai_);
                }
            }

            for(int i = 0; i < _device->count_ai(); i++)
                _device->ai(i)->set_rate(_rate);
        }

        void device::set_ai_data(qreal *data, int size)
        {
            _device->lock_ai();

            for(int i = 0; i < _device->count_ai(); i++)
                ai(i)->set_data(data, size, i, _device->count_ai());

            _device->unlock_ai();
        }

        analog_input *device::create_ai(int idx)
        {
            return new analog_input(_rate, tr("intput") + " " + QString::number(idx), _device);
        }

        bool device::stop()
        {
            if(_is_continue)
            {
                _is_continue = false;
                wait();
            }
            return true;
        }

        void device::restart()
        {
//            if(!isRunning())
//                return;

            stop();

            start(_id, _rate);
        }

        void device::save(QDomElement &root_element)
        {
            root_element.setAttribute("type", type());
            root_element.setAttribute("id", _id);
            root_element.setAttribute("rate", _rate);
            root_element.setAttribute("is_running", isRunning());
            root_element.setAttribute("count_ai", _count_ai);
            root_element.setAttribute("uuid", _uuid.toString());
        }

        void device::load(const QDomElement &root_element)
        {
            _count_ai = root_element.attribute("count_ai", QString::number(_count_ai)).toInt();
            _uuid = QUuid::fromString(root_element.attribute("uuid", _uuid.toString()));
        }
    }
}