#include "Logic_myiothread.h"

//QString trigger_signal_condition_name = "";
//QMutex *commond_pack_lock = new QMutex;
static int startSign[4] = { 0 };

Logic_myiothread::Logic_myiothread(QObject* parent) :mm_obj(parent)
{
    //setImageflag_lock = new QMutex;
    sendProcess_mutex = new  QMutex;
    m_runAndCheck_cameraThread = new runAndCheck_cameraThread;
}


Logic_myiothread::~Logic_myiothread()
{
    //退出线程
    io_runflag = false;
    m_runAndCheck_cameraThread->runflag = false;
    Sleep(100);
    if (m_runAndCheck_cameraThread) {
        m_runAndCheck_cameraThread->deleteLater();
        m_runAndCheck_cameraThread = nullptr;
    }
    wait(100);
    exit();
    qDebug() << __FUNCTION__ << "  line:" << __LINE__ << " ~Logic_myiothread success! ";
}

//设置批量读指令
void Logic_myiothread::setReadAllCmd(QString cmd, QString restSignal, QString restSignalBack)
{
    readAll_cmd = cmd;
    QString startpos = cmd.split("_")[2].mid(1, cmd.split("_")[2].length() - 1);
    if (startpos.isEmpty())
    {
        qCritical() << __FUNCTION__ << "  line:" << __LINE__ << " startpos is null! ";
        return;
    }
    trigger_startpos = startpos.toInt();

    if (!restSignal.isEmpty())
        rest_signal = restSignal;
    if (!restSignalBack.isEmpty())
        rest_signal_back = restSignalBack;
}

//设置全局指令
void Logic_myiothread::setOverAllCmd(QString cmd, QString restSignal, QString programNum, QString restSignalBack, QString programNumBack)
{
    readAll_cmd = cmd;
    QString startpos = cmd.split("_")[2].mid(1, cmd.split("_")[2].length() - 1);
    if (startpos.isEmpty())
    {
        qCritical() << __FUNCTION__ << "  line:" << __LINE__ << " startpos is null! ";
        return;
    }
    trigger_startpos = startpos.toInt();

    if (!restSignal.isEmpty())
        rest_signal = restSignal;
    if (!restSignalBack.isEmpty())
        rest_signal_back = restSignalBack;
    if (!programNumBack.isEmpty())
        program_Num_back = programNumBack;
    if (!programNum.isEmpty())
        program_Num = programNum;
}


void Logic_myiothread::setIOMutex(QMutex* iomutex, QMutex* write_mutex)
{
    m_iomutex = iomutex; //通信模块只一个，所有IO线程用同一个锁
    write_data_mutex = write_mutex;//Logic_taskthread检测完成后，需要发数据给PLC，数据存入容器，写入、取出加锁
}

// 递归转换 QJsonValue 到 nlohmann::json
inline nlohmann::json QJsonValueToNlohmannJson(const QJsonValue& value) {
    if (value.isObject()) {
        nlohmann::json objJson;
        QJsonObject obj = value.toObject();
        for (auto it = obj.begin(); it != obj.end(); ++it) {
            objJson[it.key().toStdString()] = QJsonValueToNlohmannJson(it.value());
        }
        return objJson;
    }
    else if (value.isArray()) {
        nlohmann::json arrJson = nlohmann::json::array();
        QJsonArray arr = value.toArray();
        for (const auto& v : arr) {
            arrJson.push_back(QJsonValueToNlohmannJson(v));
        }
        return arrJson;
    }
    else if (value.isString()) {
        return value.toString().toStdString();
    }
    else if (value.isDouble()) {
        return value.toDouble();
    }
    else if (value.isBool()) {
        return value.toBool();
    }
    else if (value.isNull() || value.isUndefined()) {
        return nullptr;
    }
    return nullptr;
}

// QJsonArray 转 nlohmann::json
inline nlohmann::json QJsonArrayToNlohmannJson(const QJsonArray& arr) {
    nlohmann::json result = nlohmann::json::array();
    for (const auto& v : arr) {
        result.push_back(QJsonValueToNlohmannJson(v));
    }
    return result;
}
//设置触发指令
void Logic_myiothread::setTriggerCmd(QJsonObject station_obj)
{
    QVector<QString> camera_trigger_cmds;
    {
        //QJsonObject station_obj = stationlist.at(i).toObject();
        QString station_name = station_obj.value("工站名").toString();
        m_stationName = station_obj.value("工站名").toString();
        QJsonArray cameramodulelist = station_obj.value("相机模块列表").toArray();
        m_cameralist = cameramodulelist;
        for (int val = 0; val < cameramodulelist.size(); val++)
        {
            QJsonObject m_obj = cameramodulelist.at(val).toObject();
            QString     trigger_camera_name = m_obj.value("相机key").toString();

            QString     clear_camera_startpos_flag = m_obj.value("拍照信号-收到后-写值").toString();

            //相机开始信号
            QJsonArray  trigger_camera_startpos_array = m_obj.value("拍照信号-拍照张数-列表").toArray();
            QJsonArray  plc_feedback_msg_array = m_obj.value("拍照信号-完成写入PLC-列表").toArray();
            QString     feedback_sleep_time = m_obj.value("拍照信号-检查完成的时间").toString();

            QStringList m_feedback_list;
            for (auto yyy = 0; yyy < plc_feedback_msg_array.size(); yyy++)
            {
                m_feedback_list.push_back(plc_feedback_msg_array.at(yyy).toString());
            }

            // 添加相机反馈延迟时间
            if (!feedback_sleep_time.isEmpty())
                map_camera_feedback_sleep_time.insert(trigger_camera_name, feedback_sleep_time);

            for (int val = 0; val < trigger_camera_startpos_array.size(); val++)
            {
                //开始的触发信号
                QString  trigger_signal = trigger_camera_startpos_array.at(val).toString();
                if (m_runAndCheck_cameraThread->map_trigger_signal_pack.keys().contains(trigger_signal))
                {
                    trigger_signal_pack m_pack = m_runAndCheck_cameraThread->map_trigger_signal_pack.value(trigger_signal);
                    m_pack.vector_camera.push_back(trigger_camera_name);
                    m_runAndCheck_cameraThread->map_trigger_signal_pack.insert(trigger_signal, m_pack);  // 替换
                }
                else
                {
                    trigger_signal_pack m_pack;  // 创建
                    foreach(QString value, m_feedback_list)
                    {
                        QString check_trigger_signal = trigger_signal.split("_")[0];
                        if (value.contains(check_trigger_signal))
                        {
                            //反馈信号
                            m_pack.vector_trigger_feedback_signal.push_back(value);
                            break;
                        }
                    }
                    m_pack.trigger_reentry_signal = 0;    // 初始化
                    //清理开始信号标志，true写0
                    m_pack.clear_camera_startpos_flag = clear_camera_startpos_flag;

                    m_pack.vector_camera.push_back(trigger_camera_name);
                    m_runAndCheck_cameraThread->map_trigger_signal_pack.insert(trigger_signal, m_pack);
                }
            }
        }

        //算法的通信内容
        QJsonArray algorithmlist = station_obj.value("算法列表").toArray();
        m_algorithmlistArray = algorithmlist;
        for (int val = 0; val < algorithmlist.size(); val++)
        {
            QJsonObject m_obj = algorithmlist.at(val).toObject();
            QString     trigger_algorithm_name = m_obj.value("算法名称").toString();
            for (int i = 0; i < station_trigger_signal_dataIntegrationThread_list.size(); i++)
            {
                if (station_trigger_signal_dataIntegrationThread_list[i]->m_algorithmKey == trigger_algorithm_name)
                {
                    trigger_signal_pack m_pack;
                    m_pack.trigger_reentry_signal = 0;    // 初始化
                    QString trigger_signal = station_trigger_signal_dataIntegrationThread_list[i]->m_trigger_signal;
                    QString trigger_feedback_signal = station_trigger_signal_dataIntegrationThread_list[i]->m_trigger_back_signal;
                    if (map_algorithm_trigger_signal_pack.keys().contains(trigger_signal))
                        m_pack = map_algorithm_trigger_signal_pack.value(trigger_signal);
                    m_pack.vector_trigger_feedback_signal.push_back(trigger_feedback_signal);
                    m_pack.vector_camera.push_back(trigger_algorithm_name);
                    map_algorithm_trigger_signal_pack.insert(trigger_signal, m_pack);
                }
            }
            if (m_obj.value("SN设置").toObject().value("汇总-是否删除SN容器首数据").toString() == "true")
                m_runAndCheck_cameraThread->ifTaskDoneFlag = true;
        }

        QJsonArray sn_array = station_obj.value("SN流程列表").toArray();
        if (!sn_array.isEmpty())
        {
            QVector<bool> vector_flag;
            for (int iiiii = 0; iiiii < sn_array.size(); iiiii++)
            {
                vector_flag.append(false);
            }
            map_sn_area_array.insert(station_name, sn_array);
            //602
            auto nloJsonData = QJsonArrayToNlohmannJson(sn_array);
            map_sn_area_array_nlohmann.insert(station_name, nloJsonData);
            std::vector<ClearData> clearDatas;
            for (auto& jData : nloJsonData) {
                ClearData cData;
                auto& jsonData = jData["清理容器数据"];
                cData.channel_index = std::atoi(jsonData["通道序号"].get<std::string>().c_str());
                for (auto& v : jsonData["相机列表"])
                    cData.cameraList.append(QString::fromStdString(v));
				clearDatas.push_back(cData);
            }
			map_ClearData.insert(station_name, clearDatas);
            
            map_read_sn_reentry_vector_flag.insert(station_name, vector_flag);
        }
        if (!station_obj.value("工站结束效验信号(缺图重拍)").toString().isEmpty())
            map_endSingnal_backObj.insert(station_obj.value("工站结束效验信号(缺图重拍)").toString(), station_obj.value("工站结束效验信号-回复").toObject());
    }
}


void Logic_myiothread::run()
{
    // 运行并检查相机是否取图完成的线程
    // 一个信号取多张的情况，取图时间长，和通信线程分开。
    int times = 0;
    heart_start = clock();

    //心跳（定时向PLC的指定寄存器写入值）代码。
    if (m_IoType.contains("Heart"))
    {
        int heartIndex = 0;
        int cnt = 0;
        while (io_runflag){
            cnt++;
            if (cnt > 100) {
                QStringList m_heartCmdList = m_heartCmd.split("#");
                int m_heartCmdListSize = m_heartCmdList.size();
                if (m_heartCmdList.size() == 0)
                    return;
                QByteArray byte = m_heartCmdList[heartIndex].toUtf8();      // 设置 从起始位开始读取的指令
                if (!finstcp_ptr->writeData(vec_mat, byte))
                {
                    qCritical() << __FUNCTION__ << "line:" << __LINE__ << " finstcp_ptr reciveData error!";
                }
                heartIndex >= m_heartCmdListSize -1 ? heartIndex = 0 : heartIndex++;
                cnt = 0;
                
            }
#if 0
            for (int m = 0; m < m_heartCmdList.size(); m++)
            {
                Sleep(10);
                qApp->processEvents();
                heart_stop = clock();
                //if ((m_heartTime / 10) <= times++)
                if (heart_stop - heart_start >= m_heartTime)
                {
                    heart_start = clock();
                    if (!m_heartCmdList[m].isEmpty())
                    {// 发送心跳
                        ////QMutexLocker locker(m_iomutex);;
                        QByteArray byte = m_heartCmdList[m].toUtf8();      // 设置 从起始位开始读取的指令
                        if (!finstcp_ptr->writeData(vec_mat, byte))
                        {
                            qCritical() << __FUNCTION__ << "line:" << __LINE__ << " finstcp_ptr reciveData error!";
                        }
                        times = 0;
                    }
                }
                else
                {
                    if (!rest_signal.isEmpty())
                    {
                        if (times % int(m_heartTime / 50 + 1) == 0)
                        {
                            // 修改读取多个命令
                            //QMutexLocker locker(m_iomutex);;
                            QByteArray byte = readAll_cmd.toUtf8();      // 设置 从起始位开始读取的指令
                            if (!finstcp_ptr->writeData(vec_mat, byte))
                            {
                                qCritical() << __FUNCTION__ << "line:" << __LINE__ << " finstcp_ptr reciveData error!";
                            }

                            // 读取到的信息解析
                            QByteArray readByte;
                            if (!finstcp_ptr->readData(vec_mat, readByte))
                            {
                                qCritical() << __FUNCTION__ << "line:" << __LINE__ << " finstcp_ptr sendData error!";
                            }

                            if (readByte.isEmpty())
                                return;
                            QByteArray readsnByte = readByte;
                            QVector<int> vec_value;
                            while (!readByte.isEmpty())
                            {
                                QByteArray retByte = readByte.mid(0, 2);
                                readByte.remove(0, 2);

                                QString msg = retByte.toHex();
                                int number_tmp = msg.toInt(NULL, 16);
                                vec_value.push_back(number_tmp);
                            }

                            QString  m_startpos = rest_signal.split("_")[0];
                            QString  m_value = rest_signal.split("_")[1];
                            int trigger_index = m_startpos.mid(1, m_startpos.length() - 1).toInt();
                            trigger_index -= trigger_startpos;
                            if (trigger_index < 0)
                            {
                                qCritical() << __FUNCTION__ << "  line:" << __LINE__ << " vec_value is error! read_sn_startpos:" << m_startpos;
                            }
                            else if (vec_value.size() > trigger_index)
                            {
                                //读复位标志满足
                                if (vec_value.at(trigger_index) == m_value.toInt())
                                {
                                    qCritical() << __FUNCTION__ << "  line:" << __LINE__ << " 复位信号:" << rest_signal;
                                    foreach(QString m_station_name, station_list.keys())
                                        for (int i = 0; i < station_list.value(m_station_name)->sndata_list.size(); i++)
                                        {
                                            QStringList  cameraList;
                                            cameraList.append("all");
                                            for (int i = 0; i < 10; i++)
                                                station_list.value(m_station_name)->clearData("all", cameraList);
                                        }
                                    //完成清标志
                                    QByteArray send_byte = rest_signal_back.toUtf8();
                                    if (!finstcp_ptr->writeData(vec_mat, send_byte))
                                    {
                                        qCritical() << __FUNCTION__ << "line:" << __LINE__ << " finstcp_ptr reciveData error! ";
                                        return;
                                    }
                                }
                            }
                            //程序号；传到到主界面类，再进行切换
                            if (!program_Num.isEmpty())
                            {
                                QString  m_startpos = program_Num;// .split("_")[0];
                                //QString  m_value = program_Num.split("_")[1];
                                int trigger_index = m_startpos.mid(1, m_startpos.length() - 1).toInt();
                                trigger_index -= trigger_startpos;
                                if (trigger_index < 0)
                                {
                                    qCritical() << __FUNCTION__ << "  line:" << __LINE__ << " vec_value is error! read_sn_startpos:" << m_startpos;
                                }
                                else if (vec_value.size() > trigger_index)
                                {
                                    //读复位标志满足
                                    if (vec_value.at(trigger_index) != 0)
                                    {
                                        qCritical() << __FUNCTION__ << "  line:" << __LINE__ << " 程序号:" << vec_value.at(trigger_index);

                                        dataPack m_data;
                                        m_data.algorithmName = "程序号";
                                        m_data.cameraName = m_startpos;
                                        m_data.byteArray = QByteArray::number(vec_value.at(trigger_index));
                                        m_data.retFlag = "algorithm";

                                        QMutexLocker locker(sendProcess_mutex);
                                        sendProcessTask.enqueue(m_data);
                                        //完成清标志
                                        QByteArray send_byte = program_Num_back.toUtf8();
                                        if (!finstcp_ptr->writeData(vec_mat, send_byte))
                                        {
                                            qCritical() << __FUNCTION__ << "line:" << __LINE__ << " finstcp_ptr reciveData error! ";
                                            return;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

#endif
            // 写入
            writeCommond();
            QThread::msleep(10);
        }
    }
    else
    {
        while (io_runflag)
        {
            // 读取
            reciveCommond();
            QThread::msleep(5);
            //for (int s = 0; s < 5; s++)
            //{
            //    Sleep(1);
            //    qApp->processEvents();
            //}
            //Sleep(20);
        }
    }

}

// 写入数据
void Logic_myiothread::writeCommond()
{
    if (writeCommondPack.isEmpty())
        return;
    //多线程也行
    //要先加锁，不加锁会访问冲突
    QMutexLocker locker(write_data_mutex);
    while (!writeCommondPack.isEmpty())
    {
        //QMutexLocker locker(m_iomutex);;
        QByteArray write_byte = writeCommondPack.dequeue();
        if (!finstcp_ptr->writeData(vec_mat, write_byte))
        {
            qCritical() << __FUNCTION__ << "line:" << __LINE__ << " finstcp_ptr reciveData error!";
            return;
        }
    }
}

void Logic_myiothread::reciveCommond()
{
#if JSONRPC_SWTICH == 1
    //QString tmpDate = QDateTime::currentDateTime().toString("yyyy-MM-dd-hh-mm-ss-zzz");
    //qDebug() << __FUNCTION__ << " line: " << __LINE__ << " readAll_cmd: " << readAll_cmd <<"   " << tmpDate;
    
    
    // 修改读取多个命令
    //QMutexLocker locker ( m_iomutex );
    
    QByteArray readByte = readAll_cmd.toUtf8();      // 设置 从起始位开始读取的指令
    //if (!finstcp_ptr->writeData(vec_mat, byte))
    //{
    //    qCritical() << __FUNCTION__ << "line:" << __LINE__ << " finstcp_ptr reciveData error!";
    //}

    //// 读取到的信息解析
    //QByteArray readByte;
    m_iomutex->lock();
    if (!finstcp_ptr->readData(vec_mat, readByte))
    {
        qCritical() << __FUNCTION__ << "line:" << __LINE__ << " finstcp_ptr sendData error!";
    }
    m_iomutex->unlock();
    loopCnt++;
    if (loopCnt > 1000) {
        clock_stop = clock();
        double ctime = clock_stop - clock_start;
        qDebug() << "最近一千次循环耗时 " << ctime << "ms";
        loopCnt = 0;
        clock_start = clock();
    }
#else
    QByteArray readByte = readAll_cmd.toUtf8();      // 设置 从起始位开始读取的指令
    if (!finstcp_ptr->writeData(vec_mat, readByte))
    {
        qCritical() << __FUNCTION__ << "line:" << __LINE__ << " finstcp_ptr reciveData error!";
    }

    //// 读取到的信息解析
    m_iomutex->lock();
    if (!finstcp_ptr->readData(vec_mat, readByte))
    {
        qCritical() << __FUNCTION__ << "line:" << __LINE__ << " finstcp_ptr sendData error!";
    }
    m_iomutex->unlock();
    loopCnt++;
    if (loopCnt > 1000) {
        clock_stop = clock();
        double ctime = clock_stop - clock_start;
        qDebug() << "最近一千次循环耗时 " << ctime << "ms";
        loopCnt = 0;
        clock_start = clock();
    }
#endif
    //if (ctime > 500)
        //qCritical() << __FUNCTION__ << __LINE__ << "readAll_cmd ctime :" << ctime<<" m_stationName:"<<m_stationName;//;127ms

    // tmpDate = QDateTime::currentDateTime().toString("yyyy-MM-dd-hh-mm-ss-zzz");
    //qDebug() << __FUNCTION__ << " line: " << __LINE__ << " readAll_cmd  done: " << readAll_cmd << "   " << tmpDate;

    decodeCameraCMD(readByte);
    QThread::msleep(1);
}

// 读取多个命令信息的解析
QVector<int> byteArrayToIntVector(const QByteArray& byte)
{
    QVector<int> vec_value;
    int count = byte.size() / 2;
    vec_value.reserve(count);
    const uchar* data = reinterpret_cast<const uchar*>(byte.constData());
    for (int i = 0; i < count; ++i) {
        int value = (data[2 * i] << 8) | data[2 * i + 1];
        vec_value.push_back(value);
    }
    return vec_value;
}
void Logic_myiothread::decodeCameraCMD(QByteArray& byte)
{
    if (byte.isEmpty())
        return;

    readsnByte = byte;
    QVector<int> vec_value = byteArrayToIntVector(byte);
    _triggerLockerT.reFreshLocker(vec_value);
    for (auto& it : _triggerLockerT.lockerList) {
        vec_value[it] = 0;
    }
    // 读取sn数据
    readSnInfo(vec_value, readsnByte);
    // 读取紧急停止信号
    //931/949-5-2,读急停信号
    //readEmergencyStopSignal(vec_value);

     //防重入检查标识符
    checkReentrySign(vec_value);

    // 触发相机拍照信息检查
    checkTriggerCamera(vec_value);

    //触发算法检查
    checkTriggerAlgorithm(vec_value);

    // 工站结束校验（缺图重拍使用）
    checkEndSingnal(vec_value);
}
//SN逻辑
// "读SN信号"满足时，代表新料来了，安装"清理容器数据"-"相机列表"及"通道序号"清理对应的容器；
//SN保存到容器HSnData；下料的SN，根据"汇总-触发信号"、"汇总-读哪个SN"匹配Logic_hdataintegration，并保存SN到变量；
void Logic_myiothread::readSnSub(
    const QString& station_name,
    const nlohmann::json& jsonObj,
    const QVector<int>& vec_value,
    const QByteArray& byte,
    const ClearData& clearData) {
    //clock_t start = clock();
    //clock_t stop2, stop3, stop4, stop5, stop6, stop7;
    //bool printTimeCost = false;
    // 提前解析 json，减少多次 toObject/toArray


    HSnData* m_sndata = station_list.value(station_name)->getSnInfoData(clearData.channel_index);
    if (!m_sndata) return;
    m_sndata->stationName = station_name;
    //stop2 = clock();
    QString m_startpos, m_value;
    QString read_sn_startpos = QString::fromStdString(jsonObj["读SN信号"]);
    if (!read_sn_startpos.isEmpty())
    {
        auto parts = read_sn_startpos.split('_');
        if (parts.size() >= 2) {
            m_startpos = parts[0];
            m_value = parts[1];
        }
    }

    int trigger_index = m_startpos.mid(1).toInt() - trigger_startpos;
    if (trigger_index < 0 || vec_value.size() <= trigger_index) {
        qCritical() << __FUNCTION__ << " line:" << __LINE__ << " invalid trigger_index:" << trigger_index;
        return;
    }
#if YH_LOGIC_SWITCH == 2
    if ((vec_value.at(trigger_index) == m_value.toInt() && _triggerLockerT.checkLocker(trigger_index))||
        (vec_value.at(trigger_index+ 2) == m_value.toInt() && _triggerLockerT.checkLocker(trigger_index + 2))
        ) {
#elif YH_LOGIC_SWITCH == 4
    if ((vec_value.at(trigger_index) == m_value.toInt() && _triggerLockerT.checkLocker(trigger_index)||
        (vec_value.at(trigger_index + 2) == m_value.toInt() && _triggerLockerT.checkLocker(trigger_index + 2)) ||
        (vec_value.at(trigger_index + 4) == m_value.toInt() && _triggerLockerT.checkLocker(trigger_index + 4)) ||
        (vec_value.at(trigger_index + 6) == m_value.toInt() && _triggerLockerT.checkLocker(trigger_index + 6))
        ) {
#else
    if (vec_value.at(trigger_index) == m_value.toInt() && _triggerLockerT.checkLocker(trigger_index)) {
#endif

        if (!clearData.cameraList.isEmpty()) {
            if (m_runAndCheck_cameraThread->ifTaskDoneFlag) {
                if (m_sndata->getTaskDoneFlag()) {
                    for (auto& camThread : m_runAndCheck_cameraThread->station_camerathreadlist)
                        camThread->degressSnIndex();
                    m_sndata->setTaskDoneFlag(false);
                }
                else {
                    QString tmpDate = QDateTime::currentDateTime().toString("yyyy-MM-dd-hh-mm-ss-zzz");
                    qCritical() << __FUNCTION__ << " line:" << __LINE__ << " getTaskDoneFlag false !! 堆积风险 "
                        << tmpDate << " m_startpos:" << m_startpos;
                }
            }
        }

        //stop3 = clock();
        QVector<bool>& m_vec_sn_flag = map_read_sn_reentry_vector_flag[station_name];
        //qCritical() << __FUNCTION__ << " line:" << __LINE__ << " m_vec_sn_flag:" << m_vec_sn_flag[clearData.channel_index];
        //stop4 = clock();
        //相机列表清理
        for (auto& cameraKey : clearData.cameraList) {
            for (auto& cam : camerathreadlist) {
                if (cam->m_name == cameraKey) {
                    //std::thread([cam] {
                    std::vector<cv::Mat> vec_mat;
                    //QByteArray restCamera = "rest_newProductIn";
                    cam->set_m_stoprun(true);
                    //cam->m_Module.module_ptr->writeData(vec_mat, restCamera);
                    QByteArray sf = "softwareTrigger";
                    cam->m_Module.module_ptr->writeData(vec_mat, sf);
                    //}).detach();

                }
            }
        }
        //stop5 = clock();
        for (auto& camThread : m_runAndCheck_cameraThread->station_camerathreadlist) {
            if (camThread->SN_signalList.contains(read_sn_startpos))
                camThread->SN_signal = read_sn_startpos;
        }

        if (!clearData.cameraList.isEmpty())
            station_list.value(station_name)->clearData(QString::number(clearData.channel_index), clearData.cameraList);

        //时间戳一次生成
        QString tmpDate = QDateTime::currentDateTime().toString("yyyy-MM-dd-hh-mm-ss-zzz");
        QVector<QString> datatime_vector;
        //auto read_datatime_list = obj.value("读时间戳-寄存器列表").toArray();
        //auto write_datatime_list = obj.value("写时间戳-寄存器列表").toArray();

        //if (!read_datatime_list.isEmpty()) {
        //    for (auto& item : read_datatime_list) {
        //        QString datatime = getSn(obj.value("读SN异常-插值").toString(), item.toString(), byte);
        //        if (datatime == obj.value("读SN异常-插值").toString())
        //            datatime = "errDataTime";
        //        datatime_vector.append(datatime);
        //    }
        //}
        //else if (!write_datatime_list.isEmpty()) {
        //    for (auto& item : write_datatime_list)
        //        datatime_vector.append(tmpDate);
        //}
        if (jsonObj["读时间戳-寄存器列表"].size()>0) {
            for (auto& item : jsonObj["读时间戳-寄存器列表"]) {
                QString datatime = getSn(QString::fromStdString(jsonObj["读SN异常-插值"]), QString::fromStdString(item), byte);
                if (datatime == QString::fromStdString(jsonObj["读SN异常-插值"]))
                    datatime = "errDataTime";
                datatime_vector.append(datatime);
            }
        }
        else if (jsonObj["写时间戳-寄存器列表"].size() > 0) {
            for (auto& item : jsonObj["写时间戳-寄存器列表"])
                datatime_vector.append(tmpDate);
        }
        //读取 SN
        bool ifReadSnErr = false;
        QVector<QString> sn_vector;
        //auto read_sn_list = obj.value("读SN寄存器列表").toArray();
        for (int i = 0; i < jsonObj["读SN寄存器列表"].size(); ++i) {
            QString sn_value = getSn(QString::fromStdString(jsonObj["读SN异常-插值"]), QString::fromStdString(jsonObj["读SN寄存器列表"].at(i)), byte);
            if (sn_value == QString::fromStdString(jsonObj["读SN异常-插值"])) {
                sn_value = "errSN";
                ifReadSnErr = true;
            }
            if (!datatime_vector.isEmpty())
                sn_value += "_" % (datatime_vector.size() == jsonObj["读SN寄存器列表"].size() ? datatime_vector[i] : datatime_vector[0]);
            sn_vector.append(sn_value);
            if (!station_trigger_signal_dataIntegrationThread_list.isEmpty())
                setSN_hdataintegration(read_sn_startpos, i, sn_value);
        }

        m_sndata->addSnVector(sn_vector);

        m_vec_sn_flag[clearData.channel_index] = true;

        //异常 or 正常 回包
        QStringList replyList = ifReadSnErr ?
            QString::fromStdString(jsonObj["读SN异常-回复指令"]).split("#") :
            QString::fromStdString(jsonObj["读SN正常-回复指令"]).split("#");
        //stop6 = clock();
        //std::thread([this, replyList, m_startpos] {
            for (auto& cmd : replyList)
                finstcp_ptr->writeData(vec_mat, cmd.toUtf8());

            //清除触发信号

           // finstcp_ptr->writeData(vec_mat, ("write_short_" % m_startpos % "_0").toUtf8());
            //}).detach();
        //stop7 = clock();
        //printTimeCost = false;
    }
    else if (vec_value.at(trigger_index) == 0) {
        QVector<bool>& m_vec_sn_flag = map_read_sn_reentry_vector_flag[station_name];
        m_vec_sn_flag[clearData.channel_index] = false;
    }

    //if (printTimeCost == true){
    //    clock_t stop = clock();
    //    double ctime2 = stop2 - start;
    //    double ctime3 = stop3 - start;
    //    double ctime4 = stop4 - start;
    //    double ctime5 = stop5 - start;
    //    double ctime6 = stop6 - start;
    //    double ctime7 = stop7 - start;
    //    double ctime = stop - start;
    //    std::stringstream ss;
    //    ss << std::this_thread::get_id();
    //    QString tid = QString::fromStdString(ss.str());
    //    qDebug() << __FUNCTION__ << " line:" << __LINE__ << " readSnSub done: "
    //        << station_name << " channel_index:" << clearData.channel_index
    //        << " ctime2:" << ctime2 << " ctime3:" << ctime3 << " ctime4:" << ctime4 
    //        << " ctime5:" << ctime5 << " ctime6:" << ctime6 << " ctime7:" << ctime7
    //        << " ctime:" << ctime << " threadid:" << tid;
    //}

}

void Logic_myiothread::readSnInfo(QVector<int> vec_value, QByteArray byte)
{
    QStringList keys = map_sn_area_array.keys();
    //重新加载用
    //bool ifinitSCA = false;
    for (auto vvv = 0; vvv < keys.size(); vvv++)
    {
        QString station_name = keys[vvv];
        //QJsonArray sn_area_array = map_sn_area_array.value(station_name);//station_name应该是 this->m_stationKey
        //int sn_area_arraysize = sn_area_array.size();
        std::vector<std::future<void>> futures;
        for (int snsn = 0; snsn < map_sn_area_array_nlohmann[station_name].size(); snsn++)
        {
            futures.push_back(std::async(std::launch::async, &Logic_myiothread::readSnSub, this, 
                station_name, map_sn_area_array_nlohmann[station_name].at(snsn), vec_value, byte,
                map_ClearData[station_name].at(snsn)));
            //readSnSub(station_name, sn_area_array.at(snsn).toObject(), vec_value, byte);
   /*         std::thread([this,station_name, sn_area_array, snsn, vec_value, byte] {
                readSnSub(station_name, sn_area_array.at(snsn).toObject(), vec_value, byte);
                }).detach();*/
        }
        for (auto& fut : futures) {
            fut.get(); // 等待所有线程完成
        }
        //qDebug() << "readSnInfo End!";
    }

}

//下料的SN，根据"汇总-触发信号"、"汇总-读哪个SN"匹配Logic_hdataintegration，并保存SN到变量；
void Logic_myiothread::setSN_hdataintegration(QString read_sn_startpos, int index, QString sn_value)
{
    //给算法sn
    for (int da = 0; da < station_trigger_signal_dataIntegrationThread_list.size(); da++)
    {
        if (station_trigger_signal_dataIntegrationThread_list[da]->m_trigger_signal == read_sn_startpos)
        {
            QJsonObject sn_set = station_trigger_signal_dataIntegrationThread_list[da]->algorithmObject.value("SN设置").toObject();
            //QString     read_sn_area_index = sn_set.value("汇总-读哪个上料通道的SN").toString();
            QString sn_key = sn_set.value("汇总-读哪个SN").toString();
            if (sn_key.contains("sn"))
            {
                if (sn_key.split("sn")[1].toInt() == (index + 1))
                {
                    station_trigger_signal_dataIntegrationThread_list[da]->SN_dataTime = sn_value;
                    QString sendBack = station_trigger_signal_dataIntegrationThread_list[da]->m_trigger_back_signal;//"汇总-回复信号"
                    if (sendBack.isEmpty())
                        continue;
                    //反馈信号
                    QString m_signal = sendBack;
                    QByteArray m_byte = m_signal.toLocal8Bit(); //toUtf8出现一次m_byte无法读取内存
                    //QMutexLocker locker(m_iomutex);;
                    if (!finstcp_ptr->writeData(vec_mat, m_byte))
                    {
                        qCritical() << __FUNCTION__ << " line:" << __LINE__ << " finstcp_ptr reciveData error! ";
                        //return;
                    }
                    //Sleep(5);
                }
            }
        }

    }
}


//未使用
//根据配置文件clearData，清除相机图片容器内容
bool Logic_myiothread::clearSnCameraAlgorithmData(int areaIndex, QJsonObject obj)
{
    if (obj.isEmpty())
    {
        return true;
    }

    if (m_stationName.isEmpty())
    {
        return true;
    }

    QString    channel_index = obj.value("通道序号").toString();
    QJsonArray cameralist = obj.value("相机列表").toArray();
    QJsonArray algorithmlist = obj.value("算法列表").toArray();
    QJsonArray algorithmexeclist = obj.value("算法数据容器列表").toArray();
    if (!cameralist.isEmpty())
    {
        for (int ccc = 0; ccc < cameralist.size(); ccc++)
        {
            QString cameraName = cameralist.at(ccc).toString();
            if (!cameraName.isEmpty())//.contains("camera"))// 如果用相机SN初始化；
            {
                if (channel_index.isEmpty())
                {
                    station_list.value(m_stationName)->clearCameraData(cameraName, "");
                }
                else
                {
                    station_list.value(m_stationName)->clearCameraData(cameraName, channel_index);
                }
            }
        }
    }
    if (!algorithmlist.isEmpty())
    {
        for (int aaa = 0; aaa < algorithmlist.size(); aaa++)
        {
            QString algorithmName = algorithmlist.at(aaa).toString();
            if (algorithmName.contains("algorithm"))
            {
                station_list.value(m_stationName)->clearAlgorithmData(algorithmName);
            }
        }
    }
    if (!algorithmexeclist.isEmpty())
    {
        for (int aaa = 0; aaa < algorithmexeclist.size(); aaa++)
        {
            QString algorithmName = algorithmexeclist.at(aaa).toString();
            if (algorithmName.contains("algorithm"))
            {
                station_list.value(m_stationName)->clearAlgorithmExecData(algorithmName);
            }
        }
    }
    // 清理sn码
    //station_list.value(m_stationName)->clearSnData(areaIndex);
}
// sn方向相反，重新做转换
QString Logic_myiothread::snHex(QString sn)
{
    QString resultStr = "";
    if (sn.size() % 2 == 0)
    {
        for (int i = 0; i < sn.size() - 1; i = i + 2)
        {
            resultStr = resultStr + sn.at(i + 1) + sn.at(i);
        }
    }
    else
    {
        for (int i = 0; i < sn.size() - 1; i = i + 2)
        {
            resultStr = resultStr + sn.at(i + 1) + sn.at(i);
        }
        resultStr.append(sn.at(sn.size() - 1));
    }

    return resultStr;
}
//SN为""时，返回配置文件的"读SN异常-插值"
QString Logic_myiothread::getSn(QString errorinfo, QString area, QByteArray byte)
{
    QString m_startpos = area.split("_")[0];
    QString lenght = area.split("_")[1];

    int start_index = m_startpos.mid(1, m_startpos.length() - 1).toInt();
    start_index -= trigger_startpos;

    QByteArray snByte = byte.mid(start_index * 2, lenght.toInt());
    QString sn = snByte;

    if (sn.contains("\n\r"))
        sn.replace("\n\r", "");

    if (sn == "")
    {
        return errorinfo;
    }
    return sn;
}

//931/949-5-2,读急停信号
//void Logic_myiothread::readEmergencyStopSignal(QVector<int> vec_value)
//{
//    if (emergency_stop_signal.isEmpty())
//    {
//        //qWarning() << __FUNCTION__ << "  LINE:" << __LINE__ << " emergency_stop_signal is null! ";
//        return;
//    }
//    QString  m_startpos = emergency_stop_signal.split("_")[0];
//    QString  m_value = emergency_stop_signal.split("_")[1];
//    int trigger_index = m_startpos.mid(2, m_startpos.length() - 2).toInt();
//    trigger_index -= trigger_startpos;
//    if (trigger_index < 0){
//        qCritical() << __FUNCTION__ << "  line:" << __LINE__ << " value is error! m_startpos:" << m_startpos;
//    }else if (vec_value.size() > trigger_index){
//        if (vec_value.at(trigger_index) == m_value.toInt())
//        {
//            if (!emergency_stop_state)
//                return;
//            else
//            {
//                //修改报警、复位逻辑。。
//
//                qDebug() << __FUNCTION__ << "  LINE:" << __LINE__ << " emergency_stop_signal:" << emergency_stop_signal;
//                B_time_Start = 0;
//                A_time_Start = 0;
//                QString m_signal = "write_DM3006_0";
//                QByteArray m_byte = m_signal.toUtf8();
//                if (!finstcp_ptr->writeData(vec_mat, m_byte))
//                {
//                    qCritical() << __FUNCTION__ << " line:" << __LINE__ << " finstcp_ptr reciveData error! ";
//                    return;
//                }
//                m_signal = "write_DM3010_0";
//                m_byte = m_signal.toUtf8();
//                if (!finstcp_ptr->writeData(vec_mat, m_byte))
//                {
//                    qCritical() << __FUNCTION__ << " line:" << __LINE__ << " finstcp_ptr reciveData error! ";
//                    return;
//                }
//                m_signal = "write_DM3056_0";
//                m_byte = m_signal.toUtf8();
//                if (!finstcp_ptr->writeData(vec_mat, m_byte))
//                {
//                    qCritical() << __FUNCTION__ << " line:" << __LINE__ << " finstcp_ptr reciveData error! ";
//                    return;
//                }
//                m_signal = "write_DM3060_0";
//                m_byte = m_signal.toUtf8();
//                if (!finstcp_ptr->writeData(vec_mat, m_byte))
//                {
//                    qCritical() << __FUNCTION__ << " line:" << __LINE__ << " finstcp_ptr reciveData error! ";
//                    return;
//                }
//                for (int vvv = 1; vvv < 7; vvv++)
//                {
//                    QString algorithmName = QString("algorithm%1").arg(vvv);
//                    if (algorithmName.contains("algorithm"))
//                    {
//                        station_list.value(m_stationName)->clearAlgorithmData(algorithmName);
//                    }
//                }
//                station_list.value(m_stationName)->clearAlgorithmData("algorithm9");
//                station_list.value(m_stationName)->clearAlgorithmData("algorithm10");
//                station_list.value(m_stationName)->changeAlgorithmDataGetIndex("algorithm7",1);
//                station_list.value(m_stationName)->changeAlgorithmDataGetIndex("algorithm8", 1);
//                station_list.value(m_stationName)->getSnInfoData(0)->SetDeleteSnIndex(0);
//                station_list.value(m_stationName)->getSnInfoData(1)->SetDeleteSnIndex(0);
//                emergency_stop_state = false;
//            }
//
//            //// 先反馈信号,再清理
//            //QString m_signal = "write_" + m_startpos + "_0";
//            //QByteArray m_byte = m_signal.toUtf8();
//            //if (!finstcp_ptr->writeData(vec_mat, m_byte))
//            //{
//            //    qCritical() << __FUNCTION__ << " line:" << __LINE__ << " finstcp_ptr reciveData error! ";
//            //    return;
//            //}
//            //Sleep(10000);
//            //QList<QString> keyList = station_list.keys();
//            //for (int i = 0; i < keyList.size(); i++)
//            //{
//            //    HStationData* stationPtr = station_list.value(keyList.at(i));
//            //    if (stationPtr)
//            //    {
//            //        stationPtr->clearData("");
//            //    }
//            //}
//            //qDebug() << __FUNCTION__ << "  line:" << __LINE__ << " clear data success! ";
//        }
//        else
//        {
//            emergency_stop_state = true;
//        }
//    }
//}

//检查相机、算法信号重入
void Logic_myiothread::checkReentrySign(QVector<int> vec_value)
{
    //检查相机信号重入
    QStringList  m_keys = m_runAndCheck_cameraThread->map_trigger_signal_pack.keys();
    for (int i = 0; i < m_keys.size(); i++)
    {
        QString  trigger_signal = m_keys.at(i);
        QString  m_startpos = trigger_signal.split("_")[0];
        QString  m_value = trigger_signal.split("_")[1];
        int trigger_index = m_startpos.mid(1, m_startpos.length() - 1).toInt();
        trigger_index -= trigger_startpos;
        if (trigger_index < 0)
        {
            qCritical() << __FUNCTION__ << "  line:" << __LINE__ << " value is error! m_startpos:" << m_startpos;
        }
        else if (vec_value.size() > trigger_index)
        {
            trigger_signal_pack m_pack = m_runAndCheck_cameraThread->map_trigger_signal_pack.value(trigger_signal);
            if (vec_value.at(trigger_index) == 0 && m_pack.trigger_reentry_signal == 1)
            {
                m_pack.trigger_reentry_signal = 0;
                m_runAndCheck_cameraThread->map_trigger_signal_pack.insert(trigger_signal, m_pack); // 替换为0

            }
        }
    }

    //检查算法信号重入
    //触发条件的
    m_keys = map_algorithm_trigger_signal_pack.keys();
    for (int i = 0; i < m_keys.size(); i++)
    {
        QString  trigger_signal = m_keys.at(i);
        QString  m_startpos = trigger_signal.split("_")[0];
        QString  m_value = trigger_signal.split("_")[1];
        int trigger_index = m_startpos.mid(1, m_startpos.length() - 1).toInt();
        trigger_index -= trigger_startpos;
        if (trigger_index < 0)
        {
            qCritical() << __FUNCTION__ << "  line:" << __LINE__ << " value is error! m_startpos:" << m_startpos;
        }
        else if (vec_value.size() > trigger_index)
        {
            trigger_signal_pack m_pack = map_algorithm_trigger_signal_pack.value(trigger_signal);
            if (vec_value.at(trigger_index) == 0 && m_pack.trigger_reentry_signal == 1)
            {
                m_pack.trigger_reentry_signal = 0;
                map_algorithm_trigger_signal_pack.insert(trigger_signal, m_pack); // 替换为0
            }
        }
    }

}
void Logic_myiothread::checkTriggerCameraSub(
    const QString& trigger_signal,
    const QVector<int>& vec_value,
    int trigger_startpos,
    const QString& m_stationName,
    QMap<QString, QString> map_camera_feedback_sleep_time
) {
    QStringList splist = trigger_signal.split("_");
    if (splist.size() < 2)
    {
        qCritical() << __FUNCTION__ << "  line:" << __LINE__ << " trigger_signal is error! :" << trigger_signal;
        return;
    }
    QString  m_startpos = splist[0];
    QString  m_value = splist[1];
    QString  trigger_getImgNum = "1";//运行次数
    if (splist.size() > 3)
        if (splist[3].toInt() > 0)trigger_getImgNum = splist[3];
    int trigger_index = m_startpos.mid(1, m_startpos.length() - 1).toInt();
    trigger_index -= trigger_startpos;
    if (trigger_index < 0)
    {
        qCritical() << __FUNCTION__ << "  line:" << __LINE__ << " value is error! m_startpos:" << m_startpos;
    }
    else if (vec_value.size() > trigger_index)
    {
        trigger_signal_pack m_pack = m_runAndCheck_cameraThread->map_trigger_signal_pack.value(trigger_signal);
        //602 屏蔽无意义代码
        //收到信号直接回复；软件卡顿、通信断开等异常，可能导致信号回复失败
        //if (vec_value.at(trigger_index) == m_value.toInt())
        //{
        //    // 写清除当前信号 修改
        //    QString  clear_signal = m_startpos;
        //    QStringList myCmdHead = m_pack.clear_camera_startpos_flag.split("_");
        //    clear_signal = myCmdHead[0] + "_" + myCmdHead[1] + "_" + clear_signal + +"_" + myCmdHead[2];
        //    QByteArray m_byte = clear_signal.toUtf8();
        //    ////QMutexLocker locker(m_iomutex);;
        //    /*if ( !finstcp_ptr->writeData(vec_mat,m_byte) )
        //    {
        //        qCritical() << __FUNCTION__ << " line:"<< __LINE__ << " finstcp_ptr reciveData error! ";
        //        return;
        //    }*/
        //}
#if YH_LOGIC_SWITCH == 2
        if ( (vec_value.at(trigger_index) == m_value.toInt() && _triggerLockerT.checkLocker(trigger_index))
            || (vec_value.at(trigger_index + 2) == m_value.toInt() && _triggerLockerT.checkLocker(trigger_index + 2)))
        {
            if (vec_value.at(trigger_index) == m_value.toInt())_triggerLockerT.adddLocker(trigger_index);
            if (vec_value.at(trigger_index + 2) == m_value.toInt())_triggerLockerT.adddLocker(trigger_index + 2);
#elif YH_LOGIC_SWITCH == 4
        if ((vec_value.at(trigger_index) == m_value.toInt() && _triggerLockerT.checkLocker(trigger_index))
            || (vec_value.at(trigger_index + 2) == m_value.toInt() && _triggerLockerT.checkLocker(trigger_index + 2))
            || (vec_value.at(trigger_index + 4) == m_value.toInt() && _triggerLockerT.checkLocker(trigger_index + 4))
            || (vec_value.at(trigger_index + 6) == m_value.toInt() && _triggerLockerT.checkLocker(trigger_index + 6))
            )
        {
            if (vec_value.at(trigger_index) == m_value.toInt())_triggerLockerT.adddLocker(trigger_index);
            if (vec_value.at(trigger_index + 2) == m_value.toInt())_triggerLockerT.adddLocker(trigger_index + 2);
            if (vec_value.at(trigger_index + 4) == m_value.toInt())_triggerLockerT.adddLocker(trigger_index + 4);
            if (vec_value.at(trigger_index + 6) == m_value.toInt())_triggerLockerT.adddLocker(trigger_index + 6);
#else
        if (vec_value.at(trigger_index) == m_value.toInt() && _triggerLockerT.checkLocker(trigger_index))//&& m_pack.trigger_reentry_signal == 0 )
        {
            if (vec_value.at(trigger_index) == m_value.toInt())_triggerLockerT.adddLocker(trigger_index);
#endif

            //qDebug() << __FUNCTION__ << " line:" << __LINE__ << "trigger_signal: " << trigger_signal;

            //一个信号，对应相机拍多张图？
            // 添加被触发的相机名称;运行相机及取图
            if (!m_pack.vector_camera.isEmpty()){

                QStringList trigger_camera_name_getImgNumS;

                for (int val = 0; val < m_pack.vector_camera.size(); val++){

                    QString trigger_camera_name_getImgNum = m_pack.vector_camera.at(val) + "_" + trigger_getImgNum;
                    if (!trigger_camera_name_getImgNum.isEmpty()){
                        //多工站需考虑加锁？
                        //注意，信号不可重入。
                        //开线程去运行；一个信号对应相机拍多张图的情况 
                        trigger_camera_name_getImgNumS.append(trigger_camera_name_getImgNum);
                    }
                }
                //qDebug() << "trigger_signal:" << trigger_signal << " run_camera_module station_camerathreadlist ";
                QStringList yh_getImageSignal;
#if YH_LOGIC_SWITCH == 2
                yh_getImageSignal.append({ QString::number(vec_value.at(trigger_index)),
                QString::number(vec_value.at(trigger_index + 2)) });
#elif YH_LOGIC_SWITCH == 4
                yh_getImageSignal.append({ QString::number(vec_value.at(trigger_index)),
                QString::number(vec_value.at(trigger_index + 2)),
                QString::number(vec_value.at(trigger_index + 4)),
                QString::number(vec_value.at(trigger_index + 6)) });             
#endif
                m_runAndCheck_cameraThread->runCameraKey_num.enqueue(trigger_camera_name_getImgNumS);
                if (!m_pack.trigger_signal_condition.isEmpty())
                {
                    station_list.value(m_stationName)->set_trigger_signal(trigger_signal);
                }

                // 判断是否需要反馈延迟
                int sleep_time = 10;
                QString camera_name = m_pack.vector_camera.at(0);  // 只提取一个
                if (!camera_name.isEmpty())
                {
                    QString m_feedback_sleep_time = map_camera_feedback_sleep_time.value(camera_name);
                    if (!m_feedback_sleep_time.isEmpty())
                    {
                        sleep_time = m_feedback_sleep_time.toInt();
                        //Sleep(sleep_time);
                    }
                }
                m_pack.trigger_getImgNum = trigger_getImgNum;
                m_pack.m_startpos = m_startpos;
                m_pack.sleep_time = sleep_time;
                // 运行并检查相机是否取图完成的线程
                // 一个信号取多张的情况，取图时间长，和通信线程分开。
                //QFuture偶然需要5秒，start()偶然需要30ms；
                //m_runAndCheck_cameraThread->check_pack.enqueue(m_pack);
                std::thread(
                    [this, trigger_camera_name_getImgNumS, m_pack, yh_getImageSignal]
                    {m_runAndCheck_cameraThread->run_camera_moduleOneTime(trigger_camera_name_getImgNumS, m_pack, yh_getImageSignal); }
                ).detach();
            }

            m_pack.trigger_reentry_signal = 1;
            m_runAndCheck_cameraThread->map_trigger_signal_pack.insert(trigger_signal, m_pack); // 替换为1
        }
    }
}
void Logic_myiothread::checkTriggerCamera(QVector<int> vec_value)
{
    QStringList  m_keys = m_runAndCheck_cameraThread->map_trigger_signal_pack.keys();
    QJsonArray sn_area_array = map_sn_area_array.value(m_stationKey);// ("station1");
    std::vector<std::future<void>> futures;
    for (int i = 0; i < m_keys.size(); i++)
    {
        futures.push_back(std::async(std::launch::async, &Logic_myiothread::checkTriggerCameraSub, this,
            m_keys.at(i), vec_value, trigger_startpos, m_stationName, map_camera_feedback_sleep_time));
        /*      checkTriggerCameraSub(m_keys.at(i), vec_value, trigger_startpos,
                  m_stationName, map_camera_feedback_sleep_time);*/
    }
    for (auto& fut : futures) {
        fut.get(); // 等待所有线程完成
    }
}

void Logic_myiothread::checkTriggerAlgorithm(QVector<int> vec_value)
{
    QStringList  m_keys = map_algorithm_trigger_signal_pack.keys();
    QJsonArray sn_area_array = map_sn_area_array.value(m_stationKey);// ("station1");
    for (int i = 0; i < m_keys.size(); i++)
    {
        QString  trigger_signal = m_keys.at(i);
        QStringList splist = trigger_signal.split("_");
        if (splist.size() < 2)
        {
            qCritical() << __FUNCTION__ << "  line:" << __LINE__ << " trigger_signal is error! :" << trigger_signal;
            return;
        }
        QString  m_startpos = splist[0];
        QString  m_value = splist[1];
        QString  trigger_getImgNum = "1";//运行次数
        if (splist.size() > 3)
            if (splist[3].toInt() > 0)trigger_getImgNum = splist[3];
        int trigger_index = m_startpos.mid(1, m_startpos.length() - 1).toInt();
        trigger_index -= trigger_startpos;
        if (trigger_index < 0)
        {
            qCritical() << __FUNCTION__ << "  line:" << __LINE__ << " value is error! m_startpos:" << m_startpos;
        }
        else if (vec_value.size() > trigger_index)
        {
            trigger_signal_pack m_pack = map_algorithm_trigger_signal_pack.value(trigger_signal);
            if (vec_value.at(trigger_index) == m_value.toInt())
            {
                // 写清除当前信号 修改
                QString  clear_signal = m_startpos;
                clear_signal = "write_short_" + clear_signal + "_0";
                QByteArray m_byte = clear_signal.toUtf8();
                //QMutexLocker locker(m_iomutex);;
                if (!finstcp_ptr->writeData(vec_mat, m_byte))
                {
                    qCritical() << __FUNCTION__ << " line:" << __LINE__ << " finstcp_ptr reciveData error! ";
                    return;
                }
            }
            if (vec_value.at(trigger_index) == m_value.toInt())
                //if(m_pack.trigger_reentry_signal == 0)
            {
                qDebug() << __FUNCTION__ << " line:" << __LINE__ << "trigger_signal: " << trigger_signal;

                //反馈信号；考虑到一个模块可能对应几组检测内容，对应的开始和回复信号不同
                QVector<QString> vector_trigger_feedback_signal = m_pack.vector_trigger_feedback_signal;
                foreach(QString trigger_feedback_signal, vector_trigger_feedback_signal) //例：D3104_0
                {
                    if (trigger_feedback_signal.isEmpty())
                        continue;
                    QByteArray send_byte = trigger_feedback_signal.toUtf8();
                    //QMutexLocker locker(m_iomutex);;
                    if (!finstcp_ptr->writeData(vec_mat, send_byte))
                    {
                        qCritical() << __FUNCTION__ << "line:" << __LINE__ << " finstcp_ptr reciveData error! ";
                        return;
                    }
                }

                m_pack.trigger_reentry_signal = 1;
                map_algorithm_trigger_signal_pack.insert(trigger_signal, m_pack); // 替换为1

                // 添加被触发的相机名称
                if (!m_pack.vector_camera.isEmpty())
                {
                    //QMutexLocker locker(commond_pack_lock);
                    for (int val = 0; val < m_pack.vector_camera.size(); val++)
                    {
                        QString trigger_signal_num = trigger_signal + "#" + trigger_getImgNum;
                        if (!trigger_signal_num.isEmpty())
                        {
                            //注意，信号不可重入。
                            //一般对应的是下料工位的汇总算法
                            run_Algorithm_hdataintegration(trigger_signal_num);
                        }
                    }
                }
                // 查看是否需要使用触发信号
                //if (!m_pack.trigger_signal_condition.isEmpty())
                //{
                    //station_list.value(m_stationName)->set_trigger_signal(trigger_signal);
                    //trigger_signal_condition_name = trigger_signal; //作用同mv_trigger_signal
                //}
                //if (m_pack.clear_camera_startpos_flag.contains("true"))
                //{
                //    // 写清除当前信号 修改
                //    QString  clear_signal = m_startpos;
                //    clear_signal = CmdHeadShort + clear_signal + "_0";
                //    QByteArray m_byte = clear_signal.toUtf8();
                //    if (!finstcp_ptr->writeData(vec_mat, m_byte))
                //    {
                //        qCritical() << __FUNCTION__ << " line:" << __LINE__ << " finstcp_ptr reciveData error! ";
                //        return;
                //    }
                //    // 判断是否需要反馈延迟
                //    int sleep_time = 0;
                //    QString trigger_name = m_pack.vector_camera.at(0);  // 只提取一个
                //    if (!trigger_name.isEmpty())
                //    {
                //        QString m_feedback_sleep_time = map_algorithm_feedback_sleep_time.value(trigger_name);
                //        if (!m_feedback_sleep_time.isEmpty())
                //        {
                //            sleep_time = m_feedback_sleep_time.toInt();
                //            //Sleep(sleep_time);
                //        }
                //    }
                //}

            }
            //else
             //   qDebug() << __FUNCTION__ << " line:" << __LINE__ << "trigger_signal: " << trigger_signal << " m_pack.trigger_reentry_signal != 0";
        }
    }
}


// 工站结束校验
// 相机缺图需要重拍时使用。此方法需工位开始时(读SN信号)，清理相机容器、检测算法容器数据（HStationData::clearData）。
void Logic_myiothread::checkEndSingnal(QVector<int> vec_value)
{
    foreach(QString endSingnal, map_endSingnal_backObj.keys())
    {
        QString  m_startpos = endSingnal.split("_")[0];
        QString  m_value = endSingnal.split("_")[1];
        int trigger_index = m_startpos.mid(1, m_startpos.length() - 1).toInt();
        trigger_index -= trigger_startpos;
        if (trigger_index < 0)
        {
            qCritical() << __FUNCTION__ << "  line:" << __LINE__ << " vec_value is error! read_sn_startpos:" << m_startpos;
        }
        else if (vec_value.size() > trigger_index)
        {
            //读SN标志满足read_sn_startpos
            if (vec_value.at(trigger_index) == m_value.toInt())
            {
                // 清理当前信号
                QString m_signal = "write_short_" + m_startpos + "_0";
                QByteArray m_byte = m_signal.toUtf8();
                //QMutexLocker locker(m_iomutex);;
                if (!finstcp_ptr->writeData(vec_mat, m_byte))
                {
                    qCritical() << __FUNCTION__ << " line:" << __LINE__ << " finstcp_ptr reciveData error! ";
                    return;
                }

                QJsonObject end_backObj = map_endSingnal_backObj.value(endSingnal);
                QString backSignal;
                bool ifCameraMissImage = false;
                for (int i = 0; i < m_runAndCheck_cameraThread->station_camerathreadlist.size(); i++)
                    if (m_runAndCheck_cameraThread->station_camerathreadlist[i]->ifMissImage == true)
                    {
                        ifCameraMissImage = true;
                        m_runAndCheck_cameraThread->station_camerathreadlist[i]->set_ifMissImage(false);
                    }
                if (ifCameraMissImage == false)
                {
                    backSignal = end_backObj.value("取图数量-正常").toString();
                }
                else
                {
                    backSignal = end_backObj.value("取图数量-异常").toString();
                }
                if (!backSignal.isEmpty())
                {
                    // 清理当前sn码的触发信号
                    m_signal = backSignal;
                    m_byte = m_signal.toUtf8();
                    if (!finstcp_ptr->writeData(vec_mat, m_byte))
                    {
                        qCritical() << __FUNCTION__ << " line:" << __LINE__ << " finstcp_ptr reciveData error! ";
                        return;
                    }
                }
            }
        }
    }
}


//条件判断
//一般对应的是下料工位的汇总算法
void Logic_myiothread::run_Algorithm_hdataintegration(QString trigger_signal_num)
{
    try
    {
        QString mytrigger_signal_num = trigger_signal_num; //相机key_运行次数
        int runNum = mytrigger_signal_num.split("#")[1].toInt();
        if (runNum < 1)
        {
            qCritical() << __FUNCTION__ << __LINE__ << " cameraKey_runNum err:" << mytrigger_signal_num;
            return;
        }
        bool if_camera_get_All = true;
        for (int i = 0; i < station_trigger_signal_dataIntegrationThread_list.size(); i++)
        {
            QString trigger_signal = station_trigger_signal_dataIntegrationThread_list.at(i)->m_trigger_signal; //相机SN或userID
            if (trigger_signal == mytrigger_signal_num.split("#")[0])
            {
                Logic_hdataintegration* mydataIntegrationPtr = station_trigger_signal_dataIntegrationThread_list.at(i);
                if (mydataIntegrationPtr->SN_dataTime == "")
                    mydataIntegrationPtr->SN_dataTime = "errSN_errDataTime";
                //开线程去运行；一个信号对应相机拍多张图的情况
                for (int i = 0; i < runNum; i++)
                {
                    mydataIntegrationPtr->ifalwaysRun = true;
                    mydataIntegrationPtr->start();//偶然需要30ms
                }
            }
        }
    }
    catch (QString ev)
    {
        qCritical() << __FUNCTION__ << __LINE__ << " ev:" << ev;
    }
    return;
}

QJsonObject Logic_myiothread::loadJsonCfg(QString json_cfg_file_path)
{
    QJsonObject json_object;
    try
    {
        QJsonParseError jsonError;
        if (json_cfg_file_path.isEmpty())
        {
            qCritical() << __FUNCTION__ << " line:" << __LINE__ << " JsonPath is null!";
            return json_object;
        }

        QFile JsonFile;
        JsonFile.setFileName(json_cfg_file_path);
        if (!JsonFile.isReadable())
        {
            qCritical() << __FUNCTION__ << " line:" << __LINE__ << " camera_cfg.json not isReadable!";
            return json_object;
        }
        JsonFile.open(QIODevice::ReadOnly);

        QByteArray m_Byte = JsonFile.readAll();
        if (m_Byte.isEmpty())
        {
            qDebug() << __FUNCTION__ << " line:" << __LINE__ << json_cfg_file_path + " Content is empty";
            JsonFile.close();
            return json_object;
        }

        QJsonDocument jsonDocument(QJsonDocument::fromJson(m_Byte, &jsonError));

        if (!jsonDocument.isNull() && jsonError.error == QJsonParseError::NoError)
        {
            if (jsonDocument.isObject())
            {
                json_object = jsonDocument.object();
                JsonFile.close();
                return json_object;
            }
        }
        else
        {
            qCritical() << __FUNCTION__ << " line:" << __LINE__ << json_cfg_file_path + " is error!";
        }
        JsonFile.close();

    }
    catch (QString ev)
    {
        qCritical() << __FUNCTION__ << " line:" << __LINE__ << " ev:" << ev;
    }
    return json_object;
}

//未使用；
// 信号复位逻辑
//重新加载并传参数到相机、算法
bool Logic_myiothread::initStationCameraAndAlgorithm()
{
    //相机/算法模块，传入参数；
    QDir dir = QApplication::applicationDirPath();
    QString currPath = dir.path();
    QString cf_finish = currPath + "/config/finish.txt";
    QFile cf_finish_file(cf_finish);
    if (cf_finish_file.exists())
    {
        Sleep(10);
        //读配置文件；加载参数；
        QString camera_cfg = currPath + "/config/camera_cfg.json";
        QJsonObject m_jsonObj = loadJsonCfg(camera_cfg);
        if (m_jsonObj.isEmpty())
        {
            qCritical() << __FUNCTION__ << " line:" << __LINE__ << " m_jsonObj is null";
            return false;
        }
        QJsonArray stationList = m_jsonObj.value("工站列表").toArray();
        for (int s = 0; s < stationList.size(); s++)
        {
            QJsonObject station_obj = stationList[s].toObject();
            if (station_obj.value("工站名").toString() == m_stationName)
            {
                QJsonArray m_cameramodulelist = station_obj.value("相机模块列表").toArray();
                for (auto val = 0; val < m_cameramodulelist.size(); val++)
                {
                    QJsonObject camera_obj = m_cameramodulelist.at(val).toObject();
                    QString     camera_key = camera_obj.value("相机key").toString();
                    for (int sc = 0; sc < m_runAndCheck_cameraThread->station_camerathreadlist.size(); sc++)
                    {
                        if (m_runAndCheck_cameraThread->station_camerathreadlist[sc]->m_name == camera_key)
                        {
                            m_runAndCheck_cameraThread->station_camerathreadlist[sc]->m_Module.ConfigArray = camera_obj.value("相机参数").toArray();
                            initStationsModule(m_runAndCheck_cameraThread->station_camerathreadlist[sc]->m_Module);
                        }
                    }
                }
                QJsonArray m_Algorithmlist = station_obj.value("算法列表").toArray();
                for (auto val = 0; val < m_Algorithmlist.size(); val++)
                {
                    QJsonObject obj = m_Algorithmlist.at(val).toObject();
                    QString     key = obj.value("算法名称").toString();
                    for (int sc = 0; sc < station_task_thread_list.size(); sc++)
                    {
                        //for (int t = 0; t < station_task_thread_list[sc]->m_module_list.size(); t++)
                        {
                            if (station_task_thread_list[sc]->m_module.m_stationKey == m_stationName &&
                                station_task_thread_list[sc]->m_module.module_key == key)
                            {
                                station_task_thread_list[sc]->m_module.ConfigArray = obj.value("算法初始化参数").toArray();
                                initStationsModule(station_task_thread_list[sc]->m_module);
                            }
                        }
                    }
                }
            }
        }
    }

}


//未使用；
// 信号复位逻辑
bool Logic_myiothread::initStationsModule(MyModule cameraOrAlgorithm_module)
{
    QString moduleName = cameraOrAlgorithm_module.moduleName;
    QString key = cameraOrAlgorithm_module.module_key;

    //传递初始化参数
    QByteArray  initByte = cameraOrAlgorithm_module.m_initByte;
    std::vector<cv::Mat>  vec_moduleMat;
    //数据格式：3+3+数据长度+数据内容
    QByteArray m_keyByte = initCameraParam(key, cameraOrAlgorithm_module.ConfigArray);
    //统一用initParas进行初始化
    if (moduleName.contains("Camera"))
        cameraOrAlgorithm_module.module_ptr->writeData(vec_moduleMat, m_keyByte);  // 初始化相机
    if (cameraOrAlgorithm_module.module_ptr->initParas(initByte))
    {
        qDebug() << __FUNCTION__ << " line: " << __LINE__ << " key: " << key << " initParas   success! ";
    }
    else
    {
        qCritical() << __FUNCTION__ << "  line: " << __LINE__ << " moduleName: " << cameraOrAlgorithm_module.moduleName << " initParas failed! ";
        return false;
    }
    return true;
}


//未使用；
// 信号复位逻辑
QByteArray Logic_myiothread::initCameraParam(QString key, QJsonArray array)
{
    if (key.isEmpty())
        return "";

    std::string sendMsg;

    // 添加相机名称
    int type = 3;     // int
    std::string m_type;
    m_type.insert(0, 4, '1');
    memcpy((void*)m_type.c_str(), (void*)&type, 4);
    sendMsg.append(m_type);

    // len
    int len = key.length();
    std::string m_len;
    m_len.insert(0, 4, '1');
    memcpy((void*)m_len.c_str(), (void*)&len, 4);
    sendMsg.append(m_len);

    // 相机名称
    std::string m_key = key.toStdString();
    sendMsg.append(key.toStdString());

    //添加数据
    for (int i = 0; i < array.size(); i++)
    {
        QJsonObject m_obj = array.at(i).toObject();
        QString value = m_obj.value("相机参数值").toString();
        if (value.isEmpty())
        {
            qCritical() << __FUNCTION__ << "line:" << __LINE__ << " value is null!";
            return "";
        }

        int type = 3;    // int
        std::string _type;
        _type.insert(0, 4, '1');
        memcpy((void*)_type.c_str(), (void*)&type, 4);
        sendMsg.append(_type);

        // len
        int data_len = value.length();
        std::string _len;
        _len.insert(0, 4, '1');
        memcpy((void*)_len.c_str(), (void*)&data_len, 4);
        sendMsg.append(_len);

        // data
        sendMsg.append(value.toStdString());
    }

    QByteArray byteArray(sendMsg.c_str(), sendMsg.length());
    return byteArray;
}

//根据信号，切换"程序号"
int Logic_myiothread::dataPack_size()
{
    QMutexLocker locker(sendProcess_mutex);
    return sendProcessTask.size();
}
//根据信号，切换"程序号"
//获取数据
dataPack Logic_myiothread::getdataPack()
{
    QMutexLocker locker(sendProcess_mutex);
    return sendProcessTask.dequeue();
}


// 运行并检查相机是否取图完成的线程
// 一个信号取多张的情况，取图时间长，和通信线程分开。
runAndCheck_cameraThread::runAndCheck_cameraThread(QObject* parent)
{
    runflag = true;
}
runAndCheck_cameraThread::~runAndCheck_cameraThread()
{
    runCameraKey_num.clear();
    qDebug() << __FUNCTION__ << "line:" << __LINE__ << " delete success! ";
}

//Logic_myiothread的run运行时，开始线程运行
//~Logic_myiothread时，runflag为false结束运行
//运行相机并等待拍完
void runAndCheck_cameraThread::run_camera_module(QStringList cameraKeyS_runNumS)
{
    try
    {
        clock_t start, stop;
        start = clock();
        trigger_signal_pack my_check_pack = check_pack.dequeue();
        for (int ca = 0; ca < cameraKeyS_runNumS.size(); ca++)
        {
            QString cameraName_getImgNum = cameraKeyS_runNumS[ca]; //相机key_运行次数
            int runNum = cameraName_getImgNum.split("_")[1].toInt();
            if (runNum < 1)
            {
                qCritical() << __FUNCTION__ << __LINE__ << " cameraKey_runNum err:" << cameraKeyS_runNumS[ca];
                return;
            }
            //runModule(cameraName);
            bool if_camera_get_All = true;
            for (int i = 0; i < station_camerathreadlist.size(); i++)
            {
                QString cameraKey = station_camerathreadlist.at(i)->m_name; //相机SN或userID
                if (cameraKey == cameraName_getImgNum.split("_")[0])
                {
                    station_camerathreadlist.at(i)->set_m_stoprun(true);
                    //----2024.03.05修改
                    // 回复信号放到Logic_camera_thread相机取图完成后执行
                    // 可能出现同一工位多个相机，信号先后给的情况，避免相机取图时间过长，导致下一个相机开始取图慢
                    //相机拍照完成检查包
                    if (my_check_pack.sleep_time > 100)
                        station_camerathreadlist.at(i)->maxCheckTime = my_check_pack.sleep_time;
                    if (ca == 0)
                        station_camerathreadlist.at(i)->send_byte = checkCamerasFinish_feedbackSignal(my_check_pack);
                    else
                        station_camerathreadlist.at(i)->send_byte = "pass"; //一个开始拍照对应多个相机的，回复的信号只保留一个，后面的不发了。减少通信耗时。
                    //Logic_camera_thread在线程运行，当getImgNums不为0时从相机模块获取getImgNums次图
                    //取图总时间超过maxCheckTime，会结束取图。
                    station_camerathreadlist.at(i)->getImgNums = runNum;
                    break;
                }
            }
        }
        ///*stop = clock();
        //qCritical() << "trigger_signal:" << trigger_signal << " run_camera_module station_camerathreadlist cut Time ::" << stop - start;
        //start = clock();*/
        //for (int ca = 0; ca < cameraKeyS_runNumS.size(); ca++)
        //{
        //    QString cameraName_getImgNum = cameraKeyS_runNumS[ca]; //相机key_运行次数
        //    int runNum = cameraName_getImgNum.split("_")[1].toInt();
        //    if (runNum < 1)
        //    {
        //        qCritical() << __FUNCTION__ << __LINE__ << " cameraKey_runNum err:" << cameraKeyS_runNumS[ca];
        //        return;
        //    }
        //    //runModule(cameraName);
        //    bool if_camera_get_All = true;
        //    for (int i = 0; i < station_camerathreadlist.size(); i++)
        //    {
        //        QString cameraKey = station_camerathreadlist.at(i)->getName(); //相机SN或userID
        //        // tmpDate = QDateTime::currentDateTime().toString("yyyy-MM-dd-hh-mm-ss-zzz");
        //        //std::cout << "run_camera_module strat 3 ::" << tmpDate.toStdString() << " trigger_camera_name::" << cameraKey_runNum.toStdString() << std::endl;
        //        if (cameraKey == cameraName_getImgNum.split("_")[0])
        //        {
        //            Logic_camera_thread* mycameraPtr = station_camerathreadlist.at(i);
        //            //mycameraPtr->wait();
        //            int mytime = 0;
        //            while (mycameraPtr->getImgNums != 0)
        //            {
        //                Sleep(20);
        //                mytime++;
        //                if (mytime >= check_pack.head().sleep_time) //"拍照信号-检查完成的时间": "360000"。设置很大：机台中途报警，复位后继续拍照检测
        //                {
        //                    mycameraPtr->set_m_stoprun(true);
        //                    Sleep(10);
        //                }
        //                //mycameraPtr->m_stoprun=true相机读SN信号时，进行设置
        //                if (mycameraPtr->getImgNums == 0 || mytime*20 >= check_pack.head().sleep_time || (mycameraPtr->m_stoprun==true && mytime>=50))
        //                    break;
        //            }
        //            Sleep(1);
        //            mycameraPtr->set_m_stoprun(true);// m_stoprun = true;
        //        }
        //    }
        //}


    }
    catch (QString ev)
    {
        qCritical() << __FUNCTION__ << __LINE__ << " ev:" << ev;
    }
    return;
}

void runAndCheck_cameraThread::run_camera_moduleOneTime(
    const QStringList& cameraKeyS_runNumS, const trigger_signal_pack& my_check_pack,
    const QStringList& yh_getImageSignal) {
    try
    {
        clock_t start, stop;
        start = clock();
        for (int index = 0; index < cameraKeyS_runNumS.size(); index++)
        {
            QString cameraName_getImgNum = cameraKeyS_runNumS[index]; //相机key_运行次数
            int runNum = cameraName_getImgNum.split("_")[1].toInt();
            if (runNum < 1)
            {
                qCritical() << __FUNCTION__ << __LINE__ << " cameraKey_runNum err:" << cameraKeyS_runNumS[index];
                return;
            }
            //runModule(cameraName);
            bool if_camera_get_All = true;
            for (int i = 0; i < station_camerathreadlist.size(); i++)
            {
                QString cameraKey = station_camerathreadlist.at(i)->m_name; //相机SN或userID
                if (cameraKey == cameraName_getImgNum.split("_")[0])
                {
                    station_camerathreadlist.at(i)->set_m_stoprun(true);
                    //----2024.03.05修改
                    // 回复信号放到Logic_camera_thread相机取图完成后执行
                    // 可能出现同一工位多个相机，信号先后给的情况，避免相机取图时间过长，导致下一个相机开始取图慢
                    //相机拍照完成检查包
                    if (my_check_pack.sleep_time > 100)
                        station_camerathreadlist.at(i)->maxCheckTime = my_check_pack.sleep_time;
                    if (index == 0)
                        station_camerathreadlist.at(i)->send_byte = checkCamerasFinish_feedbackSignal(my_check_pack);
                    else
                        station_camerathreadlist.at(i)->send_byte = "pass"; //一个开始拍照对应多个相机的，回复的信号只保留一个，后面的不发了。减少通信耗时。
                    //Logic_camera_thread在线程运行，当getImgNums不为0时从相机模块获取getImgNums次图
                    //取图总时间超过maxCheckTime，会结束取图。
#if YH_LOGIC_SWITCH > 0
                    station_camerathreadlist.at(i)->yh_getImageSignal = yh_getImageSignal;
#endif
                    station_camerathreadlist.at(i)->getImgNums = runNum;
                    break;
                }
            }
        }
        ///*stop = clock();
        //qCritical() << "trigger_signal:" << trigger_signal << " run_camera_module station_camerathreadlist cut Time ::" << stop - start;
        //start = clock();*/
        //for (int ca = 0; ca < cameraKeyS_runNumS.size(); ca++)
        //{
        //    QString cameraName_getImgNum = cameraKeyS_runNumS[ca]; //相机key_运行次数
        //    int runNum = cameraName_getImgNum.split("_")[1].toInt();
        //    if (runNum < 1)
        //    {
        //        qCritical() << __FUNCTION__ << __LINE__ << " cameraKey_runNum err:" << cameraKeyS_runNumS[ca];
        //        return;
        //    }
        //    //runModule(cameraName);
        //    bool if_camera_get_All = true;
        //    for (int i = 0; i < station_camerathreadlist.size(); i++)
        //    {
        //        QString cameraKey = station_camerathreadlist.at(i)->getName(); //相机SN或userID
        //        // tmpDate = QDateTime::currentDateTime().toString("yyyy-MM-dd-hh-mm-ss-zzz");
        //        //std::cout << "run_camera_module strat 3 ::" << tmpDate.toStdString() << " trigger_camera_name::" << cameraKey_runNum.toStdString() << std::endl;
        //        if (cameraKey == cameraName_getImgNum.split("_")[0])
        //        {
        //            Logic_camera_thread* mycameraPtr = station_camerathreadlist.at(i);
        //            //mycameraPtr->wait();
        //            int mytime = 0;
        //            while (mycameraPtr->getImgNums != 0)
        //            {
        //                Sleep(20);
        //                mytime++;
        //                if (mytime >= check_pack.head().sleep_time) //"拍照信号-检查完成的时间": "360000"。设置很大：机台中途报警，复位后继续拍照检测
        //                {
        //                    mycameraPtr->set_m_stoprun(true);
        //                    Sleep(10);
        //                }
        //                //mycameraPtr->m_stoprun=true相机读SN信号时，进行设置
        //                if (mycameraPtr->getImgNums == 0 || mytime*20 >= check_pack.head().sleep_time || (mycameraPtr->m_stoprun==true && mytime>=50))
        //                    break;
        //            }
        //            Sleep(1);
        //            mycameraPtr->set_m_stoprun(true);// m_stoprun = true;
        //        }
        //    }
        //}


    }
    catch (QString ev)
    {
        qCritical() << __FUNCTION__ << __LINE__ << " ev:" << ev;
    }
    return;
}
//获取"拍照信号-完成写入PLC-列表"，拍照信号对应的反馈信号
QByteArray runAndCheck_cameraThread::checkCamerasFinish_feedbackSignal(trigger_signal_pack m_pack)
{
    int tmp_size = 0;
    //clock_t start_triggerTime = clock();
    // 写入反馈信号
    QVector<QString> vector_trigger_feedback_signal = m_pack.vector_trigger_feedback_signal;
    foreach(QString trigger_feedback_signal, vector_trigger_feedback_signal)
    {
        QStringList plc_feedback_msg_list = trigger_feedback_signal.split("_");
        if (plc_feedback_msg_list.size() != 5)
        {
            qWarning() << __FUNCTION__ << "  line: " << __LINE__ << " plc_feedback_msg_list num is error! plc_feedback_msg_list num:" << plc_feedback_msg_list.length();
        }
        else if (plc_feedback_msg_list.contains(m_pack.m_startpos))
        {
            // 发送反馈信号
            QString feedback_signal_type = plc_feedback_msg_list.at(1) + "_" + plc_feedback_msg_list.at(2);
            QString feedback_signal_pos = plc_feedback_msg_list.at(3);
            QString feedback_signal_value = plc_feedback_msg_list.at(4);
            QString send_msg = feedback_signal_type + "_" + feedback_signal_pos + "_" + feedback_signal_value;
            QByteArray send_byte = send_msg.toUtf8();
            return send_byte;

            /*//QMutexLocker locker(m_iomutex);;
            if (!finstcp_ptr->writeData(vec_mat, send_byte))
            {
                qCritical() << __FUNCTION__ << "line:" << __LINE__ << " finstcp_ptr reciveData error! ";
                return;
            }
            else
            {
                qDebug() << __FUNCTION__ << " line:" << __LINE__ << "feedback_signal: " << send_byte;
            }*/
        }
    }
    return "";
}