Modbus动态链接库供多语言使用 | Go

Modbus协议控制动态链接库

应用场景

基于各门语言都有各自的modbus协议库，且良莠不齐，而且在具体的框架下可能存在版本依赖问题， 而且对modbus协议存在比较多的细节处理，可以查看modbus slave、或者modbus poll中相关的配置可知， 数据类型对应读写寄存器个数、大小端的处理等等细节，所以将以常用的场景下的配置编写动态链接库供其他语言调用。 

编程语言

因为我不会写C语言，这里使用Go语言编写代码，以C函数分享库的模式编译成动态链接库
将以Python与Node.js调用的示例演示

辅助工具下载地址

Modbus Poll: 激活码(仅供学习 5A5742575C5D10) -> 模拟主站

链接: https://pan.baidu.com/s/1Sk2m6HWTU0-hE82-BxPvKA 提取码: 1fwn  

Modbus Slave: 激活码(仅供学习 5455415451475662) -> 模拟从站

链接: https://pan.baidu.com/s/137w1-2gGQ3bETvbyBefNQg 提取码: 9433  

编写Go代码示例 使用Cgo引入C函数

• Modbus TCP示例

package main  /* #include <stdlib.h> */ import ( 	"C" 	"bytes" 	"encoding/binary" 	"fmt" 	"log" 	"math" 	"time"  	"github.com/goburrow/modbus" ) import "strings"  var handler *modbus.TCPClientHandler  //export Connect func Connect(ip *C.char, port C.int) C.int { 	log.Printf("Connect ...") 	handler = modbus.NewTCPClientHandler(fmt.Sprintf("%s:%d", C.GoString(ip), int(port))) 	handler.Timeout = 250 * time.Millisecond 	err := handler.Connect() 	if err != nil { 		log.Printf("Connect error: %v", err) 		return -1 	} 	return 0 }  //export Close func Close() C.int { 	log.Printf("Close ...") 	err := handler.Close() 	if err != nil { 		log.Printf("Close error: %v", err) 		return -1 	} 	return 0 }  //ReadRegister 一般错误返回 -1 连接失败返回 -3 //export ReadRegister func ReadRegister(slaveId C.int, address C.int, dataType *C.char, data *C.double) C.int { 	var results []byte 	var err error  	handler.SlaveId = byte(slaveId)  	client := modbus.NewClient(handler)  	dt := C.GoString(dataType)  	switch dt { 	case "int16": 		results, err = client.ReadInputRegisters(uint16(address), 1) 	case "int32", "float": 		results, err = client.ReadInputRegisters(uint16(address), 2) 	case "int64", "double": 		results, err = client.ReadInputRegisters(uint16(address), 4) 	}  	if err != nil { 		switch { 		case strings.Contains(err.Error(), "connection"): 			log.Println("Connection error:", err) 			return -3 		case strings.Contains(err.Error(), "timeout"): 			log.Println("Timeout error:", err) 			return -1 		default: 			log.Println("Other error:", err) 			return -1 		} 	}  	var value float64 	switch dt { 	case "int16": 		var intValue int16 		err = binary.Read(bytes.NewReader(results), binary.BigEndian, &intValue) 		value = float64(intValue) 	case "int32": 		var intValue int32 		err = binary.Read(bytes.NewReader(results), binary.BigEndian, &intValue) 		value = float64(intValue) 	case "float": 		var floatValue float32 		err = binary.Read(bytes.NewReader(results), binary.BigEndian, &floatValue) 		value = float64(floatValue) 	case "int64": 		var intValue int64 		err = binary.Read(bytes.NewReader(results), binary.BigEndian, &intValue) 		value = float64(intValue) 	case "double": 		err = binary.Read(bytes.NewReader(results), binary.BigEndian, &value) 	}  	if err != nil { 		log.Println(err) 		return -1 	}  	*data = C.double(value) 	return 0 }  //ReadHoldingRegister 一般错误返回 -1 连接失败返回 -3 //export ReadHoldingRegister func ReadHoldingRegister(slaveId C.int, address C.int, dataType *C.char, data *C.double) C.int { 	var results []byte 	var err error  	handler.SlaveId = byte(slaveId)  	client := modbus.NewClient(handler)  	dt := C.GoString(dataType) 	// startTime := time.Now() 	switch dt { 	case "int16": 		results, err = client.ReadHoldingRegisters(uint16(address), 1) 	case "int32", "float": 		results, err = client.ReadHoldingRegisters(uint16(address), 2) 	case "int64", "double": 		results, err = client.ReadHoldingRegisters(uint16(address), 4) 	} 	// endTime := time.Now()  	// // 计算时间差 	// duration := endTime.Sub(startTime) 	// fmt.Printf("Takes: %vn", duration) 	if err != nil { 		switch { 		case strings.Contains(err.Error(), "connection"): 			log.Println("Connection error:", err) 			return -3 		case strings.Contains(err.Error(), "timeout"): 			log.Println("Timeout error:", err) 			return -1 		default: 			log.Println("Other error:", err) 			return -1 		} 	}  	var value float64 	switch dt { 	case "int16": 		var intValue int16 		err = binary.Read(bytes.NewReader(results), binary.BigEndian, &intValue) 		value = float64(intValue) 	case "int32": 		var intValue int32 		err = binary.Read(bytes.NewReader(results), binary.BigEndian, &intValue) 		value = float64(intValue) 	case "float": 		var floatValue float32 		err = binary.Read(bytes.NewReader(results), binary.BigEndian, &floatValue) 		value = float64(floatValue) 	case "int64": 		var intValue int64 		err = binary.Read(bytes.NewReader(results), binary.BigEndian, &intValue) 		value = float64(intValue) 	case "double": 		err = binary.Read(bytes.NewReader(results), binary.BigEndian, &value) 	}  	if err != nil { 		log.Println(err) 		return -1 	}  	*data = C.double(value) 	return 0 }  //export WriteRegister func WriteRegister(slaveId C.int, address C.int, dataType *C.char, value C.double) C.int { 	var err error  	handler.SlaveId = byte(slaveId) 	client := modbus.NewClient(handler)  	dt := C.GoString(dataType)  	switch dt { 	case "int16": 		var intValue int16 = int16(value) 		_, err = client.WriteSingleRegister(uint16(address), uint16(intValue)) 	case "int32": 		var intValue int32 = int32(value) 		results := make([]byte, 4) 		binary.BigEndian.PutUint32(results, uint32(intValue)) 		_, err = client.WriteMultipleRegisters(uint16(address), uint16(len(results)/2), results) 	case "float": 		var floatValue float32 = float32(value) 		results := make([]byte, 4) 		binary.BigEndian.PutUint32(results, math.Float32bits(floatValue)) 		_, err = client.WriteMultipleRegisters(uint16(address), uint16(len(results)/2), results) 	case "int64": 		var intValue int64 = int64(value) 		results := make([]byte, 8) 		binary.BigEndian.PutUint64(results, uint64(intValue)) 		_, err = client.WriteMultipleRegisters(uint16(address), uint16(len(results)/2), results) 	case "double": 		var doubleValue float64 = float64(value) 		results := make([]byte, 8) 		binary.BigEndian.PutUint64(results, math.Float64bits(doubleValue)) 		_, err = client.WriteMultipleRegisters(uint16(address), uint16(len(results)/2), results) 	default: 		return -1 	}  	if err != nil { 		switch { 		case strings.Contains(err.Error(), "connection"): 			log.Println("Connection error:", err) 			return -3 		case strings.Contains(err.Error(), "timeout"): 			log.Println("Timeout error:", err) 			return -1 		default: 			log.Println("Other error:", err) 			return -1 		} 	} 	return 0 }  func main() {} 

• Modbus RTU示例

package main  /* #include <stdlib.h> */ import ( 	"C" 	"bytes" 	"encoding/binary" 	"log" 	"math" 	"time"  	"github.com/goburrow/modbus" ) import "strings"  var handler *modbus.RTUClientHandler  //export Connect func Connect(port *C.char, baudrate C.int) C.int { 	log.Printf("Connect ...") 	handler = modbus.NewRTUClientHandler(C.GoString(port)) 	handler.BaudRate = int(baudrate) 	handler.DataBits = 8 	handler.Parity = "N" 	handler.StopBits = 1 	handler.Timeout = 250 * time.Millisecond 	err := handler.Connect() 	if err != nil { 		log.Printf("Connect error: %v", err) 		return -1 	} 	return 0 }  //export Close func Close() C.int { 	log.Printf("Close ...") 	err := handler.Close() 	if err != nil { 		log.Printf("Close error: %v", err) 		return -1 	} 	return 0 }  //ReadRegister 一般错误返回 -1 连接失败返回 -3 //export ReadRegister func ReadRegister(slaveId C.int, address C.int, dataType *C.char, data *C.double) C.int { 	var results []byte 	var err error  	handler.SlaveId = byte(slaveId)  	client := modbus.NewClient(handler)  	dt := C.GoString(dataType)  	switch dt { 	case "int16": 		results, err = client.ReadInputRegisters(uint16(address), 1) 	case "int32", "float": 		results, err = client.ReadInputRegisters(uint16(address), 2) 	case "int64", "double": 		results, err = client.ReadInputRegisters(uint16(address), 4) 	}  	if err != nil { 		switch { 		case strings.Contains(err.Error(), "connection"): 			log.Println("Connection error:", err) 			return -3 		case strings.Contains(err.Error(), "timeout"): 			log.Println("Timeout error:", err) 			return -1 		default: 			log.Println("Other error:", err) 			return -1 		} 	}  	var value float64 	switch dt { 	case "int16": 		var intValue int16 		err = binary.Read(bytes.NewReader(results), binary.BigEndian, &intValue) 		value = float64(intValue) 	case "int32": 		var intValue int32 		err = binary.Read(bytes.NewReader(results), binary.BigEndian, &intValue) 		value = float64(intValue) 	case "float": 		var floatValue float32 		err = binary.Read(bytes.NewReader(results), binary.BigEndian, &floatValue) 		value = float64(floatValue) 	case "int64": 		var intValue int64 		err = binary.Read(bytes.NewReader(results), binary.BigEndian, &intValue) 		value = float64(intValue) 	case "double": 		err = binary.Read(bytes.NewReader(results), binary.BigEndian, &value) 	}  	if err != nil { 		log.Println(err) 		return -1 	}  	*data = C.double(value) 	return 0 }  //ReadHoldingRegister 一般错误返回 -1 连接失败返回 -3 //export ReadHoldingRegister func ReadHoldingRegister(slaveId C.int, address C.int, dataType *C.char, data *C.double) C.int { 	var results []byte 	var err error  	handler.SlaveId = byte(slaveId)  	client := modbus.NewClient(handler)  	dt := C.GoString(dataType) 	// startTime := time.Now() 	switch dt { 	case "int16": 		results, err = client.ReadHoldingRegisters(uint16(address), 1) 	case "int32", "float": 		results, err = client.ReadHoldingRegisters(uint16(address), 2) 	case "int64", "double": 		results, err = client.ReadHoldingRegisters(uint16(address), 4) 	} 	// endTime := time.Now()  	// // 计算时间差 	// duration := endTime.Sub(startTime) 	// fmt.Printf("Takes: %vn", duration) 	if err != nil { 		switch { 		case strings.Contains(err.Error(), "connection"): 			log.Println("Connection error:", err) 			return -3 		case strings.Contains(err.Error(), "timeout"): 			log.Println("Timeout error:", err) 			return -1 		default: 			log.Println("Other error:", err) 			return -1 		} 	}  	var value float64 	switch dt { 	case "int16": 		var intValue int16 		err = binary.Read(bytes.NewReader(results), binary.BigEndian, &intValue) 		value = float64(intValue) 	case "int32": 		var intValue int32 		err = binary.Read(bytes.NewReader(results), binary.BigEndian, &intValue) 		value = float64(intValue) 	case "float": 		var floatValue float32 		err = binary.Read(bytes.NewReader(results), binary.BigEndian, &floatValue) 		value = float64(floatValue) 	case "int64": 		var intValue int64 		err = binary.Read(bytes.NewReader(results), binary.BigEndian, &intValue) 		value = float64(intValue) 	case "double": 		err = binary.Read(bytes.NewReader(results), binary.BigEndian, &value) 	}  	if err != nil { 		log.Println(err) 		return -1 	}  	*data = C.double(value) 	return 0 }  //export WriteRegister func WriteRegister(slaveId C.int, address C.int, dataType *C.char, value C.double) C.int { 	var err error  	handler.SlaveId = byte(slaveId) 	client := modbus.NewClient(handler)  	dt := C.GoString(dataType)  	switch dt { 	case "int16": 		var intValue int16 = int16(value) 		_, err = client.WriteSingleRegister(uint16(address), uint16(intValue)) 	case "int32": 		var intValue int32 = int32(value) 		results := make([]byte, 4) 		binary.BigEndian.PutUint32(results, uint32(intValue)) 		_, err = client.WriteMultipleRegisters(uint16(address), uint16(len(results)/2), results) 	case "float": 		var floatValue float32 = float32(value) 		results := make([]byte, 4) 		binary.BigEndian.PutUint32(results, math.Float32bits(floatValue)) 		_, err = client.WriteMultipleRegisters(uint16(address), uint16(len(results)/2), results) 	case "int64": 		var intValue int64 = int64(value) 		results := make([]byte, 8) 		binary.BigEndian.PutUint64(results, uint64(intValue)) 		_, err = client.WriteMultipleRegisters(uint16(address), uint16(len(results)/2), results) 	case "double": 		var doubleValue float64 = float64(value) 		results := make([]byte, 8) 		binary.BigEndian.PutUint64(results, math.Float64bits(doubleValue)) 		_, err = client.WriteMultipleRegisters(uint16(address), uint16(len(results)/2), results) 	default: 		return -1 	}  	if err != nil { 		switch { 		case strings.Contains(err.Error(), "connection"): 			log.Println("Connection error:", err) 			return -3 		case strings.Contains(err.Error(), "timeout"): 			log.Println("Timeout error:", err) 			return -1 		default: 			log.Println("Other error:", err) 			return -1 		} 	} 	return 0 }  func main() {} 

编译动态链接库

Go语言支持交叉编译成各个平台的二进制运行程序，但是Cgo不支持，可以去寻找第三方库去处理这个问题，这里选择用Docker容器

• 编译命令

windows下是modbus.dll，Linux下是 modbus.so，Macos下是 modbus.dylib

go build -o modbus.so -buildmode=c-shared main.go 

• 其他平台编译，比如树莓派，选择使用docker容器

这里找一个 arm32v7 的docker容器，可以通过 docker search arm32v7的方式去搜索，我是试了几个选了个node版本的容器， 不同版本里面的 GLIBC 可能不一样，需要先查看你的树莓派上 GLIBC版本，通过命令 strings /lib/*/libc.so.* | grep GLIBC， 根据版本我选择了node v16的版本下载镜像 

• 下载镜像、创建容器

docker run -itd --name raspberry arm32v7/node:16

• 进入容器、安装go环境

wget -e http_proxy=127.0.0.1:10809  https://studygolang.com/dl/golang/go1.17.linux-armv6l.tar.gz tar -zxvf go1.17.linux-armv6l.tar.gz go/ mv go /usr/local/go # 安装vim apt-get update apt-get install vim -y # 加入系统环境 vim /etc/profile # 加入内容到最后一行 export PATH=$PATH:/usr/local/go/bin source /etc/profile # 每次进入容器都要执行一次，要是没有找到go命令的话 

• 将Go代码文件拷贝至容器

docker cp modbus_dir raspberry:/  # 将modbus_dir拷贝至容器raspberry的 / 目录下 

• 进入容器编译动态链接库

docker exec -it raspberry /bin/bash cd modbus_dir go build -o modbus.so -buildmode=c-shared main.go 

• 将编译后的动态链接库拷贝到宿主机

exit # 退出容器 docker cp raspberry:/modbus_dir/modbus.so ./  # 拷贝至当前目录 

应用示例

• Python

modbus tcp示例

import ctypes import platform  # 加载共享库 print(platform.system()) if platform.system() == "Windows":   modbus = ctypes.CDLL('./modbus.dll') elif platform.system() == "Darwin":   modbus = ctypes.CDLL('./modbus.dylib') else:  # 树莓派   modbus = ctypes.CDLL('./modbus.so')  # 定义函数参数类型和返回类型 modbus.ReadRegister.argtypes = [ctypes.c_int, ctypes.c_int, ctypes.c_char_p, ctypes.POINTER(ctypes.c_double)] modbus.ReadRegister.restype = ctypes.c_int  modbus.WriteRegister.argtypes = [ctypes.c_int, ctypes.c_int, ctypes.c_char_p, ctypes.c_double] modbus.WriteRegister.restype = ctypes.c_int  modbus.ReadHoldingRegister.argtypes = [ctypes.c_int, ctypes.c_int, ctypes.c_char_p, ctypes.POINTER(ctypes.c_double)] modbus.ReadHoldingRegister.restype = ctypes.c_int  modbus.Connect.argtypes = [ctypes.c_char_p, ctypes.c_int] modbus.Connect.restype = ctypes.c_int  modbus.Close.argtypes = [] modbus.Close.restype = ctypes.c_int  # 调用ReadRegister函数 modbus.Connect(b'192.168.1.138', 502)  # 写控制寄存器 for i in range(50):   data = ctypes.c_double()   result = modbus.WriteRegister(1, 30, b'float', 123.45 + i)   if result == -3:     print('Connect error.')   if result == 0:     print('Write success.')  # 读控制寄存器 | 读输入寄存器时改成 ReadRegister for i in range(50):   data = ctypes.c_double()   result = modbus.ReadHoldingRegister(1, 30, b'int16', ctypes.byref(data))   print('Read Result:', result, data.value) modbus.Close() 

modbus rtu示例

import ctypes import platform  # 加载共享库 print(platform.system()) if platform.system() == "Windows":   modbus = ctypes.CDLL('./modbus-rtu.dll') elif platform.system() == "Darwin":   modbus = ctypes.CDLL('./modbus-rtu.dylib') else:  # 树莓派   modbus = ctypes.CDLL('./modbus-rtu.so')  # 定义函数参数类型和返回类型 modbus.ReadRegister.argtypes = [ctypes.c_int, ctypes.c_int, ctypes.c_char_p, ctypes.POINTER(ctypes.c_double)] modbus.ReadRegister.restype = ctypes.c_int  modbus.WriteRegister.argtypes = [ctypes.c_int, ctypes.c_int, ctypes.c_char_p, ctypes.c_double] modbus.WriteRegister.restype = ctypes.c_int  modbus.ReadHoldingRegister.argtypes = [ctypes.c_int, ctypes.c_int, ctypes.c_char_p, ctypes.POINTER(ctypes.c_double)] modbus.ReadHoldingRegister.restype = ctypes.c_int  modbus.Connect.argtypes = [ctypes.c_char_p, ctypes.c_int] modbus.Connect.restype = ctypes.c_int  modbus.Close.argtypes = [] modbus.Close.restype = ctypes.c_int  # 调用ReadRegister函数 modbus.Connect(b'COM2', 9600)  # 写控制寄存器 for i in range(50):   data = ctypes.c_double()   result = modbus.WriteRegister(1, 30, b'float', 123.45 + i)   if result == -3:     print('Connect error.')   if result == 0:     print('Write success.')  # 读控制寄存器 | 读输入寄存器时改成 ReadRegister for i in range(50):   data = ctypes.c_double()   result = modbus.ReadHoldingRegister(1, 30, b'int16', ctypes.byref(data))   print('Read Result:', result, data.value) modbus.Close() 

• Node.js

这是我在electron进行软件开发过程中封装的函数
调用顺序: DefineModbus -> connectModbus -> writeRegisterAsync/readRegisterAsync/readHoldingRegisterAsync -> connectModbus

const ffi = require('ffi-napi'); const ref = require('ref-napi'); const double = ref.types.double; const doublePtr = ref.refType(double); const path = require('path'); import {checkPort} from './net';  let dllPath: string;  console.log(`当前平台: ${process.platform}`)  // darwin  let dllName = 'modbus.dll'; if (process.platform === 'darwin') {   dllName = 'modbus.dylib'; }  if (process.env.MODE === 'development') {   dllPath = path.resolve(`extraResources/dlls/${dllName}`); } else {   dllPath = path.join(process.resourcesPath, 'extraResources', 'dlls', dllName); }  let modbus: any;  const closeModbus = () => {   return new Promise((resolve, reject) => {     modbus.Close.async(       (err: any, result: any) => {         if (err) {           reject(err);         } else {           resolve(result);         }       },     );   }); };  const connectModbus = (ip: string, port: number) => {   return new Promise((resolve, reject) => {     modbus.Connect.async(       ip,       port,       (err: any, result: any) => {         if (err) {           reject(err);         } else {           resolve(result);         }       },     );   }); };  const writeRegisterAsync = (   slaveId: number,   startAddress: number,   dataType: string,   val: number, ) => {   return new Promise((resolve, reject) => {     modbus.WriteRegister.async(       slaveId,       startAddress,       dataType,       val,       (err: any, result: any) => {         if (err) {           reject(err);         } else {           resolve(result);         }       },     );   }); };  const readRegisterAsync = (   slaveId: number,   startAddress: number,   dataType: string,   data: any, ) => {   return new Promise((resolve, reject) => {     modbus.ReadRegister.async(       slaveId,       startAddress,       dataType,       data,       (err: any, result: any) => {         if (err) {           reject(err);         } else {           resolve(result);         }       },     );   }); };  const readHoldingRegisterAsync = (   slaveId: number,   startAddress: number,   dataType: string,   data: any, ) => {   return new Promise((resolve, reject) => {     modbus.ReadHoldingRegister.async(       slaveId,       startAddress,       dataType,       data,       (err: any, result: any) => {         if (err) {           reject(err);         } else {           resolve(result);         }       },     );   }); };  export const ConnectModbus = async (ip: string, port: number) => {   try {     const result = await connectModbus(ip, port);     return [result, 0];   } catch (e) {     return [-1, 0];   } }  export const CloseModbus = async () => {   try {     const result = await closeModbus();     return [result, 0];   } catch(e) {     return [-1, 0];   } }  export const ReadByModbusTcp = async (   slaveId: number,   startAddress: number,   dataType: string,   method: string = 'Input', ) => {   const data = ref.alloc(double);   try {     let result: any;     if (method === 'Input') {       result = await readRegisterAsync(slaveId, startAddress, dataType, data);     } else {       result = await readHoldingRegisterAsync(slaveId, startAddress, dataType, data);     }     return [result, data.deref() as number];   } catch (e) {     console.log(`e :${e}`);     return [0, 0];   } }  export const WriteByModbusTcp = async (   slaveId: number,   startAddress: number,   dataType: string,   val: number, ) => {   try {     const result: any = await writeRegisterAsync(       slaveId,       startAddress,       dataType,       val,     );     return [result, val];   } catch (e) {     return [0, 0];   } }  export const DefineModbus = async () => {   try {     modbus = ffi.Library(dllPath, {       ReadRegister: ['int', ['int', 'int', 'string', doublePtr]],       ReadHoldingRegister: ['int', ['int', 'int', 'string', doublePtr]],       WriteRegister: ['int', ['int', 'int', 'string', 'double']],       Connect: ['int', ['string', 'int']],       Close: ['int', []],     });     console.log('Define Modbus Success.');   } catch (e) {     console.log(`defineModbus error: ${e}`);   }   return dllPath; }  export const CheckConnected = async (ip: string, port: number) => {   try {     const result = await checkPort(ip, port);     return true;   } catch (e) {     return false;   } } 

最后

这里只写了 读写控制寄存器、读输入寄存器，支持数据类型 int16/int32/int64/float/double
可以根据需要加入自己的代码，比如线圈的读写控制设备启停等

动态链接库、源码地址

链接: https://pan.baidu.com/s/1q40gHnftqzGJtUgfws_sdw 提取码: 72o2