infrastructure for file system commands. rockers disabled

45 files changed, 3238 insertions, 148 deletions

diff --git a/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c
new file mode 100644
index 000000000..f9806552d
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c
@@ -0,0 +1,229 @@
+/*
+ * FileSystem.c
+ *
+ *  Created on: Oct 23, 2018
+ *      Author: shlomo
+ */
+#include "include.h"
+#include "Communication/CommunicationTask.h"
+
+#include  <Communication/PMR/IO/FileUploadRequest.pb-c.h>
+#include  <Communication/PMR/IO/FileUploadResponse.pb-c.h>
+#include  <Communication/PMR/IO/FileChunkUploadRequest.pb-c.h>
+#include  <Communication/PMR/IO/FileChunkUploadResponse.pb-c.h>
+#include  <Communication/PMR/IO/ExecuteProcessRequest.pb-c.h>
+#include  <Communication/PMR/IO/ExecuteProcessResponse.pb-c.h>
+#include  <Communication/PMR/IO/KillProcessRequest.pb-c.h>
+#include  <Communication/PMR/IO/KillProcessResponse.pb-c.h>
+#include  <Communication/PMR/IO/CreateRequest.pb-c.h>
+#include  <Communication/PMR/IO/CreateResponse.pb-c.h>
+#include  <Communication/PMR/IO/DeleteRequest.pb-c.h>
+#include  <Communication/PMR/IO/DeleteResponse.pb-c.h>
+#include  <Communication/PMR/IO/GetStorageInfoRequest.pb-c.h>
+#include  <Communication/PMR/IO/GetStorageInfoResponse.pb-c.h>
+#include  <Communication/PMR/IO/GetFilesRequest.pb-c.h>
+#include  <Communication/PMR/IO/GetFilesResponse.pb-c.h>
+
+
+
+uint32_t    FileUploadRequestFunc(MessageContainer* requestContainer)
+{
+    uint32_t status = OK;
+
+    MessageContainer responseContainer;
+
+    FileUploadRequest* request = file_upload_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+
+    FileUploadResponse response = FILE_UPLOAD_RESPONSE__INIT;
+
+
+    responseContainer = createContainer(MESSAGE_TYPE__FileUploadResponse,  requestContainer->token, false, &response, &file_upload_response__pack, &file_upload_response__get_packed_size);
+    if (status!= OK)
+    {
+        responseContainer.error = ERROR_CODE__INVALID_PROCESS_ID;
+        responseContainer.errormessage = "JOb Active or incorrect parameters";
+    }
+    responseContainer.continuous = false;
+    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    free(responseContainer.data.data);
+    SendChars(container_buffer, container_size);
+
+    return OK;
+}
+
+uint32_t    FileChunkUploadRequestFunc(MessageContainer* requestContainer)
+{
+    uint32_t status = OK;
+
+    MessageContainer responseContainer;
+
+    FileChunkUploadRequest* request = file_chunk_upload_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+
+    FileChunkUploadResponse response = FILE_CHUNK_UPLOAD_RESPONSE__INIT;
+
+
+    responseContainer = createContainer(MESSAGE_TYPE__FileChunkUploadResponse,  requestContainer->token, false, &response, &file_chunk_upload_response__pack, &file_chunk_upload_response__get_packed_size);
+    if (status!= OK)
+    {
+        responseContainer.error = ERROR_CODE__INVALID_PROCESS_ID;
+        responseContainer.errormessage = "JOb Active or incorrect parameters";
+    }
+    responseContainer.continuous = false;
+    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    free(responseContainer.data.data);
+    SendChars(container_buffer, container_size);
+
+    return OK;
+}
+uint32_t    ExecuteProcessRequestFunc(MessageContainer* requestContainer)
+{
+    uint32_t status = OK;
+
+    MessageContainer responseContainer;
+
+    ExecuteProcessRequest* request = execute_process_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+
+    ExecuteProcessResponse response = EXECUTE_PROCESS_RESPONSE__INIT;
+
+
+    responseContainer = createContainer(MESSAGE_TYPE__ExecuteProcessResponse,  requestContainer->token, false, &response, &execute_process_response__pack, &execute_process_response__get_packed_size);
+    if (status!= OK)
+    {
+        responseContainer.error = ERROR_CODE__INVALID_PROCESS_ID;
+        responseContainer.errormessage = "JOb Active or incorrect parameters";
+    }
+    responseContainer.continuous = false;
+    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    free(responseContainer.data.data);
+    SendChars(container_buffer, container_size);
+
+    return OK;
+}
+uint32_t    KillProcessRequestFunc(MessageContainer* requestContainer)
+{
+    uint32_t status = OK;
+
+    MessageContainer responseContainer;
+
+    KillProcessRequest* request = kill_process_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+
+    KillProcessResponse response = KILL_PROCESS_RESPONSE__INIT;
+
+
+    responseContainer = createContainer(MESSAGE_TYPE__KillProcessResponse,  requestContainer->token, false, &response, &kill_process_response__pack, &kill_process_response__get_packed_size);
+    if (status!= OK)
+    {
+        responseContainer.error = ERROR_CODE__INVALID_PROCESS_ID;
+        responseContainer.errormessage = "JOb Active or incorrect parameters";
+    }
+    responseContainer.continuous = false;
+    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    free(responseContainer.data.data);
+    SendChars(container_buffer, container_size);
+
+    return OK;
+}
+uint32_t    CreateRequestFunc(MessageContainer* requestContainer)
+{
+    uint32_t status = OK;
+
+    MessageContainer responseContainer;
+
+    CreateRequest* request = create_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+
+    CreateResponse response = CREATE_RESPONSE__INIT;
+
+
+    responseContainer = createContainer(MESSAGE_TYPE__CreateResponse,  requestContainer->token, false, &response, &create_response__pack, &create_response__get_packed_size);
+    if (status!= OK)
+    {
+        responseContainer.error = ERROR_CODE__INVALID_PROCESS_ID;
+        responseContainer.errormessage = "JOb Active or incorrect parameters";
+    }
+    responseContainer.continuous = false;
+    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    free(responseContainer.data.data);
+    SendChars(container_buffer, container_size);
+
+    return OK;
+}
+uint32_t    DeleteRequestFunc(MessageContainer* requestContainer)
+{
+    uint32_t status = OK;
+
+    MessageContainer responseContainer;
+
+    DeleteRequest* request = delete_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+
+    DeleteResponse response = DELETE_RESPONSE__INIT;
+
+
+    responseContainer = createContainer(MESSAGE_TYPE__DeleteResponse,  requestContainer->token, false, &response, &delete_response__pack, &delete_response__get_packed_size);
+    if (status!= OK)
+    {
+        responseContainer.error = ERROR_CODE__INVALID_PROCESS_ID;
+        responseContainer.errormessage = "JOb Active or incorrect parameters";
+    }
+    responseContainer.continuous = false;
+    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    free(responseContainer.data.data);
+    SendChars(container_buffer, container_size);
+
+    return OK;
+}
+uint32_t    GetStorageInfoRequestFunc(MessageContainer* requestContainer)
+{
+    uint32_t status = OK;
+
+    MessageContainer responseContainer;
+
+    GetStorageInfoRequest* request = get_storage_info_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+
+    GetStorageInfoResponse response = GET_STORAGE_INFO_RESPONSE__INIT;
+
+
+    responseContainer = createContainer(MESSAGE_TYPE__GetStorageInfoResponse,  requestContainer->token, false, &response, &get_storage_info_response__pack, &get_storage_info_response__get_packed_size);
+    if (status!= OK)
+    {
+        responseContainer.error = ERROR_CODE__INVALID_PROCESS_ID;
+        responseContainer.errormessage = "JOb Active or incorrect parameters";
+    }
+    responseContainer.continuous = false;
+    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    free(responseContainer.data.data);
+    SendChars(container_buffer, container_size);
+
+    return OK;
+}
+uint32_t    GetFilesRequestFunc(MessageContainer* requestContainer)
+{
+    uint32_t status = OK;
+
+    MessageContainer responseContainer;
+
+    GetFilesRequest* request = get_files_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+
+    GetFilesResponse response = GET_FILES_RESPONSE__INIT;
+
+
+    responseContainer = createContainer(MESSAGE_TYPE__GetFilesResponse,  requestContainer->token, false, &response, &get_files_response__pack, &get_files_response__get_packed_size);
+    if (status!= OK)
+    {
+        responseContainer.error = ERROR_CODE__INVALID_PROCESS_ID;
+        responseContainer.errormessage = "JOb Active or incorrect parameters";
+    }
+    responseContainer.continuous = false;
+    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    free(responseContainer.data.data);
+    SendChars(container_buffer, container_size);
+
+    return OK;
+}
diff --git a/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.h b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.h
new file mode 100644
index 000000000..4a76a0aad
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.h
@@ -0,0 +1,23 @@
+/*
+ * FileSystem.h
+ *
+ *  Created on: Oct 23, 2018
+ *      Author: shlomo
+ */
+
+#ifndef COMMON_SWUPDATE_FILESYSTEM_H_
+#define COMMON_SWUPDATE_FILESYSTEM_H_
+
+uint32_t    FileUploadRequestFunc(MessageContainer* requestContainer);
+uint32_t    FileChunkUploadRequestFunc(MessageContainer* requestContainer);
+uint32_t    ExecuteProcessRequestFunc(MessageContainer* requestContainer);
+uint32_t    KillProcessRequestFunc(MessageContainer* requestContainer);
+uint32_t    CreateRequestFunc(MessageContainer* requestContainer);
+uint32_t    DeleteRequestFunc(MessageContainer* requestContainer);
+uint32_t    GetStorageInfoRequestFunc(MessageContainer* requestContainer);
+uint32_t    GetFilesRequestFunc(MessageContainer* requestContainer);
+
+
+
+
+#endif /* COMMON_SWUPDATE_FILESYSTEM_H_ */
diff --git a/Software/Embedded_SW/Embedded/Communication/Container.c b/Software/Embedded_SW/Embedded/Communication/Container.c
index a9bffa90d..751f7bfca 100644
--- a/Software/Embedded_SW/Embedded/Communication/Container.c
+++ b/Software/Embedded_SW/Embedded/Communication/Container.c
@@ -37,6 +37,7 @@
 #include "Modules/General/process.h"
 #include "Modules/Thread/Thread_ex.h"
 
+#include "Common/SWUpdate/FileSystem.h"
 #include "Communication/CommunicationTask.h"
 
 #include "StateMachines/Printing/PrintingSTM.h"
@@ -310,6 +311,30 @@ void receive_callback(char* buffer, size_t length)
          case MESSAGE_TYPE__KeepAliveRequest:
              KeepAliveRequestFunc(requestContainer);
              break;
+         case MESSAGE_TYPE__FileUploadRequest:
+             FileUploadRequestFunc(requestContainer);
+             break;
+         case MESSAGE_TYPE__FileChunkUploadRequest:
+             FileChunkUploadRequestFunc(requestContainer);
+             break;
+         case MESSAGE_TYPE__ExecuteProcessRequest:
+             ExecuteProcessRequestFunc(requestContainer);
+             break;
+         case MESSAGE_TYPE__KillProcessRequest:
+             KillProcessRequestFunc(requestContainer);
+             break;
+         case MESSAGE_TYPE__CreateRequest:
+             CreateRequestFunc(requestContainer);
+             break;
+         case MESSAGE_TYPE__DeleteRequest:
+             DeleteRequestFunc(requestContainer);
+             break;
+         case MESSAGE_TYPE__GetStorageInfoRequest:
+             GetStorageInfoRequestFunc(requestContainer);
+             break;
+         case MESSAGE_TYPE__GetFilesRequest:
+             GetFilesRequestFunc(requestContainer);
+             break;
          default:
              //unsupported message type !!
              LOG_ERROR (requestContainer->type,"unsupported message type");
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.c
index b708cf4cd..f172f53f5 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.c
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.c
@@ -7,7 +7,7 @@
 #endif
 
 #include "MessageType.pb-c.h"
-static const ProtobufCEnumValue message_type__enum_values_by_number[175] =
+static const ProtobufCEnumValue message_type__enum_values_by_number[183] =
 {
   { "None", "MESSAGE_TYPE__None", 0 },
   { "ErrorResponse", "MESSAGE_TYPE__ErrorResponse", 1 },
@@ -184,11 +184,19 @@ static const ProtobufCEnumValue message_type__enum_values_by_number[175] =
   { "ExecuteProcessResponse", "MESSAGE_TYPE__ExecuteProcessResponse", 7005 },
   { "KillProcessRequest", "MESSAGE_TYPE__KillProcessRequest", 7006 },
   { "KillProcessResponse", "MESSAGE_TYPE__KillProcessResponse", 7007 },
+  { "CreateRequest", "MESSAGE_TYPE__CreateRequest", 7008 },
+  { "CreateResponse", "MESSAGE_TYPE__CreateResponse", 7009 },
+  { "DeleteRequest", "MESSAGE_TYPE__DeleteRequest", 7010 },
+  { "DeleteResponse", "MESSAGE_TYPE__DeleteResponse", 7011 },
+  { "GetStorageInfoRequest", "MESSAGE_TYPE__GetStorageInfoRequest", 7012 },
+  { "GetStorageInfoResponse", "MESSAGE_TYPE__GetStorageInfoResponse", 7013 },
+  { "GetFilesRequest", "MESSAGE_TYPE__GetFilesRequest", 7014 },
+  { "GetFilesResponse", "MESSAGE_TYPE__GetFilesResponse", 7015 },
 };
 static const ProtobufCIntRange message_type__value_ranges[] = {
-{0, 0},{3, 2},{1000, 98},{2000, 107},{3000, 147},{4000, 153},{5000, 157},{6000, 161},{7000, 167},{0, 175}
+{0, 0},{3, 2},{1000, 98},{2000, 107},{3000, 147},{4000, 153},{5000, 157},{6000, 161},{7000, 167},{0, 183}
 };
-static const ProtobufCEnumValueIndex message_type__enum_values_by_name[175] =
+static const ProtobufCEnumValueIndex message_type__enum_values_by_name[183] =
 {
   { "AbortJobRequest", 149 },
   { "AbortJobResponse", 150 },
@@ -196,6 +204,10 @@ static const ProtobufCEnumValueIndex message_type__enum_values_by_name[175] =
   { "CalculateResponse", 3 },
   { "ConnectRequest", 163 },
   { "ConnectResponse", 164 },
+  { "CreateRequest", 175 },
+  { "CreateResponse", 176 },
+  { "DeleteRequest", 177 },
+  { "DeleteResponse", 178 },
   { "DirectSynchronizationRequest", 103 },
   { "DirectSynchronizationResponse", 104 },
   { "DisconnectRequest", 165 },
@@ -220,6 +232,10 @@ static const ProtobufCEnumValueIndex message_type__enum_values_by_name[175] =
   { "FileChunkUploadResponse", 170 },
   { "FileUploadRequest", 167 },
   { "FileUploadResponse", 168 },
+  { "GetFilesRequest", 181 },
+  { "GetFilesResponse", 182 },
+  { "GetStorageInfoRequest", 179 },
+  { "GetStorageInfoResponse", 180 },
   { "JobRequest", 147 },
   { "JobResponse", 148 },
   { "KeepAliveRequest", 161 },
@@ -373,9 +389,9 @@ const ProtobufCEnumDescriptor message_type__descriptor =
   "MessageType",
   "MessageType",
   "",
-  175,
+  183,
   message_type__enum_values_by_number,
-  175,
+  183,
   message_type__enum_values_by_name,
   9,
   message_type__value_ranges,
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.h
index 05a859f00..a698fc09a 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.h
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.h
@@ -194,7 +194,15 @@ typedef enum _MessageType {
   MESSAGE_TYPE__ExecuteProcessRequest = 7004,
   MESSAGE_TYPE__ExecuteProcessResponse = 7005,
   MESSAGE_TYPE__KillProcessRequest = 7006,
-  MESSAGE_TYPE__KillProcessResponse = 7007
+  MESSAGE_TYPE__KillProcessResponse = 7007,
+  MESSAGE_TYPE__CreateRequest = 7008,
+  MESSAGE_TYPE__CreateResponse = 7009,
+  MESSAGE_TYPE__DeleteRequest = 7010,
+  MESSAGE_TYPE__DeleteResponse = 7011,
+  MESSAGE_TYPE__GetStorageInfoRequest = 7012,
+  MESSAGE_TYPE__GetStorageInfoResponse = 7013,
+  MESSAGE_TYPE__GetFilesRequest = 7014,
+  MESSAGE_TYPE__GetFilesResponse = 7015
     PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(MESSAGE_TYPE)
 } MessageType;
 
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DigitalPin.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DigitalPin.pb-c.c
deleted file mode 100644
index 48e358d3d..000000000
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DigitalPin.pb-c.c
+++ /dev/null
@@ -1,105 +0,0 @@
-/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
-/* Generated from: DigitalPin.proto */
-
-/* Do not generate deprecated warnings for self */
-#ifndef PROTOBUF_C__NO_DEPRECATED
-#define PROTOBUF_C__NO_DEPRECATED
-#endif
-
-#include "DigitalPin.pb-c.h"
-void   digital_pin__init
-                     (DigitalPin         *message)
-{
-  static const DigitalPin init_value = DIGITAL_PIN__INIT;
-  *message = init_value;
-}
-size_t digital_pin__get_packed_size
-                     (const DigitalPin *message)
-{
-  assert(message->base.descriptor == &digital_pin__descriptor);
-  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
-}
-size_t digital_pin__pack
-                     (const DigitalPin *message,
-                      uint8_t       *out)
-{
-  assert(message->base.descriptor == &digital_pin__descriptor);
-  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
-}
-size_t digital_pin__pack_to_buffer
-                     (const DigitalPin *message,
-                      ProtobufCBuffer *buffer)
-{
-  assert(message->base.descriptor == &digital_pin__descriptor);
-  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
-}
-DigitalPin *
-       digital_pin__unpack
-                     (ProtobufCAllocator  *allocator,
-                      size_t               len,
-                      const uint8_t       *data)
-{
-  return (DigitalPin *)
-     protobuf_c_message_unpack (&digital_pin__descriptor,
-                                allocator, len, data);
-}
-void   digital_pin__free_unpacked
-                     (DigitalPin *message,
-                      ProtobufCAllocator *allocator)
-{
-  if(!message)
-    return;
-  assert(message->base.descriptor == &digital_pin__descriptor);
-  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
-}
-static const ProtobufCFieldDescriptor digital_pin__field_descriptors[2] =
-{
-  {
-    "Port",
-    1,
-    PROTOBUF_C_LABEL_OPTIONAL,
-    PROTOBUF_C_TYPE_INT32,
-    offsetof(DigitalPin, has_port),
-    offsetof(DigitalPin, port),
-    NULL,
-    NULL,
-    0,             /* flags */
-    0,NULL,NULL    /* reserved1,reserved2, etc */
-  },
-  {
-    "Value",
-    2,
-    PROTOBUF_C_LABEL_OPTIONAL,
-    PROTOBUF_C_TYPE_BOOL,
-    offsetof(DigitalPin, has_value),
-    offsetof(DigitalPin, value),
-    NULL,
-    NULL,
-    0,             /* flags */
-    0,NULL,NULL    /* reserved1,reserved2, etc */
-  },
-};
-static const unsigned digital_pin__field_indices_by_name[] = {
-  0,   /* field[0] = Port */
-  1,   /* field[1] = Value */
-};
-static const ProtobufCIntRange digital_pin__number_ranges[1 + 1] =
-{
-  { 1, 0 },
-  { 0, 2 }
-};
-const ProtobufCMessageDescriptor digital_pin__descriptor =
-{
-  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
-  "DigitalPin",
-  "DigitalPin",
-  "DigitalPin",
-  "",
-  sizeof(DigitalPin),
-  2,
-  digital_pin__field_descriptors,
-  digital_pin__field_indices_by_name,
-  1,  digital_pin__number_ranges,
-  (ProtobufCMessageInit) digital_pin__init,
-  NULL,NULL,NULL    /* reserved[123] */
-};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/CreateRequest.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/IO/CreateRequest.pb-c.c
new file mode 100644
index 000000000..611e27607
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/CreateRequest.pb-c.c
@@ -0,0 +1,105 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: CreateRequest.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "CreateRequest.pb-c.h"
+void   create_request__init
+                     (CreateRequest         *message)
+{
+  static const CreateRequest init_value = CREATE_REQUEST__INIT;
+  *message = init_value;
+}
+size_t create_request__get_packed_size
+                     (const CreateRequest *message)
+{
+  assert(message->base.descriptor == &create_request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t create_request__pack
+                     (const CreateRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->base.descriptor == &create_request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t create_request__pack_to_buffer
+                     (const CreateRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->base.descriptor == &create_request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CreateRequest *
+       create_request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CreateRequest *)
+     protobuf_c_message_unpack (&create_request__descriptor,
+                                allocator, len, data);
+}
+void   create_request__free_unpacked
+                     (CreateRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->base.descriptor == &create_request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+static const ProtobufCFieldDescriptor create_request__field_descriptors[2] =
+{
+  {
+    "Attribute",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_ENUM,
+    offsetof(CreateRequest, has_attribute),
+    offsetof(CreateRequest, attribute),
+    &file_attribute__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "Path",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(CreateRequest, path),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned create_request__field_indices_by_name[] = {
+  0,   /* field[0] = Attribute */
+  1,   /* field[1] = Path */
+};
+static const ProtobufCIntRange create_request__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 2 }
+};
+const ProtobufCMessageDescriptor create_request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CreateRequest",
+  "CreateRequest",
+  "CreateRequest",
+  "",
+  sizeof(CreateRequest),
+  2,
+  create_request__field_descriptors,
+  create_request__field_indices_by_name,
+  1,  create_request__number_ranges,
+  (ProtobufCMessageInit) create_request__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/CreateRequest.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/IO/CreateRequest.pb-c.h
new file mode 100644
index 000000000..69bfd8969
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/CreateRequest.pb-c.h
@@ -0,0 +1,74 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: CreateRequest.proto */
+
+#ifndef PROTOBUF_C_CreateRequest_2eproto__INCLUDED
+#define PROTOBUF_C_CreateRequest_2eproto__INCLUDED
+
+#include <protobuf-c/protobuf-c.h>
+
+PROTOBUF_C__BEGIN_DECLS
+
+#if PROTOBUF_C_VERSION_NUMBER < 1003000
+# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
+#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION
+# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
+#endif
+
+#include "FileAttribute.pb-c.h"
+
+typedef struct _CreateRequest CreateRequest;
+
+
+/* --- enums --- */
+
+
+/* --- messages --- */
+
+struct  _CreateRequest
+{
+  ProtobufCMessage base;
+  protobuf_c_boolean has_attribute;
+  FileAttribute attribute;
+  char *path;
+};
+#define CREATE_REQUEST__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&create_request__descriptor) \
+    , 0, FILE_ATTRIBUTE__Unspecified, NULL }
+
+
+/* CreateRequest methods */
+void   create_request__init
+                     (CreateRequest         *message);
+size_t create_request__get_packed_size
+                     (const CreateRequest   *message);
+size_t create_request__pack
+                     (const CreateRequest   *message,
+                      uint8_t             *out);
+size_t create_request__pack_to_buffer
+                     (const CreateRequest   *message,
+                      ProtobufCBuffer     *buffer);
+CreateRequest *
+       create_request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   create_request__free_unpacked
+                     (CreateRequest *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*CreateRequest_Closure)
+                 (const CreateRequest *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCMessageDescriptor create_request__descriptor;
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_CreateRequest_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/CreateResponse.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/IO/CreateResponse.pb-c.c
new file mode 100644
index 000000000..57784eecf
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/CreateResponse.pb-c.c
@@ -0,0 +1,72 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: CreateResponse.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "CreateResponse.pb-c.h"
+void   create_response__init
+                     (CreateResponse         *message)
+{
+  static const CreateResponse init_value = CREATE_RESPONSE__INIT;
+  *message = init_value;
+}
+size_t create_response__get_packed_size
+                     (const CreateResponse *message)
+{
+  assert(message->base.descriptor == &create_response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t create_response__pack
+                     (const CreateResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->base.descriptor == &create_response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t create_response__pack_to_buffer
+                     (const CreateResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->base.descriptor == &create_response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+CreateResponse *
+       create_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (CreateResponse *)
+     protobuf_c_message_unpack (&create_response__descriptor,
+                                allocator, len, data);
+}
+void   create_response__free_unpacked
+                     (CreateResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->base.descriptor == &create_response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+#define create_response__field_descriptors NULL
+#define create_response__field_indices_by_name NULL
+#define create_response__number_ranges NULL
+const ProtobufCMessageDescriptor create_response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "CreateResponse",
+  "CreateResponse",
+  "CreateResponse",
+  "",
+  sizeof(CreateResponse),
+  0,
+  create_response__field_descriptors,
+  create_response__field_indices_by_name,
+  0,  create_response__number_ranges,
+  (ProtobufCMessageInit) create_response__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DigitalPin.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/IO/CreateResponse.pb-c.h
index 2fd18cdff..bec8189f6 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DigitalPin.pb-c.h
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/CreateResponse.pb-c.h
@@ -1,8 +1,8 @@
 /* Generated by the protocol buffer compiler.  DO NOT EDIT! */
-/* Generated from: DigitalPin.proto */
+/* Generated from: CreateResponse.proto */
 
-#ifndef PROTOBUF_C_DigitalPin_2eproto__INCLUDED
-#define PROTOBUF_C_DigitalPin_2eproto__INCLUDED
+#ifndef PROTOBUF_C_CreateResponse_2eproto__INCLUDED
+#define PROTOBUF_C_CreateResponse_2eproto__INCLUDED
 
 #include <protobuf-c/protobuf-c.h>
 
@@ -15,7 +15,7 @@ PROTOBUF_C__BEGIN_DECLS
 #endif
 
 
-typedef struct _DigitalPin DigitalPin;
+typedef struct _CreateResponse CreateResponse;
 
 
 /* --- enums --- */
@@ -23,42 +23,38 @@ typedef struct _DigitalPin DigitalPin;
 
 /* --- messages --- */
 
-struct  _DigitalPin
+struct  _CreateResponse
 {
   ProtobufCMessage base;
-  protobuf_c_boolean has_port;
-  int32_t port;
-  protobuf_c_boolean has_value;
-  protobuf_c_boolean value;
 };
-#define DIGITAL_PIN__INIT \
- { PROTOBUF_C_MESSAGE_INIT (&digital_pin__descriptor) \
-    , 0, 0, 0, 0 }
+#define CREATE_RESPONSE__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&create_response__descriptor) \
+     }
 
 
-/* DigitalPin methods */
-void   digital_pin__init
-                     (DigitalPin         *message);
-size_t digital_pin__get_packed_size
-                     (const DigitalPin   *message);
-size_t digital_pin__pack
-                     (const DigitalPin   *message,
+/* CreateResponse methods */
+void   create_response__init
+                     (CreateResponse         *message);
+size_t create_response__get_packed_size
+                     (const CreateResponse   *message);
+size_t create_response__pack
+                     (const CreateResponse   *message,
                       uint8_t             *out);
-size_t digital_pin__pack_to_buffer
-                     (const DigitalPin   *message,
+size_t create_response__pack_to_buffer
+                     (const CreateResponse   *message,
                       ProtobufCBuffer     *buffer);
-DigitalPin *
-       digital_pin__unpack
+CreateResponse *
+       create_response__unpack
                      (ProtobufCAllocator  *allocator,
                       size_t               len,
                       const uint8_t       *data);
-void   digital_pin__free_unpacked
-                     (DigitalPin *message,
+void   create_response__free_unpacked
+                     (CreateResponse *message,
                       ProtobufCAllocator *allocator);
 /* --- per-message closures --- */
 
-typedef void (*DigitalPin_Closure)
-                 (const DigitalPin *message,
+typedef void (*CreateResponse_Closure)
+                 (const CreateResponse *message,
                   void *closure_data);
 
 /* --- services --- */
@@ -66,9 +62,9 @@ typedef void (*DigitalPin_Closure)
 
 /* --- descriptors --- */
 
-extern const ProtobufCMessageDescriptor digital_pin__descriptor;
+extern const ProtobufCMessageDescriptor create_response__descriptor;
 
 PROTOBUF_C__END_DECLS
 
 
-#endif  /* PROTOBUF_C_DigitalPin_2eproto__INCLUDED */
+#endif  /* PROTOBUF_C_CreateResponse_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/DeleteRequest.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/IO/DeleteRequest.pb-c.c
new file mode 100644
index 000000000..27fd07849
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/DeleteRequest.pb-c.c
@@ -0,0 +1,92 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: DeleteRequest.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "DeleteRequest.pb-c.h"
+void   delete_request__init
+                     (DeleteRequest         *message)
+{
+  static const DeleteRequest init_value = DELETE_REQUEST__INIT;
+  *message = init_value;
+}
+size_t delete_request__get_packed_size
+                     (const DeleteRequest *message)
+{
+  assert(message->base.descriptor == &delete_request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t delete_request__pack
+                     (const DeleteRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->base.descriptor == &delete_request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t delete_request__pack_to_buffer
+                     (const DeleteRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->base.descriptor == &delete_request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+DeleteRequest *
+       delete_request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (DeleteRequest *)
+     protobuf_c_message_unpack (&delete_request__descriptor,
+                                allocator, len, data);
+}
+void   delete_request__free_unpacked
+                     (DeleteRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->base.descriptor == &delete_request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+static const ProtobufCFieldDescriptor delete_request__field_descriptors[1] =
+{
+  {
+    "Path",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(DeleteRequest, path),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned delete_request__field_indices_by_name[] = {
+  0,   /* field[0] = Path */
+};
+static const ProtobufCIntRange delete_request__number_ranges[1 + 1] =
+{
+  { 2, 0 },
+  { 0, 1 }
+};
+const ProtobufCMessageDescriptor delete_request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "DeleteRequest",
+  "DeleteRequest",
+  "DeleteRequest",
+  "",
+  sizeof(DeleteRequest),
+  1,
+  delete_request__field_descriptors,
+  delete_request__field_indices_by_name,
+  1,  delete_request__number_ranges,
+  (ProtobufCMessageInit) delete_request__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/DeleteRequest.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/IO/DeleteRequest.pb-c.h
new file mode 100644
index 000000000..79dabee5e
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/DeleteRequest.pb-c.h
@@ -0,0 +1,71 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: DeleteRequest.proto */
+
+#ifndef PROTOBUF_C_DeleteRequest_2eproto__INCLUDED
+#define PROTOBUF_C_DeleteRequest_2eproto__INCLUDED
+
+#include <protobuf-c/protobuf-c.h>
+
+PROTOBUF_C__BEGIN_DECLS
+
+#if PROTOBUF_C_VERSION_NUMBER < 1003000
+# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
+#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION
+# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
+#endif
+
+
+typedef struct _DeleteRequest DeleteRequest;
+
+
+/* --- enums --- */
+
+
+/* --- messages --- */
+
+struct  _DeleteRequest
+{
+  ProtobufCMessage base;
+  char *path;
+};
+#define DELETE_REQUEST__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&delete_request__descriptor) \
+    , NULL }
+
+
+/* DeleteRequest methods */
+void   delete_request__init
+                     (DeleteRequest         *message);
+size_t delete_request__get_packed_size
+                     (const DeleteRequest   *message);
+size_t delete_request__pack
+                     (const DeleteRequest   *message,
+                      uint8_t             *out);
+size_t delete_request__pack_to_buffer
+                     (const DeleteRequest   *message,
+                      ProtobufCBuffer     *buffer);
+DeleteRequest *
+       delete_request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   delete_request__free_unpacked
+                     (DeleteRequest *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*DeleteRequest_Closure)
+                 (const DeleteRequest *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCMessageDescriptor delete_request__descriptor;
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_DeleteRequest_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/DeleteResponse.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/IO/DeleteResponse.pb-c.c
new file mode 100644
index 000000000..7f5aac69c
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/DeleteResponse.pb-c.c
@@ -0,0 +1,72 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: DeleteResponse.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "DeleteResponse.pb-c.h"
+void   delete_response__init
+                     (DeleteResponse         *message)
+{
+  static const DeleteResponse init_value = DELETE_RESPONSE__INIT;
+  *message = init_value;
+}
+size_t delete_response__get_packed_size
+                     (const DeleteResponse *message)
+{
+  assert(message->base.descriptor == &delete_response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t delete_response__pack
+                     (const DeleteResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->base.descriptor == &delete_response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t delete_response__pack_to_buffer
+                     (const DeleteResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->base.descriptor == &delete_response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+DeleteResponse *
+       delete_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (DeleteResponse *)
+     protobuf_c_message_unpack (&delete_response__descriptor,
+                                allocator, len, data);
+}
+void   delete_response__free_unpacked
+                     (DeleteResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->base.descriptor == &delete_response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+#define delete_response__field_descriptors NULL
+#define delete_response__field_indices_by_name NULL
+#define delete_response__number_ranges NULL
+const ProtobufCMessageDescriptor delete_response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "DeleteResponse",
+  "DeleteResponse",
+  "DeleteResponse",
+  "",
+  sizeof(DeleteResponse),
+  0,
+  delete_response__field_descriptors,
+  delete_response__field_indices_by_name,
+  0,  delete_response__number_ranges,
+  (ProtobufCMessageInit) delete_response__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/DeleteResponse.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/IO/DeleteResponse.pb-c.h
new file mode 100644
index 000000000..3f06abbaa
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/DeleteResponse.pb-c.h
@@ -0,0 +1,70 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: DeleteResponse.proto */
+
+#ifndef PROTOBUF_C_DeleteResponse_2eproto__INCLUDED
+#define PROTOBUF_C_DeleteResponse_2eproto__INCLUDED
+
+#include <protobuf-c/protobuf-c.h>
+
+PROTOBUF_C__BEGIN_DECLS
+
+#if PROTOBUF_C_VERSION_NUMBER < 1003000
+# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
+#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION
+# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
+#endif
+
+
+typedef struct _DeleteResponse DeleteResponse;
+
+
+/* --- enums --- */
+
+
+/* --- messages --- */
+
+struct  _DeleteResponse
+{
+  ProtobufCMessage base;
+};
+#define DELETE_RESPONSE__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&delete_response__descriptor) \
+     }
+
+
+/* DeleteResponse methods */
+void   delete_response__init
+                     (DeleteResponse         *message);
+size_t delete_response__get_packed_size
+                     (const DeleteResponse   *message);
+size_t delete_response__pack
+                     (const DeleteResponse   *message,
+                      uint8_t             *out);
+size_t delete_response__pack_to_buffer
+                     (const DeleteResponse   *message,
+                      ProtobufCBuffer     *buffer);
+DeleteResponse *
+       delete_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   delete_response__free_unpacked
+                     (DeleteResponse *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*DeleteResponse_Closure)
+                 (const DeleteResponse *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCMessageDescriptor delete_response__descriptor;
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_DeleteResponse_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/ExecuteProcessRequest.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/IO/ExecuteProcessRequest.pb-c.c
new file mode 100644
index 000000000..a9c8d5f1b
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/ExecuteProcessRequest.pb-c.c
@@ -0,0 +1,105 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: ExecuteProcessRequest.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "ExecuteProcessRequest.pb-c.h"
+void   execute_process_request__init
+                     (ExecuteProcessRequest         *message)
+{
+  static const ExecuteProcessRequest init_value = EXECUTE_PROCESS_REQUEST__INIT;
+  *message = init_value;
+}
+size_t execute_process_request__get_packed_size
+                     (const ExecuteProcessRequest *message)
+{
+  assert(message->base.descriptor == &execute_process_request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t execute_process_request__pack
+                     (const ExecuteProcessRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->base.descriptor == &execute_process_request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t execute_process_request__pack_to_buffer
+                     (const ExecuteProcessRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->base.descriptor == &execute_process_request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+ExecuteProcessRequest *
+       execute_process_request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (ExecuteProcessRequest *)
+     protobuf_c_message_unpack (&execute_process_request__descriptor,
+                                allocator, len, data);
+}
+void   execute_process_request__free_unpacked
+                     (ExecuteProcessRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->base.descriptor == &execute_process_request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+static const ProtobufCFieldDescriptor execute_process_request__field_descriptors[2] =
+{
+  {
+    "UploadID",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(ExecuteProcessRequest, uploadid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "FileName",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(ExecuteProcessRequest, filename),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned execute_process_request__field_indices_by_name[] = {
+  1,   /* field[1] = FileName */
+  0,   /* field[0] = UploadID */
+};
+static const ProtobufCIntRange execute_process_request__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 2 }
+};
+const ProtobufCMessageDescriptor execute_process_request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "ExecuteProcessRequest",
+  "ExecuteProcessRequest",
+  "ExecuteProcessRequest",
+  "",
+  sizeof(ExecuteProcessRequest),
+  2,
+  execute_process_request__field_descriptors,
+  execute_process_request__field_indices_by_name,
+  1,  execute_process_request__number_ranges,
+  (ProtobufCMessageInit) execute_process_request__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/ExecuteProcessRequest.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/IO/ExecuteProcessRequest.pb-c.h
new file mode 100644
index 000000000..b8afe6331
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/ExecuteProcessRequest.pb-c.h
@@ -0,0 +1,72 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: ExecuteProcessRequest.proto */
+
+#ifndef PROTOBUF_C_ExecuteProcessRequest_2eproto__INCLUDED
+#define PROTOBUF_C_ExecuteProcessRequest_2eproto__INCLUDED
+
+#include <protobuf-c/protobuf-c.h>
+
+PROTOBUF_C__BEGIN_DECLS
+
+#if PROTOBUF_C_VERSION_NUMBER < 1003000
+# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
+#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION
+# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
+#endif
+
+
+typedef struct _ExecuteProcessRequest ExecuteProcessRequest;
+
+
+/* --- enums --- */
+
+
+/* --- messages --- */
+
+struct  _ExecuteProcessRequest
+{
+  ProtobufCMessage base;
+  char *uploadid;
+  char *filename;
+};
+#define EXECUTE_PROCESS_REQUEST__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&execute_process_request__descriptor) \
+    , NULL, NULL }
+
+
+/* ExecuteProcessRequest methods */
+void   execute_process_request__init
+                     (ExecuteProcessRequest         *message);
+size_t execute_process_request__get_packed_size
+                     (const ExecuteProcessRequest   *message);
+size_t execute_process_request__pack
+                     (const ExecuteProcessRequest   *message,
+                      uint8_t             *out);
+size_t execute_process_request__pack_to_buffer
+                     (const ExecuteProcessRequest   *message,
+                      ProtobufCBuffer     *buffer);
+ExecuteProcessRequest *
+       execute_process_request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   execute_process_request__free_unpacked
+                     (ExecuteProcessRequest *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*ExecuteProcessRequest_Closure)
+                 (const ExecuteProcessRequest *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCMessageDescriptor execute_process_request__descriptor;
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_ExecuteProcessRequest_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/ExecuteProcessResponse.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/IO/ExecuteProcessResponse.pb-c.c
new file mode 100644
index 000000000..95799299c
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/ExecuteProcessResponse.pb-c.c
@@ -0,0 +1,92 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: ExecuteProcessResponse.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "ExecuteProcessResponse.pb-c.h"
+void   execute_process_response__init
+                     (ExecuteProcessResponse         *message)
+{
+  static const ExecuteProcessResponse init_value = EXECUTE_PROCESS_RESPONSE__INIT;
+  *message = init_value;
+}
+size_t execute_process_response__get_packed_size
+                     (const ExecuteProcessResponse *message)
+{
+  assert(message->base.descriptor == &execute_process_response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t execute_process_response__pack
+                     (const ExecuteProcessResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->base.descriptor == &execute_process_response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t execute_process_response__pack_to_buffer
+                     (const ExecuteProcessResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->base.descriptor == &execute_process_response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+ExecuteProcessResponse *
+       execute_process_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (ExecuteProcessResponse *)
+     protobuf_c_message_unpack (&execute_process_response__descriptor,
+                                allocator, len, data);
+}
+void   execute_process_response__free_unpacked
+                     (ExecuteProcessResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->base.descriptor == &execute_process_response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+static const ProtobufCFieldDescriptor execute_process_response__field_descriptors[1] =
+{
+  {
+    "ProcessID",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(ExecuteProcessResponse, processid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned execute_process_response__field_indices_by_name[] = {
+  0,   /* field[0] = ProcessID */
+};
+static const ProtobufCIntRange execute_process_response__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 1 }
+};
+const ProtobufCMessageDescriptor execute_process_response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "ExecuteProcessResponse",
+  "ExecuteProcessResponse",
+  "ExecuteProcessResponse",
+  "",
+  sizeof(ExecuteProcessResponse),
+  1,
+  execute_process_response__field_descriptors,
+  execute_process_response__field_indices_by_name,
+  1,  execute_process_response__number_ranges,
+  (ProtobufCMessageInit) execute_process_response__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/ExecuteProcessResponse.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/IO/ExecuteProcessResponse.pb-c.h
new file mode 100644
index 000000000..cb3fd586b
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/ExecuteProcessResponse.pb-c.h
@@ -0,0 +1,71 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: ExecuteProcessResponse.proto */
+
+#ifndef PROTOBUF_C_ExecuteProcessResponse_2eproto__INCLUDED
+#define PROTOBUF_C_ExecuteProcessResponse_2eproto__INCLUDED
+
+#include <protobuf-c/protobuf-c.h>
+
+PROTOBUF_C__BEGIN_DECLS
+
+#if PROTOBUF_C_VERSION_NUMBER < 1003000
+# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
+#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION
+# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
+#endif
+
+
+typedef struct _ExecuteProcessResponse ExecuteProcessResponse;
+
+
+/* --- enums --- */
+
+
+/* --- messages --- */
+
+struct  _ExecuteProcessResponse
+{
+  ProtobufCMessage base;
+  char *processid;
+};
+#define EXECUTE_PROCESS_RESPONSE__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&execute_process_response__descriptor) \
+    , NULL }
+
+
+/* ExecuteProcessResponse methods */
+void   execute_process_response__init
+                     (ExecuteProcessResponse         *message);
+size_t execute_process_response__get_packed_size
+                     (const ExecuteProcessResponse   *message);
+size_t execute_process_response__pack
+                     (const ExecuteProcessResponse   *message,
+                      uint8_t             *out);
+size_t execute_process_response__pack_to_buffer
+                     (const ExecuteProcessResponse   *message,
+                      ProtobufCBuffer     *buffer);
+ExecuteProcessResponse *
+       execute_process_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   execute_process_response__free_unpacked
+                     (ExecuteProcessResponse *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*ExecuteProcessResponse_Closure)
+                 (const ExecuteProcessResponse *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCMessageDescriptor execute_process_response__descriptor;
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_ExecuteProcessResponse_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileAttribute.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileAttribute.pb-c.c
new file mode 100644
index 000000000..e1462f37e
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileAttribute.pb-c.c
@@ -0,0 +1,47 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: FileAttribute.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "FileAttribute.pb-c.h"
+static const ProtobufCEnumValue file_attribute__enum_values_by_number[7] =
+{
+  { "Unspecified", "FILE_ATTRIBUTE__Unspecified", 0 },
+  { "ReadOnly", "FILE_ATTRIBUTE__ReadOnly", 1 },
+  { "Hidden", "FILE_ATTRIBUTE__Hidden", 2 },
+  { "System", "FILE_ATTRIBUTE__System", 4 },
+  { "VolumeLabel", "FILE_ATTRIBUTE__VolumeLabel", 8 },
+  { "Directory", "FILE_ATTRIBUTE__Directory", 16 },
+  { "Archive", "FILE_ATTRIBUTE__Archive", 32 },
+};
+static const ProtobufCIntRange file_attribute__value_ranges[] = {
+{0, 0},{4, 3},{8, 4},{16, 5},{32, 6},{0, 7}
+};
+static const ProtobufCEnumValueIndex file_attribute__enum_values_by_name[7] =
+{
+  { "Archive", 6 },
+  { "Directory", 5 },
+  { "Hidden", 2 },
+  { "ReadOnly", 1 },
+  { "System", 3 },
+  { "Unspecified", 0 },
+  { "VolumeLabel", 4 },
+};
+const ProtobufCEnumDescriptor file_attribute__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "FileAttribute",
+  "FileAttribute",
+  "FileAttribute",
+  "",
+  7,
+  file_attribute__enum_values_by_number,
+  7,
+  file_attribute__enum_values_by_name,
+  5,
+  file_attribute__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileAttribute.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileAttribute.pb-c.h
new file mode 100644
index 000000000..5ba7f4f44
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileAttribute.pb-c.h
@@ -0,0 +1,48 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: FileAttribute.proto */
+
+#ifndef PROTOBUF_C_FileAttribute_2eproto__INCLUDED
+#define PROTOBUF_C_FileAttribute_2eproto__INCLUDED
+
+#include <protobuf-c/protobuf-c.h>
+
+PROTOBUF_C__BEGIN_DECLS
+
+#if PROTOBUF_C_VERSION_NUMBER < 1003000
+# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
+#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION
+# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
+#endif
+
+
+
+
+/* --- enums --- */
+
+typedef enum _FileAttribute {
+  FILE_ATTRIBUTE__Unspecified = 0,
+  FILE_ATTRIBUTE__Archive = 32,
+  FILE_ATTRIBUTE__Directory = 16,
+  FILE_ATTRIBUTE__Hidden = 2,
+  FILE_ATTRIBUTE__ReadOnly = 1,
+  FILE_ATTRIBUTE__System = 4,
+  FILE_ATTRIBUTE__VolumeLabel = 8
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(FILE_ATTRIBUTE)
+} FileAttribute;
+
+/* --- messages --- */
+
+/* --- per-message closures --- */
+
+
+/* --- services --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCEnumDescriptor    file_attribute__descriptor;
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_FileAttribute_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileChunkUploadRequest.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileChunkUploadRequest.pb-c.c
new file mode 100644
index 000000000..a4ca27f4f
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileChunkUploadRequest.pb-c.c
@@ -0,0 +1,119 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: FileChunkUploadRequest.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "FileChunkUploadRequest.pb-c.h"
+void   file_chunk_upload_request__init
+                     (FileChunkUploadRequest         *message)
+{
+  static const FileChunkUploadRequest init_value = FILE_CHUNK_UPLOAD_REQUEST__INIT;
+  *message = init_value;
+}
+size_t file_chunk_upload_request__get_packed_size
+                     (const FileChunkUploadRequest *message)
+{
+  assert(message->base.descriptor == &file_chunk_upload_request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t file_chunk_upload_request__pack
+                     (const FileChunkUploadRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->base.descriptor == &file_chunk_upload_request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t file_chunk_upload_request__pack_to_buffer
+                     (const FileChunkUploadRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->base.descriptor == &file_chunk_upload_request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+FileChunkUploadRequest *
+       file_chunk_upload_request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (FileChunkUploadRequest *)
+     protobuf_c_message_unpack (&file_chunk_upload_request__descriptor,
+                                allocator, len, data);
+}
+void   file_chunk_upload_request__free_unpacked
+                     (FileChunkUploadRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->base.descriptor == &file_chunk_upload_request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+static const ProtobufCFieldDescriptor file_chunk_upload_request__field_descriptors[3] =
+{
+  {
+    "UploadID",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(FileChunkUploadRequest, uploadid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "Buffer",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BYTES,
+    offsetof(FileChunkUploadRequest, has_buffer),
+    offsetof(FileChunkUploadRequest, buffer),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "IsCanceled",
+    4,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(FileChunkUploadRequest, has_iscanceled),
+    offsetof(FileChunkUploadRequest, iscanceled),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned file_chunk_upload_request__field_indices_by_name[] = {
+  1,   /* field[1] = Buffer */
+  2,   /* field[2] = IsCanceled */
+  0,   /* field[0] = UploadID */
+};
+static const ProtobufCIntRange file_chunk_upload_request__number_ranges[2 + 1] =
+{
+  { 1, 0 },
+  { 4, 2 },
+  { 0, 3 }
+};
+const ProtobufCMessageDescriptor file_chunk_upload_request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "FileChunkUploadRequest",
+  "FileChunkUploadRequest",
+  "FileChunkUploadRequest",
+  "",
+  sizeof(FileChunkUploadRequest),
+  3,
+  file_chunk_upload_request__field_descriptors,
+  file_chunk_upload_request__field_indices_by_name,
+  2,  file_chunk_upload_request__number_ranges,
+  (ProtobufCMessageInit) file_chunk_upload_request__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileChunkUploadRequest.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileChunkUploadRequest.pb-c.h
new file mode 100644
index 000000000..5b084a772
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileChunkUploadRequest.pb-c.h
@@ -0,0 +1,75 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: FileChunkUploadRequest.proto */
+
+#ifndef PROTOBUF_C_FileChunkUploadRequest_2eproto__INCLUDED
+#define PROTOBUF_C_FileChunkUploadRequest_2eproto__INCLUDED
+
+#include <protobuf-c/protobuf-c.h>
+
+PROTOBUF_C__BEGIN_DECLS
+
+#if PROTOBUF_C_VERSION_NUMBER < 1003000
+# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
+#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION
+# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
+#endif
+
+
+typedef struct _FileChunkUploadRequest FileChunkUploadRequest;
+
+
+/* --- enums --- */
+
+
+/* --- messages --- */
+
+struct  _FileChunkUploadRequest
+{
+  ProtobufCMessage base;
+  char *uploadid;
+  protobuf_c_boolean has_buffer;
+  ProtobufCBinaryData buffer;
+  protobuf_c_boolean has_iscanceled;
+  protobuf_c_boolean iscanceled;
+};
+#define FILE_CHUNK_UPLOAD_REQUEST__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&file_chunk_upload_request__descriptor) \
+    , NULL, 0, {0,NULL}, 0, 0 }
+
+
+/* FileChunkUploadRequest methods */
+void   file_chunk_upload_request__init
+                     (FileChunkUploadRequest         *message);
+size_t file_chunk_upload_request__get_packed_size
+                     (const FileChunkUploadRequest   *message);
+size_t file_chunk_upload_request__pack
+                     (const FileChunkUploadRequest   *message,
+                      uint8_t             *out);
+size_t file_chunk_upload_request__pack_to_buffer
+                     (const FileChunkUploadRequest   *message,
+                      ProtobufCBuffer     *buffer);
+FileChunkUploadRequest *
+       file_chunk_upload_request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   file_chunk_upload_request__free_unpacked
+                     (FileChunkUploadRequest *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*FileChunkUploadRequest_Closure)
+                 (const FileChunkUploadRequest *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCMessageDescriptor file_chunk_upload_request__descriptor;
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_FileChunkUploadRequest_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileChunkUploadResponse.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileChunkUploadResponse.pb-c.c
new file mode 100644
index 000000000..453421e03
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileChunkUploadResponse.pb-c.c
@@ -0,0 +1,92 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: FileChunkUploadResponse.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "FileChunkUploadResponse.pb-c.h"
+void   file_chunk_upload_response__init
+                     (FileChunkUploadResponse         *message)
+{
+  static const FileChunkUploadResponse init_value = FILE_CHUNK_UPLOAD_RESPONSE__INIT;
+  *message = init_value;
+}
+size_t file_chunk_upload_response__get_packed_size
+                     (const FileChunkUploadResponse *message)
+{
+  assert(message->base.descriptor == &file_chunk_upload_response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t file_chunk_upload_response__pack
+                     (const FileChunkUploadResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->base.descriptor == &file_chunk_upload_response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t file_chunk_upload_response__pack_to_buffer
+                     (const FileChunkUploadResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->base.descriptor == &file_chunk_upload_response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+FileChunkUploadResponse *
+       file_chunk_upload_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (FileChunkUploadResponse *)
+     protobuf_c_message_unpack (&file_chunk_upload_response__descriptor,
+                                allocator, len, data);
+}
+void   file_chunk_upload_response__free_unpacked
+                     (FileChunkUploadResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->base.descriptor == &file_chunk_upload_response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+static const ProtobufCFieldDescriptor file_chunk_upload_response__field_descriptors[1] =
+{
+  {
+    "IsCanceled",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(FileChunkUploadResponse, has_iscanceled),
+    offsetof(FileChunkUploadResponse, iscanceled),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned file_chunk_upload_response__field_indices_by_name[] = {
+  0,   /* field[0] = IsCanceled */
+};
+static const ProtobufCIntRange file_chunk_upload_response__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 1 }
+};
+const ProtobufCMessageDescriptor file_chunk_upload_response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "FileChunkUploadResponse",
+  "FileChunkUploadResponse",
+  "FileChunkUploadResponse",
+  "",
+  sizeof(FileChunkUploadResponse),
+  1,
+  file_chunk_upload_response__field_descriptors,
+  file_chunk_upload_response__field_indices_by_name,
+  1,  file_chunk_upload_response__number_ranges,
+  (ProtobufCMessageInit) file_chunk_upload_response__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileChunkUploadResponse.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileChunkUploadResponse.pb-c.h
new file mode 100644
index 000000000..82e95302e
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileChunkUploadResponse.pb-c.h
@@ -0,0 +1,72 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: FileChunkUploadResponse.proto */
+
+#ifndef PROTOBUF_C_FileChunkUploadResponse_2eproto__INCLUDED
+#define PROTOBUF_C_FileChunkUploadResponse_2eproto__INCLUDED
+
+#include <protobuf-c/protobuf-c.h>
+
+PROTOBUF_C__BEGIN_DECLS
+
+#if PROTOBUF_C_VERSION_NUMBER < 1003000
+# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
+#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION
+# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
+#endif
+
+
+typedef struct _FileChunkUploadResponse FileChunkUploadResponse;
+
+
+/* --- enums --- */
+
+
+/* --- messages --- */
+
+struct  _FileChunkUploadResponse
+{
+  ProtobufCMessage base;
+  protobuf_c_boolean has_iscanceled;
+  protobuf_c_boolean iscanceled;
+};
+#define FILE_CHUNK_UPLOAD_RESPONSE__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&file_chunk_upload_response__descriptor) \
+    , 0, 0 }
+
+
+/* FileChunkUploadResponse methods */
+void   file_chunk_upload_response__init
+                     (FileChunkUploadResponse         *message);
+size_t file_chunk_upload_response__get_packed_size
+                     (const FileChunkUploadResponse   *message);
+size_t file_chunk_upload_response__pack
+                     (const FileChunkUploadResponse   *message,
+                      uint8_t             *out);
+size_t file_chunk_upload_response__pack_to_buffer
+                     (const FileChunkUploadResponse   *message,
+                      ProtobufCBuffer     *buffer);
+FileChunkUploadResponse *
+       file_chunk_upload_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   file_chunk_upload_response__free_unpacked
+                     (FileChunkUploadResponse *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*FileChunkUploadResponse_Closure)
+                 (const FileChunkUploadResponse *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCMessageDescriptor file_chunk_upload_response__descriptor;
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_FileChunkUploadResponse_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileInfo.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileInfo.pb-c.c
new file mode 100644
index 000000000..a27b5b1fc
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileInfo.pb-c.c
@@ -0,0 +1,157 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: FileInfo.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "FileInfo.pb-c.h"
+void   file_info__init
+                     (FileInfo         *message)
+{
+  static const FileInfo init_value = FILE_INFO__INIT;
+  *message = init_value;
+}
+size_t file_info__get_packed_size
+                     (const FileInfo *message)
+{
+  assert(message->base.descriptor == &file_info__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t file_info__pack
+                     (const FileInfo *message,
+                      uint8_t       *out)
+{
+  assert(message->base.descriptor == &file_info__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t file_info__pack_to_buffer
+                     (const FileInfo *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->base.descriptor == &file_info__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+FileInfo *
+       file_info__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (FileInfo *)
+     protobuf_c_message_unpack (&file_info__descriptor,
+                                allocator, len, data);
+}
+void   file_info__free_unpacked
+                     (FileInfo *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->base.descriptor == &file_info__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+static const ProtobufCFieldDescriptor file_info__field_descriptors[6] =
+{
+  {
+    "Name",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(FileInfo, name),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "FullPath",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(FileInfo, fullpath),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "Length",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(FileInfo, has_length),
+    offsetof(FileInfo, length),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "LastModifiedDate",
+    4,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(FileInfo, has_lastmodifieddate),
+    offsetof(FileInfo, lastmodifieddate),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "LastModifiedTime",
+    5,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(FileInfo, has_lastmodifiedtime),
+    offsetof(FileInfo, lastmodifiedtime),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "Attribute",
+    6,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_ENUM,
+    offsetof(FileInfo, has_attribute),
+    offsetof(FileInfo, attribute),
+    &file_attribute__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned file_info__field_indices_by_name[] = {
+  5,   /* field[5] = Attribute */
+  1,   /* field[1] = FullPath */
+  3,   /* field[3] = LastModifiedDate */
+  4,   /* field[4] = LastModifiedTime */
+  2,   /* field[2] = Length */
+  0,   /* field[0] = Name */
+};
+static const ProtobufCIntRange file_info__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 6 }
+};
+const ProtobufCMessageDescriptor file_info__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "FileInfo",
+  "FileInfo",
+  "FileInfo",
+  "",
+  sizeof(FileInfo),
+  6,
+  file_info__field_descriptors,
+  file_info__field_indices_by_name,
+  1,  file_info__number_ranges,
+  (ProtobufCMessageInit) file_info__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileInfo.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileInfo.pb-c.h
new file mode 100644
index 000000000..5875b98a8
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileInfo.pb-c.h
@@ -0,0 +1,81 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: FileInfo.proto */
+
+#ifndef PROTOBUF_C_FileInfo_2eproto__INCLUDED
+#define PROTOBUF_C_FileInfo_2eproto__INCLUDED
+
+#include <protobuf-c/protobuf-c.h>
+
+PROTOBUF_C__BEGIN_DECLS
+
+#if PROTOBUF_C_VERSION_NUMBER < 1003000
+# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
+#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION
+# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
+#endif
+
+#include "FileAttribute.pb-c.h"
+
+typedef struct _FileInfo FileInfo;
+
+
+/* --- enums --- */
+
+
+/* --- messages --- */
+
+struct  _FileInfo
+{
+  ProtobufCMessage base;
+  char *name;
+  char *fullpath;
+  protobuf_c_boolean has_length;
+  int32_t length;
+  protobuf_c_boolean has_lastmodifieddate;
+  int32_t lastmodifieddate;
+  protobuf_c_boolean has_lastmodifiedtime;
+  int32_t lastmodifiedtime;
+  protobuf_c_boolean has_attribute;
+  FileAttribute attribute;
+};
+#define FILE_INFO__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&file_info__descriptor) \
+    , NULL, NULL, 0, 0, 0, 0, 0, 0, 0, FILE_ATTRIBUTE__Unspecified }
+
+
+/* FileInfo methods */
+void   file_info__init
+                     (FileInfo         *message);
+size_t file_info__get_packed_size
+                     (const FileInfo   *message);
+size_t file_info__pack
+                     (const FileInfo   *message,
+                      uint8_t             *out);
+size_t file_info__pack_to_buffer
+                     (const FileInfo   *message,
+                      ProtobufCBuffer     *buffer);
+FileInfo *
+       file_info__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   file_info__free_unpacked
+                     (FileInfo *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*FileInfo_Closure)
+                 (const FileInfo *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCMessageDescriptor file_info__descriptor;
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_FileInfo_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileUploadRequest.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileUploadRequest.pb-c.c
new file mode 100644
index 000000000..4b17c92ed
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileUploadRequest.pb-c.c
@@ -0,0 +1,105 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: FileUploadRequest.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "FileUploadRequest.pb-c.h"
+void   file_upload_request__init
+                     (FileUploadRequest         *message)
+{
+  static const FileUploadRequest init_value = FILE_UPLOAD_REQUEST__INIT;
+  *message = init_value;
+}
+size_t file_upload_request__get_packed_size
+                     (const FileUploadRequest *message)
+{
+  assert(message->base.descriptor == &file_upload_request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t file_upload_request__pack
+                     (const FileUploadRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->base.descriptor == &file_upload_request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t file_upload_request__pack_to_buffer
+                     (const FileUploadRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->base.descriptor == &file_upload_request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+FileUploadRequest *
+       file_upload_request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (FileUploadRequest *)
+     protobuf_c_message_unpack (&file_upload_request__descriptor,
+                                allocator, len, data);
+}
+void   file_upload_request__free_unpacked
+                     (FileUploadRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->base.descriptor == &file_upload_request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+static const ProtobufCFieldDescriptor file_upload_request__field_descriptors[2] =
+{
+  {
+    "FileName",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(FileUploadRequest, filename),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "Length",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT64,
+    offsetof(FileUploadRequest, has_length),
+    offsetof(FileUploadRequest, length),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned file_upload_request__field_indices_by_name[] = {
+  0,   /* field[0] = FileName */
+  1,   /* field[1] = Length */
+};
+static const ProtobufCIntRange file_upload_request__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 2 }
+};
+const ProtobufCMessageDescriptor file_upload_request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "FileUploadRequest",
+  "FileUploadRequest",
+  "FileUploadRequest",
+  "",
+  sizeof(FileUploadRequest),
+  2,
+  file_upload_request__field_descriptors,
+  file_upload_request__field_indices_by_name,
+  1,  file_upload_request__number_ranges,
+  (ProtobufCMessageInit) file_upload_request__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileUploadRequest.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileUploadRequest.pb-c.h
new file mode 100644
index 000000000..c4b936d12
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileUploadRequest.pb-c.h
@@ -0,0 +1,73 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: FileUploadRequest.proto */
+
+#ifndef PROTOBUF_C_FileUploadRequest_2eproto__INCLUDED
+#define PROTOBUF_C_FileUploadRequest_2eproto__INCLUDED
+
+#include <protobuf-c/protobuf-c.h>
+
+PROTOBUF_C__BEGIN_DECLS
+
+#if PROTOBUF_C_VERSION_NUMBER < 1003000
+# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
+#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION
+# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
+#endif
+
+
+typedef struct _FileUploadRequest FileUploadRequest;
+
+
+/* --- enums --- */
+
+
+/* --- messages --- */
+
+struct  _FileUploadRequest
+{
+  ProtobufCMessage base;
+  char *filename;
+  protobuf_c_boolean has_length;
+  int64_t length;
+};
+#define FILE_UPLOAD_REQUEST__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&file_upload_request__descriptor) \
+    , NULL, 0, 0 }
+
+
+/* FileUploadRequest methods */
+void   file_upload_request__init
+                     (FileUploadRequest         *message);
+size_t file_upload_request__get_packed_size
+                     (const FileUploadRequest   *message);
+size_t file_upload_request__pack
+                     (const FileUploadRequest   *message,
+                      uint8_t             *out);
+size_t file_upload_request__pack_to_buffer
+                     (const FileUploadRequest   *message,
+                      ProtobufCBuffer     *buffer);
+FileUploadRequest *
+       file_upload_request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   file_upload_request__free_unpacked
+                     (FileUploadRequest *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*FileUploadRequest_Closure)
+                 (const FileUploadRequest *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCMessageDescriptor file_upload_request__descriptor;
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_FileUploadRequest_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileUploadResponse.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileUploadResponse.pb-c.c
new file mode 100644
index 000000000..bb7cf5cb7
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileUploadResponse.pb-c.c
@@ -0,0 +1,105 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: FileUploadResponse.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "FileUploadResponse.pb-c.h"
+void   file_upload_response__init
+                     (FileUploadResponse         *message)
+{
+  static const FileUploadResponse init_value = FILE_UPLOAD_RESPONSE__INIT;
+  *message = init_value;
+}
+size_t file_upload_response__get_packed_size
+                     (const FileUploadResponse *message)
+{
+  assert(message->base.descriptor == &file_upload_response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t file_upload_response__pack
+                     (const FileUploadResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->base.descriptor == &file_upload_response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t file_upload_response__pack_to_buffer
+                     (const FileUploadResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->base.descriptor == &file_upload_response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+FileUploadResponse *
+       file_upload_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (FileUploadResponse *)
+     protobuf_c_message_unpack (&file_upload_response__descriptor,
+                                allocator, len, data);
+}
+void   file_upload_response__free_unpacked
+                     (FileUploadResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->base.descriptor == &file_upload_response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+static const ProtobufCFieldDescriptor file_upload_response__field_descriptors[2] =
+{
+  {
+    "UploadID",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(FileUploadResponse, uploadid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "MaxChunkLength",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT64,
+    offsetof(FileUploadResponse, has_maxchunklength),
+    offsetof(FileUploadResponse, maxchunklength),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned file_upload_response__field_indices_by_name[] = {
+  1,   /* field[1] = MaxChunkLength */
+  0,   /* field[0] = UploadID */
+};
+static const ProtobufCIntRange file_upload_response__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 2 }
+};
+const ProtobufCMessageDescriptor file_upload_response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "FileUploadResponse",
+  "FileUploadResponse",
+  "FileUploadResponse",
+  "",
+  sizeof(FileUploadResponse),
+  2,
+  file_upload_response__field_descriptors,
+  file_upload_response__field_indices_by_name,
+  1,  file_upload_response__number_ranges,
+  (ProtobufCMessageInit) file_upload_response__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileUploadResponse.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileUploadResponse.pb-c.h
new file mode 100644
index 000000000..a26abf41f
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/FileUploadResponse.pb-c.h
@@ -0,0 +1,73 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: FileUploadResponse.proto */
+
+#ifndef PROTOBUF_C_FileUploadResponse_2eproto__INCLUDED
+#define PROTOBUF_C_FileUploadResponse_2eproto__INCLUDED
+
+#include <protobuf-c/protobuf-c.h>
+
+PROTOBUF_C__BEGIN_DECLS
+
+#if PROTOBUF_C_VERSION_NUMBER < 1003000
+# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
+#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION
+# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
+#endif
+
+
+typedef struct _FileUploadResponse FileUploadResponse;
+
+
+/* --- enums --- */
+
+
+/* --- messages --- */
+
+struct  _FileUploadResponse
+{
+  ProtobufCMessage base;
+  char *uploadid;
+  protobuf_c_boolean has_maxchunklength;
+  int64_t maxchunklength;
+};
+#define FILE_UPLOAD_RESPONSE__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&file_upload_response__descriptor) \
+    , NULL, 0, 0 }
+
+
+/* FileUploadResponse methods */
+void   file_upload_response__init
+                     (FileUploadResponse         *message);
+size_t file_upload_response__get_packed_size
+                     (const FileUploadResponse   *message);
+size_t file_upload_response__pack
+                     (const FileUploadResponse   *message,
+                      uint8_t             *out);
+size_t file_upload_response__pack_to_buffer
+                     (const FileUploadResponse   *message,
+                      ProtobufCBuffer     *buffer);
+FileUploadResponse *
+       file_upload_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   file_upload_response__free_unpacked
+                     (FileUploadResponse *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*FileUploadResponse_Closure)
+                 (const FileUploadResponse *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCMessageDescriptor file_upload_response__descriptor;
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_FileUploadResponse_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/GetFilesRequest.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/IO/GetFilesRequest.pb-c.c
new file mode 100644
index 000000000..1997e92dd
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/GetFilesRequest.pb-c.c
@@ -0,0 +1,92 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: GetFilesRequest.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "GetFilesRequest.pb-c.h"
+void   get_files_request__init
+                     (GetFilesRequest         *message)
+{
+  static const GetFilesRequest init_value = GET_FILES_REQUEST__INIT;
+  *message = init_value;
+}
+size_t get_files_request__get_packed_size
+                     (const GetFilesRequest *message)
+{
+  assert(message->base.descriptor == &get_files_request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t get_files_request__pack
+                     (const GetFilesRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->base.descriptor == &get_files_request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t get_files_request__pack_to_buffer
+                     (const GetFilesRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->base.descriptor == &get_files_request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+GetFilesRequest *
+       get_files_request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (GetFilesRequest *)
+     protobuf_c_message_unpack (&get_files_request__descriptor,
+                                allocator, len, data);
+}
+void   get_files_request__free_unpacked
+                     (GetFilesRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->base.descriptor == &get_files_request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+static const ProtobufCFieldDescriptor get_files_request__field_descriptors[1] =
+{
+  {
+    "Path",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(GetFilesRequest, path),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned get_files_request__field_indices_by_name[] = {
+  0,   /* field[0] = Path */
+};
+static const ProtobufCIntRange get_files_request__number_ranges[1 + 1] =
+{
+  { 2, 0 },
+  { 0, 1 }
+};
+const ProtobufCMessageDescriptor get_files_request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "GetFilesRequest",
+  "GetFilesRequest",
+  "GetFilesRequest",
+  "",
+  sizeof(GetFilesRequest),
+  1,
+  get_files_request__field_descriptors,
+  get_files_request__field_indices_by_name,
+  1,  get_files_request__number_ranges,
+  (ProtobufCMessageInit) get_files_request__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/GetFilesRequest.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/IO/GetFilesRequest.pb-c.h
new file mode 100644
index 000000000..909885b75
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/GetFilesRequest.pb-c.h
@@ -0,0 +1,71 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: GetFilesRequest.proto */
+
+#ifndef PROTOBUF_C_GetFilesRequest_2eproto__INCLUDED
+#define PROTOBUF_C_GetFilesRequest_2eproto__INCLUDED
+
+#include <protobuf-c/protobuf-c.h>
+
+PROTOBUF_C__BEGIN_DECLS
+
+#if PROTOBUF_C_VERSION_NUMBER < 1003000
+# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
+#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION
+# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
+#endif
+
+
+typedef struct _GetFilesRequest GetFilesRequest;
+
+
+/* --- enums --- */
+
+
+/* --- messages --- */
+
+struct  _GetFilesRequest
+{
+  ProtobufCMessage base;
+  char *path;
+};
+#define GET_FILES_REQUEST__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&get_files_request__descriptor) \
+    , NULL }
+
+
+/* GetFilesRequest methods */
+void   get_files_request__init
+                     (GetFilesRequest         *message);
+size_t get_files_request__get_packed_size
+                     (const GetFilesRequest   *message);
+size_t get_files_request__pack
+                     (const GetFilesRequest   *message,
+                      uint8_t             *out);
+size_t get_files_request__pack_to_buffer
+                     (const GetFilesRequest   *message,
+                      ProtobufCBuffer     *buffer);
+GetFilesRequest *
+       get_files_request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   get_files_request__free_unpacked
+                     (GetFilesRequest *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*GetFilesRequest_Closure)
+                 (const GetFilesRequest *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCMessageDescriptor get_files_request__descriptor;
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_GetFilesRequest_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/GetFilesResponse.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/IO/GetFilesResponse.pb-c.c
new file mode 100644
index 000000000..5678697f0
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/GetFilesResponse.pb-c.c
@@ -0,0 +1,92 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: GetFilesResponse.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "GetFilesResponse.pb-c.h"
+void   get_files_response__init
+                     (GetFilesResponse         *message)
+{
+  static const GetFilesResponse init_value = GET_FILES_RESPONSE__INIT;
+  *message = init_value;
+}
+size_t get_files_response__get_packed_size
+                     (const GetFilesResponse *message)
+{
+  assert(message->base.descriptor == &get_files_response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t get_files_response__pack
+                     (const GetFilesResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->base.descriptor == &get_files_response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t get_files_response__pack_to_buffer
+                     (const GetFilesResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->base.descriptor == &get_files_response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+GetFilesResponse *
+       get_files_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (GetFilesResponse *)
+     protobuf_c_message_unpack (&get_files_response__descriptor,
+                                allocator, len, data);
+}
+void   get_files_response__free_unpacked
+                     (GetFilesResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->base.descriptor == &get_files_response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+static const ProtobufCFieldDescriptor get_files_response__field_descriptors[1] =
+{
+  {
+    "Items",
+    1,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_MESSAGE,
+    offsetof(GetFilesResponse, n_items),
+    offsetof(GetFilesResponse, items),
+    &file_info__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned get_files_response__field_indices_by_name[] = {
+  0,   /* field[0] = Items */
+};
+static const ProtobufCIntRange get_files_response__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 1 }
+};
+const ProtobufCMessageDescriptor get_files_response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "GetFilesResponse",
+  "GetFilesResponse",
+  "GetFilesResponse",
+  "",
+  sizeof(GetFilesResponse),
+  1,
+  get_files_response__field_descriptors,
+  get_files_response__field_indices_by_name,
+  1,  get_files_response__number_ranges,
+  (ProtobufCMessageInit) get_files_response__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/GetFilesResponse.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/IO/GetFilesResponse.pb-c.h
new file mode 100644
index 000000000..c1f8ae6b9
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/GetFilesResponse.pb-c.h
@@ -0,0 +1,73 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: GetFilesResponse.proto */
+
+#ifndef PROTOBUF_C_GetFilesResponse_2eproto__INCLUDED
+#define PROTOBUF_C_GetFilesResponse_2eproto__INCLUDED
+
+#include <protobuf-c/protobuf-c.h>
+
+PROTOBUF_C__BEGIN_DECLS
+
+#if PROTOBUF_C_VERSION_NUMBER < 1003000
+# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
+#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION
+# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
+#endif
+
+#include "FileInfo.pb-c.h"
+
+typedef struct _GetFilesResponse GetFilesResponse;
+
+
+/* --- enums --- */
+
+
+/* --- messages --- */
+
+struct  _GetFilesResponse
+{
+  ProtobufCMessage base;
+  size_t n_items;
+  FileInfo **items;
+};
+#define GET_FILES_RESPONSE__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&get_files_response__descriptor) \
+    , 0,NULL }
+
+
+/* GetFilesResponse methods */
+void   get_files_response__init
+                     (GetFilesResponse         *message);
+size_t get_files_response__get_packed_size
+                     (const GetFilesResponse   *message);
+size_t get_files_response__pack
+                     (const GetFilesResponse   *message,
+                      uint8_t             *out);
+size_t get_files_response__pack_to_buffer
+                     (const GetFilesResponse   *message,
+                      ProtobufCBuffer     *buffer);
+GetFilesResponse *
+       get_files_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   get_files_response__free_unpacked
+                     (GetFilesResponse *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*GetFilesResponse_Closure)
+                 (const GetFilesResponse *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCMessageDescriptor get_files_response__descriptor;
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_GetFilesResponse_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/GetStorageInfoRequest.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/IO/GetStorageInfoRequest.pb-c.c
new file mode 100644
index 000000000..0757766f7
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/GetStorageInfoRequest.pb-c.c
@@ -0,0 +1,105 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: GetStorageInfoRequest.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "GetStorageInfoRequest.pb-c.h"
+void   get_storage_info_request__init
+                     (GetStorageInfoRequest         *message)
+{
+  static const GetStorageInfoRequest init_value = GET_STORAGE_INFO_REQUEST__INIT;
+  *message = init_value;
+}
+size_t get_storage_info_request__get_packed_size
+                     (const GetStorageInfoRequest *message)
+{
+  assert(message->base.descriptor == &get_storage_info_request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t get_storage_info_request__pack
+                     (const GetStorageInfoRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->base.descriptor == &get_storage_info_request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t get_storage_info_request__pack_to_buffer
+                     (const GetStorageInfoRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->base.descriptor == &get_storage_info_request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+GetStorageInfoRequest *
+       get_storage_info_request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (GetStorageInfoRequest *)
+     protobuf_c_message_unpack (&get_storage_info_request__descriptor,
+                                allocator, len, data);
+}
+void   get_storage_info_request__free_unpacked
+                     (GetStorageInfoRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->base.descriptor == &get_storage_info_request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+static const ProtobufCFieldDescriptor get_storage_info_request__field_descriptors[2] =
+{
+  {
+    "Capacity",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(GetStorageInfoRequest, has_capacity),
+    offsetof(GetStorageInfoRequest, capacity),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "FreeSpace",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(GetStorageInfoRequest, has_freespace),
+    offsetof(GetStorageInfoRequest, freespace),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned get_storage_info_request__field_indices_by_name[] = {
+  0,   /* field[0] = Capacity */
+  1,   /* field[1] = FreeSpace */
+};
+static const ProtobufCIntRange get_storage_info_request__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 2 }
+};
+const ProtobufCMessageDescriptor get_storage_info_request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "GetStorageInfoRequest",
+  "GetStorageInfoRequest",
+  "GetStorageInfoRequest",
+  "",
+  sizeof(GetStorageInfoRequest),
+  2,
+  get_storage_info_request__field_descriptors,
+  get_storage_info_request__field_indices_by_name,
+  1,  get_storage_info_request__number_ranges,
+  (ProtobufCMessageInit) get_storage_info_request__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/GetStorageInfoRequest.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/IO/GetStorageInfoRequest.pb-c.h
new file mode 100644
index 000000000..6b7f7cf74
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/GetStorageInfoRequest.pb-c.h
@@ -0,0 +1,74 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: GetStorageInfoRequest.proto */
+
+#ifndef PROTOBUF_C_GetStorageInfoRequest_2eproto__INCLUDED
+#define PROTOBUF_C_GetStorageInfoRequest_2eproto__INCLUDED
+
+#include <protobuf-c/protobuf-c.h>
+
+PROTOBUF_C__BEGIN_DECLS
+
+#if PROTOBUF_C_VERSION_NUMBER < 1003000
+# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
+#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION
+# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
+#endif
+
+
+typedef struct _GetStorageInfoRequest GetStorageInfoRequest;
+
+
+/* --- enums --- */
+
+
+/* --- messages --- */
+
+struct  _GetStorageInfoRequest
+{
+  ProtobufCMessage base;
+  protobuf_c_boolean has_capacity;
+  int32_t capacity;
+  protobuf_c_boolean has_freespace;
+  int32_t freespace;
+};
+#define GET_STORAGE_INFO_REQUEST__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&get_storage_info_request__descriptor) \
+    , 0, 0, 0, 0 }
+
+
+/* GetStorageInfoRequest methods */
+void   get_storage_info_request__init
+                     (GetStorageInfoRequest         *message);
+size_t get_storage_info_request__get_packed_size
+                     (const GetStorageInfoRequest   *message);
+size_t get_storage_info_request__pack
+                     (const GetStorageInfoRequest   *message,
+                      uint8_t             *out);
+size_t get_storage_info_request__pack_to_buffer
+                     (const GetStorageInfoRequest   *message,
+                      ProtobufCBuffer     *buffer);
+GetStorageInfoRequest *
+       get_storage_info_request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   get_storage_info_request__free_unpacked
+                     (GetStorageInfoRequest *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*GetStorageInfoRequest_Closure)
+                 (const GetStorageInfoRequest *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCMessageDescriptor get_storage_info_request__descriptor;
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_GetStorageInfoRequest_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/GetStorageInfoResponse.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/IO/GetStorageInfoResponse.pb-c.c
new file mode 100644
index 000000000..59a4a43bc
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/GetStorageInfoResponse.pb-c.c
@@ -0,0 +1,72 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: GetStorageInfoResponse.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "GetStorageInfoResponse.pb-c.h"
+void   get_storage_info_response__init
+                     (GetStorageInfoResponse         *message)
+{
+  static const GetStorageInfoResponse init_value = GET_STORAGE_INFO_RESPONSE__INIT;
+  *message = init_value;
+}
+size_t get_storage_info_response__get_packed_size
+                     (const GetStorageInfoResponse *message)
+{
+  assert(message->base.descriptor == &get_storage_info_response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t get_storage_info_response__pack
+                     (const GetStorageInfoResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->base.descriptor == &get_storage_info_response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t get_storage_info_response__pack_to_buffer
+                     (const GetStorageInfoResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->base.descriptor == &get_storage_info_response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+GetStorageInfoResponse *
+       get_storage_info_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (GetStorageInfoResponse *)
+     protobuf_c_message_unpack (&get_storage_info_response__descriptor,
+                                allocator, len, data);
+}
+void   get_storage_info_response__free_unpacked
+                     (GetStorageInfoResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->base.descriptor == &get_storage_info_response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+#define get_storage_info_response__field_descriptors NULL
+#define get_storage_info_response__field_indices_by_name NULL
+#define get_storage_info_response__number_ranges NULL
+const ProtobufCMessageDescriptor get_storage_info_response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "GetStorageInfoResponse",
+  "GetStorageInfoResponse",
+  "GetStorageInfoResponse",
+  "",
+  sizeof(GetStorageInfoResponse),
+  0,
+  get_storage_info_response__field_descriptors,
+  get_storage_info_response__field_indices_by_name,
+  0,  get_storage_info_response__number_ranges,
+  (ProtobufCMessageInit) get_storage_info_response__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/GetStorageInfoResponse.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/IO/GetStorageInfoResponse.pb-c.h
new file mode 100644
index 000000000..a453fef7b
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/GetStorageInfoResponse.pb-c.h
@@ -0,0 +1,70 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: GetStorageInfoResponse.proto */
+
+#ifndef PROTOBUF_C_GetStorageInfoResponse_2eproto__INCLUDED
+#define PROTOBUF_C_GetStorageInfoResponse_2eproto__INCLUDED
+
+#include <protobuf-c/protobuf-c.h>
+
+PROTOBUF_C__BEGIN_DECLS
+
+#if PROTOBUF_C_VERSION_NUMBER < 1003000
+# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
+#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION
+# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
+#endif
+
+
+typedef struct _GetStorageInfoResponse GetStorageInfoResponse;
+
+
+/* --- enums --- */
+
+
+/* --- messages --- */
+
+struct  _GetStorageInfoResponse
+{
+  ProtobufCMessage base;
+};
+#define GET_STORAGE_INFO_RESPONSE__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&get_storage_info_response__descriptor) \
+     }
+
+
+/* GetStorageInfoResponse methods */
+void   get_storage_info_response__init
+                     (GetStorageInfoResponse         *message);
+size_t get_storage_info_response__get_packed_size
+                     (const GetStorageInfoResponse   *message);
+size_t get_storage_info_response__pack
+                     (const GetStorageInfoResponse   *message,
+                      uint8_t             *out);
+size_t get_storage_info_response__pack_to_buffer
+                     (const GetStorageInfoResponse   *message,
+                      ProtobufCBuffer     *buffer);
+GetStorageInfoResponse *
+       get_storage_info_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   get_storage_info_response__free_unpacked
+                     (GetStorageInfoResponse *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*GetStorageInfoResponse_Closure)
+                 (const GetStorageInfoResponse *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCMessageDescriptor get_storage_info_response__descriptor;
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_GetStorageInfoResponse_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/KillProcessRequest.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/IO/KillProcessRequest.pb-c.c
new file mode 100644
index 000000000..a36b94f4a
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/KillProcessRequest.pb-c.c
@@ -0,0 +1,92 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: KillProcessRequest.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "KillProcessRequest.pb-c.h"
+void   kill_process_request__init
+                     (KillProcessRequest         *message)
+{
+  static const KillProcessRequest init_value = KILL_PROCESS_REQUEST__INIT;
+  *message = init_value;
+}
+size_t kill_process_request__get_packed_size
+                     (const KillProcessRequest *message)
+{
+  assert(message->base.descriptor == &kill_process_request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t kill_process_request__pack
+                     (const KillProcessRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->base.descriptor == &kill_process_request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t kill_process_request__pack_to_buffer
+                     (const KillProcessRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->base.descriptor == &kill_process_request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+KillProcessRequest *
+       kill_process_request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (KillProcessRequest *)
+     protobuf_c_message_unpack (&kill_process_request__descriptor,
+                                allocator, len, data);
+}
+void   kill_process_request__free_unpacked
+                     (KillProcessRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->base.descriptor == &kill_process_request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+static const ProtobufCFieldDescriptor kill_process_request__field_descriptors[1] =
+{
+  {
+    "ProcessID",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(KillProcessRequest, processid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned kill_process_request__field_indices_by_name[] = {
+  0,   /* field[0] = ProcessID */
+};
+static const ProtobufCIntRange kill_process_request__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 1 }
+};
+const ProtobufCMessageDescriptor kill_process_request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "KillProcessRequest",
+  "KillProcessRequest",
+  "KillProcessRequest",
+  "",
+  sizeof(KillProcessRequest),
+  1,
+  kill_process_request__field_descriptors,
+  kill_process_request__field_indices_by_name,
+  1,  kill_process_request__number_ranges,
+  (ProtobufCMessageInit) kill_process_request__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/KillProcessRequest.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/IO/KillProcessRequest.pb-c.h
new file mode 100644
index 000000000..3782ebff3
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/KillProcessRequest.pb-c.h
@@ -0,0 +1,71 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: KillProcessRequest.proto */
+
+#ifndef PROTOBUF_C_KillProcessRequest_2eproto__INCLUDED
+#define PROTOBUF_C_KillProcessRequest_2eproto__INCLUDED
+
+#include <protobuf-c/protobuf-c.h>
+
+PROTOBUF_C__BEGIN_DECLS
+
+#if PROTOBUF_C_VERSION_NUMBER < 1003000
+# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
+#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION
+# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
+#endif
+
+
+typedef struct _KillProcessRequest KillProcessRequest;
+
+
+/* --- enums --- */
+
+
+/* --- messages --- */
+
+struct  _KillProcessRequest
+{
+  ProtobufCMessage base;
+  char *processid;
+};
+#define KILL_PROCESS_REQUEST__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&kill_process_request__descriptor) \
+    , NULL }
+
+
+/* KillProcessRequest methods */
+void   kill_process_request__init
+                     (KillProcessRequest         *message);
+size_t kill_process_request__get_packed_size
+                     (const KillProcessRequest   *message);
+size_t kill_process_request__pack
+                     (const KillProcessRequest   *message,
+                      uint8_t             *out);
+size_t kill_process_request__pack_to_buffer
+                     (const KillProcessRequest   *message,
+                      ProtobufCBuffer     *buffer);
+KillProcessRequest *
+       kill_process_request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   kill_process_request__free_unpacked
+                     (KillProcessRequest *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*KillProcessRequest_Closure)
+                 (const KillProcessRequest *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCMessageDescriptor kill_process_request__descriptor;
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_KillProcessRequest_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/KillProcessResponse.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/IO/KillProcessResponse.pb-c.c
new file mode 100644
index 000000000..cf2f046fa
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/KillProcessResponse.pb-c.c
@@ -0,0 +1,72 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: KillProcessResponse.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "KillProcessResponse.pb-c.h"
+void   kill_process_response__init
+                     (KillProcessResponse         *message)
+{
+  static const KillProcessResponse init_value = KILL_PROCESS_RESPONSE__INIT;
+  *message = init_value;
+}
+size_t kill_process_response__get_packed_size
+                     (const KillProcessResponse *message)
+{
+  assert(message->base.descriptor == &kill_process_response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t kill_process_response__pack
+                     (const KillProcessResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->base.descriptor == &kill_process_response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t kill_process_response__pack_to_buffer
+                     (const KillProcessResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->base.descriptor == &kill_process_response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+KillProcessResponse *
+       kill_process_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (KillProcessResponse *)
+     protobuf_c_message_unpack (&kill_process_response__descriptor,
+                                allocator, len, data);
+}
+void   kill_process_response__free_unpacked
+                     (KillProcessResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->base.descriptor == &kill_process_response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+#define kill_process_response__field_descriptors NULL
+#define kill_process_response__field_indices_by_name NULL
+#define kill_process_response__number_ranges NULL
+const ProtobufCMessageDescriptor kill_process_response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "KillProcessResponse",
+  "KillProcessResponse",
+  "KillProcessResponse",
+  "",
+  sizeof(KillProcessResponse),
+  0,
+  kill_process_response__field_descriptors,
+  kill_process_response__field_indices_by_name,
+  0,  kill_process_response__number_ranges,
+  (ProtobufCMessageInit) kill_process_response__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/IO/KillProcessResponse.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/IO/KillProcessResponse.pb-c.h
new file mode 100644
index 000000000..9fc47c640
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/IO/KillProcessResponse.pb-c.h
@@ -0,0 +1,70 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: KillProcessResponse.proto */
+
+#ifndef PROTOBUF_C_KillProcessResponse_2eproto__INCLUDED
+#define PROTOBUF_C_KillProcessResponse_2eproto__INCLUDED
+
+#include <protobuf-c/protobuf-c.h>
+
+PROTOBUF_C__BEGIN_DECLS
+
+#if PROTOBUF_C_VERSION_NUMBER < 1003000
+# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
+#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION
+# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
+#endif
+
+
+typedef struct _KillProcessResponse KillProcessResponse;
+
+
+/* --- enums --- */
+
+
+/* --- messages --- */
+
+struct  _KillProcessResponse
+{
+  ProtobufCMessage base;
+};
+#define KILL_PROCESS_RESPONSE__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&kill_process_response__descriptor) \
+     }
+
+
+/* KillProcessResponse methods */
+void   kill_process_response__init
+                     (KillProcessResponse         *message);
+size_t kill_process_response__get_packed_size
+                     (const KillProcessResponse   *message);
+size_t kill_process_response__pack
+                     (const KillProcessResponse   *message,
+                      uint8_t             *out);
+size_t kill_process_response__pack_to_buffer
+                     (const KillProcessResponse   *message,
+                      ProtobufCBuffer     *buffer);
+KillProcessResponse *
+       kill_process_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   kill_process_response__free_unpacked
+                     (KillProcessResponse *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*KillProcessResponse_Closure)
+                 (const KillProcessResponse *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCMessageDescriptor kill_process_response__descriptor;
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_KillProcessResponse_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_INTERRUPTS/FPGA_Interrupts.c b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_INTERRUPTS/FPGA_Interrupts.c
index e5c78cf79..51270621e 100644
--- a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_INTERRUPTS/FPGA_Interrupts.c
+++ b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_INTERRUPTS/FPGA_Interrupts.c
@@ -17,6 +17,7 @@
 #include "Drivers/Motors/Motor.h"
 #include "drivers/FPGA/FPGA_SPI_Comm.h"
 #include "drivers/FPGA/FPGA_INTERRUPTS/fpga_interrupts.h"
+#include "Modules/Thread/Thread_ex.h"
 
 #define Screw_Not_Busy_Mask 0x02
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
index 960581da7..857b90d9e 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
@@ -159,11 +159,11 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
     {
         if ((JobIsActive() == false)&&(isMotorConfigured(MotorId) == true))
         {
-            if (request->direction == MOTOR_DIRECTION__Forward) //opening the loading system
+            if (request->direction == MOTOR_DIRECTION__Backward) //opening the loading system
             {
                 if ( Motor_Id_to_LS_IdUp[MotorId] != MAX_GPI)
                 {
-                    MotorMovetoLimitSwitch (MotorId,MotorsCfg[MotorId].directionthreadwize, speed,  Motor_Id_to_LS_IdUp[MotorId], MotorHomingRequestCallback);
+                    MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed,  Motor_Id_to_LS_IdUp[MotorId], MotorHomingRequestCallback);
                     ustrncpy (HomingToken[MotorId], requestContainer->token,36);
                     return OK;
                 }
@@ -172,7 +172,7 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
             {
                 if ( Motor_Id_to_LS_IdDown[MotorId] != MAX_GPI)
                 {
-                    MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed,  Motor_Id_to_LS_IdDown[MotorId], MotorHomingRequestCallback);
+                    MotorMovetoLimitSwitch (MotorId,MotorsCfg[MotorId].directionthreadwize, speed,  Motor_Id_to_LS_IdDown[MotorId], MotorHomingRequestCallback);
                     ustrncpy (HomingToken[MotorId], requestContainer->token,36);
                     return OK;
                 }
@@ -264,7 +264,7 @@ uint32_t DispenserHomingRequestFunc(MessageContainer* requestContainer)
     {
         if ((JobIsActive() == false)&&(isMotorConfigured(MotorId) == true))
         {
-            if (request->direction == MOTOR_DIRECTION__Backward) //dispenser homing
+            if (request->direction == MOTOR_DIRECTION__Forward) //dispenser homing
                 IDS_HomeDispenser(request->index,speed,DispenserHomingRequestCallback);
             else //empty dispenser - support TBD
                 IDS_EmptyDispenser(request->index,speed,DispenserHomingRequestCallback);//return ERROR;
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index 54309a187..21a4a23c1 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -666,8 +666,8 @@ uint32_t ThreadPreSegmentState(void *JobDetails)
  //only for testing - when control works, these motors will take their speed from the dryer
     //MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, OriginalMotorSpd_2PPS[FEEDER_MOTOR]);
 
-//#warning rocker disabled
-    if (MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].maxfrequency > 0)
+#warning rocker disabled
+/*    if (MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].maxfrequency > 0)
     {
         MotorSetDirection((TimerMotors_t)HARDWARE_MOTOR_TYPE__MOTO_RLOADING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].directionthreadwize);
         MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 2);
@@ -676,8 +676,8 @@ uint32_t ThreadPreSegmentState(void *JobDetails)
     {
         MotorSetDirection((TimerMotors_t)HARDWARE_MOTOR_TYPE__MOTO_LLOADING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].directionthreadwize);
         MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 2);
-    }
- //#warning rocker disabled
+    }*/
+ #warning rocker disabled
 
 //    MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDRIVING].directionthreadwize, 0, GPI_LS_RLOADMOTOR_UP, EndState); //TODO