217 lines
5.0 KiB
C++
217 lines
5.0 KiB
C++
#include "gtl_analog_data.h"
|
|
|
|
#include "gtl_device.h"
|
|
|
|
namespace gtl
|
|
{
|
|
analog_data::analog_data(data_model_node *parent, bool is_hidden)
|
|
:data_model_node(types::analog, parent, is_hidden)
|
|
, _color(Qt::black)
|
|
{
|
|
|
|
}
|
|
|
|
analog_data::analog_data(analog_data *parent, bool is_hidden)
|
|
:data_model_node(types::analog, parent, is_hidden)
|
|
{
|
|
if(parent)
|
|
_rate = parent->get_rate();
|
|
else
|
|
_rate = 100000;
|
|
|
|
connect(parent, &analog_data::reference_changed, this, &analog_data::reference_changed);
|
|
}
|
|
|
|
analog_data::analog_data(qreal rate)
|
|
:data_model_node(types::analog, nullptr, true)
|
|
{
|
|
_rate = rate;
|
|
}
|
|
|
|
|
|
|
|
void analog_data::get_data(std::back_insert_iterator<std::vector<qreal> > data)
|
|
{
|
|
std::copy(begin(), end(), data);
|
|
}
|
|
|
|
void analog_data::set_data(iterator begin, iterator end)
|
|
{
|
|
|
|
if(!_history.empty())
|
|
{
|
|
int size = (int)std::distance(begin, end);
|
|
|
|
int idx = std::max<int>(0, size - (int)_history.size());
|
|
while(idx != size)
|
|
{
|
|
int copy_size = std::min<int>(size - idx, (int)_history.size() - _history_ptr);
|
|
|
|
std::copy(begin + idx, begin + idx + copy_size, _history.begin() + _history_ptr);
|
|
|
|
_history_ptr = (_history_ptr + copy_size) % _history.size();
|
|
idx += copy_size;
|
|
}
|
|
}
|
|
|
|
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());
|
|
}
|
|
|
|
for(auto iter_node : _hidden_children)
|
|
{
|
|
if(iter_node->type() != data_model_node::analog)
|
|
continue;
|
|
|
|
static_cast<analog_data*>(iter_node)->set_data(this->begin(), this->end());
|
|
}
|
|
}
|
|
|
|
void analog_data::set_rate(qreal value)
|
|
{
|
|
if(value != _rate)
|
|
{
|
|
|
|
foreach(data_model_node* child, _children)
|
|
{
|
|
if(child->type() == data_model_node::analog)
|
|
{
|
|
static_cast<analog_data*>(child)->set_rate(value);
|
|
}
|
|
}
|
|
_rate = value;
|
|
}
|
|
}
|
|
|
|
void analog_data::set_color(int value)
|
|
{
|
|
if(value != _color)
|
|
{
|
|
_color = value;
|
|
emit color_changed();
|
|
}
|
|
}
|
|
|
|
qreal analog_data::get_rate() const
|
|
{
|
|
return _rate;
|
|
}
|
|
|
|
void analog_data::lock_device()
|
|
{
|
|
data_model_node* root_node = root();
|
|
if(root_node == NULL)
|
|
return;
|
|
if(root_node->type() != data_model_node::device)
|
|
return;
|
|
|
|
static_cast<gtl::device*>(root_node)->lock_ai();
|
|
}
|
|
|
|
void analog_data::unlock_device()
|
|
{
|
|
data_model_node* root_node = root();
|
|
if(root_node == NULL)
|
|
return;
|
|
if(root_node->type() != data_model_node::device)
|
|
return;
|
|
|
|
static_cast<gtl::device*>(root_node)->unlock_ai();
|
|
}
|
|
|
|
int analog_data::color() const
|
|
{
|
|
return _color;
|
|
}
|
|
|
|
qreal analog_data::reference() const
|
|
{
|
|
if(parent_node())
|
|
{
|
|
if(parent_node()->type() == analog)
|
|
{
|
|
return static_cast<gtl::analog_data*>(parent_node())->reference();
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void analog_data::save(QDomElement &root_element)
|
|
{
|
|
data_model_node::save(root_element);
|
|
|
|
root_element.setAttribute("color", _color);
|
|
}
|
|
|
|
void analog_data::load(const QDomElement &root_element)
|
|
{
|
|
data_model_node::load(root_element);
|
|
|
|
_color = root_element.attribute("color", "0").toInt();
|
|
}
|
|
|
|
void analog_data::get_state(QJsonObject &root)
|
|
{
|
|
root["color"] = _color;
|
|
data_model_node::get_state(root);
|
|
}
|
|
|
|
analog_data* analog_data::analog_data_root()
|
|
{
|
|
data_model_node* node = this;
|
|
while(node->parent_node())
|
|
{
|
|
if(node->parent_node()->type() != analog)
|
|
break;
|
|
|
|
node = node->parent_node();
|
|
}
|
|
|
|
if(node->type() != analog)
|
|
return nullptr;
|
|
|
|
return static_cast<analog_data*>(node);
|
|
}
|
|
|
|
qreal analog_data::history() const
|
|
{
|
|
if(_rate == 0)
|
|
return 0;
|
|
|
|
return _history.size() / _rate;
|
|
}
|
|
|
|
void analog_data::set_history(qreal value)
|
|
{
|
|
if(_rate == 0)
|
|
return;
|
|
|
|
_history.resize(qRound(value*_rate));
|
|
std::fill(_history.begin(), _history.end(), 0);
|
|
_history_ptr = 0;
|
|
|
|
}
|
|
|
|
QJsonArray analog_data::getHistoryArray()
|
|
{
|
|
QJsonArray array;
|
|
for(int i = 0; i < _history.size(); i++)
|
|
array.append(_history[(_history_ptr + i)%_history.size()]);
|
|
|
|
return array;
|
|
}
|
|
|
|
bool analog_data::is_checkable() const
|
|
{
|
|
return true;
|
|
}
|
|
}
|