handleaiuinew/HanddleAI/HandleAiUi-new/back/triggerManager.h

    #ifndef TRIGGERManager_H
#define TRIGGERManager_H
#include <qdebug.h>
#include <qthread.h>
#include <base.h>
#include <qlibrary.h>
#include <globalStruct.h>
#include <backStruct.h>
#include <functional>
#include <appConfig/appConfig.h>
#include <serviceModule.hpp>
using triggerCallback = std::function<void(QByteArray& byte)>;
class cameraManager;
class detThreadManager;
class detDataManager;
class lightSourceManager;
class detProcess;
//防止重复触发
class triggerLockerT
{
public:
    triggerLockerT()
    {

    }
    ~triggerLockerT()
    {
        lockerList.clear();
    }
    bool checkLocker(int input)
    {
        for (int i = 0; i < lockerList.size(); i++)
        {
            if (input == lockerList[i].pos)
            {
                return false;
            }
        }
        return true;
    }
    void reFreshLocker(QByteArray byte)
    {
        for (int i = 0; i < lockerList.size(); i++)
        {
            if (byte.at(lockerList[i].pos) != lockerList[i].value)
            {
                lockerList.removeAt(i);
            }

        }
    }
    void adddLocker(int inputPos, int posValue)
    {
        lockerList.push_back(lockerStruct({ inputPos, posValue }));
    }
    struct lockerStruct
    {
        int pos;
        int value;
    };
    QList<lockerStruct>lockerList;
private:

};  
//触发器类 fins触发 tcp触发等 替代myiothread
class triggerManager : public serviceModule
{
public:

    QByteArray readAllCmd;
    QString triggerFileName;    
    QString IpAndPort;
    QString triggerInitStr;
    ~triggerManager()
    {
        runFlag = false;
        this->stop();
        this->terminate();
        delete trigger;
    }
    void initialization(detProcess*);
    bool connectHost();
    void run();
    void stop()
    {
        runFlag = false;
        this->terminate();
    }

    void reciveCommond();
    //发送数据到
    bool sendFinsMsg(QString cmdx)
    {
        
        if (!trigger->reciveData(vec_mat, cmdx.toUtf8()))
        {
            qCritical() << "[TCP Error] " << QString::fromUtf8("Fins数据发送失败！") << cmdx;
            return false;
        }
        return true;
    }
    bool sendFinsMsg(const char* cmdx)
    {
        QString str = cmdx;
        if (!trigger->reciveData(vec_mat, str.toUtf8()))
        {
            qCritical() << "[TCP Error] " << QString::fromUtf8("Fins数据发送失败！") << cmdx;
            return false;
        }
        return true;
    }
    bool sendFinsMsg(QByteArray write_byte)
    {
        if (!trigger->reciveData(vec_mat, write_byte))
        {
            qCritical() << "[TCP Error] " << QString::fromUtf8("Fins数据发送失败！") << write_byte;
            return false;
        }
        return true;
    }

    int getValue(int dmPos, QByteArray byte);

    //CALL BACK
    struct triggerCallbackStruct
    {
        int triggerAddress;
        int triggerValue;
        triggerCallback func;
        std::string funcName;
    };
    std::vector<triggerCallbackStruct> triggerCallbackFunc;
    bool registerCallback(int triggerAddress, int triggerValue, triggerCallback func, std::string funcName ="")
    {
        triggerCallbackStruct _triggerCallbackStruct;
        _triggerCallbackStruct.triggerAddress = triggerAddress;
        _triggerCallbackStruct.triggerValue = triggerValue;
        _triggerCallbackStruct.func = func;
        _triggerCallbackStruct.funcName = funcName;
        triggerCallbackFunc.push_back(_triggerCallbackStruct);
        return true;
    }
    void checkCallbackAndTrigger(QByteArray &byte)//检查是否符合回调函数的触发条件
    {
        for (auto callback : triggerCallbackFunc)
        {
            if (checkTrigger(callback.triggerAddress, callback.triggerValue, byte) == true)
            {
                callback.func(byte);
                std::cout << "func:" << callback.funcName << "->triggered" << std::endl;
            }
        }
    }
private:

    std::string writeType;
    bool libLoadedflag = false;
    QLibrary* m_lib = nullptr;
    detProcess* _detProcess;  
    lightSourceManager* _lightSourceManager;
    detThreadManager* _threadManager;
    detDataManager* dManager;
    cameraManager* _cameraManager;
    triggerLockerT tLocker;//防止重复触发,每次收到数据时检查数据是否与上次相同，如果相同checkTrigger会返回false
    /// <summary>
    /// 检测QByteArray中某位置的值是否和输入一样，使用了绝对位置
    /// </summary>
    /// <param name="dmPos">绝对位置</param>
    /// <param name="value">值</param>
    /// <param name="byte">QByteArray</param>
    /// <returns></returns>
    bool checkTrigger(int dmPos, int value, QByteArray byte, bool lockerDisable = false)
    {
        int triggerPos = (dmPos - startPos) * 2 + 1;
        if (byte.size() < triggerPos)
            return false;
        if (byte.at(triggerPos) == value)
        {
            if (tLocker.checkLocker(triggerPos) == false)
                return false;
            if (lockerDisable == false)
                tLocker.adddLocker(triggerPos, value);
            return true;
        }
        else
            return false;
    }
    //接受数据
    bool reciveFinsMsg(QByteArray& readByte)
    {
        if (!trigger->sendData(vec_mat, readByte))
        {
            qCritical() << "[TCP] " << " finstcp_ptr sendData error!";
            return false;
        }
        return true;
    }
    //解析并触发
    void decodeCameraCMD(QByteArray byte);
    //触发器的配置
    int startPos=-1;//数据读取的起始位
    int sleepTime = -1;//间隔
    int readNum = -1;//范围
    int interval = 50;//间隔

    ReleaseFunction destory_finstcp; //释放
    Base* trigger = nullptr;
    bool runFlag = true;
    bool init = false;
    std::vector<cv::Mat> vec_mat;//没啥用，一直保持为空就好
};
#endif