testbench/tcp/mdbs/mdbsConn.go

package mdbs

import (
    "fmt"
    "net"
    "wb/ut"
    "testbench/tcp/tc"
    "github.com/astaxie/beego"
    "time"
    "testbench/models/statusMgr"
    "testbench/tcp/tcpserver"
    "strings"
    "wb/lg"
    "wb/st"
    "wb/modbus"
)

type MConn struct {
    tc.TConn
    ModeInfo modbus.ModelInfo
}
type model interface {
    GetStatus(mConn *MConn)(string, map[string]interface{})
    SendCmd(mConn *MConn, cmd string)
}
func NewMConn(conn net.Conn)*MConn{
    o := MConn{}
    o.Conn = conn
    o.IsConnect = true
    o.Typo = "MDBS"
    o.ReadBuf = make([]byte, 4096)
    return &o
}
func (this *MConn)Init(termId string)bool{
    this.TConn.Init(termId)
    for startId, modelInfo := range modbus.ModelInfoMap{
        if strings.HasPrefix(termId, startId){
            this.LogInfo("MConn.Init modelInfo as: ", modelInfo.Name)
            this.ModeInfo = modelInfo
            this.StatusMgr = statusMgr.GetMgrBySid(this.TermId)
            this.StatusMap = this.StatusMgr.GetDefaultStatusMap(this.TermId)
            return true
        }
    }
    this.LogError("MConn.Init modelInfo error: no model match id:", termId)
    return false
}
func (this *MConn) Read() ([]byte, error) {
    READ:
    i, err := this.Conn.Read(this.ReadBuf)
    if err != nil {
        this.LogError("MDBS Read error:", err.Error())
        this.IsConnect = false
        return []byte{}, err
    } else {
        this.LogRecv(this.ReadBuf[:i])
        if i < 5{
            goto READ
        }
        this.LogDebug("[P]R: ", this.ParseRecv(this.ReadBuf[:i]))
    }
    return this.ReadBuf[:i], nil
}
func (this *MConn)ParseRecv(bs []byte)string{
    if len(bs) < 5{
        this.LogError("parse ERROR:", ut.BytesToHexStr(bs))
        return ""
    }
    funcCode := bs[modbus.FuncCode]
    retLen := int8(bs[modbus.RetLen])
    body := bs[modbus.RetBobyStart:len(bs) - 2]
    return fmt.Sprint("FUNC=>" , ut.ByteToHex(funcCode) , " LEN=>", retLen , " BODY=>" , ut.BytesToHexStr(body))
}
const (
    StartCmd = "start"
    StopCmd = "stop"
)

func (this *MConn) SendCmd(key string)  {
    if cmd, ok := this.ModeInfo.CmdMap[key];ok{
        this.WriteReq(cmd.Bytes)
    }else{
        this.LogError("MConn.SendCmd error no such cmd:",key)
    }
}

func (this *MConn) WriteReq(req []byte) ([]byte, error) {
    req = modbus.AppendCrc(req)
    _, err := this.Write(req)
    if err != nil {
        this.LogError("WriteReq send error:", err.Error())
        this.IsConnect = false
        //		panic("network broken")
        return []byte{}, err
    }
    buf, err := this.Read()
    if err != nil {
        return []byte{}, err
    }
    return buf, nil
}
func (this *MConn)GetStatus() (string, map[string]interface{}) {
    if this.ModeInfo.Querys == nil{
        this.LogError("MConn.SendCmd error: model not init.")
        return st.Failed, nil
    }
    for _, query := range this.ModeInfo.Querys{
        this.GetRegisters(query, this.StatusMap, query.RegStart, query.RegLen, query.Address)
    }
    return st.Success, ut.Maps.Copy(this.StatusMap)
}

// 只适合连续的寄存器，并且结果位数相同
func (mConn *MConn) GetRegisters(query modbus.Query, mapValue map[string]interface{}, regStart, regLen, address int) {
    mConn.LogDebug("GetRegisters regStart:", regStart, " regLen:", regLen)
    req := modbus.BuildReadRequest(address, query.Code, regStart, regLen)
    //fmt.Println(ut.BytesToHexStr(req))
    _, err := mConn.Write(req)
    if err != nil {
        mConn.LogError("GetRegisters send error:", err.Error())
        mConn.IsConnect = false
        return
    }
    resp, err := mConn.Read()
    if err != nil {
        return
    }
    if len(resp) < 5{
        return
    }
    modbus.DoRecvMdbsUart(mConn.ModeInfo, mapValue, resp, mConn.Logger)
}

const idLen = 6
func ReadTermId(conn net.Conn) string {
    buf := make([]byte, 1024)
    mLen, err := conn.Read(buf)
    if err != nil {
        println("Error register:", err.Error())
        return ""
    }
    if mLen >= idLen {
        mLen = idLen
    }
    dst := make([]byte, idLen * 2)
    for i := 0; i< idLen*2;i++{
        dst [i] = '0'
    }
    d := (idLen - mLen)*2
    for _, v := range buf[:mLen] {
        dst[d] = ut.Hextable[v >> 4]
        dst[d + 1] = ut.Hextable[v & 0x0f]
        d = d + 2
    }
    return string(dst)
}

func EchoFunc(conn net.Conn) {
    lg.Info("MDBS CONNECT FROM: ", conn.RemoteAddr())
    defer conn.Close()
    id := ReadTermId(conn)
    if id == ""{
        return
    }
    mConn := NewMConn(conn)
    if !mConn.Init(id){
        return
    }
    tc.AddMConn(mConn)
    for mConn.IsConnect{
        time.Sleep(queryUartDelay * time.Second)
        mConn.LogInfo("queryUartDelay")
        status, vMap := mConn.GetStatus()
        if status == st.Success {
            mConn.StatusMgr.AddStatus(vMap)
        }
    }
}
func ServerRun() {
    port := beego.AppConfig.String("shport")
    server.Run(port, EchoFunc)
}
var queryUartDelay time.Duration
func init(){
    samp := beego.AppConfig.DefaultInt("samplingPeriods", 10)
    queryUartDelay = time.Duration(samp)
    lg.Info("mbds samplingPeriods:", queryUartDelay)
}