前言
使用多线程后台批量刷寄存器的状态，在某种程度上保证了上层接口读取的时候，不会卡顿，
整体应用效果比较友好。程序应用简单稳定高效，是一个比较不错的尝试。
一、演示效果
二、关键程序
1.头文件
代码如下：
#pragma once
#include "modbustcpclient_global.h"
#include <QObject>
#include <QThread>
#include <QHash>
#include <QMutexLocker>
#include <QMutex>
namespace YModbus {
class Master;
};
class MODBUSTCPCLIENT_EXPORT cModbusItem : public QThread
{
Q_OBJECT
public:
cModbusItem(QObject *parent = 0);
~cModbusItem();
public:
bool connect(QString strIp, int nPort);
bool isConnected();
void setServerId(int nId);
int getServerId();
void release();
bool getBit(uint16_t uAddr, uint16_t uBit);
bool readRegister16(uint16_t uAddr, uint16_t &uValue);
bool readRegister32(uint16_t uAddr, uint32_t &uValue);
bool readCoil(uint16_t uAddr);
bool setBit(uint16_t uAddr, uint16_t uBit, bool bState);
bool writeRegister16(uint16_t uAddr, uint16_t uValue);
bool writeRegister32(uint16_t uAddr, uint32_t uValue);
bool writeCoil(uint16_t uAddr, bool bState);
private:
void addValueCoilsHash(uint16_t uAddr);
void addValueHoldingRegistersHash(uint16_t uAddr);
private:
bool ctxReadRegister(uint16_t nStartAddress, int nNum);
bool ctxReadCoil(uint16_t nStartAddress, int nNum);
bool ctxWriteRegister(uint16_t nStartAddress, uint16_t uValue);
bool ctxWriteCoil(uint16_t nStartAddress, bool bState);
protected:
void run() override;
private:
bool m_bConnected;
bool m_bAppClose;
bool m_bWriteRequestState;
bool m_bReadRequestState;
bool m_bReadNext;
int m_nServerID;
QString m_strIp;
int m_nPort;
QMutex m_mutex;
YModbus::Master *m_pMaster;
private:
QHash<uint16_t, uint16_t> m_readValueHoldingRegistersHash;
QHash<uint16_t, uint16_> m_readAddrHoldingRegistersHash;
QHash<uint16_t, uint16_t> m_readValueCoilsHash;
QHash<uint16_t, uint16_t> m_readAddrCoilsHash;
};
2.源文件
代码如下：
#include "ModbusItem.h"
#include "ymblog.h"
#include "Ymod/ymbutils.h"
#include "Ymod/ymbtask.h"
#include "Ymod/ymbdefs.h"
#include "Ymod/Master/ymbmaster.h"
#include "Ymod/Master/ymaster.h"
#include <QVariant>
#include <QDebug>
#include <QTime>
#include <QVector>
#include <QTimer>
#define COILS_READ_COUNT 100
#define HOLDING_REGISTERS_READ_COUNT 100
struct sModbusTimer
{
QTime time;
uint32_t interval;
void start(uint32_t t)
{
interval = t;
time.restart();
};
bool isTimeOut()
{
return time.elapsed() > interval;
};
};
cModbusItem::cModbusItem(QObject *parent)
: QThread(parent)
, m_bConnected(false)
, m_bAppClose(false)
, m_bWriteRequestState(false)
, m_bReadRequestState(false)
, m_bReadNext(true)
, m_nServerID(1)
, m_strIp("")
, m_nPort(-1)
, m_pMaster(nullptr)
{
this->start();
}
cModbusItem::~cModbusItem()
{
m_bAppClose = true;
QThread::msleep(100);
}
void cModbusItem::run()
{
static sModbusTimer timeout;
static int nMainStep = 0;
while (true)
{
if (m_bAppClose)
return;
switch (nMainStep)
{
case 0:
{
if (m_bConnected)
nMainStep = 1;
else
QThread::msleep(500);
}break;
case 1:
{
if (true)
{
static int nIndex = 0;
QHash<uint16_t, uint16_t> readAddrHoldingRegistersHashTemp;
readAddrHoldingRegistersHashTemp = m_readAddrHoldingRegistersHash;
auto keys = readAddrHoldingRegistersHashTemp.keys();
if (keys.size() > 0)
{
nIndex = nIndex < keys.size() ? nIndex : 0;
uint16_t uAddr = keys[nIndex];
int nRead = uAddr - (HOLDING_REGISTERS_READ_COUNT / 2);
// 从中间覆盖读取
ctxReadRegister(nRead < 0 ? 0 : nRead, readAddrHoldingRegistersHashTemp[uAddr]);
nIndex++;
}
}
if (true)
{
static int nIndex = 0;
QHash<uint16_t, uint16_t> readAddrCoilsHashTemp;
readAddrCoilsHashTemp = m_readAddrCoilsHash;
auto keys = readAddrCoilsHashTemp.keys();
if (keys.size() > 0)
{
nIndex = nIndex < keys.size() ? nIndex : 0;
uint16_t uAddr = keys[nIndex];
// 从中间覆盖读取
int nRead = uAddr - COILS_READ_COUNT / 2;
ctxReadCoil(nRead < 0 ? 0 : nRead, readAddrCoilsHashTemp[uAddr]);
nIndex++;
}
}
}break;
default:
break;
}
}
}
// 连接
bool cModbusItem::connect(QString strIp, int nPort)
{
if (m_bConnected)
return true;
char *chIp;
QByteArray ba = strIp.toLatin1();
chIp = ba.data();
m_pMaster = new YModbus::Master(chIp, nPort, YModbus::TCP, YModbus::POLL);
if (!m_pMaster->CheckConnect())
{
m_bConnected = false;
delete m_pMaster;
m_pMaster = nullptr;
}
else
{
m_bConnected = true;
}
m_strIp = strIp;
m_nPort = nPort;
return m_bConnected;
}
// 是否连接
bool cModbusItem::isConnected()
{
return m_bConnected;
}
void cModbusItem::setServerId(int nId)
{
m_nServerID = nId;
}
int cModbusItem::getServerId()
{
return m_nServerID;
}
void cModbusItem::release()
{
m_bAppClose = true;
QThread::msleep(30);
}
// 读取16位值
bool cModbusItem::readRegister16(uint16_t uAddr, uint16_t &uValue)
{
if (!m_bConnected)
return false;
// 如果值读取哈希链表没有找到，需要插入到地址哈希链表，让它在后台读取
auto itFind = m_readValueHoldingRegistersHash.find(uAddr);
if (itFind == m_readValueHoldingRegistersHash.end())
{
m_readAddrHoldingRegistersHash[uAddr] = HOLDING_REGISTERS_READ_COUNT;
if (true)
{
// 如果没有就先读取一次
QHash<uint16_t, uint16_t> readAddrHoldingRegistersHashTemp;
readAddrHoldingRegistersHashTemp = m_readAddrHoldingRegistersHash;
int nRead = uAddr - (HOLDING_REGISTERS_READ_COUNT / 2);
ctxReadRegister(nRead < 0 ? 0 : nRead, readAddrHoldingRegistersHashTemp[uAddr]);
auto itFindItem = m_readValueHoldingRegistersHash.find(uAddr);
if (itFindItem == m_readValueHoldingRegistersHash.end())
return false;
else
uValue = m_readValueHoldingRegistersHash[uAddr];
}
}
else
{
// 找到值，直接返回
uValue = m_readValueHoldingRegistersHash[uAddr];
}
return true;
}
// 读取32位值
bool cModbusItem::readRegister32(uint16_t uAddr, uint32_t &uValue)
{
if (!m_bConnected)
return false;
bool bRet = false;
uint16_t uData16[2] = { 0 };
bRet = readRegister16(uAddr, uData16[0]);
bRet = readRegister16(uAddr + 1, uData16[1]);
uValue = uData16[0] | (uData16[1] << 16);
return bRet;
}
// 获取位值
bool cModbusItem::getBit(uint16_t uAddr, uint16_t uBit)
{
if (!m_bConnected)
return false;
uint16_t uValue = 0;
readRegister16(uAddr, uValue);
return uValue & (1 << (uBit % 16));
}
// 读取线圈值
bool cModbusItem::readCoil(uint16_t uAddr)
{
bool bResult = false;
uint16_t uValue = 0;
auto itFind = m_readValueCoilsHash.find(uAddr);
if (itFind == m_readValueCoilsHash.end())
{
m_readAddrCoilsHash[uAddr] = COILS_READ_COUNT;
if (true)
{
QHash<uint16_t, uint16_t> readAddrCoilsHashTemp;
readAddrCoilsHashTemp = m_readAddrCoilsHash;
// 从中间覆盖读取
int nRead = uAddr - COILS_READ_COUNT / 2;
ctxReadCoil(nRead < 0 ? 0 : nRead, readAddrCoilsHashTemp[uAddr]);
auto itFindItem = m_readValueCoilsHash.find(uAddr);
if (itFindItem == m_readValueCoilsHash.end())
bResult = false;
else
uValue = m_readValueCoilsHash[uAddr];
}
bResult = false;
}
else
uValue = m_readValueCoilsHash[uAddr];
if (true)
{
int nAddrSize = m_readAddrCoilsHash.size();
int nValueSize = m_readValueCoilsHash.size();
}
uValue == 1 ? bResult = true : bResult = false;
return bResult;
}
// 设置位值
bool cModbusItem::setBit(uint16_t uAddr, uint16_t uBit, bool bState)
{
bool bRet = false;
uint16_t uValue = 0;
bRet = readRegister16(uAddr, uValue);
if (bRet)
{
if (bState)
uValue |= (1 << (uBit % 16)); // 把某位置1
else
uValue &= ~(1 << (uBit % 16)); // 把某位置0
writeRegister16(uAddr, uValue);
}
return bRet;
}
// 写入16位值
bool cModbusItem::writeRegister16(uint16_t uAddr, uint16_t uValue)
{
bool bRet = true;
ctxWriteRegister(uAddr, uValue);
return bRet;
}
// 写入32位值
bool cModbusItem::writeRegister32(uint16_t uAddr, uint32_t uValue)
{
bool bRet = false;
uint16_t uData16[2] = {0};
uData16[0] = uValue & 0Xffff;
uData16[1] = (uValue >> 16) & 0Xffff;
bRet = writeRegister16(uAddr, uData16[0]);
bRet = writeRegister16(uAddr+1, uData16[1]);
return bRet;
}
// 写入线圈值
bool cModbusItem::writeCoil(uint16_t uAddr, bool bState)
{
ctxWriteCoil(uAddr, bState);
return true;
}
// 添加线圈数据列表
void cModbusItem::addValueCoilsHash(uint16_t uAddr)
{
int nAddrStart = uAddr - (COILS_READ_COUNT / 2);
if (nAddrStart < 0)
nAddrStart = 0;
// 提前添加数据列表，避免重复查询
for (size_t i = 0; i < COILS_READ_COUNT; i++)
{
m_readValueCoilsHash[nAddrStart + i] = 0;
}
}
// 添加保持寄存器数据列表
void cModbusItem::addValueHoldingRegistersHash(uint16_t uAddr)
{
int nAddrStart = uAddr - (HOLDING_REGISTERS_READ_COUNT / 2);
if (nAddrStart < 0)
nAddrStart = 0;
// 提前添加数据列表，避免重复查询
for (size_t i = 0; i < HOLDING_REGISTERS_READ_COUNT; i++)
{
m_readValueHoldingRegistersHash[nAddrStart + i] = 0;
}
}
// 读取寄存器
bool cModbusItem::ctxReadRegister(uint16_t nStartAddress, int nNum)
{
if (!m_bConnected || m_pMaster == nullptr)
return false;
m_mutex.lock();
static uint8_t buf[BUFSIZ] = { 0 };
memset(buf, 0, sizeof(buf));
int nLen;
nLen = m_pMaster->ReadHoldingRegisters(m_nServerID, nStartAddress, nNum, buf, sizeof(buf));
if (nLen == (nNum*2) && nLen != 0)
{
QList<uint16_t> uReadDataList;
for (int i = 0; i < nLen; i++)
{
if ((i %2) ==0 )
{
uint16_t uValue = (buf[i] << 8) | buf[i+1];
uReadDataList << uValue;
}
}
// 写入数据哈希表
for (size_t i = 0; i < uReadDataList.size(); i++)
{
m_readValueHoldingRegistersHash[nStartAddress + i] = uReadDataList[i];
}
}
m_mutex.unlock();
return true;
}
// 读取线圈
bool cModbusItem::ctxReadCoil(uint16_t nStartAddress, int nNum)
{
if (!m_bConnected || m_pMaster == nullptr)
return false;
m_mutex.lock();
static uint8_t buf[BUFSIZ] = { 0 };
memset(buf, 0, sizeof(buf));
int nLen;
nLen = m_pMaster->ReadCoils(m_nServerID, nStartAddress, nNum, buf, sizeof(buf));
if (nLen > 0)
{
QList<uint16_t> uReadDataList;
for (int i = 0; i < nLen; i++)
{
uint16_t uValue = buf[i];
uReadDataList << uValue;
}
// 写入数据哈希表
for (size_t i = 0; i < nNum; i++)
{
int nIndex = i / 8;
if (nIndex >= 0 && nIndex < uReadDataList.size())
{
int nBit = i - (8)*nIndex;
if (nBit >= 0 && nBit < 8)
{
uint16_t uValue = (uReadDataList[nIndex] & (1 << nBit)) > 0 ? 1 : 0;
m_readValueCoilsHash[nStartAddress + i] = uValue;
}
}
}
}
m_mutex.unlock();
return true;
}
bool cModbusItem::ctxWriteRegister(uint16_t nStartAddress, uint16_t uValue)
{
m_mutex.lock();
int nLen = m_pMaster->WriteSingleRegister(m_nServerID, nStartAddress, uValue);
m_mutex.unlock();
return true;
}
bool cModbusItem::ctxWriteCoil(uint16_t nStartAddress, bool bState)
{
m_mutex.lock();
int nLen = m_pMaster->WriteSingleCoil(m_nServerID, nStartAddress, bState);
m_mutex.unlock();
return true;
}
三、下载链接
https://download.csdn.net/download/u013083044/87062401文章来源：https://www.toymoban.com/news/detail-587359.html
文章来源地址https://www.toymoban.com/news/detail-587359.html
到了这里，关于C++基于开源Modbus Tcp 通讯应用客户端（稳定高效，多线程后台状态读取，不卡顿）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
