101 lines
2.1 KiB
Go
101 lines
2.1 KiB
Go
package skylab
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"encoding/json"
|
|
"math"
|
|
)
|
|
|
|
/*
|
|
This file provides helpers used for serializing and deserializing skylab packets.
|
|
It contains common code and interfaces.
|
|
*/
|
|
|
|
// float32ToBytes is an internal function used to encode a float value to bytes
|
|
func float32ToBytes(b []byte, f float32, bigEndian bool) {
|
|
bits := math.Float32bits(f)
|
|
if bigEndian {
|
|
binary.BigEndian.PutUint32(b, bits)
|
|
} else {
|
|
binary.LittleEndian.PutUint32(b, bits)
|
|
}
|
|
}
|
|
|
|
// float32FromBytes is an internal function used to decode float value from bytes
|
|
func float32FromBytes(b []byte, bigEndian bool) (f float32) {
|
|
var bits uint32
|
|
if bigEndian {
|
|
bits = binary.BigEndian.Uint32(b)
|
|
} else {
|
|
bits = binary.LittleEndian.Uint32(b)
|
|
}
|
|
return math.Float32frombits(bits)
|
|
}
|
|
|
|
// Packet is any Skylab-generated packet.
|
|
type Packet interface {
|
|
MarshalPacket() ([]byte, error)
|
|
UnmarshalPacket(p []byte) error
|
|
CANId() (uint32, error)
|
|
Size() uint
|
|
}
|
|
|
|
// Marshaler is a packet that can be marshalled into bytes.
|
|
type Marshaler interface {
|
|
MarshalPacket() ([]byte, error)
|
|
}
|
|
|
|
// Unmarshaler is a packet that can be unmarshalled from bytes.
|
|
type Unmarshaler interface {
|
|
UnmarshalPacket(p []byte) error
|
|
}
|
|
|
|
// Ider is a packet that can get its ID, based on the index of the packet, if any.
|
|
type Ider interface {
|
|
CANId() (uint32, error)
|
|
}
|
|
|
|
// Sizer allows for fast allocation.
|
|
type Sizer interface {
|
|
Size() uint
|
|
}
|
|
|
|
// CanSend takes a packet and makes CAN framing data.
|
|
func CanSend(p Packet) (id uint32, data []byte, err error) {
|
|
|
|
id, err = p.CANId()
|
|
if err != nil {
|
|
return
|
|
}
|
|
data, err = p.MarshalPacket()
|
|
return
|
|
}
|
|
|
|
// ---- JSON encoding business ----
|
|
|
|
type JSONPacket struct {
|
|
Id uint32
|
|
Data json.RawMessage
|
|
}
|
|
|
|
func ToJson(p Packet) (*JSONPacket, error) {
|
|
|
|
d, err := json.Marshal(p)
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
id, err := p.CANId()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
jp := &JSONPacket{Id: id, Data: d}
|
|
|
|
return jp, nil
|
|
}
|
|
|
|
// we need to be able to parse the JSON as well. this is done using the
|
|
// generator since we can use the switch/case thing since it's the fastest
|