- 为Serial表统一做准备
This commit is contained in:
mori 2023-10-21 12:07:37 +08:00
parent 1c9d915adb
commit 27326340e3
4 changed files with 0 additions and 924 deletions

View File

@ -1,38 +0,0 @@
package modbus
import (
"fmt"
"github.com/simonvetter/modbus"
"time"
)
func makeModbusClientConf(conn *Conn) (*modbus.ClientConfiguration, error) {
var connType string
var path = ""
switch conn.ConnType {
case RTU:
connType = "rtu"
path = "/dev/"
case RTUOverTCP:
connType = "rtuovertcp"
case RTUOverUDP:
connType = "rtuoverudp"
case TCP:
connType = "tcp"
case TCPOverUDP:
connType = "udp"
default:
return nil, fmt.Errorf("未知的连接类型")
}
return &modbus.ClientConfiguration{
URL: connType + "://" + path + conn.Addr,
Speed: conn.Speed,
DataBits: conn.DataBits,
Parity: conn.Parity,
StopBits: conn.StopBits,
Timeout: time.Duration(conn.TimeOut) * time.Millisecond,
}, nil
}

View File

@ -1,38 +0,0 @@
package modbus
import (
"fmt"
"github.com/simonvetter/modbus"
"time"
)
func makeModbusClientConf(conn *Conn) (*modbus.ClientConfiguration, error) {
var connType string
var path = ""
switch conn.ConnType {
case RTU:
connType = "rtu"
path = `\\.\`
case RTUOverTCP:
connType = "rtuovertcp"
case RTUOverUDP:
connType = "rtuoverudp"
case TCP:
connType = "tcp"
case TCPOverUDP:
connType = "udp"
default:
return nil, fmt.Errorf("未知的连接类型")
}
return &modbus.ClientConfiguration{
URL: connType + "://" + path + conn.Addr,
Speed: conn.Speed,
DataBits: conn.DataBits,
Parity: conn.Parity,
StopBits: conn.StopBits,
Timeout: time.Duration(conn.TimeOut) * time.Millisecond,
}, nil
}

View File

@ -1,59 +0,0 @@
package modbus
import (
"fmt"
"sync"
)
const (
RTU = 1
RTUOverTCP = 2
RTUOverUDP = 3
TCP = 4
TCPOverUDP = 6
)
type (
Modbus struct {
ModbusList *sync.Map
}
)
func NewModbus() *Modbus {
m := new(Modbus)
m.ModbusList = new(sync.Map)
return m
}
func (m *Modbus) GetModbusClient(connId int) (*Master, error) {
value, ok := m.ModbusList.Load(connId)
if !ok {
return nil, fmt.Errorf("无法在对应Map中获取Key")
}
out, ok := value.(*Master)
if !ok {
return nil, fmt.Errorf("无法将参数转为对应的类型")
}
return out, nil
}
func (m *Modbus) AddModbusClient(conn *Conn) error {
master, err := newMaster(conn).Open()
if err != nil {
return err
}
m.ModbusList.Store(conn.ConnId, master)
return nil
}
func (m *Modbus) RemoveModbusClient(connId int) error {
master, err := m.GetModbusClient(connId)
if err != nil {
return err
}
return master.Close()
}

View File

@ -1,789 +0,0 @@
package modbus
import (
"github.com/simonvetter/modbus"
)
type (
Master struct {
modbus *modbus.ModbusClient
serialChan chan struct{}
conn *Conn // 链接信息
}
Conn struct {
ConnId int // ConnId 连接ID
ConnType int // ConnType 连接类型
ConnName string // ConnName 连接名称
Addr string // Addr 地址
Speed uint // Speed 速度/波特率
DataBits uint // DataBits 数据位
Parity uint // Parity 校验方式
StopBits uint // StopBits 停止位
TimeOut int // TimeOut 超时时间
}
)
func newMaster(conn *Conn) *Master {
m := new(Master)
var tempChan = make(chan struct{}, 1)
tempChan <- struct{}{}
m.serialChan = tempChan
m.conn = conn
return m
}
func (m *Master) Open() (*Master, error) {
<-m.serialChan
defer clearChan(m.serialChan)
conf, err := makeModbusClientConf(m.conn)
if err != nil {
return nil, err
}
tempModbusClient, err := modbus.NewClient(conf)
if err != nil {
return nil, err
}
if err := tempModbusClient.Open(); err != nil {
return nil, err
}
m.modbus = tempModbusClient
//app.L.Infof("·· 连接 id:%d\t名称:%s\t%s", list.ConnId, color.Blue.Sprint(list.ConnName), color.Green.Sprint("激活连接成功"))
return m, nil
}
func (m *Master) Close() error {
<-m.serialChan
defer clearChan(m.serialChan)
return m.modbus.Close()
}
func clearChan(c chan struct{}) {
c <- struct{}{}
}
// ReadHoldRegister 0x03
func (m *Master) ReadHoldRegister(id uint8, addr uint16) (value uint16, err error) {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return 0, err
}
register, err := m.modbus.ReadRegister(addr, modbus.HOLDING_REGISTER)
if err != nil {
return 0, err
}
return register, nil
}
// ReadHoldRegisters 0x03
func (m *Master) ReadHoldRegisters(id uint8, addr uint16, quantity uint16) ([]uint16, error) {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return nil, err
}
register, err := m.modbus.ReadRegisters(addr, quantity, modbus.HOLDING_REGISTER)
if err != nil {
return nil, err
}
return register, nil
}
// ReadHoldingUint32 0x03
func (m *Master) ReadHoldingUint32(id uint8, addr uint16) (uint32, error) {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return 0, err
}
register, err := m.modbus.ReadUint32(addr, modbus.HOLDING_REGISTER)
if err != nil {
return 0, err
}
return register, nil
}
// ReadHoldingUint32s 0x03
func (m *Master) ReadHoldingUint32s(id uint8, addr uint16, quantity uint16) ([]uint32, error) {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return nil, err
}
register, err := m.modbus.ReadUint32s(addr, quantity, modbus.HOLDING_REGISTER)
if err != nil {
return nil, err
}
return register, nil
}
// ReadHoldingUint64 0x03
func (m *Master) ReadHoldingUint64(id uint8, addr uint16) (uint64, error) {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return 0, err
}
register, err := m.modbus.ReadUint64(addr, modbus.HOLDING_REGISTER)
if err != nil {
return 0, err
}
return register, nil
}
// ReadHoldingUint64s 0x03
func (m *Master) ReadHoldingUint64s(id uint8, addr uint16, quantity uint16) ([]uint64, error) {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return nil, err
}
register, err := m.modbus.ReadUint64s(addr, quantity, modbus.HOLDING_REGISTER)
if err != nil {
return nil, err
}
return register, nil
}
// ReadHoldingFloat32 0x03
func (m *Master) ReadHoldingFloat32(id uint8, addr uint16) (float32, error) {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return 0, err
}
register, err := m.modbus.ReadFloat32(addr, modbus.HOLDING_REGISTER)
if err != nil {
return 0, err
}
return register, nil
}
// ReadHoldingFloat32s 0x03
func (m *Master) ReadHoldingFloat32s(id uint8, addr uint16, quantity uint16) ([]float32, error) {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return nil, err
}
register, err := m.modbus.ReadFloat32s(addr, quantity, modbus.HOLDING_REGISTER)
if err != nil {
return nil, err
}
return register, nil
}
// ReadHoldingFloat64 0x03
func (m *Master) ReadHoldingFloat64(id uint8, addr uint16) (float64, error) {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return 0, err
}
register, err := m.modbus.ReadFloat64(addr, modbus.HOLDING_REGISTER)
if err != nil {
return 0, err
}
return register, nil
}
// ReadHoldingFloat64s 0x03
func (m *Master) ReadHoldingFloat64s(id uint8, addr uint16, quantity uint16) ([]float64, error) {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return nil, err
}
register, err := m.modbus.ReadFloat64s(addr, quantity, modbus.HOLDING_REGISTER)
if err != nil {
return nil, err
}
return register, nil
}
// ReadInputRegister 0x04
func (m *Master) ReadInputRegister(id uint8, addr uint16) (uint16, error) {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return 0, err
}
register, err := m.modbus.ReadRegister(addr, modbus.INPUT_REGISTER)
if err != nil {
return 0, err
}
return register, nil
}
// ReadInputRegisters 0x04
func (m *Master) ReadInputRegisters(id uint8, addr uint16, quantity uint16) ([]uint16, error) {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return nil, err
}
register, err := m.modbus.ReadRegisters(addr, quantity, modbus.INPUT_REGISTER)
if err != nil {
return nil, err
}
return register, nil
}
// ReadInputUint32 0x04
func (m *Master) ReadInputUint32(id uint8, addr uint16) (uint32, error) {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return 0, err
}
register, err := m.modbus.ReadUint32(addr, modbus.INPUT_REGISTER)
if err != nil {
return 0, err
}
return register, nil
}
// ReadInputUint32s 0x04
func (m *Master) ReadInputUint32s(id uint8, addr uint16, quantity uint16) ([]uint32, error) {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return nil, err
}
register, err := m.modbus.ReadUint32s(addr, quantity, modbus.INPUT_REGISTER)
if err != nil {
return nil, err
}
return register, nil
}
// ReadInputUint64 0x04
func (m *Master) ReadInputUint64(id uint8, addr uint16) (uint64, error) {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return 0, err
}
register, err := m.modbus.ReadUint64(addr, modbus.INPUT_REGISTER)
if err != nil {
return 0, err
}
return register, nil
}
// ReadInputUint64s 0x04
func (m *Master) ReadInputUint64s(id uint8, addr uint16, quantity uint16) ([]uint64, error) {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return nil, err
}
register, err := m.modbus.ReadUint64s(addr, quantity, modbus.INPUT_REGISTER)
if err != nil {
return nil, err
}
return register, nil
}
// ReadInputFloat32 0x03
func (m *Master) ReadInputFloat32(id uint8, addr uint16) (float32, error) {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return 0, err
}
register, err := m.modbus.ReadFloat32(addr, modbus.INPUT_REGISTER)
if err != nil {
return 0, err
}
return register, nil
}
// ReadInputFloat32s 0x03
func (m *Master) ReadInputFloat32s(id uint8, addr uint16, quantity uint16) ([]float32, error) {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return nil, err
}
register, err := m.modbus.ReadFloat32s(addr, quantity, modbus.INPUT_REGISTER)
if err != nil {
return nil, err
}
return register, nil
}
// ReadInputFloat64 0x03
func (m *Master) ReadInputFloat64(id uint8, addr uint16) (float64, error) {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return 0, err
}
register, err := m.modbus.ReadFloat64(addr, modbus.INPUT_REGISTER)
if err != nil {
return 0, err
}
return register, nil
}
// ReadInputFloat64s 0x03
func (m *Master) ReadInputFloat64s(id uint8, addr uint16, quantity uint16) ([]float64, error) {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return nil, err
}
register, err := m.modbus.ReadFloat64s(addr, quantity, modbus.INPUT_REGISTER)
if err != nil {
return nil, err
}
return register, nil
}
// ReadCoil 0x01
func (m *Master) ReadCoil(id uint8, addr uint16) (bool, error) {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return false, err
}
register, err := m.modbus.ReadCoil(addr)
if err != nil {
return false, err
}
return register, nil
}
// ReadCoils 0x01
func (m *Master) ReadCoils(id uint8, addr uint16, quantity uint16) ([]bool, error) {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return nil, err
}
register, err := m.modbus.ReadCoils(addr, quantity)
if err != nil {
return nil, err
}
return register, nil
}
// ReadDiscreteInput 0x02
func (m *Master) ReadDiscreteInput(id uint8, addr uint16) (bool, error) {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return false, err
}
register, err := m.modbus.ReadDiscreteInput(addr)
if err != nil {
return false, err
}
return register, nil
}
// ReadDiscreteInputs 0x02
func (m *Master) ReadDiscreteInputs(id uint8, addr uint16, quantity uint16) ([]bool, error) {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return nil, err
}
register, err := m.modbus.ReadDiscreteInputs(addr, quantity)
if err != nil {
return nil, err
}
return register, nil
}
// WriteRegister 0x06
func (m *Master) WriteRegister(id uint8, addr uint16, value uint16) error {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return err
}
err := m.modbus.WriteRegister(addr, value)
if err != nil {
return err
}
return nil
}
// WriteRegisters 0x10
func (m *Master) WriteRegisters(id uint8, addr uint16, values []uint16) error {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return err
}
err := m.modbus.WriteRegisters(addr, values)
if err != nil {
return err
}
return nil
}
// WriteUint32 0x10
func (m *Master) WriteUint32(id uint8, addr uint16, value uint32) error {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return err
}
err := m.modbus.WriteUint32(addr, value)
if err != nil {
return err
}
return nil
}
// WriteUint32s 0x10
func (m *Master) WriteUint32s(id uint8, addr uint16, values []uint32) error {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return err
}
err := m.modbus.WriteUint32s(addr, values)
if err != nil {
return err
}
return nil
}
// WriteUint64 0x10
func (m *Master) WriteUint64(id uint8, addr uint16, value uint64) error {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return err
}
err := m.modbus.WriteUint64(addr, value)
if err != nil {
return err
}
return nil
}
// WriteUint64s 0x10
func (m *Master) WriteUint64s(id uint8, addr uint16, values []uint64) error {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return err
}
err := m.modbus.WriteUint64s(addr, values)
if err != nil {
return err
}
return nil
}
// WriteFloat32 0x10
func (m *Master) WriteFloat32(id uint8, addr uint16, value float32) error {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return err
}
err := m.modbus.WriteFloat32(addr, value)
if err != nil {
return err
}
return nil
}
// WriteFloat32s 0x10
func (m *Master) WriteFloat32s(id uint8, addr uint16, values []float32) error {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return err
}
err := m.modbus.WriteFloat32s(addr, values)
if err != nil {
return err
}
return nil
}
// WriteFloat64 0x10
func (m *Master) WriteFloat64(id uint8, addr uint16, value float64) error {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return err
}
err := m.modbus.WriteFloat64(addr, value)
if err != nil {
return err
}
return nil
}
// WriteFloat64s 0x10
func (m *Master) WriteFloat64s(id uint8, addr uint16, values []float64) error {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return err
}
err := m.modbus.WriteFloat64s(addr, values)
if err != nil {
return err
}
return nil
}
// WriteCoil 0x05
func (m *Master) WriteCoil(id uint8, addr uint16, value bool) error {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return err
}
err := m.modbus.WriteCoil(addr, value)
if err != nil {
return err
}
return nil
}
// WriteCoils 0x0F
func (m *Master) WriteCoils(id uint8, addr uint16, values []bool) error {
<-m.serialChan
defer clearChan(m.serialChan)
if err := m.modbus.SetUnitId(id); err != nil {
return err
}
err := m.modbus.WriteCoils(addr, values)
if err != nil {
return err
}
return nil
}