b

App/Setting/Index1/ParameterInspector/ParameterInspector.cpp

@@ -771,7 +771,7 @@ void ParameterInspector::on_pushButton_Load_clicked()
 
 void ParameterInspector::ParamsEncode(QString fileName)
 {
-    QString Vehicle_Id;
+    QString Vehicle_Id = 1;
 
     QByteArray ParamsString;
 
@@ -793,6 +793,7 @@ void ParameterInspector::ParamsEncode(QString fileName)
     {
        if(ui->treeWidget->topLevelItem(i)->text(0) == ui->pushButton_system->text())
        {
+           Vehicle_Id = ui->treeWidget->topLevelItem(i)->text(0);
           p = ui->treeWidget->topLevelItem(i);
           //break;
        }
@@ -806,7 +807,7 @@ void ParameterInspector::ParamsEncode(QString fileName)
     {
        QTreeWidgetItem *childItem = p->child(i);
 
-       ParamsString.append("1\t");
+       ParamsString.append(Vehicle_Id +  "\t");
        ParamsString.append("1\t");
        ParamsString.append(childItem->text(0) + "\t");
        ParamsString.append(childItem->text(1) + "\t");

App/ToolsUI/ToolsUI.ui

@@ -6,8 +6,8 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>396</width>
+    <width>663</width>
-    <height>426</height>
+    <height>414</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -40,7 +40,7 @@
         <x>0</x>
         <y>0</y>
         <width>198</width>
-        <height>380</height>
+        <height>368</height>
        </rect>
       </property>
       <layout class="QGridLayout" name="gridLayout_3">

MavLinkNode/parameterprocess.cpp

@@ -418,11 +418,6 @@ void ParameterProcess::ext_value(float value)
 
     Q_UNUSED(value);
 
-    //param_ext_value.param_value = value;
-
-
-    //param_ext_value.target_system = sysid;
-    //param_ext_value.target_component = compid;
 
     mavlink_msg_param_ext_value_encode(Current_sysID,Current_CompID, &msg,&param_ext_value);
     Send(msg);
@@ -457,8 +452,275 @@ void ParameterProcess::request_read(const char *id, int16_t index)//
 
 
 
-
+//================================
-
+
+QVariant ParameterProcess::set_value(mavlink_param_value_t param)
+{
+        QVariant value;
+
+        switch (param.param_type)
+        {
+        case MAV_PARAM_TYPE_UINT8:
+        {
+            value = ((uint8_t *)&param.param_value)[0];
+        }break;
+        case MAV_PARAM_TYPE_INT8:
+        {
+            value = ((int8_t *)&param.param_value)[0];
+        }break;
+        case MAV_PARAM_TYPE_UINT16:
+        {
+            value = ((uint16_t *)&param.param_value)[0];
+        }break;
+        case MAV_PARAM_TYPE_INT16:
+        {
+            value = ((int16_t *)&param.param_value)[0];
+        }break;
+        case MAV_PARAM_TYPE_UINT32:
+        {
+            value = ((uint32_t *)&param.param_value)[0];
+        }break;
+        case MAV_PARAM_TYPE_INT32:
+        {
+            value = ((int32_t *)&param.param_value)[0];
+        }break;
+        case MAV_PARAM_TYPE_UINT64:
+        {
+            value = ((uint64_t *)&param.param_value)[0];
+        }break;
+        case MAV_PARAM_TYPE_INT64:
+        {
+            value = ((int64_t *)&param.param_value)[0];
+        }break;
+        case MAV_PARAM_TYPE_REAL32:
+        {
+            value = ((float *)&param.param_value)[0];
+        }break;
+        case MAV_PARAM_TYPE_REAL64:
+        {
+            value = ((double *)&param.param_value)[0];
+        }break;
+         default:
+        {
+            value = ((float *)&param.param_value)[0];
+        }break;
+
+        }
+
+        return value;
+}
+
+float ParameterProcess::get_value(QVariant param,uint8_t type)
+{
+        float value;
+        union {
+            uint8_t   u8[8];
+            int8_t    i8[8];
+            uint16_t  u16[4];
+            int16_t   i16[4];
+            uint32_t  u32[2];
+            int32_t   i32[2];
+            uint64_t  u64;
+            int64_t   i64;
+            float     f[2];
+            double    d;
+        }src;
+
+        switch (type)
+        {
+        case MAV_PARAM_TYPE_UINT8:
+        {
+            src.u8[0] =  param.toUInt();
+            ((uint8_t *)&value)[0] = src.u8[0];
+
+        }break;
+        case MAV_PARAM_TYPE_INT8:
+        {
+            src.i8[0] =  param.toUInt();
+            ((int8_t *)&value)[0] = src.i8[0];
+        }break;
+        case MAV_PARAM_TYPE_UINT16:
+        {
+            src.u16[0] =  param.toUInt();
+            ((uint16_t *)&value)[0] = src.u16[0];
+        }break;
+        case MAV_PARAM_TYPE_INT16:
+        {
+            src.i16[0] =  param.toUInt();
+            ((int16_t *)&value)[0] = src.i16[0];
+        }break;
+        case MAV_PARAM_TYPE_UINT32:
+        {
+            src.u32[0] =  param.toUInt();
+            ((uint32_t *)&value)[0] = (uint32_t)src.u32[0];
+        }break;
+        case MAV_PARAM_TYPE_INT32:
+        {
+            src.i32[0] =  param.toUInt();
+            ((int32_t *)&value)[0] = (int32_t)src.i32[0];
+        }break;
+        case MAV_PARAM_TYPE_UINT64:
+        {
+            src.u64 =  param.toUInt();
+            ((uint64_t *)&value)[0] = (uint64_t )src.u64;
+        }break;
+        case MAV_PARAM_TYPE_INT64:
+        {
+            src.i64 =  param.toUInt();
+            ((int64_t *)&value)[0] = (int64_t)src.i64;
+        }break;
+        case MAV_PARAM_TYPE_REAL32:
+        {
+            src.f[0] =  param.toFloat();
+            ((float *)&value)[0] = (float)src.f[0];
+        }break;
+        case MAV_PARAM_TYPE_REAL64:
+        {
+            src.d =  param.toDouble();
+            ((double *)&value)[0]= (double)src.d;
+        }break;
+         default:
+        {
+            src.f[0] =  param.toFloat();
+            ((float *)&value)[0] = (float)src.i32[0];
+        }break;
+
+        }
+
+        return value;
+}
+
+
+QVariant ParameterProcess::set_type(mavlink_param_value_t param)
+{
+        QVariant value;
+
+        switch (param.param_type)
+        {
+            case MAV_PARAM_TYPE_UINT8:
+            {
+                value = "uint8";
+            }break;
+            case MAV_PARAM_TYPE_INT8:
+            {
+                value = "int8";
+            }break;
+            case MAV_PARAM_TYPE_UINT16:
+            {
+                value = "uint16";
+            }break;
+            case MAV_PARAM_TYPE_INT16:
+            {
+                value = "int16";
+            }break;
+            case MAV_PARAM_TYPE_UINT32:
+            {
+                value = "uint32";
+            }break;
+            case MAV_PARAM_TYPE_INT32:
+            {
+                value = "int32";
+            }break;
+            case MAV_PARAM_TYPE_UINT64:
+            {
+                value = "uint64";
+            }break;
+            case MAV_PARAM_TYPE_INT64:
+            {
+                value = "int64";
+            }break;
+            case MAV_PARAM_TYPE_REAL32:
+            {
+                value = "float";
+            }break;
+            case MAV_PARAM_TYPE_REAL64:
+            {
+                value = "double";
+            }break;
+             default:
+            {
+                value = "unknow";
+            }break;
+
+        }
+
+        return value;
+}
+
+uint8_t ParameterProcess::get_type(QVariant type)
+{
+        uint8_t value = 0;
+
+        if(type.toString() == "uint8")
+        {
+            value = MAV_PARAM_TYPE_UINT8;
+        }
+        else if(type.toString() == "int8")
+        {
+            value = MAV_PARAM_TYPE_INT8;
+        }
+        else if(type.toString() == "uint16")
+        {
+            value = MAV_PARAM_TYPE_UINT16;
+        }
+        else if(type.toString() == "int16")
+        {
+            value = MAV_PARAM_TYPE_INT16;
+        }
+        else if(type.toString() == "uint32")
+        {
+            value = MAV_PARAM_TYPE_UINT32;
+        }
+        else if(type.toString() == "int32")
+        {
+            value = MAV_PARAM_TYPE_INT32;
+        }
+        else if(type.toString() == "uint64")
+        {
+            value = MAV_PARAM_TYPE_UINT64;
+        }
+        else if(type.toString() == "int64")
+        {
+            value = MAV_PARAM_TYPE_INT64;
+        }
+        else if(type.toString() == "float")
+        {
+            value = MAV_PARAM_TYPE_REAL32;
+        }
+        else if(type.toString() == "double")
+        {
+            value = MAV_PARAM_TYPE_REAL64;
+        }
+        else if(type.toString() == "unknow")
+        {
+            value = 0;
+        }
+
+        return value;
+}
+
+
+//使用QString
+QString ParameterProcess::set_id(char *id)//设置id,如果id小于16，那么能够找到/0，如果等于或者大于，那么会找不到，因此乱码
+{
+     QString Name;
+
+     Name.append(id);
+
+     if(Name.size() >= 16)
+     {
+         Name = Name.left(16);
+     }
+
+     return Name;
+}
+
+char * ParameterProcess::get_id(QVariant Name)
+{
+     QString str = Name.toString();
+
+     return str.toLatin1().data();
+}
 
 
 

MavLinkNode/parameterprocess.h

@@ -95,6 +95,13 @@ public slots:
 
     void Parse(mavlink_message_t msg);
 
+    QVariant set_value(mavlink_param_value_t param);
+    float get_value(QVariant param,uint8_t type);
+    QVariant set_type(mavlink_param_value_t param);
+    uint8_t get_type(QVariant type);
+    QString set_id(char *id);
+    char *get_id(QVariant Name);
+
 private slots:
    //线程私有接口
    void Send(mavlink_message_t msg);

opmap/core/opmaps.cpp

@@ -132,6 +132,7 @@ QByteArray OPMaps::GetImageFrom(const MapType::Types &type, const Point &pos, co
             case MapType::GoogleHybrid:
             {
                 qheader.setRawHeader("Referrer", "http://maps.google.com/");
+                qDebug() << "google";
             }
             break;
 

opmap/core/urlfactory.cpp

@@ -180,6 +180,7 @@ void UrlFactory::TryCorrectGoogleVersions()
 
 QString UrlFactory::MakeImageUrl(const MapType::Types &type, const Point &pos, const int &zoom, const QString &language)
 {
+    qDebug() << type;
 #ifdef DEBUG_URLFACTORY
     qDebug() << "Entered MakeImageUrl";
 #endif // DEBUG_URLFACTORY
@@ -545,7 +546,7 @@ QString UrlFactory::MakeImageUrl(const MapType::Types &type, const Point &pos, c
         return QString("https://maponline%1.bdimg.com/starpic/?qt=satepc&u=x=%2;y=%3;z=%4;v=009;type=sate&fm=46&app=webearth2&v=009&udt=20200623")
                 .arg(GetServerNum(pos, 4))
                 .arg(pos.X())
-                .arg(pos.Y())
+                .arg(4-pos.Y())
                 .arg(zoom);
 
         qDebug() << pos.X()

opmap/internals/core.cpp

@@ -112,13 +112,15 @@ void Core::run()
                                 QByteArray img;
 
                                 // tile number inversion(BottomLeft -> TopLeft) for pergo maps
-                                if (tl == MapType::PergoTurkeyMap) {
+                                if ((tl == MapType::PergoTurkeyMap) || (tl == MapType::BaiduSatellite)) {
                                     img = OPMaps::Instance()->GetImageFrom(tl, Point(task.Pos.X(), maxOfTiles.Height() - task.Pos.Y()), task.Zoom);
+
                                 } else { // ok
 #ifdef DEBUG_CORE
                                     qDebug() << "start getting image" << " ID=" << debug;
 #endif // DEBUG_CORE
                                     img = OPMaps::Instance()->GetImageFrom(tl, task.Pos, task.Zoom);
+
 #ifdef DEBUG_CORE
                                     qDebug() << "Core::run:gotimage size:" << img.count() << " ID=" << debug << " time=" << t.elapsed();
 #endif // DEBUG_CORE

opmap/mapwidget/mapripper.cpp

@@ -110,6 +110,8 @@ void MapRipper::run()
                 emit providerChanged(core::MapType::StrByType(type), zoom);
                 QByteArray img = OPMaps::Instance()->GetImageFrom(type, p, zoom);
 
+                //qDebug() << "map rapper";
+
                 if (img.length() != 0) {
                     goodtile = true;
                     img = NULL;