Refactor for ESP32.

Author: Mysticial

ClientSource/Connection/PABotBase.cpp

@@ -563,7 +563,7 @@ uint64_t PABotBase::try_issue_request(
     if (message.body.size() < sizeof(uint32_t)){
         throw InternalProgramError(&m_logger, PA_CURRENT_FUNCTION, "Message is too short.");
     }
-    if (message.body.size() > PABB_MAX_MESSAGE_SIZE){
+    if (message.body.size() > MAX_MESSAGE_SIZE){
         throw InternalProgramError(&m_logger, PA_CURRENT_FUNCTION, "Message is too long.");
     }
 
@@ -628,7 +628,7 @@ uint64_t PABotBase::try_issue_command(
     if (message.body.size() < sizeof(uint32_t)){
         throw InternalProgramError(&m_logger, PA_CURRENT_FUNCTION, "Message is too short.");
     }
-    if (message.body.size() > PABB_MAX_MESSAGE_SIZE){
+    if (message.body.size() > MAX_MESSAGE_SIZE){
         throw InternalProgramError(&m_logger, PA_CURRENT_FUNCTION, "Message is too long.");
     }
 

ClientSource/Connection/PABotBaseConnection.cpp

@@ -11,9 +11,9 @@
 #include "BotBaseMessage.h"
 #include "PABotBaseConnection.h"
 
-#include <iostream>
-using std::cout;
-using std::endl;
+//#include <iostream>
+//using std::cout;
+//using std::endl;
 
 namespace PokemonAutomation{
 
@@ -67,7 +67,7 @@ void PABotBaseConnection::send_message(const BotBaseMessage& message, bool is_re
     m_sniffer->on_send(message, is_retransmit);
 
     size_t total_bytes = PABB_PROTOCOL_OVERHEAD + message.body.size();
-    if (total_bytes > PABB_MAX_PACKET_SIZE){
+    if (total_bytes > MAX_MESSAGE_SIZE){
         throw InternalProgramError(&m_logger, PA_CURRENT_FUNCTION, "Message is too long.");
     }
 
@@ -105,7 +105,7 @@ void PABotBaseConnection::on_recv(const void* data, size_t bytes){
         }
 
         //  Message is too long.
-        if (length > PABB_MAX_PACKET_SIZE){
+        if (length > MAX_MESSAGE_SIZE){
             m_sniffer->log("Message is too long: bytes = " + std::to_string(length));
             m_recv_buffer.pop_front();
             continue;

ClientSource/Connection/PABotBaseConnection.h

@@ -27,14 +27,17 @@ namespace PokemonAutomation{
 //  None the functions in this class are thread-safe. It is up to
 //  the child class to wrap and make them thread-safe.
 class PABotBaseConnection : public StreamListener{
+public:
+    static const size_t MAX_MESSAGE_SIZE = 64;
+
 public:
     PABotBaseConnection(Logger& logger, std::unique_ptr<StreamConnection> connection);
     virtual ~PABotBaseConnection();
 
     void set_sniffer(MessageSniffer* sniffer);
 
 public:
-    void send_zeros(uint8_t bytes = PABB_MAX_PACKET_SIZE);
+    void send_zeros(uint8_t bytes = MAX_MESSAGE_SIZE);
     void send_message(const BotBaseMessage& message, bool is_retransmit);
 
 protected:

Common/Microcontroller/MessageProtocol.h

@@ -172,6 +172,8 @@
 #define PABB_BAUD_RATE                  115200
 #define PABB_RETRANSMIT_DELAY_MILLIS    80
 
+//  This limit of 12 is only for AVR8. ESP32 will go much larger. So we ignore
+//  this number and allow large messages on the computer side.
 #define PABB_MAX_MESSAGE_SIZE           12
 #define PABB_PROTOCOL_OVERHEAD          (2 + sizeof(uint32_t))
 #define PABB_MAX_PACKET_SIZE            (PABB_MAX_MESSAGE_SIZE + PABB_PROTOCOL_OVERHEAD)

SerialPrograms/Source/Controllers/SerialPABotBase/SerialPABotBase_Descriptor.cpp

@@ -10,7 +10,8 @@
 #include "SerialPABotBase_Descriptor.h"
 #include "SerialPABotBase_SelectorWidget.h"
 
-#include "NintendoSwitch/Controllers/NintendoSwitch_ProController_SerialPABotBase.h"
+#include "NintendoSwitch/Controllers/SerialPABotBase/NintendoSwitch_PokkenController.h"
+#include "NintendoSwitch/Controllers/SerialPABotBase/NintendoSwitch_WirelessProController.h"
 
 //#include <iostream>
 //using std::cout;
@@ -67,11 +68,18 @@ std::unique_ptr<AbstractController> SerialPABotBase_Descriptor::make_controller(
 ) const{
     switch (controller_type){
     case ControllerType::NintendoSwitch_WiredProController:
+        return std::unique_ptr<AbstractController>(
+            new NintendoSwitch::SerialPABotBase_PokkenController(
+                logger,
+                static_cast<SerialPABotBase_Connection&>(connection),
+                requirements
+            )
+        );
+
     case ControllerType::NintendoSwitch_WirelessProController:
         return std::unique_ptr<AbstractController>(
-            new NintendoSwitch::ProController_SerialPABotBase(
+            new NintendoSwitch::SerialPABotBase_WirelessProController(
                 logger,
-                controller_type,
                 static_cast<SerialPABotBase_Connection&>(connection),
                 requirements
             )

SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_ProControllerWithScheduler.h

@@ -11,7 +11,6 @@
 #define PokemonAutomation_NintendoSwitch_ControllerWithScheduler_H
 
 #include <mutex>
-#include "Common/Cpp/Concurrency/SpinLock.h"
 #include "Controllers/SuperscalarScheduler.h"
 #include "NintendoSwitch_ProController.h"
 
@@ -38,6 +37,35 @@ struct ProControllerSchedulerState{
 };
 
 
+struct SplitDpad{
+    bool up = false;
+    bool right = false;
+    bool down = false;
+    bool left = false;
+};
+inline SplitDpad convert_unified_to_split_dpad(DpadPosition dpad){
+    switch (dpad){
+    case DpadPosition::DPAD_UP:
+        return {true, false, false, false};
+    case DpadPosition::DPAD_UP_RIGHT:
+        return {true, true, false, false};
+    case DpadPosition::DPAD_RIGHT:
+        return {false, true, false, false};
+    case DpadPosition::DPAD_DOWN_RIGHT:
+        return {false, true, true, false};
+    case DpadPosition::DPAD_DOWN:
+        return {false, false, true, false};
+    case DpadPosition::DPAD_DOWN_LEFT:
+        return {false, false, true, true};
+    case DpadPosition::DPAD_LEFT:
+        return {false, false, false, true};
+    case DpadPosition::DPAD_UP_LEFT:
+        return {true, false, false, true};
+    default:
+        return {false, false, false, false};
+    }
+}
+
 
 
 

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

@@ -0,0 +1,96 @@
+/*  Pokken Controller
+ *
+ *  From: https://github.com/PokemonAutomation/Arduino-Source
+ *
+ */
+
+#include "Common/Cpp/Exceptions.h"
+#include "Common/Cpp/Concurrency/ReverseLockGuard.h"
+#include "Controllers/ControllerCapability.h"
+#include "NintendoSwitch/Commands/NintendoSwitch_Messages_PushButtons.h"
+#include "NintendoSwitch_PokkenController.h"
+
+//#include <iostream>
+//using std::cout;
+//using std::endl;
+
+namespace PokemonAutomation{
+namespace NintendoSwitch{
+
+using namespace std::chrono_literals;
+
+
+
+
+SerialPABotBase_PokkenController::SerialPABotBase_PokkenController(
+    Logger& logger,
+    SerialPABotBase::SerialPABotBase_Connection& connection,
+    const ControllerRequirements& requirements
+)
+    : SerialPABotBase_ProController(
+        logger,
+        ControllerType::NintendoSwitch_WiredProController,
+        connection,
+        requirements
+    )
+{}
+SerialPABotBase_PokkenController::~SerialPABotBase_PokkenController(){
+    stop();
+}
+
+void SerialPABotBase_PokkenController::push_state(const Cancellable* cancellable, WallDuration duration){
+    //  Must be called inside "m_state_lock".
+
+    if (!is_ready()){
+        throw InvalidConnectionStateException();
+    }
+
+    Button buttons = BUTTON_NONE;
+    for (size_t c = 0; c < 14; c++){
+        buttons |= m_buttons[c].is_busy()
+            ? (Button)((uint16_t)1 << c)
+            : BUTTON_NONE;
+    }
+
+    DpadPosition dpad = m_dpad.is_busy() ? m_dpad.position : DPAD_NONE;
+
+    uint8_t left_x = 128;
+    uint8_t left_y = 128;
+    uint8_t right_x = 128;
+    uint8_t right_y = 128;
+    if (m_left_joystick.is_busy()){
+        left_x = m_left_joystick.x;
+        left_y = m_left_joystick.y;
+    }
+    if (m_right_joystick.is_busy()){
+        right_x = m_right_joystick.x;
+        right_y = m_right_joystick.y;
+    }
+
+
+    //  Release the state lock since we are no longer touching state.
+    //  This loop can block indefinitely if the command queue is full.
+    ReverseLockGuard<std::mutex> lg(m_state_lock);
+
+    //  Divide the controller state into smaller chunks of 255 ticks.
+    Milliseconds time_left = std::chrono::duration_cast<Milliseconds>(duration);
+    while (time_left > Milliseconds::zero()){
+        Milliseconds current_ms = std::min(time_left, 255 * 8ms);
+        uint8_t current_ticks = (uint8_t)milliseconds_to_ticks_8ms(current_ms.count());
+        m_serial->issue_request(
+            DeviceRequest_controller_state(buttons, dpad, left_x, left_y, right_x, right_y, current_ticks),
+            cancellable
+        );
+        time_left -= current_ms;
+    }
+}
+
+
+
+
+
+
+
+
+}
+}

SerialPrograms/Source/NintendoSwitch/Controllers/SerialPABotBase/NintendoSwitch_PokkenController.h

@@ -0,0 +1,42 @@
+/*  Pokken Controller
+ *
+ *  From: https://github.com/PokemonAutomation/Arduino-Source
+ *
+ */
+
+#ifndef PokemonAutomation_NintendoSwitch_PokkenController_H
+#define PokemonAutomation_NintendoSwitch_PokkenController_H
+
+#include "NintendoSwitch_ProController.h"
+
+namespace PokemonAutomation{
+namespace NintendoSwitch{
+
+
+class SerialPABotBase_PokkenController final : public SerialPABotBase_ProController{
+public:
+    using ContextType = ProControllerContext;
+
+public:
+    SerialPABotBase_PokkenController(
+        Logger& logger,
+        SerialPABotBase::SerialPABotBase_Connection& connection,
+        const ControllerRequirements& requirements
+    );
+    ~SerialPABotBase_PokkenController();
+
+
+private:
+    template <typename Type>
+    PA_FORCE_INLINE Type milliseconds_to_ticks_8ms(Type milliseconds){
+        return milliseconds / 8 + (milliseconds % 8 + 7) / 8;
+    }
+    virtual void push_state(const Cancellable* cancellable, WallDuration duration) override;
+};
+
+
+
+
+}
+}
+#endif