VisionPlus_V3.0/VisionPlusTools/CstModbusRTU/ToolDialog.cpp

#include "ToolDialog.h"
#include <QImage>
#include <QFileInfo>
#include <QFileDialog>
#include <QElapsedTimer>
#include <QGridLayout>

ToolDialogImpl::ToolDialogImpl(QWidget *parent)
	: DllToolDialog(parent)
{
	ui.setupUi(this);
	this->setWindowFlags(Qt::Dialog | Qt::WindowCloseButtonHint /*| Qt::WindowStaysOnTopHint*/);

	connect(this, SIGNAL(sigUpdateUI()), this, SLOT(on_UpdateUI()));

	m_nTableRowCount = 0;
	// 列数
	ui.tableWidget->setColumnCount(5);

	// 设置表头文字
	QStringList headers;
	headers
		<< ("Index")
		<< ("Name")
		<< ("DataAddr")
		<< ("Value")
		<< ("Comment");

	ui.tableWidget->setHorizontalHeaderLabels(headers);

	//设置表头字体
	QFont font = ui.tableWidget->horizontalHeader()->font();
	font.setBold(true);
	ui.tableWidget->horizontalHeader()->setFont(font);
	// 设置文字左对齐
	ui.tableWidget->horizontalHeader()->setDefaultAlignment(Qt::AlignCenter);
	// 设置为不可编辑
	ui.tableWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
	// 设置为整行选中模式
	ui.tableWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
	ui.tableWidget->setSelectionMode(QAbstractItemView::SingleSelection);
	// 设置最左侧的序号不用显示
	ui.tableWidget->verticalHeader()->setVisible(false);
	//设置行高
	ui.tableWidget->verticalHeader()->setDefaultSectionSize(10);
	//点击表时不对表头行光亮（获取焦点）
	ui.tableWidget->horizontalHeader()->setHighlightSections(false);


	m_strTP = "127.0.0.1";
	ui.edit_IP->setText(m_strTP);

	m_nTimerID = 0;
	m_nTimerID = this->startTimer(1000);
	
	m_nIsCOnnect = -1;
	m_pModbus = nullptr;

	m_nThreadState = 1;

	// 启动线程
	m_ReadThreadPool.start(
		new _ReadThread(this)
	);
	// 启动线程
	m_WriteThreadPool.start(
		new _WriteThread(this)
	);
}


ToolDialogImpl::~ToolDialogImpl()
{
	if (m_pModbus)
	{
		modbus_close(m_pModbus);
		modbus_free(m_pModbus);
	}

	m_nThreadState = 0;
}



/// <summary>
/// 调整大小的消息中改变表格栏的宽度
/// </summary>
/// <param name="event"></param>
void ToolDialogImpl::resizeEvent(QResizeEvent* event)
{
	Q_UNUSED(event);

	// qDebug() << "WindowAppVariableTable::resizeEvent";
	int nTotalSize = ui.tableWidget->size().width();

	ui.tableWidget->setColumnWidth(0, nTotalSize * 0.05);
	ui.tableWidget->setColumnWidth(1, nTotalSize * 0.2);
	ui.tableWidget->setColumnWidth(2, nTotalSize * 0.2);
	ui.tableWidget->setColumnWidth(3, nTotalSize * 0.2);
	ui.tableWidget->setColumnWidth(4, nTotalSize * 0.34);


	//ui.tableWidget->resize(ui.tableWidget->size());
}


VPEnum::RETURN_VALUE ToolDialogImpl::Execute()
{
	emit sigUpdateUI();
	return VPEnum::RETURN_VALUE::Success;
}


void ToolDialogImpl::Running(bool bRun)
{

}


/// <summary>
/// 
/// </summary>
/// <param name="nIndex"></param>
/// <returns></returns>
bool ToolDialogImpl::updateValue(int nIndex)
{
	return writeValueToPLC(nIndex);
}


void ToolDialogImpl::timerEvent(QTimerEvent* event)
{
	if (event->timerId() == m_nTimerID)
	{

	}


}

bool ToolDialogImpl::Serialized(QDataStream& ar, bool bIsOut)
{
	int paranum;//参数数量
	if (bIsOut)//保存参数流程
	{
		paranum = 3;
		ar << paranum;//先保存参数数量

		ar << (int)1 << m_strTP;
		ar << (int)2 << m_strPort;
		ar << (int)3 << m_nIsCOnnect;
		
		


	}
	else//加载参数流程，参数加载顺序一定要跟保存顺序一致
	{
		int nSize1 = 0;

		int para;
		ar >> paranum;//读取参数数量
		for (int i = 0; i < paranum; i++)
		{
			ar >> para;
			switch (para)
			{
			case 1:			  ar >> m_strTP;										break;
			case 2:			  ar >> m_strPort;										break;
			case 3:			  ar >> m_nIsCOnnect;										break;

			default:
			{
				qWarning() << "Serialized(In) Error";
				return false;
			}
			break;
			}
		}

		setValueToUI();
		//hwndUnit->getHWndCtrl()->useROIController(&roiController);

	}
	return true;
}


void ToolDialogImpl::on_UpdateUI()
{
	if (m_pDB != nullptr)
	{
		// 更新表格
		if (m_nTableRowCount != m_pDB->Variables.size())
		{
			m_nTableRowCount = m_pDB->Variables.size();
		
			for (int row = 0; row < m_nTableRowCount; row++)
			{
				ui.tableWidget->removeRow(0);
			}
			m_TableWidgetItems.clear();

			int i = 0;
			for (VARIABLE* var : m_pDB->Variables)
			{
				ui.tableWidget->insertRow(ui.tableWidget->rowCount());//增加一行
				ui.tableWidget->setItem(i, 0, new QTableWidgetItem(QString::number(i)));
				ui.tableWidget->setItem(i, 1, new QTableWidgetItem(var->strName));
				ui.tableWidget->setItem(i, 2, new QTableWidgetItem(var->strCommAddress));

				QTableWidgetItem* pItem = new QTableWidgetItem(var->strComment);
				m_TableWidgetItems.push_back(pItem);
				ui.tableWidget->setItem(i, 3, pItem);
				ui.tableWidget->setItem(i, 4, new QTableWidgetItem(var->strComment));
				i++;
			}
		}

		// 更新值
		const QVector<QTableWidgetItem*>& pTaskItems = m_TableWidgetItems;
		int i = 0;
		for (VARIABLE* var : m_pDB->Variables)
		{
			pTaskItems[i]->setText(var->getValueString());
			i++;
		}
	}
}



/// <summary>
/// 确定
/// </summary>
void ToolDialogImpl::on_btnOK_clicked()
{
	this->hide();
}


/// <summary>
/// 取消按钮
/// </summary>
void ToolDialogImpl::on_btnCancel_clicked()
{
	// 将本工具的恢复到打开工具之前的状态
	RecoverData();
}


/// <summary>
/// 测试按钮
/// </summary>
void ToolDialogImpl::on_btnExecute_clicked()
{
	QElapsedTimer toolTimer;
	toolTimer.start();
	// 发送事件
	ToolEvent* pToolEvent = new ToolEvent(m_strPouName, m_strInstanceName, TOOL_EVENT_TYPE::TOOL_TRIGGER);
	QCoreApplication::sendEvent(m_pEventTarget, pToolEvent);
	delete pToolEvent;

	// 统计返回值
	VPEnum::RETURN_VALUE ret = VPEnum::RETURN_VALUE::Success;

	double nExecTime = toolTimer.elapsed();
	QString str;
	str = QString("耗时： %1 ms").arg(nExecTime, 0, 'G', 5);
	ui.label_time->setText(str);

	str = QString("状态： %1 ").arg(QMetaEnum::fromType<VPEnum::RETURN_VALUE>().key((short)ret));
	ui.label_state->setText(str);

}



void ToolDialogImpl::on_btn_Connect_clicked()
{
	m_strTP = ui.edit_IP->text();
	//if (m_pModbus != nullptr)
	{
		int nRet = ConnectToPLC();

		// Connect OK
		if (nRet == 0)
		{
			m_nIsCOnnect = 1;
		}
	}

}



bool ToolDialogImpl::on_rbnModbusRTU_clicked()
{

	return true;
}


bool ToolDialogImpl::on_rbnModbusTCP_clicked()
{

	return true;
}



/// <summary>
/// 2022-3-1 向exe中的变量表界面同步数值
/// </summary>
/// <param name="pInfs"></param>
void ToolDialogImpl::syncValuesToTableUI(QList<VARIABLE*> pInfs)
{
	SyncValueEvent* valueEvent = new SyncValueEvent();

	// 携带需要同步的多个接口
	valueEvent->setSyncValues(pInfs);

	// post数值同步消息
	QCoreApplication::postEvent((QObject*)this->m_pGvlTarget, valueEvent);
}



int ToolDialogImpl::ConnectToPLC()
{

	m_pModbus = modbus_new_tcp(m_strTP.toStdString().c_str(), 502);
	modbus_set_slave(m_pModbus, 1);
	
	struct timeval time;
	time.tv_sec = 0;
	time.tv_usec = 1000000;
	modbus_set_response_timeout(m_pModbus, (int)&time.tv_sec, (int)&time.tv_usec);
	

	return   modbus_connect(m_pModbus);
}


void ToolDialogImpl::setValueToUI()
{

	ui.edit_IP->setText(m_strTP);

	// 如果反序列化上来，发现之前是连接的状态，即开始新的链接。注：如果此时链接不成功，该值会被覆盖为未连接状态
	if (m_nIsCOnnect != -1)
	{
		ConnectToPLC();
	}
}


/// <summary>
/// 
/// </summary>
/// <returns></returns>
bool ToolDialogImpl::readValueByPLC()
{
	if (m_pDB == nullptr || m_pModbus == nullptr || m_nIsCOnnect == -1)
	{
		return false;
	}

	// 如果窗口的tab 行数与变量行数不一致，就需要添加数据行
	
	emit sigUpdateUI();
		
	
	QList<VARIABLE*> infs;
	int i = 0;
	for (VARIABLE* var : m_pDB->Variables)
	{

		int nCommAddress = var->strCommAddress.toInt();

		if (var->value.type == VALUE_TYPE::Type_Bool)
		{
			int nValue = (*(int*)(var->value.Ptr));

			if (nCommAddress > 40000 && nCommAddress < 50000)
			{
				// 根据DB 中的地址，去PLC 中读取对用的值
				uint16_t read_reg[255] = { 0 };
				modbus_read_registers(m_pModbus, nCommAddress - 40001, 1, read_reg);
				int nReadVar = read_reg[0];

				// 如果发现读上来的值与实际DB 中值不一致，就需要修改DB的值，并更新 DB的UI
				if (nReadVar != nValue)
				{
					(*(int*)(var->value.Ptr)) = nReadVar;
					infs.push_back(var);// 储存要刷新的变量列表
				}
			}
		}

		else if (var->value.type == VALUE_TYPE::Type_Int)
		{
			int nValue = (*(int*)(var->value.Ptr));

			if (nCommAddress > 40000 && nCommAddress < 50000)
			{
				// 根据DB 中的地址，去PLC 中读取对用的值
				uint16_t read_reg[255] = { 0 };
				modbus_read_registers(m_pModbus, nCommAddress - 40001, 1, read_reg);
				int nReadVar = read_reg[0];
				
				// 如果发现读上来的值与实际DB 中值不一致，就需要修改DB的值，并更新 DB的UI
				if (nReadVar != nValue)
				{
					(*(int*)(var->value.Ptr)) = nReadVar;
					infs.push_back(var);// 储存要刷新的变量列表
				}
			}
		}

		else if (var->value.type == VALUE_TYPE::Type_Float)
		{
			float fValue = (*(float*)(var->value.Ptr));

			if (nCommAddress > 40000 && nCommAddress < 50000)
			{
				// 根据DB 中的地址，去PLC 中读取对用的值
				uint16_t read_reg[255] = { 0 };
				modbus_read_registers(m_pModbus, nCommAddress - 40001, 2, read_reg);
				float fReadVar = modbus_get_float_badc(read_reg);
				//int fReadVar = modbus_get_float_dcba(read_reg); //高低位置换

				// 如果发现读上来的值与实际DB 中值不一致，就需要修改DB的值，并更新 DB的UI
				if ((fabs(fReadVar - fValue)) > 0.0001)
				{
					(*(float*)(var->value.Ptr)) = fReadVar;
					infs.push_back(var);// 储存要刷新的变量列表
				}
			}
		}

		else if (var->value.type == VALUE_TYPE::Type_Double)
		{
			float fValue = (*(float*)(var->value.Ptr));

			if (nCommAddress > 40000 && nCommAddress < 50000)
			{
				// 根据DB 中的地址，去PLC 中读取对用的值
				uint16_t read_reg[255] = { 0 };
				modbus_read_registers(m_pModbus, nCommAddress - 40001, 2, read_reg);
				float fReadVar = modbus_get_float_badc(read_reg);
				//int fReadVar = modbus_get_float_dcba(read_reg); //高低位置换

				// 如果发现读上来的值与实际DB 中值不一致，就需要修改DB的值，并更新 DB的UI
				if (fabs(fReadVar - fValue) < 0.000001)
				{
					(*(float*)(var->value.Ptr)) = fReadVar;
					infs.push_back(var);// 储存要刷新的变量列表
				}
			}
		}

		

		i++;
	}


	if (infs.size() > 0)
	{
		// 发送变更通知
		this->syncValuesToTableUI(infs);
	}
	return true;
}


/// <summary>
/// 
/// </summary>
/// <param name="nIndex"></param>
/// <returns></returns>
bool ToolDialogImpl::writeValueToPLC(int nIndex)
{
	
	if (m_pDB != nullptr)
	{

		VARIABLE* var = m_pDB->Variables[nIndex];
		if (var != nullptr)
		{
			
			qDebug() << "Variable:" << var->strName << "[" << var->getValueString() << "]";

			int nCommAddress = var->strCommAddress.toInt();

			// bool
			if (var->value.type == VALUE_TYPE::Type_Bool)
			{
				if (nCommAddress > 40000 && nCommAddress < 50000)
				{
					// 写int 数据的启示地址为 0
					modbus_write_register(m_pModbus, nCommAddress - 40001, var->getValueString().toInt());
				}
			}

			// int
			else if (var->value.type == VALUE_TYPE::Type_Int)
			{
				if (nCommAddress > 40000 && nCommAddress < 50000)
				{
					// 写int 数据的启示地址为 0
					modbus_write_register(m_pModbus, nCommAddress - 40001, var->getValueString().toInt());
				}
			}

			// float
			else if (var->value.type == VALUE_TYPE::Type_Float)
			{
				if (nCommAddress > 40000 && nCommAddress < 50000)
				{
					// 写float 数据的启示地址为 0

					float fVilue = var->getValueString().toFloat();
					uint16_t* pRegisters = (uint16_t*)malloc(4 * sizeof(uint16_t));
					memset(pRegisters, 0, 4 * sizeof(uint16_t));
					modbus_set_float_badc(fVilue, pRegisters);// 正常高低位
					//modbus_set_float_dcba(fVilue, pRegisters);// 高低位置换
					modbus_write_registers(m_pModbus, nCommAddress - 40001, 2, pRegisters);
				}
			}

			// dobule
			else if (var->value.type == VALUE_TYPE::Type_Double)
			{
				if (nCommAddress > 40000 && nCommAddress < 50000)
				{
					// 写int 数据的启示地址为 0
					modbus_write_register(m_pModbus, nCommAddress - 40001, var->getValueString().toInt());
				}
			}


			// string
			else if (var->value.type == VALUE_TYPE::Type_String)
			{
				if (nCommAddress > 40000 && nCommAddress < 50000)
				{
					// 写int 数据的启示地址为 0
					modbus_write_register(m_pModbus, nCommAddress - 40001, var->getValueString().toInt());
				}
			}



		}
	}
	return true;
}


//============================================================
//
//					Save 线程
//
//============================================================

/// <summary>
/// 线程函数
/// </summary>
void _ReadThread::run()
{
	// 调用函数执行任务
	while (m_pDialog->m_nThreadState)
	{
		m_pDialog->readValueByPLC();
		QThread::msleep(50);
	}
	return;
}

/// <summary>
/// 线程函数
/// </summary>
void _WriteThread::run()
{
	// 调用函数执行任务
	while (m_pDialog->m_nThreadState)
	{
		//m_pDialog->writeValueToPLC();
		QThread::msleep(500);
	}
	return;
}