ammeter/drivers/uemis.go

package drviers

import (
	"bytes"
	"errors"
	"time"

	bus "github.com/ammeter/Bus"
	"github.com/yuguorong/go/log"
)

type SAirModel struct {
	Id       string `json:"id"`
	DevName  string `json:"devName"`
	Code     string `json:"code"`
	Protocol string `json:"protocol"`
	GwDevId  string `json:"gwDevId"`
	Type     string `json:"-" `
}

type Uemis struct {
	baseDevice
	chnExit    chan bool
	loopserver bool
}

func (u *Uemis) ChannelDispatch(stream []byte, args interface{}) bus.ChnDispResult {
	devName := ""
	buf := bytes.NewBuffer(stream)
	mret := u.Route[1].iproto.ParsePacket(buf.Bytes(), &devName)
	if mret != nil && devName != "" {
		devN := devName[8:]
		devN = "SA10" + "-00000000" + devN
		if devN == u.DeviceName {
			log.Info(u.DeviceName+" Dispatch ["+devN+"]: ", string(stream))
			return bus.DispatchSingle
		}
	}
	return bus.DispatchNone
}

func (u *Uemis) Run() error {
	u.loopserver = true
	for u.loopserver {
		select {
		case msg := <-u.Route[1].router[0]:
			b := msg.([]byte)
			devName := ""
			mret := u.Route[1].iproto.ParsePacket(b, &devName)
			if mret != nil && devName != "" {
				v := mret.(map[string]interface{})
				dev := devName[8:]
				dev = "SA10" + "-00000000" + dev
				log.Info(u.baseDevice.Id+"/"+dev, v)
				telemetry := u.Route[0].iproto.PackageCmd(dev, mret)
				u.Route[0].ibus.Send(u.Route[0].iChn, telemetry)
				u.tsSample = time.Now().Unix()
			}
		case <-u.chnExit:
			u.loopserver = false

		}
	}
	return nil
}

func (u *Uemis) Open(...interface{}) error {
	lenr := len(u.Route)
	if lenr < 1 {
		return errors.New("wrong route config")
	} else if lenr < 2 {
		u.SetRoute(u, "HJ212", "dtuFtpServer", "HJ212-"+u.Id, 0)
	}
	if !u.loopserver {
		go u.Run()
	}
	return nil
}

func (u *Uemis) Close() error {
	u.loopserver = false
	u.chnExit <- true
	return nil
}

func (u *Uemis) GetDevice(s string) interface{} {
	return u
}

type UemisDrv struct {
	baseDriver
}

func (drv *UemisDrv) GetModel() interface{} {
	return &[]SAirModel{}
}

func (drv *UemisDrv) CreateDevice(model interface{}) (int, []IDevice) {
	ts := time.Now().UnixMilli()
	devlist := make([]IDevice, 0)
	mlist := model.(*[]SAirModel)
	var dev *Uemis = nil
	for _, mod := range *mlist {
		mt, has := (drv.DevList[mod.Id])
		if !has {
			dev = &Uemis{}
			dev.Id = mod.Id
			dev.DeviceName = mod.DevName
			dev.loopserver = false
			dev.Probe(dev.DeviceName, drv)

			devlist = append(devlist, dev)
			drv.DevList[mod.Id] = dev
		} else {
			dev = mt.(*Uemis)
		}
		dev.tsUpdate = ts
	}
	return len(devlist), devlist
}

func NewUemis(param interface{}) IDriver {
	drv := new(UemisDrv)
	return drv
}

func init() {
	driverReg["SA10"] = NewUemis
}