From 873a249e0835dffd5d21d16e66da0f0bdd54c872 Mon Sep 17 00:00:00 2001 From: aespin Date: Tue, 20 Aug 2024 10:07:14 +0200 Subject: [PATCH] wip --- README.md | 0 cmd/main.go | 9 ++ go.mod | 27 ++++++ go.sum | 51 ++++++++++ internal/app/app.go | 143 ++++++++++++++++++++++++++++ internal/logging/logging.go | 86 +++++++++++++++++ internal/service/service.go | 45 +++++++++ internal/types/bd.go | 25 +++++ internal/types/ed.go | 45 +++++++++ internal/types/header.go | 11 +++ internal/types/uf.go | 181 ++++++++++++++++++++++++++++++++++++ internal/types/ur.go | 181 ++++++++++++++++++++++++++++++++++++ 12 files changed, 804 insertions(+) create mode 100644 README.md create mode 100644 cmd/main.go create mode 100644 go.mod create mode 100644 go.sum create mode 100644 internal/app/app.go create mode 100644 internal/logging/logging.go create mode 100644 internal/service/service.go create mode 100644 internal/types/bd.go create mode 100644 internal/types/ed.go create mode 100644 internal/types/header.go create mode 100644 internal/types/uf.go create mode 100644 internal/types/ur.go diff --git a/README.md b/README.md new file mode 100644 index 0000000..e69de29 diff --git a/cmd/main.go b/cmd/main.go new file mode 100644 index 0000000..171a7f7 --- /dev/null +++ b/cmd/main.go @@ -0,0 +1,9 @@ +package main + +import "git.espin.casa/albert/cml04-l2-rsm-out/internal/app" + +func main() { + if err := app.Run(); err != nil { + panic(err) + } +} diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..59c3280 --- /dev/null +++ b/go.mod @@ -0,0 +1,27 @@ +module git.espin.casa/albert/cml04-l2-rsm-out + +go 1.22.0 + +require ( + git.espin.casa/albert/cml04-eventer v0.0.0-20240222031945-f20c9e4ddc36 + git.espin.casa/albert/logger v0.0.0-20240221100041-dc3cb01119a3 +) + +require ( + github.com/golang/protobuf v1.5.3 // indirect + golang.org/x/net v0.18.0 // indirect + golang.org/x/text v0.14.0 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20231106174013-bbf56f31fb17 // indirect + google.golang.org/grpc v1.61.1 // indirect +) + +require ( + git.espin.casa/albert/cml04-gdm-int v0.0.0-20240221200353-854fa2d29d83 + github.com/golang/snappy v0.0.1 // indirect + github.com/google/uuid v1.6.0 // indirect + github.com/nsqio/go-nsq v1.1.0 // indirect + github.com/pkg/errors v0.9.1 // indirect + github.com/sirupsen/logrus v1.9.3 // indirect + golang.org/x/sys v0.14.0 // indirect + google.golang.org/protobuf v1.32.0 +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..8885d5e --- /dev/null +++ b/go.sum @@ -0,0 +1,51 @@ +git.espin.casa/albert/cml04-eventer v0.0.0-20240222031945-f20c9e4ddc36 h1:HbF07y7ExWmkXVzQeKoo1t/u7rduuvn93IGJFCBCKAg= +git.espin.casa/albert/cml04-eventer v0.0.0-20240222031945-f20c9e4ddc36/go.mod h1:/fj0cTIFEdeYmzL2r4WLEAN2q3N3T48ZPOT1hqusuSI= +git.espin.casa/albert/cml04-gdm-int v0.0.0-20240221200353-854fa2d29d83 h1:M7Tpn26MPG+4PIFEBFwatfajLaEcaGCSeigtfzutGiM= +git.espin.casa/albert/cml04-gdm-int v0.0.0-20240221200353-854fa2d29d83/go.mod h1:ixkbymSPizICKrPse8rBi/WiVDrVZ7PXOKYa7XvB1VM= +git.espin.casa/albert/logger v0.0.0-20240221100041-dc3cb01119a3 h1:HUEESn4o8sVXAUJWGJAATeitiNRxVzzwBU8RiIW4Wzc= +git.espin.casa/albert/logger v0.0.0-20240221100041-dc3cb01119a3/go.mod h1:P1yAUiotJurq7j/wZt6Cnel17HChplkz0E40WD8a5to= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= +github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg= +github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= +github.com/golang/snappy v0.0.1 h1:Qgr9rKW7uDUkrbSmQeiDsGa8SjGyCOGtuasMWwvp2P4= +github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/nsqio/go-nsq v1.1.0 h1:PQg+xxiUjA7V+TLdXw7nVrJ5Jbl3sN86EhGCQj4+FYE= +github.com/nsqio/go-nsq v1.1.0/go.mod h1:vKq36oyeVXgsS5Q8YEO7WghqidAVXQlcFxzQbQTuDEY= +github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ= +github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +golang.org/x/net v0.18.0 h1:mIYleuAkSbHh0tCv7RvjL3F6ZVbLjq4+R7zbOn3Kokg= +golang.org/x/net v0.18.0/go.mod h1:/czyP5RqHAH4odGYxBJ1qz0+CE5WZ+2j1YgoEo8F2jQ= +golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.4.0 h1:Zr2JFtRQNX3BCZ8YtxRE9hNJYC8J6I1MVbMg6owUp18= +golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.14.0 h1:Vz7Qs629MkJkGyHxUlRHizWJRG2j8fbQKjELVSNhy7Q= +golang.org/x/sys v0.14.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= +golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +google.golang.org/genproto/googleapis/rpc v0.0.0-20231106174013-bbf56f31fb17 h1:Jyp0Hsi0bmHXG6k9eATXoYtjd6e2UzZ1SCn/wIupY14= +google.golang.org/genproto/googleapis/rpc v0.0.0-20231106174013-bbf56f31fb17/go.mod h1:oQ5rr10WTTMvP4A36n8JpR1OrO1BEiV4f78CneXZxkA= +google.golang.org/grpc v1.61.1 h1:kLAiWrZs7YeDM6MumDe7m3y4aM6wacLzM1Y/wiLP9XY= +google.golang.org/grpc v1.61.1/go.mod h1:VUbo7IFqmF1QtCAstipjG0GIoq49KvMe9+h1jFLBNJs= +google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= +google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= +google.golang.org/protobuf v1.32.0 h1:pPC6BG5ex8PDFnkbrGU3EixyhKcQ2aDuBS36lqK/C7I= +google.golang.org/protobuf v1.32.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/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 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/internal/app/app.go b/internal/app/app.go new file mode 100644 index 0000000..7e2eb10 --- /dev/null +++ b/internal/app/app.go @@ -0,0 +1,143 @@ +package app + +import ( + "context" + "flag" + "fmt" + "os" + "os/signal" + "syscall" + + cml04eventer "git.espin.casa/albert/cml04-eventer" + "git.espin.casa/albert/cml04-gdm-int/pkg/api" + "git.espin.casa/albert/cml04-l2-rsm-out/internal/logging" + "git.espin.casa/albert/cml04-l2-rsm-out/internal/service" + "git.espin.casa/albert/logger" + "google.golang.org/protobuf/proto" +) + +func Run() error { + // flags + l2OutAddr := flag.String("l2-in-addr", "0.0.0.0:5013", "tcp l2 server address") + nsqAddr := flag.String("nsq-addr", "10.1.152.13", "nsq server address") + nsqPort := flag.Int("nsq-port", 4150, "nsq server port") + logLevel := flag.String("log-level", "debug", "trace debug level") + flag.Parse() + // setup logger + log := logger.New(os.Stdout, *logLevel) + // log fields + logFields := logger.LogFields{ + "log_level": *logLevel, + "l2_out_address": *l2OutAddr, + "nsq_address": *nsqAddr, + "nsq_port": *nsqPort, + } + // create service + svc := service.NewService() + svc = logging.NewLogginService(log, svc) + // create context + ctx := context.Background() + // subscribe events + subscriber, err := cml04eventer.NewSubscriber(&cml04eventer.SubscriberConfig{ + NSQAddress: *nsqAddr, + NSQPort: *nsqPort, + Unmarshaler: cml04eventer.JSONMarshaler{}, + Channel: "cml04-l2-rsm-out", + }, log) + // check error + if err != nil { + log.Error("create subscriber failed", err, logFields) + return err + } + // subscribe events + eventChan, err := subscriber.SubscribeEvent(ctx, "RSM") + if err != nil { + log.Error("subscribe event failed", err, logFields) + return err + } + // + go func() { + for event := range eventChan { + if err := ProcessEvent(event, svc); err != nil { + log.Error("", err, logFields) + } + } + }() + // info banner + log.Info("started cml04-l2-rsm-out telegram service", logFields) + // wait signal to finish + signal := WaitSignal() + log.Info("signal received", logFields.Add(logger.LogFields{ + "signal": signal, + })) + return nil +} + +func ProcessEvent(evt *cml04eventer.Event, svc service.IService) error { + telegramID, err := evt.EventMeta.Get("telegram_id") + if err != nil { + return err + } + fmt.Println(telegramID) + switch telegramID.(float64) { + case 9000: + // bd roll data holder + bdRollData := &api.BdRollData{} + // unmarshal proto message + if err := proto.Unmarshal(evt.EventData, bdRollData); err != nil { + return err + } + if err := svc.SendBdRollData(context.Background(), bdRollData); err != nil { + return err + } + case 9001: + // ur roll data holder + urRollData := &api.UrRollData{} + // unmarshal proto message + if err := proto.Unmarshal(evt.EventData, urRollData); err != nil { + return err + } + if err := svc.SendUrRollData(context.Background(), urRollData); err != nil { + return err + } + case 9002: + // ed roll data holder + edRollData := &api.EdRollData{} + // unmarshal proto message + if err := proto.Unmarshal(evt.EventData, edRollData); err != nil { + return err + } + if err := svc.SendEdRollData(context.Background(), edRollData); err != nil { + return err + } + case 9003: + // uf roll data holder + ufRollData := &api.UfRollData{} + // unmarshal proto message + if err := proto.Unmarshal(evt.EventData, ufRollData); err != nil { + return err + } + if err := svc.SendUfRollData(context.Background(), ufRollData); err != nil { + return err + } + } + return nil +} + +// WaitSignal catching exit signal +func WaitSignal() os.Signal { + ch := make(chan os.Signal, 2) + signal.Notify( + ch, + syscall.SIGINT, + syscall.SIGQUIT, + syscall.SIGTERM, + ) + for { + sig := <-ch + switch sig { + case syscall.SIGINT, syscall.SIGQUIT, syscall.SIGTERM: + return sig + } + } +} diff --git a/internal/logging/logging.go b/internal/logging/logging.go new file mode 100644 index 0000000..6e4ab66 --- /dev/null +++ b/internal/logging/logging.go @@ -0,0 +1,86 @@ +package logging + +import ( + "context" + "time" + + "git.espin.casa/albert/cml04-gdm-int/pkg/api" + "git.espin.casa/albert/cml04-l2-rsm-out/internal/service" + "git.espin.casa/albert/logger" +) + +type LoggingService struct { + log logger.LoggerAdapter + next service.IService +} + +// SendEdRollData implements service.IService. +func (svc *LoggingService) SendEdRollData(ctx context.Context, rollData *api.EdRollData) (err error) { + defer func(start time.Time) { + logFields := logger.LogFields{ + "took": time.Since(start), + "ed_roll_id": rollData.GetEdRollId(), + } + if err != nil { + svc.log.Error("Send level 2 ED roll data failed", err, logFields) + } else { + svc.log.Info("Send level 2 ED roll success", logFields) + } + }(time.Now()) + return svc.next.SendEdRollData(ctx, rollData) +} + +// SendUfRollData implements service.IService. +func (svc *LoggingService) SendUfRollData(ctx context.Context, rollData *api.UfRollData) (err error) { + defer func(start time.Time) { + logFields := logger.LogFields{ + "took": time.Since(start), + "uf_roll_id": rollData.GetUfRollId(), + } + if err != nil { + svc.log.Error("Send level 2 UF roll data failed", err, logFields) + } else { + svc.log.Info("Send level 2 UF roll success", logFields) + } + }(time.Now()) + return svc.next.SendUfRollData(ctx, rollData) +} + +// SendUrRollData implements service.IService. +func (svc *LoggingService) SendUrRollData(ctx context.Context, rollData *api.UrRollData) (err error) { + defer func(start time.Time) { + logFields := logger.LogFields{ + "took": time.Since(start), + "ur_roll_id": rollData.GetUrRollId(), + } + if err != nil { + svc.log.Error("Send level 2 UR roll data failed", err, logFields) + } else { + svc.log.Info("Send level 2 UR roll success", logFields) + } + }(time.Now()) + return svc.next.SendUrRollData(ctx, rollData) +} + +// SendBdRollData implements service.IService. +func (svc *LoggingService) SendBdRollData(ctx context.Context, rollData *api.BdRollData) (err error) { + defer func(start time.Time) { + logFields := logger.LogFields{ + "took": time.Since(start), + "bd_roll_id": rollData.GetBdRollId(), + } + if err != nil { + svc.log.Error("Send level 2 BD roll data failed", err, logFields) + } else { + svc.log.Info("Send level 2 BD roll success", logFields) + } + }(time.Now()) + return svc.next.SendBdRollData(ctx, rollData) +} + +func NewLogginService(log logger.LoggerAdapter, svc service.IService) service.IService { + return &LoggingService{ + log: log, + next: svc, + } +} diff --git a/internal/service/service.go b/internal/service/service.go new file mode 100644 index 0000000..ce3427b --- /dev/null +++ b/internal/service/service.go @@ -0,0 +1,45 @@ +package service + +import ( + "context" + "fmt" + + "git.espin.casa/albert/cml04-gdm-int/pkg/api" +) + +type IService interface { + SendBdRollData(ctx context.Context, rollData *api.BdRollData) (err error) + SendUrRollData(ctx context.Context, rollData *api.UrRollData) (err error) + SendEdRollData(ctx context.Context, rollData *api.EdRollData) (err error) + SendUfRollData(ctx context.Context, rollData *api.UfRollData) (err error) +} + +type service struct{} + +// SendEdRollData implements IService. +func (*service) SendEdRollData(ctx context.Context, rollData *api.EdRollData) (err error) { + fmt.Printf("roll data: %+v\n", rollData) + return nil +} + +// SendUfRollData implements IService. +func (*service) SendUfRollData(ctx context.Context, rollData *api.UfRollData) (err error) { + fmt.Printf("roll data: %+v\n", rollData) + return nil +} + +// SendUrRollData implements IService. +func (*service) SendUrRollData(ctx context.Context, rollData *api.UrRollData) (err error) { + fmt.Printf("roll data: %+v\n", rollData) + return nil +} + +// SendBdRollData implements IService. +func (*service) SendBdRollData(ctx context.Context, rollData *api.BdRollData) (err error) { + fmt.Printf("roll data: %+v\n", rollData) + return nil +} + +func NewService() IService { + return &service{} +} diff --git a/internal/types/bd.go b/internal/types/bd.go new file mode 100644 index 0000000..b28c778 --- /dev/null +++ b/internal/types/bd.go @@ -0,0 +1,25 @@ +package types + +type L2Bd struct { + TelegramHeader TelegramHeader + BdRollSetId [20]byte /* roll set identification */ + BdRollMaterial [20]byte /* roll material type (H = Hard, */ + BdRollsChangedFlag int32 /* 0 = not changed, 1 = changed */ + BdRollSetType int32 /* roll set type, 1=DUO */ + BdRollDiamNomActTop float32 /* actual nominal diameter of top */ + BdRollDiamNomActBot float32 /* actual nominal diameter of bot */ + BdRollNominalGap float32 /* nominal roll gap */ + BdRollGrooves int32 /* number of grooves (equal for t */ + BdRollGrooveWidth [10]float32 /* groove width of each groove (e */ + BdRollGrooveStiffnessTop [10]float32 /* stiffness of each groove (top */ + BdRollGrooveStiffnessBot [10]float32 /* stiffness of each groove (bott */ + BdRollGroovePos [10]float32 /* groove position, the position */ + BdRollGrooveSharp [10]int32 /* groove sharpened, 1= no, 2=yes */ + BdRollGrooveDepth [10]float32 /* distance from roll barrel to g */ + BdRollActualShimpsTop float32 /* thickness chock shim top roll */ + BdRollActualShimpsBot float32 /* thickness chock shim bottom ro */ + BdTonnageAccum [10]float32 /* tonnage accumulated per groove */ + BdDummyArray [10]float32 /* Placeholder for extensions */ + BdDummyVal1 float32 /* Placeholder for extensions */ + BdDummyVal2 float32 /* Placeholder for extensions */ +} diff --git a/internal/types/ed.go b/internal/types/ed.go new file mode 100644 index 0000000..dd4ec48 --- /dev/null +++ b/internal/types/ed.go @@ -0,0 +1,45 @@ +package types + +type L2Ed struct { + TelegramHeader TelegramHeader + EdRollSetId [20]byte /* roll set identification */ + EdRollSetType int32 /* roll set type, 1=DUO, 3=EDGER */ + EdTonnageAccum [10]float32 /* tonnage accumulated per groove */ + EdChangeSleeveLength float32 /* length of the roll changing ca */ + EdChangeSleeveDepth float32 /* depth of the roll changing car */ + EdChangedFlag int32 /* changed flag , 0=not changed, */ + EdRollDiamNomHbo float32 /* actual nominal diameter bottom */ + EdRollDiamNomHtp float32 /* actual nominal diameter top ro */ + EdRollNoofGrooves int32 /* number of grooves on roll */ + EdRollNominalGap float32 /* nominal roll gap */ + EdRollMaterial [20]byte /* roll material */ + EdRollFlangeDiamTop [10]float32 /* Flange diameters of each groov */ + EdRollFlangeDiamBot [10]float32 /* Flange diameters of each groov */ + EdRollWebDiamTop [10]float32 /* Web diameters of each groove t */ + EdRollWebDiamBot [10]float32 /* Web diameters of each groove b */ + EdRollChamWidthTop [10]float32 /* Chamber width for each groove, */ + EdRollChamWidthBot [10]float32 /* Chamber width for each groove, */ + EdRollGrooveStiffTop [10]float32 /* groove stiffness for each groo */ + EdRollGrooveStiffBot [10]float32 /* groove stiffness for each groo */ + EdRollAngleFlangeFace [10]float32 /* angle flange face for each gro */ + EdRollRootRadius [10]float32 /* root radius for each groove */ + EdRollGroovePos [10]float32 /* distance between vertical groo */ + EdPasslineOffset float32 /* passline offset */ + EdActualShimpsHbo float32 /* thickness chock shim hor. bott */ + EdActualShimpsHtp float32 /* thickness chock shim hor. top */ + EdDummyArray [10]float32 /* Placeholder for extensions */ + EdDummyVal1 float32 /* Placeholder for extensions */ + EdDummyVal2 float32 /* Placeholder for extensions */ + EdDRollMaterial [20]string /* roll material type (H = Hard, */ + EdDRollDiamNomActTop float32 /* actual nominal diameter of top */ + EDDRollDiamNomActBot float32 /* actual nominal diameter of bot */ + EdDRollNominalGap float32 /* nominal roll gap */ + EdDRollGrooves int32 /* number of grooves (equal for t */ + EdDRollGrooveWidth [10]float32 /* groove width of each groove (e */ + EdDRollGrooveStiffnessTop [10]float32 /* stiffness of each groove (top */ + EdDRollGrooveStiffnessBot [10]float32 /* stiffness of each groove (bott */ + EdDRollGroovePos [10]float32 /* groove position, the position */ + EdDRollGrooveSharp [10]int32 /* groove sharpened, 1= no, 2=yes */ + EdDRollActualShimpsTop float32 /* thickness chock shim top roll */ + EdDRollActualShimpsBotp float32 /* thickness chock shimbottom rol */ +} diff --git a/internal/types/header.go b/internal/types/header.go new file mode 100644 index 0000000..7f8b505 --- /dev/null +++ b/internal/types/header.go @@ -0,0 +1,11 @@ +package types + +type TelegramID int16 + +type TelegramHeader struct { + MessageLength int16 + TelegramID TelegramID + SequenceCounter int16 + Flags int16 + TimeStamp [8]int16 +} diff --git a/internal/types/uf.go b/internal/types/uf.go new file mode 100644 index 0000000..e287724 --- /dev/null +++ b/internal/types/uf.go @@ -0,0 +1,181 @@ +package types + +import ( + "bytes" + "encoding/binary" + "unsafe" + + "git.espin.casa/albert/cml04-gdm-int/pkg/api" +) + +type L2Uf struct { + TelegramHeader *TelegramHeader + UfRollSetId [20]byte /* roll set identification */ + UfRollSetType int32 /* roll set type, 1=DUO,2=UNI */ + UfTonnageAccum [10]float32 /* tonnage accumulated per groove */ + UfChangeSleeveLength float32 /* length of the roll changing ca */ + UfChangeSleeveDepth float32 /* depth of the roll changing car */ + UfHrChangedFlag int32 /* changed flag horizontal roll, */ + UfVrChangedFlag int32 /* changed flag vertical roll, 0= */ + UfRollMaterialH [20]byte /* roll material horizontal rolls */ + UfRollMaterialV [20]byte /* roll material vertical rolls */ + UfHNomGap float32 /* nominal gap (from roll drawing */ + UfRollDiamActHbo float32 /* actual nominal diameter bottom */ + UfRollDiamActHtp float32 /* actual nominal diameter top ro */ + UfRollBarrelWidthHbo float32 /* barrel width bottom roll */ + UfRollBarrelWidthHtp float32 /* barrel width top roll */ + UfRollChamWidthHbo float32 /* chamber width bottom roll */ + UfRollChamWidthHtp float32 /* chamber width top roll */ + UfRollAngleHbo float32 /* angle roll flange face bottom */ + UfRollAngleHtb float32 /* angle roll flange face top rol */ + UfRollDiamActVds float32 /* actual nominal vertical roll d */ + UfRollDiamActVos float32 /* actual nominal vertical roll d */ + UfRollAngleVds float32 /* roll angle flange face (vertic */ + UfRollAngleVos float32 /* roll angle flange face (vertic */ + UfActualShimpsHbo float32 /* thickness shimplate hor. botto */ + UfActualShimpsHtp float32 /* thickness shimplate hor. top r */ + UfActualShimpsVDS1 float32 /* thickness shimplate 1 drive si */ + UfActualShimpsVDS2 float32 /* thickness shimplate 2 drive si */ + UfActualShimpsVOS1 float32 /* thickness shimplate 1 oper. Si */ + UfActualShimpsVOS2 float32 /* thickness shimplate 2 oper. Si */ + UfPasslineOffset float32 /* passline offset */ + UfPinVChock float32 /* pin between horizontal and ver */ + UfDummyVal1 float32 /* Placeholder for Extensions */ + UfDummyVal2 float32 /* Placeholder for Extensions */ + UfDummyVal3 float32 /* Placeholder for Extensions */ + UfDummyVal4 float32 /* Placeholder for Extensions */ + UfDRollMaterial [20]byte /* roll material type (H = Hard, */ + UfDRollDiamNomActTop float32 /* actual nominal diameter of top */ + UfDRollDiamNomActBot float32 /* actual nominal diameter of bot */ + UfDRollNominalGap float32 /* nominal roll gap */ + UfDRollGrooves int32 /* number of grooves (equal for t */ + UfDRollGrooveWidth [10]float32 /* groove width of each groove (e */ + UfDRollGrooveStiffnessTop [10]float32 /* stiffness of each groove (top */ + UfDRollGrooveStiffnessBot [10]float32 /* stiffness of each groove (bott */ + UfDRollGroovePos [10]float32 /* groove position, the position */ + UfDRollGrooveSharp [10]int32 /* groove sharpened, 1= no, 2=yes */ + UfDRollActualShimpsTop float32 /* thickness chock shim top roll */ + UfDRollActualShimpsBot float32 /* thickness chock shim bottom ro */ + UfDRollThrustPlate float32 /* thickness of thrust plate betw */ +} + +func (uf *L2Uf) FillTelegram(rolldata *api.UfRollData) { + size := unsafe.Sizeof(uf) + uf.TelegramHeader = &TelegramHeader{ + MessageLength: int16(size), + TelegramID: 9001, + SequenceCounter: 0, + Flags: 0, + TimeStamp: [8]int16{}, + } + copy(uf.UfRollSetId[:], []byte(rolldata.GetUfRollSetId())) + uf.UfRollSetType = int32(rolldata.GetUfRollSetType()) + uf.UfTonnageAccum[0] = float32(rolldata.GetUfTonnageAccum0()) + uf.UfTonnageAccum[1] = float32(rolldata.GetUfTonnageAccum1()) + uf.UfTonnageAccum[2] = float32(rolldata.GetUfTonnageAccum2()) + uf.UfTonnageAccum[3] = float32(rolldata.GetUfTonnageAccum3()) + uf.UfTonnageAccum[4] = float32(rolldata.GetUfTonnageAccum4()) + uf.UfTonnageAccum[5] = float32(rolldata.GetUfTonnageAccum5()) + uf.UfTonnageAccum[6] = float32(rolldata.GetUfTonnageAccum6()) + uf.UfTonnageAccum[7] = float32(rolldata.GetUfTonnageAccum7()) + uf.UfTonnageAccum[8] = float32(rolldata.GetUfTonnageAccum8()) + uf.UfTonnageAccum[9] = float32(rolldata.GetUfTonnageAccum9()) + uf.UfChangeSleeveLength = float32(rolldata.GetUfChangeSleeveLength()) + uf.UfChangeSleeveDepth = float32(rolldata.GetUfChangeSleeveLength()) + uf.UfHrChangedFlag = 0 // ???????????????????????????????????????????? + uf.UfVrChangedFlag = 0 // ???????????????????????????????????????????? + copy(uf.UfRollMaterialH[:], []byte(rolldata.GetUfRollMaterialH())) + copy(uf.UfRollMaterialV[:], []byte(rolldata.GetUfRollMaterialV())) + uf.UfHNomGap = float32(rolldata.GetUfHNomgap()) + uf.UfRollDiamActHbo = float32(rolldata.GetUfRollDiamActHbo()) + uf.UfRollDiamActHtp = float32(rolldata.GetUfRollDiamActHtp()) + uf.UfRollBarrelWidthHbo = float32(rolldata.GetUfRollBarrelWidthHbo()) + uf.UfRollBarrelWidthHtp = float32(rolldata.GetUfRollBarrelWidthHtp()) + uf.UfRollChamWidthHbo = float32(rolldata.GetUfRollChamWidthHbo()) + uf.UfRollChamWidthHtp = float32(rolldata.GetUfRollChamWidthHtp()) + uf.UfRollAngleHbo = float32(rolldata.GetUfRollAngleHbo()) + uf.UfRollAngleHtb = float32(rolldata.GetUfRollAngleHtb()) + uf.UfRollDiamActVds = float32(rolldata.GetUfRollDiamActVds()) + uf.UfRollDiamActVos = float32(rolldata.GetUfRollDiamActVos()) + uf.UfRollAngleVds = float32(rolldata.GetUfRollAngleVds()) + uf.UfRollAngleVos = float32(rolldata.GetUfRollAngleVos()) + uf.UfActualShimpsHbo = float32(rolldata.GetUfActualShimpsHbo()) + uf.UfActualShimpsHtp = float32(rolldata.GetUfActualShimpsHtp()) + uf.UfActualShimpsVDS1 = float32(rolldata.GetUfActualShimpsVds_1()) + uf.UfActualShimpsVDS2 = float32(rolldata.GetUfActualShimpsVds_2()) + uf.UfActualShimpsVOS1 = float32(rolldata.GetUfActualShimpsVos_1()) + uf.UfActualShimpsVOS2 = float32(rolldata.GetUfActualShimpsVos_2()) + uf.UfPasslineOffset = float32(rolldata.GetUfPasslineOffset()) + uf.UfPinVChock = float32(rolldata.GetUfPinVChock()) + uf.UfDummyVal1 = 0 + uf.UfDummyVal2 = 0 + uf.UfDummyVal3 = 0 + uf.UfDummyVal4 = 0 + copy(uf.UfDRollMaterial[:], []byte(rolldata.GetUfRollMaterialH())) // ???????????????????? + uf.UfDRollDiamNomActTop = float32(rolldata.GetUfRollDiamActHtp()) + uf.UfDRollDiamNomActBot = float32(rolldata.GetUfRollDiamActHbo()) + uf.UfDRollNominalGap = float32(rolldata.GetUfHNomgap()) + uf.UfDRollGrooves = int32(rolldata.GetUfRollGrooves()) + uf.UfDRollGrooveWidth[0] = float32(rolldata.GetUfRollGrooveWidth0()) + uf.UfDRollGrooveWidth[1] = float32(rolldata.GetUfRollGrooveWidth1()) + uf.UfDRollGrooveWidth[2] = float32(rolldata.GetUfRollGrooveWidth2()) + uf.UfDRollGrooveWidth[3] = float32(rolldata.GetUfRollGrooveWidth3()) + uf.UfDRollGrooveWidth[4] = float32(rolldata.GetUfRollGrooveWidth4()) + uf.UfDRollGrooveWidth[5] = float32(rolldata.GetUfRollGrooveWidth5()) + uf.UfDRollGrooveWidth[6] = float32(rolldata.GetUfRollGrooveWidth6()) + uf.UfDRollGrooveWidth[7] = float32(rolldata.GetUfRollGrooveWidth7()) + uf.UfDRollGrooveWidth[8] = float32(rolldata.GetUfRollGrooveWidth8()) + uf.UfDRollGrooveWidth[9] = float32(rolldata.GetUfRollGrooveWidth9()) + uf.UfDRollGrooveStiffnessTop[0] = float32(rolldata.GetUfRollGrooveStiffnessTop0()) + uf.UfDRollGrooveStiffnessTop[1] = float32(rolldata.GetUfRollGrooveStiffnessTop1()) + uf.UfDRollGrooveStiffnessTop[2] = float32(rolldata.GetUfRollGrooveStiffnessTop2()) + uf.UfDRollGrooveStiffnessTop[3] = float32(rolldata.GetUfRollGrooveStiffnessTop3()) + uf.UfDRollGrooveStiffnessTop[4] = float32(rolldata.GetUfRollGrooveStiffnessTop4()) + uf.UfDRollGrooveStiffnessTop[5] = float32(rolldata.GetUfRollGrooveStiffnessTop5()) + uf.UfDRollGrooveStiffnessTop[6] = float32(rolldata.GetUfRollGrooveStiffnessTop6()) + uf.UfDRollGrooveStiffnessTop[7] = float32(rolldata.GetUfRollGrooveStiffnessTop7()) + uf.UfDRollGrooveStiffnessTop[8] = float32(rolldata.GetUfRollGrooveStiffnessTop8()) + uf.UfDRollGrooveStiffnessTop[9] = float32(rolldata.GetUfRollGrooveStiffnessTop9()) + uf.UfDRollGrooveStiffnessBot[0] = float32(rolldata.GetUfRollGrooveStiffnessBot0()) + uf.UfDRollGrooveStiffnessBot[1] = float32(rolldata.GetUfRollGrooveStiffnessBot1()) + uf.UfDRollGrooveStiffnessBot[2] = float32(rolldata.GetUfRollGrooveStiffnessBot2()) + uf.UfDRollGrooveStiffnessBot[3] = float32(rolldata.GetUfRollGrooveStiffnessBot3()) + uf.UfDRollGrooveStiffnessBot[4] = float32(rolldata.GetUfRollGrooveStiffnessBot4()) + uf.UfDRollGrooveStiffnessBot[5] = float32(rolldata.GetUfRollGrooveStiffnessBot5()) + uf.UfDRollGrooveStiffnessBot[6] = float32(rolldata.GetUfRollGrooveStiffnessBot6()) + uf.UfDRollGrooveStiffnessBot[7] = float32(rolldata.GetUfRollGrooveStiffnessBot7()) + uf.UfDRollGrooveStiffnessBot[8] = float32(rolldata.GetUfRollGrooveStiffnessBot8()) + uf.UfDRollGrooveStiffnessBot[9] = float32(rolldata.GetUfRollGrooveStiffnessBot9()) + uf.UfDRollGroovePos[0] = float32(rolldata.GetUfRollGroovePos0()) + uf.UfDRollGroovePos[1] = float32(rolldata.GetUfRollGroovePos1()) + uf.UfDRollGroovePos[2] = float32(rolldata.GetUfRollGroovePos2()) + uf.UfDRollGroovePos[3] = float32(rolldata.GetUfRollGroovePos3()) + uf.UfDRollGroovePos[4] = float32(rolldata.GetUfRollGroovePos4()) + uf.UfDRollGroovePos[5] = float32(rolldata.GetUfRollGroovePos5()) + uf.UfDRollGroovePos[6] = float32(rolldata.GetUfRollGroovePos6()) + uf.UfDRollGroovePos[7] = float32(rolldata.GetUfRollGroovePos7()) + uf.UfDRollGroovePos[8] = float32(rolldata.GetUfRollGroovePos8()) + uf.UfDRollGroovePos[9] = float32(rolldata.GetUfRollGroovePos9()) + uf.UfDRollGrooveSharp[0] = int32(rolldata.GetUfRollGrooveSharp0()) + uf.UfDRollGrooveSharp[1] = int32(rolldata.GetUfRollGrooveSharp1()) + uf.UfDRollGrooveSharp[2] = int32(rolldata.GetUfRollGrooveSharp2()) + uf.UfDRollGrooveSharp[3] = int32(rolldata.GetUfRollGrooveSharp3()) + uf.UfDRollGrooveSharp[4] = int32(rolldata.GetUfRollGrooveSharp4()) + uf.UfDRollGrooveSharp[5] = int32(rolldata.GetUfRollGrooveSharp5()) + uf.UfDRollGrooveSharp[6] = int32(rolldata.GetUfRollGrooveSharp6()) + uf.UfDRollGrooveSharp[7] = int32(rolldata.GetUfRollGrooveSharp7()) + uf.UfDRollGrooveSharp[8] = int32(rolldata.GetUfRollGrooveSharp8()) + uf.UfDRollGrooveSharp[9] = int32(rolldata.GetUfRollGrooveSharp9()) + uf.UfDRollActualShimpsTop = float32(rolldata.GetUfActualShimpsHtp()) + uf.UfDRollActualShimpsBot = float32(rolldata.GetUfActualShimpsHbo()) + uf.UfDRollThrustPlate = float32(rolldata.GetUfRollThrustPlate()) +} + +func (uf *L2Uf) ToBytes() ([]byte, error) { + bs := make([]byte, unsafe.Sizeof(uf)) + buffer := bytes.NewBuffer(bs) + if err := binary.Write(buffer, binary.LittleEndian, uf); err != nil { + return nil, err + } + return buffer.Bytes(), nil +} diff --git a/internal/types/ur.go b/internal/types/ur.go new file mode 100644 index 0000000..872d8eb --- /dev/null +++ b/internal/types/ur.go @@ -0,0 +1,181 @@ +package types + +import ( + "bytes" + "encoding/binary" + "unsafe" + + "git.espin.casa/albert/cml04-gdm-int/pkg/api" +) + +type L2Ur struct { + TelegramHeader *TelegramHeader + UrRollSetId [20]byte /* roll set identification */ + UrRollSetType int32 /* roll set type, 1=DUO,2=UNI */ + UrTonnageAccum [10]float32 /* tonnage accumulated per groove */ + UrChangeSleeveLength float32 /* length of the roll changing ca */ + UrChangeSleeveDepth float32 /* depth of the roll changing car */ + UrHrChangedFlag int32 /* changed flag horizontal roll, */ + UrVrChangedFlag int32 /* changed flag vertical roll, 0= */ + UrRollMaterialH [20]byte /* roll material horizontal rolls */ + UrRollMaterialV [20]byte /* roll material vertical rolls */ + UrHNomGap float32 /* nominal gap (from roll drawing */ + UrRollDiamActHbo float32 /* actual nominal diameter bottom */ + UrRollDiamActHtp float32 /* actual nominal diameter top ro */ + UrRollBarrelWidthHbo float32 /* barrel width bottom roll */ + UrRollBarrelWidthHtp float32 /* barrel width top roll */ + UrRollChamWidthHbo float32 /* chamber width bottom roll */ + UrRollChamWidthHtp float32 /* chamber width top roll */ + UrRollAngleHbo float32 /* angle roll flange face bottom */ + UrRollAngleHtb float32 /* angle roll flange face top rol */ + UrRollDiamActVds float32 /* actual nominal vertical roll d */ + UrRollDiamActVos float32 /* actual nominal vertical roll d */ + UrRollAngleVds float32 /* roll angle flange face (vertic */ + UrRollAngleVos float32 /* roll angle flange face (vertic */ + UrActualShimpsHbo float32 /* thickness shimplate hor. botto */ + UrActualShimpsHtp float32 /* thickness shimplate hor. top r */ + UrActualShimpsVDS1 float32 /* thickness shimplate 1 drive si */ + UrActualShimpsVDS2 float32 /* thickness shimplate 2 drive si */ + UrActualShimpsVOS1 float32 /* thickness shimplate 1 oper. Si */ + UrActualShimpsVOS2 float32 /* thickness shimplate 2 oper. Si */ + UrPasslineOffset float32 /* passline offset */ + UrPinVChock float32 /* pin between horizontal and ver */ + UrDummyVal1 float32 /* Placeholder for Extensions */ + UrDummyVal2 float32 /* Placeholder for Extensions */ + UrDummyVal3 float32 /* Placeholder for Extensions */ + UrDummyVal4 float32 /* Placeholder for Extensions */ + UrDRollMaterial [20]byte /* roll material type (H = Hard, */ + UrDRollDiamNomActTop float32 /* actual nominal diameter of top */ + UrDRollDiamNomActBot float32 /* actual nominal diameter of bot */ + UrDRollNominalGap float32 /* nominal roll gap */ + UrDRollGrooves int32 /* number of grooves (equal for t */ + UrDRollGrooveWidth [10]float32 /* groove width of each groove (e */ + UrDRollGrooveStiffnessTop [10]float32 /* stiffness of each groove (top */ + UrDRollGrooveStiffnessBot [10]float32 /* stiffness of each groove (bott */ + UrDRollGroovePos [10]float32 /* groove position, the position */ + UrDRollGrooveSharp [10]int32 /* groove sharpened, 1= no, 2=yes */ + UrDRollActualShimpsTop float32 /* thickness chock shim top roll */ + UrDRollActualShimpsBot float32 /* thickness chock shim bottom ro */ + UrDRollThrustPlate float32 /* thickness of thrust plate betw */ +} + +func (ur *L2Ur) FillTelegram(rolldata *api.UrRollData) { + size := unsafe.Sizeof(ur) + ur.TelegramHeader = &TelegramHeader{ + MessageLength: int16(size), + TelegramID: 9001, + SequenceCounter: 0, + Flags: 0, + TimeStamp: [8]int16{}, + } + copy(ur.UrRollSetId[:], []byte(rolldata.GetUrRollSetId())) + ur.UrRollSetType = int32(rolldata.GetUrRollSetType()) + ur.UrTonnageAccum[0] = float32(rolldata.GetUrTonnageAccum0()) + ur.UrTonnageAccum[1] = float32(rolldata.GetUrTonnageAccum1()) + ur.UrTonnageAccum[2] = float32(rolldata.GetUrTonnageAccum2()) + ur.UrTonnageAccum[3] = float32(rolldata.GetUrTonnageAccum3()) + ur.UrTonnageAccum[4] = float32(rolldata.GetUrTonnageAccum4()) + ur.UrTonnageAccum[5] = float32(rolldata.GetUrTonnageAccum5()) + ur.UrTonnageAccum[6] = float32(rolldata.GetUrTonnageAccum6()) + ur.UrTonnageAccum[7] = float32(rolldata.GetUrTonnageAccum7()) + ur.UrTonnageAccum[8] = float32(rolldata.GetUrTonnageAccum8()) + ur.UrTonnageAccum[9] = float32(rolldata.GetUrTonnageAccum9()) + ur.UrChangeSleeveLength = float32(rolldata.GetUrChangeSleeveLength()) + ur.UrChangeSleeveDepth = float32(rolldata.GetUrChangeSleeveLength()) + ur.UrHrChangedFlag = 0 // ???????????????????????????????????????????? + ur.UrVrChangedFlag = 0 // ???????????????????????????????????????????? + copy(ur.UrRollMaterialH[:], []byte(rolldata.GetUrRollMaterialH())) + copy(ur.UrRollMaterialV[:], []byte(rolldata.GetUrRollMaterialV())) + ur.UrHNomGap = float32(rolldata.GetUrHNomgap()) + ur.UrRollDiamActHbo = float32(rolldata.GetUrRollDiamActHbo()) + ur.UrRollDiamActHtp = float32(rolldata.GetUrRollDiamActHtp()) + ur.UrRollBarrelWidthHbo = float32(rolldata.GetUrRollBarrelWidthHbo()) + ur.UrRollBarrelWidthHtp = float32(rolldata.GetUrRollBarrelWidthHtp()) + ur.UrRollChamWidthHbo = float32(rolldata.GetUrRollChamWidthHbo()) + ur.UrRollChamWidthHtp = float32(rolldata.GetUrRollChamWidthHtp()) + ur.UrRollAngleHbo = float32(rolldata.GetUrRollAngleHbo()) + ur.UrRollAngleHtb = float32(rolldata.GetUrRollAngleHtb()) + ur.UrRollDiamActVds = float32(rolldata.GetUrRollDiamActVds()) + ur.UrRollDiamActVos = float32(rolldata.GetUrRollDiamActVos()) + ur.UrRollAngleVds = float32(rolldata.GetUrRollAngleVds()) + ur.UrRollAngleVos = float32(rolldata.GetUrRollAngleVos()) + ur.UrActualShimpsHbo = float32(rolldata.GetUrActualShimpsHbo()) + ur.UrActualShimpsHtp = float32(rolldata.GetUrActualShimpsHtp()) + ur.UrActualShimpsVDS1 = float32(rolldata.GetUrActualShimpsVds_1()) + ur.UrActualShimpsVDS2 = float32(rolldata.GetUrActualShimpsVds_2()) + ur.UrActualShimpsVOS1 = float32(rolldata.GetUrActualShimpsVos_1()) + ur.UrActualShimpsVOS2 = float32(rolldata.GetUrActualShimpsVos_2()) + ur.UrPasslineOffset = float32(rolldata.GetUrPasslineOffset()) + ur.UrPinVChock = float32(rolldata.GetUrPinVChock()) + ur.UrDummyVal1 = 0 + ur.UrDummyVal2 = 0 + ur.UrDummyVal3 = 0 + ur.UrDummyVal4 = 0 + copy(ur.UrDRollMaterial[:], []byte(rolldata.GetUrRollMaterialH())) // ???????????????????? + ur.UrDRollDiamNomActTop = float32(rolldata.GetUrRollDiamActHtp()) + ur.UrDRollDiamNomActBot = float32(rolldata.GetUrRollDiamActHbo()) + ur.UrDRollNominalGap = float32(rolldata.GetUrHNomgap()) + ur.UrDRollGrooves = int32(rolldata.GetUrRollGrooves()) + ur.UrDRollGrooveWidth[0] = float32(rolldata.GetUrRollGrooveWidth0()) + ur.UrDRollGrooveWidth[1] = float32(rolldata.GetUrRollGrooveWidth1()) + ur.UrDRollGrooveWidth[2] = float32(rolldata.GetUrRollGrooveWidth2()) + ur.UrDRollGrooveWidth[3] = float32(rolldata.GetUrRollGrooveWidth3()) + ur.UrDRollGrooveWidth[4] = float32(rolldata.GetUrRollGrooveWidth4()) + ur.UrDRollGrooveWidth[5] = float32(rolldata.GetUrRollGrooveWidth5()) + ur.UrDRollGrooveWidth[6] = float32(rolldata.GetUrRollGrooveWidth6()) + ur.UrDRollGrooveWidth[7] = float32(rolldata.GetUrRollGrooveWidth7()) + ur.UrDRollGrooveWidth[8] = float32(rolldata.GetUrRollGrooveWidth8()) + ur.UrDRollGrooveWidth[9] = float32(rolldata.GetUrRollGrooveWidth9()) + ur.UrDRollGrooveStiffnessTop[0] = float32(rolldata.GetUrRollGrooveStiffnessTop0()) + ur.UrDRollGrooveStiffnessTop[1] = float32(rolldata.GetUrRollGrooveStiffnessTop1()) + ur.UrDRollGrooveStiffnessTop[2] = float32(rolldata.GetUrRollGrooveStiffnessTop2()) + ur.UrDRollGrooveStiffnessTop[3] = float32(rolldata.GetUrRollGrooveStiffnessTop3()) + ur.UrDRollGrooveStiffnessTop[4] = float32(rolldata.GetUrRollGrooveStiffnessTop4()) + ur.UrDRollGrooveStiffnessTop[5] = float32(rolldata.GetUrRollGrooveStiffnessTop5()) + ur.UrDRollGrooveStiffnessTop[6] = float32(rolldata.GetUrRollGrooveStiffnessTop6()) + ur.UrDRollGrooveStiffnessTop[7] = float32(rolldata.GetUrRollGrooveStiffnessTop7()) + ur.UrDRollGrooveStiffnessTop[8] = float32(rolldata.GetUrRollGrooveStiffnessTop8()) + ur.UrDRollGrooveStiffnessTop[9] = float32(rolldata.GetUrRollGrooveStiffnessTop9()) + ur.UrDRollGrooveStiffnessBot[0] = float32(rolldata.GetUrRollGrooveStiffnessBot0()) + ur.UrDRollGrooveStiffnessBot[1] = float32(rolldata.GetUrRollGrooveStiffnessBot1()) + ur.UrDRollGrooveStiffnessBot[2] = float32(rolldata.GetUrRollGrooveStiffnessBot2()) + ur.UrDRollGrooveStiffnessBot[3] = float32(rolldata.GetUrRollGrooveStiffnessBot3()) + ur.UrDRollGrooveStiffnessBot[4] = float32(rolldata.GetUrRollGrooveStiffnessBot4()) + ur.UrDRollGrooveStiffnessBot[5] = float32(rolldata.GetUrRollGrooveStiffnessBot5()) + ur.UrDRollGrooveStiffnessBot[6] = float32(rolldata.GetUrRollGrooveStiffnessBot6()) + ur.UrDRollGrooveStiffnessBot[7] = float32(rolldata.GetUrRollGrooveStiffnessBot7()) + ur.UrDRollGrooveStiffnessBot[8] = float32(rolldata.GetUrRollGrooveStiffnessBot8()) + ur.UrDRollGrooveStiffnessBot[9] = float32(rolldata.GetUrRollGrooveStiffnessBot9()) + ur.UrDRollGroovePos[0] = float32(rolldata.GetUrRollGroovePos0()) + ur.UrDRollGroovePos[1] = float32(rolldata.GetUrRollGroovePos1()) + ur.UrDRollGroovePos[2] = float32(rolldata.GetUrRollGroovePos2()) + ur.UrDRollGroovePos[3] = float32(rolldata.GetUrRollGroovePos3()) + ur.UrDRollGroovePos[4] = float32(rolldata.GetUrRollGroovePos4()) + ur.UrDRollGroovePos[5] = float32(rolldata.GetUrRollGroovePos5()) + ur.UrDRollGroovePos[6] = float32(rolldata.GetUrRollGroovePos6()) + ur.UrDRollGroovePos[7] = float32(rolldata.GetUrRollGroovePos7()) + ur.UrDRollGroovePos[8] = float32(rolldata.GetUrRollGroovePos8()) + ur.UrDRollGroovePos[9] = float32(rolldata.GetUrRollGroovePos9()) + ur.UrDRollGrooveSharp[0] = int32(rolldata.GetUrRollGrooveSharp0()) + ur.UrDRollGrooveSharp[1] = int32(rolldata.GetUrRollGrooveSharp1()) + ur.UrDRollGrooveSharp[2] = int32(rolldata.GetUrRollGrooveSharp2()) + ur.UrDRollGrooveSharp[3] = int32(rolldata.GetUrRollGrooveSharp3()) + ur.UrDRollGrooveSharp[4] = int32(rolldata.GetUrRollGrooveSharp4()) + ur.UrDRollGrooveSharp[5] = int32(rolldata.GetUrRollGrooveSharp5()) + ur.UrDRollGrooveSharp[6] = int32(rolldata.GetUrRollGrooveSharp6()) + ur.UrDRollGrooveSharp[7] = int32(rolldata.GetUrRollGrooveSharp7()) + ur.UrDRollGrooveSharp[8] = int32(rolldata.GetUrRollGrooveSharp8()) + ur.UrDRollGrooveSharp[9] = int32(rolldata.GetUrRollGrooveSharp9()) + ur.UrDRollActualShimpsTop = float32(rolldata.GetUrActualShimpsHtp()) + ur.UrDRollActualShimpsBot = float32(rolldata.GetUrActualShimpsHbo()) + ur.UrDRollThrustPlate = float32(rolldata.GetUrRollThrustPlate()) +} + +func (ur *L2Ur) ToBytes() ([]byte, error) { + bs := make([]byte, unsafe.Sizeof(ur)) + buffer := bytes.NewBuffer(bs) + if err := binary.Write(buffer, binary.LittleEndian, ur); err != nil { + return nil, err + } + return buffer.Bytes(), nil +}