init files

BaseModules/Hd_SocketModule_PLC/CMakeLists.txt

@@ -0,0 +1,66 @@
+# 获取获取当前目录名
+get_filename_component(CURRENT_FOLDER ${CMAKE_CURRENT_SOURCE_DIR} NAME)
+string(TIMESTAMP RUN_TIME)
+
+message( " model start : " ${CURRENT_FOLDER}:${RUN_TIME})
+
+STRING(REPLACE "/EHsc" "/EHa" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+STRING(REPLACE "/RTC1" "" CMAKE_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_DEBUG})
+SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /AI${CMAKE_CURRENT_SOURCE_DIR} /clr")
+
+message( " model start : " ${CURRENT_FOLDER}:${RUN_TIME})
+
+set(DLL_NAMES "opencv") #对应的总cmakeList.txt的target
+foreach(child ${DLL_NAMES})         
+    LIST(APPEND ENV_INCLUDE ${${child}_include})
+    LIST(APPEND ENV_LIB ${${child}_lib})
+    LIST(APPEND ENV_TARGET ${${child}_target_link})         
+endforeach()
+message("   ENV_INCLUDE : " ${ENV_INCLUDE} )
+message("   ENV_LIB : " ${ENV_LIB} )
+message("   ENV_TARGET : " ${ENV_TARGET} )
+include_directories(
+    ${ENV_INCLUDE}
+    )
+
+link_directories (
+    ${ENV_LIB}
+    )
+
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
+SET(CMAKE_CXX_STANDARD 11)
+SET(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+set(CMAKE_AUTOMOC ON)
+SET(CMAKE_AUTOUIC ON)
+set(CMAKE_AUTORCC ON)
+
+FILE(GLOB HEAD_FILES "./*.h" )
+FILE(GLOB SRC_FILES "./*.cpp")
+FILE(GLOB UI_FILES "./*.ui")
+
+#find_package(Qt5 COMPONENTS Core REQUIRED)
+find_package(QT NAMES Qt6 Qt5 COMPONENTS Core REQUIRED)
+find_package(Qt${QT_VERSION_MAJOR} COMPONENTS Core Network REQUIRED)
+
+add_library(${CURRENT_FOLDER} SHARED
+    ${HEAD_FILES}
+    ${SRC_FILES}
+    ${UI_FILES}
+    )
+
+set_target_properties(${CURRENT_FOLDER} PROPERTIES LINKER_LANGUAGE C
+                 RUNTIME_OUTPUT_DIRECTORY  ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}  
+                 LIBRARY_OUTPUT_DIRECTORY  ${CMAKE_LIBRARY_OUTPUT_DIRECTORY} 
+                 ARCHIVE_OUTPUT_DIRECTORY  ${CMAKE_ARCHIVE_OUTPUT_DIRECTORY}      
+)
+
+target_link_libraries(${CURRENT_FOLDER} PRIVATE
+
+    ${ENV_TARGET}
+    Qt${QT_VERSION_MAJOR}::Core
+    Qt${QT_VERSION_MAJOR}::Network
+)
+
+string(TIMESTAMP RUN_TIME)
+message( " model end : " ${CURRENT_FOLDER}:${RUN_TIME})

BaseModules/Hd_SocketModule_PLC/Hd_PLC_Adaptor.cpp

@@ -0,0 +1,83 @@
+#include "Hd_PLC_Adaptor.h"
+
+#include <QDebug>
+
+Hd_PLC_Adaptor* create(int type)
+{
+	qDebug() << "Hd_PLC_Adaptor create success!";
+	return new Hd_PLC_Adaptor(type, nullptr);
+}
+
+void destory(Hd_PLC_Adaptor* ptr)
+{
+	if (ptr != nullptr)
+	{
+		delete ptr;
+		ptr = nullptr;
+	}
+	qDebug() << "Hd_PLC_Adaptor destory success!";
+}
+
+Hd_PLC_Adaptor::Hd_PLC_Adaptor(int type, QObject* parent) : PbGlobalObject(type, parent)
+{
+	famliy = PGOFAMLIY::PLC;
+	m_plc = new Hd_SocketModule_PLC(type, parent);
+}
+
+Hd_PLC_Adaptor::~Hd_PLC_Adaptor()
+{
+	if (m_plc)
+	{
+		m_plc->deleteLater();
+		m_plc = nullptr;
+	}
+}
+
+bool Hd_PLC_Adaptor::setParameter(const QMap<QString, QString>& param)
+{
+	if (m_plc == nullptr)
+		return false;
+
+	return m_plc->setParameter(param);
+}
+
+QMap<QString, QString> Hd_PLC_Adaptor::parameters()
+{
+	if (m_plc == nullptr)
+		return QMap<QString, QString>();
+
+	return m_plc->parameters();
+}
+
+bool Hd_PLC_Adaptor::init()
+{
+	if (m_plc == nullptr)
+		return false;
+
+	return  m_plc->init();
+}
+
+bool Hd_PLC_Adaptor::setData(const vector<cv::Mat>& mat, const QStringList& data)
+{
+	UNREFERENCED_PARAMETER(mat);
+	if (m_plc == nullptr)
+		return false;
+
+	if (data.isEmpty() || data.size() != 1)//每次只处理一条命令
+		return false;
+
+	return m_plc->setData(data[0].toLocal8Bit());
+}
+
+bool Hd_PLC_Adaptor::data(std::vector<cv::Mat>& mat, QStringList& data)
+{
+	UNREFERENCED_PARAMETER(mat);
+	if (m_plc == nullptr)
+		return false;
+
+	QByteArray bytes;
+	bool res = m_plc->data(bytes);
+	if (res)
+		data.append(bytes.toHex());
+	return res;
+}

BaseModules/Hd_SocketModule_PLC/Hd_PLC_Adaptor.h

@@ -0,0 +1,30 @@
+#pragma once
+#include "pbglobalobject.h"
+#include "Hd_SocketModule_PLC.h"
+
+#pragma execution_character_set("utf-8")
+
+class Hd_PLC_Adaptor : public PbGlobalObject
+{
+	Q_OBJECT
+public:
+	Hd_PLC_Adaptor(int settype, QObject* parent = nullptr);
+	~Hd_PLC_Adaptor();
+
+	virtual bool setParameter(const QMap<QString, QString>& param);
+	virtual QMap<QString, QString> parameters();
+
+	virtual bool init();
+
+	virtual bool setData(const vector<cv::Mat>& mat, const QStringList& data);
+	virtual bool data(std::vector<cv::Mat>& mat, QStringList& data);
+
+private:
+	Hd_SocketModule_PLC* m_plc = nullptr;
+};
+
+extern "C"
+{
+	Q_DECL_EXPORT Hd_PLC_Adaptor* create(int type = -1);
+	Q_DECL_EXPORT void destory(Hd_PLC_Adaptor* ptr);
+}

BaseModules/Hd_SocketModule_PLC/Hd_SocketModule_PLC.cpp

@@ -0,0 +1,622 @@
+#include"Hd_SocketModule_PLC.h"
+#include <QDebug>
+#include <QDateTime>
+#include "pbglobalobject.h"
+
+Hd_SocketModule_PLC::Hd_SocketModule_PLC(int type, QObject* parent) :
+	QObject(parent), m_plcType(type)
+{
+	initUnionGcMembers();
+}
+
+void Hd_SocketModule_PLC::initUnionGcMembers()
+{
+	if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::FinsTcp))
+	{
+		delete (*m_plcImpl.FinsTcp);//托管对象无法判空
+		*m_plcImpl.FinsTcp = gcnew HslCommunication::Profinet::Omron::OmronFinsNet();
+
+		//也可用指针保存，但是使用时要转回原来的类型，略麻烦
+		//gcroot<HslCommunication::Profinet::Omron::OmronFinsNet^>* FinsTcp = new gcroot<HslCommunication::Profinet::Omron::OmronFinsNet^>;
+		//void* plc = static_cast<void*>(FinsTcp);
+		//gcroot<HslCommunication::Profinet::Omron::OmronFinsNet^>* FinsTcp = static_cast<gcroot<HslCommunication::Profinet::Omron::OmronFinsNet^>*>(plc);
+	}
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::ModbusTcp))
+	{
+		delete (*m_plcImpl.ModBusTcp);
+		*m_plcImpl.ModBusTcp = gcnew HslCommunication::ModBus::ModbusTcpNet();
+	}
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::McAsciiTcp))
+	{
+		delete (*m_plcImpl.McAscii);
+		*m_plcImpl.McAscii = gcnew HslCommunication::Profinet::Melsec::MelsecMcAsciiNet();
+	}
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::McA1ETcp))
+	{
+		delete (*m_plcImpl.McA1E);
+		*m_plcImpl.McA1E = gcnew HslCommunication::Profinet::Melsec::MelsecA1ENet();
+	}
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::McBinaryTcp))
+	{
+		delete (*m_plcImpl.McBinary);
+		*m_plcImpl.McBinary = gcnew HslCommunication::Profinet::Melsec::MelsecMcNet();
+	}
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::PanasonicMC))
+	{
+		delete (*m_plcImpl.PanasonicMc);
+		*m_plcImpl.PanasonicMc = gcnew HslCommunication::Profinet::Panasonic::PanasonicMcNet();
+	}
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::InovanceH5UTcp))
+	{
+		delete (*m_plcImpl.InovanceTcp);
+		*m_plcImpl.InovanceTcp = gcnew HslCommunication::Profinet::Inovance::InovanceH5UTcp();
+	}
+
+}
+Hd_SocketModule_PLC::~Hd_SocketModule_PLC()
+{
+	if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::FinsTcp))
+	{
+		delete (*m_plcImpl.FinsTcp);
+		*m_plcImpl.FinsTcp = nullptr;
+
+		delete m_plcImpl.FinsTcp;
+		m_plcImpl.FinsTcp = nullptr;
+	}
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::ModbusTcp))
+	{
+		delete (*m_plcImpl.ModBusTcp);
+		*m_plcImpl.ModBusTcp = nullptr;
+
+		delete m_plcImpl.ModBusTcp;
+		m_plcImpl.ModBusTcp = nullptr;
+	}
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::McAsciiTcp))
+	{
+		delete (*m_plcImpl.McAscii);
+		*m_plcImpl.McAscii = nullptr;
+
+		delete m_plcImpl.McAscii;
+		m_plcImpl.McAscii = nullptr;
+	}
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::McA1ETcp))
+	{
+		delete (*m_plcImpl.McA1E);
+		*m_plcImpl.McA1E = nullptr;
+
+		delete m_plcImpl.McA1E;
+		m_plcImpl.McA1E = nullptr;
+	}
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::McBinaryTcp))
+	{
+		delete (*m_plcImpl.McBinary);
+		*m_plcImpl.McBinary = nullptr;
+
+		delete m_plcImpl.McBinary;
+		m_plcImpl.McBinary = nullptr;
+	}
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::PanasonicMC))
+	{
+		delete (*m_plcImpl.PanasonicMc);
+		*m_plcImpl.PanasonicMc = nullptr;
+
+		delete m_plcImpl.PanasonicMc;
+		m_plcImpl.PanasonicMc = nullptr;
+	}
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::InovanceH5UTcp))
+	{
+		delete (*m_plcImpl.InovanceTcp);
+		*m_plcImpl.InovanceTcp = nullptr;
+
+		delete m_plcImpl.InovanceTcp;
+		m_plcImpl.InovanceTcp = nullptr;
+	}
+	qDebug() << " ~Hd_SocketModule_PLC success!";
+}
+
+bool Hd_SocketModule_PLC::setParameter(const QMap<QString, QString>& param)
+{
+	m_params = param;
+	return true;
+}
+
+QMap<QString, QString> Hd_SocketModule_PLC::parameters()
+{
+	return m_params;
+}
+
+//加载模块dll导出函数，构造类
+bool Hd_SocketModule_PLC::init()
+{
+	System::String^ Code = gcnew System::String("b5f8f9f7-c075-4913-ae6e-d7d2cc6f2de1");
+	if (HslCommunication::Authorization::SetAuthorizationCode(Code))
+		qDebug() << "Register HSLCode Success" << endl;
+	else
+		qDebug() << "Register HSLCode Fail" << endl;
+
+	if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::FinsTcp))
+		return initFinsTcp();
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::ModbusTcp))
+		return initModbusTcp();
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::McAsciiTcp))
+		return initMcAscii();
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::McA1ETcp))
+		return initMcA1E();
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::McBinaryTcp))
+		return initMcBinary();
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::PanasonicMC))
+		return initPanasonicMc();
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::InovanceH5UTcp))
+		return initInovanceTcp();
+	return true;
+}
+
+bool Hd_SocketModule_PLC::setData(const QByteArray& data)
+{
+	if (data.isEmpty())
+	{
+		qCritical() << " data is null";
+		return false;
+	}
+
+	QMutexLocker locker(m_writeMutex);
+	Sleep(m_sleepTime);
+
+	QList<QByteArray> byteList = data.split('_');
+	if (byteList.size() != 4)
+	{
+		qCritical() << data + " size() != 4, command error." << endl;
+		return false;
+	}
+	if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::ModbusTcp))
+		byteList[2] = byteList[2].mid(1, byteList[2].length() - 1);
+	if (byteList[0] == "read")//"read_byte_D3000_300"
+	{
+		auto readFunc = [=]() {
+			System::String^ address = gcnew System::String(byteList[2].toStdString().c_str());
+			HslCommunication::OperateResult<cli::array<unsigned char>^>^ result;
+
+			if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::FinsTcp))
+				result = (*m_plcImpl.FinsTcp)->Read(address, byteList[3].toInt());
+			else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::ModbusTcp))
+				result = (*m_plcImpl.ModBusTcp)->Read(address, byteList[3].toInt());
+			else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::McAsciiTcp))
+				result = (*m_plcImpl.McAscii)->Read(address, byteList[3].toInt());
+			else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::McA1ETcp))
+				result = (*m_plcImpl.McA1E)->Read(address, byteList[3].toInt());
+			else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::McBinaryTcp))
+				result = (*m_plcImpl.McBinary)->Read(address, byteList[3].toInt());
+			else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::PanasonicMC))
+				result = (*m_plcImpl.PanasonicMc)->Read(address, byteList[3].toInt());
+			else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::InovanceH5UTcp))
+				result = (*m_plcImpl.InovanceTcp)->Read(address, byteList[3].toInt());
+			return result;
+			};
+
+		auto readSucFunc = [&](HslCommunication::OperateResult<cli::array<unsigned char>^>^& result) {
+			QByteArray byte;
+			for (int i = 0; i < byteList[3].toInt() * 2; i++)
+				byte.append(result->Content[i]);
+
+			//qDebug() << "read bytes:" << byte;
+			m_readData.append(byte);
+			};
+
+		auto result = readFunc();
+		if (result->IsSuccess)
+		{
+			readSucFunc(result);
+			return true;
+		}
+		qDebug() << data + "read failed" << endl;
+		int retryCount = 3;
+		while (retryCount-- > 0)
+		{
+			closeSocket();
+			initUnionGcMembers();
+			if (!init())//成功
+			{
+				Sleep(m_sleepTime);
+				continue;
+			}
+			auto res = readFunc();
+			if (!res->IsSuccess)
+			{
+				Sleep(m_sleepTime);
+				continue;
+			}
+
+			readSucFunc(res);
+			return true;
+		}
+		return false;
+	}
+	else if (byteList[0] == "write")//例"write_short_D1003_1", "write_short_D1003_1,1,1,1"
+	{
+		if (byteList[1] != "short" && byteList[1] != "float" &&
+			byteList[1] != "double" && byteList[1] != "string")
+			return false;
+
+		QList<QByteArray> valueList = byteList[3].split(',');
+		for (auto val = 0; val < 5; val++)
+		{
+			bool res = false;
+			if (byteList[1] == "short")
+				res = writeShortData(byteList[2], valueList);
+			else if (byteList[1] == "float")
+				res = writeFloatData(byteList[2], valueList);
+			else if (byteList[1] == "double")
+				res = writeDoubleData(byteList[2], valueList);
+			else
+				res = writeStringData(byteList[2], byteList[3]);
+			if (res)
+				break;
+
+			qCritical() << "val: " << val << " write failed!  byteList: " << byteList;
+			m_failedData.enqueue(data);
+			Sleep(m_sleepTime);
+		}
+	}
+
+	return true;
+}
+
+bool Hd_SocketModule_PLC::data(QByteArray& data)
+{
+	QMutexLocker locker(m_readMutex);
+	if (m_readData.isEmpty())
+		data = {};
+	else
+		data.append(m_readData.dequeue());
+	return true;
+}
+
+bool Hd_SocketModule_PLC::initFinsTcp()
+{
+	//"init_ip_port_sA1_dA1_dA2"
+	QStringList init = m_params["init"].split("_");
+	m_sleepTime = m_params["initParams"].split("_")[1].toUInt();
+	if (init[0] != "init" && init.size() != 6)
+	{
+		qDebug() << "init FinsTcp param error" << endl;
+		return false;
+	}
+	(*m_plcImpl.FinsTcp)->IpAddress = gcnew System::String(init[1].toStdString().c_str());
+	(*m_plcImpl.FinsTcp)->Port = init[2].toUInt();
+	(*m_plcImpl.FinsTcp)->DA1 = (unsigned char)(init[4].toUInt());
+	(*m_plcImpl.FinsTcp)->DA2 = (unsigned char)(init[5].toUInt());
+	(*m_plcImpl.FinsTcp)->ConnectTimeOut = 500;//连接超时0.5秒
+	(*m_plcImpl.FinsTcp)->ReceiveTimeOut = 500;//收发超时0.5秒
+	int sa1 = (unsigned char)(init[3].toUInt());
+	int loopCount = 20;
+	while (loopCount > 0)
+	{
+		(*m_plcImpl.FinsTcp)->SA1 = (unsigned char)sa1;
+		if ((*m_plcImpl.FinsTcp)->ConnectServer()->IsSuccess)
+		{
+			qDebug() << "FinsTcp Connect Success! SA1: " << sa1 << endl;
+			return true;
+		}
+
+		--loopCount;
+		++sa1;
+		qCritical() << "FinsTcp Connect failed! SA1: " << sa1 << endl;
+		Sleep(m_sleepTime);
+	}
+	return false;
+}
+
+bool Hd_SocketModule_PLC::initModbusTcp()
+{
+	//"init_ip_port_station"
+	QStringList init = m_params["init"].split("_");
+	m_sleepTime = m_params["initParams"].split("_")[1].toUInt();
+	if (init[0] != "init" && init.size() != 4)
+	{
+		qDebug() << "init Modbus param error" << endl;
+		return false;
+	}
+
+	(*m_plcImpl.ModBusTcp)->IpAddress = gcnew System::String(init[1].toStdString().c_str());
+	(*m_plcImpl.ModBusTcp)->Port = init[2].toUInt();
+	(*m_plcImpl.ModBusTcp)->Station = (unsigned char)init[3].toUInt();
+	//(*m_plcImpl.ModBusTcp)->ConnectTimeOut = 500;//连接超时0.5秒
+	//(*m_plcImpl.ModBusTcp)->ReceiveTimeOut = 500;//收发超时0.5秒
+
+	int loopCount = 20;
+	while (loopCount > 0)
+	{
+		if ((*m_plcImpl.ModBusTcp)->ConnectServer()->IsSuccess)
+		{
+			qDebug() << "ModBusTcp Connect Success!" << endl;
+			return true;
+		}
+
+		qCritical() << "ModBusTcp Connect failed!" << endl;
+		--loopCount;
+		Sleep(m_sleepTime);
+	}
+	return false;
+}
+
+bool Hd_SocketModule_PLC::initMcAscii()
+{
+	//"init_ip_port"
+	QStringList init = m_params["init"].split("_");
+	m_sleepTime = m_params["initParams"].split("_")[1].toUInt();
+	if (init[0] != "init" && init.size() != 3)
+	{
+		qDebug() << "init McAscii param error" << endl;
+		return false;
+	}
+	(*m_plcImpl.McAscii)->IpAddress = gcnew System::String(init[1].toStdString().c_str());
+	(*m_plcImpl.McAscii)->Port = init[2].toUInt();
+	(*m_plcImpl.McAscii)->ConnectTimeOut = 500;//连接超时0.5秒
+	(*m_plcImpl.McAscii)->ReceiveTimeOut = 500;//收发超时0.5秒
+	int loopCount = 20;
+	while (loopCount > 0)
+	{
+		if ((*m_plcImpl.McAscii)->ConnectServer()->IsSuccess)
+		{
+			qDebug() << "McAscii Connect Success!" << endl;
+			return true;
+		}
+
+		qCritical() << "McAscii Connect failed!" << endl;
+		--loopCount;
+		Sleep(m_sleepTime);
+	}
+
+	return false;
+}
+
+bool Hd_SocketModule_PLC::initMcA1E()
+{
+	//"init_ip_port"
+	QStringList init = m_params["init"].split("_");
+	m_sleepTime = m_params["initParams"].split("_")[1].toUInt();
+	if (init[0] != "init" && init.size() != 3)
+	{
+		qDebug() << "init McA1E param error" << endl;
+		return false;
+	}
+
+	(*m_plcImpl.McA1E)->IpAddress = gcnew System::String(init[1].toStdString().c_str());
+	(*m_plcImpl.McA1E)->Port = init[2].toUInt();
+	(*m_plcImpl.McA1E)->ConnectTimeOut = 500;//连接超时0.5秒
+	(*m_plcImpl.McA1E)->ReceiveTimeOut = 500;//收发超时0.5秒
+	int loopCount = 20;
+	while (loopCount > 0)
+	{
+		if ((*m_plcImpl.McA1E)->ConnectServer()->IsSuccess)
+		{
+			qDebug() << "McA1E Connect Success!" << endl;
+			return true;
+		}
+
+		qCritical() << "McA1E Connect failed!" << endl;
+		--loopCount;
+		Sleep(m_sleepTime);
+	}
+
+	return false;
+}
+
+bool Hd_SocketModule_PLC::initMcBinary()
+{
+	//"init_ip_port"
+	QStringList init = m_params["init"].split("_");
+	m_sleepTime = m_params["initParams"].split("_")[1].toUInt();
+	if (init[0] != "init" && init.size() != 3)
+	{
+		qDebug() << "init McBinary param error" << endl;
+		return false;
+	}
+
+	(*m_plcImpl.McBinary)->IpAddress = gcnew System::String(init[1].toStdString().c_str());
+	(*m_plcImpl.McBinary)->Port = init[2].toUInt();
+	(*m_plcImpl.McBinary)->ConnectTimeOut = 500;//连接超时0.5秒
+	(*m_plcImpl.McBinary)->ReceiveTimeOut = 500;//收发超时0.5秒
+	int loopCount = 20;
+	while (loopCount > 0)
+	{
+		if ((*m_plcImpl.McBinary)->ConnectServer()->IsSuccess)
+		{
+			qDebug() << "McBinary Connect Success!" << endl;
+			return true;
+		}
+
+		qCritical() << "McBinary Connect failed!" << endl;
+		--loopCount;
+		Sleep(m_sleepTime);
+	}
+
+	return false;
+}
+
+bool Hd_SocketModule_PLC::initPanasonicMc()
+{
+	//"init_ip_port"
+	QStringList init = m_params["init"].split("_");
+	m_sleepTime = m_params["initParams"].split("_")[1].toUInt();
+	if (init[0] != "init" && init.size() != 3)
+	{
+		qDebug() << "init PanasonicMc param error" << endl;
+		return false;
+	}
+
+	(*m_plcImpl.PanasonicMc)->IpAddress = gcnew System::String(init[1].toStdString().c_str());
+	(*m_plcImpl.PanasonicMc)->Port = init[2].toUInt();
+	(*m_plcImpl.PanasonicMc)->ConnectTimeOut = 500;//连接超时0.5秒
+	(*m_plcImpl.PanasonicMc)->ReceiveTimeOut = 500;//收发超时0.5秒
+	int loopCount = 20;
+	while (loopCount > 0)
+	{
+		if ((*m_plcImpl.PanasonicMc)->ConnectServer()->IsSuccess)
+		{
+			qDebug() << "PanasonicMc Connect Success!" << endl;
+			return true;
+		}
+
+		qCritical() << "PanasonicMc Connect failed!" << endl;
+		--loopCount;
+		Sleep(m_sleepTime);
+	}
+
+	return false;
+}
+
+bool Hd_SocketModule_PLC::initInovanceTcp()
+{
+	//"init_ip_port"
+	QStringList init = m_params["init"].split("_");
+	m_sleepTime = m_params["initParams"].split("_")[1].toUInt();
+	if (init[0] != "init" && init.size() != 3)
+	{
+		qDebug() << "init InovanceTcp param error" << endl;
+		return false;
+	}
+
+	(*m_plcImpl.InovanceTcp)->IpAddress = gcnew System::String(init[1].toStdString().c_str());
+	(*m_plcImpl.InovanceTcp)->Port = init[2].toUInt();
+	(*m_plcImpl.InovanceTcp)->ConnectTimeOut = 500;//连接超时0.5秒
+	(*m_plcImpl.InovanceTcp)->ReceiveTimeOut = 500;//收发超时0.5秒
+	int loopCount = 20;
+	while (loopCount > 0)
+	{
+		if ((*m_plcImpl.InovanceTcp)->ConnectServer()->IsSuccess)
+		{
+			qDebug() << "InovanceTcp Connect Success!" << endl;
+			return true;
+		}
+
+		qCritical() << "InovanceTcp Connect failed!" << endl;
+		--loopCount;
+		Sleep(m_sleepTime);
+	}
+	return false;
+}
+
+bool Hd_SocketModule_PLC::closeSocket()
+{
+	bool res = false;
+	if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::FinsTcp))
+		res = (*m_plcImpl.FinsTcp)->ConnectClose()->IsSuccess;
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::ModbusTcp))
+		res = (*m_plcImpl.ModBusTcp)->ConnectClose()->IsSuccess;
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::McAsciiTcp))
+		res = (*m_plcImpl.McAscii)->ConnectClose()->IsSuccess;
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::McA1ETcp))
+		res = (*m_plcImpl.McA1E)->ConnectClose()->IsSuccess;
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::McBinaryTcp))
+		res = (*m_plcImpl.McBinary)->ConnectClose()->IsSuccess;
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::PanasonicMC))
+		res = (*m_plcImpl.PanasonicMc)->ConnectClose()->IsSuccess;
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::InovanceH5UTcp))
+		res = (*m_plcImpl.InovanceTcp)->ConnectClose()->IsSuccess;
+
+	if (!res)
+		qCritical() << "ConnectClose() failed!";
+	return res;
+}
+
+bool Hd_SocketModule_PLC::writeShortData(const QByteArray& addr, const QList<QByteArray>& data)
+{
+	cli::array<short>^ writeList = gcnew cli::array<short>(data.length());
+	for (int i = 0; i < data.length(); i++)
+		writeList[i] = data[i].toShort();
+
+	System::String^ address = gcnew System::String(addr.toStdString().c_str());
+
+	if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::FinsTcp))
+		return (*m_plcImpl.FinsTcp)->HslCommunication::Core::Net::NetworkDeviceBase::Write(address, writeList)->IsSuccess;
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::ModbusTcp))
+		return (*m_plcImpl.ModBusTcp)->HslCommunication::Core::Net::NetworkDeviceBase::Write(address, writeList)->IsSuccess;
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::McAsciiTcp))
+		return (*m_plcImpl.McAscii)->HslCommunication::Core::Net::NetworkDeviceBase::Write(address, writeList)->IsSuccess;
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::McA1ETcp))
+		return (*m_plcImpl.McA1E)->HslCommunication::Core::Net::NetworkDeviceBase::Write(address, writeList)->IsSuccess;
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::McBinaryTcp))
+		return (*m_plcImpl.McBinary)->HslCommunication::Core::Net::NetworkDeviceBase::Write(address, writeList)->IsSuccess;
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::PanasonicMC))
+		return (*m_plcImpl.PanasonicMc)->HslCommunication::Core::Net::NetworkDeviceBase::Write(address, writeList)->IsSuccess;
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::InovanceH5UTcp))
+		return (*m_plcImpl.InovanceTcp)->HslCommunication::Core::Net::NetworkDeviceBase::Write(address, writeList)->IsSuccess;
+
+	return false;
+}
+
+bool Hd_SocketModule_PLC::writeFloatData(const QByteArray& addr, const QList<QByteArray>& data)
+{
+	cli::array<float>^ writeList = gcnew cli::array<float>(data.length());
+	for (int i = 0; i < data.length(); i++)
+		writeList[i] = data[i].toFloat();
+
+	System::String^ address = gcnew System::String(addr.toStdString().c_str());
+
+	if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::FinsTcp))
+		return (*m_plcImpl.FinsTcp)->HslCommunication::Core::Net::NetworkDeviceBase::Write(address, writeList)->IsSuccess;
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::ModbusTcp))
+		return (*m_plcImpl.ModBusTcp)->HslCommunication::Core::Net::NetworkDeviceBase::Write(address, writeList)->IsSuccess;
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::McAsciiTcp))
+		return (*m_plcImpl.McAscii)->HslCommunication::Core::Net::NetworkDeviceBase::Write(address, writeList)->IsSuccess;
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::McA1ETcp))
+		return (*m_plcImpl.McA1E)->HslCommunication::Core::Net::NetworkDeviceBase::Write(address, writeList)->IsSuccess;
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::McBinaryTcp))
+		return (*m_plcImpl.McBinary)->HslCommunication::Core::Net::NetworkDeviceBase::Write(address, writeList)->IsSuccess;
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::PanasonicMC))
+		return (*m_plcImpl.PanasonicMc)->HslCommunication::Core::Net::NetworkDeviceBase::Write(address, writeList)->IsSuccess;
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::InovanceH5UTcp))
+		return (*m_plcImpl.InovanceTcp)->HslCommunication::Core::Net::NetworkDeviceBase::Write(address, writeList)->IsSuccess;
+
+	return false;
+}
+
+bool Hd_SocketModule_PLC::writeDoubleData(const QByteArray& addr, const QList<QByteArray>& data)
+{
+	cli::array<double>^ writeList = gcnew cli::array<double>(data.length());
+	for (int i = 0; i < data.length(); i++)
+		writeList[i] = data[i].toDouble();
+
+	System::String^ address = gcnew System::String(addr.toStdString().c_str());
+
+	if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::FinsTcp))
+		return (*m_plcImpl.FinsTcp)->HslCommunication::Core::Net::NetworkDeviceBase::Write(address, writeList)->IsSuccess;
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::ModbusTcp))
+		return (*m_plcImpl.ModBusTcp)->HslCommunication::Core::Net::NetworkDeviceBase::Write(address, writeList)->IsSuccess;
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::McAsciiTcp))
+		return (*m_plcImpl.McAscii)->HslCommunication::Core::Net::NetworkDeviceBase::Write(address, writeList)->IsSuccess;
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::McA1ETcp))
+		return (*m_plcImpl.McA1E)->HslCommunication::Core::Net::NetworkDeviceBase::Write(address, writeList)->IsSuccess;
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::McBinaryTcp))
+		return (*m_plcImpl.McBinary)->HslCommunication::Core::Net::NetworkDeviceBase::Write(address, writeList)->IsSuccess;
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::PanasonicMC))
+		return (*m_plcImpl.PanasonicMc)->HslCommunication::Core::Net::NetworkDeviceBase::Write(address, writeList)->IsSuccess;
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::InovanceH5UTcp))
+		return (*m_plcImpl.InovanceTcp)->HslCommunication::Core::Net::NetworkDeviceBase::Write(address, writeList)->IsSuccess;
+
+	return false;
+}
+
+bool Hd_SocketModule_PLC::writeStringData(const QByteArray& addr, const QByteArray& data)
+{
+	System::String^ address = gcnew System::String(addr.toStdString().c_str());
+	System::String^ writeValue = gcnew System::String(data.toStdString().c_str());
+
+	if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::FinsTcp))
+		return (*m_plcImpl.FinsTcp)->HslCommunication::Core::Net::NetworkDeviceBase::Write(address, writeValue)->IsSuccess;
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::ModbusTcp))
+		return (*m_plcImpl.ModBusTcp)->HslCommunication::Core::Net::NetworkDeviceBase::Write(address, writeValue)->IsSuccess;
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::McAsciiTcp))
+		return (*m_plcImpl.McAscii)->HslCommunication::Core::Net::NetworkDeviceBase::Write(address, writeValue)->IsSuccess;
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::McA1ETcp))
+		return (*m_plcImpl.McA1E)->HslCommunication::Core::Net::NetworkDeviceBase::Write(address, writeValue)->IsSuccess;
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::McBinaryTcp))
+		return (*m_plcImpl.McBinary)->HslCommunication::Core::Net::NetworkDeviceBase::Write(address, writeValue)->IsSuccess;
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::PanasonicMC))
+		return (*m_plcImpl.PanasonicMc)->HslCommunication::Core::Net::NetworkDeviceBase::Write(address, writeValue)->IsSuccess;
+	else if (m_plcType == static_cast<int>(PLC_MODULE_TYPE::InovanceH5UTcp))
+		return (*m_plcImpl.InovanceTcp)->HslCommunication::Core::Net::NetworkDeviceBase::Write(address, writeValue)->IsSuccess;
+
+	return false;
+}

BaseModules/Hd_SocketModule_PLC/Hd_SocketModule_PLC.h

@@ -0,0 +1,101 @@
+#ifndef Hd_SocketModule_PLC_H
+#define Hd_SocketModule_PLC_H
+
+#include <QObject>
+#include <QMap>
+#include <QQueue>
+#include <QMutex>
+#include <QByteArray>
+#include <Windows.h>
+#include <msclr/marshal_cppstd.h>
+#using "../../bin/HslCommunication.dll"
+
+#pragma execution_character_set("utf-8")
+
+/*
+PLC通信模块管理类
+*/
+
+class Hd_SocketModule_PLC : public QObject
+{
+	Q_OBJECT
+
+	union PlcImpl
+	{
+		gcroot<HslCommunication::Profinet::Omron::OmronFinsNet^>* FinsTcp;
+		gcroot<HslCommunication::ModBus::ModbusTcpNet^>* ModBusTcp;
+		gcroot<HslCommunication::Profinet::Melsec::MelsecMcAsciiNet^>* McAscii;
+		gcroot<HslCommunication::Profinet::Melsec::MelsecA1ENet^>* McA1E;
+		gcroot<HslCommunication::Profinet::Melsec::MelsecMcNet^>* McBinary;
+		gcroot<HslCommunication::Profinet::Panasonic::PanasonicMcNet^>* PanasonicMc;
+		gcroot<HslCommunication::Profinet::Inovance::InovanceH5UTcp^>* InovanceTcp;
+
+		PlcImpl()
+		{
+			FinsTcp = new gcroot<HslCommunication::Profinet::Omron::OmronFinsNet^>;
+			ModBusTcp = new gcroot<HslCommunication::ModBus::ModbusTcpNet^>;
+			McAscii = new gcroot<HslCommunication::Profinet::Melsec::MelsecMcAsciiNet^>;
+			McA1E = new gcroot<HslCommunication::Profinet::Melsec::MelsecA1ENet^>;
+			McBinary = new gcroot<HslCommunication::Profinet::Melsec::MelsecMcNet^>;
+			PanasonicMc = new gcroot<HslCommunication::Profinet::Panasonic::PanasonicMcNet^>;
+			InovanceTcp = new gcroot<HslCommunication::Profinet::Inovance::InovanceH5UTcp^>;
+
+			*FinsTcp = nullptr;
+			*ModBusTcp = nullptr;
+			*McAscii = nullptr;
+			*McA1E = nullptr;
+			*McBinary = nullptr;
+			*PanasonicMc = nullptr;
+			*InovanceTcp = nullptr;
+		}
+	};
+
+public:
+	explicit Hd_SocketModule_PLC(int type = -1, QObject* parent = nullptr);
+	~Hd_SocketModule_PLC();
+
+	//通信的初始化参数
+	virtual bool setParameter(const QMap<QString, QString>& param);
+
+	//通信：获取初始化示例参数
+	virtual QMap<QString, QString> parameters();
+
+	//初始化(创建对象并连接到PLC服务器)
+	virtual bool init();
+
+	//写入数据
+	virtual bool setData(const QByteArray& data);
+
+	//获取数据
+	virtual bool data(QByteArray& data);
+
+protected:
+	void initUnionGcMembers();
+	bool initFinsTcp();
+	bool initModbusTcp();
+	bool initMcAscii();
+	bool initMcA1E();
+	bool initMcBinary();
+	bool initPanasonicMc();
+	bool initInovanceTcp();
+	bool closeSocket();
+
+	bool writeShortData(const QByteArray& addr, const QList<QByteArray>& data);
+	bool writeFloatData(const QByteArray& addr, const QList<QByteArray>& data);
+	bool writeDoubleData(const QByteArray& addr, const QList<QByteArray>& data);
+	bool writeStringData(const QByteArray& addr, const QByteArray& data);
+
+private:
+	//参数设置的数据
+	QMap<QString, QString> m_params{};
+	int m_plcType = -1;
+	PlcImpl m_plcImpl;
+	int m_sleepTime = 1;
+
+	QMutex* m_writeMutex = new QMutex();
+	QMutex* m_readMutex = new QMutex();
+	QQueue<QByteArray> m_readData;
+	QQueue<QByteArray> m_failedData;
+};
+
+#endif

BaseModules/Hd_SocketModule_PLC/base.h

@@ -0,0 +1,29 @@
+#ifndef __BASECLASS_H__
+#define __BASECLASS_H__
+
+#include <iostream>
+#include <QObject>
+#include <QByteArray>
+#include <opencv2/opencv.hpp>
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+
+class Base :public QObject
+{
+    Q_OBJECT
+public:
+    bool        init_flag;           //是否初始化,false,true
+    bool        status = true;              //相机状态（判断相机是否断开连接）
+    std::string paras;               //传输数据
+    std::vector<cv::Mat>     m_mat;  //传输图片
+    std::string moduleName="";          //模块名称
+public:
+    Base(){}
+    virtual ~Base(){}
+    virtual bool  readData(std::vector<cv::Mat>&,QByteArray&){return true;}
+    virtual bool  writeData(std::vector<cv::Mat>&,QByteArray&){return true;}
+    virtual bool  initParas(QByteArray&){return true;}
+    virtual bool  run() {return true;}
+    virtual bool  checkStatus() { return true; }
+};
+#endif

BaseModules/Hd_SocketModule_PLC/pbglobalobject.h

@@ -0,0 +1,52 @@
+#ifndef PBGLOBALOBJECT_H
+#define PBGLOBALOBJECT_H
+
+#include <QObject>
+#include<opencv2/opencv.hpp>
+#include <opencv.hpp>
+using namespace std;
+
+//支持的PLC通信协议类型
+enum class PLC_MODULE_TYPE
+{
+    FinsTcp,
+    ModbusTcp,
+    McAsciiTcp,
+    McA1ETcp,
+    McBinaryTcp,
+    PanasonicMC,
+    InovanceH5UTcp,
+
+    Count,//总数，加协议类型须在前面添加
+};
+
+class PbGlobalObject : public QObject
+{
+    Q_OBJECT
+public:
+    explicit PbGlobalObject(int settype, QObject* parent = nullptr) : QObject(parent), type1(settype) {}
+    virtual ~PbGlobalObject() {}
+    virtual bool setParameter(const QMap<QString, QString> &) { return true; }
+    virtual QMap<QString,QString> parameters() = 0;
+
+    virtual bool init() { return true; }
+
+    virtual bool setData(const vector<cv::Mat> &, const QStringList &) { return true; }
+    virtual bool data(std::vector<cv::Mat> &, QStringList &) { return true; }
+public:
+    //大类
+    enum PGOFAMLIY { GLOBALVARIABLE = 0, CAMERA2D, CAMERA2_5D, CAMERA3D, PLC, COM }famliy;
+    //小类
+    int type1 = -1;  //对应哪个品牌相机(触发方式)/通信
+    int type2 = -1;
+    int type3 = -1;
+    QString name = "";
+    int id;
+
+signals:
+    void trigged(bool);
+
+private:
+};
+
+#endif // PBGLOBALOBJECT_H