Status updates for AVR and ESP32-S3.

Author: Mysticial

Common/SerialPABotBase/SerialPABotBase_Messages_ESP32.h

@@ -60,14 +60,6 @@ typedef struct{
 
 
 
-
-#define PABB_MSG_ESP32_REQUEST_STATUS   0x50
-typedef struct{
-    seqnum_t seqnum;
-} PABB_PACK pabb_Message_ESP32_RequestStatus;
-
-
-
 #define PABB_MSG_ESP32_REQUEST_READ_SPI         0x60
 typedef struct{
     seqnum_t seqnum;

Common/SerialPABotBase/SerialPABotBase_Protocol.h

@@ -1,122 +1,122 @@
 /*  Serial PABotBase Message Protocol
- * 
+ *
  *  From: https://github.com/PokemonAutomation/
  *
  *
  *      Pokemon Automation Bot-Base implements reliable data transmissions over
  *  serial communication. This is done by checksumming messages along with a
  *  protocol that is tolerant to data drops.
- * 
+ *
  *  This file describes the message protocol. The data being transmitted is raw
  *  binary and not is readable text.
- * 
- * 
+ *
+ *
  *  Message Format:
  *      byte 0: Length of the entire message. (bits are inverted)
  *      byte 1: Message Type
  *      byte X: Optional data of variable length.
  *      Last 4 bytes: CRC32C of the entire message except these last 4 bytes.
- * 
+ *
  *      Thus there are 6 bytes of overhead for each message.
- * 
- * 
+ *
+ *
  *  There are currently 4 categories of message types:
- * 
+ *
  *      1.  Info: These are simple one-way messages. They do not need to be
  *          acked and may be dropped without adversely affecting anything.
- * 
+ *
  *      2.  Ack/Response: These are messages sent in response to an earlier
  *          message that was received.
- * 
+ *
  *      3.  Request: The sender requests the receiver to do something simple.
  *          The receiver must respond with an ack.
- * 
+ *
  *          This is used for things that take no clock time. For example, querying
  *          for program identifiers, turning on/off LEDs, or setting flags in the
  *          program to change its behavior in the future.
- * 
+ *
  *      4.  Command: The sender requests the receiver to do a large asynchronous
  *          operation. The receiver must ack this message. Once the command is
  *          finished, the receiver must send a request message back to the sender
  *          to indicate that the command is finished.
- * 
+ *
  *          This is used for issuing button presses or other subroutines that
  *          consume time.
- * 
- * 
+ *
+ *
  *  General Protocol:
- * 
+ *
  *      1.  Every time you send a new request/command message, you increment
  *          your sequence number (seqnum) by 1.
- * 
+ *
  *      2.  If you receive an invalid message (bad length or bad checksum), ignore
  *          the first byte and attempt to parse the next byte as the start of a
  *          new message.
- * 
+ *
  *      3.  If you receive a zero for the 1st byte of a message, ignore it and
  *          attempt to parse the next byte as the start of a new message.
- * 
+ *
  *      4.  At any point, you can send a bunch of zero bytes. This will cause
  *          the receiver to re-synchronize.
- * 
+ *
  *      5.  If you receive a request/command message, you must send the appropriate
  *          ack/response message using the same seqnum.
- * 
+ *
  *      6.  If you receive a command message, you must first ack the message itself.
  *          Once the command is finished, you must send a request referencing the
  *          command to indicate that it is finished. You will receive an ack for
  *          this short (finishing) command, and if you don't, send it again until
  *          you do. If the command finishes immediately, you can skip the ack and
  *          just send the finish request.
- * 
+ *
  *      7.  If you send a request/command message and don't get a response after
  *          a time limit, you should resend the message with the same seqnum.
- * 
+ *
  *      8.  If you receive a request/command that has a seqnum ahead of what you
  *          are expecting, it means an earlier request/command was dropped.
  *          Do not process the request/command since you will lose ordering.
- * 
+ *
  *      9.  If you receive a request/command that has an old seqnum, it is a
  *          retransmit. Send an ack for it, but don't process it again. (idempotency)
- * 
- * 
+ *
+ *
  *  Failure Analysis:
- * 
+ *
  *      -   Corrupted messages will either fail checksum or will have an invalid
  *          length/type. These are simply ignored and dropped.
- * 
+ *
  *      -   If either sender or receiver gets out-of-sync and loses track of
  *          message boundaries, it will eventually find the boundary again by
  *          simply trying to parse every byte as the start of a new message and
  *          verifying the length and CRC.
- * 
+ *
  *      -   If a request/command is dropped, no ack will be received. The sender
  *          will eventually send the command again. (#7)
- * 
+ *
  *      -   If an ack is dropped, the sender will eventually resend the
  *          request/command again. The receiver will see the duplicate
  *          request/command and ack it. But the receiver will not process it
  *          again to preserve idempotency. (#9)
- * 
+ *
  *  The current protocol guarantees that all commands are processed in order
  *  exactly once. Requests are not guaranteed to process in order and may execute
  *  more than once so they should be idempotent.
- * 
+ *
  *  The protocol also allows both sides to queue up requests and commands.
  *  In other words, it is possible to send multiple requests/commands at once
  *  without waiting for the individual acks.
- * 
- * 
+ *
+ *
  *  PABotBase Specifics:
  *
- *      -   PABotBase can queue 4 commands. Some implementations can handle
- *          more. If it receives any commands while the queue is full, it drops
- *          it and responds with "PABB_MSG_ERROR_COMMAND_DROPPED".
- *          (Any command that results in a button press or a wait is a long command.)
- * 
+ *      -   PABotBase can queue up to 4 commands. If it receives any commands
+ *          while the queue is full, it drops it and responds with
+ *          "PABB_MSG_ERROR_COMMAND_DROPPED". (Any command that results in a
+ *          button press or a wait is a long command.)
+ *
  *      -   PABotBase can still handle other messages while it is running a long
  *          command.
- * 
+ *
  */
 
 #ifndef PokemonAutomation_SerialPABotBase_Protocol_H
@@ -208,6 +208,7 @@ typedef struct{
 
 ////////////////////////////////////////////////////////////////////////////////
 //  Ack
+
 #define PABB_MSG_ACK_COMMAND                    0x10
 typedef struct{
     seqnum_t seqnum;
@@ -265,6 +266,7 @@ typedef struct{
 
 ////////////////////////////////////////////////////////////////////////////////
 //  Requests
+
 #define PABB_MSG_SEQNUM_RESET                   0x40
 //  After you send this message, the next seqnum you should use is (seqnum + 1).
 typedef struct{
@@ -325,6 +327,14 @@ typedef struct{
     uint32_t mode;
 } PABB_PACK pabb_MsgRequestChangeControllerMode;
 
+////////////////////////////////////////////////////////////////////////////////
+//  Common Requests
+
+#define PABB_MSG_REQUEST_STATUS   0x50
+typedef struct{
+    seqnum_t seqnum;
+} PABB_PACK pabb_Message_RequestStatus;
+
 ////////////////////////////////////////////////////////////////////////////////
 //  Commands
 

SerialPrograms/Source/Controllers/SerialPABotBase/SerialPABotBase.cpp

@@ -111,7 +111,7 @@ const std::map<
             }},
         }},
     }},
-    {2025061302, {
+    {2025061303, {
         {PABB_PID_PABOTBASE_ESP32S3, {
             {ControllerType::NintendoSwitch_WiredProController, {
                 ControllerFeature::TickPrecise,
@@ -121,7 +121,7 @@ const std::map<
             }},
         }},
     }},
-    {2025061402, {
+    {2025061403, {
         {PABB_PID_PABOTBASE_ArduinoUnoR3, {
             {ControllerType::NintendoSwitch_WiredProController, {
                 ControllerFeature::TickPrecise,

SerialPrograms/Source/Controllers/SerialPABotBase/SerialPABotBase_Routines_ESP32.cpp

@@ -17,16 +17,16 @@ namespace SerialPABotBase{
 
 int register_message_converters_ESP32(){
     register_message_converter(
-        PABB_MSG_ESP32_REQUEST_STATUS,
+        PABB_MSG_REQUEST_STATUS,
         [](const std::string& body){
             //  Disable this by default since it's very spammy.
             if (!GlobalSettings::instance().LOG_EVERYTHING){
                 return std::string();
             }
             std::ostringstream ss;
-            ss << "PABB_MSG_ESP32_REQUEST_STATUS() - ";
-            if (body.size() != sizeof(pabb_Message_ESP32_RequestStatus)){ ss << "(invalid size)" << std::endl; return ss.str(); }
-            const auto* params = (const pabb_Message_ESP32_RequestStatus*)body.c_str();
+            ss << "PABB_MSG_REQUEST_STATUS() - ";
+            if (body.size() != sizeof(pabb_Message_RequestStatus)){ ss << "(invalid size)" << std::endl; return ss.str(); }
+            const auto* params = (const pabb_Message_RequestStatus*)body.c_str();
             ss << "seqnum = " << (uint64_t)params->seqnum;
             return ss.str();
         }

SerialPrograms/Source/Controllers/SerialPABotBase/SerialPABotBase_Routines_ESP32.h

@@ -18,18 +18,6 @@ namespace SerialPABotBase{
 
 
 
-class MessageControllerStatus : public BotBaseRequest{
-public:
-    pabb_Message_ESP32_RequestStatus params;
-    MessageControllerStatus()
-        : BotBaseRequest(false)
-    {
-        params.seqnum = 0;
-    }
-    virtual BotBaseMessage message() const override{
-        return BotBaseMessage(PABB_MSG_ESP32_REQUEST_STATUS, params);
-    }
-};
 class MessageControllerReadSpi : public BotBaseRequest{
 public:
     pabb_Message_ESP32_ReadSpi params;

SerialPrograms/Source/Controllers/SerialPABotBase/SerialPABotBase_Routines_Protocol.h

@@ -126,6 +126,18 @@ class DeviceRequest_change_controller_mode : public BotBaseRequest{
         return BotBaseMessage(PABB_MSG_REQUEST_CHANGE_CONTROLLER_MODE, params);
     }
 };
+class MessageControllerStatus : public BotBaseRequest{
+public:
+    pabb_Message_RequestStatus params;
+    MessageControllerStatus()
+        : BotBaseRequest(false)
+    {
+        params.seqnum = 0;
+    }
+    virtual BotBaseMessage message() const override{
+        return BotBaseMessage(PABB_MSG_REQUEST_STATUS, params);
+    }
+};
 
 
 

SerialPrograms/Source/NintendoSwitch/Controllers/SerialPABotBase/NintendoSwitch_SerialPABotBase_PokkenController.cpp

@@ -354,19 +354,45 @@ void SerialPABotBase_PokkenController::status_thread(){
 
         std::string error;
         try{
+            pabb_MsgAckRequestI32 response;
+            m_serial->issue_request_and_wait(
+                SerialPABotBase::MessageControllerStatus(),
+                &m_scope
+            ).convert<PABB_MSG_ACK_REQUEST_I32>(m_logger, response);
+            last_ack.store(current_time(), std::memory_order_relaxed);
+
+            uint32_t status = response.data;
+            bool status_connected = status & 1;
+            bool status_ready     = status & 2;
+
+            std::string str;
+            str += "Connected: " + (status_connected
+                ? html_color_text("Yes", theme_friendly_darkblue())
+                : html_color_text("No", COLOR_RED)
+            );
+            str += " - Ready: " + (status_ready
+                ? html_color_text("Yes", theme_friendly_darkblue())
+                : html_color_text("No", COLOR_RED)
+            );
+
+            m_handle.set_status_line1(str);
+
+
+#if 0
             pabb_MsgAckRequestI32 response;
             m_serial->issue_request_and_wait(
                 SerialPABotBase::DeviceRequest_system_clock(),
                 &m_scope
             ).convert<PABB_MSG_ACK_REQUEST_I32>(logger(), response);
             last_ack.store(current_time(), std::memory_order_relaxed);
+
             uint64_t wallclock = clock_tracker.push_short_value(response.data);
 //            double ticks_per_second = tick_rate_tracker.push_ticks(wallclock);
-
             m_handle.set_status_line1(
                 "Device Clock: " + tostr_u_commas(wallclock),
                 theme_friendly_darkblue()
             );
+#endif
 
 //            if (tick_rate_tracker.consecutive_off_readings() >= 10){
 //                error = "Tick rate is erratic. Arduino/Teensy is not reliable on Switch 2.";

SerialPrograms/Source/NintendoSwitch/Controllers/SerialPABotBase/NintendoSwitch_SerialPABotBase_WirelessController.cpp

@@ -7,6 +7,7 @@
 #include "Common/Cpp/PrettyPrint.h"
 #include "Common/Cpp/Concurrency/ReverseLockGuard.h"
 #include "CommonFramework/Options/Environment/ThemeSelectorOption.h"
+#include "Controllers/SerialPABotBase/SerialPABotBase_Routines_Protocol.h"
 #include "Controllers/SerialPABotBase/SerialPABotBase_Routines_ESP32.h"
 #include "NintendoSwitch/NintendoSwitch_Settings.h"
 #include "NintendoSwitch_SerialPABotBase_WirelessController.h"