tecamino-driver-artNet/driver/artNet.go

package driver

import (
	"artNet/cfg"
	"artNet/models"
	ws "artNet/websocket"
	"fmt"
	"path"
	"time"

	json_data "github.com/tecamino/tecamino-json_data"
	"github.com/tecamino/tecamino-logger/logging"
)

type ArtNetDriver struct {
	Name          string                 `yaml:"driver" json:"driver"`
	Buses         map[string]*models.Bus `yaml:"buses,omitempty" json:"buses,omitempty"`
	cfgHandler    *cfg.Cfg               `yaml:"-" json:"-"`
	Subscriptions models.Subscriptions   `yaml:"-" json:"-"`
	Log           *logging.Logger        `yaml:"-" json:"-"`
}

// initialize new Art-Net driver
// cfgDir config directory
// name name of driver
func NewDriver(cfgDir, name string, debug bool) (*ArtNetDriver, error) {
	if cfgDir == "" {
		cfgDir = "./cfg"
	}

	logger, err := logging.NewLogger(path.Join(cfgDir, name+".log"), &logging.Config{
		MaxSize:     1,
		MaxBackup:   3,
		MaxAge:      28,
		Debug:       debug,
		TerminalOut: true,
	})
	if err != nil {
		panic(err)
	}

	logger.Debug("artNet.NewDriver", "initialize "+name+" driver")
	d := ArtNetDriver{
		Name:       name,
		Buses:      make(map[string]*models.Bus),
		cfgHandler: cfg.NewCfgHandler(cfgDir, name),
		Log:        logger,
	}

	if err := d.LoadCfg(); err != nil {
		logger.Error("artNet.NewDriver.LoadCfg", "error load driver configuration: "+err.Error())
		return nil, err
	}
	return &d, nil
}

// loads driver config
func (d *ArtNetDriver) LoadCfg() error {
	d.Log.Debug("artNet.LoadCfg", "load driver configuration")
	if err := d.cfgHandler.LoadCfg(d); err != nil {
		return err
	}

	for name, b := range d.Buses {
		d.NewBus(name, b.Ip, *b.Port)
	}
	return nil
}

// adds new Art-Net bus/interface to driver port 0 = 6454 (default art-net)
func (d *ArtNetDriver) NewBus(name, ip string, port int) *models.Bus {
	b := models.NewBus(name, ip, port)
	d.Buses[name] = b
	return b
}

func (d *ArtNetDriver) SetValue(bus string, address uint, value uint8) error {
	if _, ok := d.Buses[bus]; !ok {
		return fmt.Errorf("no bus '%s' found", bus)
	}
	if d.Buses[bus].Data == nil {
		return fmt.Errorf("no dmx data on bus '%s' found", bus)
	}
	d.Buses[bus].Data.SetValue(address, value)
	return d.Buses[bus].SendData()
}

// connect to websocket server and listen to subscriptions
// ip: ip address of server
// id: id of driver
// port: port of server
func (d *ArtNetDriver) Connect(ip, id string, port uint) error {
	var err error
	client, err := ws.NewClient(ip, id, port)
	if err != nil {
		return err
	}
	client.OnError = func(err error) {
		d.Log.Error("websocket connection", err)
	}
	client.OnMessage = func(data []byte) {
		//fmt.Println(100, string(data))
		fmt.Println(100, string(data))
	}

	client.Connect(5)

	req := json_data.NewRequest()
	req.AddDriverSubscription(".*", id, 0, true, false, false)

	if err := client.SendData(req); err != nil {
		d.Log.Error("websocket send data", err)
	}

	for {
		time.Sleep(1)
	}
	return nil

	// d.Conn = websocket.NewClient()
	// if err := d.Conn.Connect(ip, id, port); err != nil {
	// 	return err
	// }
	// defer d.Conn.Disconnect()

	// if err := d.Conn.Subscribe(id); err != nil {
	// 	return err
	// }

	// Subscribe to websocket server
	// func (c *Client) Subscribe(id string) error {
	// 	req := json_data.NewRequest()
	// 	req.AddDriverSubscription(".*", id, 0, true, false, false)
	// 	if err := wsjson.Write(c.ctx, c.conn, req); err != nil {
	// 		return err
	// 	}
	// 	return nil
	// }

	// for {
	// 	respond, err := d.Conn.ReadJsonData()
	// 	if err != nil {
	// 		return err
	// 	}

	// 	d.Subscribe(respond.Subscribe...)

	// 	for _, pub := range respond.Publish {
	// 		if sub, ok := d.Subscriptions[pub.Uuid]; ok {
	// 			if err := d.SetValue(sub.Bus, sub.Address, uint8(pub.Value.(float64))); err != nil {
	// 				d.Log.Info("artNet.Connect", err.Error())
	// 			}
	// 		}
	// 	}
	// }
}