A new forlder for embedded software in our common structure

29 files changed, 2200 insertions, 0 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Calculate.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Calculate.c
new file mode 100644
index 000000000..f12b92adc
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Calculate.c
@@ -0,0 +1,39 @@
+
+#include <PMR/Common/MessageContainer.pb-c.h>
+#include <PMR/Stubs/CalculateRequest.pb-c.h>
+#include <PMR/Stubs/CalculateResponse.pb-c.h>
+#include "include.h"
+#include "driverlib/gpio.h"
+
+#include "drivers/twine_usblib/usb_serial_adapter.h"
+#include "drivers/twine_graphicslib/graphics_adapter.h"
+#include "Container.h"
+
+void Stub_CalculateRequest(MessageContainer* requestContainer)
+{
+    MessageContainer responseContainer;
+
+    CalculateRequest* request = calculate_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+
+    writeLine("Calculate Request: ");
+    writeFloat(request->a);
+    writeString(" + ");
+    writeFloat(request->b);
+
+    CalculateResponse response = CALCULATE_RESPONSE__INIT;
+    response.sum = request->a + request->b;
+    response.has_sum = true;
+
+    responseContainer = createContainer(MESSAGE_TYPE__CalculateResponse, requestContainer->token, true, &response, &calculate_response__pack, &calculate_response__get_packed_size);
+
+    writeLine("Sending Response: ");
+    writeFloat(response.sum);
+
+    free(request);
+
+    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    SendChars((char*)container_buffer, container_size);
+    free(container_buffer);
+    free(requestContainer);
+}
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Calculate.h b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Calculate.h
new file mode 100644
index 000000000..0623435f0
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Calculate.h
@@ -0,0 +1,8 @@
+#ifndef STUB_CALCULATE_H
+#define STUB_CALCULATE_H
+
+#include "PMR/Common/MessageContainer.pb-c.h"
+void Stub_CalculateRequest(MessageContainer* requestContainer);
+
+#endif //STUB_CALCULATE_H
+
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Container.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Container.c
new file mode 100644
index 000000000..b9c3ffbd0
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Container.c
@@ -0,0 +1,125 @@
+#include <PMR/Common/MessageContainer.pb-c.h>
+#include "include.h"
+#include "driverlib/gpio.h"
+
+//#include "usb_serial_adapter.h"
+//#include "graphics_adapter.h"
+#include "Calculate.h"
+#include "Progress.h"
+#include "Stub_Cartridge.h"
+#include "Stub_Dispenser.h"
+#include "Stub_GPIO.h"
+#include "Stub_Heater.h"
+#include "Stub_MotorEncoder.h"
+#include "Stub_OptLimitSwitch.h"
+#include "Stub_SteperMotor.h"
+#include "Stub_Valve.h"
+#include "Stub_ExtFlash.h"
+#include "General/GeneralHardware.h"
+#include "heaters/heaters_ex.h"
+#include "StateMachines/Printing/PrintingSTM.h"
+#include "Modules/General/process.h"
+#include "Common/report/report.h"
+
+
+MessageContainer createContainer(MessageType type, char* token, protobuf_c_boolean completed, void* response, size_t (*packPtr)(void*, uint8_t*), size_t (*sizePtr)(void*))
+{
+    MessageContainer container = MESSAGE_CONTAINER__INIT;
+    container.completed = completed;
+    container.token = token;
+    container.has_completed = true;
+    container.has_data = true;
+    container.has_type = true;
+    container.type = type;
+
+
+
+    uint8_t* response_buffer = malloc((*sizePtr)(response));
+    size_t response_size = (*packPtr)(response, response_buffer);
+    container.data.data = response_buffer;
+    container.data.len = response_size;
+
+    free(response);
+    return container;
+}
+
+void receive_callback(char* buffer, size_t length)
+{
+     //SendChars(buffer,length);
+     //draw_string(buffer, length);
+     //draw_image((uint8_t *)buffer);
+
+     //writeLine("Received ");
+     //writeFloat(length);
+     //writeString(" bytes");
+     //writeLine("Parsing message...");
+
+     MessageContainer* requestContainer = message_container__unpack(NULL, length, (uint8_t*)buffer);
+
+     switch(requestContainer->type)
+     {
+         case MESSAGE_TYPE__CalculateRequest:
+             Stub_CalculateRequest(requestContainer);
+             break;
+         case MESSAGE_TYPE__ProgressRequest:
+             Stub_ProgressRequest(requestContainer);
+             break;
+         case MESSAGE_TYPE__StubCartridgeReadRequest:
+             Stub_CartridgeReadRequest(requestContainer);
+             break;
+         case MESSAGE_TYPE__StubCartridgeWriteRequest:
+             Stub_CartridgeWriteRequest(requestContainer);
+             break;
+         case MESSAGE_TYPE__StubDispenserRequest:
+             Stub_DispenserRequest(requestContainer);
+             break;
+         case MESSAGE_TYPE__StubGPIOInputSetupRequest:
+             Stub_GPIOInputSetupRequest(requestContainer);
+             break;
+         case MESSAGE_TYPE__StubGPIOReadBitRequest:
+             Stub_GPIOReadBitRequest(requestContainer);
+             break;
+         case MESSAGE_TYPE__StubGPIOReadByteRequest:
+             Stub_GPIOReadByteRequest(requestContainer);
+             break;
+         case MESSAGE_TYPE__StubGPIOWriteBitRequest:
+             Stub_GPIOWriteBitRequest(requestContainer);
+             break;
+         case MESSAGE_TYPE__StubGPIOWriteByteRequest:
+             Stub_GPIOWriteByteRequest(requestContainer);
+             break;
+         case MESSAGE_TYPE__StubHeaterRequest:
+             Stub_HeaterRequest(requestContainer);
+             break;
+         case MESSAGE_TYPE__StubMotorEncoderRequest:
+             Stub_MotorEncoderRequest(requestContainer);
+             break;
+         case MESSAGE_TYPE__StubOptLimitSwitchRequest:
+             Stub_OptLimitSwitchRequest(requestContainer);
+             break;
+         case MESSAGE_TYPE__StubSteperMotorRequest:
+             Stub_SteperMotorRequest(requestContainer);
+             break;
+         case MESSAGE_TYPE__StubValveRequest:
+             Stub_ValveRequest(requestContainer);
+             break;
+         case MESSAGE_TYPE__StubExtFlashReadRequest:
+             Stub_ExtFlashReadRequest(requestContainer);
+             break;
+         case MESSAGE_TYPE__StubExtFlashWriteRequest:
+             Stub_ExtFlashWriteRequest(requestContainer);
+             break;
+         case MESSAGE_TYPE__DebugLogRequest:
+             ReportInitMessage(requestContainer);
+             break;
+         case MESSAGE_TYPE__JobRequest:
+             JobRequestFunc(requestContainer);
+             break;
+         case MESSAGE_TYPE__UploadProcessParametersRequest:
+             ProcessRequestFunc(requestContainer);
+             break;
+         default:
+             //unsupported message type !!
+             break;
+     }
+}
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Container.h b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Container.h
new file mode 100644
index 000000000..2c5d9fa60
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Container.h
@@ -0,0 +1,7 @@
+#ifndef CONTAINER_H
+#define CONTAINER_H
+
+MessageContainer createContainer(MessageType type, char* token, protobuf_c_boolean completed, void* response, size_t (*packPtr)(void*, uint8_t*), size_t (*sizePtr)(void*));
+void receive_callback(char* buffer, size_t length);
+
+#endif //CONTAINER_H
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/DataDef.h b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/DataDef.h
new file mode 100644
index 000000000..08da87c09
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/DataDef.h
@@ -0,0 +1,71 @@
+#ifndef DATADEF_H
+#define DATADEF_H
+
+#define EVALUATION_BOARD // to use the LCD only when using the evaluation board
+#define USE_HIGH_SPEED_GPIO // to use AHB GPIO (A..J) ports A-J APB or AHB, ports K-Q on AHB only
+
+#define ON  1
+#define OFF 0
+
+enum
+{
+    PASSED = 0,
+    FAILED = 1,
+    NOT_SUPPORTED = 254,
+    VERIFIED = 255
+};
+
+
+#define OK     0
+#define ERROR  1
+
+#define ENABLE  0
+#define DISABLE 1
+
+#define NEW  0
+#define USED 1
+
+#define START 1
+#define STOP  0
+
+// motor direction
+#define CW  1 // clockwise
+#define CCW 0 // counter clockwise
+
+#define TRUE  1
+#define FALSE 0
+
+#define INPUT  1
+#define OUTPUT 0
+
+#define PULLDOWN 0
+#define PULLUP   1
+
+#define TX 0
+#define RX 1
+#define TXRX 2
+
+//---------------------------------------------------------------------
+#pragma diag_suppress 169 /*  Avoid warnings on VOID * conversions (protobuf issue)
+The warning:
+#169-D argument of type "size_t (*)(const CalculateResponse *, uint8_t *)" is incompatible with parameter of type "size_t (*)(void *, uint8_t *)"   Calculate.c /twine_usblib_demo/PMR/Stubs    line 53 C/C++ Problem
+
+
+//#pragma diag_suppress 190 // Avoid the warning - #190-D enumerated type mixed with another type    protobuf-c.c
+ *
+or in the environment add command line:
+
+Project -> properties ->
+
+Add the warning number in
+Supports diagnostic <id> (--diag_suppress, - pds)
+169
+190
+*/
+
+//Project Properties->Build->Compiler->Include Options
+//There may be paths there relative to a build variable, rather than hard-coded paths, that may be triggering the error.
+
+
+
+#endif /* DATADEF_H */
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
new file mode 100644
index 000000000..c44df4ef7
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -0,0 +1,48 @@
+
+#include <PMR/Common/MessageContainer.pb-c.h>
+#include <PMR/Stubs/ProgressRequest.pb-c.h>
+#include <PMR/Stubs/ProgressResponse.pb-c.h>
+#include "include.h"
+#include "driverlib/gpio.h"
+
+#include "drivers/twine_usblib/usb_serial_adapter.h"
+//#include "graphics_adapter.h"
+#include "Container.h"
+
+void Stub_ProgressRequest(MessageContainer* requestContainer)
+{
+    MessageContainer responseContainer;
+
+    ProgressRequest* request = progress_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+
+    //writeLine("Progress Request...");
+
+    ProgressResponse response = PROGRESS_RESPONSE__INIT;
+    response.has_progress = true;
+
+    int i = 0;
+    for (i = 0; i < request->amount; i++)
+    {
+        response.progress = i;
+        responseContainer = createContainer(MESSAGE_TYPE__ProgressResponse, requestContainer->token, false, &response, &progress_response__pack, &progress_response__get_packed_size);
+        uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
+        size_t container_size = message_container__pack(&responseContainer, container_buffer);
+        //writeLine("Sending Progress: ");
+        //writeFloat(response.progress);
+        SendChars((char*)container_buffer, container_size);
+
+        int co = 0;
+        for (co = 0; co < request->delay; co++)
+        {
+            __delay_cycles(1000000);
+        }
+    }
+
+    responseContainer = createContainer(MESSAGE_TYPE__ProgressResponse, requestContainer->token, true, &response, &progress_response__pack, &progress_response__get_packed_size);
+    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    //writeLine("Progress Completed!");
+    SendChars((char*)container_buffer, container_size);
+    return;
+
+}
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.h b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.h
new file mode 100644
index 000000000..a0595e4b9
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.h
@@ -0,0 +1,7 @@
+#ifndef PROGRESS_H
+#define PROGRESS_H
+
+#include "PMR/Common/MessageContainer.pb-c.h"
+void Stub_ProgressRequest(MessageContainer* requestContainer);
+
+#endif //PROGRESS_H
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Cartridge.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Cartridge.c
new file mode 100644
index 000000000..166cf9e7a
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Cartridge.c
@@ -0,0 +1,128 @@
+
+
+#include <PMR/Common/MessageContainer.pb-c.h>
+#include <PMR/Stubs/StubCartridgeReadRequest.pb-c.h>
+#include <PMR/Stubs/StubCartridgeReadResponse.pb-c.h>
+#include <PMR/Stubs/StubCartridgeWriteRequest.pb-c.h>
+#include <PMR/Stubs/StubCartridgeWriteResponse.pb-c.h>
+#include "include.h"
+#include "inc/hw_uart.h"
+#include "driverlib/gpio.h"
+
+#include "drivers/twine_usblib/usb_serial_adapter.h"
+#include "drivers/twine_graphicslib/graphics_adapter.h"
+
+#include "Container.h"
+#include "Stub_Status.h"
+
+void Stub_CartridgeReadRequest(MessageContainer* requestContainer)
+{
+    uint32_t status = NOT_SUPPORTED;
+    MessageContainer responseContainer;
+
+    StubCartridgeReadRequest* request = stub_cartridge_read_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+
+	//request->cartridgeid
+
+    writeLine("cartridge Request: ");
+
+    writeFloat(request->cartridgeid);
+
+    StubCartridgeReadResponse response =   STUB_CARTRIDGE_READ_RESPONSE__INIT;
+	
+	response.cartridgeid = request->cartridgeid;
+	response.has_cartridgeid = true;
+	
+	//response.cartridgecolor
+	response.has_cartridgecolor = false;
+
+	//response.cartridgeversion
+	response.has_cartridgeversion = false;
+	
+	//response.cartridgedata
+	response.has_cartridgedata = false;
+	
+	//response.cartridgeused
+	response.has_cartridgeused = false;
+	
+    status_response(status,&response.status, &response.statusword ,&response.has_statusword);
+
+    writeLine("Sending Response: ");
+
+    writeFloat(response.cartridgeid);
+    writeString(", ");
+    writeFloat(response.cartridgecolor);
+    writeString(", ");
+    writeFloat(response.cartridgeversion);
+    writeString(", ");
+    writeFloat(response.cartridgedata);
+    writeString(", ");
+    writeFloat(response.cartridgeused);
+    writeString(", ");
+
+    Write_status_response(status);
+
+    responseContainer = createContainer(MESSAGE_TYPE__StubCartridgeReadResponse, requestContainer->token, true, &response, &stub_cartridge_read_response__pack, &stub_cartridge_read_response__get_packed_size);
+
+    //-------------------------------------------------------------------------------------------
+    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    SendChars((char*)container_buffer, container_size);
+    free(container_buffer);
+    free(requestContainer);
+}
+
+void Stub_CartridgeWriteRequest(MessageContainer* requestContainer)
+{
+    uint32_t status = NOT_SUPPORTED;
+    MessageContainer responseContainer;
+
+    StubCartridgeWriteRequest* request = stub_cartridge_write_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+
+	//request->cartridgeid
+	//request->cartridgecolor
+	//request->cartridgeversion
+	//request->cartridgedata
+	//request->cartridgeused
+
+    writeLine("Cartridge Request: ");
+
+    writeFloat(request->cartridgeid);
+    writeString(", ");
+    writeFloat(request->cartridgecolor);
+    writeString(", ");
+    writeFloat(request->cartridgeversion);
+    writeString(", ");
+    writeFloat(request->cartridgedata);
+    writeString(", ");
+    writeFloat(request->cartridgeused);
+	
+    StubCartridgeWriteResponse response =   STUB_CARTRIDGE_WRITE_RESPONSE__INIT;
+	
+	response.cartridgeid = request->cartridgeid;
+	response.has_cartridgeid = true;
+	
+//    char temp[7] = "PASSED";
+//    response.status = temp;
+//    response.statusword = OK;
+//    response.has_statusword = true;
+	status_response(status,&response.status, &response.statusword ,&response.has_statusword);
+
+    writeLine("Sending Response: ");
+
+    writeFloat(response.cartridgeid);
+    writeString(", ");
+//    writeFloat(response.statusword);
+//    WRITELINESTATUS;
+    Write_status_response(status);
+
+    responseContainer = createContainer(MESSAGE_TYPE__StubCartridgeWriteResponse, requestContainer->token, true, &response, &stub_cartridge_write_response__pack, &stub_cartridge_write_response__get_packed_size);
+
+    //-------------------------------------------------------------------------------------------
+    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    SendChars((char*)container_buffer, container_size);
+    free(container_buffer);
+    free(requestContainer);
+}
+
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Cartridge.h b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Cartridge.h
new file mode 100644
index 000000000..38c71c233
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Cartridge.h
@@ -0,0 +1,9 @@
+#ifndef STUB_CARTRIDGE_H
+#define STUB_CARTRIDGE_H
+
+#include "PMR/Common/MessageContainer.pb-c.h"
+
+void Stub_CartridgeReadRequest(MessageContainer* requestContainer);
+void Stub_CartridgeWriteRequest(MessageContainer* requestContainer);
+
+#endif //STUB_CARTRIDGE_H
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dispenser.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dispenser.c
new file mode 100644
index 000000000..384133e7e
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dispenser.c
@@ -0,0 +1,72 @@
+
+
+#include <PMR/Common/MessageContainer.pb-c.h>
+#include <PMR/Stubs/StubDispenserRequest.pb-c.h>
+#include <PMR/Stubs/StubDispenserResponse.pb-c.h>
+#include "include.h"
+#include "driverlib/gpio.h"
+
+#include "drivers/twine_usblib/usb_serial_adapter.h"
+#include "drivers/twine_graphicslib/graphics_adapter.h"
+
+#include "Container.h"
+#include "Stub_Status.h"
+
+void Stub_DispenserRequest(MessageContainer* requestContainer)
+{
+    uint32_t status = NOT_SUPPORTED;
+    MessageContainer responseContainer;
+
+    StubDispenserRequest* request = stub_dispenser_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+
+	//request->dispenserid
+	//request->start
+	//request->setdirection
+	//request->setmicrostepdivision
+	//request->setspeed
+
+    writeLine("Dispenser Request: ");
+
+    writeFloat(request->dispenserid);
+    writeString(", ");
+    writeFloat(request->start);
+    writeString(", ");
+    writeFloat(request->setdirection);
+    writeString(", ");
+    writeFloat(request->setmicrostepdivision);
+    writeString(", ");
+    writeFloat(request->setspeed);
+
+    StubDispenserResponse response =   STUB_DISPENSER_RESPONSE__INIT;
+	
+	response.dispenserid = request->dispenserid;
+	response.has_dispenserid = true;
+	
+	//response.dispenserposition
+	response.has_dispenserposition = false;
+
+	//response.inkworninglevel
+	response.has_inkworninglevel = false;
+	
+	status_response(status,&response.status, &response.statusword ,&response.has_statusword);
+
+    writeLine("Sending Response: ");
+
+    writeFloat(response.dispenserid);
+    writeString(", ");
+    writeFloat(response.dispenserposition);
+    writeString(", ");
+    writeFloat(response.inkworninglevel);
+    writeString(", ");
+
+    Write_status_response(status);
+
+    responseContainer = createContainer(MESSAGE_TYPE__StubDispenserResponse, requestContainer->token, true, &response, &stub_dispenser_response__pack, &stub_dispenser_response__get_packed_size);
+
+    //-------------------------------------------------------------------------------------------
+    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    SendChars((char*)container_buffer, container_size);
+    free(container_buffer);
+    free(requestContainer);
+}
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dispenser.h b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dispenser.h
new file mode 100644
index 000000000..f2f163e99
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dispenser.h
@@ -0,0 +1,9 @@
+
+#ifndef STUB_DISPENSER_H
+#define STUB_DISPENSER_H
+
+#include "PMR/Common/MessageContainer.pb-c.h"
+
+void Stub_DispenserRequest(MessageContainer* requestContainer);
+
+#endif //STUB_DISPENSER_H
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_ExtFlash.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_ExtFlash.c
new file mode 100644
index 000000000..5b7577dfe
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_ExtFlash.c
@@ -0,0 +1,160 @@
+
+#include <PMR/Common/MessageContainer.pb-c.h>
+#include <PMR/Stubs/StubExtFlashReadRequest.pb-c.h>
+#include <PMR/Stubs/StubExtFlashReadResponse.pb-c.h>
+#include <PMR/Stubs/StubExtFlashWriteRequest.pb-c.h>
+#include <PMR/Stubs/StubExtFlashWriteResponse.pb-c.h>
+#include <drivers/Flash_Memory/Flash_Memory.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <Modules/Stubs_Handler/DataDef.h>
+#include "inc/hw_memmap.h"
+#include "inc/hw_types.h"
+#include "inc/hw_uart.h"
+#include "driverlib/gpio.h"
+
+#include "drivers/twine_usblib/usb_serial_adapter.h"
+#include "drivers/twine_graphicslib/graphics_adapter.h"
+
+#include "Container.h"
+#include "Stub_Status.h"
+
+
+#define Max_words 5
+
+
+void Stub_ExtFlashWriteRequest(MessageContainer* requestContainer)
+{
+
+    uint32_t WriteBuf[5];
+    uint32_t status = PASSED;
+
+    MessageContainer responseContainer;
+
+    StubExtFlashWriteRequest* request = stub_ext_flash_write_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+
+	
+    WriteBuf[0] = request->wordtowrite1;
+    WriteBuf[1] = request->wordtowrite2;
+    WriteBuf[2] = request->wordtowrite3;
+    WriteBuf[3] = request->wordtowrite4;
+    WriteBuf[4] = request->wordtowrite5;
+    
+    writeLine("ExtFlash Request: ");
+    writeFloat(request->wordtowrite1);
+    writeString(", ");
+    writeFloat(request->wordtowrite2);
+    writeString(", ");
+    writeFloat(request->wordtowrite3);
+	writeString(", ");
+    writeFloat(request->wordtowrite4);
+    writeString(", ");
+    writeFloat(request->wordtowrite5);
+
+    Ext_Flash_Operation(TX, Max_words, WriteBuf, NULL );
+
+    StubExtFlashWriteResponse response =   STUB_EXT_FLASH_WRITE_RESPONSE__INIT;
+	
+    status_response(status,&response.status, &response.statusword ,&response.has_statusword);
+
+    responseContainer = createContainer(MESSAGE_TYPE__StubExtFlashWriteResponse, requestContainer->token, true, &response, &stub_ext_flash_write_response__pack, &stub_ext_flash_write_response__get_packed_size);
+
+    writeLine("Sending Response: ");
+
+    Write_status_response(status);
+
+    free(request);
+    //-------------------------------------------------------------------------------------------
+    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    SendChars((char*)container_buffer, container_size);
+    free(container_buffer);
+    free(requestContainer);
+
+}
+
+void Stub_ExtFlashReadRequest(MessageContainer* requestContainer)
+{
+    uint32_t status = PASSED;
+    MessageContainer responseContainer;
+
+    StubExtFlashReadRequest* request = stub_ext_flash_read_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+
+    uint32_t No_Words;
+    uint32_t ReadBuf[Max_words];
+
+    if(request->number_of_words>Max_words)
+    {
+        No_Words = Max_words;
+    }
+    else
+    {
+        No_Words = request->number_of_words;
+    }
+
+    Ext_Flash_Operation(RX, No_Words, NULL, ReadBuf );
+
+    writeLine("ExtFlash Request: ");
+    writeFloat(request->number_of_words);
+    
+
+    StubExtFlashReadResponse response =   STUB_EXT_FLASH_READ_RESPONSE__INIT;
+	
+    status_response(status,&response.status, &response.statusword ,&response.has_statusword);
+
+	response.has_readword_5 = false;
+	response.has_readword_4 = false;
+	response.has_readword_3 = false;
+	response.has_readword_2 = false;
+	response.has_readword_1 = false;
+
+	switch(No_Words)
+	{
+	    case 5:
+	        response.readword_5 = ReadBuf[4];
+	        response.has_readword_5 = true;
+	    case 4:
+	        response.readword_4 = ReadBuf[3];
+	        response.has_readword_4 = true;
+	    case 3:
+	        response.readword_3 = ReadBuf[2];
+	        response.has_readword_3 = true;
+	    case 2:
+	        response.readword_2 = ReadBuf[1];
+	        response.has_readword_2 = true;
+	    case 1:
+	        response.readword_1 = ReadBuf[0];
+	        response.has_readword_1 = true;
+	        break;
+	    default:
+	        break;
+	}
+
+    responseContainer = createContainer(MESSAGE_TYPE__StubExtFlashReadResponse, requestContainer->token, true, &response, &stub_ext_flash_read_response__pack, &stub_ext_flash_read_response__get_packed_size);
+    //clear();
+	writeLine("Sending Response: ");
+
+	Write_status_response(status);
+    writeString(", ");
+    writeFloat(response.readword_1);
+    writeString(", ");
+    writeFloat(response.readword_2);
+    writeString(", ");
+    writeFloat(response.readword_3);
+    writeString(", ");
+    writeFloat(response.readword_4);
+    writeString(", ");
+    writeFloat(response.readword_5);
+
+    free(request);
+    //-------------------------------------------------------------------------------------------
+    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    SendChars((char*)container_buffer, container_size);
+    free(container_buffer);
+    free(requestContainer);
+}
+
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_ExtFlash.h b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_ExtFlash.h
new file mode 100644
index 000000000..35fc78f85
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_ExtFlash.h
@@ -0,0 +1,8 @@
+#ifndef STUB_EXTFLASH_H
+#define STUB_EXTFLASH_H
+
+void Stub_ExtFlashWriteRequest(MessageContainer* requestContainer);
+void Stub_ExtFlashReadRequest(MessageContainer* requestContainer);
+
+#endif //STUB_EXTFLASH_H
+
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_GPIO.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_GPIO.c
new file mode 100644
index 000000000..07ef4a360
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_GPIO.c
@@ -0,0 +1,947 @@
+#include "include.h"
+
+#include <PMR/Common/MessageContainer.pb-c.h>
+#include <PMR/Stubs/StubGPIOInputSetupRequest.pb-c.h>
+#include <PMR/Stubs/StubGPIOInputSetupResponse.pb-c.h>
+#include <PMR/Stubs/StubGPIOReadBitRequest.pb-c.h>
+#include <PMR/Stubs/StubGPIOReadBitResponse.pb-c.h>
+#include <PMR/Stubs/StubGPIOReadByteRequest.pb-c.h>
+#include <PMR/Stubs/StubGPIOReadByteResponse.pb-c.h>
+#include <PMR/Stubs/StubGPIOWriteBitRequest.pb-c.h>
+#include <PMR/Stubs/StubGPIOWriteBitResponse.pb-c.h>
+#include <PMR/Stubs/StubGPIOWriteByteRequest.pb-c.h>
+#include <PMR/Stubs/StubGPIOWriteByteResponse.pb-c.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <Modules/Stubs_Handler/DataDef.h>
+
+#include "inc/hw_memmap.h"
+#include "inc/hw_types.h"
+#include "inc/hw_uart.h"
+#include "driverlib/gpio.h"
+
+#include "drivers/twine_usblib/usb_serial_adapter.h"
+#include "drivers/twine_graphicslib/graphics_adapter.h"
+
+#include "Container.h"
+#include <Modules/Stubs_Handler/User_Leds.h>
+
+#include "Stub_Status.h"
+
+void Stub_GPIOWriteBitRequest(MessageContainer* requestContainer)
+{
+    uint32_t status = FAILED;
+    MessageContainer responseContainer;
+
+    StubGPIOWriteBitRequest* request =  stub_gpiowrite_bit_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+
+    writeLine("GPIO Request: ");
+
+    writeString(request->portid);
+    writeString(", ");
+    writeFloat(request->pinid);
+    writeString(", ");
+    writeFloat(request->bittowrite);
+
+
+              uint8_t PinId = 0;
+              uint32_t PortId = 0;
+
+              switch(request->pinid)
+              {
+                  case 0:
+                      PinId = GPIO_PIN_0;
+                      break;
+                  case 1:
+                      PinId = GPIO_PIN_1;
+                      break;
+                  case 2:
+                      PinId = GPIO_PIN_2;
+                      break;
+                  case 3:
+                      PinId = GPIO_PIN_3;
+                      break;
+                  case 4:
+                      PinId = GPIO_PIN_4;
+                      break;
+                  case 5:
+                      PinId = GPIO_PIN_5;
+                      break;
+                  case 6:
+                      PinId = GPIO_PIN_6;
+                      break;
+                  case 7:
+                      PinId = GPIO_PIN_7;
+                      break;
+                  default:
+                      break;
+              }
+
+              char Port = request->portid[0];
+              switch(Port)
+              {
+                #ifdef USE_HIGH_SPEED_GPIO
+                case 'A':
+                    PortId = GPIO_PORTA_AHB_BASE;
+                    break;
+                case 'B':
+                    PortId = GPIO_PORTB_AHB_BASE;
+                    break;
+                case 'C':
+                    PortId = GPIO_PORTC_AHB_BASE;
+                    break;
+                case 'D':
+                    PortId = GPIO_PORTD_AHB_BASE;
+                    break;
+                case 'E':
+                    PortId = GPIO_PORTE_AHB_BASE;
+                    break;
+                case 'F':
+                    PortId = GPIO_PORTF_AHB_BASE;
+                    break;
+                case 'G':
+                    PortId = GPIO_PORTG_AHB_BASE;
+                    break;
+                case 'H':
+                    PortId = GPIO_PORTH_AHB_BASE;
+                    break;
+                case 'J':
+                    PortId = GPIO_PORTJ_AHB_BASE;
+                    break;
+                #else
+                case 'A':
+                    PortId = GPIO_PORTA_BASE;
+                    break;
+                case 'B':
+                    PortId = GPIO_PORTB_BASE;
+                    break;
+                case 'C':
+                    PortId = GPIO_PORTC_BASE;
+                    break;
+                case 'D':
+                    PortId = GPIO_PORTD_BASE;
+                    break;
+                case 'E':
+                    PortId = GPIO_PORTE_BASE;
+                    break;
+                case 'F':
+                    PortId = GPIO_PORTF_BASE;
+                    break;
+                case 'G':
+                    PortId = GPIO_PORTG_BASE;
+                    break;
+                case 'H':
+                    PortId = GPIO_PORTH_BASE;
+                    break;
+                case 'J':
+                    PortId = GPIO_PORTJ_BASE;
+                    break;
+                #endif
+                  case 'K':
+                      PortId = GPIO_PORTK_BASE;
+                      break;
+                  case 'L':
+                      PortId = GPIO_PORTL_BASE;
+                      break;
+                  case 'M':
+                      PortId = GPIO_PORTM_BASE;
+                      break;
+                  case 'N':
+                      PortId = GPIO_PORTN_BASE;
+                      break;
+                  case 'P':
+                      PortId = GPIO_PORTP_BASE;
+                      break;
+                  case 'Q':
+                      PortId = GPIO_PORTQ_BASE;
+                      break;
+                  case 'R':
+                      PortId = GPIO_PORTR_BASE;
+                      break;
+                  case 'S':
+                      PortId = GPIO_PORTS_BASE;
+                      break;
+                  case 'T':
+                      PortId = GPIO_PORTT_BASE;
+                      break;
+
+                  default:
+                      writeLine("Unsupported Port ID: ");
+                      writeString(request->portid);
+                      break;
+              }
+
+              ROM_GPIOPinTypeGPIOOutput(PortId, PinId); // set the requested GPIO to output
+              SysCtlDelay(10000);
+
+              if(request->bittowrite)
+                  ROM_GPIOPinWrite(PortId, PinId, ROM_GPIOPinRead(PortId, GPIO_BYTE) |  PinId); //Turn ON the requested GPIO
+              else
+                  ROM_GPIOPinWrite(PortId, PinId, ROM_GPIOPinRead(PortId, GPIO_BYTE) &  ~PinId); //Turn OFF the requested GPIO
+
+              //GPIOPinWrite(PortId, PinId, PinId*request->bittowrite);//
+
+              StubGPIOWriteBitResponse response = STUB_GPIOWRITE_BIT_RESPONSE__INIT;
+			  
+			  response.portid = request->portid;
+				
+			  response.pinid = request->pinid;
+			  response.has_pinid = true;
+
+			  //Verify Writing
+              if(request->bittowrite)
+              {
+                  if(ROM_GPIOPinRead(PortId, PinId) ==  PinId)
+                      status = VERIFIED;
+              }
+              else
+              {
+                  if(ROM_GPIOPinRead(PortId, PinId) ==  0)
+                      status = VERIFIED;
+              }
+
+			  status_response(status,&response.status, &response.statusword ,&response.has_statusword);
+
+			  writeLine("Sending Response: ");
+
+			  writeString(response.portid);
+			  writeString(", ");
+			  writeFloat(response.pinid);
+			  writeString(", ");
+
+			  Write_status_response(status);
+
+
+              responseContainer = createContainer(MESSAGE_TYPE__StubGPIOWriteBitResponse, requestContainer->token, true, &response, &stub_gpiowrite_bit_response__pack, &stub_gpiowrite_bit_response__get_packed_size);
+
+              //-------------------------------------------------------------------------------------------
+              uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
+              size_t container_size = message_container__pack(&responseContainer, container_buffer);
+              SendChars((char*)container_buffer, container_size);
+              free(container_buffer);
+              free(requestContainer);
+}
+
+//
+void Stub_GPIOReadByteRequest(MessageContainer* requestContainer)
+{
+    uint32_t status = PASSED;
+    MessageContainer responseContainer;
+
+    StubGPIOReadByteRequest* request =  stub_gpioread_byte_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+
+    writeLine("GPIO Request: ");
+
+    writeString(request->portid);
+
+    char Port = request->portid[0];
+    uint32_t PortId = 0;
+
+    switch(Port)
+    {
+        #ifdef USE_HIGH_SPEED_GPIO
+        case 'A':
+            PortId = GPIO_PORTA_AHB_BASE;
+            break;
+        case 'B':
+            PortId = GPIO_PORTB_AHB_BASE;
+            break;
+        case 'C':
+            PortId = GPIO_PORTC_AHB_BASE;
+            break;
+        case 'D':
+            PortId = GPIO_PORTD_AHB_BASE;
+            break;
+        case 'E':
+            PortId = GPIO_PORTE_AHB_BASE;
+            break;
+        case 'F':
+            PortId = GPIO_PORTF_AHB_BASE;
+            break;
+        case 'G':
+            PortId = GPIO_PORTG_AHB_BASE;
+            break;
+        case 'H':
+            PortId = GPIO_PORTH_AHB_BASE;
+            break;
+        case 'J':
+            PortId = GPIO_PORTJ_AHB_BASE;
+            break;
+        #else
+        case 'A':
+            PortId = GPIO_PORTA_BASE;
+            break;
+        case 'B':
+            PortId = GPIO_PORTB_BASE;
+            break;
+        case 'C':
+            PortId = GPIO_PORTC_BASE;
+            break;
+        case 'D':
+            PortId = GPIO_PORTD_BASE;
+            break;
+        case 'E':
+            PortId = GPIO_PORTE_BASE;
+            break;
+        case 'F':
+            PortId = GPIO_PORTF_BASE;
+            break;
+        case 'G':
+            PortId = GPIO_PORTG_BASE;
+            break;
+        case 'H':
+            PortId = GPIO_PORTH_BASE;
+            break;
+        case 'J':
+            PortId = GPIO_PORTJ_BASE;
+            break;
+        #endif
+        case 'K':
+            PortId = GPIO_PORTK_BASE;
+            break;
+        case 'L':
+            PortId = GPIO_PORTL_BASE;
+            break;
+        case 'M':
+            PortId = GPIO_PORTM_BASE;
+            break;
+        case 'N':
+            PortId = GPIO_PORTN_BASE;
+            break;
+        case 'P':
+            PortId = GPIO_PORTP_BASE;
+            break;
+        case 'Q':
+            PortId = GPIO_PORTQ_BASE;
+            break;
+        case 'R':
+            PortId = GPIO_PORTR_BASE;
+            break;
+        case 'S':
+            PortId = GPIO_PORTS_BASE;
+            break;
+        case 'T':
+            PortId = GPIO_PORTT_BASE;
+            break;
+
+        default:
+            writeLine("Unsupported Port ID: ");
+            writeString(request->portid);
+            break;
+    }
+
+    StubGPIOReadByteResponse response = STUB_GPIOREAD_BYTE_RESPONSE__INIT;
+
+    response.portid = request->portid;
+
+    char temp = ROM_GPIOPinRead(PortId, GPIO_BYTE);
+    response.bytevalue = temp;
+    response.has_bytevalue = true;
+
+    status_response(status,&response.status, &response.statusword ,&response.has_statusword);
+
+    writeLine("Sending Response: ");
+
+    writeString(response.portid);
+    writeString(", ");
+    writeFloat(response.bytevalue);
+    writeString(", ");
+
+    Write_status_response(status);
+
+    responseContainer = createContainer(MESSAGE_TYPE__StubGPIOReadByteResponse, requestContainer->token, true, &response, &stub_gpioread_byte_response__pack, &stub_gpioread_byte_response__get_packed_size);
+
+    //-------------------------------------------------------------------------------------------
+    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    SendChars((char*)container_buffer, container_size);
+    free(container_buffer);
+    free(requestContainer);
+}
+
+
+void Stub_GPIOReadBitRequest(MessageContainer* requestContainer)
+{
+    uint32_t status = PASSED;
+    MessageContainer responseContainer;
+
+    StubGPIOReadBitRequest* request = stub_gpioread_bit_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+
+    writeLine("GPIO Request: ");
+
+    writeString(request->portid);
+    writeString(", ");
+    writeFloat(request->pinid);
+
+    uint8_t PinId = 0;
+    uint32_t PortId = 0;
+
+    switch(request->pinid)
+    {
+        case 0:
+            PinId = GPIO_PIN_0;
+            break;
+        case 1:
+            PinId = GPIO_PIN_1;
+            break;
+        case 2:
+            PinId = GPIO_PIN_2;
+            break;
+        case 3:
+            PinId = GPIO_PIN_3;
+            break;
+        case 4:
+            PinId = GPIO_PIN_4;
+            break;
+        case 5:
+            PinId = GPIO_PIN_5;
+            break;
+        case 6:
+            PinId = GPIO_PIN_6;
+            break;
+        case 7:
+            PinId = GPIO_PIN_7;
+            break;
+        default:
+            break;
+    }
+
+    char Port = request->portid[0];
+    switch(Port)
+    {
+        #ifdef USE_HIGH_SPEED_GPIO
+        case 'A':
+            PortId = GPIO_PORTA_AHB_BASE;
+            break;
+        case 'B':
+            PortId = GPIO_PORTB_AHB_BASE;
+            break;
+        case 'C':
+            PortId = GPIO_PORTC_AHB_BASE;
+            break;
+        case 'D':
+            PortId = GPIO_PORTD_AHB_BASE;
+            break;
+        case 'E':
+            PortId = GPIO_PORTE_AHB_BASE;
+            break;
+        case 'F':
+            PortId = GPIO_PORTF_AHB_BASE;
+            break;
+        case 'G':
+            PortId = GPIO_PORTG_AHB_BASE;
+            break;
+        case 'H':
+            PortId = GPIO_PORTH_AHB_BASE;
+            break;
+        case 'J':
+            PortId = GPIO_PORTJ_AHB_BASE;
+            break;
+        #else
+        case 'A':
+            PortId = GPIO_PORTA_BASE;
+            break;
+        case 'B':
+            PortId = GPIO_PORTB_BASE;
+            break;
+        case 'C':
+            PortId = GPIO_PORTC_BASE;
+            break;
+        case 'D':
+            PortId = GPIO_PORTD_BASE;
+            break;
+        case 'E':
+            PortId = GPIO_PORTE_BASE;
+            break;
+        case 'F':
+            PortId = GPIO_PORTF_BASE;
+            break;
+        case 'G':
+            PortId = GPIO_PORTG_BASE;
+            break;
+        case 'H':
+            PortId = GPIO_PORTH_BASE;
+            break;
+        case 'J':
+            PortId = GPIO_PORTJ_BASE;
+            break;
+        #endif
+        case 'K':
+            PortId = GPIO_PORTK_BASE;
+            break;
+        case 'L':
+            PortId = GPIO_PORTL_BASE;
+            break;
+        case 'M':
+            PortId = GPIO_PORTM_BASE;
+            break;
+        case 'N':
+            PortId = GPIO_PORTN_BASE;
+            break;
+        case 'P':
+            PortId = GPIO_PORTP_BASE;
+            break;
+        case 'Q':
+            PortId = GPIO_PORTQ_BASE;
+            break;
+        case 'R':
+            PortId = GPIO_PORTR_BASE;
+            break;
+        case 'S':
+            PortId = GPIO_PORTS_BASE;
+            break;
+        case 'T':
+            PortId = GPIO_PORTT_BASE;
+            break;
+
+        default:
+            writeLine("Unsupported Port ID: ");
+            writeString(request->portid);
+            break;
+    }
+
+///////////////////////////////////////////-----------------------------------------------------------------------------
+    char temp;
+    uint8_t expvalue;
+    uint32_t timeout = 10000;
+
+        if(request->pollexpvalue)
+            expvalue = PinId;
+
+        //Polling
+        if(request->polling)
+        {
+            do
+            {
+                timeout--;
+                SysCtlDelay(10000);
+                temp = ROM_GPIOPinRead(PortId, PinId);
+            } while(( temp != expvalue) && (timeout));
+
+        }
+        else
+        {
+            temp = ROM_GPIOPinRead(PortId, PinId);
+        }
+
+        StubGPIOReadBitResponse response =   STUB_GPIOREAD_BIT_RESPONSE__INIT;
+
+        response.portid = request->portid;
+
+        response.pinid = request->pinid;
+        response.has_pinid = true;
+
+        response.bitvalue = temp;
+        response.has_bitvalue = true;
+
+        status_response(status,&response.status, &response.statusword ,&response.has_statusword);
+
+        writeLine("Sending Response: ");
+
+        writeString(response.portid);
+        writeString(", ");
+        writeFloat(response.pinid);
+        writeString(", ");
+        writeFloat(response.bitvalue);
+        writeString(", ");
+
+        Write_status_response(status);
+
+        responseContainer = createContainer(MESSAGE_TYPE__StubGPIOReadBitResponse, requestContainer->token, true, &response, &stub_gpioread_bit_response__pack, &stub_gpioread_bit_response__get_packed_size);
+
+///////////////////////////////////////////-----------------------------------------------------------------------------
+/*
+//    if( (PortId == GPIO_PORTS_BASE) && (PinId == GPIO_PIN_3))
+//    {
+//        MAP_GPIOPinTypeGPIOInput(GPIO_PORTS_BASE, GPIO_PIN_3); // Enable pin PS3 for GPIOInput
+//        GPIOPadConfigSet(GPIO_PORTS_BASE,GPIO_PIN_3,GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU);//Configure GPIO pull up resistors. NOTE: does not work if ROM_GPIOPinTypeGPIOInput() isnt called before.
+//        //GPIOPadConfigSet(GPIO_PORTS_BASE,GPIO_PIN_3,GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPD );//Configure GPIO pull down resistors. NOTE: does not work if ROM_GPIOPinTypeGPIOInput() isnt called before.
+//    }
+
+    //ROM_GPIOPinTypeGPIOInput(PortId, PinId); // set the requested GPIO to Input
+    //SysCtlDelay(10000);
+
+    StubGPIOReadBitResponse response =   STUB_GPIOREAD_BIT_RESPONSE__INIT;
+
+    response.portid = request->portid;
+
+    response.pinid = request->pinid;
+    response.has_pinid = true;
+
+    char temp = ROM_GPIOPinRead(PortId, PinId);
+
+    //char temp2 = ROM_GPIOPinRead(GPIO_PORTQ_BASE, GPIO_BYTE);
+
+    //GPIOPinTypeGPIOInput(GPIO_PORTS_BASE, GPIO_PIN_3); // set the requested GPIO to Input
+    //SysCtlDelay(10000);
+    //char temp3 = GPIOPinRead(GPIO_PORTS_BASE, GPIO_PIN_3);
+    //char temp4 = GPIOPinRead(GPIO_PORTS_BASE, GPIO_BYTE);
+
+    response.bitvalue = temp;
+    response.has_bitvalue = true;
+
+    response.status = OK;
+    response.has_status = true;
+
+    writeLine("Sending Response: ");
+
+    writeString(response.portid);
+    writeString(", ");
+    writeFloat(response.pinid);
+    writeString(", ");
+    writeFloat(response.bitvalue);
+    writeString(", ");
+    writeFloat(response.status);
+    WRITELINESTATUS;
+
+    responseContainer = createContainer(MESSAGE_TYPE__StubGPIOReadBitResponse, requestContainer->token, true, &response, &stub_gpioread_bit_response__pack, &stub_gpioread_bit_response__get_packed_size);
+*/
+    //-------------------------------------------------------------------------------------------
+    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    SendChars((char*)container_buffer, container_size);
+    free(container_buffer);
+    free(requestContainer);
+}
+
+
+
+void Stub_GPIOWriteByteRequest(MessageContainer* requestContainer)
+{
+    uint32_t status = FAILED;
+    MessageContainer responseContainer;
+
+    StubGPIOWriteByteRequest* request = stub_gpiowrite_byte_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+
+    writeLine("GPIO Request: ");
+
+    writeString(request->portid);
+    writeString(", ");
+    writeFloat(request->datatowrite);
+
+    uint32_t PortId = 0;
+
+    char Port = request->portid[0];
+    switch(Port)
+    {
+        #ifdef USE_HIGH_SPEED_GPIO
+        case 'A':
+            PortId = GPIO_PORTA_AHB_BASE;
+            break;
+        case 'B':
+            PortId = GPIO_PORTB_AHB_BASE;
+            break;
+        case 'C':
+            PortId = GPIO_PORTC_AHB_BASE;
+            break;
+        case 'D':
+            PortId = GPIO_PORTD_AHB_BASE;
+            break;
+        case 'E':
+            PortId = GPIO_PORTE_AHB_BASE;
+            break;
+        case 'F':
+            PortId = GPIO_PORTF_AHB_BASE;
+            break;
+        case 'G':
+            PortId = GPIO_PORTG_AHB_BASE;
+            break;
+        case 'H':
+            PortId = GPIO_PORTH_AHB_BASE;
+            break;
+        case 'J':
+            PortId = GPIO_PORTJ_AHB_BASE;
+            break;
+        #else
+        case 'A':
+            PortId = GPIO_PORTA_BASE;
+            break;
+        case 'B':
+            PortId = GPIO_PORTB_BASE;
+            break;
+        case 'C':
+            PortId = GPIO_PORTC_BASE;
+            break;
+        case 'D':
+            PortId = GPIO_PORTD_BASE;
+            break;
+        case 'E':
+            PortId = GPIO_PORTE_BASE;
+            break;
+        case 'F':
+            PortId = GPIO_PORTF_BASE;
+            break;
+        case 'G':
+            PortId = GPIO_PORTG_BASE;
+            break;
+        case 'H':
+            PortId = GPIO_PORTH_BASE;
+            break;
+        case 'J':
+            PortId = GPIO_PORTJ_BASE;
+            break;
+        #endif
+        case 'K':
+            PortId = GPIO_PORTK_BASE;
+            break;
+        case 'L':
+            PortId = GPIO_PORTL_BASE;
+            break;
+        case 'M':
+            PortId = GPIO_PORTM_BASE;
+            break;
+        case 'N':
+            PortId = GPIO_PORTN_BASE;
+            break;
+        case 'P':
+            PortId = GPIO_PORTP_BASE;
+            break;
+        case 'Q':
+            PortId = GPIO_PORTQ_BASE;
+            break;
+        case 'R':
+            PortId = GPIO_PORTR_BASE;
+            break;
+        case 'S':
+            PortId = GPIO_PORTS_BASE;
+            break;
+        case 'T':
+            PortId = GPIO_PORTS_BASE;
+            break;
+
+        default:
+            writeLine("Unsupported Port ID: ");
+            writeString(request->portid);
+            break;
+    }
+
+    ROM_GPIOPinTypeGPIOOutput(PortId, GPIO_BYTE); // set the requested GPIO to output
+    SysCtlDelay(10000);
+
+    ROM_GPIOPinWrite(PortId, GPIO_BYTE, request->datatowrite); //Turn ON the requested GPIOs BYTE
+
+    StubGPIOWriteByteResponse response =   STUB_GPIOWRITE_BYTE_RESPONSE__INIT;
+
+    response.portid = request->portid;
+
+    //Verify writing
+    if(ROM_GPIOPinRead(PortId, GPIO_BYTE) == request->datatowrite)
+    {
+        status = VERIFIED;
+    }
+    status_response(status,&response.status, &response.statusword ,&response.has_statusword);
+
+    writeLine("Sending Response: ");
+
+    writeString(response.portid);
+    writeString(", ");
+
+    Write_status_response(status);
+
+    responseContainer = createContainer(MESSAGE_TYPE__StubGPIOWriteByteResponse, requestContainer->token, true, &response, &stub_gpiowrite_byte_response__pack, &stub_gpiowrite_byte_response__get_packed_size);
+
+    //-------------------------------------------------------------------------------------------
+    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    SendChars((char*)container_buffer, container_size);
+    free(container_buffer);
+    free(requestContainer);
+}
+
+
+
+void Stub_GPIOInputSetupRequest(MessageContainer* requestContainer)
+{
+    uint32_t status = PASSED;
+    MessageContainer responseContainer;
+
+    StubGPIOInputSetupRequest* request =  stub_gpioinput_setup_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+
+    writeLine("GPIO Request: ");
+
+    writeString(request->portid);
+    writeString(", ");
+    writeFloat(request->pinid);
+    writeString(", ");
+    writeFloat(request->setinput);
+    writeString(", ");
+    writeFloat(request->setpullup);
+
+
+              uint8_t PinId = 0;
+              uint32_t PortId = 0;
+
+              switch(request->pinid)
+              {
+                  case 0:
+                      PinId = GPIO_PIN_0;
+                      break;
+                  case 1:
+                      PinId = GPIO_PIN_1;
+                      break;
+                  case 2:
+                      PinId = GPIO_PIN_2;
+                      break;
+                  case 3:
+                      PinId = GPIO_PIN_3;
+                      break;
+                  case 4:
+                      PinId = GPIO_PIN_4;
+                      break;
+                  case 5:
+                      PinId = GPIO_PIN_5;
+                      break;
+                  case 6:
+                      PinId = GPIO_PIN_6;
+                      break;
+                  case 7:
+                      PinId = GPIO_PIN_7;
+                      break;
+                  default:
+                      break;
+              }
+
+              char Port = request->portid[0];
+              switch(Port)
+              {
+                #ifdef USE_HIGH_SPEED_GPIO
+                case 'A':
+                    PortId = GPIO_PORTA_AHB_BASE;
+                    break;
+                case 'B':
+                    PortId = GPIO_PORTB_AHB_BASE;
+                    break;
+                case 'C':
+                    PortId = GPIO_PORTC_AHB_BASE;
+                    break;
+                case 'D':
+                    PortId = GPIO_PORTD_AHB_BASE;
+                    break;
+                case 'E':
+                    PortId = GPIO_PORTE_AHB_BASE;
+                    break;
+                case 'F':
+                    PortId = GPIO_PORTF_AHB_BASE;
+                    break;
+                case 'G':
+                    PortId = GPIO_PORTG_AHB_BASE;
+                    break;
+                case 'H':
+                    PortId = GPIO_PORTH_AHB_BASE;
+                    break;
+                case 'J':
+                    PortId = GPIO_PORTJ_AHB_BASE;
+                    break;
+                #else
+                case 'A':
+                    PortId = GPIO_PORTA_BASE;
+                    break;
+                case 'B':
+                    PortId = GPIO_PORTB_BASE;
+                    break;
+                case 'C':
+                    PortId = GPIO_PORTC_BASE;
+                    break;
+                case 'D':
+                    PortId = GPIO_PORTD_BASE;
+                    break;
+                case 'E':
+                    PortId = GPIO_PORTE_BASE;
+                    break;
+                case 'F':
+                    PortId = GPIO_PORTF_BASE;
+                    break;
+                case 'G':
+                    PortId = GPIO_PORTG_BASE;
+                    break;
+                case 'H':
+                    PortId = GPIO_PORTH_BASE;
+                    break;
+                case 'J':
+                    PortId = GPIO_PORTJ_BASE;
+                    break;
+                #endif
+                  case 'K':
+                      PortId = GPIO_PORTK_BASE;
+                      break;
+                  case 'L':
+                      PortId = GPIO_PORTL_BASE;
+                      break;
+                  case 'M':
+                      PortId = GPIO_PORTM_BASE;
+                      break;
+                  case 'N':
+                      PortId = GPIO_PORTN_BASE;
+                      break;
+                  case 'P':
+                      PortId = GPIO_PORTP_BASE;
+                      break;
+                  case 'Q':
+                      PortId = GPIO_PORTQ_BASE;
+                      break;
+                  case 'R':
+                      PortId = GPIO_PORTR_BASE;
+                      break;
+                  case 'S':
+                      PortId = GPIO_PORTS_BASE;
+                      break;
+                  case 'T':
+                      PortId = GPIO_PORTT_BASE;
+                      break;
+
+                  default:
+                      writeLine("Unsupported Port ID: ");
+                      writeString(request->portid);
+                      break;
+              }
+
+              if(request->setinput == INPUT)
+              {
+                    MAP_GPIOPinTypeGPIOInput(PortId, PinId); // Enable pin for GPIOInput
+
+                    if(request->setpullup == PULLUP)
+                    {
+                        GPIOPadConfigSet(PortId,PinId,GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU);//Configure GPIO pull up resistors. NOTE: does not work if ROM_GPIOPinTypeGPIOInput() isnt called before.
+                    }
+                    else //set pulldown:
+                    {
+                        GPIOPadConfigSet(GPIO_PORTS_BASE,GPIO_PIN_3,GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPD );//Configure GPIO pull down resistors. NOTE: does not work if ROM_GPIOPinTypeGPIOInput() isnt called before.
+                    }
+              }
+              else
+              {
+                   ROM_GPIOPinTypeGPIOOutput(PortId, PinId); // set the requested GPIO to output
+              }
+
+              SysCtlDelay(10000);
+
+              StubGPIOInputSetupResponse response = STUB_GPIOINPUT_SETUP_RESPONSE__INIT;
+
+              response.portid = request->portid;
+
+              response.pinid = request->pinid;
+              response.has_pinid = true;
+
+              status_response(status,&response.status, &response.statusword ,&response.has_statusword);
+
+              writeLine("Sending Response: ");
+
+              writeString(response.portid);
+              writeString(", ");
+              writeFloat(response.pinid);
+              writeString(", ");
+
+              Write_status_response(status);
+
+              responseContainer = createContainer(MESSAGE_TYPE__StubGPIOInputSetupResponse, requestContainer->token, true, &response, &stub_gpioinput_setup_response__pack, &stub_gpioinput_setup_response__get_packed_size);
+
+              //-------------------------------------------------------------------------------------------
+              uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
+              size_t container_size = message_container__pack(&responseContainer, container_buffer);
+              SendChars((char*)container_buffer, container_size);
+              free(container_buffer);
+              free(requestContainer);
+}
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_GPIO.h b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_GPIO.h
new file mode 100644
index 000000000..3830ba54f
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_GPIO.h
@@ -0,0 +1,12 @@
+#ifndef STUB_GPIO_H
+#define STUB_GPIO_H
+
+#include "PMR/Common/MessageContainer.pb-c.h"
+
+void Stub_GPIOWriteBitRequest(MessageContainer* requestContainer);
+void Stub_GPIOReadByteRequest(MessageContainer* requestContainer);
+void Stub_GPIOReadBitRequest(MessageContainer* requestContainer);
+void Stub_GPIOWriteByteRequest(MessageContainer* requestContainer);
+void Stub_GPIOInputSetupRequest(MessageContainer* requestContainer);
+
+#endif //STUB_GPIO_H
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Heater.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Heater.c
new file mode 100644
index 000000000..ff2f2ce1c
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Heater.c
@@ -0,0 +1,74 @@
+
+
+#include <PMR/Common/MessageContainer.pb-c.h>
+#include <PMR/Stubs/StubHeaterRequest.pb-c.h>
+#include <PMR/Stubs/StubHeaterResponse.pb-c.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <Modules/Stubs_Handler/DataDef.h>
+
+#include "inc/hw_memmap.h"
+#include "inc/hw_types.h"
+#include "inc/hw_uart.h"
+#include "driverlib/gpio.h"
+
+#include "drivers/twine_usblib/usb_serial_adapter.h"
+#include "drivers/twine_graphicslib/graphics_adapter.h"
+
+#include "Container.h"
+#include "Stub_Status.h"
+#include "Drivers/Heater/Heater.h"
+
+void Stub_HeaterRequest(MessageContainer* requestContainer)
+{
+    uint32_t status = NOT_SUPPORTED;
+    MessageContainer responseContainer;
+
+    StubHeaterRequest* request = stub_heater_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+
+	/*
+	request->heaterid
+	request->heatergroupon
+    */
+
+    writeLine("Heater Request: ");
+
+    writeFloat(request->heatergroupid);
+    writeString(", ");
+    writeFloat(request->heatergroupon);
+
+    if (request->heatergroupon )
+        status = ActivateHeater(request->heatergroupid);
+    else
+        status = DeActivateHeater(request->heatergroupid);
+    StubHeaterResponse response =   STUB_HEATER_RESPONSE__INIT;
+
+	response.heatergroupid = request->heatergroupid;
+	response.has_heatergroupid = true;
+	
+	//response.heatertemperaturesensor
+	response.has_heatertemperaturesensor = false;
+	
+	status_response(status,&response.status, &response.statusword ,&response.has_statusword);
+	
+    writeLine("Sending Response: ");
+
+    writeFloat(response.heatergroupid);
+    writeString(", ");
+    writeFloat(response.heatertemperaturesensor);
+    writeString(", ");
+
+    Write_status_response(status);
+
+    responseContainer = createContainer(MESSAGE_TYPE__StubHeaterResponse, requestContainer->token, true, &response, &stub_heater_response__pack, &stub_heater_response__get_packed_size);
+
+    //-------------------------------------------------------------------------------------------
+    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    SendChars((char*)container_buffer, container_size);
+    free(container_buffer);
+    free(requestContainer);
+}
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Heater.h b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Heater.h
new file mode 100644
index 000000000..14c2dad3c
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Heater.h
@@ -0,0 +1,6 @@
+#ifndef STUB_HEATER_H
+#define STUB_HEATER_H
+
+void Stub_HeaterRequest(MessageContainer* requestContainer);
+
+#endif //STUB_HEATER_H
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_MotorEncoder.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_MotorEncoder.c
new file mode 100644
index 000000000..346b595e2
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_MotorEncoder.c
@@ -0,0 +1,84 @@
+
+#include <PMR/Common/MessageContainer.pb-c.h>
+#include <PMR/Stubs/StubMotorEncoderRequest.pb-c.h>
+#include <PMR/Stubs/StubMotorEncoderResponse.pb-c.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <Modules/Stubs_Handler/DataDef.h>
+
+#include "inc/hw_memmap.h"
+#include "inc/hw_types.h"
+#include "inc/hw_uart.h"
+#include "driverlib/gpio.h"
+
+#include "drivers/twine_usblib/usb_serial_adapter.h"
+#include "drivers/twine_graphicslib/graphics_adapter.h"
+
+#include "Container.h"
+#include "Stub_Status.h"
+
+void Stub_MotorEncoderRequest(MessageContainer* requestContainer)
+{
+    uint32_t status = NOT_SUPPORTED;
+    MessageContainer responseContainer;
+
+    StubMotorEncoderRequest* request = stub_motor_encoder_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+
+	/*
+	request->motorid
+	request->readencspeed
+	request->readdirection
+	request->motion_control
+    */
+
+    writeLine("Encoder Request: ");
+
+    writeFloat(request->motorid);
+    writeString(", ");
+    writeFloat(request->readencspeed);
+    writeString(", ");
+    writeFloat(request->readdirection);
+    writeString(", ");
+    writeFloat(request->motion_control);
+              
+    StubMotorEncoderResponse response =   STUB_MOTOR_ENCODER_RESPONSE__INIT;
+	
+	response.encoderid = request->motorid;
+	response.has_encoderid = true;
+	
+	response.encoderversion = 456;
+	response.has_encoderversion = true;
+	
+	//response.motorspeed
+	response.has_motorspeed = false;
+	
+	response.motordirection = CW;
+	response.has_motordirection = true;
+
+	status_response(status,&response.status, &response.statusword ,&response.has_statusword);
+
+    writeLine("Sending Response: ");
+
+    writeFloat(response.encoderid);
+    writeString(", ");
+    writeFloat(response.encoderversion);
+    writeString(", ");
+    writeFloat(response.motorspeed);
+    writeString(", ");
+    writeFloat(response.motordirection);
+    writeString(", ");
+
+    Write_status_response(status);
+
+    responseContainer = createContainer(MESSAGE_TYPE__StubMotorEncoderResponse, requestContainer->token, true, &response, &stub_motor_encoder_response__pack, &stub_motor_encoder_response__get_packed_size);
+
+    //-------------------------------------------------------------------------------------------
+    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    SendChars((char*)container_buffer, container_size);
+    free(container_buffer);
+    free(requestContainer);
+}
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_MotorEncoder.h b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_MotorEncoder.h
new file mode 100644
index 000000000..0e0a1c41e
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_MotorEncoder.h
@@ -0,0 +1,6 @@
+#ifndef STUB_MOTORENCODER_H
+#define STUB_MOTORENCODER_H
+
+void Stub_MotorEncoderRequest(MessageContainer* requestContainer);
+
+#endif //STUB_STUB_MOTORENCODER_H
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_OptLimitSwitch.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_OptLimitSwitch.c
new file mode 100644
index 000000000..5da89ab10
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_OptLimitSwitch.c
@@ -0,0 +1,70 @@
+
+
+#include <PMR/Common/MessageContainer.pb-c.h>
+#include <PMR/Stubs/StubOptLimitSwitchRequest.pb-c.h>
+#include <PMR/Stubs/StubOptLimitSwitchResponse.pb-c.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <Modules/Stubs_Handler/DataDef.h>
+
+#include "inc/hw_memmap.h"
+#include "inc/hw_types.h"
+#include "inc/hw_uart.h"
+#include "driverlib/gpio.h"
+
+#include "drivers/twine_usblib/usb_serial_adapter.h"
+#include "drivers/twine_graphicslib/graphics_adapter.h"
+
+#include "Container.h"
+#include "Stub_Status.h"
+
+void Stub_OptLimitSwitchRequest(MessageContainer* requestContainer)
+{
+    uint32_t status = NOT_SUPPORTED;
+
+    MessageContainer responseContainer;
+
+    StubOptLimitSwitchRequest* request = stub_opt_limit_switch_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+
+	/*
+	request->limitswitchrid
+	request->limitswitchrdisable
+    */
+
+    writeLine("OptLimit Switch Request: ");
+
+    writeFloat(request->limitswitchrid);
+    writeString(", ");
+    writeFloat(request->limitswitchrdisable);
+              
+    StubOptLimitSwitchResponse response =   STUB_OPT_LIMIT_SWITCH_RESPONSE__INIT;
+	
+	response.limitswitchrid = request->limitswitchrid;
+	response.has_limitswitchrid = true;
+	
+	//response.limitswitchditection = 2;
+	response.has_limitswitchditection = false;
+	
+	status_response(status,&response.status, &response.statusword ,&response.has_statusword);
+
+    writeLine("Sending Response: ");
+
+    writeFloat(response.limitswitchrid);
+    writeString(", ");
+    writeFloat(response.limitswitchditection);
+    writeString(", ");
+
+    Write_status_response(status);
+
+    responseContainer = createContainer(MESSAGE_TYPE__StubOptLimitSwitchResponse, requestContainer->token, true, &response, &stub_opt_limit_switch_response__pack, &stub_opt_limit_switch_response__get_packed_size);
+
+    //-------------------------------------------------------------------------------------------
+    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    SendChars((char*)container_buffer, container_size);
+    free(container_buffer);
+    free(requestContainer);
+}
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_OptLimitSwitch.h b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_OptLimitSwitch.h
new file mode 100644
index 000000000..dbd064a1d
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_OptLimitSwitch.h
@@ -0,0 +1,6 @@
+#ifndef STUB_OPTLIMITSWITCH_H
+#define STUB_OPTLIMITSWITCH_H
+
+void Stub_OptLimitSwitchRequest(MessageContainer* requestContainer);
+
+#endif //STUB_OPTLIMITSWITCH_H
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Status.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Status.c
new file mode 100644
index 000000000..00299c74c
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Status.c
@@ -0,0 +1,58 @@
+
+#include "include.h"
+/*#include <graphics_adapter.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include "Stub_Status.h"
+#include <Stubs_Handler/DataDef.h>*/
+#include "drivers/twine_graphicslib/graphics_adapter.h"
+
+int status_response(uint32_t Rstatus,char *status[20],uint32_t *statusword ,protobuf_c_boolean *has_statusword)
+{
+    if(Rstatus==PASSED)
+    {
+        *status = "PASSED";
+        *has_statusword = false;
+    }
+    else if(Rstatus==VERIFIED)
+    {
+        *status = "PASSED (VERIFIED)";
+        *has_statusword = false;
+    }
+    else if(Rstatus==NOT_SUPPORTED)
+    {
+        *status = "NOT_SUPPORTED";
+        *statusword = Rstatus;
+        *has_statusword = false;
+    }
+    else
+    {
+        *status = "FAILED";
+        *statusword = Rstatus;
+        *has_statusword = true;
+    }
+    return 0;
+}
+
+int Write_status_response(uint32_t Rstatus)
+{
+    writeFloat(Rstatus);
+
+    if(Rstatus==PASSED)
+    {
+        writeLine("PASSED");
+    }
+    else if(Rstatus==VERIFIED)
+    {
+        writeLine("PASSED (VERIFIED)");
+    }
+    else if(Rstatus==NOT_SUPPORTED)
+    {
+        writeLine("NOT_SUPPORTED");
+    }
+    else
+    {
+        writeLine("FAILED");
+    }
+    return 0;
+}
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Status.h b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Status.h
new file mode 100644
index 000000000..c2ff1b7e5
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Status.h
@@ -0,0 +1,3 @@
+
+int status_response(uint32_t Rstatus,char *status[8],uint32_t *statusword ,protobuf_c_boolean *has_statusword);
+int Write_status_response(uint32_t Rstatus);
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_SteperMotor.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_SteperMotor.c
new file mode 100644
index 000000000..03807934b
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_SteperMotor.c
@@ -0,0 +1,79 @@
+
+
+#include <PMR/Common/MessageContainer.pb-c.h>
+#include <PMR/Stubs/StubSteperMotorRequest.pb-c.h>
+#include <PMR/Stubs/StubSteperMotorResponse.pb-c.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <Modules/Stubs_Handler/DataDef.h>
+
+#include "inc/hw_memmap.h"
+#include "inc/hw_types.h"
+#include "inc/hw_uart.h"
+#include "driverlib/gpio.h"
+
+#include "drivers/twine_usblib/usb_serial_adapter.h"
+#include "drivers/twine_graphicslib/graphics_adapter.h"
+
+#include "Container.h"
+#include "Stub_Status.h"
+
+void Stub_SteperMotorRequest(MessageContainer* requestContainer)
+{
+    uint32_t status = NOT_SUPPORTED;
+    MessageContainer responseContainer;
+
+    StubSteperMotorRequest* request = stub_steper_motor_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+
+
+	writeLine("Steper Motor Request: ");
+
+    writeFloat(request->motorid);
+    writeString(", ");
+    writeFloat(request->start);
+    writeString(", ");
+    writeFloat(request->setdirection);
+    writeString(", ");
+    writeFloat(request->setmicrostepdivision);
+    writeString(", ");
+    writeFloat(request->setspeed);
+    /*
+	request->motorid
+	request->start
+	request->setdirection
+	request->setmicrostepdivision
+	request->setspeed
+    */
+              
+    StubSteperMotorResponse response =   STUB_STEPER_MOTOR_RESPONSE__INIT;
+	
+	response.motorid = request->motorid;
+	response.has_motorid = true;
+	
+	response.motorversion = 123;
+	response.has_motorversion = true;
+	
+	status_response(status,&response.status, &response.statusword ,&response.has_statusword);
+
+    writeLine("Sending Response: ");
+
+    writeFloat(response.motorid);
+    writeString(", ");
+    writeFloat(response.motorversion);
+    writeString(", ");
+
+    Write_status_response(status);
+
+
+    responseContainer = createContainer(MESSAGE_TYPE__StubSteperMotorResponse, requestContainer->token, true, &response, &stub_steper_motor_response__pack, &stub_steper_motor_response__get_packed_size);
+
+    //-------------------------------------------------------------------------------------------
+    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    SendChars((char*)container_buffer, container_size);
+    free(container_buffer);
+    free(requestContainer);
+}
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_SteperMotor.h b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_SteperMotor.h
new file mode 100644
index 000000000..b19aa0cc0
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_SteperMotor.h
@@ -0,0 +1,7 @@
+
+#ifndef STUB_STEPERMOTOR_H
+#define STUB_STEPERMOTOR_H
+
+void Stub_SteperMotorRequest(MessageContainer* requestContainer);
+
+#endif //STUB_STEPERMOTOR_H
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Valve.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Valve.c
new file mode 100644
index 000000000..ef38bb496
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Valve.c
@@ -0,0 +1,60 @@
+
+#include <PMR/Common/MessageContainer.pb-c.h>
+#include <PMR/Stubs/StubValveRequest.pb-c.h>
+#include <PMR/Stubs/StubValveResponse.pb-c.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <Modules/Stubs_Handler/DataDef.h>
+
+#include "inc/hw_memmap.h"
+#include "inc/hw_types.h"
+#include "inc/hw_uart.h"
+#include "driverlib/gpio.h"
+
+#include "drivers/twine_usblib/usb_serial_adapter.h"
+#include "drivers/twine_graphicslib/graphics_adapter.h"
+
+#include "Container.h"
+
+#include "Stub_Status.h"
+
+void Stub_ValveRequest(MessageContainer* requestContainer)
+{
+    MessageContainer responseContainer;
+    uint32_t status = NOT_SUPPORTED;
+
+    StubValveRequest* request = stub_valve_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+
+	/*
+	request->valveid
+	request->inkflow
+	request->valveon
+    */
+    writeLine("Valve Request: ");
+    writeFloat(request->valveid);
+    writeString(", ");
+    writeFloat(request->inkflow);
+    writeString(", ");
+    writeFloat(request->valveon);
+
+    StubValveResponse response =   STUB_VALVE_RESPONSE__INIT;
+
+    status_response(status,&response.status, &response.statusword ,&response.has_statusword);
+
+    responseContainer = createContainer(MESSAGE_TYPE__StubValveResponse, requestContainer->token, true, &response, &stub_valve_response__pack, &stub_valve_response__get_packed_size);
+
+    writeLine("Sending Response: ");
+
+    Write_status_response(status);
+
+    free(request);
+    //-------------------------------------------------------------------------------------------
+    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    SendChars((char*)container_buffer, container_size);
+    free(container_buffer);
+    free(requestContainer);
+}
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Valve.h b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Valve.h
new file mode 100644
index 000000000..1948fa37b
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Valve.h
@@ -0,0 +1,6 @@
+#ifndef STUB_VALVE_H
+#define STUB_VALVE_H
+void Stub_ValveRequest(MessageContainer* requestContainer);
+
+#endif //STUB_VALVE_H
+
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/User_Leds.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/User_Leds.c
new file mode 100644
index 000000000..d06b3aeef
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/User_Leds.c
@@ -0,0 +1,68 @@
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "inc/hw_memmap.h"
+
+#include "driverlib/rom.h"
+#include "driverlib/gpio.h"
+#include "driverlib/sysctl.h"
+
+#include <Modules/Stubs_Handler/DataDef.h>
+#include <Modules/Stubs_Handler/User_Leds.h>
+
+void Turn_Green_Led_On()
+{
+    INIT_GPIO_GREEN_LED
+    GREEN_LED_ON
+    LED_SET_DELAY
+}
+
+void Turn_Green_Led_Off()
+{
+    GREEN_LED_OFF
+}
+
+void Turn_Blue_Led_On()
+{
+    INIT_GPIO_BLUE_LED
+    BLUE_LED_ON
+    LED_SET_DELAY
+}
+
+void Turn_Blue_Led_Off()
+{
+    BLUE_LED_OFF
+}
+
+void Turn_Red_Led_On()
+{
+    INIT_GPIO_RED_LED
+    RED_LED_ON
+    LED_SET_DELAY
+}
+
+void Turn_Red_Led_Off()
+{
+    RED_LED_OFF
+}
+
+
+void Test_3_Color_Led()
+{
+    char i;
+
+    for (i=0;i<5000;i++)
+    {
+        Turn_Green_Led_On();
+        Turn_Green_Led_Off();
+
+        Turn_Blue_Led_On();
+        Turn_Blue_Led_Off();
+
+        Turn_Red_Led_On();
+        Turn_Red_Led_Off();
+    }
+}
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/User_Leds.h b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/User_Leds.h
new file mode 100644
index 000000000..5f0016bda
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/User_Leds.h
@@ -0,0 +1,23 @@
+#ifndef USER_LEDS_H
+#define USER_LEDS_H
+
+#define GPIO_BYTE   (GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7)
+
+#define INIT_GPIO_GREEN_LED  ROM_GPIOPinTypeGPIOOutput(GPIO_PORTQ_BASE, GPIO_PIN_7); // set PQ7 to output (Green LED)
+#define INIT_GPIO_BLUE_LED   ROM_GPIOPinTypeGPIOOutput(GPIO_PORTQ_BASE, GPIO_PIN_4); // set PQ4 to output (Blue LED)
+#define INIT_GPIO_RED_LED    ROM_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_5); // set PN5 to output (RED LED)
+
+#define GREEN_LED_ON  ROM_GPIOPinWrite(GPIO_PORTQ_BASE, GPIO_PIN_7, ROM_GPIOPinRead(GPIO_PORTQ_BASE, GPIO_BYTE) |  GPIO_PIN_7); //Turn the GREEN led on
+#define GREEN_LED_OFF ROM_GPIOPinWrite(GPIO_PORTQ_BASE, GPIO_PIN_7, ROM_GPIOPinRead(GPIO_PORTQ_BASE, GPIO_BYTE) & ~ GPIO_PIN_7); //Turn the GREEN led off
+
+#define BLUE_LED_ON   ROM_GPIOPinWrite(GPIO_PORTQ_BASE, GPIO_PIN_4, ROM_GPIOPinRead(GPIO_PORTQ_BASE, GPIO_BYTE) |  GPIO_PIN_4); //Turn the BLUE led on
+#define BLUE_LED_OFF  ROM_GPIOPinWrite(GPIO_PORTQ_BASE, GPIO_PIN_4, ROM_GPIOPinRead(GPIO_PORTQ_BASE, GPIO_BYTE) & ~ GPIO_PIN_4); //Turn the BLUE led off
+
+#define RED_LED_ON    ROM_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_5, ROM_GPIOPinRead(GPIO_PORTN_BASE, GPIO_BYTE) |  GPIO_PIN_5); //Turn the RED led on
+#define RED_LED_OFF   ROM_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_5, ROM_GPIOPinRead(GPIO_PORTN_BASE, GPIO_BYTE) & ~ GPIO_PIN_5); //Turn the RED led off
+
+#define LED_SET_DELAY SysCtlDelay(10000000); // need #include "driverlib/sysctl.h"
+
+void Test_3_Color_Led();
+
+#endif //USER_LEDS_H