gcs-nf/MavLinkNode/mavlinknode.h

#ifndef MAVLINKNODE_H
#define MAVLINKNODE_H

#include <QObject>
#include "QThread"
#include "QFile"
#include "QDebug"

#include "mavlink.h"
#include "replay.h"
#include "missionprocess.h"
#include "parameterprocess.h"
#include "commandprocess.h"
#include "statusprocess.h"
#include "Terminal.h"
#include "sbusparser.h"
//#include "QAxObject"

#include "rcprocess.h"
#include "rtkprocess.h"

#include "ThreadTemplet.h"

#include "ParsePack.h"
#include "QTime"
#include "QDateTime"
#include <QTimer>

#ifdef QtMavlinkNode
#include <mavlinknodeglobal.h>
class MAVLINKNODESHARED_EXPORT MavLinkNode : public ThreadTemplet {
#else
class MavLinkNode : public ThreadTemplet
{
#endif
    Q_OBJECT
public:

    typedef struct
    {
        quint16 year;
        quint8 mon;
        quint8 day;

        quint8 hour;
        quint8 min;
        quint8 sec;
        quint16 ms;
    }_gpsTimer;


    typedef struct {
        int sysid = 0;          /* ID of message sender system/aircraft */
        int compid = 0;         /* ID of the message sender component */

        qint64 timebase;


        mavlink_autopilot_version_t autopilot_version = {0};
        mavlink_sys_status_t sys_status = {0};
        mavlink_heartbeat_t heartbeat = {0};
        mavlink_ping_t ping = {0};
        mavlink_attitude_t attitude = {0};
        mavlink_ins1_t ins1 = {0};
        mavlink_ins2_t ins2 = {0};
        mavlink_gps_raw_int_t gps_raw_int = {0};
        mavlink_global_position_int_t global_position_int = {0};
        mavlink_servo_output_raw_t servo_output_raw = {0};
        mavlink_rc_channels_raw_t rc_channels_raw = {0};
        mavlink_nav_controller_output_t nav_controller_output = {0};
        mavlink_airspeed_autocal_t airspeed_autocal = {0};
        mavlink_rpm_t rpm = {0};
        mavlink_scaled_pressure_t scaled_pressure = {0};
        mavlink_extended_sys_state_t extended_sys_state = {0};
        mavlink_battery_status_t battery_status = {0};
        mavlink_vibration_t vibration = {0};
        mavlink_enginestate_t enginestate = {0};
        mavlink_vfr_hud_t vfr_hud = {0};
        mavlink_aoa_ssa_t aoa_ssa = {0};
        mavlink_emb_atmo_com_t emb_atom_com = {0};
        mavlink_turbinestate_t turbinstate = {0};
        mavlink_bmustate_t bmustate = {0};
        mavlink_ccmstate_t ccmstate = {0};
        mavlink_serial_control_t serial_control = {0};

    }_vehicle;

    typedef struct
    {
        uint16_t flag;//
        uint16_t id;//1
        int32_t time;//(second+min*60+hour*3600)*1000
        int32_t lng;//*10000000
        int32_t lat;//*10000000
        int32_t alt;//*100
        int32_t ve;//*100
        int32_t vn;//*100
        int32_t vu;//*100
        int32_t v;//*100
        int32_t course;//*100
        int32_t backup1;//*100
        int32_t backup2;//*100
    }_showinfo;//192.168.5.72:10049



    explicit MavLinkNode(QObject *parent = nullptr);
    ~MavLinkNode();

     _gpsTimer gpsTimer;
     _vehicle vehicle;//没有初始化，所以会有野值
      QHash<int,_vehicle> vehicleList;

     Replay *replay = nullptr;

     MissionProcess *Mission = nullptr;
     ParameterProcess *Parameter = nullptr;
     commandprocess *Commander = nullptr;
     statusprocess *Status = nullptr;
     terminal *Terminal = nullptr;
     rcprocess *RC = nullptr;
     rtkprocess *rtk = nullptr;

     bool isCommunicationLost = false;

     uint64_t rate_in = 0;
     uint64_t count_in = 0;

     uint64_t rate_out = 0;
     uint64_t count_out = 0;



     uint64_t bittotal = 0;

     uint64_t parserSuccess = 0;
     uint64_t parserFailure = 0;


     uint64_t TotalFrame_1s = 0;
     uint64_t LossFrame_1s = 0;

     float rssi = 100;



    QByteArray rtkrawdata;

    QFile * autopilot_version_file = nullptr;
    QFile * sys_status_file = nullptr;
    QFile * heartbeat_file = nullptr;
    QFile * ping_file = nullptr;
    QFile * attitude_file = nullptr;
    QFile * ins1_file = nullptr;
    QFile * ins2_file = nullptr;
    QFile * gps_raw_int_file = nullptr;
    QFile * global_position_int_file = nullptr;
    QFile * servo_output_raw_file = nullptr;
    QFile * rc_channels_raw_file = nullptr;
    QFile * nav_controller_output_file = nullptr;
    QFile * airspeed_autocal_file = nullptr;
    QFile * rpm_file = nullptr;
    QFile * scaled_pressure_file = nullptr;
    QFile * extended_sys_state_file = nullptr;
    QFile * battery_status_file = nullptr;
    QFile * vibration_file = nullptr;
    QFile * enginestate_file = nullptr;
    QFile * vfr_hud_file = nullptr;
    QFile * aoa_ssa_file = nullptr;
    QFile * emb_atom_com_file = nullptr;
    QFile * turbinstate_file = nullptr;
    QFile * bmustate_file = nullptr;
    QFile * ccmstate_file = nullptr;
    QFile * serial_control_file = nullptr;

    int infoExportID = 1;
signals:

    void setMa(qint64 time, QVariant Ma);

    void signal_autopilot_version(mavlink_autopilot_version_t);
    void signal_sys_status(mavlink_sys_status_t);
    void signal_heartbeat(mavlink_heartbeat_t);
    void signal_ping(mavlink_ping_t);
    void signal_attitude(mavlink_attitude_t);
    void signal_ins1(mavlink_ins1_t ins);
    void signal_ins2(mavlink_ins2_t ins);
    void signal_gps_raw_int(mavlink_gps_raw_int_t);
    void signal_global_position_int(mavlink_global_position_int_t);
    void signal_servo_output_raw(mavlink_servo_output_raw_t servo);
    void signal_rc_channels_raw(mavlink_rc_channels_raw_t);
    void signal_nav_controller_output(mavlink_nav_controller_output_t);
    void signal_airspeed_autocal(mavlink_airspeed_autocal_t);
    void signal_rpm(mavlink_rpm_t);
    void signal_scaled_pressure(mavlink_scaled_pressure_t);
    void signal_extended_sys_state(mavlink_extended_sys_state_t);
    void signal_battery_status(mavlink_battery_status_t);
    void signal_vibration(mavlink_vibration_t);
    void signal_enginestate(mavlink_enginestate_t);
    void signal_vfr_hud(mavlink_vfr_hud_t);
    void signal_aoa_ssa(mavlink_aoa_ssa_t);
    void signal_emb_atom_com(mavlink_emb_atmo_com_t);
    void signal_turbinstate(mavlink_turbinestate_t);
    void signal_bmustate(mavlink_bmustate_t);
    void signal_ccmstate(mavlink_ccmstate_t);
    void signal_serial_control(mavlink_serial_control_t);

    void signal_vehicle(MavLinkNode::_vehicle vehicle);

    void updateDlink(float rssi,uint64_t in,uint64_t out);
    void CommuniationLost(bool);

    void beep(int);

    void addVehicles(int sysid,int compid);

    void recievemsg(mavlink_message_t msg);

    void state_updated();
    void parameter_updated();
    //void mission_updated();

    void setCurrentID(int sysid,int compid);



    void setAltitude(int sysid,int compid,double roll,double pitch,double yaw);
    void setPos(int sysid,int compid,double x,double y,double z);
    void setHeading(int sysid,int compid,double x,double y,double z);

    void Recieve(QString msg);

    void heartbeatTimeStamp(quint32 time);


    void SendMessageToExport(quint8 ch, quint8 *data,quint16 len);
public slots:
    /**
     * @brief 设置厂家标识
     */
    void setManufacturerIdentification(quint16 id);

    //线程对外接口
    void CreateCSV(void);
    void CloseCSV(void);

    bool setFileData(QFile *file,const QByteArray &data);


    //缓存对外接口
    void readPendingDatagramsReplay(void);

    void setCurrentSelected(int sysid,int compid);

    void setLogfile(QString file);

    void setGCSID(int id);

    void setHeartbeat(QVariant state, QVariant frq );

    void serial_control(void);
    void Transmit(QString msg);

    void infoExport(_showinfo info);

private slots:
   //线程私有接口
   void process();

   //缓存私有接口


   void TimerOut(void);
   void LogTimerOut(void);
   void timer_1s_Out(void);
   //解析
   void Mavlinkparse(quint32 src,QByteArray datagram);

   void MAVLinkRcv_Handler(mavlink_message_t msg);

   void StatusParse(mavlink_message_t msg);
   void CommandParse(mavlink_message_t msg);
   //

   //check for new vehicle
   void CheckVehicle(int sysid, int compid);

   bool setLogData(mavlink_message_t msg);

   void heartbeat(uint32_t custom_mode,
                  uint8_t type,
                  uint8_t autopilot,
                  uint8_t base_mode,
                  uint8_t system_status,
                  uint8_t mavlink_version);

protected:

   int Current_sysID = 0xF1;
   int Current_CompID = MAV_COMP_ID_MISSIONPLANNER;

   enum SourceType{
      c_sock = 0,
      s_port = 1
   };

   bool hasConneted = false;
   int32_t CommucationOverCount = 5;
   uint64_t CommucationOverTimer = 5000;

    uint8_t GCS_System_ID = 0xFF;


    QDateTime startuptime;

    QTime *LocationTime;


    QTimer *gdt_timer = nullptr;
    QTimer *timer = nullptr;


    QByteArray databuff;

    _buffdef serial_buff;
    _buffdef client_buff;

    QString mavlogFileName;
    QFile *mavLogFile = NULL;

    QString HeartBeatTimeName;
    QFile *HeartBeatTimeFile = NULL;



    QTimer *logTimer = nullptr;



    QTimer *timer_1s = nullptr;


    Parser2_t parser;
    Packer2_t packer;

    mutable QReadWriteLock RWlock;


    qreal heartbeatFrq = 1;
    bool isSendHeartBeat  = false;

    mavlink_heartbeat_t m_heartbeat;

    QTimer *heartbeatTimer = nullptr;


    bool isSendTerminal = false;
    QString SerialData;

    bool use_ins1 = false;

    QDateTime *gpstimebase = nullptr;

    _showinfo info;

    QPointer<QTimer> showInfoTimer = nullptr;
    QThread showInfoThread;

    quint16 ManufacturerID;

private slots:
    void showInfoTimerTimeout();
};

#endif // MAVLINKNODE_H