15 changed files with 194 additions and 348 deletions
--- a/can/can.go
+++ b/can/can.go
@ -11,11 +11,36 @@ import (
 	"golang.org/x/sys/unix"
 )

+const CAN_ID_071 = 0x071
+const CAN_ID_073 = 0x073
+const CAN_ID_074 = 0x074
+const CAN_ID_075 = 0x075
+const CAN_ID_021 = 0x021
+const CAN_ID_022 = 0x022
+const CAN_ID_023 = 0x023
+const CAN_ID_011 = 0x011
+const CAN_ID_014 = 0x014
+const CAN_ID_015 = 0x015
+const CAN_ID_016 = 0x016
+const CAN_ID_01A = 0x01A
+const CAN_ID_02A = 0x02A
+const CAN_ID_041 = 0x041
+const CAN_ID_042 = 0x042
+const CAN_ID_046 = 0x046
+const CAN_ID_047 = 0x047
+const CAN_ID_048 = 0x048
+const CAN_ID_049 = 0x049
+const CAN_ID_067 = 0x067
+const CAN_ID_068 = 0x068
+const CAN_ID_06C = 0x06C
+const CAN_ID_061 = 0x061
+const CAN_ID_062 = 0x062
+const CAN_ID_065 = 0x065
 const bufferSize = 100

 type CanFrame struct {
 	CanId   uint32
-	Payload *[]uint8
+	Payload []uint8
 	Date    *time.Time
 }

@ -58,9 +83,9 @@ func (sck *Socket) Bind(addr string, filter []unix.CanFilter) error {
 	return unix.Bind(sck.dev.fd, sck.addr)
 }

-// Receive receives data from the CAN socket.
+// Recv receives data from the CAN socket.
 // id is the CAN_frame id the data was originated from.
-func (sck *Socket) Receive() (id uint32, data *[]byte, err error) {
+func (sck *Socket) Recv() (id uint32, data []byte, err error) {
 	var buf [frameSize]byte
 	n, err := io.ReadFull(sck.dev, buf[:])
 	if err != nil {
@ -74,9 +99,9 @@ func (sck *Socket) Receive() (id uint32, data *[]byte, err error) {
 	id = binary.LittleEndian.Uint32(buf[:4])
 	//TODO make correct switch betwin EFF and SFF
 	id &= unix.CAN_EFF_MASK
-	payload := make([]byte, buf[4])
-	copy(payload, buf[8:])
-	return id, &payload, nil
+	data = make([]byte, buf[4])
+	copy(data, buf[8:])
+	return id, data, nil
 }

 type device struct {
@ -101,7 +126,35 @@ type canframe struct {
 	Data [8]byte
 }

-func StartCan(canbus string, filter []unix.CanFilter) (<-chan *CanFrame, error) {
+func StartCan(canbus string) (<-chan *CanFrame, error) {
+
+	var filter []unix.CanFilter = []unix.CanFilter{
+		{Id: CAN_ID_071, Mask: 0xFFF},
+		{Id: CAN_ID_073, Mask: 0xFFF},
+		{Id: CAN_ID_074, Mask: 0xFFF},
+		{Id: CAN_ID_075, Mask: 0xFFF},
+		{Id: CAN_ID_021, Mask: 0xFFF},
+		{Id: CAN_ID_022, Mask: 0xFFF},
+		{Id: CAN_ID_011, Mask: 0xFFF},
+		{Id: CAN_ID_014, Mask: 0xFFF},
+		{Id: CAN_ID_015, Mask: 0xFFF},
+		{Id: CAN_ID_016, Mask: 0xFFF},
+		{Id: CAN_ID_01A, Mask: 0xFFF},
+		{Id: CAN_ID_023, Mask: 0xFFF},
+		{Id: CAN_ID_02A, Mask: 0xFFF},
+		{Id: CAN_ID_041, Mask: 0xFFF},
+		{Id: CAN_ID_042, Mask: 0xFFF},
+		{Id: CAN_ID_046, Mask: 0xFFF},
+		{Id: CAN_ID_047, Mask: 0xFFF},
+		{Id: CAN_ID_048, Mask: 0xFFF},
+		{Id: CAN_ID_049, Mask: 0xFFF},
+		{Id: CAN_ID_067, Mask: 0xFFF},
+		{Id: CAN_ID_068, Mask: 0xFFF},
+		{Id: CAN_ID_06C, Mask: 0xFFF},
+		{Id: CAN_ID_061, Mask: 0xFFF},
+		{Id: CAN_ID_062, Mask: 0xFFF},
+		{Id: CAN_ID_065, Mask: 0xFFF},
+	}

 	if socket, err := NewCan(); err == nil {

@ -114,7 +167,7 @@ func StartCan(canbus string, filter []unix.CanFilter) (<-chan *CanFrame, error)
 				defer socket.Close()

 				for { //TODO implement stop
-					if id, data, serr := socket.Receive(); serr == nil {
+					if id, data, serr := socket.Recv(); serr == nil {
 						var now = time.Now()
 						canevents <- &CanFrame{
 							Date:    &now,
--- a/can/input.go
+++ b/can/input.go
@ -52,13 +52,12 @@ func process(scanner *bufio.Scanner, ch chan<- *CanFrame) {
 	}
 }

-func ReadStdin(file *os.File) <-chan *CanFrame {
+func ReadStdin() <-chan *CanFrame {
 	c := make(chan *CanFrame)

 	go func() {
-		scanner := bufio.NewScanner(file)
+		scanner := bufio.NewScanner(os.Stdin)
 		process(scanner, c)
-		close(c)
 	}()
 	return c
 }
@ -105,7 +104,7 @@ func fromString(text string) *CanFrame {
 		return &CanFrame{
 			Date:    &now,
 			CanId:   uint32(canId),
-			Payload: &payload,
+			Payload: payload,
 		}
 	}

--- a/can/input_test.go
+++ b/can/input_test.go
@ -36,7 +36,7 @@ func Test_fromString(t *testing.T) {
 			want: &CanFrame{
 				Date:    &time_m,
 				CanId:   0x4021,
-				Payload: &[]uint8{00, 00, 00, 00, 0xFC, 0xFF, 0xFF, 0xFF},
+				Payload: []uint8{00, 00, 00, 00, 0xFC, 0xFF, 0xFF, 0xFF},
 			},
 		},
 		{
@ -45,7 +45,7 @@ func Test_fromString(t *testing.T) {
 			want: &CanFrame{
 				Date:    &time_p,
 				CanId:   0x100,
-				Payload: &[]uint8{00, 00, 00, 00, 00, 00, 0x64, 00},
+				Payload: []uint8{00, 00, 00, 00, 00, 00, 0x64, 00},
 			},
 		},
 	}
--- a/cli-mon.go
+++ b/cli-mon.go
@ -4,60 +4,29 @@ import (
 	"cli-mon/can"
 	"cli-mon/ui"
 	"cli-mon/yabl"
-	flag "flag"
+	"flag"
 	"fmt"
-	"golang.org/x/sys/unix"
 	"os"
 	"time"
 )

 func main() {
 	filename := flag.String("f", "", "Candump filename")
-	canbus := flag.String("i", "can0", "CAN bus interface")
+	canbus := flag.String("i", "", "CAN bus interface")
 	stdin := flag.Bool("s", false, "Read from stdin")
-	gui := flag.Bool("gui", false, "Pseudo-GUI CLI interface")
-	amqp := flag.String("amqp", "", "Run output to AMQP broker url")
-	interval := time.Duration(*flag.Uint("t", 50, "Override data loss check interval, ms"))
+	gui := flag.Bool("gui", false, "Text mode gui")
 	flag.Parse()

 	var frames <-chan *can.CanFrame

 	switch {
 	case *stdin:
-		frames = can.ReadStdin(os.Stdin)
+		frames = can.ReadStdin()
 	case len(*filename) > 0:
 		frames = can.Readfile(filename)
 	case len(*canbus) > 0:
-		filter := []unix.CanFilter{
-			{Id: yabl.CanIdContIntState, Mask: 0xFFF},
-			{Id: yabl.CanIdContIntErr, Mask: 0xFFF},
-			{Id: yabl.CanIdContIntForce, Mask: 0xFFF},
-			{Id: yabl.CanIdContIntDebug, Mask: 0xFFF},
-			{Id: yabl.CanIdPuPresentEnergy, Mask: 0xFFF},
-			{Id: yabl.CanIdPuPeriphery, Mask: 0xFFF},
-			{Id: yabl.CanIdCpuPresentEnergy, Mask: 0xFFF},
-			{Id: yabl.CanIdCpuPeriphery, Mask: 0xFFF},
-			{Id: yabl.CanIdCpuEnergySettings, Mask: 0xFFF},
-			{Id: yabl.CanIdCpuErrors, Mask: 0xFFF},
-			{Id: yabl.CanIdCpuDebug, Mask: 0xFFF},
-			{Id: yabl.CanIdPuErrors, Mask: 0xFFF},
-			{Id: yabl.CanIdPuDebug, Mask: 0xFFF},
-			{Id: yabl.CanIdSeccTargetEnergy, Mask: 0xFFF},
-			{Id: yabl.CanIdSeccErrors, Mask: 0xFFF},
-			{Id: yabl.CanIdLogicAuth, Mask: 0xFFF},
-			{Id: yabl.CanIdLogicEnergyMode, Mask: 0xFFF},
-			{Id: yabl.CanIdLogicErrors, Mask: 0xFFF},
-			{Id: yabl.CanIdLogicWorkingMode, Mask: 0xFFF},
-			{Id: yabl.CanIdPeripheryState, Mask: 0xFFF},
-			{Id: yabl.CanIdPeripheryInfo, Mask: 0xFFF},
-			{Id: yabl.CanIdPeripheryDebug, Mask: 0xFFF},
-			{Id: yabl.CanIdConverterPresentEnergy, Mask: 0xFFF},
-			{Id: yabl.CanIdConverterErrors, Mask: 0xFFF},
-			{Id: yabl.CanIdConverterDebug, Mask: 0xFFF},
-		}
-
 		var err error
-		frames, err = can.StartCan(*canbus, filter)
+		frames, err = can.StartCan(*canbus)
 		if err != nil {
 			fmt.Println(err)
 			return
@ -71,14 +40,12 @@ func main() {
 		os.Exit(0)
 	}

-	converter := yabl.NewProtocolConverter("")
+	converter := yabl.NewProtocolConverter()

 	var display ui.UI

 	if *gui {
 		display = ui.NewUI()
-	} else if len(*amqp) > 0 {
-		display = ui.NewAmqp(*amqp)
 	} else {
 		display = ui.NewLog()
 	}
@ -87,16 +54,14 @@ func main() {

 	updates := make(chan *yabl.Event, 1000)

-	isOffline := len(*filename) > 0 || *stdin
-
 	var f func()
 	f = func() {
-		if events, ok := converter.CheckTimeouts(isOffline); ok {
+		if events, ok := converter.CheckTimeouts(); ok {
 			for _, event := range events {
 				updates <- event
 			}
 		}
-		time.AfterFunc(interval*time.Millisecond, f)
+		time.AfterFunc(50*time.Millisecond, f)
 	}

 	time.AfterFunc(5*time.Second, f)
--- a/go.mod
+++ b/go.mod
@ -3,14 +3,13 @@ module cli-mon
 go 1.19

 require (
-	github.com/gdamore/tcell/v2 v2.6.0
-	github.com/rabbitmq/amqp091-go v1.9.0
 	github.com/rivo/tview v0.0.0-20230621164836-6cc0565babaf
 	golang.org/x/sys v0.5.0
 )

 require (
 	github.com/gdamore/encoding v1.0.0 // indirect
+	github.com/gdamore/tcell/v2 v2.6.0 // indirect
 	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
 	github.com/mattn/go-runewidth v0.0.14 // indirect
 	github.com/rivo/uniseg v0.4.3 // indirect
--- a/go.sum
+++ b/go.sum
@ -1,31 +1,17 @@
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/gdamore/encoding v1.0.0 h1:+7OoQ1Bc6eTm5niUzBa0Ctsh6JbMW6Ra+YNuAtDBdko=
 github.com/gdamore/encoding v1.0.0/go.mod h1:alR0ol34c49FCSBLjhosxzcPHQbf2trDkoo5dl+VrEg=
 github.com/gdamore/tcell/v2 v2.6.0 h1:OKbluoP9VYmJwZwq/iLb4BxwKcwGthaa1YNBJIyCySg=
 github.com/gdamore/tcell/v2 v2.6.0/go.mod h1:be9omFATkdr0D9qewWW3d+MEvl5dha+Etb5y65J2H8Y=
-github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
 github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
 github.com/mattn/go-runewidth v0.0.14 h1:+xnbZSEeDbOIg5/mE6JF0w6n9duR1l3/WmbinWVwUuU=
 github.com/mattn/go-runewidth v0.0.14/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/rabbitmq/amqp091-go v1.9.0 h1:qrQtyzB4H8BQgEuJwhmVQqVHB9O4+MNDJCCAcpc3Aoo=
-github.com/rabbitmq/amqp091-go v1.9.0/go.mod h1:+jPrT9iY2eLjRaMSRHUhc3z14E/l85kv/f+6luSD3pc=
 github.com/rivo/tview v0.0.0-20230621164836-6cc0565babaf h1:IchpMMtnfvzg7T3je672bP1nKWz1M4tW3kMZT6CbgoM=
 github.com/rivo/tview v0.0.0-20230621164836-6cc0565babaf/go.mod h1:nVwGv4MP47T0jvlk7KuTTjjuSmrGO4JF0iaiNt4bufE=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.4.3 h1:utMvzDsuh3suAEnhH0RdHmoPbU648o6CvXxTx4SBMOw=
 github.com/rivo/uniseg v0.4.3/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
-go.uber.org/goleak v1.2.1 h1:NBol2c7O1ZokfZ0LEU9K6Whx/KnwvepVetCUhtKja4A=
-go.uber.org/goleak v1.2.1/go.mod h1:qlT2yGI9QafXHhZZLxlSuNsMw3FFLxBr+tBRlmO1xH4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
@ -54,7 +40,3 @@ golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGm
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
--- a/ui/amqp.go
+++ b/ui/amqp.go
@ -1,76 +0,0 @@
-package ui
-
-import (
-	"cli-mon/yabl"
-	"context"
-	json "encoding/json"
-	"fmt"
-	amqp "github.com/rabbitmq/amqp091-go"
-	"time"
-)
-
-const exchange = "yabl-newproto-in"
-
-type broker struct {
-	uri  string
-	conn *amqp.Connection
-	ch   *amqp.Channel
-}
-
-func NewAmqp(uri string) UI {
-	return &broker{uri: uri}
-}
-
-func (b *broker) Consume(event *yabl.Event) {
-	var bytes []byte
-	var err error
-	if bytes, err = json.Marshal(event); err != nil {
-		return
-	}
-
-	route := fmt.Sprintf(
-		"%s.%s.%s.%d",
-		*event.Tag,
-		*event.ActionName,
-		*event.Field,
-		event.GetUnitId())
-
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-
-	if err = b.ch.PublishWithContext(ctx,
-		exchange,
-		route,
-		false,
-		false,
-		amqp.Publishing{
-			ContentType: "application/json",
-			Body:        bytes,
-		}); err != nil {
-		fmt.Printf("Can't publish msg: %v", err)
-	}
-}
-
-func (b *broker) Start() {
-	var err error
-	b.conn, err = amqp.Dial(b.uri)
-	if err != nil {
-		panic(fmt.Sprintf("Can't connect to AMQP: %v", err))
-	}
-
-	b.ch, err = b.conn.Channel()
-	if err != nil {
-		panic(fmt.Sprintf("Can't create AMQP channel: %v", err))
-	}
-
-	fmt.Printf("AMQP client connected to %v, sending data to server..", b.uri)
-}
-
-func (b *broker) Stop() {
-	if b.conn != nil {
-		b.conn.Close()
-	}
-	if b.ch != nil {
-		b.ch.Close()
-	}
-}
--- a/ui/amqp_test.go
+++ b/ui/amqp_test.go
@ -1,39 +0,0 @@
-package ui
-
-import (
-	"cli-mon/yabl"
-	"testing"
-	"time"
-)
-
-func TestNewAmqp(t *testing.T) {
-	t.Run("Amqp Test", func(t *testing.T) {
-		client := NewAmqp("amqp://user:password@localhost:5672/")
-
-		if client == nil {
-			t.Errorf("Can't create client")
-		}
-
-		client.Start()
-
-		now := time.Now()
-		field := yabl.FBoardReady
-		action := yabl.PPuErrors
-		tag := "localhost"
-
-		event := &yabl.Event{
-			Tag:        &tag,
-			Field:      &field,
-			ActionName: &action,
-			Object:     nil,
-			//unit:       3,
-			Updated: &now,
-			Value:   yabl.ERROR,
-		}
-
-		client.Consume(event)
-
-		client.Stop()
-	})
-
-}
--- a/ui/table.go
+++ b/ui/table.go
@ -21,7 +21,7 @@ type key struct {
 }

 func (t *table) update(event *yabl.Event) {
-	if cell, ok := t.views[key{*event.ActionName, *event.Field, event.GetUnitId()}]; ok {
+	if cell, ok := t.views[key{event.ActionName, event.Field, event.GetUnitId()}]; ok {
 		cell.SetText(fmt.Sprintf("%v", event.Value))
 	}
 }
--- a/ui/ui.go
+++ b/ui/ui.go
@ -67,6 +67,48 @@ func (g *gui) Consume(event *yabl.Event) {
 	g.convertersErrors.update(event)
 	g.cpu.update(event)

+	switch event.Object.(type) {
+	case *yabl.PuPresentEnergy:
+		break
+	case *yabl.PuPeriphery:
+		break
+	case *yabl.PuDebug:
+		break
+	case *yabl.PuErrors:
+		break
+	case *yabl.ContactorInternalErrors:
+		break
+	case *yabl.ContactorInternalDebug:
+		break
+	case *yabl.ContactorInternalState:
+		break
+	case *yabl.ContactorsInternalForce:
+		break
+	case *yabl.PeripheryState:
+		break
+	case *yabl.PeripheryInfo:
+		break
+	case *yabl.PeripheryDebug:
+		break
+	case *yabl.ConverterPresentEnergy:
+		break
+	case *yabl.ConverterErrors:
+		break
+	case *yabl.ConverterDebug:
+		break
+	case *yabl.CpuPresentEnergy:
+		break
+	case *yabl.CpuEnergySettings:
+		break
+	case *yabl.CpuErrors:
+		break
+	case *yabl.CpuPeriphery:
+		break
+	case *yabl.CpuDebug:
+		break
+	default:
+		return
+	}
 	g.redraw = true
 }

@ -199,8 +241,8 @@ func (l log) Consume(event *yabl.Event) {
 	fmt.Printf(
 		"%v %v.%v [%d] %v\n",
 		event.Updated.Format("Jan _2 15:04:05.000"),
-		*event.ActionName,
-		*event.Field,
+		event.ActionName,
+		event.Field,
 		event.GetUnitId(),
 		event.Value)
 }
--- a/yabl/const.go
+++ b/yabl/const.go
@ -1,41 +1,14 @@
 package yabl

 const (
-	CONVERTERS_MAX  = 18 + 1
-	CONTACTOR_MAX   = 18 + 1
-	CONNECTOR_COUNT = 6
-	CONNECTOR_MAX   = CONNECTOR_COUNT + 1
-	ALL_BITS        = 0xFFFFFFFFFFFFFFFF
-	UNIT_ID_OFFSET  = 12
-	UNIT_ID_MASK    = 0b111111111111 << UNIT_ID_OFFSET
-	ACTION_ID_MASK  = 0b111111111111
-
-	CanIdContIntState           = 0x071
-	CanIdContIntErr             = 0x073
-	CanIdContIntForce           = 0x074
-	CanIdContIntDebug           = 0x075
-	CanIdPuPresentEnergy        = 0x021
-	CanIdPuPeriphery            = 0x022
-	CanIdPuErrors               = 0x023
-	CanIdCpuPresentEnergy       = 0x011
-	CanIdCpuPeriphery           = 0x014
-	CanIdCpuEnergySettings      = 0x015
-	CanIdCpuErrors              = 0x016
-	CanIdCpuDebug               = 0x01A
-	CanIdPuDebug                = 0x02A
-	CanIdSeccTargetEnergy       = 0x041
-	CanIdSeccErrors             = 0x042
-	CanIdLogicAuth              = 0x046
-	CanIdLogicEnergyMode        = 0x047
-	CanIdLogicErrors            = 0x048
-	CanIdLogicWorkingMode       = 0x049
-	CanIdPeripheryState         = 0x067
-	CanIdPeripheryInfo          = 0x068
-	CanIdPeripheryDebug         = 0x06C
-	CanIdConverterPresentEnergy = 0x061
-	CanIdConverterErrors        = 0x062
-	CanIdConverterDebug         = 0x065
-
+	CONVERTERS_MAX                                                  = 18 + 1
+	CONTACTOR_MAX                                                   = 18 + 1
+	CONNECTOR_COUNT                                                 = 6
+	CONNECTOR_MAX                                                   = CONNECTOR_COUNT + 1
+	ALL_BITS                                                        = 0xFFFFFFFFFFFFFFFF
+	UNIT_ID_OFFSET                                                  = 12
+	UNIT_ID_MASK                                                    = 0b111111111111 << UNIT_ID_OFFSET
+	ACTION_ID_MASK                                                  = 0b111111111111
 	BOARD_READY_OK                  BoardReadyType                  = 0
 	BOARD_READY_INFO                BoardReadyType                  = 1
 	BOARD_READY_WARNING             BoardReadyType                  = 2
--- a/yabl/init.go
+++ b/yabl/init.go
@ -1,10 +1,12 @@
 package yabl

+import "cli-mon/can"
+
 func (c *converter) initialize() {
-	c.protocolMap = make(map[key]*action)
+	c.protocolMap = make(map[key]action)

 	for i := uint(1); i <= CONNECTOR_COUNT; i++ {
-		key := key{CanIdCpuPresentEnergy, i}
+		key := key{can.CAN_ID_011, i}
 		cpe := &CpuPresentEnergy{unit: 1}
 		c.cpuPresentEnergyArray[i] = cpe
 		fields := []*field{
@ -12,7 +14,7 @@ func (c *converter) initialize() {
 			{length: 10, setter: cpe.setPresentCurrent, name: FPresentCurrent},
 			{length: 11, setter: cpe.setPresentVoltage, name: FPresentVoltage},
 		}
-		c.protocolMap[key] = &action{fields: fields, interval: 50, name: PCpuPresentEnergy, object: cpe}
+		c.protocolMap[key] = action{fields: fields, interval: 50, name: PCpuPresentEnergy, object: cpe}
 	}

 	c.cpuPeripheryInstance = &CpuPeriphery{unit: 0}
@ -21,7 +23,7 @@ func (c *converter) initialize() {
 		{length: 2, setter: c.cpuPeripheryInstance.setCircuitBreakerInput, name: FCircuitBreakerInput},
 		{length: 2, setter: c.cpuPeripheryInstance.setCircuitBreakerPowerCBInput, name: FCircuitBreakerPowerCBInput},
 	}
-	c.protocolMap[key{CanIdCpuPeriphery, 0}] = &action{
+	c.protocolMap[key{can.CAN_ID_014, 0}] = action{
 		fields:   fields,
 		interval: 1000,
 		name:     PCpuPeriphery,
@ -29,7 +31,7 @@ func (c *converter) initialize() {
 	}

 	for i := uint(0); i <= CONNECTOR_COUNT; i++ {
-		key := key{CanIdCpuEnergySettings, i}
+		key := key{can.CAN_ID_015, i}
 		ces := &CpuEnergySettings{unit: unit(i)}
 		c.cpuEnergySettingsArray[i] = ces
 		fields := []*field{
@ -39,7 +41,7 @@ func (c *converter) initialize() {
 			{length: 11, setter: ces.setTargetBatteryVoltage, name: FTargetBatteryVoltage},
 			{length: 11, setter: ces.setTargetGoalVoltage, name: FTargetGoalVoltage},
 		}
-		c.protocolMap[key] = &action{fields: fields, interval: 1000, name: PCpuEnergySettings, object: ces}
+		c.protocolMap[key] = action{fields: fields, interval: 1000, name: PCpuEnergySettings, object: ces}
 	}

 	c.cpuErrorsInstance = &CpuErrors{unit: 0}
@ -63,7 +65,7 @@ func (c *converter) initialize() {
 		{length: 2, setter: c.cpuErrorsInstance.setContactorInputError, name: FContactorInputError},
 		{length: 2, setter: c.cpuErrorsInstance.setNotReadyPeriphery, name: FNotReadyPeriphery},
 	}
-	c.protocolMap[key{CanIdCpuErrors, 0}] = &action{
+	c.protocolMap[key{can.CAN_ID_016, 0}] = action{
 		fields:   fields,
 		interval: 1000,
 		name:     PCpuErrors,
@ -77,7 +79,7 @@ func (c *converter) initialize() {
 		{length: 3, setter: c.cpuDebugInstance.setDebugCircuitBreakerOn, name: FDebugCircuitBreakerOn},
 		{length: 3, setter: c.cpuDebugInstance.setDebugRedButtonSoftware, name: FDebugRedButtonSoftware},
 	}
-	c.protocolMap[key{CanIdCpuDebug, 0}] = &action{
+	c.protocolMap[key{can.CAN_ID_01A, 0}] = action{
 		fields:   fields,
 		interval: 1000,
 		name:     PCpuDebug,
@ -85,7 +87,7 @@ func (c *converter) initialize() {
 	}

 	for i := uint(1); i <= CONNECTOR_COUNT; i++ {
-		key := key{CanIdPuPresentEnergy, i}
+		key := key{can.CAN_ID_021, i}
 		ppe := &PuPresentEnergy{unit: unit(i)}
 		c.puPresentEnergyArray[i] = ppe
 		fields := []*field{
@ -94,11 +96,11 @@ func (c *converter) initialize() {
 			{length: 11, setter: ppe.setVoltageAfter, name: FVoltageAfter},
 			{length: 10, setter: ppe.setPresentCurrent, name: FPresentCurrent},
 		}
-		c.protocolMap[key] = &action{fields: fields, interval: 50, name: PPuPresentEnergy, object: ppe}
+		c.protocolMap[key] = action{fields: fields, interval: 50, name: PPuPresentEnergy, object: ppe}
 	}

 	for i := uint(1); i <= CONNECTOR_COUNT; i++ {
-		key := key{CanIdPuPeriphery, i}
+		key := key{can.CAN_ID_022, i}
 		pp := &PuPeriphery{unit: unit(i)}
 		c.puPeripheryArray[i] = pp
 		fields := []*field{
@ -111,11 +113,11 @@ func (c *converter) initialize() {
 			{length: 2, setter: pp.setPwmEnabled, name: FPwmEnabled},
 			{length: 9, setter: pp.setCpLineVoltage, name: FCpLineVoltage},
 		}
-		c.protocolMap[key] = &action{fields: fields, interval: 1000, name: PPuPeriphery, object: pp}
+		c.protocolMap[key] = action{fields: fields, interval: 1000, name: PPuPeriphery, object: pp}
 	}

 	for i := uint(1); i <= CONNECTOR_COUNT; i++ {
-		key := key{CanIdPuErrors, i}
+		key := key{can.CAN_ID_023, i}
 		pe := &PuErrors{unit: 1}
 		c.puErrorsArray[i] = pe
 		fields := []*field{
@ -136,22 +138,22 @@ func (c *converter) initialize() {
 			{length: 2, setter: pe.setOutputCircuitBreakerEnabled, name: FOutputCircuitBreakerEnabled},
 			{length: 12, setter: pe.setOutputCircuitBreakerEnabledValue, name: FOutputCircuitBreakerEnabledValue},
 		}
-		c.protocolMap[key] = &action{fields: fields, interval: 1000, name: PPuErrors, object: pe}
+		c.protocolMap[key] = action{fields: fields, interval: 1000, name: PPuErrors, object: pe}
 	}

 	for i := uint(0); i <= CONNECTOR_COUNT; i++ {
-		key := key{CanIdPuDebug, i}
+		key := key{can.CAN_ID_02A, i}
 		pd := &PuDebug{unit: unit(i)}
 		c.puDebugArray[i] = pd
 		fields = []*field{
 			{length: 2, setter: pd.setDebugModeOn, name: FDebugModeOn},
 			{length: 3, setter: pd.setDebugContactorOutputOn, name: FDebugContactorOutputOn},
 		}
-		c.protocolMap[key] = &action{fields: fields, interval: 1000, name: PPuDebug, object: pd}
+		c.protocolMap[key] = action{fields: fields, interval: 1000, name: PPuDebug, object: pd}
 	}

 	for i := uint(1); i <= CONNECTOR_COUNT; i++ {
-		key := key{CanIdSeccTargetEnergy, i}
+		key := key{can.CAN_ID_041, i}
 		ste := &SeccTargetEnergy{unit: unit(i)}
 		c.seccTargetEnergyArray[i] = ste
 		fields = []*field{
@ -160,33 +162,33 @@ func (c *converter) initialize() {
 			{length: 11, setter: ste.setTargetGoalVoltage, name: FTargetGoalVoltage},
 			{length: 10, setter: ste.setTargetCurrent, name: FTargetCurrent},
 		}
-		c.protocolMap[key] = &action{fields: fields, interval: 1000, name: PSeccTargetEnergy, object: ste}
+		c.protocolMap[key] = action{fields: fields, interval: 1000, name: PSeccTargetEnergy, object: ste}
 	}

 	for i := uint(1); i <= CONNECTOR_COUNT; i++ {
-		key := key{CanIdSeccErrors, i}
+		key := key{can.CAN_ID_042, i}
 		se := &SeccErrors{unit: unit(i)}
 		c.seccErrorsArray[i] = se
 		fields = []*field{
 			{length: 3, setter: se.setBoardReady, name: FBoardReady},
 			{length: 2, setter: se.setNotReadyLogic, name: FNotReadyLogic},
 		}
-		c.protocolMap[key] = &action{fields: fields, interval: 1000, name: PSeccErrors, object: se}
+		c.protocolMap[key] = action{fields: fields, interval: 1000, name: PSeccErrors, object: se}
 	}

 	for i := uint(0); i <= CONNECTOR_COUNT; i++ {
-		key := key{CanIdLogicAuth, i}
+		key := key{can.CAN_ID_046, i}
 		la := &LogicAuth{unit: unit(i)}
 		c.logicAuthArray[i] = la
 		fields = []*field{
 			{length: 2, setter: la.setAuthMode, name: FAuthMode},
 			{length: 3, setter: la.setAuthState, name: FAuthState},
 		}
-		c.protocolMap[key] = &action{fields: fields, interval: 1000, name: PLogicAuth, object: la}
+		c.protocolMap[key] = action{fields: fields, interval: 1000, name: PLogicAuth, object: la}
 	}

 	for i := uint(0); i <= CONNECTOR_COUNT; i++ {
-		key := key{CanIdLogicEnergyMode, i}
+		key := key{can.CAN_ID_047, i}
 		lem := &LogicEnergyMode{unit: unit(i)}
 		c.logicEnergyMode[i] = lem
 		fields = []*field{
@ -195,7 +197,7 @@ func (c *converter) initialize() {
 			{length: 11, setter: lem.setVoltageMax, name: FVoltageMax},
 			{length: 14, setter: lem.setPowerMax, name: FPowerMax},
 		}
-		c.protocolMap[key] = &action{fields: fields, interval: 1000, name: PLogicEnergyMode, object: lem}
+		c.protocolMap[key] = action{fields: fields, interval: 1000, name: PLogicEnergyMode, object: lem}
 	}

 	c.logicErrorsInstance = &LogicErrors{unit: 0}
@ -203,7 +205,7 @@ func (c *converter) initialize() {
 		{length: 3, setter: c.logicErrorsInstance.setBoardReady, name: FBoardReady},
 		{length: 2, setter: c.logicErrorsInstance.setNotReadySettings, name: FNotReadySettings},
 	}
-	c.protocolMap[key{CanIdLogicErrors, 0}] = &action{
+	c.protocolMap[key{can.CAN_ID_048, 0}] = action{
 		fields:   fields,
 		interval: 1000,
 		name:     PLogicErrors,
@ -211,14 +213,14 @@ func (c *converter) initialize() {
 	}

 	for i := uint(0); i <= CONNECTOR_COUNT; i++ {
-		key := key{CanIdLogicWorkingMode, i}
+		key := key{can.CAN_ID_049, i}
 		lwm := &LogicWorkingMode{unit: unit(i)}
 		c.logicWorkingMode[i] = lwm
 		fields = []*field{
 			{length: 5, setter: lwm.setTargetContactorMode, name: FTargetContactorMode},
 			{length: 2, setter: lwm.setAvailability, name: FAvailability},
 		}
-		c.protocolMap[key] = &action{
+		c.protocolMap[key] = action{
 			fields:   fields,
 			interval: 1000,
 			name:     PLogicWorkingMode,
@ -227,7 +229,7 @@ func (c *converter) initialize() {
 	}

 	for i := uint(0); i < CONTACTOR_MAX; i++ {
-		key := key{CanIdContIntState, i}
+		key := key{can.CAN_ID_071, i}
 		cis := &ContactorInternalState{unit: unit(i)}
 		c.contactorInternalStateArray[i] = cis
 		fields = []*field{
@ -237,7 +239,7 @@ func (c *converter) initialize() {
 			{length: 2, setter: cis.setIsolated, name: FIsolated},
 			{length: 2, setter: cis.setDebugEnabled, name: FDebugEnabled},
 		}
-		c.protocolMap[key] = &action{fields: fields, interval: 1000, name: PContactorInternalState, object: cis}
+		c.protocolMap[key] = action{fields: fields, interval: 1000, name: PContactorInternalState, object: cis}
 	}

 	c.contactorInternalErrorsInstance = &ContactorInternalErrors{unit: 0}
@ -251,7 +253,7 @@ func (c *converter) initialize() {
 		{length: 2, setter: c.contactorInternalErrorsInstance.setDebug, name: FDebug},
 		{length: 5, setter: c.contactorInternalErrorsInstance.setPresentContactorMode, name: FPresentContactorMode},
 	}
-	c.protocolMap[key{CanIdContIntErr, 0}] = &action{
+	c.protocolMap[key{can.CAN_ID_073, 0}] = action{
 		fields:   fields,
 		interval: 1000,
 		name:     PContactorInternalErrors,
@ -263,7 +265,7 @@ func (c *converter) initialize() {
 		{length: 2, setter: c.contactorsInternalForce.setForceModeEnabled, name: FForceModeEnabled},
 		{length: 4, setter: c.contactorsInternalForce.setForceModeValue, name: FForceModeValue},
 	}
-	c.protocolMap[key{CanIdContIntForce, 0}] = &action{
+	c.protocolMap[key{can.CAN_ID_074, 0}] = action{
 		fields:   fields,
 		interval: 1000,
 		name:     PContactorsInternalForce,
@ -271,18 +273,18 @@ func (c *converter) initialize() {
 	}

 	for i := uint(0); i < CONTACTOR_MAX; i++ {
-		key := key{CanIdContIntDebug, i}
+		key := key{can.CAN_ID_075, i}
 		cid := &ContactorInternalDebug{unit: unit(i)}
 		c.contactorInternalDebugArray[i] = cid
 		fields = []*field{
 			{length: 2, setter: cid.setDebugModeOn, name: FDebugModeOn},
 			{length: 3, setter: cid.setDebugContactorOn, name: FDebugContactorOn},
 		}
-		c.protocolMap[key] = &action{fields: fields, interval: 1000, name: PContactorInternalDebug, object: cid}
+		c.protocolMap[key] = action{fields: fields, interval: 1000, name: PContactorInternalDebug, object: cid}
 	}

 	for i := uint(0); i <= CONNECTOR_COUNT; i++ {
-		key := key{CanIdPeripheryState, i}
+		key := key{can.CAN_ID_067, i}
 		ps := &PeripheryState{unit: unit(i)}
 		c.peripheryStateArray[i] = ps
 		fields = []*field{
@ -309,11 +311,11 @@ func (c *converter) initialize() {
 			{length: 2, setter: ps.setErrorContactorsInternalCircuitBreaker, name: FErrorContactorsInternalCircuitBreaker},
 			{length: 2, setter: ps.setErrorPlcCircuitBreaker, name: FErrorPlcCircuitBreaker},
 		}
-		c.protocolMap[key] = &action{fields: fields, interval: 1000, name: PPeripheryState, object: ps}
+		c.protocolMap[key] = action{fields: fields, interval: 1000, name: PPeripheryState, object: ps}
 	}

 	for i := uint(0); i <= CONNECTOR_COUNT; i++ {
-		key := key{CanIdPeripheryInfo, i}
+		key := key{can.CAN_ID_068, i}
 		pi := &PeripheryInfo{unit: unit(i)}
 		c.peripheryInfoArray[i] = pi
 		fields = []*field{
@ -323,11 +325,11 @@ func (c *converter) initialize() {
 			{length: 2, setter: pi.setStateShsnFan, name: FStateShsnFan},
 			{length: 2, setter: pi.setStateShptFan, name: FStateShptFan},
 		}
-		c.protocolMap[key] = &action{fields: fields, interval: 5000, name: PPeripheryInfo, object: pi}
+		c.protocolMap[key] = action{fields: fields, interval: 5000, name: PPeripheryInfo, object: pi}
 	}

 	for i := uint(0); i <= CONNECTOR_COUNT; i++ {
-		key := key{CanIdPeripheryDebug, i}
+		key := key{can.CAN_ID_06C, i}
 		pd := &PeripheryDebug{unit: unit(i)}
 		c.peripheryDebugArray[i] = pd
 		fields = []*field{
@ -336,11 +338,11 @@ func (c *converter) initialize() {
 			{length: 3, setter: pd.setDebugShptFan, name: FDebugShptFan},
 			{length: 3, setter: pd.setDebugIoBoardTestLamp, name: FDebugIoBoardTestLamp},
 		}
-		c.protocolMap[key] = &action{fields: fields, interval: 1000, name: PPeripheryDebug, object: pd}
+		c.protocolMap[key] = action{fields: fields, interval: 1000, name: PPeripheryDebug, object: pd}
 	}

 	for i := uint(1); i < CONVERTERS_MAX; i++ {
-		key := key{CanIdConverterPresentEnergy, i}
+		key := key{can.CAN_ID_061, i}
 		cpe := &ConverterPresentEnergy{unit: unit(i)}
 		c.converterPresentEnergyArray[i] = cpe
 		fields = []*field{
@ -349,11 +351,11 @@ func (c *converter) initialize() {
 			{length: 10, setter: cpe.setPresentCurrent, name: FPresentCurrent},
 			{length: 8, setter: cpe.setConnectedOut, name: FConnectedOut},
 		}
-		c.protocolMap[key] = &action{fields: fields, interval: 500, name: PConverterPresentEnergy, object: cpe}
+		c.protocolMap[key] = action{fields: fields, interval: 500, name: PConverterPresentEnergy, object: cpe}
 	}

 	for i := uint(1); i < CONVERTERS_MAX; i++ {
-		key := key{CanIdConverterErrors, i}
+		key := key{can.CAN_ID_062, i}
 		ce := &ConverterErrors{unit: unit(i)}
 		c.converterErrorsArray[i] = ce
 		fields = []*field{
@ -375,11 +377,11 @@ func (c *converter) initialize() {
 			{length: 2, setter: ce.setDebugConvEnabled, name: FDebugConvEnabled},
 			{length: 2, setter: ce.setDebugConvDisabled, name: FDebugConvDisabled},
 		}
-		c.protocolMap[key] = &action{fields: fields, interval: 1000, name: PConverterErrors, object: ce}
+		c.protocolMap[key] = action{fields: fields, interval: 1000, name: PConverterErrors, object: ce}
 	}

 	for i := uint(0); i < CONVERTERS_MAX; i++ {
-		key := key{CanIdConverterDebug, i}
+		key := key{can.CAN_ID_065, i}
 		cd := &ConverterDebug{unit: unit(i)}
 		c.converterDebugArray[i] = cd
 		fields = []*field{
@ -388,7 +390,7 @@ func (c *converter) initialize() {
 			{length: 11, setter: cd.setDebugTargetVoltage, name: FDebugTargetVoltage},
 			{length: 10, setter: cd.setDebugTargetCurrent, name: FDebugTargetCurrent},
 		}
-		c.protocolMap[key] = &action{fields: fields, interval: 1000, name: PConverterDebug, object: cd}
+		c.protocolMap[key] = action{fields: fields, interval: 1000, name: PConverterDebug, object: cd}
 	}

 	// set "null" values
--- a/yabl/protocol.go
+++ b/yabl/protocol.go
@ -3,7 +3,6 @@ package yabl
 import (
 	can "cli-mon/can"
 	"encoding/binary"
-	"os"
 	time "time"
 )

@ -28,8 +27,7 @@ type key struct {
 }

 type converter struct {
-	tag                             string
-	protocolMap                     map[key]*action
+	protocolMap                     map[key]action
 	cpuPresentEnergyArray           [CONNECTOR_MAX]*CpuPresentEnergy
 	cpuPeripheryInstance            *CpuPeriphery
 	cpuEnergySettingsArray          [CONNECTOR_MAX]*CpuEnergySettings
@ -59,18 +57,11 @@ type converter struct {

 type Converter interface {
 	EventsFromFrame(*can.CanFrame) ([]*Event, bool)
-	CheckTimeouts(isOffline bool) ([]*Event, bool)
+	CheckTimeouts() ([]*Event, bool)
 }

-func NewProtocolConverter(tag string) Converter {
-	if len(tag) == 0 {
-		tag = os.Getenv("HOSTNAME")
-		if len(tag) == 0 {
-			tag, _ = os.Hostname()
-		}
-	}
-
-	c := &converter{tag: tag}
+func NewProtocolConverter() Converter {
+	c := &converter{}
 	c.initialize()
 	return c
 }
@ -95,10 +86,9 @@ func (c *converter) EventsFromFrame(frame *can.CanFrame) ([]*Event, bool) {
 					obj := f.setter(val)

 					event := &Event{
-						Tag:        &c.tag,
-						Field:      &f.name,
-						ActionName: &param.name,
-						Object:     &param.object,
+						Field:      f.name,
+						ActionName: param.name,
+						Object:     param.object,
 						unit:       unit(unitId),
 						Updated:    frame.Date,
 						Value:      obj,
@ -114,8 +104,8 @@ func (c *converter) EventsFromFrame(frame *can.CanFrame) ([]*Event, bool) {
 	return nil, false
 }

-func get(from uint8, size uint8, buffer *[]byte) (uint64, bool) {
-	value := binary.LittleEndian.Uint64(*buffer)
+func get(from uint8, size uint8, buffer []byte) (uint64, bool) {
+	value := binary.LittleEndian.Uint64(buffer)

 	var mask uint64 = ^(ALL_BITS << size)
 	mask = mask << from
@ -132,19 +122,12 @@ func (u unit) GetUnitId() uint {
 	return uint(u)
 }

-func (c *converter) CheckTimeouts(isOffline bool) ([]*Event, bool) {
+func (c *converter) CheckTimeouts() ([]*Event, bool) {
 	var multipler uint = 2
 	var events []*Event

 	for k, param := range c.protocolMap {
-
-		var now time.Time
-		if isOffline {
-			now = getMaxTime(&c.protocolMap)
-		} else {
-			now = time.Now()
-		}
-
+		now := time.Now()
 		deadline := now.Add(-time.Duration(param.interval*multipler) * time.Millisecond)

 		var from uint8 = 0
@ -158,12 +141,11 @@ func (c *converter) CheckTimeouts(isOffline bool) ([]*Event, bool) {
 				}

 				event := &Event{
-					Tag:        &c.tag,
-					Field:      &fld.name,
-					ActionName: &param.name,
-					Object:     &param.object,
+					Field:      fld.name,
+					ActionName: param.name,
+					Object:     param.object,
 					unit:       unit(k.unitId),
-					Updated:    &deadline,
+					Updated:    &now,
 					Value:      nil,
 				}

@ -179,16 +161,3 @@ func (c *converter) CheckTimeouts(isOffline bool) ([]*Event, bool) {
 	}
 	return events, events != nil
 }
-
-func getMaxTime(protocolMap *map[key]*action) time.Time {
-	now := time.Unix(0, 0)
-
-	for _, param := range *protocolMap {
-		for _, fld := range param.fields {
-			if fld.last != nil && fld.last.After(now) {
-				now = *fld.last
-			}
-		}
-	}
-	return now
-}
--- a/yabl/strings.go
+++ b/yabl/strings.go
@ -1,10 +1,6 @@
 package yabl

-import (
-	"encoding/json"
-	"fmt"
-	"time"
-)
+import "fmt"

 func (t BooleanType) String() string {
 	switch t {
@ -215,21 +211,3 @@ func (t SignedAirTemp8BitType) String() string {
 func (c ConnectedOut8bitType) String() string {
 	return fmt.Sprintf("%d", c)
 }
-
-func (u *Event) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Host       *string
-		Unit       uint
-		ActionName *AName
-		Field      *FName
-		Updated    *time.Time
-		Value      string
-	}{
-		Host:       u.Tag,
-		Unit:       u.GetUnitId(),
-		ActionName: u.ActionName,
-		Field:      u.Field,
-		Updated:    u.Updated,
-		Value:      fmt.Sprintf("%v", u.Value),
-	})
-}
--- a/yabl/types.go
+++ b/yabl/types.go
@ -13,10 +13,9 @@ type Action interface {

 type Event struct {
 	unit
-	Tag        *string
-	ActionName *AName
-	Field      *FName
-	Object     *Action //TODO Actually obj, or copy on event generation time?
+	ActionName AName
+	Field      FName
+	Object     Action
 	Updated    *time.Time
 	Value      any
 }