first commit

.gitignore

@@ -0,0 +1,2 @@
+*.pro.user
+*.pro.user.*

backgroundserver.cpp

@@ -0,0 +1,768 @@
+#include "backgroundserver.h"
+
+BackgroundServer::BackgroundServer(QObject *parent, quint16 port) : QObject(parent)
+{
+    sim = new SimulationControl();
+    SimThread = new QThread();
+    sim->moveToThread(SimThread);
+    connect(this,&BackgroundServer::sigGetInit,
+            sim,&SimulationControl::SlotGetInit);
+    connect(this,&BackgroundServer::sigGetLeadPost,
+            sim,&SimulationControl::SlotGetLeadPost);
+    connect(this,&BackgroundServer::sigGetTaskPlan,
+            sim,&SimulationControl::SlotGetTaskPlan);
+    connect(this,&BackgroundServer::sigGetGlobalMap,
+            sim,&SimulationControl::SlotGetGlobalMap);
+    connect(this,&BackgroundServer::sigGetPlatformTable,
+            sim,&SimulationControl::SlotGetPlatformTable);
+    connect(this,&BackgroundServer::sigGetInstanceTable,
+            sim,&SimulationControl::SlotGetInstanceTable);
+    connect(this,&BackgroundServer::sigGetRadarInstances,
+            sim,&SimulationControl::SlotGetRadarInstances);
+    connect(this,&BackgroundServer::sigGetRadarParams,
+            sim,&SimulationControl::SlotGetRadarParams);
+    connect(this,&BackgroundServer::sigGetThaadInstances,
+            sim,&SimulationControl::SlotGetThaadInstances);
+    connect(this,&BackgroundServer::sigGetThaadParams,
+            sim,&SimulationControl::SlotGetThaadParams);
+    connect(this,&BackgroundServer::sigSetThaadStyle,
+            sim,&SimulationControl::SlotSetThaadStyle);
+    connect(this,&BackgroundServer::sigGetJammingInstances,
+            sim,&SimulationControl::SlotGetJammingInstances);
+    connect(this,&BackgroundServer::sigGetJammingParams,
+            sim,&SimulationControl::SlotGetJammingParams);
+    connect(this,&BackgroundServer::sigGetESMParams,
+            sim,&SimulationControl::SlotGetESMParams);
+    connect(sim,&SimulationControl::SigReturnData,
+            this,&BackgroundServer::SlotReturnData);
+    SimThread->start();
+
+    m_pWebSocketServer = new QWebSocketServer(QStringLiteral("Mock Server"),
+                                                    QWebSocketServer::NonSecureMode,
+                                                    this);
+    if (m_pWebSocketServer->listen(QHostAddress::Any, port))
+    {
+      qDebug() << "Mock Server listening on port" << port;
+      connect(m_pWebSocketServer, &QWebSocketServer::newConnection,
+              this, &BackgroundServer::onNewConnection);
+    }
+
+}
+
+BackgroundServer::~BackgroundServer()
+{
+    m_pWebSocketServer->close();
+    qDeleteAll(m_clients.begin(), m_clients.end());
+}
+
+void BackgroundServer::onNewConnection()
+{
+    QWebSocket *pSocket = m_pWebSocketServer->nextPendingConnection();
+
+    connect(pSocket, &QWebSocket::textMessageReceived, this, &BackgroundServer::processMessage);
+    connect(pSocket, &QWebSocket::disconnected, this, &BackgroundServer::socketDisconnected);
+
+    m_clients << pSocket;
+}
+
+QJsonObject BackgroundServer::processJsonObj(QJsonObject objin)
+{
+    QJsonObject ret;
+
+    QStringList Keys = objin.keys();
+
+    for (auto k : Keys)
+    {
+        QJsonValue v = objin.value(k);
+
+        if (k == "url")
+        {
+            ret.insert(k, v);
+        }
+        else if (k == "InstanceID")
+        {
+            ret.insert(k, v);
+        }
+        else if (k == "data")
+        {
+            if (v.isObject())
+            {
+                QJsonObject Props = v.toObject();
+                QStringList Propkeys = Props.keys();
+                if (Propkeys.contains("InstanceID"))
+                {
+                    ret.insert("InstanceID", Props.take("InstanceID"));
+                }
+                if (Propkeys.contains("PlatformID"))
+                {
+                    ret.insert("PlatformID", Props.take("PlatformID"));
+                }
+                ret.insert("data",Props);
+            }
+        }
+//            if (v.isArray())
+//            {
+//                for (auto i : v.toArray())
+//                {
+//                    if (i.isString())
+//                    {
+//                        objout->insert(i.toString(),QJsonValue());
+//                    }
+//                }
+//            }
+//            else if (v.isObject())
+//            {
+//                QJsonObject Props = v.toObject();
+//                QStringList Propkeys = Props.keys();
+//                for (auto propkey: Propkeys)
+//                {
+//                    objout->insert(propkey,Props.value(k));
+//                }
+//            }
+
+        // 不想打印
+//        if (v.isObject())
+//        {
+//            processJsonObj(v.toObject(),objout);
+//        }
+
+        // 打印调试信息
+        if (v.isDouble())
+        {
+            qDebug() << k << ": " << v.toDouble();
+        }
+        else if (v.isString())
+        {
+            qDebug() << k << ": " << v.toString();
+        }
+        else if (v.isObject())
+        {
+            qDebug() << k << "{";
+//            processJsonObj(v.toObject(),objout);
+            QJsonObject objout = processJsonObj(v.toObject());
+            qDebug() << "}";
+        }
+        else if (v.isArray())
+        {
+            QJsonArray qarray = v.toArray();
+            qDebug() << k << "[";
+
+            for (auto i : qarray)
+            {
+                if (i.isString())
+                {
+                    qDebug() << i.toString();
+                }
+            }
+            qDebug() << "]";
+        }
+    }
+    //qDebug() << QString(QJsonDocument(*objout).toJson());
+    return ret;
+}
+
+void BackgroundServer::processMessage(QString message)
+{   
+    // 获取客户端
+    QWebSocket *pSender = qobject_cast<QWebSocket *>(sender());
+
+    // 以Json格式解码message
+    QByteArray *ByteMessage = new QByteArray();
+    ByteMessage->append(message);
+    QJsonParseError *error = new QJsonParseError();
+    QJsonDocument IncomingJson = QJsonDocument::fromJson(*ByteMessage, error);
+
+
+    if (error->error == QJsonParseError::NoError)
+    {
+        if (IncomingJson.isObject())
+        {
+            // 解析message
+            QJsonObject IncomingObj = IncomingJson.object();
+            QJsonObject msgobj = this->processJsonObj(IncomingObj);
+
+            QStringList props = msgobj.keys();
+            QString url = msgobj.value("url").toString();
+//            qDebug() << QString(QJsonDocument(msgobj).toJson());
+            qDebug() << "url:" << url;
+            // 判断请求
+            if (url == "getInit")
+            {
+                emit sigGetInit(pSender, msgobj);
+            }
+            else if (url == "getPlatformTable")
+            {
+                emit sigGetPlatformTable(pSender, msgobj);
+            }
+            else if (url == "getGlobalMap" || url == "getLocalMap" || url == "getRemoteMap" || url == "getCombineMap")
+            {
+                emit sigGetGlobalMap(pSender, msgobj);
+            }
+            else if (url == "getThaadInstances")
+            {
+                emit sigGetThaadInstances(pSender, msgobj);
+            }
+            else
+            {
+                // 其他接口都需要带平台ID
+                if (msgobj.contains("PlatformID")==false)
+                {
+                    QJsonObject *ret = new QJsonObject();
+                    ret->insert("data", QJsonValue());
+                    // 要是没有平台ID，返回空数据
+                    msgobj.insert("data", QJsonValue());
+                    if (msgobj.contains("url") == true)
+                    {
+                        ret->insert("url", msgobj.value("url"));
+                    }
+
+                    SlotReturnData(pSender, ret);
+                }
+                else if (url == "getInstanceTable")
+                {
+                    emit sigGetInstanceTable(pSender, msgobj);
+                }
+                else if (url == "getRadarInstances")
+                {
+                    emit sigGetRadarInstances(pSender, msgobj);
+                }
+                else if (url == "getRadarParams" && msgobj.contains("InstanceID"))
+                {
+                    emit sigGetRadarParams(pSender, msgobj);
+                }
+                else if (url == "getThaadParams" && msgobj.contains("InstanceID"))
+                {
+                    emit sigGetRadarParams(pSender, msgobj);
+                }
+                else if (url == "setThaadStyle" && msgobj.contains("InstanceID"))
+                {
+                    emit sigSetThaadStyle(pSender, msgobj);
+                }
+                else if (url == "getJammingInstances")
+                {
+                    emit sigGetJammingInstances(pSender, msgobj);
+                }
+                else if (url == "getJammingParams" && msgobj.contains("InstanceID"))
+                {
+                    emit sigGetJammingParams(pSender, msgobj);
+                }
+                else if (url == "getESMParams")
+                {
+                    emit sigGetESMParams(pSender, msgobj);
+                }
+                else if (url == "getNavParams")
+                {
+//                    getNavParams(msgobj);
+                }
+                else if (url == "setFreePost")
+                {
+//                    setFreePost(msgobj);
+                }
+                else if (url == "getLeadPost")
+                {
+                    emit sigGetLeadPost(pSender, msgobj);
+                }
+                else if (url == "getTaskPlan")
+                {
+                    emit sigGetTaskPlan(pSender, msgobj);
+                }
+            }
+
+//        qDebug() << "return message:";
+//        qDebug() << QString(QJsonDocument(*msgobj).toJson());
+
+//        QWebSocket *pSender = qobject_cast<QWebSocket *>(sender());
+//        pSender->sendTextMessage(QString(QJsonDocument(*msgobj).toJson()));
+
+//        for (QWebSocket *pClient : qAsConst(m_clients)) {
+
+//            QJsonDocument *msgdoc = new QJsonDocument(*msgobj);
+
+//            if (pClient == pSender) //don't echo message back to sender
+//            {
+//                QJsonValue msg = new QJsonValue(message);
+//                pClient->sendTextMessage(QString(msgdoc->toJson()));
+//            }
+//            qDebug() << QString(msgdoc->toJson());
+        }
+    }
+}
+
+void BackgroundServer::socketDisconnected()
+{
+    QWebSocket *pClient = qobject_cast<QWebSocket *>(sender());
+    if (pClient)
+    {
+        m_clients.removeAll(pClient);
+        pClient->deleteLater();
+    }
+}
+
+void BackgroundServer::getInit(QJsonObject *obj)
+{
+    //obj->insert("data",QJsonValue(1));
+
+    QJsonObject *InitState = new QJsonObject();
+    InitState->insert("InitState", 100);
+    obj->insert("data", *InitState);
+
+    delete InitState;
+}
+
+void BackgroundServer::getLeadPost(QJsonObject *obj)
+{
+    QJsonArray *LeadPost = new QJsonArray();
+
+    QJsonObject *CurrentLeadPost;
+
+    CurrentLeadPost = new QJsonObject();
+    CurrentLeadPost->insert("time", "20:20:01");
+    CurrentLeadPost->insert("GroupID", "0001");
+    CurrentLeadPost->insert("LeaderID", "8013");
+    CurrentLeadPost->insert("Abstract", QString::fromLocal8Bit("冲冲冲"));
+    LeadPost->append(*CurrentLeadPost);
+    delete CurrentLeadPost;
+    CurrentLeadPost = new QJsonObject();
+    CurrentLeadPost->insert("time", "20:20:30");
+    CurrentLeadPost->insert("GroupID", "0001");
+    CurrentLeadPost->insert("LeaderID", "8013");
+    CurrentLeadPost->insert("Abstract", QString::fromLocal8Bit("有点小寄"));
+    LeadPost->append(*CurrentLeadPost);
+    delete CurrentLeadPost;
+    CurrentLeadPost = new QJsonObject();
+    CurrentLeadPost->insert("time", "20:20:40");
+    CurrentLeadPost->insert("GroupID", "0003");
+    CurrentLeadPost->insert("LeaderID", "8014");
+    CurrentLeadPost->insert("Abstract", QString::fromLocal8Bit("有内鬼"));
+    LeadPost->append(*CurrentLeadPost);
+    delete CurrentLeadPost;
+    CurrentLeadPost = new QJsonObject();
+    CurrentLeadPost->insert("time", "20:21:00");
+    CurrentLeadPost->insert("GroupID", "0002");
+    CurrentLeadPost->insert("LeaderID", "8015");
+    CurrentLeadPost->insert("Abstract", QString::fromLocal8Bit("好起来了"));
+    LeadPost->append(*CurrentLeadPost);
+    delete CurrentLeadPost;
+
+    obj->insert("data", *LeadPost);
+}
+
+void BackgroundServer::getTaskPlan(QJsonObject *obj)
+{
+    QJsonObject *TaskPlan = new QJsonObject();
+
+    QJsonObject *CurrentAirLine;
+    QJsonObject *CurrentTaskPlan;
+
+    CurrentAirLine = new QJsonObject;
+    CurrentAirLine->insert("TargetArea", 3);
+    CurrentAirLine->insert("Longitude", 123);
+    CurrentAirLine->insert("Longitude", 27);
+    CurrentAirLine->insert("Radius", 300000);
+
+    CurrentTaskPlan = new QJsonObject;
+    CurrentTaskPlan->insert("TargetArea", 2);
+    CurrentTaskPlan->insert("ThrowGas", 2);
+    CurrentTaskPlan->insert("ThrowBT", 2);
+
+    TaskPlan->insert("Airline", *CurrentAirLine);
+    TaskPlan->insert("TaskPlan", *CurrentTaskPlan);
+
+    obj->insert("data", *TaskPlan);
+
+    delete TaskPlan;
+    delete CurrentAirLine;
+    delete CurrentTaskPlan;
+}
+
+void BackgroundServer::getGlobalMap(QJsonObject *obj)
+{
+    QJsonObject *GlobalMap = new QJsonObject();
+
+//    QJsonObject *alies = new QJsonObject();
+//    QJsonObject *enemys = new QJsonObject();
+    QJsonArray *alies = new QJsonArray();
+    QJsonArray *enemys = new QJsonArray();
+    QJsonArray *temparray;
+    QJsonObject *tempobj;
+
+    {
+        temparray = new QJsonArray();
+        tempobj = new QJsonObject();
+        tempobj->insert("name", QString::fromLocal8Bit("80xxA电子侦察船_1"));
+        temparray->append(120.446), temparray->append(24.8902), temparray->append(100);
+        tempobj->insert("value", *temparray);
+//        alies->insert(QString::fromLocal8Bit("80xxA电子侦察船_1"), QJsonValue(*temparray));
+        alies->append(*tempobj);
+        delete temparray;
+        delete tempobj;
+
+        temparray = new QJsonArray();
+        tempobj = new QJsonObject();
+        tempobj->insert("name", QString::fromLocal8Bit("导弹发射架_1"));
+        temparray->append(117.525), temparray->append(25.826), temparray->append(100);
+        tempobj->insert("value", *temparray);
+        alies->append(*tempobj);
+        delete temparray;
+        delete tempobj;
+
+        temparray = new QJsonArray();
+        tempobj = new QJsonObject();
+        tempobj->insert("name", QString::fromLocal8Bit("机场_1"));
+        temparray->append(119.271), temparray->append(26.26), temparray->append(100);
+        tempobj->insert("value", *temparray);
+        alies->append(*tempobj);
+        delete temparray;
+        delete tempobj;
+
+        temparray = new QJsonArray();
+        tempobj = new QJsonObject();
+        tempobj->insert("name", QString::fromLocal8Bit("预警机_1"));
+        temparray->append(120.288), temparray->append(25.5734), temparray->append(100);
+        tempobj->insert("value", *temparray);
+        alies->append(*tempobj);
+        delete temparray;
+        delete tempobj;
+
+        temparray = new QJsonArray();
+        tempobj = new QJsonObject();
+        tempobj->insert("name", QString::fromLocal8Bit("运侦8_1"));
+        temparray->append(117.525), temparray->append(25.826), temparray->append(100);
+        tempobj->insert("value", *temparray);
+        alies->append(*tempobj);
+        delete temparray;
+        delete tempobj;
+    }
+    GlobalMap->insert("friend", QJsonValue(*alies));
+
+    {
+        temparray = new QJsonArray();
+        tempobj = new QJsonObject();
+        tempobj->insert("name", QString::fromLocal8Bit("宙斯盾舰"));
+        temparray->append(123.528), temparray->append(25.2951), temparray->append(100);
+        tempobj->insert("value",*temparray);
+        enemys->append(*tempobj);
+        delete temparray;
+        delete tempobj;
+    }
+    GlobalMap->insert("enemy", QJsonValue(*enemys));
+
+    obj->insert("data",QJsonValue(*GlobalMap));
+    delete GlobalMap;
+    delete alies;
+    delete enemys;
+}
+
+void BackgroundServer::getPlatformTable(QJsonObject *obj)
+{
+    QJsonArray *Platforms = new QJsonArray();
+    QJsonObject *SinglePlatform;
+
+    {
+        SinglePlatform = new QJsonObject();
+        SinglePlatform->insert("platformID", 8015);
+        SinglePlatform->insert("platformName", QString::fromLocal8Bit("侦察机_1"));
+        Platforms->append(*SinglePlatform);
+        delete SinglePlatform;
+
+        SinglePlatform = new QJsonObject();
+        SinglePlatform->insert("platformID", 8016);
+        SinglePlatform->insert("platformName", QString::fromLocal8Bit("侦察机_2"));
+        Platforms->append(*SinglePlatform);
+        delete SinglePlatform;
+    }
+    obj->insert("data",QJsonValue(*Platforms));
+    delete Platforms;
+}
+
+void BackgroundServer::getInstanceTable(QJsonObject *obj)
+{
+    QJsonArray *Instances = new QJsonArray();
+    QJsonObject *SingleInstance;
+    if (true)
+    {
+        SingleInstance = new QJsonObject();
+        SingleInstance->insert("instanceID", 22);
+        SingleInstance->insert("instanceName", QString::fromLocal8Bit("侦察机_1"));
+        Instances->append(*SingleInstance);
+        delete SingleInstance;
+
+        SingleInstance = new QJsonObject();
+        SingleInstance->insert("instanceID", 62);
+        SingleInstance->insert("instanceName", QString::fromLocal8Bit("信号侦察_1"));
+        Instances->append(*SingleInstance);
+        delete SingleInstance;
+
+        SingleInstance = new QJsonObject();
+        SingleInstance->insert("instanceID", 96);
+        SingleInstance->insert("instanceName", QString::fromLocal8Bit("体系增量_1"));
+        Instances->append(*SingleInstance);
+        delete SingleInstance;
+
+        SingleInstance = new QJsonObject();
+        SingleInstance->insert("instanceID", 111);
+        SingleInstance->insert("instanceName", QString::fromLocal8Bit("侦察平台任务系统_1"));
+        Instances->append(*SingleInstance);
+        delete SingleInstance;
+
+        SingleInstance = new QJsonObject();
+        SingleInstance->insert("instanceID", 171);
+        SingleInstance->insert("instanceName", QString::fromLocal8Bit("导航_1"));
+        Instances->append(*SingleInstance);
+        delete SingleInstance;
+    }
+    obj->insert("data",QJsonValue(*Instances));
+    delete Instances;
+}
+
+void BackgroundServer::getESMParams(QJsonObject *obj)
+{
+    int InstanceID = obj->value("InstanceID").toInt();
+
+    QJsonArray *ESMInitParams;
+    QJsonArray *ESMCtrlParams;
+    QJsonObject *ESMPropTemp;
+
+    if (true)
+    {
+        ESMInitParams = new QJsonArray();
+        ESMCtrlParams = new QJsonArray();
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","fBeamAzWidth");
+        ESMPropTemp->insert("value",2);
+        ESMInitParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","fBeamElWidth");
+        ESMPropTemp->insert("value",2);
+        ESMInitParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","fTecMinFreqMhz");
+        ESMPropTemp->insert("value",2e3);
+        ESMInitParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","fTecMaxFreqMhz");
+        ESMPropTemp->insert("value",18e3);
+        ESMInitParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","fInstantPageWidMhz");
+        ESMPropTemp->insert("value",500);
+        ESMInitParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","ulChanNum");
+        ESMPropTemp->insert("value",64);
+        ESMInitParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","fTecMinPW");
+        ESMPropTemp->insert("value",0.5);
+        ESMInitParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","fTecMaxPW");
+        ESMPropTemp->insert("value",10);
+        ESMInitParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","fTecPriMean");
+        ESMPropTemp->insert("value",40);
+        ESMInitParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","ulTecTrNumMean");
+        ESMPropTemp->insert("value",5);
+        ESMInitParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","fMinSnrdB");
+        ESMPropTemp->insert("value",0.5);
+        ESMInitParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","fSysRcvLoss");
+        ESMPropTemp->insert("value",5);
+        ESMInitParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","fFreqAccuracyReq");
+        ESMPropTemp->insert("value",100);
+        ESMInitParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","uRrPowerOn");
+        ESMPropTemp->insert("value",0);
+        ESMCtrlParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","uRrWorkMode");
+        ESMPropTemp->insert("value",0);
+        ESMCtrlParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","dScanAzCentDeg");
+        ESMPropTemp->insert("value",0);
+        ESMCtrlParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","dScanAzWidthDeg");
+        ESMPropTemp->insert("value",5);
+        ESMCtrlParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","dScanElCentDeg");
+        ESMPropTemp->insert("value",0);
+        ESMCtrlParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","uLineNumPerFrame");
+        ESMPropTemp->insert("value",20);
+        ESMCtrlParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","fAntScanVel");
+        ESMPropTemp->insert("value",1);
+        ESMCtrlParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","fFreqScanVel");
+        ESMPropTemp->insert("value",100);
+        ESMCtrlParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","fTecBeginFreqMhz");
+        ESMPropTemp->insert("value",500);
+        ESMCtrlParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","fTecEndFreqMhz");
+        ESMPropTemp->insert("value",10000);
+        ESMCtrlParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        QJsonObject *ESMParams = new QJsonObject();
+        ESMParams->insert("InitParams", *ESMInitParams);
+        ESMParams->insert("CtrlParams", *ESMCtrlParams);
+        obj->insert("data", *ESMParams);
+        delete ESMInitParams;
+        delete ESMCtrlParams;
+        delete ESMParams;
+    }
+}
+
+void BackgroundServer::getESMData(QJsonObject *obj)
+{
+
+}
+
+void BackgroundServer::getNavParams(QJsonObject *obj)
+{
+    if (obj->contains("InstanceID")==false)
+    {
+        obj->insert("data", QJsonValue());
+        return;
+    }
+
+    int InstanceID = obj->value("InstanceID").toInt();
+
+    QJsonArray *NavInitParams;
+    QJsonArray *NavCtrlParams;
+    QJsonObject *NavPropTemp;
+
+    NavInitParams = new QJsonArray();
+    NavCtrlParams = new QJsonArray();
+
+    NavPropTemp = new QJsonObject();
+    NavPropTemp->insert("key","precision");
+    NavPropTemp->insert("value",QJsonValue(5));
+    NavInitParams->append(*NavPropTemp);
+    delete NavPropTemp;
+
+    qDebug() << "aaa" << QString(QJsonDocument(*NavCtrlParams).toJson());
+
+    NavPropTemp = new QJsonObject();
+    NavPropTemp->insert("key","longitude");
+    NavPropTemp->insert("value",QJsonValue(120));
+    NavCtrlParams->append(*NavPropTemp);
+    delete NavPropTemp;
+
+    NavPropTemp = new QJsonObject();
+    NavPropTemp->insert("key","latitude");
+    NavPropTemp->insert("value",QJsonValue(30));
+    NavCtrlParams->append(*NavPropTemp);
+    delete NavPropTemp;
+
+    NavPropTemp = new QJsonObject();
+    NavPropTemp->insert("key","altitude");
+    NavPropTemp->insert("value",QJsonValue(8014.8));
+    NavCtrlParams->append(*NavPropTemp);
+    delete NavPropTemp;
+
+    NavPropTemp = new QJsonObject();
+    NavPropTemp->insert("key","azimush");
+    NavPropTemp->insert("value",QJsonValue(10));
+    NavCtrlParams->append(*NavPropTemp);
+    delete NavPropTemp;
+
+    NavPropTemp = new QJsonObject();
+    NavPropTemp->insert("key","elevation");
+    NavPropTemp->insert("value",QJsonValue(-3));
+    NavCtrlParams->append(*NavPropTemp);
+    delete NavPropTemp;
+
+    QJsonObject *NAVParams = new QJsonObject();
+    NAVParams->insert("InitParams", *NavInitParams);
+    NAVParams->insert("CtrlParams", *NavCtrlParams);
+    obj->insert("data", *NAVParams);
+
+    QJsonDocument *NavDoc = new QJsonDocument(*NAVParams);
+    qDebug() << QString(NavDoc->toJson());
+    delete NavDoc;
+
+    delete NavInitParams;
+    delete NavCtrlParams;
+    delete NAVParams;
+}
+
+void BackgroundServer::setFreePost(QJsonObject *obj)
+{
+    if (obj->contains("PlatformID")==false)
+    {
+        obj->insert("data", QJsonValue());
+        return;
+    }
+}
+
+void BackgroundServer::SlotReturnData(QWebSocket *pSender, QJsonObject *obj)
+{
+    qDebug() << "return message:";
+    qDebug() << QString(QJsonDocument(*obj).toJson());
+    pSender->sendTextMessage(QString(QJsonDocument(*obj).toJson()));
+    delete obj;
+}

backgroundserver.h

@@ -0,0 +1,67 @@
+#ifndef BACKGROUNDSERVER_H
+#define BACKGROUNDSERVER_H
+
+#include <QObject>
+#include <QList>
+#include <QByteArray>
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QJsonValue>
+#include <QJsonParseError>
+#include "QtWebSockets/QWebSocketServer"
+#include "QtWebSockets/QWebSocket"
+#include <QThread>
+#include <QMutex>
+#include "simulationcontrol.h"
+
+//QT_FORWARD_DECLARE_CLASS(QWebSocketServer)
+//QT_FORWARD_DECLARE_CLASS(QWebSocket)
+
+class BackgroundServer : public QObject
+{
+    Q_OBJECT
+public:
+    QThread *SimThread;
+    SimulationControl *sim;
+
+    QWebSocketServer *m_pWebSocketServer;
+    QList<QWebSocket *> m_clients;
+
+    explicit BackgroundServer(QObject *parent = nullptr, quint16 port = 80);
+    virtual ~BackgroundServer();
+signals:
+    void sigGetInit(QWebSocket *pSender, QJsonObject jsonObj);
+    void sigGetLeadPost(QWebSocket *pSender, QJsonObject jsonObj);
+    void sigGetTaskPlan(QWebSocket *pSender, QJsonObject jsonObj);
+    void sigGetGlobalMap(QWebSocket *pSender, QJsonObject jsonObj);
+    void sigGetPlatformTable(QWebSocket *pSender, QJsonObject jsonObj);
+    void sigGetInstanceTable(QWebSocket *pSender, QJsonObject jsonObj);
+    void sigGetRadarInstances(QWebSocket *pSender, QJsonObject jsonObj);
+    void sigGetRadarParams(QWebSocket *pSender, QJsonObject jsonObj);
+    void sigGetThaadInstances(QWebSocket *pSender, QJsonObject jsonObj);
+    void sigSetThaadStyle(QWebSocket *pSender, QJsonObject jsonObj);
+    void sigGetThaadParams(QWebSocket *pSender, QJsonObject jsonObj);
+    void sigGetJammingInstances(QWebSocket *pSender, QJsonObject jsonObj);
+    void sigGetJammingParams(QWebSocket *pSender, QJsonObject jsonObj);
+    void sigGetESMParams(QWebSocket *pSender, QJsonObject jsonObj);
+
+public slots:
+    void onNewConnection();
+    QJsonObject processJsonObj(QJsonObject objin);
+    void processMessage(QString message);
+    void socketDisconnected();
+    void getInit(QJsonObject *obj);
+    void getLeadPost(QJsonObject *obj);
+    void getTaskPlan(QJsonObject *obj);
+    void getGlobalMap(QJsonObject *obj);
+    void getPlatformTable(QJsonObject *obj);
+    void getInstanceTable(QJsonObject *obj);
+    void getESMParams(QJsonObject *obj);
+    void getESMData(QJsonObject *obj);
+    void getNavParams(QJsonObject *obj);
+    void setFreePost(QJsonObject *obj);
+    void SlotReturnData(QWebSocket *pSender, QJsonObject *obj);
+};
+
+#endif // BACKGROUNDSERVER_H

coordTrans/XYZ2ELL.cpp

@@ -0,0 +1,126 @@
+//
+// Academic License - for use in teaching, academic research, and meeting
+// course requirements at degree granting institutions only.  Not for
+// government, commercial, or other organizational use.
+// File: XYZ2ELL.cpp
+//
+// MATLAB Coder version            : 5.3
+// C/C++ source code generated on  : 04-Apr-2023 15:28:59
+//
+
+// Include Files
+#include "XYZ2ELL.h"
+#include "rt_nonfinite.h"
+#include "rt_defines.h"
+#include <cmath>
+
+// Function Declarations
+static double rt_atan2d_snf(double u0, double u1);
+
+// Function Definitions
+//
+// Arguments    : double u0
+//                double u1
+// Return Type  : double
+//
+static double rt_atan2d_snf(double u0, double u1)
+{
+  double y;
+  if (std::isnan(u0) || std::isnan(u1)) {
+    y = rtNaN;
+  } else if (std::isinf(u0) && std::isinf(u1)) {
+    int b_u0;
+    int b_u1;
+    if (u0 > 0.0) {
+      b_u0 = 1;
+    } else {
+      b_u0 = -1;
+    }
+    if (u1 > 0.0) {
+      b_u1 = 1;
+    } else {
+      b_u1 = -1;
+    }
+    y = std::atan2(static_cast<double>(b_u0), static_cast<double>(b_u1));
+  } else if (u1 == 0.0) {
+    if (u0 > 0.0) {
+      y = RT_PI / 2.0;
+    } else if (u0 < 0.0) {
+      y = -(RT_PI / 2.0);
+    } else {
+      y = 0.0;
+    }
+  } else {
+    y = std::atan2(u0, u1);
+  }
+  return y;
+}
+
+//
+// choose reference ellipsoid
+//        1 ...... tide free
+//        2 ...... GRS80
+//        3 ...... WGS84
+//
+// Arguments    : const double pos[3]
+//                double *lat
+//                double *lon
+//                double *h
+// Return Type  : void
+//
+void XYZ2ELL(const double pos[3], double *lat, double *lon, double *h)
+{
+  double N;
+  double N_tmp;
+  double h_tmp;
+  double lat_tmp_im;
+  double lat_tmp_re;
+  //  ************************************************************************
+  //    Description:
+  //    Transformation from Cartesian coordinates X,Y,Z to ellipsoidal
+  //    coordinates lam,phi,elh. based on Occam subroutine transf.
+  //
+  //    Input:
+  //       pos = [x,y,z]                 [m,m,m]
+  //                can be a matrix: number of rows = number of stations
+  //
+  //    Output:
+  //       coor_ell = [lat,lon,h]      [deg,deg,m]
+  //
+  //    External calls:
+  //       global   a_...              Equatorial radius of the Earth [m]
+  //                f_...              Flattening factor of the Earth
+  //
+  //    Coded for VieVS:
+  //    17 Dec 2008 by Lucia Plank
+  //
+  //    Revision:
+  //    11 Nov 2022 by Haobin Luo
+  //  *************************************************************************
+  //  WGS84
+  lat_tmp_re = pos[2] * 0.0;
+  lat_tmp_im = pos[2];
+  *lat = rt_atan2d_snf(pos[2], std::sqrt(pos[0] * pos[0] + pos[1] * pos[1]) +
+                                   lat_tmp_re);
+  N_tmp = pos[0];
+  N = pos[1];
+  h_tmp = std::sqrt(N_tmp * N_tmp + N * N);
+  for (int j{0}; j < 10; j++) {
+    N_tmp = std::sin(*lat);
+    N = 6.378137E+6 / std::sqrt(1.0 - 0.0066943799902085387 * N_tmp * N_tmp);
+    *h = h_tmp / std::cos(*lat) - N;
+    N_tmp = N + *h;
+    *lat = rt_atan2d_snf(lat_tmp_im * N_tmp,
+                         h_tmp * (0.9933056200097915 * N + *h) +
+                             lat_tmp_re * N_tmp);
+  }
+  *lat *= 57.295779513082323;
+  *lon = 57.295779513082323 * rt_atan2d_snf(pos[1], pos[0]);
+  // lat=cart2phigd(pos);
+}
+
+//
+// File trailer for XYZ2ELL.cpp
+//
+// [EOF]
+//

coordTrans/XYZ2ELL.h

@@ -0,0 +1,27 @@
+//
+// Academic License - for use in teaching, academic research, and meeting
+// course requirements at degree granting institutions only.  Not for
+// government, commercial, or other organizational use.
+// File: XYZ2ELL.h
+//
+// MATLAB Coder version            : 5.3
+// C/C++ source code generated on  : 04-Apr-2023 15:28:59
+//
+
+#ifndef XYZ2ELL_H
+#define XYZ2ELL_H
+
+// Include Files
+#include "rtwtypes.h"
+#include <cstddef>
+#include <cstdlib>
+
+// Function Declarations
+extern void XYZ2ELL(const double pos[3], double *lat, double *lon, double *h);
+
+#endif
+//
+// File trailer for XYZ2ELL.h
+//
+// [EOF]
+//

coordTrans/blh2xyz.cpp

@@ -0,0 +1,52 @@
+//
+// Academic License - for use in teaching, academic research, and meeting
+// course requirements at degree granting institutions only.  Not for
+// government, commercial, or other organizational use.
+// File: blh2xyz.cpp
+//
+// MATLAB Coder version            : 5.3
+// C/C++ source code generated on  : 04-Apr-2023 15:36:25
+//
+
+// Include Files
+#include "blh2xyz.h"
+#include <cmath>
+
+// Function Definitions
+//
+// Example:
+// (BLh)WGS84-(XYZ)WGS84
+//  LAT = 40.9987167395335;
+//  LON = 39.7652393428761;
+//  h = 51.403;
+//
+// Arguments    : double LAT
+//                double LON
+//                double h
+//                double *X
+//                double *Y
+//                double *Z
+// Return Type  : void
+//
+void blh2xyz(double LAT, double LON, double h, double *X, double *Y, double *Z)
+{
+  double N;
+  double a_tmp;
+  double lat;
+  double lon;
+  //  WGS84
+  lat = LAT * 3.1415926535897931 / 180.0;
+  lon = LON * 3.1415926535897931 / 180.0;
+  a_tmp = std::sin(lat);
+  N = 6.378137E+6 / std::sqrt(1.0 - 0.0066943799902085318 * (a_tmp * a_tmp));
+  lat = (N + h) * std::cos(lat);
+  *X = lat * std::cos(lon);
+  *Y = lat * std::sin(lon);
+  *Z = (N * 0.9933056200097915 + h) * a_tmp;
+}
+
+//
+// File trailer for blh2xyz.cpp
+//
+// [EOF]
+//

coordTrans/blh2xyz.h

@@ -0,0 +1,28 @@
+//
+// Academic License - for use in teaching, academic research, and meeting
+// course requirements at degree granting institutions only.  Not for
+// government, commercial, or other organizational use.
+// File: blh2xyz.h
+//
+// MATLAB Coder version            : 5.3
+// C/C++ source code generated on  : 04-Apr-2023 15:36:25
+//
+
+#ifndef BLH2XYZ_H
+#define BLH2XYZ_H
+
+// Include Files
+#include "rtwtypes.h"
+#include <cstddef>
+#include <cstdlib>
+
+// Function Declarations
+extern void blh2xyz(double LAT, double LON, double h, double *X, double *Y,
+                    double *Z);
+
+#endif
+//
+// File trailer for blh2xyz.h
+//
+// [EOF]
+//

coordTrans/rt_defines.h

@@ -0,0 +1,38 @@
+//
+// Academic License - for use in teaching, academic research, and meeting
+// course requirements at degree granting institutions only.  Not for
+// government, commercial, or other organizational use.
+// File: rt_defines.h
+//
+// MATLAB Coder version            : 5.3
+// C/C++ source code generated on  : 04-Apr-2023 15:28:59
+//
+
+#ifndef RT_DEFINES_H
+#define RT_DEFINES_H
+
+// Include Files
+#include "rtwtypes.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+static const real_T RT_PI{3.14159265358979323846};
+static const real32_T RT_PIF{3.1415927F};
+static const real_T RT_LN_10{2.30258509299404568402};
+static const real32_T RT_LN_10F{2.3025851F};
+static const real_T RT_LOG10E{0.43429448190325182765};
+static const real32_T RT_LOG10EF{0.43429449F};
+static const real_T RT_E{2.7182818284590452354};
+static const real32_T RT_EF{2.7182817F};
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+//
+// File trailer for rt_defines.h
+//
+// [EOF]
+//

coordTrans/rt_nonfinite.cpp

@@ -0,0 +1,27 @@
+//
+// File: rt_nonfinite.cpp
+//
+// MATLAB Coder version            : 5.2
+// C/C++ source code generated on  : 01-Mar-2023 10:44:39
+//
+
+// Abstract:
+//      MATLAB for code generation function to initialize non-finites,
+//      (Inf, NaN and -Inf).
+// Include Files
+#include "rt_nonfinite.h"
+#include <cmath>
+#include <limits>
+
+real_T rtNaN{std::numeric_limits<real_T>::quiet_NaN()};
+real_T rtInf{std::numeric_limits<real_T>::infinity()};
+real_T rtMinusInf{-std::numeric_limits<real_T>::infinity()};
+real32_T rtNaNF{std::numeric_limits<real32_T>::quiet_NaN()};
+real32_T rtInfF{std::numeric_limits<real32_T>::infinity()};
+real32_T rtMinusInfF{-std::numeric_limits<real32_T>::infinity()};
+
+//
+// File trailer for rt_nonfinite.cpp
+//
+// [EOF]
+//

coordTrans/rt_nonfinite.h

@@ -0,0 +1,33 @@
+//
+// File: rt_nonfinite.h
+//
+// MATLAB Coder version            : 5.2
+// C/C++ source code generated on  : 01-Mar-2023 10:44:39
+//
+
+#ifndef RT_NONFINITE_H
+#define RT_NONFINITE_H
+
+// Include Files
+#include "rtwtypes.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern real_T rtInf;
+extern real_T rtMinusInf;
+extern real_T rtNaN;
+extern real32_T rtInfF;
+extern real32_T rtMinusInfF;
+extern real32_T rtNaNF;
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+//
+// File trailer for rt_nonfinite.h
+//
+// [EOF]
+//

coordTrans/rtwtypes.h

@@ -0,0 +1,45 @@
+//
+// File: rtwtypes.h
+//
+// MATLAB Coder version            : 5.2
+// C/C++ source code generated on  : 01-Mar-2023 10:44:39
+//
+
+#ifndef RTWTYPES_H
+#define RTWTYPES_H
+
+/*=======================================================================*
+ * Fixed width word size data types:                                     *
+ *   int64_T                      - signed 64 bit integers               *
+ *   uint64_T                     - unsigned 64 bit integers             *
+ *=======================================================================*/
+
+#if defined(__APPLE__)
+#ifndef INT64_T
+#define INT64_T long
+#define FMT64 "l"
+#if defined(__LP64__) && !defined(INT_TYPE_64_IS_LONG)
+#define INT_TYPE_64_IS_LONG
+#endif
+#endif
+#endif
+
+#if defined(__APPLE__)
+#ifndef UINT64_T
+#define UINT64_T unsigned long
+#define FMT64 "l"
+#if defined(__LP64__) && !defined(INT_TYPE_64_IS_LONG)
+#define INT_TYPE_64_IS_LONG
+#endif
+#endif
+#endif
+
+// Include Files
+#include "tmwtypes.h"
+
+#endif
+//
+// File trailer for rtwtypes.h
+//
+// [EOF]
+//

coordTrans/tmwtypes.h

@@ -0,0 +1,757 @@
+/*
+ * @(#)tmwtypes.h    generated by: makeheader 5.1.3  Mon Jan  8 22:14:40 2007
+ *
+ *		built from:	../../src/include/copyright.h
+ *				../../src/include/tmwtypes.h
+ */
+
+#if defined(_MSC_VER) || __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 3)
+#pragma once
+#endif
+
+#ifndef tmwtypes_h
+#define tmwtypes_h
+
+
+/*
+ * Copyright 1984-2007 The MathWorks, Inc.
+ */
+
+
+
+/* Copyright 1995-2006 The MathWorks, Inc. */
+
+#ifndef __TMWTYPES__
+#define __TMWTYPES__
+/*
+ * File    : tmwtypes.h
+ * Abstract:
+ *      Data types for use with MATLAB/SIMULINK and the Real-Time Workshop.
+ *
+ *      When compiling stand-alone model code, data types can be overridden
+ *      via compiler switches.
+ *
+ *      Define NO_FLOATS to eliminate reference to real_T, etc.
+ */
+
+
+#include <limits.h>
+
+#ifdef __APPLE_CC__
+#include <stdbool.h>
+#endif
+
+#define LOGICAL_IS_A_TYPE
+#define SPARSE_GENERALIZATION
+
+#ifdef NO_FLOATS
+# define double double_not_allowed
+# define float  float_not_allowed
+#endif /*NO_FLOATS*/
+
+#ifndef NO_FLOATS
+
+#ifndef __MWERKS__
+# ifdef __STDC__
+#  include <float.h>
+# else
+#  define FLT_MANT_DIG 24
+#  define DBL_MANT_DIG 53
+# endif
+#endif
+
+#endif /*NO_FLOATS*/
+
+/*
+ *      The following data types cannot be overridden when building MEX files.
+ */
+#ifdef MATLAB_MEX_FILE
+# undef CHARACTER_T
+# undef INTEGER_T
+# undef BOOLEAN_T
+# undef REAL_T
+# undef TIME_T
+#endif
+
+/*
+ * The uchar_T, ushort_T and ulong_T types are needed for compilers which do 
+ * not allow defines to be specified, at the command line, with spaces in them.
+ */
+
+typedef unsigned char  uchar_T;
+typedef unsigned short ushort_T;
+typedef unsigned long  ulong_T;
+
+
+
+/*=======================================================================*
+ * Fixed width word size data types:                                     *
+ *   int8_T, int16_T, int32_T     - signed 8, 16, or 32 bit integers     *
+ *   uint8_T, uint16_T, uint32_T  - unsigned 8, 16, or 32 bit integers   *
+ *   real32_T, real64_T           - 32 and 64 bit floating point numbers *
+ *=======================================================================*/
+
+/* When used with Real Time Workshop generated code, this
+ * header file can be used with a variety of compilers.
+ *
+ * The compiler could be for an 8 bit embedded processor that
+ * only had 8 bits per integer and 16 bits per long.
+ * In that example, a 32 bit integer size is not even available.
+ * This header file should be robust to that.   
+ *
+ * For the case of an 8 bit processor, the preprocessor
+ * may be limited to 16 bit math like its target.  That limitation 
+ * would mean that 32 bit comparisons can't be done accurately.  
+ * To increase robustness to this, comparisons are done against
+ * smaller values first.  An inaccurate 32 bit comparison isn't
+ * attempted if the 16 bit comparison has already succeeded.
+ *
+ * Limitations on preprocessor math can also be stricter than
+ * for the target.  There are known cases where a compiler
+ * targeting processors with 64 bit longs can't do accurate
+ * preprocessor comparisons on more than 32 bits.  
+ */
+
+/* Determine the number of bits for int, long, short, and char.
+ * If one fails to be determined, set the number of bits to -1
+ */
+
+#ifndef TMW_BITS_PER_INT
+# if   INT_MAX  == 0x7FL
+#  define TMW_BITS_PER_INT 8
+# elif INT_MAX  == 0x7FFFL
+#  define TMW_BITS_PER_INT 16
+# elif INT_MAX  == 0x7FFFFFFFL
+#  define TMW_BITS_PER_INT 32
+# else
+#  define TMW_BITS_PER_INT -1
+# endif
+#endif
+
+#ifndef TMW_BITS_PER_LONG
+# if   LONG_MAX  == 0x7FL
+#  define TMW_BITS_PER_LONG 8
+# elif LONG_MAX  == 0x7FFFL
+#  define TMW_BITS_PER_LONG 16
+# elif LONG_MAX  == 0x7FFFFFFFL
+#  define TMW_BITS_PER_LONG 32
+# else
+#  define TMW_BITS_PER_LONG -1
+# endif
+#endif
+
+#ifndef TMW_BITS_PER_SHRT
+# if   SHRT_MAX  == 0x7FL
+#  define TMW_BITS_PER_SHRT 8
+# elif SHRT_MAX  == 0x7FFFL
+#  define TMW_BITS_PER_SHRT 16
+# elif SHRT_MAX  == 0x7FFFFFFFL
+#  define TMW_BITS_PER_SHRT 32
+# else
+#  define TMW_BITS_PER_SHRT -1
+# endif
+#endif
+
+#ifndef TMW_BITS_PER_SCHAR
+# if   SCHAR_MAX  == 0x7FL
+#  define TMW_BITS_PER_SCHAR 8
+# elif SCHAR_MAX  == 0x7FFFL
+#  define TMW_BITS_PER_SCHAR 16
+# elif SCHAR_MAX  == 0x7FFFFFFFL
+#  define TMW_BITS_PER_SCHAR 32
+# else
+#  define TMW_BITS_PER_SCHAR -1
+# endif
+#endif
+
+#ifndef TMW_CHAR_SIGNED
+# if SCHAR_MAX == CHAR_MAX
+#  define TMW_CHAR_SIGNED 1
+# else
+#  define TMW_CHAR_SIGNED 0
+# endif
+#endif
+
+/* It is common for one or more of the integer types
+ * to be the same size.  For example, on many embedded
+ * processors, both shorts and ints are 16 bits.  On
+ * processors used for workstations, it is quite common
+ * for both int and long to be 32 bits.  
+ *   When there is more than one choice for typdef'ing
+ * a portable type like int16_T or uint32_T, in
+ * concept, it should not matter which choice is made.
+ * However, some style guides and some code checking
+ * tools do identify and complain about seemingly
+ * irrelevant differences.  For example, a code
+ * checking tool may complain about an implicit
+ * conversion from int to short even though both
+ * are 16 bits.  To reduce these types of
+ * complaints, it is best to make int the
+ * preferred choice when more than one is available.
+ */
+
+#ifndef INT8_T
+# if   TMW_BITS_PER_INT   == 8
+#  define  INT8_T int
+# elif TMW_BITS_PER_LONG  == 8
+#  define  INT8_T long
+# elif TMW_BITS_PER_SCHAR == 8
+#  if TMW_CHAR_SIGNED
+#   define INT8_T char
+#  else
+#   define INT8_T signed char
+#  endif
+# elif TMW_BITS_PER_SHRT  == 8
+#  define  INT8_T short
+# endif
+#endif
+#ifdef INT8_T
+ typedef INT8_T int8_T;
+#endif
+
+#ifndef UINT8_T
+# if   TMW_BITS_PER_INT   == 8
+#  define  UINT8_T unsigned int
+# elif TMW_BITS_PER_LONG  == 8
+#  define  UINT8_T unsigned long
+# elif TMW_BITS_PER_SCHAR == 8
+#  if TMW_CHAR_SIGNED
+#   define UINT8_T unsigned char
+#  else
+#   define UINT8_T char
+#  endif
+# elif TMW_BITS_PER_SHRT  == 8
+#  define  UINT8_T unsigned short
+# endif
+#endif
+#ifdef UINT8_T
+ typedef UINT8_T uint8_T;
+#endif
+
+
+#ifndef INT16_T
+# if   TMW_BITS_PER_INT   == 16
+#  define  INT16_T int
+# elif TMW_BITS_PER_LONG  == 16
+#  define  INT16_T long
+# elif TMW_BITS_PER_SCHAR == 16
+#  if TMW_CHAR_SIGNED
+#   define INT16_T char
+#  else
+#   define INT16_T signed char
+#  endif
+# elif TMW_BITS_PER_SHRT  == 16
+#  define  INT16_T short
+# endif
+#endif
+#ifdef INT16_T
+ typedef INT16_T int16_T;
+#endif
+
+
+#ifndef UINT16_T
+# if   TMW_BITS_PER_INT   == 16
+#  define  UINT16_T unsigned int
+# elif TMW_BITS_PER_LONG  == 16
+#  define  UINT16_T unsigned long
+# elif TMW_BITS_PER_SCHAR == 16
+#  if TMW_CHAR_SIGNED
+#   define UINT16_T unsigned char
+#  else
+#   define UINT16_T char
+#  endif
+# elif TMW_BITS_PER_SHRT  == 16
+#  define  UINT16_T unsigned short
+# endif
+#endif
+#ifdef UINT16_T
+ typedef UINT16_T uint16_T;
+#endif
+
+
+#ifndef INT32_T
+# if   TMW_BITS_PER_INT   == 32
+#  define  INT32_T int
+# elif TMW_BITS_PER_LONG  == 32
+#  define  INT32_T long
+# elif TMW_BITS_PER_SCHAR == 32
+#  if TMW_CHAR_SIGNED
+#   define INT32_T char
+#  else
+#   define INT32_T signed char
+#  endif
+# elif TMW_BITS_PER_SHRT  == 32
+#  define  INT32_T short
+# endif
+#endif
+#ifdef INT32_T
+ typedef INT32_T int32_T;
+#endif
+
+
+#ifndef UINT32_T
+# if   TMW_BITS_PER_INT   == 32
+#  define  UINT32_T unsigned int
+# elif TMW_BITS_PER_LONG  == 32
+#  define  UINT32_T unsigned long
+# elif TMW_BITS_PER_SCHAR == 32
+#  if TMW_CHAR_SIGNED
+#   define UINT32_T unsigned char
+#  else
+#   define UINT32_T char
+#  endif
+# elif TMW_BITS_PER_SHRT  == 32
+#  define  UINT32_T unsigned short
+# endif
+#endif
+#ifdef UINT32_T
+ typedef UINT32_T uint32_T;
+#endif
+
+/* The following is used to emulate smaller integer types when only
+ * larger types are available.  For example, compilers for TI C3x/C4x DSPs 
+ * define char and short to be 32 bits, so 8 and 16 bits are not directly
+ * available.  This target is commonly used with RTW rapid prototyping.
+ * Other DSPs define char to be 16 bits, so 8 bits is not directly 
+ * available.
+ */
+#ifndef INT8_T
+# ifdef INT16_T
+    typedef INT16_T int8_T;
+# else
+#  ifdef INT32_T
+    typedef INT32_T int8_T;
+#  endif
+# endif
+#endif
+
+#ifndef UINT8_T
+# ifdef UINT16_T
+    typedef UINT16_T uint8_T;
+# else
+#  ifdef UINT32_T
+    typedef UINT32_T uint8_T;
+#  endif
+# endif
+#endif
+
+#ifndef INT16_T
+# ifdef INT32_T
+    typedef INT32_T int16_T;
+# endif
+#endif
+
+#ifndef UINT16_T
+# ifdef UINT32_T
+    typedef UINT32_T uint16_T;
+# endif
+#endif
+
+
+#ifndef NO_FLOATS
+
+#ifndef REAL32_T
+# ifndef __MWERKS__
+#  if FLT_MANT_DIG >= 23
+#   define REAL32_T float
+#  endif
+# else
+#  define REAL32_T float
+# endif
+#endif
+#ifdef REAL32_T
+ typedef REAL32_T real32_T;
+#endif
+
+
+#ifndef REAL64_T
+# ifndef __MWERKS__
+#  if DBL_MANT_DIG >= 52
+#   define REAL64_T double
+#  endif
+# else
+#  define REAL64_T double
+# endif
+#endif
+#ifdef REAL64_T
+ typedef REAL64_T real64_T;
+#endif
+
+#endif /* NO_FLOATS*/
+
+/*=======================================================================*
+ * Fixed width word size data types:                                     *
+ *   int64_T                      - signed 64 bit integers               *
+ *   uint64_T                     - unsigned 64 bit integers             *
+ *=======================================================================*/
+
+
+
+#ifndef INT64_T
+# if defined(__alpha) || defined(__sparcv9) || defined(__ia64) || \
+     defined(__ia64__) || defined(__x86_64__) || defined(__LP64__)
+#  define INT64_T long
+#  define FMT64 "l"
+# elif defined(_MSC_VER) || (defined(__BORLANDC__) && __BORLANDC__ >= 0x530) \
+                         || (defined(__WATCOMC__)  && __WATCOMC__  >= 1100)
+#  define INT64_T __int64
+#  define FMT64 "I64"
+# elif defined(__GNUC__) || defined(__hpux) || defined(__sun) \
+			 || defined(TMW_ENABLE_INT64)
+#  define INT64_T long long
+#  define FMT64 "ll"
+# endif
+#endif
+
+
+
+#if defined(INT64_T)
+# if (__GNUC__ > 2) || ((__GNUC__ == 2) && (__GNUC_MINOR__ >=9))
+  __extension__
+# endif
+ typedef INT64_T int64_T;
+#endif
+
+
+
+#ifndef UINT64_T
+# if defined(__alpha) || defined(__sparcv9) || defined(__ia64) || \
+     defined(__ia64__) || defined(__x86_64__) || defined(__LP64__)
+#  define UINT64_T unsigned long
+#  define FMT64 "l"
+# elif defined(_MSC_VER) || (defined(__BORLANDC__) && __BORLANDC__ >= 0x530) \
+                         || (defined(__WATCOMC__)  && __WATCOMC__  >= 1100)
+#  define UINT64_T unsigned __int64
+#  define FMT64 "I64"
+# elif defined(__GNUC__) || defined(__hpux) || defined(__sun) \
+			 || defined(TMW_ENABLE_INT64)
+#  define UINT64_T unsigned long long
+#  define FMT64 "ll"
+# endif
+#endif
+
+
+
+#if defined(UINT64_T)
+# if (__GNUC__ > 2) || ((__GNUC__ == 2) && (__GNUC_MINOR__ >=9))
+  __extension__
+# endif
+ typedef UINT64_T uint64_T;
+#endif
+
+/*===========================================================================*
+ * Format string modifiers for using size_t variables in printf statements.  *
+ *===========================================================================*/
+
+#ifndef FMT_SIZE_T
+#  if defined( __GNUC__ ) || defined(_STDC_C99)
+#    define FMT_SIZE_T "z"
+#  elif defined (__WATCOMC__)
+#    define FMT_SIZE_T "l"
+#  elif defined (_WIN32 )
+#    define FMT_SIZE_T "I"
+#  else
+#    define FMT_SIZE_T "l"
+#  endif
+#endif
+
+/*===========================================================================*
+ * General or logical data types where the word size is not guaranteed.      *
+ *  real_T     - possible settings include real32_T or real64_T              *
+ *  time_T     - possible settings include real64_T or uint32_T              *
+ *  boolean_T                                                                *
+ *  char_T                                                                   *
+ *  int_T                                                                    *
+ *  uint_T                                                                   *
+ *  byte_T                                                                   *
+ *===========================================================================*/
+
+#ifndef NO_FLOATS
+
+#ifndef REAL_T
+# ifdef REAL64_T
+#  define REAL_T real64_T
+# else
+#  ifdef REAL32_T
+#   define REAL_T real32_T
+#  endif
+# endif
+#endif
+#ifdef REAL_T
+ typedef REAL_T real_T;
+#endif
+
+#ifndef TIME_T
+# ifdef REAL_T
+#  define TIME_T real_T
+# endif
+#endif
+#ifdef TIME_T
+ typedef TIME_T time_T;
+#endif
+
+#endif /* NO_FLOATS */
+
+#ifndef BOOLEAN_T
+# if defined(UINT8_T)
+#  define BOOLEAN_T UINT8_T
+# else
+#  define BOOLEAN_T unsigned int
+# endif
+#endif
+typedef BOOLEAN_T boolean_T;
+
+
+#ifndef CHARACTER_T
+# define CHARACTER_T char
+#endif
+typedef CHARACTER_T char_T;
+
+
+#ifndef INTEGER_T
+# define INTEGER_T int
+#endif
+typedef INTEGER_T int_T;
+
+
+#ifndef UINTEGER_T
+# define UINTEGER_T unsigned
+#endif
+typedef UINTEGER_T uint_T;
+
+
+#ifndef BYTE_T
+# define BYTE_T unsigned char
+#endif
+typedef BYTE_T byte_T;
+
+
+/*===========================================================================*
+ * Define Complex Structures                                                 *
+ *===========================================================================*/
+#ifndef NO_FLOATS
+
+#ifndef CREAL32_T
+#  ifdef REAL32_T
+    typedef struct {
+      real32_T re, im;
+    } creal32_T;
+#    define CREAL32_T creal32_T
+#  endif
+#endif
+
+#ifndef CREAL64_T
+#  ifdef REAL64_T
+    typedef struct {
+      real64_T re, im;
+    } creal64_T;
+#    define CREAL64_T creal64_T
+#  endif
+#endif
+
+#ifndef CREAL_T
+#  ifdef REAL_T
+    typedef struct {
+      real_T re, im;
+    } creal_T;
+#    define CREAL_T creal_T
+#  endif
+#endif
+
+#endif /* NO_FLOATS */
+
+#ifndef CINT8_T
+#  ifdef INT8_T
+    typedef struct {
+      int8_T re, im;
+    } cint8_T;
+#    define CINT8_T cint8_T
+#  endif
+#endif
+
+#ifndef CUINT8_T
+#  ifdef UINT8_T
+    typedef struct {
+      uint8_T re, im;
+    } cuint8_T;
+#    define CUINT8_T cuint8_T
+#  endif
+#endif
+
+#ifndef CINT16_T
+#  ifdef INT16_T
+    typedef struct {
+      int16_T re, im;
+    } cint16_T;
+#    define CINT16_T cint16_T
+#  endif
+#endif
+
+#ifndef CUINT16_T
+#  ifdef UINT16_T
+    typedef struct {
+      uint16_T re, im;
+    } cuint16_T;
+#    define CUINT16_T cuint16_T
+#  endif
+#endif
+
+#ifndef CINT32_T
+#  ifdef INT32_T
+    typedef struct {
+      int32_T re, im;
+    } cint32_T;
+#    define CINT32_T cint32_T
+#  endif
+#endif
+
+#ifndef CUINT32_T
+#  ifdef UINT32_T
+    typedef struct {
+      uint32_T re, im;
+    } cuint32_T;
+#    define CUINT32_T cuint32_T
+#  endif
+#endif
+
+/*=======================================================================*
+ * Min and Max:                                                          *
+ *   int8_T, int16_T, int32_T     - signed 8, 16, or 32 bit integers     *
+ *   uint8_T, uint16_T, uint32_T  - unsigned 8, 16, or 32 bit integers   *
+ *=======================================================================*/
+
+#define  MAX_int8_T      ((int8_T)(127))            /* 127  */
+#define  MIN_int8_T      ((int8_T)(-128))           /* -128 */
+#define  MAX_uint8_T     ((uint8_T)(255))           /* 255  */
+#define  MIN_uint8_T     ((uint8_T)(0))
+                           
+#define  MAX_int16_T     ((int16_T)(32767))         /* 32767 */
+#define  MIN_int16_T     ((int16_T)(-32768))        /* -32768 */
+#define  MAX_uint16_T    ((uint16_T)(65535))        /* 65535 */
+#define  MIN_uint16_T    ((uint16_T)(0))
+                           
+#define  MAX_int32_T     ((int32_T)(2147483647))    /* 2147483647  */
+#define  MIN_int32_T     ((int32_T)(-2147483647-1)) /* -2147483648 */
+#define  MAX_uint32_T    ((uint32_T)(0xFFFFFFFFU))  /* 4294967295  */
+#define  MIN_uint32_T    ((uint32_T)(0))
+
+#if defined(_MSC_VER) || (defined(__BORLANDC__) && __BORLANDC__ >= 0x530) \
+                      || (defined(__WATCOMC__)  && __WATCOMC__  >= 1100)
+#  ifdef INT64_T
+#    define  MAX_int64_T     ((int64_T)(9223372036854775807))
+#    define  MIN_int64_T     ((int64_T)(-9223372036854775807-1))
+#  endif
+#  ifdef UINT64_T
+#    define  MAX_uint64_T    ((uint64_T)(0xFFFFFFFFFFFFFFFFU))
+#    define  MIN_uint64_T    ((uint64_T)(0))
+#  endif
+#else
+#  ifdef INT64_T
+#    define  MAX_int64_T     ((int64_T)(9223372036854775807LL))
+#    define  MIN_int64_T     ((int64_T)(-9223372036854775807LL-1LL))
+#  endif
+#  ifdef UINT64_T
+#    define  MAX_uint64_T    ((uint64_T)(0xFFFFFFFFFFFFFFFFLLU))
+#    define  MIN_uint64_T    ((uint64_T)(0))
+#  endif
+#endif
+
+#ifdef _MSC_VER
+/* Conversion from unsigned __int64 to double is not implemented in windows
+ * and results in a compile error, thus the value must first be cast to
+ * signed __int64, and then to double.
+ *
+ * If the 64 bit int value is greater than 2^63-1, which is the signed int64 max,
+ * the macro below provides a workaround for casting a uint64 value to a double
+ * in windows.
+ */
+#  define uint64_to_double(u) ( ((u) > _I64_MAX) ? \
+            (double)(__int64)((u) - _I64_MAX - 1) + (double)_I64_MAX + 1: \
+            (double)(__int64)(u) )
+
+/* The largest double value that can be cast to uint64 in windows is the
+ * signed int64 max, which is 2^63-1. The macro below provides
+ * a workaround for casting large double values to uint64 in windows.
+ */
+#  define double_to_uint64(d) ( ((d) > 0xffffffffffffffffu) ? \
+            (unsigned __int64) 0xffffffffffffffffu : \
+            ((d) < 0) ? (unsigned __int64) 0 : \
+            ((d) > _I64_MAX) ? \
+            (unsigned __int64) ((d) - _I64_MAX) - 1 + (unsigned __int64)_I64_MAX + 1: \
+            (unsigned __int64)(d) )
+#else
+#  define uint64_to_double(u) ((double)(u))
+#  if defined(__BORLANDC__) || defined(__WATCOMC__) || defined(__TICCSC__)
+/* double_to_uint64 defined only for MSVC and UNIX */
+#  else
+#  define double_to_uint64(d) ( ((d) > 0xffffffffffffffffLLU) ? \
+            (unsigned long long) 0xffffffffffffffffLLU : \
+            ((d) < 0) ? (unsigned long long) 0 : (unsigned long long)(d) )
+#  endif
+#endif
+
+#if !defined(__cplusplus) && !defined(__bool_true_false_are_defined)
+
+#ifndef _bool_T
+#define _bool_T
+
+typedef boolean_T bool;
+
+#ifndef false
+#define false (0)
+#endif
+#ifndef true 
+#define true (1)
+#endif
+
+#endif /* _bool_T */
+
+#endif /* !__cplusplus */
+
+/* 
+ * This software assumes that the code is being compiled on a target using a 
+ * 2's complement representation for signed integer values.
+ */
+#if ((SCHAR_MIN + 1) != -SCHAR_MAX)
+#error "This code must be compiled using a 2's complement representation for signed integer values"
+#endif
+
+/*
+ * Maximum length of a MATLAB identifier (function/variable/model)
+ * including the null-termination character.
+ */
+#define TMW_NAME_LENGTH_MAX 64
+
+/*
+ * Maximum values for indices and dimensions
+ */
+#include <stddef.h>
+
+#ifdef MX_COMPAT_32
+typedef int mwSize;
+typedef int mwIndex;
+typedef int mwSignedIndex;
+#else
+typedef size_t    mwSize;         /* unsigned pointer-width integer */
+typedef size_t    mwIndex;        /* unsigned pointer-width integer */
+typedef ptrdiff_t mwSignedIndex;  /* a signed pointer-width integer */
+#endif
+
+#if (defined(_LP64) || defined(_WIN64)) && !defined(MX_COMPAT_32)
+/* Currently 2^48 based on hardware limitations */
+# define MWSIZE_MAX    281474976710655UL
+# define MWINDEX_MAX   281474976710655UL
+# define MWSINDEX_MAX  281474976710655L
+# define MWSINDEX_MIN -281474976710655L
+#else
+# define MWSIZE_MAX    2147483647UL
+# define MWINDEX_MAX   2147483647UL
+# define MWSINDEX_MAX  2147483647L
+# define MWSINDEX_MIN -2147483647L
+#endif
+#define MWSIZE_MIN    0UL
+#define MWINDEX_MIN   0UL
+
+#endif  /* __TMWTYPES__ */
+
+#endif /* tmwtypes_h */

external/externalsim.cpp

@@ -0,0 +1,10 @@
+#include "externalsim.h"
+
+ExternalSim::ExternalSim(QObject *parent, uint32_t PlatformID, uint32_t InstanceID, bool SwitchMode, QString Name, QUrl SimulationUrl) : QObject(parent)
+{
+    this->PlatformID = PlatformID;
+    this->InstanceID = InstanceID;
+    this->Name = Name;
+    this->SimulatorUrl = SimulationUrl;
+    this->SwitchMode = SwitchMode;
+}

external/externalsim.h

@@ -0,0 +1,26 @@
+#ifndef EXTERNALSIM_H
+#define EXTERNALSIM_H
+
+#include <QObject>
+#include <QUrl>
+
+class ExternalSim : public QObject
+{
+    Q_OBJECT
+public:
+    uint32_t PlatformID;
+    uint32_t InstanceID;
+    bool SwitchMode;
+    QString Name;
+    QUrl SimulatorUrl;
+
+    explicit ExternalSim(QObject *parent = nullptr, uint32_t PlatformID = 0,
+                         uint32_t InstanceID = 0, bool SwitchMode = false,
+                         QString Name = QString::fromLocal8Bit("未知模拟器"),
+                         QUrl SimulationUrl = QUrl(QStringLiteral("ws://localhost:1235")));
+
+signals:
+
+};
+
+#endif // EXTERNALSIM_H

external/jamming.cpp

@@ -0,0 +1,24 @@
+#include "jamming.h"
+
+Jamming::Jamming(QObject *parent,
+                 uint32_t PlatformID, uint32_t InstanceID, bool SwitchMode,
+                 QString Name, QUrl SimulationUrl,
+                 int style) : ExternalSim(parent)
+{
+    StyleInit();
+    this->PlatformID = PlatformID;
+    this->InstanceID = InstanceID;
+    this->SwitchMode = SwitchMode;
+    this->Name = Name;
+    this->SimulatorUrl = SimulationUrl;
+    this->style = style;
+}
+
+void Jamming::StyleInit()
+{
+    JammingStyle Jamming001;
+    Jamming001.OpMode = QString::fromLocal8Bit("噪声直放干扰");
+    Jamming001.fc = 9.5e9;
+    Jamming001.fs = 20e9;
+    JammingStyleList.insert(std::pair<int, JammingStyle>(1,Jamming001));
+}

external/jamming.h

@@ -0,0 +1,34 @@
+#ifndef JAMMING_H
+#define JAMMING_H
+
+#include <QObject>
+#include <QUrl>
+#include "externalsim.h"
+
+struct JammingStyle
+{
+    double fs;
+    double fc;
+    QString OpMode;
+};
+
+class Jamming : public ExternalSim
+{
+    Q_OBJECT
+public:
+    int style;
+    std::map<int, JammingStyle> JammingStyleList;
+
+    void StyleInit();
+    explicit Jamming(QObject *parent = nullptr,
+                     uint32_t PlatformID = 0, uint32_t InstanceID = 0,
+                     bool SwitchMode = false,
+                     QString Name = QString::fromLocal8Bit("未知模拟器"),
+                     QUrl SimulationUrl = QUrl(QStringLiteral("ws://localhost:1235")),
+                     int style = 0);
+
+signals:
+
+};
+
+#endif // JAMMING_H

external/radar.cpp

@@ -0,0 +1,149 @@
+#include "radar.h"
+
+Radar::Radar(QObject *parent,
+             uint32_t PlatformID, uint32_t InstanceID, bool SwitchMode,
+             QString Name, QUrl SimulationUrl,
+             int style) : ExternalSim(parent)
+{
+    StyleInit();
+    this->PlatformID = PlatformID;
+    this->InstanceID = InstanceID;
+    this->SwitchMode = SwitchMode;
+    this->Name = Name;
+    this->SimulatorUrl = SimulationUrl;
+    this->style = style;
+    radarsim = new client(nullptr, SimulationUrl);
+    connect(this,&Radar::SigSendStyleToSim,
+            radarsim,&client::SlotSendStyleToSim);
+}
+
+void Radar::StyleInit()
+{
+    Style Radar101;
+    Radar101.fs = 20e9;
+    Radar101.fc = 9.5e9;
+    Radar101.moduType = QString::fromLocal8Bit("矩形脉冲");
+    Radar101.PRFMode = QString::fromLocal8Bit("抖动");
+    Radar101.PRFs.push_back(1/2e-6);
+    Radar101.PRFs.push_back(1/3e-6);
+    Radar101.PRFs.push_back(1/4e-6);
+    Radar101.PulseWidth = 1e-6;
+    RadarStyleList.insert(std::pair<int, Style>(101,Radar101));
+
+    Style Radar201;
+    Radar201.fs = 20e9;
+    Radar201.fc = 9.5e9;
+    Radar201.moduType = QString::fromLocal8Bit("相位编码");
+    Radar201.PRFMode = QString::fromLocal8Bit("抖动");
+    Radar201.PRFs.push_back(1/2e-6);
+    Radar201.PRFs.push_back(1/3e-6);
+    Radar201.PRFs.push_back(1/4e-6);
+    Radar201.PulseWidth = 1e-6;
+    RadarStyleList.insert(std::pair<int, Style>(201,Radar201));
+
+    Style Radar301;
+    Radar301.fs = 20e9;
+    Radar301.fc = 9.5e9;
+    Radar301.moduType = QString::fromLocal8Bit("线性调频");
+    Radar301.PRFMode = QString::fromLocal8Bit("抖动");
+    Radar301.PRFs.push_back(1/2e-6);
+    Radar301.PRFs.push_back(1/3e-6);
+    Radar301.PRFs.push_back(1/4e-6);
+    Radar301.PulseWidth = 1e-6;
+    Radar301.BandWidth = 1e9;
+    RadarStyleList.insert(std::pair<int, Style>(301,Radar301));
+
+    Style Radar401;
+    Radar401.fs = 20e9;
+    Radar401.fc = 9.5e9;
+    Radar401.moduType = QString::fromLocal8Bit("调频连续");
+    Radar401.PRFMode = QString::fromLocal8Bit("抖动");
+    Radar401.PRFs.push_back(1/2e-6);
+    Radar401.PRFs.push_back(1/3e-6);
+    Radar401.PRFs.push_back(1/4e-6);
+    Radar401.PulseWidth = 1e-6;
+    Radar401.BandWidth = 1e9;
+    RadarStyleList.insert(std::pair<int, Style>(401,Radar401));
+
+    Style Radar102;
+    Radar102.fs = 20e9;
+    Radar102.fc = 9.5e9;
+    Radar102.moduType = QString::fromLocal8Bit("矩形脉冲");
+    Radar102.PRFMode = QString::fromLocal8Bit("固定");
+    Radar102.PRFs.push_back(1/3e-6);
+    Radar102.PulseWidth = 1e-6;
+    RadarStyleList.insert(std::pair<int, Style>(102,Radar102));
+
+    Style Radar202;
+    Radar202.fs = 20e9;
+    Radar202.fc = 9.5e9;
+    Radar202.moduType = QString::fromLocal8Bit("相位编码");
+    Radar202.PRFMode = QString::fromLocal8Bit("固定");
+    Radar202.PRFs.push_back(1/3e-6);
+    Radar202.PulseWidth = 1e-6;
+    RadarStyleList.insert(std::pair<int, Style>(202,Radar202));
+
+    Style Radar302;
+    Radar302.fs = 20e9;
+    Radar302.fc = 9.5e9;
+    Radar302.moduType = QString::fromLocal8Bit("线性调频");
+    Radar302.PRFMode = QString::fromLocal8Bit("固定");
+    Radar302.PRFs.push_back(1/3e-6);
+    Radar302.PulseWidth = 1e-6;
+    Radar302.BandWidth = 1e9;
+    RadarStyleList.insert(std::pair<int, Style>(302,Radar302));
+
+    Style Radar402;
+    Radar402.fs = 20e9;
+    Radar402.fc = 9.5e9;
+    Radar402.moduType = QString::fromLocal8Bit("调频连续");
+    Radar402.PRFMode = QString::fromLocal8Bit("固定");
+    Radar402.PRFs.push_back(1/3e-6);
+    Radar402.PulseWidth = 1e-6;
+    Radar402.BandWidth = 1e9;
+    RadarStyleList.insert(std::pair<int, Style>(402,Radar402));
+
+    Style Radar103;
+    Radar103.fs = 20e9;
+    Radar103.fc = 9.5e9;
+    Radar103.moduType = QString::fromLocal8Bit("矩形脉冲");
+    Radar103.PRFMode = QString::fromLocal8Bit("固定");
+    Radar103.PRFs.push_back(1/2e-6);
+    Radar103.PulseWidth = 0.5e-6;
+    RadarStyleList.insert(std::pair<int, Style>(103,Radar103));
+
+    Style Radar203;
+    Radar203.fs = 20e9;
+    Radar203.fc = 9.5e9;
+    Radar203.moduType = QString::fromLocal8Bit("相位编码");
+    Radar203.PRFMode = QString::fromLocal8Bit("固定");
+    Radar203.PRFs.push_back(1/2e-6);
+    Radar203.PulseWidth = 0.5e-6;
+    RadarStyleList.insert(std::pair<int, Style>(203,Radar203));
+
+    Style Radar303;
+    Radar303.fs = 20e9;
+    Radar303.fc = 9.5e9;
+    Radar303.moduType = QString::fromLocal8Bit("线性调频");
+    Radar303.PRFMode = QString::fromLocal8Bit("固定");
+    Radar303.PRFs.push_back(1/2e-6);
+    Radar303.PulseWidth = 0.5e-6;
+    Radar303.BandWidth = 0.5e9;
+    RadarStyleList.insert(std::pair<int, Style>(303,Radar303));
+
+    Style Radar403;
+    Radar403.fs = 20e9;
+    Radar403.fc = 9.5e9;
+    Radar403.moduType = QString::fromLocal8Bit("调频连续");
+    Radar403.PRFMode = QString::fromLocal8Bit("固定");
+    Radar403.PRFs.push_back(1/2e-6);
+    Radar403.PulseWidth = 0.5e-6;
+    Radar303.BandWidth = 0.5e9;
+    RadarStyleList.insert(std::pair<int, Style>(403,Radar403));
+}
+
+void Radar::StyleUpdate(int newstyle)
+{
+    style = newstyle;
+    emit SigSendStyleToSim(QString::number(newstyle));
+}

external/radar.h

@@ -0,0 +1,43 @@
+#ifndef RADAR_H
+#define RADAR_H
+
+#include <QObject>
+#include <QThread>
+#include "externalsim.h"
+#include "../wsclient/client.h"
+
+struct Style
+{
+    double fs;
+    double fc;
+    QString moduType;
+    QString PRFMode;
+    std::vector<double> PRFs;
+    double PulseWidth;
+    double BandWidth;
+};
+
+class Radar : public ExternalSim
+{
+    Q_OBJECT
+
+public:
+    int style;
+    std::map<int, Style> RadarStyleList;
+    client *radarsim;
+    QThread *radarsimthread;
+
+    explicit Radar(QObject *parent = nullptr,
+                   uint32_t PlatformID = 0, uint32_t InstanceID = 0,
+                   bool SwitchMode = false,
+                   QString Name = QString::fromLocal8Bit("未知模拟器"),
+                   QUrl SimulationUrl = QUrl(QStringLiteral("ws://localhost:1235")),
+                   int style = 101);
+    void StyleInit();
+signals:
+    void SigSendStyleToSim(QString newstyle);
+public slots:
+    void StyleUpdate(int newstyle);
+};
+
+#endif // RADAR_H

main.cpp

@@ -0,0 +1,13 @@
+#include <QCoreApplication>
+//#include "QtWebSockets/QWebSocketServer"
+//#include "QtWebSockets/QWebSocket"
+#include "backgroundserver.h"
+
+int main(int argc, char *argv[])
+{
+    QCoreApplication a(argc, argv);
+
+    BackgroundServer *server = new BackgroundServer(nullptr,1234);
+
+    return a.exec();
+}

platform.cpp

@@ -0,0 +1,60 @@
+#include "platform.h"
+
+Platform::Platform(QObject *parent, uint32_t ID, QString Name,
+                   double initlon, double initlat, double inith,
+                   double vx, double vy, double vz,
+                   double ax,double ay, double az) : QObject(parent)
+{
+    this->ID = ID;
+    this->Name = Name;
+    lon = initlon;
+    lat = initlat;
+    h = inith;
+    x = new double();
+    y = new double();
+    z = new double();
+    blh2xyz(initlat,initlon,inith,x,y,z);
+    this->vx = vx;
+    this->vy = vy;
+    this->vz = vz;
+    this->ax = ax;
+    this->ay = ay;
+    this->az = az;
+    TimerUpdatePos = startTimer(1000);
+}
+
+void Platform::UpdateAcc(double ax, double ay, double az)
+{
+    this->ax = ax;
+    this->ay = ay;
+    this->az = az;
+}
+
+void Platform::UpdateVel(double vx, double vy, double vz)
+{
+    this->vx = vx;
+    this->vy = vy;
+    this->vz = vz;
+}
+
+void Platform::timerEvent(QTimerEvent *event)
+{
+    if (event->timerId() == TimerUpdatePos)
+    {
+        vx = vx + ax;
+        vy = vy + ay;
+        vz = vz + az;
+
+        double vel = vx*vx + vy*vy +vz*vz;
+        if (vel > 1e-5)
+        {
+            *x = *x + vx;
+            *y = *y + vy;
+            *z = *z + vz;
+
+            double pos[3] = {*x,*y,*z};
+            XYZ2ELL(pos,&lat,&lon,&h);
+            qDebug() << this->Name << QString::fromLocal8Bit("位置更新");
+        }
+    }
+}

platform.h

@@ -0,0 +1,43 @@
+#ifndef PLATFORM_H
+#define PLATFORM_H
+
+#include <QObject>
+#include <QTimerEvent>
+#include <QDebug>
+#include "coordTrans/XYZ2ELL.h"
+#include "coordTrans/blh2xyz.h"
+
+class Platform : public QObject
+{
+    Q_OBJECT
+public:
+    uint32_t ID;
+    QString Name;
+    double *x;
+    double *y;
+    double *z;
+    double vx;
+    double vy;
+    double vz;
+    double ax;
+    double ay;
+    double az;
+    double lon;
+    double lat;
+    double h;
+    int TimerUpdatePos;
+    explicit Platform(QObject *parent = nullptr, uint32_t ID = 0,
+                      QString Name = QString::fromLocal8Bit("未知平台"),
+                      double initlon = 120, double initlat = 20, double inith = 8000,
+                      double vx = 0, double vy = 0, double vz = 0,
+                      double ax = 0, double ay = 0, double az = 0);
+
+    void UpdateAcc(double ax, double ay, double az);
+    void UpdateVel(double vx, double vy, double vz);
+
+    void timerEvent(QTimerEvent *event);
+signals:
+
+};
+
+#endif // PLATFORM_H

simulationcontrol.cpp

@@ -0,0 +1,934 @@
+#include "simulationcontrol.h"
+
+SimulationControl::SimulationControl(QObject *parent) : QObject(parent)
+{
+    // 添加场景平台
+    allyplane.push_back(new Platform(this, 1001, QString::fromLocal8Bit("干扰机_1"),120,27,8000,-200,200,-300));
+    allyplane.push_back(new Platform(this, 1002, QString::fromLocal8Bit("干扰机_2"),120.3,27,8000,-200,200,-300));
+    allyplane.push_back(new Platform(this, 1003, QString::fromLocal8Bit("干扰机_3"),120,27.3,8000,-200,200,-300));
+    allyplane.push_back(new Platform(this, 1004, QString::fromLocal8Bit("干扰机_4"),120.3,27.3,8000,-200,200,-300));
+
+    allymissile.push_back(new Platform(this, 2001, QString::fromLocal8Bit("弹道导弹1"),117,33,0));
+    allymissile.push_back(new Platform(this, 2001, QString::fromLocal8Bit("弹道导弹2"),117,33,0));
+    allymissile.push_back(new Platform(this, 2001, QString::fromLocal8Bit("弹道导弹3"),117,33,0));
+    allymissile.push_back(new Platform(this, 2001, QString::fromLocal8Bit("弹道导弹4"),117,33,0));
+
+    ally.push_back(allyplane);
+    ally.push_back(allymissile);
+
+    enemyradar.push_back(new Platform(this,6001,QString::fromLocal8Bit("Thaad系统1"),120,20,0));
+    enemyradar.push_back(new Platform(this,6002,QString::fromLocal8Bit("Thaad系统2"),122,20,0));
+
+    enemy.push_back(enemyradar);
+    enemy.push_back(enemysat);
+
+    // 添加雷达模拟器
+    Radar *radar1 = new Radar(this, 6001, 12, true, QString::fromLocal8Bit("AN-TPY/2雷达-1"),
+                              QStringLiteral("ws://localhost:1235"));
+    Radar *radar2 = new Radar(this, 6002, 13, false, QString::fromLocal8Bit("AN-TPY/2雷达-2"),
+                              QStringLiteral("ws://localhost:1236"));
+//    connect(this,&SimulationControl::SigRadarStyleUpdate,
+//            radar1,&Radar::StyleUpdate);
+//    connect(this,&SimulationControl::SigRadarStyleUpdate,
+//            radar2,&Radar::StyleUpdate);
+    enemyThaadRadarSim.insert(std::pair<int, Radar*>(12, radar1));
+    enemyThaadRadarSim.insert(std::pair<int, Radar*>(13, radar2));
+
+
+    // 添加干扰机
+    allyJammingSim.insert(std::pair<int, Jamming*>
+                          (20, new Jamming(this, 1001, 20, true, QString::fromLocal8Bit("干扰器1"))));
+    allyJammingSim.insert(std::pair<int, Jamming*>
+                          (21, new Jamming(this, 1002, 21, true, QString::fromLocal8Bit("干扰器1"))));
+    allyJammingSim.insert(std::pair<int, Jamming*>
+                          (22, new Jamming(this, 1003, 22, true, QString::fromLocal8Bit("干扰器1"))));
+    allyJammingSim.insert(std::pair<int, Jamming*>
+                          (23, new Jamming(this, 1004, 23, true, QString::fromLocal8Bit("干扰器1"))));
+}
+
+void SimulationControl::SlotGetInit(QWebSocket *pSender, QJsonObject obj)
+{
+    qDebug() << "Build with Slot";
+    QJsonObject *InitState = new QJsonObject();
+    InitState->insert("InitState", 100);
+
+    QJsonObject *ret = new QJsonObject();
+    ret->insert("url", obj.value("url"));
+    ret->insert("data", *InitState);
+    delete InitState;
+
+    emit SigReturnData(pSender, ret);
+}
+
+void SimulationControl::SlotGetLeadPost(QWebSocket *pSender, QJsonObject obj)
+{
+    QJsonArray *LeadPost = new QJsonArray();
+
+    QJsonObject *CurrentLeadPost;
+
+    CurrentLeadPost = new QJsonObject();
+    CurrentLeadPost->insert("time", "20:20:01");
+    CurrentLeadPost->insert("GroupID", "0001");
+    CurrentLeadPost->insert("LeaderID", "8013");
+    CurrentLeadPost->insert("Abstract", QString::fromLocal8Bit("发现雷达"));
+    LeadPost->append(*CurrentLeadPost);
+    delete CurrentLeadPost;
+    CurrentLeadPost = new QJsonObject();
+    CurrentLeadPost->insert("time", "20:20:30");
+    CurrentLeadPost->insert("GroupID", "0001");
+    CurrentLeadPost->insert("LeaderID", "8013");
+    CurrentLeadPost->insert("Abstract", QString::fromLocal8Bit("请求施加干扰"));
+    LeadPost->append(*CurrentLeadPost);
+    delete CurrentLeadPost;
+    CurrentLeadPost = new QJsonObject();
+    CurrentLeadPost->insert("time", "20:20:40");
+    CurrentLeadPost->insert("GroupID", "0003");
+    CurrentLeadPost->insert("LeaderID", "8014");
+    CurrentLeadPost->insert("Abstract", QString::fromLocal8Bit("干扰样式生成"));
+    LeadPost->append(*CurrentLeadPost);
+    delete CurrentLeadPost;
+    CurrentLeadPost = new QJsonObject();
+    CurrentLeadPost->insert("time", "20:21:00");
+    CurrentLeadPost->insert("GroupID", "0002");
+    CurrentLeadPost->insert("LeaderID", "8015");
+    CurrentLeadPost->insert("Abstract", QString::fromLocal8Bit("干扰信号发射"));
+    LeadPost->append(*CurrentLeadPost);
+    delete CurrentLeadPost;
+
+    QJsonObject *ret = new QJsonObject();
+    ret->insert("url", obj.value("url"));
+    ret->insert("PlatformID", obj.value("PlatformID"));
+    ret->insert("data", *LeadPost);
+
+    delete LeadPost;
+    emit SigReturnData(pSender, ret);
+}
+
+void SimulationControl::SlotGetTaskPlan(QWebSocket *pSender, QJsonObject obj)
+{
+    QJsonObject *TaskPlan = new QJsonObject();
+
+    QJsonObject *CurrentAirLine;
+    QJsonObject *CurrentTaskPlan;
+
+    CurrentAirLine = new QJsonObject;
+    CurrentAirLine->insert("TargetArea", 3);
+    CurrentAirLine->insert("Longitude", 123);
+    CurrentAirLine->insert("Longitude", 27);
+    CurrentAirLine->insert("Radius", 300000);
+
+    CurrentTaskPlan = new QJsonObject;
+    CurrentTaskPlan->insert("TargetArea", 2);
+    CurrentTaskPlan->insert("ThrowGas", 2);
+    CurrentTaskPlan->insert("ThrowBT", 2);
+
+    TaskPlan->insert("Airline", *CurrentAirLine);
+    TaskPlan->insert("TaskPlan", *CurrentTaskPlan);
+
+    QJsonObject *ret = new QJsonObject();
+    ret->insert("url", obj.value("url"));
+    ret->insert("PlatformID", obj.value("PlatformID"));
+    ret->insert("data", *TaskPlan);
+
+    delete TaskPlan;
+    delete CurrentAirLine;
+    delete CurrentTaskPlan;
+    emit SigReturnData(pSender, ret);
+}
+void SimulationControl::SlotGetGlobalMap(QWebSocket *pSender, QJsonObject obj)
+{
+    QJsonObject GlobalMap;
+
+//    QJsonObject *alies = new QJsonObject();
+//    QJsonObject *enemys = new QJsonObject();
+    QJsonObject allies;
+    QJsonObject enemys;
+
+    for (int i=0; i < ally.size(); i++)
+    {
+        QJsonArray allyNow;
+        for (auto j: ally.at(i))
+        {
+            QJsonArray temparray = {j->lon, j->lat, j->h};
+
+            QJsonObject tempObject
+            {
+                {"name", j->Name},
+                {"value", temparray}
+            };
+
+            allyNow.append(tempObject);
+        }
+        if (i == 0)
+        {
+            allies.insert("Planes", allyNow);
+        }
+        else if (i == 1)
+        {
+            allies.insert("Missiles",allyNow);
+        }
+    }
+
+    for (int i=0; i < enemy.size(); i++)
+    {
+        QJsonArray enemyNow;
+        for (auto j: enemy.at(i))
+        {
+            QJsonArray temparray = {j->lon, j->lat, j->h};
+
+            QJsonObject tempObject
+            {
+                {"name", j->Name},
+                {"value", temparray}
+            };
+            enemyNow.append(tempObject);
+        }
+        if (i == 0)
+        {
+            enemys.insert("Radars", enemyNow);
+        }
+    }
+
+    GlobalMap.insert("friend", QJsonValue(allies));
+    GlobalMap.insert("enemy", QJsonValue(enemys));
+    QJsonObject *ret = new QJsonObject();
+    ret->insert("url", obj.value("url"));
+    ret->insert("PlatformID", obj.value("PlatformID"));
+    ret->insert("data",QJsonValue(GlobalMap));
+    emit SigReturnData(pSender, ret);
+}
+
+void SimulationControl::SlotGetPlatformTable(QWebSocket *pSender, QJsonObject obj)
+{
+    QJsonArray Platforms;
+
+    for (int i = 0; i < ally.size(); i++)
+    {
+        std::vector<Platform *> allyplatforms = ally.at(i);
+        if (i == 0)
+        {
+            for (auto j : allyplatforms)
+            {
+                QJsonObject SinglePlatform
+                {
+                    {"platformID", QString::number(j->ID)},
+                    {"platformName", j->Name}
+                };
+
+                Platforms.append(SinglePlatform);
+            }
+        }
+    }
+
+    QJsonObject *ret = new QJsonObject();
+    ret->insert("url", obj.value("url"));
+    ret->insert("data",QJsonValue(Platforms));
+
+    emit SigReturnData(pSender, ret);
+}
+void SimulationControl::SlotGetInstanceTable(QWebSocket *pSender, QJsonObject obj)
+{
+    QJsonArray *Instances = new QJsonArray();
+    QJsonObject *SingleInstance;
+    if (true)
+    {
+        SingleInstance = new QJsonObject();
+        SingleInstance->insert("instanceID", 22);
+        SingleInstance->insert("instanceName", QString::fromLocal8Bit("侦察机_1"));
+        Instances->append(*SingleInstance);
+        delete SingleInstance;
+
+        SingleInstance = new QJsonObject();
+        SingleInstance->insert("instanceID", 62);
+        SingleInstance->insert("instanceName", QString::fromLocal8Bit("信号侦察_1"));
+        Instances->append(*SingleInstance);
+        delete SingleInstance;
+
+        SingleInstance = new QJsonObject();
+        SingleInstance->insert("instanceID", 96);
+        SingleInstance->insert("instanceName", QString::fromLocal8Bit("体系增量_1"));
+        Instances->append(*SingleInstance);
+        delete SingleInstance;
+
+        SingleInstance = new QJsonObject();
+        SingleInstance->insert("instanceID", 111);
+        SingleInstance->insert("instanceName", QString::fromLocal8Bit("侦察平台任务系统_1"));
+        Instances->append(*SingleInstance);
+        delete SingleInstance;
+
+        SingleInstance = new QJsonObject();
+        SingleInstance->insert("instanceID", 171);
+        SingleInstance->insert("instanceName", QString::fromLocal8Bit("导航_1"));
+        Instances->append(*SingleInstance);
+        delete SingleInstance;
+    }
+    QJsonObject *ret = new QJsonObject();
+    ret->insert("url", obj.value("url"));
+    ret->insert("PlatformID", obj.value("PlatformID"));
+    ret->insert("data",QJsonValue(*Instances));
+    delete Instances;
+    emit SigReturnData(pSender, ret);
+}
+
+void SimulationControl::SlotGetRadarInstances(QWebSocket *pSender, QJsonObject obj)
+{
+    int nowPlatform = obj.value("PlatformID").toInt();
+
+    QJsonArray RadarInstances;
+
+    for (auto i : enemyThaadRadarSim)
+    {
+        QJsonObject tempThaad;
+
+        if (1 || nowPlatform == i.second->PlatformID)
+        {
+            tempThaad.insert("instanceID", QString::number(i.first));
+            tempThaad.insert("instanceName",i.second->Name);
+            if (i.second->SwitchMode)
+            {
+                tempThaad.insert("instanceState", QString::fromLocal8Bit("开机"));
+            }
+            else
+            {
+                tempThaad.insert("instanceState", QString::fromLocal8Bit("关机"));
+            }
+        }
+        RadarInstances.append(tempThaad);
+    }
+
+    QJsonObject *ret = new QJsonObject();
+    ret->insert("url", obj.value("url"));
+    ret->insert("PlatformID", obj.value("PlatformID"));
+    ret->insert("data",QJsonValue(RadarInstances));
+
+    emit SigReturnData(pSender, ret);
+}
+
+void SimulationControl::SlotGetRadarParams(QWebSocket *pSender, QJsonObject obj)
+{
+
+    int nowInstance = obj.value("InstanceID").toString().toInt();
+
+    Radar *nowRadar = enemyThaadRadarSim.at(nowInstance);
+
+    if (nowRadar == nullptr)
+    {
+        QJsonObject *ret = new QJsonObject();
+        ret->insert("url", obj.value("url"));
+        ret->insert("PlatformID", obj.value("PlatformID"));
+        ret->insert("InstanceID", obj.value("InstanceID"));
+        ret->insert("data",QJsonValue());
+
+        emit SigReturnData(pSender, ret);
+    }
+    else if (true || nowRadar->PlatformID == obj.value("PlatformID").toInt())
+    {
+        int styleIdx = nowRadar->style;
+        qDebug() << styleIdx;
+        Style nowStyle = nowRadar->RadarStyleList.at(styleIdx);
+
+        QJsonObject nowfs {
+            {"key", QString::fromLocal8Bit("采样频率")},
+            {"value", nowStyle.fs}
+        };
+        QJsonObject nowfc {
+            {"key", QString::fromLocal8Bit("载波频率")},
+            {"value", nowStyle.fc}
+        };
+        QJsonObject nowModuType {
+            {"key", QString::fromLocal8Bit("调制类型")},
+            {"value", nowStyle.moduType}
+        };
+        QJsonObject nowPRFMode {
+            {"key", QString::fromLocal8Bit("PRF模式")},
+            {"value", nowStyle.PRFMode}
+        };
+        QJsonArray PRFarray;
+        for (auto i : nowStyle.PRFs)
+        {
+            PRFarray.push_back(i);
+        }
+        QJsonObject nowPRF
+        {
+            {"key", QString::fromLocal8Bit("PRF")},
+            {"value", PRFarray}
+        };
+        QJsonObject nowPW
+        {
+            {"key", QString::fromLocal8Bit("脉冲宽度")},
+            {"value", nowStyle.PulseWidth}
+        };
+        QJsonObject nowBW
+        {
+            {"key", QString::fromLocal8Bit("带宽")},
+            {"value", nowStyle.BandWidth}
+        };
+
+        QJsonArray nowParams = {nowfs, nowfc, nowModuType, nowPRFMode, nowPRF, nowPW, nowBW};
+
+        QJsonObject initMaxDis {
+            {"key", QString::fromLocal8Bit("最大量程")},
+            {"value", 800000}
+        };
+        QJsonObject initMinDis {
+            {"key", QString::fromLocal8Bit("最小量程")},
+            {"value", 1000}
+        };
+        QJsonObject initMaxFre {
+            {"key", QString::fromLocal8Bit("最大频率")},
+            {"value", 12e9}
+        };
+        QJsonObject initMinFre {
+            {"key", QString::fromLocal8Bit("最大频率")},
+            {"value", 8e9}
+        };
+        QJsonObject initNumArrayElement {
+            {"key", QString::fromLocal8Bit("阵元数")},
+            {"value", 25344}
+        };
+        QJsonObject initGain {
+            {"key", QString::fromLocal8Bit("天线增益")},
+            {"value", 48.77}
+        };
+        QJsonObject initPt {
+            {"key", QString::fromLocal8Bit("发射机功率")},
+            {"value", 405e3}
+        };
+        QJsonArray initParams = {initMaxDis, initMinDis, initMaxFre, initMinFre, initNumArrayElement, initGain, initPt};
+        QJsonObject retParams {
+            {"InitParams", initParams},
+            {"CtrlParams", nowParams}
+        };
+
+        QJsonObject *ret = new QJsonObject({
+                                               {"url", obj.value("url")},
+                                               {"PlatformID", obj.value("PlatformID")},
+                                               {"InstanceID", obj.value("InstanceID")},
+                                               {"data",QJsonValue(retParams)}
+                                           });
+
+        emit SigReturnData(pSender, ret);
+    }
+}
+
+void SimulationControl::SlotGetThaadInstances(QWebSocket *pSender, QJsonObject obj)
+{
+    QJsonArray RadarInstances;
+
+    for (auto i : enemyThaadRadarSim)
+    {
+        QJsonObject tempThaad;
+
+        if (1)
+        {
+            tempThaad.insert("instanceID", QString::number(i.first));
+            tempThaad.insert("instanceName",i.second->Name);
+            if (i.second->SwitchMode)
+            {
+                tempThaad.insert("instanceState", QString::fromLocal8Bit("开机"));
+            }
+            else
+            {
+                tempThaad.insert("instanceState", QString::fromLocal8Bit("关机"));
+            }
+        }
+        RadarInstances.append(tempThaad);
+    }
+
+    QJsonObject *ret = new QJsonObject();
+    ret->insert("url", obj.value("url"));
+    ret->insert("PlatformID", obj.value("PlatformID"));
+    ret->insert("data",QJsonValue(RadarInstances));
+
+    emit SigReturnData(pSender, ret);
+}
+
+void SimulationControl::SlotGetThaadParams(QWebSocket *pSender, QJsonObject obj)
+{
+
+    int nowInstance = obj.value("InstanceID").toString().toInt();
+
+    Radar *nowRadar = enemyThaadRadarSim.at(nowInstance);
+
+    if (nowRadar == nullptr)
+    {
+        QJsonObject *ret = new QJsonObject();
+        ret->insert("url", obj.value("url"));
+        ret->insert("PlatformID", obj.value("PlatformID"));
+        ret->insert("InstanceID", obj.value("InstanceID"));
+        ret->insert("data",QJsonValue());
+
+        emit SigReturnData(pSender, ret);
+    }
+    else if (true || nowRadar->PlatformID == obj.value("PlatformID").toInt())
+    {
+        int styleIdx = nowRadar->style;
+        qDebug() << styleIdx;
+        Style nowStyle = nowRadar->RadarStyleList.at(styleIdx);
+
+        QJsonObject nowfs {
+            {"key", QString::fromLocal8Bit("采样频率")},
+            {"value", nowStyle.fs}
+        };
+        QJsonObject nowfc {
+            {"key", QString::fromLocal8Bit("载波频率")},
+            {"value", nowStyle.fc}
+        };
+        QJsonObject nowModuType {
+            {"key", QString::fromLocal8Bit("调制类型")},
+            {"value", nowStyle.moduType}
+        };
+        QJsonObject nowPRFMode {
+            {"key", QString::fromLocal8Bit("PRF模式")},
+            {"value", nowStyle.PRFMode}
+        };
+        QJsonArray PRFarray;
+        for (auto i : nowStyle.PRFs)
+        {
+            PRFarray.push_back(i);
+        }
+        QJsonObject nowPRF
+        {
+            {"key", QString::fromLocal8Bit("PRF")},
+            {"value", PRFarray}
+        };
+        QJsonObject nowPW
+        {
+            {"key", QString::fromLocal8Bit("脉冲宽度")},
+            {"value", nowStyle.PulseWidth}
+        };
+        QJsonObject nowBW
+        {
+            {"key", QString::fromLocal8Bit("带宽")},
+            {"value", nowStyle.BandWidth}
+        };
+
+        QJsonArray nowParams = {nowfs, nowfc, nowModuType, nowPRFMode, nowPRF, nowPW, nowBW};
+
+        QJsonObject initMaxDis {
+            {"key", QString::fromLocal8Bit("最大量程")},
+            {"value", 800000}
+        };
+        QJsonObject initMinDis {
+            {"key", QString::fromLocal8Bit("最小量程")},
+            {"value", 1000}
+        };
+        QJsonObject initMaxFre {
+            {"key", QString::fromLocal8Bit("最大频率")},
+            {"value", 12e9}
+        };
+        QJsonObject initMinFre {
+            {"key", QString::fromLocal8Bit("最大频率")},
+            {"value", 8e9}
+        };
+        QJsonObject initNumArrayElement {
+            {"key", QString::fromLocal8Bit("阵元数")},
+            {"value", 25344}
+        };
+        QJsonObject initGain {
+            {"key", QString::fromLocal8Bit("天线增益")},
+            {"value", 48.77}
+        };
+        QJsonObject initPt {
+            {"key", QString::fromLocal8Bit("发射机功率")},
+            {"value", 405e3}
+        };
+        QJsonArray initParams = {initMaxDis, initMinDis, initMaxFre, initMinFre, initNumArrayElement, initGain, initPt};
+        QJsonObject retParams {
+            {"InitParams", initParams},
+            {"CtrlParams", nowParams}
+        };
+
+        QJsonObject *ret = new QJsonObject({
+                                               {"url", obj.value("url")},
+                                               {"PlatformID", obj.value("PlatformID")},
+                                               {"InstanceID", obj.value("InstanceID")},
+                                               {"data",QJsonValue(retParams)}
+                                           });
+
+        emit SigReturnData(pSender, ret);
+    }
+}
+
+void SimulationControl::SlotSetThaadStyle(QWebSocket *pSender, QJsonObject obj)
+{
+    // PlatformID和InstanceID是字符串
+    int nowPlatform = obj.value("PlatformID").toString().toInt();
+    int nowInstance = obj.value("InstanceID").toString().toInt();
+    QJsonObject nowdata = obj.value("data").toObject();
+    if (nowdata.contains("Style"))
+    {
+        // Style索引是整型
+        int nowStyle = nowdata.value("Style").toInt();
+//        qDebug() << nowPlatform <<" "<< nowInstance << " " << nowStyle;
+
+        Radar *nowRadar = enemyThaadRadarSim.at(nowInstance);
+        if (nowRadar == nullptr)
+        {
+            QJsonObject *ret = new QJsonObject();
+            ret->insert("url", obj.value("url"));
+            ret->insert("PlatformID", obj.value("PlatformID"));
+            ret->insert("InstanceID", obj.value("InstanceID"));
+            ret->insert("data", QJsonValue(""));
+
+            emit SigReturnData(pSender, ret);
+        }
+        else
+        {
+            nowRadar->StyleUpdate(nowStyle);
+
+            int styleIdx = nowRadar->style;
+            qDebug() << styleIdx;
+            Style nowStyle = nowRadar->RadarStyleList.at(styleIdx);
+
+            QJsonObject nowfs {
+                {"key", QString::fromLocal8Bit("采样频率")},
+                {"value", nowStyle.fs}
+            };
+            QJsonObject nowfc {
+                {"key", QString::fromLocal8Bit("载波频率")},
+                {"value", nowStyle.fc}
+            };
+            QJsonObject nowModuType {
+                {"key", QString::fromLocal8Bit("调制类型")},
+                {"value", nowStyle.moduType}
+            };
+            QJsonObject nowPRFMode {
+                {"key", QString::fromLocal8Bit("PRF模式")},
+                {"value", nowStyle.PRFMode}
+            };
+            QJsonArray PRFarray;
+            for (auto i : nowStyle.PRFs)
+            {
+                PRFarray.push_back(i);
+            }
+            QJsonObject nowPRF
+            {
+                {"key", QString::fromLocal8Bit("PRF")},
+                {"value", PRFarray}
+            };
+            QJsonObject nowPW
+            {
+                {"key", QString::fromLocal8Bit("脉冲宽度")},
+                {"value", nowStyle.PulseWidth}
+            };
+            QJsonObject nowBW
+            {
+                {"key", QString::fromLocal8Bit("带宽")},
+                {"value", nowStyle.BandWidth}
+            };
+
+            QJsonArray nowParams = {nowfs, nowfc, nowModuType, nowPRFMode, nowPRF, nowPW, nowBW};
+
+            QJsonObject initMaxDis {
+                {"key", QString::fromLocal8Bit("最大量程")},
+                {"value", 800000}
+            };
+            QJsonObject initMinDis {
+                {"key", QString::fromLocal8Bit("最小量程")},
+                {"value", 1000}
+            };
+            QJsonObject initMaxFre {
+                {"key", QString::fromLocal8Bit("最大频率")},
+                {"value", 12e9}
+            };
+            QJsonObject initMinFre {
+                {"key", QString::fromLocal8Bit("最大频率")},
+                {"value", 8e9}
+            };
+            QJsonObject initNumArrayElement {
+                {"key", QString::fromLocal8Bit("阵元数")},
+                {"value", 25344}
+            };
+            QJsonObject initGain {
+                {"key", QString::fromLocal8Bit("天线增益")},
+                {"value", 48.77}
+            };
+            QJsonObject initPt {
+                {"key", QString::fromLocal8Bit("发射机功率")},
+                {"value", 405e3}
+            };
+            QJsonArray initParams = {initMaxDis, initMinDis, initMaxFre, initMinFre, initNumArrayElement, initGain, initPt};
+            QJsonObject retParams {
+                {"InitParams", initParams},
+                {"CtrlParams", nowParams}
+            };
+
+            QJsonObject *ret = new QJsonObject({
+                                                   {"url", obj.value("url")},
+                                                   {"PlatformID", obj.value("PlatformID")},
+                                                   {"InstanceID", obj.value("InstanceID")},
+                                                   {"data",QJsonValue(retParams)}
+                                               });
+
+            emit SigReturnData(pSender, ret);
+        }
+    }
+}
+
+void SimulationControl::SlotGetJammingInstances(QWebSocket *pSender, QJsonObject obj)
+{
+    int nowPlatform = obj.value("PlatformID").toInt();
+
+    QJsonArray JammingInstances;
+
+    for (auto i : allyJammingSim)
+    {
+        QJsonObject tempJamming;
+
+        if (true || nowPlatform == i.second->PlatformID)
+        {
+            tempJamming.insert("instanceID", QString::number(i.first));
+            tempJamming.insert("instanceName",i.second->Name);
+            if (i.second->SwitchMode)
+            {
+                tempJamming.insert("instanceState", QString::fromLocal8Bit("开机"));
+            }
+            else
+            {
+                tempJamming.insert("instanceState", QString::fromLocal8Bit("关机"));
+            }
+
+            JammingInstances.append(tempJamming);
+        }
+    }
+
+    QJsonObject *ret = new QJsonObject();
+    ret->insert("url", obj.value("url"));
+    ret->insert("PlatformID", obj.value("PlatformID"));
+    ret->insert("data",QJsonValue(JammingInstances));
+
+    emit SigReturnData(pSender, ret);
+}
+
+void SimulationControl::SlotGetJammingParams(QWebSocket *pSender, QJsonObject obj)
+{
+    int nowInstance = obj.value("InstanceID").toInt();
+
+    Radar *nowRadar = enemyThaadRadarSim.at(nowInstance);
+
+    if (true || nowRadar->PlatformID == obj.value("PlatformID").toInt())
+    {
+        int styleIdx = nowRadar->style;
+        Style nowStyle = nowRadar->RadarStyleList.at(styleIdx);
+
+        QJsonObject nowfs
+        {
+            {"key", QString::fromLocal8Bit("采样频率")},
+            {"value", nowStyle.fs}
+        };
+        QJsonObject nowfc
+        {
+            {"key", QString::fromLocal8Bit("载波频率")},
+            {"value", nowStyle.fc}
+        };
+        QJsonObject nowModuType
+        {
+            {"key", QString::fromLocal8Bit("调制类型")},
+            {"value", nowStyle.moduType}
+        };
+        QJsonObject nowPRFMode
+        {
+            {"key", QString::fromLocal8Bit("PRF模式")},
+            {"value", nowStyle.PRFMode}
+        };
+        QJsonArray PRFarray;
+        for (auto i : nowStyle.PRFs)
+        {
+            PRFarray.push_back(i);
+        }
+        QJsonObject nowPRF
+        {
+            {"key", QString::fromLocal8Bit("PRF")},
+            {"value", PRFarray}
+        };
+        QJsonObject nowPW
+        {
+            {"key", QString::fromLocal8Bit("脉冲宽度")},
+            {"value", nowStyle.PulseWidth}
+        };
+        QJsonObject nowBW
+        {
+            {"key", QString::fromLocal8Bit("带宽")},
+            {"value", nowStyle.BandWidth}
+        };
+
+        QJsonArray nowParams = {nowfs, nowfc, nowModuType, nowPRFMode, nowPRF, nowPW, nowBW};
+
+        QJsonObject *ret = new QJsonObject();
+        ret->insert("url", obj.value("url"));
+        ret->insert("PlatformID", obj.value("PlatformID"));
+        ret->insert("InstanceID", obj.value("InstanceID"));
+        ret->insert("data",QJsonValue(nowParams));
+
+        emit SigReturnData(pSender, ret);
+    }
+
+}
+
+void SimulationControl::SlotGetESMParams(QWebSocket *pSender, QJsonObject obj)
+{
+    int InstanceID = obj.value("InstanceID").toInt();
+
+    QJsonArray *ESMInitParams;
+    QJsonArray *ESMCtrlParams;
+    QJsonObject *ESMPropTemp;
+
+    if (true)
+    {
+        ESMInitParams = new QJsonArray();
+        ESMCtrlParams = new QJsonArray();
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","fBeamAzWidth");
+        ESMPropTemp->insert("value",2);
+        ESMInitParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","fBeamElWidth");
+        ESMPropTemp->insert("value",2);
+        ESMInitParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","fTecMinFreqMhz");
+        ESMPropTemp->insert("value",2e3);
+        ESMInitParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","fTecMaxFreqMhz");
+        ESMPropTemp->insert("value",18e3);
+        ESMInitParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","fInstantPageWidMhz");
+        ESMPropTemp->insert("value",500);
+        ESMInitParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","ulChanNum");
+        ESMPropTemp->insert("value",64);
+        ESMInitParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","fTecMinPW");
+        ESMPropTemp->insert("value",0.5);
+        ESMInitParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","fTecMaxPW");
+        ESMPropTemp->insert("value",10);
+        ESMInitParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","fTecPriMean");
+        ESMPropTemp->insert("value",40);
+        ESMInitParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","ulTecTrNumMean");
+        ESMPropTemp->insert("value",5);
+        ESMInitParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","fMinSnrdB");
+        ESMPropTemp->insert("value",0.5);
+        ESMInitParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","fSysRcvLoss");
+        ESMPropTemp->insert("value",5);
+        ESMInitParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","fFreqAccuracyReq");
+        ESMPropTemp->insert("value",100);
+        ESMInitParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","uRrPowerOn");
+        ESMPropTemp->insert("value",0);
+        ESMCtrlParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","uRrWorkMode");
+        ESMPropTemp->insert("value",0);
+        ESMCtrlParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","dScanAzCentDeg");
+        ESMPropTemp->insert("value",0);
+        ESMCtrlParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","dScanAzWidthDeg");
+        ESMPropTemp->insert("value",5);
+        ESMCtrlParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","dScanElCentDeg");
+        ESMPropTemp->insert("value",0);
+        ESMCtrlParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","uLineNumPerFrame");
+        ESMPropTemp->insert("value",20);
+        ESMCtrlParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","fAntScanVel");
+        ESMPropTemp->insert("value",1);
+        ESMCtrlParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","fFreqScanVel");
+        ESMPropTemp->insert("value",100);
+        ESMCtrlParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","fTecBeginFreqMhz");
+        ESMPropTemp->insert("value",500);
+        ESMCtrlParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+
+        ESMPropTemp = new QJsonObject();
+        ESMPropTemp->insert("key","fTecEndFreqMhz");
+        ESMPropTemp->insert("value",10000);
+        ESMCtrlParams->append(*ESMPropTemp);
+        delete ESMPropTemp;
+    }
+    QJsonObject *ESMParams = new QJsonObject();
+    ESMParams->insert("InitParams", *ESMInitParams);
+    ESMParams->insert("CtrlParams", *ESMCtrlParams);
+
+    QJsonObject *ret = new QJsonObject();
+    ret->insert("url", obj.value("url"));
+    ret->insert("PlatformID", obj.value("PlatformID"));
+    ret->insert("InstanceID", InstanceID);
+    ret->insert("data", *ESMParams);
+    emit SigReturnData(pSender, ret);
+
+    delete ESMInitParams;
+    delete ESMCtrlParams;
+    delete ESMParams;
+}

simulationcontrol.h

@@ -0,0 +1,49 @@
+#ifndef SIMULATIONCONTROL_H
+#define SIMULATIONCONTROL_H
+
+#include <QObject>
+#include <QJsonObject>
+#include <QJsonArray>
+#include <QJsonValue>
+#include "platform.h"
+#include "external/radar.h"
+#include "external/jamming.h"
+#include "QtWebSockets/QWebSocket"
+
+class SimulationControl : public QObject
+{
+    Q_OBJECT
+public:
+    std::vector<Platform *> allyplane;
+    std::vector<Platform *> allymissile;
+    std::map<int, Jamming *> allyJammingSim;
+    std::vector<std::vector<Platform *>> ally;
+
+    std::vector<Platform *> enemyradar;
+    std::map<int, Radar *> enemyThaadRadarSim;
+    std::vector<Platform *> enemysat;
+    std::vector<std::vector<Platform *>> enemy;
+
+    explicit SimulationControl(QObject *parent = nullptr);
+
+signals:
+    void SigReturnData(QWebSocket *pSender, QJsonObject *obj);
+
+public slots:
+    void SlotGetInit(QWebSocket *pSender, QJsonObject obj);
+    void SlotGetLeadPost(QWebSocket *pSender, QJsonObject obj);
+    void SlotGetTaskPlan(QWebSocket *pSender, QJsonObject obj);
+    void SlotGetGlobalMap(QWebSocket *pSender, QJsonObject obj);
+    void SlotGetPlatformTable(QWebSocket *pSender, QJsonObject obj);
+    void SlotGetInstanceTable(QWebSocket *pSender, QJsonObject obj);
+    void SlotGetRadarInstances(QWebSocket *pSender, QJsonObject obj);
+    void SlotGetRadarParams(QWebSocket *pSender, QJsonObject obj);
+    void SlotGetThaadInstances(QWebSocket *pSender, QJsonObject obj);
+    void SlotGetThaadParams(QWebSocket *pSender, QJsonObject obj);
+    void SlotSetThaadStyle(QWebSocket *pSender, QJsonObject obj);
+    void SlotGetJammingInstances(QWebSocket *pSender, QJsonObject obj);
+    void SlotGetJammingParams(QWebSocket *pSender, QJsonObject obj);
+    void SlotGetESMParams(QWebSocket *pSender, QJsonObject obj);
+};
+
+#endif // SIMULATIONCONTROL_H

websockettest.pro

@@ -0,0 +1,43 @@
+QT -= gui
+QT += core websockets
+
+CONFIG += c++11 console
+CONFIG -= app_bundle
+
+# The following define makes your compiler emit warnings if you use
+# any feature of Qt which as been marked deprecated (the exact warnings
+# depend on your compiler). Please consult the documentation of the
+# deprecated API in order to know how to port your code away from it.
+DEFINES += QT_DEPRECATED_WARNINGS
+
+# You can also make your code fail to compile if you use deprecated APIs.
+# In order to do so, uncomment the following line.
+# You can also select to disable deprecated APIs only up to a certain version of Qt.
+#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
+
+SOURCES += main.cpp \
+    backgroundserver.cpp \
+    coordTrans/XYZ2ELL.cpp \
+    coordTrans/blh2xyz.cpp \
+    coordTrans/rt_nonfinite.cpp \
+    external/externalsim.cpp \
+    external/jamming.cpp \
+    external/radar.cpp \
+    platform.cpp \
+    simulationcontrol.cpp \
+    wsclient/client.cpp
+
+HEADERS += \
+    backgroundserver.h \
+    coordTrans/XYZ2ELL.h \
+    coordTrans/blh2xyz.h \
+    coordTrans/rt_defines.h \
+    coordTrans/rt_nonfinite.h \
+    coordTrans/rtwtypes.h \
+    coordTrans/tmwtypes.h \
+    external/externalsim.h \
+    external/jamming.h \
+    external/radar.h \
+    platform.h \
+    simulationcontrol.h \
+    wsclient/client.h

wsclient/client.cpp

@@ -0,0 +1,40 @@
+#include "client.h"
+
+client::client(QObject *parent, QUrl url) : QObject(parent)
+{
+    qDebug() << "WebSocket server:" << url;
+    m_url = url;
+    connect(&m_webSocket, &QWebSocket::connected, this, &client::onConnected);
+    connect(&m_webSocket, &QWebSocket::disconnected, this, &client::closed);
+    m_webSocket.open(m_url);
+}
+
+void client::SlotSendStyleToSim(QString newstyle)
+{
+    msg = newstyle;
+    m_webSocket.sendTextMessage(msg);
+}
+
+void client::onConnected()
+{
+    qDebug() << "WebSocket connected";
+    connect(&m_webSocket, &QWebSocket::textMessageReceived,
+            this, &client::onTextMessageReceived);
+//    m_webSocket.sendTextMessage(msg);
+}
+
+void client::onTextMessageReceived(QString message)
+{
+    qDebug() << "Message received:" << message;
+    bool *ok = new bool();
+    int msg = message.toInt(ok);
+    if (ok)
+    {
+        if (msg == 111)
+        {
+            qDebug()<<QString::fromLocal8Bit("收到应答");
+        }
+    }
+    delete ok;
+//    m_webSocket.close();
+}

wsclient/client.h

@@ -0,0 +1,29 @@
+#ifndef CLIENT_H
+#define CLIENT_H
+
+#include <QObject>
+#include <QtWebSockets/QtWebSockets>
+#include <QDebug>
+
+class client : public QObject
+{
+    Q_OBJECT
+public:
+    QWebSocket m_webSocket;
+    QUrl m_url;
+    QString msg;
+
+    explicit client(QObject *parent = nullptr, QUrl url = QStringLiteral("ws://localhost:1235"));
+
+signals:
+    void closed();
+
+public slots:
+    void SlotSendStyleToSim(QString newstyle);
+private slots:
+    void onConnected();
+    void onTextMessageReceived(QString message);
+
+};
+
+#endif // CLIENT_H