794 lines
33 KiB
C++
794 lines
33 KiB
C++
#include "myiothread.h"
|
|
#include <processtask.h>
|
|
#include <FrontendBackendBridge.h>
|
|
#include <mainwindow.h>
|
|
#include<io.h>
|
|
#include <report.h>
|
|
#include<cmath>
|
|
#include<math.h>
|
|
string snErrorsnError("snErrNoSn");
|
|
QQueue<QByteArray> writeCommondPack;
|
|
|
|
MyIoThread::~MyIoThread()
|
|
{
|
|
io_runflag = false;
|
|
|
|
for( int i = 0 ; i < vector_camera_signal_pack_ptr.size();i++)
|
|
{
|
|
if(vector_camera_signal_pack_ptr.at(i))
|
|
delete vector_camera_signal_pack_ptr.at(i);
|
|
}
|
|
|
|
wait(100);
|
|
exit();
|
|
|
|
qDebug() << "[INFO] " << " ~MyIoThread success! ";
|
|
}
|
|
void writeToDataSheetCSV(bool isOK);
|
|
|
|
//IO线程
|
|
void MyIoThread::run()
|
|
{
|
|
bool isInitTcp = true;
|
|
int times = 0;
|
|
m_timer = new QTimer();
|
|
m_timer->setInterval(8000);
|
|
connect(m_timer, &QTimer::timeout, [this] {
|
|
qDebug() << "[TCP Error] " << QString::fromUtf8("注意心跳发送超时") << endl;
|
|
});
|
|
|
|
if (m_IoType == "Heart")//心跳线程
|
|
{
|
|
m_heartCmd = bridge.back.json.tcp.heartCmd;
|
|
while (io_runflag)
|
|
{
|
|
QMutexLocker locker(m_iomutex);
|
|
QString cmd1 = m_heartCmd;//心跳
|
|
if (bridge.back.sendFinsMsg(cmd1))
|
|
{
|
|
m_timer->setInterval(8000);
|
|
m_timer->start();
|
|
}
|
|
QThread::msleep(100);
|
|
}
|
|
}
|
|
else//解析fins线程
|
|
{
|
|
//初始化
|
|
m_readAllCmd = bridge.back.json.tcp.finstcp_readAllCmd;
|
|
//bridge.back.sendFinsMsg("writeAll_DM9100_1000_0");
|
|
/*for (int i = 0; i < 1000; i++)
|
|
bridge.back.sendFinsMsg(
|
|
QString::fromStdString("write_DM" + to_string(bridge.back.json.tcp.startPos + i) + "_0"));*/
|
|
workThread = new threadConroller();
|
|
for (auto thread : threadlist)
|
|
thread->cameraImgsPtr = &workThread->cameraImgs;
|
|
msleep(1000);
|
|
while (io_runflag)
|
|
{
|
|
reciveCommond();
|
|
QThread::msleep(1);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 写入数据
|
|
void MyIoThread::writeCommond()
|
|
{
|
|
while( !writeCommondPack.isEmpty())
|
|
{
|
|
//qDebug() << __FUNCTION__ << " line:" << __LINE__ << " writeCommondPack len:" << writeCommondPack.length();
|
|
QByteArray write_byte = writeCommondPack.dequeue();
|
|
if ( !bridge.back.sendFinsMsg(write_byte) )
|
|
{
|
|
qCritical() << "[TCP] " << " finstcp_ptr reciveData error!";
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void MyIoThread::reciveCommond()
|
|
{
|
|
|
|
QByteArray byte = m_readAllCmd.toUtf8(); // 设置 从起始位开始读取的指令
|
|
if (!bridge.back.sendFinsMsg(byte))
|
|
{
|
|
qCritical() << "[TCP] " << " finstcp_ptr reciveData error!";
|
|
}
|
|
|
|
// 读取到的信息解析
|
|
QByteArray readByte;
|
|
if (!bridge.back.reciveFinsMsg(readByte))
|
|
{
|
|
qCritical() << "[TCP] " << " finstcp_ptr sendData error!";
|
|
}
|
|
tLocker.reFreshLocker(readByte);
|
|
decodeCameraCMD(readByte);
|
|
workThread->snDatas.checkSnFromWaittingVec(readByte);
|
|
}
|
|
|
|
void MyIoThread::setIOMutex(QMutex *mutex)
|
|
{
|
|
m_iomutex = mutex;
|
|
}
|
|
|
|
void MyIoThread::setStationObject( QJsonObject camera_obj)
|
|
{
|
|
|
|
QVector<QString> camera_trigger_cmds;
|
|
QJsonArray stationlist = camera_obj.value("stationlist").toArray();
|
|
|
|
for ( int i = 0; i < stationlist.size(); i++ )
|
|
{
|
|
QJsonObject station_obj = stationlist.at(i).toObject();
|
|
QJsonArray cameramodulelist = station_obj.value("cameramodulelist").toArray();
|
|
QString stationKey = station_obj.value("key").toString();
|
|
#if 1
|
|
for( int val = 0 ; val < cameramodulelist.size();val++)
|
|
{
|
|
trigger_camera_pack *m_pack = new trigger_camera_pack;
|
|
QJsonObject m_obj = cameramodulelist.at(val).toObject();
|
|
QString trigger_camera_name = m_obj.value("key").toString();
|
|
QJsonArray trigger_camera_startpos = m_obj.value("trigger_camera_startpos").toArray();
|
|
QJsonArray plc_feedback_msg = m_obj.value("plc_feedback_msg").toArray();
|
|
QString read_clear_plc_startpos = m_obj.value("read_clear_plc_startpos").toString();
|
|
QString clear_plc_data_msg = m_obj.value("clear_plc_data_msg").toString();
|
|
QString clear_camera_startpos_flag = m_obj.value("clear_camera_startpos_flag").toString();
|
|
if(stationKey == m_stationKey)
|
|
m_StationCameraIndexMap.insert(trigger_camera_name, 0);
|
|
// 添加相机名称
|
|
if ( !trigger_camera_name.isEmpty() )
|
|
m_pack->trigger_camera_name = trigger_camera_name;
|
|
|
|
if ( !trigger_camera_startpos.isEmpty())
|
|
{
|
|
m_pack->trigger_camera_startpos = trigger_camera_startpos;
|
|
}
|
|
|
|
if ( !plc_feedback_msg.isEmpty() )
|
|
{
|
|
m_pack->plc_feedback_msg = plc_feedback_msg;
|
|
}
|
|
|
|
if( !read_clear_plc_startpos.isEmpty())
|
|
{
|
|
QString clear_startpos = read_clear_plc_startpos.split("_")[0];
|
|
QString clear_value = read_clear_plc_startpos.split("_")[1];
|
|
if ( !clear_startpos.isEmpty() && !clear_value.isEmpty())
|
|
{
|
|
m_pack->read_clear_plc_startpos = clear_startpos;
|
|
m_pack->read_clear_plc_value = clear_value;
|
|
}
|
|
}
|
|
|
|
if( !clear_plc_data_msg.isEmpty())
|
|
{
|
|
m_pack->clear_plc_data_msg = clear_plc_data_msg;
|
|
}
|
|
|
|
// 是否清楚当前点位的信号
|
|
if( !clear_camera_startpos_flag.isEmpty())
|
|
{
|
|
m_pack->clear_camera_startpos_flag = clear_camera_startpos_flag;
|
|
}
|
|
|
|
vector_camera_signal_pack_ptr.push_back(m_pack); // 添加
|
|
}
|
|
|
|
|
|
//
|
|
#endif
|
|
//if (stationKey == m_stationKey)
|
|
//{
|
|
//获取write指令
|
|
QJsonObject writeCmdObject = station_obj.value("plcwrite_area").toObject();
|
|
QString snOkCmd = writeCmdObject.value("snOkCmd").toString();
|
|
QString snErrorCmd = writeCmdObject.value("snErrorCmd").toString();
|
|
QString overOkCmd = writeCmdObject.value("overOkCmd").toString();
|
|
QString overErrorCmd = writeCmdObject.value("overErrorCmd").toString();
|
|
QString dateCmd = writeCmdObject.value("dateCmd").toString();
|
|
writeCmdMap.insert("snOkCmd", snOkCmd);
|
|
writeCmdMap.insert("snErrorCmd", snErrorCmd);
|
|
writeCmdMap.insert("overOkCmd", overOkCmd);
|
|
writeCmdMap.insert("overErrorCmd", overErrorCmd);
|
|
writeCmdMap.insert("dateCmd", dateCmd);
|
|
|
|
//qDebug() << m_stationKey;
|
|
m_cameralist = cameramodulelist;
|
|
cameraSize = cameramodulelist.size();
|
|
//qDebug() << cameraSize;
|
|
readPlcCmd = station_obj.value("plcread_area").toObject();
|
|
m_readAllCmd = readPlcCmd.value("finstcp_readAllCmd").toString();
|
|
writePlcCmd = station_obj.value("plcwrite_area").toObject();
|
|
//}
|
|
//addReadAndWritePlcCmd(stationKey, readPlcCmd, writePlcCmd);
|
|
}
|
|
}
|
|
|
|
void MyIoThread::writeSnFromString(string SN, int startPos, bool highLowConversion)
|
|
{
|
|
std::vector<int>asciiCodes;
|
|
for (auto a : SN)
|
|
asciiCodes.push_back(toascii(a));
|
|
if (highLowConversion == false)
|
|
for (int i = 0; i < asciiCodes.size(); i += 2)
|
|
{
|
|
if (i != asciiCodes.size() - 1)
|
|
bridge.back.sendFinsMsg("write_DM" + QString::number(startPos + i / 2) + "_" + QString::number(asciiCodes[i + 1] * 256 + asciiCodes[i]));//SN
|
|
else
|
|
bridge.back.sendFinsMsg("write_DM" + QString::number(startPos + i / 2) + "_" + QString::number(asciiCodes[i] * 256));//SN
|
|
}
|
|
else
|
|
for (int i = 0; i < asciiCodes.size(); i += 2)//未测试
|
|
{
|
|
if (i != asciiCodes.size() - 1)
|
|
bridge.back.sendFinsMsg("write_DM" + QString::number(startPos + i / 2) + "_" + QString::number(asciiCodes[i] * 256));//SN
|
|
else
|
|
bridge.back.sendFinsMsg("write_DM" + QString::number(startPos + i / 2) + "_" + QString::number(asciiCodes[i + 1] * 256 + asciiCodes[i]));//SN
|
|
}
|
|
}
|
|
|
|
void writeToDataSheetCSV(bool isOK)
|
|
{
|
|
QDateTime currentDateTime = QDateTime::currentDateTime();
|
|
//年-月-日
|
|
QString ymd = currentDateTime.toString("yyyy-MM-dd");
|
|
int h = currentDateTime.time().hour();
|
|
string hour;
|
|
if (h < 10)
|
|
hour = "0" + to_string(h);
|
|
else
|
|
hour = to_string(h);
|
|
|
|
QStringList dataList;
|
|
QString filePathCurrentDay =".//DataSheet//statics_" + ymd+".csv";
|
|
// 创建CSV文件
|
|
QFile file(filePathCurrentDay);
|
|
if (!file.exists())
|
|
{
|
|
QFile sourceFile(".//DataSheet//statics_default.csv");
|
|
if (!sourceFile.open(QIODevice::ReadOnly)) {
|
|
qDebug() << "无法打开源文件： " << sourceFile.errorString();
|
|
}
|
|
else
|
|
{
|
|
QString destinationFilePath = filePathCurrentDay;
|
|
QFile destinationFile(destinationFilePath);
|
|
if (!destinationFile.open(QIODevice::WriteOnly)) {
|
|
qDebug() << "无法打开目标文件： " << destinationFile.errorString();
|
|
}
|
|
else
|
|
{
|
|
QByteArray fileData = sourceFile.readAll();
|
|
destinationFile.write(fileData);
|
|
sourceFile.close();
|
|
destinationFile.close();
|
|
}
|
|
}
|
|
}
|
|
QList<QStringList> data;
|
|
QStringList headers;
|
|
// 打开CSV文件并写入数据
|
|
if (file.open(QIODevice::ReadOnly | QIODevice::Text))
|
|
{
|
|
QTextStream stream(&file);
|
|
/////
|
|
|
|
while (!stream.atEnd()) {
|
|
QString line = stream.readLine();
|
|
QStringList fields = line.split(',');
|
|
|
|
if (headers.isEmpty()) {
|
|
// 如果headers为空，则当前行为标题行
|
|
headers = fields;
|
|
}
|
|
else {
|
|
data.append(fields);
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < data.size(); i++) {
|
|
QStringList& row = data[i];
|
|
|
|
// 在当前行中检索字符串
|
|
if (row[0].contains(QString::fromStdString(hour), Qt::CaseInsensitive)) {
|
|
// 匹配到字符串，进行修改
|
|
if (row.size() >= 4)
|
|
{
|
|
int goods = row[1].toInt();
|
|
int bads = row[2].toInt();
|
|
double rate = row[3].toDouble();
|
|
if (isOK == true)
|
|
goods++;
|
|
else
|
|
bads++;
|
|
rate = row[1].toDouble() / (row[1].toDouble() + row[2].toDouble());
|
|
rate = round(rate * 100) / 100;
|
|
row[1] = QString::number(goods);
|
|
row[2] = QString::number(bads);
|
|
row[3] = QString::number(rate*100);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
file.close();
|
|
QFile writeFile(filePathCurrentDay);
|
|
if (!writeFile.open(QIODevice::WriteOnly | QIODevice::Text)) {
|
|
qDebug() << "Error opening file for writing.";
|
|
}
|
|
|
|
QTextStream out(&writeFile);
|
|
// 写入标题行
|
|
out << headers.join(",") << "\n";
|
|
|
|
// 写入修改后的数据行
|
|
for (const auto& row : data) {
|
|
out << row.join(",") << "\n";
|
|
}
|
|
|
|
writeFile.close();
|
|
|
|
//else
|
|
// qWarning() << "无法打开CSV文件：" << filePath;
|
|
|
|
}
|
|
/// <summary>
|
|
/// 检测QByteArray中某位置的值是否和输入一样，使用了绝对位置
|
|
/// </summary>
|
|
/// <param name="dmPos">绝对位置</param>
|
|
/// <param name="value">想判断的值</param>
|
|
/// <param name="byte">QByteArray</param>
|
|
/// <returns></returns>
|
|
bool MyIoThread::checkTrigger(int dmPos, int value, QByteArray byte)
|
|
{
|
|
int triggerPos = (dmPos - bridge.back.json.tcp.startPos) * 2 + 1;
|
|
if (byte.size() < triggerPos)
|
|
return false;
|
|
if (byte.at(triggerPos) == value)
|
|
{
|
|
if (tLocker.checkLocker(triggerPos) == false)
|
|
return false;
|
|
tLocker.adddLocker(triggerPos);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
void MyIoThread::_24CameraTrigger(int times, QByteArray& byte)
|
|
{
|
|
workThread->offTimesMutex.lock();
|
|
workThread->offsetTimes = times;
|
|
workThread->offTimesMutex.unlock();
|
|
/////////SN码读取操作///////
|
|
int snPos1 = 7000;
|
|
int snPos2 = 7040;
|
|
int snPos3 = 7080;
|
|
int snPos4 = 7120;
|
|
string sn1 = workThread->snDatas.readSnFromQByteArray(byte, snPos1, false, true, 0);
|
|
string sn2 = workThread->snDatas.readSnFromQByteArray(byte, snPos2, false, true, 0);
|
|
string sn3 = workThread->snDatas.readSnFromQByteArray(byte, snPos3, false, true, 0);
|
|
string sn4 = workThread->snDatas.readSnFromQByteArray(byte, snPos4, false, true, 0);
|
|
///////////将数据发往图片等待模块/////////////
|
|
|
|
detData* data1_1 = dController.insertDetData("camera1-1", "camera1-1-Thread", sn1, 0);
|
|
threadlist[0]->takeImg(data1_1->timeCode, MyThread::normal, "", data1_1, "", 0);
|
|
threadlist[1]->takeImg(data1_1->timeCode, MyThread::normal, "", data1_1, "", 1);
|
|
detData* data1_2 = dController.insertDetData("camera1-2", "camera1-2-Thread", sn1, 2);
|
|
threadlist[2]->takeImg(data1_2->timeCode, MyThread::normal, "", data1_2, "", 0);
|
|
threadlist[3]->takeImg(data1_2->timeCode, MyThread::normal, "", data1_2, "", 1);
|
|
detData* data1_3 = dController.insertDetData("camera1-3", "camera1-3-Thread", sn1, 4);
|
|
threadlist[4]->takeImg(data1_3->timeCode, MyThread::normal, "", data1_3, "", 0);
|
|
threadlist[5]->takeImg(data1_3->timeCode, MyThread::normal, "", data1_3, "", 1);
|
|
|
|
detData* data2_1 = dController.insertDetData("camera2-1", "camera2-1-Thread", sn2, 6);
|
|
threadlist[6]->takeImg(data2_1->timeCode, MyThread::normal, "", data2_1, "", 0);
|
|
threadlist[7]->takeImg(data2_1->timeCode, MyThread::normal, "", data2_1, "", 1);
|
|
detData* data2_2 = dController.insertDetData("camera2-2", "camera2-2-Thread", sn2, 8);
|
|
threadlist[8]->takeImg(data2_2->timeCode, MyThread::normal, "", data2_2, "", 0);
|
|
threadlist[9]->takeImg(data2_2->timeCode, MyThread::normal, "", data2_2, "", 1);
|
|
detData* data2_3 = dController.insertDetData("camera2-3", "camera2-3-Thread", sn2, 10);
|
|
threadlist[10]->takeImg(data2_3->timeCode, MyThread::normal, "", data2_3, "", 0);
|
|
threadlist[11]->takeImg(data2_3->timeCode, MyThread::normal, "", data2_3, "", 1);
|
|
|
|
detData* data3_1 = dController.insertDetData("camera3-1", "camera3-1-Thread", sn3, 12);
|
|
threadlist[12]->takeImg(data3_1->timeCode, MyThread::normal, "", data3_1, "", 0);
|
|
threadlist[13]->takeImg(data3_1->timeCode, MyThread::normal, "", data3_1, "", 1);
|
|
detData* data3_2 = dController.insertDetData("camera3-2", "camera3-2-Thread", sn3, 14);
|
|
threadlist[14]->takeImg(data3_2->timeCode, MyThread::normal, "", data3_2, "", 0);
|
|
threadlist[15]->takeImg(data3_2->timeCode, MyThread::normal, "", data3_2, "", 1);
|
|
detData* data3_3 = dController.insertDetData("camera3-3", "camera3-3-Thread", sn3, 16);
|
|
threadlist[16]->takeImg(data3_3->timeCode, MyThread::normal, "", data3_3, "", 0);
|
|
threadlist[17]->takeImg(data3_3->timeCode, MyThread::normal, "", data3_3, "", 1);
|
|
|
|
detData* data4_1 = dController.insertDetData("camera4-1", "camera4-1-Thread", sn4, 18);
|
|
threadlist[18]->takeImg(data4_1->timeCode, MyThread::normal, "", data4_1, "", 0);
|
|
threadlist[19]->takeImg(data4_1->timeCode, MyThread::normal, "", data4_1, "", 1);
|
|
detData* data4_2 = dController.insertDetData("camera4-2", "camera4-2-Thread", sn4, 20);
|
|
threadlist[20]->takeImg(data4_2->timeCode, MyThread::normal, "", data4_2, "", 0);
|
|
threadlist[21]->takeImg(data4_2->timeCode, MyThread::normal, "", data4_2, "", 1);
|
|
detData* data4_3 = dController.insertDetData("camera4-3", "camera4-3-Thread", sn4, 22);
|
|
threadlist[22]->takeImg(data4_3->timeCode, MyThread::normal, "", data4_3, "", 0);
|
|
threadlist[23]->takeImg(data4_3->timeCode, MyThread::normal, "", data4_3, "", 1);
|
|
#if 1
|
|
//查不到SN,送到snWaittingVec继续查询
|
|
if (!sn1.compare(snErrorsnError))
|
|
{
|
|
workThread->snDatas.snWaittingVec.push_back({ data1_1->timeCode ,data1_1->SNcode,snPos1 });
|
|
workThread->snDatas.snWaittingVec.push_back({ data1_2->timeCode ,data1_2->SNcode,snPos1 });
|
|
workThread->snDatas.snWaittingVec.push_back({ data1_3->timeCode ,data1_3->SNcode,snPos1 });
|
|
|
|
}
|
|
if (!sn2.compare(snErrorsnError))
|
|
{
|
|
workThread->snDatas.snWaittingVec.push_back({ data2_1->timeCode ,data2_1->SNcode,snPos2 });
|
|
workThread->snDatas.snWaittingVec.push_back({ data2_2->timeCode ,data2_2->SNcode,snPos2 });
|
|
workThread->snDatas.snWaittingVec.push_back({ data2_3->timeCode ,data2_3->SNcode,snPos2 });
|
|
}
|
|
if (!sn3.compare(snErrorsnError))
|
|
{
|
|
workThread->snDatas.snWaittingVec.push_back({ data3_1->timeCode ,data3_1->SNcode,snPos3 });
|
|
workThread->snDatas.snWaittingVec.push_back({ data3_2->timeCode ,data3_2->SNcode,snPos3 });
|
|
workThread->snDatas.snWaittingVec.push_back({ data3_3->timeCode ,data3_3->SNcode,snPos3 });
|
|
}
|
|
if (!sn3.compare(snErrorsnError))
|
|
{
|
|
workThread->snDatas.snWaittingVec.push_back({ data4_1->timeCode ,data4_1->SNcode,snPos4 });
|
|
workThread->snDatas.snWaittingVec.push_back({ data4_2->timeCode ,data4_2->SNcode,snPos4 });
|
|
workThread->snDatas.snWaittingVec.push_back({ data4_3->timeCode ,data4_3->SNcode,snPos4 });
|
|
}
|
|
#endif
|
|
workThread->addTask(data1_1);
|
|
workThread->addTask(data1_2);
|
|
workThread->addTask(data1_3);
|
|
workThread->addTask(data2_1);
|
|
workThread->addTask(data2_2);
|
|
workThread->addTask(data2_3);
|
|
workThread->addTask(data3_1);
|
|
workThread->addTask(data3_2);
|
|
workThread->addTask(data3_3);
|
|
workThread->addTask(data4_1);
|
|
workThread->addTask(data4_2);
|
|
workThread->addTask(data4_3);
|
|
}
|
|
/// <summary>
|
|
/// 目前只负责检测fins信号,拍照和传递数据到等待队列
|
|
/// </summary>
|
|
/// <param name="byte">从reciveCommond传入，从fins(JSON->finstcp_readAllCmd)读取的数据</param>
|
|
void MyIoThread::decodeCameraCMD(QByteArray byte)
|
|
{
|
|
if ( byte.isEmpty() )
|
|
return;
|
|
//////////////////////////////////////////////
|
|
if (checkTrigger(7200, 1, byte) == true)//第一次
|
|
{
|
|
bridge.back.sendFinsMsg("write_DM7200_0");//触发信号清零
|
|
bridge.back.sendFinsMsg("write_DM7201_1");//开始检测信号
|
|
qDebug() << "[ Station 10 ] " << QString::fromUtf8("后段测外形拍照1开始信号!");
|
|
_24CameraTrigger(0, byte);//相机触发及发送到检测线程
|
|
bridge.back.sendFinsMsg("write_DM7202_1");//拍照结束信号
|
|
}
|
|
else if (checkTrigger(7206, 1, byte) == true)//第二次
|
|
{
|
|
bridge.back.sendFinsMsg("write_DM7206_0");//触发信号清零
|
|
bridge.back.sendFinsMsg("write_DM7201_1");//开始检测信号
|
|
qDebug() << "[ Station 10 ] " << QString::fromUtf8("后段测外形拍照2开始信号!");
|
|
_24CameraTrigger(1, byte);//相机触发及发送到检测线程
|
|
bridge.back.sendFinsMsg("write_DM7202_1");//拍照结束信号
|
|
}
|
|
///////////////////////////////////
|
|
if (checkTrigger(7205, 1, byte) == true)//汇总
|
|
{
|
|
bridge.back.sendFinsMsg("write_DM7205_0");
|
|
///////////将数据请求发往算法线程/////////////
|
|
string SN=workThread->snDatas.readSnFromQByteArray(byte, 7400, -1, false, true, 0);//读SN码
|
|
string SN2 = workThread->snDatas.readSnFromQByteArray(byte, 7440, -1, false, true, 0);//读SN码2
|
|
string SN3 = workThread->snDatas.readSnFromQByteArray(byte, 7480, -1, false, true, 0);//读SN码3
|
|
string SN4 = workThread->snDatas.readSnFromQByteArray(byte, 7520, -1, false, true, 0);//读SN码4
|
|
string SN5 = workThread->snDatas.readSnFromQByteArray(byte, 7560, -1, false, true, 0);//读SN码5
|
|
string SN6 = workThread->snDatas.readSnFromQByteArray(byte, 7600, -1, false, true, 0);//读SN码6
|
|
string SN7 = workThread->snDatas.readSnFromQByteArray(byte, 7640, -1, false, true, 0);//读SN码7
|
|
string SN8 = workThread->snDatas.readSnFromQByteArray(byte, 7680, -1, false, true, 0);//读SN码8
|
|
/////////发送//////////////
|
|
requestSummary(SN,0);
|
|
requestSummary(SN2,2);
|
|
requestSummary(SN3,4);
|
|
requestSummary(SN4,6);
|
|
requestSummary(SN5,8);
|
|
requestSummary(SN6,10);
|
|
requestSummary(SN7,12);
|
|
requestSummary(SN8,14);
|
|
}
|
|
|
|
}
|
|
void MyIoThread::requestSummary(std::string SN,int offset)
|
|
{
|
|
qDebug() << "汇总请求 SN:" << QString::fromStdString(SN);
|
|
cout << "summarry SN:" << SN << endl;
|
|
sqlDataStruct sqlData = workThread->sql->selectData(SN, 0);//请求数据库
|
|
bool isOK = true;
|
|
if (sqlData.dataVec.size() == 0)
|
|
{
|
|
for (auto data : bridge.back.json.summaryData.datas)
|
|
{
|
|
//QString messageBase = QString::fromStdString("write_DM" + to_string(data.second.toInt() + offset) + "_");
|
|
QString messageBase = QString::fromStdString("writeInt_DM" + to_string(data.second.toInt() + offset) + "_");
|
|
bridge.back.sendFinsMsg(messageBase + "123456"); // "空"
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (auto data : sqlData.dataVec) {
|
|
QThread::msleep(10);
|
|
auto it = bridge.back.json.summaryData.datas.find(QString::fromStdString(data.dataName));
|
|
if (it != bridge.back.json.summaryData.datas.end()) {
|
|
std::string messageBase = "writeInt_DM" + to_string(it->second.toInt()+offset) + "_";
|
|
std::string messageBase2 = "write_DM" + to_string(it->second.toInt() + offset) + "_";
|
|
if (!data.valueText.compare("NULL") || data.valueText.empty()) {
|
|
bridge.back.sendFinsMsg(QString::fromStdString(messageBase2 + "-1")); // "空"
|
|
std::cout << data.dataName << " empty" << "SN" << SN << endl;//
|
|
}
|
|
else {
|
|
int value = stoi(data.valueText);
|
|
if (value < 0)
|
|
value = -value;
|
|
if (value < 10)
|
|
{
|
|
string finsSend(messageBase2 + std::to_string(value));
|
|
bridge.back.sendFinsMsg(QString::fromStdString(finsSend));
|
|
}
|
|
else
|
|
{
|
|
string finsSend(messageBase + std::to_string(value));
|
|
bridge.back.sendFinsMsg(QString::fromStdString(finsSend));
|
|
}
|
|
if (stoi(data.valueText) == 2)
|
|
isOK = false;
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
writeToDataSheetCSV(isOK);
|
|
}
|
|
// 防重入
|
|
void MyIoThread::checkReentrySign(QVector<int> vec_value)
|
|
{
|
|
for( int i = 0; i < vector_camera_signal_pack_ptr.size(); i++)
|
|
{
|
|
QJsonArray trigger_camera_startpos = vector_camera_signal_pack_ptr.at(i)->trigger_camera_startpos;
|
|
for ( int val = 0; val < trigger_camera_startpos.size(); val++ )
|
|
{
|
|
QString trigger_startpos = trigger_camera_startpos.at(val).toString();
|
|
QString m_startpos = trigger_startpos.split("_")[0];
|
|
QString m_value = trigger_startpos.split("_")[1];
|
|
int trigger_index = m_startpos.mid(3,m_startpos.length()-3).toInt();
|
|
if(trigger_index < 0)
|
|
{
|
|
qCritical() << "[Error] " << " value is error! m_startpos:" << m_startpos;
|
|
}
|
|
else if( vec_value.size() > trigger_index )
|
|
{
|
|
if ( vec_value.at(trigger_index) == 0 )
|
|
{
|
|
// qDebug() << __FUNCTION__ << " line:" << " 00000 camera_reentry_sign:" << vector_camera_signal_pack_ptr.at(i)->camera_reentry_sign;
|
|
vector_camera_signal_pack_ptr.at(i)->camera_reentry_sign = 0; // 赋值为0
|
|
// qDebug() << __FUNCTION__ << " line:" << " 11111 camera_reentry_sign:" << vector_camera_signal_pack_ptr.at(i)->camera_reentry_sign;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void MyIoThread::checkTriggerCamera(QVector<int> vec_value)
|
|
{
|
|
for( int i = 0; i < vector_camera_signal_pack_ptr.size(); i++)
|
|
{
|
|
QString camera_key = vector_camera_signal_pack_ptr.at(i)->trigger_camera_name;
|
|
QJsonArray trigger_camera_startpos = vector_camera_signal_pack_ptr.at(i)->trigger_camera_startpos;
|
|
QJsonArray plc_feedback_msg = vector_camera_signal_pack_ptr.at(i)->plc_feedback_msg; // 反馈信号包
|
|
for ( int val = 0; val < trigger_camera_startpos.size(); val++ )
|
|
{
|
|
QString trigger_startpos = trigger_camera_startpos.at(val).toString();
|
|
QString m_startpos = trigger_startpos.split("_")[0];
|
|
QString m_value = trigger_startpos.split("_")[1];
|
|
int trigger_index = m_startpos.mid(3,m_startpos.length()-3).toInt();
|
|
if(trigger_index < 0)
|
|
{
|
|
qCritical() << "[Error] " << " value is error! m_startpos:" << m_startpos;
|
|
}
|
|
else if ( vec_value.size() > trigger_index )
|
|
{
|
|
if ( vec_value.at(trigger_index) == m_value.toInt() && vector_camera_signal_pack_ptr.at(i)->camera_reentry_sign == 0 )
|
|
{
|
|
vector_camera_signal_pack_ptr.at(i)->camera_reentry_sign = 1; // 放重入 赋值为1
|
|
if(vector_camera_signal_pack_ptr.at(i)->clear_camera_startpos_flag == "true")
|
|
{
|
|
// 写清除当前信号 修改
|
|
if ( checkCameraTriggerLastPos(camera_key,trigger_startpos) )
|
|
{
|
|
QString clear_signal = trigger_startpos.split("_")[0];
|
|
clear_signal = "write_" + clear_signal + "_0";
|
|
QByteArray m_byte = clear_signal.toUtf8();
|
|
if ( !bridge.back.sendFinsMsg(m_byte) )
|
|
{
|
|
qCritical() << "[Error] " << " finstcp_ptr reciveData error! ";
|
|
return;
|
|
}
|
|
|
|
// 写入反馈信号
|
|
QString trigger_startpos_signal = trigger_startpos.split("_")[0];
|
|
for ( auto iii = 0; iii < plc_feedback_msg.size(); iii++ )
|
|
{
|
|
QStringList plc_feedback_msg_list = plc_feedback_msg.at(iii).toString().split("_");
|
|
if(plc_feedback_msg_list.size() != 4)
|
|
{
|
|
qWarning() << "[Error] " << " plc_feedback_msg_list num is error! plc_feedback_msg_list num:" << plc_feedback_msg_list.length();
|
|
}
|
|
else
|
|
{
|
|
if ( plc_feedback_msg_list.contains(trigger_startpos_signal) )
|
|
{
|
|
// 发送反馈信号
|
|
QString feedback_signal_type = plc_feedback_msg_list.at(1);
|
|
QString feedback_signal_pos = plc_feedback_msg_list.at(2);
|
|
QString feedback_signal_value = plc_feedback_msg_list.at(3);
|
|
QString send_msg = feedback_signal_type + "_" + feedback_signal_pos + "_" + feedback_signal_value;
|
|
QByteArray send_byte = send_msg.toUtf8();
|
|
if ( !bridge.back.sendFinsMsg(send_byte) )
|
|
{
|
|
qCritical() << "[Error] " << " finstcp_ptr reciveData error! ";
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// 写反馈信号
|
|
QString clear_plc_data_msg = vector_camera_signal_pack_ptr.at(i)->clear_plc_data_msg;
|
|
QByteArray m_byte = clear_plc_data_msg.toUtf8();
|
|
if ( !bridge.back.sendFinsMsg(m_byte) )
|
|
{
|
|
qCritical() << "[Error] " << " finstcp_ptr reciveData error! ";
|
|
return;
|
|
}
|
|
}
|
|
|
|
// 添加被触发的相机名称
|
|
QString trigger_camera_name = vector_camera_signal_pack_ptr.at(i)->trigger_camera_name;
|
|
if ( !trigger_camera_name.isEmpty() )
|
|
{
|
|
QByteArray camera_Byte = trigger_camera_name.toUtf8();
|
|
IoCommondPack.append(camera_Byte);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool MyIoThread::checkCameraTriggerLastPos ( QString camera_key,QString camera_trigger_pos)
|
|
{
|
|
// qDebug() << " ------------------------------- checkCameraTriggerLastPos camera_key:" << camera_key << " camera_trigger_pos:" << camera_trigger_pos;
|
|
int camera_index = 0;
|
|
for ( int i = 0; i < m_cameralist.size(); i++ )
|
|
{
|
|
QJsonObject m_obj = m_cameralist.at(i).toObject();
|
|
QString camera_key = m_obj.value("key").toString();
|
|
QJsonArray trigger_camera_startpos = m_obj.value("trigger_camera_startpos").toArray();
|
|
for ( int val = 0; val < trigger_camera_startpos.size(); val++ )
|
|
{
|
|
QString trigger_pos = trigger_camera_startpos.at(val).toString();
|
|
if ( camera_trigger_pos == trigger_pos )
|
|
{
|
|
camera_index = i;
|
|
// qDebug() << " ------------- camera_index:" << camera_index ;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
QJsonObject m_obj = m_cameralist.at(camera_index).toObject();
|
|
QString m_key = m_obj.value("key").toString();
|
|
// qDebug() << " ------------- camera_key:" << camera_key << " ----------- m_key:" << m_key;
|
|
if( camera_key == m_key )
|
|
{
|
|
return true;
|
|
}
|
|
return false;;
|
|
}
|
|
|
|
void MyIoThread::setReadAndWritePlcCmd( QJsonObject readArray, QJsonObject writeArray)
|
|
{
|
|
readPlcCmd = readArray;
|
|
writePlcCmd = writeArray;
|
|
}
|
|
|
|
void MyIoThread::setCameraIndexMap( QMap<QString, int> cameraIndexMap)
|
|
{
|
|
m_StationCameraIndexMap = cameraIndexMap;
|
|
m_StationCameraIndexMap.detach();
|
|
}
|
|
|
|
void MyIoThread::clearPlcData(QVector<int> vec_value )
|
|
{
|
|
for ( int i = 0; i < vector_camera_signal_pack_ptr.size(); i++ )
|
|
{
|
|
QString read_clear_plc_startpos = vector_camera_signal_pack_ptr.at(i)->read_clear_plc_startpos;
|
|
QString read_clear_plc_value = vector_camera_signal_pack_ptr.at(i)->read_clear_plc_value;
|
|
QString clear_plc_data_msg = vector_camera_signal_pack_ptr.at(i)->clear_plc_data_msg;
|
|
int trigger_index = read_clear_plc_startpos.mid(3,read_clear_plc_startpos.length()-3).toInt();
|
|
if ( trigger_index < 0 )
|
|
{
|
|
qCritical() << "[Error] " << " value is error! read_clear_plc_startpos:" << read_clear_plc_startpos;
|
|
}
|
|
else if( vec_value.size() > trigger_index )
|
|
{
|
|
if ( vec_value.at(trigger_index) == read_clear_plc_value.toInt() )
|
|
{
|
|
// 所有位归零
|
|
if(!clear_plc_data_msg.isEmpty())
|
|
{
|
|
QByteArray mm_byte = clear_plc_data_msg.toUtf8(); // 0-9
|
|
if ( !bridge.back.sendFinsMsg(mm_byte) )
|
|
{
|
|
qCritical() << "[Error] " << " finstcp_ptr reciveData error!";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*************************读取io包******************************/
|
|
ReadPackThread::~ReadPackThread()
|
|
{
|
|
runflag = true;
|
|
exit();
|
|
wait(1);
|
|
qDebug() << "[INFO] " << "ReadPackThread delete success! " ;
|
|
}
|
|
|
|
void ReadPackThread::run()
|
|
{
|
|
while (true)
|
|
{
|
|
if(runflag)
|
|
{
|
|
return;
|
|
}
|
|
|
|
while (!IoCommondPack.isEmpty())
|
|
{
|
|
QMutexLocker locker ( m_mutex );
|
|
QByteArray byte = IoCommondPack.dequeue();
|
|
QString cameraName = QString(byte);
|
|
}
|
|
QThread::msleep(1);
|
|
}
|
|
}
|
|
|
|
bool ReadPackThread::runModule(QString cameraName)
|
|
{
|
|
// qDebug() << __FUNCTION__ << " line:" << __LINE__ << " cameraName:" << cameraName << " threadlist size:" << threadlist.size();
|
|
try
|
|
{
|
|
for ( int i = 0; i < threadlist.size();i++ )
|
|
{
|
|
QString name = threadlist.at(i)->getName();
|
|
if ( name == cameraName )
|
|
{
|
|
threadlist.at(i)->start();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch ( QString ev )
|
|
{
|
|
qCritical() << "[Error] " << " ev:" << ev;
|
|
}
|
|
return true;
|
|
}
|
|
///////////////////DEBUG////////////////////////////////
|