Feat: Refactor BLCU TFTP status handling

Author: Humanoidear

backend/cmd/dev-config.toml

@@ -18,13 +18,13 @@ boards = ["HVSCU", "HVSCU-cabinet", "PCU", "LCU", "BCU", "BMSL"]
 
 # ADJ (Architecture Description JSON) Configuration
 [adj]
-branch = "software" # Leave blank when using ADJ as a submodule (like this: "")
+branch = "BLCU_fixed_packets" # Leave blank when using ADJ as a submodule (like this: "")
 test = true         # Enable test mode
 
 # Network Configuration
 [network]
-manual = false  # Manual network device selection
-dev_mode = true # IMPORTANT: Dev mode enabled - uses UDP server instead of packet sniffer
+manual = true  # Manual network device selection
+dev_mode = true  # IMPORTANT: Dev mode enabled - uses UDP server instead of packet sniffer
 
 # Transport Configuration
 [transport]

backend/pkg/boards/blcu.go

@@ -12,7 +12,7 @@ import (
 )
 
 const (
-	BlcuName = "BLCU"
+	BlcuName = "target"
 
 	AckId           = abstraction.BoardEvent("ACK")
 	DownloadEventId = abstraction.BoardEvent("DOWNLOAD")
@@ -33,7 +33,7 @@ type TFTPConfig struct {
 
 type BLCU struct {
 	api             abstraction.BoardAPI
-	ackChan         chan struct{}
+	tftpStatusChan  chan bool
 	ip              string
 	tftpConfig      TFTPConfig
 	id              abstraction.BoardId
@@ -55,7 +55,7 @@ func New(ip string) *BLCU {
 // Deprecated: Use NewWithConfig for proper order ID configuration
 func NewWithTFTPConfig(ip string, tftpConfig TFTPConfig, id abstraction.BoardId) *BLCU {
 	return &BLCU{
-		ackChan:         make(chan struct{}),
+		tftpStatusChan:  make(chan bool, 1),
 		ip:              ip,
 		tftpConfig:      tftpConfig,
 		id:              id,
@@ -66,7 +66,7 @@ func NewWithTFTPConfig(ip string, tftpConfig TFTPConfig, id abstraction.BoardId)
 
 func NewWithConfig(ip string, tftpConfig TFTPConfig, id abstraction.BoardId, downloadOrderId, uploadOrderId uint16) *BLCU {
 	return &BLCU{
-		ackChan:         make(chan struct{}),
+		tftpStatusChan:  make(chan bool, 1),
 		ip:              ip,
 		tftpConfig:      tftpConfig,
 		id:              id,
@@ -80,8 +80,8 @@ func (board *BLCU) Id() abstraction.BoardId {
 
 func (boards *BLCU) Notify(boardNotification abstraction.BoardNotification) {
 	switch notification := boardNotification.(type) {
-	case *AckNotification:
-		boards.ackChan <- struct{}{}
+	case *TFTPStatusNotification:
+		boards.tftpStatusChan <- notification.IsTFTPEnabled
 
 	case *DownloadEvent:
 		err := boards.download(*notification)
@@ -92,6 +92,7 @@ func (boards *BLCU) Notify(boardNotification abstraction.BoardNotification) {
 			}.Error())
 		}
 	case *UploadEvent:
+		fmt.Println("Received upload event for board:", notification.Board)
 		err := boards.upload(*notification)
 		if err != nil {
 			fmt.Println(ErrUploadFailure{
@@ -124,17 +125,32 @@ func (boards *BLCU) download(notification DownloadEvent) error {
 
 	err := boards.api.SendMessage(transport.NewPacketMessage(ping))
 	if err != nil {
+		// Couldn't connect to the BLCU
 		return ErrSendMessageFailed{
 			Timestamp: time.Now(),
 			Inner:     err,
 		}
 	}
 
-	// Wait for the ACK
-	<-boards.ackChan
+	// Wait for TFTP enabled status
+	select {
+	case isTFTPEnabled := <-boards.tftpStatusChan:
+		if !isTFTPEnabled {
+			return ErrSendMessageFailed{
+				Timestamp: time.Now(),
+				Inner:     fmt.Errorf("TFTP not enabled on BLCU device"),
+			}
+		}
+	case <-time.After(10 * time.Second):
+		return ErrSendMessageFailed{
+			Timestamp: time.Now(),
+			Inner:     fmt.Errorf("timeout waiting for TFTP status"),
+		}
+	}
 
 	// TODO! Notify on progress
 
+	// Start TFTP client
 	client, err := tftp.NewClient(boards.ip,
 		tftp.WithBlockSize(boards.tftpConfig.BlockSize),
 		tftp.WithRetries(boards.tftpConfig.Retries),
@@ -148,6 +164,7 @@ func (boards *BLCU) download(notification DownloadEvent) error {
 		}
 	}
 
+	// Download the file
 	buffer := &bytes.Buffer{}
 
 	_, err = client.ReadFile(BlcuName, tftp.BinaryMode, buffer)
@@ -171,6 +188,7 @@ func (boards *BLCU) download(notification DownloadEvent) error {
 		}
 	}
 
+	// Notify success to front
 	pushErr := boards.api.SendPush(abstraction.BrokerPush(
 		&DownloadSuccess{
 			Data: buffer.Bytes(),
@@ -187,42 +205,72 @@ func (boards *BLCU) download(notification DownloadEvent) error {
 }
 
 func (boards *BLCU) upload(notification UploadEvent) error {
-	ping := dataPacket.NewPacketWithValues(abstraction.PacketId(boards.uploadOrderId),
+	fmt.Println("Uploading BLCU firmware...")
+
+	// Create new packet with board update command
+	ping := dataPacket.NewPacketWithValues(abstraction.PacketId(boards.uploadOrderId), // 700
 		map[dataPacket.ValueName]dataPacket.Value{
-			BlcuName: dataPacket.NewEnumValue(dataPacket.EnumVariant(notification.Board)),
+			BlcuName: dataPacket.NewEnumValue(dataPacket.EnumVariant(notification.Board)), // The board to be updated
 		},
-		map[dataPacket.ValueName]bool{
+		map[dataPacket.ValueName]bool{ // True
 			BlcuName: true,
 		})
+	fmt.Println("Notifying BLCU...", ping)
 
+	// Actually send the message
 	err := boards.api.SendMessage(transport.NewPacketMessage(ping))
 	if err != nil {
+		// Couldn't connect to the BLCU
+		fmt.Println("Failed to send upload ping:", err)
 		return ErrSendMessageFailed{
 			Timestamp: time.Now(),
 			Inner:     err,
 		}
 	}
 
-	<-boards.ackChan
+	// Wait for TFTP enabled status
+	fmt.Println("Waiting for TFTP status...")
+	select {
+	case isTFTPEnabled := <-boards.tftpStatusChan:
+		if !isTFTPEnabled {
+			fmt.Println("TFTP not enabled on BLCU device")
+			return ErrSendMessageFailed{
+				Timestamp: time.Now(),
+				Inner:     fmt.Errorf("TFTP not enabled on BLCU device"),
+			}
+		}
+		fmt.Println("TFTP enabled, starting upload...")
+	case <-time.After(10 * time.Second):
+		fmt.Println("Timeout waiting for TFTP status")
+		return ErrSendMessageFailed{
+			Timestamp: time.Now(),
+			Inner:     fmt.Errorf("timeout waiting for TFTP status"),
+		}
+	}
 
 	// TODO! Notify on progress
 
+	// Start TFTP client
+	// TODO: Check if it fails here
 	client, err := tftp.NewClient(boards.ip,
 		tftp.WithBlockSize(boards.tftpConfig.BlockSize),
 		tftp.WithRetries(boards.tftpConfig.Retries),
 		tftp.WithTimeout(time.Duration(boards.tftpConfig.TimeoutMs)*time.Millisecond),
 	)
 	if err != nil {
+		fmt.Println("Failed to create TFTP client:", err)
 		return ErrNewClientFailed{
 			Addr:      boards.ip,
 			Timestamp: time.Now(),
 			Inner:     err,
 		}
 	}
 
+	// Get the update payload and prepare the buffer
 	data := notification.Data
 	buffer := bytes.NewBuffer(data)
 
+	// Write the file
 	read, err := client.WriteFile(BlcuName, tftp.BinaryMode, buffer)
 	if err != nil {
 		pushErr := boards.api.SendPush(abstraction.BrokerPush(
@@ -263,6 +311,7 @@ func (boards *BLCU) upload(notification UploadEvent) error {
 		return err
 	}
 
+	// Notify success to front
 	pushErr := boards.api.SendPush(abstraction.BrokerPush(
 		&UploadSuccess{}))
 	if pushErr != nil {

backend/pkg/boards/events.go

@@ -12,6 +12,14 @@ func (ack AckNotification) Event() abstraction.BoardEvent {
 	return ack.ID
 }
 
+type TFTPStatusNotification struct {
+	IsTFTPEnabled bool
+}
+
+func (status TFTPStatusNotification) Event() abstraction.BoardEvent {
+	return "TFTP_STATUS"
+}
+
 type DownloadEvent struct {
 	BoardEvent abstraction.BoardEvent // DownloadId
 	BoardID    abstraction.BoardId

backend/pkg/vehicle/notification.go

@@ -47,6 +47,22 @@ func (vehicle *Vehicle) handlePacketNotification(notification transport.PacketNo
 
 	switch p := notification.Packet.(type) {
 	case *data.Packet:
+		// Check if this is a TFTP status packet from BLCU (packet ID 5)
+		if p.Id() == 5 && notification.From != "" {
+			// Extract isTFTPEnabled boolean value
+			values := p.GetValues()
+			if isTFTPEnabledValue, ok := values["isTFTPEnabled"]; ok {
+				if boolVal, ok := isTFTPEnabledValue.(*data.BooleanValue); ok {
+					vehicle.boards[vehicle.BlcuId].Notify(abstraction.BoardNotification(
+						&boards.TFTPStatusNotification{
+							IsTFTPEnabled: boolVal.Value(),
+						},
+					))
+					return nil
+				}
+			}
+		}
+
 		update := vehicle.updateFactory.NewUpdate(p)
 		err := vehicle.broker.Push(data_topic.NewPush(&update))
 		if err != nil {