#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，数据存入容器，写入、取出加锁
}
//设置触发指令
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);
            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()
{
    // 运行并检查相机是否取图完成的线程
    // 一个信号取多张的情况，取图时间长，和通信线程分开。
    m_runAndCheck_cameraThread->start();
    int times = 0;
    while ( io_runflag )
    {
        //心跳（定时向PLC的指定寄存器写入值）代码。
        if (m_IoType.contains("Heart"))
        {
            //break;
            //times++;
            Sleep(10);
            qApp->processEvents();
            if ((m_heartTime / 10) <= times++)
            {
                if (!m_heartCmd.isEmpty())
                {// 发送心跳
                        ////QMutexLocker locker(m_iomutex);;
                    QByteArray byteArray = m_heartCmd.toUtf8();      // 设置 从起始位开始读取的指令
                    if (!finstcp_ptr->writeData(vec_mat, byteArray))
                    {
                        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 byteArray = readAll_cmd.toUtf8();      // 设置 从起始位开始读取的指令
                        if (!finstcp_ptr->writeData(vec_mat, byteArray))
                        {
                            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;
                                    }
                                }
                            }
                        }
                    }
                }
            }

            // 写入
            writeCommond();
        }
        else
        {
            // 读取
            reciveCommond();

            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()
{
    //QString tmpDate = QDateTime::currentDateTime().toString("yyyy-MM-dd-hh-mm-ss-zzz");
    //qDebug() << __FUNCTION__ << " line: " << __LINE__ << " readAll_cmd: " << readAll_cmd <<"   " << tmpDate;
    clock_t start, stop;
    start = clock();
    // 修改读取多个命令
    //QMutexLocker locker ( m_iomutex );
    m_iomutex->lock();
    QByteArray byteArray = readAll_cmd.toUtf8();      // 设置 从起始位开始读取的指令
    if ( !finstcp_ptr->writeData(vec_mat,byteArray) )
    {
        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!";
    }
    m_iomutex->unlock();
    stop = clock();
    double ctime = stop - start;
    //if (ctime > 500)
    //    qCritical() << __FUNCTION__ << __LINE__ << "readAll_cmd ctime :" << ctime;//;127ms

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

    decodeCameraCMD ( readByte );
}

// 读取多个命令信息的解析
void Logic_myiothread::decodeCameraCMD(QByteArray byteArray)
{
    if (byteArray.isEmpty())
        return;

     readsnByte = byteArray;
     vec_value.clear();
    while ( !byteArray.isEmpty() )
    {
        QByteArray retByte = byteArray.mid(0,2);
        byteArray.remove(0,2);

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

    // 读取sn数据
    readSnInfo(vec_value, readsnByte);

    // 读取紧急停止信号
    //931/949-5-2,读急停信号
    //readEmergencyStopSignal(vec_value);
    
    // 防重入检查标识符
    checkReentrySign(vec_value);

    // 触发相机拍照信息检查
    checkTriggerCamera(vec_value);
    //Sleep(100);
    //触发算法检查
    checkTriggerAlgorithm(vec_value);

    // 工站结束校验（缺图重拍使用）
    checkEndSingnal(vec_value);
}
//SN逻辑
// "读SN信号"满足时，代表新料来了，安装"清理容器数据"-"相机列表"及"通道序号"清理对应的容器；
//SN保存到容器HSnData；下料的SN，根据"汇总-触发信号"、"汇总-读哪个SN"匹配Logic_hdataintegration，并保存SN到变量；
void Logic_myiothread::readSnInfo(QVector<int> vec_value, QByteArray byteArray)
{
    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
        for ( int snsn = 0; snsn < sn_area_array.size(); snsn++ )
        {
            QJsonObject   obj = sn_area_array.at(snsn).toObject();
            QJsonObject   clearData = obj.value("清理容器数据").toObject();
            QJsonArray    clera_cameraList = clearData.value("相机列表").toArray();

            int channel_index = 0;
            channel_index= clearData.value("通道序号").toString().toInt();
            HSnData* m_sndata = station_list.value(station_name)->getSnInfoData(channel_index);
            m_sndata->stationName = station_name;
            if (m_sndata == nullptr)
            {
                continue;
            }

            //流程开始信号
            QString read_sn_startpos = obj.value("读SN信号").toString(); 
            if (!read_sn_startpos.isEmpty())
            {
                QString  m_startpos = read_sn_startpos.split("_")[0];
                QString  m_value = read_sn_startpos.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())
                    {
                        if (clera_cameraList.size() > 0) //清理时检查完成标志
                        {
                            //初始为true
                            if (m_runAndCheck_cameraThread->ifTaskDoneFlag == true)//是否检查任务完成标志（按照SN容器是否为空）
                            {
                                if (m_sndata->getTaskDoneFlag() == true)
                                {
                                    // 所有相机线程的snIndex减一？没什么用？
                                    for (int i = 0; i < m_runAndCheck_cameraThread->station_camerathreadlist.size(); i++)
                                    {
                                        m_runAndCheck_cameraThread->station_camerathreadlist.at(i)->degressSnIndex();
                                    }
                                    m_sndata->setTaskDoneFlag(false);
                                    //HCameraData的m_index
                                }
                                else
                                {
                                    QString tmpDate = QDateTime::currentDateTime().toString("yyyy-MM-dd-hh-mm-ss-zzz");
                                    if (m_runAndCheck_cameraThread->station_camerathreadlist.size() > 0)
                                        qCritical() << __FUNCTION__ << "  line:" << __LINE__ << " getTaskDoneFlag false !! 任务堆积风险，逻辑可能异常  "
                                        << tmpDate << " m_startpos::" << m_startpos << " at(0)m_stationName:" << m_runAndCheck_cameraThread->station_camerathreadlist.at(0)->m_stationName
                                        << " at(0)m_name:" << m_runAndCheck_cameraThread->station_camerathreadlist.at(0)->m_name;
                                }
                            }
                        }
                        
                        
                        // sn码防重入检查
                        QVector<bool>  m_vec_sn_flag = map_read_sn_reentry_vector_flag.value(station_name);
                        
                        if (m_vec_sn_flag.at(channel_index))  // false 添加sn码  true 已经添加过sn,不再重复添加
                        {
                            // 清理当前sn码的触发信号
                            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;
                            }
                            continue;
                        }
                        qCritical() << __FUNCTION__ << "  line:" << __LINE__ << " m_vec_sn_flag:" << m_vec_sn_flag.at(channel_index);


                        //相机列表
                        QStringList clearCameraList;
                        QJsonObject   clear_obj = obj.value("清理容器数据").toObject();
                        for (int cl = 0; cl < clera_cameraList.size(); cl++)
                        {
                            QString cameraKey = clera_cameraList[cl].toString();
                            clearCameraList.append(cameraKey);
                            for (int ca = 0; ca < camerathreadlist.size(); ca++)
                                if (camerathreadlist[ca]->m_name == cameraKey)
                                {
                                    QByteArray restCamera = "rest_newProductIn";//新产品进入，需清理相机模块的计数
                                    camerathreadlist[ca]->set_m_stoprun(true);
                                    camerathreadlist[ca]->m_Module.module_ptr->writeData(vec_mat, restCamera);
                                }
                        }

                        for (int i = 0; i < m_runAndCheck_cameraThread->station_camerathreadlist.size(); i++)
                            if (m_runAndCheck_cameraThread->station_camerathreadlist[i]->SN_signalList.contains(read_sn_startpos))
                                m_runAndCheck_cameraThread->station_camerathreadlist.at(i)->SN_signal = read_sn_startpos;

                        //软件汇总有问题，不能清理检测的结果数据？
                        // 清理sn、相机和算法数据
                        //新料来了，清容器数据；
                        //根据项目情况，考虑是否清检测容器数据。清，偶尔检测超时，数据缺失；不清，连续检测超时，内存溢出；默认不清，内存溢出现象容易排查。
                        if (clera_cameraList.size() > 0 && clearCameraList.size()>0)
                        {
                            //qCritical() << __FUNCTION__ << "  line:" << __LINE__ << " clearData:" << channel_index;
                            station_list.value(station_name)->clearData(QString::number(channel_index), clearCameraList);
                        }

                        ////重新加载并传参数到相机、算法
                        //if (ifinitSCA == false)
                        //{
                        //    //不能开线程去传参数
                        //    //QFuture<bool> SCAfuture= QtConcurrent::run(this, &Logic_myiothread::initStationCameraAndAlgorithm);
                        //    initStationCameraAndAlgorithm();
                        //    ifinitSCA = true;
                        //}


                        //SN必须正常，且不和上次相同。

                        QString read_sn_error_send_format = obj.value("读SN异常-插值").toString();

                        //读时间戳
                        QVector<QString> datatime_vector;
                        QJsonArray read_datatime_list = obj.value("读时间戳-寄存器列表").toArray();
                        QJsonArray write_datatime_list = obj.value("写时间戳-寄存器列表").toArray();
                        if (read_datatime_list.size() > 0)
                        {
                            for (int aaa = 0; aaa < read_datatime_list.size(); aaa++)
                            {
                                //SN为""时，返回配置文件的read_sn_error_send_format值
                                QString datatime = getSn(read_sn_error_send_format, read_datatime_list[aaa].toString(), byteArray);
                                qDebug() << __FUNCTION__ << " line: " << __LINE__ << " channel_index: " << channel_index << " read_datatime_list: " << datatime;
                                //sn_value = snHex(sn_value);  // sn方向相反，重新做转换

                                //异常
                                if (datatime == read_sn_error_send_format)
                                    datatime = "errDataTime";// datatime = QDateTime::currentDateTime().toString("yyyy-MM-dd-hh-mm-ss-zzz");
                                datatime_vector.append(datatime);
                            }

                            // 清理当前区域数据
                            QString clear_datatime = obj.value("读时间戳后-清0").toString();//"write_short_0"
                            if (!clear_datatime.isEmpty())
                            {
                                QStringList mycmdHead = clear_datatime.split("_");
                                for (int aaa = 0; aaa < read_datatime_list.size(); aaa++)
                                {
                                    QString datatime_area = read_datatime_list.at(aaa).toString();
                                    QString start_pos = datatime_area.split("_")[0];
                                    int lenght = datatime_area.split("_")[1].toInt();
                                    QString m_signal = nullptr;
                                    for (auto yyy = 0; yyy < (lenght + 1) /2; yyy++)
                                    {
                                        m_signal += mycmdHead[2];
                                        if (yyy != ((lenght + 1) / 2 - 1))
                                            m_signal += ",";
                                    }
                                    m_signal = mycmdHead[0]+"_"+ mycmdHead[1]+"_" + start_pos + "_" + m_signal;// QString("write_short_%1_%2").arg(start_pos).arg(m_signal);
                                    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;
                                    }
                                }
                            }

                        }
                        else if (write_datatime_list.size() > 0)
                        {
                            for (int aaa = 0; aaa < write_datatime_list.size(); aaa++)
                            {
                                QString tmpDate = QDateTime::currentDateTime().toString("yyyy-MM-dd-hh-mm-ss-zzz");
                                qDebug() << __FUNCTION__ << " line: " << __LINE__ << " channel_index: " << channel_index << " write_datatime_list: " << tmpDate;
                                //sn_value = snHex(sn_value);  // sn方向相反，重新做转换
                                datatime_vector.append(tmpDate);
                                //发给PLC:
                                QString datatime_area = write_datatime_list.at(aaa).toString(); //  "write_string_D3200_24"
                                QStringList mycmdHead = datatime_area.split("_");
                                QString start_pos = mycmdHead[2];
                                int lenght = mycmdHead[3].toInt();
                                if (tmpDate.size() % 2 == 1)tmpDate += "0";
                                QString m_signal = tmpDate; //= snHex(tmpDate); 
                                m_signal = mycmdHead[0]+"_"+ mycmdHead[1]+"_" + start_pos + "_" + m_signal;// QString("write_string_%1_%2").arg(start_pos).arg(m_signal);
                                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;
                                }
                            }
                        }

                        bool ifReadSnErr = false;

                        QJsonArray read_sn_list = obj.value("读SN寄存器列表").toArray();  // 读取sn
                        QVector<QString> sn_vector;
                        for (int aaa = 0; aaa < read_sn_list.size(); aaa++)
                        {
                            //SN为""时，返回配置文件的read_sn_error_send_format值
                            QString sn_value = getSn(read_sn_error_send_format, read_sn_list[aaa].toString(), byteArray);
                            qDebug() << __FUNCTION__ << " line: " << __LINE__ << " channel_index: " << channel_index << " sn_value: " << sn_value;
                            //sn_value = snHex(sn_value);  // sn方向相反，重新做转换
                            //异常
                            if (sn_value == read_sn_error_send_format)
                            {
                                sn_value = "errSN";// += "_" + read_sn_startpos;
                                ifReadSnErr = true;
                            }
                            if (datatime_vector.size() > 0)
                            {
                                if (datatime_vector.size() == read_sn_list.size())
                                    sn_value = sn_value + "_" + datatime_vector[aaa];
                                else sn_value = sn_value + "_" + datatime_vector[0];
                            }
                            sn_vector.append(sn_value);
                            
                            //匹配dataIntegration，并写入SN_datatime到容器
                            if(station_trigger_signal_dataIntegrationThread_list.size()>0)
                                setSN_hdataintegration(read_sn_startpos, aaa, sn_value);
                        }
                        m_sndata->addSnVector(sn_vector);//跟上个SN做对比，不同则添加；连续SN异常的，是否考虑不对比。
                        // 更新sn码防重入标志
                        QVector<bool>  vector_sn_flag = map_read_sn_reentry_vector_flag.value(station_name);
                        vector_sn_flag.replace(channel_index, true);
                        map_read_sn_reentry_vector_flag.insert(station_name, vector_sn_flag); // 替换sn码标识状态

                        


                        // 清理当前区域数据
                        QString clear_SN = obj.value("读SN后-清0").toString();
                        if (!clear_SN.isEmpty())
                        {
                            QStringList mycmdHead = clear_SN.split("_");
                            for (int aaa = 0; aaa < read_sn_list.size(); aaa++)
                            {
                                QString sn_area = read_sn_list.at(aaa).toString();
                                QString start_pos = sn_area.split("_")[0];
                                int lenght = sn_area.split("_")[1].toInt();
                                QString m_signal = nullptr;
                                //SN清空
                                for (auto yyy = 0; yyy < (lenght+1)/2; yyy++)
                                {
                                    m_signal += mycmdHead[2];
                                    if (yyy != ((lenght + 1) / 2 - 1))
                                        m_signal += ",";
                                }
                                m_signal = mycmdHead[0] + "_" + mycmdHead[1] + "_" + start_pos + "_" + m_signal;// QString("write_short_%1_%2").arg(start_pos).arg(m_signal);
                                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;
                                }
                            }
                        }
                        
                        // 清理当前sn码的触发信号
                        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;
                        }

                        

                        if (ifReadSnErr == true)
                        {
                            QString       snErrCmd = obj.value("读SN异常-回复指令").toString();
                            if (!snErrCmd.isEmpty())
                            {
                                //snErrCmd = CmdHeadShort + snErrCmd;
                                QByteArray ok_byte = snErrCmd.toUtf8();
                                if (!finstcp_ptr->writeData(vec_mat, ok_byte))
                                {
                                    qCritical() << __FUNCTION__ << " line:" << __LINE__ << " finstcp_ptr reciveData error! ";
                                    return;
                                }
                            }
                        }
                        else
                        {
                            // snOKCmd
                            QString       snOKCmd = obj.value("读SN正常-回复指令").toString();
                            if (!snOKCmd.isEmpty())
                            {
                                //snOKCmd = CmdHeadShort + snOKCmd;
                                QByteArray ok_byte = snOKCmd.toUtf8();
                                if (!finstcp_ptr->writeData(vec_mat, ok_byte))
                                {
                                    qCritical() << __FUNCTION__ << " line:" << __LINE__ << " finstcp_ptr reciveData error! ";
                                    return;
                                }
                            }
                        }
                    }
                    else if ( vec_value.at(trigger_index) == 0 ){ //读到PLC标志为0时
                        // 更改防重入标识符
                        QVector<bool>  vector_sn_flag = map_read_sn_reentry_vector_flag.value(station_name);
                        vector_sn_flag.replace(channel_index, false);
                        map_read_sn_reentry_vector_flag.insert(station_name, vector_sn_flag); // 替换sn码标识状态
                    }
                }
            }
        }
    }

}

//下料的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 byteArray)
{
    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 = byteArray.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::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");
    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 = m_runAndCheck_cameraThread->map_trigger_signal_pack.value(trigger_signal);
            //收到信号直接回复；软件卡顿、通信断开等异常，可能导致信号回复失败
            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 ( vec_value.at(trigger_index) == m_value.toInt() && m_pack.trigger_reentry_signal == 0 )
            {
                qDebug() << __FUNCTION__ << " line:" << __LINE__ << "trigger_signal: " << trigger_signal;
                
                //一个信号，对应相机拍多张图？
                // 添加被触发的相机名称;运行相机及取图
                if ( !m_pack.vector_camera.isEmpty() )
                {
                    QStringList trigger_camera_name_getImgNumS;
                    QMutexLocker locker(m_runAndCheck_cameraThread->commond_pack_lock );
                    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);
                        }
                    }
                    qCritical() << "trigger_signal:" << trigger_signal << " run_camera_module station_camerathreadlist ";
                    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); 
                }
                
                m_pack.trigger_reentry_signal = 1;
                m_runAndCheck_cameraThread->map_trigger_signal_pack.insert(trigger_signal,m_pack); // 替换为1
            }
        }
    }
}

// 触发算法检查
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();
    exit();
    wait(1);
    qDebug() << __FUNCTION__ << "line:" << __LINE__ << " delete success! " ;
}

//Logic_myiothread的run运行时，开始线程运行
//~Logic_myiothread时，runflag为false结束运行
void runAndCheck_cameraThread::run()
{
    while (true)
    {
        if(!runflag)
        {
            return;
        }

        while (!runCameraKey_num.isEmpty())
        {
            QMutexLocker locker ( commond_pack_lock );
            QStringList cameraKeyS_runNumS = runCameraKey_num.dequeue();
            run_camera_module(cameraKeyS_runNumS);
        }
        Sleep(1);
        qApp->processEvents();
    }
}
//运行相机并等待拍完
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;
}

//获取"拍照信号-完成写入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 "";
}