1053 lines
24 KiB
C++
1053 lines
24 KiB
C++
#include "hd_finstcp_module.h"
|
|
#include "qcoreapplication.h"
|
|
|
|
static QQueue<QByteArray> WritePLCPack;
|
|
static QQueue<QByteArray> ReadPack;
|
|
static QQueue<QByteArray> ReadPLCPack;
|
|
|
|
QByteArray readResult = "";
|
|
QMutex* r_Mutex = new QMutex();
|
|
QMutex* write_Mutex = new QMutex();
|
|
QMutex* read_Mutex = new QMutex();
|
|
QMutex* recive_Mutex = new QMutex();
|
|
|
|
Hd_FinsTcp_module* create()
|
|
{
|
|
qDebug() << "[INFO] " << "Hd_FinsTcp_module create success!";
|
|
return new Hd_FinsTcp_module;
|
|
}
|
|
|
|
void destory(Hd_FinsTcp_module* ptr)
|
|
{
|
|
if (ptr)
|
|
{
|
|
delete ptr;
|
|
ptr = nullptr;
|
|
}
|
|
qDebug() << "[INFO] " << " Hd_FinsTcp_module destory success!";
|
|
}
|
|
|
|
// 可传递ushort 类型的值 和-1
|
|
QString Hd_FinsTcp_module::UShortToHex(int num)
|
|
{
|
|
if (num == -1)
|
|
{
|
|
return "FF FF";
|
|
}
|
|
|
|
QString result = QString::number(num, 16);
|
|
if (result.size() == 1)
|
|
{
|
|
result = "00 0" + result;
|
|
}
|
|
if (result.size() == 2)
|
|
{
|
|
result = "00 " + result;
|
|
}
|
|
if (result.size() == 3)
|
|
{
|
|
result = "0" + result;
|
|
result.insert(2, " ");
|
|
}
|
|
if (result.size() == 4)
|
|
{
|
|
result.insert(2, " ");
|
|
}
|
|
return result;
|
|
}
|
|
// 可传递short类型的正负值
|
|
QString Hd_FinsTcp_module::ShortToHex(int value)
|
|
{
|
|
QString result = QString::number(value, 16);
|
|
|
|
result = result.right(4);
|
|
|
|
if (result.size() == 1)
|
|
{
|
|
result = "000" + result;
|
|
}
|
|
if (result.size() == 2)
|
|
{
|
|
result = "00" + result;
|
|
}
|
|
if (result.size() == 3)
|
|
{
|
|
result = "0" + result;
|
|
}
|
|
|
|
QString m_data1 = result.mid(0, 2);
|
|
QString m_data2 = result.mid(2, 2);
|
|
|
|
result = m_data1 + " " + m_data2;
|
|
|
|
return result;
|
|
}
|
|
QString Hd_FinsTcp_module::IntToHex(int value)
|
|
{
|
|
QString result = QString::number(value, 16);
|
|
|
|
result = result.right(8);
|
|
|
|
if (result.size() == 1)
|
|
{
|
|
result = "0000000" + result;
|
|
}
|
|
else if (result.size() == 2)
|
|
{
|
|
result = "000000" + result;
|
|
}
|
|
else if (result.size() == 3)
|
|
{
|
|
result = "00000" + result;
|
|
}
|
|
else if (result.size() == 4)
|
|
{
|
|
result = "0000" + result;
|
|
}
|
|
else if (result.size() == 5)
|
|
{
|
|
result = "000" + result;
|
|
}
|
|
else if (result.size() == 6)
|
|
{
|
|
result = "00" + result;
|
|
}
|
|
else if (result.size() == 7)
|
|
{
|
|
result = "0" + result;
|
|
}
|
|
QString m_data1 = result.mid(0, 2);
|
|
QString m_data2 = result.mid(2, 2);
|
|
QString m_data3 = result.mid(4, 2);
|
|
QString m_data4 = result.mid(6, 2);
|
|
result = m_data1 + " " + m_data2 + " " + m_data3 + " " + m_data4;
|
|
|
|
return result;
|
|
}
|
|
Hd_FinsTcp_module::Hd_FinsTcp_module()
|
|
{
|
|
m_Mutex = new QMutex;
|
|
m_Thread = new MyThread(this);
|
|
m_Thread->setMutexLock(m_Mutex);
|
|
}
|
|
|
|
Hd_FinsTcp_module::~Hd_FinsTcp_module()
|
|
{
|
|
m_Thread->setRunStop();
|
|
m_Thread->wait();
|
|
m_Thread->quit();
|
|
if (m_Thread)
|
|
{
|
|
qDebug() << "[INFO] "<< "~m_Thread()";
|
|
delete m_Thread;
|
|
m_Thread = nullptr;
|
|
}
|
|
|
|
qDebug() << "[INFO] " << "~Hd_FinsTcp_module success!";
|
|
}
|
|
|
|
bool Hd_FinsTcp_module::sendData(std::vector<cv::Mat>& vec_mat, QByteArray& data)
|
|
{
|
|
Q_UNUSED(vec_mat);
|
|
|
|
/*if (ReadPack.isEmpty())
|
|
return true;*/
|
|
|
|
// 发送数据包
|
|
/*QMutexLocker locker(m_Mutex);
|
|
QByteArray m_byte = ReadPack.dequeue();*/
|
|
QByteArray m_byte = "";
|
|
|
|
int times = 0;
|
|
while (m_byte == "")
|
|
{
|
|
times++;
|
|
if (times > 2000)
|
|
{
|
|
qDebug() << "[TCP] " << "fansTcp readCmd fail";
|
|
return false;
|
|
}
|
|
r_Mutex->lock();
|
|
m_byte = readResult;
|
|
if (m_byte != "")
|
|
readResult = "";
|
|
r_Mutex->unlock();
|
|
Sleep(5);
|
|
}
|
|
|
|
m_byte.remove(0, 30);
|
|
data = m_byte;
|
|
//qDebug() << __FUNCTION__ << "line:" << __LINE__ << "result:" << data.size();
|
|
return true;
|
|
}
|
|
|
|
bool Hd_FinsTcp_module::reciveData(std::vector<cv::Mat>& vec_mat, QByteArray& data)
|
|
{
|
|
Q_UNUSED(vec_mat);
|
|
recive_Mutex->lock();
|
|
QString str = QString(data);
|
|
if (data.isEmpty())
|
|
{
|
|
qCritical() << "[TCP] " << " str is null";
|
|
recive_Mutex->unlock();
|
|
return false;
|
|
}
|
|
|
|
QList<QByteArray> m_list = data.split('_');
|
|
//init_192.168.1.50_9600_20",
|
|
QString m_value;
|
|
QString m_ip_lastpos;
|
|
QString commond = m_list.at(0);
|
|
if (commond == "init")
|
|
{
|
|
m_IP = m_list.at(1);
|
|
m_host = m_list.at(2);
|
|
socketIp = m_list.at(3);
|
|
QStringList list = m_IP.split(".");
|
|
if (list.size() == 4)
|
|
{
|
|
m_ip_lastpos = list.at(3);
|
|
}
|
|
if (!m_ip_lastpos.isEmpty())
|
|
{
|
|
if (m_ip_lastpos.toInt() < 10)
|
|
{
|
|
hex_ip_lastpos = "1" + m_ip_lastpos;
|
|
}
|
|
else
|
|
{
|
|
hex_ip_lastpos = QString::number(m_ip_lastpos.toInt(), 16);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
qCritical() << "[TCP] " << " m_ip_lastpos is null! ";
|
|
recive_Mutex->unlock();
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//"finstcp_readAllCmd": "readAll_DM110_100",
|
|
m_posName = m_list.at(1);
|
|
m_pos = m_list.at(1);
|
|
m_pos = m_pos.split("DM")[1]; // 获取点位
|
|
m_value = m_list.at(2);
|
|
if (m_pos.isEmpty() || m_value.isEmpty())
|
|
{
|
|
qCritical() << "[TCP] " << "decode Commond null!";
|
|
recive_Mutex->unlock();
|
|
return false;
|
|
}
|
|
}
|
|
//qDebug() << __FUNCTION__ << " line:" << __LINE__ << " m_posName:" << m_posName << " m_pos:" << m_pos << " m_value:" << m_value;
|
|
if (commond.isEmpty())
|
|
{
|
|
qCritical() << "[TCP] " << "decode Commond null!";
|
|
recive_Mutex->unlock();
|
|
return false;
|
|
}
|
|
if (commond == "init")
|
|
{
|
|
|
|
}
|
|
else if (commond == "writeHeart")
|
|
{
|
|
writeCommond(m_pos, m_value);
|
|
//qDebug() << "[TCP] " << str << endl;
|
|
}
|
|
else if (commond == "write")
|
|
{
|
|
writeCommond(m_pos, m_value);
|
|
qDebug() << "[TCP] " << str << endl;
|
|
}
|
|
else if (commond == "writeInt")
|
|
{
|
|
writeCommondInt(m_pos, m_value);
|
|
qDebug() << "[TCP] " << str << endl;
|
|
}
|
|
else if (commond == "read")
|
|
{
|
|
//设置延迟时间
|
|
Sleep(m_sleepTime);
|
|
readCommond(m_pos, m_value);
|
|
}
|
|
else if (commond == "readAll")
|
|
{
|
|
//设置延迟时间
|
|
//Sleep(m_sleepTime);
|
|
readAllCommond(m_pos, m_value);
|
|
}
|
|
else if (commond == "writeAll") // 格式 writeAll_DM100_3_101 // 起始位置+数量+值
|
|
{
|
|
QVector<int> vec_value;
|
|
QString vecValue = m_list.at(3);
|
|
|
|
QStringList valueList = vecValue.split(",");
|
|
for (size_t i = 0; i < valueList.size(); i++)
|
|
{
|
|
vec_value.push_back(valueList[i].toInt());
|
|
}
|
|
writeAllCommond(m_pos, m_value, vec_value); //m_value 为数量
|
|
|
|
qDebug() << "[TCP] " << str << endl;
|
|
}
|
|
else if (commond == "writeString")
|
|
{
|
|
QString vecValue = m_list.at(3);
|
|
writeStringCommond(m_pos, m_value, vecValue);
|
|
qDebug() << "[TCP] " << str << endl;
|
|
}
|
|
else if (commond == "writeResult")
|
|
{
|
|
QVector<QString> vec_value;
|
|
QByteArray vecByte = m_list.at(3);
|
|
qDebug() << "[TCP] " << str << endl;
|
|
if (!decodeWriteResult(vecByte, vec_value))
|
|
{
|
|
qCritical() << "[TCP] " << " decodeWriteResult is error!";
|
|
recive_Mutex->unlock();
|
|
return false;
|
|
}
|
|
if (!writeResultCommond(m_pos, m_value, vec_value))
|
|
{
|
|
recive_Mutex->unlock();
|
|
return false;
|
|
}
|
|
//qDebug() << __FUNCTION__ << " line:" << __LINE__ << " ----<>----- vec_value:" << vec_value;
|
|
}
|
|
|
|
recive_Mutex->unlock();
|
|
return true;
|
|
}
|
|
|
|
bool Hd_FinsTcp_module::decodeWriteResult(QByteArray byte, QVector<QString>& vec_ret)
|
|
{
|
|
try
|
|
{
|
|
if (byte.isEmpty())
|
|
{
|
|
qCritical() << "[TCP] " << " byte is null!";
|
|
return false;
|
|
}
|
|
while (!byte.isEmpty())
|
|
{
|
|
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);
|
|
// qDebug() << __FUNCTION__ << " line:" << __LINE__ << " mm_data:" << mm_data;
|
|
vec_ret.append(QString::fromUtf8(mm_data));
|
|
byte.remove(0, len);
|
|
}
|
|
}
|
|
catch (QString ev) {
|
|
qCritical() << "[Error] " << " ev:" << ev;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool Hd_FinsTcp_module::tcpServer(QByteArray cmd, QByteArray& m_resultPack)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
void Hd_FinsTcp_module::decodePack(QByteArray resultArray)
|
|
{
|
|
|
|
}
|
|
|
|
bool Hd_FinsTcp_module::initParas(QByteArray& data)
|
|
{
|
|
qDebug() << "[TCP] " << "DATA: " << data;
|
|
if (data.isEmpty())
|
|
{
|
|
qWarning()<< "[TCP] " << " data is null!";
|
|
}
|
|
else
|
|
{
|
|
QString initDat = QString::fromUtf8(data);
|
|
QStringList list = initDat.split("_");
|
|
if (list.size() < 3)
|
|
{
|
|
qCritical() << "[TCP] " << " list size error :" << list.size();
|
|
return false;
|
|
}
|
|
QString sleepname = list.at(0);
|
|
QString sleepvalue = list.at(1);
|
|
QString readname = list.at(2);
|
|
QString readvalue = list.at(3);
|
|
QString write_type = list.at(4);
|
|
QString write_value = list.at(5);
|
|
|
|
// 设置收发数据的类型
|
|
if (!write_value.isEmpty())
|
|
m_writeType = write_value;
|
|
|
|
qDebug() << "[TCP] " << "list: " << list;
|
|
setSleepTimeAndReadNum(sleepvalue.toInt(), readvalue.toInt());
|
|
m_Thread->setSocketIp(socketIp);
|
|
if (!m_Thread->setIpAndPort(m_IP, m_host))
|
|
{
|
|
qDebug() << "[TCP] " << "m_IP:" << m_IP << " m_host:" << m_host << " connectToHost failed!";
|
|
return false;
|
|
}
|
|
}
|
|
|
|
//开启读PLC数据的客户端
|
|
//开启socket
|
|
m_Thread->start();
|
|
Sleep(500);
|
|
|
|
if (!m_Thread->getInitSuccessFlag())
|
|
{
|
|
qCritical() << "[TCP] " << "TCP init failed!";
|
|
return false;
|
|
}
|
|
|
|
// 发送握手指令
|
|
QString ret = "46 49 4E 53 00 00 00 0C 00 00 00 00 00 00 00 00 00 00 00 " + socketIp;
|
|
QByteArray array = QByteArray::fromHex(ret.toLatin1()); //使用16进制格式
|
|
WritePLCPack.append(array);
|
|
|
|
// 开启线程循环
|
|
m_Thread->start();
|
|
return true;
|
|
}
|
|
|
|
bool Hd_FinsTcp_module::run()
|
|
{
|
|
//qDebug() << "[info] " << __FUNCTION__ << " line:" << __LINE__ << " success!";
|
|
return true;
|
|
}
|
|
|
|
void Hd_FinsTcp_module::setSleepTimeAndReadNum(int time, int num)
|
|
{
|
|
m_sleepTime = time;
|
|
m_Thread->setReadPackValue(num);
|
|
}
|
|
//110 100
|
|
bool Hd_FinsTcp_module::writeCommond(QString DM, QString Num)
|
|
{
|
|
try
|
|
{
|
|
if (DM.isEmpty() || Num.isEmpty())
|
|
{
|
|
qCritical() << "[TCP] " << " DM or Num is null!";
|
|
return false;
|
|
}
|
|
|
|
int mm_pos = DM.toInt();
|
|
int mm_value = Num.toInt();
|
|
mm_pos = abs(mm_pos);
|
|
// mm_value = abs(mm_value);
|
|
DM = UShortToHex(mm_pos);
|
|
Num = ShortToHex(mm_value);
|
|
QString ret = "46 49 4E 53 00 00 00 1C 00 00 00 02 00 00 00 00 80 00 02 00 33 00 00 "+ socketIp +" 00 00 01 02 82 " + DM + "00 00 01 " + Num;
|
|
QByteArray array = QByteArray::fromHex(ret.toLatin1()); // 使用 16 进制格式
|
|
write_Mutex->lock();
|
|
if(!WritePLCPack.contains(array))
|
|
WritePLCPack.append(array);
|
|
write_Mutex->unlock();
|
|
}
|
|
catch (QString ev)
|
|
{
|
|
qDebug() << "[TCP] " << "writeCommond failed!" << Num;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool Hd_FinsTcp_module::writeCommondInt(QString DM, QString Num)
|
|
{
|
|
try
|
|
{
|
|
if (DM.isEmpty() || Num.isEmpty())
|
|
{
|
|
qCritical() << "[TCP] " << " DM or Num is null!";
|
|
return false;
|
|
}
|
|
|
|
int mm_pos = DM.toInt();
|
|
int mm_value = Num.toInt();
|
|
mm_pos = abs(mm_pos);
|
|
// mm_value = abs(mm_value);
|
|
DM = UShortToHex(mm_pos);
|
|
QString DM2 = UShortToHex(mm_pos+1);
|
|
QString intToHexRes = IntToHex(mm_value);
|
|
Num = intToHexRes.mid(0,5);
|
|
QString Num2 = intToHexRes.mid(6, 5);
|
|
QString ret = "46 49 4E 53 00 00 00 1C 00 00 00 02 00 00 00 00 80 00 02 00 33 00 00 " + socketIp + " 00 00 01 02 82 " + DM + " 00 00 01 " + Num2;
|
|
QString ret2 = "46 49 4E 53 00 00 00 1C 00 00 00 02 00 00 00 00 80 00 02 00 33 00 00 " + socketIp + " 00 00 01 02 82 " + DM2 + " 00 00 01 " + Num;
|
|
QByteArray array = QByteArray::fromHex(ret.toLatin1()); // 使用 16 进制格式
|
|
QByteArray array2 = QByteArray::fromHex(ret2.toLatin1()); // 使用 16 进制格式
|
|
write_Mutex->lock();
|
|
if (!WritePLCPack.contains(array))
|
|
WritePLCPack.append(array);
|
|
if (!WritePLCPack.contains(array2))
|
|
WritePLCPack.append(array2);
|
|
write_Mutex->unlock();
|
|
}
|
|
catch (QString ev)
|
|
{
|
|
qDebug() << "[TCP] " << "writeCommond failed!" << Num;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// 备注：不能写入 -1
|
|
// 写入起始地址 + 写入数量 + 写入的值
|
|
bool Hd_FinsTcp_module::writeAllCommond(QString DM, QString write_Num, QVector<int> vec_value)
|
|
{
|
|
try
|
|
{
|
|
if (DM.isEmpty() || write_Num.isEmpty())
|
|
{
|
|
qCritical() << "[TCP] " << " DM or Num is null!";
|
|
return false;
|
|
}
|
|
|
|
int m_len = 26 + vec_value.size() * 2;
|
|
|
|
int mm_pos = DM.toInt();
|
|
int mm_Num = write_Num.toInt();
|
|
mm_pos = abs(mm_pos);
|
|
mm_Num = abs(mm_Num);
|
|
DM = UShortToHex(mm_pos); // 位置
|
|
write_Num = UShortToHex(mm_Num); // 写入数量
|
|
QString string_len = UShortToHex(m_len);
|
|
qDebug() << "[TCP] " << " write_Num:" << write_Num;
|
|
|
|
QString write_data = "46 49 4E 53 00 00 " + string_len + " 00 00 00 02 00 00 00 00 80 00 02 00 32 00 00 "+ socketIp+" 00 00 01 02 82 " + DM + " 00 " + write_Num;
|
|
|
|
// 写入值拼凑
|
|
QString send_value;
|
|
for (int i = 0; i < vec_value.size(); i++)
|
|
{
|
|
int value = abs(vec_value.at(i));
|
|
send_value += " " + UShortToHex(value); // 写入的每一位的值
|
|
}
|
|
|
|
write_data += send_value;
|
|
|
|
qDebug() << "[TCP] " << " write_data:" << write_data;
|
|
QByteArray array = QByteArray::fromHex(write_data.toLatin1()); // 使用 16 进制格式
|
|
write_Mutex->lock();
|
|
WritePLCPack.append(array);
|
|
write_Mutex->unlock();
|
|
}
|
|
catch (QString ev)
|
|
{
|
|
qDebug() << "[TCP] " << "writeCommond failed!" << write_Num;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
//写入起始地址 + 写入数量 + 写入的值
|
|
bool Hd_FinsTcp_module::writeResultCommond(QString DM, QString write_Num, QVector<QString> vec_value)
|
|
{
|
|
try
|
|
{
|
|
if (vec_value.isEmpty())
|
|
{
|
|
qCritical() << "[TCP] " << " vec_value is null!";
|
|
return false;
|
|
}
|
|
int m_len = 26 + vec_value.size() * 2;
|
|
int mm_pos = DM.toInt(); // 起始位
|
|
int mm_Num = write_Num.toInt(); // 写入数量
|
|
mm_pos = abs(mm_pos);
|
|
mm_Num = abs(mm_Num);
|
|
DM = UShortToHex(mm_pos); // 位置
|
|
write_Num = UShortToHex(mm_Num); // 写入数量
|
|
QString string_len = UShortToHex(m_len);
|
|
|
|
QString write_data = "46 49 4E 53 00 00 " + string_len + " 00 00 00 02 00 00 00 00 80 00 02 00 33 00 00 " + socketIp + " 00 00 01 02 82 " + DM + " 00 " + write_Num;
|
|
|
|
qDebug() << "[TCP] " << " m_writeType:" << m_writeType << " write_data:" << write_data;
|
|
|
|
//写入值拼凑
|
|
QString send_value;
|
|
for (int i = 0; i < vec_value.size(); i++)
|
|
{
|
|
int value = vec_value.at(i).toInt();
|
|
//根据发的类型来判断
|
|
if (m_writeType == "short")
|
|
{
|
|
send_value += " " + ShortToHex(value); // 写入的每一位的值
|
|
}
|
|
else
|
|
{
|
|
send_value += " " + UShortToHex(value); // 写入的每一位的值
|
|
}
|
|
}
|
|
|
|
write_data += send_value;
|
|
QByteArray m_byte = QByteArray::fromHex(write_data.toLatin1()); // 使用 16 进制格式
|
|
|
|
QString str;
|
|
for (int i = 0; i < m_byte.size(); i++)
|
|
{
|
|
str += QString("%1").arg((unsigned char)m_byte.at(i), 2, 16, QLatin1Char('0')) + ' ';
|
|
}
|
|
qDebug() << "[TCP] " << " writeData str:" << str;
|
|
write_Mutex->lock();
|
|
WritePLCPack.append(m_byte);
|
|
write_Mutex->unlock();
|
|
}
|
|
catch (QString ev) {
|
|
qCritical() << "[TCP] " << " writeCommond failed!" << write_Num;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool Hd_FinsTcp_module::writeStringCommond(QString DM, QString write_num, QString vec_value)
|
|
{
|
|
try
|
|
{
|
|
if (DM.isEmpty())
|
|
{
|
|
qCritical() << "[TCP] " << " DM or Num is null!";
|
|
return false;
|
|
}
|
|
|
|
int m_len = 26 + vec_value.size();
|
|
|
|
int mm_pos = DM.toInt();
|
|
int mm_Num;
|
|
mm_pos = abs(mm_pos);
|
|
mm_Num = abs(write_num.toInt());
|
|
DM = UShortToHex(mm_pos); //位置
|
|
QString write_Num = UShortToHex(mm_Num); //写入数量
|
|
QString string_len = UShortToHex(m_len);
|
|
qDebug() << "[TCP] " << " write_Num:" << write_Num;
|
|
|
|
QString write_data = "46 49 4E 53 00 00 " + string_len + " 00 00 00 02 00 00 00 00 80 00 02 00 33 00 00 " + socketIp + " 00 00 01 02 82 " + DM + " 00 " + write_Num;
|
|
|
|
//写入值拼凑
|
|
QByteArray strArray;
|
|
if (vec_value.size() == 1)
|
|
{
|
|
strArray = "00 " + vec_value.toUtf8().toHex().toUpper();
|
|
}
|
|
else
|
|
{
|
|
if (vec_value.size() % 2 == 0)
|
|
{
|
|
for (int i = 0; i < vec_value.size(); i++)
|
|
{
|
|
QByteArray strArray1;
|
|
strArray1 = QString(vec_value.at(i)).toUtf8().toHex().toUpper();
|
|
if (i == vec_value.size() - 1)
|
|
strArray = strArray + strArray1;
|
|
else
|
|
strArray = strArray + strArray1 + " ";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < vec_value.size(); i++)
|
|
{
|
|
QByteArray strArray1;
|
|
strArray1 = QString(vec_value.at(i)).toUtf8().toHex().toUpper();
|
|
if (i == vec_value.size() - 1)
|
|
{
|
|
strArray = strArray + "00 " + strArray1;
|
|
|
|
}
|
|
else
|
|
{
|
|
strArray = strArray + strArray1 + " ";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
write_data = write_data + " " + strArray;
|
|
|
|
qDebug() << "[TCP] " << " write_data:" << write_data;
|
|
QByteArray array = QByteArray::fromHex(write_data.toLatin1()); // 使用 16 进制格式
|
|
|
|
write_Mutex->lock();
|
|
WritePLCPack.append(array);
|
|
write_Mutex->unlock();
|
|
|
|
}
|
|
catch (QString ev)
|
|
{
|
|
qDebug() << "[TCP] " << "writeCommond failed!";
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool Hd_FinsTcp_module::readCommond(QString DM, QString Num)
|
|
{
|
|
try
|
|
{
|
|
if (DM.isEmpty() || Num.isEmpty())
|
|
{
|
|
qCritical() << "[TCP] " << " DM or Num is null!";
|
|
return false;
|
|
}
|
|
|
|
int mm_pos = DM.toInt();
|
|
int mm_value = Num.toInt();
|
|
|
|
DM = UShortToHex(mm_pos);
|
|
Num = UShortToHex(mm_value);
|
|
QString ret = "46 49 4E 53 00 00 00 1A 00 00 00 02 00 00 00 00 80 00 02 00 32 00 00 " + socketIp + " 00 00 01 01 82 " + DM + " 00 " + Num;
|
|
QByteArray array = QByteArray::fromHex(ret.toLatin1()); // 使用16 进制格式
|
|
//WritePack.append(array);
|
|
/*QByteArray resultArray;
|
|
bool isConed = tcpServer(array, resultArray);
|
|
decodePack(resultArray);*/
|
|
bool ifHas = false;
|
|
for (int i = 0; i < ReadPLCPack.size(); i++)
|
|
{
|
|
if (ReadPLCPack[i] == array)ifHas = true;
|
|
}
|
|
if (ifHas == false)
|
|
{
|
|
read_Mutex->lock();
|
|
ReadPLCPack.append(array);
|
|
read_Mutex->unlock();
|
|
}
|
|
}
|
|
catch (QString ev)
|
|
{
|
|
qDebug() << "[TCP] " << "readCommond failed!" << Num;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool Hd_FinsTcp_module::readAllCommond(QString DM, QString Num)
|
|
{
|
|
try
|
|
{
|
|
if (DM.isEmpty() || Num.isEmpty())
|
|
{
|
|
qCritical() << "[TCP] " << " DM or Num is null!";
|
|
return false;
|
|
}
|
|
|
|
int mm_pos = DM.toInt();
|
|
int mm_value = Num.toInt();
|
|
|
|
DM = UShortToHex(mm_pos);
|
|
Num = UShortToHex(mm_value);
|
|
//QString ret = "46 49 4E 53 00 00 00 1A 00 00 00 02 00 00 00 00 80 00 02 00 32 00 00 " + socketIp + " 00 00 01 01 82 " + DM + " 00 " + Num;
|
|
QString ret = "46 49 4E 53 00 00 00 1A 00 00 00 02 00 00 00 00 80 00 02 00 33 00 00 " + socketIp + " 00 00 01 01 82 " + DM + " 00 " + Num;
|
|
std::string str = ret.toStdString();
|
|
std::string str2 = socketIp.toStdString();
|
|
QByteArray array = QByteArray::fromHex(ret.toLatin1()); // 使用16 进制格式
|
|
//WritePack.append(array);
|
|
/*QByteArray resultArray;
|
|
bool isConed = tcpServer(array, resultArray);
|
|
decodePack(resultArray);*/
|
|
|
|
/* bool ifHas = false;
|
|
for (int i = 0; i < ReadPLCPack.size(); i++)
|
|
{
|
|
if (ReadPLCPack[i] == array)ifHas = true;
|
|
}
|
|
if (ifHas == false)
|
|
{
|
|
|
|
}*/
|
|
read_Mutex->lock();
|
|
if (!ReadPLCPack.contains(array))
|
|
ReadPLCPack.append(array);
|
|
read_Mutex->unlock();
|
|
Sleep(m_sleepTime);
|
|
}
|
|
catch (QString ev)
|
|
{
|
|
qDebug() << "[TCP] " << "readCommond failed!" << Num;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
MyThread::~MyThread()
|
|
{
|
|
if (tcpsocket) {
|
|
tcpsocket->deleteLater();
|
|
} // tcp通信的socket
|
|
if (m_mutex_lock) {
|
|
delete m_mutex_lock;
|
|
m_mutex_lock = nullptr;
|
|
}
|
|
|
|
}
|
|
|
|
void MyThread::closeSocket()
|
|
{
|
|
if (tcpsocket)
|
|
{
|
|
tcpsocket->abort();
|
|
tcpsocket->disconnect();
|
|
tcpsocket->close();
|
|
|
|
}
|
|
qDebug() << "[TCP] " << " Hd_FinsTcp_module close tcpsocket success!";
|
|
}
|
|
|
|
bool MyThread::disReconnects()
|
|
{
|
|
bool reResult = false;
|
|
if (!(tcpsocket->state() == QAbstractSocket::ConnectedState))
|
|
{
|
|
qCritical() << "[TCP] " << QString("tcp disconected");
|
|
for (int i = 0; i < 5; i++)
|
|
{
|
|
tcpsocket->bind(QHostAddress::Any);
|
|
tcpsocket->connectToHost(m_IP, m_Port.toInt());
|
|
if (tcpsocket->waitForConnected(5))
|
|
{
|
|
qWarning() << "[TCP] " << " You have connected to the server again";
|
|
|
|
// 发送握手指令
|
|
QString ret = "46 49 4E 53 00 00 00 0C 00 00 00 00 00 00 00 00 00 00 00 " + socketIp;
|
|
QByteArray array = QByteArray::fromHex(ret.toLatin1()); //使用16进制格式
|
|
tcpsocket->write(array);
|
|
tcpsocket->waitForReadyRead();
|
|
QByteArray readData = tcpsocket->readAll();
|
|
reResult = true;
|
|
break;
|
|
}
|
|
Sleep(200);
|
|
}
|
|
|
|
}
|
|
else
|
|
reResult = true;
|
|
return reResult;
|
|
}
|
|
|
|
//线程 run 中初始化 socket
|
|
void MyThread::run()
|
|
{
|
|
qDebug() << "[TCP] " << " run start";
|
|
|
|
if (init_flag == 0)
|
|
{
|
|
tcpsocket = new QTcpSocket;
|
|
tcpsocket->bind(QHostAddress::Any);
|
|
tcpsocket->abort();
|
|
|
|
if (tcpsocket->state() == QAbstractSocket::ConnectedState)
|
|
{
|
|
qCritical() << "[TCP] " << QString("[%1:%2] server has been linked").arg(m_IP).arg(m_Port);
|
|
return;
|
|
}
|
|
|
|
tcpsocket->connectToHost(m_IP, m_Port.toInt());
|
|
if (tcpsocket->waitForConnected(5))
|
|
{
|
|
qWarning() << "[TCP] " << " You have connected to the server ";
|
|
}
|
|
else
|
|
{
|
|
qWarning() << "[TCP] " << " Server not connected";
|
|
init_success = false;
|
|
return;
|
|
}
|
|
init_flag = 1;
|
|
qDebug() << "[TCP] " << " run end ----------";
|
|
}
|
|
else if (init_flag == 1)
|
|
{
|
|
//开启wile循环来读写
|
|
while (true)
|
|
{
|
|
if (init_flag == 2) {
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
writeSocketData();
|
|
Sleep(2);
|
|
}
|
|
}
|
|
if (init_flag == 2) {
|
|
|
|
QThread::msleep(10);
|
|
closeSocket();
|
|
}
|
|
|
|
|
|
}
|
|
|
|
bool MyThread::setIpAndPort(QString ip, QString port)
|
|
{
|
|
m_IP = ip;
|
|
m_Port = port;
|
|
return true;
|
|
}
|
|
|
|
//读取数据
|
|
void MyThread::readSocketData()
|
|
{
|
|
qApp->processEvents();
|
|
QByteArray readData = tcpsocket->readAll();
|
|
|
|
if (readData.isEmpty())
|
|
return;
|
|
|
|
reciveData.append(readData);
|
|
decodePack();
|
|
}
|
|
|
|
void MyThread::decodePack()
|
|
{
|
|
QString str;
|
|
//解析包头
|
|
QByteArray head_byte = reciveData.mid(0, 2); // 46 49 转十进制 17993
|
|
QByteArray head1_byte = reciveData.mid(2, 2); // 4E 53 转十进制 20051
|
|
|
|
//转十进制判断包头
|
|
if (head_byte.toHex() == "4649" && head1_byte.toHex() == "4e53")
|
|
{
|
|
QByteArray len_byte = reciveData.mid(6, 2); //长度 commond 长度 转十进制
|
|
|
|
QString msg = len_byte.toHex();
|
|
int number_len = msg.toInt(NULL, 16);
|
|
|
|
if (number_len == 16) //十六进制的10 十进制为16 备注为握手回复信息 长度为24字节
|
|
{
|
|
reciveData.remove(0, 24);
|
|
}
|
|
else if (number_len == m_readPackValue) // 示例: 接受50个数据包的长度 为 122 ，加包头一起为 130
|
|
{
|
|
QByteArray byte = reciveData.mid(0, m_readPackValue + 8);
|
|
r_Mutex->lock();
|
|
readResult = byte;
|
|
r_Mutex->unlock();
|
|
reciveData.remove(0, m_readPackValue + 8);
|
|
}
|
|
else
|
|
{
|
|
reciveData.remove(0, number_len + 8); // 其他包暂时丢弃,待定处理
|
|
}
|
|
}
|
|
}
|
|
|
|
void MyThread::writeSocketData()
|
|
{
|
|
|
|
if (WritePLCPack.isEmpty() && ReadPLCPack.isEmpty())
|
|
return;
|
|
//写PLC
|
|
if (!WritePLCPack.isEmpty())
|
|
{
|
|
|
|
for (int i = 0; i < WritePLCPack.size(); i++)
|
|
{
|
|
write_Mutex->lock();
|
|
if (!(WritePLCPack.size() > 0))
|
|
{
|
|
write_Mutex->unlock();
|
|
break;
|
|
}
|
|
QByteArray byte = WritePLCPack.dequeue(); // 取出包
|
|
write_Mutex->unlock();
|
|
if (!disReconnects())
|
|
{
|
|
qDebug() << "[TCP] " << QString("The server cannot be connected. Check the network port");
|
|
init_flag = 2;
|
|
return;
|
|
}
|
|
tcpsocket->write(byte);
|
|
tcpsocket->waitForBytesWritten(3000);
|
|
tcpsocket->flush();
|
|
|
|
int timeOut = 0;
|
|
int readIndex1 = 0;
|
|
QByteArray m_resultPack;
|
|
while (1)
|
|
{
|
|
timeOut++;
|
|
if (timeOut > 500)break;
|
|
Sleep(1);
|
|
|
|
qApp->processEvents();
|
|
//if (!tcpsocket->isReadable())continue;
|
|
if (!disReconnects())
|
|
{
|
|
qDebug() << "[TCP] " << QString("The server cannot be connected. Check the network port");
|
|
init_flag = 2;
|
|
return;
|
|
}
|
|
QByteArray readData = tcpsocket->readAll();
|
|
m_resultPack.append(readData);
|
|
if (!m_resultPack.isEmpty())
|
|
readIndex1++;
|
|
else
|
|
continue;
|
|
if (readIndex1 == 2)
|
|
{
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// 读PLC
|
|
|
|
read_Mutex->lock();
|
|
if (ReadPLCPack.isEmpty())
|
|
{
|
|
read_Mutex->unlock();
|
|
return;
|
|
}
|
|
QByteArray byte = ReadPLCPack.dequeue(); // 取出包
|
|
|
|
read_Mutex->unlock();
|
|
if (!disReconnects())
|
|
{
|
|
qDebug() << "[TCP] " << QString("The server cannot be connected. Check the network port");
|
|
init_flag = 2;
|
|
return;
|
|
}
|
|
tcpsocket->write(byte);
|
|
tcpsocket->waitForBytesWritten(3000);
|
|
tcpsocket->flush();
|
|
|
|
int timeOut = 0;
|
|
while (1)
|
|
{
|
|
timeOut++;
|
|
if (timeOut > 500)break;
|
|
Sleep(1);
|
|
if (!disReconnects())
|
|
{
|
|
qDebug() << "[TCP] " << QString("The server cannot be connected. Check the network port");
|
|
init_flag = 2;
|
|
return;
|
|
}
|
|
tcpsocket->waitForReadyRead();
|
|
QByteArray readData = tcpsocket->readAll();
|
|
|
|
if (readData.isEmpty())
|
|
continue;
|
|
|
|
reciveData.append(readData);
|
|
decodePack();
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
void MyThread::setReadPackValue(int value)
|
|
{
|
|
m_readPackValue = 22 + value * 2;
|
|
}
|