rooty/LibrePilot
1
0
Fork 0
mirror of https://bitbucket.org/librepilot/librepilot.git synced 2024-11-29 07:24:13 +01:00
Code Issues Releases Activity

Preparatory commit before moving framework to a better location.

Browse Source
This commit is contained in:
zedamota 2012-02-05 14:41:23 +00:00
parent 427acee559
commit 32ebdb63a3
6 changed files with 837 additions and 406 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
ground/openpilotgcs/src/plugins/config/configstabilizationwidget.cpp
View File

@ -43,12 +43,12 @@ ConfigStabilizationWidget::ConfigStabilizationWidget(QWidget *parent) : ConfigTa
QList<int> * rateGroup=new QList<int>();
rateGroup->append(0);
addApplySaveButtons(m_stabilization->saveStabilizationToRAM,m_stabilization->saveStabilizationToSD);
addUAVObjectToWidgetRelation("StabilizationSettings","RollRatePID",m_stabilization->rateRollKp,"Kp",1,false,rateGroup);
addUAVObjectToWidgetRelation("StabilizationSettings","RollRatePID",m_stabilization->rateRollKp,"Kp",1,true,rateGroup);
addDefaultButton(m_stabilization->defaultButton,0);
addReloadButton(m_stabilization->reloadButton,0);
addWidgetToDefaultReloadGroups(m_stabilization->rateRollKp,rateGroup);
addShadowWidget("StabilizationSettings","RollRatePID",m_stabilization->rateRollKi,0,1,false,rateGroup);
addShadowWidget("StabilizationSettings","RollRatePID",m_stabilization->rateRollKi,0,1,true,rateGroup);
}

167
ground/openpilotgcs/src/plugins/config/configtaskwidget.cpp
View File

@ -29,7 +29,7 @@
#include "uavsettingsimportexport/uavsettingsimportexportfactory.h"
#include "configgadgetwidget.h"
ConfigTaskWidget::ConfigTaskWidget(QWidget *parent) : QWidget(parent),isConnected(false),smartsave(NULL),dirty(false)
ConfigTaskWidget::ConfigTaskWidget(QWidget *parent) : QWidget(parent),isConnected(false),smartsave(NULL),dirty(false),outOfLimitsStyle("background-color: rgb(255, 0, 0);")
{
pm = ExtensionSystem::PluginManager::instance();
objManager = pm->getObject<UAVObjectManager>();
@ -89,6 +89,7 @@ void ConfigTaskWidget::addUAVObjectToWidgetRelation(QString object, QString fiel
ow->widget=widget;
ow->index=index;
ow->scale=scale;
ow->isLimited=isLimited;
objOfInterest.append(ow);
if(obj)
{
@ -105,9 +106,10 @@ void ConfigTaskWidget::addUAVObjectToWidgetRelation(QString object, QString fiel
else
{
connectWidgetUpdatesToSlot(widget,SLOT(widgetsContentsChanged()));
if(defaultReloadGroups)
addWidgetToDefaultReloadGroups(widget,defaultReloadGroups);
shadowsList.insert(widget,ow);
if(defaultReloadGroups)
addWidgetToDefaultReloadGroups(widget,defaultReloadGroups);
shadowsList.insert(widget,ow);
loadWidgetLimits(widget,_field,index,isLimited,scale);
}
}
@ -181,8 +183,8 @@ void ConfigTaskWidget::populateWidgets()
{
// do nothing
}
else
setWidgetFromField(ow->widget,ow->field,ow->index,ow->scale);
else
setWidgetFromField(ow->widget,ow->field,ow->index,ow->scale,ow->isLimited);
}
setDirty(dirtyBack);
}
@ -198,7 +200,7 @@ void ConfigTaskWidget::refreshWidgetsValues()
}
else
{
setWidgetFromField(ow->widget,ow->field,ow->index,ow->scale);
setWidgetFromField(ow->widget,ow->field,ow->index,ow->scale,ow->isLimited);
}
}
@ -246,17 +248,21 @@ void ConfigTaskWidget::enableControls(bool enable)
void ConfigTaskWidget::widgetsContentsChanged()
{
float scale;
objectToWidget * oTw= shadowsList.value((QWidget*)sender(),NULL);
/*
qDebug()<<"sender:"<<(quint32)sender();
foreach(QWidget * w,shadowsList.keys())
qDebug()<<"in list:"<<(quint32)w;
objectToWidget * oTw= shadowsList.value((QWidget*)sender(),NULL);
if(oTw)
qDebug()<<"in oTw OK"<<(quint32)oTw->widget;
*/
if(oTw)
{
if(oTw->widget==(QWidget*)sender())
{
scale=oTw->scale;
checkWidgetsLimits((QWidget*)sender(),oTw->field,oTw->index,oTw->isLimited,getVariantFromWidget((QWidget*)sender(),oTw->scale),oTw->scale);
qDebug()<<"sender was master";
}
else
@ -266,16 +272,23 @@ void ConfigTaskWidget::widgetsContentsChanged()
if(sh->widget==(QWidget*)sender())
{
scale=sh->scale;
checkWidgetsLimits((QWidget*)sender(),oTw->field,oTw->index,sh->isLimited,getVariantFromWidget((QWidget*)sender(),scale),scale);
qDebug()<<"sender was shadow";
}
}
}
if(oTw->widget!=(QWidget *)sender())
{
checkWidgetsLimits(oTw->widget,oTw->field,oTw->index,oTw->isLimited,getVariantFromWidget((QWidget*)sender(),scale),oTw->scale);
setWidgetFromVariant(oTw->widget,getVariantFromWidget((QWidget*)sender(),scale),oTw->scale);
}
foreach (shadow * sh, oTw->shadowsList)
{
if(sh->widget!=(QWidget*)sender())
{
checkWidgetsLimits(sh->widget,oTw->field,oTw->index,sh->isLimited,getVariantFromWidget((QWidget*)sender(),scale),oTw->scale);
setWidgetFromVariant(sh->widget,getVariantFromWidget((QWidget*)sender(),scale),sh->scale);
}
}
}
setDirty(true);
@ -540,7 +553,7 @@ void ConfigTaskWidget::defaultButtonClicked()
if(!oTw->object)
continue;
UAVDataObject * temp=((UAVDataObject*)oTw->object)->dirtyClone();
setWidgetFromField(oTw->widget,temp->getField(oTw->field->getName()),oTw->index,oTw->scale);
setWidgetFromField(oTw->widget,temp->getField(oTw->field->getName()),oTw->index,oTw->scale,oTw->isLimited);
}
}
@ -568,7 +581,7 @@ void ConfigTaskWidget::reloadButtonClicked()
eventLoop->exec();
if(timeOut->isActive())
{
setWidgetFromField(oTw->widget,oTw->field,oTw->index,oTw->scale);
setWidgetFromField(oTw->widget,oTw->field,oTw->index,oTw->scale,oTw->isLimited);
}
timeOut->stop();
}
@ -614,7 +627,7 @@ void ConfigTaskWidget::connectWidgetUpdatesToSlot(QWidget * widget,const char* f
connect(cb,SIGNAL(clicked()),this,function);
}
else
qDebug()<<__FUNCTION__<<"widget to uavobject relation not implemented"<<widget->metaObject()->className();
qDebug()<<__FUNCTION__<<"widget to uavobject relation not implemented"<<widget->metaObject()->className();
}
@ -667,8 +680,8 @@ bool ConfigTaskWidget::setWidgetFromVariant(QWidget *widget, QVariant value, flo
{
if(QComboBox * cb=qobject_cast<QComboBox *>(widget))
{
cb->setCurrentIndex(cb->findText(value.toString()));
return true;
cb->setCurrentIndex(cb->findText(value.toString()));
return true;
}
else if(QLabel * cb=qobject_cast<QLabel *>(widget))
{
@ -699,16 +712,17 @@ bool ConfigTaskWidget::setWidgetFromVariant(QWidget *widget, QVariant value, flo
return false;
}
bool ConfigTaskWidget::setWidgetFromField(QWidget * widget,UAVObjectField * field,int index,float scale)
bool ConfigTaskWidget::setWidgetFromField(QWidget * widget,UAVObjectField * field,int index,float scale,bool hasLimits)
{
if(!widget || !field)
return false;
if(QComboBox * cb=qobject_cast<QComboBox *>(widget))
{
if(cb->count()==0)
cb->addItems(field->getOptions());
loadWidgetLimits(cb,field,index,hasLimits,scale);
}
QVariant var=field->getValue(index);
checkWidgetsLimits(widget,field,index,hasLimits,var,scale);
bool ret=setWidgetFromVariant(widget,var,scale);
if(ret)
return true;
@ -718,6 +732,129 @@ bool ConfigTaskWidget::setWidgetFromField(QWidget * widget,UAVObjectField * fiel
return false;
}
}
void ConfigTaskWidget::checkWidgetsLimits(QWidget * widget,UAVObjectField * field,int index,bool hasLimits, QVariant value, float scale)
{
if(!hasLimits)
return;
qDebug()<<"check widget"<<widget->accessibleName()<<"value"<<value.toString()<<"result"<<field->isWithinLimits(value,index);
if(!field->isWithinLimits(value,index))
{
if(!widget->property("styleBackup").isValid())
widget->setProperty("styleBackup",widget->styleSheet());
widget->setStyleSheet(outOfLimitsStyle);
widget->setProperty("wasOverLimits",(bool)true);
if(QComboBox * cb=qobject_cast<QComboBox *>(widget))
{
if(cb->findText(value.toString())==-1)
cb->addItem(value.toString());
}
else if(QDoubleSpinBox * cb=qobject_cast<QDoubleSpinBox *>(widget))
{
if(value.toDouble()/scale>cb->maximum())
{
cb->setMaximum(value.toDouble()/scale);
}
else if(value.toDouble()/scale<cb->minimum())
{
cb->setMinimum(value.toDouble()/scale);
}
}
else if(QSpinBox * cb=qobject_cast<QSpinBox *>(widget))
{
if(value.toInt()/scale>cb->maximum())
{
cb->setMaximum(value.toInt()/scale);
}
else if(value.toInt()/scale<cb->minimum())
{
cb->setMinimum(value.toInt()/scale);
}
}
else if(QSlider * cb=qobject_cast<QSlider *>(widget))
{
if(value.toInt()/scale>cb->maximum())
{
cb->setMaximum(value.toInt()/scale);
}
else if(value.toInt()/scale<cb->minimum())
{
cb->setMinimum(value.toInt()/scale);
}
}
}
else if(widget->property("wasOverLimits").isValid())
{
qDebug()<<"1wasOverLimits";
if(widget->property("wasOverLimits").toBool())
{
qDebug()<<"2";
widget->setProperty("wasOverLimits",(bool)false);
if(widget->property("styleBackup").isValid())
{
qDebug()<<"3";
QString style=widget->property("styleBackup").toString();
qDebug()<<"STYLE"<<style;
widget->setStyleSheet(style);
}
loadWidgetLimits(widget,field,index,hasLimits,scale);
}
}
}
void ConfigTaskWidget::loadWidgetLimits(QWidget * widget,UAVObjectField * field,int index,bool hasLimits,float scale)
{
if(QComboBox * cb=qobject_cast<QComboBox *>(widget))
{
cb->clear();
QStringList option=field->getOptions();
if(hasLimits)
{
foreach(QString str,option)
{
if(field->isWithinLimits(str,index))
cb->addItem(str);
}
}
else
cb->addItems(option);
}
if(!hasLimits)
return;
else if(QDoubleSpinBox * cb=qobject_cast<QDoubleSpinBox *>(widget))
{
if(field->getMaxLimit(index).isValid())
{
cb->setMaximum(field->getMaxLimit(index).toDouble()/scale);
}
if(field->getMinLimit(index).isValid())
{
cb->setMinimum(field->getMinLimit(index).toDouble()/scale);
}
}
else if(QSpinBox * cb=qobject_cast<QSpinBox *>(widget))
{
if(field->getMaxLimit(index).isValid())
{
cb->setMaximum((int)(field->getMaxLimit(index).toInt()/scale));
}
if(field->getMinLimit(index).isValid())
{
cb->setMinimum((int)(field->getMinLimit(index).toInt()/scale));
}
}
else if(QSlider * cb=qobject_cast<QSlider *>(widget))
{
if(field->getMaxLimit(index).isValid())
{
cb->setMaximum((int)(field->getMaxLimit(index).toInt()/scale));
}
if(field->getMinLimit(index).isValid())
{
cb->setMinimum((int)(field->getMinLimit(index).toInt()/scale));
}
}
}
/**
@}

7
ground/openpilotgcs/src/plugins/config/configtaskwidget.h
View File

@ -111,7 +111,6 @@ void addUAVObjectToWidgetRelation(QString object, QString field, QWidget *widget
bool allObjectsUpdated();
public slots:
void onAutopilotDisconnect();
void onAutopilotConnect();
@ -137,10 +136,12 @@ private:
QMap<QWidget *,objectToWidget*> shadowsList;
bool dirty;
bool setFieldFromWidget(QWidget *widget, UAVObjectField *field, int index, float scale);
bool setWidgetFromField(QWidget *widget, UAVObjectField *field, int index, float scale);
bool setWidgetFromField(QWidget *widget, UAVObjectField *field, int index, float scale, bool hasLimits);
QVariant getVariantFromWidget(QWidget *widget, float scale);
bool setWidgetFromVariant(QWidget *widget,QVariant value,float scale);
void connectWidgetUpdatesToSlot(QWidget *widget, const char *function);
void loadWidgetLimits(QWidget *widget, UAVObjectField *field, int index, bool hasLimits, float sclale);
QString outOfLimitsStyle;
protected slots:
virtual void disableObjUpdates();
virtual void enableObjUpdates();
@ -151,7 +152,7 @@ protected slots:
virtual void updateObjectsFromWidgets();
protected:
virtual void enableControls(bool enable);
void checkWidgetsLimits(QWidget *widget, UAVObjectField *field, int index, bool hasLimits, QVariant value, float scale);
};
#endif // CONFIGTASKWIDGET_H

6
ground/openpilotgcs/src/plugins/config/stabilization.ui
View File

@ -111,6 +111,12 @@
<string>Slowly raise Kp until you start seeing clear oscillations when you fly.
Then lower the value by 20% or so.</string>
</property>
<property name="autoFillBackground">
<bool>true</bool>
</property>
<property name="styleSheet">
<string notr="true"/>
</property>
<property name="decimals">
<number>6</number>
</property>

1052
ground/openpilotgcs/src/plugins/uavobjects/uavobjectfield.cpp
View File

@ -11,18 +11,18 @@
* @brief The UAVUObjects GCS plugin
*****************************************************************************/
/*
* 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 3 of the License, or
* 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 3 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
*
* 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.,
*
* 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.,
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "uavobjectfield.h"
@ -47,7 +47,7 @@ UAVObjectField::UAVObjectField(const QString& name, const QString& units, FieldT
constructorInitialize(name, units, type, elementNames, options,limits);
}
void UAVObjectField::constructorInitialize(const QString& name, const QString& units, FieldType type, const QStringList& elementNames, const QStringList& options,QString &limits)
void UAVObjectField::constructorInitialize(const QString& name, const QString& units, FieldType type, const QStringList& elementNames, const QStringList& options,const QString &limits)
{
// Copy params
this->name = name;
@ -62,39 +62,40 @@ void UAVObjectField::constructorInitialize(const QString& name, const QString& u
// Set field size
switch (type)
{
case INT8:
numBytesPerElement = sizeof(qint8);
break;
case INT16:
numBytesPerElement = sizeof(qint16);
break;
case INT32:
numBytesPerElement = sizeof(qint32);
break;
case UINT8:
numBytesPerElement = sizeof(quint8);
break;
case UINT16:
numBytesPerElement = sizeof(quint16);
break;
case UINT32:
numBytesPerElement = sizeof(quint32);
break;
case FLOAT32:
numBytesPerElement = sizeof(quint32);
break;
case ENUM:
numBytesPerElement = sizeof(quint8);
break;
case STRING:
numBytesPerElement = sizeof(quint8);
break;
default:
numBytesPerElement = 0;
case INT8:
numBytesPerElement = sizeof(qint8);
break;
case INT16:
numBytesPerElement = sizeof(qint16);
break;
case INT32:
numBytesPerElement = sizeof(qint32);
break;
case UINT8:
numBytesPerElement = sizeof(quint8);
break;
case UINT16:
numBytesPerElement = sizeof(quint16);
break;
case UINT32:
numBytesPerElement = sizeof(quint32);
break;
case FLOAT32:
numBytesPerElement = sizeof(quint32);
break;
case ENUM:
numBytesPerElement = sizeof(quint8);
break;
case STRING:
numBytesPerElement = sizeof(quint8);
break;
default:
numBytesPerElement = 0;
}
limitsInitialize(limits);
}
void UAVObjectField::limitsInitialize(QString &limits)
void UAVObjectField::limitsInitialize(const QString &limits)
{
/// format
/// (TY)->type (EQ-equal;NE-not equal;BE-between;BI-bigger;SM-smaller)
@ -102,6 +103,8 @@ void UAVObjectField::limitsInitialize(QString &limits)
/// %TY:VAL1:VAL2:VAL3,%TY,VAL1,VAL2,VAL3
/// example: first element bigger than 3 and second element inside [2.3,5]
/// "%0BI:3,%1BE:2.3:5"
if(limits.isEmpty())
return;
QStringList stringPerElement=limits.split(",");
foreach (QString str, stringPerElement) {
QStringList valuesPerElement=str.split(":");
@ -124,13 +127,293 @@ void UAVObjectField::limitsInitialize(QString &limits)
valuesPerElement.removeAt(0);
foreach(QString value,valuesPerElement)
{
lstruc.values.append(value);
switch (type)
{
case INT8:
case INT16:
case INT32:
case UINT8:
lstruc.values.append((quint32)value.toULong());
break;
case UINT16:
case UINT32:
lstruc.values.append((qint32)value.toLong());
break;
case FLOAT32:
lstruc.values.append((float)value.toFloat());
break;
case ENUM:
lstruc.values.append((QString)value);
break;
case STRING:
lstruc.values.append((QString)value);
break;
default:
lstruc.values.append(QVariant());
}
}
elementLimits.insert(index,lstruc);
}
else
qDebug()<<"limits parsing failed on UAVObjectField"<<name;
}
}
bool UAVObjectField::isWithinLimits(QVariant var,quint32 index)
{
if(!elementLimits.keys().contains(index))
return true;
LimitStruct struc=elementLimits.value(index);
switch(struc.type)
{
case EQUAL:
switch (type)
{
case INT8:
case INT16:
case INT32:
foreach (QVariant vars, struc.values) {
if(var.toInt()==vars.toInt())
return true;
}
return false;
break;
case UINT8:
case UINT16:
case UINT32:
foreach (QVariant vars, struc.values) {
if(var.toUInt()==vars.toUInt())
return true;
}
return false;
break;
case ENUM:
case STRING:
foreach (QVariant vars, struc.values) {
if(var.toString()==vars.toString())
return true;
}
return false;
break;
case FLOAT32:
foreach (QVariant vars, struc.values) {
if(var.toFloat()==vars.toFloat())
return true;
}
return false;
break;
default:
return true;
}
break;
case NOT_EQUAL:
switch (type)
{
case INT8:
case INT16:
case INT32:
foreach (QVariant vars, struc.values) {
if(var.toInt()==vars.toInt())
return false;
}
return true;
break;
case UINT8:
case UINT16:
case UINT32:
foreach (QVariant vars, struc.values) {
if(var.toUInt()==vars.toUInt())
return false;
}
return true;
break;
case ENUM:
case STRING:
foreach (QVariant vars, struc.values) {
if(var.toString()==vars.toString())
return false;
}
return true;
break;
case FLOAT32:
foreach (QVariant vars, struc.values) {
if(var.toFloat()==vars.toFloat())
return false;
}
return true;
break;
default:
return true;
}
break;
case BETWEEN:
if(struc.values.length()<2)
{
qDebug()<<__FUNCTION__<<"between limit with less than 1 pair, aborting; field:"<<name;
return true;
}
if(struc.values.length()>2)
qDebug()<<__FUNCTION__<<"between limit with more than 1 pair, using first; field"<<name;
switch (type)
{
case INT8:
case INT16:
case INT32:
if(!(var.toInt()>=struc.values.at(0).toInt() && var.toInt()<=struc.values.at(1).toInt()))
return false;
return true;
break;
case UINT8:
case UINT16:
case UINT32:
if(!(var.toUInt()>=struc.values.at(0).toUInt() && var.toUInt()<=struc.values.at(1).toUInt()))
return false;
return true;
break;
case ENUM:
if(!(options.indexOf(var.toString())>=options.indexOf(struc.values.at(0).toString()) && options.indexOf(var.toString())<=options.indexOf(struc.values.at(1).toString())))
return false;
return true;
break;
case STRING:
return true;
break;
case FLOAT32:
if(!(var.toFloat()>=struc.values.at(0).toFloat() && var.toFloat()<=struc.values.at(1).toFloat()))
return false;
return true;
break;
default:
return true;
}
break;
case BIGGER:
if(struc.values.length()<1)
{
qDebug()<<__FUNCTION__<<"BIGGER limit with less than 1 value, aborting; field:"<<name;
return true;
}
if(struc.values.length()>1)
qDebug()<<__FUNCTION__<<"BIGGER limit with more than 1 value, using first; field"<<name;
switch (type)
{
case INT8:
case INT16:
case INT32:
if(!(var.toInt()>=struc.values.at(0).toInt()))
return false;
return true;
break;
case UINT8:
case UINT16:
case UINT32:
if(!(var.toUInt()>=struc.values.at(0).toUInt()))
return false;
return true;
break;
case ENUM:
if(!(options.indexOf(var.toString())>=options.indexOf(struc.values.at(0).toString())))
return false;
return true;
break;
case STRING:
return true;
break;
case FLOAT32:
if(!(var.toFloat()>=struc.values.at(0).toFloat()))
return false;
return true;
break;
default:
return true;
}
break;
case SMALLER:
switch (type)
{
case INT8:
case INT16:
case INT32:
if(!(var.toInt()<=struc.values.at(0).toInt()))
return false;
return true;
break;
case UINT8:
case UINT16:
case UINT32:
if(!(var.toUInt()<=struc.values.at(0).toUInt()))
return false;
return true;
break;
case ENUM:
if(!(options.indexOf(var.toString())<=options.indexOf(struc.values.at(0).toString())))
return false;
return true;
break;
case STRING:
return true;
break;
case FLOAT32:
if(!(var.toFloat()<=struc.values.at(0).toFloat()))
return false;
return true;
break;
default:
return true;
}
}
return true;
}
QVariant UAVObjectField::getMaxLimit(quint32 index)
{
if(!elementLimits.keys().contains(index))
return QVariant();
LimitStruct struc=elementLimits.value(index);
switch(struc.type)
{
case EQUAL:
case NOT_EQUAL:
case BIGGER:
return QVariant();
break;
break;
case BETWEEN:
return struc.values.at(1);
break;
case SMALLER:
return struc.values.at(0);
break;
default:
return QVariant();
break;
}
return QVariant();
}
QVariant UAVObjectField::getMinLimit(quint32 index)
{
if(!elementLimits.keys().contains(index))
return QVariant();
LimitStruct struc=elementLimits.value(index);
switch(struc.type)
{
case EQUAL:
case NOT_EQUAL:
case SMALLER:
return QVariant();
break;
break;
case BETWEEN:
return struc.values.at(0);
break;
case BIGGER:
return struc.values.at(0);
break;
default:
return QVariant();
break;
}
return QVariant();
}
void UAVObjectField::initialize(quint8* data, quint32 dataOffset, UAVObject* obj)
{
this->data = data;
@ -148,26 +431,26 @@ QString UAVObjectField::getTypeAsString()
{
switch (type)
{
case UAVObjectField::INT8:
return "int8";
case UAVObjectField::INT16:
return "int16";
case UAVObjectField::INT32:
return "int32";
case UAVObjectField::UINT8:
return "uint8";
case UAVObjectField::UINT16:
return "uint16";
case UAVObjectField::UINT32:
return "uint32";
case UAVObjectField::FLOAT32:
return "float32";
case UAVObjectField::ENUM:
return "enum";
case UAVObjectField::STRING:
return "string";
default:
return "";
case UAVObjectField::INT8:
return "int8";
case UAVObjectField::INT16:
return "int16";
case UAVObjectField::INT32:
return "int32";
case UAVObjectField::UINT8:
return "uint8";
case UAVObjectField::UINT16:
return "uint16";
case UAVObjectField::UINT32:
return "uint32";
case UAVObjectField::FLOAT32:
return "float32";
case UAVObjectField::ENUM:
return "enum";
case UAVObjectField::STRING:
return "string";
default:
return "";
}
}
@ -236,64 +519,64 @@ qint32 UAVObjectField::pack(quint8* dataOut)
// Pack each element in output buffer
switch (type)
{
case INT8:
memcpy(dataOut, &data[offset], numElements);
break;
case INT16:
for (quint32 index = 0; index < numElements; ++index)
{
qint16 value;
memcpy(&value, &data[offset + numBytesPerElement*index], numBytesPerElement);
qToLittleEndian<qint16>(value, &dataOut[numBytesPerElement*index]);
}
break;
case INT32:
for (quint32 index = 0; index < numElements; ++index)
{
qint32 value;
memcpy(&value, &data[offset + numBytesPerElement*index], numBytesPerElement);
qToLittleEndian<qint32>(value, &dataOut[numBytesPerElement*index]);
}
break;
case UINT8:
for (quint32 index = 0; index < numElements; ++index)
{
dataOut[numBytesPerElement*index] = data[offset + numBytesPerElement*index];
}
break;
case UINT16:
for (quint32 index = 0; index < numElements; ++index)
{
quint16 value;
memcpy(&value, &data[offset + numBytesPerElement*index], numBytesPerElement);
qToLittleEndian<quint16>(value, &dataOut[numBytesPerElement*index]);
}
break;
case UINT32:
for (quint32 index = 0; index < numElements; ++index)
{
quint32 value;
memcpy(&value, &data[offset + numBytesPerElement*index], numBytesPerElement);
qToLittleEndian<quint32>(value, &dataOut[numBytesPerElement*index]);
}
break;
case FLOAT32:
for (quint32 index = 0; index < numElements; ++index)
{
quint32 value;
memcpy(&value, &data[offset + numBytesPerElement*index], numBytesPerElement);
qToLittleEndian<quint32>(value, &dataOut[numBytesPerElement*index]);
}
break;
case ENUM:
for (quint32 index = 0; index < numElements; ++index)
{
dataOut[numBytesPerElement*index] = data[offset + numBytesPerElement*index];
}
break;
case STRING:
memcpy(dataOut, &data[offset], numElements);
break;
case INT8:
memcpy(dataOut, &data[offset], numElements);
break;
case INT16:
for (quint32 index = 0; index < numElements; ++index)
{
qint16 value;
memcpy(&value, &data[offset + numBytesPerElement*index], numBytesPerElement);
qToLittleEndian<qint16>(value, &dataOut[numBytesPerElement*index]);
}
break;
case INT32:
for (quint32 index = 0; index < numElements; ++index)
{
qint32 value;
memcpy(&value, &data[offset + numBytesPerElement*index], numBytesPerElement);
qToLittleEndian<qint32>(value, &dataOut[numBytesPerElement*index]);
}
break;
case UINT8:
for (quint32 index = 0; index < numElements; ++index)
{
dataOut[numBytesPerElement*index] = data[offset + numBytesPerElement*index];
}
break;
case UINT16:
for (quint32 index = 0; index < numElements; ++index)
{
quint16 value;
memcpy(&value, &data[offset + numBytesPerElement*index], numBytesPerElement);
qToLittleEndian<quint16>(value, &dataOut[numBytesPerElement*index]);
}
break;
case UINT32:
for (quint32 index = 0; index < numElements; ++index)
{
quint32 value;
memcpy(&value, &data[offset + numBytesPerElement*index], numBytesPerElement);
qToLittleEndian<quint32>(value, &dataOut[numBytesPerElement*index]);
}
break;
case FLOAT32:
for (quint32 index = 0; index < numElements; ++index)
{
quint32 value;
memcpy(&value, &data[offset + numBytesPerElement*index], numBytesPerElement);
qToLittleEndian<quint32>(value, &dataOut[numBytesPerElement*index]);
}
break;
case ENUM:
for (quint32 index = 0; index < numElements; ++index)
{
dataOut[numBytesPerElement*index] = data[offset + numBytesPerElement*index];
}
break;
case STRING:
memcpy(dataOut, &data[offset], numElements);
break;
}
// Done
return getNumBytes();
@ -305,64 +588,64 @@ qint32 UAVObjectField::unpack(const quint8* dataIn)
// Unpack each element from input buffer
switch (type)
{
case INT8:
memcpy(&data[offset], dataIn, numElements);
break;
case INT16:
for (quint32 index = 0; index < numElements; ++index)
{
qint16 value;
value = qFromLittleEndian<qint16>(&dataIn[numBytesPerElement*index]);
memcpy(&data[offset + numBytesPerElement*index], &value, numBytesPerElement);
}
break;
case INT32:
for (quint32 index = 0; index < numElements; ++index)
{
qint32 value;
value = qFromLittleEndian<qint32>(&dataIn[numBytesPerElement*index]);
memcpy(&data[offset + numBytesPerElement*index], &value, numBytesPerElement);
}
break;
case UINT8:
for (quint32 index = 0; index < numElements; ++index)
{
data[offset + numBytesPerElement*index] = dataIn[numBytesPerElement*index];
}
break;
case UINT16:
for (quint32 index = 0; index < numElements; ++index)
{
quint16 value;
value = qFromLittleEndian<quint16>(&dataIn[numBytesPerElement*index]);
memcpy(&data[offset + numBytesPerElement*index], &value, numBytesPerElement);
}
break;
case UINT32:
for (quint32 index = 0; index < numElements; ++index)
{
quint32 value;
value = qFromLittleEndian<quint32>(&dataIn[numBytesPerElement*index]);
memcpy(&data[offset + numBytesPerElement*index], &value, numBytesPerElement);
}
break;
case FLOAT32:
for (quint32 index = 0; index < numElements; ++index)
{
quint32 value;
value = qFromLittleEndian<quint32>(&dataIn[numBytesPerElement*index]);
memcpy(&data[offset + numBytesPerElement*index], &value, numBytesPerElement);
}
break;
case ENUM:
for (quint32 index = 0; index < numElements; ++index)
{
data[offset + numBytesPerElement*index] = dataIn[numBytesPerElement*index];
}
break;
case STRING:
memcpy(&data[offset], dataIn, numElements);
break;
case INT8:
memcpy(&data[offset], dataIn, numElements);
break;
case INT16:
for (quint32 index = 0; index < numElements; ++index)
{
qint16 value;
value = qFromLittleEndian<qint16>(&dataIn[numBytesPerElement*index]);
memcpy(&data[offset + numBytesPerElement*index], &value, numBytesPerElement);
}
break;
case INT32:
for (quint32 index = 0; index < numElements; ++index)
{
qint32 value;
value = qFromLittleEndian<qint32>(&dataIn[numBytesPerElement*index]);
memcpy(&data[offset + numBytesPerElement*index], &value, numBytesPerElement);
}
break;
case UINT8:
for (quint32 index = 0; index < numElements; ++index)
{
data[offset + numBytesPerElement*index] = dataIn[numBytesPerElement*index];
}
break;
case UINT16:
for (quint32 index = 0; index < numElements; ++index)
{
quint16 value;
value = qFromLittleEndian<quint16>(&dataIn[numBytesPerElement*index]);
memcpy(&data[offset + numBytesPerElement*index], &value, numBytesPerElement);
}
break;
case UINT32:
for (quint32 index = 0; index < numElements; ++index)
{
quint32 value;
value = qFromLittleEndian<quint32>(&dataIn[numBytesPerElement*index]);
memcpy(&data[offset + numBytesPerElement*index], &value, numBytesPerElement);
}
break;
case FLOAT32:
for (quint32 index = 0; index < numElements; ++index)
{
quint32 value;
value = qFromLittleEndian<quint32>(&dataIn[numBytesPerElement*index]);
memcpy(&data[offset + numBytesPerElement*index], &value, numBytesPerElement);
}
break;
case ENUM:
for (quint32 index = 0; index < numElements; ++index)
{
data[offset + numBytesPerElement*index] = dataIn[numBytesPerElement*index];
}
break;
case STRING:
memcpy(&data[offset], dataIn, numElements);
break;
}
// Done
return getNumBytes();
@ -377,35 +660,35 @@ bool UAVObjectField::isNumeric()
{
switch (type)
{
case INT8:
return true;
break;
case INT16:
return true;
break;
case INT32:
return true;
break;
case UINT8:
return true;
break;
case UINT16:
return true;
break;
case UINT32:
return true;
break;
case FLOAT32:
return true;
break;
case ENUM:
return false;
break;
case STRING:
return false;
break;
default:
return false;
case INT8:
return true;
break;
case INT16:
return true;
break;
case INT32:
return true;
break;
case UINT8:
return true;
break;
case UINT16:
return true;
break;
case UINT32:
return true;
break;
case FLOAT32:
return true;
break;
case ENUM:
return false;
break;
case STRING:
return false;
break;
default:
return false;
}
}
@ -413,35 +696,35 @@ bool UAVObjectField::isText()
{
switch (type)
{
case INT8:
return false;
break;
case INT16:
return false;
break;
case INT32:
return false;
break;
case UINT8:
return false;
break;
case UINT16:
return false;
break;
case UINT32:
return false;
break;
case FLOAT32:
return false;
break;
case ENUM:
return true;
break;
case STRING:
return true;
break;
default:
return false;
case INT8:
return false;
break;
case INT16:
return false;
break;
case INT32:
return false;
break;
case UINT8:
return false;
break;
case UINT16:
return false;
break;
case UINT32:
return false;
break;
case FLOAT32:
return false;
break;
case ENUM:
return true;
break;
case STRING:
return true;
break;
default:
return false;
}
}
@ -456,74 +739,74 @@ QVariant UAVObjectField::getValue(quint32 index)
// Get value
switch (type)
{
case INT8:
{
qint8 tmpint8;
memcpy(&tmpint8, &data[offset + numBytesPerElement*index], numBytesPerElement);
return QVariant(tmpint8);
break;
}
case INT16:
{
qint16 tmpint16;
memcpy(&tmpint16, &data[offset + numBytesPerElement*index], numBytesPerElement);
return QVariant(tmpint16);
break;
}
case INT32:
{
qint32 tmpint32;
memcpy(&tmpint32, &data[offset + numBytesPerElement*index], numBytesPerElement);
return QVariant(tmpint32);
break;
}
case UINT8:
{
quint8 tmpuint8;
memcpy(&tmpuint8, &data[offset + numBytesPerElement*index], numBytesPerElement);
return QVariant(tmpuint8);
break;
}
case UINT16:
{
quint16 tmpuint16;
memcpy(&tmpuint16, &data[offset + numBytesPerElement*index], numBytesPerElement);
return QVariant(tmpuint16);
break;
}
case UINT32:
{
quint32 tmpuint32;
memcpy(&tmpuint32, &data[offset + numBytesPerElement*index], numBytesPerElement);
return QVariant(tmpuint32);
break;
}
case FLOAT32:
{
float tmpfloat;
memcpy(&tmpfloat, &data[offset + numBytesPerElement*index], numBytesPerElement);
return QVariant(tmpfloat);
break;
}
case ENUM:
{
quint8 tmpenum;
memcpy(&tmpenum, &data[offset + numBytesPerElement*index], numBytesPerElement);
// Q_ASSERT((tmpenum < options.length()) && (tmpenum >= 0)); // catch bad enum settings
if(tmpenum >= options.length()) {
qDebug() << "Invalid value for" << name;
return QVariant( QString("Bad Value") );
}
return QVariant( options[tmpenum] );
break;
}
case STRING:
{
data[offset + numElements - 1] = '\0';
QString str((char*)&data[offset]);
return QVariant( str );
break;
case INT8:
{
qint8 tmpint8;
memcpy(&tmpint8, &data[offset + numBytesPerElement*index], numBytesPerElement);
return QVariant(tmpint8);
break;
}
case INT16:
{
qint16 tmpint16;
memcpy(&tmpint16, &data[offset + numBytesPerElement*index], numBytesPerElement);
return QVariant(tmpint16);
break;
}
case INT32:
{
qint32 tmpint32;
memcpy(&tmpint32, &data[offset + numBytesPerElement*index], numBytesPerElement);
return QVariant(tmpint32);
break;
}
case UINT8:
{
quint8 tmpuint8;
memcpy(&tmpuint8, &data[offset + numBytesPerElement*index], numBytesPerElement);
return QVariant(tmpuint8);
break;
}
case UINT16:
{
quint16 tmpuint16;
memcpy(&tmpuint16, &data[offset + numBytesPerElement*index], numBytesPerElement);
return QVariant(tmpuint16);
break;
}
case UINT32:
{
quint32 tmpuint32;
memcpy(&tmpuint32, &data[offset + numBytesPerElement*index], numBytesPerElement);
return QVariant(tmpuint32);
break;
}
case FLOAT32:
{
float tmpfloat;
memcpy(&tmpfloat, &data[offset + numBytesPerElement*index], numBytesPerElement);
return QVariant(tmpfloat);
break;
}
case ENUM:
{
quint8 tmpenum;
memcpy(&tmpenum, &data[offset + numBytesPerElement*index], numBytesPerElement);
// Q_ASSERT((tmpenum < options.length()) && (tmpenum >= 0)); // catch bad enum settings
if(tmpenum >= options.length()) {
qDebug() << "Invalid value for" << name;
return QVariant( QString("Bad Value") );
}
return QVariant( options[tmpenum] );
break;
}
case STRING:
{
data[offset + numElements - 1] = '\0';
QString str((char*)&data[offset]);
return QVariant( str );
break;
}
}
// If this point is reached then we got an invalid type
return QVariant();
@ -536,7 +819,7 @@ bool UAVObjectField::checkValue(const QVariant& value, quint32 index)
if ( index >= numElements )
{
return false;
}
}
// Get metadata
UAVObject::Metadata mdata = obj->getMetadata();
// Update value if the access mode permits
@ -544,28 +827,29 @@ bool UAVObjectField::checkValue(const QVariant& value, quint32 index)
{
switch (type)
{
case INT8:
case INT16:
case INT32:
case UINT8:
case UINT16:
case UINT32:
case FLOAT32:
case STRING:
return true;
break;
case ENUM:
{
qint8 tmpenum = options.indexOf( value.toString() );
return ((tmpenum < 0) ? false : true);
break;
}
default:
qDebug() << "checkValue: other types" << type;
Q_ASSERT(0); // To catch any programming errors where we tried to test invalid values
break;
case INT8:
case INT16:
case INT32:
case UINT8:
case UINT16:
case UINT32:
case FLOAT32:
case STRING:
return true;
break;
case ENUM:
{
qint8 tmpenum = options.indexOf( value.toString() );
return ((tmpenum < 0) ? false : true);
break;
}
default:
qDebug() << "checkValue: other types" << type;
Q_ASSERT(0); // To catch any programming errors where we tried to test invalid values
break;
}
}
return true;
}
void UAVObjectField::setValue(const QVariant& value, quint32 index)
@ -575,7 +859,7 @@ void UAVObjectField::setValue(const QVariant& value, quint32 index)
if ( index >= numElements )
{
return;
}
}
// Get metadata
UAVObject::Metadata mdata = obj->getMetadata();
// Update value if the access mode permits
@ -583,67 +867,67 @@ void UAVObjectField::setValue(const QVariant& value, quint32 index)
{
switch (type)
{
case INT8:
case INT8:
{
qint8 tmpint8 = value.toInt();
memcpy(&data[offset + numBytesPerElement*index], &tmpint8, numBytesPerElement);
break;
}
case INT16:
{
qint16 tmpint16 = value.toInt();
memcpy(&data[offset + numBytesPerElement*index], &tmpint16, numBytesPerElement);
break;
}
case INT32:
{
qint32 tmpint32 = value.toInt();
memcpy(&data[offset + numBytesPerElement*index], &tmpint32, numBytesPerElement);
break;
}
case UINT8:
{
quint8 tmpuint8 = value.toUInt();
memcpy(&data[offset + numBytesPerElement*index], &tmpuint8, numBytesPerElement);
break;
}
case UINT16:
{
quint16 tmpuint16 = value.toUInt();
memcpy(&data[offset + numBytesPerElement*index], &tmpuint16, numBytesPerElement);
break;
}
case UINT32:
{
quint32 tmpuint32 = value.toUInt();
memcpy(&data[offset + numBytesPerElement*index], &tmpuint32, numBytesPerElement);
break;
}
case FLOAT32:
{
float tmpfloat = value.toFloat();
memcpy(&data[offset + numBytesPerElement*index], &tmpfloat, numBytesPerElement);
break;
}
case ENUM:
{
qint8 tmpenum = options.indexOf( value.toString() );
Q_ASSERT(tmpenum >= 0); // To catch any programming errors where we set invalid values
memcpy(&data[offset + numBytesPerElement*index], &tmpenum, numBytesPerElement);
break;
}
case STRING:
{
QString str = value.toString();
QByteArray barray = str.toAscii();
quint32 index;
for (index = 0; index < (quint32)barray.length() && index < (numElements-1); ++index)
{
qint8 tmpint8 = value.toInt();
memcpy(&data[offset + numBytesPerElement*index], &tmpint8, numBytesPerElement);
break;
}
case INT16:
{
qint16 tmpint16 = value.toInt();
memcpy(&data[offset + numBytesPerElement*index], &tmpint16, numBytesPerElement);
break;
}
case INT32:
{
qint32 tmpint32 = value.toInt();
memcpy(&data[offset + numBytesPerElement*index], &tmpint32, numBytesPerElement);
break;
}
case UINT8:
{
quint8 tmpuint8 = value.toUInt();
memcpy(&data[offset + numBytesPerElement*index], &tmpuint8, numBytesPerElement);
break;
}
case UINT16:
{
quint16 tmpuint16 = value.toUInt();
memcpy(&data[offset + numBytesPerElement*index], &tmpuint16, numBytesPerElement);
break;
}
case UINT32:
{
quint32 tmpuint32 = value.toUInt();
memcpy(&data[offset + numBytesPerElement*index], &tmpuint32, numBytesPerElement);
break;
}
case FLOAT32:
{
float tmpfloat = value.toFloat();
memcpy(&data[offset + numBytesPerElement*index], &tmpfloat, numBytesPerElement);
break;
}
case ENUM:
{
qint8 tmpenum = options.indexOf( value.toString() );
Q_ASSERT(tmpenum >= 0); // To catch any programming errors where we set invalid values
memcpy(&data[offset + numBytesPerElement*index], &tmpenum, numBytesPerElement);
break;
}
case STRING:
{
QString str = value.toString();
QByteArray barray = str.toAscii();
quint32 index;
for (index = 0; index < (quint32)barray.length() && index < (numElements-1); ++index)
{
data[offset+index] = barray[index];
}
barray[index] = '\0';
break;
data[offset+index] = barray[index];
}
barray[index] = '\0';
break;
}
}
}
}

7
ground/openpilotgcs/src/plugins/uavobjects/uavobjectfield.h
View File

@ -75,6 +75,9 @@ public:
bool isText();
QString toString();
bool isWithinLimits(QVariant var, quint32 index);
QVariant getMaxLimit(quint32 index);
QVariant getMinLimit(quint32 index);
signals:
void fieldUpdated(UAVObjectField* field);
@ -91,8 +94,8 @@ protected:
UAVObject* obj;
QMap<quint32,LimitStruct> elementLimits;
void clear();
void constructorInitialize(const QString& name, const QString& units, FieldType type, const QStringList& elementNames, const QStringList& options, QString &limits);
void limitsInitialize(QString &limits);
void constructorInitialize(const QString& name, const QString& units, FieldType type, const QStringList& elementNames, const QStringList& options, const QString &limits);
void limitsInitialize(const QString &limits);
};