Merge pull request #100 from HyperloopUPV-H8/backend/reset-counter

[ethernet-view] reset packet information when board reconnects

Author: jmaralo

backend/cmd/main.go

@@ -112,7 +112,15 @@ func main() {
 	}
 
 	// <--- update factory --->
-	updateFactory := update_factory.NewFactory()
+	boardToPackets := make(map[abstraction.TransportTarget][]uint16)
+	for _, board := range podData.Boards {
+		packetIds := make([]uint16, len(board.Packets))
+		for i, packet := range board.Packets {
+			packetIds[i] = packet.Id
+		}
+		boardToPackets[abstraction.TransportTarget(board.Name)] = packetIds
+	}
+	updateFactory := update_factory.NewFactory(boardToPackets)
 
 	// <--- logger --->
 	var boardMap map[abstraction.BoardId]string

backend/internal/update_factory/update_factory.go

@@ -6,6 +6,7 @@ import (
 	"time"
 
 	"github.com/HyperloopUPV-H8/h9-backend/internal/common"
+	"github.com/HyperloopUPV-H8/h9-backend/pkg/abstraction"
 	"github.com/HyperloopUPV-H8/h9-backend/pkg/transport/packet/data"
 
 	"github.com/HyperloopUPV-H8/h9-backend/internal/update_factory/models"
@@ -30,9 +31,10 @@ type UpdateFactory struct {
 	packetCount     map[uint16]uint
 	lastPacketCount map[uint16]float64
 	trace           zerolog.Logger
+	boardToPackets  map[abstraction.TransportTarget][]uint16
 }
 
-func NewFactory() *UpdateFactory {
+func NewFactory(boardToPackets map[abstraction.TransportTarget][]uint16) *UpdateFactory {
 	trace.Info().Msg("new update factory")
 	factory := &UpdateFactory{
 		count:           make(map[uint16]uint64),
@@ -44,13 +46,39 @@ func NewFactory() *UpdateFactory {
 		packetCount:     make(map[uint16]uint),
 		lastPacketCount: make(map[uint16]float64),
 		trace:           trace.With().Str("component", "updateFactory").Logger(),
+		boardToPackets:  boardToPackets,
 	}
 
 	go factory.adjustOrder()
 
 	return factory
 }
 
+func (factory *UpdateFactory) ClearPacketsFor(target abstraction.TransportTarget) {
+	packets, ok := factory.boardToPackets[target]
+	if !ok {
+		return
+	}
+
+	factory.averageMx.Lock()
+	defer factory.averageMx.Unlock()
+	factory.countMx.Lock()
+	defer factory.countMx.Unlock()
+
+	for _, id := range packets {
+		factory.clearPacket(id)
+	}
+}
+
+func (factory *UpdateFactory) clearPacket(id uint16) {
+	delete(factory.count, id)
+	delete(factory.cycleTimeAvg, id)
+	delete(factory.timestamp, id)
+	delete(factory.fieldAvg, id)
+	delete(factory.packetCount, id)
+	delete(factory.lastPacketCount, id)
+}
+
 func (factory *UpdateFactory) NewUpdate(packet *data.Packet) models.Update {
 	factory.updateCount(uint16(packet.Id()))
 

backend/pkg/broker/topics/connection/update.go

@@ -49,7 +49,9 @@ func (update *Update) Push(push abstraction.BrokerPush) error {
 	defer update.connectionMx.Unlock()
 	update.connections[connection.Name] = *connection
 
-	rawPayload, err := json.Marshal(update.connections)
+	rawPayload, err := json.Marshal(map[string]Connection{
+		connection.Name: *connection,
+	})
 	if err != nil {
 		return err
 	}

backend/pkg/vehicle/vehicle.go

@@ -177,4 +177,7 @@ func (vehicle *Vehicle) SendPush(abstraction.BrokerPush) error {
 // ConnectionUpdate is the method invoked by transport to signal a connection state has changed
 func (vehicle *Vehicle) ConnectionUpdate(target abstraction.TransportTarget, isConnected bool) {
 	vehicle.broker.Push(connection_topic.NewConnection(string(target), isConnected))
+	if isConnected {
+		vehicle.updateFactory.ClearPacketsFor(target)
+	}
 }

common-front/lib/adapters/ConnectionUpdate.ts

@@ -1,3 +1,3 @@
 import { Connection } from "../models";
 
-export type ConnectionsUpdate = Connection[];
+export type ConnectionsUpdate = {[name: string]: Connection};

common-front/lib/components/Connections/useConnections.ts

@@ -1,15 +1,20 @@
-import { useConnectionsStore, useSubscribe } from "../..";
+import { useConnectionsStore, useMeasurementsStore, usePodDataStore, useSubscribe } from "../..";
 
 export function useConnections() {
 
-    // const setBoardConnections = useStore(state => state.setConnections);
-    // const connections = useStore(state => state.connections);
-
-    const setBoardConnections = useConnectionsStore(state => state.setConnections);
+    const setBoardConnections = useConnectionsStore(state => state.setConnections)
+    const clearMeasurements = useMeasurementsStore(state => state.clearMeasurements)
+    const clearPodData = usePodDataStore(state => state.clearPodData);
     const connections = useConnectionsStore(state => state.connections)
 
     useSubscribe("connection/update", (update) => {
         setBoardConnections(update)
+        for (const connection of Object.values(update)) {
+            if (connection.isConnected) {
+                clearMeasurements(connection.name)
+                clearPodData(connection.name)
+            }
+        }
     });
 
     return connections;

common-front/lib/store/connectionsStore.ts

@@ -1,4 +1,4 @@
-import { Connection } from "..";
+import { Connection, ConnectionsUpdate } from "..";
 import { StateCreator, StoreApi, create } from "zustand";
 
 export interface ConnectionsStore {
@@ -7,10 +7,10 @@ export interface ConnectionsStore {
         boards: Connection[];
     }
     setBackendConnection: (isConnected: boolean) => void;
-    setConnections: (connections: Connection[]) => void;
+    setConnections: (connections: ConnectionsUpdate) => void;
 }
 
-export const useConnectionsStore = create<ConnectionsStore>((set) => ({
+export const useConnectionsStore = create<ConnectionsStore>((set, get) => ({
     connections: {
         backend: { name: "Backend WebSocket", isConnected: false },
         boards: [] as Connection[],
@@ -42,12 +42,25 @@ export const useConnectionsStore = create<ConnectionsStore>((set) => ({
      * When a board connection state changes, it updates all the connections.
      * @param {Connection[]} connections 
      */
-    setConnections: (connections: Connection[]) => {
+    setConnections: (connections: ConnectionsUpdate) => {
+        const boardsDraft = get().connections.boards;
+
+        for (const board of boardsDraft) {
+            if (board.name in connections) {
+                board.isConnected = connections[board.name].isConnected
+                delete(connections[board.name])
+            }
+        }
+
+        for (const connection of Object.values(connections)) {
+            boardsDraft.push(connection)
+        }
+
         set(state => ({
             ...state,
             connections: {
                 ...state.connections,
-                boards: connections
+                boards: boardsDraft
             }
         }))
     }

common-front/lib/store/measurementsStore.ts

@@ -8,14 +8,16 @@ import {
     PacketUpdate,
 } from "../adapters";
 import { create } from "zustand";
+import { isNumericType } from "../BackendTypes";
 
 export type Measurements = Record<string, Measurement>
 
 export interface MeasurementsStore {
     measurements: Measurements;
     packetIdToBoard: Record<number, string>;
     initMeasurements: (podDataAdapter: PodDataAdapter) => void;
-    updateMeasurements: (measurements: Record<string, PacketUpdate>) => void
+    updateMeasurements: (measurements: Record<string, PacketUpdate>) => void;
+    clearMeasurements: (board: string) => void
 }
 
 export const useMeasurementsStore = create<MeasurementsStore>((set, get) => ({
@@ -57,6 +59,31 @@ export const useMeasurementsStore = create<MeasurementsStore>((set, get) => ({
                 measurementsDraft[measurementId].value = mUpdate;
             }
         }
+        
+        set(state => ({
+            ...state,
+            measurements: measurementsDraft
+        }))
+    },
+
+    clearMeasurements: (board: string) => {
+        const measurementsDraft = get().measurements;
+
+        for (const measurementId in measurementsDraft) {
+            if (measurementId.includes(board)) {
+                if (isNumericType(measurementsDraft[measurementId].type)) {
+                    measurementsDraft[measurementId].value = {
+                        average: 0,
+                        last: 0,
+                    }
+                } else if (measurementsDraft[measurementId].type == "bool") {
+                    measurementsDraft[measurementId].value = false
+                } else {
+                    measurementsDraft[measurementId].value = "Default"
+                }
+            }
+        }
+
         set(state => ({
             ...state,
             measurements: measurementsDraft

common-front/lib/store/podDataStore.ts

@@ -1,3 +1,4 @@
+import { isNumericType } from "../BackendTypes";
 import {
     createPodDataFromAdapter,
     PacketUpdate,
@@ -13,6 +14,7 @@ export interface PodDataStore {
     podData: PodData
     initPodData: (podDataAdapter: PodDataAdapter) => void
     updatePodData: (packetUpdates: Record<number, PacketUpdate>) => void
+    clearPodData: (board: string) => void
 }
 
 export const usePodDataStore = create<PodDataStore>((set, get) => ({
@@ -101,6 +103,42 @@ export const usePodDataStore = create<PodDataStore>((set, get) => ({
             }
         }))
     },
+
+    clearPodData(boardName: string) {
+        const boardsDraft = get().podData.boards
+
+        for (const board of boardsDraft) {
+            if (board.name != boardName) {
+                continue;
+            }
+
+            for (const packet of board.packets) {
+                packet.count = 0
+                packet.cycleTime = 0
+                packet.hexValue = ""
+                for (const measurement of packet.measurements) {
+                    if (isNumericType(measurement.type)) {
+                        measurement.value = {
+                            average: 0,
+                            last: 0,
+                        }
+                    } else if (measurement.type == "bool") {
+                        measurement.value = false
+                    } else {
+                        measurement.value = "Default"
+                    }
+                }
+            }
+        }
+
+        set(state => ({
+            ...state,
+            podData: {
+                ...state.podData,
+                boards: boardsDraft,
+            }
+        }))
+    }
 }))
 
 export function getPacket(podData: PodData, id: number): Packet | undefined {