1884 lines
80 KiB
C++
1884 lines
80 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，数据存入容器，写入、取出加锁
|
||
}
|
||
|
||
// 递归转换 QJsonValue 到 nlohmann::json
|
||
inline nlohmann::json QJsonValueToNlohmannJson(const QJsonValue& value) {
|
||
if (value.isObject()) {
|
||
nlohmann::json objJson;
|
||
QJsonObject obj = value.toObject();
|
||
for (auto it = obj.begin(); it != obj.end(); ++it) {
|
||
objJson[it.key().toStdString()] = QJsonValueToNlohmannJson(it.value());
|
||
}
|
||
return objJson;
|
||
}
|
||
else if (value.isArray()) {
|
||
nlohmann::json arrJson = nlohmann::json::array();
|
||
QJsonArray arr = value.toArray();
|
||
for (const auto& v : arr) {
|
||
arrJson.push_back(QJsonValueToNlohmannJson(v));
|
||
}
|
||
return arrJson;
|
||
}
|
||
else if (value.isString()) {
|
||
return value.toString().toStdString();
|
||
}
|
||
else if (value.isDouble()) {
|
||
return value.toDouble();
|
||
}
|
||
else if (value.isBool()) {
|
||
return value.toBool();
|
||
}
|
||
else if (value.isNull() || value.isUndefined()) {
|
||
return nullptr;
|
||
}
|
||
return nullptr;
|
||
}
|
||
|
||
// QJsonArray 转 nlohmann::json
|
||
inline nlohmann::json QJsonArrayToNlohmannJson(const QJsonArray& arr) {
|
||
nlohmann::json result = nlohmann::json::array();
|
||
for (const auto& v : arr) {
|
||
result.push_back(QJsonValueToNlohmannJson(v));
|
||
}
|
||
return result;
|
||
}
|
||
//设置触发指令
|
||
void Logic_myiothread::setTriggerCmd(QJsonObject station_obj)
|
||
{
|
||
QVector<QString> camera_trigger_cmds;
|
||
{
|
||
//QJsonObject station_obj = stationlist.at(i).toObject();
|
||
QString station_name = station_obj.value("工站名").toString();
|
||
m_stationName = station_obj.value("工站名").toString();
|
||
QJsonArray cameramodulelist = station_obj.value("相机模块列表").toArray();
|
||
m_cameralist = cameramodulelist;
|
||
for (int val = 0; val < cameramodulelist.size(); val++)
|
||
{
|
||
QJsonObject m_obj = cameramodulelist.at(val).toObject();
|
||
QString trigger_camera_name = m_obj.value("相机key").toString();
|
||
|
||
QString clear_camera_startpos_flag = m_obj.value("拍照信号-收到后-写值").toString();
|
||
|
||
//相机开始信号
|
||
QJsonArray trigger_camera_startpos_array = m_obj.value("拍照信号-拍照张数-列表").toArray();
|
||
QJsonArray plc_feedback_msg_array = m_obj.value("拍照信号-完成写入PLC-列表").toArray();
|
||
QString feedback_sleep_time = m_obj.value("拍照信号-检查完成的时间").toString();
|
||
|
||
QStringList m_feedback_list;
|
||
for (auto yyy = 0; yyy < plc_feedback_msg_array.size(); yyy++)
|
||
{
|
||
m_feedback_list.push_back(plc_feedback_msg_array.at(yyy).toString());
|
||
}
|
||
|
||
// 添加相机反馈延迟时间
|
||
if (!feedback_sleep_time.isEmpty())
|
||
map_camera_feedback_sleep_time.insert(trigger_camera_name, feedback_sleep_time);
|
||
|
||
for (int val = 0; val < trigger_camera_startpos_array.size(); val++)
|
||
{
|
||
//开始的触发信号
|
||
QString trigger_signal = trigger_camera_startpos_array.at(val).toString();
|
||
if (m_runAndCheck_cameraThread->map_trigger_signal_pack.keys().contains(trigger_signal))
|
||
{
|
||
trigger_signal_pack m_pack = m_runAndCheck_cameraThread->map_trigger_signal_pack.value(trigger_signal);
|
||
m_pack.vector_camera.push_back(trigger_camera_name);
|
||
m_runAndCheck_cameraThread->map_trigger_signal_pack.insert(trigger_signal, m_pack); // 替换
|
||
}
|
||
else
|
||
{
|
||
trigger_signal_pack m_pack; // 创建
|
||
foreach(QString value, m_feedback_list)
|
||
{
|
||
QString check_trigger_signal = trigger_signal.split("_")[0];
|
||
if (value.contains(check_trigger_signal))
|
||
{
|
||
//反馈信号
|
||
m_pack.vector_trigger_feedback_signal.push_back(value);
|
||
break;
|
||
}
|
||
}
|
||
m_pack.trigger_reentry_signal = 0; // 初始化
|
||
//清理开始信号标志，true写0
|
||
m_pack.clear_camera_startpos_flag = clear_camera_startpos_flag;
|
||
|
||
m_pack.vector_camera.push_back(trigger_camera_name);
|
||
m_runAndCheck_cameraThread->map_trigger_signal_pack.insert(trigger_signal, m_pack);
|
||
}
|
||
}
|
||
}
|
||
|
||
//算法的通信内容
|
||
QJsonArray algorithmlist = station_obj.value("算法列表").toArray();
|
||
m_algorithmlistArray = algorithmlist;
|
||
for (int val = 0; val < algorithmlist.size(); val++)
|
||
{
|
||
QJsonObject m_obj = algorithmlist.at(val).toObject();
|
||
QString trigger_algorithm_name = m_obj.value("算法名称").toString();
|
||
for (int i = 0; i < station_trigger_signal_dataIntegrationThread_list.size(); i++)
|
||
{
|
||
if (station_trigger_signal_dataIntegrationThread_list[i]->m_algorithmKey == trigger_algorithm_name)
|
||
{
|
||
trigger_signal_pack m_pack;
|
||
m_pack.trigger_reentry_signal = 0; // 初始化
|
||
QString trigger_signal = station_trigger_signal_dataIntegrationThread_list[i]->m_trigger_signal;
|
||
QString trigger_feedback_signal = station_trigger_signal_dataIntegrationThread_list[i]->m_trigger_back_signal;
|
||
if (map_algorithm_trigger_signal_pack.keys().contains(trigger_signal))
|
||
m_pack = map_algorithm_trigger_signal_pack.value(trigger_signal);
|
||
m_pack.vector_trigger_feedback_signal.push_back(trigger_feedback_signal);
|
||
m_pack.vector_camera.push_back(trigger_algorithm_name);
|
||
map_algorithm_trigger_signal_pack.insert(trigger_signal, m_pack);
|
||
}
|
||
}
|
||
if (m_obj.value("SN设置").toObject().value("汇总-是否删除SN容器首数据").toString() == "true")
|
||
m_runAndCheck_cameraThread->ifTaskDoneFlag = true;
|
||
}
|
||
|
||
QJsonArray sn_array = station_obj.value("SN流程列表").toArray();
|
||
if (!sn_array.isEmpty())
|
||
{
|
||
QVector<bool> vector_flag;
|
||
for (int iiiii = 0; iiiii < sn_array.size(); iiiii++)
|
||
{
|
||
vector_flag.append(false);
|
||
}
|
||
map_sn_area_array.insert(station_name, sn_array);
|
||
//602
|
||
auto nloJsonData = QJsonArrayToNlohmannJson(sn_array);
|
||
map_sn_area_array_nlohmann.insert(station_name, nloJsonData);
|
||
std::vector<ClearData> clearDatas;
|
||
for (auto& jData : nloJsonData) {
|
||
ClearData cData;
|
||
auto& jsonData = jData["清理容器数据"];
|
||
cData.channel_index = std::atoi(jsonData["通道序号"].get<std::string>().c_str());
|
||
for (auto& v : jsonData["相机列表"])
|
||
cData.cameraList.append(QString::fromStdString(v));
|
||
clearDatas.push_back(cData);
|
||
}
|
||
map_ClearData.insert(station_name, clearDatas);
|
||
|
||
map_read_sn_reentry_vector_flag.insert(station_name, vector_flag);
|
||
}
|
||
if (!station_obj.value("工站结束效验信号(缺图重拍)").toString().isEmpty())
|
||
map_endSingnal_backObj.insert(station_obj.value("工站结束效验信号(缺图重拍)").toString(), station_obj.value("工站结束效验信号-回复").toObject());
|
||
}
|
||
}
|
||
|
||
|
||
void Logic_myiothread::run()
|
||
{
|
||
// 运行并检查相机是否取图完成的线程
|
||
// 一个信号取多张的情况，取图时间长，和通信线程分开。
|
||
int times = 0;
|
||
heart_start = clock();
|
||
|
||
//心跳（定时向PLC的指定寄存器写入值）代码。
|
||
if (m_IoType.contains("Heart"))
|
||
{
|
||
int heartIndex = 0;
|
||
int cnt = 0;
|
||
while (io_runflag){
|
||
cnt++;
|
||
if (cnt > 100) {
|
||
QStringList m_heartCmdList = m_heartCmd.split("#");
|
||
int m_heartCmdListSize = m_heartCmdList.size();
|
||
if (m_heartCmdList.size() == 0)
|
||
return;
|
||
QByteArray byte = m_heartCmdList[heartIndex].toUtf8(); // 设置 从起始位开始读取的指令
|
||
if (!finstcp_ptr->writeData(vec_mat, byte))
|
||
{
|
||
qCritical() << __FUNCTION__ << "line:" << __LINE__ << " finstcp_ptr reciveData error!";
|
||
}
|
||
heartIndex >= m_heartCmdListSize -1 ? heartIndex = 0 : heartIndex++;
|
||
cnt = 0;
|
||
|
||
}
|
||
#if 0
|
||
for (int m = 0; m < m_heartCmdList.size(); m++)
|
||
{
|
||
Sleep(10);
|
||
qApp->processEvents();
|
||
heart_stop = clock();
|
||
//if ((m_heartTime / 10) <= times++)
|
||
if (heart_stop - heart_start >= m_heartTime)
|
||
{
|
||
heart_start = clock();
|
||
if (!m_heartCmdList[m].isEmpty())
|
||
{// 发送心跳
|
||
////QMutexLocker locker(m_iomutex);;
|
||
QByteArray byte = m_heartCmdList[m].toUtf8(); // 设置 从起始位开始读取的指令
|
||
if (!finstcp_ptr->writeData(vec_mat, byte))
|
||
{
|
||
qCritical() << __FUNCTION__ << "line:" << __LINE__ << " finstcp_ptr reciveData error!";
|
||
}
|
||
times = 0;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!rest_signal.isEmpty())
|
||
{
|
||
if (times % int(m_heartTime / 50 + 1) == 0)
|
||
{
|
||
// 修改读取多个命令
|
||
//QMutexLocker locker(m_iomutex);;
|
||
QByteArray byte = readAll_cmd.toUtf8(); // 设置 从起始位开始读取的指令
|
||
if (!finstcp_ptr->writeData(vec_mat, byte))
|
||
{
|
||
qCritical() << __FUNCTION__ << "line:" << __LINE__ << " finstcp_ptr reciveData error!";
|
||
}
|
||
|
||
// 读取到的信息解析
|
||
QByteArray readByte;
|
||
if (!finstcp_ptr->readData(vec_mat, readByte))
|
||
{
|
||
qCritical() << __FUNCTION__ << "line:" << __LINE__ << " finstcp_ptr sendData error!";
|
||
}
|
||
|
||
if (readByte.isEmpty())
|
||
return;
|
||
QByteArray readsnByte = readByte;
|
||
QVector<int> vec_value;
|
||
while (!readByte.isEmpty())
|
||
{
|
||
QByteArray retByte = readByte.mid(0, 2);
|
||
readByte.remove(0, 2);
|
||
|
||
QString msg = retByte.toHex();
|
||
int number_tmp = msg.toInt(NULL, 16);
|
||
vec_value.push_back(number_tmp);
|
||
}
|
||
|
||
QString m_startpos = rest_signal.split("_")[0];
|
||
QString m_value = rest_signal.split("_")[1];
|
||
int trigger_index = m_startpos.mid(1, m_startpos.length() - 1).toInt();
|
||
trigger_index -= trigger_startpos;
|
||
if (trigger_index < 0)
|
||
{
|
||
qCritical() << __FUNCTION__ << " line:" << __LINE__ << " vec_value is error! read_sn_startpos:" << m_startpos;
|
||
}
|
||
else if (vec_value.size() > trigger_index)
|
||
{
|
||
//读复位标志满足
|
||
if (vec_value.at(trigger_index) == m_value.toInt())
|
||
{
|
||
qCritical() << __FUNCTION__ << " line:" << __LINE__ << " 复位信号:" << rest_signal;
|
||
foreach(QString m_station_name, station_list.keys())
|
||
for (int i = 0; i < station_list.value(m_station_name)->sndata_list.size(); i++)
|
||
{
|
||
QStringList cameraList;
|
||
cameraList.append("all");
|
||
for (int i = 0; i < 10; i++)
|
||
station_list.value(m_station_name)->clearData("all", cameraList);
|
||
}
|
||
//完成清标志
|
||
QByteArray send_byte = rest_signal_back.toUtf8();
|
||
if (!finstcp_ptr->writeData(vec_mat, send_byte))
|
||
{
|
||
qCritical() << __FUNCTION__ << "line:" << __LINE__ << " finstcp_ptr reciveData error! ";
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
//程序号；传到到主界面类，再进行切换
|
||
if (!program_Num.isEmpty())
|
||
{
|
||
QString m_startpos = program_Num;// .split("_")[0];
|
||
//QString m_value = program_Num.split("_")[1];
|
||
int trigger_index = m_startpos.mid(1, m_startpos.length() - 1).toInt();
|
||
trigger_index -= trigger_startpos;
|
||
if (trigger_index < 0)
|
||
{
|
||
qCritical() << __FUNCTION__ << " line:" << __LINE__ << " vec_value is error! read_sn_startpos:" << m_startpos;
|
||
}
|
||
else if (vec_value.size() > trigger_index)
|
||
{
|
||
//读复位标志满足
|
||
if (vec_value.at(trigger_index) != 0)
|
||
{
|
||
qCritical() << __FUNCTION__ << " line:" << __LINE__ << " 程序号:" << vec_value.at(trigger_index);
|
||
|
||
dataPack m_data;
|
||
m_data.algorithmName = "程序号";
|
||
m_data.cameraName = m_startpos;
|
||
m_data.byteArray = QByteArray::number(vec_value.at(trigger_index));
|
||
m_data.retFlag = "algorithm";
|
||
|
||
QMutexLocker locker(sendProcess_mutex);
|
||
sendProcessTask.enqueue(m_data);
|
||
//完成清标志
|
||
QByteArray send_byte = program_Num_back.toUtf8();
|
||
if (!finstcp_ptr->writeData(vec_mat, send_byte))
|
||
{
|
||
qCritical() << __FUNCTION__ << "line:" << __LINE__ << " finstcp_ptr reciveData error! ";
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
#endif
|
||
// 写入
|
||
writeCommond();
|
||
QThread::msleep(10);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
while (io_runflag)
|
||
{
|
||
// 读取
|
||
reciveCommond();
|
||
QThread::msleep(5);
|
||
//for (int s = 0; s < 5; s++)
|
||
//{
|
||
// Sleep(1);
|
||
// qApp->processEvents();
|
||
//}
|
||
//Sleep(20);
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
// 写入数据
|
||
void Logic_myiothread::writeCommond()
|
||
{
|
||
if (writeCommondPack.isEmpty())
|
||
return;
|
||
//多线程也行
|
||
//要先加锁，不加锁会访问冲突
|
||
QMutexLocker locker(write_data_mutex);
|
||
while (!writeCommondPack.isEmpty())
|
||
{
|
||
//QMutexLocker locker(m_iomutex);;
|
||
QByteArray write_byte = writeCommondPack.dequeue();
|
||
if (!finstcp_ptr->writeData(vec_mat, write_byte))
|
||
{
|
||
qCritical() << __FUNCTION__ << "line:" << __LINE__ << " finstcp_ptr reciveData error!";
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
|
||
void Logic_myiothread::reciveCommond()
|
||
{
|
||
#if JSONRPC_SWTICH == 1
|
||
//QString tmpDate = QDateTime::currentDateTime().toString("yyyy-MM-dd-hh-mm-ss-zzz");
|
||
//qDebug() << __FUNCTION__ << " line: " << __LINE__ << " readAll_cmd: " << readAll_cmd <<" " << tmpDate;
|
||
|
||
|
||
// 修改读取多个命令
|
||
//QMutexLocker locker ( m_iomutex );
|
||
|
||
QByteArray readByte = readAll_cmd.toUtf8(); // 设置 从起始位开始读取的指令
|
||
//if (!finstcp_ptr->writeData(vec_mat, byte))
|
||
//{
|
||
// qCritical() << __FUNCTION__ << "line:" << __LINE__ << " finstcp_ptr reciveData error!";
|
||
//}
|
||
|
||
//// 读取到的信息解析
|
||
//QByteArray readByte;
|
||
m_iomutex->lock();
|
||
if (!finstcp_ptr->readData(vec_mat, readByte))
|
||
{
|
||
qCritical() << __FUNCTION__ << "line:" << __LINE__ << " finstcp_ptr sendData error!";
|
||
}
|
||
m_iomutex->unlock();
|
||
loopCnt++;
|
||
if (loopCnt > 1000) {
|
||
clock_stop = clock();
|
||
double ctime = clock_stop - clock_start;
|
||
qDebug() << "最近一千次循环耗时 " << ctime << "ms";
|
||
loopCnt = 0;
|
||
clock_start = clock();
|
||
}
|
||
#else
|
||
QByteArray readByte = readAll_cmd.toUtf8(); // 设置 从起始位开始读取的指令
|
||
if (!finstcp_ptr->writeData(vec_mat, readByte))
|
||
{
|
||
qCritical() << __FUNCTION__ << "line:" << __LINE__ << " finstcp_ptr reciveData error!";
|
||
}
|
||
|
||
//// 读取到的信息解析
|
||
m_iomutex->lock();
|
||
if (!finstcp_ptr->readData(vec_mat, readByte))
|
||
{
|
||
qCritical() << __FUNCTION__ << "line:" << __LINE__ << " finstcp_ptr sendData error!";
|
||
}
|
||
m_iomutex->unlock();
|
||
loopCnt++;
|
||
if (loopCnt > 1000) {
|
||
clock_stop = clock();
|
||
double ctime = clock_stop - clock_start;
|
||
qDebug() << "最近一千次循环耗时 " << ctime << "ms";
|
||
loopCnt = 0;
|
||
clock_start = clock();
|
||
}
|
||
#endif
|
||
//if (ctime > 500)
|
||
//qCritical() << __FUNCTION__ << __LINE__ << "readAll_cmd ctime :" << ctime<<" m_stationName:"<<m_stationName;//;127ms
|
||
|
||
// tmpDate = QDateTime::currentDateTime().toString("yyyy-MM-dd-hh-mm-ss-zzz");
|
||
//qDebug() << __FUNCTION__ << " line: " << __LINE__ << " readAll_cmd done: " << readAll_cmd << " " << tmpDate;
|
||
|
||
decodeCameraCMD(readByte);
|
||
QThread::msleep(1);
|
||
}
|
||
|
||
// 读取多个命令信息的解析
|
||
QVector<int> byteArrayToIntVector(const QByteArray& byte)
|
||
{
|
||
QVector<int> vec_value;
|
||
int count = byte.size() / 2;
|
||
vec_value.reserve(count);
|
||
const uchar* data = reinterpret_cast<const uchar*>(byte.constData());
|
||
for (int i = 0; i < count; ++i) {
|
||
int value = (data[2 * i] << 8) | data[2 * i + 1];
|
||
vec_value.push_back(value);
|
||
}
|
||
return vec_value;
|
||
}
|
||
void Logic_myiothread::decodeCameraCMD(QByteArray& byte)
|
||
{
|
||
if (byte.isEmpty())
|
||
return;
|
||
|
||
readsnByte = byte;
|
||
QVector<int> vec_value = byteArrayToIntVector(byte);
|
||
_triggerLockerT.reFreshLocker(vec_value);
|
||
for (auto& it : _triggerLockerT.lockerList) {
|
||
vec_value[it] = 0;
|
||
}
|
||
// 读取sn数据
|
||
readSnInfo(vec_value, readsnByte);
|
||
// 读取紧急停止信号
|
||
//931/949-5-2,读急停信号
|
||
//readEmergencyStopSignal(vec_value);
|
||
|
||
//防重入检查标识符
|
||
checkReentrySign(vec_value);
|
||
|
||
// 触发相机拍照信息检查
|
||
checkTriggerCamera(vec_value);
|
||
|
||
//触发算法检查
|
||
checkTriggerAlgorithm(vec_value);
|
||
|
||
// 工站结束校验（缺图重拍使用）
|
||
checkEndSingnal(vec_value);
|
||
}
|
||
//SN逻辑
|
||
// "读SN信号"满足时，代表新料来了，安装"清理容器数据"-"相机列表"及"通道序号"清理对应的容器；
|
||
//SN保存到容器HSnData；下料的SN，根据"汇总-触发信号"、"汇总-读哪个SN"匹配Logic_hdataintegration，并保存SN到变量；
|
||
void Logic_myiothread::readSnSub(
|
||
const QString& station_name,
|
||
const nlohmann::json& jsonObj,
|
||
const QVector<int>& vec_value,
|
||
const QByteArray& byte,
|
||
const ClearData& clearData) {
|
||
//clock_t start = clock();
|
||
//clock_t stop2, stop3, stop4, stop5, stop6, stop7;
|
||
//bool printTimeCost = false;
|
||
// 提前解析 json，减少多次 toObject/toArray
|
||
|
||
|
||
HSnData* m_sndata = station_list.value(station_name)->getSnInfoData(clearData.channel_index);
|
||
if (!m_sndata) return;
|
||
m_sndata->stationName = station_name;
|
||
//stop2 = clock();
|
||
QString m_startpos, m_value;
|
||
QString read_sn_startpos = QString::fromStdString(jsonObj["读SN信号"]);
|
||
if (!read_sn_startpos.isEmpty())
|
||
{
|
||
auto parts = read_sn_startpos.split('_');
|
||
if (parts.size() >= 2) {
|
||
m_startpos = parts[0];
|
||
m_value = parts[1];
|
||
}
|
||
}
|
||
|
||
int trigger_index = m_startpos.mid(1).toInt() - trigger_startpos;
|
||
if (trigger_index < 0 || vec_value.size() <= trigger_index) {
|
||
qCritical() << __FUNCTION__ << " line:" << __LINE__ << " invalid trigger_index:" << trigger_index;
|
||
return;
|
||
}
|
||
#if YH_LOGIC_SWITCH == 2
|
||
if ((vec_value.at(trigger_index) == m_value.toInt() && _triggerLockerT.checkLocker(trigger_index))||
|
||
(vec_value.at(trigger_index+ 2) == m_value.toInt() && _triggerLockerT.checkLocker(trigger_index + 2))
|
||
) {
|
||
#elif YH_LOGIC_SWITCH == 4
|
||
if ((vec_value.at(trigger_index) == m_value.toInt() && _triggerLockerT.checkLocker(trigger_index)||
|
||
(vec_value.at(trigger_index + 2) == m_value.toInt() && _triggerLockerT.checkLocker(trigger_index + 2)) ||
|
||
(vec_value.at(trigger_index + 4) == m_value.toInt() && _triggerLockerT.checkLocker(trigger_index + 4)) ||
|
||
(vec_value.at(trigger_index + 6) == m_value.toInt() && _triggerLockerT.checkLocker(trigger_index + 6))
|
||
) {
|
||
#else
|
||
if (vec_value.at(trigger_index) == m_value.toInt() && _triggerLockerT.checkLocker(trigger_index)) {
|
||
#endif
|
||
|
||
if (!clearData.cameraList.isEmpty()) {
|
||
if (m_runAndCheck_cameraThread->ifTaskDoneFlag) {
|
||
if (m_sndata->getTaskDoneFlag()) {
|
||
for (auto& camThread : m_runAndCheck_cameraThread->station_camerathreadlist)
|
||
camThread->degressSnIndex();
|
||
m_sndata->setTaskDoneFlag(false);
|
||
}
|
||
else {
|
||
QString tmpDate = QDateTime::currentDateTime().toString("yyyy-MM-dd-hh-mm-ss-zzz");
|
||
qCritical() << __FUNCTION__ << " line:" << __LINE__ << " getTaskDoneFlag false !! 堆积风险 "
|
||
<< tmpDate << " m_startpos:" << m_startpos;
|
||
}
|
||
}
|
||
}
|
||
|
||
//stop3 = clock();
|
||
QVector<bool>& m_vec_sn_flag = map_read_sn_reentry_vector_flag[station_name];
|
||
//qCritical() << __FUNCTION__ << " line:" << __LINE__ << " m_vec_sn_flag:" << m_vec_sn_flag[clearData.channel_index];
|
||
//stop4 = clock();
|
||
//相机列表清理
|
||
for (auto& cameraKey : clearData.cameraList) {
|
||
for (auto& cam : camerathreadlist) {
|
||
if (cam->m_name == cameraKey) {
|
||
//std::thread([cam] {
|
||
std::vector<cv::Mat> vec_mat;
|
||
//QByteArray restCamera = "rest_newProductIn";
|
||
cam->set_m_stoprun(true);
|
||
//cam->m_Module.module_ptr->writeData(vec_mat, restCamera);
|
||
QByteArray sf = "softwareTrigger";
|
||
cam->m_Module.module_ptr->writeData(vec_mat, sf);
|
||
//}).detach();
|
||
|
||
}
|
||
}
|
||
}
|
||
//stop5 = clock();
|
||
for (auto& camThread : m_runAndCheck_cameraThread->station_camerathreadlist) {
|
||
if (camThread->SN_signalList.contains(read_sn_startpos))
|
||
camThread->SN_signal = read_sn_startpos;
|
||
}
|
||
|
||
if (!clearData.cameraList.isEmpty())
|
||
station_list.value(station_name)->clearData(QString::number(clearData.channel_index), clearData.cameraList);
|
||
|
||
//时间戳一次生成
|
||
QString tmpDate = QDateTime::currentDateTime().toString("yyyy-MM-dd-hh-mm-ss-zzz");
|
||
QVector<QString> datatime_vector;
|
||
//auto read_datatime_list = obj.value("读时间戳-寄存器列表").toArray();
|
||
//auto write_datatime_list = obj.value("写时间戳-寄存器列表").toArray();
|
||
|
||
//if (!read_datatime_list.isEmpty()) {
|
||
// for (auto& item : read_datatime_list) {
|
||
// QString datatime = getSn(obj.value("读SN异常-插值").toString(), item.toString(), byte);
|
||
// if (datatime == obj.value("读SN异常-插值").toString())
|
||
// datatime = "errDataTime";
|
||
// datatime_vector.append(datatime);
|
||
// }
|
||
//}
|
||
//else if (!write_datatime_list.isEmpty()) {
|
||
// for (auto& item : write_datatime_list)
|
||
// datatime_vector.append(tmpDate);
|
||
//}
|
||
if (jsonObj["读时间戳-寄存器列表"].size()>0) {
|
||
for (auto& item : jsonObj["读时间戳-寄存器列表"]) {
|
||
QString datatime = getSn(QString::fromStdString(jsonObj["读SN异常-插值"]), QString::fromStdString(item), byte);
|
||
if (datatime == QString::fromStdString(jsonObj["读SN异常-插值"]))
|
||
datatime = "errDataTime";
|
||
datatime_vector.append(datatime);
|
||
}
|
||
}
|
||
else if (jsonObj["写时间戳-寄存器列表"].size() > 0) {
|
||
for (auto& item : jsonObj["写时间戳-寄存器列表"])
|
||
datatime_vector.append(tmpDate);
|
||
}
|
||
//读取 SN
|
||
bool ifReadSnErr = false;
|
||
QVector<QString> sn_vector;
|
||
//auto read_sn_list = obj.value("读SN寄存器列表").toArray();
|
||
for (int i = 0; i < jsonObj["读SN寄存器列表"].size(); ++i) {
|
||
QString sn_value = getSn(QString::fromStdString(jsonObj["读SN异常-插值"]), QString::fromStdString(jsonObj["读SN寄存器列表"].at(i)), byte);
|
||
if (sn_value == QString::fromStdString(jsonObj["读SN异常-插值"])) {
|
||
sn_value = "errSN";
|
||
ifReadSnErr = true;
|
||
}
|
||
if (!datatime_vector.isEmpty())
|
||
sn_value += "_" % (datatime_vector.size() == jsonObj["读SN寄存器列表"].size() ? datatime_vector[i] : datatime_vector[0]);
|
||
sn_vector.append(sn_value);
|
||
if (!station_trigger_signal_dataIntegrationThread_list.isEmpty())
|
||
setSN_hdataintegration(read_sn_startpos, i, sn_value);
|
||
}
|
||
|
||
m_sndata->addSnVector(sn_vector);
|
||
|
||
m_vec_sn_flag[clearData.channel_index] = true;
|
||
|
||
//异常 or 正常 回包
|
||
QStringList replyList = ifReadSnErr ?
|
||
QString::fromStdString(jsonObj["读SN异常-回复指令"]).split("#") :
|
||
QString::fromStdString(jsonObj["读SN正常-回复指令"]).split("#");
|
||
//stop6 = clock();
|
||
//std::thread([this, replyList, m_startpos] {
|
||
for (auto& cmd : replyList)
|
||
finstcp_ptr->writeData(vec_mat, cmd.toUtf8());
|
||
|
||
//清除触发信号
|
||
|
||
// finstcp_ptr->writeData(vec_mat, ("write_short_" % m_startpos % "_0").toUtf8());
|
||
//}).detach();
|
||
//stop7 = clock();
|
||
//printTimeCost = false;
|
||
}
|
||
else if (vec_value.at(trigger_index) == 0) {
|
||
QVector<bool>& m_vec_sn_flag = map_read_sn_reentry_vector_flag[station_name];
|
||
m_vec_sn_flag[clearData.channel_index] = false;
|
||
}
|
||
|
||
//if (printTimeCost == true){
|
||
// clock_t stop = clock();
|
||
// double ctime2 = stop2 - start;
|
||
// double ctime3 = stop3 - start;
|
||
// double ctime4 = stop4 - start;
|
||
// double ctime5 = stop5 - start;
|
||
// double ctime6 = stop6 - start;
|
||
// double ctime7 = stop7 - start;
|
||
// double ctime = stop - start;
|
||
// std::stringstream ss;
|
||
// ss << std::this_thread::get_id();
|
||
// QString tid = QString::fromStdString(ss.str());
|
||
// qDebug() << __FUNCTION__ << " line:" << __LINE__ << " readSnSub done: "
|
||
// << station_name << " channel_index:" << clearData.channel_index
|
||
// << " ctime2:" << ctime2 << " ctime3:" << ctime3 << " ctime4:" << ctime4
|
||
// << " ctime5:" << ctime5 << " ctime6:" << ctime6 << " ctime7:" << ctime7
|
||
// << " ctime:" << ctime << " threadid:" << tid;
|
||
//}
|
||
|
||
}
|
||
|
||
void Logic_myiothread::readSnInfo(QVector<int> vec_value, QByteArray byte)
|
||
{
|
||
QStringList keys = map_sn_area_array.keys();
|
||
//重新加载用
|
||
//bool ifinitSCA = false;
|
||
for (auto vvv = 0; vvv < keys.size(); vvv++)
|
||
{
|
||
QString station_name = keys[vvv];
|
||
//QJsonArray sn_area_array = map_sn_area_array.value(station_name);//station_name应该是 this->m_stationKey
|
||
//int sn_area_arraysize = sn_area_array.size();
|
||
std::vector<std::future<void>> futures;
|
||
for (int snsn = 0; snsn < map_sn_area_array_nlohmann[station_name].size(); snsn++)
|
||
{
|
||
futures.push_back(std::async(std::launch::async, &Logic_myiothread::readSnSub, this,
|
||
station_name, map_sn_area_array_nlohmann[station_name].at(snsn), vec_value, byte,
|
||
map_ClearData[station_name].at(snsn)));
|
||
//readSnSub(station_name, sn_area_array.at(snsn).toObject(), vec_value, byte);
|
||
/* std::thread([this,station_name, sn_area_array, snsn, vec_value, byte] {
|
||
readSnSub(station_name, sn_area_array.at(snsn).toObject(), vec_value, byte);
|
||
}).detach();*/
|
||
}
|
||
for (auto& fut : futures) {
|
||
fut.get(); // 等待所有线程完成
|
||
}
|
||
//qDebug() << "readSnInfo End!";
|
||
}
|
||
|
||
}
|
||
|
||
//下料的SN，根据"汇总-触发信号"、"汇总-读哪个SN"匹配Logic_hdataintegration，并保存SN到变量；
|
||
void Logic_myiothread::setSN_hdataintegration(QString read_sn_startpos, int index, QString sn_value)
|
||
{
|
||
//给算法sn
|
||
for (int da = 0; da < station_trigger_signal_dataIntegrationThread_list.size(); da++)
|
||
{
|
||
if (station_trigger_signal_dataIntegrationThread_list[da]->m_trigger_signal == read_sn_startpos)
|
||
{
|
||
QJsonObject sn_set = station_trigger_signal_dataIntegrationThread_list[da]->algorithmObject.value("SN设置").toObject();
|
||
//QString read_sn_area_index = sn_set.value("汇总-读哪个上料通道的SN").toString();
|
||
QString sn_key = sn_set.value("汇总-读哪个SN").toString();
|
||
if (sn_key.contains("sn"))
|
||
{
|
||
if (sn_key.split("sn")[1].toInt() == (index + 1))
|
||
{
|
||
station_trigger_signal_dataIntegrationThread_list[da]->SN_dataTime = sn_value;
|
||
QString sendBack = station_trigger_signal_dataIntegrationThread_list[da]->m_trigger_back_signal;//"汇总-回复信号"
|
||
if (sendBack.isEmpty())
|
||
continue;
|
||
//反馈信号
|
||
QString m_signal = sendBack;
|
||
QByteArray m_byte = m_signal.toLocal8Bit(); //toUtf8出现一次m_byte无法读取内存
|
||
//QMutexLocker locker(m_iomutex);;
|
||
if (!finstcp_ptr->writeData(vec_mat, m_byte))
|
||
{
|
||
qCritical() << __FUNCTION__ << " line:" << __LINE__ << " finstcp_ptr reciveData error! ";
|
||
//return;
|
||
}
|
||
//Sleep(5);
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
|
||
//未使用
|
||
//根据配置文件clearData，清除相机图片容器内容
|
||
bool Logic_myiothread::clearSnCameraAlgorithmData(int areaIndex, QJsonObject obj)
|
||
{
|
||
if (obj.isEmpty())
|
||
{
|
||
return true;
|
||
}
|
||
|
||
if (m_stationName.isEmpty())
|
||
{
|
||
return true;
|
||
}
|
||
|
||
QString channel_index = obj.value("通道序号").toString();
|
||
QJsonArray cameralist = obj.value("相机列表").toArray();
|
||
QJsonArray algorithmlist = obj.value("算法列表").toArray();
|
||
QJsonArray algorithmexeclist = obj.value("算法数据容器列表").toArray();
|
||
if (!cameralist.isEmpty())
|
||
{
|
||
for (int ccc = 0; ccc < cameralist.size(); ccc++)
|
||
{
|
||
QString cameraName = cameralist.at(ccc).toString();
|
||
if (!cameraName.isEmpty())//.contains("camera"))// 如果用相机SN初始化；
|
||
{
|
||
if (channel_index.isEmpty())
|
||
{
|
||
station_list.value(m_stationName)->clearCameraData(cameraName, "");
|
||
}
|
||
else
|
||
{
|
||
station_list.value(m_stationName)->clearCameraData(cameraName, channel_index);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (!algorithmlist.isEmpty())
|
||
{
|
||
for (int aaa = 0; aaa < algorithmlist.size(); aaa++)
|
||
{
|
||
QString algorithmName = algorithmlist.at(aaa).toString();
|
||
if (algorithmName.contains("algorithm"))
|
||
{
|
||
station_list.value(m_stationName)->clearAlgorithmData(algorithmName);
|
||
}
|
||
}
|
||
}
|
||
if (!algorithmexeclist.isEmpty())
|
||
{
|
||
for (int aaa = 0; aaa < algorithmexeclist.size(); aaa++)
|
||
{
|
||
QString algorithmName = algorithmexeclist.at(aaa).toString();
|
||
if (algorithmName.contains("algorithm"))
|
||
{
|
||
station_list.value(m_stationName)->clearAlgorithmExecData(algorithmName);
|
||
}
|
||
}
|
||
}
|
||
// 清理sn码
|
||
//station_list.value(m_stationName)->clearSnData(areaIndex);
|
||
}
|
||
// sn方向相反，重新做转换
|
||
QString Logic_myiothread::snHex(QString sn)
|
||
{
|
||
QString resultStr = "";
|
||
if (sn.size() % 2 == 0)
|
||
{
|
||
for (int i = 0; i < sn.size() - 1; i = i + 2)
|
||
{
|
||
resultStr = resultStr + sn.at(i + 1) + sn.at(i);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
for (int i = 0; i < sn.size() - 1; i = i + 2)
|
||
{
|
||
resultStr = resultStr + sn.at(i + 1) + sn.at(i);
|
||
}
|
||
resultStr.append(sn.at(sn.size() - 1));
|
||
}
|
||
|
||
return resultStr;
|
||
}
|
||
//SN为""时，返回配置文件的"读SN异常-插值"
|
||
QString Logic_myiothread::getSn(QString errorinfo, QString area, QByteArray byte)
|
||
{
|
||
QString m_startpos = area.split("_")[0];
|
||
QString lenght = area.split("_")[1];
|
||
|
||
int start_index = m_startpos.mid(1, m_startpos.length() - 1).toInt();
|
||
start_index -= trigger_startpos;
|
||
|
||
QByteArray snByte = byte.mid(start_index * 2, lenght.toInt());
|
||
QString sn = snByte;
|
||
|
||
if (sn.contains("\n\r"))
|
||
sn.replace("\n\r", "");
|
||
|
||
if (sn == "")
|
||
{
|
||
return errorinfo;
|
||
}
|
||
return sn;
|
||
}
|
||
|
||
//931/949-5-2,读急停信号
|
||
//void Logic_myiothread::readEmergencyStopSignal(QVector<int> vec_value)
|
||
//{
|
||
// if (emergency_stop_signal.isEmpty())
|
||
// {
|
||
// //qWarning() << __FUNCTION__ << " LINE:" << __LINE__ << " emergency_stop_signal is null! ";
|
||
// return;
|
||
// }
|
||
// QString m_startpos = emergency_stop_signal.split("_")[0];
|
||
// QString m_value = emergency_stop_signal.split("_")[1];
|
||
// int trigger_index = m_startpos.mid(2, m_startpos.length() - 2).toInt();
|
||
// trigger_index -= trigger_startpos;
|
||
// if (trigger_index < 0){
|
||
// qCritical() << __FUNCTION__ << " line:" << __LINE__ << " value is error! m_startpos:" << m_startpos;
|
||
// }else if (vec_value.size() > trigger_index){
|
||
// if (vec_value.at(trigger_index) == m_value.toInt())
|
||
// {
|
||
// if (!emergency_stop_state)
|
||
// return;
|
||
// else
|
||
// {
|
||
// //修改报警、复位逻辑。。
|
||
//
|
||
// qDebug() << __FUNCTION__ << " LINE:" << __LINE__ << " emergency_stop_signal:" << emergency_stop_signal;
|
||
// B_time_Start = 0;
|
||
// A_time_Start = 0;
|
||
// QString m_signal = "write_DM3006_0";
|
||
// QByteArray m_byte = m_signal.toUtf8();
|
||
// if (!finstcp_ptr->writeData(vec_mat, m_byte))
|
||
// {
|
||
// qCritical() << __FUNCTION__ << " line:" << __LINE__ << " finstcp_ptr reciveData error! ";
|
||
// return;
|
||
// }
|
||
// m_signal = "write_DM3010_0";
|
||
// m_byte = m_signal.toUtf8();
|
||
// if (!finstcp_ptr->writeData(vec_mat, m_byte))
|
||
// {
|
||
// qCritical() << __FUNCTION__ << " line:" << __LINE__ << " finstcp_ptr reciveData error! ";
|
||
// return;
|
||
// }
|
||
// m_signal = "write_DM3056_0";
|
||
// m_byte = m_signal.toUtf8();
|
||
// if (!finstcp_ptr->writeData(vec_mat, m_byte))
|
||
// {
|
||
// qCritical() << __FUNCTION__ << " line:" << __LINE__ << " finstcp_ptr reciveData error! ";
|
||
// return;
|
||
// }
|
||
// m_signal = "write_DM3060_0";
|
||
// m_byte = m_signal.toUtf8();
|
||
// if (!finstcp_ptr->writeData(vec_mat, m_byte))
|
||
// {
|
||
// qCritical() << __FUNCTION__ << " line:" << __LINE__ << " finstcp_ptr reciveData error! ";
|
||
// return;
|
||
// }
|
||
// for (int vvv = 1; vvv < 7; vvv++)
|
||
// {
|
||
// QString algorithmName = QString("algorithm%1").arg(vvv);
|
||
// if (algorithmName.contains("algorithm"))
|
||
// {
|
||
// station_list.value(m_stationName)->clearAlgorithmData(algorithmName);
|
||
// }
|
||
// }
|
||
// station_list.value(m_stationName)->clearAlgorithmData("algorithm9");
|
||
// station_list.value(m_stationName)->clearAlgorithmData("algorithm10");
|
||
// station_list.value(m_stationName)->changeAlgorithmDataGetIndex("algorithm7",1);
|
||
// station_list.value(m_stationName)->changeAlgorithmDataGetIndex("algorithm8", 1);
|
||
// station_list.value(m_stationName)->getSnInfoData(0)->SetDeleteSnIndex(0);
|
||
// station_list.value(m_stationName)->getSnInfoData(1)->SetDeleteSnIndex(0);
|
||
// emergency_stop_state = false;
|
||
// }
|
||
//
|
||
// //// 先反馈信号,再清理
|
||
// //QString m_signal = "write_" + m_startpos + "_0";
|
||
// //QByteArray m_byte = m_signal.toUtf8();
|
||
// //if (!finstcp_ptr->writeData(vec_mat, m_byte))
|
||
// //{
|
||
// // qCritical() << __FUNCTION__ << " line:" << __LINE__ << " finstcp_ptr reciveData error! ";
|
||
// // return;
|
||
// //}
|
||
// //Sleep(10000);
|
||
// //QList<QString> keyList = station_list.keys();
|
||
// //for (int i = 0; i < keyList.size(); i++)
|
||
// //{
|
||
// // HStationData* stationPtr = station_list.value(keyList.at(i));
|
||
// // if (stationPtr)
|
||
// // {
|
||
// // stationPtr->clearData("");
|
||
// // }
|
||
// //}
|
||
// //qDebug() << __FUNCTION__ << " line:" << __LINE__ << " clear data success! ";
|
||
// }
|
||
// else
|
||
// {
|
||
// emergency_stop_state = true;
|
||
// }
|
||
// }
|
||
//}
|
||
|
||
//检查相机、算法信号重入
|
||
void Logic_myiothread::checkReentrySign(QVector<int> vec_value)
|
||
{
|
||
//检查相机信号重入
|
||
QStringList m_keys = m_runAndCheck_cameraThread->map_trigger_signal_pack.keys();
|
||
for (int i = 0; i < m_keys.size(); i++)
|
||
{
|
||
QString trigger_signal = m_keys.at(i);
|
||
QString m_startpos = trigger_signal.split("_")[0];
|
||
QString m_value = trigger_signal.split("_")[1];
|
||
int trigger_index = m_startpos.mid(1, m_startpos.length() - 1).toInt();
|
||
trigger_index -= trigger_startpos;
|
||
if (trigger_index < 0)
|
||
{
|
||
qCritical() << __FUNCTION__ << " line:" << __LINE__ << " value is error! m_startpos:" << m_startpos;
|
||
}
|
||
else if (vec_value.size() > trigger_index)
|
||
{
|
||
trigger_signal_pack m_pack = m_runAndCheck_cameraThread->map_trigger_signal_pack.value(trigger_signal);
|
||
if (vec_value.at(trigger_index) == 0 && m_pack.trigger_reentry_signal == 1)
|
||
{
|
||
m_pack.trigger_reentry_signal = 0;
|
||
m_runAndCheck_cameraThread->map_trigger_signal_pack.insert(trigger_signal, m_pack); // 替换为0
|
||
|
||
}
|
||
}
|
||
}
|
||
|
||
//检查算法信号重入
|
||
//触发条件的
|
||
m_keys = map_algorithm_trigger_signal_pack.keys();
|
||
for (int i = 0; i < m_keys.size(); i++)
|
||
{
|
||
QString trigger_signal = m_keys.at(i);
|
||
QString m_startpos = trigger_signal.split("_")[0];
|
||
QString m_value = trigger_signal.split("_")[1];
|
||
int trigger_index = m_startpos.mid(1, m_startpos.length() - 1).toInt();
|
||
trigger_index -= trigger_startpos;
|
||
if (trigger_index < 0)
|
||
{
|
||
qCritical() << __FUNCTION__ << " line:" << __LINE__ << " value is error! m_startpos:" << m_startpos;
|
||
}
|
||
else if (vec_value.size() > trigger_index)
|
||
{
|
||
trigger_signal_pack m_pack = map_algorithm_trigger_signal_pack.value(trigger_signal);
|
||
if (vec_value.at(trigger_index) == 0 && m_pack.trigger_reentry_signal == 1)
|
||
{
|
||
m_pack.trigger_reentry_signal = 0;
|
||
map_algorithm_trigger_signal_pack.insert(trigger_signal, m_pack); // 替换为0
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
void Logic_myiothread::checkTriggerCameraSub(
|
||
const QString& trigger_signal,
|
||
const QVector<int>& vec_value,
|
||
int trigger_startpos,
|
||
const QString& m_stationName,
|
||
QMap<QString, QString> map_camera_feedback_sleep_time
|
||
) {
|
||
QStringList splist = trigger_signal.split("_");
|
||
if (splist.size() < 2)
|
||
{
|
||
qCritical() << __FUNCTION__ << " line:" << __LINE__ << " trigger_signal is error! :" << trigger_signal;
|
||
return;
|
||
}
|
||
QString m_startpos = splist[0];
|
||
QString m_value = splist[1];
|
||
QString trigger_getImgNum = "1";//运行次数
|
||
if (splist.size() > 3)
|
||
if (splist[3].toInt() > 0)trigger_getImgNum = splist[3];
|
||
int trigger_index = m_startpos.mid(1, m_startpos.length() - 1).toInt();
|
||
trigger_index -= trigger_startpos;
|
||
if (trigger_index < 0)
|
||
{
|
||
qCritical() << __FUNCTION__ << " line:" << __LINE__ << " value is error! m_startpos:" << m_startpos;
|
||
}
|
||
else if (vec_value.size() > trigger_index)
|
||
{
|
||
trigger_signal_pack m_pack = m_runAndCheck_cameraThread->map_trigger_signal_pack.value(trigger_signal);
|
||
//602 屏蔽无意义代码
|
||
//收到信号直接回复；软件卡顿、通信断开等异常，可能导致信号回复失败
|
||
//if (vec_value.at(trigger_index) == m_value.toInt())
|
||
//{
|
||
// // 写清除当前信号 修改
|
||
// QString clear_signal = m_startpos;
|
||
// QStringList myCmdHead = m_pack.clear_camera_startpos_flag.split("_");
|
||
// clear_signal = myCmdHead[0] + "_" + myCmdHead[1] + "_" + clear_signal + +"_" + myCmdHead[2];
|
||
// QByteArray m_byte = clear_signal.toUtf8();
|
||
// ////QMutexLocker locker(m_iomutex);;
|
||
// /*if ( !finstcp_ptr->writeData(vec_mat,m_byte) )
|
||
// {
|
||
// qCritical() << __FUNCTION__ << " line:"<< __LINE__ << " finstcp_ptr reciveData error! ";
|
||
// return;
|
||
// }*/
|
||
//}
|
||
#if YH_LOGIC_SWITCH == 2
|
||
if ( (vec_value.at(trigger_index) == m_value.toInt() && _triggerLockerT.checkLocker(trigger_index))
|
||
|| (vec_value.at(trigger_index + 2) == m_value.toInt() && _triggerLockerT.checkLocker(trigger_index + 2)))
|
||
{
|
||
if (vec_value.at(trigger_index) == m_value.toInt())_triggerLockerT.adddLocker(trigger_index);
|
||
if (vec_value.at(trigger_index + 2) == m_value.toInt())_triggerLockerT.adddLocker(trigger_index + 2);
|
||
#elif YH_LOGIC_SWITCH == 4
|
||
if ((vec_value.at(trigger_index) == m_value.toInt() && _triggerLockerT.checkLocker(trigger_index))
|
||
|| (vec_value.at(trigger_index + 2) == m_value.toInt() && _triggerLockerT.checkLocker(trigger_index + 2))
|
||
|| (vec_value.at(trigger_index + 4) == m_value.toInt() && _triggerLockerT.checkLocker(trigger_index + 4))
|
||
|| (vec_value.at(trigger_index + 6) == m_value.toInt() && _triggerLockerT.checkLocker(trigger_index + 6))
|
||
)
|
||
{
|
||
if (vec_value.at(trigger_index) == m_value.toInt())_triggerLockerT.adddLocker(trigger_index);
|
||
if (vec_value.at(trigger_index + 2) == m_value.toInt())_triggerLockerT.adddLocker(trigger_index + 2);
|
||
if (vec_value.at(trigger_index + 4) == m_value.toInt())_triggerLockerT.adddLocker(trigger_index + 4);
|
||
if (vec_value.at(trigger_index + 6) == m_value.toInt())_triggerLockerT.adddLocker(trigger_index + 6);
|
||
#else
|
||
if (vec_value.at(trigger_index) == m_value.toInt() && _triggerLockerT.checkLocker(trigger_index))//&& m_pack.trigger_reentry_signal == 0 )
|
||
{
|
||
if (vec_value.at(trigger_index) == m_value.toInt())_triggerLockerT.adddLocker(trigger_index);
|
||
#endif
|
||
|
||
//qDebug() << __FUNCTION__ << " line:" << __LINE__ << "trigger_signal: " << trigger_signal;
|
||
|
||
//一个信号，对应相机拍多张图？
|
||
// 添加被触发的相机名称;运行相机及取图
|
||
if (!m_pack.vector_camera.isEmpty()){
|
||
|
||
QStringList trigger_camera_name_getImgNumS;
|
||
|
||
for (int val = 0; val < m_pack.vector_camera.size(); val++){
|
||
|
||
QString trigger_camera_name_getImgNum = m_pack.vector_camera.at(val) + "_" + trigger_getImgNum;
|
||
if (!trigger_camera_name_getImgNum.isEmpty()){
|
||
//多工站需考虑加锁？
|
||
//注意，信号不可重入。
|
||
//开线程去运行；一个信号对应相机拍多张图的情况
|
||
trigger_camera_name_getImgNumS.append(trigger_camera_name_getImgNum);
|
||
}
|
||
}
|
||
//qDebug() << "trigger_signal:" << trigger_signal << " run_camera_module station_camerathreadlist ";
|
||
QStringList yh_getImageSignal;
|
||
#if YH_LOGIC_SWITCH == 2
|
||
yh_getImageSignal.append({ QString::number(vec_value.at(trigger_index)),
|
||
QString::number(vec_value.at(trigger_index + 2)) });
|
||
#elif YH_LOGIC_SWITCH == 4
|
||
yh_getImageSignal.append({ QString::number(vec_value.at(trigger_index)),
|
||
QString::number(vec_value.at(trigger_index + 2)),
|
||
QString::number(vec_value.at(trigger_index + 4)),
|
||
QString::number(vec_value.at(trigger_index + 6)) });
|
||
#endif
|
||
m_runAndCheck_cameraThread->runCameraKey_num.enqueue(trigger_camera_name_getImgNumS);
|
||
if (!m_pack.trigger_signal_condition.isEmpty())
|
||
{
|
||
station_list.value(m_stationName)->set_trigger_signal(trigger_signal);
|
||
}
|
||
|
||
// 判断是否需要反馈延迟
|
||
int sleep_time = 10;
|
||
QString camera_name = m_pack.vector_camera.at(0); // 只提取一个
|
||
if (!camera_name.isEmpty())
|
||
{
|
||
QString m_feedback_sleep_time = map_camera_feedback_sleep_time.value(camera_name);
|
||
if (!m_feedback_sleep_time.isEmpty())
|
||
{
|
||
sleep_time = m_feedback_sleep_time.toInt();
|
||
//Sleep(sleep_time);
|
||
}
|
||
}
|
||
m_pack.trigger_getImgNum = trigger_getImgNum;
|
||
m_pack.m_startpos = m_startpos;
|
||
m_pack.sleep_time = sleep_time;
|
||
// 运行并检查相机是否取图完成的线程
|
||
// 一个信号取多张的情况，取图时间长，和通信线程分开。
|
||
//QFuture偶然需要5秒，start()偶然需要30ms；
|
||
//m_runAndCheck_cameraThread->check_pack.enqueue(m_pack);
|
||
std::thread(
|
||
[this, trigger_camera_name_getImgNumS, m_pack, yh_getImageSignal]
|
||
{m_runAndCheck_cameraThread->run_camera_moduleOneTime(trigger_camera_name_getImgNumS, m_pack, yh_getImageSignal); }
|
||
).detach();
|
||
}
|
||
|
||
m_pack.trigger_reentry_signal = 1;
|
||
m_runAndCheck_cameraThread->map_trigger_signal_pack.insert(trigger_signal, m_pack); // 替换为1
|
||
}
|
||
}
|
||
}
|
||
void Logic_myiothread::checkTriggerCamera(QVector<int> vec_value)
|
||
{
|
||
QStringList m_keys = m_runAndCheck_cameraThread->map_trigger_signal_pack.keys();
|
||
QJsonArray sn_area_array = map_sn_area_array.value(m_stationKey);// ("station1");
|
||
std::vector<std::future<void>> futures;
|
||
for (int i = 0; i < m_keys.size(); i++)
|
||
{
|
||
futures.push_back(std::async(std::launch::async, &Logic_myiothread::checkTriggerCameraSub, this,
|
||
m_keys.at(i), vec_value, trigger_startpos, m_stationName, map_camera_feedback_sleep_time));
|
||
/* checkTriggerCameraSub(m_keys.at(i), vec_value, trigger_startpos,
|
||
m_stationName, map_camera_feedback_sleep_time);*/
|
||
}
|
||
for (auto& fut : futures) {
|
||
fut.get(); // 等待所有线程完成
|
||
}
|
||
}
|
||
|
||
void Logic_myiothread::checkTriggerAlgorithm(QVector<int> vec_value)
|
||
{
|
||
QStringList m_keys = map_algorithm_trigger_signal_pack.keys();
|
||
QJsonArray sn_area_array = map_sn_area_array.value(m_stationKey);// ("station1");
|
||
for (int i = 0; i < m_keys.size(); i++)
|
||
{
|
||
QString trigger_signal = m_keys.at(i);
|
||
QStringList splist = trigger_signal.split("_");
|
||
if (splist.size() < 2)
|
||
{
|
||
qCritical() << __FUNCTION__ << " line:" << __LINE__ << " trigger_signal is error! :" << trigger_signal;
|
||
return;
|
||
}
|
||
QString m_startpos = splist[0];
|
||
QString m_value = splist[1];
|
||
QString trigger_getImgNum = "1";//运行次数
|
||
if (splist.size() > 3)
|
||
if (splist[3].toInt() > 0)trigger_getImgNum = splist[3];
|
||
int trigger_index = m_startpos.mid(1, m_startpos.length() - 1).toInt();
|
||
trigger_index -= trigger_startpos;
|
||
if (trigger_index < 0)
|
||
{
|
||
qCritical() << __FUNCTION__ << " line:" << __LINE__ << " value is error! m_startpos:" << m_startpos;
|
||
}
|
||
else if (vec_value.size() > trigger_index)
|
||
{
|
||
trigger_signal_pack m_pack = map_algorithm_trigger_signal_pack.value(trigger_signal);
|
||
if (vec_value.at(trigger_index) == m_value.toInt())
|
||
{
|
||
// 写清除当前信号 修改
|
||
QString clear_signal = m_startpos;
|
||
clear_signal = "write_short_" + clear_signal + "_0";
|
||
QByteArray m_byte = clear_signal.toUtf8();
|
||
//QMutexLocker locker(m_iomutex);;
|
||
if (!finstcp_ptr->writeData(vec_mat, m_byte))
|
||
{
|
||
qCritical() << __FUNCTION__ << " line:" << __LINE__ << " finstcp_ptr reciveData error! ";
|
||
return;
|
||
}
|
||
}
|
||
if (vec_value.at(trigger_index) == m_value.toInt())
|
||
//if(m_pack.trigger_reentry_signal == 0)
|
||
{
|
||
qDebug() << __FUNCTION__ << " line:" << __LINE__ << "trigger_signal: " << trigger_signal;
|
||
|
||
//反馈信号；考虑到一个模块可能对应几组检测内容，对应的开始和回复信号不同
|
||
QVector<QString> vector_trigger_feedback_signal = m_pack.vector_trigger_feedback_signal;
|
||
foreach(QString trigger_feedback_signal, vector_trigger_feedback_signal) //例：D3104_0
|
||
{
|
||
if (trigger_feedback_signal.isEmpty())
|
||
continue;
|
||
QByteArray send_byte = trigger_feedback_signal.toUtf8();
|
||
//QMutexLocker locker(m_iomutex);;
|
||
if (!finstcp_ptr->writeData(vec_mat, send_byte))
|
||
{
|
||
qCritical() << __FUNCTION__ << "line:" << __LINE__ << " finstcp_ptr reciveData error! ";
|
||
return;
|
||
}
|
||
}
|
||
|
||
m_pack.trigger_reentry_signal = 1;
|
||
map_algorithm_trigger_signal_pack.insert(trigger_signal, m_pack); // 替换为1
|
||
|
||
// 添加被触发的相机名称
|
||
if (!m_pack.vector_camera.isEmpty())
|
||
{
|
||
//QMutexLocker locker(commond_pack_lock);
|
||
for (int val = 0; val < m_pack.vector_camera.size(); val++)
|
||
{
|
||
QString trigger_signal_num = trigger_signal + "#" + trigger_getImgNum;
|
||
if (!trigger_signal_num.isEmpty())
|
||
{
|
||
//注意，信号不可重入。
|
||
//一般对应的是下料工位的汇总算法
|
||
run_Algorithm_hdataintegration(trigger_signal_num);
|
||
}
|
||
}
|
||
}
|
||
// 查看是否需要使用触发信号
|
||
//if (!m_pack.trigger_signal_condition.isEmpty())
|
||
//{
|
||
//station_list.value(m_stationName)->set_trigger_signal(trigger_signal);
|
||
//trigger_signal_condition_name = trigger_signal; //作用同mv_trigger_signal
|
||
//}
|
||
//if (m_pack.clear_camera_startpos_flag.contains("true"))
|
||
//{
|
||
// // 写清除当前信号 修改
|
||
// QString clear_signal = m_startpos;
|
||
// clear_signal = CmdHeadShort + clear_signal + "_0";
|
||
// QByteArray m_byte = clear_signal.toUtf8();
|
||
// if (!finstcp_ptr->writeData(vec_mat, m_byte))
|
||
// {
|
||
// qCritical() << __FUNCTION__ << " line:" << __LINE__ << " finstcp_ptr reciveData error! ";
|
||
// return;
|
||
// }
|
||
// // 判断是否需要反馈延迟
|
||
// int sleep_time = 0;
|
||
// QString trigger_name = m_pack.vector_camera.at(0); // 只提取一个
|
||
// if (!trigger_name.isEmpty())
|
||
// {
|
||
// QString m_feedback_sleep_time = map_algorithm_feedback_sleep_time.value(trigger_name);
|
||
// if (!m_feedback_sleep_time.isEmpty())
|
||
// {
|
||
// sleep_time = m_feedback_sleep_time.toInt();
|
||
// //Sleep(sleep_time);
|
||
// }
|
||
// }
|
||
//}
|
||
|
||
}
|
||
//else
|
||
// qDebug() << __FUNCTION__ << " line:" << __LINE__ << "trigger_signal: " << trigger_signal << " m_pack.trigger_reentry_signal != 0";
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
// 工站结束校验
|
||
// 相机缺图需要重拍时使用。此方法需工位开始时(读SN信号)，清理相机容器、检测算法容器数据（HStationData::clearData）。
|
||
void Logic_myiothread::checkEndSingnal(QVector<int> vec_value)
|
||
{
|
||
foreach(QString endSingnal, map_endSingnal_backObj.keys())
|
||
{
|
||
QString m_startpos = endSingnal.split("_")[0];
|
||
QString m_value = endSingnal.split("_")[1];
|
||
int trigger_index = m_startpos.mid(1, m_startpos.length() - 1).toInt();
|
||
trigger_index -= trigger_startpos;
|
||
if (trigger_index < 0)
|
||
{
|
||
qCritical() << __FUNCTION__ << " line:" << __LINE__ << " vec_value is error! read_sn_startpos:" << m_startpos;
|
||
}
|
||
else if (vec_value.size() > trigger_index)
|
||
{
|
||
//读SN标志满足read_sn_startpos
|
||
if (vec_value.at(trigger_index) == m_value.toInt())
|
||
{
|
||
// 清理当前信号
|
||
QString m_signal = "write_short_" + m_startpos + "_0";
|
||
QByteArray m_byte = m_signal.toUtf8();
|
||
//QMutexLocker locker(m_iomutex);;
|
||
if (!finstcp_ptr->writeData(vec_mat, m_byte))
|
||
{
|
||
qCritical() << __FUNCTION__ << " line:" << __LINE__ << " finstcp_ptr reciveData error! ";
|
||
return;
|
||
}
|
||
|
||
QJsonObject end_backObj = map_endSingnal_backObj.value(endSingnal);
|
||
QString backSignal;
|
||
bool ifCameraMissImage = false;
|
||
for (int i = 0; i < m_runAndCheck_cameraThread->station_camerathreadlist.size(); i++)
|
||
if (m_runAndCheck_cameraThread->station_camerathreadlist[i]->ifMissImage == true)
|
||
{
|
||
ifCameraMissImage = true;
|
||
m_runAndCheck_cameraThread->station_camerathreadlist[i]->set_ifMissImage(false);
|
||
}
|
||
if (ifCameraMissImage == false)
|
||
{
|
||
backSignal = end_backObj.value("取图数量-正常").toString();
|
||
}
|
||
else
|
||
{
|
||
backSignal = end_backObj.value("取图数量-异常").toString();
|
||
}
|
||
if (!backSignal.isEmpty())
|
||
{
|
||
// 清理当前sn码的触发信号
|
||
m_signal = backSignal;
|
||
m_byte = m_signal.toUtf8();
|
||
if (!finstcp_ptr->writeData(vec_mat, m_byte))
|
||
{
|
||
qCritical() << __FUNCTION__ << " line:" << __LINE__ << " finstcp_ptr reciveData error! ";
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
//条件判断
|
||
//一般对应的是下料工位的汇总算法
|
||
void Logic_myiothread::run_Algorithm_hdataintegration(QString trigger_signal_num)
|
||
{
|
||
try
|
||
{
|
||
QString mytrigger_signal_num = trigger_signal_num; //相机key_运行次数
|
||
int runNum = mytrigger_signal_num.split("#")[1].toInt();
|
||
if (runNum < 1)
|
||
{
|
||
qCritical() << __FUNCTION__ << __LINE__ << " cameraKey_runNum err:" << mytrigger_signal_num;
|
||
return;
|
||
}
|
||
bool if_camera_get_All = true;
|
||
for (int i = 0; i < station_trigger_signal_dataIntegrationThread_list.size(); i++)
|
||
{
|
||
QString trigger_signal = station_trigger_signal_dataIntegrationThread_list.at(i)->m_trigger_signal; //相机SN或userID
|
||
if (trigger_signal == mytrigger_signal_num.split("#")[0])
|
||
{
|
||
Logic_hdataintegration* mydataIntegrationPtr = station_trigger_signal_dataIntegrationThread_list.at(i);
|
||
if (mydataIntegrationPtr->SN_dataTime == "")
|
||
mydataIntegrationPtr->SN_dataTime = "errSN_errDataTime";
|
||
//开线程去运行；一个信号对应相机拍多张图的情况
|
||
for (int i = 0; i < runNum; i++)
|
||
{
|
||
mydataIntegrationPtr->ifalwaysRun = true;
|
||
mydataIntegrationPtr->start();//偶然需要30ms
|
||
}
|
||
}
|
||
}
|
||
}
|
||
catch (QString ev)
|
||
{
|
||
qCritical() << __FUNCTION__ << __LINE__ << " ev:" << ev;
|
||
}
|
||
return;
|
||
}
|
||
|
||
QJsonObject Logic_myiothread::loadJsonCfg(QString json_cfg_file_path)
|
||
{
|
||
QJsonObject json_object;
|
||
try
|
||
{
|
||
QJsonParseError jsonError;
|
||
if (json_cfg_file_path.isEmpty())
|
||
{
|
||
qCritical() << __FUNCTION__ << " line:" << __LINE__ << " JsonPath is null!";
|
||
return json_object;
|
||
}
|
||
|
||
QFile JsonFile;
|
||
JsonFile.setFileName(json_cfg_file_path);
|
||
if (!JsonFile.isReadable())
|
||
{
|
||
qCritical() << __FUNCTION__ << " line:" << __LINE__ << " camera_cfg.json not isReadable!";
|
||
return json_object;
|
||
}
|
||
JsonFile.open(QIODevice::ReadOnly);
|
||
|
||
QByteArray m_Byte = JsonFile.readAll();
|
||
if (m_Byte.isEmpty())
|
||
{
|
||
qDebug() << __FUNCTION__ << " line:" << __LINE__ << json_cfg_file_path + " Content is empty";
|
||
JsonFile.close();
|
||
return json_object;
|
||
}
|
||
|
||
QJsonDocument jsonDocument(QJsonDocument::fromJson(m_Byte, &jsonError));
|
||
|
||
if (!jsonDocument.isNull() && jsonError.error == QJsonParseError::NoError)
|
||
{
|
||
if (jsonDocument.isObject())
|
||
{
|
||
json_object = jsonDocument.object();
|
||
JsonFile.close();
|
||
return json_object;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
qCritical() << __FUNCTION__ << " line:" << __LINE__ << json_cfg_file_path + " is error!";
|
||
}
|
||
JsonFile.close();
|
||
|
||
}
|
||
catch (QString ev)
|
||
{
|
||
qCritical() << __FUNCTION__ << " line:" << __LINE__ << " ev:" << ev;
|
||
}
|
||
return json_object;
|
||
}
|
||
|
||
//未使用；
|
||
// 信号复位逻辑
|
||
//重新加载并传参数到相机、算法
|
||
bool Logic_myiothread::initStationCameraAndAlgorithm()
|
||
{
|
||
//相机/算法模块，传入参数；
|
||
QDir dir = QApplication::applicationDirPath();
|
||
QString currPath = dir.path();
|
||
QString cf_finish = currPath + "/config/finish.txt";
|
||
QFile cf_finish_file(cf_finish);
|
||
if (cf_finish_file.exists())
|
||
{
|
||
Sleep(10);
|
||
//读配置文件；加载参数；
|
||
QString camera_cfg = currPath + "/config/camera_cfg.json";
|
||
QJsonObject m_jsonObj = loadJsonCfg(camera_cfg);
|
||
if (m_jsonObj.isEmpty())
|
||
{
|
||
qCritical() << __FUNCTION__ << " line:" << __LINE__ << " m_jsonObj is null";
|
||
return false;
|
||
}
|
||
QJsonArray stationList = m_jsonObj.value("工站列表").toArray();
|
||
for (int s = 0; s < stationList.size(); s++)
|
||
{
|
||
QJsonObject station_obj = stationList[s].toObject();
|
||
if (station_obj.value("工站名").toString() == m_stationName)
|
||
{
|
||
QJsonArray m_cameramodulelist = station_obj.value("相机模块列表").toArray();
|
||
for (auto val = 0; val < m_cameramodulelist.size(); val++)
|
||
{
|
||
QJsonObject camera_obj = m_cameramodulelist.at(val).toObject();
|
||
QString camera_key = camera_obj.value("相机key").toString();
|
||
for (int sc = 0; sc < m_runAndCheck_cameraThread->station_camerathreadlist.size(); sc++)
|
||
{
|
||
if (m_runAndCheck_cameraThread->station_camerathreadlist[sc]->m_name == camera_key)
|
||
{
|
||
m_runAndCheck_cameraThread->station_camerathreadlist[sc]->m_Module.ConfigArray = camera_obj.value("相机参数").toArray();
|
||
initStationsModule(m_runAndCheck_cameraThread->station_camerathreadlist[sc]->m_Module);
|
||
}
|
||
}
|
||
}
|
||
QJsonArray m_Algorithmlist = station_obj.value("算法列表").toArray();
|
||
for (auto val = 0; val < m_Algorithmlist.size(); val++)
|
||
{
|
||
QJsonObject obj = m_Algorithmlist.at(val).toObject();
|
||
QString key = obj.value("算法名称").toString();
|
||
for (int sc = 0; sc < station_task_thread_list.size(); sc++)
|
||
{
|
||
//for (int t = 0; t < station_task_thread_list[sc]->m_module_list.size(); t++)
|
||
{
|
||
if (station_task_thread_list[sc]->m_module.m_stationKey == m_stationName &&
|
||
station_task_thread_list[sc]->m_module.module_key == key)
|
||
{
|
||
station_task_thread_list[sc]->m_module.ConfigArray = obj.value("算法初始化参数").toArray();
|
||
initStationsModule(station_task_thread_list[sc]->m_module);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
|
||
//未使用；
|
||
// 信号复位逻辑
|
||
bool Logic_myiothread::initStationsModule(MyModule cameraOrAlgorithm_module)
|
||
{
|
||
QString moduleName = cameraOrAlgorithm_module.moduleName;
|
||
QString key = cameraOrAlgorithm_module.module_key;
|
||
|
||
//传递初始化参数
|
||
QByteArray initByte = cameraOrAlgorithm_module.m_initByte;
|
||
std::vector<cv::Mat> vec_moduleMat;
|
||
//数据格式：3+3+数据长度+数据内容
|
||
QByteArray m_keyByte = initCameraParam(key, cameraOrAlgorithm_module.ConfigArray);
|
||
//统一用initParas进行初始化
|
||
if (moduleName.contains("Camera"))
|
||
cameraOrAlgorithm_module.module_ptr->writeData(vec_moduleMat, m_keyByte); // 初始化相机
|
||
if (cameraOrAlgorithm_module.module_ptr->initParas(initByte))
|
||
{
|
||
qDebug() << __FUNCTION__ << " line: " << __LINE__ << " key: " << key << " initParas success! ";
|
||
}
|
||
else
|
||
{
|
||
qCritical() << __FUNCTION__ << " line: " << __LINE__ << " moduleName: " << cameraOrAlgorithm_module.moduleName << " initParas failed! ";
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
|
||
//未使用；
|
||
// 信号复位逻辑
|
||
QByteArray Logic_myiothread::initCameraParam(QString key, QJsonArray array)
|
||
{
|
||
if (key.isEmpty())
|
||
return "";
|
||
|
||
std::string sendMsg;
|
||
|
||
// 添加相机名称
|
||
int type = 3; // int
|
||
std::string m_type;
|
||
m_type.insert(0, 4, '1');
|
||
memcpy((void*)m_type.c_str(), (void*)&type, 4);
|
||
sendMsg.append(m_type);
|
||
|
||
// len
|
||
int len = key.length();
|
||
std::string m_len;
|
||
m_len.insert(0, 4, '1');
|
||
memcpy((void*)m_len.c_str(), (void*)&len, 4);
|
||
sendMsg.append(m_len);
|
||
|
||
// 相机名称
|
||
std::string m_key = key.toStdString();
|
||
sendMsg.append(key.toStdString());
|
||
|
||
//添加数据
|
||
for (int i = 0; i < array.size(); i++)
|
||
{
|
||
QJsonObject m_obj = array.at(i).toObject();
|
||
QString value = m_obj.value("相机参数值").toString();
|
||
if (value.isEmpty())
|
||
{
|
||
qCritical() << __FUNCTION__ << "line:" << __LINE__ << " value is null!";
|
||
return "";
|
||
}
|
||
|
||
int type = 3; // int
|
||
std::string _type;
|
||
_type.insert(0, 4, '1');
|
||
memcpy((void*)_type.c_str(), (void*)&type, 4);
|
||
sendMsg.append(_type);
|
||
|
||
// len
|
||
int data_len = value.length();
|
||
std::string _len;
|
||
_len.insert(0, 4, '1');
|
||
memcpy((void*)_len.c_str(), (void*)&data_len, 4);
|
||
sendMsg.append(_len);
|
||
|
||
// data
|
||
sendMsg.append(value.toStdString());
|
||
}
|
||
|
||
QByteArray byteArray(sendMsg.c_str(), sendMsg.length());
|
||
return byteArray;
|
||
}
|
||
|
||
//根据信号，切换"程序号"
|
||
int Logic_myiothread::dataPack_size()
|
||
{
|
||
QMutexLocker locker(sendProcess_mutex);
|
||
return sendProcessTask.size();
|
||
}
|
||
//根据信号，切换"程序号"
|
||
//获取数据
|
||
dataPack Logic_myiothread::getdataPack()
|
||
{
|
||
QMutexLocker locker(sendProcess_mutex);
|
||
return sendProcessTask.dequeue();
|
||
}
|
||
|
||
|
||
// 运行并检查相机是否取图完成的线程
|
||
// 一个信号取多张的情况，取图时间长，和通信线程分开。
|
||
runAndCheck_cameraThread::runAndCheck_cameraThread(QObject* parent)
|
||
{
|
||
runflag = true;
|
||
}
|
||
runAndCheck_cameraThread::~runAndCheck_cameraThread()
|
||
{
|
||
runCameraKey_num.clear();
|
||
qDebug() << __FUNCTION__ << "line:" << __LINE__ << " delete success! ";
|
||
}
|
||
|
||
//Logic_myiothread的run运行时，开始线程运行
|
||
//~Logic_myiothread时，runflag为false结束运行
|
||
//运行相机并等待拍完
|
||
void runAndCheck_cameraThread::run_camera_module(QStringList cameraKeyS_runNumS)
|
||
{
|
||
try
|
||
{
|
||
clock_t start, stop;
|
||
start = clock();
|
||
trigger_signal_pack my_check_pack = check_pack.dequeue();
|
||
for (int ca = 0; ca < cameraKeyS_runNumS.size(); ca++)
|
||
{
|
||
QString cameraName_getImgNum = cameraKeyS_runNumS[ca]; //相机key_运行次数
|
||
int runNum = cameraName_getImgNum.split("_")[1].toInt();
|
||
if (runNum < 1)
|
||
{
|
||
qCritical() << __FUNCTION__ << __LINE__ << " cameraKey_runNum err:" << cameraKeyS_runNumS[ca];
|
||
return;
|
||
}
|
||
//runModule(cameraName);
|
||
bool if_camera_get_All = true;
|
||
for (int i = 0; i < station_camerathreadlist.size(); i++)
|
||
{
|
||
QString cameraKey = station_camerathreadlist.at(i)->m_name; //相机SN或userID
|
||
if (cameraKey == cameraName_getImgNum.split("_")[0])
|
||
{
|
||
station_camerathreadlist.at(i)->set_m_stoprun(true);
|
||
//----2024.03.05修改
|
||
// 回复信号放到Logic_camera_thread相机取图完成后执行
|
||
// 可能出现同一工位多个相机，信号先后给的情况，避免相机取图时间过长，导致下一个相机开始取图慢
|
||
//相机拍照完成检查包
|
||
if (my_check_pack.sleep_time > 100)
|
||
station_camerathreadlist.at(i)->maxCheckTime = my_check_pack.sleep_time;
|
||
if (ca == 0)
|
||
station_camerathreadlist.at(i)->send_byte = checkCamerasFinish_feedbackSignal(my_check_pack);
|
||
else
|
||
station_camerathreadlist.at(i)->send_byte = "pass"; //一个开始拍照对应多个相机的，回复的信号只保留一个，后面的不发了。减少通信耗时。
|
||
//Logic_camera_thread在线程运行，当getImgNums不为0时从相机模块获取getImgNums次图
|
||
//取图总时间超过maxCheckTime，会结束取图。
|
||
station_camerathreadlist.at(i)->getImgNums = runNum;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
///*stop = clock();
|
||
//qCritical() << "trigger_signal:" << trigger_signal << " run_camera_module station_camerathreadlist cut Time ::" << stop - start;
|
||
//start = clock();*/
|
||
//for (int ca = 0; ca < cameraKeyS_runNumS.size(); ca++)
|
||
//{
|
||
// QString cameraName_getImgNum = cameraKeyS_runNumS[ca]; //相机key_运行次数
|
||
// int runNum = cameraName_getImgNum.split("_")[1].toInt();
|
||
// if (runNum < 1)
|
||
// {
|
||
// qCritical() << __FUNCTION__ << __LINE__ << " cameraKey_runNum err:" << cameraKeyS_runNumS[ca];
|
||
// return;
|
||
// }
|
||
// //runModule(cameraName);
|
||
// bool if_camera_get_All = true;
|
||
// for (int i = 0; i < station_camerathreadlist.size(); i++)
|
||
// {
|
||
// QString cameraKey = station_camerathreadlist.at(i)->getName(); //相机SN或userID
|
||
// // tmpDate = QDateTime::currentDateTime().toString("yyyy-MM-dd-hh-mm-ss-zzz");
|
||
// //std::cout << "run_camera_module strat 3 ::" << tmpDate.toStdString() << " trigger_camera_name::" << cameraKey_runNum.toStdString() << std::endl;
|
||
// if (cameraKey == cameraName_getImgNum.split("_")[0])
|
||
// {
|
||
// Logic_camera_thread* mycameraPtr = station_camerathreadlist.at(i);
|
||
// //mycameraPtr->wait();
|
||
// int mytime = 0;
|
||
// while (mycameraPtr->getImgNums != 0)
|
||
// {
|
||
// Sleep(20);
|
||
// mytime++;
|
||
// if (mytime >= check_pack.head().sleep_time) //"拍照信号-检查完成的时间": "360000"。设置很大：机台中途报警，复位后继续拍照检测
|
||
// {
|
||
// mycameraPtr->set_m_stoprun(true);
|
||
// Sleep(10);
|
||
// }
|
||
// //mycameraPtr->m_stoprun=true相机读SN信号时，进行设置
|
||
// if (mycameraPtr->getImgNums == 0 || mytime*20 >= check_pack.head().sleep_time || (mycameraPtr->m_stoprun==true && mytime>=50))
|
||
// break;
|
||
// }
|
||
// Sleep(1);
|
||
// mycameraPtr->set_m_stoprun(true);// m_stoprun = true;
|
||
// }
|
||
// }
|
||
//}
|
||
|
||
|
||
}
|
||
catch (QString ev)
|
||
{
|
||
qCritical() << __FUNCTION__ << __LINE__ << " ev:" << ev;
|
||
}
|
||
return;
|
||
}
|
||
|
||
void runAndCheck_cameraThread::run_camera_moduleOneTime(
|
||
const QStringList& cameraKeyS_runNumS, const trigger_signal_pack& my_check_pack,
|
||
const QStringList& yh_getImageSignal) {
|
||
try
|
||
{
|
||
clock_t start, stop;
|
||
start = clock();
|
||
for (int index = 0; index < cameraKeyS_runNumS.size(); index++)
|
||
{
|
||
QString cameraName_getImgNum = cameraKeyS_runNumS[index]; //相机key_运行次数
|
||
int runNum = cameraName_getImgNum.split("_")[1].toInt();
|
||
if (runNum < 1)
|
||
{
|
||
qCritical() << __FUNCTION__ << __LINE__ << " cameraKey_runNum err:" << cameraKeyS_runNumS[index];
|
||
return;
|
||
}
|
||
//runModule(cameraName);
|
||
bool if_camera_get_All = true;
|
||
for (int i = 0; i < station_camerathreadlist.size(); i++)
|
||
{
|
||
QString cameraKey = station_camerathreadlist.at(i)->m_name; //相机SN或userID
|
||
if (cameraKey == cameraName_getImgNum.split("_")[0])
|
||
{
|
||
station_camerathreadlist.at(i)->set_m_stoprun(true);
|
||
//----2024.03.05修改
|
||
// 回复信号放到Logic_camera_thread相机取图完成后执行
|
||
// 可能出现同一工位多个相机，信号先后给的情况，避免相机取图时间过长，导致下一个相机开始取图慢
|
||
//相机拍照完成检查包
|
||
if (my_check_pack.sleep_time > 100)
|
||
station_camerathreadlist.at(i)->maxCheckTime = my_check_pack.sleep_time;
|
||
if (index == 0)
|
||
station_camerathreadlist.at(i)->send_byte = checkCamerasFinish_feedbackSignal(my_check_pack);
|
||
else
|
||
station_camerathreadlist.at(i)->send_byte = "pass"; //一个开始拍照对应多个相机的，回复的信号只保留一个，后面的不发了。减少通信耗时。
|
||
//Logic_camera_thread在线程运行，当getImgNums不为0时从相机模块获取getImgNums次图
|
||
//取图总时间超过maxCheckTime，会结束取图。
|
||
#if YH_LOGIC_SWITCH > 0
|
||
station_camerathreadlist.at(i)->yh_getImageSignal = yh_getImageSignal;
|
||
#endif
|
||
station_camerathreadlist.at(i)->getImgNums = runNum;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
///*stop = clock();
|
||
//qCritical() << "trigger_signal:" << trigger_signal << " run_camera_module station_camerathreadlist cut Time ::" << stop - start;
|
||
//start = clock();*/
|
||
//for (int ca = 0; ca < cameraKeyS_runNumS.size(); ca++)
|
||
//{
|
||
// QString cameraName_getImgNum = cameraKeyS_runNumS[ca]; //相机key_运行次数
|
||
// int runNum = cameraName_getImgNum.split("_")[1].toInt();
|
||
// if (runNum < 1)
|
||
// {
|
||
// qCritical() << __FUNCTION__ << __LINE__ << " cameraKey_runNum err:" << cameraKeyS_runNumS[ca];
|
||
// return;
|
||
// }
|
||
// //runModule(cameraName);
|
||
// bool if_camera_get_All = true;
|
||
// for (int i = 0; i < station_camerathreadlist.size(); i++)
|
||
// {
|
||
// QString cameraKey = station_camerathreadlist.at(i)->getName(); //相机SN或userID
|
||
// // tmpDate = QDateTime::currentDateTime().toString("yyyy-MM-dd-hh-mm-ss-zzz");
|
||
// //std::cout << "run_camera_module strat 3 ::" << tmpDate.toStdString() << " trigger_camera_name::" << cameraKey_runNum.toStdString() << std::endl;
|
||
// if (cameraKey == cameraName_getImgNum.split("_")[0])
|
||
// {
|
||
// Logic_camera_thread* mycameraPtr = station_camerathreadlist.at(i);
|
||
// //mycameraPtr->wait();
|
||
// int mytime = 0;
|
||
// while (mycameraPtr->getImgNums != 0)
|
||
// {
|
||
// Sleep(20);
|
||
// mytime++;
|
||
// if (mytime >= check_pack.head().sleep_time) //"拍照信号-检查完成的时间": "360000"。设置很大：机台中途报警，复位后继续拍照检测
|
||
// {
|
||
// mycameraPtr->set_m_stoprun(true);
|
||
// Sleep(10);
|
||
// }
|
||
// //mycameraPtr->m_stoprun=true相机读SN信号时，进行设置
|
||
// if (mycameraPtr->getImgNums == 0 || mytime*20 >= check_pack.head().sleep_time || (mycameraPtr->m_stoprun==true && mytime>=50))
|
||
// break;
|
||
// }
|
||
// Sleep(1);
|
||
// mycameraPtr->set_m_stoprun(true);// m_stoprun = true;
|
||
// }
|
||
// }
|
||
//}
|
||
|
||
|
||
}
|
||
catch (QString ev)
|
||
{
|
||
qCritical() << __FUNCTION__ << __LINE__ << " ev:" << ev;
|
||
}
|
||
return;
|
||
}
|
||
//获取"拍照信号-完成写入PLC-列表"，拍照信号对应的反馈信号
|
||
QByteArray runAndCheck_cameraThread::checkCamerasFinish_feedbackSignal(trigger_signal_pack m_pack)
|
||
{
|
||
int tmp_size = 0;
|
||
//clock_t start_triggerTime = clock();
|
||
// 写入反馈信号
|
||
QVector<QString> vector_trigger_feedback_signal = m_pack.vector_trigger_feedback_signal;
|
||
foreach(QString trigger_feedback_signal, vector_trigger_feedback_signal)
|
||
{
|
||
QStringList plc_feedback_msg_list = trigger_feedback_signal.split("_");
|
||
if (plc_feedback_msg_list.size() != 5)
|
||
{
|
||
qWarning() << __FUNCTION__ << " line: " << __LINE__ << " plc_feedback_msg_list num is error! plc_feedback_msg_list num:" << plc_feedback_msg_list.length();
|
||
}
|
||
else if (plc_feedback_msg_list.contains(m_pack.m_startpos))
|
||
{
|
||
// 发送反馈信号
|
||
QString feedback_signal_type = plc_feedback_msg_list.at(1) + "_" + plc_feedback_msg_list.at(2);
|
||
QString feedback_signal_pos = plc_feedback_msg_list.at(3);
|
||
QString feedback_signal_value = plc_feedback_msg_list.at(4);
|
||
QString send_msg = feedback_signal_type + "_" + feedback_signal_pos + "_" + feedback_signal_value;
|
||
QByteArray send_byte = send_msg.toUtf8();
|
||
return send_byte;
|
||
|
||
/*//QMutexLocker locker(m_iomutex);;
|
||
if (!finstcp_ptr->writeData(vec_mat, send_byte))
|
||
{
|
||
qCritical() << __FUNCTION__ << "line:" << __LINE__ << " finstcp_ptr reciveData error! ";
|
||
return;
|
||
}
|
||
else
|
||
{
|
||
qDebug() << __FUNCTION__ << " line:" << __LINE__ << "feedback_signal: " << send_byte;
|
||
}*/
|
||
}
|
||
}
|
||
return "";
|
||
} |