diff options
Diffstat (limited to 'Software/Code_Composer')
148 files changed, 11231 insertions, 477 deletions
diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Common/ErrorCode.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Common/ErrorCode.pb-c.c index d5690d60f..88e9b78bf 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Common/ErrorCode.pb-c.c +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Common/ErrorCode.pb-c.c @@ -7,20 +7,32 @@ #endif #include "ErrorCode.pb-c.h" -static const ProtobufCEnumValue error_code__enum_values_by_number[3] = +static const ProtobufCEnumValue error_code__enum_values_by_number[9] = { { "NONE", "ERROR_CODE__NONE", 0 }, - { "BAD_CRC", "ERROR_CODE__BAD_CRC", 1 }, - { "INVALID_DIGITAL_PIN_NUMBER", "ERROR_CODE__INVALID_DIGITAL_PIN_NUMBER", 2 }, + { "GENERAL_ERROR", "ERROR_CODE__GENERAL_ERROR", 1 }, + { "BAD_CRC", "ERROR_CODE__BAD_CRC", 2 }, + { "INVALID_DIGITAL_PIN_NUMBER", "ERROR_CODE__INVALID_DIGITAL_PIN_NUMBER", 3 }, + { "UNAUTHORIZED_CONNECTION", "ERROR_CODE__UNAUTHORIZED_CONNECTION", 4 }, + { "INVALID_UPLOAD_ID", "ERROR_CODE__INVALID_UPLOAD_ID", 1000 }, + { "FILE_NOT_FOUND", "ERROR_CODE__FILE_NOT_FOUND", 1001 }, + { "INVALID_PROCESS_ID", "ERROR_CODE__INVALID_PROCESS_ID", 1002 }, + { "FILE_LENGTH_OUT_OF_RANGE", "ERROR_CODE__FILE_LENGTH_OUT_OF_RANGE", 1003 }, }; static const ProtobufCIntRange error_code__value_ranges[] = { -{0, 0},{0, 3} +{0, 0},{1000, 5},{0, 9} }; -static const ProtobufCEnumValueIndex error_code__enum_values_by_name[3] = +static const ProtobufCEnumValueIndex error_code__enum_values_by_name[9] = { - { "BAD_CRC", 1 }, - { "INVALID_DIGITAL_PIN_NUMBER", 2 }, + { "BAD_CRC", 2 }, + { "FILE_LENGTH_OUT_OF_RANGE", 8 }, + { "FILE_NOT_FOUND", 6 }, + { "GENERAL_ERROR", 1 }, + { "INVALID_DIGITAL_PIN_NUMBER", 3 }, + { "INVALID_PROCESS_ID", 7 }, + { "INVALID_UPLOAD_ID", 5 }, { "NONE", 0 }, + { "UNAUTHORIZED_CONNECTION", 4 }, }; const ProtobufCEnumDescriptor error_code__descriptor = { @@ -29,11 +41,11 @@ const ProtobufCEnumDescriptor error_code__descriptor = "ErrorCode", "ErrorCode", "", - 3, + 9, error_code__enum_values_by_number, - 3, + 9, error_code__enum_values_by_name, - 1, + 2, error_code__value_ranges, NULL,NULL,NULL,NULL /* reserved[1234] */ }; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Common/ErrorCode.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Common/ErrorCode.pb-c.h index feb3bf249..3cc7f6972 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Common/ErrorCode.pb-c.h +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Common/ErrorCode.pb-c.h @@ -20,12 +20,39 @@ PROTOBUF_C__BEGIN_DECLS /* --- enums --- */ typedef enum _ErrorCode { + /* + *General (Needs to be organized) + */ ERROR_CODE__NONE = 0, - ERROR_CODE__BAD_CRC = 1, + ERROR_CODE__GENERAL_ERROR = 1, + ERROR_CODE__BAD_CRC = 2, /* *Can be returned by SetDigitalOutResponse. */ - ERROR_CODE__INVALID_DIGITAL_PIN_NUMBER = 2 + ERROR_CODE__INVALID_DIGITAL_PIN_NUMBER = 3, + /* + *Should be returned if no ConnectionRequest with a valid password was made. + */ + ERROR_CODE__UNAUTHORIZED_CONNECTION = 4, + /* + *IO + */ + /* + *Returned by FileChunkUploadResponse when the UploadID was not set by FileUploadRequest. Or returned by ExecuteProcessResponse when the UploadID does not exist or has not been completed. + */ + ERROR_CODE__INVALID_UPLOAD_ID = 1000, + /* + *Returned by ExecuteProcessResponse when the FileName was not found. + */ + ERROR_CODE__FILE_NOT_FOUND = 1001, + /* + *Returned by KillProcessResponse when the process id was not found. + */ + ERROR_CODE__INVALID_PROCESS_ID = 1002, + /* + *Returned by FileChunkUploadResponse when the uploaded file size exceeds the expected Length from FileUploadRequest. + */ + ERROR_CODE__FILE_LENGTH_OUT_OF_RANGE = 1003 PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ERROR_CODE) } ErrorCode; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Common/ErrorResponse.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Common/ErrorResponse.pb-c.c new file mode 100644 index 000000000..8778d75a6 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Common/ErrorResponse.pb-c.c @@ -0,0 +1,72 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: ErrorResponse.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "ErrorResponse.pb-c.h" +void error_response__init + (ErrorResponse *message) +{ + static const ErrorResponse init_value = ERROR_RESPONSE__INIT; + *message = init_value; +} +size_t error_response__get_packed_size + (const ErrorResponse *message) +{ + assert(message->base.descriptor == &error_response__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t error_response__pack + (const ErrorResponse *message, + uint8_t *out) +{ + assert(message->base.descriptor == &error_response__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t error_response__pack_to_buffer + (const ErrorResponse *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &error_response__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +ErrorResponse * + error_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (ErrorResponse *) + protobuf_c_message_unpack (&error_response__descriptor, + allocator, len, data); +} +void error_response__free_unpacked + (ErrorResponse *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &error_response__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +#define error_response__field_descriptors NULL +#define error_response__field_indices_by_name NULL +#define error_response__number_ranges NULL +const ProtobufCMessageDescriptor error_response__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "ErrorResponse", + "ErrorResponse", + "ErrorResponse", + "", + sizeof(ErrorResponse), + 0, + error_response__field_descriptors, + error_response__field_indices_by_name, + 0, error_response__number_ranges, + (ProtobufCMessageInit) error_response__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Common/ErrorResponse.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Common/ErrorResponse.pb-c.h new file mode 100644 index 000000000..42d6d076c --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Common/ErrorResponse.pb-c.h @@ -0,0 +1,70 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: ErrorResponse.proto */ + +#ifndef PROTOBUF_C_ErrorResponse_2eproto__INCLUDED +#define PROTOBUF_C_ErrorResponse_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 _ErrorResponse ErrorResponse; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _ErrorResponse +{ + ProtobufCMessage base; +}; +#define ERROR_RESPONSE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&error_response__descriptor) \ + } + + +/* ErrorResponse methods */ +void error_response__init + (ErrorResponse *message); +size_t error_response__get_packed_size + (const ErrorResponse *message); +size_t error_response__pack + (const ErrorResponse *message, + uint8_t *out); +size_t error_response__pack_to_buffer + (const ErrorResponse *message, + ProtobufCBuffer *buffer); +ErrorResponse * + error_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void error_response__free_unpacked + (ErrorResponse *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*ErrorResponse_Closure) + (const ErrorResponse *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor error_response__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_ErrorResponse_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Common/MessageContainer.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Common/MessageContainer.pb-c.c index de74c4054..a54709bfd 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Common/MessageContainer.pb-c.c +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Common/MessageContainer.pb-c.c @@ -52,7 +52,7 @@ void message_container__free_unpacked assert(message->base.descriptor == &message_container__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -static const ProtobufCFieldDescriptor message_container__field_descriptors[7] = +static const ProtobufCFieldDescriptor message_container__field_descriptors[8] = { { "Type", @@ -138,6 +138,18 @@ static const ProtobufCFieldDescriptor message_container__field_descriptors[7] = 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, + { + "ErrorMessage", + 8, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(MessageContainer, errormessage), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, }; static const unsigned message_container__field_indices_by_name[] = { 5, /* field[5] = CRC */ @@ -145,13 +157,14 @@ static const unsigned message_container__field_indices_by_name[] = { 2, /* field[2] = Continuous */ 4, /* field[4] = Data */ 6, /* field[6] = Error */ + 7, /* field[7] = ErrorMessage */ 1, /* field[1] = Token */ 0, /* field[0] = Type */ }; static const ProtobufCIntRange message_container__number_ranges[1 + 1] = { { 1, 0 }, - { 0, 7 } + { 0, 8 } }; const ProtobufCMessageDescriptor message_container__descriptor = { @@ -161,7 +174,7 @@ const ProtobufCMessageDescriptor message_container__descriptor = "MessageContainer", "", sizeof(MessageContainer), - 7, + 8, message_container__field_descriptors, message_container__field_indices_by_name, 1, message_container__number_ranges, diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Common/MessageContainer.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Common/MessageContainer.pb-c.h index edb24d775..dc895b980 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Common/MessageContainer.pb-c.h +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Common/MessageContainer.pb-c.h @@ -41,10 +41,11 @@ struct _MessageContainer uint32_t crc; protobuf_c_boolean has_error; ErrorCode error; + char *errormessage; }; #define MESSAGE_CONTAINER__INIT \ { PROTOBUF_C_MESSAGE_INIT (&message_container__descriptor) \ - , 0, MESSAGE_TYPE__None, NULL, 0, 0, 0, 0, 0, {0,NULL}, 0, 0, 0, ERROR_CODE__NONE } + , 0, MESSAGE_TYPE__None, NULL, 0, 0, 0, 0, 0, {0,NULL}, 0, 0, 0, ERROR_CODE__NONE, NULL } /* MessageContainer methods */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Common/MessageType.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Common/MessageType.pb-c.c index 45ba5c5b9..9e6fbde11 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Common/MessageType.pb-c.c +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Common/MessageType.pb-c.c @@ -7,9 +7,10 @@ #endif #include "MessageType.pb-c.h" -static const ProtobufCEnumValue message_type__enum_values_by_number[114] = +static const ProtobufCEnumValue message_type__enum_values_by_number[159] = { { "None", "MESSAGE_TYPE__None", 0 }, + { "ErrorResponse", "MESSAGE_TYPE__ErrorResponse", 1 }, { "CalculateRequest", "MESSAGE_TYPE__CalculateRequest", 3 }, { "CalculateResponse", "MESSAGE_TYPE__CalculateResponse", 4 }, { "ProgressRequest", "MESSAGE_TYPE__ProgressRequest", 5 }, @@ -32,8 +33,8 @@ static const ProtobufCEnumValue message_type__enum_values_by_number[114] = { "StubGPIOWriteByteResponse", "MESSAGE_TYPE__StubGPIOWriteByteResponse", 22 }, { "StubHeaterRequest", "MESSAGE_TYPE__StubHeaterRequest", 23 }, { "StubHeaterResponse", "MESSAGE_TYPE__StubHeaterResponse", 24 }, - { "StubMotorEncoderRequest", "MESSAGE_TYPE__StubMotorEncoderRequest", 25 }, - { "StubMotorEncoderResponse", "MESSAGE_TYPE__StubMotorEncoderResponse", 26 }, + { "StubI2CRequest", "MESSAGE_TYPE__StubI2CRequest", 25 }, + { "StubI2CResponse", "MESSAGE_TYPE__StubI2CResponse", 26 }, { "StubOptLimitSwitchRequest", "MESSAGE_TYPE__StubOptLimitSwitchRequest", 27 }, { "StubOptLimitSwitchResponse", "MESSAGE_TYPE__StubOptLimitSwitchResponse", 28 }, { "StubSteperMotorRequest", "MESSAGE_TYPE__StubSteperMotorRequest", 29 }, @@ -78,6 +79,30 @@ static const ProtobufCEnumValue message_type__enum_values_by_number[114] = { "StubMotorHomeMarkResponse", "MESSAGE_TYPE__StubMotorHomeMarkResponse", 68 }, { "StubMotorRunStepTickRequest", "MESSAGE_TYPE__StubMotorRunStepTickRequest", 69 }, { "StubMotorRunStepTickResponse", "MESSAGE_TYPE__StubMotorRunStepTickResponse", 70 }, + { "StubFpgaReadRegRequest", "MESSAGE_TYPE__StubFpgaReadRegRequest", 71 }, + { "StubFpgaReadRegResponse", "MESSAGE_TYPE__StubFpgaReadRegResponse", 72 }, + { "StubFpgaWriteRegRequest", "MESSAGE_TYPE__StubFpgaWriteRegRequest", 73 }, + { "StubFpgaWriteRegResponse", "MESSAGE_TYPE__StubFpgaWriteRegResponse", 74 }, + { "StubReadEmbeddedVersionRequest", "MESSAGE_TYPE__StubReadEmbeddedVersionRequest", 75 }, + { "StubReadEmbeddedVersionResponse", "MESSAGE_TYPE__StubReadEmbeddedVersionResponse", 76 }, + { "StubTivaReadRegRequest", "MESSAGE_TYPE__StubTivaReadRegRequest", 77 }, + { "StubTivaReadRegResponse", "MESSAGE_TYPE__StubTivaReadRegResponse", 78 }, + { "StubTivaWriteRegRequest", "MESSAGE_TYPE__StubTivaWriteRegRequest", 79 }, + { "StubTivaWriteRegResponse", "MESSAGE_TYPE__StubTivaWriteRegResponse", 80 }, + { "StubDancerPositionRequest", "MESSAGE_TYPE__StubDancerPositionRequest", 81 }, + { "StubDancerPositionResponse", "MESSAGE_TYPE__StubDancerPositionResponse", 82 }, + { "StubSpeedSensorRequest", "MESSAGE_TYPE__StubSpeedSensorRequest", 83 }, + { "StubSpeedSensorResponse", "MESSAGE_TYPE__StubSpeedSensorResponse", 84 }, + { "StubRealTimeUsageRequest", "MESSAGE_TYPE__StubRealTimeUsageRequest", 85 }, + { "StubRealTimeUsageResponse", "MESSAGE_TYPE__StubRealTimeUsageResponse", 86 }, + { "StubIntADCReadRequest", "MESSAGE_TYPE__StubIntADCReadRequest", 87 }, + { "StubIntADCReadResponse", "MESSAGE_TYPE__StubIntADCReadResponse", 88 }, + { "StubTempSensorRequest", "MESSAGE_TYPE__StubTempSensorRequest", 89 }, + { "StubTempSensorResponse", "MESSAGE_TYPE__StubTempSensorResponse", 90 }, + { "StubI2CReadBytesRequest", "MESSAGE_TYPE__StubI2CReadBytesRequest", 91 }, + { "StubI2CReadBytesResponse", "MESSAGE_TYPE__StubI2CReadBytesResponse", 92 }, + { "StubI2CWriteBytesRequest", "MESSAGE_TYPE__StubI2CWriteBytesRequest", 93 }, + { "StubI2CWriteBytesResponse", "MESSAGE_TYPE__StubI2CWriteBytesResponse", 94 }, { "ExternalBridgeUdpDiscoveryPacket", "MESSAGE_TYPE__ExternalBridgeUdpDiscoveryPacket", 1000 }, { "ExternalClientLoginRequest", "MESSAGE_TYPE__ExternalClientLoginRequest", 1001 }, { "ExternalClientLoginResponse", "MESSAGE_TYPE__ExternalClientLoginResponse", 1002 }, @@ -85,10 +110,8 @@ static const ProtobufCEnumValue message_type__enum_values_by_number[114] = { "DirectSynchronizationResponse", "MESSAGE_TYPE__DirectSynchronizationResponse", 1004 }, { "OverrideDataBaseRequest", "MESSAGE_TYPE__OverrideDataBaseRequest", 1005 }, { "OverrideDataBaseResponse", "MESSAGE_TYPE__OverrideDataBaseResponse", 1006 }, - { "KeepAliveRequest", "MESSAGE_TYPE__KeepAliveRequest", 1007 }, - { "KeepAliveResponse", "MESSAGE_TYPE__KeepAliveResponse", 1008 }, - { "PushDiagnosticsRequest", "MESSAGE_TYPE__PushDiagnosticsRequest", 2000 }, - { "PushDiagnosticsResponse", "MESSAGE_TYPE__PushDiagnosticsResponse", 2001 }, + { "StartDiagnosticsRequest", "MESSAGE_TYPE__StartDiagnosticsRequest", 2000 }, + { "StartDiagnosticsResponse", "MESSAGE_TYPE__StartDiagnosticsResponse", 2001 }, { "MotorAbortHomingRequest", "MESSAGE_TYPE__MotorAbortHomingRequest", 2002 }, { "MotorAbortHomingResponse", "MESSAGE_TYPE__MotorAbortHomingResponse", 2003 }, { "MotorHomingRequest", "MESSAGE_TYPE__MotorHomingRequest", 2004 }, @@ -113,136 +136,203 @@ static const ProtobufCEnumValue message_type__enum_values_by_number[114] = { "ThreadAbortJoggingResponse", "MESSAGE_TYPE__ThreadAbortJoggingResponse", 2023 }, { "SetComponentValueRequest", "MESSAGE_TYPE__SetComponentValueRequest", 2024 }, { "SetComponentValueResponse", "MESSAGE_TYPE__SetComponentValueResponse", 2025 }, + { "ResolveEventRequest", "MESSAGE_TYPE__ResolveEventRequest", 2026 }, + { "ResolveEventResponse", "MESSAGE_TYPE__ResolveEventResponse", 2027 }, + { "StopDiagnosticsRequest", "MESSAGE_TYPE__StopDiagnosticsRequest", 2028 }, + { "StopDiagnosticsResponse", "MESSAGE_TYPE__StopDiagnosticsResponse", 2029 }, { "JobRequest", "MESSAGE_TYPE__JobRequest", 3000 }, { "JobResponse", "MESSAGE_TYPE__JobResponse", 3001 }, { "AbortJobRequest", "MESSAGE_TYPE__AbortJobRequest", 3002 }, { "AbortJobResponse", "MESSAGE_TYPE__AbortJobResponse", 3003 }, { "UploadProcessParametersRequest", "MESSAGE_TYPE__UploadProcessParametersRequest", 3004 }, { "UploadProcessParametersResponse", "MESSAGE_TYPE__UploadProcessParametersResponse", 3005 }, - { "DebugLogRequest", "MESSAGE_TYPE__DebugLogRequest", 4000 }, - { "DebugLogResponse", "MESSAGE_TYPE__DebugLogResponse", 4001 }, + { "StartDebugLogRequest", "MESSAGE_TYPE__StartDebugLogRequest", 4000 }, + { "StartDebugLogResponse", "MESSAGE_TYPE__StartDebugLogResponse", 4001 }, + { "StopDebugLogRequest", "MESSAGE_TYPE__StopDebugLogRequest", 4002 }, + { "StopDebugLogResponse", "MESSAGE_TYPE__StopDebugLogResponse", 4003 }, { "UploadHardwareConfigurationRequest", "MESSAGE_TYPE__UploadHardwareConfigurationRequest", 5000 }, { "UploadHardwareConfigurationResponse", "MESSAGE_TYPE__UploadHardwareConfigurationResponse", 5001 }, + { "SystemResetRequest", "MESSAGE_TYPE__SystemResetRequest", 5002 }, + { "SystemResetResponse", "MESSAGE_TYPE__SystemResetResponse", 5003 }, + { "KeepAliveRequest", "MESSAGE_TYPE__KeepAliveRequest", 6000 }, + { "KeepAliveResponse", "MESSAGE_TYPE__KeepAliveResponse", 6001 }, + { "ConnectRequest", "MESSAGE_TYPE__ConnectRequest", 6002 }, + { "ConnectResponse", "MESSAGE_TYPE__ConnectResponse", 6003 }, + { "DisconnectRequest", "MESSAGE_TYPE__DisconnectRequest", 6004 }, + { "DisconnectResponse", "MESSAGE_TYPE__DisconnectResponse", 6005 }, + { "FileUploadRequest", "MESSAGE_TYPE__FileUploadRequest", 7000 }, + { "FileUploadResponse", "MESSAGE_TYPE__FileUploadResponse", 7001 }, + { "FileChunkUploadRequest", "MESSAGE_TYPE__FileChunkUploadRequest", 7002 }, + { "FileChunkUploadResponse", "MESSAGE_TYPE__FileChunkUploadResponse", 7003 }, + { "ExecuteProcessRequest", "MESSAGE_TYPE__ExecuteProcessRequest", 7004 }, + { "ExecuteProcessResponse", "MESSAGE_TYPE__ExecuteProcessResponse", 7005 }, + { "KillProcessRequest", "MESSAGE_TYPE__KillProcessRequest", 7006 }, + { "KillProcessResponse", "MESSAGE_TYPE__KillProcessResponse", 7007 }, }; static const ProtobufCIntRange message_type__value_ranges[] = { -{0, 0},{3, 1},{1000, 69},{2000, 78},{3000, 104},{4000, 110},{5000, 112},{0, 114} +{0, 0},{3, 2},{1000, 94},{2000, 101},{3000, 131},{4000, 137},{5000, 141},{6000, 145},{7000, 151},{0, 159} }; -static const ProtobufCEnumValueIndex message_type__enum_values_by_name[114] = +static const ProtobufCEnumValueIndex message_type__enum_values_by_name[159] = { - { "AbortJobRequest", 106 }, - { "AbortJobResponse", 107 }, - { "CalculateRequest", 1 }, - { "CalculateResponse", 2 }, - { "DebugLogRequest", 110 }, - { "DebugLogResponse", 111 }, - { "DirectSynchronizationRequest", 72 }, - { "DirectSynchronizationResponse", 73 }, - { "DispenserAbortHomingRequest", 88 }, - { "DispenserAbortHomingResponse", 89 }, - { "DispenserAbortJoggingRequest", 94 }, - { "DispenserAbortJoggingResponse", 95 }, - { "DispenserHomingRequest", 90 }, - { "DispenserHomingResponse", 91 }, - { "DispenserJoggingRequest", 92 }, - { "DispenserJoggingResponse", 93 }, - { "ExternalBridgeUdpDiscoveryPacket", 69 }, - { "ExternalClientLoginRequest", 70 }, - { "ExternalClientLoginResponse", 71 }, - { "JobRequest", 104 }, - { "JobResponse", 105 }, - { "KeepAliveRequest", 76 }, - { "KeepAliveResponse", 77 }, - { "MotorAbortHomingRequest", 80 }, - { "MotorAbortHomingResponse", 81 }, - { "MotorAbortJoggingRequest", 86 }, - { "MotorAbortJoggingResponse", 87 }, - { "MotorHomingRequest", 82 }, - { "MotorHomingResponse", 83 }, - { "MotorJoggingRequest", 84 }, - { "MotorJoggingResponse", 85 }, + { "AbortJobRequest", 133 }, + { "AbortJobResponse", 134 }, + { "CalculateRequest", 2 }, + { "CalculateResponse", 3 }, + { "ConnectRequest", 147 }, + { "ConnectResponse", 148 }, + { "DirectSynchronizationRequest", 97 }, + { "DirectSynchronizationResponse", 98 }, + { "DisconnectRequest", 149 }, + { "DisconnectResponse", 150 }, + { "DispenserAbortHomingRequest", 111 }, + { "DispenserAbortHomingResponse", 112 }, + { "DispenserAbortJoggingRequest", 117 }, + { "DispenserAbortJoggingResponse", 118 }, + { "DispenserHomingRequest", 113 }, + { "DispenserHomingResponse", 114 }, + { "DispenserJoggingRequest", 115 }, + { "DispenserJoggingResponse", 116 }, + { "ErrorResponse", 1 }, + { "ExecuteProcessRequest", 155 }, + { "ExecuteProcessResponse", 156 }, + { "ExternalBridgeUdpDiscoveryPacket", 94 }, + { "ExternalClientLoginRequest", 95 }, + { "ExternalClientLoginResponse", 96 }, + { "FileChunkUploadRequest", 153 }, + { "FileChunkUploadResponse", 154 }, + { "FileUploadRequest", 151 }, + { "FileUploadResponse", 152 }, + { "JobRequest", 131 }, + { "JobResponse", 132 }, + { "KeepAliveRequest", 145 }, + { "KeepAliveResponse", 146 }, + { "KillProcessRequest", 157 }, + { "KillProcessResponse", 158 }, + { "MotorAbortHomingRequest", 103 }, + { "MotorAbortHomingResponse", 104 }, + { "MotorAbortJoggingRequest", 109 }, + { "MotorAbortJoggingResponse", 110 }, + { "MotorHomingRequest", 105 }, + { "MotorHomingResponse", 106 }, + { "MotorJoggingRequest", 107 }, + { "MotorJoggingResponse", 108 }, { "None", 0 }, - { "OverrideDataBaseRequest", 74 }, - { "OverrideDataBaseResponse", 75 }, - { "ProgressRequest", 3 }, - { "ProgressResponse", 4 }, - { "PushDiagnosticsRequest", 78 }, - { "PushDiagnosticsResponse", 79 }, - { "SetComponentValueRequest", 102 }, - { "SetComponentValueResponse", 103 }, - { "SetDigitalOutRequest", 96 }, - { "SetDigitalOutResponse", 97 }, - { "StubCartridgeReadRequest", 5 }, - { "StubCartridgeReadResponse", 6 }, - { "StubCartridgeWriteRequest", 7 }, - { "StubCartridgeWriteResponse", 8 }, - { "StubDispenserRequest", 9 }, - { "StubDispenserResponse", 10 }, - { "StubExtFlashReadRequest", 31 }, - { "StubExtFlashReadResponse", 32 }, - { "StubExtFlashWriteRequest", 33 }, - { "StubExtFlashWriteResponse", 34 }, - { "StubF3Gpo01WriteRequest", 57 }, - { "StubF3Gpo01WriteResponse", 58 }, - { "StubFPGAReadBackRegRequest", 35 }, - { "StubFPGAReadBackRegResponse", 36 }, - { "StubFPGAReadVersionRequest", 37 }, - { "StubFPGAReadVersionResponse", 38 }, - { "StubGPIOInputSetupRequest", 11 }, - { "StubGPIOInputSetupResponse", 12 }, - { "StubGPIOReadBitRequest", 13 }, - { "StubGPIOReadBitResponse", 14 }, - { "StubGPIOReadByteRequest", 15 }, - { "StubGPIOReadByteResponse", 16 }, - { "StubGPIOWriteBitRequest", 17 }, - { "StubGPIOWriteBitResponse", 18 }, - { "StubGPIOWriteByteRequest", 19 }, - { "StubGPIOWriteByteResponse", 20 }, - { "StubHWVersionRequest", 55 }, - { "StubHWVersionResponse", 56 }, - { "StubHeaterRequest", 21 }, - { "StubHeaterResponse", 22 }, - { "StubHeatingTestPollRequest", 61 }, - { "StubHeatingTestPollResponse", 62 }, - { "StubHeatingTestRequest", 59 }, - { "StubHeatingTestResponse", 60 }, - { "StubL6470DriverRequest", 39 }, - { "StubL6470DriverResponse", 40 }, - { "StubMotorEncoderRequest", 23 }, - { "StubMotorEncoderResponse", 24 }, - { "StubMotorHomeMarkRequest", 65 }, - { "StubMotorHomeMarkResponse", 66 }, - { "StubMotorInitRequest", 41 }, - { "StubMotorInitResponse", 42 }, - { "StubMotorMovRequest", 49 }, - { "StubMotorMovResponse", 50 }, - { "StubMotorPositionRequest", 53 }, - { "StubMotorPositionResponse", 54 }, - { "StubMotorRequest", 63 }, - { "StubMotorResponse", 64 }, - { "StubMotorRunRequest", 43 }, - { "StubMotorRunResponse", 44 }, - { "StubMotorRunStepTickRequest", 67 }, - { "StubMotorRunStepTickResponse", 68 }, - { "StubMotorSpeedRequest", 51 }, - { "StubMotorSpeedResponse", 52 }, - { "StubMotorStatusRequest", 47 }, - { "StubMotorStatusResponse", 48 }, - { "StubMotorStopRequest", 45 }, - { "StubMotorStopResponse", 46 }, - { "StubOptLimitSwitchRequest", 25 }, - { "StubOptLimitSwitchResponse", 26 }, - { "StubSteperMotorRequest", 27 }, - { "StubSteperMotorResponse", 28 }, - { "StubValveRequest", 29 }, - { "StubValveResponse", 30 }, - { "ThreadAbortJoggingRequest", 100 }, - { "ThreadAbortJoggingResponse", 101 }, - { "ThreadJoggingRequest", 98 }, - { "ThreadJoggingResponse", 99 }, - { "UploadHardwareConfigurationRequest", 112 }, - { "UploadHardwareConfigurationResponse", 113 }, - { "UploadProcessParametersRequest", 108 }, - { "UploadProcessParametersResponse", 109 }, + { "OverrideDataBaseRequest", 99 }, + { "OverrideDataBaseResponse", 100 }, + { "ProgressRequest", 4 }, + { "ProgressResponse", 5 }, + { "ResolveEventRequest", 127 }, + { "ResolveEventResponse", 128 }, + { "SetComponentValueRequest", 125 }, + { "SetComponentValueResponse", 126 }, + { "SetDigitalOutRequest", 119 }, + { "SetDigitalOutResponse", 120 }, + { "StartDebugLogRequest", 137 }, + { "StartDebugLogResponse", 138 }, + { "StartDiagnosticsRequest", 101 }, + { "StartDiagnosticsResponse", 102 }, + { "StopDebugLogRequest", 139 }, + { "StopDebugLogResponse", 140 }, + { "StopDiagnosticsRequest", 129 }, + { "StopDiagnosticsResponse", 130 }, + { "StubCartridgeReadRequest", 6 }, + { "StubCartridgeReadResponse", 7 }, + { "StubCartridgeWriteRequest", 8 }, + { "StubCartridgeWriteResponse", 9 }, + { "StubDancerPositionRequest", 80 }, + { "StubDancerPositionResponse", 81 }, + { "StubDispenserRequest", 10 }, + { "StubDispenserResponse", 11 }, + { "StubExtFlashReadRequest", 32 }, + { "StubExtFlashReadResponse", 33 }, + { "StubExtFlashWriteRequest", 34 }, + { "StubExtFlashWriteResponse", 35 }, + { "StubF3Gpo01WriteRequest", 58 }, + { "StubF3Gpo01WriteResponse", 59 }, + { "StubFPGAReadBackRegRequest", 36 }, + { "StubFPGAReadBackRegResponse", 37 }, + { "StubFPGAReadVersionRequest", 38 }, + { "StubFPGAReadVersionResponse", 39 }, + { "StubFpgaReadRegRequest", 70 }, + { "StubFpgaReadRegResponse", 71 }, + { "StubFpgaWriteRegRequest", 72 }, + { "StubFpgaWriteRegResponse", 73 }, + { "StubGPIOInputSetupRequest", 12 }, + { "StubGPIOInputSetupResponse", 13 }, + { "StubGPIOReadBitRequest", 14 }, + { "StubGPIOReadBitResponse", 15 }, + { "StubGPIOReadByteRequest", 16 }, + { "StubGPIOReadByteResponse", 17 }, + { "StubGPIOWriteBitRequest", 18 }, + { "StubGPIOWriteBitResponse", 19 }, + { "StubGPIOWriteByteRequest", 20 }, + { "StubGPIOWriteByteResponse", 21 }, + { "StubHWVersionRequest", 56 }, + { "StubHWVersionResponse", 57 }, + { "StubHeaterRequest", 22 }, + { "StubHeaterResponse", 23 }, + { "StubHeatingTestPollRequest", 62 }, + { "StubHeatingTestPollResponse", 63 }, + { "StubHeatingTestRequest", 60 }, + { "StubHeatingTestResponse", 61 }, + { "StubI2CReadBytesRequest", 90 }, + { "StubI2CReadBytesResponse", 91 }, + { "StubI2CRequest", 24 }, + { "StubI2CResponse", 25 }, + { "StubI2CWriteBytesRequest", 92 }, + { "StubI2CWriteBytesResponse", 93 }, + { "StubIntADCReadRequest", 86 }, + { "StubIntADCReadResponse", 87 }, + { "StubL6470DriverRequest", 40 }, + { "StubL6470DriverResponse", 41 }, + { "StubMotorHomeMarkRequest", 66 }, + { "StubMotorHomeMarkResponse", 67 }, + { "StubMotorInitRequest", 42 }, + { "StubMotorInitResponse", 43 }, + { "StubMotorMovRequest", 50 }, + { "StubMotorMovResponse", 51 }, + { "StubMotorPositionRequest", 54 }, + { "StubMotorPositionResponse", 55 }, + { "StubMotorRequest", 64 }, + { "StubMotorResponse", 65 }, + { "StubMotorRunRequest", 44 }, + { "StubMotorRunResponse", 45 }, + { "StubMotorRunStepTickRequest", 68 }, + { "StubMotorRunStepTickResponse", 69 }, + { "StubMotorSpeedRequest", 52 }, + { "StubMotorSpeedResponse", 53 }, + { "StubMotorStatusRequest", 48 }, + { "StubMotorStatusResponse", 49 }, + { "StubMotorStopRequest", 46 }, + { "StubMotorStopResponse", 47 }, + { "StubOptLimitSwitchRequest", 26 }, + { "StubOptLimitSwitchResponse", 27 }, + { "StubReadEmbeddedVersionRequest", 74 }, + { "StubReadEmbeddedVersionResponse", 75 }, + { "StubRealTimeUsageRequest", 84 }, + { "StubRealTimeUsageResponse", 85 }, + { "StubSpeedSensorRequest", 82 }, + { "StubSpeedSensorResponse", 83 }, + { "StubSteperMotorRequest", 28 }, + { "StubSteperMotorResponse", 29 }, + { "StubTempSensorRequest", 88 }, + { "StubTempSensorResponse", 89 }, + { "StubTivaReadRegRequest", 76 }, + { "StubTivaReadRegResponse", 77 }, + { "StubTivaWriteRegRequest", 78 }, + { "StubTivaWriteRegResponse", 79 }, + { "StubValveRequest", 30 }, + { "StubValveResponse", 31 }, + { "SystemResetRequest", 143 }, + { "SystemResetResponse", 144 }, + { "ThreadAbortJoggingRequest", 123 }, + { "ThreadAbortJoggingResponse", 124 }, + { "ThreadJoggingRequest", 121 }, + { "ThreadJoggingResponse", 122 }, + { "UploadHardwareConfigurationRequest", 141 }, + { "UploadHardwareConfigurationResponse", 142 }, + { "UploadProcessParametersRequest", 135 }, + { "UploadProcessParametersResponse", 136 }, }; const ProtobufCEnumDescriptor message_type__descriptor = { @@ -251,11 +341,11 @@ const ProtobufCEnumDescriptor message_type__descriptor = "MessageType", "MessageType", "", - 114, + 159, message_type__enum_values_by_number, - 114, + 159, message_type__enum_values_by_name, - 7, + 9, message_type__value_ranges, NULL,NULL,NULL,NULL /* reserved[1234] */ }; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Common/MessageType.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Common/MessageType.pb-c.h index 387a5eb1d..25356ff24 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Common/MessageType.pb-c.h +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Common/MessageType.pb-c.h @@ -20,7 +20,17 @@ PROTOBUF_C__BEGIN_DECLS /* --- enums --- */ typedef enum _MessageType { + /* + *The first enumeration value must be zero so.. + */ MESSAGE_TYPE__None = 0, + /* + *Common + */ + MESSAGE_TYPE__ErrorResponse = 1, + /* + *Stubs + */ MESSAGE_TYPE__CalculateRequest = 3, MESSAGE_TYPE__CalculateResponse = 4, MESSAGE_TYPE__ProgressRequest = 5, @@ -43,8 +53,8 @@ typedef enum _MessageType { MESSAGE_TYPE__StubGPIOWriteByteResponse = 22, MESSAGE_TYPE__StubHeaterRequest = 23, MESSAGE_TYPE__StubHeaterResponse = 24, - MESSAGE_TYPE__StubMotorEncoderRequest = 25, - MESSAGE_TYPE__StubMotorEncoderResponse = 26, + MESSAGE_TYPE__StubI2CRequest = 25, + MESSAGE_TYPE__StubI2CResponse = 26, MESSAGE_TYPE__StubOptLimitSwitchRequest = 27, MESSAGE_TYPE__StubOptLimitSwitchResponse = 28, MESSAGE_TYPE__StubSteperMotorRequest = 29, @@ -89,6 +99,33 @@ typedef enum _MessageType { MESSAGE_TYPE__StubMotorHomeMarkResponse = 68, MESSAGE_TYPE__StubMotorRunStepTickRequest = 69, MESSAGE_TYPE__StubMotorRunStepTickResponse = 70, + MESSAGE_TYPE__StubFpgaReadRegRequest = 71, + MESSAGE_TYPE__StubFpgaReadRegResponse = 72, + MESSAGE_TYPE__StubFpgaWriteRegRequest = 73, + MESSAGE_TYPE__StubFpgaWriteRegResponse = 74, + MESSAGE_TYPE__StubReadEmbeddedVersionRequest = 75, + MESSAGE_TYPE__StubReadEmbeddedVersionResponse = 76, + MESSAGE_TYPE__StubTivaReadRegRequest = 77, + MESSAGE_TYPE__StubTivaReadRegResponse = 78, + MESSAGE_TYPE__StubTivaWriteRegRequest = 79, + MESSAGE_TYPE__StubTivaWriteRegResponse = 80, + MESSAGE_TYPE__StubDancerPositionRequest = 81, + MESSAGE_TYPE__StubDancerPositionResponse = 82, + MESSAGE_TYPE__StubSpeedSensorRequest = 83, + MESSAGE_TYPE__StubSpeedSensorResponse = 84, + MESSAGE_TYPE__StubRealTimeUsageRequest = 85, + MESSAGE_TYPE__StubRealTimeUsageResponse = 86, + MESSAGE_TYPE__StubIntADCReadRequest = 87, + MESSAGE_TYPE__StubIntADCReadResponse = 88, + MESSAGE_TYPE__StubTempSensorRequest = 89, + MESSAGE_TYPE__StubTempSensorResponse = 90, + MESSAGE_TYPE__StubI2CReadBytesRequest = 91, + MESSAGE_TYPE__StubI2CReadBytesResponse = 92, + MESSAGE_TYPE__StubI2CWriteBytesRequest = 93, + MESSAGE_TYPE__StubI2CWriteBytesResponse = 94, + /* + *Integration + */ MESSAGE_TYPE__ExternalBridgeUdpDiscoveryPacket = 1000, MESSAGE_TYPE__ExternalClientLoginRequest = 1001, MESSAGE_TYPE__ExternalClientLoginResponse = 1002, @@ -96,10 +133,11 @@ typedef enum _MessageType { MESSAGE_TYPE__DirectSynchronizationResponse = 1004, MESSAGE_TYPE__OverrideDataBaseRequest = 1005, MESSAGE_TYPE__OverrideDataBaseResponse = 1006, - MESSAGE_TYPE__KeepAliveRequest = 1007, - MESSAGE_TYPE__KeepAliveResponse = 1008, - MESSAGE_TYPE__PushDiagnosticsRequest = 2000, - MESSAGE_TYPE__PushDiagnosticsResponse = 2001, + /* + *Diagnostics + */ + MESSAGE_TYPE__StartDiagnosticsRequest = 2000, + MESSAGE_TYPE__StartDiagnosticsResponse = 2001, MESSAGE_TYPE__MotorAbortHomingRequest = 2002, MESSAGE_TYPE__MotorAbortHomingResponse = 2003, MESSAGE_TYPE__MotorHomingRequest = 2004, @@ -124,16 +162,53 @@ typedef enum _MessageType { MESSAGE_TYPE__ThreadAbortJoggingResponse = 2023, MESSAGE_TYPE__SetComponentValueRequest = 2024, MESSAGE_TYPE__SetComponentValueResponse = 2025, + MESSAGE_TYPE__ResolveEventRequest = 2026, + MESSAGE_TYPE__ResolveEventResponse = 2027, + MESSAGE_TYPE__StopDiagnosticsRequest = 2028, + MESSAGE_TYPE__StopDiagnosticsResponse = 2029, + /* + *Printing + */ MESSAGE_TYPE__JobRequest = 3000, MESSAGE_TYPE__JobResponse = 3001, MESSAGE_TYPE__AbortJobRequest = 3002, MESSAGE_TYPE__AbortJobResponse = 3003, MESSAGE_TYPE__UploadProcessParametersRequest = 3004, MESSAGE_TYPE__UploadProcessParametersResponse = 3005, - MESSAGE_TYPE__DebugLogRequest = 4000, - MESSAGE_TYPE__DebugLogResponse = 4001, + /* + *Debugging + */ + MESSAGE_TYPE__StartDebugLogRequest = 4000, + MESSAGE_TYPE__StartDebugLogResponse = 4001, + MESSAGE_TYPE__StopDebugLogRequest = 4002, + MESSAGE_TYPE__StopDebugLogResponse = 4003, + /* + *Hardware + */ MESSAGE_TYPE__UploadHardwareConfigurationRequest = 5000, - MESSAGE_TYPE__UploadHardwareConfigurationResponse = 5001 + MESSAGE_TYPE__UploadHardwareConfigurationResponse = 5001, + MESSAGE_TYPE__SystemResetRequest = 5002, + MESSAGE_TYPE__SystemResetResponse = 5003, + /* + *Connection + */ + MESSAGE_TYPE__KeepAliveRequest = 6000, + MESSAGE_TYPE__KeepAliveResponse = 6001, + MESSAGE_TYPE__ConnectRequest = 6002, + MESSAGE_TYPE__ConnectResponse = 6003, + MESSAGE_TYPE__DisconnectRequest = 6004, + MESSAGE_TYPE__DisconnectResponse = 6005, + /* + *IO + */ + MESSAGE_TYPE__FileUploadRequest = 7000, + MESSAGE_TYPE__FileUploadResponse = 7001, + MESSAGE_TYPE__FileChunkUploadRequest = 7002, + MESSAGE_TYPE__FileChunkUploadResponse = 7003, + MESSAGE_TYPE__ExecuteProcessRequest = 7004, + MESSAGE_TYPE__ExecuteProcessResponse = 7005, + MESSAGE_TYPE__KillProcessRequest = 7006, + MESSAGE_TYPE__KillProcessResponse = 7007 PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(MESSAGE_TYPE) } MessageType; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Connection/ConnectRequest.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Connection/ConnectRequest.pb-c.c new file mode 100644 index 000000000..127b22ef3 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Connection/ConnectRequest.pb-c.c @@ -0,0 +1,92 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: ConnectRequest.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "ConnectRequest.pb-c.h" +void connect_request__init + (ConnectRequest *message) +{ + static const ConnectRequest init_value = CONNECT_REQUEST__INIT; + *message = init_value; +} +size_t connect_request__get_packed_size + (const ConnectRequest *message) +{ + assert(message->base.descriptor == &connect_request__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t connect_request__pack + (const ConnectRequest *message, + uint8_t *out) +{ + assert(message->base.descriptor == &connect_request__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t connect_request__pack_to_buffer + (const ConnectRequest *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &connect_request__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +ConnectRequest * + connect_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (ConnectRequest *) + protobuf_c_message_unpack (&connect_request__descriptor, + allocator, len, data); +} +void connect_request__free_unpacked + (ConnectRequest *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &connect_request__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor connect_request__field_descriptors[1] = +{ + { + "Password", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(ConnectRequest, password), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned connect_request__field_indices_by_name[] = { + 0, /* field[0] = Password */ +}; +static const ProtobufCIntRange connect_request__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor connect_request__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "ConnectRequest", + "ConnectRequest", + "ConnectRequest", + "", + sizeof(ConnectRequest), + 1, + connect_request__field_descriptors, + connect_request__field_indices_by_name, + 1, connect_request__number_ranges, + (ProtobufCMessageInit) connect_request__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Connection/ConnectRequest.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Connection/ConnectRequest.pb-c.h new file mode 100644 index 000000000..6e6be56e5 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Connection/ConnectRequest.pb-c.h @@ -0,0 +1,71 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: ConnectRequest.proto */ + +#ifndef PROTOBUF_C_ConnectRequest_2eproto__INCLUDED +#define PROTOBUF_C_ConnectRequest_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 _ConnectRequest ConnectRequest; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _ConnectRequest +{ + ProtobufCMessage base; + char *password; +}; +#define CONNECT_REQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&connect_request__descriptor) \ + , NULL } + + +/* ConnectRequest methods */ +void connect_request__init + (ConnectRequest *message); +size_t connect_request__get_packed_size + (const ConnectRequest *message); +size_t connect_request__pack + (const ConnectRequest *message, + uint8_t *out); +size_t connect_request__pack_to_buffer + (const ConnectRequest *message, + ProtobufCBuffer *buffer); +ConnectRequest * + connect_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void connect_request__free_unpacked + (ConnectRequest *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*ConnectRequest_Closure) + (const ConnectRequest *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor connect_request__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_ConnectRequest_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Connection/ConnectResponse.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Connection/ConnectResponse.pb-c.c new file mode 100644 index 000000000..ce449266e --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Connection/ConnectResponse.pb-c.c @@ -0,0 +1,92 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: ConnectResponse.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "ConnectResponse.pb-c.h" +void connect_response__init + (ConnectResponse *message) +{ + static const ConnectResponse init_value = CONNECT_RESPONSE__INIT; + *message = init_value; +} +size_t connect_response__get_packed_size + (const ConnectResponse *message) +{ + assert(message->base.descriptor == &connect_response__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t connect_response__pack + (const ConnectResponse *message, + uint8_t *out) +{ + assert(message->base.descriptor == &connect_response__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t connect_response__pack_to_buffer + (const ConnectResponse *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &connect_response__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +ConnectResponse * + connect_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (ConnectResponse *) + protobuf_c_message_unpack (&connect_response__descriptor, + allocator, len, data); +} +void connect_response__free_unpacked + (ConnectResponse *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &connect_response__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor connect_response__field_descriptors[1] = +{ + { + "DeviceInformation", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(ConnectResponse, deviceinformation), + &device_information__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned connect_response__field_indices_by_name[] = { + 0, /* field[0] = DeviceInformation */ +}; +static const ProtobufCIntRange connect_response__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor connect_response__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "ConnectResponse", + "ConnectResponse", + "ConnectResponse", + "", + sizeof(ConnectResponse), + 1, + connect_response__field_descriptors, + connect_response__field_indices_by_name, + 1, connect_response__number_ranges, + (ProtobufCMessageInit) connect_response__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Connection/ConnectResponse.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Connection/ConnectResponse.pb-c.h new file mode 100644 index 000000000..85a15995c --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Connection/ConnectResponse.pb-c.h @@ -0,0 +1,72 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: ConnectResponse.proto */ + +#ifndef PROTOBUF_C_ConnectResponse_2eproto__INCLUDED +#define PROTOBUF_C_ConnectResponse_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 "DeviceInformation.pb-c.h" + +typedef struct _ConnectResponse ConnectResponse; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _ConnectResponse +{ + ProtobufCMessage base; + DeviceInformation *deviceinformation; +}; +#define CONNECT_RESPONSE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&connect_response__descriptor) \ + , NULL } + + +/* ConnectResponse methods */ +void connect_response__init + (ConnectResponse *message); +size_t connect_response__get_packed_size + (const ConnectResponse *message); +size_t connect_response__pack + (const ConnectResponse *message, + uint8_t *out); +size_t connect_response__pack_to_buffer + (const ConnectResponse *message, + ProtobufCBuffer *buffer); +ConnectResponse * + connect_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void connect_response__free_unpacked + (ConnectResponse *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*ConnectResponse_Closure) + (const ConnectResponse *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor connect_response__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_ConnectResponse_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Connection/DeviceInformation.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Connection/DeviceInformation.pb-c.c new file mode 100644 index 000000000..2ecae726e --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Connection/DeviceInformation.pb-c.c @@ -0,0 +1,118 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: DeviceInformation.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "DeviceInformation.pb-c.h" +void device_information__init + (DeviceInformation *message) +{ + static const DeviceInformation init_value = DEVICE_INFORMATION__INIT; + *message = init_value; +} +size_t device_information__get_packed_size + (const DeviceInformation *message) +{ + assert(message->base.descriptor == &device_information__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t device_information__pack + (const DeviceInformation *message, + uint8_t *out) +{ + assert(message->base.descriptor == &device_information__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t device_information__pack_to_buffer + (const DeviceInformation *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &device_information__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +DeviceInformation * + device_information__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (DeviceInformation *) + protobuf_c_message_unpack (&device_information__descriptor, + allocator, len, data); +} +void device_information__free_unpacked + (DeviceInformation *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &device_information__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor device_information__field_descriptors[3] = +{ + { + "Name", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(DeviceInformation, name), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Version", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(DeviceInformation, version), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "BuildDate", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(DeviceInformation, builddate), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned device_information__field_indices_by_name[] = { + 2, /* field[2] = BuildDate */ + 0, /* field[0] = Name */ + 1, /* field[1] = Version */ +}; +static const ProtobufCIntRange device_information__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor device_information__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "DeviceInformation", + "DeviceInformation", + "DeviceInformation", + "", + sizeof(DeviceInformation), + 3, + device_information__field_descriptors, + device_information__field_indices_by_name, + 1, device_information__number_ranges, + (ProtobufCMessageInit) device_information__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Connection/DeviceInformation.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Connection/DeviceInformation.pb-c.h new file mode 100644 index 000000000..521c77424 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Connection/DeviceInformation.pb-c.h @@ -0,0 +1,73 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: DeviceInformation.proto */ + +#ifndef PROTOBUF_C_DeviceInformation_2eproto__INCLUDED +#define PROTOBUF_C_DeviceInformation_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 _DeviceInformation DeviceInformation; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _DeviceInformation +{ + ProtobufCMessage base; + char *name; + char *version; + char *builddate; +}; +#define DEVICE_INFORMATION__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&device_information__descriptor) \ + , NULL, NULL, NULL } + + +/* DeviceInformation methods */ +void device_information__init + (DeviceInformation *message); +size_t device_information__get_packed_size + (const DeviceInformation *message); +size_t device_information__pack + (const DeviceInformation *message, + uint8_t *out); +size_t device_information__pack_to_buffer + (const DeviceInformation *message, + ProtobufCBuffer *buffer); +DeviceInformation * + device_information__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void device_information__free_unpacked + (DeviceInformation *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*DeviceInformation_Closure) + (const DeviceInformation *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor device_information__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_DeviceInformation_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Connection/DisconnectRequest.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Connection/DisconnectRequest.pb-c.c new file mode 100644 index 000000000..39e442cbe --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Connection/DisconnectRequest.pb-c.c @@ -0,0 +1,72 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: DisconnectRequest.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "DisconnectRequest.pb-c.h" +void disconnect_request__init + (DisconnectRequest *message) +{ + static const DisconnectRequest init_value = DISCONNECT_REQUEST__INIT; + *message = init_value; +} +size_t disconnect_request__get_packed_size + (const DisconnectRequest *message) +{ + assert(message->base.descriptor == &disconnect_request__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t disconnect_request__pack + (const DisconnectRequest *message, + uint8_t *out) +{ + assert(message->base.descriptor == &disconnect_request__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t disconnect_request__pack_to_buffer + (const DisconnectRequest *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &disconnect_request__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +DisconnectRequest * + disconnect_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (DisconnectRequest *) + protobuf_c_message_unpack (&disconnect_request__descriptor, + allocator, len, data); +} +void disconnect_request__free_unpacked + (DisconnectRequest *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &disconnect_request__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +#define disconnect_request__field_descriptors NULL +#define disconnect_request__field_indices_by_name NULL +#define disconnect_request__number_ranges NULL +const ProtobufCMessageDescriptor disconnect_request__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "DisconnectRequest", + "DisconnectRequest", + "DisconnectRequest", + "", + sizeof(DisconnectRequest), + 0, + disconnect_request__field_descriptors, + disconnect_request__field_indices_by_name, + 0, disconnect_request__number_ranges, + (ProtobufCMessageInit) disconnect_request__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Connection/DisconnectRequest.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Connection/DisconnectRequest.pb-c.h new file mode 100644 index 000000000..1f7fa145b --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Connection/DisconnectRequest.pb-c.h @@ -0,0 +1,70 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: DisconnectRequest.proto */ + +#ifndef PROTOBUF_C_DisconnectRequest_2eproto__INCLUDED +#define PROTOBUF_C_DisconnectRequest_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 _DisconnectRequest DisconnectRequest; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _DisconnectRequest +{ + ProtobufCMessage base; +}; +#define DISCONNECT_REQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&disconnect_request__descriptor) \ + } + + +/* DisconnectRequest methods */ +void disconnect_request__init + (DisconnectRequest *message); +size_t disconnect_request__get_packed_size + (const DisconnectRequest *message); +size_t disconnect_request__pack + (const DisconnectRequest *message, + uint8_t *out); +size_t disconnect_request__pack_to_buffer + (const DisconnectRequest *message, + ProtobufCBuffer *buffer); +DisconnectRequest * + disconnect_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void disconnect_request__free_unpacked + (DisconnectRequest *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*DisconnectRequest_Closure) + (const DisconnectRequest *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor disconnect_request__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_DisconnectRequest_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Connection/DisconnectResponse.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Connection/DisconnectResponse.pb-c.c new file mode 100644 index 000000000..e17f48d2b --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Connection/DisconnectResponse.pb-c.c @@ -0,0 +1,72 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: DisconnectResponse.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "DisconnectResponse.pb-c.h" +void disconnect_response__init + (DisconnectResponse *message) +{ + static const DisconnectResponse init_value = DISCONNECT_RESPONSE__INIT; + *message = init_value; +} +size_t disconnect_response__get_packed_size + (const DisconnectResponse *message) +{ + assert(message->base.descriptor == &disconnect_response__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t disconnect_response__pack + (const DisconnectResponse *message, + uint8_t *out) +{ + assert(message->base.descriptor == &disconnect_response__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t disconnect_response__pack_to_buffer + (const DisconnectResponse *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &disconnect_response__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +DisconnectResponse * + disconnect_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (DisconnectResponse *) + protobuf_c_message_unpack (&disconnect_response__descriptor, + allocator, len, data); +} +void disconnect_response__free_unpacked + (DisconnectResponse *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &disconnect_response__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +#define disconnect_response__field_descriptors NULL +#define disconnect_response__field_indices_by_name NULL +#define disconnect_response__number_ranges NULL +const ProtobufCMessageDescriptor disconnect_response__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "DisconnectResponse", + "DisconnectResponse", + "DisconnectResponse", + "", + sizeof(DisconnectResponse), + 0, + disconnect_response__field_descriptors, + disconnect_response__field_indices_by_name, + 0, disconnect_response__number_ranges, + (ProtobufCMessageInit) disconnect_response__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Connection/DisconnectResponse.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Connection/DisconnectResponse.pb-c.h new file mode 100644 index 000000000..3518f360f --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Connection/DisconnectResponse.pb-c.h @@ -0,0 +1,70 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: DisconnectResponse.proto */ + +#ifndef PROTOBUF_C_DisconnectResponse_2eproto__INCLUDED +#define PROTOBUF_C_DisconnectResponse_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 _DisconnectResponse DisconnectResponse; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _DisconnectResponse +{ + ProtobufCMessage base; +}; +#define DISCONNECT_RESPONSE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&disconnect_response__descriptor) \ + } + + +/* DisconnectResponse methods */ +void disconnect_response__init + (DisconnectResponse *message); +size_t disconnect_response__get_packed_size + (const DisconnectResponse *message); +size_t disconnect_response__pack + (const DisconnectResponse *message, + uint8_t *out); +size_t disconnect_response__pack_to_buffer + (const DisconnectResponse *message, + ProtobufCBuffer *buffer); +DisconnectResponse * + disconnect_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void disconnect_response__free_unpacked + (DisconnectResponse *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*DisconnectResponse_Closure) + (const DisconnectResponse *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor disconnect_response__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_DisconnectResponse_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Connection/KeepAliveRequest.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Connection/KeepAliveRequest.pb-c.c new file mode 100644 index 000000000..70fca2425 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Connection/KeepAliveRequest.pb-c.c @@ -0,0 +1,72 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: KeepAliveRequest.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "KeepAliveRequest.pb-c.h" +void keep_alive_request__init + (KeepAliveRequest *message) +{ + static const KeepAliveRequest init_value = KEEP_ALIVE_REQUEST__INIT; + *message = init_value; +} +size_t keep_alive_request__get_packed_size + (const KeepAliveRequest *message) +{ + assert(message->base.descriptor == &keep_alive_request__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t keep_alive_request__pack + (const KeepAliveRequest *message, + uint8_t *out) +{ + assert(message->base.descriptor == &keep_alive_request__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t keep_alive_request__pack_to_buffer + (const KeepAliveRequest *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &keep_alive_request__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +KeepAliveRequest * + keep_alive_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (KeepAliveRequest *) + protobuf_c_message_unpack (&keep_alive_request__descriptor, + allocator, len, data); +} +void keep_alive_request__free_unpacked + (KeepAliveRequest *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &keep_alive_request__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +#define keep_alive_request__field_descriptors NULL +#define keep_alive_request__field_indices_by_name NULL +#define keep_alive_request__number_ranges NULL +const ProtobufCMessageDescriptor keep_alive_request__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "KeepAliveRequest", + "KeepAliveRequest", + "KeepAliveRequest", + "", + sizeof(KeepAliveRequest), + 0, + keep_alive_request__field_descriptors, + keep_alive_request__field_indices_by_name, + 0, keep_alive_request__number_ranges, + (ProtobufCMessageInit) keep_alive_request__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Connection/KeepAliveRequest.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Connection/KeepAliveRequest.pb-c.h new file mode 100644 index 000000000..379aa6caa --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Connection/KeepAliveRequest.pb-c.h @@ -0,0 +1,70 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: KeepAliveRequest.proto */ + +#ifndef PROTOBUF_C_KeepAliveRequest_2eproto__INCLUDED +#define PROTOBUF_C_KeepAliveRequest_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 _KeepAliveRequest KeepAliveRequest; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _KeepAliveRequest +{ + ProtobufCMessage base; +}; +#define KEEP_ALIVE_REQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&keep_alive_request__descriptor) \ + } + + +/* KeepAliveRequest methods */ +void keep_alive_request__init + (KeepAliveRequest *message); +size_t keep_alive_request__get_packed_size + (const KeepAliveRequest *message); +size_t keep_alive_request__pack + (const KeepAliveRequest *message, + uint8_t *out); +size_t keep_alive_request__pack_to_buffer + (const KeepAliveRequest *message, + ProtobufCBuffer *buffer); +KeepAliveRequest * + keep_alive_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void keep_alive_request__free_unpacked + (KeepAliveRequest *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*KeepAliveRequest_Closure) + (const KeepAliveRequest *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor keep_alive_request__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_KeepAliveRequest_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Connection/KeepAliveResponse.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Connection/KeepAliveResponse.pb-c.c new file mode 100644 index 000000000..9bae1f119 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Connection/KeepAliveResponse.pb-c.c @@ -0,0 +1,72 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: KeepAliveResponse.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "KeepAliveResponse.pb-c.h" +void keep_alive_response__init + (KeepAliveResponse *message) +{ + static const KeepAliveResponse init_value = KEEP_ALIVE_RESPONSE__INIT; + *message = init_value; +} +size_t keep_alive_response__get_packed_size + (const KeepAliveResponse *message) +{ + assert(message->base.descriptor == &keep_alive_response__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t keep_alive_response__pack + (const KeepAliveResponse *message, + uint8_t *out) +{ + assert(message->base.descriptor == &keep_alive_response__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t keep_alive_response__pack_to_buffer + (const KeepAliveResponse *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &keep_alive_response__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +KeepAliveResponse * + keep_alive_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (KeepAliveResponse *) + protobuf_c_message_unpack (&keep_alive_response__descriptor, + allocator, len, data); +} +void keep_alive_response__free_unpacked + (KeepAliveResponse *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &keep_alive_response__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +#define keep_alive_response__field_descriptors NULL +#define keep_alive_response__field_indices_by_name NULL +#define keep_alive_response__number_ranges NULL +const ProtobufCMessageDescriptor keep_alive_response__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "KeepAliveResponse", + "KeepAliveResponse", + "KeepAliveResponse", + "", + sizeof(KeepAliveResponse), + 0, + keep_alive_response__field_descriptors, + keep_alive_response__field_indices_by_name, + 0, keep_alive_response__number_ranges, + (ProtobufCMessageInit) keep_alive_response__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Connection/KeepAliveResponse.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Connection/KeepAliveResponse.pb-c.h new file mode 100644 index 000000000..a29f79c99 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Connection/KeepAliveResponse.pb-c.h @@ -0,0 +1,70 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: KeepAliveResponse.proto */ + +#ifndef PROTOBUF_C_KeepAliveResponse_2eproto__INCLUDED +#define PROTOBUF_C_KeepAliveResponse_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 _KeepAliveResponse KeepAliveResponse; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _KeepAliveResponse +{ + ProtobufCMessage base; +}; +#define KEEP_ALIVE_RESPONSE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&keep_alive_response__descriptor) \ + } + + +/* KeepAliveResponse methods */ +void keep_alive_response__init + (KeepAliveResponse *message); +size_t keep_alive_response__get_packed_size + (const KeepAliveResponse *message); +size_t keep_alive_response__pack + (const KeepAliveResponse *message, + uint8_t *out); +size_t keep_alive_response__pack_to_buffer + (const KeepAliveResponse *message, + ProtobufCBuffer *buffer); +KeepAliveResponse * + keep_alive_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void keep_alive_response__free_unpacked + (KeepAliveResponse *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*KeepAliveResponse_Closure) + (const KeepAliveResponse *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor keep_alive_response__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_KeepAliveResponse_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Debugging/StartDebugLogRequest.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Debugging/StartDebugLogRequest.pb-c.c new file mode 100644 index 000000000..4c9f854c8 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Debugging/StartDebugLogRequest.pb-c.c @@ -0,0 +1,72 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StartDebugLogRequest.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StartDebugLogRequest.pb-c.h" +void start_debug_log_request__init + (StartDebugLogRequest *message) +{ + static const StartDebugLogRequest init_value = START_DEBUG_LOG_REQUEST__INIT; + *message = init_value; +} +size_t start_debug_log_request__get_packed_size + (const StartDebugLogRequest *message) +{ + assert(message->base.descriptor == &start_debug_log_request__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t start_debug_log_request__pack + (const StartDebugLogRequest *message, + uint8_t *out) +{ + assert(message->base.descriptor == &start_debug_log_request__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t start_debug_log_request__pack_to_buffer + (const StartDebugLogRequest *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &start_debug_log_request__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StartDebugLogRequest * + start_debug_log_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StartDebugLogRequest *) + protobuf_c_message_unpack (&start_debug_log_request__descriptor, + allocator, len, data); +} +void start_debug_log_request__free_unpacked + (StartDebugLogRequest *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &start_debug_log_request__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +#define start_debug_log_request__field_descriptors NULL +#define start_debug_log_request__field_indices_by_name NULL +#define start_debug_log_request__number_ranges NULL +const ProtobufCMessageDescriptor start_debug_log_request__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StartDebugLogRequest", + "StartDebugLogRequest", + "StartDebugLogRequest", + "", + sizeof(StartDebugLogRequest), + 0, + start_debug_log_request__field_descriptors, + start_debug_log_request__field_indices_by_name, + 0, start_debug_log_request__number_ranges, + (ProtobufCMessageInit) start_debug_log_request__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Debugging/StartDebugLogRequest.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Debugging/StartDebugLogRequest.pb-c.h new file mode 100644 index 000000000..13de9c765 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Debugging/StartDebugLogRequest.pb-c.h @@ -0,0 +1,70 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StartDebugLogRequest.proto */ + +#ifndef PROTOBUF_C_StartDebugLogRequest_2eproto__INCLUDED +#define PROTOBUF_C_StartDebugLogRequest_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 _StartDebugLogRequest StartDebugLogRequest; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StartDebugLogRequest +{ + ProtobufCMessage base; +}; +#define START_DEBUG_LOG_REQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&start_debug_log_request__descriptor) \ + } + + +/* StartDebugLogRequest methods */ +void start_debug_log_request__init + (StartDebugLogRequest *message); +size_t start_debug_log_request__get_packed_size + (const StartDebugLogRequest *message); +size_t start_debug_log_request__pack + (const StartDebugLogRequest *message, + uint8_t *out); +size_t start_debug_log_request__pack_to_buffer + (const StartDebugLogRequest *message, + ProtobufCBuffer *buffer); +StartDebugLogRequest * + start_debug_log_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void start_debug_log_request__free_unpacked + (StartDebugLogRequest *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StartDebugLogRequest_Closure) + (const StartDebugLogRequest *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor start_debug_log_request__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StartDebugLogRequest_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Debugging/StartDebugLogResponse.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Debugging/StartDebugLogResponse.pb-c.c new file mode 100644 index 000000000..c9a1e6405 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Debugging/StartDebugLogResponse.pb-c.c @@ -0,0 +1,157 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StartDebugLogResponse.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StartDebugLogResponse.pb-c.h" +void start_debug_log_response__init + (StartDebugLogResponse *message) +{ + static const StartDebugLogResponse init_value = START_DEBUG_LOG_RESPONSE__INIT; + *message = init_value; +} +size_t start_debug_log_response__get_packed_size + (const StartDebugLogResponse *message) +{ + assert(message->base.descriptor == &start_debug_log_response__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t start_debug_log_response__pack + (const StartDebugLogResponse *message, + uint8_t *out) +{ + assert(message->base.descriptor == &start_debug_log_response__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t start_debug_log_response__pack_to_buffer + (const StartDebugLogResponse *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &start_debug_log_response__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StartDebugLogResponse * + start_debug_log_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StartDebugLogResponse *) + protobuf_c_message_unpack (&start_debug_log_response__descriptor, + allocator, len, data); +} +void start_debug_log_response__free_unpacked + (StartDebugLogResponse *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &start_debug_log_response__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor start_debug_log_response__field_descriptors[6] = +{ + { + "Category", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_ENUM, + offsetof(StartDebugLogResponse, has_category), + offsetof(StartDebugLogResponse, category), + &debug_log_category__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "FileName", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(StartDebugLogResponse, filename), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "LineNumber", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StartDebugLogResponse, has_linenumber), + offsetof(StartDebugLogResponse, linenumber), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Filter", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StartDebugLogResponse, has_filter), + offsetof(StartDebugLogResponse, filter), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Message", + 5, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(StartDebugLogResponse, message), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ModuleId", + 6, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StartDebugLogResponse, has_moduleid), + offsetof(StartDebugLogResponse, moduleid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned start_debug_log_response__field_indices_by_name[] = { + 0, /* field[0] = Category */ + 1, /* field[1] = FileName */ + 3, /* field[3] = Filter */ + 2, /* field[2] = LineNumber */ + 4, /* field[4] = Message */ + 5, /* field[5] = ModuleId */ +}; +static const ProtobufCIntRange start_debug_log_response__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 6 } +}; +const ProtobufCMessageDescriptor start_debug_log_response__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StartDebugLogResponse", + "StartDebugLogResponse", + "StartDebugLogResponse", + "", + sizeof(StartDebugLogResponse), + 6, + start_debug_log_response__field_descriptors, + start_debug_log_response__field_indices_by_name, + 1, start_debug_log_response__number_ranges, + (ProtobufCMessageInit) start_debug_log_response__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Debugging/StartDebugLogResponse.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Debugging/StartDebugLogResponse.pb-c.h new file mode 100644 index 000000000..4301223de --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Debugging/StartDebugLogResponse.pb-c.h @@ -0,0 +1,81 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StartDebugLogResponse.proto */ + +#ifndef PROTOBUF_C_StartDebugLogResponse_2eproto__INCLUDED +#define PROTOBUF_C_StartDebugLogResponse_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 "DebugLogCategory.pb-c.h" + +typedef struct _StartDebugLogResponse StartDebugLogResponse; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StartDebugLogResponse +{ + ProtobufCMessage base; + protobuf_c_boolean has_category; + DebugLogCategory category; + char *filename; + protobuf_c_boolean has_linenumber; + uint32_t linenumber; + protobuf_c_boolean has_filter; + uint32_t filter; + char *message; + protobuf_c_boolean has_moduleid; + uint32_t moduleid; +}; +#define START_DEBUG_LOG_RESPONSE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&start_debug_log_response__descriptor) \ + , 0, DEBUG_LOG_CATEGORY__Info, NULL, 0, 0, 0, 0, NULL, 0, 0 } + + +/* StartDebugLogResponse methods */ +void start_debug_log_response__init + (StartDebugLogResponse *message); +size_t start_debug_log_response__get_packed_size + (const StartDebugLogResponse *message); +size_t start_debug_log_response__pack + (const StartDebugLogResponse *message, + uint8_t *out); +size_t start_debug_log_response__pack_to_buffer + (const StartDebugLogResponse *message, + ProtobufCBuffer *buffer); +StartDebugLogResponse * + start_debug_log_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void start_debug_log_response__free_unpacked + (StartDebugLogResponse *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StartDebugLogResponse_Closure) + (const StartDebugLogResponse *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor start_debug_log_response__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StartDebugLogResponse_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Debugging/StopDebugLogRequest.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Debugging/StopDebugLogRequest.pb-c.c new file mode 100644 index 000000000..74194f1d3 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Debugging/StopDebugLogRequest.pb-c.c @@ -0,0 +1,72 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StopDebugLogRequest.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StopDebugLogRequest.pb-c.h" +void stop_debug_log_request__init + (StopDebugLogRequest *message) +{ + static const StopDebugLogRequest init_value = STOP_DEBUG_LOG_REQUEST__INIT; + *message = init_value; +} +size_t stop_debug_log_request__get_packed_size + (const StopDebugLogRequest *message) +{ + assert(message->base.descriptor == &stop_debug_log_request__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stop_debug_log_request__pack + (const StopDebugLogRequest *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stop_debug_log_request__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stop_debug_log_request__pack_to_buffer + (const StopDebugLogRequest *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stop_debug_log_request__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StopDebugLogRequest * + stop_debug_log_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StopDebugLogRequest *) + protobuf_c_message_unpack (&stop_debug_log_request__descriptor, + allocator, len, data); +} +void stop_debug_log_request__free_unpacked + (StopDebugLogRequest *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stop_debug_log_request__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +#define stop_debug_log_request__field_descriptors NULL +#define stop_debug_log_request__field_indices_by_name NULL +#define stop_debug_log_request__number_ranges NULL +const ProtobufCMessageDescriptor stop_debug_log_request__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StopDebugLogRequest", + "StopDebugLogRequest", + "StopDebugLogRequest", + "", + sizeof(StopDebugLogRequest), + 0, + stop_debug_log_request__field_descriptors, + stop_debug_log_request__field_indices_by_name, + 0, stop_debug_log_request__number_ranges, + (ProtobufCMessageInit) stop_debug_log_request__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Debugging/StopDebugLogRequest.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Debugging/StopDebugLogRequest.pb-c.h new file mode 100644 index 000000000..ffd8ea9f9 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Debugging/StopDebugLogRequest.pb-c.h @@ -0,0 +1,70 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StopDebugLogRequest.proto */ + +#ifndef PROTOBUF_C_StopDebugLogRequest_2eproto__INCLUDED +#define PROTOBUF_C_StopDebugLogRequest_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 _StopDebugLogRequest StopDebugLogRequest; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StopDebugLogRequest +{ + ProtobufCMessage base; +}; +#define STOP_DEBUG_LOG_REQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stop_debug_log_request__descriptor) \ + } + + +/* StopDebugLogRequest methods */ +void stop_debug_log_request__init + (StopDebugLogRequest *message); +size_t stop_debug_log_request__get_packed_size + (const StopDebugLogRequest *message); +size_t stop_debug_log_request__pack + (const StopDebugLogRequest *message, + uint8_t *out); +size_t stop_debug_log_request__pack_to_buffer + (const StopDebugLogRequest *message, + ProtobufCBuffer *buffer); +StopDebugLogRequest * + stop_debug_log_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stop_debug_log_request__free_unpacked + (StopDebugLogRequest *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StopDebugLogRequest_Closure) + (const StopDebugLogRequest *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stop_debug_log_request__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StopDebugLogRequest_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Debugging/StopDebugLogResponse.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Debugging/StopDebugLogResponse.pb-c.c new file mode 100644 index 000000000..7a885594e --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Debugging/StopDebugLogResponse.pb-c.c @@ -0,0 +1,72 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StopDebugLogResponse.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StopDebugLogResponse.pb-c.h" +void stop_debug_log_response__init + (StopDebugLogResponse *message) +{ + static const StopDebugLogResponse init_value = STOP_DEBUG_LOG_RESPONSE__INIT; + *message = init_value; +} +size_t stop_debug_log_response__get_packed_size + (const StopDebugLogResponse *message) +{ + assert(message->base.descriptor == &stop_debug_log_response__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stop_debug_log_response__pack + (const StopDebugLogResponse *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stop_debug_log_response__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stop_debug_log_response__pack_to_buffer + (const StopDebugLogResponse *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stop_debug_log_response__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StopDebugLogResponse * + stop_debug_log_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StopDebugLogResponse *) + protobuf_c_message_unpack (&stop_debug_log_response__descriptor, + allocator, len, data); +} +void stop_debug_log_response__free_unpacked + (StopDebugLogResponse *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stop_debug_log_response__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +#define stop_debug_log_response__field_descriptors NULL +#define stop_debug_log_response__field_indices_by_name NULL +#define stop_debug_log_response__number_ranges NULL +const ProtobufCMessageDescriptor stop_debug_log_response__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StopDebugLogResponse", + "StopDebugLogResponse", + "StopDebugLogResponse", + "", + sizeof(StopDebugLogResponse), + 0, + stop_debug_log_response__field_descriptors, + stop_debug_log_response__field_indices_by_name, + 0, stop_debug_log_response__number_ranges, + (ProtobufCMessageInit) stop_debug_log_response__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Debugging/StopDebugLogResponse.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Debugging/StopDebugLogResponse.pb-c.h new file mode 100644 index 000000000..2a4c21b85 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Debugging/StopDebugLogResponse.pb-c.h @@ -0,0 +1,70 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StopDebugLogResponse.proto */ + +#ifndef PROTOBUF_C_StopDebugLogResponse_2eproto__INCLUDED +#define PROTOBUF_C_StopDebugLogResponse_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 _StopDebugLogResponse StopDebugLogResponse; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StopDebugLogResponse +{ + ProtobufCMessage base; +}; +#define STOP_DEBUG_LOG_RESPONSE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stop_debug_log_response__descriptor) \ + } + + +/* StopDebugLogResponse methods */ +void stop_debug_log_response__init + (StopDebugLogResponse *message); +size_t stop_debug_log_response__get_packed_size + (const StopDebugLogResponse *message); +size_t stop_debug_log_response__pack + (const StopDebugLogResponse *message, + uint8_t *out); +size_t stop_debug_log_response__pack_to_buffer + (const StopDebugLogResponse *message, + ProtobufCBuffer *buffer); +StopDebugLogResponse * + stop_debug_log_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stop_debug_log_response__free_unpacked + (StopDebugLogResponse *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StopDebugLogResponse_Closure) + (const StopDebugLogResponse *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stop_debug_log_response__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StopDebugLogResponse_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/DataFileFrame.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/DataFileFrame.pb-c.c index d4f4ff5cf..afbafe2c0 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/DataFileFrame.pb-c.c +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/DataFileFrame.pb-c.c @@ -67,13 +67,13 @@ static const ProtobufCFieldDescriptor data_file_frame__field_descriptors[3] = 0,NULL,NULL /* reserved1,reserved2, etc */ }, { - "PushDiagnosticsResponse", + "StartDiagnosticsResponse", 2, PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - offsetof(DataFileFrame, pushdiagnosticsresponse), - &push_diagnostics_response__descriptor, + offsetof(DataFileFrame, startdiagnosticsresponse), + &start_diagnostics_response__descriptor, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -93,7 +93,7 @@ static const ProtobufCFieldDescriptor data_file_frame__field_descriptors[3] = }; static const unsigned data_file_frame__field_indices_by_name[] = { 0, /* field[0] = Milliseconds */ - 1, /* field[1] = PushDiagnosticsResponse */ + 1, /* field[1] = StartDiagnosticsResponse */ 2, /* field[2] = VideoFrames */ }; static const ProtobufCIntRange data_file_frame__number_ranges[1 + 1] = diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/DataFileFrame.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/DataFileFrame.pb-c.h index 9e9c9af48..2392027da 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/DataFileFrame.pb-c.h +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/DataFileFrame.pb-c.h @@ -14,7 +14,7 @@ PROTOBUF_C__BEGIN_DECLS # 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 "PushDiagnosticsResponse.pb-c.h" +#include "StartDiagnosticsResponse.pb-c.h" typedef struct _DataFileFrame DataFileFrame; @@ -29,7 +29,7 @@ struct _DataFileFrame ProtobufCMessage base; protobuf_c_boolean has_milliseconds; int32_t milliseconds; - PushDiagnosticsResponse *pushdiagnosticsresponse; + StartDiagnosticsResponse *startdiagnosticsresponse; size_t n_videoframes; ProtobufCBinaryData *videoframes; }; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/DiagnosticsMonitors.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/DiagnosticsMonitors.pb-c.h index 2de77dc8f..55ca10ce0 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/DiagnosticsMonitors.pb-c.h +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/DiagnosticsMonitors.pb-c.h @@ -27,76 +27,184 @@ typedef struct _DiagnosticsMonitors DiagnosticsMonitors; struct _DiagnosticsMonitors { ProtobufCMessage base; + /* + *Dancer 1 (Min = 0, Max = 255, PPF = 10) + */ size_t n_dancer1angle; double *dancer1angle; + /* + *Dancer 2 (Min = 0, Max = 1200, PPF = 1) + */ size_t n_dancer2angle; double *dancer2angle; + /* + *Dancer 3 (Min = 0, Max = 1200, PPF = 1) + */ size_t n_dancer3angle; double *dancer3angle; + /* + *Feeder Motor (Min = 0, Max = 100, PPF = 1) + */ size_t n_feedermotorfrequency; double *feedermotorfrequency; + /* + *Dryer Motor (Min = 0, Max = 100, PPF = 1) + */ size_t n_dryermotor; double *dryermotor; + /* + *Poller Motor (Min = 0, Max = 100, PPF = 1) + */ size_t n_pollermotor; double *pollermotor; + /* + *Winder Motor (Min = 0, Max = 100, PPF = 1) + */ size_t n_windermotor; double *windermotor; + /* + *Screw Motor (Min = 0, Max = 100, PPF = 1) + */ size_t n_screwmotor; double *screwmotor; + /* + *Thread Speed (Min = 0, Max = 100, PPF = 1) + */ size_t n_threadspeed; double *threadspeed; + /* + *Mixer (Min = 0, Max = 100, PPF = 1) + */ size_t n_mixertemperature; double *mixertemperature; + /* + *Head Zone 1 (Min = 0, Max = 100, PPF = 1) + */ size_t n_headzone1temperature; double *headzone1temperature; + /* + *Head Zone 2 (Min = 0, Max = 100, PPF = 1) + */ size_t n_headzone2temperature; double *headzone2temperature; + /* + *Head Zone 3 (Min = 0, Max = 100, PPF = 1) + */ size_t n_headzone3temperature; double *headzone3temperature; + /* + *Head Air Flow (Min = 0, Max = 100, PPF = 1) + */ size_t n_headairflow; double *headairflow; + /* + *Feeder Tension (Min = 0, Max = 100, PPF = 1) + */ size_t n_feedertension; double *feedertension; + /* + *Puller Tension (Min = 0, Max = 100, PPF = 1) + */ size_t n_pullertension; double *pullertension; + /* + *Dryer Zone 1 (Min = 0, Max = 100, PPF = 1) + */ size_t n_dryerzone1temperature; double *dryerzone1temperature; + /* + *Dryer Zone 2 (Min = 0, Max = 100, PPF = 1) + */ size_t n_dryerzone2temperature; double *dryerzone2temperature; + /* + *Dryer Zone 3 (Min = 0, Max = 100, PPF = 1) + */ size_t n_dryerzone3temperature; double *dryerzone3temperature; + /* + *Dryer Air Flow (Min = 0, Max = 100, PPF = 1) + */ size_t n_dryerairflow; double *dryerairflow; + /* + *Winder Tension (Min = 0, Max = 100, PPF = 1) + */ size_t n_windertension; double *windertension; + /* + *Dispensers Motors (Min = 0, Max = 1080, PPF = 10) Channel Count = 8 + */ size_t n_dispensersmotorsfrequency; DoubleArray **dispensersmotorsfrequency; + /* + *Dispensers Angular Encoders (Min = 0, Max = 100, PPF = 1) Channel Count = 8 + */ size_t n_dispensersangularencoders; DoubleArray **dispensersangularencoders; + /* + *Dispensers Linear Positions (Min = 0, Max = 100, PPF = 1) Channel Count = 8 + */ size_t n_dispenserslinearpositions; DoubleArray **dispenserslinearpositions; + /* + *Dispensers Pressure (Min = 0, Max = 100, PPF = 1) Channel Count = 8 + */ size_t n_dispenserspressure; DoubleArray **dispenserspressure; + /* + *Mid Tank Pressure (Min = 0, Max = 100, PPF = 1) + */ size_t n_midtankpressure; double *midtankpressure; + /* + *Filter Delta Pressure (Min = 0, Max = 100, PPF = 1) + */ size_t n_filterdeltapressure; double *filterdeltapressure; + /* + *Chiller Temperature (Min = 0, Max = 100, PPF = 1) + */ size_t n_chillertemperature; double *chillertemperature; + /* + *Dispenser 1 Motor Frequency (Min = 0, Max = 1080, PPF = 10) + */ size_t n_dispenser1motorfrequency; double *dispenser1motorfrequency; + /* + *Dispenser 2 Motor Frequency (Min = 0, Max = 1080, PPF = 10) + */ size_t n_dispenser2motorfrequency; double *dispenser2motorfrequency; + /* + *Dispenser 3 Motor Frequency (Min = 0, Max = 1080, PPF = 10) + */ size_t n_dispenser3motorfrequency; double *dispenser3motorfrequency; + /* + *Dispenser 4 Motor Frequency (Min = 0, Max = 1080, PPF = 10) + */ size_t n_dispenser4motorfrequency; double *dispenser4motorfrequency; + /* + *Dispenser 5 Motor Frequency (Min = 0, Max = 1080, PPF = 10) + */ size_t n_dispenser5motorfrequency; double *dispenser5motorfrequency; + /* + *Dispenser 6 Motor Frequency (Min = 0, Max = 1080, PPF = 10) + */ size_t n_dispenser6motorfrequency; double *dispenser6motorfrequency; + /* + *Dispenser 7 Motor Frequency (Min = 0, Max = 1080, PPF = 10) + */ size_t n_dispenser7motorfrequency; double *dispenser7motorfrequency; + /* + *Dispenser 8 Motor Frequency (Min = 0, Max = 1080, PPF = 10) + */ size_t n_dispenser8motorfrequency; double *dispenser8motorfrequency; }; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/EventType.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/EventType.pb-c.c index bd3bc7fd6..92786b4ad 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/EventType.pb-c.c +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/EventType.pb-c.c @@ -7,7 +7,7 @@ #endif #include "EventType.pb-c.h" -static const ProtobufCEnumValue event_type__enum_values_by_number[36] = +static const ProtobufCEnumValue event_type__enum_values_by_number[38] = { { "ThreadBreak", "EVENT_TYPE__ThreadBreak", 0 }, { "ThreadTensionControlFailure", "EVENT_TYPE__ThreadTensionControlFailure", 1 }, @@ -45,11 +45,13 @@ static const ProtobufCEnumValue event_type__enum_values_by_number[36] = { "ApplicationInformation", "EVENT_TYPE__ApplicationInformation", 33 }, { "ApplicationStarted", "EVENT_TYPE__ApplicationStarted", 34 }, { "ApplicationTerminated", "EVENT_TYPE__ApplicationTerminated", 35 }, + { "RecordingStarted", "EVENT_TYPE__RecordingStarted", 36 }, + { "RecordingStopped", "EVENT_TYPE__RecordingStopped", 37 }, }; static const ProtobufCIntRange event_type__value_ranges[] = { -{0, 0},{0, 36} +{0, 0},{0, 38} }; -static const ProtobufCEnumValueIndex event_type__enum_values_by_name[36] = +static const ProtobufCEnumValueIndex event_type__enum_values_by_name[38] = { { "AirFilterClogged", 13 }, { "AirFilterNotInstalled", 14 }, @@ -74,6 +76,8 @@ static const ProtobufCEnumValueIndex event_type__enum_values_by_name[36] = { "MidTankEmpty", 21 }, { "MidTankLowLevel", 22 }, { "MidTankNotInPlace", 23 }, + { "RecordingStarted", 36 }, + { "RecordingStopped", 37 }, { "RequestFailed", 31 }, { "RequestSent", 29 }, { "ResponseReceived", 30 }, @@ -95,9 +99,9 @@ const ProtobufCEnumDescriptor event_type__descriptor = "EventType", "EventType", "", - 36, + 38, event_type__enum_values_by_number, - 36, + 38, event_type__enum_values_by_name, 1, event_type__value_ranges, diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/EventType.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/EventType.pb-c.h index c6bd394cf..05cd19d3a 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/EventType.pb-c.h +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/EventType.pb-c.h @@ -20,42 +20,158 @@ PROTOBUF_C__BEGIN_DECLS /* --- enums --- */ typedef enum _EventType { + /* + *Dancer overshot / Thread break sensor (Group = Thread Feeding System, Category = Error, Actions = Abort Running Job, Prevent Job Execution, Soft Visual Notification) + */ EVENT_TYPE__ThreadBreak = 0, + /* + *Dancer not stable or got down (Group = Thread Feeding System, Category = Error, Actions = Abort Running Job, Soft Visual Notification, Prevent Job Execution) + */ EVENT_TYPE__ThreadTensionControlFailure = 1, + /* + *Source thread counter (counter shall be reset upon loading a new cone) (Group = Thread Feeding System, Category = Error, Actions = Abort Running Job, Prevent Job Execution, Soft Visual Notification) + */ EVENT_TYPE__FeederConeInsufficiant = 2, + /* + *Winder Controller (Group = Thread Feeding System, Category = Error, Actions = Abort Running Job, Prevent Job Execution, Soft Visual Notification) + */ EVENT_TYPE__WinderGeneralError = 3, + /* + *SW_SPOOL_EXISTS='0' or Winder Controller (Group = Thread Feeding System, Category = Error, Actions = Abort Running Job, Prevent Job Execution, Soft Visual Notification) + */ EVENT_TYPE__WinderConeNotExists = 4, + /* + *Motor Stall (Group = Thread Feeding System, Category = Error, Actions = Abort Running Job, Soft Visual Notification, Prevent Job Execution) + */ EVENT_TYPE__ThreadFeedingGeneralError = 5, + /* + *Dyeing Head Thermometers (Group = DH Dryer, Category = Error, Actions = Abort Running Job, Soft Visual Notification, Prevent Job Execution) + */ EVENT_TYPE__DyeingHeadOverTemperature = 6, + /* + *Current sense in all heaters is 0 (Group = DH Dryer, Category = Error, Actions = Abort Running Job, Soft Visual Notification, Prevent Job Execution) + */ EVENT_TYPE__DHThermalCutoff = 7, + /* + *Dryer Thermometers (Group = DH Dryer, Category = Error, Actions = Prevent Job Execution, Abort Running Job, Soft Visual Notification) + */ EVENT_TYPE__DryerOverTemperature = 8, + /* + *Current sense in all heaters is 0 (Group = DH Dryer, Category = Error, Actions = Abort Running Job, Soft Visual Notification, Prevent Job Execution) + */ EVENT_TYPE__DryerThermalCutoff = 9, + /* + *Dyeing head Heaters failure (Under /Over current) (Group = DH Dryer, Category = Error, Actions = Soft Visual Notification, Prevent Job Execution, Abort Running Job) + */ EVENT_TYPE__DyeingHeadHeatersCurrentOutOfRange = 10, + /* + *Dryer Heaters failure (Under /Over current) (Group = DH Dryer, Category = Error, Actions = Abort Running Job, Soft Visual Notification, Prevent Job Execution) + */ EVENT_TYPE__DryerHeatersCurrentOutOfRange = 11, + /* + *Covers Tampers (Group = DH Dryer, Category = Error, Actions = Prevent Job Execution, Soft Visual Notification) + */ EVENT_TYPE__DryerDHeadCoverOpen = 12, + /* + *Pressure sensor Purex or Air flow sensor (Flap) (Group = Waste Handling System, Category = Error, Actions = Abort Running Job, Prevent Job Execution, Soft Visual Notification) + */ EVENT_TYPE__AirFilterClogged = 13, + /* + *Micro-switch (Group = Waste Handling System, Category = Error, Actions = Abort Running Job, Prevent Job Execution, Soft Visual Notification) + */ EVENT_TYPE__AirFilterNotInstalled = 14, + /* + *blower techo. Feedback, air flap (Group = Waste Handling System, Category = Error, Actions = Prevent Job Execution, Soft Visual Notification, Abort Running Job) + */ EVENT_TYPE__WHSFailure = 15, + /* + *Check container float sensor (Group = Waste Handling System, Category = Warning, Actions = Soft Visual Notification) + */ EVENT_TYPE__WasteContainerIsAlmostFull = 16, + /* + *Check container float sensor (Group = Waste Handling System, Category = Error, Actions = Soft Visual Notification) + */ EVENT_TYPE__WasteContainerIsFull = 17, + /* + *Dispenser position sensor/s (Group = Ink Delivery System, Category = Error, Actions = Prevent Job Execution, Abort Running Job, Soft Visual Notification) + */ EVENT_TYPE__DispenserEmpty = 18, + /* + *Check if job can be executor refill needed (Group = Ink Delivery System, Category = Warning, Actions = Soft Visual Notification) + */ EVENT_TYPE__DispenserLowLevel = 19, + /* + *Cartridge float displacement (Group = Ink Delivery System, Category = Error, Actions = Prevent Job Execution, Soft Visual Notification) + */ EVENT_TYPE__DispenserRefillFailure = 20, + /* + *Mid-Tank (Group = Ink Delivery System, Category = Warning, Actions = Soft Visual Notification) + */ EVENT_TYPE__MidTankEmpty = 21, + /* + *Cartridge float sensor (Group = Ink Delivery System, Category = Warning, Actions = Soft Visual Notification) + */ EVENT_TYPE__MidTankLowLevel = 22, + /* + *Cartridge float sensor or Additional micro-switch (Group = Ink Delivery System, Category = Warning, Actions = Soft Visual Notification) + */ EVENT_TYPE__MidTankNotInPlace = 23, + /* + *System BIT Failure (Group = General Hardware, Category = Error, Actions = Soft Visual Notification) + */ EVENT_TYPE__SystemBITFail = 24, + /* + *Internal Thermostat (Group = General Hardware, Category = Error, Actions = Prevent Job Execution, Soft Visual Notification, Abort Running Job, Stop Heaters) + */ EVENT_TYPE__GeneralInternalOverTemperature = 25, + /* + *Covers Tampers (Group = General Hardware, Category = Warning, Actions = Soft Visual Notification) + */ EVENT_TYPE__MachineCoverOpen = 26, + /* + *EPB (Group = General Hardware, Category = Critical, Actions = Overall Power Down, Soft Visual Notification) + */ EVENT_TYPE__EmergencyPushButtonPressed = 27, + /* + *System General Error (Group = General Hardware, Category = Warning, Actions = Soft Visual Notification) + */ EVENT_TYPE__SystemGeneralError = 28, + /* + *Occurs a request has been sent to the machine or external bridge service (Group = Transport, Category = Info, Actions = ) + */ EVENT_TYPE__RequestSent = 29, + /* + *Occures when a response has been received (Group = Transport, Category = Info, Actions = ) + */ EVENT_TYPE__ResponseReceived = 30, + /* + *Occures when a request to the machine has failed (Group = Transport, Category = Error, Actions = ) + */ EVENT_TYPE__RequestFailed = 31, + /* + *Occures when the application has encountered some error (Group = Application, Category = Error, Actions = ) + */ EVENT_TYPE__ApplicationException = 32, + /* + *General application event logs (Group = Application, Category = Info, Actions = ) + */ EVENT_TYPE__ApplicationInformation = 33, + /* + *Notifies about application succesfully started (Group = Application, Category = Info, Actions = ) + */ EVENT_TYPE__ApplicationStarted = 34, - EVENT_TYPE__ApplicationTerminated = 35 + /* + *Notifies about application termination (Group = Application, Category = Info, Actions = ) + */ + EVENT_TYPE__ApplicationTerminated = 35, + /* + *Occures when a diagnostics recording has been started (Group = Application, Category = Info, Actions = ) + */ + EVENT_TYPE__RecordingStarted = 36, + /* + *Occures when a diagnostics recording has been stopped (Group = Application, Category = Info, Actions = ) + */ + EVENT_TYPE__RecordingStopped = 37 PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(EVENT_TYPE) } EventType; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/ResolveEventRequest.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/ResolveEventRequest.pb-c.c new file mode 100644 index 000000000..34d06d55d --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/ResolveEventRequest.pb-c.c @@ -0,0 +1,92 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: ResolveEventRequest.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "ResolveEventRequest.pb-c.h" +void resolve_event_request__init + (ResolveEventRequest *message) +{ + static const ResolveEventRequest init_value = RESOLVE_EVENT_REQUEST__INIT; + *message = init_value; +} +size_t resolve_event_request__get_packed_size + (const ResolveEventRequest *message) +{ + assert(message->base.descriptor == &resolve_event_request__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t resolve_event_request__pack + (const ResolveEventRequest *message, + uint8_t *out) +{ + assert(message->base.descriptor == &resolve_event_request__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t resolve_event_request__pack_to_buffer + (const ResolveEventRequest *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &resolve_event_request__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +ResolveEventRequest * + resolve_event_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (ResolveEventRequest *) + protobuf_c_message_unpack (&resolve_event_request__descriptor, + allocator, len, data); +} +void resolve_event_request__free_unpacked + (ResolveEventRequest *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &resolve_event_request__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor resolve_event_request__field_descriptors[1] = +{ + { + "Type", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_ENUM, + offsetof(ResolveEventRequest, has_type), + offsetof(ResolveEventRequest, type), + &event_type__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned resolve_event_request__field_indices_by_name[] = { + 0, /* field[0] = Type */ +}; +static const ProtobufCIntRange resolve_event_request__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor resolve_event_request__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "ResolveEventRequest", + "ResolveEventRequest", + "ResolveEventRequest", + "", + sizeof(ResolveEventRequest), + 1, + resolve_event_request__field_descriptors, + resolve_event_request__field_indices_by_name, + 1, resolve_event_request__number_ranges, + (ProtobufCMessageInit) resolve_event_request__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/ResolveEventRequest.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/ResolveEventRequest.pb-c.h new file mode 100644 index 000000000..2553d657d --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/ResolveEventRequest.pb-c.h @@ -0,0 +1,73 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: ResolveEventRequest.proto */ + +#ifndef PROTOBUF_C_ResolveEventRequest_2eproto__INCLUDED +#define PROTOBUF_C_ResolveEventRequest_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 "EventType.pb-c.h" + +typedef struct _ResolveEventRequest ResolveEventRequest; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _ResolveEventRequest +{ + ProtobufCMessage base; + protobuf_c_boolean has_type; + EventType type; +}; +#define RESOLVE_EVENT_REQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&resolve_event_request__descriptor) \ + , 0, EVENT_TYPE__ThreadBreak } + + +/* ResolveEventRequest methods */ +void resolve_event_request__init + (ResolveEventRequest *message); +size_t resolve_event_request__get_packed_size + (const ResolveEventRequest *message); +size_t resolve_event_request__pack + (const ResolveEventRequest *message, + uint8_t *out); +size_t resolve_event_request__pack_to_buffer + (const ResolveEventRequest *message, + ProtobufCBuffer *buffer); +ResolveEventRequest * + resolve_event_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void resolve_event_request__free_unpacked + (ResolveEventRequest *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*ResolveEventRequest_Closure) + (const ResolveEventRequest *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor resolve_event_request__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_ResolveEventRequest_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/ResolveEventResponse.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/ResolveEventResponse.pb-c.c new file mode 100644 index 000000000..e6dfe698b --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/ResolveEventResponse.pb-c.c @@ -0,0 +1,72 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: ResolveEventResponse.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "ResolveEventResponse.pb-c.h" +void resolve_event_response__init + (ResolveEventResponse *message) +{ + static const ResolveEventResponse init_value = RESOLVE_EVENT_RESPONSE__INIT; + *message = init_value; +} +size_t resolve_event_response__get_packed_size + (const ResolveEventResponse *message) +{ + assert(message->base.descriptor == &resolve_event_response__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t resolve_event_response__pack + (const ResolveEventResponse *message, + uint8_t *out) +{ + assert(message->base.descriptor == &resolve_event_response__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t resolve_event_response__pack_to_buffer + (const ResolveEventResponse *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &resolve_event_response__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +ResolveEventResponse * + resolve_event_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (ResolveEventResponse *) + protobuf_c_message_unpack (&resolve_event_response__descriptor, + allocator, len, data); +} +void resolve_event_response__free_unpacked + (ResolveEventResponse *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &resolve_event_response__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +#define resolve_event_response__field_descriptors NULL +#define resolve_event_response__field_indices_by_name NULL +#define resolve_event_response__number_ranges NULL +const ProtobufCMessageDescriptor resolve_event_response__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "ResolveEventResponse", + "ResolveEventResponse", + "ResolveEventResponse", + "", + sizeof(ResolveEventResponse), + 0, + resolve_event_response__field_descriptors, + resolve_event_response__field_indices_by_name, + 0, resolve_event_response__number_ranges, + (ProtobufCMessageInit) resolve_event_response__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/ResolveEventResponse.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/ResolveEventResponse.pb-c.h new file mode 100644 index 000000000..e8f00a2ef --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/ResolveEventResponse.pb-c.h @@ -0,0 +1,70 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: ResolveEventResponse.proto */ + +#ifndef PROTOBUF_C_ResolveEventResponse_2eproto__INCLUDED +#define PROTOBUF_C_ResolveEventResponse_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 _ResolveEventResponse ResolveEventResponse; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _ResolveEventResponse +{ + ProtobufCMessage base; +}; +#define RESOLVE_EVENT_RESPONSE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&resolve_event_response__descriptor) \ + } + + +/* ResolveEventResponse methods */ +void resolve_event_response__init + (ResolveEventResponse *message); +size_t resolve_event_response__get_packed_size + (const ResolveEventResponse *message); +size_t resolve_event_response__pack + (const ResolveEventResponse *message, + uint8_t *out); +size_t resolve_event_response__pack_to_buffer + (const ResolveEventResponse *message, + ProtobufCBuffer *buffer); +ResolveEventResponse * + resolve_event_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void resolve_event_response__free_unpacked + (ResolveEventResponse *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*ResolveEventResponse_Closure) + (const ResolveEventResponse *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor resolve_event_response__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_ResolveEventResponse_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/StartDiagnosticsRequest.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/StartDiagnosticsRequest.pb-c.c new file mode 100644 index 000000000..33f3360a8 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/StartDiagnosticsRequest.pb-c.c @@ -0,0 +1,72 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StartDiagnosticsRequest.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StartDiagnosticsRequest.pb-c.h" +void start_diagnostics_request__init + (StartDiagnosticsRequest *message) +{ + static const StartDiagnosticsRequest init_value = START_DIAGNOSTICS_REQUEST__INIT; + *message = init_value; +} +size_t start_diagnostics_request__get_packed_size + (const StartDiagnosticsRequest *message) +{ + assert(message->base.descriptor == &start_diagnostics_request__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t start_diagnostics_request__pack + (const StartDiagnosticsRequest *message, + uint8_t *out) +{ + assert(message->base.descriptor == &start_diagnostics_request__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t start_diagnostics_request__pack_to_buffer + (const StartDiagnosticsRequest *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &start_diagnostics_request__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StartDiagnosticsRequest * + start_diagnostics_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StartDiagnosticsRequest *) + protobuf_c_message_unpack (&start_diagnostics_request__descriptor, + allocator, len, data); +} +void start_diagnostics_request__free_unpacked + (StartDiagnosticsRequest *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &start_diagnostics_request__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +#define start_diagnostics_request__field_descriptors NULL +#define start_diagnostics_request__field_indices_by_name NULL +#define start_diagnostics_request__number_ranges NULL +const ProtobufCMessageDescriptor start_diagnostics_request__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StartDiagnosticsRequest", + "StartDiagnosticsRequest", + "StartDiagnosticsRequest", + "", + sizeof(StartDiagnosticsRequest), + 0, + start_diagnostics_request__field_descriptors, + start_diagnostics_request__field_indices_by_name, + 0, start_diagnostics_request__number_ranges, + (ProtobufCMessageInit) start_diagnostics_request__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/StartDiagnosticsRequest.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/StartDiagnosticsRequest.pb-c.h new file mode 100644 index 000000000..5cd35b720 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/StartDiagnosticsRequest.pb-c.h @@ -0,0 +1,70 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StartDiagnosticsRequest.proto */ + +#ifndef PROTOBUF_C_StartDiagnosticsRequest_2eproto__INCLUDED +#define PROTOBUF_C_StartDiagnosticsRequest_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 _StartDiagnosticsRequest StartDiagnosticsRequest; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StartDiagnosticsRequest +{ + ProtobufCMessage base; +}; +#define START_DIAGNOSTICS_REQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&start_diagnostics_request__descriptor) \ + } + + +/* StartDiagnosticsRequest methods */ +void start_diagnostics_request__init + (StartDiagnosticsRequest *message); +size_t start_diagnostics_request__get_packed_size + (const StartDiagnosticsRequest *message); +size_t start_diagnostics_request__pack + (const StartDiagnosticsRequest *message, + uint8_t *out); +size_t start_diagnostics_request__pack_to_buffer + (const StartDiagnosticsRequest *message, + ProtobufCBuffer *buffer); +StartDiagnosticsRequest * + start_diagnostics_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void start_diagnostics_request__free_unpacked + (StartDiagnosticsRequest *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StartDiagnosticsRequest_Closure) + (const StartDiagnosticsRequest *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor start_diagnostics_request__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StartDiagnosticsRequest_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/StartDiagnosticsResponse.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/StartDiagnosticsResponse.pb-c.c new file mode 100644 index 000000000..a337e084d --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/StartDiagnosticsResponse.pb-c.c @@ -0,0 +1,131 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StartDiagnosticsResponse.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StartDiagnosticsResponse.pb-c.h" +void start_diagnostics_response__init + (StartDiagnosticsResponse *message) +{ + static const StartDiagnosticsResponse init_value = START_DIAGNOSTICS_RESPONSE__INIT; + *message = init_value; +} +size_t start_diagnostics_response__get_packed_size + (const StartDiagnosticsResponse *message) +{ + assert(message->base.descriptor == &start_diagnostics_response__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t start_diagnostics_response__pack + (const StartDiagnosticsResponse *message, + uint8_t *out) +{ + assert(message->base.descriptor == &start_diagnostics_response__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t start_diagnostics_response__pack_to_buffer + (const StartDiagnosticsResponse *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &start_diagnostics_response__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StartDiagnosticsResponse * + start_diagnostics_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StartDiagnosticsResponse *) + protobuf_c_message_unpack (&start_diagnostics_response__descriptor, + allocator, len, data); +} +void start_diagnostics_response__free_unpacked + (StartDiagnosticsResponse *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &start_diagnostics_response__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor start_diagnostics_response__field_descriptors[4] = +{ + { + "Monitors", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(StartDiagnosticsResponse, monitors), + &diagnostics_monitors__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "DigitalPins", + 2, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(StartDiagnosticsResponse, n_digitalpins), + offsetof(StartDiagnosticsResponse, digitalpins), + &digital_pin__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ComponentsStates", + 3, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(StartDiagnosticsResponse, n_componentsstates), + offsetof(StartDiagnosticsResponse, componentsstates), + &value_component_state__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Events", + 4, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(StartDiagnosticsResponse, n_events), + offsetof(StartDiagnosticsResponse, events), + &event__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned start_diagnostics_response__field_indices_by_name[] = { + 2, /* field[2] = ComponentsStates */ + 1, /* field[1] = DigitalPins */ + 3, /* field[3] = Events */ + 0, /* field[0] = Monitors */ +}; +static const ProtobufCIntRange start_diagnostics_response__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor start_diagnostics_response__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StartDiagnosticsResponse", + "StartDiagnosticsResponse", + "StartDiagnosticsResponse", + "", + sizeof(StartDiagnosticsResponse), + 4, + start_diagnostics_response__field_descriptors, + start_diagnostics_response__field_indices_by_name, + 1, start_diagnostics_response__number_ranges, + (ProtobufCMessageInit) start_diagnostics_response__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/StartDiagnosticsResponse.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/StartDiagnosticsResponse.pb-c.h new file mode 100644 index 000000000..d3967ca49 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/StartDiagnosticsResponse.pb-c.h @@ -0,0 +1,93 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StartDiagnosticsResponse.proto */ + +#ifndef PROTOBUF_C_StartDiagnosticsResponse_2eproto__INCLUDED +#define PROTOBUF_C_StartDiagnosticsResponse_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 "DigitalPin.pb-c.h" +#include "ValueComponentState.pb-c.h" +#include "DiagnosticsMonitors.pb-c.h" +#include "Event.pb-c.h" + +typedef struct _StartDiagnosticsResponse StartDiagnosticsResponse; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StartDiagnosticsResponse +{ + ProtobufCMessage base; + /* + *Monitors + */ + DiagnosticsMonitors *monitors; + /* + *Digital Pins States + */ + size_t n_digitalpins; + DigitalPin **digitalpins; + /* + *Value Components Effective Values + */ + size_t n_componentsstates; + ValueComponentState **componentsstates; + /* + *Hardware Errors & Warnings + */ + size_t n_events; + Event **events; +}; +#define START_DIAGNOSTICS_RESPONSE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&start_diagnostics_response__descriptor) \ + , NULL, 0,NULL, 0,NULL, 0,NULL } + + +/* StartDiagnosticsResponse methods */ +void start_diagnostics_response__init + (StartDiagnosticsResponse *message); +size_t start_diagnostics_response__get_packed_size + (const StartDiagnosticsResponse *message); +size_t start_diagnostics_response__pack + (const StartDiagnosticsResponse *message, + uint8_t *out); +size_t start_diagnostics_response__pack_to_buffer + (const StartDiagnosticsResponse *message, + ProtobufCBuffer *buffer); +StartDiagnosticsResponse * + start_diagnostics_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void start_diagnostics_response__free_unpacked + (StartDiagnosticsResponse *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StartDiagnosticsResponse_Closure) + (const StartDiagnosticsResponse *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor start_diagnostics_response__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StartDiagnosticsResponse_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/StopDiagnosticsRequest.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/StopDiagnosticsRequest.pb-c.c new file mode 100644 index 000000000..3f8502a2c --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/StopDiagnosticsRequest.pb-c.c @@ -0,0 +1,72 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StopDiagnosticsRequest.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StopDiagnosticsRequest.pb-c.h" +void stop_diagnostics_request__init + (StopDiagnosticsRequest *message) +{ + static const StopDiagnosticsRequest init_value = STOP_DIAGNOSTICS_REQUEST__INIT; + *message = init_value; +} +size_t stop_diagnostics_request__get_packed_size + (const StopDiagnosticsRequest *message) +{ + assert(message->base.descriptor == &stop_diagnostics_request__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stop_diagnostics_request__pack + (const StopDiagnosticsRequest *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stop_diagnostics_request__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stop_diagnostics_request__pack_to_buffer + (const StopDiagnosticsRequest *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stop_diagnostics_request__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StopDiagnosticsRequest * + stop_diagnostics_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StopDiagnosticsRequest *) + protobuf_c_message_unpack (&stop_diagnostics_request__descriptor, + allocator, len, data); +} +void stop_diagnostics_request__free_unpacked + (StopDiagnosticsRequest *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stop_diagnostics_request__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +#define stop_diagnostics_request__field_descriptors NULL +#define stop_diagnostics_request__field_indices_by_name NULL +#define stop_diagnostics_request__number_ranges NULL +const ProtobufCMessageDescriptor stop_diagnostics_request__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StopDiagnosticsRequest", + "StopDiagnosticsRequest", + "StopDiagnosticsRequest", + "", + sizeof(StopDiagnosticsRequest), + 0, + stop_diagnostics_request__field_descriptors, + stop_diagnostics_request__field_indices_by_name, + 0, stop_diagnostics_request__number_ranges, + (ProtobufCMessageInit) stop_diagnostics_request__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/StopDiagnosticsRequest.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/StopDiagnosticsRequest.pb-c.h new file mode 100644 index 000000000..9a0cd955e --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/StopDiagnosticsRequest.pb-c.h @@ -0,0 +1,70 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StopDiagnosticsRequest.proto */ + +#ifndef PROTOBUF_C_StopDiagnosticsRequest_2eproto__INCLUDED +#define PROTOBUF_C_StopDiagnosticsRequest_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 _StopDiagnosticsRequest StopDiagnosticsRequest; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StopDiagnosticsRequest +{ + ProtobufCMessage base; +}; +#define STOP_DIAGNOSTICS_REQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stop_diagnostics_request__descriptor) \ + } + + +/* StopDiagnosticsRequest methods */ +void stop_diagnostics_request__init + (StopDiagnosticsRequest *message); +size_t stop_diagnostics_request__get_packed_size + (const StopDiagnosticsRequest *message); +size_t stop_diagnostics_request__pack + (const StopDiagnosticsRequest *message, + uint8_t *out); +size_t stop_diagnostics_request__pack_to_buffer + (const StopDiagnosticsRequest *message, + ProtobufCBuffer *buffer); +StopDiagnosticsRequest * + stop_diagnostics_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stop_diagnostics_request__free_unpacked + (StopDiagnosticsRequest *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StopDiagnosticsRequest_Closure) + (const StopDiagnosticsRequest *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stop_diagnostics_request__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StopDiagnosticsRequest_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/StopDiagnosticsResponse.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/StopDiagnosticsResponse.pb-c.c new file mode 100644 index 000000000..ee0c95def --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/StopDiagnosticsResponse.pb-c.c @@ -0,0 +1,72 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StopDiagnosticsResponse.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StopDiagnosticsResponse.pb-c.h" +void stop_diagnostics_response__init + (StopDiagnosticsResponse *message) +{ + static const StopDiagnosticsResponse init_value = STOP_DIAGNOSTICS_RESPONSE__INIT; + *message = init_value; +} +size_t stop_diagnostics_response__get_packed_size + (const StopDiagnosticsResponse *message) +{ + assert(message->base.descriptor == &stop_diagnostics_response__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stop_diagnostics_response__pack + (const StopDiagnosticsResponse *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stop_diagnostics_response__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stop_diagnostics_response__pack_to_buffer + (const StopDiagnosticsResponse *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stop_diagnostics_response__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StopDiagnosticsResponse * + stop_diagnostics_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StopDiagnosticsResponse *) + protobuf_c_message_unpack (&stop_diagnostics_response__descriptor, + allocator, len, data); +} +void stop_diagnostics_response__free_unpacked + (StopDiagnosticsResponse *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stop_diagnostics_response__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +#define stop_diagnostics_response__field_descriptors NULL +#define stop_diagnostics_response__field_indices_by_name NULL +#define stop_diagnostics_response__number_ranges NULL +const ProtobufCMessageDescriptor stop_diagnostics_response__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StopDiagnosticsResponse", + "StopDiagnosticsResponse", + "StopDiagnosticsResponse", + "", + sizeof(StopDiagnosticsResponse), + 0, + stop_diagnostics_response__field_descriptors, + stop_diagnostics_response__field_indices_by_name, + 0, stop_diagnostics_response__number_ranges, + (ProtobufCMessageInit) stop_diagnostics_response__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/StopDiagnosticsResponse.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/StopDiagnosticsResponse.pb-c.h new file mode 100644 index 000000000..d901dc6c7 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/StopDiagnosticsResponse.pb-c.h @@ -0,0 +1,70 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StopDiagnosticsResponse.proto */ + +#ifndef PROTOBUF_C_StopDiagnosticsResponse_2eproto__INCLUDED +#define PROTOBUF_C_StopDiagnosticsResponse_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 _StopDiagnosticsResponse StopDiagnosticsResponse; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StopDiagnosticsResponse +{ + ProtobufCMessage base; +}; +#define STOP_DIAGNOSTICS_RESPONSE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stop_diagnostics_response__descriptor) \ + } + + +/* StopDiagnosticsResponse methods */ +void stop_diagnostics_response__init + (StopDiagnosticsResponse *message); +size_t stop_diagnostics_response__get_packed_size + (const StopDiagnosticsResponse *message); +size_t stop_diagnostics_response__pack + (const StopDiagnosticsResponse *message, + uint8_t *out); +size_t stop_diagnostics_response__pack_to_buffer + (const StopDiagnosticsResponse *message, + ProtobufCBuffer *buffer); +StopDiagnosticsResponse * + stop_diagnostics_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stop_diagnostics_response__free_unpacked + (StopDiagnosticsResponse *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StopDiagnosticsResponse_Closure) + (const StopDiagnosticsResponse *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stop_diagnostics_response__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StopDiagnosticsResponse_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/ValueComponent.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/ValueComponent.pb-c.h index 013c5f7a0..1e60dac27 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/ValueComponent.pb-c.h +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Diagnostics/ValueComponent.pb-c.h @@ -20,7 +20,13 @@ PROTOBUF_C__BEGIN_DECLS /* --- enums --- */ typedef enum _ValueComponent { + /* + *Heater 1 Temperature (Min = 0, Max = 100) + */ VALUE_COMPONENT__Heater1Temp = 0, + /* + *Heater 2 Temperature (Min = 0, Max = 100) + */ VALUE_COMPONENT__Heater2Temp = 1 PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(VALUE_COMPONENT) } ValueComponent; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Discovery/BasicDiscoveryMessage.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Discovery/BasicDiscoveryMessage.pb-c.c new file mode 100644 index 000000000..343e0cbe6 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Discovery/BasicDiscoveryMessage.pb-c.c @@ -0,0 +1,105 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: BasicDiscoveryMessage.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "BasicDiscoveryMessage.pb-c.h" +void basic_discovery_message__init + (BasicDiscoveryMessage *message) +{ + static const BasicDiscoveryMessage init_value = BASIC_DISCOVERY_MESSAGE__INIT; + *message = init_value; +} +size_t basic_discovery_message__get_packed_size + (const BasicDiscoveryMessage *message) +{ + assert(message->base.descriptor == &basic_discovery_message__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t basic_discovery_message__pack + (const BasicDiscoveryMessage *message, + uint8_t *out) +{ + assert(message->base.descriptor == &basic_discovery_message__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t basic_discovery_message__pack_to_buffer + (const BasicDiscoveryMessage *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &basic_discovery_message__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +BasicDiscoveryMessage * + basic_discovery_message__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (BasicDiscoveryMessage *) + protobuf_c_message_unpack (&basic_discovery_message__descriptor, + allocator, len, data); +} +void basic_discovery_message__free_unpacked + (BasicDiscoveryMessage *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &basic_discovery_message__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor basic_discovery_message__field_descriptors[2] = +{ + { + "ServiceName", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(BasicDiscoveryMessage, servicename), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Port", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + offsetof(BasicDiscoveryMessage, has_port), + offsetof(BasicDiscoveryMessage, port), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned basic_discovery_message__field_indices_by_name[] = { + 1, /* field[1] = Port */ + 0, /* field[0] = ServiceName */ +}; +static const ProtobufCIntRange basic_discovery_message__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor basic_discovery_message__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "BasicDiscoveryMessage", + "BasicDiscoveryMessage", + "BasicDiscoveryMessage", + "", + sizeof(BasicDiscoveryMessage), + 2, + basic_discovery_message__field_descriptors, + basic_discovery_message__field_indices_by_name, + 1, basic_discovery_message__number_ranges, + (ProtobufCMessageInit) basic_discovery_message__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Discovery/BasicDiscoveryMessage.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Discovery/BasicDiscoveryMessage.pb-c.h new file mode 100644 index 000000000..fbc033dae --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Discovery/BasicDiscoveryMessage.pb-c.h @@ -0,0 +1,73 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: BasicDiscoveryMessage.proto */ + +#ifndef PROTOBUF_C_BasicDiscoveryMessage_2eproto__INCLUDED +#define PROTOBUF_C_BasicDiscoveryMessage_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 _BasicDiscoveryMessage BasicDiscoveryMessage; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _BasicDiscoveryMessage +{ + ProtobufCMessage base; + char *servicename; + protobuf_c_boolean has_port; + int32_t port; +}; +#define BASIC_DISCOVERY_MESSAGE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&basic_discovery_message__descriptor) \ + , NULL, 0, 0 } + + +/* BasicDiscoveryMessage methods */ +void basic_discovery_message__init + (BasicDiscoveryMessage *message); +size_t basic_discovery_message__get_packed_size + (const BasicDiscoveryMessage *message); +size_t basic_discovery_message__pack + (const BasicDiscoveryMessage *message, + uint8_t *out); +size_t basic_discovery_message__pack_to_buffer + (const BasicDiscoveryMessage *message, + ProtobufCBuffer *buffer); +BasicDiscoveryMessage * + basic_discovery_message__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void basic_discovery_message__free_unpacked + (BasicDiscoveryMessage *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*BasicDiscoveryMessage_Closure) + (const BasicDiscoveryMessage *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor basic_discovery_message__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_BasicDiscoveryMessage_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareConfiguration.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareConfiguration.pb-c.c index 6ba4d7fc9..113b04e58 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareConfiguration.pb-c.c +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareConfiguration.pb-c.c @@ -52,7 +52,7 @@ void hardware_configuration__free_unpacked assert(message->base.descriptor == &hardware_configuration__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -static const ProtobufCFieldDescriptor hardware_configuration__field_descriptors[5] = +static const ProtobufCFieldDescriptor hardware_configuration__field_descriptors[6] = { { "Dancers", @@ -114,18 +114,31 @@ static const ProtobufCFieldDescriptor hardware_configuration__field_descriptors[ 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, + { + "SpeedSensors", + 6, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(HardwareConfiguration, n_speedsensors), + offsetof(HardwareConfiguration, speedsensors), + &hardware_speed_sensor__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, }; static const unsigned hardware_configuration__field_indices_by_name[] = { 0, /* field[0] = Dancers */ 1, /* field[1] = Dispensers */ 2, /* field[2] = Motors */ 3, /* field[3] = PidControls */ + 5, /* field[5] = SpeedSensors */ 4, /* field[4] = Winders */ }; static const ProtobufCIntRange hardware_configuration__number_ranges[1 + 1] = { { 1, 0 }, - { 0, 5 } + { 0, 6 } }; const ProtobufCMessageDescriptor hardware_configuration__descriptor = { @@ -135,7 +148,7 @@ const ProtobufCMessageDescriptor hardware_configuration__descriptor = "HardwareConfiguration", "", sizeof(HardwareConfiguration), - 5, + 6, hardware_configuration__field_descriptors, hardware_configuration__field_indices_by_name, 1, hardware_configuration__number_ranges, diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareConfiguration.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareConfiguration.pb-c.h index d9818c891..8bf232435 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareConfiguration.pb-c.h +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareConfiguration.pb-c.h @@ -19,6 +19,7 @@ PROTOBUF_C__BEGIN_DECLS #include "HardwareMotor.pb-c.h" #include "HardwarePidControl.pb-c.h" #include "HardwareWinder.pb-c.h" +#include "HardwareSpeedSensor.pb-c.h" typedef struct _HardwareConfiguration HardwareConfiguration; @@ -41,10 +42,12 @@ struct _HardwareConfiguration HardwarePidControl **pidcontrols; size_t n_winders; HardwareWinder **winders; + size_t n_speedsensors; + HardwareSpeedSensor **speedsensors; }; #define HARDWARE_CONFIGURATION__INIT \ { PROTOBUF_C_MESSAGE_INIT (&hardware_configuration__descriptor) \ - , 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL } + , 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL } /* HardwareConfiguration methods */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareDancer.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareDancer.pb-c.c index b838e1382..a86ad1a7b 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareDancer.pb-c.c +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareDancer.pb-c.c @@ -52,7 +52,7 @@ void hardware_dancer__free_unpacked assert(message->base.descriptor == &hardware_dancer__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -static const ProtobufCFieldDescriptor hardware_dancer__field_descriptors[5] = +static const ProtobufCFieldDescriptor hardware_dancer__field_descriptors[11] = { { "HardwareDancerType", @@ -114,18 +114,96 @@ static const ProtobufCFieldDescriptor hardware_dancer__field_descriptors[5] = 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, + { + "MaximalMovementMm", + 6, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + offsetof(HardwareDancer, has_maximalmovementmm), + offsetof(HardwareDancer, maximalmovementmm), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ZeroPoint", + 7, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + offsetof(HardwareDancer, has_zeropoint), + offsetof(HardwareDancer, zeropoint), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ResolutionBits", + 8, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + offsetof(HardwareDancer, has_resolutionbits), + offsetof(HardwareDancer, resolutionbits), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ArmLength", + 9, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + offsetof(HardwareDancer, has_armlength), + offsetof(HardwareDancer, armlength), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "AssemblyDirectionRight", + 10, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BOOL, + offsetof(HardwareDancer, has_assemblydirectionright), + offsetof(HardwareDancer, assemblydirectionright), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "AccelerateOnTensionRaise", + 11, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BOOL, + offsetof(HardwareDancer, has_accelerateontensionraise), + offsetof(HardwareDancer, accelerateontensionraise), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, }; static const unsigned hardware_dancer__field_indices_by_name[] = { + 10, /* field[10] = AccelerateOnTensionRaise */ + 8, /* field[8] = ArmLength */ + 9, /* field[9] = AssemblyDirectionRight */ 1, /* field[1] = Gradual */ 0, /* field[0] = HardwareDancerType */ 2, /* field[2] = K */ + 5, /* field[5] = MaximalMovementMm */ 4, /* field[4] = PulsePerMmSpring */ + 7, /* field[7] = ResolutionBits */ 3, /* field[3] = X */ + 6, /* field[6] = ZeroPoint */ }; static const ProtobufCIntRange hardware_dancer__number_ranges[1 + 1] = { { 1, 0 }, - { 0, 5 } + { 0, 11 } }; const ProtobufCMessageDescriptor hardware_dancer__descriptor = { @@ -135,7 +213,7 @@ const ProtobufCMessageDescriptor hardware_dancer__descriptor = "HardwareDancer", "", sizeof(HardwareDancer), - 5, + 11, hardware_dancer__field_descriptors, hardware_dancer__field_indices_by_name, 1, hardware_dancer__number_ranges, diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareDancer.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareDancer.pb-c.h index 8e6e74cde..c2744553d 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareDancer.pb-c.h +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareDancer.pb-c.h @@ -37,10 +37,22 @@ struct _HardwareDancer double x; protobuf_c_boolean has_pulsepermmspring; int32_t pulsepermmspring; + protobuf_c_boolean has_maximalmovementmm; + int32_t maximalmovementmm; + protobuf_c_boolean has_zeropoint; + int32_t zeropoint; + protobuf_c_boolean has_resolutionbits; + int32_t resolutionbits; + protobuf_c_boolean has_armlength; + int32_t armlength; + protobuf_c_boolean has_assemblydirectionright; + protobuf_c_boolean assemblydirectionright; + protobuf_c_boolean has_accelerateontensionraise; + protobuf_c_boolean accelerateontensionraise; }; #define HARDWARE_DANCER__INIT \ { PROTOBUF_C_MESSAGE_INIT (&hardware_dancer__descriptor) \ - , 0, HARDWARE_DANCER_TYPE__LeftDancer, 0, 0, 0, 0, 0, 0, 0, 0 } + , 0, HARDWARE_DANCER_TYPE__LeftDancer, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } /* HardwareDancer methods */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareDancerType.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareDancerType.pb-c.h index fed2b0108..294363d95 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareDancerType.pb-c.h +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareDancerType.pb-c.h @@ -20,8 +20,17 @@ PROTOBUF_C__BEGIN_DECLS /* --- enums --- */ typedef enum _HardwareDancerType { + /* + *Left Dancer + */ HARDWARE_DANCER_TYPE__LeftDancer = 0, + /* + *Middle Dancer + */ HARDWARE_DANCER_TYPE__MiddleDancer = 1, + /* + *Right Dancer + */ HARDWARE_DANCER_TYPE__RightDancer = 2 PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(HARDWARE_DANCER_TYPE) } HardwareDancerType; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareDispenser.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareDispenser.pb-c.c index 1691150ab..fdfef474f 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareDispenser.pb-c.c +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareDispenser.pb-c.c @@ -52,7 +52,7 @@ void hardware_dispenser__free_unpacked assert(message->base.descriptor == &hardware_dispenser__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -static const ProtobufCFieldDescriptor hardware_dispenser__field_descriptors[15] = +static const ProtobufCFieldDescriptor hardware_dispenser__field_descriptors[4] = { { "HardwareDispenserType", @@ -67,168 +67,36 @@ static const ProtobufCFieldDescriptor hardware_dispenser__field_descriptors[15] 0,NULL,NULL /* reserved1,reserved2, etc */ }, { - "NlPerPulse", + "Index", 2, PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_DOUBLE, - offsetof(HardwareDispenser, has_nlperpulse), - offsetof(HardwareDispenser, nlperpulse), + PROTOBUF_C_TYPE_INT32, + offsetof(HardwareDispenser, has_index), + offsetof(HardwareDispenser, index), NULL, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, { - "Capacity", + "NlPerPulse", 3, PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_DOUBLE, - offsetof(HardwareDispenser, has_capacity), - offsetof(HardwareDispenser, capacity), + offsetof(HardwareDispenser, has_nlperpulse), + offsetof(HardwareDispenser, nlperpulse), NULL, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, { - "MinFrequency", + "Capacity", 4, PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_INT32, - offsetof(HardwareDispenser, has_minfrequency), - offsetof(HardwareDispenser, minfrequency), - NULL, - NULL, - 0, /* flags */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "MaxFrequency", - 5, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_INT32, - offsetof(HardwareDispenser, has_maxfrequency), - offsetof(HardwareDispenser, maxfrequency), - NULL, - NULL, - 0, /* flags */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "MinMicroStep", - 6, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_INT32, - offsetof(HardwareDispenser, has_minmicrostep), - offsetof(HardwareDispenser, minmicrostep), - NULL, - NULL, - 0, /* flags */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "MaxMicroStep", - 7, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_INT32, - offsetof(HardwareDispenser, has_maxmicrostep), - offsetof(HardwareDispenser, maxmicrostep), - NULL, - NULL, - 0, /* flags */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "CorrectionGain", - 8, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_DOUBLE, - offsetof(HardwareDispenser, has_correctiongain), - offsetof(HardwareDispenser, correctiongain), - NULL, - NULL, - 0, /* flags */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "RatioToDryerSpeed", - 9, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_DOUBLE, - offsetof(HardwareDispenser, has_ratiotodryerspeed), - offsetof(HardwareDispenser, ratiotodryerspeed), - NULL, - NULL, - 0, /* flags */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "Kp", - 10, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_DOUBLE, - offsetof(HardwareDispenser, has_kp), - offsetof(HardwareDispenser, kp), - NULL, - NULL, - 0, /* flags */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "Ki", - 11, - PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_DOUBLE, - offsetof(HardwareDispenser, has_ki), - offsetof(HardwareDispenser, ki), - NULL, - NULL, - 0, /* flags */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "Kd", - 12, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_DOUBLE, - offsetof(HardwareDispenser, has_kd), - offsetof(HardwareDispenser, kd), - NULL, - NULL, - 0, /* flags */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "ChangeSlope", - 13, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_DOUBLE, - offsetof(HardwareDispenser, has_changeslope), - offsetof(HardwareDispenser, changeslope), - NULL, - NULL, - 0, /* flags */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "HighLengthMicroSecond", - 14, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_DOUBLE, - offsetof(HardwareDispenser, has_highlengthmicrosecond), - offsetof(HardwareDispenser, highlengthmicrosecond), - NULL, - NULL, - 0, /* flags */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "ControlTiming", - 15, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_INT32, - offsetof(HardwareDispenser, has_controltiming), - offsetof(HardwareDispenser, controltiming), + offsetof(HardwareDispenser, has_capacity), + offsetof(HardwareDispenser, capacity), NULL, NULL, 0, /* flags */ @@ -236,26 +104,15 @@ static const ProtobufCFieldDescriptor hardware_dispenser__field_descriptors[15] }, }; static const unsigned hardware_dispenser__field_indices_by_name[] = { - 2, /* field[2] = Capacity */ - 12, /* field[12] = ChangeSlope */ - 14, /* field[14] = ControlTiming */ - 7, /* field[7] = CorrectionGain */ + 3, /* field[3] = Capacity */ 0, /* field[0] = HardwareDispenserType */ - 13, /* field[13] = HighLengthMicroSecond */ - 11, /* field[11] = Kd */ - 10, /* field[10] = Ki */ - 9, /* field[9] = Kp */ - 4, /* field[4] = MaxFrequency */ - 6, /* field[6] = MaxMicroStep */ - 3, /* field[3] = MinFrequency */ - 5, /* field[5] = MinMicroStep */ - 1, /* field[1] = NlPerPulse */ - 8, /* field[8] = RatioToDryerSpeed */ + 1, /* field[1] = Index */ + 2, /* field[2] = NlPerPulse */ }; static const ProtobufCIntRange hardware_dispenser__number_ranges[1 + 1] = { { 1, 0 }, - { 0, 15 } + { 0, 4 } }; const ProtobufCMessageDescriptor hardware_dispenser__descriptor = { @@ -265,7 +122,7 @@ const ProtobufCMessageDescriptor hardware_dispenser__descriptor = "HardwareDispenser", "", sizeof(HardwareDispenser), - 15, + 4, hardware_dispenser__field_descriptors, hardware_dispenser__field_indices_by_name, 1, hardware_dispenser__number_ranges, diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareDispenser.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareDispenser.pb-c.h index bde6bad40..cd910b833 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareDispenser.pb-c.h +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareDispenser.pb-c.h @@ -29,38 +29,16 @@ struct _HardwareDispenser ProtobufCMessage base; protobuf_c_boolean has_hardwaredispensertype; HardwareDispenserType hardwaredispensertype; + protobuf_c_boolean has_index; + int32_t index; protobuf_c_boolean has_nlperpulse; double nlperpulse; protobuf_c_boolean has_capacity; double capacity; - protobuf_c_boolean has_minfrequency; - int32_t minfrequency; - protobuf_c_boolean has_maxfrequency; - int32_t maxfrequency; - protobuf_c_boolean has_minmicrostep; - int32_t minmicrostep; - protobuf_c_boolean has_maxmicrostep; - int32_t maxmicrostep; - protobuf_c_boolean has_correctiongain; - double correctiongain; - protobuf_c_boolean has_ratiotodryerspeed; - double ratiotodryerspeed; - protobuf_c_boolean has_kp; - double kp; - protobuf_c_boolean has_ki; - double ki; - protobuf_c_boolean has_kd; - double kd; - protobuf_c_boolean has_changeslope; - double changeslope; - protobuf_c_boolean has_highlengthmicrosecond; - double highlengthmicrosecond; - protobuf_c_boolean has_controltiming; - int32_t controltiming; }; #define HARDWARE_DISPENSER__INIT \ { PROTOBUF_C_MESSAGE_INIT (&hardware_dispenser__descriptor) \ - , 0, HARDWARE_DISPENSER_TYPE__StandardDispenser, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } + , 0, HARDWARE_DISPENSER_TYPE__StandardDispenser, 0, 0, 0, 0, 0, 0 } /* HardwareDispenser methods */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareMotor.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareMotor.pb-c.c index 68b02ae76..ad64bb77c 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareMotor.pb-c.c +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareMotor.pb-c.c @@ -52,7 +52,7 @@ void hardware_motor__free_unpacked assert(message->base.descriptor == &hardware_motor__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -static const ProtobufCFieldDescriptor hardware_motor__field_descriptors[15] = +static const ProtobufCFieldDescriptor hardware_motor__field_descriptors[24] = { { "HardwareMotorType", @@ -91,144 +91,252 @@ static const ProtobufCFieldDescriptor hardware_motor__field_descriptors[15] = 0,NULL,NULL /* reserved1,reserved2, etc */ }, { - "MinMicroStep", + "SetMicroStep", 4, PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_INT32, - offsetof(HardwareMotor, has_minmicrostep), - offsetof(HardwareMotor, minmicrostep), + offsetof(HardwareMotor, has_setmicrostep), + offsetof(HardwareMotor, setmicrostep), NULL, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, { - "MaxMicroStep", + "MicroStep", 5, PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_INT32, - offsetof(HardwareMotor, has_maxmicrostep), - offsetof(HardwareMotor, maxmicrostep), + offsetof(HardwareMotor, has_microstep), + offsetof(HardwareMotor, microstep), NULL, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, { - "LinearRatio", + "MaxChangeSlope", 6, PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_DOUBLE, - offsetof(HardwareMotor, has_linearratio), - offsetof(HardwareMotor, linearratio), + offsetof(HardwareMotor, has_maxchangeslope), + offsetof(HardwareMotor, maxchangeslope), NULL, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, { - "MedianPosition", + "HighLengthMicroSecond", 7, PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_INT32, - offsetof(HardwareMotor, has_medianposition), - offsetof(HardwareMotor, medianposition), + PROTOBUF_C_TYPE_DOUBLE, + offsetof(HardwareMotor, has_highlengthmicrosecond), + offsetof(HardwareMotor, highlengthmicrosecond), NULL, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, { - "CorrectionGain", + "SpeedMaster", 8, PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_DOUBLE, - offsetof(HardwareMotor, has_correctiongain), - offsetof(HardwareMotor, correctiongain), + PROTOBUF_C_TYPE_BOOL, + offsetof(HardwareMotor, has_speedmaster), + offsetof(HardwareMotor, speedmaster), NULL, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, { - "RatioToDryerSpeed", + "PulsePerRound", 9, PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_DOUBLE, - offsetof(HardwareMotor, has_ratiotodryerspeed), - offsetof(HardwareMotor, ratiotodryerspeed), + PROTOBUF_C_TYPE_INT32, + offsetof(HardwareMotor, has_pulseperround), + offsetof(HardwareMotor, pulseperround), NULL, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, { - "Kp", + "PulleyRadius", 10, PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_DOUBLE, - offsetof(HardwareMotor, has_kp), - offsetof(HardwareMotor, kp), + offsetof(HardwareMotor, has_pulleyradius), + offsetof(HardwareMotor, pulleyradius), NULL, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, { - "Ki", + "ConfigWord", 11, PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_DOUBLE, - offsetof(HardwareMotor, has_ki), - offsetof(HardwareMotor, ki), + PROTOBUF_C_TYPE_INT32, + offsetof(HardwareMotor, has_configword), + offsetof(HardwareMotor, configword), NULL, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, { - "Kd", + "DirectionThreadWize", 12, PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_DOUBLE, - offsetof(HardwareMotor, has_kd), - offsetof(HardwareMotor, kd), + PROTOBUF_C_TYPE_BOOL, + offsetof(HardwareMotor, has_directionthreadwize), + offsetof(HardwareMotor, directionthreadwize), NULL, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, { - "ChangeSlope", + "KvalHold", 13, PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_DOUBLE, - offsetof(HardwareMotor, has_changeslope), - offsetof(HardwareMotor, changeslope), + PROTOBUF_C_TYPE_INT32, + offsetof(HardwareMotor, has_kvalhold), + offsetof(HardwareMotor, kvalhold), NULL, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, { - "HighLengthMicroSecond", + "KvalRun", 14, PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_DOUBLE, - offsetof(HardwareMotor, has_highlengthmicrosecond), - offsetof(HardwareMotor, highlengthmicrosecond), + PROTOBUF_C_TYPE_INT32, + offsetof(HardwareMotor, has_kvalrun), + offsetof(HardwareMotor, kvalrun), NULL, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, { - "SpeedMaster", + "KvalAcc", 15, PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + offsetof(HardwareMotor, has_kvalacc), + offsetof(HardwareMotor, kvalacc), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "KvalDec", + 16, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + offsetof(HardwareMotor, has_kvaldec), + offsetof(HardwareMotor, kvaldec), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "OverCurrentThreshold", + 17, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + offsetof(HardwareMotor, has_overcurrentthreshold), + offsetof(HardwareMotor, overcurrentthreshold), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "StallThreshold", + 18, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + offsetof(HardwareMotor, has_stallthreshold), + offsetof(HardwareMotor, stallthreshold), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ThermalCompensationFactor", + 19, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + offsetof(HardwareMotor, has_thermalcompensationfactor), + offsetof(HardwareMotor, thermalcompensationfactor), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "LowSpeedOptimization", + 20, + PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_BOOL, - offsetof(HardwareMotor, has_speedmaster), - offsetof(HardwareMotor, speedmaster), + offsetof(HardwareMotor, has_lowspeedoptimization), + offsetof(HardwareMotor, lowspeedoptimization), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "StSlp", + 21, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + offsetof(HardwareMotor, has_stslp), + offsetof(HardwareMotor, stslp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "IntSpd", + 22, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + offsetof(HardwareMotor, has_intspd), + offsetof(HardwareMotor, intspd), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "FnSlpAcc", + 23, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + offsetof(HardwareMotor, has_fnslpacc), + offsetof(HardwareMotor, fnslpacc), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "FnSlpDec", + 24, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + offsetof(HardwareMotor, has_fnslpdec), + offsetof(HardwareMotor, fnslpdec), NULL, NULL, 0, /* flags */ @@ -236,26 +344,35 @@ static const ProtobufCFieldDescriptor hardware_motor__field_descriptors[15] = }, }; static const unsigned hardware_motor__field_indices_by_name[] = { - 12, /* field[12] = ChangeSlope */ - 7, /* field[7] = CorrectionGain */ + 10, /* field[10] = ConfigWord */ + 11, /* field[11] = DirectionThreadWize */ + 22, /* field[22] = FnSlpAcc */ + 23, /* field[23] = FnSlpDec */ 0, /* field[0] = HardwareMotorType */ - 13, /* field[13] = HighLengthMicroSecond */ - 11, /* field[11] = Kd */ - 10, /* field[10] = Ki */ - 9, /* field[9] = Kp */ - 5, /* field[5] = LinearRatio */ + 6, /* field[6] = HighLengthMicroSecond */ + 21, /* field[21] = IntSpd */ + 14, /* field[14] = KvalAcc */ + 15, /* field[15] = KvalDec */ + 12, /* field[12] = KvalHold */ + 13, /* field[13] = KvalRun */ + 19, /* field[19] = LowSpeedOptimization */ + 5, /* field[5] = MaxChangeSlope */ 2, /* field[2] = MaxFrequency */ - 4, /* field[4] = MaxMicroStep */ - 6, /* field[6] = MedianPosition */ + 4, /* field[4] = MicroStep */ 1, /* field[1] = MinFrequency */ - 3, /* field[3] = MinMicroStep */ - 8, /* field[8] = RatioToDryerSpeed */ - 14, /* field[14] = SpeedMaster */ + 16, /* field[16] = OverCurrentThreshold */ + 9, /* field[9] = PulleyRadius */ + 8, /* field[8] = PulsePerRound */ + 3, /* field[3] = SetMicroStep */ + 7, /* field[7] = SpeedMaster */ + 20, /* field[20] = StSlp */ + 17, /* field[17] = StallThreshold */ + 18, /* field[18] = ThermalCompensationFactor */ }; static const ProtobufCIntRange hardware_motor__number_ranges[1 + 1] = { { 1, 0 }, - { 0, 15 } + { 0, 24 } }; const ProtobufCMessageDescriptor hardware_motor__descriptor = { @@ -265,7 +382,7 @@ const ProtobufCMessageDescriptor hardware_motor__descriptor = "HardwareMotor", "", sizeof(HardwareMotor), - 15, + 24, hardware_motor__field_descriptors, hardware_motor__field_indices_by_name, 1, hardware_motor__number_ranges, diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareMotor.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareMotor.pb-c.h index 1b09015fb..7194765e0 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareMotor.pb-c.h +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareMotor.pb-c.h @@ -33,34 +33,52 @@ struct _HardwareMotor int32_t minfrequency; protobuf_c_boolean has_maxfrequency; int32_t maxfrequency; - protobuf_c_boolean has_minmicrostep; - int32_t minmicrostep; - protobuf_c_boolean has_maxmicrostep; - int32_t maxmicrostep; - protobuf_c_boolean has_linearratio; - double linearratio; - protobuf_c_boolean has_medianposition; - int32_t medianposition; - protobuf_c_boolean has_correctiongain; - double correctiongain; - protobuf_c_boolean has_ratiotodryerspeed; - double ratiotodryerspeed; - protobuf_c_boolean has_kp; - double kp; - protobuf_c_boolean has_ki; - double ki; - protobuf_c_boolean has_kd; - double kd; - protobuf_c_boolean has_changeslope; - double changeslope; + protobuf_c_boolean has_setmicrostep; + int32_t setmicrostep; + protobuf_c_boolean has_microstep; + int32_t microstep; + protobuf_c_boolean has_maxchangeslope; + double maxchangeslope; protobuf_c_boolean has_highlengthmicrosecond; double highlengthmicrosecond; protobuf_c_boolean has_speedmaster; protobuf_c_boolean speedmaster; + protobuf_c_boolean has_pulseperround; + int32_t pulseperround; + protobuf_c_boolean has_pulleyradius; + double pulleyradius; + protobuf_c_boolean has_configword; + int32_t configword; + protobuf_c_boolean has_directionthreadwize; + protobuf_c_boolean directionthreadwize; + protobuf_c_boolean has_kvalhold; + int32_t kvalhold; + protobuf_c_boolean has_kvalrun; + int32_t kvalrun; + protobuf_c_boolean has_kvalacc; + int32_t kvalacc; + protobuf_c_boolean has_kvaldec; + int32_t kvaldec; + protobuf_c_boolean has_overcurrentthreshold; + int32_t overcurrentthreshold; + protobuf_c_boolean has_stallthreshold; + int32_t stallthreshold; + protobuf_c_boolean has_thermalcompensationfactor; + int32_t thermalcompensationfactor; + protobuf_c_boolean has_lowspeedoptimization; + protobuf_c_boolean lowspeedoptimization; + protobuf_c_boolean has_stslp; + int32_t stslp; + protobuf_c_boolean has_intspd; + int32_t intspd; + protobuf_c_boolean has_fnslpacc; + int32_t fnslpacc; + protobuf_c_boolean has_fnslpdec; + int32_t fnslpdec; }; #define HARDWARE_MOTOR__INIT \ { PROTOBUF_C_MESSAGE_INIT (&hardware_motor__descriptor) \ - , 0, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } + , 0, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } /* HardwareMotor methods */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareMotorType.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareMotorType.pb-c.h index b98139a4d..3352ffed6 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareMotorType.pb-c.h +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareMotorType.pb-c.h @@ -20,34 +20,121 @@ PROTOBUF_C__BEGIN_DECLS /* --- enums --- */ typedef enum _HardwareMotorType { + /* + *Cleaning Head Motor + */ HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD = 0, + /* + *Cleaning Mechanism Motor + */ HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH = 1, + /* + *Dyeing Head Lid Motor + */ HARDWARE_MOTOR_TYPE__MOTO_DH_LID = 2, + /* + *Dryer Main Motor + */ HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING = 3, + /* + *Drier Lid Motor + */ HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID = 4, + /* + *Drier Thread Loading Arm Motor + */ HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM = 5, + /* + *Dispenser 1 Motor + */ HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1 = 6, + /* + *Dispenser 2 Motor + */ HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2 = 7, + /* + *Dispenser 3 Motor + */ HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3 = 8, + /* + *Dispenser 4 Motor + */ HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4 = 9, + /* + *Dispenser 5 Motor + */ HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5 = 10, + /* + *Dispenser 6 Motor + */ HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6 = 11, + /* + *Dispenser 7 Motor + */ HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7 = 12, + /* + *Dispenser 8 Motor + */ HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8 = 13, + /* + *Winder Screw Motor + */ HARDWARE_MOTOR_TYPE__MOTO_SCREW = 14, + /* + *Winder Motor + */ HARDWARE_MOTOR_TYPE__MOTO_WINDER = 15, + /* + *Pooler Dancer Adjustment + */ HARDWARE_MOTOR_TYPE__MOTO_LDANCER1 = 16, + /* + *Winder Dancer Adjustment #1 + */ HARDWARE_MOTOR_TYPE__MOTO_LDANCER2 = 17, + /* + *Pooler Motor + */ HARDWARE_MOTOR_TYPE__MOTO_LDRIVING = 18, + /* + *Pooler Loading Motor + */ HARDWARE_MOTOR_TYPE__MOTO_LLOADING = 19, + /* + *Pooler Loading Pivot Arm Motor + */ HARDWARE_MOTOR_TYPE__MOTO_LPIVOT1 = 20, + /* + *Feeder Dancer Adjustment Motor + */ HARDWARE_MOTOR_TYPE__MOTO_RDANCER = 21, + /* + *Feeder Motor + */ HARDWARE_MOTOR_TYPE__MOTO_RDRIVING = 22, + /* + *Right Loading Arm Motor + */ HARDWARE_MOTOR_TYPE__MOTO_RLOADARM = 23, + /* + *Right Loading Motor + */ HARDWARE_MOTOR_TYPE__MOTO_RLOADING = 24, + /* + *Spare 1 Motor + */ HARDWARE_MOTOR_TYPE__MOTO_SPARE1_1 = 25, + /* + *Spare 2 Motor + */ HARDWARE_MOTOR_TYPE__MOTO_SPARE1_2 = 26, + /* + *Spare 3 Motor + */ HARDWARE_MOTOR_TYPE__MOTO_SPARE2_1 = 27, + /* + *Spare 4 Motor + */ HARDWARE_MOTOR_TYPE__MOTO_SPARE2_2 = 28 PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(HARDWARE_MOTOR_TYPE) } HardwareMotorType; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwarePidControl.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwarePidControl.pb-c.c index 9826afdda..c2e0f4a75 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwarePidControl.pb-c.c +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwarePidControl.pb-c.c @@ -52,7 +52,7 @@ void hardware_pid_control__free_unpacked assert(message->base.descriptor == &hardware_pid_control__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -static const ProtobufCFieldDescriptor hardware_pid_control__field_descriptors[17] = +static const ProtobufCFieldDescriptor hardware_pid_control__field_descriptors[18] = { { "HardwarePidControlType", @@ -258,6 +258,18 @@ static const ProtobufCFieldDescriptor hardware_pid_control__field_descriptors[17 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, + { + "ProportionalGain", + 18, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_DOUBLE, + offsetof(HardwarePidControl, has_proportionalgain), + offsetof(HardwarePidControl, proportionalgain), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, }; static const unsigned hardware_pid_control__field_indices_by_name[] = { 16, /* field[16] = AcHeatersHalfCycleTime */ @@ -270,6 +282,7 @@ static const unsigned hardware_pid_control__field_indices_by_name[] = { 15, /* field[15] = OutputProportionalCycleTime */ 1, /* field[1] = OutputProportionalPowerLimit */ 13, /* field[13] = ProcessVariableSamplingRate */ + 17, /* field[17] = ProportionalGain */ 14, /* field[14] = PvInputFilterFactorMode */ 5, /* field[5] = SensorCorrectionAdjustment */ 7, /* field[7] = SensorMaxValue */ @@ -281,7 +294,7 @@ static const unsigned hardware_pid_control__field_indices_by_name[] = { static const ProtobufCIntRange hardware_pid_control__number_ranges[1 + 1] = { { 1, 0 }, - { 0, 17 } + { 0, 18 } }; const ProtobufCMessageDescriptor hardware_pid_control__descriptor = { @@ -291,7 +304,7 @@ const ProtobufCMessageDescriptor hardware_pid_control__descriptor = "HardwarePidControl", "", sizeof(HardwarePidControl), - 17, + 18, hardware_pid_control__field_descriptors, hardware_pid_control__field_indices_by_name, 1, hardware_pid_control__number_ranges, diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwarePidControl.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwarePidControl.pb-c.h index b012fb377..0f9a23cad 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwarePidControl.pb-c.h +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwarePidControl.pb-c.h @@ -61,10 +61,12 @@ struct _HardwarePidControl int32_t outputproportionalcycletime; protobuf_c_boolean has_acheatershalfcycletime; int32_t acheatershalfcycletime; + protobuf_c_boolean has_proportionalgain; + double proportionalgain; }; #define HARDWARE_PID_CONTROL__INIT \ { PROTOBUF_C_MESSAGE_INIT (&hardware_pid_control__descriptor) \ - , 0, HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } + , 0, HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } /* HardwarePidControl methods */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwarePidControlType.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwarePidControlType.pb-c.c index a64913666..fe42b6669 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwarePidControlType.pb-c.c +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwarePidControlType.pb-c.c @@ -7,7 +7,7 @@ #endif #include "HardwarePidControlType.pb-c.h" -static const ProtobufCEnumValue hardware_pid_control_type__enum_values_by_number[14] = +static const ProtobufCEnumValue hardware_pid_control_type__enum_values_by_number[22] = { { "DryerHeater1000w", "HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w", 0 }, { "DryerHeater200w1", "HARDWARE_PID_CONTROL_TYPE__DryerHeater200w1", 1 }, @@ -16,33 +16,49 @@ static const ProtobufCEnumValue hardware_pid_control_type__enum_values_by_number { "HeadHeaterZ2", "HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2", 4 }, { "HeadHeaterZ3", "HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3", 5 }, { "HeadHeaterZ4", "HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4", 6 }, - { "MixerHeater", "HARDWARE_PID_CONTROL_TYPE__MixerHeater", 7 }, - { "WasteControl", "HARDWARE_PID_CONTROL_TYPE__WasteControl", 8 }, - { "MotorDryer", "HARDWARE_PID_CONTROL_TYPE__MotorDryer", 9 }, - { "MotorFeeder", "HARDWARE_PID_CONTROL_TYPE__MotorFeeder", 10 }, - { "MotorPooler", "HARDWARE_PID_CONTROL_TYPE__MotorPooler", 11 }, - { "MotorWinder", "HARDWARE_PID_CONTROL_TYPE__MotorWinder", 12 }, - { "DryerHeater400", "HARDWARE_PID_CONTROL_TYPE__DryerHeater400", 13 }, + { "HeadHeaterZ5", "HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5", 7 }, + { "MixerHeater", "HARDWARE_PID_CONTROL_TYPE__MixerHeater", 8 }, + { "WasteControl", "HARDWARE_PID_CONTROL_TYPE__WasteControl", 9 }, + { "MotorDryer", "HARDWARE_PID_CONTROL_TYPE__MotorDryer", 10 }, + { "MotorFeeder", "HARDWARE_PID_CONTROL_TYPE__MotorFeeder", 11 }, + { "MotorPooler", "HARDWARE_PID_CONTROL_TYPE__MotorPooler", 12 }, + { "MotorWinder", "HARDWARE_PID_CONTROL_TYPE__MotorWinder", 13 }, + { "Dispenser1", "HARDWARE_PID_CONTROL_TYPE__Dispenser1", 14 }, + { "Dispenser2", "HARDWARE_PID_CONTROL_TYPE__Dispenser2", 15 }, + { "Dispenser3", "HARDWARE_PID_CONTROL_TYPE__Dispenser3", 16 }, + { "Dispenser4", "HARDWARE_PID_CONTROL_TYPE__Dispenser4", 17 }, + { "Dispenser5", "HARDWARE_PID_CONTROL_TYPE__Dispenser5", 18 }, + { "Dispenser6", "HARDWARE_PID_CONTROL_TYPE__Dispenser6", 19 }, + { "Dispenser7", "HARDWARE_PID_CONTROL_TYPE__Dispenser7", 20 }, + { "Dispenser8", "HARDWARE_PID_CONTROL_TYPE__Dispenser8", 21 }, }; static const ProtobufCIntRange hardware_pid_control_type__value_ranges[] = { -{0, 0},{0, 14} +{0, 0},{0, 22} }; -static const ProtobufCEnumValueIndex hardware_pid_control_type__enum_values_by_name[14] = +static const ProtobufCEnumValueIndex hardware_pid_control_type__enum_values_by_name[22] = { + { "Dispenser1", 14 }, + { "Dispenser2", 15 }, + { "Dispenser3", 16 }, + { "Dispenser4", 17 }, + { "Dispenser5", 18 }, + { "Dispenser6", 19 }, + { "Dispenser7", 20 }, + { "Dispenser8", 21 }, { "DryerHeater1000w", 0 }, { "DryerHeater200w1", 1 }, { "DryerHeater200w2", 2 }, - { "DryerHeater400", 13 }, { "HeadHeaterZ1", 3 }, { "HeadHeaterZ2", 4 }, { "HeadHeaterZ3", 5 }, { "HeadHeaterZ4", 6 }, - { "MixerHeater", 7 }, - { "MotorDryer", 9 }, - { "MotorFeeder", 10 }, - { "MotorPooler", 11 }, - { "MotorWinder", 12 }, - { "WasteControl", 8 }, + { "HeadHeaterZ5", 7 }, + { "MixerHeater", 8 }, + { "MotorDryer", 10 }, + { "MotorFeeder", 11 }, + { "MotorPooler", 12 }, + { "MotorWinder", 13 }, + { "WasteControl", 9 }, }; const ProtobufCEnumDescriptor hardware_pid_control_type__descriptor = { @@ -51,9 +67,9 @@ const ProtobufCEnumDescriptor hardware_pid_control_type__descriptor = "HardwarePidControlType", "HardwarePidControlType", "", - 14, + 22, hardware_pid_control_type__enum_values_by_number, - 14, + 22, hardware_pid_control_type__enum_values_by_name, 1, hardware_pid_control_type__value_ranges, diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwarePidControlType.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwarePidControlType.pb-c.h index 8bcea3bd0..8bbfd3525 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwarePidControlType.pb-c.h +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwarePidControlType.pb-c.h @@ -20,20 +20,94 @@ PROTOBUF_C__BEGIN_DECLS /* --- enums --- */ typedef enum _HardwarePidControlType { + /* + *Dryer Heater 1000w + */ HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w = 0, + /* + *Dryer Heater 200w 1 + */ HARDWARE_PID_CONTROL_TYPE__DryerHeater200w1 = 1, + /* + *Dryer Heater 200w 2 + */ HARDWARE_PID_CONTROL_TYPE__DryerHeater200w2 = 2, + /* + *Head Heater Zone 1 + */ HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1 = 3, + /* + *Head Heater Zone 2 + */ HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2 = 4, + /* + *Head Heater Zone 3 + */ HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3 = 5, + /* + *Head Heater Zone 4 + */ HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4 = 6, - HARDWARE_PID_CONTROL_TYPE__MixerHeater = 7, - HARDWARE_PID_CONTROL_TYPE__WasteControl = 8, - HARDWARE_PID_CONTROL_TYPE__MotorDryer = 9, - HARDWARE_PID_CONTROL_TYPE__MotorFeeder = 10, - HARDWARE_PID_CONTROL_TYPE__MotorPooler = 11, - HARDWARE_PID_CONTROL_TYPE__MotorWinder = 12, - HARDWARE_PID_CONTROL_TYPE__DryerHeater400 = 13 + /* + *Head Heater Zone 5 + */ + HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5 = 7, + /* + *Mixer Heater + */ + HARDWARE_PID_CONTROL_TYPE__MixerHeater = 8, + /* + *Waste Control + */ + HARDWARE_PID_CONTROL_TYPE__WasteControl = 9, + /* + *Dryer Motor + */ + HARDWARE_PID_CONTROL_TYPE__MotorDryer = 10, + /* + *Feeder Motor + */ + HARDWARE_PID_CONTROL_TYPE__MotorFeeder = 11, + /* + *Pooler Motor + */ + HARDWARE_PID_CONTROL_TYPE__MotorPooler = 12, + /* + *Winder Motor + */ + HARDWARE_PID_CONTROL_TYPE__MotorWinder = 13, + /* + *Dispenser 1 + */ + HARDWARE_PID_CONTROL_TYPE__Dispenser1 = 14, + /* + *Dispenser 2 + */ + HARDWARE_PID_CONTROL_TYPE__Dispenser2 = 15, + /* + *Dispenser 3 + */ + HARDWARE_PID_CONTROL_TYPE__Dispenser3 = 16, + /* + *Dispenser 4 + */ + HARDWARE_PID_CONTROL_TYPE__Dispenser4 = 17, + /* + *Dispenser 5 + */ + HARDWARE_PID_CONTROL_TYPE__Dispenser5 = 18, + /* + *Dispenser 6 + */ + HARDWARE_PID_CONTROL_TYPE__Dispenser6 = 19, + /* + *Dispenser 7 + */ + HARDWARE_PID_CONTROL_TYPE__Dispenser7 = 20, + /* + *Dispenser 8 + */ + HARDWARE_PID_CONTROL_TYPE__Dispenser8 = 21 PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(HARDWARE_PID_CONTROL_TYPE) } HardwarePidControlType; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareSpeedSensor.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareSpeedSensor.pb-c.c new file mode 100644 index 000000000..a0f34fe31 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareSpeedSensor.pb-c.c @@ -0,0 +1,118 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: HardwareSpeedSensor.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "HardwareSpeedSensor.pb-c.h" +void hardware_speed_sensor__init + (HardwareSpeedSensor *message) +{ + static const HardwareSpeedSensor init_value = HARDWARE_SPEED_SENSOR__INIT; + *message = init_value; +} +size_t hardware_speed_sensor__get_packed_size + (const HardwareSpeedSensor *message) +{ + assert(message->base.descriptor == &hardware_speed_sensor__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t hardware_speed_sensor__pack + (const HardwareSpeedSensor *message, + uint8_t *out) +{ + assert(message->base.descriptor == &hardware_speed_sensor__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t hardware_speed_sensor__pack_to_buffer + (const HardwareSpeedSensor *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &hardware_speed_sensor__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +HardwareSpeedSensor * + hardware_speed_sensor__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (HardwareSpeedSensor *) + protobuf_c_message_unpack (&hardware_speed_sensor__descriptor, + allocator, len, data); +} +void hardware_speed_sensor__free_unpacked + (HardwareSpeedSensor *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &hardware_speed_sensor__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor hardware_speed_sensor__field_descriptors[3] = +{ + { + "HardwareSpeedSensorType", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_ENUM, + offsetof(HardwareSpeedSensor, has_hardwarespeedsensortype), + offsetof(HardwareSpeedSensor, hardwarespeedsensortype), + &hardware_speed_sensor_type__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ResolutionBits", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + offsetof(HardwareSpeedSensor, has_resolutionbits), + offsetof(HardwareSpeedSensor, resolutionbits), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Perimeter", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_DOUBLE, + offsetof(HardwareSpeedSensor, has_perimeter), + offsetof(HardwareSpeedSensor, perimeter), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned hardware_speed_sensor__field_indices_by_name[] = { + 0, /* field[0] = HardwareSpeedSensorType */ + 2, /* field[2] = Perimeter */ + 1, /* field[1] = ResolutionBits */ +}; +static const ProtobufCIntRange hardware_speed_sensor__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor hardware_speed_sensor__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "HardwareSpeedSensor", + "HardwareSpeedSensor", + "HardwareSpeedSensor", + "", + sizeof(HardwareSpeedSensor), + 3, + hardware_speed_sensor__field_descriptors, + hardware_speed_sensor__field_indices_by_name, + 1, hardware_speed_sensor__number_ranges, + (ProtobufCMessageInit) hardware_speed_sensor__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareSpeedSensor.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareSpeedSensor.pb-c.h new file mode 100644 index 000000000..8c46e86c0 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareSpeedSensor.pb-c.h @@ -0,0 +1,77 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: HardwareSpeedSensor.proto */ + +#ifndef PROTOBUF_C_HardwareSpeedSensor_2eproto__INCLUDED +#define PROTOBUF_C_HardwareSpeedSensor_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 "HardwareSpeedSensorType.pb-c.h" + +typedef struct _HardwareSpeedSensor HardwareSpeedSensor; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _HardwareSpeedSensor +{ + ProtobufCMessage base; + protobuf_c_boolean has_hardwarespeedsensortype; + HardwareSpeedSensorType hardwarespeedsensortype; + protobuf_c_boolean has_resolutionbits; + int32_t resolutionbits; + protobuf_c_boolean has_perimeter; + double perimeter; +}; +#define HARDWARE_SPEED_SENSOR__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&hardware_speed_sensor__descriptor) \ + , 0, HARDWARE_SPEED_SENSOR_TYPE__DefaultSpeedSensor, 0, 0, 0, 0 } + + +/* HardwareSpeedSensor methods */ +void hardware_speed_sensor__init + (HardwareSpeedSensor *message); +size_t hardware_speed_sensor__get_packed_size + (const HardwareSpeedSensor *message); +size_t hardware_speed_sensor__pack + (const HardwareSpeedSensor *message, + uint8_t *out); +size_t hardware_speed_sensor__pack_to_buffer + (const HardwareSpeedSensor *message, + ProtobufCBuffer *buffer); +HardwareSpeedSensor * + hardware_speed_sensor__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void hardware_speed_sensor__free_unpacked + (HardwareSpeedSensor *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*HardwareSpeedSensor_Closure) + (const HardwareSpeedSensor *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor hardware_speed_sensor__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_HardwareSpeedSensor_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareSpeedSensorType.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareSpeedSensorType.pb-c.c new file mode 100644 index 000000000..20c66aff3 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareSpeedSensorType.pb-c.c @@ -0,0 +1,35 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: HardwareSpeedSensorType.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "HardwareSpeedSensorType.pb-c.h" +static const ProtobufCEnumValue hardware_speed_sensor_type__enum_values_by_number[1] = +{ + { "DefaultSpeedSensor", "HARDWARE_SPEED_SENSOR_TYPE__DefaultSpeedSensor", 0 }, +}; +static const ProtobufCIntRange hardware_speed_sensor_type__value_ranges[] = { +{0, 0},{0, 1} +}; +static const ProtobufCEnumValueIndex hardware_speed_sensor_type__enum_values_by_name[1] = +{ + { "DefaultSpeedSensor", 0 }, +}; +const ProtobufCEnumDescriptor hardware_speed_sensor_type__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "HardwareSpeedSensorType", + "HardwareSpeedSensorType", + "HardwareSpeedSensorType", + "", + 1, + hardware_speed_sensor_type__enum_values_by_number, + 1, + hardware_speed_sensor_type__enum_values_by_name, + 1, + hardware_speed_sensor_type__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareSpeedSensorType.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareSpeedSensorType.pb-c.h new file mode 100644 index 000000000..567c2246e --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareSpeedSensorType.pb-c.h @@ -0,0 +1,45 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: HardwareSpeedSensorType.proto */ + +#ifndef PROTOBUF_C_HardwareSpeedSensorType_2eproto__INCLUDED +#define PROTOBUF_C_HardwareSpeedSensorType_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 _HardwareSpeedSensorType { + /* + *Default Speed Sensor + */ + HARDWARE_SPEED_SENSOR_TYPE__DefaultSpeedSensor = 0 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(HARDWARE_SPEED_SENSOR_TYPE) +} HardwareSpeedSensorType; + +/* --- messages --- */ + +/* --- per-message closures --- */ + + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCEnumDescriptor hardware_speed_sensor_type__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_HardwareSpeedSensorType_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareWinderType.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareWinderType.pb-c.h index 952c9ea12..2acabb018 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareWinderType.pb-c.h +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/HardwareWinderType.pb-c.h @@ -20,6 +20,9 @@ PROTOBUF_C__BEGIN_DECLS /* --- enums --- */ typedef enum _HardwareWinderType { + /* + *Internal Winder + */ HARDWARE_WINDER_TYPE__InternalWinder = 0 PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(HARDWARE_WINDER_TYPE) } HardwareWinderType; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/SystemResetRequest.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/SystemResetRequest.pb-c.c new file mode 100644 index 000000000..f33ad9db6 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/SystemResetRequest.pb-c.c @@ -0,0 +1,72 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: SystemResetRequest.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "SystemResetRequest.pb-c.h" +void system_reset_request__init + (SystemResetRequest *message) +{ + static const SystemResetRequest init_value = SYSTEM_RESET_REQUEST__INIT; + *message = init_value; +} +size_t system_reset_request__get_packed_size + (const SystemResetRequest *message) +{ + assert(message->base.descriptor == &system_reset_request__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t system_reset_request__pack + (const SystemResetRequest *message, + uint8_t *out) +{ + assert(message->base.descriptor == &system_reset_request__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t system_reset_request__pack_to_buffer + (const SystemResetRequest *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &system_reset_request__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +SystemResetRequest * + system_reset_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (SystemResetRequest *) + protobuf_c_message_unpack (&system_reset_request__descriptor, + allocator, len, data); +} +void system_reset_request__free_unpacked + (SystemResetRequest *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &system_reset_request__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +#define system_reset_request__field_descriptors NULL +#define system_reset_request__field_indices_by_name NULL +#define system_reset_request__number_ranges NULL +const ProtobufCMessageDescriptor system_reset_request__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "SystemResetRequest", + "SystemResetRequest", + "SystemResetRequest", + "", + sizeof(SystemResetRequest), + 0, + system_reset_request__field_descriptors, + system_reset_request__field_indices_by_name, + 0, system_reset_request__number_ranges, + (ProtobufCMessageInit) system_reset_request__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/SystemResetRequest.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/SystemResetRequest.pb-c.h new file mode 100644 index 000000000..80cac34d3 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/SystemResetRequest.pb-c.h @@ -0,0 +1,70 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: SystemResetRequest.proto */ + +#ifndef PROTOBUF_C_SystemResetRequest_2eproto__INCLUDED +#define PROTOBUF_C_SystemResetRequest_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 _SystemResetRequest SystemResetRequest; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _SystemResetRequest +{ + ProtobufCMessage base; +}; +#define SYSTEM_RESET_REQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&system_reset_request__descriptor) \ + } + + +/* SystemResetRequest methods */ +void system_reset_request__init + (SystemResetRequest *message); +size_t system_reset_request__get_packed_size + (const SystemResetRequest *message); +size_t system_reset_request__pack + (const SystemResetRequest *message, + uint8_t *out); +size_t system_reset_request__pack_to_buffer + (const SystemResetRequest *message, + ProtobufCBuffer *buffer); +SystemResetRequest * + system_reset_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void system_reset_request__free_unpacked + (SystemResetRequest *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*SystemResetRequest_Closure) + (const SystemResetRequest *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor system_reset_request__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_SystemResetRequest_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/SystemResetResponse.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/SystemResetResponse.pb-c.c new file mode 100644 index 000000000..71962b031 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/SystemResetResponse.pb-c.c @@ -0,0 +1,72 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: SystemResetResponse.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "SystemResetResponse.pb-c.h" +void system_reset_response__init + (SystemResetResponse *message) +{ + static const SystemResetResponse init_value = SYSTEM_RESET_RESPONSE__INIT; + *message = init_value; +} +size_t system_reset_response__get_packed_size + (const SystemResetResponse *message) +{ + assert(message->base.descriptor == &system_reset_response__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t system_reset_response__pack + (const SystemResetResponse *message, + uint8_t *out) +{ + assert(message->base.descriptor == &system_reset_response__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t system_reset_response__pack_to_buffer + (const SystemResetResponse *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &system_reset_response__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +SystemResetResponse * + system_reset_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (SystemResetResponse *) + protobuf_c_message_unpack (&system_reset_response__descriptor, + allocator, len, data); +} +void system_reset_response__free_unpacked + (SystemResetResponse *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &system_reset_response__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +#define system_reset_response__field_descriptors NULL +#define system_reset_response__field_indices_by_name NULL +#define system_reset_response__number_ranges NULL +const ProtobufCMessageDescriptor system_reset_response__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "SystemResetResponse", + "SystemResetResponse", + "SystemResetResponse", + "", + sizeof(SystemResetResponse), + 0, + system_reset_response__field_descriptors, + system_reset_response__field_indices_by_name, + 0, system_reset_response__number_ranges, + (ProtobufCMessageInit) system_reset_response__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/SystemResetResponse.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/SystemResetResponse.pb-c.h new file mode 100644 index 000000000..f8d035096 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Hardware/SystemResetResponse.pb-c.h @@ -0,0 +1,70 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: SystemResetResponse.proto */ + +#ifndef PROTOBUF_C_SystemResetResponse_2eproto__INCLUDED +#define PROTOBUF_C_SystemResetResponse_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 _SystemResetResponse SystemResetResponse; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _SystemResetResponse +{ + ProtobufCMessage base; +}; +#define SYSTEM_RESET_RESPONSE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&system_reset_response__descriptor) \ + } + + +/* SystemResetResponse methods */ +void system_reset_response__init + (SystemResetResponse *message); +size_t system_reset_response__get_packed_size + (const SystemResetResponse *message); +size_t system_reset_response__pack + (const SystemResetResponse *message, + uint8_t *out); +size_t system_reset_response__pack_to_buffer + (const SystemResetResponse *message, + ProtobufCBuffer *buffer); +SystemResetResponse * + system_reset_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void system_reset_response__free_unpacked + (SystemResetResponse *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*SystemResetResponse_Closure) + (const SystemResetResponse *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor system_reset_response__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_SystemResetResponse_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/IO/ExecuteProcessRequest.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/IO/ExecuteProcessRequest.pb-c.c new file mode 100644 index 000000000..a9c8d5f1b --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/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/Code_Composer/twine_usblib_demo/PMR/IO/ExecuteProcessRequest.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/IO/ExecuteProcessRequest.pb-c.h new file mode 100644 index 000000000..b8afe6331 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/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/Code_Composer/twine_usblib_demo/PMR/IO/ExecuteProcessResponse.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/IO/ExecuteProcessResponse.pb-c.c new file mode 100644 index 000000000..95799299c --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/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/Code_Composer/twine_usblib_demo/PMR/IO/ExecuteProcessResponse.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/IO/ExecuteProcessResponse.pb-c.h new file mode 100644 index 000000000..cb3fd586b --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/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/Code_Composer/twine_usblib_demo/PMR/IO/FileChunkUploadRequest.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/IO/FileChunkUploadRequest.pb-c.c new file mode 100644 index 000000000..a4ca27f4f --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/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/Code_Composer/twine_usblib_demo/PMR/IO/FileChunkUploadRequest.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/IO/FileChunkUploadRequest.pb-c.h new file mode 100644 index 000000000..5b084a772 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/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/Code_Composer/twine_usblib_demo/PMR/IO/FileChunkUploadResponse.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/IO/FileChunkUploadResponse.pb-c.c new file mode 100644 index 000000000..453421e03 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/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/Code_Composer/twine_usblib_demo/PMR/IO/FileChunkUploadResponse.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/IO/FileChunkUploadResponse.pb-c.h new file mode 100644 index 000000000..82e95302e --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/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/Code_Composer/twine_usblib_demo/PMR/IO/FileUploadRequest.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/IO/FileUploadRequest.pb-c.c new file mode 100644 index 000000000..4b17c92ed --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/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/Code_Composer/twine_usblib_demo/PMR/IO/FileUploadRequest.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/IO/FileUploadRequest.pb-c.h new file mode 100644 index 000000000..c4b936d12 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/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/Code_Composer/twine_usblib_demo/PMR/IO/FileUploadResponse.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/IO/FileUploadResponse.pb-c.c new file mode 100644 index 000000000..bb7cf5cb7 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/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/Code_Composer/twine_usblib_demo/PMR/IO/FileUploadResponse.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/IO/FileUploadResponse.pb-c.h new file mode 100644 index 000000000..a26abf41f --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/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/Code_Composer/twine_usblib_demo/PMR/IO/KillProcessRequest.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/IO/KillProcessRequest.pb-c.c new file mode 100644 index 000000000..a36b94f4a --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/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/Code_Composer/twine_usblib_demo/PMR/IO/KillProcessRequest.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/IO/KillProcessRequest.pb-c.h new file mode 100644 index 000000000..3782ebff3 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/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/Code_Composer/twine_usblib_demo/PMR/IO/KillProcessResponse.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/IO/KillProcessResponse.pb-c.c new file mode 100644 index 000000000..cf2f046fa --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/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/Code_Composer/twine_usblib_demo/PMR/IO/KillProcessResponse.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/IO/KillProcessResponse.pb-c.h new file mode 100644 index 000000000..9fc47c640 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/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/Code_Composer/twine_usblib_demo/PMR/Printing/JobSpool.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Printing/JobSpool.pb-c.c index 329c9e701..b7a7d8126 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Printing/JobSpool.pb-c.c +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Printing/JobSpool.pb-c.c @@ -52,7 +52,7 @@ void job_spool__free_unpacked assert(message->base.descriptor == &job_spool__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -static const ProtobufCFieldDescriptor job_spool__field_descriptors[7] = +static const ProtobufCFieldDescriptor job_spool__field_descriptors[9] = { { "JobSpoolType", @@ -138,12 +138,38 @@ static const ProtobufCFieldDescriptor job_spool__field_descriptors[7] = 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, + { + "BottomBackingRate", + 8, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + offsetof(JobSpool, has_bottombackingrate), + offsetof(JobSpool, bottombackingrate), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "RotationsPerPassage", + 9, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_DOUBLE, + offsetof(JobSpool, has_rotationsperpassage), + offsetof(JobSpool, rotationsperpassage), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, }; static const unsigned job_spool__field_indices_by_name[] = { 5, /* field[5] = BackingRate */ + 7, /* field[7] = BottomBackingRate */ 3, /* field[3] = Diameter */ 0, /* field[0] = JobSpoolType */ 1, /* field[1] = Length */ + 8, /* field[8] = RotationsPerPassage */ 6, /* field[6] = SegmentOffsetPulses */ 4, /* field[4] = StartOffsetPulses */ 2, /* field[2] = Weight */ @@ -151,7 +177,7 @@ static const unsigned job_spool__field_indices_by_name[] = { static const ProtobufCIntRange job_spool__number_ranges[1 + 1] = { { 1, 0 }, - { 0, 7 } + { 0, 9 } }; const ProtobufCMessageDescriptor job_spool__descriptor = { @@ -161,7 +187,7 @@ const ProtobufCMessageDescriptor job_spool__descriptor = "JobSpool", "", sizeof(JobSpool), - 7, + 9, job_spool__field_descriptors, job_spool__field_indices_by_name, 1, job_spool__number_ranges, diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Printing/JobSpool.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Printing/JobSpool.pb-c.h index 38e9236ce..87c391207 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Printing/JobSpool.pb-c.h +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Printing/JobSpool.pb-c.h @@ -41,10 +41,14 @@ struct _JobSpool int32_t backingrate; protobuf_c_boolean has_segmentoffsetpulses; int32_t segmentoffsetpulses; + protobuf_c_boolean has_bottombackingrate; + int32_t bottombackingrate; + protobuf_c_boolean has_rotationsperpassage; + double rotationsperpassage; }; #define JOB_SPOOL__INIT \ { PROTOBUF_C_MESSAGE_INIT (&job_spool__descriptor) \ - , 0, JOB_SPOOL_TYPE__StandardSpool, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } + , 0, JOB_SPOOL_TYPE__StandardSpool, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } /* JobSpool methods */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Printing/JobWindingMethod.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Printing/JobWindingMethod.pb-c.h index a762ae2c5..d3bac5cb2 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Printing/JobWindingMethod.pb-c.h +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Printing/JobWindingMethod.pb-c.h @@ -20,7 +20,13 @@ PROTOBUF_C__BEGIN_DECLS /* --- enums --- */ typedef enum _JobWindingMethod { + /* + *Embroidery Winding + */ JOB_WINDING_METHOD__Embroidery = 0, + /* + *Calibration Winding + */ JOB_WINDING_METHOD__Calibration = 1 PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(JOB_WINDING_METHOD) } JobWindingMethod; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubDancerPositionRequest.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubDancerPositionRequest.pb-c.c new file mode 100644 index 000000000..332208da1 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubDancerPositionRequest.pb-c.c @@ -0,0 +1,92 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubDancerPositionRequest.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StubDancerPositionRequest.pb-c.h" +void stub_dancer_position_request__init + (StubDancerPositionRequest *message) +{ + static const StubDancerPositionRequest init_value = STUB_DANCER_POSITION_REQUEST__INIT; + *message = init_value; +} +size_t stub_dancer_position_request__get_packed_size + (const StubDancerPositionRequest *message) +{ + assert(message->base.descriptor == &stub_dancer_position_request__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stub_dancer_position_request__pack + (const StubDancerPositionRequest *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stub_dancer_position_request__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stub_dancer_position_request__pack_to_buffer + (const StubDancerPositionRequest *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stub_dancer_position_request__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StubDancerPositionRequest * + stub_dancer_position_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StubDancerPositionRequest *) + protobuf_c_message_unpack (&stub_dancer_position_request__descriptor, + allocator, len, data); +} +void stub_dancer_position_request__free_unpacked + (StubDancerPositionRequest *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stub_dancer_position_request__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor stub_dancer_position_request__field_descriptors[1] = +{ + { + "Dancer_ID", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubDancerPositionRequest, has_dancer_id), + offsetof(StubDancerPositionRequest, dancer_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned stub_dancer_position_request__field_indices_by_name[] = { + 0, /* field[0] = Dancer_ID */ +}; +static const ProtobufCIntRange stub_dancer_position_request__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor stub_dancer_position_request__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StubDancerPositionRequest", + "StubDancerPositionRequest", + "StubDancerPositionRequest", + "", + sizeof(StubDancerPositionRequest), + 1, + stub_dancer_position_request__field_descriptors, + stub_dancer_position_request__field_indices_by_name, + 1, stub_dancer_position_request__number_ranges, + (ProtobufCMessageInit) stub_dancer_position_request__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubDancerPositionRequest.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubDancerPositionRequest.pb-c.h new file mode 100644 index 000000000..f7937b782 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubDancerPositionRequest.pb-c.h @@ -0,0 +1,72 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubDancerPositionRequest.proto */ + +#ifndef PROTOBUF_C_StubDancerPositionRequest_2eproto__INCLUDED +#define PROTOBUF_C_StubDancerPositionRequest_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 _StubDancerPositionRequest StubDancerPositionRequest; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StubDancerPositionRequest +{ + ProtobufCMessage base; + protobuf_c_boolean has_dancer_id; + uint32_t dancer_id; +}; +#define STUB_DANCER_POSITION_REQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stub_dancer_position_request__descriptor) \ + , 0, 0 } + + +/* StubDancerPositionRequest methods */ +void stub_dancer_position_request__init + (StubDancerPositionRequest *message); +size_t stub_dancer_position_request__get_packed_size + (const StubDancerPositionRequest *message); +size_t stub_dancer_position_request__pack + (const StubDancerPositionRequest *message, + uint8_t *out); +size_t stub_dancer_position_request__pack_to_buffer + (const StubDancerPositionRequest *message, + ProtobufCBuffer *buffer); +StubDancerPositionRequest * + stub_dancer_position_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stub_dancer_position_request__free_unpacked + (StubDancerPositionRequest *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StubDancerPositionRequest_Closure) + (const StubDancerPositionRequest *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stub_dancer_position_request__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StubDancerPositionRequest_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubDancerPositionResponse.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubDancerPositionResponse.pb-c.c new file mode 100644 index 000000000..5dfb74a1a --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubDancerPositionResponse.pb-c.c @@ -0,0 +1,131 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubDancerPositionResponse.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StubDancerPositionResponse.pb-c.h" +void stub_dancer_position_response__init + (StubDancerPositionResponse *message) +{ + static const StubDancerPositionResponse init_value = STUB_DANCER_POSITION_RESPONSE__INIT; + *message = init_value; +} +size_t stub_dancer_position_response__get_packed_size + (const StubDancerPositionResponse *message) +{ + assert(message->base.descriptor == &stub_dancer_position_response__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stub_dancer_position_response__pack + (const StubDancerPositionResponse *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stub_dancer_position_response__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stub_dancer_position_response__pack_to_buffer + (const StubDancerPositionResponse *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stub_dancer_position_response__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StubDancerPositionResponse * + stub_dancer_position_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StubDancerPositionResponse *) + protobuf_c_message_unpack (&stub_dancer_position_response__descriptor, + allocator, len, data); +} +void stub_dancer_position_response__free_unpacked + (StubDancerPositionResponse *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stub_dancer_position_response__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor stub_dancer_position_response__field_descriptors[4] = +{ + { + "Dancer_ID", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubDancerPositionResponse, has_dancer_id), + offsetof(StubDancerPositionResponse, dancer_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Position", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubDancerPositionResponse, has_position), + offsetof(StubDancerPositionResponse, position), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "General_Status", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubDancerPositionResponse, has_general_status), + offsetof(StubDancerPositionResponse, general_status), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Detailed_Status", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubDancerPositionResponse, has_detailed_status), + offsetof(StubDancerPositionResponse, detailed_status), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned stub_dancer_position_response__field_indices_by_name[] = { + 0, /* field[0] = Dancer_ID */ + 3, /* field[3] = Detailed_Status */ + 2, /* field[2] = General_Status */ + 1, /* field[1] = Position */ +}; +static const ProtobufCIntRange stub_dancer_position_response__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor stub_dancer_position_response__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StubDancerPositionResponse", + "StubDancerPositionResponse", + "StubDancerPositionResponse", + "", + sizeof(StubDancerPositionResponse), + 4, + stub_dancer_position_response__field_descriptors, + stub_dancer_position_response__field_indices_by_name, + 1, stub_dancer_position_response__number_ranges, + (ProtobufCMessageInit) stub_dancer_position_response__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubDancerPositionResponse.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubDancerPositionResponse.pb-c.h new file mode 100644 index 000000000..6e8803cd3 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubDancerPositionResponse.pb-c.h @@ -0,0 +1,78 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubDancerPositionResponse.proto */ + +#ifndef PROTOBUF_C_StubDancerPositionResponse_2eproto__INCLUDED +#define PROTOBUF_C_StubDancerPositionResponse_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 _StubDancerPositionResponse StubDancerPositionResponse; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StubDancerPositionResponse +{ + ProtobufCMessage base; + protobuf_c_boolean has_dancer_id; + uint32_t dancer_id; + protobuf_c_boolean has_position; + uint32_t position; + protobuf_c_boolean has_general_status; + uint32_t general_status; + protobuf_c_boolean has_detailed_status; + uint32_t detailed_status; +}; +#define STUB_DANCER_POSITION_RESPONSE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stub_dancer_position_response__descriptor) \ + , 0, 0, 0, 0, 0, 0, 0, 0 } + + +/* StubDancerPositionResponse methods */ +void stub_dancer_position_response__init + (StubDancerPositionResponse *message); +size_t stub_dancer_position_response__get_packed_size + (const StubDancerPositionResponse *message); +size_t stub_dancer_position_response__pack + (const StubDancerPositionResponse *message, + uint8_t *out); +size_t stub_dancer_position_response__pack_to_buffer + (const StubDancerPositionResponse *message, + ProtobufCBuffer *buffer); +StubDancerPositionResponse * + stub_dancer_position_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stub_dancer_position_response__free_unpacked + (StubDancerPositionResponse *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StubDancerPositionResponse_Closure) + (const StubDancerPositionResponse *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stub_dancer_position_response__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StubDancerPositionResponse_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubFpgaReadRegRequest.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubFpgaReadRegRequest.pb-c.c new file mode 100644 index 000000000..01e5051ea --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubFpgaReadRegRequest.pb-c.c @@ -0,0 +1,92 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubFpgaReadRegRequest.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StubFpgaReadRegRequest.pb-c.h" +void stub_fpga_read_reg_request__init + (StubFpgaReadRegRequest *message) +{ + static const StubFpgaReadRegRequest init_value = STUB_FPGA_READ_REG_REQUEST__INIT; + *message = init_value; +} +size_t stub_fpga_read_reg_request__get_packed_size + (const StubFpgaReadRegRequest *message) +{ + assert(message->base.descriptor == &stub_fpga_read_reg_request__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stub_fpga_read_reg_request__pack + (const StubFpgaReadRegRequest *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stub_fpga_read_reg_request__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stub_fpga_read_reg_request__pack_to_buffer + (const StubFpgaReadRegRequest *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stub_fpga_read_reg_request__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StubFpgaReadRegRequest * + stub_fpga_read_reg_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StubFpgaReadRegRequest *) + protobuf_c_message_unpack (&stub_fpga_read_reg_request__descriptor, + allocator, len, data); +} +void stub_fpga_read_reg_request__free_unpacked + (StubFpgaReadRegRequest *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stub_fpga_read_reg_request__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor stub_fpga_read_reg_request__field_descriptors[1] = +{ + { + "Address", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubFpgaReadRegRequest, has_address), + offsetof(StubFpgaReadRegRequest, address), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned stub_fpga_read_reg_request__field_indices_by_name[] = { + 0, /* field[0] = Address */ +}; +static const ProtobufCIntRange stub_fpga_read_reg_request__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor stub_fpga_read_reg_request__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StubFpgaReadRegRequest", + "StubFpgaReadRegRequest", + "StubFpgaReadRegRequest", + "", + sizeof(StubFpgaReadRegRequest), + 1, + stub_fpga_read_reg_request__field_descriptors, + stub_fpga_read_reg_request__field_indices_by_name, + 1, stub_fpga_read_reg_request__number_ranges, + (ProtobufCMessageInit) stub_fpga_read_reg_request__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubFpgaReadRegRequest.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubFpgaReadRegRequest.pb-c.h new file mode 100644 index 000000000..f3fbd1080 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubFpgaReadRegRequest.pb-c.h @@ -0,0 +1,72 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubFpgaReadRegRequest.proto */ + +#ifndef PROTOBUF_C_StubFpgaReadRegRequest_2eproto__INCLUDED +#define PROTOBUF_C_StubFpgaReadRegRequest_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 _StubFpgaReadRegRequest StubFpgaReadRegRequest; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StubFpgaReadRegRequest +{ + ProtobufCMessage base; + protobuf_c_boolean has_address; + uint32_t address; +}; +#define STUB_FPGA_READ_REG_REQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stub_fpga_read_reg_request__descriptor) \ + , 0, 0 } + + +/* StubFpgaReadRegRequest methods */ +void stub_fpga_read_reg_request__init + (StubFpgaReadRegRequest *message); +size_t stub_fpga_read_reg_request__get_packed_size + (const StubFpgaReadRegRequest *message); +size_t stub_fpga_read_reg_request__pack + (const StubFpgaReadRegRequest *message, + uint8_t *out); +size_t stub_fpga_read_reg_request__pack_to_buffer + (const StubFpgaReadRegRequest *message, + ProtobufCBuffer *buffer); +StubFpgaReadRegRequest * + stub_fpga_read_reg_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stub_fpga_read_reg_request__free_unpacked + (StubFpgaReadRegRequest *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StubFpgaReadRegRequest_Closure) + (const StubFpgaReadRegRequest *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stub_fpga_read_reg_request__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StubFpgaReadRegRequest_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubFpgaReadRegResponse.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubFpgaReadRegResponse.pb-c.c new file mode 100644 index 000000000..a6f64fe0e --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubFpgaReadRegResponse.pb-c.c @@ -0,0 +1,131 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubFpgaReadRegResponse.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StubFpgaReadRegResponse.pb-c.h" +void stub_fpga_read_reg_response__init + (StubFpgaReadRegResponse *message) +{ + static const StubFpgaReadRegResponse init_value = STUB_FPGA_READ_REG_RESPONSE__INIT; + *message = init_value; +} +size_t stub_fpga_read_reg_response__get_packed_size + (const StubFpgaReadRegResponse *message) +{ + assert(message->base.descriptor == &stub_fpga_read_reg_response__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stub_fpga_read_reg_response__pack + (const StubFpgaReadRegResponse *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stub_fpga_read_reg_response__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stub_fpga_read_reg_response__pack_to_buffer + (const StubFpgaReadRegResponse *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stub_fpga_read_reg_response__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StubFpgaReadRegResponse * + stub_fpga_read_reg_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StubFpgaReadRegResponse *) + protobuf_c_message_unpack (&stub_fpga_read_reg_response__descriptor, + allocator, len, data); +} +void stub_fpga_read_reg_response__free_unpacked + (StubFpgaReadRegResponse *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stub_fpga_read_reg_response__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor stub_fpga_read_reg_response__field_descriptors[4] = +{ + { + "Address", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubFpgaReadRegResponse, has_address), + offsetof(StubFpgaReadRegResponse, address), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Value", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubFpgaReadRegResponse, has_value), + offsetof(StubFpgaReadRegResponse, value), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Status", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(StubFpgaReadRegResponse, status), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "StatusWord", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubFpgaReadRegResponse, has_statusword), + offsetof(StubFpgaReadRegResponse, statusword), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned stub_fpga_read_reg_response__field_indices_by_name[] = { + 0, /* field[0] = Address */ + 2, /* field[2] = Status */ + 3, /* field[3] = StatusWord */ + 1, /* field[1] = Value */ +}; +static const ProtobufCIntRange stub_fpga_read_reg_response__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor stub_fpga_read_reg_response__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StubFpgaReadRegResponse", + "StubFpgaReadRegResponse", + "StubFpgaReadRegResponse", + "", + sizeof(StubFpgaReadRegResponse), + 4, + stub_fpga_read_reg_response__field_descriptors, + stub_fpga_read_reg_response__field_indices_by_name, + 1, stub_fpga_read_reg_response__number_ranges, + (ProtobufCMessageInit) stub_fpga_read_reg_response__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubFpgaReadRegResponse.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubFpgaReadRegResponse.pb-c.h new file mode 100644 index 000000000..caae94515 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubFpgaReadRegResponse.pb-c.h @@ -0,0 +1,83 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubFpgaReadRegResponse.proto */ + +#ifndef PROTOBUF_C_StubFpgaReadRegResponse_2eproto__INCLUDED +#define PROTOBUF_C_StubFpgaReadRegResponse_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 _StubFpgaReadRegResponse StubFpgaReadRegResponse; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StubFpgaReadRegResponse +{ + ProtobufCMessage base; + protobuf_c_boolean has_address; + uint32_t address; + protobuf_c_boolean has_value; + uint32_t value; + /* + * Passed/Failed + */ + char *status; + /* + * Error number/bit when the status is Failed + */ + protobuf_c_boolean has_statusword; + uint32_t statusword; +}; +#define STUB_FPGA_READ_REG_RESPONSE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stub_fpga_read_reg_response__descriptor) \ + , 0, 0, 0, 0, NULL, 0, 0 } + + +/* StubFpgaReadRegResponse methods */ +void stub_fpga_read_reg_response__init + (StubFpgaReadRegResponse *message); +size_t stub_fpga_read_reg_response__get_packed_size + (const StubFpgaReadRegResponse *message); +size_t stub_fpga_read_reg_response__pack + (const StubFpgaReadRegResponse *message, + uint8_t *out); +size_t stub_fpga_read_reg_response__pack_to_buffer + (const StubFpgaReadRegResponse *message, + ProtobufCBuffer *buffer); +StubFpgaReadRegResponse * + stub_fpga_read_reg_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stub_fpga_read_reg_response__free_unpacked + (StubFpgaReadRegResponse *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StubFpgaReadRegResponse_Closure) + (const StubFpgaReadRegResponse *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stub_fpga_read_reg_response__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StubFpgaReadRegResponse_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubFpgaWriteRegRequest.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubFpgaWriteRegRequest.pb-c.c new file mode 100644 index 000000000..ca32b9094 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubFpgaWriteRegRequest.pb-c.c @@ -0,0 +1,105 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubFpgaWriteRegRequest.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StubFpgaWriteRegRequest.pb-c.h" +void stub_fpga_write_reg_request__init + (StubFpgaWriteRegRequest *message) +{ + static const StubFpgaWriteRegRequest init_value = STUB_FPGA_WRITE_REG_REQUEST__INIT; + *message = init_value; +} +size_t stub_fpga_write_reg_request__get_packed_size + (const StubFpgaWriteRegRequest *message) +{ + assert(message->base.descriptor == &stub_fpga_write_reg_request__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stub_fpga_write_reg_request__pack + (const StubFpgaWriteRegRequest *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stub_fpga_write_reg_request__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stub_fpga_write_reg_request__pack_to_buffer + (const StubFpgaWriteRegRequest *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stub_fpga_write_reg_request__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StubFpgaWriteRegRequest * + stub_fpga_write_reg_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StubFpgaWriteRegRequest *) + protobuf_c_message_unpack (&stub_fpga_write_reg_request__descriptor, + allocator, len, data); +} +void stub_fpga_write_reg_request__free_unpacked + (StubFpgaWriteRegRequest *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stub_fpga_write_reg_request__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor stub_fpga_write_reg_request__field_descriptors[2] = +{ + { + "Address", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubFpgaWriteRegRequest, has_address), + offsetof(StubFpgaWriteRegRequest, address), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Value", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubFpgaWriteRegRequest, has_value), + offsetof(StubFpgaWriteRegRequest, value), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned stub_fpga_write_reg_request__field_indices_by_name[] = { + 0, /* field[0] = Address */ + 1, /* field[1] = Value */ +}; +static const ProtobufCIntRange stub_fpga_write_reg_request__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor stub_fpga_write_reg_request__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StubFpgaWriteRegRequest", + "StubFpgaWriteRegRequest", + "StubFpgaWriteRegRequest", + "", + sizeof(StubFpgaWriteRegRequest), + 2, + stub_fpga_write_reg_request__field_descriptors, + stub_fpga_write_reg_request__field_indices_by_name, + 1, stub_fpga_write_reg_request__number_ranges, + (ProtobufCMessageInit) stub_fpga_write_reg_request__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubFpgaWriteRegRequest.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubFpgaWriteRegRequest.pb-c.h new file mode 100644 index 000000000..69d559cde --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubFpgaWriteRegRequest.pb-c.h @@ -0,0 +1,74 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubFpgaWriteRegRequest.proto */ + +#ifndef PROTOBUF_C_StubFpgaWriteRegRequest_2eproto__INCLUDED +#define PROTOBUF_C_StubFpgaWriteRegRequest_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 _StubFpgaWriteRegRequest StubFpgaWriteRegRequest; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StubFpgaWriteRegRequest +{ + ProtobufCMessage base; + protobuf_c_boolean has_address; + uint32_t address; + protobuf_c_boolean has_value; + uint32_t value; +}; +#define STUB_FPGA_WRITE_REG_REQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stub_fpga_write_reg_request__descriptor) \ + , 0, 0, 0, 0 } + + +/* StubFpgaWriteRegRequest methods */ +void stub_fpga_write_reg_request__init + (StubFpgaWriteRegRequest *message); +size_t stub_fpga_write_reg_request__get_packed_size + (const StubFpgaWriteRegRequest *message); +size_t stub_fpga_write_reg_request__pack + (const StubFpgaWriteRegRequest *message, + uint8_t *out); +size_t stub_fpga_write_reg_request__pack_to_buffer + (const StubFpgaWriteRegRequest *message, + ProtobufCBuffer *buffer); +StubFpgaWriteRegRequest * + stub_fpga_write_reg_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stub_fpga_write_reg_request__free_unpacked + (StubFpgaWriteRegRequest *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StubFpgaWriteRegRequest_Closure) + (const StubFpgaWriteRegRequest *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stub_fpga_write_reg_request__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StubFpgaWriteRegRequest_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubFpgaWriteRegResponse.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubFpgaWriteRegResponse.pb-c.c new file mode 100644 index 000000000..8520b6e78 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubFpgaWriteRegResponse.pb-c.c @@ -0,0 +1,105 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubFpgaWriteRegResponse.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StubFpgaWriteRegResponse.pb-c.h" +void stub_fpga_write_reg_response__init + (StubFpgaWriteRegResponse *message) +{ + static const StubFpgaWriteRegResponse init_value = STUB_FPGA_WRITE_REG_RESPONSE__INIT; + *message = init_value; +} +size_t stub_fpga_write_reg_response__get_packed_size + (const StubFpgaWriteRegResponse *message) +{ + assert(message->base.descriptor == &stub_fpga_write_reg_response__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stub_fpga_write_reg_response__pack + (const StubFpgaWriteRegResponse *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stub_fpga_write_reg_response__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stub_fpga_write_reg_response__pack_to_buffer + (const StubFpgaWriteRegResponse *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stub_fpga_write_reg_response__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StubFpgaWriteRegResponse * + stub_fpga_write_reg_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StubFpgaWriteRegResponse *) + protobuf_c_message_unpack (&stub_fpga_write_reg_response__descriptor, + allocator, len, data); +} +void stub_fpga_write_reg_response__free_unpacked + (StubFpgaWriteRegResponse *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stub_fpga_write_reg_response__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor stub_fpga_write_reg_response__field_descriptors[2] = +{ + { + "Status", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(StubFpgaWriteRegResponse, status), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "StatusWord", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubFpgaWriteRegResponse, has_statusword), + offsetof(StubFpgaWriteRegResponse, statusword), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned stub_fpga_write_reg_response__field_indices_by_name[] = { + 0, /* field[0] = Status */ + 1, /* field[1] = StatusWord */ +}; +static const ProtobufCIntRange stub_fpga_write_reg_response__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor stub_fpga_write_reg_response__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StubFpgaWriteRegResponse", + "StubFpgaWriteRegResponse", + "StubFpgaWriteRegResponse", + "", + sizeof(StubFpgaWriteRegResponse), + 2, + stub_fpga_write_reg_response__field_descriptors, + stub_fpga_write_reg_response__field_indices_by_name, + 1, stub_fpga_write_reg_response__number_ranges, + (ProtobufCMessageInit) stub_fpga_write_reg_response__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubFpgaWriteRegResponse.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubFpgaWriteRegResponse.pb-c.h new file mode 100644 index 000000000..b91dbc426 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubFpgaWriteRegResponse.pb-c.h @@ -0,0 +1,79 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubFpgaWriteRegResponse.proto */ + +#ifndef PROTOBUF_C_StubFpgaWriteRegResponse_2eproto__INCLUDED +#define PROTOBUF_C_StubFpgaWriteRegResponse_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 _StubFpgaWriteRegResponse StubFpgaWriteRegResponse; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StubFpgaWriteRegResponse +{ + ProtobufCMessage base; + /* + * Passed/Failed + */ + char *status; + /* + * Error number/bit when the status is Failed + */ + protobuf_c_boolean has_statusword; + uint32_t statusword; +}; +#define STUB_FPGA_WRITE_REG_RESPONSE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stub_fpga_write_reg_response__descriptor) \ + , NULL, 0, 0 } + + +/* StubFpgaWriteRegResponse methods */ +void stub_fpga_write_reg_response__init + (StubFpgaWriteRegResponse *message); +size_t stub_fpga_write_reg_response__get_packed_size + (const StubFpgaWriteRegResponse *message); +size_t stub_fpga_write_reg_response__pack + (const StubFpgaWriteRegResponse *message, + uint8_t *out); +size_t stub_fpga_write_reg_response__pack_to_buffer + (const StubFpgaWriteRegResponse *message, + ProtobufCBuffer *buffer); +StubFpgaWriteRegResponse * + stub_fpga_write_reg_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stub_fpga_write_reg_response__free_unpacked + (StubFpgaWriteRegResponse *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StubFpgaWriteRegResponse_Closure) + (const StubFpgaWriteRegResponse *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stub_fpga_write_reg_response__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StubFpgaWriteRegResponse_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubHeatingTestPollResponse.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubHeatingTestPollResponse.pb-c.c index 6697b916d..6a6a33409 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubHeatingTestPollResponse.pb-c.c +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubHeatingTestPollResponse.pb-c.c @@ -52,7 +52,7 @@ void stub_heating_test_poll_response__free_unpacked assert(message->base.descriptor == &stub_heating_test_poll_response__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -static const ProtobufCFieldDescriptor stub_heating_test_poll_response__field_descriptors[7] = +static const ProtobufCFieldDescriptor stub_heating_test_poll_response__field_descriptors[8] = { { "HeaterGroupId", @@ -138,6 +138,18 @@ static const ProtobufCFieldDescriptor stub_heating_test_poll_response__field_des 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, + { + "InfoMessage", + 8, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(StubHeatingTestPollResponse, infomessage), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, }; static const unsigned stub_heating_test_poll_response__field_indices_by_name[] = { 3, /* field[3] = Heater1Active */ @@ -145,13 +157,14 @@ static const unsigned stub_heating_test_poll_response__field_indices_by_name[] = 4, /* field[4] = Heater2Active */ 6, /* field[6] = Heater2Percentage */ 0, /* field[0] = HeaterGroupId */ + 7, /* field[7] = InfoMessage */ 1, /* field[1] = Zone1Temp */ 2, /* field[2] = Zone2Temp */ }; static const ProtobufCIntRange stub_heating_test_poll_response__number_ranges[1 + 1] = { { 1, 0 }, - { 0, 7 } + { 0, 8 } }; const ProtobufCMessageDescriptor stub_heating_test_poll_response__descriptor = { @@ -161,7 +174,7 @@ const ProtobufCMessageDescriptor stub_heating_test_poll_response__descriptor = "StubHeatingTestPollResponse", "", sizeof(StubHeatingTestPollResponse), - 7, + 8, stub_heating_test_poll_response__field_descriptors, stub_heating_test_poll_response__field_indices_by_name, 1, stub_heating_test_poll_response__number_ranges, diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubHeatingTestPollResponse.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubHeatingTestPollResponse.pb-c.h index 8cf25d5be..6974a5be8 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubHeatingTestPollResponse.pb-c.h +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubHeatingTestPollResponse.pb-c.h @@ -43,10 +43,11 @@ struct _StubHeatingTestPollResponse uint32_t heater1percentage; protobuf_c_boolean has_heater2percentage; uint32_t heater2percentage; + char *infomessage; }; #define STUB_HEATING_TEST_POLL_RESPONSE__INIT \ { PROTOBUF_C_MESSAGE_INIT (&stub_heating_test_poll_response__descriptor) \ - , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } + , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL } /* StubHeatingTestPollResponse methods */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CReadBytesRequest.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CReadBytesRequest.pb-c.c new file mode 100644 index 000000000..49887924d --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CReadBytesRequest.pb-c.c @@ -0,0 +1,118 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubI2CReadBytesRequest.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StubI2CReadBytesRequest.pb-c.h" +void stub_i2_cread_bytes_request__init + (StubI2CReadBytesRequest *message) +{ + static const StubI2CReadBytesRequest init_value = STUB_I2_CREAD_BYTES_REQUEST__INIT; + *message = init_value; +} +size_t stub_i2_cread_bytes_request__get_packed_size + (const StubI2CReadBytesRequest *message) +{ + assert(message->base.descriptor == &stub_i2_cread_bytes_request__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stub_i2_cread_bytes_request__pack + (const StubI2CReadBytesRequest *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stub_i2_cread_bytes_request__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stub_i2_cread_bytes_request__pack_to_buffer + (const StubI2CReadBytesRequest *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stub_i2_cread_bytes_request__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StubI2CReadBytesRequest * + stub_i2_cread_bytes_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StubI2CReadBytesRequest *) + protobuf_c_message_unpack (&stub_i2_cread_bytes_request__descriptor, + allocator, len, data); +} +void stub_i2_cread_bytes_request__free_unpacked + (StubI2CReadBytesRequest *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stub_i2_cread_bytes_request__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor stub_i2_cread_bytes_request__field_descriptors[3] = +{ + { + "I2CId", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubI2CReadBytesRequest, has_i2cid), + offsetof(StubI2CReadBytesRequest, i2cid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "SlaveAddress", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubI2CReadBytesRequest, has_slaveaddress), + offsetof(StubI2CReadBytesRequest, slaveaddress), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "NumberOfBytesToRead", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubI2CReadBytesRequest, has_numberofbytestoread), + offsetof(StubI2CReadBytesRequest, numberofbytestoread), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned stub_i2_cread_bytes_request__field_indices_by_name[] = { + 0, /* field[0] = I2CId */ + 2, /* field[2] = NumberOfBytesToRead */ + 1, /* field[1] = SlaveAddress */ +}; +static const ProtobufCIntRange stub_i2_cread_bytes_request__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor stub_i2_cread_bytes_request__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StubI2CReadBytesRequest", + "StubI2CReadBytesRequest", + "StubI2CReadBytesRequest", + "", + sizeof(StubI2CReadBytesRequest), + 3, + stub_i2_cread_bytes_request__field_descriptors, + stub_i2_cread_bytes_request__field_indices_by_name, + 1, stub_i2_cread_bytes_request__number_ranges, + (ProtobufCMessageInit) stub_i2_cread_bytes_request__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CReadBytesRequest.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CReadBytesRequest.pb-c.h new file mode 100644 index 000000000..6c3e35bb1 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CReadBytesRequest.pb-c.h @@ -0,0 +1,80 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubI2CReadBytesRequest.proto */ + +#ifndef PROTOBUF_C_StubI2CReadBytesRequest_2eproto__INCLUDED +#define PROTOBUF_C_StubI2CReadBytesRequest_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 _StubI2CReadBytesRequest StubI2CReadBytesRequest; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StubI2CReadBytesRequest +{ + ProtobufCMessage base; + /* + */ + protobuf_c_boolean has_i2cid; + uint32_t i2cid; + /* + */ + protobuf_c_boolean has_slaveaddress; + uint32_t slaveaddress; + protobuf_c_boolean has_numberofbytestoread; + uint32_t numberofbytestoread; +}; +#define STUB_I2_CREAD_BYTES_REQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stub_i2_cread_bytes_request__descriptor) \ + , 0, 0, 0, 0, 0, 0 } + + +/* StubI2CReadBytesRequest methods */ +void stub_i2_cread_bytes_request__init + (StubI2CReadBytesRequest *message); +size_t stub_i2_cread_bytes_request__get_packed_size + (const StubI2CReadBytesRequest *message); +size_t stub_i2_cread_bytes_request__pack + (const StubI2CReadBytesRequest *message, + uint8_t *out); +size_t stub_i2_cread_bytes_request__pack_to_buffer + (const StubI2CReadBytesRequest *message, + ProtobufCBuffer *buffer); +StubI2CReadBytesRequest * + stub_i2_cread_bytes_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stub_i2_cread_bytes_request__free_unpacked + (StubI2CReadBytesRequest *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StubI2CReadBytesRequest_Closure) + (const StubI2CReadBytesRequest *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stub_i2_cread_bytes_request__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StubI2CReadBytesRequest_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CReadBytesResponse.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CReadBytesResponse.pb-c.c new file mode 100644 index 000000000..347c661a7 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CReadBytesResponse.pb-c.c @@ -0,0 +1,144 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubI2CReadBytesResponse.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StubI2CReadBytesResponse.pb-c.h" +void stub_i2_cread_bytes_response__init + (StubI2CReadBytesResponse *message) +{ + static const StubI2CReadBytesResponse init_value = STUB_I2_CREAD_BYTES_RESPONSE__INIT; + *message = init_value; +} +size_t stub_i2_cread_bytes_response__get_packed_size + (const StubI2CReadBytesResponse *message) +{ + assert(message->base.descriptor == &stub_i2_cread_bytes_response__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stub_i2_cread_bytes_response__pack + (const StubI2CReadBytesResponse *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stub_i2_cread_bytes_response__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stub_i2_cread_bytes_response__pack_to_buffer + (const StubI2CReadBytesResponse *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stub_i2_cread_bytes_response__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StubI2CReadBytesResponse * + stub_i2_cread_bytes_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StubI2CReadBytesResponse *) + protobuf_c_message_unpack (&stub_i2_cread_bytes_response__descriptor, + allocator, len, data); +} +void stub_i2_cread_bytes_response__free_unpacked + (StubI2CReadBytesResponse *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stub_i2_cread_bytes_response__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor stub_i2_cread_bytes_response__field_descriptors[5] = +{ + { + "I2CId", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubI2CReadBytesResponse, has_i2cid), + offsetof(StubI2CReadBytesResponse, i2cid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "SlaveAddress", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubI2CReadBytesResponse, has_slaveaddress), + offsetof(StubI2CReadBytesResponse, slaveaddress), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ReadBytes", + 3, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubI2CReadBytesResponse, n_readbytes), + offsetof(StubI2CReadBytesResponse, readbytes), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Status", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(StubI2CReadBytesResponse, status), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "StatusWord", + 5, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubI2CReadBytesResponse, has_statusword), + offsetof(StubI2CReadBytesResponse, statusword), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned stub_i2_cread_bytes_response__field_indices_by_name[] = { + 0, /* field[0] = I2CId */ + 2, /* field[2] = ReadBytes */ + 1, /* field[1] = SlaveAddress */ + 3, /* field[3] = Status */ + 4, /* field[4] = StatusWord */ +}; +static const ProtobufCIntRange stub_i2_cread_bytes_response__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 5 } +}; +const ProtobufCMessageDescriptor stub_i2_cread_bytes_response__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StubI2CReadBytesResponse", + "StubI2CReadBytesResponse", + "StubI2CReadBytesResponse", + "", + sizeof(StubI2CReadBytesResponse), + 5, + stub_i2_cread_bytes_response__field_descriptors, + stub_i2_cread_bytes_response__field_indices_by_name, + 1, stub_i2_cread_bytes_response__number_ranges, + (ProtobufCMessageInit) stub_i2_cread_bytes_response__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CReadBytesResponse.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CReadBytesResponse.pb-c.h new file mode 100644 index 000000000..e8d2521cc --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CReadBytesResponse.pb-c.h @@ -0,0 +1,89 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubI2CReadBytesResponse.proto */ + +#ifndef PROTOBUF_C_StubI2CReadBytesResponse_2eproto__INCLUDED +#define PROTOBUF_C_StubI2CReadBytesResponse_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 _StubI2CReadBytesResponse StubI2CReadBytesResponse; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StubI2CReadBytesResponse +{ + ProtobufCMessage base; + /* + */ + protobuf_c_boolean has_i2cid; + uint32_t i2cid; + protobuf_c_boolean has_slaveaddress; + uint32_t slaveaddress; + /* + */ + size_t n_readbytes; + uint32_t *readbytes; + /* + * Passed/Failed + */ + char *status; + /* + * Error number/bit when the status is Failed + */ + protobuf_c_boolean has_statusword; + uint32_t statusword; +}; +#define STUB_I2_CREAD_BYTES_RESPONSE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stub_i2_cread_bytes_response__descriptor) \ + , 0, 0, 0, 0, 0,NULL, NULL, 0, 0 } + + +/* StubI2CReadBytesResponse methods */ +void stub_i2_cread_bytes_response__init + (StubI2CReadBytesResponse *message); +size_t stub_i2_cread_bytes_response__get_packed_size + (const StubI2CReadBytesResponse *message); +size_t stub_i2_cread_bytes_response__pack + (const StubI2CReadBytesResponse *message, + uint8_t *out); +size_t stub_i2_cread_bytes_response__pack_to_buffer + (const StubI2CReadBytesResponse *message, + ProtobufCBuffer *buffer); +StubI2CReadBytesResponse * + stub_i2_cread_bytes_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stub_i2_cread_bytes_response__free_unpacked + (StubI2CReadBytesResponse *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StubI2CReadBytesResponse_Closure) + (const StubI2CReadBytesResponse *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stub_i2_cread_bytes_response__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StubI2CReadBytesResponse_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CRequest.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CRequest.pb-c.c new file mode 100644 index 000000000..ccc789192 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CRequest.pb-c.c @@ -0,0 +1,131 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubI2CRequest.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StubI2CRequest.pb-c.h" +void stub_i2_crequest__init + (StubI2CRequest *message) +{ + static const StubI2CRequest init_value = STUB_I2_CREQUEST__INIT; + *message = init_value; +} +size_t stub_i2_crequest__get_packed_size + (const StubI2CRequest *message) +{ + assert(message->base.descriptor == &stub_i2_crequest__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stub_i2_crequest__pack + (const StubI2CRequest *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stub_i2_crequest__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stub_i2_crequest__pack_to_buffer + (const StubI2CRequest *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stub_i2_crequest__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StubI2CRequest * + stub_i2_crequest__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StubI2CRequest *) + protobuf_c_message_unpack (&stub_i2_crequest__descriptor, + allocator, len, data); +} +void stub_i2_crequest__free_unpacked + (StubI2CRequest *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stub_i2_crequest__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor stub_i2_crequest__field_descriptors[4] = +{ + { + "I2CId", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubI2CRequest, has_i2cid), + offsetof(StubI2CRequest, i2cid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "SlaveAddress", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubI2CRequest, has_slaveaddress), + offsetof(StubI2CRequest, slaveaddress), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ReadOrWrite", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BOOL, + offsetof(StubI2CRequest, has_readorwrite), + offsetof(StubI2CRequest, readorwrite), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ByteToWrite", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubI2CRequest, has_bytetowrite), + offsetof(StubI2CRequest, bytetowrite), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned stub_i2_crequest__field_indices_by_name[] = { + 3, /* field[3] = ByteToWrite */ + 0, /* field[0] = I2CId */ + 2, /* field[2] = ReadOrWrite */ + 1, /* field[1] = SlaveAddress */ +}; +static const ProtobufCIntRange stub_i2_crequest__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor stub_i2_crequest__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StubI2CRequest", + "StubI2CRequest", + "StubI2CRequest", + "", + sizeof(StubI2CRequest), + 4, + stub_i2_crequest__field_descriptors, + stub_i2_crequest__field_indices_by_name, + 1, stub_i2_crequest__number_ranges, + (ProtobufCMessageInit) stub_i2_crequest__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CRequest.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CRequest.pb-c.h new file mode 100644 index 000000000..8815f72f9 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CRequest.pb-c.h @@ -0,0 +1,84 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubI2CRequest.proto */ + +#ifndef PROTOBUF_C_StubI2CRequest_2eproto__INCLUDED +#define PROTOBUF_C_StubI2CRequest_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 _StubI2CRequest StubI2CRequest; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StubI2CRequest +{ + ProtobufCMessage base; + /* + */ + protobuf_c_boolean has_i2cid; + uint32_t i2cid; + protobuf_c_boolean has_slaveaddress; + uint32_t slaveaddress; + /* + */ + protobuf_c_boolean has_readorwrite; + protobuf_c_boolean readorwrite; + /* + */ + protobuf_c_boolean has_bytetowrite; + uint32_t bytetowrite; +}; +#define STUB_I2_CREQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stub_i2_crequest__descriptor) \ + , 0, 0, 0, 0, 0, 0, 0, 0 } + + +/* StubI2CRequest methods */ +void stub_i2_crequest__init + (StubI2CRequest *message); +size_t stub_i2_crequest__get_packed_size + (const StubI2CRequest *message); +size_t stub_i2_crequest__pack + (const StubI2CRequest *message, + uint8_t *out); +size_t stub_i2_crequest__pack_to_buffer + (const StubI2CRequest *message, + ProtobufCBuffer *buffer); +StubI2CRequest * + stub_i2_crequest__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stub_i2_crequest__free_unpacked + (StubI2CRequest *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StubI2CRequest_Closure) + (const StubI2CRequest *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stub_i2_crequest__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StubI2CRequest_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CResponse.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CResponse.pb-c.c new file mode 100644 index 000000000..470a2a99a --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CResponse.pb-c.c @@ -0,0 +1,131 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubI2CResponse.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StubI2CResponse.pb-c.h" +void stub_i2_cresponse__init + (StubI2CResponse *message) +{ + static const StubI2CResponse init_value = STUB_I2_CRESPONSE__INIT; + *message = init_value; +} +size_t stub_i2_cresponse__get_packed_size + (const StubI2CResponse *message) +{ + assert(message->base.descriptor == &stub_i2_cresponse__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stub_i2_cresponse__pack + (const StubI2CResponse *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stub_i2_cresponse__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stub_i2_cresponse__pack_to_buffer + (const StubI2CResponse *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stub_i2_cresponse__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StubI2CResponse * + stub_i2_cresponse__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StubI2CResponse *) + protobuf_c_message_unpack (&stub_i2_cresponse__descriptor, + allocator, len, data); +} +void stub_i2_cresponse__free_unpacked + (StubI2CResponse *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stub_i2_cresponse__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor stub_i2_cresponse__field_descriptors[4] = +{ + { + "I2CId", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubI2CResponse, has_i2cid), + offsetof(StubI2CResponse, i2cid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ReadByte", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubI2CResponse, has_readbyte), + offsetof(StubI2CResponse, readbyte), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Status", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(StubI2CResponse, status), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "StatusWord", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubI2CResponse, has_statusword), + offsetof(StubI2CResponse, statusword), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned stub_i2_cresponse__field_indices_by_name[] = { + 0, /* field[0] = I2CId */ + 1, /* field[1] = ReadByte */ + 2, /* field[2] = Status */ + 3, /* field[3] = StatusWord */ +}; +static const ProtobufCIntRange stub_i2_cresponse__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor stub_i2_cresponse__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StubI2CResponse", + "StubI2CResponse", + "StubI2CResponse", + "", + sizeof(StubI2CResponse), + 4, + stub_i2_cresponse__field_descriptors, + stub_i2_cresponse__field_indices_by_name, + 1, stub_i2_cresponse__number_ranges, + (ProtobufCMessageInit) stub_i2_cresponse__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CResponse.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CResponse.pb-c.h new file mode 100644 index 000000000..cbdf573a6 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CResponse.pb-c.h @@ -0,0 +1,87 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubI2CResponse.proto */ + +#ifndef PROTOBUF_C_StubI2CResponse_2eproto__INCLUDED +#define PROTOBUF_C_StubI2CResponse_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 _StubI2CResponse StubI2CResponse; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StubI2CResponse +{ + ProtobufCMessage base; + /* + */ + protobuf_c_boolean has_i2cid; + uint32_t i2cid; + /* + */ + protobuf_c_boolean has_readbyte; + uint32_t readbyte; + /* + * Passed/Failed + */ + char *status; + /* + * Error number/bit when the status is Failed + */ + protobuf_c_boolean has_statusword; + uint32_t statusword; +}; +#define STUB_I2_CRESPONSE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stub_i2_cresponse__descriptor) \ + , 0, 0, 0, 0, NULL, 0, 0 } + + +/* StubI2CResponse methods */ +void stub_i2_cresponse__init + (StubI2CResponse *message); +size_t stub_i2_cresponse__get_packed_size + (const StubI2CResponse *message); +size_t stub_i2_cresponse__pack + (const StubI2CResponse *message, + uint8_t *out); +size_t stub_i2_cresponse__pack_to_buffer + (const StubI2CResponse *message, + ProtobufCBuffer *buffer); +StubI2CResponse * + stub_i2_cresponse__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stub_i2_cresponse__free_unpacked + (StubI2CResponse *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StubI2CResponse_Closure) + (const StubI2CResponse *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stub_i2_cresponse__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StubI2CResponse_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CWriteBytesRequest.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CWriteBytesRequest.pb-c.c new file mode 100644 index 000000000..13ad2f16b --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CWriteBytesRequest.pb-c.c @@ -0,0 +1,118 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubI2CWriteBytesRequest.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StubI2CWriteBytesRequest.pb-c.h" +void stub_i2_cwrite_bytes_request__init + (StubI2CWriteBytesRequest *message) +{ + static const StubI2CWriteBytesRequest init_value = STUB_I2_CWRITE_BYTES_REQUEST__INIT; + *message = init_value; +} +size_t stub_i2_cwrite_bytes_request__get_packed_size + (const StubI2CWriteBytesRequest *message) +{ + assert(message->base.descriptor == &stub_i2_cwrite_bytes_request__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stub_i2_cwrite_bytes_request__pack + (const StubI2CWriteBytesRequest *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stub_i2_cwrite_bytes_request__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stub_i2_cwrite_bytes_request__pack_to_buffer + (const StubI2CWriteBytesRequest *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stub_i2_cwrite_bytes_request__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StubI2CWriteBytesRequest * + stub_i2_cwrite_bytes_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StubI2CWriteBytesRequest *) + protobuf_c_message_unpack (&stub_i2_cwrite_bytes_request__descriptor, + allocator, len, data); +} +void stub_i2_cwrite_bytes_request__free_unpacked + (StubI2CWriteBytesRequest *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stub_i2_cwrite_bytes_request__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor stub_i2_cwrite_bytes_request__field_descriptors[3] = +{ + { + "I2CId", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubI2CWriteBytesRequest, has_i2cid), + offsetof(StubI2CWriteBytesRequest, i2cid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "SlaveAddress", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubI2CWriteBytesRequest, has_slaveaddress), + offsetof(StubI2CWriteBytesRequest, slaveaddress), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "BytesTWrite", + 3, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubI2CWriteBytesRequest, n_bytestwrite), + offsetof(StubI2CWriteBytesRequest, bytestwrite), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned stub_i2_cwrite_bytes_request__field_indices_by_name[] = { + 2, /* field[2] = BytesTWrite */ + 0, /* field[0] = I2CId */ + 1, /* field[1] = SlaveAddress */ +}; +static const ProtobufCIntRange stub_i2_cwrite_bytes_request__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor stub_i2_cwrite_bytes_request__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StubI2CWriteBytesRequest", + "StubI2CWriteBytesRequest", + "StubI2CWriteBytesRequest", + "", + sizeof(StubI2CWriteBytesRequest), + 3, + stub_i2_cwrite_bytes_request__field_descriptors, + stub_i2_cwrite_bytes_request__field_indices_by_name, + 1, stub_i2_cwrite_bytes_request__number_ranges, + (ProtobufCMessageInit) stub_i2_cwrite_bytes_request__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CWriteBytesRequest.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CWriteBytesRequest.pb-c.h new file mode 100644 index 000000000..6390e625d --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CWriteBytesRequest.pb-c.h @@ -0,0 +1,80 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubI2CWriteBytesRequest.proto */ + +#ifndef PROTOBUF_C_StubI2CWriteBytesRequest_2eproto__INCLUDED +#define PROTOBUF_C_StubI2CWriteBytesRequest_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 _StubI2CWriteBytesRequest StubI2CWriteBytesRequest; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StubI2CWriteBytesRequest +{ + ProtobufCMessage base; + /* + */ + protobuf_c_boolean has_i2cid; + uint32_t i2cid; + protobuf_c_boolean has_slaveaddress; + uint32_t slaveaddress; + /* + */ + size_t n_bytestwrite; + uint32_t *bytestwrite; +}; +#define STUB_I2_CWRITE_BYTES_REQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stub_i2_cwrite_bytes_request__descriptor) \ + , 0, 0, 0, 0, 0,NULL } + + +/* StubI2CWriteBytesRequest methods */ +void stub_i2_cwrite_bytes_request__init + (StubI2CWriteBytesRequest *message); +size_t stub_i2_cwrite_bytes_request__get_packed_size + (const StubI2CWriteBytesRequest *message); +size_t stub_i2_cwrite_bytes_request__pack + (const StubI2CWriteBytesRequest *message, + uint8_t *out); +size_t stub_i2_cwrite_bytes_request__pack_to_buffer + (const StubI2CWriteBytesRequest *message, + ProtobufCBuffer *buffer); +StubI2CWriteBytesRequest * + stub_i2_cwrite_bytes_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stub_i2_cwrite_bytes_request__free_unpacked + (StubI2CWriteBytesRequest *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StubI2CWriteBytesRequest_Closure) + (const StubI2CWriteBytesRequest *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stub_i2_cwrite_bytes_request__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StubI2CWriteBytesRequest_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CWriteBytesResponse.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CWriteBytesResponse.pb-c.c new file mode 100644 index 000000000..e9e283ca7 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CWriteBytesResponse.pb-c.c @@ -0,0 +1,131 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubI2CWriteBytesResponse.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StubI2CWriteBytesResponse.pb-c.h" +void stub_i2_cwrite_bytes_response__init + (StubI2CWriteBytesResponse *message) +{ + static const StubI2CWriteBytesResponse init_value = STUB_I2_CWRITE_BYTES_RESPONSE__INIT; + *message = init_value; +} +size_t stub_i2_cwrite_bytes_response__get_packed_size + (const StubI2CWriteBytesResponse *message) +{ + assert(message->base.descriptor == &stub_i2_cwrite_bytes_response__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stub_i2_cwrite_bytes_response__pack + (const StubI2CWriteBytesResponse *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stub_i2_cwrite_bytes_response__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stub_i2_cwrite_bytes_response__pack_to_buffer + (const StubI2CWriteBytesResponse *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stub_i2_cwrite_bytes_response__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StubI2CWriteBytesResponse * + stub_i2_cwrite_bytes_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StubI2CWriteBytesResponse *) + protobuf_c_message_unpack (&stub_i2_cwrite_bytes_response__descriptor, + allocator, len, data); +} +void stub_i2_cwrite_bytes_response__free_unpacked + (StubI2CWriteBytesResponse *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stub_i2_cwrite_bytes_response__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor stub_i2_cwrite_bytes_response__field_descriptors[4] = +{ + { + "I2CId", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubI2CWriteBytesResponse, has_i2cid), + offsetof(StubI2CWriteBytesResponse, i2cid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "SlaveAddress", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubI2CWriteBytesResponse, has_slaveaddress), + offsetof(StubI2CWriteBytesResponse, slaveaddress), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Status", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(StubI2CWriteBytesResponse, status), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "StatusWord", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubI2CWriteBytesResponse, has_statusword), + offsetof(StubI2CWriteBytesResponse, statusword), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned stub_i2_cwrite_bytes_response__field_indices_by_name[] = { + 0, /* field[0] = I2CId */ + 1, /* field[1] = SlaveAddress */ + 2, /* field[2] = Status */ + 3, /* field[3] = StatusWord */ +}; +static const ProtobufCIntRange stub_i2_cwrite_bytes_response__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor stub_i2_cwrite_bytes_response__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StubI2CWriteBytesResponse", + "StubI2CWriteBytesResponse", + "StubI2CWriteBytesResponse", + "", + sizeof(StubI2CWriteBytesResponse), + 4, + stub_i2_cwrite_bytes_response__field_descriptors, + stub_i2_cwrite_bytes_response__field_indices_by_name, + 1, stub_i2_cwrite_bytes_response__number_ranges, + (ProtobufCMessageInit) stub_i2_cwrite_bytes_response__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CWriteBytesResponse.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CWriteBytesResponse.pb-c.h new file mode 100644 index 000000000..21a2a6c23 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubI2CWriteBytesResponse.pb-c.h @@ -0,0 +1,87 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubI2CWriteBytesResponse.proto */ + +#ifndef PROTOBUF_C_StubI2CWriteBytesResponse_2eproto__INCLUDED +#define PROTOBUF_C_StubI2CWriteBytesResponse_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 _StubI2CWriteBytesResponse StubI2CWriteBytesResponse; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StubI2CWriteBytesResponse +{ + ProtobufCMessage base; + /* + */ + protobuf_c_boolean has_i2cid; + uint32_t i2cid; + /* + */ + protobuf_c_boolean has_slaveaddress; + uint32_t slaveaddress; + /* + * Passed/Failed + */ + char *status; + /* + * Error number/bit when the status is Failed + */ + protobuf_c_boolean has_statusword; + uint32_t statusword; +}; +#define STUB_I2_CWRITE_BYTES_RESPONSE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stub_i2_cwrite_bytes_response__descriptor) \ + , 0, 0, 0, 0, NULL, 0, 0 } + + +/* StubI2CWriteBytesResponse methods */ +void stub_i2_cwrite_bytes_response__init + (StubI2CWriteBytesResponse *message); +size_t stub_i2_cwrite_bytes_response__get_packed_size + (const StubI2CWriteBytesResponse *message); +size_t stub_i2_cwrite_bytes_response__pack + (const StubI2CWriteBytesResponse *message, + uint8_t *out); +size_t stub_i2_cwrite_bytes_response__pack_to_buffer + (const StubI2CWriteBytesResponse *message, + ProtobufCBuffer *buffer); +StubI2CWriteBytesResponse * + stub_i2_cwrite_bytes_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stub_i2_cwrite_bytes_response__free_unpacked + (StubI2CWriteBytesResponse *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StubI2CWriteBytesResponse_Closure) + (const StubI2CWriteBytesResponse *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stub_i2_cwrite_bytes_response__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StubI2CWriteBytesResponse_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubIntADCReadRequest.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubIntADCReadRequest.pb-c.c new file mode 100644 index 000000000..3537ec062 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubIntADCReadRequest.pb-c.c @@ -0,0 +1,92 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubIntADCReadRequest.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StubIntADCReadRequest.pb-c.h" +void stub_int_adcread_request__init + (StubIntADCReadRequest *message) +{ + static const StubIntADCReadRequest init_value = STUB_INT_ADCREAD_REQUEST__INIT; + *message = init_value; +} +size_t stub_int_adcread_request__get_packed_size + (const StubIntADCReadRequest *message) +{ + assert(message->base.descriptor == &stub_int_adcread_request__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stub_int_adcread_request__pack + (const StubIntADCReadRequest *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stub_int_adcread_request__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stub_int_adcread_request__pack_to_buffer + (const StubIntADCReadRequest *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stub_int_adcread_request__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StubIntADCReadRequest * + stub_int_adcread_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StubIntADCReadRequest *) + protobuf_c_message_unpack (&stub_int_adcread_request__descriptor, + allocator, len, data); +} +void stub_int_adcread_request__free_unpacked + (StubIntADCReadRequest *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stub_int_adcread_request__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor stub_int_adcread_request__field_descriptors[1] = +{ + { + "ADC_Device", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubIntADCReadRequest, has_adc_device), + offsetof(StubIntADCReadRequest, adc_device), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned stub_int_adcread_request__field_indices_by_name[] = { + 0, /* field[0] = ADC_Device */ +}; +static const ProtobufCIntRange stub_int_adcread_request__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor stub_int_adcread_request__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StubIntADCReadRequest", + "StubIntADCReadRequest", + "StubIntADCReadRequest", + "", + sizeof(StubIntADCReadRequest), + 1, + stub_int_adcread_request__field_descriptors, + stub_int_adcread_request__field_indices_by_name, + 1, stub_int_adcread_request__number_ranges, + (ProtobufCMessageInit) stub_int_adcread_request__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubIntADCReadRequest.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubIntADCReadRequest.pb-c.h new file mode 100644 index 000000000..cbf4116a6 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubIntADCReadRequest.pb-c.h @@ -0,0 +1,74 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubIntADCReadRequest.proto */ + +#ifndef PROTOBUF_C_StubIntADCReadRequest_2eproto__INCLUDED +#define PROTOBUF_C_StubIntADCReadRequest_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 _StubIntADCReadRequest StubIntADCReadRequest; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StubIntADCReadRequest +{ + ProtobufCMessage base; + /* + */ + protobuf_c_boolean has_adc_device; + uint32_t adc_device; +}; +#define STUB_INT_ADCREAD_REQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stub_int_adcread_request__descriptor) \ + , 0, 0 } + + +/* StubIntADCReadRequest methods */ +void stub_int_adcread_request__init + (StubIntADCReadRequest *message); +size_t stub_int_adcread_request__get_packed_size + (const StubIntADCReadRequest *message); +size_t stub_int_adcread_request__pack + (const StubIntADCReadRequest *message, + uint8_t *out); +size_t stub_int_adcread_request__pack_to_buffer + (const StubIntADCReadRequest *message, + ProtobufCBuffer *buffer); +StubIntADCReadRequest * + stub_int_adcread_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stub_int_adcread_request__free_unpacked + (StubIntADCReadRequest *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StubIntADCReadRequest_Closure) + (const StubIntADCReadRequest *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stub_int_adcread_request__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StubIntADCReadRequest_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubIntADCReadResponse.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubIntADCReadResponse.pb-c.c new file mode 100644 index 000000000..00dd040fe --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubIntADCReadResponse.pb-c.c @@ -0,0 +1,144 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubIntADCReadResponse.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StubIntADCReadResponse.pb-c.h" +void stub_int_adcread_response__init + (StubIntADCReadResponse *message) +{ + static const StubIntADCReadResponse init_value = STUB_INT_ADCREAD_RESPONSE__INIT; + *message = init_value; +} +size_t stub_int_adcread_response__get_packed_size + (const StubIntADCReadResponse *message) +{ + assert(message->base.descriptor == &stub_int_adcread_response__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stub_int_adcread_response__pack + (const StubIntADCReadResponse *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stub_int_adcread_response__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stub_int_adcread_response__pack_to_buffer + (const StubIntADCReadResponse *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stub_int_adcread_response__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StubIntADCReadResponse * + stub_int_adcread_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StubIntADCReadResponse *) + protobuf_c_message_unpack (&stub_int_adcread_response__descriptor, + allocator, len, data); +} +void stub_int_adcread_response__free_unpacked + (StubIntADCReadResponse *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stub_int_adcread_response__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor stub_int_adcread_response__field_descriptors[5] = +{ + { + "ADC_Device", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubIntADCReadResponse, has_adc_device), + offsetof(StubIntADCReadResponse, adc_device), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Sampling_in_Bits", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + offsetof(StubIntADCReadResponse, has_sampling_in_bits), + offsetof(StubIntADCReadResponse, sampling_in_bits), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Voltage_Sampling_mv", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + offsetof(StubIntADCReadResponse, has_voltage_sampling_mv), + offsetof(StubIntADCReadResponse, voltage_sampling_mv), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Status", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(StubIntADCReadResponse, status), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "StatusWord", + 5, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubIntADCReadResponse, has_statusword), + offsetof(StubIntADCReadResponse, statusword), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned stub_int_adcread_response__field_indices_by_name[] = { + 0, /* field[0] = ADC_Device */ + 1, /* field[1] = Sampling_in_Bits */ + 3, /* field[3] = Status */ + 4, /* field[4] = StatusWord */ + 2, /* field[2] = Voltage_Sampling_mv */ +}; +static const ProtobufCIntRange stub_int_adcread_response__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 5 } +}; +const ProtobufCMessageDescriptor stub_int_adcread_response__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StubIntADCReadResponse", + "StubIntADCReadResponse", + "StubIntADCReadResponse", + "", + sizeof(StubIntADCReadResponse), + 5, + stub_int_adcread_response__field_descriptors, + stub_int_adcread_response__field_indices_by_name, + 1, stub_int_adcread_response__number_ranges, + (ProtobufCMessageInit) stub_int_adcread_response__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubIntADCReadResponse.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubIntADCReadResponse.pb-c.h new file mode 100644 index 000000000..24f17bf87 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubIntADCReadResponse.pb-c.h @@ -0,0 +1,91 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubIntADCReadResponse.proto */ + +#ifndef PROTOBUF_C_StubIntADCReadResponse_2eproto__INCLUDED +#define PROTOBUF_C_StubIntADCReadResponse_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 _StubIntADCReadResponse StubIntADCReadResponse; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StubIntADCReadResponse +{ + ProtobufCMessage base; + /* + */ + protobuf_c_boolean has_adc_device; + uint32_t adc_device; + /* + */ + protobuf_c_boolean has_sampling_in_bits; + int32_t sampling_in_bits; + /* + */ + protobuf_c_boolean has_voltage_sampling_mv; + int32_t voltage_sampling_mv; + /* + * Passed/Failed + */ + char *status; + /* + * Error number/bit when the status is Failed + */ + protobuf_c_boolean has_statusword; + uint32_t statusword; +}; +#define STUB_INT_ADCREAD_RESPONSE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stub_int_adcread_response__descriptor) \ + , 0, 0, 0, 0, 0, 0, NULL, 0, 0 } + + +/* StubIntADCReadResponse methods */ +void stub_int_adcread_response__init + (StubIntADCReadResponse *message); +size_t stub_int_adcread_response__get_packed_size + (const StubIntADCReadResponse *message); +size_t stub_int_adcread_response__pack + (const StubIntADCReadResponse *message, + uint8_t *out); +size_t stub_int_adcread_response__pack_to_buffer + (const StubIntADCReadResponse *message, + ProtobufCBuffer *buffer); +StubIntADCReadResponse * + stub_int_adcread_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stub_int_adcread_response__free_unpacked + (StubIntADCReadResponse *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StubIntADCReadResponse_Closure) + (const StubIntADCReadResponse *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stub_int_adcread_response__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StubIntADCReadResponse_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubMotorInitRequest.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubMotorInitRequest.pb-c.c index 0f01b16d4..a7f97ce16 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubMotorInitRequest.pb-c.c +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubMotorInitRequest.pb-c.c @@ -52,7 +52,7 @@ void stub_motor_init_request__free_unpacked assert(message->base.descriptor == &stub_motor_init_request__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -static const ProtobufCFieldDescriptor stub_motor_init_request__field_descriptors[9] = +static const ProtobufCFieldDescriptor stub_motor_init_request__field_descriptors[20] = { { "Motor_ID", @@ -162,22 +162,165 @@ static const ProtobufCFieldDescriptor stub_motor_init_request__field_descriptors 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, + { + "Min_Speed_LSPD_OPT", + 10, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubMotorInitRequest, has_min_speed_lspd_opt), + offsetof(StubMotorInitRequest, min_speed_lspd_opt), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Set_Min_Speed_LSPD_OPT", + 11, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BOOL, + offsetof(StubMotorInitRequest, has_set_min_speed_lspd_opt), + offsetof(StubMotorInitRequest, set_min_speed_lspd_opt), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Config", + 12, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubMotorInitRequest, has_config), + offsetof(StubMotorInitRequest, config), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "KVAL_HOLD", + 13, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubMotorInitRequest, has_kval_hold), + offsetof(StubMotorInitRequest, kval_hold), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "KVAL_RUN", + 14, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubMotorInitRequest, has_kval_run), + offsetof(StubMotorInitRequest, kval_run), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "KVAL_ACC", + 15, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubMotorInitRequest, has_kval_acc), + offsetof(StubMotorInitRequest, kval_acc), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "KVAL_DEC", + 16, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubMotorInitRequest, has_kval_dec), + offsetof(StubMotorInitRequest, kval_dec), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ST_SLP", + 17, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubMotorInitRequest, has_st_slp), + offsetof(StubMotorInitRequest, st_slp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "INT_SPD", + 18, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubMotorInitRequest, has_int_spd), + offsetof(StubMotorInitRequest, int_spd), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "FN_SLP_ACC", + 19, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubMotorInitRequest, has_fn_slp_acc), + offsetof(StubMotorInitRequest, fn_slp_acc), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "FN_SLP_DEC", + 20, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubMotorInitRequest, has_fn_slp_dec), + offsetof(StubMotorInitRequest, fn_slp_dec), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, }; static const unsigned stub_motor_init_request__field_indices_by_name[] = { 3, /* field[3] = ACC */ + 11, /* field[11] = Config */ 5, /* field[5] = DEC */ + 18, /* field[18] = FN_SLP_ACC */ + 19, /* field[19] = FN_SLP_DEC */ + 17, /* field[17] = INT_SPD */ + 14, /* field[14] = KVAL_ACC */ + 15, /* field[15] = KVAL_DEC */ + 12, /* field[12] = KVAL_HOLD */ + 13, /* field[13] = KVAL_RUN */ 7, /* field[7] = Max_Speed */ 1, /* field[1] = Micro_Steps */ + 9, /* field[9] = Min_Speed_LSPD_OPT */ 0, /* field[0] = Motor_ID */ + 16, /* field[16] = ST_SLP */ 4, /* field[4] = Set_ACC */ 6, /* field[6] = Set_Dec */ 8, /* field[8] = Set_Max_Speed */ 2, /* field[2] = Set_Micro_Steps */ + 10, /* field[10] = Set_Min_Speed_LSPD_OPT */ }; static const ProtobufCIntRange stub_motor_init_request__number_ranges[1 + 1] = { { 1, 0 }, - { 0, 9 } + { 0, 20 } }; const ProtobufCMessageDescriptor stub_motor_init_request__descriptor = { @@ -187,7 +330,7 @@ const ProtobufCMessageDescriptor stub_motor_init_request__descriptor = "StubMotorInitRequest", "", sizeof(StubMotorInitRequest), - 9, + 20, stub_motor_init_request__field_descriptors, stub_motor_init_request__field_indices_by_name, 1, stub_motor_init_request__number_ranges, diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubMotorInitRequest.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubMotorInitRequest.pb-c.h index 29b1f6036..759c0cd03 100644 --- a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubMotorInitRequest.pb-c.h +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubMotorInitRequest.pb-c.h @@ -47,10 +47,32 @@ struct _StubMotorInitRequest uint32_t max_speed; protobuf_c_boolean has_set_max_speed; protobuf_c_boolean set_max_speed; + protobuf_c_boolean has_min_speed_lspd_opt; + uint32_t min_speed_lspd_opt; + protobuf_c_boolean has_set_min_speed_lspd_opt; + protobuf_c_boolean set_min_speed_lspd_opt; + protobuf_c_boolean has_config; + uint32_t config; + protobuf_c_boolean has_kval_hold; + uint32_t kval_hold; + protobuf_c_boolean has_kval_run; + uint32_t kval_run; + protobuf_c_boolean has_kval_acc; + uint32_t kval_acc; + protobuf_c_boolean has_kval_dec; + uint32_t kval_dec; + protobuf_c_boolean has_st_slp; + uint32_t st_slp; + protobuf_c_boolean has_int_spd; + uint32_t int_spd; + protobuf_c_boolean has_fn_slp_acc; + uint32_t fn_slp_acc; + protobuf_c_boolean has_fn_slp_dec; + uint32_t fn_slp_dec; }; #define STUB_MOTOR_INIT_REQUEST__INIT \ { PROTOBUF_C_MESSAGE_INIT (&stub_motor_init_request__descriptor) \ - , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } + , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } /* StubMotorInitRequest methods */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubReadEmbeddedVersionRequest.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubReadEmbeddedVersionRequest.pb-c.c new file mode 100644 index 000000000..d8e11e383 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubReadEmbeddedVersionRequest.pb-c.c @@ -0,0 +1,72 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubReadEmbeddedVersionRequest.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StubReadEmbeddedVersionRequest.pb-c.h" +void stub_read_embedded_version_request__init + (StubReadEmbeddedVersionRequest *message) +{ + static const StubReadEmbeddedVersionRequest init_value = STUB_READ_EMBEDDED_VERSION_REQUEST__INIT; + *message = init_value; +} +size_t stub_read_embedded_version_request__get_packed_size + (const StubReadEmbeddedVersionRequest *message) +{ + assert(message->base.descriptor == &stub_read_embedded_version_request__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stub_read_embedded_version_request__pack + (const StubReadEmbeddedVersionRequest *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stub_read_embedded_version_request__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stub_read_embedded_version_request__pack_to_buffer + (const StubReadEmbeddedVersionRequest *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stub_read_embedded_version_request__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StubReadEmbeddedVersionRequest * + stub_read_embedded_version_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StubReadEmbeddedVersionRequest *) + protobuf_c_message_unpack (&stub_read_embedded_version_request__descriptor, + allocator, len, data); +} +void stub_read_embedded_version_request__free_unpacked + (StubReadEmbeddedVersionRequest *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stub_read_embedded_version_request__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +#define stub_read_embedded_version_request__field_descriptors NULL +#define stub_read_embedded_version_request__field_indices_by_name NULL +#define stub_read_embedded_version_request__number_ranges NULL +const ProtobufCMessageDescriptor stub_read_embedded_version_request__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StubReadEmbeddedVersionRequest", + "StubReadEmbeddedVersionRequest", + "StubReadEmbeddedVersionRequest", + "", + sizeof(StubReadEmbeddedVersionRequest), + 0, + stub_read_embedded_version_request__field_descriptors, + stub_read_embedded_version_request__field_indices_by_name, + 0, stub_read_embedded_version_request__number_ranges, + (ProtobufCMessageInit) stub_read_embedded_version_request__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubReadEmbeddedVersionRequest.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubReadEmbeddedVersionRequest.pb-c.h new file mode 100644 index 000000000..743536ba9 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubReadEmbeddedVersionRequest.pb-c.h @@ -0,0 +1,70 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubReadEmbeddedVersionRequest.proto */ + +#ifndef PROTOBUF_C_StubReadEmbeddedVersionRequest_2eproto__INCLUDED +#define PROTOBUF_C_StubReadEmbeddedVersionRequest_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 _StubReadEmbeddedVersionRequest StubReadEmbeddedVersionRequest; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StubReadEmbeddedVersionRequest +{ + ProtobufCMessage base; +}; +#define STUB_READ_EMBEDDED_VERSION_REQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stub_read_embedded_version_request__descriptor) \ + } + + +/* StubReadEmbeddedVersionRequest methods */ +void stub_read_embedded_version_request__init + (StubReadEmbeddedVersionRequest *message); +size_t stub_read_embedded_version_request__get_packed_size + (const StubReadEmbeddedVersionRequest *message); +size_t stub_read_embedded_version_request__pack + (const StubReadEmbeddedVersionRequest *message, + uint8_t *out); +size_t stub_read_embedded_version_request__pack_to_buffer + (const StubReadEmbeddedVersionRequest *message, + ProtobufCBuffer *buffer); +StubReadEmbeddedVersionRequest * + stub_read_embedded_version_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stub_read_embedded_version_request__free_unpacked + (StubReadEmbeddedVersionRequest *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StubReadEmbeddedVersionRequest_Closure) + (const StubReadEmbeddedVersionRequest *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stub_read_embedded_version_request__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StubReadEmbeddedVersionRequest_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubReadEmbeddedVersionResponse.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubReadEmbeddedVersionResponse.pb-c.c new file mode 100644 index 000000000..039aa440d --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubReadEmbeddedVersionResponse.pb-c.c @@ -0,0 +1,144 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubReadEmbeddedVersionResponse.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StubReadEmbeddedVersionResponse.pb-c.h" +void stub_read_embedded_version_response__init + (StubReadEmbeddedVersionResponse *message) +{ + static const StubReadEmbeddedVersionResponse init_value = STUB_READ_EMBEDDED_VERSION_RESPONSE__INIT; + *message = init_value; +} +size_t stub_read_embedded_version_response__get_packed_size + (const StubReadEmbeddedVersionResponse *message) +{ + assert(message->base.descriptor == &stub_read_embedded_version_response__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stub_read_embedded_version_response__pack + (const StubReadEmbeddedVersionResponse *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stub_read_embedded_version_response__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stub_read_embedded_version_response__pack_to_buffer + (const StubReadEmbeddedVersionResponse *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stub_read_embedded_version_response__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StubReadEmbeddedVersionResponse * + stub_read_embedded_version_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StubReadEmbeddedVersionResponse *) + protobuf_c_message_unpack (&stub_read_embedded_version_response__descriptor, + allocator, len, data); +} +void stub_read_embedded_version_response__free_unpacked + (StubReadEmbeddedVersionResponse *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stub_read_embedded_version_response__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor stub_read_embedded_version_response__field_descriptors[5] = +{ + { + "VerMajor", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubReadEmbeddedVersionResponse, has_vermajor), + offsetof(StubReadEmbeddedVersionResponse, vermajor), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "VerMinor", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubReadEmbeddedVersionResponse, has_verminor), + offsetof(StubReadEmbeddedVersionResponse, verminor), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "VerPatch", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubReadEmbeddedVersionResponse, has_verpatch), + offsetof(StubReadEmbeddedVersionResponse, verpatch), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "VerBuild", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubReadEmbeddedVersionResponse, has_verbuild), + offsetof(StubReadEmbeddedVersionResponse, verbuild), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Version", + 5, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(StubReadEmbeddedVersionResponse, version), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned stub_read_embedded_version_response__field_indices_by_name[] = { + 3, /* field[3] = VerBuild */ + 0, /* field[0] = VerMajor */ + 1, /* field[1] = VerMinor */ + 2, /* field[2] = VerPatch */ + 4, /* field[4] = Version */ +}; +static const ProtobufCIntRange stub_read_embedded_version_response__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 5 } +}; +const ProtobufCMessageDescriptor stub_read_embedded_version_response__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StubReadEmbeddedVersionResponse", + "StubReadEmbeddedVersionResponse", + "StubReadEmbeddedVersionResponse", + "", + sizeof(StubReadEmbeddedVersionResponse), + 5, + stub_read_embedded_version_response__field_descriptors, + stub_read_embedded_version_response__field_indices_by_name, + 1, stub_read_embedded_version_response__number_ranges, + (ProtobufCMessageInit) stub_read_embedded_version_response__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubReadEmbeddedVersionResponse.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubReadEmbeddedVersionResponse.pb-c.h new file mode 100644 index 000000000..3090d949a --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubReadEmbeddedVersionResponse.pb-c.h @@ -0,0 +1,79 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubReadEmbeddedVersionResponse.proto */ + +#ifndef PROTOBUF_C_StubReadEmbeddedVersionResponse_2eproto__INCLUDED +#define PROTOBUF_C_StubReadEmbeddedVersionResponse_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 _StubReadEmbeddedVersionResponse StubReadEmbeddedVersionResponse; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StubReadEmbeddedVersionResponse +{ + ProtobufCMessage base; + protobuf_c_boolean has_vermajor; + uint32_t vermajor; + protobuf_c_boolean has_verminor; + uint32_t verminor; + protobuf_c_boolean has_verpatch; + uint32_t verpatch; + protobuf_c_boolean has_verbuild; + uint32_t verbuild; + char *version; +}; +#define STUB_READ_EMBEDDED_VERSION_RESPONSE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stub_read_embedded_version_response__descriptor) \ + , 0, 0, 0, 0, 0, 0, 0, 0, NULL } + + +/* StubReadEmbeddedVersionResponse methods */ +void stub_read_embedded_version_response__init + (StubReadEmbeddedVersionResponse *message); +size_t stub_read_embedded_version_response__get_packed_size + (const StubReadEmbeddedVersionResponse *message); +size_t stub_read_embedded_version_response__pack + (const StubReadEmbeddedVersionResponse *message, + uint8_t *out); +size_t stub_read_embedded_version_response__pack_to_buffer + (const StubReadEmbeddedVersionResponse *message, + ProtobufCBuffer *buffer); +StubReadEmbeddedVersionResponse * + stub_read_embedded_version_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stub_read_embedded_version_response__free_unpacked + (StubReadEmbeddedVersionResponse *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StubReadEmbeddedVersionResponse_Closure) + (const StubReadEmbeddedVersionResponse *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stub_read_embedded_version_response__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StubReadEmbeddedVersionResponse_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubRealTimeUsageRequest.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubRealTimeUsageRequest.pb-c.c new file mode 100644 index 000000000..27354512b --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubRealTimeUsageRequest.pb-c.c @@ -0,0 +1,72 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubRealTimeUsageRequest.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StubRealTimeUsageRequest.pb-c.h" +void stub_real_time_usage_request__init + (StubRealTimeUsageRequest *message) +{ + static const StubRealTimeUsageRequest init_value = STUB_REAL_TIME_USAGE_REQUEST__INIT; + *message = init_value; +} +size_t stub_real_time_usage_request__get_packed_size + (const StubRealTimeUsageRequest *message) +{ + assert(message->base.descriptor == &stub_real_time_usage_request__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stub_real_time_usage_request__pack + (const StubRealTimeUsageRequest *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stub_real_time_usage_request__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stub_real_time_usage_request__pack_to_buffer + (const StubRealTimeUsageRequest *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stub_real_time_usage_request__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StubRealTimeUsageRequest * + stub_real_time_usage_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StubRealTimeUsageRequest *) + protobuf_c_message_unpack (&stub_real_time_usage_request__descriptor, + allocator, len, data); +} +void stub_real_time_usage_request__free_unpacked + (StubRealTimeUsageRequest *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stub_real_time_usage_request__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +#define stub_real_time_usage_request__field_descriptors NULL +#define stub_real_time_usage_request__field_indices_by_name NULL +#define stub_real_time_usage_request__number_ranges NULL +const ProtobufCMessageDescriptor stub_real_time_usage_request__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StubRealTimeUsageRequest", + "StubRealTimeUsageRequest", + "StubRealTimeUsageRequest", + "", + sizeof(StubRealTimeUsageRequest), + 0, + stub_real_time_usage_request__field_descriptors, + stub_real_time_usage_request__field_indices_by_name, + 0, stub_real_time_usage_request__number_ranges, + (ProtobufCMessageInit) stub_real_time_usage_request__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubRealTimeUsageRequest.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubRealTimeUsageRequest.pb-c.h new file mode 100644 index 000000000..e207ebf43 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubRealTimeUsageRequest.pb-c.h @@ -0,0 +1,70 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubRealTimeUsageRequest.proto */ + +#ifndef PROTOBUF_C_StubRealTimeUsageRequest_2eproto__INCLUDED +#define PROTOBUF_C_StubRealTimeUsageRequest_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 _StubRealTimeUsageRequest StubRealTimeUsageRequest; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StubRealTimeUsageRequest +{ + ProtobufCMessage base; +}; +#define STUB_REAL_TIME_USAGE_REQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stub_real_time_usage_request__descriptor) \ + } + + +/* StubRealTimeUsageRequest methods */ +void stub_real_time_usage_request__init + (StubRealTimeUsageRequest *message); +size_t stub_real_time_usage_request__get_packed_size + (const StubRealTimeUsageRequest *message); +size_t stub_real_time_usage_request__pack + (const StubRealTimeUsageRequest *message, + uint8_t *out); +size_t stub_real_time_usage_request__pack_to_buffer + (const StubRealTimeUsageRequest *message, + ProtobufCBuffer *buffer); +StubRealTimeUsageRequest * + stub_real_time_usage_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stub_real_time_usage_request__free_unpacked + (StubRealTimeUsageRequest *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StubRealTimeUsageRequest_Closure) + (const StubRealTimeUsageRequest *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stub_real_time_usage_request__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StubRealTimeUsageRequest_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubRealTimeUsageResponse.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubRealTimeUsageResponse.pb-c.c new file mode 100644 index 000000000..2e06502cb --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubRealTimeUsageResponse.pb-c.c @@ -0,0 +1,92 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubRealTimeUsageResponse.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StubRealTimeUsageResponse.pb-c.h" +void stub_real_time_usage_response__init + (StubRealTimeUsageResponse *message) +{ + static const StubRealTimeUsageResponse init_value = STUB_REAL_TIME_USAGE_RESPONSE__INIT; + *message = init_value; +} +size_t stub_real_time_usage_response__get_packed_size + (const StubRealTimeUsageResponse *message) +{ + assert(message->base.descriptor == &stub_real_time_usage_response__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stub_real_time_usage_response__pack + (const StubRealTimeUsageResponse *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stub_real_time_usage_response__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stub_real_time_usage_response__pack_to_buffer + (const StubRealTimeUsageResponse *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stub_real_time_usage_response__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StubRealTimeUsageResponse * + stub_real_time_usage_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StubRealTimeUsageResponse *) + protobuf_c_message_unpack (&stub_real_time_usage_response__descriptor, + allocator, len, data); +} +void stub_real_time_usage_response__free_unpacked + (StubRealTimeUsageResponse *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stub_real_time_usage_response__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor stub_real_time_usage_response__field_descriptors[1] = +{ + { + "Percentile", + 1, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubRealTimeUsageResponse, n_percentile), + offsetof(StubRealTimeUsageResponse, percentile), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned stub_real_time_usage_response__field_indices_by_name[] = { + 0, /* field[0] = Percentile */ +}; +static const ProtobufCIntRange stub_real_time_usage_response__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor stub_real_time_usage_response__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StubRealTimeUsageResponse", + "StubRealTimeUsageResponse", + "StubRealTimeUsageResponse", + "", + sizeof(StubRealTimeUsageResponse), + 1, + stub_real_time_usage_response__field_descriptors, + stub_real_time_usage_response__field_indices_by_name, + 1, stub_real_time_usage_response__number_ranges, + (ProtobufCMessageInit) stub_real_time_usage_response__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubRealTimeUsageResponse.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubRealTimeUsageResponse.pb-c.h new file mode 100644 index 000000000..2da252f81 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubRealTimeUsageResponse.pb-c.h @@ -0,0 +1,75 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubRealTimeUsageResponse.proto */ + +#ifndef PROTOBUF_C_StubRealTimeUsageResponse_2eproto__INCLUDED +#define PROTOBUF_C_StubRealTimeUsageResponse_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 _StubRealTimeUsageResponse StubRealTimeUsageResponse; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StubRealTimeUsageResponse +{ + ProtobufCMessage base; + /* + * 0..100 + */ + size_t n_percentile; + uint32_t *percentile; +}; +#define STUB_REAL_TIME_USAGE_RESPONSE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stub_real_time_usage_response__descriptor) \ + , 0,NULL } + + +/* StubRealTimeUsageResponse methods */ +void stub_real_time_usage_response__init + (StubRealTimeUsageResponse *message); +size_t stub_real_time_usage_response__get_packed_size + (const StubRealTimeUsageResponse *message); +size_t stub_real_time_usage_response__pack + (const StubRealTimeUsageResponse *message, + uint8_t *out); +size_t stub_real_time_usage_response__pack_to_buffer + (const StubRealTimeUsageResponse *message, + ProtobufCBuffer *buffer); +StubRealTimeUsageResponse * + stub_real_time_usage_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stub_real_time_usage_response__free_unpacked + (StubRealTimeUsageResponse *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StubRealTimeUsageResponse_Closure) + (const StubRealTimeUsageResponse *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stub_real_time_usage_response__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StubRealTimeUsageResponse_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubSpeedSensorRequest.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubSpeedSensorRequest.pb-c.c new file mode 100644 index 000000000..ae9b29573 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubSpeedSensorRequest.pb-c.c @@ -0,0 +1,72 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubSpeedSensorRequest.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StubSpeedSensorRequest.pb-c.h" +void stub_speed_sensor_request__init + (StubSpeedSensorRequest *message) +{ + static const StubSpeedSensorRequest init_value = STUB_SPEED_SENSOR_REQUEST__INIT; + *message = init_value; +} +size_t stub_speed_sensor_request__get_packed_size + (const StubSpeedSensorRequest *message) +{ + assert(message->base.descriptor == &stub_speed_sensor_request__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stub_speed_sensor_request__pack + (const StubSpeedSensorRequest *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stub_speed_sensor_request__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stub_speed_sensor_request__pack_to_buffer + (const StubSpeedSensorRequest *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stub_speed_sensor_request__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StubSpeedSensorRequest * + stub_speed_sensor_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StubSpeedSensorRequest *) + protobuf_c_message_unpack (&stub_speed_sensor_request__descriptor, + allocator, len, data); +} +void stub_speed_sensor_request__free_unpacked + (StubSpeedSensorRequest *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stub_speed_sensor_request__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +#define stub_speed_sensor_request__field_descriptors NULL +#define stub_speed_sensor_request__field_indices_by_name NULL +#define stub_speed_sensor_request__number_ranges NULL +const ProtobufCMessageDescriptor stub_speed_sensor_request__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StubSpeedSensorRequest", + "StubSpeedSensorRequest", + "StubSpeedSensorRequest", + "", + sizeof(StubSpeedSensorRequest), + 0, + stub_speed_sensor_request__field_descriptors, + stub_speed_sensor_request__field_indices_by_name, + 0, stub_speed_sensor_request__number_ranges, + (ProtobufCMessageInit) stub_speed_sensor_request__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubSpeedSensorRequest.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubSpeedSensorRequest.pb-c.h new file mode 100644 index 000000000..1393f5c12 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubSpeedSensorRequest.pb-c.h @@ -0,0 +1,70 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubSpeedSensorRequest.proto */ + +#ifndef PROTOBUF_C_StubSpeedSensorRequest_2eproto__INCLUDED +#define PROTOBUF_C_StubSpeedSensorRequest_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 _StubSpeedSensorRequest StubSpeedSensorRequest; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StubSpeedSensorRequest +{ + ProtobufCMessage base; +}; +#define STUB_SPEED_SENSOR_REQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stub_speed_sensor_request__descriptor) \ + } + + +/* StubSpeedSensorRequest methods */ +void stub_speed_sensor_request__init + (StubSpeedSensorRequest *message); +size_t stub_speed_sensor_request__get_packed_size + (const StubSpeedSensorRequest *message); +size_t stub_speed_sensor_request__pack + (const StubSpeedSensorRequest *message, + uint8_t *out); +size_t stub_speed_sensor_request__pack_to_buffer + (const StubSpeedSensorRequest *message, + ProtobufCBuffer *buffer); +StubSpeedSensorRequest * + stub_speed_sensor_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stub_speed_sensor_request__free_unpacked + (StubSpeedSensorRequest *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StubSpeedSensorRequest_Closure) + (const StubSpeedSensorRequest *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stub_speed_sensor_request__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StubSpeedSensorRequest_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubSpeedSensorResponse.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubSpeedSensorResponse.pb-c.c new file mode 100644 index 000000000..8daa3feeb --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubSpeedSensorResponse.pb-c.c @@ -0,0 +1,92 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubSpeedSensorResponse.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StubSpeedSensorResponse.pb-c.h" +void stub_speed_sensor_response__init + (StubSpeedSensorResponse *message) +{ + static const StubSpeedSensorResponse init_value = STUB_SPEED_SENSOR_RESPONSE__INIT; + *message = init_value; +} +size_t stub_speed_sensor_response__get_packed_size + (const StubSpeedSensorResponse *message) +{ + assert(message->base.descriptor == &stub_speed_sensor_response__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stub_speed_sensor_response__pack + (const StubSpeedSensorResponse *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stub_speed_sensor_response__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stub_speed_sensor_response__pack_to_buffer + (const StubSpeedSensorResponse *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stub_speed_sensor_response__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StubSpeedSensorResponse * + stub_speed_sensor_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StubSpeedSensorResponse *) + protobuf_c_message_unpack (&stub_speed_sensor_response__descriptor, + allocator, len, data); +} +void stub_speed_sensor_response__free_unpacked + (StubSpeedSensorResponse *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stub_speed_sensor_response__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor stub_speed_sensor_response__field_descriptors[1] = +{ + { + "Speed", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubSpeedSensorResponse, has_speed), + offsetof(StubSpeedSensorResponse, speed), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned stub_speed_sensor_response__field_indices_by_name[] = { + 0, /* field[0] = Speed */ +}; +static const ProtobufCIntRange stub_speed_sensor_response__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor stub_speed_sensor_response__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StubSpeedSensorResponse", + "StubSpeedSensorResponse", + "StubSpeedSensorResponse", + "", + sizeof(StubSpeedSensorResponse), + 1, + stub_speed_sensor_response__field_descriptors, + stub_speed_sensor_response__field_indices_by_name, + 1, stub_speed_sensor_response__number_ranges, + (ProtobufCMessageInit) stub_speed_sensor_response__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubSpeedSensorResponse.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubSpeedSensorResponse.pb-c.h new file mode 100644 index 000000000..6bc9cfa68 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubSpeedSensorResponse.pb-c.h @@ -0,0 +1,75 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubSpeedSensorResponse.proto */ + +#ifndef PROTOBUF_C_StubSpeedSensorResponse_2eproto__INCLUDED +#define PROTOBUF_C_StubSpeedSensorResponse_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 _StubSpeedSensorResponse StubSpeedSensorResponse; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StubSpeedSensorResponse +{ + ProtobufCMessage base; + /* + *uint32 Speed_Sensor_ID = 1; + */ + protobuf_c_boolean has_speed; + uint32_t speed; +}; +#define STUB_SPEED_SENSOR_RESPONSE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stub_speed_sensor_response__descriptor) \ + , 0, 0 } + + +/* StubSpeedSensorResponse methods */ +void stub_speed_sensor_response__init + (StubSpeedSensorResponse *message); +size_t stub_speed_sensor_response__get_packed_size + (const StubSpeedSensorResponse *message); +size_t stub_speed_sensor_response__pack + (const StubSpeedSensorResponse *message, + uint8_t *out); +size_t stub_speed_sensor_response__pack_to_buffer + (const StubSpeedSensorResponse *message, + ProtobufCBuffer *buffer); +StubSpeedSensorResponse * + stub_speed_sensor_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stub_speed_sensor_response__free_unpacked + (StubSpeedSensorResponse *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StubSpeedSensorResponse_Closure) + (const StubSpeedSensorResponse *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stub_speed_sensor_response__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StubSpeedSensorResponse_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTempSensorRequest.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTempSensorRequest.pb-c.c new file mode 100644 index 000000000..7d353b7a3 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTempSensorRequest.pb-c.c @@ -0,0 +1,92 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubTempSensorRequest.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StubTempSensorRequest.pb-c.h" +void stub_temp_sensor_request__init + (StubTempSensorRequest *message) +{ + static const StubTempSensorRequest init_value = STUB_TEMP_SENSOR_REQUEST__INIT; + *message = init_value; +} +size_t stub_temp_sensor_request__get_packed_size + (const StubTempSensorRequest *message) +{ + assert(message->base.descriptor == &stub_temp_sensor_request__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stub_temp_sensor_request__pack + (const StubTempSensorRequest *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stub_temp_sensor_request__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stub_temp_sensor_request__pack_to_buffer + (const StubTempSensorRequest *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stub_temp_sensor_request__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StubTempSensorRequest * + stub_temp_sensor_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StubTempSensorRequest *) + protobuf_c_message_unpack (&stub_temp_sensor_request__descriptor, + allocator, len, data); +} +void stub_temp_sensor_request__free_unpacked + (StubTempSensorRequest *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stub_temp_sensor_request__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor stub_temp_sensor_request__field_descriptors[1] = +{ + { + "STemp_Sensor_ID", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubTempSensorRequest, has_stemp_sensor_id), + offsetof(StubTempSensorRequest, stemp_sensor_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned stub_temp_sensor_request__field_indices_by_name[] = { + 0, /* field[0] = STemp_Sensor_ID */ +}; +static const ProtobufCIntRange stub_temp_sensor_request__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor stub_temp_sensor_request__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StubTempSensorRequest", + "StubTempSensorRequest", + "StubTempSensorRequest", + "", + sizeof(StubTempSensorRequest), + 1, + stub_temp_sensor_request__field_descriptors, + stub_temp_sensor_request__field_indices_by_name, + 1, stub_temp_sensor_request__number_ranges, + (ProtobufCMessageInit) stub_temp_sensor_request__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTempSensorRequest.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTempSensorRequest.pb-c.h new file mode 100644 index 000000000..4f132efd2 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTempSensorRequest.pb-c.h @@ -0,0 +1,72 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubTempSensorRequest.proto */ + +#ifndef PROTOBUF_C_StubTempSensorRequest_2eproto__INCLUDED +#define PROTOBUF_C_StubTempSensorRequest_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 _StubTempSensorRequest StubTempSensorRequest; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StubTempSensorRequest +{ + ProtobufCMessage base; + protobuf_c_boolean has_stemp_sensor_id; + uint32_t stemp_sensor_id; +}; +#define STUB_TEMP_SENSOR_REQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stub_temp_sensor_request__descriptor) \ + , 0, 0 } + + +/* StubTempSensorRequest methods */ +void stub_temp_sensor_request__init + (StubTempSensorRequest *message); +size_t stub_temp_sensor_request__get_packed_size + (const StubTempSensorRequest *message); +size_t stub_temp_sensor_request__pack + (const StubTempSensorRequest *message, + uint8_t *out); +size_t stub_temp_sensor_request__pack_to_buffer + (const StubTempSensorRequest *message, + ProtobufCBuffer *buffer); +StubTempSensorRequest * + stub_temp_sensor_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stub_temp_sensor_request__free_unpacked + (StubTempSensorRequest *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StubTempSensorRequest_Closure) + (const StubTempSensorRequest *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stub_temp_sensor_request__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StubTempSensorRequest_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTempSensorResponse.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTempSensorResponse.pb-c.c new file mode 100644 index 000000000..77503aff0 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTempSensorResponse.pb-c.c @@ -0,0 +1,105 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubTempSensorResponse.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StubTempSensorResponse.pb-c.h" +void stub_temp_sensor_response__init + (StubTempSensorResponse *message) +{ + static const StubTempSensorResponse init_value = STUB_TEMP_SENSOR_RESPONSE__INIT; + *message = init_value; +} +size_t stub_temp_sensor_response__get_packed_size + (const StubTempSensorResponse *message) +{ + assert(message->base.descriptor == &stub_temp_sensor_response__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stub_temp_sensor_response__pack + (const StubTempSensorResponse *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stub_temp_sensor_response__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stub_temp_sensor_response__pack_to_buffer + (const StubTempSensorResponse *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stub_temp_sensor_response__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StubTempSensorResponse * + stub_temp_sensor_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StubTempSensorResponse *) + protobuf_c_message_unpack (&stub_temp_sensor_response__descriptor, + allocator, len, data); +} +void stub_temp_sensor_response__free_unpacked + (StubTempSensorResponse *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stub_temp_sensor_response__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor stub_temp_sensor_response__field_descriptors[2] = +{ + { + "Temp_Sensor_ID", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubTempSensorResponse, has_temp_sensor_id), + offsetof(StubTempSensorResponse, temp_sensor_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Temperature_C_Mult_By_100", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubTempSensorResponse, has_temperature_c_mult_by_100), + offsetof(StubTempSensorResponse, temperature_c_mult_by_100), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned stub_temp_sensor_response__field_indices_by_name[] = { + 0, /* field[0] = Temp_Sensor_ID */ + 1, /* field[1] = Temperature_C_Mult_By_100 */ +}; +static const ProtobufCIntRange stub_temp_sensor_response__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor stub_temp_sensor_response__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StubTempSensorResponse", + "StubTempSensorResponse", + "StubTempSensorResponse", + "", + sizeof(StubTempSensorResponse), + 2, + stub_temp_sensor_response__field_descriptors, + stub_temp_sensor_response__field_indices_by_name, + 1, stub_temp_sensor_response__number_ranges, + (ProtobufCMessageInit) stub_temp_sensor_response__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTempSensorResponse.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTempSensorResponse.pb-c.h new file mode 100644 index 000000000..e1208d082 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTempSensorResponse.pb-c.h @@ -0,0 +1,74 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubTempSensorResponse.proto */ + +#ifndef PROTOBUF_C_StubTempSensorResponse_2eproto__INCLUDED +#define PROTOBUF_C_StubTempSensorResponse_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 _StubTempSensorResponse StubTempSensorResponse; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StubTempSensorResponse +{ + ProtobufCMessage base; + protobuf_c_boolean has_temp_sensor_id; + uint32_t temp_sensor_id; + protobuf_c_boolean has_temperature_c_mult_by_100; + uint32_t temperature_c_mult_by_100; +}; +#define STUB_TEMP_SENSOR_RESPONSE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stub_temp_sensor_response__descriptor) \ + , 0, 0, 0, 0 } + + +/* StubTempSensorResponse methods */ +void stub_temp_sensor_response__init + (StubTempSensorResponse *message); +size_t stub_temp_sensor_response__get_packed_size + (const StubTempSensorResponse *message); +size_t stub_temp_sensor_response__pack + (const StubTempSensorResponse *message, + uint8_t *out); +size_t stub_temp_sensor_response__pack_to_buffer + (const StubTempSensorResponse *message, + ProtobufCBuffer *buffer); +StubTempSensorResponse * + stub_temp_sensor_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stub_temp_sensor_response__free_unpacked + (StubTempSensorResponse *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StubTempSensorResponse_Closure) + (const StubTempSensorResponse *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stub_temp_sensor_response__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StubTempSensorResponse_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTivaReadRegRequest.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTivaReadRegRequest.pb-c.c new file mode 100644 index 000000000..0075f3900 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTivaReadRegRequest.pb-c.c @@ -0,0 +1,92 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubTivaReadRegRequest.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StubTivaReadRegRequest.pb-c.h" +void stub_tiva_read_reg_request__init + (StubTivaReadRegRequest *message) +{ + static const StubTivaReadRegRequest init_value = STUB_TIVA_READ_REG_REQUEST__INIT; + *message = init_value; +} +size_t stub_tiva_read_reg_request__get_packed_size + (const StubTivaReadRegRequest *message) +{ + assert(message->base.descriptor == &stub_tiva_read_reg_request__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stub_tiva_read_reg_request__pack + (const StubTivaReadRegRequest *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stub_tiva_read_reg_request__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stub_tiva_read_reg_request__pack_to_buffer + (const StubTivaReadRegRequest *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stub_tiva_read_reg_request__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StubTivaReadRegRequest * + stub_tiva_read_reg_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StubTivaReadRegRequest *) + protobuf_c_message_unpack (&stub_tiva_read_reg_request__descriptor, + allocator, len, data); +} +void stub_tiva_read_reg_request__free_unpacked + (StubTivaReadRegRequest *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stub_tiva_read_reg_request__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor stub_tiva_read_reg_request__field_descriptors[1] = +{ + { + "Address", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubTivaReadRegRequest, has_address), + offsetof(StubTivaReadRegRequest, address), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned stub_tiva_read_reg_request__field_indices_by_name[] = { + 0, /* field[0] = Address */ +}; +static const ProtobufCIntRange stub_tiva_read_reg_request__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor stub_tiva_read_reg_request__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StubTivaReadRegRequest", + "StubTivaReadRegRequest", + "StubTivaReadRegRequest", + "", + sizeof(StubTivaReadRegRequest), + 1, + stub_tiva_read_reg_request__field_descriptors, + stub_tiva_read_reg_request__field_indices_by_name, + 1, stub_tiva_read_reg_request__number_ranges, + (ProtobufCMessageInit) stub_tiva_read_reg_request__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTivaReadRegRequest.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTivaReadRegRequest.pb-c.h new file mode 100644 index 000000000..96fd7c4d1 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTivaReadRegRequest.pb-c.h @@ -0,0 +1,72 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubTivaReadRegRequest.proto */ + +#ifndef PROTOBUF_C_StubTivaReadRegRequest_2eproto__INCLUDED +#define PROTOBUF_C_StubTivaReadRegRequest_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 _StubTivaReadRegRequest StubTivaReadRegRequest; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StubTivaReadRegRequest +{ + ProtobufCMessage base; + protobuf_c_boolean has_address; + uint32_t address; +}; +#define STUB_TIVA_READ_REG_REQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stub_tiva_read_reg_request__descriptor) \ + , 0, 0 } + + +/* StubTivaReadRegRequest methods */ +void stub_tiva_read_reg_request__init + (StubTivaReadRegRequest *message); +size_t stub_tiva_read_reg_request__get_packed_size + (const StubTivaReadRegRequest *message); +size_t stub_tiva_read_reg_request__pack + (const StubTivaReadRegRequest *message, + uint8_t *out); +size_t stub_tiva_read_reg_request__pack_to_buffer + (const StubTivaReadRegRequest *message, + ProtobufCBuffer *buffer); +StubTivaReadRegRequest * + stub_tiva_read_reg_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stub_tiva_read_reg_request__free_unpacked + (StubTivaReadRegRequest *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StubTivaReadRegRequest_Closure) + (const StubTivaReadRegRequest *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stub_tiva_read_reg_request__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StubTivaReadRegRequest_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTivaReadRegResponse.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTivaReadRegResponse.pb-c.c new file mode 100644 index 000000000..34bddc069 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTivaReadRegResponse.pb-c.c @@ -0,0 +1,131 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubTivaReadRegResponse.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StubTivaReadRegResponse.pb-c.h" +void stub_tiva_read_reg_response__init + (StubTivaReadRegResponse *message) +{ + static const StubTivaReadRegResponse init_value = STUB_TIVA_READ_REG_RESPONSE__INIT; + *message = init_value; +} +size_t stub_tiva_read_reg_response__get_packed_size + (const StubTivaReadRegResponse *message) +{ + assert(message->base.descriptor == &stub_tiva_read_reg_response__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stub_tiva_read_reg_response__pack + (const StubTivaReadRegResponse *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stub_tiva_read_reg_response__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stub_tiva_read_reg_response__pack_to_buffer + (const StubTivaReadRegResponse *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stub_tiva_read_reg_response__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StubTivaReadRegResponse * + stub_tiva_read_reg_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StubTivaReadRegResponse *) + protobuf_c_message_unpack (&stub_tiva_read_reg_response__descriptor, + allocator, len, data); +} +void stub_tiva_read_reg_response__free_unpacked + (StubTivaReadRegResponse *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stub_tiva_read_reg_response__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor stub_tiva_read_reg_response__field_descriptors[4] = +{ + { + "Address", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubTivaReadRegResponse, has_address), + offsetof(StubTivaReadRegResponse, address), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Value", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubTivaReadRegResponse, has_value), + offsetof(StubTivaReadRegResponse, value), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Status", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(StubTivaReadRegResponse, status), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "StatusWord", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubTivaReadRegResponse, has_statusword), + offsetof(StubTivaReadRegResponse, statusword), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned stub_tiva_read_reg_response__field_indices_by_name[] = { + 0, /* field[0] = Address */ + 2, /* field[2] = Status */ + 3, /* field[3] = StatusWord */ + 1, /* field[1] = Value */ +}; +static const ProtobufCIntRange stub_tiva_read_reg_response__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor stub_tiva_read_reg_response__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StubTivaReadRegResponse", + "StubTivaReadRegResponse", + "StubTivaReadRegResponse", + "", + sizeof(StubTivaReadRegResponse), + 4, + stub_tiva_read_reg_response__field_descriptors, + stub_tiva_read_reg_response__field_indices_by_name, + 1, stub_tiva_read_reg_response__number_ranges, + (ProtobufCMessageInit) stub_tiva_read_reg_response__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTivaReadRegResponse.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTivaReadRegResponse.pb-c.h new file mode 100644 index 000000000..d1235a475 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTivaReadRegResponse.pb-c.h @@ -0,0 +1,83 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubTivaReadRegResponse.proto */ + +#ifndef PROTOBUF_C_StubTivaReadRegResponse_2eproto__INCLUDED +#define PROTOBUF_C_StubTivaReadRegResponse_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 _StubTivaReadRegResponse StubTivaReadRegResponse; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StubTivaReadRegResponse +{ + ProtobufCMessage base; + protobuf_c_boolean has_address; + uint32_t address; + protobuf_c_boolean has_value; + uint32_t value; + /* + * Passed/Failed + */ + char *status; + /* + * Error number/bit when the status is Failed + */ + protobuf_c_boolean has_statusword; + uint32_t statusword; +}; +#define STUB_TIVA_READ_REG_RESPONSE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stub_tiva_read_reg_response__descriptor) \ + , 0, 0, 0, 0, NULL, 0, 0 } + + +/* StubTivaReadRegResponse methods */ +void stub_tiva_read_reg_response__init + (StubTivaReadRegResponse *message); +size_t stub_tiva_read_reg_response__get_packed_size + (const StubTivaReadRegResponse *message); +size_t stub_tiva_read_reg_response__pack + (const StubTivaReadRegResponse *message, + uint8_t *out); +size_t stub_tiva_read_reg_response__pack_to_buffer + (const StubTivaReadRegResponse *message, + ProtobufCBuffer *buffer); +StubTivaReadRegResponse * + stub_tiva_read_reg_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stub_tiva_read_reg_response__free_unpacked + (StubTivaReadRegResponse *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StubTivaReadRegResponse_Closure) + (const StubTivaReadRegResponse *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stub_tiva_read_reg_response__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StubTivaReadRegResponse_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTivaWriteRegRequest.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTivaWriteRegRequest.pb-c.c new file mode 100644 index 000000000..febee0760 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTivaWriteRegRequest.pb-c.c @@ -0,0 +1,105 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubTivaWriteRegRequest.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StubTivaWriteRegRequest.pb-c.h" +void stub_tiva_write_reg_request__init + (StubTivaWriteRegRequest *message) +{ + static const StubTivaWriteRegRequest init_value = STUB_TIVA_WRITE_REG_REQUEST__INIT; + *message = init_value; +} +size_t stub_tiva_write_reg_request__get_packed_size + (const StubTivaWriteRegRequest *message) +{ + assert(message->base.descriptor == &stub_tiva_write_reg_request__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stub_tiva_write_reg_request__pack + (const StubTivaWriteRegRequest *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stub_tiva_write_reg_request__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stub_tiva_write_reg_request__pack_to_buffer + (const StubTivaWriteRegRequest *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stub_tiva_write_reg_request__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StubTivaWriteRegRequest * + stub_tiva_write_reg_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StubTivaWriteRegRequest *) + protobuf_c_message_unpack (&stub_tiva_write_reg_request__descriptor, + allocator, len, data); +} +void stub_tiva_write_reg_request__free_unpacked + (StubTivaWriteRegRequest *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stub_tiva_write_reg_request__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor stub_tiva_write_reg_request__field_descriptors[2] = +{ + { + "Address", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubTivaWriteRegRequest, has_address), + offsetof(StubTivaWriteRegRequest, address), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Value", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubTivaWriteRegRequest, has_value), + offsetof(StubTivaWriteRegRequest, value), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned stub_tiva_write_reg_request__field_indices_by_name[] = { + 0, /* field[0] = Address */ + 1, /* field[1] = Value */ +}; +static const ProtobufCIntRange stub_tiva_write_reg_request__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor stub_tiva_write_reg_request__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StubTivaWriteRegRequest", + "StubTivaWriteRegRequest", + "StubTivaWriteRegRequest", + "", + sizeof(StubTivaWriteRegRequest), + 2, + stub_tiva_write_reg_request__field_descriptors, + stub_tiva_write_reg_request__field_indices_by_name, + 1, stub_tiva_write_reg_request__number_ranges, + (ProtobufCMessageInit) stub_tiva_write_reg_request__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTivaWriteRegRequest.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTivaWriteRegRequest.pb-c.h new file mode 100644 index 000000000..6b33f4da6 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTivaWriteRegRequest.pb-c.h @@ -0,0 +1,74 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubTivaWriteRegRequest.proto */ + +#ifndef PROTOBUF_C_StubTivaWriteRegRequest_2eproto__INCLUDED +#define PROTOBUF_C_StubTivaWriteRegRequest_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 _StubTivaWriteRegRequest StubTivaWriteRegRequest; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StubTivaWriteRegRequest +{ + ProtobufCMessage base; + protobuf_c_boolean has_address; + uint32_t address; + protobuf_c_boolean has_value; + uint32_t value; +}; +#define STUB_TIVA_WRITE_REG_REQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stub_tiva_write_reg_request__descriptor) \ + , 0, 0, 0, 0 } + + +/* StubTivaWriteRegRequest methods */ +void stub_tiva_write_reg_request__init + (StubTivaWriteRegRequest *message); +size_t stub_tiva_write_reg_request__get_packed_size + (const StubTivaWriteRegRequest *message); +size_t stub_tiva_write_reg_request__pack + (const StubTivaWriteRegRequest *message, + uint8_t *out); +size_t stub_tiva_write_reg_request__pack_to_buffer + (const StubTivaWriteRegRequest *message, + ProtobufCBuffer *buffer); +StubTivaWriteRegRequest * + stub_tiva_write_reg_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stub_tiva_write_reg_request__free_unpacked + (StubTivaWriteRegRequest *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StubTivaWriteRegRequest_Closure) + (const StubTivaWriteRegRequest *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stub_tiva_write_reg_request__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StubTivaWriteRegRequest_2eproto__INCLUDED */ diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTivaWriteRegResponse.pb-c.c b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTivaWriteRegResponse.pb-c.c new file mode 100644 index 000000000..d57d9cf20 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTivaWriteRegResponse.pb-c.c @@ -0,0 +1,105 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubTivaWriteRegResponse.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StubTivaWriteRegResponse.pb-c.h" +void stub_tiva_write_reg_response__init + (StubTivaWriteRegResponse *message) +{ + static const StubTivaWriteRegResponse init_value = STUB_TIVA_WRITE_REG_RESPONSE__INIT; + *message = init_value; +} +size_t stub_tiva_write_reg_response__get_packed_size + (const StubTivaWriteRegResponse *message) +{ + assert(message->base.descriptor == &stub_tiva_write_reg_response__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stub_tiva_write_reg_response__pack + (const StubTivaWriteRegResponse *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stub_tiva_write_reg_response__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stub_tiva_write_reg_response__pack_to_buffer + (const StubTivaWriteRegResponse *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stub_tiva_write_reg_response__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StubTivaWriteRegResponse * + stub_tiva_write_reg_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StubTivaWriteRegResponse *) + protobuf_c_message_unpack (&stub_tiva_write_reg_response__descriptor, + allocator, len, data); +} +void stub_tiva_write_reg_response__free_unpacked + (StubTivaWriteRegResponse *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stub_tiva_write_reg_response__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor stub_tiva_write_reg_response__field_descriptors[2] = +{ + { + "Status", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(StubTivaWriteRegResponse, status), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "StatusWord", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(StubTivaWriteRegResponse, has_statusword), + offsetof(StubTivaWriteRegResponse, statusword), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned stub_tiva_write_reg_response__field_indices_by_name[] = { + 0, /* field[0] = Status */ + 1, /* field[1] = StatusWord */ +}; +static const ProtobufCIntRange stub_tiva_write_reg_response__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor stub_tiva_write_reg_response__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StubTivaWriteRegResponse", + "StubTivaWriteRegResponse", + "StubTivaWriteRegResponse", + "", + sizeof(StubTivaWriteRegResponse), + 2, + stub_tiva_write_reg_response__field_descriptors, + stub_tiva_write_reg_response__field_indices_by_name, + 1, stub_tiva_write_reg_response__number_ranges, + (ProtobufCMessageInit) stub_tiva_write_reg_response__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTivaWriteRegResponse.pb-c.h b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTivaWriteRegResponse.pb-c.h new file mode 100644 index 000000000..60966fdf2 --- /dev/null +++ b/Software/Code_Composer/twine_usblib_demo/PMR/Stubs/StubTivaWriteRegResponse.pb-c.h @@ -0,0 +1,79 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StubTivaWriteRegResponse.proto */ + +#ifndef PROTOBUF_C_StubTivaWriteRegResponse_2eproto__INCLUDED +#define PROTOBUF_C_StubTivaWriteRegResponse_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 _StubTivaWriteRegResponse StubTivaWriteRegResponse; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StubTivaWriteRegResponse +{ + ProtobufCMessage base; + /* + * Passed/Failed + */ + char *status; + /* + * Error number/bit when the status is Failed + */ + protobuf_c_boolean has_statusword; + uint32_t statusword; +}; +#define STUB_TIVA_WRITE_REG_RESPONSE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stub_tiva_write_reg_response__descriptor) \ + , NULL, 0, 0 } + + +/* StubTivaWriteRegResponse methods */ +void stub_tiva_write_reg_response__init + (StubTivaWriteRegResponse *message); +size_t stub_tiva_write_reg_response__get_packed_size + (const StubTivaWriteRegResponse *message); +size_t stub_tiva_write_reg_response__pack + (const StubTivaWriteRegResponse *message, + uint8_t *out); +size_t stub_tiva_write_reg_response__pack_to_buffer + (const StubTivaWriteRegResponse *message, + ProtobufCBuffer *buffer); +StubTivaWriteRegResponse * + stub_tiva_write_reg_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stub_tiva_write_reg_response__free_unpacked + (StubTivaWriteRegResponse *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StubTivaWriteRegResponse_Closure) + (const StubTivaWriteRegResponse *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stub_tiva_write_reg_response__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StubTivaWriteRegResponse_2eproto__INCLUDED */ |