More PABB2 iteration.

Author: Mysticial

Common/PABotBase2/PABotBase2CC_MessageDumper.cpp

@@ -373,6 +373,17 @@ MessageLogger::MessageLogger(){
             return str;
         }
     );
+    add_message<Message_u32>(
+        "PABB2_MESSAGE_OPCODE_SET_LOGGING_FLAG",
+        PABB2_MESSAGE_OPCODE_SET_LOGGING_FLAG,
+        true,
+        [](const Message_u32* message){
+            std::string str;
+            str += "id = " + std::to_string(message->id);
+            str += ", flag = " + tostr_hex(message->data);
+            return str;
+        }
+    );
     add_message<MessageHeader>(
         "PABB2_MESSAGE_OPCODE_CQ_CAPACITY",
         PABB2_MESSAGE_OPCODE_CQ_CAPACITY,

Common/PABotBase2/ReliableConnectionLayer/PABotBase2FW_ReliableStreamConnection.cpp

@@ -9,6 +9,10 @@
 #include "PABotBase2_ConnectionDebug.h"
 #include "PABotBase2FW_ReliableStreamConnection.h"
 
+#ifdef PABB2_SUPPORTS_PRINTF_LOGGING
+#include <stdio.h>
+#endif
+
 //#include <iostream>
 //using std::cout;
 //using std::endl;
@@ -35,6 +39,9 @@ ReliableStreamConnectionFW::ReliableStreamConnectionFW(UnreliableStreamConnectio
 bool ReliableStreamConnectionFW::enqueue_uncommitted_reliable_sends(const void* data, size_t bytes) noexcept{
     if (!m_stream_ready){
         m_reliable_sender.send_oob_packet_empty(0, PABB2_CONNECTION_OPCODE_INFO_STREAM_NOT_READY);
+#ifdef PABB2_SUPPORTS_PRINTF_LOGGING
+        printf("Stream not ready...\n");
+#endif
         return false;
     }
     if (m_reliable_sender.enqueue_uncommitted_send_stream(data, bytes)){
@@ -44,6 +51,9 @@ bool ReliableStreamConnectionFW::enqueue_uncommitted_reliable_sends(const void*
     if (!m_send_is_currently_full){
         m_send_is_currently_full = true;
         m_reliable_sender.send_oob_packet_empty(0, PABB2_CONNECTION_OPCODE_INFO_STREAM_SEND_FULL);
+#ifdef PABB2_SUPPORTS_PRINTF_LOGGING
+        printf("Send stream is full...\n");
+#endif
     }
     return false;
 }
@@ -103,28 +113,28 @@ bool ReliableStreamConnectionFW::run_recv_events(const WallDuration& timeout){
         ? POLL_RATE
         : timeout;
 
-    const PacketHeader* packet = m_parser.pull_bytes(m_unreliable_connection, adjusted_timeout);
-    if (packet == nullptr){
+    const PacketHeader* header = m_parser.pull_bytes(m_unreliable_connection, adjusted_timeout);
+    if (header == nullptr){
         return false;
     }
 
     m_packets_received++;
 
     //  Check the packet status.
-    switch (packet->magic_number){
+    switch (header->magic_number){
     case PABB2_PacketParser_RESULT_VALID:
         break;
     case PABB2_PacketParser_RESULT_INVALID:
 //        printf("PABB2_PacketParser_RESULT_INVALID\n");
         m_reliable_sender.send_oob_packet_empty(
-            packet->seqnum,
+            header->seqnum,
             PABB2_CONNECTION_OPCODE_INVALID_LENGTH
         );
         return true;
     case PABB2_PacketParser_RESULT_CHECKSUM_FAIL:
 //        printf("PABB2_PacketParser_RESULT_CHECKSUM_FAIL\n");
         m_reliable_sender.send_oob_packet_empty(
-            packet->seqnum,
+            header->seqnum,
             PABB2_CONNECTION_OPCODE_INVALID_CHECKSUM_FAIL
         );
 //        cout << "CRC error:";
@@ -138,74 +148,76 @@ bool ReliableStreamConnectionFW::run_recv_events(const WallDuration& timeout){
 //    printf("Device Received: %d\n", packet->opcode);
 
     //  Now handle the different opcodes.
-    uint8_t opcode = packet->opcode & PABB2_CONNECTION_OPCODE_MASK;
+    uint8_t opcode = header->opcode & PABB2_CONNECTION_OPCODE_MASK;
     switch (opcode){
     case PABB2_CONNECTION_OPCODE_ASK_RESET:
-        m_reliable_sender.send_oob_packet_empty(
-            packet->seqnum,
-            PABB2_CONNECTION_OPCODE_RET_RESET
-        );
+        m_stream_ready = false;
+        m_send_is_currently_full = false;
         m_reliable_sender.reset();
         m_parser.reset();
         m_stream_coalescer.reset();
         m_stream_coalescer.push_packet(0);
+        m_reliable_sender.send_oob_packet_empty(
+            header->seqnum,
+            PABB2_CONNECTION_OPCODE_RET_RESET
+        );
 #ifdef PABB2_ENABLE
         issue_reset_to_all();
 #endif
-        m_stream_ready = false;
         return true;
     case PABB2_CONNECTION_OPCODE_ASK_VERSION:
-        m_stream_coalescer.push_packet(packet->seqnum);
+        m_stream_coalescer.push_packet(header->seqnum);
         m_reliable_sender.send_oob_packet_u32(
-            packet->seqnum,
+            header->seqnum,
             PABB2_CONNECTION_OPCODE_RET_VERSION,
             PABB2_CONNECTION_PROTOCOL_VERSION
         );
         return true;
     case PABB2_CONNECTION_OPCODE_ASK_PACKET_SIZE:
-        m_stream_coalescer.push_packet(packet->seqnum);
+        m_stream_coalescer.push_packet(header->seqnum);
         m_reliable_sender.send_oob_packet_u16(
-            packet->seqnum,
+            header->seqnum,
             PABB2_CONNECTION_OPCODE_RET_PACKET_SIZE,
             PABB2_MAX_INCOMING_PACKET_SIZE
         );
         return true;
     case PABB2_CONNECTION_OPCODE_ASK_BUFFER_SLOTS:
-        m_stream_coalescer.push_packet(packet->seqnum);
+        m_stream_coalescer.push_packet(header->seqnum);
         m_reliable_sender.send_oob_packet_u8(
-            packet->seqnum,
+            header->seqnum,
             PABB2_CONNECTION_OPCODE_RET_BUFFER_SLOTS,
             PABB2_StreamCoalescer_SLOTS
         );
         return true;
     case PABB2_CONNECTION_OPCODE_ASK_BUFFER_BYTES:
-        m_stream_coalescer.push_packet(packet->seqnum);
+        m_stream_coalescer.push_packet(header->seqnum);
         m_reliable_sender.send_oob_packet_u16(
-            packet->seqnum,
+            header->seqnum,
             PABB2_CONNECTION_OPCODE_RET_BUFFER_BYTES,
             PABB2_StreamCoalescer_BUFFER_SIZE
         );
         return true;
+
     case PABB2_CONNECTION_OPCODE_ASK_STREAM_DATA:
         m_stream_ready = true;
-        if (!m_stream_coalescer.push_stream((const PacketHeaderData*)packet)){
+        if (!m_stream_coalescer.push_stream((const PacketHeaderData*)header)){
             send_oob_info_label_u32("Push Stream Failed", m_stream_coalescer.free_bytes());
             return true;
         }
         m_reliable_sender.send_oob_packet_u16(
-            packet->seqnum,
+            header->seqnum,
             PABB2_CONNECTION_OPCODE_RET_STREAM_DATA,
             m_stream_coalescer.free_bytes()
         );
         return true;
     case PABB2_CONNECTION_OPCODE_RET_STREAM_DATA:
-        m_reliable_sender.remove(packet->seqnum);
+        m_reliable_sender.remove(header->seqnum);
         return true;
     default:
         m_reliable_sender.send_oob_packet_u8(
-            packet->seqnum,
+            header->seqnum,
             PABB2_CONNECTION_OPCODE_UNKNOWN_OPCODE,
-            packet->opcode
+            header->opcode
         );
     }
 

Common/PABotBase2/ReliableConnectionLayer/PABotBase2FW_ReliableStreamConnection.h

@@ -44,6 +44,7 @@ class ReliableStreamConnectionFW final
         return m_reliable_sender.slots_used() != 0;
     }
 
+
 public:
     virtual bool enqueue_uncommitted_reliable_sends(const void* data, size_t bytes) noexcept override;
     virtual void abort_uncommitted_reliable_sends() noexcept override;

Common/PABotBase2/ReliableConnectionLayer/PABotBase2_ConnectionDebug.cpp

@@ -132,6 +132,7 @@ void StreamCoalescer::print(bool ascii) const{
     std::cout << "---- StreamCoalescer ---- (Start)" << std::endl;
     std::cout << "Slot Head:         " << (int)m_slot_head << std::endl;
     std::cout << "Slot Tail:         " << (int)m_slot_tail << std::endl;
+    std::cout << "Stream Free:       " << m_stream_free << std::endl;
     std::cout << "Stream Head:       " << m_stream_head << std::endl;
     std::cout << "Stream Tail:       " << m_stream_tail << std::endl;
     for (uint8_t seqnum = m_slot_head; seqnum != m_slot_tail; seqnum++){
@@ -142,13 +143,13 @@ void StreamCoalescer::print(bool ascii) const{
             std::cout << std::endl;
             continue;
         }
-        if (size == 255){
+        if (size == 0xff){
             std::cout << " non-stream" << std::endl;
             continue;
         }
 
-        uint16_t offset_s = m_offsets[index];
-        uint16_t offset_e = offset_s + size;
+        uint16_t offset_e = m_end_offsets[index];
+        uint16_t offset_s = offset_e - size;
         std::cout << "[" << offset_s << ":" << offset_e << "] => ";
 
         offset_s &= BUFFER_MASK;

Common/PABotBase2/ReliableConnectionLayer/PABotBase2_PacketSender.cpp

@@ -139,10 +139,12 @@ bool PacketSender::remove(uint8_t seqnum){
 //        cout << "PacketSender::remove(" << this << "): " << (int)seqnum << endl;
 //    }
 
-    //  Seqnum is out of range.
+    //  Too far in the future.
     if ((uint8_t)(seqnum - m_slot_head) >= SLOTS){
         return false;
     }
+
+    //  Too far in the past.
     if ((uint8_t)(m_slot_tail - seqnum) > SLOTS){
         return false;
     }