Release v11.2.0

backend/cmd/config.toml

@@ -27,8 +27,8 @@ backoff_min_ms = 100         # Minimum backoff duration in milliseconds
 backoff_max_ms = 5000        # Maximum backoff duration in milliseconds
 backoff_multiplier = 1.5     # Exponential backoff multiplier (e.g., 1.5 means each retry waits 1.5x longer)
 max_retries = 0              # Maximum retries before cycling (0 = infinite retries, recommended for persistent reconnection)
-connection_timeout_ms = 3000 # Connection timeout in milliseconds
-keep_alive_ms = 1000         # Keep-alive interval in milliseconds
+keep_alive_interval_ms = 50
+
 
 # UDP Configuration
 # These settings control the UDP server's buffer sizes and performance characteristics

backend/cmd/dev-config.toml

@@ -30,7 +30,7 @@ backoff_max_ms = 999999        # Maximum backoff duration in milliseconds
 backoff_multiplier = 1         # Exponential backoff multiplier (e.g., 1.5 means each retry waits 1.5x longer)
 max_retries = 0                # Maximum retries before cycling (0 = infinite retries, recommended for persistent reconnection)
 connection_timeout_ms = 999999 # Timeout for the initial connection attempt
-keep_alive_ms = 0              # Keep-alive interval in milliseconds (0 to disable)
+keep_alive_interval_ms = 0     # Keep-alive interval in milliseconds (0 to disable)
 
 # UDP Configuration
 # These settings control the UDP server's buffer sizes and performance characteristics

backend/cmd/setup_transport.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"context"
 	"encoding/binary"
 	"fmt"
 	"net"
@@ -52,6 +51,8 @@ func configureTransport(
 	// Start handling network packets using UDP server
 	configureUDPServerTransport(adj, transp, config)
 
+	// Start the application-level TCP keep-alive (empty order with id 1)
+	go transp.HandleKeepAlive(time.Duration(config.TCP.KeepAliveIntervalMs) * time.Millisecond)
 }
 
 func configureTCPClientTransport(
@@ -86,11 +87,6 @@ func configureTCPClientTransport(
 			clientConfig.Timeout = time.Duration(config.TCP.ConnectionTimeout) * time.Millisecond
 		}
 
-		// Apply custom keep-alive if specified
-		if config.TCP.KeepAlive > 0 {
-			clientConfig.KeepAlive = time.Duration(config.TCP.KeepAlive) * time.Millisecond
-		}
-
 		// Apply custom backoff parameters
 		if config.TCP.BackoffMinMs > 0 || config.TCP.BackoffMaxMs > 0 || config.TCP.BackoffMultiplier > 0 {
 			minBackoff := 100 * time.Millisecond // default
@@ -118,18 +114,12 @@ func configureTCPClientTransport(
 	}
 }
 
-// configureTCPServerTransport starts the TCP server handler using a ListenConfig with KeepAlive.
+// configureTCPServerTransport starts the TCP server handler.
 func configureTCPServerTransport(
 	adj adj_module.ADJ,
 	transp *transport.Transport,
 ) {
-	go transp.HandleServer(tcp.ServerConfig{
-		ListenConfig: net.ListenConfig{
-			KeepAlive: time.Second,
-		},
-		Context: context.TODO(),
-	}, fmt.Sprintf("%s:%d", adj.Info.Addresses[BACKEND], adj.Info.Ports[TcpServer]))
-
+	go transp.HandleServer(tcp.NewServerConfig(), fmt.Sprintf("%s:%d", adj.Info.Addresses[BACKEND], adj.Info.Ports[TcpServer]))
 }
 
 // configureUDPServerTransport creates and starts the UDP server then delegates handling to transport.
@@ -246,6 +236,15 @@ func getTransportDecEnc(info adj_module.Info, podData pod_data.PodData) (*presen
 		encoder.SetPacketEncoder(id, dataEncoder)
 	}
 
+	// The TCP keep-alive order is an empty packet, so give it an empty
+	// descriptor unless the ADJ already defines packet id 1
+	if !common.Contains(ids, transport.KeepAliveId) {
+		dataDecoder.SetDescriptor(transport.KeepAliveId, data.Descriptor{})
+		dataEncoder.SetDescriptor(transport.KeepAliveId, data.Descriptor{})
+		decoder.SetPacketDecoder(transport.KeepAliveId, dataDecoder)
+		encoder.SetPacketEncoder(transport.KeepAliveId, dataEncoder)
+	}
+
 	// TODO Solve this foking mess, I have tried...
 	stateOrdersDecoder := order.NewDecoder(binary.LittleEndian)
 	stateOrdersDecoder.SetActionId(abstraction.PacketId(info.MessageIds[AddStateOrder]), stateOrdersDecoder.DecodeAdd)

backend/cmd/setup_vehicle.go

@@ -64,6 +64,15 @@ func configureBroker(subloggers abstraction.SubloggersMap, loggerHandler *logger
 	pool := websocket.NewPool(connections, trace.Logger)
 	pool.SetOnDisconnect(func(count int) {
 		if count == 0 {
+			// Losing the last control-station GUI (closed, crashed or hung:
+			// heartbeats stop and the read deadline expires) must put the
+			// vehicle in a safe state, as required by competition rules.
+			trace.Warn().Msg("no clients connected, sending FAULT order")
+			faultOrder := &order_topic.Order{Id: 0, Fields: map[string]order_topic.Field{}}
+			if err := broker.UserPush(faultOrder); err != nil {
+				trace.Error().Err(err).Msg("failed to send fault order on client disconnect")
+			}
+
 			trace.Info().Msg("no clients connected, stopping logger")
 			loggerHandler.Stop()
 			if err := loggerTopic.NotifyStopped(); err != nil {

backend/internal/config/config_types.go

@@ -16,12 +16,12 @@ type Transport struct {
 }
 
 type TCP struct {
-	BackoffMinMs      int     `toml:"backoff_min_ms"`
-	BackoffMaxMs      int     `toml:"backoff_max_ms"`
-	BackoffMultiplier float64 `toml:"backoff_multiplier"`
-	MaxRetries        int     `toml:"max_retries"`
-	ConnectionTimeout int     `toml:"connection_timeout_ms"`
-	KeepAlive         int     `toml:"keep_alive_ms"`
+	BackoffMinMs        int     `toml:"backoff_min_ms"`
+	BackoffMaxMs        int     `toml:"backoff_max_ms"`
+	BackoffMultiplier   float64 `toml:"backoff_multiplier"`
+	MaxRetries          int     `toml:"max_retries"`
+	ConnectionTimeout   int     `toml:"connection_timeout_ms"`
+	KeepAliveIntervalMs int     `toml:"keep_alive_interval_ms"`
 }
 
 type UDP struct {

backend/pkg/transport/keepalive.go

@@ -0,0 +1,72 @@
+package transport
+
+import (
+	"errors"
+	"fmt"
+	"net"
+	"time"
+
+	"github.com/HyperloopUPV-H8/h9-backend/pkg/abstraction"
+	"github.com/HyperloopUPV-H8/h9-backend/pkg/transport/packet/data"
+)
+
+// KeepAliveId is the packet id of the empty order used as the
+// application-level TCP keep-alive.
+const KeepAliveId abstraction.PacketId = 1
+
+// DefaultKeepAliveInterval is how often the keep-alive order is sent to each
+// board when no interval is configured.
+const DefaultKeepAliveInterval = 50 * time.Millisecond
+
+// HandleKeepAlive broadcasts an empty order with id KeepAliveId to every
+// connected board every interval. Write errors are forwarded to the
+// connection handler by the connection wrapper, which tears the connection
+// down. This method blocks.
+func (transport *Transport) HandleKeepAlive(interval time.Duration) {
+	if interval <= 0 {
+		interval = DefaultKeepAliveInterval
+	}
+	// The keep-alive frame never changes, so encode it once up front
+	buf, err := transport.encoder.Encode(data.NewPacket(KeepAliveId))
+	if err != nil {
+		transport.logger.Error().Stack().Err(err).Msg("encode keep-alive")
+		transport.errChan <- err
+		return
+	}
+	frame := make([]byte, buf.Len())
+	copy(frame, buf.Bytes())
+	transport.encoder.ReleaseBuffer(buf)
+
+	ticker := time.NewTicker(interval)
+	defer ticker.Stop()
+	for range ticker.C {
+		transport.broadcastKeepAlive(frame, interval)
+	}
+}
+
+// broadcastKeepAlive writes the keep-alive frame to all active connections.
+func (transport *Transport) broadcastKeepAlive(frame []byte, interval time.Duration) {
+	transport.connectionsMx.RLock()
+	defer transport.connectionsMx.RUnlock()
+
+	for target, conn := range transport.connections {
+		// Bound the write so a dead peer with a full send buffer cannot hold
+		// the connections lock past the next tick
+		conn.SetWriteDeadline(time.Now().Add(interval))
+		totalWritten := 0
+		for totalWritten < len(frame) {
+			n, err := conn.Write(frame[totalWritten:])
+			totalWritten += n
+			if err != nil {
+				// net.ErrClosed means the connection was closed on purpose
+				// and its handler already reported the reason
+				if !errors.Is(err, net.ErrClosed) {
+					transport.logger.Error().Stack().Err(err).Str("target", string(target)).Msg("keep-alive write")
+					transport.errChan <- fmt.Errorf("TCP keep-alive to board %s failed: %w", target, err)
+				}
+				break
+			}
+		}
+		conn.SetWriteDeadline(time.Time{})
+	}
+}

backend/pkg/transport/network/tcp/config.go

@@ -23,13 +23,9 @@ func NewClientConfig(laddr net.Addr) ClientConfig {
 		Dialer: net.Dialer{
 			Timeout:   time.Second,
 			LocalAddr: laddr,
-			KeepAlive: -1, // managed via KeepAliveConfig
-			KeepAliveConfig: net.KeepAliveConfig{
-				Enable:   true,
-				Idle:     time.Second,
-				Interval: time.Second,
-				Count:    3,
-			},
+			// Kernel keep-alive disabled: liveness is handled by the
+			// application-level keep-alive order (transport.HandleKeepAlive)
+			KeepAlive: -1,
 		},
 
 		Context:                   context.TODO(),
@@ -73,13 +69,9 @@ type ServerConfig struct {
 func NewServerConfig() ServerConfig {
 	return ServerConfig{
 		ListenConfig: net.ListenConfig{
-			KeepAlive: -1, // managed via KeepAliveConfig
-			KeepAliveConfig: net.KeepAliveConfig{
-				Enable:   true,
-				Idle:     time.Second,
-				Interval: time.Second,
-				Count:    3,
-			},
+			// Kernel keep-alive disabled: liveness is handled by the
+			// application-level keep-alive order (transport.HandleKeepAlive)
+			KeepAlive: -1,
 		},
 		Context: context.TODO(),
 	}

backend/pkg/websocket/client.go

@@ -9,6 +9,15 @@ import (
 	ws "github.com/gorilla/websocket"
 )
 
+// HeartbeatTopic is the liveness message every frontend sends once per
+// second. It is consumed by the websocket layer and never reaches the broker.
+const HeartbeatTopic = "connection/heartbeat"
+
+// heartbeatTimeout bounds how long a dead or frozen frontend goes undetected:
+// if no message (the heartbeat guarantees one per second) arrives within this
+// window, Read fails and the client is treated as disconnected.
+const heartbeatTimeout = 3 * time.Second
+
 type Client struct {
 	readMx    *sync.Mutex
 	writeMx   *sync.Mutex
@@ -26,6 +35,8 @@ func NewClient(conn *ws.Conn) *Client {
 		onClose:   func() {},
 	}
 
+	conn.SetReadDeadline(time.Now().Add(heartbeatTimeout))
+
 	return client
 }
 
@@ -46,6 +57,9 @@ func (client *Client) Read() (Message, error) {
 
 	var message Message
 	err := client.conn.ReadJSON(&message)
+	if err == nil {
+		client.conn.SetReadDeadline(time.Now().Add(heartbeatTimeout))
+	}
 	return message, err
 }
 

backend/pkg/websocket/pool.go

@@ -84,6 +84,13 @@ func (pool *Pool) handle(id ClientId, client *Client) {
 		}
 
 		clientLogger.Trace().Msg("read")
+
+		// Heartbeats only refresh the read deadline; they carry no payload
+		// for the broker.
+		if string(message.Topic) == HeartbeatTopic {
+			continue
+		}
+
 		pool.onMessage(id, &message)
 	}
 }