Added timeliner

Author: Tails86

src/coreLib/TransmissionScheduler.cpp

@@ -72,24 +72,13 @@ uint32_t TransmissionScheduler::add(uint8_t priority,
 std::shared_ptr<const TransmissionScheduler::Transmission> TransmissionScheduler::popNext(uint64_t time)
 {
     std::shared_ptr<Transmission> item = nullptr;
+
     if (!mSchedule.empty())
     {
         if (time >= (*mSchedule.begin())->nextTxTimeUs)
         {
             item = (*mSchedule.begin());
             mSchedule.erase(mSchedule.begin());
-            if (item->autoRepeatUs > 0)
-            {
-                // Determine how many intervals to add in cast this auto reload packet has overflowed
-                uint32_t n = INT_DIVIDE_CEILING(time - item->nextTxTimeUs, item->autoRepeatUs);
-                if (n == 0)
-                {
-                    n = 1;
-                }
-                // Reinsert it back into the schedule with a new time
-                item->nextTxTimeUs += (item->autoRepeatUs * n);
-                add(item);
-            }
         }
         else
         {
@@ -117,7 +106,21 @@ std::shared_ptr<const TransmissionScheduler::Transmission> TransmissionScheduler
                 ++iter;
             }
         }
+
+        if (item != nullptr && item->autoRepeatUs > 0)
+        {
+            // Determine how many intervals to add in cast this auto reload packet has overflowed
+            uint32_t n = INT_DIVIDE_CEILING(time - item->nextTxTimeUs, item->autoRepeatUs);
+            if (n == 0)
+            {
+                n = 1;
+            }
+            // Reinsert it back into the schedule with a new time
+            item->nextTxTimeUs += (item->autoRepeatUs * n);
+            add(item);
+        }
     }
+
     return item;
 }
 

src/coreLib/TransmissionScheduler.hpp

@@ -18,7 +18,7 @@ class TransmissionScheduler
         const uint32_t autoRepeatUs;
         const uint32_t txDurationUs;
         uint64_t nextTxTimeUs;
-        const std::shared_ptr<MaplePacket> packet;
+        std::shared_ptr<const MaplePacket> packet;
 
         Transmission(uint32_t transmissionId,
                      bool priority,

src/coreLib/TransmissionTimeliner.cpp

@@ -0,0 +1,33 @@
+#include "TransmissionTimeliner.hpp"
+#include <assert.h>
+
+TransmissionTimeliner::TransmissionTimeliner(MapleBusInterface& bus, TransmissionScheduler& schedule):
+    mBus(bus), mSchedule(schedule), mNextTx(nullptr)
+{}
+
+uint32_t TransmissionTimeliner::recipientDisconnect(uint8_t recipientAddr)
+{
+    return mSchedule.cancelByRecipient(recipientAddr);
+}
+
+std::shared_ptr<const MaplePacket> TransmissionTimeliner::task(uint64_t time)
+{
+    std::shared_ptr<const MaplePacket> pkt = nullptr;
+
+    if (mNextTx == nullptr)
+    {
+        mNextTx = mSchedule.popNext(time);
+    }
+
+    if (mNextTx != nullptr)
+    {
+        pkt = mNextTx->packet;
+        assert(pkt->isValid());
+        if (mBus.write(*pkt, mNextTx->expectResponse, mNextTx->readTimeoutUs))
+        {
+            mNextTx = nullptr;
+        }
+    }
+
+    return pkt;
+}

src/coreLib/TransmissionTimeliner.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "MaplePacket.hpp"
+#include "MapleBusInterface.hpp"
+#include "TransmissionScheduler.hpp"
+
+class TransmissionTimeliner
+{
+
+public:
+    TransmissionTimeliner(MapleBusInterface& bus, TransmissionScheduler& schedule);
+
+    uint32_t recipientDisconnect(uint8_t recipientAddr);
+
+    std::shared_ptr<const MaplePacket> task(uint64_t time);
+
+protected:
+    MapleBusInterface& mBus;
+    TransmissionScheduler& mSchedule;
+    std::shared_ptr<const TransmissionScheduler::Transmission> mNextTx;
+};

src/test/TransmissionSchedulerTests.cpp

@@ -388,6 +388,7 @@ class TransmissionSchedulePopTestB : public TransmissionScheduleTest
             txTime = 2;
             expectedResponseNumPayloadWords = 3; // 267 us
             MaplePacket packet2(0x33, 0x02, 0x99887766);
+            autoRepeatUs = 1111;
             scheduler.add(priority,
                           txTime,
                           packet2,
@@ -404,6 +405,11 @@ TEST_F(TransmissionSchedulePopTestB, popTestAutoReload2)
     std::shared_ptr<const TransmissionScheduler::Transmission> item = scheduler.popNext(2);
     ASSERT_NE(item, nullptr);
     EXPECT_EQ(item->transmissionId, 2);
+    EXPECT_EQ(item->nextTxTimeUs, 1113);
+
+    // Transmission should auto reload
+    const std::list<std::shared_ptr<TransmissionScheduler::Transmission>> schedule = scheduler.getSchedule();
+    ASSERT_EQ(schedule.size(), 3);
 }
 
 class TransmissionScheduleCancelTest : public TransmissionSchedulePopTestA