package plccom
|
|
import (
|
"apsClient/pkg/logx"
|
"apsClient/pkg/plccom/mitsubishi"
|
"encoding/base64"
|
"errors"
|
"fmt"
|
"io"
|
"net/http"
|
"strings"
|
)
|
|
// SerialProtocol 是串口通信协议的通用接口
|
type SerialProtocol interface {
|
// ConvertLabelToAddress 将设备特定的标签转换为寄存器地址
|
ConvertLabelToAddress(label string) string
|
|
// MakeReadProtocol 创建读取数据的协议
|
MakeReadProtocol(addr string) []byte
|
|
// MakeReadProtocolBits 创建读取数据的协议
|
MakeReadProtocolBits(bits int, addr string) []byte
|
|
// MakeWriteProtocol 创建写入数据的协议
|
MakeWriteProtocol(addr string, value int) []byte
|
|
MakeWriteProtocolBits(bits int, addr string, ival int) []byte
|
|
// ParseReadValue 解析从设备读取的值
|
ParseReadValue(data []byte) int
|
|
ParseReadValueBits(data []byte) int
|
|
// ParseWriteValue 解析写入设备的结果，并返回结果和是否成功
|
ParseWriteValue(data []byte) (int, bool)
|
}
|
|
const (
|
DeviceTypeMitsubishi = "mitsubishi"
|
)
|
|
// LoadProtocol 根据配置加载不同的协议实现
|
func LoadProtocol(deviceType string) (SerialProtocol, error) {
|
var protocol SerialProtocol
|
|
switch deviceType {
|
case DeviceTypeMitsubishi:
|
protocol = &mitsubishi.ProtocolMitsubishi{} // 使用三菱设备协议
|
// case "OtherDevice":
|
// protocol = &OtherDeviceProtocol{} // 使用其他设备的协议
|
default:
|
return nil, fmt.Errorf("unsupported device type: %s", deviceType)
|
}
|
|
return protocol, nil
|
}
|
|
func ReadPLC(deviceType, url, label string, length int) (val int, err error) {
|
protocol, err := LoadProtocol(deviceType)
|
if err != nil {
|
return 0, err
|
}
|
addr := protocol.ConvertLabelToAddress(label)
|
var proto []byte
|
if length == 1 {
|
proto = protocol.MakeReadProtocol(addr)
|
} else {
|
proto = protocol.MakeReadProtocolBits(length*16, addr)
|
}
|
|
bp := base64.StdEncoding.EncodeToString(proto)
|
fullUrl := fmt.Sprintf("%v?proto=%v", url, bp)
|
resp, err := http.Get(fullUrl)
|
if err != nil {
|
logx.Errorf("ReadPLC http get failed:%v", err)
|
return 0, err
|
}
|
body := readBody(resp.Body)
|
data, err := base64.StdEncoding.DecodeString(string(body))
|
if err != nil {
|
logx.Errorf("ReadPLC base64.StdEncoding.DecodeString failed: %v, data: %v", err, string(body))
|
return 0, err
|
}
|
if length == 1 {
|
val = protocol.ParseReadValue(data)
|
} else {
|
val = protocol.ParseReadValueBits(data)
|
}
|
|
fmt.Println("read PLC:", val)
|
return val, nil
|
|
}
|
|
func readBody(r io.ReadCloser) []byte {
|
body, e := io.ReadAll(r)
|
defer r.Close()
|
if e != nil {
|
fmt.Println("ReadAll resp body error:", e)
|
return nil
|
}
|
return body
|
}
|
|
func WritePLC(deviceType, url, label string, val int) error {
|
protocol, err := LoadProtocol(deviceType)
|
if err != nil {
|
return err
|
}
|
addr := protocol.ConvertLabelToAddress(label)
|
var proto []byte
|
if val < 65536 {
|
proto = protocol.MakeWriteProtocol(addr, val)
|
} else {
|
proto = protocol.MakeWriteProtocolBits(32, addr, val)
|
}
|
|
bp := base64.StdEncoding.EncodeToString(proto)
|
resp, err := http.Post(url, "text/plain", strings.NewReader(bp))
|
if err != nil {
|
logx.Errorf("write plc http post failed:%v", err)
|
return err
|
}
|
body := readBody(resp.Body)
|
data, err := base64.StdEncoding.DecodeString(string(body))
|
if err != nil {
|
logx.Errorf("write plc base64 StdEncoding DecodeString:%v", err)
|
return err
|
}
|
val, ok := protocol.ParseWriteValue(data)
|
if !ok {
|
logx.Errorf("serial write failed, response:%v", val)
|
return errors.New("failed")
|
}
|
logx.Errorf("serial write success, response:%v", val)
|
return nil
|
}
|
