modbus RTU、TCP实现

最新推荐文章于 2023-12-18 16:26:15 发布
最新推荐文章于 2023-12-18 16:26:15 发布
阅读量1.1k 收藏 4
点赞数
文章标签： tcp/ip 网络 网络协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41492038/article/details/124971983
版权

##Modbus常用的功能码： DiscreteInputs,Coils,InputRegisters,HoldingRegisters
在这里插入图片描述
##常用功能码在这里插入图片描述

##核心代码如下：
通过传入connectType_的类型来设置连接类型，串口或者网口，即Serial或TCP，
当为Serial时，需要将串口号、波特率、数据位、校验位、停止位传入，为TCP则只用传入IP和Port即可，然后传入从站号即SetAddress，最后通过connectSlot进行连接即可，以下接口中通过信号与槽的连接将读写操作分别做了区分，可跨线程操作。
ModBus封装接口

class DModbusDevice: public QObject
{
	Q_OBJECT

	signals:
		void connectSignal(bool&);
		void disconnectSignal();

		void readSignal(quint16, quint16&, QModbusDevice::Error&) const;
		void readSignal(quint16, quint16, QVector<quint16>&, QModbusDevice::Error&) const;
		void read2Signal(quint16, quint16, QVector<bool>&, QModbusDevice::Error&) const;
		void read3Signal(quint16, quint16, QVector<bool>&, QModbusDevice::Error&) const;
		void read4Signal(quint16, quint16, QVector<quint16>&, QModbusDevice::Error&) const;
		void readSignal(QModbusDataUnit::RegisterType, quint16, quint16, QVector<quint16>&, QModbusDevice::Error&) const;

		void write2Signal(quint16, bool, QModbusDevice::Error&);
		void writeSignal(quint16, quint16, QModbusDevice::Error&) const;
		void writeSignal(quint16, quint16, const QVector<quint16>&, QModbusDevice::Error&) const;
		void writeSignal(QModbusDataUnit::RegisterType, quint16, quint16, const QVector<quint16>&, QModbusDevice::Error&) const;


public:
	DModbusDevice(QObject* parent = Q_NULLPTR);
	~DModbusDevice();

	void setConnectType(const ConnectType type);
	ConnectType connectType() const;

	void setIp(const QString& ip);
	QString ip() const;

	void setTcpPort(const qint32 port);
	qint32 tcpPort() const;

	void setPort(const QString& port);
	QString port() const;

	void setBaudRate(qint32 baudRate);
	qint32 baudRate() const;

	void setDataBits(QSerialPort::DataBits dataBits);
	QSerialPort::DataBits dataBits() const;

	void setParity(QSerialPort::Parity parity);
	QSerialPort::Parity parity() const;

	void setStopBits(QSerialPort::StopBits stopBits);
	QSerialPort::StopBits stopBits() const;

	void setTimeout(qint32 timeout);
	qint32 timeout() const;

	void setAddress(quint8);
	quint8 address() const;

	QModbusDevice::Error error();
	QString errorString();

	bool connect();
	void disconnect();

	QModbusDevice::Error read(quint16, quint16&) const;
	QModbusDevice::Error read(quint16, quint16, QVector<quint16>&) const;
	QModbusDevice::Error read2(quint16, quint16, QVector<bool>&) const;
	QModbusDevice::Error read3(quint16, quint16, QVector<bool>&) const;
	QModbusDevice::Error read4(quint16, quint16, QVector<quint16>&) const;
	QModbusDevice::Error read(QModbusDataUnit::RegisterType, quint16, quint16, QVector<quint16>&) const;

	QModbusDevice::Error write2(quint16, bool);
	QModbusDevice::Error write(quint16, quint16) const;
	QModbusDevice::Error write(quint16, quint16, const QVector<quint16>&) const;
	QModbusDevice::Error write(QModbusDataUnit::RegisterType, quint16, quint16, const QVector<quint16>&) const;

public slots:
	//
	void connectSlot(bool&);
	void disconnectSlot();

	void readSlot(quint16, quint16&, QModbusDevice::Error&) const;
	void readSlot(quint16, quint16, QVector<quint16>&, QModbusDevice::Error&) const;
	void read2Slot(quint16, quint16, QVector<bool>&, QModbusDevice::Error&) const;
	void read3Slot(quint16, quint16, QVector<bool>&, QModbusDevice::Error&) const;
	void read4Slot(quint16, quint16, QVector<quint16>&, QModbusDevice::Error&) const;
	void readSlot(QModbusDataUnit::RegisterType, quint16, quint16, QVector<quint16>&, QModbusDevice::Error&) const;

	void write2Slot(quint16, bool, QModbusDevice::Error&);
	void writeSlot(quint16, quint16, QModbusDevice::Error&) const;
	void writeSlot(quint16, quint16, const QVector<quint16>&, QModbusDevice::Error&) const;
	void writeSlot(QModbusDataUnit::RegisterType, quint16, quint16, const QVector<quint16>&, QModbusDevice::Error&) const;
	QModbusDevice::State state() const;
	QModbusDevice::Error ping();
	QModbusClient* baseDevice() const;

private:
	static QMutex mutex_;
	ConnectType connectType_;
	QString port_;
	qint32 baudRate_;
	QSerialPort::DataBits dataBits_;
	QSerialPort::Parity parity_;
	QSerialPort::StopBits stopBits_;
	qint32 timeout_;

	QString ip_;
	qint32 tcp_port_;

	quint8 address_;
	QModbusClient* client_;
};

实现

DModbusDevice::DModbusDevice(QObject* parent)
	: QObject(parent)
	, port_("")
	, baudRate_(QSerialPort::Baud9600)
	, dataBits_(QSerialPort::Data8)
	, parity_(QSerialPort::EvenParity)
	, stopBits_(QSerialPort::OneStop)
	, timeout_(1500)
	, address_(0)
	, client_(Q_NULLPTR)
	, connectType_(Serial)
	, ip_("127.0.0.1")
	, tcp_port_(8080)
{
	QObject::connect(this, SIGNAL(connectSignal(bool&)), this, SLOT(connectSlot(bool&)), Qt::BlockingQueuedConnection);
	QObject::connect(this, SIGNAL(disconnectSignal()), this, SLOT(disconnectSlot()), Qt::BlockingQueuedConnection);

	QObject::connect(this, SIGNAL(readSignal(quint16, quint16&, QModbusDevice::Error&)), this, SLOT(readSlot(quint16, quint16&, QModbusDevice::Error&)), Qt::BlockingQueuedConnection);
	QObject::connect(this, SIGNAL(readSignal(quint16, quint16, QVector<quint16>&, QModbusDevice::Error&)), this, SLOT(readSlot(quint16, quint16, QVector<quint16>&, QModbusDevice::Error&)), Qt::BlockingQueuedConnection);
	QObject::connect(this, SIGNAL(read2Signal(quint16, quint16, QVector<bool>&, QModbusDevice::Error&)), this, SLOT(read2Slot(quint16, quint16, QVector<bool>&, QModbusDevice::Error&)), Qt::BlockingQueuedConnection);
	QObject::connect(this, SIGNAL(read3Signal(quint16, quint16, QVector<bool>&, QModbusDevice::Error&)), this, SLOT(read3Slot(quint16, quint16, QVector<bool>&, QModbusDevice::Error&)), Qt::BlockingQueuedConnection);
	QObject::connect(this, SIGNAL(readSignal(QModbusDataUnit::RegisterType, quint16, quint16, QVector<quint16>&, QModbusDevice::Error&)), this, SLOT(readSlot(QModbusDataUnit::RegisterType, quint16, quint16, QVector<quint16>&, QModbusDevice::Error&)), Qt::BlockingQueuedConnection);
	QObject::connect(this, SIGNAL(read4Signal(quint16, quint16, QVector<quint16>&, QModbusDevice::Error&)), this, SLOT(read4Slot(quint16, quint16, QVector<quint16>&, QModbusDevice::Error&)), Qt::BlockingQueuedConnection);

	QObject::connect(this, SIGNAL(write2Signal(quint16, bool, QModbusDevice::Error&)), this, SLOT(write2Slot(quint16, bool, QModbusDevice::Error&)), Qt::BlockingQueuedConnection);
	QObject::connect(this, SIGNAL(writeSignal(quint16, quint16, QModbusDevice::Error&)), this, SLOT(writeSlot(quint16, quint16, QModbusDevice::Error&)), Qt::BlockingQueuedConnection);
	QObject::connect(this, SIGNAL(writeSignal(quint16, quint16, const QVector<quint16>&, QModbusDevice::Error&)), this, SLOT(writeSlot(quint16, quint16, const QVector<quint16>&, QModbusDevice::Error&)), Qt::BlockingQueuedConnection);
	QObject::connect(this, SIGNAL(writeSignal(QModbusDataUnit::RegisterType, quint16, quint16, const QVector<quint16>&, QModbusDevice::Error&)), this, SLOT(writeSlot(QModbusDataUnit::RegisterType, quint16, quint16, const QVector<quint16>&, QModbusDevice::Error&)), Qt::BlockingQueuedConnection);
}

void DModbusDevice::connectSlot(bool& result)
{


	if(connectType_ == Serial) {
		client_ = new QModbusRtuSerialMaster(/*this*/);
		if (state() == QModbusDevice::ConnectedState) {
			result = true;
			return;
		}
		client_->setConnectionParameter(QModbusDevice::SerialPortNameParameter, port_);
		client_->setConnectionParameter(QModbusDevice::SerialParityParameter, parity_);
		client_->setConnectionParameter(QModbusDevice::SerialBaudRateParameter, baudRate_);
		client_->setConnectionParameter(QModbusDevice::SerialDataBitsParameter, dataBits_);
		client_->setConnectionParameter(QModbusDevice::SerialStopBitsParameter, stopBits_);
	}
	else if(connectType_ == Tcp) {
		client_ = new QModbusTcpClient();
		if (state() == QModbusDevice::ConnectedState) {
			result = true;
			return;
		}
		client_->setConnectionParameter(QModbusDevice::NetworkAddressParameter, ip_);
		client_->setConnectionParameter(QModbusDevice::NetworkPortParameter, tcp_port_);
	}
	
	client_->setTimeout(timeout_);
	client_->setNumberOfRetries(2);

	result = client_->connectDevice();
}



void DModbusDevice::disconnectSlot()
{
	if (state() == QModbusDevice::UnconnectedState) {
		return;
	}
	client_->disconnectDevice();
	delete client_;
	client_ = Q_NULLPTR;
}

QModbusDevice::State DModbusDevice::state() const
{
	return client_->state();
}



void DModbusDevice::readSlot(quint16 start_address, quint16& value, QModbusDevice::Error& error) const
{
	QVector<quint16> values;
	readSlot(start_address, 1, values, error);
	if (error == QModbusDevice::NoError) {
		value = values[0];
	}

	//return ret;
}

void DModbusDevice::readSlot(quint16 start_address, quint16 count, QVector<quint16>& values, QModbusDevice::Error& error) const
{
	readSlot(QModbusDataUnit::HoldingRegisters, start_address, count, values, error);
}

void DModbusDevice::read2Slot(quint16 start_address, quint16 count, QVector<bool>& values, QModbusDevice::Error& error) const
{
	QVector<quint16> tmp;
	readSlot(QModbusDataUnit::DiscreteInputs, start_address, count, tmp, error);
	if (error == QModbusDevice::NoError) {
		for (int i = 0; i < count; ++i) {
			values.append(tmp.value(i));
		}
	}
	//return ret;
}




void DModbusDevice::read3Slot(quint16 start_address, quint16 count, QVector<bool>& values, QModbusDevice::Error& error) const {
	QVector<quint16> tmp;
	readSlot(QModbusDataUnit::Coils, start_address, count, tmp, error);
	if (error == QModbusDevice::NoError) {
		for (int i = 0; i < count; ++i) {
			values.append(tmp.value(i) == 1);
		}
	}
}

void DModbusDevice::read4Slot(quint16 start_address, quint16 count, QVector<quint16>& values, QModbusDevice::Error& error) const {
	readSlot(QModbusDataUnit::HoldingRegisters, start_address, count, values, error);
}

void DModbusDevice::readSlot(QModbusDataUnit::RegisterType type
                             , quint16 start_address, quint16 count, QVector<quint16>& values, QModbusDevice::Error& error) const
{
	//qInfo() << "device read enter" << QThread::currentThread();
	//QMutexLocker locker(&mutex_);
	//qInfo() << "device read leave";
	if (!client_)
	{
		error = QModbusDevice::ConnectionError;
		return;
	}
	int index = 0;
	R:
	const QModbusDataUnit read_unit(type, start_address, count);
	if (QModbusReply* reply = client_->sendReadRequest(read_unit, address_)) {
		QTimer timer;
		QEventLoop event_loop;
		QObject::connect(reply, &QModbusReply::finished, &event_loop, &QEventLoop::quit);
		QObject::connect(&timer, &QTimer::timeout, [&]() {
			event_loop.quit();
			//qCritical() << "device read timeout.";
		});
		timer.start(5000);
		event_loop.exec();
		timer.stop();
		//qInfo() << client_->error() << client_->errorString();

		if (!reply->isFinished()) {
			if(index < 3) {
				index++;
				QThread::msleep(500);
				goto R;
			}
			qCritical() << "device read timeout.";
			error = QModbusDevice::ConnectionError;
			return;
		}
		

		const auto error_code = reply->error();
		const auto error_string = reply->errorString();
		//qDebug() << error_code << error_string;

		if (error_code == QModbusDevice::NoError) {
			values.clear();
			const QModbusDataUnit unit = reply->result();
			//const auto data = reply->rawResult().data();
			for (uint i = 0; i < unit.valueCount(); i++) {
				values.append(unit.value(i));
			}
		}

		reply->deleteLater();
		error = error_code;
		return;
	}

	error = QModbusDevice::ConnectionError;
}


void DModbusDevice::write2Slot(quint16 start_address, bool on, QModbusDevice::Error& error)
{
	QVector<quint16> values;
	values << (on ? 1 : 0);
	qDebug() << "device " << start_address << " write" << on;
	writeSlot(QModbusDataUnit::Coils, start_address, 1, values, error);
}


void DModbusDevice::writeSlot(quint16 start_address, quint16 value, QModbusDevice::Error& error) const
{
	QVector<quint16> values;
	values << value;

	writeSlot(start_address, 1, values, error);
}

void DModbusDevice::writeSlot(quint16 start_address, quint16 count, const QVector<quint16>& values, QModbusDevice::Error& error) const
{
	return writeSlot(QModbusDataUnit::HoldingRegisters, start_address, count, values, error);
}


void DModbusDevice::writeSlot(QModbusDataUnit::RegisterType type
	, quint16 start_address, quint16 count, const QVector<quint16>& values, QModbusDevice::Error& error) const
{

	//qInfo() << "device write enter" << QThread::currentThread();
	//QMutexLocker locker(&mutex_);
	//qInfo() << "device write leave";
	if (!client_)
	{
		error = QModbusDevice::ConnectionError;
		return;
	}

	QModbusDataUnit write_unit(type, start_address, count);
	for (quint32 i = 0; i < write_unit.valueCount(); i++) {
		write_unit.setValue(i, values.value(i));
	}
	int index = 0;
	R:
	if (QModbusReply* reply = client_->sendWriteRequest(write_unit, address_)) {

		QTimer timer;
		QEventLoop event_loop;
		QObject::connect(reply, &QModbusReply::finished, &event_loop, &QEventLoop::quit);
		QObject::connect(&timer, &QTimer::timeout, [&]() {
			event_loop.quit();
		});
		timer.start(3000);
		event_loop.exec();
		timer.stop();

		qDebug() << "device write " << type << start_address << count << reply->isFinished() << reply->error();

		if (!reply->isFinished()) {
			if(index < 3) {
				index++;
				QThread::msleep(500);
				goto R;
			}
			qCritical() << "device write timeout.";
			error = QModbusDevice::ConnectionError;
			return;
		}

		const auto error_code = reply->error();
		//const auto error_string = reply->errorString();
		//qDebug() << error_code << error_string;

		//if(error_code == QModbusDevice::NoError) {
		//	const QModbusDataUnit data = reply->result();
		//	qDebug() << u8"消息数据个数：" << data.valueCount() << " :" << data.values();
		//}

		reply->deleteLater();
		error = error_code;
		return;
	}

	error = QModbusDevice::ConnectionError;
}


QModbusDevice::Error DModbusDevice::ping()
{
	return QModbusDevice::NoError;
}

QModbusClient* DModbusDevice::baseDevice() const
{
	return client_;
}

void DModbusDevice::setConnectType(const ConnectType type) {
	connectType_ = type;
}

ConnectType DModbusDevice::connectType() const {
	return connectType_;
}

void DModbusDevice::setIp(const QString& ip) {
	ip_ = ip;
}

QString DModbusDevice::ip() const {
	return ip_;
}

void DModbusDevice::setTcpPort(const qint32 port) {
	tcp_port_ = port;
}

qint32 DModbusDevice::tcpPort() const {
	return tcp_port_;
}


void DModbusDevice::setPort(const QString& port)
{
	port_ = port;
}

QString DModbusDevice::port() const
{
	return port_;
}

void DModbusDevice::setBaudRate(qint32 baudRate)
{
	baudRate_ = baudRate;
}

qint32 DModbusDevice::baudRate() const
{
	return baudRate_;
}

void DModbusDevice::setDataBits(QSerialPort::DataBits dataBits)
{
	dataBits_ = dataBits;
}

QSerialPort::DataBits DModbusDevice::dataBits() const
{
	return dataBits_;
}

void DModbusDevice::setParity(QSerialPort::Parity parity)
{
	parity_ = parity;
}

QSerialPort::Parity DModbusDevice::parity() const
{
	return parity_;
}

void DModbusDevice::setStopBits(QSerialPort::StopBits stopBits)
{
	stopBits_ = stopBits;
}

QSerialPort::StopBits DModbusDevice::stopBits() const
{
	return stopBits_;
}

void DModbusDevice::setTimeout(qint32 timeout)
{
	timeout_ = timeout;
}

qint32 DModbusDevice::timeout() const
{
	return timeout_;
}

void DModbusDevice::setAddress(quint8 address)
{
	address_ = address;
}
quint8 DModbusDevice::address() const
{
	return address_;
}

QModbusDevice::Error DModbusDevice::error()
{
	return baseDevice()->error();
}

QString DModbusDevice::errorString()
{
	return baseDevice()->errorString();
}

bool DModbusDevice::connect()  {
	bool result;
	if (this->thread() == QThread::currentThread()) {
		connectSlot(result);
	}
	else {
		emit connectSignal(result);
	}
	return result;
}

void DModbusDevice::disconnect()  {

	if (this->thread() == QThread::currentThread()) {
		disconnectSlot();
	}
	else {
		emit disconnectSignal();
	}
}

QModbusDevice::Error DModbusDevice::read(quint16 start_address, quint16& value) const {
	QModbusDevice::Error error;
	if (this->thread() == QThread::currentThread()) {
		readSlot(start_address, value, error);
	}
	else {
		emit readSignal(start_address, value, error);
	}
	return error;
}

QModbusDevice::Error DModbusDevice::read(quint16 start_address, quint16 count, QVector<quint16>& values) const {
	QModbusDevice::Error error;
	if (this->thread() == QThread::currentThread()) {
		readSlot(start_address, count, values, error);
	}
	else {
		emit readSignal(start_address, count, values, error);
	}
	return error;
}

QModbusDevice::Error DModbusDevice::read2(quint16 start_address, quint16 count, QVector<bool>& values) const {
	QModbusDevice::Error error;
	if (this->thread() == QThread::currentThread()) {
		read2Slot(start_address, count, values, error);
	}
	else {
		emit read2Signal(start_address, count, values, error);
	}
	return error;
}

QModbusDevice::Error DModbusDevice::read3(quint16 start_address, quint16 count, QVector<bool>& values) const {
	QModbusDevice::Error error;
	if (this->thread() == QThread::currentThread()) {
		read3Slot(start_address, count, values, error);
	}
	else {
		emit read3Signal(start_address, count, values, error);
	}
	return error;

}

QModbusDevice::Error DModbusDevice::read4(quint16 start_address, quint16 count, QVector<quint16>& values) const {
	QModbusDevice::Error error;
	if (this->thread() == QThread::currentThread()) {
		read4Slot(start_address, count, values, error);
	}
	else {
		emit read4Signal(start_address, count, values, error);
	}
	return error;
}


QModbusDevice::Error DModbusDevice::read(QModbusDataUnit::RegisterType type, quint16 start_address, quint16 count, QVector<quint16>& values) const {
	QModbusDevice::Error error;
	if (this->thread() == QThread::currentThread()) {
		readSlot(type, start_address, count, values, error);
	}
	else {
		emit readSignal(type, start_address, count, values, error);
	}
	return error;
}

QModbusDevice::Error DModbusDevice::write2(quint16  start_address, bool op) {
	QModbusDevice::Error error;
	if (this->thread() == QThread::currentThread()) {
		write2Slot(start_address, op, error);
	}
	else {
		emit write2Signal(start_address, op, error);
	}
	return error;
}

QModbusDevice::Error DModbusDevice::write(quint16 start_address, quint16 value) const {
	QModbusDevice::Error error;
	if (this->thread() == QThread::currentThread()) {
		writeSlot(start_address, value, error);
	}
	else {
		emit writeSignal(start_address, value, error);
	}
	return error;
}

QModbusDevice::Error DModbusDevice::write(quint16 start_address, quint16 count, const QVector<quint16>& values) const {
	QModbusDevice::Error error;
	if (this->thread() == QThread::currentThread()) {
		writeSlot(start_address,count, values, error);
	}
	else {
		emit writeSignal(start_address, count,  values, error);
	}
	return error;
}

QModbusDevice::Error DModbusDevice::write(QModbusDataUnit::RegisterType type, quint16 start_address, quint16 count,
	const QVector<quint16>& values) const {
	QModbusDevice::Error error;
	if (this->thread() == QThread::currentThread()) {
		writeSlot(type, start_address, count, values, error);
	}
	else {
		emit writeSignal(type, start_address, count, values, error);
	}
	return error;
}

DModbusDevice::~DModbusDevice()
{
	delete client_;
}

配置连接类型和配置参数，我通过读写ini将配置信息保存在本地。在这里插入图片描述测试读写线圈是否正常在这里插入图片描述

测试写保持寄存器在这里插入图片描述

monkeykind_
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Modbus TCP转Modbus RTU
09-15
支持Modbus TCP转Modubus RTU。RTU可以为RS232或者RS485。 支持RTU做主站或者Modubs TCP做主站。 支持多主机访问支持，最多连接100个TCP客户端。 支持所有的Modubus功能码和寄存器范围。 同时也可以做普通串口服务器使用。 ZLAN5142 概述 ZLAN5142 Modbus网关是上海卓岚信息科技有限公司开发的一款在Modbus TCP和Modbus RTU之间进行协议转化的转换器，其中Modbus RTU可以是RS485也可以是RS232接口。 ZLAN5142具备了强大的多主机访问支持功能和RS485总线冲突控制功能。所谓多主机功能是指，ZLAN5142作为Modbus TCP服务器时可以支持多达100个TCP客户端同时连接，多个TCP连接可以随机性的访问，ZLAN5142能够分别对不同的连接给出正确应答，保证数据稳定不丢包。相对于RS485总线只能够有一个主机进行访问，ZLAN5142实现了“多主机”功能。ZLAN5142实现了RS485总线的冲突控制，防止了多主机时的串口总线抢占问题。 另外，将ZLAN5142的“转化协议”选择为“无”，也可以当作普通的透明传输的串口服务器使用。但是不同于普通的串口服务器例如ZLAN5102，ZLAN5142即使作为普通串口服务器模式下也可以支持“多主机”功能，可解决多个计算机或主站如何同时监控一个串口设备的难题。 特点 支持Modbus TCP转Modubus RTU，RTU可以为RS232或者RS485。 支持RTU做主站或者TCP做主站。 支持多主机访问支持，最多连接100个TCP客户端。 支持1200～460800波特率。 支持RS485总线冲突调度机制，防止总线冲突。 支持所有的Modubus功能码和寄存器范围。 可作为普通的透传串口服务器使用，具备ZLAN5102相同功能。 小于1W的低功耗设计。 内嵌485防雷保护功能，适合室外485通信。 支持DNS，满足通过域名实现通信的要求。支持DHCP。 2KV网络浪涌保护。 外壳采用抗辐射的SECC板，保证在高电磁辐射区也能够正常工作。 规格 网络界面 以太网 10/100 Mbps, RJ45 保护 内建2KV电磁隔离 串口界面 界面 RS-232/485 串口数 1 校验位 None, Even, Odd, Space, Mark 数据位 5～9 停止位 1,2 流控 RTS/CTS,DTR/DCR, XON/XOFF 速率 1200bps～460800bps 软件特性 协议 TCP,HTTP,UDP,ICMP,ARP,IP,DNS,DHCP 虚拟串口平台 Windows 95/98/ME/NT/2000/XP/WIN7/WIN8 配置方式 Web浏览器、卓岚ZLVirCom、串口类AT命令 电器特性 电压输入 DC9～24V，100mA 机械特性 外壳材料 抗电磁材料SECC钢板 尺寸 长×宽×高=9.4cm×6.5cm×2.5cm 工作环境 工作温度，湿度 -45～85℃，5～95% RH 储存温度，湿度 -45～165℃，5～95% RH W
如何快速实现Modbus RTU和Modbus TCP协议转换？
工业智能网关
08-18 1728
工业现场设备经过物通博联网关采集底下多台设备（如各个品牌的PLC、仪器仪表、水电表等），采集到的数据在网关端经过协议解析、数据处理后，将数据格式转换成 Modbus TCP 协议，转发给上位机（如触摸屏、上位机软件：Poll、PLC等等），从而实现通过一个上位机软件或者设备触摸屏监控管理现场各种不同型号设备的数据。03物通博联WG系列工业智能网关，是具备两化融合和边缘计算为一体的高可靠性工业智能网关，实现对复杂的智能设备的数据采集、边缘计算、标准化和云端接入。过滤、报警、跳变、公式、本地编程等。...
STM32F103移植FreeModbus同时实现ModbusRTU和ModbusTCP.zip
06-16
STM32F103移植FreeModbus实现ModbusRTU和ModbusTCP同时工作。工程已验证，可以直接使用。
Modbus转Modbus TCP的几种姿势
weixin_42660214的博客
03-14 4914
导读 Modbus协议是工业现场串口设备之间常用的连接方式，并基于不同连接存在多种变种的协议；其中最常见的就是串口Modbus（RTU/ASCII）和以太网Modbus TCP两种。 在实际工业现场，需要Modbus两种协议之间转换的应用不在少数。对此上海泗博利用自行研发的ES系列网关提供一系列的解决方案，轻松实现Modbus TCP与Modbus RTU/ASCII之间的转换。 典型应用一 多以太网主站连接多台串口从站：用ES系列网关将多台Modbus从站设备连接到以太网并与SCADA软件或PLC对接。
linux串口服务器编程,基于Linux的串口服务器设计与实现
weixin_31419153的博客
05-06 643
Modbus TCP/RTU相互转换功能的实现这一步是串口服务器设计的关键，其转换重点在于CRC校验和MBPA报头的变换。在这里，定义mod2tcp函数来完成Modbus RTU到TCP格式的转换，定义tcp2mod函数来完成Modbus TCP到RTU格式的数据转换。例如，来自Modbus主站的TCP协议请求，经串口服务器转换成Modbus RTU格式，经485口发送给从站，并将从站相应数据经4...
java实现modbus rtu协议与 modscan等工具（4）rtu转tcp
weixin_42240941的博客
12-23 2506
一 由于xx原因，将modscan，modmis工具，换为了modbus poll 与modbus slave 都是模拟主从设备的工具，大同小异 二 硬件方，不想在一台服务器上连接太多的usb转串口。所以使用rtu转tcp 注：rtu转tcp 指 使用modbus rtu over tcp 而不是 modbus tcp modbus tcp是没有从设备id这个概念的 三 差异 原本的连接方式 java服务器 -> 主机com串口(usb转)->从设备串口（...
modbus rtu 接口转换软件源码，可以将原独占串口扩展为新串口和modbus tcp
jHdLhfNobx的博客
10-23 185
这样，旧系统可以继续使用原有的数据采集方式，同时新系统也可以通过Modbus TCP RTU采集数据，实现了设备数据采集的无缝衔接。我们的源代码还为用户提供了更多的自主开发空间，让用户可以根据自己的需求，对软件进行更加深入的定制和扩展。modbus rtu 接口转换软件源码，可以将原独占串口扩展为新串口和modbus tcp，保证原有系统数据采集方式不变，同时可以供其他系统通过modbus tcp rtu采集数据。用户可以根据自己的需求，对代码进行修改和适配，从而实现在不同平台上的运行。
aix 查询db2客户端版本_S7-1200 MODBUS TCP客户端指令使用方法
weixin_39859715的博客
12-05 356
S7-1200 Modbus TCP 通信指令块　　STEP 7 V13 SP1 软件版本中的 Modbus TCP 库指令目前最新的版本已升至V4.0，该版本的使用需要具备以下两个条件：1. 软件版本：STEP 7 V13 SP1及其以上2. 固件版本：S7-1200 CPU 的固件版本V4.1图1. Modbus TCP V4.0 版本指令块S7-1200 Modbus TCP 实验环境　　下...
ModBus RTU与ModBus TCP通信协议详解
成都亿佰特的博客
02-24 1350
Modbus通信协议由Modicon公司（现已经为施耐德公司并购，成为其旗下的子品牌）于1979年发明的，是全球最早用于工业现场的总线规约。由于其免费公开发行，该协议免费使用，Modbus通信协议采用的是主从通信模式（Master/Slave)。在控制方面应用广泛，促进Modbus协议在全球得到了很好的发展。Modbus通信协议具有多个变种，具有支持串口（主要是RS-485总线id=885），以太网多个版本，其中最著名的是Modbus TCP , Modbus ASCII和Modbus RTU三种。
modbus串口虚拟服务器,RS485串口服务器实现Modbus-RTU转Modbus-TCP采集串口设备数据...
weixin_42310231的博客
08-09 2162
回顾一下当时踩的坑：我计划是把采集电量这个任务也挂到NAS上(DS218+)。于是把采集数据的RS485(Modbus-RUT转)USB连接到NAS的USB口，发现调用不到，一查NAS上有4个串口，然后没有一个能用，找商家一问：Nas的USB口只支持存储设备，其他不支持。结果很明显，不能用NAS跑采集任务。于是我在某宝上找到了一款RS485串口服务器，它天生就是为了填平我踩的这个坑：因为它能完成M...
Modbus协议中文版-国标_modbus_modbusRTU_modbusTCP_
10-01
Modbus-RTU、Modbus-TCP国际标准中文版
QT环境下实现ModbusRTU以及ModBusTCP 支持功能码：0x01、0x03、0x0f、0x10
06-25
QT环境下实现ModbusRTU以及ModBusTCP。支持功能码：0x01、0x03、0x0f、0x10 适用人群，想了解Modbus协议的人，以及从事相关行业的人。了解了这个协议，对于学习其他协议如CAN,1533B等都非常容易，其实这些协议是原理...
ModBusTCP 和 ModBusRtu
10-11
找了好多ModBus 的资源，只有这个可以真的用起来了。包含了ModBusTCP 和 ModBusRtu 两个部分。
基于Java的modbusRTU通信
06-13
基于Java的modbusRTU通信
工业智能网关BL110应用之二十八：Modbus RTU 转Modbus TCP
钡铼技术工业物联网
09-07 1681
配置Modbus RTU转Modbus TCP协议，先要设置COM的模式为“Modbus RTU转Modbus TCP”，并设置COM的参数，才能配置Modbus RTU转Modbus TCP协议的参数。4个COM都可以选择Modbus RTU转Modbus TCP协议，以COM3作Modbus RTU转Modbus TCP为例，操作步骤：先在COM3选择Modbus RTU转Modbus TCP模式，并配置COM口参数，点击确定跳转到“数据服务”的“Modbus RTU转Modbus TCP”进行设置。
RTU转ModbusTCP网关modbusrtu转tcp协议
hkyc1988的博客
07-20 349
现场的PLC是三菱Q03UDVCPU通过一个串口通信模块QJ71C24N通过一个4路485分配器，与4台变频器走modbus RTU 通信，出现了一个问题，现在4台变频器中的其中某台出现问题，plc与变频器的通信就会中断影响生产。注意：修改电脑的IP我地址的设定方式与您所用系统有关，请查询使用系统的说明进行IP地址的设定，电脑原来的IP地址需要记录下来，等YC-TCP-RTU模块的IP地址完成之后，在将电脑恢复原来的IP设定。选中左上角设备IP-点击配置按钮。
ModbusRTU转ModbusTCP，RS232/RS485转以太网模块
wayjun0903的博客
12-05 463
WJ102是维君瑞科技开发的一款工业级RS232/485和TCP/IP之间协议转化器。该串口服务器用来将TCP网络数据包或UDP数据包与RS232或RS485接口数据实现透明传输，串口服务器可以方便地使得串口设备连接到以太网和Internet，实现串口设备的网络化管理。和同类产品相比，其显著特点是稳定性可以全双工、不间断发送大批量数据而不丢失一字节。
Modbus-RTU -- TCP协议讲解（从入门到进阶）
最新发布
LKHzzzzz的博客
12-18 3506
（200表示请求已经成功）客户端发送一个HTTP请求到服务器的请求消息包括以下格式：请求行、请求头部、空行和请求数据四个部分组成，下图给出了请求报文的一般格式。Modbus ASCII：运行在串口上协议，通过ASCII传输，每次传输内容的开始和结束都会有标志，传输效率低，适用于小数据传输。Modbus 协议是现在国内工业领域应用最多的协议，不知PLC设备，各种终端设备，例如：水表、电表、工业称。Modbus RTU: 运行在串口上的协议,通过二进制的表现形式以及紧凑的数据结构，通信效率高，应用广泛。
Modbus-RTU和Modbus-TCP如何进行协议解析和转换
wtbl007的博客
09-28 1167
工业现场设备经过物通博联网关采集底下多台设备（如各个品牌的PLC、仪器仪表、水电表等），采集到的数据在网关端经过协议解析、数据处理后，将数据格式转换成 Modbus TCP 协议，转发给上位机（如触摸屏、上位机软件：Poll、PLC等等），从而实现通过一个上位机软件或者设备触摸屏监控管理现场各种不同型号设备的数据。工业网关的出现可以实现工业协议自动解析和转换，只要工程师熟悉网关的操作，就能快速实现设备的远程监控和程序的上下载。
modbus rtu转modbus tcp
08-03
Modbus RTU转Modbus TCP是一种协议转换的功能，可以将Modbus RTU协议转换为Modbus TCP协议，实现不同设备之间的通信。根据引用[1]和引用[2]的说明，配置Modbus RTU转Modbus TCP的步骤如下： 1. 选择要操作的COM口，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值