Merge pull request #368 from openxc/devicePlatformCommand

Added command to retrieve the device's platform

src/Makefile

@@ -30,6 +30,9 @@ OBJDIR = $(OBJDIR_ROOT)
 # 0 or 1
 BOOTLOADER ?= 1
 
+PLATFORM ?= "NONE"
+SYMBOLS += PLATFORM="\"$(PLATFORM)\""
+
 DEFAULT_ALLOW_RAW_WRITE_USB ?= 1
 SYMBOLS += DEFAULT_ALLOW_RAW_WRITE_USB=$(DEFAULT_ALLOW_RAW_WRITE_USB)
 

src/commands/commands.cpp

@@ -10,6 +10,7 @@
 #include "commands/diagnostic_request_command.h"
 #include "commands/version_command.h"
 #include "commands/device_id_command.h"
+#include "commands/device_platform_command.h"
 #include "commands/can_message_write_command.h"
 #include "commands/simple_write_command.h"
 #include "commands/af_bypass_command.h"
@@ -39,6 +40,9 @@ static bool handleComplexCommand(openxc_VehicleMessage* message) {
         case openxc_ControlCommand_Type_DEVICE_ID:
             status = openxc::commands::handleDeviceIdCommmand();
             break;
+        case openxc_ControlCommand_Type_PLATFORM:
+            status = openxc::commands::handleDevicePlatformCommmand();
+            break;
         case openxc_ControlCommand_Type_PASSTHROUGH:
             status = openxc::commands::handlePassthroughModeCommand(command);
             break;
@@ -138,6 +142,7 @@ static bool validateControlCommand(openxc_VehicleMessage* message) {
             break;
         case openxc_ControlCommand_Type_VERSION:
         case openxc_ControlCommand_Type_DEVICE_ID:
+        case openxc_ControlCommand_Type_PLATFORM:
         case openxc_ControlCommand_Type_SD_MOUNT_STATUS:
             valid =  true;
             break;

src/commands/device_platform_command.cpp

@@ -0,0 +1,40 @@
+#include "device_platform_command.h"
+#include "config.h"
+#include "diagnostics.h"
+#include "interface/usb.h"
+#include "util/log.h"
+#include "config.h"
+#include "pb_decode.h"
+#include <payload/payload.h>
+#include "signals.h"
+#include <can/canutil.h>
+#include <bitfield/bitfield.h>
+#include <limits.h>
+
+using openxc::util::log::debug;
+using openxc::config::getConfiguration;
+using openxc::payload::PayloadFormat;
+using openxc::signals::getCanBuses;
+using openxc::signals::getCanBusCount;
+using openxc::signals::getSignals;
+using openxc::signals::getSignalCount;
+using openxc::signals::getCommands;
+using openxc::signals::getCommandCount;
+using openxc::can::lookupBus;
+using openxc::can::lookupSignal;
+
+namespace can = openxc::can;
+namespace payload = openxc::payload;
+namespace config = openxc::config;
+namespace diagnostics = openxc::diagnostics;
+namespace usb = openxc::interface::usb;
+namespace uart = openxc::interface::uart;
+namespace pipeline = openxc::pipeline;
+
+bool openxc::commands::handleDevicePlatformCommmand() {
+    char* platform_name;
+    platform_name = strdup(config::getConfiguration()->platform);
+    sendCommandResponse(openxc_ControlCommand_Type_PLATFORM, true, 
+        platform_name, strlen(platform_name));
+    return true;
+}

src/commands/device_platform_command.h

@@ -0,0 +1,12 @@
+#ifndef __DEVICE_PLATFORM_COMMAND_H__
+#define __DEVICE_PLATFORM_COMMAND_H__
+
+namespace openxc {
+namespace commands {
+
+bool handleDevicePlatformCommmand();
+
+} // namespace commands
+} // namespace openxc
+
+#endif // __DEVICE_PLATFORM_COMMAND_H__

src/config.cpp

@@ -119,6 +119,7 @@ openxc::config::Configuration* openxc::config::getConfiguration() {
     static openxc::config::Configuration CONFIG = {
         messageSetIndex: 0,
         version: "7.2.1-dev",
+        platform: PLATFORM,
         environmentMode: ENVIRONMENT_MODE,
         payloadFormat: PayloadFormat::DEFAULT_OUTPUT_FORMAT,
         recurringObd2Requests: DEFAULT_RECURRING_OBD2_REQUESTS_STATUS,

src/config.h

@@ -110,6 +110,7 @@ typedef enum {
 typedef struct {
     int messageSetIndex;
     const char* version;
+    const char* platform;
     const char* environmentMode;
     openxc::payload::PayloadFormat payloadFormat;
     bool recurringObd2Requests;

src/payload/json.cpp

@@ -16,6 +16,7 @@ using openxc::util::log::debug;
 
 const char openxc::payload::json::VERSION_COMMAND_NAME[] = "version";
 const char openxc::payload::json::DEVICE_ID_COMMAND_NAME[] = "device_id";
+const char openxc::payload::json::DEVICE_PLATFORM_COMMAND_NAME[] = "platform";
 const char openxc::payload::json::DIAGNOSTIC_COMMAND_NAME[] = "diagnostic_request";
 const char openxc::payload::json::PASSTHROUGH_COMMAND_NAME[] = "passthrough";
 const char openxc::payload::json::ACCEPTANCE_FILTER_BYPASS_COMMAND_NAME[] = "af_bypass";
@@ -99,6 +100,8 @@ static bool serializeCommandResponse(openxc_VehicleMessage* message,
         typeString = payload::json::VERSION_COMMAND_NAME;
     } else if(message->command_response.type == openxc_ControlCommand_Type_DEVICE_ID) {
         typeString = payload::json::DEVICE_ID_COMMAND_NAME;
+    } else if(message->command_response.type == openxc_ControlCommand_Type_PLATFORM) {
+        typeString = payload::json::DEVICE_PLATFORM_COMMAND_NAME;
     } else if(message->command_response.type == openxc_ControlCommand_Type_DIAGNOSTIC) {
         typeString = payload::json::DIAGNOSTIC_COMMAND_NAME;
     } else if(message->command_response.type == openxc_ControlCommand_Type_PASSTHROUGH) {
@@ -571,6 +574,10 @@ size_t openxc::payload::json::deserialize(uint8_t payload[], size_t length,
                         DEVICE_ID_COMMAND_NAME, strlen(DEVICE_ID_COMMAND_NAME))) {
                 command->has_type = true;
                 command->type = openxc_ControlCommand_Type_DEVICE_ID;
+            } else if(!strncmp(commandNameObject->valuestring,
+                        DEVICE_PLATFORM_COMMAND_NAME, strlen(DEVICE_PLATFORM_COMMAND_NAME))) {
+                command->has_type = true;
+                command->type = openxc_ControlCommand_Type_PLATFORM;
             } else if(!strncmp(commandNameObject->valuestring,
                         DIAGNOSTIC_COMMAND_NAME, strlen(DIAGNOSTIC_COMMAND_NAME))) {
                 deserializeDiagnostic(root, command);

src/payload/json.h

@@ -9,6 +9,7 @@ namespace json {
 
 extern const char VERSION_COMMAND_NAME[];
 extern const char DEVICE_ID_COMMAND_NAME[];
+extern const char DEVICE_PLATFORM_COMMAND_NAME[];
 extern const char DIAGNOSTIC_COMMAND_NAME[];
 extern const char PASSTHROUGH_COMMAND_NAME[];
 extern const char ACCEPTANCE_FILTER_BYPASS_COMMAND_NAME[];

src/payload/messagepack.cpp

@@ -29,6 +29,7 @@ using openxc::util::log::debug;
 
 const char openxc::payload::messagepack::VERSION_COMMAND_NAME[] = "version";
 const char openxc::payload::messagepack::DEVICE_ID_COMMAND_NAME[] = "device_id";
+const char openxc::payload::messagepack::DEVICE_PLATFORM_COMMAND_NAME[] = "platform";
 const char openxc::payload::messagepack::DIAGNOSTIC_COMMAND_NAME[] = "diagnostic_request";
 const char openxc::payload::messagepack::PASSTHROUGH_COMMAND_NAME[] = "passthrough";
 const char openxc::payload::messagepack::ACCEPTANCE_FILTER_BYPASS_COMMAND_NAME[] = "af_bypass";
@@ -288,6 +289,8 @@ static bool serializeCommandResponse(openxc_VehicleMessage* message, cmp_ctx_t *
         typeString = payload::messagepack::VERSION_COMMAND_NAME;
     } else if(message->command_response.type == openxc_ControlCommand_Type_DEVICE_ID) {
         typeString = payload::messagepack::DEVICE_ID_COMMAND_NAME;
+    } else if(message->command_response.type == openxc_ControlCommand_Type_PLATFORM) {
+        typeString = payload::messagepack::DEVICE_PLATFORM_COMMAND_NAME;
     } else if(message->command_response.type == openxc_ControlCommand_Type_DIAGNOSTIC) {
         typeString = payload::messagepack::DIAGNOSTIC_COMMAND_NAME;
     } else if(message->command_response.type == openxc_ControlCommand_Type_PASSTHROUGH) {
@@ -1116,6 +1119,10 @@ size_t openxc::payload::messagepack::deserialize(uint8_t payload[], size_t lengt
                     DEVICE_ID_COMMAND_NAME, strlen(DEVICE_ID_COMMAND_NAME))) {
             command->has_type = true;
             command->type = openxc_ControlCommand_Type_DEVICE_ID;
+        } else if(!strncmp(commandNameObject->valuestring,
+                    DEVICE_PLATFORM_COMMAND_NAME, strlen(DEVICE_PLATFORM_COMMAND_NAME))) {
+            command->has_type = true;
+            command->type = openxc_ControlCommand_Type_PLATFORM;
         } else if(!strncmp(commandNameObject->valuestring,
                     DIAGNOSTIC_COMMAND_NAME, strlen(DIAGNOSTIC_COMMAND_NAME))) {
             deserializeDiagnostic(root, command);

src/payload/messagepack.h

@@ -9,6 +9,7 @@ namespace messagepack {
 
 extern const char VERSION_COMMAND_NAME[];
 extern const char DEVICE_ID_COMMAND_NAME[];
+extern const char DEVICE_PLATFORM_COMMAND_NAME[];
 extern const char DIAGNOSTIC_COMMAND_NAME[];
 extern const char PASSTHROUGH_COMMAND_NAME[];
 extern const char ACCEPTANCE_FILTER_BYPASS_COMMAND_NAME[];

src/tests/command_tests.cpp

@@ -768,6 +768,13 @@ START_TEST (test_validate_version_command)
 }
 END_TEST
 
+START_TEST (test_validate_device_platform_command)
+{
+    CONTROL_COMMAND.control_command.type = openxc_ControlCommand_Type_PLATFORM;
+    ck_assert(validate(&CONTROL_COMMAND));
+}
+END_TEST
+
 START_TEST (test_validate_device_id_command)
 {
     CONTROL_COMMAND.control_command.type = openxc_ControlCommand_Type_DEVICE_ID;
@@ -957,6 +964,7 @@ Suite* suite(void) {
     tcase_add_test(tc_validation,
             test_validate_diagnostic_no_multiple_responses);
     tcase_add_test(tc_validation, test_validate_version_command);
+    tcase_add_test(tc_validation, test_validate_device_platform_command);
     tcase_add_test(tc_validation, test_validate_device_id_command);
     tcase_add_test(tc_validation, test_validate_passthrough_commmand);
     tcase_add_test(tc_validation, test_validate_bypass_command);