More MLC layer.

Author: Mysticial

Common/Cpp/StreamConnections/ReliableStreamConnection.cpp

@@ -393,10 +393,7 @@ void ReliableStreamConnection::process_RET_VERSION(const PacketHeader* packet){
             break;
         }
 
-        m_logger.log(
-            "[RSC]: " + str + " (compatible)",
-            COLOR_BLUE
-        );
+        m_logger.log("[RSC]: " + str + " (compatible)", COLOR_BLUE);
         m_reliable_sender.remove(packet->seqnum);
 
     }while (false);

Common/PABotBase2/DataLayer/PABotBase2_ComputerHandle.cpp

@@ -23,9 +23,17 @@ void ComputerHandle::send_message_u32(uint8_t id, uint32_t data){
     response.id = id;
     response.data = data;
     data_connection.reliable_send(&response, response.message_bytes);
-    
+
 //    data_connection.send_oob_info_u32(response.message_bytes);
 }
+void ComputerHandle::send_message_data(uint8_t id, uint16_t bytes, const void* data){
+    pabb2_Message_Response_Data response;
+    response.message_bytes = sizeof(pabb2_Message_Response_Data) + bytes;
+    response.opcode = PABB2_MESSAGE_OPCODE_RET_DATA;
+    response.id = id;
+    data_connection.reliable_send(&response, sizeof(pabb2_Message_Response_Data));
+    data_connection.reliable_send(data, bytes);
+}
 void ComputerHandle::process_completed_message(){
     const pabb2_MessageHeader* header = (const pabb2_MessageHeader*)m_buffer;
 
@@ -39,6 +47,12 @@ void ComputerHandle::process_completed_message(){
     case PABB2_MESSAGE_OPCODE_DEVICE_IDENTIFIER:
         send_message_u32(header->id, PABB2_DEVICE_ID);
         return;
+    case PABB2_MESSAGE_OPCODE_DEVICE_NAME:
+        send_message_data(header->id, sizeof(PABB2_DEVICE_NAME) - 1, PABB2_DEVICE_NAME);
+        return;
+    case PABB2_MESSAGE_OPCODE_CONTROLLER_LIST:
+        send_message_data(header->id, sizeof(PABB_CONTROLLER_LIST), PABB_CONTROLLER_LIST);
+        return;
     case PABB2_MESSAGE_OPCODE_CQ_CAPACITY:
         send_message_u32(header->id, PABB2_CommandQueue_SLOTS);
         return;

Common/PABotBase2/DataLayer/PABotBase2_ComputerHandle.h

@@ -29,6 +29,7 @@ class ComputerHandle{
 
 private:
     void send_message_u32(uint8_t id, uint32_t data);
+    void send_message_data(uint8_t id, uint16_t bytes, const void* data);
     void process_completed_message();
 
 private:

Common/PABotBase2/DataLayer/PABotBase2_MessageProtocol.h

@@ -61,8 +61,9 @@ struct PABB_PACK pabb2_Message_Response_Data{
 #define PABB2_MESSAGE_OPCODE_PROTOCOL_VERSION       0x20
 #define PABB2_MESSAGE_OPCODE_FIRMWARE_VERSION       0x21
 #define PABB2_MESSAGE_OPCODE_DEVICE_IDENTIFIER      0x22
-#define PABB2_MESSAGE_OPCODE_CONTROLLER_LIST        0x23
-#define PABB2_MESSAGE_OPCODE_CQ_CAPACITY            0x24
+#define PABB2_MESSAGE_OPCODE_DEVICE_NAME            0x23
+#define PABB2_MESSAGE_OPCODE_CONTROLLER_LIST        0x24
+#define PABB2_MESSAGE_OPCODE_CQ_CAPACITY            0x28
 
 #define PABB_MESSAGE_OPCODE_READ_CONTROLLER_MODE    0x30
 #define PABB_MESSAGE_OPCODE_CHANGE_CONTROLLER_MODE  0x31

SerialPrograms/Source/Controllers/PABotBase2/PABotBase2_DeviceHandle.cpp

@@ -5,8 +5,12 @@
  */
 
 #include "Common/Cpp/Exceptions.h"
+#include "Common/Cpp/PrettyPrint.h"
 #include "Common/Cpp/StreamConnections/PABotBase2_MessageDumper.h"
+#include "CommonFramework/Globals.h"
+#include "CommonFramework/Options/Environment/ThemeSelectorOption.h"
 #include "CommonFramework/GlobalSettingsPanel.h"
+#include "Controllers/SerialPABotBase/SerialPABotBase.h"
 #include "PABotBase2_DeviceHandle.h"
 
 //  REMOVE
@@ -54,79 +58,103 @@ bool DeviceHandle::cancel(std::exception_ptr exception) noexcept{
 }
 
 
-void DeviceHandle::connect(){
-    m_device_protocol = query_u32(PABB2_MESSAGE_OPCODE_PROTOCOL_VERSION);
-    m_logger.log("[MLC]: Remote Protocol: " + std::to_string(m_device_protocol), COLOR_BLUE);
-
-    m_device_firmware_version = query_u32(PABB2_MESSAGE_OPCODE_FIRMWARE_VERSION);
-    m_logger.log("[MLC]: Firmware Version: " + std::to_string(m_device_firmware_version), COLOR_BLUE);
 
-    m_device_id = query_u32(PABB2_MESSAGE_OPCODE_DEVICE_IDENTIFIER);
-    m_logger.log("[MLC]: Device ID: " + std::to_string(m_device_id), COLOR_BLUE);
-
-    m_command_queue_size = (uint8_t)query_u32(PABB2_MESSAGE_OPCODE_CQ_CAPACITY);
-    m_logger.log("[MLC]: Command Queue Size: " + std::to_string(m_command_queue_size), COLOR_BLUE);
+void DeviceHandle::throw_incompatible_protocol(){
+    m_logger.log(
+        "[MLC]: Remote Protocol: " + std::to_string(m_device_protocol) + " (incompatible)",
+        COLOR_RED
+    );
 
+    throw SerialProtocolException(
+        m_logger, PA_CURRENT_FUNCTION,
+        "Incompatible MLC protocol. Device: " + std::to_string(m_device_protocol) + "<br>"
+        "Please flash your microcontroller (e.g. ESP32, Pico W, Arduino) <br>"
+        "with the .bin/.uf2/.hex that came with this version of the program.<br>" +
+        make_text_url(ONLINE_DOC_URL_BASE + "SetupGuide/Reflash.html", "See documentation for more details.")
+    );
 }
-
-void DeviceHandle::on_recv(const void* data, size_t bytes){
-    cout << "DeviceHandle::on_recv()" << endl;
-    m_buffer.insert(m_buffer.end(), (const char*)data, (const char*)data + bytes);
-
-    while (true){
-        //  Header is incomplete.
-        if (m_buffer.size() < sizeof(pabb2_MessageHeader)){
-            return;
+void DeviceHandle::query_protocol(){
+    const std::map<pabb_ProgramID, uint8_t>* PROGRAMS;
+    {
+        m_device_protocol = query_u32(PABB2_MESSAGE_OPCODE_PROTOCOL_VERSION);
+        const std::map<uint32_t, std::map<pabb_ProgramID, uint8_t>>& SUPPORTED_VERSIONS =
+            SerialPABotBase::SUPPORTED_VERSIONS2();
+        auto iter = SUPPORTED_VERSIONS.find(m_device_protocol / 100);
+        if (iter == SUPPORTED_VERSIONS.end()){
+            throw_incompatible_protocol();
         }
-
-        //  Message is incomplete.
-        uint16_t message_size;
-        std::copy(m_buffer.begin(), m_buffer.begin() + 2, (char*)&message_size);
-        if (m_buffer.size() < message_size){
-            return;
+        PROGRAMS = &iter->second;
+    }
+    {
+        m_device_id = query_u32(PABB2_MESSAGE_OPCODE_DEVICE_IDENTIFIER);
+        m_logger.log("[MLC]: Device ID: " + tostr_hex(m_device_id), COLOR_BLUE);
+        auto iter = PROGRAMS->find(m_device_id);
+        if (iter == PROGRAMS->end()){
+            m_logger.Logger::log(
+                "Unrecognized Program ID: (0x" + tostr_hex(m_device_id) + ") for this protocol version. "
+                "Compatibility is not guaranteed.",
+                COLOR_RED
+            );
+            iter = PROGRAMS->find(PABB_PID_UNSPECIFIED);
+            if (iter == PROGRAMS->end()){
+                throw_incompatible_protocol();
+            }
         }
+    }
+    m_logger.log(
+        "[MLC]: Remote Protocol: " + std::to_string(m_device_protocol) + " (compatible)",
+        COLOR_RED
+    );
+}
+void DeviceHandle::query_controller_list(){
+    std::string response = query_data(PABB2_MESSAGE_OPCODE_CONTROLLER_LIST);
+    if (response.size() % sizeof(pabb_ControllerID) != 0){
+        throw InternalProgramError(
+            &m_logger,
+            PA_CURRENT_FUNCTION,
+            "Controller list query expects a response length divisible by " + std::to_string(sizeof(pabb_ControllerID)) + "."
+        );
+    }
 
-        auto iter_s = m_buffer.begin();
-        auto iter_e = iter_s + message_size;
-        std::string message(iter_s, iter_e);
-        m_buffer.erase(iter_s, iter_e);
-
-        const pabb2_MessageHeader* header = (const pabb2_MessageHeader*)message.c_str();
-
-        bool log_everything = GlobalSettings::instance().LOG_EVERYTHING;
-
-        if (log_everything){
-            m_logger.log("[MLC]: Receive: " + tostr(header), COLOR_PURPLE);
-        }
+    size_t length = response.size() / sizeof(pabb_ControllerID);
+    const pabb_ControllerID* list = (const pabb_ControllerID*)response.c_str();
 
-        //  Now we can process the message.
-        switch (header->opcode){
-        case PABB2_MESSAGE_OPCODE_INVALID:
-        case PABB2_MESSAGE_OPCODE_REQUEST_DROPPED:
-            if (!log_everything){
-                m_logger.log("[MLC]: Receive: " + tostr(header), COLOR_PURPLE);
-            }
-            continue;
-        case PABB2_MESSAGE_OPCODE_RET:
-        case PABB2_MESSAGE_OPCODE_RET_U32:
-        case PABB2_MESSAGE_OPCODE_RET_DATA:
-        {
-            std::lock_guard<Mutex> lg(m_lock);
-            auto iter = m_pending_requests.find(header->id);
-            if (iter == m_pending_requests.end()){
-                m_logger.log("[MLC]: Received response for unknown ID: " + std::to_string(header->id));
-                continue;
-            }
-            iter->second.response = std::move(message);
-            iter->second.cv.notify_all();
-            continue;
+    std::string str;
+    bool first = true;
+    for (size_t c = 0; c < length; c++){
+        pabb_ControllerID id;
+        memcpy(&id, list + c, sizeof(pabb_ControllerID));
+        if (!first){
+            str += ", ";
         }
+        first = false;
+        str += "0x" + tostr_hex(id);
+        if (SerialPABotBase::controller_is_valid(id)){
+            m_controller_list.emplace_back(SerialPABotBase::id_to_controller_type(id));
         }
-
-        //  TODO: Process device-specific messages.
     }
+    m_logger.Logger::log("Checking Controller List... (" + str + ")");
+}
+void DeviceHandle::query_command_queue(){
+    m_command_queue_size = (uint8_t)query_u32(PABB2_MESSAGE_OPCODE_CQ_CAPACITY);
+    m_logger.log("[MLC]: Command Queue Size: " + std::to_string(m_command_queue_size), COLOR_BLUE);
+
+    //  For now we don't need to use that much queue size.
+    m_command_queue_size = std::min<uint8_t>(m_command_queue_size, 32);
+
+    m_logger.Logger::log("Setting queue size to: " + std::to_string(m_command_queue_size));
+}
+void DeviceHandle::connect(){
+    query_protocol();
 
+    m_device_firmware_version = query_u32(PABB2_MESSAGE_OPCODE_FIRMWARE_VERSION);
+    m_logger.log("[MLC]: Firmware Version: " + std::to_string(m_device_firmware_version), COLOR_BLUE);
+
+    m_device_name = query_data(PABB2_MESSAGE_OPCODE_DEVICE_NAME);
+    m_logger.log("[MLC]: Device Name: " + m_device_name, COLOR_BLUE);
 
+    query_controller_list();
+    query_command_queue();
 }
 
 
@@ -180,7 +208,6 @@ std::string DeviceHandle::wait_for_response(uint8_t id){
     }
 }
 
-
 uint32_t DeviceHandle::query_u32(uint8_t opcode){
     pabb2_MessageHeader request;
     request.message_bytes = sizeof(pabb2_MessageHeader);
@@ -193,13 +220,100 @@ uint32_t DeviceHandle::query_u32(uint8_t opcode){
         throw InternalProgramError(
             &m_logger,
             PA_CURRENT_FUNCTION,
-            "Expected reponse length of: " + std::to_string(sizeof(pabb2_Message_Response_u32))
+            "Expected response length of: " + std::to_string(sizeof(pabb2_Message_Response_u32))
         );
     }
 
     const pabb2_Message_Response_u32* msg = (const pabb2_Message_Response_u32*)response.c_str();
     return msg->data;
 }
+std::string DeviceHandle::query_data(uint8_t opcode){
+    pabb2_MessageHeader request;
+    request.message_bytes = sizeof(pabb2_MessageHeader);
+    request.opcode = opcode;
+
+    send_request(request);
+
+    std::string response = wait_for_response(request.id);
+    if (response.size() < sizeof(pabb2_Message_Response_Data)){
+        throw InternalProgramError(
+            &m_logger,
+            PA_CURRENT_FUNCTION,
+            "Response length of " + std::to_string(response.size()) + " is too short."
+        );
+    }
+
+    const pabb2_Message_Response_Data* msg = (const pabb2_Message_Response_Data*)response.c_str();
+    return std::string((const char*)(msg + 1), msg->message_bytes - sizeof(pabb2_Message_Response_Data));
+}
+
+
+
+
+
+void DeviceHandle::on_recv(const void* data, size_t bytes){
+    cout << "DeviceHandle::on_recv()" << endl;
+    m_buffer.insert(m_buffer.end(), (const char*)data, (const char*)data + bytes);
+
+    while (true){
+        //  Header is incomplete.
+        if (m_buffer.size() < sizeof(pabb2_MessageHeader)){
+            return;
+        }
+
+        //  Message is incomplete.
+        uint16_t message_size;
+        std::copy(m_buffer.begin(), m_buffer.begin() + 2, (char*)&message_size);
+        if (m_buffer.size() < message_size){
+            return;
+        }
+
+        auto iter_s = m_buffer.begin();
+        auto iter_e = iter_s + message_size;
+        std::string message(iter_s, iter_e);
+        m_buffer.erase(iter_s, iter_e);
+
+        const pabb2_MessageHeader* header = (const pabb2_MessageHeader*)message.c_str();
+
+        bool log_everything = GlobalSettings::instance().LOG_EVERYTHING;
+
+        if (log_everything){
+            m_logger.log("[MLC]: Receive: " + tostr(header), COLOR_PURPLE);
+        }
+
+        //  Now we can process the message.
+        switch (header->opcode){
+        case PABB2_MESSAGE_OPCODE_INVALID:
+        case PABB2_MESSAGE_OPCODE_REQUEST_DROPPED:
+            if (!log_everything){
+                m_logger.log("[MLC]: Receive: " + tostr(header), COLOR_PURPLE);
+            }
+            continue;
+        case PABB2_MESSAGE_OPCODE_RET:
+        case PABB2_MESSAGE_OPCODE_RET_U32:
+        case PABB2_MESSAGE_OPCODE_RET_DATA:
+        {
+            std::lock_guard<Mutex> lg(m_lock);
+            auto iter = m_pending_requests.find(header->id);
+            if (iter == m_pending_requests.end()){
+                m_logger.log("[MLC]: Received response for unknown ID: " + std::to_string(header->id));
+                continue;
+            }
+            iter->second.response = std::move(message);
+            iter->second.cv.notify_all();
+            continue;
+        }
+        }
+
+        //  TODO: Process device-specific messages.
+    }
+
+
+}
+
+
+
+