update Packet classes

src/concurrency/PacketQueue.h

@@ -52,7 +52,7 @@ template <typename T> class PacketQueue
     {
         std::lock_guard<std::mutex> lock(mutex);
         if (queue.empty())
-            return {nullptr}; // std::move(T());
+            return {nullptr};
         auto packet = queue.front()->move();
         queue.pop();
         return packet;

src/mesh/api/PacketAPI.cpp

@@ -18,8 +18,10 @@ int32_t PacketAPI::runOnce()
 
 bool PacketAPI::receivePacket(void)
 {
-    if (server->hasData()) {
+    bool data_received = false;
+    while (server->hasData()) {
         isConnected = true;
+        data_received = true;
 
         // TODO: think about redesign or drop class MeshPacketServer
         meshtastic_ToRadio *mr;
@@ -51,9 +53,8 @@ bool PacketAPI::receivePacket(void)
             LOG_ERROR("Error: unhandled meshtastic_ToRadio variant: %d\n", mr->which_payload_variant);
             break;
         }
-        return true;
-    } else
-        return false;
+    }
+    return data_received;
 }
 
 bool PacketAPI::sendPacket(void)
@@ -61,11 +62,13 @@ bool PacketAPI::sendPacket(void)
     // fill dummy buffer; we don't use it, we directly send the fromRadio structure
     uint32_t len = getFromRadio(txBuf);
     if (len != 0) {
+        static uint32_t id = 0;
+        fromRadioScratch.id = ++id;
         // TODO: think about redesign or drop class MeshPacketServer
         // if (typeid(*server) == typeid(MeshPacketServer))
         //    return dynamic_cast<MeshPacketServer*>(server)->sendPacket(fromRadioScratch);
         // else
-        return server->sendPacket(DataPacket<meshtastic_FromRadio>(fromRadioScratch.id, fromRadioScratch));
+        return server->sendPacket(DataPacket<meshtastic_FromRadio>(id, fromRadioScratch));
     } else
         return false;
 }

src/mesh/sharedMem/PacketClient.cpp

@@ -1,57 +0,0 @@
-#include "sharedMem/PacketClient.h"
-#include "DebugConfiguration.h"
-#include "sharedMem/SharedQueue.h"
-#include <assert.h>
-
-const uint32_t max_packet_queue_size = 10;
-
-PacketClient *packetClient = nullptr;
-
-void PacketClient::init(void)
-{
-    // for now we hard-code (only) one client task, but in principle one could
-    // create as many PacketServer/PacketClient pairs as desired.
-    packetClient = new PacketClient();
-    packetClient->connect(sharedQueue);
-}
-
-PacketClient::PacketClient() : queue(nullptr) {}
-
-int PacketClient::connect(SharedQueue *_queue)
-{
-    if (!queue) {
-        queue = _queue;
-    } else if (_queue != queue) {
-        LOG_WARN("Client already connected.");
-    }
-    return queue->serverQueueSize();
-}
-
-Packet::PacketPtr PacketClient::receivePacket()
-{
-    assert(queue);
-    if (queue->serverQueueSize() == 0)
-        return {nullptr};
-    return queue->clientReceive();
-}
-
-bool PacketClient::sendPacket(Packet &&p)
-{
-    assert(queue);
-    if (queue->clientQueueSize() >= max_packet_queue_size)
-        return false;
-    queue->clientSend(std::move(p));
-    return true;
-}
-
-bool PacketClient::hasData() const
-{
-    assert(queue);
-    return queue->serverQueueSize() > 0;
-}
-
-bool PacketClient::available() const
-{
-    assert(queue);
-    return queue->clientQueueSize() < max_packet_queue_size;
-}

src/mesh/sharedMem/PacketClient.h

@@ -1,27 +0,0 @@
-#pragma once
-
-#include "Packet.h"
-
-class SharedQueue;
-
-/**
- * @brief Generic client implementation to receive from and
- *        send packets to the shared queue
- *
- */
-class PacketClient
-{
-  public:
-    PacketClient();
-    static void init(void);
-    virtual int connect(SharedQueue *_queue);
-    virtual bool sendPacket(Packet &&p);
-    virtual Packet::PacketPtr receivePacket();
-    virtual bool hasData() const;
-    virtual bool available() const;
-
-  private:
-    SharedQueue *queue;
-};
-
-extern PacketClient *packetClient;

src/mesh/sharedMem/PacketServer.cpp

@@ -11,7 +11,6 @@ void PacketServer::begin(SharedQueue *_queue)
     queue = _queue;
 }
 
-#if 1
 Packet::PacketPtr PacketServer::receivePacket(void)
 {
     assert(queue);
@@ -19,21 +18,13 @@ Packet::PacketPtr PacketServer::receivePacket(void)
         return {nullptr};
     return queue->serverReceive();
 }
-#else // template variant with typed return values
-template <> Packet::PacketPtr PacketServer::receivePacket<Packet::PacketPtr>()
-{
-    assert(queue);
-    if (queue->clientQueueSize() == 0)
-        return {nullptr};
-    return queue->serverReceive();
-}
-#endif
 
 bool PacketServer::sendPacket(Packet &&p)
 {
     assert(queue);
-    if (queue->serverQueueSize() >= max_packet_queue_size)
+    if (queue->serverQueueSize() >= max_packet_queue_size) {
         return false;
+    }
     queue->serverSend(std::move(p));
     return true;
 }

src/mesh/sharedMem/PacketServer.h

@@ -15,7 +15,9 @@ class PacketServer
     PacketServer();
     virtual void begin(SharedQueue *_queue);
     virtual bool sendPacket(Packet &&p);
-    virtual Packet::PacketPtr receivePacket();
+    virtual Packet::PacketPtr receivePacket(void);
+    // template variant with typed return values
+    // template<> Packet::PacketPtr receivePacket<Packet::PacketPtr>()
     // template<typename T> T receivePacket();
     virtual bool hasData() const;
     virtual bool available() const;

variants/t-deck/platformio.ini

@@ -6,7 +6,6 @@ board_check = true
 upload_protocol = esptool
 #upload_port = COM29
 
-build_src_filter = ${esp32_base.build_src_filter} +<mesh/sharedMem/>
 build_flags = ${esp32_base.build_flags} 
   -DT_DECK 
   -DBOARD_HAS_PSRAM