TLM Non-Standard Byte Sized Data Type Support (#51)

Author: AarC10

lib/tlm/tlm_interpreter.go

@@ -26,7 +26,7 @@ type TelemetryPacket struct {
 
 // InterpretUnsignedInteger interprets a byte slice as an unsigned integer.
 // The endianness parameter specifies the byte order of the data.
-// Size of the data must be 1, 2, 4, or 8 bytes.
+// Size of the data must be 1-8 bytes.
 func InterpretUnsignedInteger(data []byte, endianness string) (interface{}, error) {
 	switch len(data) {
 	case 1:
@@ -47,14 +47,34 @@ func InterpretUnsignedInteger(data []byte, endianness string) (interface{}, erro
 		}
 		return binary.BigEndian.Uint64(data), nil
 	default:
-		return nil, fmt.Errorf("unsupported data length: %d", len(data))
+		// I will crash out if we ever need to support integer sizes larger than 8 bytes - Aaron
+		if len(data) < 1 || len(data) > 8 {
+			return nil, fmt.Errorf("unsupported size for unsigned integer: %d bytes", len(data))
+		}
+
+		var val uint64
+
+		if endianness == "little" {
+			for i := 0; i < len(data); i++ {
+				val |= uint64(data[i]) << (8 * i)
+			}
+		} else {
+			for i := 0; i < len(data); i++ {
+				val |= uint64(data[i]) << (8 * (len(data) - 1 - i))
+			}
+		}
+
+		if len(data) <= 4 {
+			return uint32(val), nil
+		}
+
+		return val, nil
 	}
-	// TODO: Support non-aligned bytes less than 8?
 }
 
 // InterpretSignedInteger interprets a byte slice as a signed integer.
 // The endianness parameter specifies the byte order of the data.
-// Size of the data must be 1, 2, 4, or 8 bytes.
+// Size of the data must be 1-8 bytes.
 func InterpretSignedInteger(data []byte, endianness string) (interface{}, error) {
 	unsigned, err := InterpretUnsignedInteger(data, endianness)
 	if err != nil {
@@ -67,8 +87,22 @@ func InterpretSignedInteger(data []byte, endianness string) (interface{}, error)
 	case uint16:
 		return int16(v), nil
 	case uint32:
+		if len(data) < 4 {
+			bitLen := uint(8 * len(data))
+			if v&(1<<(bitLen-1)) != 0 {
+				v |= ^uint32(0) << bitLen
+			}
+		}
+
 		return int32(v), nil
 	case uint64:
+		if len(data) < 8 {
+			bitLen := uint(8 * len(data))
+			if v&(1<<(bitLen-1)) != 0 {
+				v |= ^uint64(0) << bitLen
+			}
+		}
+
 		return int64(v), nil
 	default:
 		return nil, fmt.Errorf("unsupported integer type for signed conversion: %T", v)
@@ -77,7 +111,7 @@ func InterpretSignedInteger(data []byte, endianness string) (interface{}, error)
 
 // InterpretFloat interprets a byte slice as a floating point number.
 // The endianness parameter specifies the byte order of the data.
-// Size of the data must be 4 or 8 bytes.
+// Size of the data must be 1-8 bytes.
 func InterpretFloat(data []byte, endianness string) (interface{}, error) {
 	unsigned, err := InterpretUnsignedInteger(data, endianness)
 	if err != nil {
@@ -103,9 +137,10 @@ func InterpretMeasurementValue(measurement Measurement, data []byte) (interface{
 	switch measurement.Type {
 	case "int":
 		if measurement.Unsigned {
-			return InterpretUnsignedInteger(data, measurement.Endianness)
+			result, err = InterpretUnsignedInteger(data, measurement.Endianness)
+		} else {
+			result, err = InterpretSignedInteger(data, measurement.Endianness)
 		}
-		result, err = InterpretSignedInteger(data, measurement.Endianness)
 	case "float":
 		result, err = InterpretFloat(data, measurement.Endianness)
 	default:

lib/tlm/tlm_interpreter_test.go

@@ -18,7 +18,7 @@ func TestInterpretUnsignedInteger(t *testing.T) {
 		{"uint32 big endian", []byte{0x12, 0x34, 0x56, 0x78}, "big", uint32(0x12345678)},
 		{"uint64 little endian", []byte{0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0}, "little", uint64(0xF0DEBC9A78563412)},
 		{"uint64 big endian", []byte{0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0}, "big", uint64(0x123456789ABCDEF0)},
-		{"unsupported length", []byte{0x12, 0x34, 0x56}, "", nil},
+		{"unsupported length", []byte{0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF, 0xCA, 0xFE, 0xBA, 0xBE, 0xDE, 0xAD, 0xBE, 0xE5}, "", nil},
 	}
 
 	for _, tt := range tests {
@@ -45,7 +45,7 @@ func TestInterpretSignedInteger(t *testing.T) {
 		{"int32 big endian", []byte{0xFF, 0xFF, 0xFF, 0x82}, "big", int32(-126)},
 		{"int64 little endian", []byte{0x82, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, "little", int64(-126)},
 		{"int64 big endian", []byte{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x82}, "big", int64(-126)},
-		{"unsupported length", []byte{0x12, 0x34, 0x56}, "", nil},
+		{"unsupported length", []byte{0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF, 0xCA, 0xFE, 0xBA, 0xBE, 0xDE, 0xAD, 0xBE, 0xE5}, "", nil},
 	}
 
 	for _, tt := range tests {
@@ -69,7 +69,7 @@ func TestInterpretFloat(t *testing.T) {
 		{"float32 big endian", []byte{0x3F, 0x80, 0x00, 0x00}, "big", float32(1.0)},
 		{"float64 little endian", []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x3F}, "little", 1.0},
 		{"float64 big endian", []byte{0x3F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, "big", 1.0},
-		{"unsupported length", []byte{0x12, 0x34, 0x56}, "", nil},
+		{"unsupported length", []byte{0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF, 0xCA, 0xFE, 0xBA, 0xBE, 0xDE, 0xAD, 0xBE, 0xE5}, "", nil},
 	}
 
 	for _, tt := range tests {
@@ -104,3 +104,34 @@ func TestInterpretMeasurementValue(t *testing.T) {
 		})
 	}
 }
+
+func TestInterpretUnalignedMeasurementValue(t *testing.T) {
+	tests := []struct {
+		name        string
+		measurement Measurement
+		data        []byte
+		expected    interface{}
+	}{
+		{"unsigned 3 byte", Measurement{Type: "int", Unsigned: true, Endianness: "big", ScalingFactor: 1.0}, []byte{0x01, 0x02, 0x03}, uint32(0x010203)},
+		// Note the hard-coded decimal value is validated. int32ing the 3-byte value 0xDEADFF results in 14593535 and doing 0xFFDEADFF will overflow the int32 :P
+		{"signed 3 byte", Measurement{Type: "int", Unsigned: false, Endianness: "big", ScalingFactor: 1.0}, []byte{0xDE, 0xAD, 0xFF}, int32(-2183681)},
+
+		{"unsigned 5 byte", Measurement{Type: "int", Unsigned: false, Endianness: "little", ScalingFactor: 1.0}, []byte{0x01, 0x02, 0x03, 0x04, 0x05}, int64(0x0504030201)},
+		{"signed 5 byte", Measurement{Type: "int", Unsigned: true, Endianness: "little", ScalingFactor: 1.0}, []byte{0xDE, 0xAD, 0xBE, 0xEF, 0xFF}, uint64(0xFFEFBEADDE)},
+
+		{"unsigned 6 byte", Measurement{Type: "int", Unsigned: false, Endianness: "big", ScalingFactor: 1.0}, []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}, int64(0x010203040506)},
+		{"signed 6 byte", Measurement{Type: "int", Unsigned: true, Endianness: "big", ScalingFactor: 1.0}, []byte{0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED}, uint64(0xDEADBEEFFEED)},
+
+		{"unsigned 7 byte", Measurement{Type: "int", Unsigned: false, Endianness: "little", ScalingFactor: 1.0}, []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}, int64(0x07060504030201)},
+		{"signed 7 byte", Measurement{Type: "int", Unsigned: true, Endianness: "little", ScalingFactor: 1.0}, []byte{0xCA, 0xFE, 0xBA, 0xBE, 0xBB, 0xBA, 0xD0}, uint64(0xD0BABBBEBAFECA)},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, _ := InterpretMeasurementValue(tt.measurement, tt.data)
+			if result != tt.expected {
+				t.Errorf("expected %v, got %v", tt.expected, result)
+			}
+		})
+	}
+}