#include "hd_finstcp_module.h"
#include "qcoreapplication.h"

static QQueue<QByteArray> WritePLCPack;
static QQueue<QByteArray> ReadPack;
static QQueue<QByteArray> ReadPLCPack;

QByteArray readResult = "";
QByteArray readResult2 = "";
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!";
}
static QString 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;
}
// 可传递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();
		if (readPackValue < 1000)
		{
			m_byte = readResult;
			if (m_byte != "")
			{
				readResult = "";
				
			}
		}
		else
		{
			if (readResult != "" && readResult2 != "")
			{
				
				m_byte = readResult;
				m_byte += readResult2;
			}
			if (m_byte != "")
			{
				readResult = "";
				readResult2 = "";
			}
		}
		r_Mutex->unlock();
		Sleep(5);
	}
	m_byte.remove(0, 30);
	if (readPackValue >= 1000)
		m_byte.remove(m_byte.size()/2-15, 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());
		readPackValue = 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;
	//QString ret = "46 49 4E 53 00 00 00 0C 00 00 00 00 00 00 00 00 00 00 00 00" ;
	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 33 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 33 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();
		if (mm_value < 1000)
		{
			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 33 00 00 " + socketIp + " 00 00 01 01 82 " + DM + " 00 " + Num;
			std::string str = ret.toStdString();
			QByteArray array = QByteArray::fromHex(ret.toLatin1());	 // 使用16 进制格式
			//WritePack.append(array);
			read_Mutex->lock();
			if (!ReadPLCPack.contains(array))
				ReadPLCPack.append(array);
			read_Mutex->unlock();
			Sleep(m_sleepTime);
		}
		else
		{
			int numHalf = mm_value / 2;
			QString DMHalf = UShortToHex(mm_pos);
			QString NumHalf = UShortToHex(numHalf);

			DM = UShortToHex(mm_pos+ numHalf);
			Num = UShortToHex(mm_value- numHalf);
			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 " + DMHalf + " 00 " + NumHalf;
			QString ret2 = "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();
			QByteArray array = QByteArray::fromHex(ret.toLatin1());	 // 使用16 进制格式
			QByteArray array2 = QByteArray::fromHex(ret2.toLatin1());	 // 使用16 进制格式
			//WritePack.append(array);
			read_Mutex->lock();
			if (!ReadPLCPack.contains(array))
				ReadPLCPack.append(array);
			if (!ReadPLCPack.contains(array2))
				ReadPLCPack.append(array2);
			read_Mutex->unlock();
			Sleep(m_sleepTime);
		}
	}
	catch (QString ev)
	{
		qDebug() << "[TCP] " << "readCommond failed!" << Num;
	}
	return true;
}

MyThread::~MyThread()
{
	if (tcpsocket) {
		closeSocket();
		tcpsocket->deleteLater();
	}   // tcp通信的socket
	if (m_mutex_lock) {
		delete m_mutex_lock;
		m_mutex_lock = nullptr;
	} 
	tcpsocket->abort();
	delete tcpsocket;
}

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())
		{
			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&& m_readPackValue<2021)  // 示例: 接受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 if (number_len == (m_readPackValue)/2+11 && m_readPackValue >= 2021&& readResult=="")  // 示例: 接受50个数据包的长度  为 122 ，加包头一起为 130
		{
			QByteArray byte = reciveData.mid(0, (m_readPackValue) / 2 + 11 + 8);
			r_Mutex->lock();
			readResult = byte;
			r_Mutex->unlock();
			reciveData.remove(0, (m_readPackValue) / 2 + 11 + 8);
		}
		else if (number_len == m_readPackValue-(m_readPackValue) / 2 + 11&& m_readPackValue >= 2021)  // 示例: 接受50个数据包的长度  为 122 ，加包头一起为 130
		{
			QByteArray byte = reciveData.mid(0, m_readPackValue - (m_readPackValue) / 2 + 11 + 8);
			r_Mutex->lock();
			readResult2 = byte;
			r_Mutex->unlock();
			reciveData.remove(0, m_readPackValue - (m_readPackValue) / 2 + 11 + 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;
				QThread::msleep(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())
				{
					//if (handShakeMsg == true)
					//{
					//	unsigned short hex=readData.toHex()[19];
					//	socketIp = QString::number(readData.toHex()[19]);
					//	std::string abc = socketIp.toStdString();
					//}
					//else
					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 > 2000)break;
		QThread::msleep (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;
}