1757 lines
79 KiB
C++
1757 lines
79 KiB
C++
#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 byte = m_heartCmd.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.byte = 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 < 10; 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 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!";
|
||
}
|
||
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 byte)
|
||
{
|
||
if (byte.isEmpty())
|
||
return;
|
||
|
||
QByteArray readsnByte = byte;
|
||
QVector<int> vec_value;
|
||
while ( !byte.isEmpty() )
|
||
{
|
||
QByteArray retByte = byte.mid(0,2);
|
||
byte.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 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
|
||
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(), byte);
|
||
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(), byte);
|
||
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 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::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 "";
|
||
} |