566 lines
17 KiB
C++
566 lines
17 KiB
C++
#include "taskthread.h"
|
|
|
|
taskThread::taskThread(QObject *parent) :m_obj(parent)
|
|
{
|
|
|
|
}
|
|
|
|
taskThread::~taskThread()
|
|
{
|
|
m_stoprun = false;
|
|
wait(100);
|
|
exit();
|
|
qDebug() << "[INFO] " << " m_name:" << m_name << " delete thread success! ";
|
|
}
|
|
|
|
bool taskThread::initTaskThread(int index,QString stationName,QJsonArray array,QList<MyModule> list)
|
|
{
|
|
try
|
|
{
|
|
m_thread_index = index;
|
|
m_stationName = stationName;
|
|
for ( int val = 0 ; val < array.size();val++ )
|
|
{
|
|
QJsonObject m_obj = array.at(val).toObject();
|
|
QString task_thread_index = m_obj.value("task_thread_index").toString();
|
|
if(task_thread_index.isEmpty())
|
|
{
|
|
qCritical() << "[Error] " << " get task_thread_index is null!";
|
|
return false;
|
|
}
|
|
|
|
if ( task_thread_index.toInt() == m_thread_index )
|
|
{
|
|
appendPlcCmd(m_obj);
|
|
module_jsonobject_list.append(m_obj);
|
|
}
|
|
}
|
|
m_module_list = list;
|
|
} catch (QString ev) {
|
|
qCritical() << "[Error] " << " ev:" << ev;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool taskThread::appendPlcCmd(QJsonObject m_moduleobj)
|
|
{
|
|
QVector<QString> plc_commond_vector;
|
|
QString m_key = m_moduleobj.value("key").toString(); // 算法名称
|
|
QString algorithm_complete_plcpos = m_moduleobj.value("algorithm_complete_plcpos").toString();
|
|
QJsonArray algorithm_result_array = m_moduleobj.value("algorithm_result").toArray();
|
|
if ( algorithm_result_array.isEmpty() || algorithm_complete_plcpos.isEmpty() )
|
|
{
|
|
qWarning() << "[Error] " << " algorithm_result_array or algorithm_complete_plcpos or trigger_cond_list is null ! ";
|
|
// return false;
|
|
}
|
|
plc_commond_vector.push_back(algorithm_complete_plcpos); // 添加 结果拍照完成信号
|
|
// 添加结果数据信息
|
|
for ( int i = 0; i < algorithm_result_array.size();i++ )
|
|
{
|
|
QString write_plcpos = algorithm_result_array.at(i).toObject().value("write_plcpos").toString();
|
|
if(!write_plcpos.isEmpty())
|
|
plc_commond_vector.push_back(write_plcpos);
|
|
else
|
|
qWarning() << "[Error] " << " warning write_plcpos is null!";
|
|
}
|
|
|
|
// 添加结果正负值信息
|
|
for ( int i = 0; i < algorithm_result_array.size();i++ )
|
|
{
|
|
QString write_plcpos = algorithm_result_array.at(i).toObject().value("negative_plcpos").toString();
|
|
if(!write_plcpos.isEmpty())
|
|
plc_commond_vector.push_back(write_plcpos);
|
|
else
|
|
qWarning() << "[Error] " << " warning negative_plcpos is null!";
|
|
}
|
|
|
|
// 添加到map中
|
|
plc_commond_vector_map.insert(m_key,plc_commond_vector);
|
|
qDebug() << "[INFO] " << " m_name:" << m_name << " plc_commond_vector:" << plc_commond_vector ;
|
|
return true;
|
|
}
|
|
|
|
void taskThread::run()
|
|
{
|
|
try
|
|
{
|
|
processTask();
|
|
} catch ( QString ev ) {
|
|
qCritical() << "[Error] " << " ev:" << ev;
|
|
return;
|
|
}
|
|
}
|
|
|
|
bool taskThread::processTask()
|
|
{
|
|
while ( true )
|
|
{
|
|
if ( !m_stoprun )
|
|
{
|
|
return true;
|
|
}
|
|
processExecData();
|
|
_sleep(5);
|
|
}
|
|
}
|
|
|
|
|
|
bool taskThread::processExecData()
|
|
{
|
|
HStationData *station_ptr = station_list.value(m_stationName);
|
|
if ( station_ptr )
|
|
{
|
|
for ( int val = 0; val < m_module_list.size(); val++ )
|
|
{
|
|
testData m_data;
|
|
QString m_key = m_module_list.at(val).key;
|
|
HAlgorithmExecData *m_ptr = station_ptr->getAlgorithmExecData(m_key);
|
|
if ( m_ptr->getDetectData( m_data ) )
|
|
{
|
|
// 任务下标---
|
|
queue_exec_cameraName.append(m_data);
|
|
m_exec_module = m_module_list.at(val);
|
|
AlgorithmModuleProcessData (m_key,m_data.dstImageMat,m_data.byte );
|
|
m_ptr->deleteDetectData();
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool taskThread::AlgorithmModuleProcessData(QString key,std::vector<cv::Mat> vector_mat,QByteArray send_byte)
|
|
{
|
|
// qDebug() << "[INFO] " << " m_name:" << m_name << " key:" << key << " vector_mat len:" << vector_mat.size() << " send_byte len:" << send_byte.length();
|
|
|
|
std::vector<cv::Mat> ai_mat;
|
|
QByteArray ai_byte;
|
|
|
|
// 查找对应的模块名,和对应模块的object
|
|
//m_exec_module = getExecModule(key);
|
|
if( m_exec_module.key.contains("error"))
|
|
{
|
|
qCritical() << "[Error] " << " getExecModule is error!";
|
|
return false;
|
|
}
|
|
|
|
m_exec_object = getModuleObject(key);
|
|
if ( m_exec_object.isEmpty() )
|
|
{
|
|
qCritical() << "[Error] " << " m_exec_object is null!";
|
|
return false;
|
|
}
|
|
|
|
m_name = m_exec_object.value("key").toString();
|
|
m_type = m_exec_object.value("type").toString();
|
|
save_data_flag = m_exec_object.value("save_data_flag").toString();
|
|
if ( m_type.isEmpty() || m_name.isEmpty() || save_data_flag.isEmpty() )
|
|
{
|
|
qCritical() << "[Error] " << " m_type or m_name is null!";
|
|
}
|
|
QString dataStr = send_byte;
|
|
//qDebug() << "[INFO] " << " dataStr:" << dataStr;
|
|
QByteArrayList datalist = send_byte.split(',');
|
|
int proIndex = datalist.at(2).toInt();
|
|
m_exec_module.module_ptr->reciveData(vector_mat,send_byte); // 接受图片和数据
|
|
|
|
if ( m_exec_module.module_ptr->run())
|
|
{
|
|
if ( !m_exec_module.module_ptr->sendData ( ai_mat,ai_byte ) )
|
|
{
|
|
qCritical() << "[Error] " << " check ai module result is error! ";
|
|
vector_mat.clear();
|
|
ai_mat.clear();
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
qCritical() << "[Error] " << " m_AiModule run result is null! ";
|
|
vector_mat.clear();
|
|
ai_mat.clear();
|
|
cv::Mat null_mat;
|
|
sendDataCommond(m_type,null_mat,"null"); // 发送异常信息到界面显示
|
|
// 发送异常指令
|
|
sendCatchCommond();
|
|
return false;
|
|
}
|
|
|
|
// 发送AI数据 和 图
|
|
if ( !ai_byte.isEmpty() )
|
|
{
|
|
// qDebug() << "[INFO] " << " m_name:" << m_name << " send ai byte :" << ai_byte.length();
|
|
cv::Mat null_mat;
|
|
if ( !ai_mat.empty() )
|
|
null_mat = ai_mat.at(0);
|
|
|
|
sendDataCommond(key,null_mat,ai_byte, proIndex);
|
|
vector_mat.clear();
|
|
ai_mat.clear();
|
|
}
|
|
else
|
|
{
|
|
qCritical() << "[Error] " <<" m_name:" << m_name << " ai_byte len:" << ai_byte.length() << " error check data is null! ";
|
|
cv::Mat null_mat;
|
|
sendDataCommond(m_type,null_mat,"null"); // 发送异常信息到界面显示
|
|
}
|
|
return true;
|
|
}
|
|
|
|
MyModule taskThread::getExecModule(QString key)
|
|
{
|
|
MyModule m_module;
|
|
m_module.key = "error";
|
|
for ( int i = 0 ; i < m_module_list.size(); i++ )
|
|
{
|
|
if ( m_module_list.at(i).key == key )
|
|
{
|
|
return m_module_list.at(i);
|
|
}
|
|
}
|
|
return m_module;
|
|
}
|
|
|
|
QJsonObject taskThread::getModuleObject ( QString key )
|
|
{
|
|
QJsonObject obj;
|
|
for ( int i = 0 ; i < module_jsonobject_list.size(); i++ )
|
|
{
|
|
QJsonObject m_obj = module_jsonobject_list.at(i);
|
|
QString m_key = m_obj.value("key").toString();
|
|
if ( m_key == key )
|
|
{
|
|
return m_obj;
|
|
}
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
bool taskThread::saveAlgorithmData(testData m_testdata,QByteArray byte)
|
|
{
|
|
QString camera_name = m_testdata.cameraName;
|
|
QString task_index = m_testdata.task_index;
|
|
|
|
Algorithm_Result_Data result_data;
|
|
result_data.byte = byte;
|
|
|
|
HAlgorithmData *algorithmPtr = station_list.value(m_stationName)->getAlgorithmData(m_name);
|
|
if ( algorithmPtr )
|
|
{
|
|
QString cameraName_and_index = camera_name + "_" + task_index;
|
|
algorithmPtr->addAlgorithmData(cameraName_and_index,result_data);
|
|
}
|
|
else
|
|
{
|
|
qCritical() << "[Error] " << " cameraPtr is null!";
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// 发送拍照异常 指令
|
|
bool taskThread::sendCatchCommond()
|
|
{
|
|
// QMutexLocker locker(m_mutex); // 加锁
|
|
std::vector<cv::Mat> vec_mat;
|
|
QByteArray send_byte;
|
|
// 写入
|
|
if ( m_name == "camera1" )
|
|
{
|
|
send_byte = "write_DM105_1";
|
|
}
|
|
else if ( m_name == "camera2" )
|
|
{
|
|
send_byte = "write_DM115_1";
|
|
}
|
|
else if ( m_name == "camera3" )
|
|
{
|
|
send_byte = "write_DM138_1";
|
|
}
|
|
else if ( m_name == "camera4" )
|
|
{
|
|
send_byte = "write_DM139_1";
|
|
}
|
|
|
|
// 写入异常信息
|
|
writeCommondPack.append(send_byte);
|
|
|
|
qDebug() << "[INFO] " << " catch success! ";
|
|
return true;
|
|
}
|
|
|
|
|
|
bool taskThread::decodeAiValue(QByteArray byte,QVector<QByteArray> &vec_ret)
|
|
{
|
|
if(byte.isEmpty())
|
|
{
|
|
qCritical() << "[Error] " << " byte is null!";
|
|
return false;
|
|
}
|
|
|
|
while (!byte.isEmpty())
|
|
{
|
|
int type = 0;
|
|
QByteArray m_type = byte.mid(0,4);
|
|
memcpy((void*)&type,(void*)m_type.data(), 4);
|
|
if(type != 3)
|
|
{
|
|
qCritical() << "[Error] " << " type is error" << type;
|
|
return false;
|
|
}
|
|
//qDebug() << __FUNCTION__ << " line:" << __LINE__ << " type:" << type;
|
|
byte.remove(0,4);
|
|
|
|
int len = 0;
|
|
QByteArray m_len = byte.mid(0,4);
|
|
memcpy((void*)&len,(void*)m_len.data(), 4);
|
|
//qDebug() << __FUNCTION__ << " line:" << __LINE__ << " len:" << len;
|
|
byte.remove(0,4);
|
|
|
|
QByteArray mm_data = byte.mid(0,len);
|
|
vec_ret.append(mm_data);
|
|
byte.remove(0,len);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
QVector<QString> taskThread::getWriteVector(QString &startPos,QMap<QString,QString> &map)
|
|
{
|
|
QVector<QString> vector_value;
|
|
if ( map.isEmpty() )
|
|
{
|
|
qWarning() << "[Error] " << " map is null!";
|
|
return vector_value;
|
|
}
|
|
|
|
startPos = map.firstKey(); // 第一个key 取出的为 DM101
|
|
int check_pos = 0;
|
|
while(!map.isEmpty())
|
|
{
|
|
QString m_key = map.firstKey();
|
|
QString m_value = map.value(m_key);
|
|
|
|
QString lastpos = m_key.right(1);
|
|
if ( check_pos == 0 )
|
|
{
|
|
check_pos = lastpos.toInt(); // 截取最后一位的值
|
|
vector_value.push_back(m_value); // 添加值
|
|
map.remove(m_key);
|
|
}
|
|
else
|
|
{
|
|
int m_lastpos = lastpos.toInt();
|
|
if ( m_lastpos == check_pos )
|
|
{
|
|
// 先判断是否连续，不连续则退出,连续则添加
|
|
vector_value.push_back(m_value); // 添加值
|
|
map.remove(m_key);
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
check_pos++; // 移动位置
|
|
}
|
|
return vector_value;
|
|
}
|
|
|
|
// 算法结果 写入plc
|
|
bool taskThread::writeAiCommond(QString cameraName,QByteArray byte)
|
|
{
|
|
qDebug() << "[INFO] " << " writeAiCommond:" << " m_name:" << m_name;
|
|
QVector<QByteArray> vec_ret; // 存储结果的
|
|
if ( !decodeAiValue(byte,vec_ret) )
|
|
{
|
|
qCritical() << "[Error] " << " decodeAiValue error!";
|
|
return false;
|
|
}
|
|
|
|
if ( vec_ret.isEmpty() )
|
|
{
|
|
qDebug() << "[Error] " << " vec_ret is null!";
|
|
return false;
|
|
}
|
|
|
|
QJsonArray algorithm_result = m_exec_object.value("algorithm_result").toArray();
|
|
if ( algorithm_result.size() != vec_ret.length() )
|
|
{
|
|
qCritical() << "[Error] " << " algorithm_result != vec_ret failed!";
|
|
vec_ret.clear();
|
|
return false;
|
|
}
|
|
|
|
QMap<QString,QString> key_value;
|
|
|
|
QString key_complete_pos = m_exec_object.value("algorithm_complete_plcpos").toString();
|
|
if (key_complete_pos.isEmpty())
|
|
{
|
|
qWarning() << "[Error] " << " algorithm_complete_plcpos is null! ";
|
|
// vec_ret.clear();
|
|
// return false;
|
|
}
|
|
else
|
|
{
|
|
// 首先添加 algorithm_complete_plcpos
|
|
key_value.insert(key_complete_pos,"1");
|
|
}
|
|
|
|
for(int i = 0; i < algorithm_result.size(); i++)
|
|
{
|
|
QString key_dmpos = algorithm_result.at(i).toObject().value("write_plcpos").toString();
|
|
double m_value = vec_ret.at(i).toDouble();
|
|
|
|
// 添加值
|
|
key_value.insert ( key_dmpos,QString::number( abs((int)m_value)) );
|
|
QString negative_plcpos = algorithm_result.at(i).toObject().value("negative_plcpos").toString();
|
|
if ( !negative_plcpos.isEmpty() )
|
|
{
|
|
// 添加正负值
|
|
|
|
QString negative_value;
|
|
if( m_value > 0)
|
|
negative_value = "1";
|
|
else
|
|
negative_value = "-1";
|
|
|
|
// 添加值
|
|
key_value.insert(negative_plcpos,negative_value);
|
|
}
|
|
}
|
|
|
|
if ( !writeTcpData(key_value) )
|
|
{
|
|
qCritical() << "[Error] " << " writeTcpData failed!";
|
|
return false;
|
|
}
|
|
|
|
qDebug() << "[INFO] " << " cameraName:" << cameraName << " writeAiCommond success!";
|
|
return true;
|
|
}
|
|
|
|
bool taskThread::writeAiCommond(QString cameraName, QByteArray byte, int index)
|
|
{
|
|
QString resultStr = byte;
|
|
//qDebug() << __FUNCTION__ << " line:" << __LINE__ << " resultStr:" << resultStr;
|
|
if (byte == "null")
|
|
return false;
|
|
QStringList resultStrList = resultStr.split(",");
|
|
int pIndex = resultStr.indexOf(",");
|
|
QString cmd1 = resultStr.mid(0, pIndex);
|
|
QString cmd2 = resultStr.mid(pIndex + 1, resultStr.size() -pIndex - 1);
|
|
|
|
QJsonArray algorithm_result = m_exec_object.value("algorithm_result").toArray();
|
|
QJsonArray write_plcpos = algorithm_result.at(0).toObject().value("write_plcpos").toArray();
|
|
QJsonArray write_plcposes = algorithm_result.at(0).toObject().value("write_plcposes").toArray();
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
QString cmd;
|
|
if(i == 1)
|
|
cmd = write_plcpos.at(index - 1).toString() + cmd1;
|
|
else
|
|
cmd = write_plcposes.at(index - 1).toString() + cmd2;
|
|
//qDebug() << __FUNCTION__ << " line:" << __LINE__ << " cmd:" << cmd;
|
|
std::vector<cv::Mat> vec_mat;
|
|
if (!finstcp_ptr->reciveData(vec_mat, cmd.toUtf8()))
|
|
{
|
|
qCritical() << "[Error] " << " finstcp_ptr reciveData error! ";
|
|
return false;
|
|
}
|
|
|
|
}
|
|
|
|
qDebug() << "[INFO] " << " cameraName:" << cameraName << " writeAiCommond success!";
|
|
return true;
|
|
}
|
|
|
|
|
|
bool taskThread::writeTcpData(QMap<QString,QString> key_value)
|
|
{
|
|
qDebug() << "[INFO] " << "-- key_value:" << key_value;
|
|
try
|
|
{
|
|
std::vector<cv::Mat> vec_mat;
|
|
while ( !key_value.isEmpty() )
|
|
{
|
|
QString dm_startPos; // 起始位
|
|
QVector<QString> vector_value = getWriteVector(dm_startPos,key_value);
|
|
qDebug() << "[INFO] " << " dm_startPos:" << dm_startPos << " vector_value:" << vector_value;
|
|
|
|
QByteArray write_byte = writeFormat(dm_startPos,vector_value);
|
|
|
|
// 写入
|
|
writeCommondPack.append(write_byte);
|
|
}
|
|
} catch (QString ev) {
|
|
qCritical() << "[Error] " << " writeTcpData is failed! ev:" << ev;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
QByteArray taskThread::writeFormat(QString startPos, QVector<QString> vector_value)
|
|
{
|
|
QByteArray byte;
|
|
// 格式 示例： writeResult_DM101_5_ writeShort_DM3000_NUM_
|
|
|
|
std::string write_format;
|
|
|
|
write_format = "writeResult_"+startPos.toStdString()+"_"+QString::number(vector_value.size()).toStdString() + "_";
|
|
|
|
// 其他格式 按照 长度+数据写入 进行编码
|
|
std::string sendData;
|
|
for(int i = 0 ; i < vector_value.size();i++)
|
|
{
|
|
int len = vector_value.at(i).length();
|
|
std::string m_len;
|
|
m_len.insert(0,4,'1');
|
|
memcpy ( (void*)m_len.c_str(),(void*)&len,4 );
|
|
// 添加长度
|
|
sendData.append(m_len);
|
|
|
|
// 添加数据
|
|
sendData.append(vector_value.at(i).toStdString());
|
|
// m_value += str_len + str_value;
|
|
}
|
|
write_format += sendData;
|
|
byte = QByteArray::fromStdString(write_format);
|
|
return byte;
|
|
}
|
|
|
|
bool taskThread::sendDataCommond( QString m_type,cv::Mat mat,QByteArray byte ,int index)
|
|
{
|
|
// QMutexLocker locker(m_mutex); // 加锁
|
|
|
|
dataPack m_pack;
|
|
m_pack.mat = mat;
|
|
m_pack.byte = byte;
|
|
m_pack.retFlag = m_exec_object.value("type").toString();
|
|
|
|
|
|
testData m_exec_testData; // 当前执行算法的输出结果信息
|
|
if ( !queue_exec_cameraName.isEmpty() )
|
|
{
|
|
m_exec_testData = queue_exec_cameraName.dequeue();
|
|
m_pack.name = m_exec_testData.cameraName;
|
|
}
|
|
|
|
qDebug() << "[INFO] " << " m_name:" << m_name << " save_data_flag:" << save_data_flag;
|
|
// 发送数据还是保存数据
|
|
if ( save_data_flag == "true" )
|
|
{
|
|
saveAlgorithmData(m_exec_testData,byte);
|
|
}
|
|
else if ( !writeAiCommond(m_type,byte,index))
|
|
{
|
|
qCritical() << "[Error] " << " writeAiCommond is failed!";
|
|
}
|
|
// 界面显示包
|
|
/* ImageDataPack.append(m_pack);
|
|
QMetaObject::invokeMethod(m_obj,"reciveImageData");*/
|
|
|
|
return true;
|
|
}
|