refactor boardConfigurationProtocol

fabik111 · fabik111 · commit 5a50ee5c45e6 · 2025-04-10T11:13:44.000+02:00
refactor packetmanager

Serial Agent init clear packet even if recognized
diff --git a/src/ConfiguratorAgents/agents/BLE/BLEAgent.h b/src/ConfiguratorAgents/agents/BLE/BLEAgent.h
@@ -45,7 +45,7 @@
 #error "Board not supported for BLE configuration"
 #endif
 
-class BLEAgentClass : public ConfiguratorAgent, BoardConfigurationProtocol {
+class BLEAgentClass : public ConfiguratorAgent, private BoardConfigurationProtocol {
 public:
   BLEAgentClass();
   AgentConfiguratorStates begin();
@@ -83,10 +83,10 @@ class BLEAgentClass : public ConfiguratorAgent, BoardConfigurationProtocol {
   static void bleOutputStreamSubscribed(BLEDevice central, BLECharacteristic characteristic);
 
   /*BoardConfigurationProtocol pure virtual methods implementation*/
-  bool hasReceivedBytes();
-  size_t receivedBytes();
-  uint8_t readByte();
-  int writeBytes(const uint8_t *data, size_t len);
+  bool received();
+  size_t available();
+  uint8_t read();
+  int write(const uint8_t *data, size_t len);
   void handleDisconnectRequest();
   void clearInputBuffer();
 };
@@ -202,7 +202,7 @@ inline bool BLEAgentClass::receivedMsgAvailable() {
 }
 
 inline bool BLEAgentClass::sendMsg(ProvisioningOutputMessage &msg) {
-  return BoardConfigurationProtocol::sendNewMsg(msg);
+  return BoardConfigurationProtocol::sendMsg(msg);
 }
 
 inline bool BLEAgentClass::isPeerConnected() {
@@ -220,27 +220,27 @@ inline void BLEAgentClass::bleOutputStreamSubscribed(BLEDevice central, BLEChara
   DEBUG_INFO("BLEAgentClass Connected event, central: %s", central.address().c_str());
 }
 
-inline bool BLEAgentClass::hasReceivedBytes() {
+inline bool BLEAgentClass::received() {
   bool res = _inputStreamCharacteristic.written();
   if (res) {
     _readByte = 0;
   }
   return res;
 }
 
-inline size_t BLEAgentClass::receivedBytes() {
+inline size_t BLEAgentClass::available() {
   return _inputStreamCharacteristic.valueLength();
 }
 
-inline uint8_t BLEAgentClass::readByte() {
+inline uint8_t BLEAgentClass::read() {
   const uint8_t *charValue = _inputStreamCharacteristic.value();
   if (_readByte < _inputStreamCharacteristic.valueLength()) {
     return charValue[_readByte++];
   }
   return 0;
 }
 
-inline int BLEAgentClass::writeBytes(const uint8_t *data, size_t len) {
+inline int BLEAgentClass::write(const uint8_t *data, size_t len) {
   return _outputStreamCharacteristic.write(data, len);
 }
 
diff --git a/src/ConfiguratorAgents/agents/BoardConfigurationProtocol/BoardConfigurationProtocol.cpp b/src/ConfiguratorAgents/agents/BoardConfigurationProtocol/BoardConfigurationProtocol.cpp
@@ -48,7 +48,7 @@ bool BoardConfigurationProtocol::getMsg(ProvisioningInputMessage &msg) {
   return true;
 }
 
-bool BoardConfigurationProtocol::sendNewMsg(ProvisioningOutputMessage &msg) {
+bool BoardConfigurationProtocol::sendMsg(ProvisioningOutputMessage &msg) {
   bool res = false;
   switch (msg.type) {
     case MessageOutputType::STATUS:
@@ -94,15 +94,15 @@ BoardConfigurationProtocol::TransmissionResult BoardConfigurationProtocol::sendA
     transmitStream();
   }
 
-  if (!hasReceivedBytes()) {
+  if (!received()) {
     return transmissionRes;
   }
 
-  int receivedDataLen = receivedBytes();
+  int receivedDataLen = available();
 
   for (int i = 0; i < receivedDataLen; i++) {
     PacketManager::ReceivingState res;
-    uint8_t val = readByte();
+    uint8_t val = read();
 
     res = PacketManager::PacketReceiver::getInstance().handleReceivedByte(_packet, val);
     if (res == PacketManager::ReceivingState::ERROR) {
@@ -126,11 +126,11 @@ BoardConfigurationProtocol::TransmissionResult BoardConfigurationProtocol::sendA
           break;
         case PacketManager::MessageType::TRANSMISSION_CONTROL:
           {
-            if (_packet.Payload.len() == 1 && _packet.Payload[0] == 0x03) {
+            if (_packet.Payload.len() == 1 && _packet.Payload[0] == (uint8_t)PacketManager::TransmissionControlMessage::NACK) {
               for (std::list<OutputPacketBuffer>::iterator packet = _outputMessagesList.begin(); packet != _outputMessagesList.end(); ++packet) {
                 packet->startProgress();
               }
-            } else if (_packet.Payload.len() == 1 && _packet.Payload[0] == 0x02) {
+            } else if (_packet.Payload.len() == 1 && _packet.Payload[0] == (uint8_t)PacketManager::TransmissionControlMessage::DISCONNECT) {
               handleDisconnectRequest();
             }
           }
@@ -344,7 +344,7 @@ BoardConfigurationProtocol::TransmissionResult BoardConfigurationProtocol::trans
   for (std::list<OutputPacketBuffer>::iterator packet = _outputMessagesList.begin(); packet != _outputMessagesList.end(); ++packet) {
     if (packet->hasBytesToSend()) {
       res = TransmissionResult::NOT_COMPLETED;
-      packet->incrementBytesSent(writeBytes(packet->get_ptrAt(packet->bytesSent()), packet->bytesToSend()));
+      packet->incrementBytesSent(write(packet->get_ptrAt(packet->bytesSent()), packet->bytesToSend()));
       #if BCP_DEBUG_PACKET == 1
       DEBUG_DEBUG("BoardConfigurationProtocol::%s  transferred: %d of %d", __FUNCTION__, packet->bytesSent(), packet->len());
       #endif
diff --git a/src/ConfiguratorAgents/agents/BoardConfigurationProtocol/BoardConfigurationProtocol.h b/src/ConfiguratorAgents/agents/BoardConfigurationProtocol/BoardConfigurationProtocol.h
@@ -14,7 +14,7 @@
 class BoardConfigurationProtocol {
 public:
   bool getMsg(ProvisioningInputMessage &msg);
-  bool sendNewMsg(ProvisioningOutputMessage &msg);
+  bool sendMsg(ProvisioningOutputMessage &msg);
   bool msgAvailable();
 
 protected:
@@ -29,10 +29,10 @@ class BoardConfigurationProtocol {
   void clear();
   void checkOutputPacketValidity();
   /*Pure virtual methods that depends on physical interface*/
-  virtual bool hasReceivedBytes() = 0;
-  virtual size_t receivedBytes() = 0;
-  virtual uint8_t readByte() = 0;
-  virtual int writeBytes(const uint8_t *data, size_t len) = 0;
+  virtual bool received() = 0;
+  virtual size_t available() = 0;
+  virtual uint8_t read() = 0;
+  virtual int write(const uint8_t *data, size_t len) = 0;
   virtual void handleDisconnectRequest() = 0;
   virtual bool isPeerConnected() = 0;
   virtual void clearInputBuffer() = 0;
diff --git a/src/ConfiguratorAgents/agents/BoardConfigurationProtocol/PacketManager.cpp b/src/ConfiguratorAgents/agents/BoardConfigurationProtocol/PacketManager.cpp
@@ -67,7 +67,7 @@ namespace PacketManager {
     }
 
     if (millis() - packet.LastByteReceivedTs > BYTES_VALIDITY_MS) {
-      clearInputBuffers(packet);
+      clear(packet);
     }
 
     packet.LastByteReceivedTs = millis();
@@ -76,7 +76,7 @@ namespace PacketManager {
       case ReceivingState::WAITING_HEADER:  _state = handle_WaitingHeader (packet,byte); break;
       case ReceivingState::WAITING_PAYLOAD: _state = handle_WaitingPayload(packet,byte); break;
       case ReceivingState::WAITING_END:     _state = handle_WaitingEnd    (packet,byte); break;
-      default:                                                                    break;
+      default:                                                                           break;
     }
 
     if (_state == ReceivingState::RECEIVED) {
@@ -87,15 +87,14 @@ namespace PacketManager {
       }
     }
 
+    if (_state == ReceivingState::ERROR) {
+      clear(packet);
+    }
+
     return _state;
   }
 
   void PacketReceiver::clear(Packet_t &packet) {
-    clearInputBuffers(packet);
-    _state = ReceivingState::WAITING_HEADER;
-  }
-
-  void PacketReceiver::clearInputBuffers(Packet_t &packet) {
     packet.LastByteReceivedTs = 0;
     packet.Header.clear();
     packet.Payload.reset();
@@ -157,7 +156,6 @@ namespace PacketManager {
 
     if (packet.Header.receivedAll()) {
       if (!checkBeginPacket(packet)) {
-        clearInputBuffers(packet);
         return ReceivingState::ERROR;
       }
 
@@ -193,7 +191,6 @@ namespace PacketManager {
         return ReceivingState::RECEIVED;
       } else {
         //Error
-        clearInputBuffers(packet);
         return ReceivingState::ERROR;
       }
     }
diff --git a/src/ConfiguratorAgents/agents/BoardConfigurationProtocol/PacketManager.h b/src/ConfiguratorAgents/agents/BoardConfigurationProtocol/PacketManager.h
@@ -12,14 +12,19 @@
 
 namespace PacketManager {
   enum class ReceivingState { WAITING_HEADER,
-    WAITING_PAYLOAD,
-    WAITING_END,
-    RECEIVED,
-    ERROR };
+                              WAITING_PAYLOAD,
+                              WAITING_END,
+                              RECEIVED,
+                              ERROR };
 
   enum class MessageType { DATA     = 2,
                            TRANSMISSION_CONTROL = 3 };
 
+  enum class TransmissionControlMessage : uint8_t{
+    CONNECT    = 0x01,
+    DISCONNECT = 0x02,
+    NACK       = 0x03 };
+
   /*
    * The packet structure
    * 0x55 0xaa <type> <len> <payload> <crc> 0xaa 0x55
@@ -56,7 +61,6 @@ namespace PacketManager {
       ReceivingState handle_WaitingHeader(Packet_t &packet, uint8_t byte);
       ReceivingState handle_WaitingPayload(Packet_t &packet, uint8_t byte);
       ReceivingState handle_WaitingEnd(Packet_t &packet, uint8_t byte);
-      void clearInputBuffers(Packet_t &packet);
       bool checkBeginPacket(Packet_t &packet);
       bool checkEndPacket(Packet_t &packet);
       bool checkCRC(Packet_t &packet);
diff --git a/src/ConfiguratorAgents/agents/Serial/SerialAgent.h b/src/ConfiguratorAgents/agents/Serial/SerialAgent.h
@@ -14,7 +14,7 @@
 #include "ConfiguratorAgents/agents/BoardConfigurationProtocol/cbor/CBORInstances.h"
 #include "Utility/LEDFeedback/LEDFeedback.h"
 
-class SerialAgentClass : public ConfiguratorAgent, BoardConfigurationProtocol { //TODO put private BoardConfigurationProtocol
+class SerialAgentClass : public ConfiguratorAgent, private BoardConfigurationProtocol {
 public:
   SerialAgentClass();
   AgentConfiguratorStates begin();
@@ -37,10 +37,10 @@ class SerialAgentClass : public ConfiguratorAgent, BoardConfigurationProtocol {
   AgentConfiguratorStates handlePeerConnected();
 
   /*BoardConfigurationProtocol pure virtual methods implementation*/
-  bool hasReceivedBytes();
-  size_t receivedBytes();
-  uint8_t readByte();
-  int writeBytes(const uint8_t *data, size_t len);
+  bool received();
+  size_t available();
+  uint8_t read();
+  int write(const uint8_t *data, size_t len);
   void handleDisconnectRequest();
   void clearInputBuffer();
 };
@@ -109,7 +109,7 @@ inline bool SerialAgentClass::receivedMsgAvailable() {
 }
 
 inline bool SerialAgentClass::sendMsg(ProvisioningOutputMessage &msg) {
-  return BoardConfigurationProtocol::sendNewMsg(msg);
+  return BoardConfigurationProtocol::sendMsg(msg);
 }
 
 inline bool SerialAgentClass::isPeerConnected() {
@@ -127,15 +127,14 @@ inline ConfiguratorAgent::AgentConfiguratorStates SerialAgentClass::handleInit()
     PacketManager::ReceivingState res = PacketManager::PacketReceiver::getInstance().handleReceivedByte(_packet, byte);
     if (res == PacketManager::ReceivingState::RECEIVED) {
       if (_packet.Type == PacketManager::MessageType::TRANSMISSION_CONTROL) {
-        if (_packet.Payload.len() == 1 && _packet.Payload[0] == 0x01) {//TODO use define
+        if (_packet.Payload.len() == 1 && _packet.Payload[0] == (uint8_t)PacketManager::TransmissionControlMessage::CONNECT) {
           //CONNECT
           nextState = AgentConfiguratorStates::PEER_CONNECTED;
-          PacketManager::PacketReceiver::getInstance().clear(_packet);
         }
       }
+      PacketManager::PacketReceiver::getInstance().clear(_packet);
     } else if (res == PacketManager::ReceivingState::ERROR) {
       DEBUG_DEBUG("SerialAgentClass::%s Error receiving packet", __FUNCTION__);
-      PacketManager::PacketReceiver::getInstance().clear(_packet);
       clearInputBuffer();
     }
   }
@@ -163,19 +162,19 @@ inline ConfiguratorAgent::AgentConfiguratorStates SerialAgentClass::handlePeerCo
   return nextState;
 }
 
-inline bool SerialAgentClass::hasReceivedBytes() {
+inline bool SerialAgentClass::received() {
   return Serial.available() > 0;
 }
 
-inline size_t SerialAgentClass::receivedBytes() {
+inline size_t SerialAgentClass::available() {
   return Serial.available();
 }
 
-inline uint8_t SerialAgentClass::readByte() {
+inline uint8_t SerialAgentClass::read() {
   return Serial.read();
 }
 
-inline int SerialAgentClass::writeBytes(const uint8_t *data, size_t len) {
+inline int SerialAgentClass::write(const uint8_t *data, size_t len) {
   return Serial.write(data, len);
 }
 

Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ namespace PacketManager {`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`if (millis() - packet.LastByteReceivedTs > BYTES_VALIDITY_MS) {`
`70`		`- clearInputBuffers(packet);`
	`70`	`+ clear(packet);`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`packet.LastByteReceivedTs = millis();`
`@@ -76,7 +76,7 @@ namespace PacketManager {`
`76`	`76`	`case ReceivingState::WAITING_HEADER: _state = handle_WaitingHeader (packet,byte); break;`
`77`	`77`	`case ReceivingState::WAITING_PAYLOAD: _state = handle_WaitingPayload(packet,byte); break;`
`78`	`78`	`case ReceivingState::WAITING_END: _state = handle_WaitingEnd (packet,byte); break;`
`79`		`- default: break;`
	`79`	`+ default: break;`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`if (_state == ReceivingState::RECEIVED) {`
`@@ -87,15 +87,14 @@ namespace PacketManager {`
`87`	`87`	`}`
`88`	`88`	`}`
`89`	`89`
	`90`	`+ if (_state == ReceivingState::ERROR) {`
	`91`	`+ clear(packet);`
	`92`	`+ }`
	`93`	`+`
`90`	`94`	`return _state;`
`91`	`95`	`}`
`92`	`96`
`93`	`97`	`void PacketReceiver::clear(Packet_t &packet) {`
`94`		`- clearInputBuffers(packet);`
`95`		`- _state = ReceivingState::WAITING_HEADER;`
`96`		`- }`
`97`		`-`
`98`		`- void PacketReceiver::clearInputBuffers(Packet_t &packet) {`
`99`	`98`	`packet.LastByteReceivedTs = 0;`
`100`	`99`	`packet.Header.clear();`
`101`	`100`	`packet.Payload.reset();`
`@@ -157,7 +156,6 @@ namespace PacketManager {`
`157`	`156`
`158`	`157`	`if (packet.Header.receivedAll()) {`
`159`	`158`	`if (!checkBeginPacket(packet)) {`
`160`		`- clearInputBuffers(packet);`
`161`	`159`	`return ReceivingState::ERROR;`
`162`	`160`	`}`
`163`	`161`
`@@ -193,7 +191,6 @@ namespace PacketManager {`
`193`	`191`	`return ReceivingState::RECEIVED;`
`194`	`192`	`} else {`
`195`	`193`	`//Error`
`196`		`- clearInputBuffers(packet);`
`197`	`194`	`return ReceivingState::ERROR;`
`198`	`195`	`}`
`199`	`196`	`}`