test_sdk/hw/gtl_analog_input.cpp

#include "gtl_analog_input.h"

namespace gtl
{

    namespace hw
    {

        analog_input::analog_input(qreal rate, QString name, gtl::device *parent)
            : gtl::analog_data(parent),
              _is_iepe(false),
              _is_coupling(false),
              _sensitivity(1),
              _gain(1),
              _offset(0),
              _is_inverting(false)
        {
            _name = name;
            _rate = rate;
            _reference = 1;
        }

        void analog_input::set_data(qreal *data, int size, int offset, int step)
        {
            clear();

            for(int i = offset; i < size; i+= step)
                push_back((_is_inverting ? -1 : 1)*data[i]/_sensitivity/_gain - _offset);

            gtl::analog_data::set_data(this->begin(), this->end());

/*
            emit data_changed();

            for(std::vector<data_model_node*>::iterator iter_node = _children.begin(); iter_node != _children.end(); iter_node++)
            {
                if((*iter_node)->type() != data_model_node::analog)
                    continue;

                static_cast<analog_data*>(*iter_node)->set_data(this->begin(), this->end());
            }
*/
        }

        void analog_input::set_iepe(bool value)
        {
            if(_is_iepe != value)
            {
                _is_iepe = value;

                emit iepe_changed();
            }
        }

        bool analog_input::is_iepe() const
        {
            return _is_iepe;
        }

        void analog_input::set_coupling(bool value)
        {
            if(_is_coupling != value)
            {
                _is_coupling = value;

                emit coupling_changed();
            }
        }

        bool analog_input::is_coupling() const
        {
            return _is_coupling;
        }

        void analog_input::set_sensitivity(qreal value)
        {
            _sensitivity = value;
        }

        qreal analog_input::sensitivity() const
        {
            return _sensitivity;
        }

        void analog_input::set_gain(qreal value)
        {
            _gain = value;
        }

        qreal analog_input::gain() const
        {
            return _gain;
        }

        void analog_input::set_offset(qreal value)
        {
            _offset = value;
        }

        bool analog_input::offset() const
        {
            return _offset;
        }

        void analog_input::set_inverting(bool value)
        {
            _is_inverting = value;
        }

        bool analog_input::is_inverting() const
        {
            return _is_inverting;
        }

        void analog_input::set_reference(qreal value)
        {
            if(value != _reference)
            {
                _reference = value;
                emit reference_changed();
            }
        }

        void analog_input::save(QDomElement &root_element)
        {
            root_element.setAttribute("sensitivity", _sensitivity);
            root_element.setAttribute("gain", _gain);
            root_element.setAttribute("offset", _offset);
            root_element.setAttribute("reference", _reference);
            root_element.setAttribute("is_inverting", _is_inverting);
            root_element.setAttribute("is_couping", _is_coupling);
            root_element.setAttribute("is_iepe", _is_iepe);

            gtl::analog_data::save(root_element);
        }

        void analog_input::load(const QDomElement &root_element)
        {
            _sensitivity = root_element.attribute("sensitivity", "1").toDouble();
            _gain = root_element.attribute("gain", "1").toDouble();
            _offset = root_element.attribute("offset", "0").toDouble();
            _reference = root_element.attribute("reference", "1").toDouble();
            _is_inverting = root_element.attribute("is_inverting", "0").toInt();
            _is_coupling = root_element.attribute("is_couping", "0").toInt();
            _is_iepe = root_element.attribute("is_iepe", "0").toInt();

            gtl::analog_data::load(root_element);
        }

        void analog_input::get_state(QJsonObject &root)
        {
            root["sensitivity"] = _sensitivity;
            root["gain"] = _gain;
            root["offset"] = _offset;
            root["reference"] = _reference;
            root["is_inverting"] = _is_inverting;
            root["is_couping"] = _is_coupling;
            root["is_iepe"] = _is_iepe;

            gtl::analog_data::get_state(root);
        }

        qreal analog_input::reference() const
        {
            return _reference;
        }
    }
}