update examples

move types out of decoders package

encoder.go

@@ -18,7 +18,7 @@ func (e *Encoder) ResetInfoFrameId() {
 	e.infoFrameId = 1
 }
 
-func (e *Encoder) GetInfoPackets(timestamp uint64, trackers []Tracker) [][]byte {
+func (e *Encoder) GetInfoPackets(timestamp uint64, trackers []*Tracker) [][]byte {
 	systemNameChunk := encoders.EncodeInfoSystemNameChunk(e.SystemName)
 
 	trackerChunks := [][]byte{}
@@ -58,7 +58,7 @@ func (e *Encoder) GetInfoPackets(timestamp uint64, trackers []Tracker) [][]byte
 	return infoPackets
 }
 
-func (e *Encoder) GetDataPackets(timestamp uint64, trackers []Tracker) [][]byte {
+func (e *Encoder) GetDataPackets(timestamp uint64, trackers []*Tracker) [][]byte {
 	trackerChunks := [][]byte{}
 
 	for _, tracker := range trackers {

examples/benchmark/main.go

@@ -7,11 +7,11 @@ import (
 	"github.com/jwetzell/psn-go"
 )
 
-func getNTrackers(n int) []psn.Tracker {
-	trackers := []psn.Tracker{}
+func getNTrackers(n int) []*psn.Tracker {
+	trackers := []*psn.Tracker{}
 
 	for index := 0; index < n; index++ {
-		tracker := psn.Tracker{Id: uint16(index), Name: "Tracker"}
+		tracker := &psn.Tracker{Id: uint16(index), Name: "Tracker"}
 		tracker.SetPos(0, 0, 0)
 		tracker.SetSpeed(0, 0, 0)
 		tracker.SetOri(0, 0, 0)

examples/encode/main.go

@@ -13,14 +13,14 @@ func main() {
 		VersionLow:  3,
 	}
 
-	tracker := psn.Tracker{
+	tracker := &psn.Tracker{
 		Id:   1,
 		Name: "Tracker 1",
 	}
 
 	tracker.SetPos(1.0, 1.0, 1.0)
 
-	trackers := []psn.Tracker{
+	trackers := []*psn.Tracker{
 		tracker,
 	}
 

examples/psn_server/main.go

@@ -23,62 +23,64 @@ func main() {
 		VersionLow:  0,
 	}
 
-	trackers := []psn.Tracker{}
+	trackers := []*psn.Tracker{}
 
-	trackers = append(trackers, psn.Tracker{Id: 0, Name: "Sun"})
-	trackers = append(trackers, psn.Tracker{Id: 1, Name: "Mercury"})
-	trackers = append(trackers, psn.Tracker{Id: 2, Name: "Venus"})
-	trackers = append(trackers, psn.Tracker{Id: 3, Name: "Earth"})
-	trackers = append(trackers, psn.Tracker{Id: 4, Name: "Mars"})
-	trackers = append(trackers, psn.Tracker{Id: 5, Name: "Jupiter"})
-	trackers = append(trackers, psn.Tracker{Id: 6, Name: "Saturn"})
-	trackers = append(trackers, psn.Tracker{Id: 7, Name: "Uranus"})
-	trackers = append(trackers, psn.Tracker{Id: 8, Name: "Neptune"})
-	trackers = append(trackers, psn.Tracker{Id: 9, Name: "Pluto"})
+	trackers = append(trackers, &psn.Tracker{Id: 0, Name: "Sun"})
+	trackers = append(trackers, &psn.Tracker{Id: 1, Name: "Mercury"})
+	trackers = append(trackers, &psn.Tracker{Id: 2, Name: "Venus"})
+	trackers = append(trackers, &psn.Tracker{Id: 3, Name: "Earth"})
+	trackers = append(trackers, &psn.Tracker{Id: 4, Name: "Mars"})
+	trackers = append(trackers, &psn.Tracker{Id: 5, Name: "Jupiter"})
+	trackers = append(trackers, &psn.Tracker{Id: 6, Name: "Saturn"})
+	trackers = append(trackers, &psn.Tracker{Id: 7, Name: "Uranus"})
+	trackers = append(trackers, &psn.Tracker{Id: 8, Name: "Neptune"})
+	trackers = append(trackers, &psn.Tracker{Id: 9, Name: "Pluto"})
 
 	orbits := []float32{1.0, 88.0, 224.7, 365.2, 687, 4332, 10760, 30700, 60200, 90600}
 	distFromSun := []float32{0, 0.58, 1.08, 1.5, 2.28, 7.78, 14.29, 28.71, 45.04, 59.13}
 
 	timestamp := 0
 
-	lastInfoMillis := time.Now().UnixMilli()
-	lastDataMillis := time.Now().UnixMilli()
+	dataTicker := time.NewTicker(time.Millisecond * 16)
+	infoTicker := time.NewTicker(time.Millisecond * 1000)
 
-	for {
-		if (time.Now().UnixMilli() - lastInfoMillis) > 500 {
-			slog.Info("Sending Info Packets")
-			infoPackets := encoder.GetInfoPackets(uint64(timestamp), trackers)
-			for _, infoPacket := range infoPackets {
-				client.Write(infoPacket)
-			}
-			lastInfoMillis = time.Now().UnixMilli()
-		}
-
-		if (time.Now().UnixMilli() - lastDataMillis) > 5 {
-			for index, orbit := range orbits {
+	go func() {
+		for {
+			for index, tracker := range trackers {
+				orbit := orbits[index]
 				a := 1.0 / orbit
 				b := distFromSun[index]
 				x := timestamp
 				cb := math.Cos(float64(a*float32(x))) * float64(b)
 				sb := math.Sin(float64(a*float32(x))) * float64(b)
 
-				trackers[index].SetPos(float32(sb), 0, float32(cb))
-				trackers[index].SetSpeed(a*float32(cb), 0, -a*float32(sb))
-				trackers[index].SetOri(0, float32(x)/1000.0, 0)
-				trackers[index].SetAccel(-a*a*float32(sb), 0, -a*a*float32(cb))
-				trackers[index].SetTrgtPos(3, 14, 16)
-				trackers[index].SetStatus(float32(index) / 10.0)
-				trackers[index].SetTimestamp(uint64(timestamp))
+				tracker.SetPos(float32(sb), 0, float32(cb))
+				tracker.SetSpeed(a*float32(cb), 0, -a*float32(sb))
+				tracker.SetOri(0, float32(x)/1000.0, 0)
+				tracker.SetAccel(-a*a*float32(sb), 0, -a*a*float32(cb))
+				tracker.SetTrgtPos(3, 14, 16)
+				tracker.SetStatus(float32(index) / 10.0)
+				tracker.SetTimestamp(uint64(timestamp))
 			}
+			time.Sleep(time.Millisecond * 16)
+		}
+	}()
 
+	for {
+		select {
+		case <-infoTicker.C:
+			slog.Info("Sending Info Packets")
+			infoPackets := encoder.GetInfoPackets(uint64(timestamp), trackers)
+			for _, infoPacket := range infoPackets {
+				client.Write(infoPacket)
+			}
+		case <-dataTicker.C:
 			slog.Info("Sending Data Packets")
 			dataPackets := encoder.GetDataPackets(uint64(timestamp), trackers)
 			for _, DataPacket := range dataPackets {
 				client.Write(DataPacket)
 			}
-			lastDataMillis = time.Now().UnixMilli()
 			timestamp += 1
 		}
-
 	}
 }

internal/decoders/chunk.go

@@ -18,7 +18,7 @@ func DecodeChunk(bytes []byte) (chunks.Chunk, error) {
 
 	data_len := lengthAndFlag
 
-	has_subchunks := lengthAndFlag > 32768
+	has_subchunks := lengthAndFlag >= 32768
 
 	if has_subchunks {
 		data_len = data_len - 32768

internal/decoders/info_packet_chunk_test.go

@@ -81,6 +81,55 @@ func TestGoodInfoPacketChunkDecoding(t *testing.T) {
 				},
 			},
 		},
+		{
+			description: "empty InfoPacketChunk",
+			bytes: []byte{
+				0x56, 0x67, 0x22, 0x80, 0x00, 0x00, 0x0C, 0x00, 0x3D, 0x2C, 0x91, 0xDB, 0x9A, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00,
+				0x01, 0x01, 0x00, 0x0A, 0x00, 0x50, 0x53, 0x4E, 0x20, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x02, 0x00, 0x00, 0x80,
+			},
+			expected: chunks.InfoPacketChunk{
+				Chunk: chunks.Chunk{
+					ChunkData: []byte{
+						0x00, 0x00, 0x0C, 0x00, 0x3D, 0x2C, 0x91, 0xDB, 0x9A, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00,
+						0x01, 0x01, 0x00, 0x0A, 0x00, 0x50, 0x53, 0x4E, 0x20, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x02, 0x00, 0x00, 0x80,
+					},
+					Header: chunks.ChunkHeader{DataLen: 34, Id: 26454, HasSubchunks: true},
+				},
+				Data: chunks.InfoPacketChunkData{
+					PacketHeader: &chunks.PacketHeaderChunk{
+						Chunk: chunks.Chunk{
+							ChunkData: []byte{0x3D, 0x2C, 0x91, 0xDB, 0x9A, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01},
+							Header:    chunks.ChunkHeader{DataLen: 12, Id: 0, HasSubchunks: false},
+						},
+						Data: chunks.PacketHeaderChunkData{
+							PacketTimestamp:  1764620315709,
+							VersionHigh:      2,
+							VersionLow:       0,
+							FrameId:          0,
+							FramePacketCount: 1,
+						},
+					},
+					SystemName: &chunks.InfoSystemNameChunk{
+						Chunk: chunks.Chunk{
+							ChunkData: []byte{80, 83, 78, 32, 83, 101, 114, 118, 101, 114},
+							Header:    chunks.ChunkHeader{DataLen: 10, Id: 1, HasSubchunks: false},
+						},
+						Data: chunks.InfoSystemNameChunkData{
+							SystemName: "PSN Server",
+						},
+					},
+					TrackerList: &chunks.InfoTrackerListChunk{
+						Chunk: chunks.Chunk{
+							ChunkData: []byte{},
+							Header:    chunks.ChunkHeader{DataLen: 0, Id: 2, HasSubchunks: true},
+						},
+						Data: chunks.InfoTrackerListChunkData{
+							Trackers: []chunks.InfoTrackerChunk{},
+						},
+					},
+				},
+			},
+		},
 	}
 
 	for _, testCase := range testCases {
@@ -93,9 +142,11 @@ func TestGoodInfoPacketChunkDecoding(t *testing.T) {
 		}
 
 		if !reflect.DeepEqual(actual, testCase.expected) {
+			fmt.Printf("%+v\n", actual.Data.TrackerList)
+			fmt.Printf("%+v\n", testCase.expected.Data.TrackerList)
 			t.Errorf("Test '%s' failed to decode chunk properly", testCase.description)
-			fmt.Printf("expected: %+v\n", testCase.expected)
-			fmt.Printf("actual: %+v\n", actual)
+			// fmt.Printf("expected: %+v\n", testCase.expected)
+			// fmt.Printf("actual: %+v\n", actual)
 		}
 	}
 }