gcs-nf/dlink/dlink.h

#ifndef DLINK_H
#define DLINK_H

#include <QObject>
#include "QtSerialPort"
#include <QHostAddress>
#include <QUdpSocket>
#include "QDebug"
#include "mavlinknode.h"

#include "QEvent"

QT_BEGIN_NAMESPACE


#ifdef QtDlink
#include <dlinkglobal.h>
class DLINKSHARED_EXPORT DLink : public QObject {
#else
class DLink : public QObject
{
#endif
    Q_OBJECT
    //Q_DECLARE_PRIVATE(DLink)

    enum devtype{
        ganeral = 0,
        datalink,
        remote,
        rtk,
        video
    };

    struct clientNode{
        QUdpSocket * sock;
        QHostAddress addr;
        quint16 port;
        devtype type;

        bool operator==(const clientNode& other)
        {
            if (this->sock == other.sock)
            {
                return true;
            }
            return false;
        }
    };

    struct serialNode{
        QSerialPort * port;
        QString name;
        qint32 baud;
        QSerialPort::Parity parity;
        devtype type;

        bool operator==(const serialNode& other)
        {
            if (this->name == other.name)
            {
                return true;
            }
            return false;
        }
    };


public:
    explicit DLink(QObject *parent = nullptr);
    ~DLink();

    bool setupPort(const QString port, qint32 baudrate, QSerialPort::Parity parity);
    //bool statesPort(const QString name);
    //void stopPort(const QString name);

    bool PortSetup(devtype type,const QString port, qint32 baud, QSerialPort::Parity parity, const char *method);

    bool PortState(const QString name);

    bool PortStop(const QString name);

    bool setup_remote(const QString port, qint32 baud, QSerialPort::Parity parity);
    bool setup_rtk(const QString port, qint32 baudrate, QSerialPort::Parity parity);



    bool setupClient(const QHostAddress &local_addr,int local_port,const QHostAddress &remote_addr,int remote_port);

    MavLinkNode *mavlinknode = nullptr;


    bool setup_multicast(const QString &recieveIP, qint32 recievePort,
                         const QString &transmitIP, qint32 transmitPort);



    bool isExportInfo = true;

signals:
   void showMessage(const QString &message,int TimeOut = 0);

   void recieveMessage(quint32 src,QByteArray data);

   void PortConnected(QVariant m_state,
                       QVariant m_usrName,QVariant m_Type,
                       QVariant m_Param1,QVariant m_Param2,
                       QVariant m_Param3,QVariant m_Param4,
                       QVariant m_Param5);

   void getRemote(quint32,QByteArray);
   void getRTK(quint32,QByteArray);


   void RTCM_Byte(uint32_t);
   void RC_Byte(uint32_t);


   void info(double rssi,double in,double out);

public slots:

   void setExportInfo(QVariant value, QVariant id);


    void connectSignal(QVariant m_state,
                       QVariant m_usrName,QVariant m_Type,
                       QVariant m_Param1,QVariant m_Param2,
                       QVariant m_Param3,QVariant m_Param4,
                       QVariant m_Param5);

    void readPendingDatagramsSerialPort(void);

    void readPendingDatagramsClient(void);

    void processPendingMulticastDatagrams(void);


    void readRemotePendingDatagrams(void);
    void readRTKPendingDatagrams(void);

    int SendMessageToExport(quint8 ch, quint8 *msg, quint16 len);
    int SendMessageTo(quint8 ch, quint8 *msg, quint16 len);


    //void replay(QString file);


    void setSendRTCM(bool flag)
    {
       sendRTCM = flag;
    }

    bool isSendRTCM(void)
    {
        return sendRTCM;
    }


private slots:

    void bitTimerout(void);

protected:

    enum SourceType{

       c_sock = 0,
       s_port = 1,
       p_port = 2,
    };




    QMap<uint32_t,unsigned> cnts_in;
    QMap<uint32_t,unsigned> cnts_out;


    QSerialPort *serialPort = nullptr;
    QUdpSocket *Clientsock = nullptr;

    QUdpSocket *Exportsock = nullptr;

    QSerialPort *serialPortRemote = nullptr;
    QSerialPort *serialPortRTK = nullptr;

    QList<clientNode> clientSockets;
    QList<serialNode> serials;


    QUdpSocket * multicast_sock=NULL;
    QHostAddress multicast_recieve_addr;
    qint32 multicast_recieve_port;
    QHostAddress  multicast_transmit_addr;
    qint32 multicast_transmit_port;





    QMap<quint8,QIODevice *> Device;


    QTimer *bitTimer = nullptr;

    quint32 outCount = 0;
    quint32 inCount = 0;
    quint32 errCount = 0;
    quint32 frameCount = 0;

    double out_bits = 0;
    double in_bits  = 0;
    double rssi_bits = 0;

    bool sendRTCM = false;


    bool isRecieveRC = false;
    bool isRecieveRTCM = false;

    uint64_t RecieveRCtime = 0;
    uint64_t RecieveRTCMtime = 0;

    uint64_t RecieveRCcount = 0;
    uint64_t RecieveRTCMcount = 0;


};




QT_END_NAMESPACE



#endif // DLINK_H