Add ability to read the controller mode from the ESP32.

Mysticial · Mysticial · commit 9aec59c42e39 · 2025-03-04T23:21:22.000-08:00
diff --git a/Common/Microcontroller/DeviceRoutines.cpp b/Common/Microcontroller/DeviceRoutines.cpp
@@ -39,6 +39,13 @@ uint8_t program_id(BotBaseController& botbase){
     ).convert<PABB_MSG_ACK_REQUEST_I8>(botbase.logger(), response);
     return response.data;
 }
+uint32_t controller_mode(BotBaseController& botbase){
+    pabb_MsgAckRequestI32 response;
+    botbase.issue_request_and_wait(
+        DeviceRequest_controller_mode()
+    ).convert<PABB_MSG_ACK_REQUEST_I32>(botbase.logger(), response);
+    return response.data;
+}
 
 
 }
diff --git a/Common/Microcontroller/DeviceRoutines.h b/Common/Microcontroller/DeviceRoutines.h
@@ -18,6 +18,7 @@ uint32_t protocol_version(BotBaseController& botbase);
 uint32_t program_version(BotBaseController& botbase);
 uint8_t device_queue_size(BotBaseController& botbase);
 uint8_t program_id(BotBaseController& botbase);
+uint32_t controller_mode(BotBaseController& botbase);
 
 
 class DeviceRequest_seqnum_reset : public BotBaseRequest{
@@ -90,6 +91,16 @@ class DeviceRequest_program_id : public BotBaseRequest{
         return BotBaseMessage(PABB_MSG_REQUEST_PROGRAM_ID, params);
     }
 };
+class DeviceRequest_controller_mode : public BotBaseRequest{
+public:
+    pabb_MsgRequestControllerMode params;
+    DeviceRequest_controller_mode()
+        : BotBaseRequest(false)
+    {}
+    virtual BotBaseMessage message() const override{
+        return BotBaseMessage(PABB_MSG_REQUEST_CONTROLLER_MODE, params);
+    }
+};
 
 
 
diff --git a/Common/Microcontroller/MessageProtocol.h b/Common/Microcontroller/MessageProtocol.h
@@ -262,6 +262,15 @@ typedef struct{
     uint32_t data;
 } PABB_PACK pabb_MsgAckRequestI32;
 
+////////////////////////////////////////////////////////////////////////////////
+//  Custom Info
+
+#define PABB_MSG_INFO_I32                       0x20
+typedef struct{
+    uint8_t tag;
+    uint32_t data;
+} PABB_PACK pabb_MsgInfoI32;
+
 ////////////////////////////////////////////////////////////////////////////////
 //  Requests
 #define PABB_MSG_SEQNUM_RESET                   0x40
@@ -313,14 +322,10 @@ typedef struct{
     seqnum_t seqnum;
 } PABB_PACK pabb_MsgRequestQueueSize;
 
-////////////////////////////////////////////////////////////////////////////////
-//  Custom Info
-
-#define PABB_MSG_INFO_I32                       0x20
+#define PABB_MSG_REQUEST_CONTROLLER_MODE        0x49
 typedef struct{
-    uint8_t tag;
-    uint32_t data;
-} PABB_PACK pabb_MsgInfoI32;
+    seqnum_t seqnum;
+} PABB_PACK pabb_MsgRequestControllerMode;
 
 ////////////////////////////////////////////////////////////////////////////////
 //  Commands
diff --git a/Common/PokemonSwSh/PokemonProgramIDs.h b/Common/PokemonSwSh/PokemonProgramIDs.h
@@ -13,6 +13,11 @@
 #define PABB_PID_PABOTBASE_31KB                             0x09
 #define PABB_PID_PABOTBASE_ESP32                            0x10
 
+#define PABB_CID_NONE                                       0
+#define PABB_CID_NINTENDO_SWITCH_WIRED_PRO_CONTROLLER       1
+#define PABB_CID_NINTENDO_SWITCH_WIRELESS_PRO_CONTROLLER    2
+#define PABB_CID_NINTENDO_SWITCH_LEFT_JOYCON                3
+#define PABB_CID_NINTENDO_SWITCH_RIGHT_JOYCON               4
 
 
 #endif
diff --git a/SerialPrograms/Source/Controllers/ControllerConnection.cpp b/SerialPrograms/Source/Controllers/ControllerConnection.cpp
@@ -18,7 +18,7 @@ namespace PokemonAutomation{
 void ControllerConnection::add_status_listener(StatusListener& listener){
     m_status_listeners.add(listener);
     if (m_ready.load(std::memory_order_acquire)){
-        listener.post_connection_ready(*this, supported_controllers());
+        listener.post_connection_ready(*this, controller_mode_status());
     }
 }
 void ControllerConnection::remove_status_listener(StatusListener& listener){
@@ -51,17 +51,17 @@ void ControllerConnection::set_status_line1(const std::string& text, Color color
     }
     signal_status_text_changed(status_text());
 }
-void ControllerConnection::declare_ready(const std::map<ControllerType, std::set<ControllerFeature>>& controllers){
+void ControllerConnection::declare_ready(const ControllerModeStatus& mode_status){
     m_ready.store(true, std::memory_order_release);
-    signal_post_ready(controllers);
+    signal_post_ready(mode_status);
 }
 
 
 //void ControllerConnection::signal_pre_not_ready(){
 //    m_status_listeners.run_method_unique(&StatusListener::pre_connection_not_ready, *this);
 //}
-void ControllerConnection::signal_post_ready(const std::map<ControllerType, std::set<ControllerFeature>>& controllers){
-    m_status_listeners.run_method_unique(&StatusListener::post_connection_ready, *this, controllers);
+void ControllerConnection::signal_post_ready(const ControllerModeStatus& mode_status){
+    m_status_listeners.run_method_unique(&StatusListener::post_connection_ready, *this, mode_status);
 }
 void ControllerConnection::signal_status_text_changed(const std::string& text){
 //    cout << "m_status_listeners.size() = " << m_status_listeners.count_unique() << endl;
diff --git a/SerialPrograms/Source/Controllers/ControllerConnection.h b/SerialPrograms/Source/Controllers/ControllerConnection.h
@@ -15,13 +15,21 @@
 namespace PokemonAutomation{
 
 
+
+struct ControllerModeStatus{
+    ControllerType current_controller = ControllerType::None;
+    std::map<ControllerType, std::set<ControllerFeature>> supported_controllers;
+};
+
+
+
 class ControllerConnection{
 public:
     struct StatusListener{
 //        virtual void pre_connection_not_ready(ControllerConnection& connection){}
         virtual void post_connection_ready(
             ControllerConnection& connection,
-            const std::map<ControllerType, std::set<ControllerFeature>>& controllers
+            const ControllerModeStatus& mode_status
         ){}
         virtual void status_text_changed(
             ControllerConnection& connection, const std::string& text
@@ -41,7 +49,10 @@ class ControllerConnection{
     bool is_ready() const{ return m_ready.load(std::memory_order_acquire); }
     std::string status_text() const;
 
-    virtual std::map<ControllerType, std::set<ControllerFeature>> supported_controllers() const = 0;
+    //  Returns the current controller type and the list of supported controllers.
+    //  The current controller may be "None" if there is only one supported
+    //  controller since it is implied to be that.
+    virtual ControllerModeStatus controller_mode_status() const = 0;
 
 
 public:
@@ -50,12 +61,12 @@ class ControllerConnection{
 
 
 protected:
-    void declare_ready(const std::map<ControllerType, std::set<ControllerFeature>>& controllers);
+    void declare_ready(const ControllerModeStatus& mode_status);
 
 
 private:
 //    void signal_pre_not_ready();
-    void signal_post_ready(const std::map<ControllerType, std::set<ControllerFeature>>& controllers);
+    void signal_post_ready(const ControllerModeStatus& mode_status);
     void signal_status_text_changed(const std::string& text);
     void signal_error(const std::string& text);
 
diff --git a/SerialPrograms/Source/Controllers/ControllerSession.cpp b/SerialPrograms/Source/Controllers/ControllerSession.cpp
@@ -62,7 +62,8 @@ ControllerSession::ControllerSession(
         //  If we already missed it, run it ourselves.
         if (m_connection->is_ready()){
             ControllerSession::post_connection_ready(
-                *m_connection, m_connection->supported_controllers()
+                *m_connection,
+                m_connection->controller_mode_status()
             );
         }
     }catch (...){
@@ -180,7 +181,8 @@ void ControllerSession::make_controller(){
     //  If we already missed it, run it ourselves.
     if (ready){
         ControllerSession::post_connection_ready(
-            *m_connection, m_connection->supported_controllers()
+            *m_connection,
+            m_connection->controller_mode_status()
         );
     }
 }
@@ -305,18 +307,21 @@ std::string ControllerSession::reset(){
 //}
 void ControllerSession::post_connection_ready(
     ControllerConnection& connection,
-    const std::map<ControllerType, std::set<ControllerFeature>>& controllers
+    const ControllerModeStatus& mode_status
 ){
-    if (controllers.empty()){
+    const std::map<ControllerType, std::set<ControllerFeature>>& supported_controllers = mode_status.supported_controllers;
+    if (supported_controllers.empty()){
         return;
     }
 
+    ControllerType current_controller = mode_status.current_controller;
+
 //    cout << "sleeping" << endl;
 //    Sleep(10000);
 
 
     std::vector<ControllerType> available_controllers;
-    ControllerType selected_controller = ControllerType::None;
+//    ControllerType selected_controller = ControllerType::None;
     bool ready;
     {
         std::lock_guard<std::mutex> lg(m_state_lock);
@@ -333,10 +338,10 @@ void ControllerSession::post_connection_ready(
 
         //  We only show the "none" option when there are multiple controllers
         //  to choose from.
-        if (controllers.size() > 1){
+        if (supported_controllers.size() > 1){
             available_controllers.emplace_back(ControllerType::None);
         }
-        for (const auto& item : controllers){
+        for (const auto& item : supported_controllers){
             available_controllers.emplace_back(item.first);
         }
 
@@ -345,30 +350,30 @@ void ControllerSession::post_connection_ready(
         m_available_controllers = available_controllers;
 
 
-        auto iter = controllers.begin();
-        if (controllers.size() == 1){
+        auto iter = supported_controllers.begin();
+        if (supported_controllers.size() == 1){
             //  Only one controller available. Force the option to it.
-            selected_controller = iter->first;
+            current_controller = iter->first;
         }else{
             //  Keep the current controller only if it exists.
-            iter = controllers.find(m_option.m_controller_type);
-            if (iter != controllers.end()){
-                selected_controller = m_option.m_controller_type;
+            iter = supported_controllers.find(m_option.m_controller_type);
+            if (iter != supported_controllers.end()){
+                current_controller = m_option.m_controller_type;
             }
         }
 
         //  Construct the controller.
-        if (selected_controller != ControllerType::None){
+        if (current_controller != ControllerType::None){
             m_controller = m_descriptor->make_controller(
                 m_logger,
                 *m_connection,
-                selected_controller,
+                current_controller,
                 m_requirements
             );
         }
 
         //  Commit all changes.
-        m_option.m_controller_type = selected_controller;
+        m_option.m_controller_type = current_controller;
         ready = m_controller && m_controller->is_ready();
 
         WriteSpinLock lg1(m_message_lock);
@@ -377,7 +382,7 @@ void ControllerSession::post_connection_ready(
         }
     }
 
-    signal_controller_changed(selected_controller, available_controllers);
+    signal_controller_changed(current_controller, available_controllers);
     signal_ready_changed(ready);
     signal_status_text_changed(status_text());
 }
diff --git a/SerialPrograms/Source/Controllers/ControllerSession.h b/SerialPrograms/Source/Controllers/ControllerSession.h
@@ -123,7 +123,7 @@ class ControllerSession : private ControllerConnection::StatusListener{
 //    virtual void pre_connection_not_ready(ControllerConnection& connection) override;
     virtual void post_connection_ready(
         ControllerConnection& connection,
-        const std::map<ControllerType, std::set<ControllerFeature>>& controllers
+        const ControllerModeStatus& mode_status
     ) override;
     virtual void status_text_changed(
         ControllerConnection& connection,
diff --git a/SerialPrograms/Source/Controllers/SerialPABotBase/SerialPABotBase.cpp b/SerialPrograms/Source/Controllers/SerialPABotBase/SerialPABotBase.cpp
@@ -31,6 +31,22 @@ std::string program_name(uint8_t id){
     default: return "Unknown ID";
     }
 }
+ControllerType controller_type(uint32_t id){
+    switch (id){
+    case PABB_CID_NONE:
+        return ControllerType::None;
+    case PABB_CID_NINTENDO_SWITCH_WIRED_PRO_CONTROLLER:
+        return ControllerType::NintendoSwitch_WiredProController;
+    case PABB_CID_NINTENDO_SWITCH_WIRELESS_PRO_CONTROLLER:
+        return ControllerType::NintendoSwitch_WirelessProController;
+    case PABB_CID_NINTENDO_SWITCH_LEFT_JOYCON:
+        return ControllerType::NintendoSwitch_LeftJoycon;
+    case PABB_CID_NINTENDO_SWITCH_RIGHT_JOYCON:
+        return ControllerType::NintendoSwitch_RightJoycon;
+    default:
+        return ControllerType::None;
+    }
+}
 
 
 
diff --git a/SerialPrograms/Source/Controllers/SerialPABotBase/SerialPABotBase.h b/SerialPrograms/Source/Controllers/SerialPABotBase/SerialPABotBase.h
@@ -24,6 +24,7 @@ extern const ControllerRequirements OLD_NINTENDO_SWITCH_DEFAULT_REQUIREMENTS;
 
 
 std::string program_name(uint8_t id);
+ControllerType controller_type(uint32_t id);
 
 
 
diff --git a/SerialPrograms/Source/Controllers/SerialPABotBase/SerialPABotBase_Connection.cpp b/SerialPrograms/Source/Controllers/SerialPABotBase/SerialPABotBase_Connection.cpp
@@ -137,13 +137,13 @@ BotBaseController* SerialPABotBase_Connection::botbase(){
 
 
 
-std::map<ControllerType, std::set<ControllerFeature>> SerialPABotBase_Connection::supported_controllers() const{
+ControllerModeStatus SerialPABotBase_Connection::controller_mode_status() const{
     std::lock_guard<std::mutex> lg(m_lock);
-    return m_controllers;
+    return m_mode_status;
 }
 
 
-std::map<ControllerType, std::set<ControllerFeature>> SerialPABotBase_Connection::read_device_specs(){
+ControllerModeStatus SerialPABotBase_Connection::read_device_specs(){
     Logger& logger = m_logger;
 
 
@@ -187,7 +187,17 @@ std::map<ControllerType, std::set<ControllerFeature>> SerialPABotBase_Connection
         );
     }
 
-    return program_iter->second;
+
+    //  Controller Type
+    ControllerType current_controller = ControllerType::None;
+    if (program_iter->second.size() == 1){
+        current_controller = program_iter->second.begin()->first;
+    }else if (program_iter->second.size() > 1){
+        uint32_t type_id = Microcontroller::controller_mode(*m_botbase);
+        current_controller = controller_type(type_id);
+    }
+
+    return {current_controller, program_iter->second};
 }
 
 
@@ -220,12 +230,12 @@ void SerialPABotBase_Connection::thread_body(){
 
     //  Check protocol and version.
     {
-        std::map<ControllerType, std::set<ControllerFeature>> controllers;
+        ControllerModeStatus mode_status;
         std::string error;
         try{
-            controllers = read_device_specs();
+            mode_status = read_device_specs();
             std::lock_guard<std::mutex> lg(m_lock);
-            m_controllers = controllers;
+            m_mode_status = mode_status;
 
             //  Stop pending commands.
             m_botbase->stop_all_commands();
@@ -240,7 +250,7 @@ void SerialPABotBase_Connection::thread_body(){
 //            std::string text = "Program: " + program_name(m_program_id) + " (" + std::to_string(m_protocol) + ")";
             std::string text = program_name(m_program_id) + " (" + std::to_string(m_protocol) + ")";
             set_status_line0(text, theme_friendly_darkblue());
-            declare_ready(controllers);
+            declare_ready(mode_status);
         }else{
             m_ready.store(false, std::memory_order_relaxed);
             set_status_line0(error, COLOR_RED);
diff --git a/SerialPrograms/Source/Controllers/SerialPABotBase/SerialPABotBase_Connection.h b/SerialPrograms/Source/Controllers/SerialPABotBase/SerialPABotBase_Connection.h
@@ -37,11 +37,12 @@ class SerialPABotBase_Connection : public ControllerConnection{
     BotBaseController* botbase();
 
 public:
-    virtual std::map<ControllerType, std::set<ControllerFeature>> supported_controllers() const override;
+
+    virtual ControllerModeStatus controller_mode_status() const override;
 
 
 private:
-    std::map<ControllerType, std::set<ControllerFeature>> read_device_specs();
+    ControllerModeStatus read_device_specs();
 
     void thread_body();
 
@@ -51,7 +52,7 @@ class SerialPABotBase_Connection : public ControllerConnection{
 
     uint32_t m_protocol = 0;
     uint8_t m_program_id = 0;
-    std::map<ControllerType, std::set<ControllerFeature>> m_controllers;
+    ControllerModeStatus m_mode_status;
 
     std::thread m_status_thread;
     std::unique_ptr<PABotBase> m_botbase;
diff --git a/SerialPrograms/Source/NintendoSwitch/Controllers/SerialPABotBase/NintendoSwitch_SerialPABotBase_ProController.cpp b/SerialPrograms/Source/NintendoSwitch/Controllers/SerialPABotBase/NintendoSwitch_SerialPABotBase_ProController.cpp
diff --git a/SerialPrograms/Source/NintendoSwitch/Controllers/SerialPABotBase/NintendoSwitch_SerialPABotBase_WirelessProController.cpp b/SerialPrograms/Source/NintendoSwitch/Controllers/SerialPABotBase/NintendoSwitch_SerialPABotBase_WirelessProController.cpp
diff --git a/SerialPrograms/Source/NintendoSwitch/Controllers/SysbotBase/SysbotBase_Connection.cpp b/SerialPrograms/Source/NintendoSwitch/Controllers/SysbotBase/SysbotBase_Connection.cpp
diff --git a/SerialPrograms/Source/NintendoSwitch/Controllers/SysbotBase/SysbotBase_Connection.h b/SerialPrograms/Source/NintendoSwitch/Controllers/SysbotBase/SysbotBase_Connection.h
diff --git a/SerialPrograms/Source/NintendoSwitch/Controllers/SysbotBase/SysbotBase_ProController.cpp b/SerialPrograms/Source/NintendoSwitch/Controllers/SysbotBase/SysbotBase_ProController.cpp

Original file line number	Diff line number	Diff line change
`@@ -39,6 +39,13 @@ uint8_t program_id(BotBaseController& botbase){`
`39`	`39`	`).convert<PABB_MSG_ACK_REQUEST_I8>(botbase.logger(), response);`
`40`	`40`	`return response.data;`
`41`	`41`	`}`
	`42`	`+uint32_t controller_mode(BotBaseController& botbase){`
	`43`	`+ pabb_MsgAckRequestI32 response;`
	`44`	`+ botbase.issue_request_and_wait(`
	`45`	`+ DeviceRequest_controller_mode()`
	`46`	`+ ).convert<PABB_MSG_ACK_REQUEST_I32>(botbase.logger(), response);`
	`47`	`+ return response.data;`
	`48`	`+}`
`42`	`49`
`43`	`50`
`44`	`51`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ namespace PokemonAutomation{`
`18`	`18`	`void ControllerConnection::add_status_listener(StatusListener& listener){`
`19`	`19`	`m_status_listeners.add(listener);`
`20`	`20`	`if (m_ready.load(std::memory_order_acquire)){`
`21`		`- listener.post_connection_ready(*this, supported_controllers());`
	`21`	`+ listener.post_connection_ready(*this, controller_mode_status());`
`22`	`22`	`}`
`23`	`23`	`}`
`24`	`24`	`void ControllerConnection::remove_status_listener(StatusListener& listener){`
`@@ -51,17 +51,17 @@ void ControllerConnection::set_status_line1(const std::string& text, Color color`
`51`	`51`	`}`
`52`	`52`	`signal_status_text_changed(status_text());`
`53`	`53`	`}`
`54`		`-void ControllerConnection::declare_ready(const std::map<ControllerType, std::set<ControllerFeature>>& controllers){`
	`54`	`+void ControllerConnection::declare_ready(const ControllerModeStatus& mode_status){`
`55`	`55`	`m_ready.store(true, std::memory_order_release);`
`56`		`- signal_post_ready(controllers);`
	`56`	`+ signal_post_ready(mode_status);`
`57`	`57`	`}`
`58`	`58`
`59`	`59`
`60`	`60`	`//void ControllerConnection::signal_pre_not_ready(){`
`61`	`61`	`// m_status_listeners.run_method_unique(&StatusListener::pre_connection_not_ready, *this);`
`62`	`62`	`//}`
`63`		`-void ControllerConnection::signal_post_ready(const std::map<ControllerType, std::set<ControllerFeature>>& controllers){`
`64`		`- m_status_listeners.run_method_unique(&StatusListener::post_connection_ready, *this, controllers);`
	`63`	`+void ControllerConnection::signal_post_ready(const ControllerModeStatus& mode_status){`
	`64`	`+ m_status_listeners.run_method_unique(&StatusListener::post_connection_ready, *this, mode_status);`
`65`	`65`	`}`
`66`	`66`	`void ControllerConnection::signal_status_text_changed(const std::string& text){`
`67`	`67`	`// cout << "m_status_listeners.size() = " << m_status_listeners.count_unique() << endl;`
Original file line number	Diff line number	Diff line change
`@@ -24,6 +24,7 @@ extern const ControllerRequirements OLD_NINTENDO_SWITCH_DEFAULT_REQUIREMENTS;`
`24`	`24`
`25`	`25`
`26`	`26`	`std::string program_name(uint8_t id);`
	`27`	`+ControllerType controller_type(uint32_t id);`
`27`	`28`
`28`	`29`
`29`	`30`