diff --git a/inc/ECSS_Definitions.hpp b/inc/ECSS_Definitions.hpp
index 216ea418d9ed7f8912a887ca00839fa939cde4b4..5f8b5ef24bde1effc062e50dfc6ff87d2d2bf818 100644
--- a/inc/ECSS_Definitions.hpp
+++ b/inc/ECSS_Definitions.hpp
@@ -1,6 +1,7 @@
 #ifndef ECSS_SERVICES_ECSS_DEFINITIONS_H
 #define ECSS_SERVICES_ECSS_DEFINITIONS_H
 
+#include <stdint.h>
 /**
  * @defgroup ECSSDefinitions ECSS Defined Constants
  *
@@ -21,46 +22,46 @@
 /**
  * The maximum size of a regular ECSS message, in bytes
  */
-#define ECSS_MAX_MESSAGE_SIZE 1024U
+inline const uint16_t ECSSMaxMessageSize = 1024U;
 
 /**
  * The maximum size of a regular ECSS message, plus its headers and trailing data, in bytes
  */
-#define CCSDS_MAX_MESSAGE_SIZE (ECSS_MAX_MESSAGE_SIZE + 6u + 6u + 2u)
+inline const uint16_t CCSDSMaxMessageSize = ECSSMaxMessageSize + 6u + 6u + 2u;
 
 /**
  * The maximum size of a string to be read or appended to a Message, in bytes
  *
  * This is used by the Message::appendString() and Message::readString() functions
  */
-#define ECSS_MAX_STRING_SIZE 256U
+inline const uint16_t ECSSMaxStringSize = 256U;
 
 /**
  * The maximum size of a string to be used by ST[13] \ref LargePacketTransferService, in bytes
  *
  * This is used by the Message::appendString() and Message::readString() functions
  */
-#define ECSS_MAX_FIXED_OCTET_STRING_SIZE 256U
+inline const uint16_t ECSSMaxFixedOctetStringSize = 256U;
 
 /**
  * The total number of different message types that can be handled by this project
  */
-#define ECSS_TOTAL_MESSAGE_TYPES (10U * 20U)
+inline const uint8_t ECSSTotalMessageTypes = 10U * 20U;
 
 /**
  * The CCSDS packet version, as specified in section 7.4.1
  */
-#define CCSDS_PACKET_VERSION 0
+inline const uint8_t CCSDSPacketVersion = 0;
 
 /**
  * The ECSS packet version, as specified in requirement 7.4.4.1c
  */
-#define ECSS_PUS_VERSION 2U
+inline const uint8_t ECSSPUSVersion = 2U;
 
 /**
  * The CCSDS sequence flags have the constant value 0x3, as specified in section 7.4.1
  */
-#define ECSS_SEQUENCE_FLAGS 0x3
+inline const uint8_t ECSSSequenceFlags = 0x3;
 
 /**
  * @brief Maximum number of TC requests that can be contained in a single message request
@@ -70,20 +71,20 @@
  * their message request.
  * @attention This definition is probably dependent on the ECSS_TC_REQUEST_STRING_SIZE
  */
-#define ECSS_MAX_REQUEST_COUNT 20
+inline const uint8_t ECSSMaxRequestCount = 20;
 
 /**
  * @brief Maximum length of a String converted TC packet message
  * @details This definition refers to the maximum length that an embedded TC packet, meaning a TC
  * packet contained in a message request as a part of the request.
  */
-#define ECSS_TC_REQUEST_STRING_SIZE 64
+inline const uint8_t ECSSTCRequestStringSize = 64;
 
 /**
  * The maximum number of activities that can be in the time-based schedule
  * @see TimeBasedSchedulingService
  */
-#define ECSS_MAX_NUMBER_OF_TIME_SCHED_ACTIVITIES 10
+inline const uint8_t ECSSMaxNumberOfTimeSchedActivities = 10;
 
 /**
  * @brief Time margin used in the time based command scheduling service ST[11]
@@ -91,73 +92,73 @@
  * have in order
  * @see TimeBasedSchedulingService
  */
-#define ECSS_TIME_MARGIN_FOR_ACTIVATION 60
+inline const uint8_t ECSSTimeMarginForActivation = 60;
 
 /**
  * @brief Maximum size of an event's auxiliary data
  * @see EventReportService
  */
-#define ECSS_EVENT_DATA_AUXILIARY_MAX_SIZE 64
+inline const uint8_t ECSSEventDataAuxiliaryMaxSize = 64;
 
 /**
  * @brief Size of the multimap that holds every event-action definition
  * @see EventActionService
  */
-#define ECSS_EVENT_ACTION_STRUCT_MAP_SIZE 256
+inline const uint16_t ECSSEventActionStructMapSize = 256;
 
 /**
  * The maximum delta between the specified release time and the actual release time
  * @see TimeBasedSchedulingService
  */
-#define ECSS_MAX_DELTA_OF_RELEASE_TIME 60
+inline const uint8_t ECSSMaxDeltaOfReleaseTime = 60;
 
 /**
  * The maximum number of stored parameters in the \ref ParameterService
  */
-#define ECSS_MAX_PARAMETERS 5
+inline const uint8_t ECSSMaxParameters = 5;
 
 /**
  * The number of functions supported by the \ref FunctionManagementService
  */
-#define ECSS_FUNCTION_MAP_SIZE 5
+inline const uint8_t ECSSFunctionMapSize = 5;
 
 /**
  * The maximum length of a function name, in bytes
  * @see FunctionManagementService
  */
-#define ECSS_FUNCTION_NAME_LENGTH 32
+inline const uint8_t ECSSFunctionNameLength = 32;
 
 /**
  * The maximum length of the argument of a function
  * @see FunctionManagementService
  */
-#define ECSS_FUNCTION_MAX_ARG_LENGTH 32
+inline const uint8_t ECSSFunctionMaxArgLength = 32;
 
 /** @} */
 
 /**
  * @brief The maximum size of a log message
  */
-#define LOGGER_MAX_MESSAGE_SIZE 512
+inline const uint16_t LoggerMaxMessageSize = 512;
 
 /**
  * @brief Size of the array holding the Parameter objects for the ST[20] parameter service
  */
-#define ECSS_PARAMETER_COUNT 4
+inline const uint8_t ECSSParameterCount = 4;
 
 /**
  * @brief Defines whether the optional CRC field is included
  */
-#define ECSS_CRC_INCLUDED true
+inline const bool ECSSCRCIncluded = true;
 
 /**
  * Number of parameters whose statistics we need and are going to be stored into the statisticsMap
  */
-#define ECSS_MAX_STATISTIC_PARAMETERS 4
+inline const uint8_t ECSSMaxStatisticParameters = 4;
 
 /**
  * Whether the ST[04] statistics calculation supports the reporting of stddev
  */
-#define SUPPORTS_STANDARD_DEVIATION true
+inline const bool SupportsStandardDeviation = true;
 
 #endif // ECSS_SERVICES_ECSS_DEFINITIONS_H
diff --git a/inc/Helpers/TimeHelper.hpp b/inc/Helpers/TimeHelper.hpp
index ecbad93d35d5893842e080e585c210f549bbce1d..42b5baf1204b01c58b3e964c5d413a6a973ea26f 100644
--- a/inc/Helpers/TimeHelper.hpp
+++ b/inc/Helpers/TimeHelper.hpp
@@ -5,16 +5,16 @@
 #include <Message.hpp>
 #include "TimeAndDate.hpp"
 
-#define SECONDS_PER_MINUTE 60U
-#define SECONDS_PER_HOUR 3600U
-#define SECONDS_PER_DAY 86400U
+inline const uint8_t SecondsPerMinute = 60U;
+inline const uint16_t SecondsPerHour = 3600U;
+inline const uint32_t SecondsPerDay = 86400U;
 
 /**
  * @todo If we use CUC time format then we should keep leap seconds up to date. Leap seconds are added in undefined
  * periods of time, so we should find a way to adjust to these changes either in runtime using GPS or sending a new
  * compiled code (changing the defined leap seconds) from the ground segment
  */
-#define LEAP_SECONDS 27
+inline const uint8_t LeapSeconds = 27;
 
 
 /**
diff --git a/inc/Logger.hpp b/inc/Logger.hpp
index b5e4b7f21546360ce2d71194b6fc2c7eae4a7cd3..158c8d65a5d11ad722138441e5ff9cdc056c05bd 100644
--- a/inc/Logger.hpp
+++ b/inc/Logger.hpp
@@ -89,7 +89,7 @@ public:
 	 * @internal
 	 */
 	struct LogEntry {
-		String<LOGGER_MAX_MESSAGE_SIZE> message = ""; ///< The current log message itself, starting from a blank slate
+		String<LoggerMaxMessageSize> message = ""; ///< The current log message itself, starting from a blank slate
 		LogLevel level; ///< The log level of this message
 
 		explicit LogEntry(LogLevel level); ///< Create a new LogEntry
diff --git a/inc/Message.hpp b/inc/Message.hpp
index 0cb719c68b11c69b2788e4a4074da6f784de0b20..9cb09f8281b1da17b104e74e1121f78e5073019a 100644
--- a/inc/Message.hpp
+++ b/inc/Message.hpp
@@ -104,7 +104,7 @@ public:
 	//
 	// @note This is initialized to 0 in order to prevent any mishaps with non-properly initialized values. \ref
 	// Message::appendBits() relies on this in order to easily OR the requested bits.
-	uint8_t data[ECSS_MAX_MESSAGE_SIZE] = {0};
+	uint8_t data[ECSSMaxMessageSize] = {0};
 
 	// private:
 	uint8_t currentBit = 0;
@@ -557,7 +557,7 @@ public:
 
 		uint16_t length = readUint16();
 		ASSERT_REQUEST(length <= string.max_size(), ErrorHandler::StringTooShort);
-		ASSERT_REQUEST((readPosition + length) <= ECSS_MAX_MESSAGE_SIZE, ErrorHandler::MessageTooShort);
+		ASSERT_REQUEST((readPosition + length) <= ECSSMaxMessageSize, ErrorHandler::MessageTooShort);
 
 		string.append(data + readPosition, length);
 		readPosition += length;
diff --git a/inc/MessageParser.hpp b/inc/MessageParser.hpp
index 5b89e20cb4925833e2a2541c88cda7d758df9acd..031a6fc505c992189f3169ceccb6877dac04ecb0 100644
--- a/inc/MessageParser.hpp
+++ b/inc/MessageParser.hpp
@@ -58,7 +58,7 @@ public:
 	 * this great analysis:
 	 * stackoverflow.com/questions/15078638/can-i-turn-unsigned-char-into-char-and-vice-versa
 	 */
-	static Message parseECSSTC(String<ECSS_TC_REQUEST_STRING_SIZE> data);
+	static Message parseECSSTC(String<ECSSTCRequestStringSize> data);
 
 	/**
 	 * @brief Overloaded version of \ref MessageParser::parseECSSTC(String<ECSS_TC_REQUEST_STRING_SIZE> data)
@@ -75,14 +75,14 @@ public:
 	 * error. Messages smaller than \p size are padded with zeros. When `size = 0`, there is no size limit.
 	 * @return A String class containing the parsed Message
 	 */
-	static String<CCSDS_MAX_MESSAGE_SIZE> composeECSS(const Message& message, uint16_t size = 0u); // Ignore-MISRA
+	static String<CCSDSMaxMessageSize> composeECSS(const Message& message, uint16_t size = 0u); // Ignore-MISRA
 
 	/**
 	 * @brief Converts a TC or TM message to a packet string, appending the ECSS and then the CCSDS header
 	 * @param message The Message object to be parsed to a String
 	 * @return A String class containing the parsed Message
 	 */
-	static String<CCSDS_MAX_MESSAGE_SIZE> compose(const Message& message);
+	static String<CCSDSMaxMessageSize> compose(const Message& message);
 
 private:
 	/**
diff --git a/inc/Platform/STM32F7/MemoryAddressLimits.hpp b/inc/Platform/STM32F7/MemoryAddressLimits.hpp
index 5afe31a625e6b819b03d1740c4b0be12b0fd2683..c0f4d514889c7f22d9ac9d7c5d855dc6404cc3fa 100644
--- a/inc/Platform/STM32F7/MemoryAddressLimits.hpp
+++ b/inc/Platform/STM32F7/MemoryAddressLimits.hpp
@@ -2,17 +2,17 @@
 #define ECSS_SERVICES_MEMORYADDRESSLIMITS_STM32F7_HPP
 
 // Memory limits definitions
-#define DTCMRAM_LOWER_LIM 0x20000000UL
-#define DTCMRAM_UPPER_LIM 0x20020000UL
-#define ITCMRAM_LOWER_LIM 0x00000000UL
-#define ITCMRAM_UPPER_LIM 0x00010000UL
-#define RAM_D1_LOWER_LIM 0x24000000UL
-#define RAM_D1_UPPER_LIM 0x24080000UL
-#define RAM_D2_LOWER_LIM 0x30000000UL
-#define RAM_D2_UPPER_LIM 0x30048000UL
-#define RAM_D3_LOWER_LIM 0x38000000UL
-#define RAM_D3_UPPER_LIM 0x38010000UL
-#define FLASH_LOWER_LIM 0x08000000UL
-#define FLASH_UPPER_LIM 0x08200000UL
+inline const uint32_t DTCMRAMLowerLim = 0x20000000UL;
+inline const uint32_t DTCMRAMUpperLim = 0x20020000UL;
+inline const uint32_t ITCMRAMLowerLim = 0x00000000UL;
+inline const uint32_t ITCMRAMUpperLim = 0x00010000UL;
+inline const uint32_t RAMD1LowerLim = 0x24000000UL;
+inline const uint32_t RAMD1UpperLim = 0x24080000UL;
+inline const uint32_t RAMD2LowerLim = 0x30000000UL;
+inline const uint32_t RAMD2UpperLim = 0x30048000UL;
+inline const uint32_t RAMD3LowerLim = 0x38000000UL;
+inline const uint32_t RAMD3UpperLim = 0x38010000UL;
+inline const uint32_t FlashLowerLim = 0x08000000UL;
+inline const uint32_t FlashUpperLim = 0x08200000UL;
 
 #endif // ECSS_SERVICES_MEMORYADDRESSLIMITS_STM32F7_HPP
diff --git a/inc/Platform/x86/Parameters/SystemParameters.hpp b/inc/Platform/x86/Parameters/SystemParameters.hpp
index 45ee285d545754238cdea46883c03b03784c6521..a1a834afc32154f620880a76f5331ac10fb7a503 100644
--- a/inc/Platform/x86/Parameters/SystemParameters.hpp
+++ b/inc/Platform/x86/Parameters/SystemParameters.hpp
@@ -23,7 +23,7 @@ public:
 	/**
 	 * The key of the array is the ID of the parameter as specified in PUS
 	 */
-	etl::array<std::reference_wrapper<ParameterBase>, ECSS_PARAMETER_COUNT> parametersArray = {parameter1, parameter2,
+	etl::array<std::reference_wrapper<ParameterBase>, ECSSParameterCount> parametersArray = {parameter1, parameter2,
 	                                                                                           parameter3, parameter4};
 
 	SystemParameters() = default;
diff --git a/inc/ServicePool.hpp b/inc/ServicePool.hpp
index bdfd7103c9527019641c1671be70806159b07f46..753dca4d6f0fc4c33864425731d287db74d36ffb 100644
--- a/inc/ServicePool.hpp
+++ b/inc/ServicePool.hpp
@@ -26,7 +26,7 @@ class ServicePool {
 	 * the number of the service, while the least significant 8 bits are the number of the Message. The value is the
 	 * counter of each MessageType.
 	 */
-	etl::map<uint16_t, uint16_t, ECSS_TOTAL_MESSAGE_TYPES> messageTypeCounter;
+	etl::map<uint16_t, uint16_t, ECSSTotalMessageTypes> messageTypeCounter;
 
 	/**
 	 * A counter for messages that corresponds to the total number of TM packets sent from an APID
diff --git a/inc/Services/EventActionService.hpp b/inc/Services/EventActionService.hpp
index 53ef1a749fb46decdaaf54ba66fbda2b4974a78f..f0c33e1702a664a851ae91053d6e7cb579b575fd 100644
--- a/inc/Services/EventActionService.hpp
+++ b/inc/Services/EventActionService.hpp
@@ -65,7 +65,7 @@ public:
 
 	friend EventReportService;
 
-	etl::multimap<uint16_t, EventActionDefinition, ECSS_EVENT_ACTION_STRUCT_MAP_SIZE>
+	etl::multimap<uint16_t, EventActionDefinition, ECSSEventActionStructMapSize>
 		eventActionDefinitionMap;
 
 	EventActionService() {
diff --git a/inc/Services/EventReportService.hpp b/inc/Services/EventReportService.hpp
index 81c34c46d9ac28de3bef8afe6e05aebfd9bcac34..0776159d77b73aca4526f401f431868b6f4ef57f 100644
--- a/inc/Services/EventReportService.hpp
+++ b/inc/Services/EventReportService.hpp
@@ -115,7 +115,7 @@ public:
 	 * @param eventID event definition ID
 	 * @param data the data of the report
 	 */
-	void informativeEventReport(Event eventID, const String<ECSS_EVENT_DATA_AUXILIARY_MAX_SIZE>& data);
+	void informativeEventReport(Event eventID, const String<ECSSEventDataAuxiliaryMaxSize>& data);
 
 	/**
 	 * TM[5,2] low severiity anomaly report
@@ -126,7 +126,7 @@ public:
 	 * @param eventID event definition ID
 	 * @param data the data of the report
 	 */
-	void lowSeverityAnomalyReport(Event eventID, const String<ECSS_EVENT_DATA_AUXILIARY_MAX_SIZE>& data);
+	void lowSeverityAnomalyReport(Event eventID, const String<ECSSEventDataAuxiliaryMaxSize>& data);
 
 	/**
 	 * TM[5,3] medium severity anomaly report
@@ -137,7 +137,7 @@ public:
 	 * @param eventID event definition ID
 	 * @param data the data of the report
 	 */
-	void mediumSeverityAnomalyReport(Event eventID, const String<ECSS_EVENT_DATA_AUXILIARY_MAX_SIZE>& data);
+	void mediumSeverityAnomalyReport(Event eventID, const String<ECSSEventDataAuxiliaryMaxSize>& data);
 
 	/**
 	 * TM[5,4] high severity anomaly report
@@ -148,7 +148,7 @@ public:
 	 * @param eventID event definition ID
 	 * @param data the data of the report
 	 */
-	void highSeverityAnomalyReport(Event eventID, const String<ECSS_EVENT_DATA_AUXILIARY_MAX_SIZE>& data);
+	void highSeverityAnomalyReport(Event eventID, const String<ECSSEventDataAuxiliaryMaxSize>& data);
 
 	/**
 	 * TC[5,5] request to enable report generation
diff --git a/inc/Services/FunctionManagementService.hpp b/inc/Services/FunctionManagementService.hpp
index aa490fe8790f7c6a74470946d1e2f6d4d003d85d..6f2bc55b34a202f86124690ce2a55059701aaf29 100644
--- a/inc/Services/FunctionManagementService.hpp
+++ b/inc/Services/FunctionManagementService.hpp
@@ -49,8 +49,8 @@
  * @endcode
  */
 
-typedef String<ECSS_FUNCTION_NAME_LENGTH> functionName;
-typedef etl::map<functionName, void (*)(String<ECSS_FUNCTION_MAX_ARG_LENGTH>), ECSS_FUNCTION_MAP_SIZE> FunctionMap;
+typedef String<ECSSFunctionNameLength> functionName;
+typedef etl::map<functionName, void (*)(String<ECSSFunctionMaxArgLength>), ECSSFunctionMapSize> FunctionMap;
 
 class FunctionManagementService : public Service {
 	/**
@@ -88,7 +88,7 @@ public:
 	 * @param ptr pointer to a function of void return type and a MAX_ARG_LENGTH-lengthed byte
 	 * string as argument (which contains the actual arguments of the function)
 	 */
-	void include(String<ECSS_FUNCTION_NAME_LENGTH> funcName, void (*ptr)(String<ECSS_FUNCTION_MAX_ARG_LENGTH>));
+	void include(String<ECSSFunctionNameLength> funcName, void (*ptr)(String<ECSSFunctionMaxArgLength>));
 
 	int getMapSize() {
 		return funcPtrIndex.size();
diff --git a/inc/Services/LargePacketTransferService.hpp b/inc/Services/LargePacketTransferService.hpp
index 731412dbdeeb1f9a248b256184c1ef597f29d111..a3ef0a2770c0a745d80d31283f0ecb925bd10b98 100644
--- a/inc/Services/LargePacketTransferService.hpp
+++ b/inc/Services/LargePacketTransferService.hpp
@@ -40,7 +40,7 @@ public:
 	 * @param string The data contained in this part of the large packet
 	 */
 	void firstDownlinkPartReport(uint16_t largeMessageTransactionIdentifier, uint16_t partSequenceNumber,
-	                             const String<ECSS_MAX_FIXED_OCTET_STRING_SIZE>& string);
+	                             const String<ECSSMaxFixedOctetStringSize>& string);
 
 	/**
 	 * Function that handles the n-2 parts of tbe n-part download report
@@ -49,7 +49,7 @@ public:
 	 * @param string The data contained in this part of the large packet
 	 */
 	void intermediateDownlinkPartReport(uint16_t largeMessageTransactionIdentifier, uint16_t partSequenceNumber,
-	                                    const String<ECSS_MAX_FIXED_OCTET_STRING_SIZE>& string);
+	                                    const String<ECSSMaxFixedOctetStringSize>& string);
 
 	/**
 	 * Function that handles the last part of the download report
@@ -58,7 +58,7 @@ public:
 	 * @param string The data contained in this part of the large packet
 	 */
 	void lastDownlinkPartReport(uint16_t largeMessageTransactionIdentifier, uint16_t partSequenceNumber,
-	                            const String<ECSS_MAX_FIXED_OCTET_STRING_SIZE>& string);
+	                            const String<ECSSMaxFixedOctetStringSize>& string);
 
 	// The three uplink functions should handle a TC request to "upload" data. Since there is not
 	// a composeECSS function ready, I just return the given string.
@@ -67,20 +67,20 @@ public:
 	 * Function that handles the first part of the uplink request
 	 * @param string This will change when these function will be modified
 	 */
-	String<ECSS_MAX_FIXED_OCTET_STRING_SIZE> firstUplinkPart(const String<ECSS_MAX_FIXED_OCTET_STRING_SIZE>& string);
+	String<ECSSMaxFixedOctetStringSize> firstUplinkPart(const String<ECSSMaxFixedOctetStringSize>& string);
 
 	/**
 	 * Function that handles the n-2 parts of tbe n-part uplink request
 	 * @param string This will change when these function will be modified
 	 */
-	String<ECSS_MAX_FIXED_OCTET_STRING_SIZE>
-	intermediateUplinkPart(const String<ECSS_MAX_FIXED_OCTET_STRING_SIZE>& string);
+	String<ECSSMaxFixedOctetStringSize>
+	intermediateUplinkPart(const String<ECSSMaxFixedOctetStringSize>& string);
 
 	/**
 	 * Function that handles the last part of the uplink request
 	 * @param string This will change when these function will be modified
 	 */
-	String<ECSS_MAX_FIXED_OCTET_STRING_SIZE> lastUplinkPart(const String<ECSS_MAX_FIXED_OCTET_STRING_SIZE>& string);
+	String<ECSSMaxFixedOctetStringSize> lastUplinkPart(const String<ECSSMaxFixedOctetStringSize>& string);
 
 	/**
 	 * Function that splits large messages
diff --git a/inc/Services/ParameterStatisticsService.hpp b/inc/Services/ParameterStatisticsService.hpp
index cd6de679831b05ca947368c11c0464240db77ad6..b15c26a89138530c3e70af0449419e0e9939e47b 100644
--- a/inc/Services/ParameterStatisticsService.hpp
+++ b/inc/Services/ParameterStatisticsService.hpp
@@ -32,7 +32,7 @@ public:
 	/**
 	 * Map containing parameters' IDs followed by the statistics that correspond to the specified parameter
 	 */
-	etl::map<uint16_t, Statistic, ECSS_MAX_STATISTIC_PARAMETERS> statisticsMap;
+	etl::map<uint16_t, Statistic, ECSSMaxStatisticParameters> statisticsMap;
 
 	/**
 	 * true means that the periodic statistics reporting is enabled
diff --git a/inc/Services/TimeBasedSchedulingService.hpp b/inc/Services/TimeBasedSchedulingService.hpp
index 5b8be4889b4ab1f7c5479dce7fe43ebfe41e786e..751b6438dac6109d05245340cdb23ac8a19d1c0e 100644
--- a/inc/Services/TimeBasedSchedulingService.hpp
+++ b/inc/Services/TimeBasedSchedulingService.hpp
@@ -92,7 +92,7 @@ private:
 	 * @details The scheduled activities in this list are ordered by their release time, as the
 	 * standard requests.
 	 */
-	etl::list<ScheduledActivity, ECSS_MAX_NUMBER_OF_TIME_SCHED_ACTIVITIES> scheduledActivities;
+	etl::list<ScheduledActivity, ECSSMaxNumberOfTimeSchedActivities> scheduledActivities;
 
 	/**
 	 * @brief Sort the activities by their release time
@@ -101,7 +101,7 @@ private:
 	 * response. Also it is better to have the activities sorted.
 	 */
 	inline void
-	sortActivitiesReleaseTime(etl::list<ScheduledActivity, ECSS_MAX_NUMBER_OF_TIME_SCHED_ACTIVITIES>& schedActivities) {
+	sortActivitiesReleaseTime(etl::list<ScheduledActivity, ECSSMaxNumberOfTimeSchedActivities>& schedActivities) {
 		schedActivities.sort([](ScheduledActivity const& leftSide, ScheduledActivity const& rightSide) {
 			// cppcheck-suppress
 			return leftSide.requestReleaseTime < rightSide.requestReleaseTime;
diff --git a/src/Helpers/Statistic.cpp b/src/Helpers/Statistic.cpp
index 70af6e62bbb42b740ceee5e357b2aa5863c931c5..70236a557d90496c08ac807b8d3783c38aca069c 100644
--- a/src/Helpers/Statistic.cpp
+++ b/src/Helpers/Statistic.cpp
@@ -30,7 +30,7 @@ void Statistic::appendStatisticsToMessage(Message& report) {
 	report.appendUint32(minTime);
 	report.appendFloat(static_cast<float>(mean));
 
-	if (SUPPORTS_STANDARD_DEVIATION) {
+	if (SupportsStandardDeviation) {
 		double standardDeviation = 0;
 		if (sampleCounter == 0) {
 			standardDeviation = 0;
diff --git a/src/Helpers/TimeHelper.cpp b/src/Helpers/TimeHelper.cpp
index b0e02d9b4debc90164b0b041ca16ee11bc3b0e28..942635140f585f3bb9d9e11d0bae32516610683c 100644
--- a/src/Helpers/TimeHelper.cpp
+++ b/src/Helpers/TimeHelper.cpp
@@ -22,17 +22,17 @@ uint32_t TimeHelper::utcToSeconds(const TimeAndDate& TimeInfo) {
 
 	uint32_t secs = 1546300800; // elapsed seconds from Unix epoch until 1/1/2019 00:00:00 (UTC)
 	for (uint16_t y = 2019; y < TimeInfo.year; ++y) {
-		secs += (IsLeapYear(y) ? 366 : 365) * SECONDS_PER_DAY;
+		secs += (IsLeapYear(y) ? 366 : 365) * SecondsPerDay;
 	}
 	for (uint16_t m = 1; m < TimeInfo.month; ++m) {
-		secs += DaysOfMonth[m - 1U] * SECONDS_PER_DAY;
+		secs += DaysOfMonth[m - 1U] * SecondsPerDay;
 		if ((m == 2U) && IsLeapYear(TimeInfo.year)) {
-			secs += SECONDS_PER_DAY;
+			secs += SecondsPerDay;
 		}
 	}
-	secs += (TimeInfo.day - 1) * SECONDS_PER_DAY;
-	secs += TimeInfo.hour * SECONDS_PER_HOUR;
-	secs += TimeInfo.minute * SECONDS_PER_MINUTE;
+	secs += (TimeInfo.day - 1) * SecondsPerDay;
+	secs += TimeInfo.hour * SecondsPerHour;
+	secs += TimeInfo.minute * SecondsPerMinute;
 	secs += TimeInfo.second;
 	return secs;
 }
@@ -51,39 +51,39 @@ struct TimeAndDate TimeHelper::secondsToUTC(uint32_t seconds) {
 	TimeInfo.second = 0;
 
 	// calculate years
-	while (seconds >= (IsLeapYear(TimeInfo.year) ? 366 : 365) * SECONDS_PER_DAY) {
-		seconds -= (IsLeapYear(TimeInfo.year) ? 366 : 365) * SECONDS_PER_DAY;
+	while (seconds >= (IsLeapYear(TimeInfo.year) ? 366 : 365) * SecondsPerDay) {
+		seconds -= (IsLeapYear(TimeInfo.year) ? 366 : 365) * SecondsPerDay;
 		TimeInfo.year++;
 	}
 
 	// calculate months
 	uint8_t i = 0;
-	while (seconds >= (DaysOfMonth[i] * SECONDS_PER_DAY)) {
+	while (seconds >= (DaysOfMonth[i] * SecondsPerDay)) {
 		TimeInfo.month++;
-		seconds -= (DaysOfMonth[i] * SECONDS_PER_DAY);
+		seconds -= (DaysOfMonth[i] * SecondsPerDay);
 		i++;
 		if ((i == 1U) && IsLeapYear(TimeInfo.year)) {
-			if (seconds <= (28 * SECONDS_PER_DAY)) {
+			if (seconds <= (28 * SecondsPerDay)) {
 				break;
 			}
 			TimeInfo.month++;
-			seconds -= 29 * SECONDS_PER_DAY;
+			seconds -= 29 * SecondsPerDay;
 			i++;
 		}
 	}
 
 	// calculate days
-	TimeInfo.day = seconds / SECONDS_PER_DAY;
-	seconds -= TimeInfo.day * SECONDS_PER_DAY;
+	TimeInfo.day = seconds / SecondsPerDay;
+	seconds -= TimeInfo.day * SecondsPerDay;
 	TimeInfo.day++; // add 1 day because we start count from 1 January (and not 0 January!)
 
 	// calculate hours
-	TimeInfo.hour = seconds / SECONDS_PER_HOUR;
-	seconds -= TimeInfo.hour * SECONDS_PER_HOUR;
+	TimeInfo.hour = seconds / SecondsPerHour;
+	seconds -= TimeInfo.hour * SecondsPerHour;
 
 	// calculate minutes
-	TimeInfo.minute = seconds / SECONDS_PER_MINUTE;
-	seconds -= TimeInfo.minute * SECONDS_PER_MINUTE;
+	TimeInfo.minute = seconds / SecondsPerMinute;
+	seconds -= TimeInfo.minute * SecondsPerMinute;
 
 	// calculate seconds
 	TimeInfo.second = seconds;
@@ -103,13 +103,13 @@ uint64_t TimeHelper::generateCDSTimeFormat(const TimeAndDate& TimeInfo) {
 	 * The `DAY` segment, 16 bits as defined from standard. Actually the days passed since Unix
 	 * epoch
 	 */
-	auto elapsedDays = static_cast<uint16_t>(seconds / SECONDS_PER_DAY);
+	auto elapsedDays = static_cast<uint16_t>(seconds / SecondsPerDay);
 
 	/**
 	 * The `ms of day` segment, 32 bits as defined in standard. The `ms of the day` and DAY`
 	 * should give the time passed since Unix epoch
 	 */
-	auto msOfDay = static_cast<uint32_t>((seconds % SECONDS_PER_DAY) * 1000);
+	auto msOfDay = static_cast<uint32_t>((seconds % SecondsPerDay) * 1000);
 
 	uint64_t timeFormat = (static_cast<uint64_t>(elapsedDays) << 32) | msOfDay;
 
@@ -121,19 +121,19 @@ TimeAndDate TimeHelper::parseCDStimeFormat(const uint8_t* data) {
 	uint32_t msOfDay = ((static_cast<uint32_t>(data[2])) << 24) | ((static_cast<uint32_t>(data[3]))) << 16 |
 	                   ((static_cast<uint32_t>(data[4]))) << 8 | (static_cast<uint32_t>(data[5]));
 
-	uint32_t seconds = (elapsedDays * SECONDS_PER_DAY) + (msOfDay / 1000U);
+	uint32_t seconds = (elapsedDays * SecondsPerDay) + (msOfDay / 1000U);
 
 	return secondsToUTC(seconds);
 }
 
 uint32_t TimeHelper::generateCUCTimeFormat(const struct TimeAndDate& TimeInfo) {
-	return (utcToSeconds(TimeInfo) + LEAP_SECONDS);
+	return (utcToSeconds(TimeInfo) + LeapSeconds);
 }
 
 TimeAndDate TimeHelper::parseCUCTimeFormat(const uint8_t* data) {
 	uint32_t seconds = ((static_cast<uint32_t>(data[0])) << 24) | ((static_cast<uint32_t>(data[1]))) << 16 |
 	                   ((static_cast<uint32_t>(data[2]))) << 8 | (static_cast<uint32_t>(data[3]));
-	seconds -= LEAP_SECONDS;
+	seconds -= LeapSeconds;
 
 	return secondsToUTC(seconds);
 }
diff --git a/src/Message.cpp b/src/Message.cpp
index 1a2ea7a593e4e8cb2f49c6f0512287d197849ae5..0ba4d75aaed85e3584d6b7e81369390cb13bd6a3 100644
--- a/src/Message.cpp
+++ b/src/Message.cpp
@@ -13,7 +13,7 @@ void Message::appendBits(uint8_t numBits, uint16_t data) {
 	ASSERT_INTERNAL(numBits <= 16, ErrorHandler::TooManyBitsAppend);
 
 	while (numBits > 0) { // For every sequence of 8 bits...
-		ASSERT_INTERNAL(dataSize < ECSS_MAX_MESSAGE_SIZE, ErrorHandler::MessageTooLarge);
+		ASSERT_INTERNAL(dataSize < ECSSMaxMessageSize, ErrorHandler::MessageTooLarge);
 
 		if ((currentBit + numBits) >= 8) {
 			// Will have to shift the bits and insert the next ones later
@@ -50,7 +50,7 @@ void Message::finalize() {
 }
 
 void Message::appendByte(uint8_t value) {
-	ASSERT_INTERNAL(dataSize < ECSS_MAX_MESSAGE_SIZE, ErrorHandler::MessageTooLarge);
+	ASSERT_INTERNAL(dataSize < ECSSMaxMessageSize, ErrorHandler::MessageTooLarge);
 	ASSERT_INTERNAL(currentBit == 0, ErrorHandler::ByteBetweenBits);
 
 	data[dataSize] = value;
@@ -58,7 +58,7 @@ void Message::appendByte(uint8_t value) {
 }
 
 void Message::appendHalfword(uint16_t value) {
-	ASSERT_INTERNAL((dataSize + 2) <= ECSS_MAX_MESSAGE_SIZE, ErrorHandler::MessageTooLarge);
+	ASSERT_INTERNAL((dataSize + 2) <= ECSSMaxMessageSize, ErrorHandler::MessageTooLarge);
 	ASSERT_INTERNAL(currentBit == 0, ErrorHandler::ByteBetweenBits);
 
 	data[dataSize] = static_cast<uint8_t>((value >> 8) & 0xFF);
@@ -68,7 +68,7 @@ void Message::appendHalfword(uint16_t value) {
 }
 
 void Message::appendWord(uint32_t value) {
-	ASSERT_INTERNAL((dataSize + 4) <= ECSS_MAX_MESSAGE_SIZE, ErrorHandler::MessageTooLarge);
+	ASSERT_INTERNAL((dataSize + 4) <= ECSSMaxMessageSize, ErrorHandler::MessageTooLarge);
 	ASSERT_INTERNAL(currentBit == 0, ErrorHandler::ByteBetweenBits);
 
 	data[dataSize] = static_cast<uint8_t>((value >> 24) & 0xFF);
@@ -85,7 +85,7 @@ uint16_t Message::readBits(uint8_t numBits) {
 	uint16_t value = 0x0;
 
 	while (numBits > 0) {
-		ASSERT_REQUEST(readPosition < ECSS_MAX_MESSAGE_SIZE, ErrorHandler::MessageTooShort);
+		ASSERT_REQUEST(readPosition < ECSSMaxMessageSize, ErrorHandler::MessageTooShort);
 
 		if ((currentBit + numBits) >= 8) {
 			auto bitsToAddNow = static_cast<uint8_t>(8 - currentBit);
@@ -108,7 +108,7 @@ uint16_t Message::readBits(uint8_t numBits) {
 }
 
 uint8_t Message::readByte() {
-	ASSERT_REQUEST(readPosition < ECSS_MAX_MESSAGE_SIZE, ErrorHandler::MessageTooShort);
+	ASSERT_REQUEST(readPosition < ECSSMaxMessageSize, ErrorHandler::MessageTooShort);
 
 	uint8_t value = data[readPosition];
 	readPosition++;
@@ -117,7 +117,7 @@ uint8_t Message::readByte() {
 }
 
 uint16_t Message::readHalfword() {
-	ASSERT_REQUEST((readPosition + 2) <= ECSS_MAX_MESSAGE_SIZE, ErrorHandler::MessageTooShort);
+	ASSERT_REQUEST((readPosition + 2) <= ECSSMaxMessageSize, ErrorHandler::MessageTooShort);
 
 	uint16_t value = (data[readPosition] << 8) | data[readPosition + 1];
 	readPosition += 2;
@@ -126,7 +126,7 @@ uint16_t Message::readHalfword() {
 }
 
 uint32_t Message::readWord() {
-	ASSERT_REQUEST((readPosition + 4) <= ECSS_MAX_MESSAGE_SIZE, ErrorHandler::MessageTooShort);
+	ASSERT_REQUEST((readPosition + 4) <= ECSSMaxMessageSize, ErrorHandler::MessageTooShort);
 
 	uint32_t value = (data[readPosition] << 24) | (data[readPosition + 1] << 16) | (data[readPosition + 2] << 8) |
 	                 data[readPosition + 3];
@@ -136,15 +136,15 @@ uint32_t Message::readWord() {
 }
 
 void Message::readString(char* string, uint16_t size) {
-	ASSERT_REQUEST((readPosition + size) <= ECSS_MAX_MESSAGE_SIZE, ErrorHandler::MessageTooShort);
-	ASSERT_REQUEST(size < ECSS_MAX_STRING_SIZE, ErrorHandler::StringTooShort);
+	ASSERT_REQUEST((readPosition + size) <= ECSSMaxMessageSize, ErrorHandler::MessageTooShort);
+	ASSERT_REQUEST(size < ECSSMaxStringSize, ErrorHandler::StringTooShort);
 	std::copy(data + readPosition, data + readPosition + size, string);
 	readPosition += size;
 }
 
 void Message::readString(uint8_t* string, uint16_t size) {
-	ASSERT_REQUEST((readPosition + size) <= ECSS_MAX_MESSAGE_SIZE, ErrorHandler::MessageTooShort);
-	ASSERT_REQUEST(size < ECSS_MAX_STRING_SIZE, ErrorHandler::StringTooShort);
+	ASSERT_REQUEST((readPosition + size) <= ECSSMaxMessageSize, ErrorHandler::MessageTooShort);
+	ASSERT_REQUEST(size < ECSSMaxStringSize, ErrorHandler::StringTooShort);
 	std::copy(data + readPosition, data + readPosition + size, string);
 	readPosition += size;
 }
@@ -164,7 +164,7 @@ void Message::appendMessage(const Message& message, uint16_t size) {
 }
 
 void Message::appendString(const etl::istring& string) {
-	ASSERT_INTERNAL(dataSize + string.size() <= ECSS_MAX_MESSAGE_SIZE, ErrorHandler::MessageTooLarge);
+	ASSERT_INTERNAL(dataSize + string.size() <= ECSSMaxMessageSize, ErrorHandler::MessageTooLarge);
 	// TODO: Do we need to keep this check? How does etl::string handle it?
 	ASSERT_INTERNAL(string.size() <= string.capacity(), ErrorHandler::StringTooLarge);
 	std::copy(string.data(), string.data() + string.size(), data + dataSize);
@@ -172,7 +172,7 @@ void Message::appendString(const etl::istring& string) {
 }
 
 void Message::appendFixedString(const etl::istring& string) {
-	ASSERT_INTERNAL((dataSize + string.max_size()) < ECSS_MAX_MESSAGE_SIZE, ErrorHandler::MessageTooLarge);
+	ASSERT_INTERNAL((dataSize + string.max_size()) < ECSSMaxMessageSize, ErrorHandler::MessageTooLarge);
 	std::copy(string.data(), string.data() + string.size(), data + dataSize);
 	(void)memset(data + dataSize + string.size(), 0, string.max_size() - string.size());
 	dataSize += string.max_size();
@@ -182,7 +182,7 @@ void Message::appendOctetString(const etl::istring& string) {
 	// Make sure that the string is large enough to count
 	ASSERT_INTERNAL(string.size() <= (std::numeric_limits<uint16_t>::max)(), ErrorHandler::StringTooLarge);
 	// Redundant check to make sure we fail before appending string.size()
-	ASSERT_INTERNAL(dataSize + 2 + string.size() < ECSS_MAX_MESSAGE_SIZE, ErrorHandler::MessageTooLarge);
+	ASSERT_INTERNAL(dataSize + 2 + string.size() < ECSSMaxMessageSize, ErrorHandler::MessageTooLarge);
 
 	appendUint16(string.size());
 	appendString(string);
diff --git a/src/MessageParser.cpp b/src/MessageParser.cpp
index b23235a42a39b777d2a4bdf95dae663f4b8ebb8d..b7e810895fb7a27bf1f00c6ffaf938bb7119ce0e 100644
--- a/src/MessageParser.cpp
+++ b/src/MessageParser.cpp
@@ -113,39 +113,39 @@ void MessageParser::parseECSSTCHeader(const uint8_t* data, uint16_t length, Mess
 	message.dataSize = length;
 }
 
-Message MessageParser::parseECSSTC(String<ECSS_TC_REQUEST_STRING_SIZE> data) {
+Message MessageParser::parseECSSTC(String<ECSSTCRequestStringSize> data) {
 	Message message;
 	auto* dataInt = reinterpret_cast<uint8_t*>(data.data());
 	message.packetType = Message::TC;
-	parseECSSTCHeader(dataInt, ECSS_TC_REQUEST_STRING_SIZE, message);
+	parseECSSTCHeader(dataInt, ECSSTCRequestStringSize, message);
 	return message;
 }
 
 Message MessageParser::parseECSSTC(uint8_t* data) {
 	Message message;
 	message.packetType = Message::TC;
-	parseECSSTCHeader(data, ECSS_TC_REQUEST_STRING_SIZE, message);
+	parseECSSTCHeader(data, ECSSTCRequestStringSize, message);
 	return message;
 }
 
-String<CCSDS_MAX_MESSAGE_SIZE> MessageParser::composeECSS(const Message& message, uint16_t size) {
+String<CCSDSMaxMessageSize> MessageParser::composeECSS(const Message& message, uint16_t size) {
 	uint8_t header[5];
 
 	if (message.packetType == Message::TC) {
-		header[0] = ECSS_PUS_VERSION << 4U; // Assign the pusVersion = 2
+		header[0] = ECSSPUSVersion << 4U; // Assign the pusVersion = 2
 		header[1] = message.serviceType;
 		header[2] = message.messageType;
 		header[3] = 0;
 		header[4] = 0;
 	} else {
-		header[0] = ECSS_PUS_VERSION << 4U; // Assign the pusVersion = 2
+		header[0] = ECSSPUSVersion << 4U; // Assign the pusVersion = 2
 		header[1] = message.serviceType;
 		header[2] = message.messageType;
 		header[3] = static_cast<uint8_t>(message.messageTypeCounter >> 8U);
 		header[4] = static_cast<uint8_t>(message.messageTypeCounter & 0xffU);
 	}
 
-	String<CCSDS_MAX_MESSAGE_SIZE> dataString(header, 5);
+	String<CCSDSMaxMessageSize> dataString(header, 5);
 	dataString.append(message.data, message.dataSize);
 
 	// Make sure to reach the requested size
@@ -164,14 +164,14 @@ String<CCSDS_MAX_MESSAGE_SIZE> MessageParser::composeECSS(const Message& message
 	return dataString;
 }
 
-String<CCSDS_MAX_MESSAGE_SIZE> MessageParser::compose(const Message& message) {
+String<CCSDSMaxMessageSize> MessageParser::compose(const Message& message) {
 	uint8_t header[6];
 
 	// First, compose the ECSS part
-	String<CCSDS_MAX_MESSAGE_SIZE> ecssMessage = MessageParser::composeECSS(message);
+	String<CCSDSMaxMessageSize> ecssMessage = MessageParser::composeECSS(message);
 
 	// Sanity check that there is enough space for the string
-	ASSERT_INTERNAL((ecssMessage.size() + 6U) <= CCSDS_MAX_MESSAGE_SIZE, ErrorHandler::StringTooLarge);
+	ASSERT_INTERNAL((ecssMessage.size() + 6U) <= CCSDSMaxMessageSize, ErrorHandler::StringTooLarge);
 
 	// Parts of the header
 	uint16_t packetId = message.applicationId;
@@ -189,7 +189,7 @@ String<CCSDS_MAX_MESSAGE_SIZE> MessageParser::compose(const Message& message) {
 	header[5] = packetDataLength & 0xffU;
 
 	// Compile the final message by appending the header
-	String<CCSDS_MAX_MESSAGE_SIZE> ccsdsMessage(header, 6);
+	String<CCSDSMaxMessageSize> ccsdsMessage(header, 6);
 	ccsdsMessage.append(ecssMessage);
 
 #if ECSS_CRC_INCLUDED
diff --git a/src/Services/EventActionService.cpp b/src/Services/EventActionService.cpp
index 84c727bef38a330796aaa6c0da4d990828240ab4..97546642db51f5b127aa9e1faccb1ded3d1bcad2 100644
--- a/src/Services/EventActionService.cpp
+++ b/src/Services/EventActionService.cpp
@@ -22,20 +22,20 @@ void EventActionService::addEventActionDefinitions(Message& message) {
 			}
 		}
 	}
-	if ((message.dataSize - 6) > ECSS_TC_REQUEST_STRING_SIZE) {
+	if ((message.dataSize - 6) > ECSSTCRequestStringSize) {
 		canBeAdded = false;
 		ErrorHandler::reportInternalError(ErrorHandler::MessageTooLarge);
 	}
 	if (canBeAdded) {
-		char data[ECSS_TC_REQUEST_STRING_SIZE] = { 0 };
+		char data[ECSSTCRequestStringSize] = { 0 };
 		message.readString(data, message.dataSize - 6);
 		EventActionDefinition temp;
 		temp.enabled = false;
 		temp.applicationId = applicationID;
 		temp.eventDefinitionID = eventDefinitionID;
 		temp.eventActionDefinitionID = eventActionDefinitionID;
-		temp.request = String<ECSS_TC_REQUEST_STRING_SIZE>(data);
-		if (eventActionDefinitionMap.size() == ECSS_EVENT_ACTION_STRUCT_MAP_SIZE) {
+		temp.request = String<ECSSTCRequestStringSize>(data);
+		if (eventActionDefinitionMap.size() == ECSSEventActionStructMapSize) {
 			ErrorHandler::reportError(message,ErrorHandler::EventActionDefinitionsMapIsFull);
 		} else {
 			eventActionDefinitionMap.insert(std::make_pair(eventDefinitionID, temp));
diff --git a/src/Services/EventReportService.cpp b/src/Services/EventReportService.cpp
index cd4b46828ac5db7992aa44c5a8ee0bb4f7ad7bf6..a52572832ae064a32cb92d361b2c7e26d57daa65 100644
--- a/src/Services/EventReportService.cpp
+++ b/src/Services/EventReportService.cpp
@@ -9,7 +9,7 @@
  * @todo: Add message type in TCs
  * @todo: this code is error prone, depending on parameters given, add fail safes (probably?)
  */
-void EventReportService::informativeEventReport(Event eventID, const String<ECSS_EVENT_DATA_AUXILIARY_MAX_SIZE>& data) {
+void EventReportService::informativeEventReport(Event eventID, const String<ECSSEventDataAuxiliaryMaxSize>& data) {
 	// TM[5,1]
 	if (stateOfEvents[static_cast<uint16_t>(eventID)]) {
 		Message report = createTM(EventReportService::MessageType::InformativeEventReport);
@@ -23,7 +23,7 @@ void EventReportService::informativeEventReport(Event eventID, const String<ECSS
 }
 
 void
-EventReportService::lowSeverityAnomalyReport(Event eventID, const String<ECSS_EVENT_DATA_AUXILIARY_MAX_SIZE>& data) {
+EventReportService::lowSeverityAnomalyReport(Event eventID, const String<ECSSEventDataAuxiliaryMaxSize>& data) {
 	lowSeverityEventCount++;
 	// TM[5,2]
 	if (stateOfEvents[static_cast<uint16_t>(eventID)]) {
@@ -40,7 +40,7 @@ EventReportService::lowSeverityAnomalyReport(Event eventID, const String<ECSS_EV
 }
 
 void
-EventReportService::mediumSeverityAnomalyReport(Event eventID, const String<ECSS_EVENT_DATA_AUXILIARY_MAX_SIZE>& data) {
+EventReportService::mediumSeverityAnomalyReport(Event eventID, const String<ECSSEventDataAuxiliaryMaxSize>& data) {
 	mediumSeverityEventCount++;
 	// TM[5,3]
 	if (stateOfEvents[static_cast<uint16_t>(eventID)]) {
@@ -57,7 +57,7 @@ EventReportService::mediumSeverityAnomalyReport(Event eventID, const String<ECSS
 }
 
 void
-EventReportService::highSeverityAnomalyReport(Event eventID, const String<ECSS_EVENT_DATA_AUXILIARY_MAX_SIZE>& data) {
+EventReportService::highSeverityAnomalyReport(Event eventID, const String<ECSSEventDataAuxiliaryMaxSize>& data) {
 	highSeverityEventCount++;
 	// TM[5,4]
 	if (stateOfEvents[static_cast<uint16_t>(eventID)]) {
diff --git a/src/Services/FunctionManagementService.cpp b/src/Services/FunctionManagementService.cpp
index b8373faad304a93b4f53df6938e12358c110a69d..c01260a922e22ef3e1422ae676762299790ee7a2 100644
--- a/src/Services/FunctionManagementService.cpp
+++ b/src/Services/FunctionManagementService.cpp
@@ -12,13 +12,13 @@ void FunctionManagementService::call(Message& msg) {
 	ErrorHandler::assertRequest(msg.serviceType == FunctionManagementService::ServiceType, msg,
 		ErrorHandler::AcceptanceErrorType::UnacceptableMessage);
 
-	uint8_t funcName[ECSS_FUNCTION_NAME_LENGTH] = { 0 }; // the function's name
-	uint8_t funcArgs[ECSS_FUNCTION_MAX_ARG_LENGTH] = { 0 }; // arguments for the function
+	uint8_t funcName[ECSSFunctionNameLength] = { 0 }; // the function's name
+	uint8_t funcArgs[ECSSFunctionMaxArgLength] = { 0 }; // arguments for the function
 
-	msg.readString(funcName, ECSS_FUNCTION_NAME_LENGTH);
-	msg.readString(funcArgs, ECSS_FUNCTION_MAX_ARG_LENGTH);
+	msg.readString(funcName, ECSSFunctionNameLength);
+	msg.readString(funcArgs, ECSSFunctionMaxArgLength);
 
-	if (msg.dataSize > (ECSS_FUNCTION_NAME_LENGTH + ECSS_FUNCTION_MAX_ARG_LENGTH)) {
+	if (msg.dataSize > (ECSSFunctionNameLength + ECSSFunctionMaxArgLength)) {
 		ErrorHandler::reportError(msg,
 		                          ErrorHandler::ExecutionStartErrorType::UnknownExecutionStartError); // report failed
 		// start of execution as requested by the standard
@@ -26,9 +26,9 @@ void FunctionManagementService::call(Message& msg) {
 	}
 
 	// locate the appropriate function pointer
-	String<ECSS_FUNCTION_NAME_LENGTH> name(funcName);
+	String<ECSSFunctionNameLength> name(funcName);
 	FunctionMap::iterator iter = funcPtrIndex.find(name);
-	void (*selected)(String<ECSS_FUNCTION_MAX_ARG_LENGTH>);
+	void (*selected)(String<ECSSFunctionMaxArgLength>);
 
 	if (iter != funcPtrIndex.end()) {
 		selected = *iter->second;
@@ -41,11 +41,11 @@ void FunctionManagementService::call(Message& msg) {
 	selected(funcArgs);
 }
 
-void FunctionManagementService::include(String<ECSS_FUNCTION_NAME_LENGTH> funcName,
-	void (* ptr)(String<ECSS_FUNCTION_MAX_ARG_LENGTH>)) {
+void FunctionManagementService::include(String<ECSSFunctionNameLength> funcName,
+	void (* ptr)(String<ECSSFunctionMaxArgLength>)) {
 	if (not funcPtrIndex.full()) { // CAUTION: etl::map won't check by itself if it's full
 		// before attempting to insert a key-value pair, causing segmentation faults. Check first!
-		funcName.append(ECSS_FUNCTION_NAME_LENGTH - funcName.length(), 0);
+		funcName.append(ECSSFunctionNameLength - funcName.length(), 0);
 		funcPtrIndex.insert(std::make_pair(funcName, ptr));
 	} else {
 		ErrorHandler::reportInternalError(ErrorHandler::InternalErrorType::MapFull);
diff --git a/src/Services/LargePacketTransferService.cpp b/src/Services/LargePacketTransferService.cpp
index b11aa16f41d02b70a97a2e245ee9cb9eb2e862a0..03bebbcd4d9df1b8df3b39d6552bcfb174420a80 100644
--- a/src/Services/LargePacketTransferService.cpp
+++ b/src/Services/LargePacketTransferService.cpp
@@ -7,7 +7,7 @@
 
 void LargePacketTransferService::firstDownlinkPartReport(uint16_t largeMessageTransactionIdentifier,
                                                          uint16_t partSequenceNumber,
-                                                         const String<ECSS_MAX_FIXED_OCTET_STRING_SIZE>& string) {
+                                                         const String<ECSSMaxFixedOctetStringSize>& string) {
 	// TM[13,1]
 
 	Message report = createTM(LargePacketTransferService::MessageType::FirstDownlinkPartReport);
@@ -19,7 +19,7 @@ void LargePacketTransferService::firstDownlinkPartReport(uint16_t largeMessageTr
 
 void LargePacketTransferService::intermediateDownlinkPartReport(
     uint16_t largeMessageTransactionIdentifier, uint16_t partSequenceNumber,
-    const String<ECSS_MAX_FIXED_OCTET_STRING_SIZE>& string) {
+    const String<ECSSMaxFixedOctetStringSize>& string) {
 	// TM[13,2]
 	Message report = createTM(LargePacketTransferService::MessageType::InternalDownlinkPartReport);
 	report.appendUint16(largeMessageTransactionIdentifier); // large message transaction identifier
@@ -30,7 +30,7 @@ void LargePacketTransferService::intermediateDownlinkPartReport(
 
 void LargePacketTransferService::lastDownlinkPartReport(uint16_t largeMessageTransactionIdentifier,
                                                         uint16_t partSequenceNumber,
-                                                        const String<ECSS_MAX_FIXED_OCTET_STRING_SIZE>& string) {
+                                                        const String<ECSSMaxFixedOctetStringSize>& string) {
 	// TM[13,3]
 	Message report = createTM(LargePacketTransferService::MessageType::LastDownlinkPartReport);
 	report.appendUint16(largeMessageTransactionIdentifier); // large message transaction identifier
@@ -39,20 +39,20 @@ void LargePacketTransferService::lastDownlinkPartReport(uint16_t largeMessageTra
 	storeMessage(report);
 }
 
-String<ECSS_MAX_FIXED_OCTET_STRING_SIZE>
-LargePacketTransferService::firstUplinkPart(const String<ECSS_MAX_FIXED_OCTET_STRING_SIZE>& string) {
+String<ECSSMaxFixedOctetStringSize>
+LargePacketTransferService::firstUplinkPart(const String<ECSSMaxFixedOctetStringSize>& string) {
 	// TC[13,9]
 	return string;
 }
 
-String<ECSS_MAX_FIXED_OCTET_STRING_SIZE>
-LargePacketTransferService::intermediateUplinkPart(const String<ECSS_MAX_FIXED_OCTET_STRING_SIZE>& string) {
+String<ECSSMaxFixedOctetStringSize>
+LargePacketTransferService::intermediateUplinkPart(const String<ECSSMaxFixedOctetStringSize>& string) {
 	// TC[13,10]
 	return string;
 }
 
-String<ECSS_MAX_FIXED_OCTET_STRING_SIZE>
-LargePacketTransferService::lastUplinkPart(const String<ECSS_MAX_FIXED_OCTET_STRING_SIZE>& string) {
+String<ECSSMaxFixedOctetStringSize>
+LargePacketTransferService::lastUplinkPart(const String<ECSSMaxFixedOctetStringSize>& string) {
 	// TC[13, 11]
 	return string;
 }
@@ -61,11 +61,11 @@ void LargePacketTransferService::split(Message& message, uint16_t largeMessageTr
 	//TODO: Should this be uint32?
 	uint16_t size = message.dataSize;
 	uint16_t positionCounter = 0;
-	uint16_t parts = (size/ECSS_MAX_FIXED_OCTET_STRING_SIZE) + 1;
-	String<ECSS_MAX_FIXED_OCTET_STRING_SIZE> stringPart("");
-	uint8_t dataPart[ECSS_MAX_FIXED_OCTET_STRING_SIZE];
+	uint16_t parts = (size/ECSSMaxFixedOctetStringSize) + 1;
+	String<ECSSMaxFixedOctetStringSize> stringPart("");
+	uint8_t dataPart[ECSSMaxFixedOctetStringSize];
 
-	for (uint16_t i = 0; i < ECSS_MAX_FIXED_OCTET_STRING_SIZE; i++){
+	for (uint16_t i = 0; i < ECSSMaxFixedOctetStringSize; i++){
 		dataPart[i] = message.data[positionCounter];
 		positionCounter++;
 	}
@@ -73,7 +73,7 @@ void LargePacketTransferService::split(Message& message, uint16_t largeMessageTr
 	firstDownlinkPartReport(largeMessageTransactionIdentifier, 0, stringPart);
 
 	for (uint16_t part = 1; part < (parts - 1U); part++){
-		for (uint16_t i = 0; i < ECSS_MAX_FIXED_OCTET_STRING_SIZE; i++){
+		for (uint16_t i = 0; i < ECSSMaxFixedOctetStringSize; i++){
 			dataPart[i] = message.data[positionCounter];
 			positionCounter++;
 		}
@@ -81,7 +81,7 @@ void LargePacketTransferService::split(Message& message, uint16_t largeMessageTr
 		intermediateDownlinkPartReport(largeMessageTransactionIdentifier, part, stringPart);
 	}
 
-	for (uint16_t i = 0; i < ECSS_MAX_FIXED_OCTET_STRING_SIZE; i++){
+	for (uint16_t i = 0; i < ECSSMaxFixedOctetStringSize; i++){
 		if (message.dataSize == positionCounter){
 			dataPart[i] = 0; // To prevent from filling the rest of the String with garbage info
 		}
diff --git a/src/Services/MemoryManagementService.cpp b/src/Services/MemoryManagementService.cpp
index b0c28944629f5ce69f8867792f8bd1cee67ff2fc..870b84cd864e15f3ed917be997f335c02d339c1a 100644
--- a/src/Services/MemoryManagementService.cpp
+++ b/src/Services/MemoryManagementService.cpp
@@ -32,7 +32,7 @@ void MemoryManagementService::RawDataMemoryManagement::loadRawData(Message& requ
 	// Check for a valid memory ID first
 	if (mainService.memoryIdValidator(MemoryManagementService::MemoryID(memoryID))) {
 		// Variable declaration
-		uint8_t readData[ECSS_MAX_STRING_SIZE]; // Preallocate the array
+		uint8_t readData[ECSSMaxStringSize]; // Preallocate the array
 		uint16_t iterationCount = request.readUint16(); // Get the iteration count
 
 		if (memoryID == MemoryManagementService::MemoryID::FLASH) {
@@ -83,7 +83,7 @@ void MemoryManagementService::RawDataMemoryManagement::dumpRawData(Message& requ
 	// Check for a valid memory ID first
 	if (mainService.memoryIdValidator(MemoryManagementService::MemoryID(memoryID))) {
 		// Variable declaration
-		uint8_t readData[ECSS_MAX_STRING_SIZE]; // Preallocate the array
+		uint8_t readData[ECSSMaxStringSize]; // Preallocate the array
 		uint16_t iterationCount = request.readUint16(); // Get the iteration count
 
 		// Append the data to report message
@@ -129,7 +129,7 @@ void MemoryManagementService::RawDataMemoryManagement::checkRawData(Message& req
 
 	if (mainService.memoryIdValidator(MemoryManagementService::MemoryID(memoryID))) {
 		// Variable declaration
-		uint8_t readData[ECSS_MAX_STRING_SIZE]; // Preallocate the array
+		uint8_t readData[ECSSMaxStringSize]; // Preallocate the array
 		uint16_t iterationCount = request.readUint16(); // Get the iteration count
 
 		// Append the data to report message
@@ -171,32 +171,32 @@ bool MemoryManagementService::addressValidator(MemoryManagementService::MemoryID
 
 	switch (memId) {
 		case MemoryManagementService::MemoryID::DTCMRAM:
-			if ((address >= DTCMRAM_LOWER_LIM) && (address <= DTCMRAM_UPPER_LIM)) {
+			if ((address >= DTCMRAMLowerLim) && (address <= DTCMRAMUpperLim)) {
 				validIndicator = true;
 			}
 			break;
 		case MemoryManagementService::MemoryID::ITCMRAM:
-			if ((address >= ITCMRAM_LOWER_LIM) && (address <= ITCMRAM_UPPER_LIM)) {
+			if ((address >= ITCMRAMLowerLim) && (address <= ITCMRAMUpperLim)) {
 				validIndicator = true;
 			}
 			break;
 		case MemoryManagementService::MemoryID::RAM_D1:
-			if ((address >= RAM_D1_LOWER_LIM) && (address <= RAM_D1_UPPER_LIM)) {
+			if ((address >= RAMD1LowerLim) && (address <= RAMD1UpperLim)) {
 				validIndicator = true;
 			}
 			break;
 		case MemoryManagementService::MemoryID::RAM_D2:
-			if ((address >= RAM_D2_LOWER_LIM) && (address <= RAM_D2_UPPER_LIM)) {
+			if ((address >= RAMD2LowerLim) && (address <= RAMD2UpperLim)) {
 				validIndicator = true;
 			}
 			break;
 		case MemoryManagementService::MemoryID::RAM_D3:
-			if ((address >= RAM_D3_LOWER_LIM) && (address <= RAM_D3_UPPER_LIM)) {
+			if ((address >= RAMD3LowerLim) && (address <= RAMD3UpperLim)) {
 				validIndicator = true;
 			}
 			break;
 		case MemoryManagementService::MemoryID::FLASH:
-			if ((address >= FLASH_LOWER_LIM) && (address <= FLASH_UPPER_LIM)) {
+			if ((address >= FlashLowerLim) && (address <= FlashUpperLim)) {
 				validIndicator = true;
 			}
 			break;
diff --git a/src/Services/ParameterStatisticsService.cpp b/src/Services/ParameterStatisticsService.cpp
index 35c23b7cea2a2a15e6d7f759b38e01847740d5ae..0cb1c86fea0dfc584e01b10993d97ec06feedb5d 100644
--- a/src/Services/ParameterStatisticsService.cpp
+++ b/src/Services/ParameterStatisticsService.cpp
@@ -108,7 +108,7 @@ void ParameterStatisticsService::addOrUpdateStatisticsDefinitions(Message& reque
 			}
 		}
 		if (not exists) {
-			if (statisticsMap.size() >= ECSS_MAX_STATISTIC_PARAMETERS) {
+			if (statisticsMap.size() >= ECSSMaxStatisticParameters) {
 				ErrorHandler::reportError(request,
 				                          ErrorHandler::ExecutionStartErrorType::MaxStatisticDefinitionsReached);
 				return;
diff --git a/src/Services/RequestVerificationService.cpp b/src/Services/RequestVerificationService.cpp
index 2cd658a8ecfd11e62d63b577e1db839d32340989..33546c778b51a0d57832080b7acc3a4e86e6832f 100644
--- a/src/Services/RequestVerificationService.cpp
+++ b/src/Services/RequestVerificationService.cpp
@@ -8,11 +8,11 @@ void RequestVerificationService::successAcceptanceVerification(const Message& re
 
 	Message report = createTM(RequestVerificationService::MessageType::SuccessfulAcceptanceReport);
 
-	report.appendEnumerated(3, CCSDS_PACKET_VERSION); // packet version number
+	report.appendEnumerated(3, CCSDSPacketVersion); // packet version number
 	report.appendEnumerated(1, request.packetType); // packet type
 	report.appendBits(1, 1); // secondary header flag
 	report.appendEnumerated(11, request.applicationId); // application process ID
-	report.appendEnumerated(2, ECSS_SEQUENCE_FLAGS); // sequence flags
+	report.appendEnumerated(2, ECSSSequenceFlags); // sequence flags
 	report.appendBits(14, request.packetSequenceCount); // packet sequence count
 
 	storeMessage(report);
@@ -24,11 +24,11 @@ void RequestVerificationService::failAcceptanceVerification(const Message& reque
 
 	Message report = createTM(RequestVerificationService::MessageType::FailedAcceptanceReport);
 
-	report.appendEnumerated(3, CCSDS_PACKET_VERSION); // packet version number
+	report.appendEnumerated(3, CCSDSPacketVersion); // packet version number
 	report.appendEnumerated(1, request.packetType); // packet type
 	report.appendBits(1, 1); // secondary header flag
 	report.appendEnumerated(11, request.applicationId); // application process ID
-	report.appendEnumerated(2, ECSS_SEQUENCE_FLAGS); // sequence flags
+	report.appendEnumerated(2, ECSSSequenceFlags); // sequence flags
 	report.appendBits(14, request.packetSequenceCount); // packet sequence count
 	report.appendEnum16(errorCode); // error code
 
@@ -40,11 +40,11 @@ void RequestVerificationService::successStartExecutionVerification(const Message
 
 	Message report = createTM(RequestVerificationService::MessageType::SuccessfulStartOfExecution);
 
-	report.appendEnumerated(3, CCSDS_PACKET_VERSION); // packet version number
+	report.appendEnumerated(3, CCSDSPacketVersion); // packet version number
 	report.appendEnumerated(1, request.packetType); // packet type
 	report.appendBits(1, 1); // secondary header flag
 	report.appendEnumerated(11, request.applicationId); // application process ID
-	report.appendEnumerated(2, ECSS_SEQUENCE_FLAGS); // sequence flags
+	report.appendEnumerated(2, ECSSSequenceFlags); // sequence flags
 	report.appendBits(14, request.packetSequenceCount); // packet sequence count
 
 	storeMessage(report);
@@ -56,11 +56,11 @@ void RequestVerificationService::failStartExecutionVerification(const Message& r
 
 	Message report = createTM(RequestVerificationService::MessageType::FailedStartOfExecution);
 
-	report.appendEnumerated(3, CCSDS_PACKET_VERSION); // packet version number
+	report.appendEnumerated(3, CCSDSPacketVersion); // packet version number
 	report.appendEnumerated(1, request.packetType); // packet type
 	report.appendBits(1, 1); // secondary header flag
 	report.appendEnumerated(11, request.applicationId); // application process ID
-	report.appendEnumerated(2, ECSS_SEQUENCE_FLAGS); // sequence flags
+	report.appendEnumerated(2, ECSSSequenceFlags); // sequence flags
 	report.appendBits(14, request.packetSequenceCount); // packet sequence count
 	report.appendEnum16(errorCode); // error code
 
@@ -72,11 +72,11 @@ void RequestVerificationService::successProgressExecutionVerification(const Mess
 
 	Message report = createTM(RequestVerificationService::MessageType::SuccessfulProgressOfExecution);
 
-	report.appendEnumerated(3, CCSDS_PACKET_VERSION); // packet version number
+	report.appendEnumerated(3, CCSDSPacketVersion); // packet version number
 	report.appendEnumerated(1, request.packetType); // packet type
 	report.appendBits(1, 1); // secondary header flag
 	report.appendEnumerated(11, request.applicationId); // application process ID
-	report.appendEnumerated(2, ECSS_SEQUENCE_FLAGS); // sequence flags
+	report.appendEnumerated(2, ECSSSequenceFlags); // sequence flags
 	report.appendBits(14, request.packetSequenceCount); // packet sequence count
 	report.appendByte(stepID); // step ID
 
@@ -90,11 +90,11 @@ void RequestVerificationService::failProgressExecutionVerification(const Message
 
 	Message report = createTM(RequestVerificationService::MessageType::FailedProgressOfExecution);
 
-	report.appendEnumerated(3, CCSDS_PACKET_VERSION); // packet version number
+	report.appendEnumerated(3, CCSDSPacketVersion); // packet version number
 	report.appendEnumerated(1, request.packetType); // packet type
 	report.appendBits(1, 1); // secondary header flag
 	report.appendEnumerated(11, request.applicationId); // application process ID
-	report.appendEnumerated(2, ECSS_SEQUENCE_FLAGS); // sequence flags
+	report.appendEnumerated(2, ECSSSequenceFlags); // sequence flags
 	report.appendBits(14, request.packetSequenceCount); // packet sequence count
 	report.appendByte(stepID); // step ID
 	report.appendEnum16(errorCode); // error code
@@ -107,11 +107,11 @@ void RequestVerificationService::successCompletionExecutionVerification(const Me
 
 	Message report = createTM(RequestVerificationService::MessageType::SuccessfulCompletionOfExecution);
 
-	report.appendEnumerated(3, CCSDS_PACKET_VERSION); // packet version number
+	report.appendEnumerated(3, CCSDSPacketVersion); // packet version number
 	report.appendEnumerated(1, request.packetType); // packet type
 	report.appendBits(1, 1); // secondary header flag
 	report.appendEnumerated(11, request.applicationId); // application process ID
-	report.appendEnumerated(2, ECSS_SEQUENCE_FLAGS); // sequence flags
+	report.appendEnumerated(2, ECSSSequenceFlags); // sequence flags
 	report.appendBits(14, request.packetSequenceCount); // packet sequence count
 
 	storeMessage(report);
@@ -123,11 +123,11 @@ void RequestVerificationService::failCompletionExecutionVerification(
 
 	Message report = createTM(RequestVerificationService::MessageType::FailedCompletionOfExecution);
 
-	report.appendEnumerated(3, CCSDS_PACKET_VERSION); // packet version number
+	report.appendEnumerated(3, CCSDSPacketVersion); // packet version number
 	report.appendEnumerated(1, request.packetType); // packet type
 	report.appendBits(1, 1); // secondary header flag
 	report.appendEnumerated(11, request.applicationId); // application process ID
-	report.appendEnumerated(2, ECSS_SEQUENCE_FLAGS); // sequence flags
+	report.appendEnumerated(2, ECSSSequenceFlags); // sequence flags
 	report.appendBits(14, request.packetSequenceCount); // packet sequence count
 	report.appendEnum16(errorCode); // error code
 
@@ -140,11 +140,11 @@ void RequestVerificationService::failRoutingVerification(const Message& request,
 
 	Message report = createTM(RequestVerificationService::MessageType::FailedRoutingReport);
 
-	report.appendEnumerated(3, CCSDS_PACKET_VERSION); // packet version number
+	report.appendEnumerated(3, CCSDSPacketVersion); // packet version number
 	report.appendEnumerated(1, request.packetType); // packet type
 	report.appendBits(1, 1); // secondary header flag
 	report.appendEnumerated(11, request.applicationId); // application process ID
-	report.appendEnumerated(2, ECSS_SEQUENCE_FLAGS); // sequence flags
+	report.appendEnumerated(2, ECSSSequenceFlags); // sequence flags
 	report.appendBits(14, request.packetSequenceCount); // packet sequence count
 	report.appendEnum16(errorCode); // error code
 
diff --git a/src/Services/TimeBasedSchedulingService.cpp b/src/Services/TimeBasedSchedulingService.cpp
index 11ddea8504d6ca4c43d20c52920bd69eac300696..61f51e029f97033116643b551350209ab65439e3 100644
--- a/src/Services/TimeBasedSchedulingService.cpp
+++ b/src/Services/TimeBasedSchedulingService.cpp
@@ -45,13 +45,13 @@ void TimeBasedSchedulingService::insertActivities(Message& request) {
 		uint32_t currentTime = TimeGetter::getSeconds(); // Get the current system time
 
 		uint32_t releaseTime = request.readUint32(); // Get the specified release time
-		if ((scheduledActivities.available() == 0) || (releaseTime < (currentTime + ECSS_TIME_MARGIN_FOR_ACTIVATION))) {
+		if ((scheduledActivities.available() == 0) || (releaseTime < (currentTime + ECSSTimeMarginForActivation))) {
 			ErrorHandler::reportError(request, ErrorHandler::InstructionExecutionStartError);
-			request.skipBytes(ECSS_TC_REQUEST_STRING_SIZE);
+			request.skipBytes(ECSSTCRequestStringSize);
 		} else {
 			// Get the TC packet request
-			uint8_t requestData[ECSS_TC_REQUEST_STRING_SIZE] = {0};
-			request.readString(requestData, ECSS_TC_REQUEST_STRING_SIZE);
+			uint8_t requestData[ECSSTCRequestStringSize] = {0};
+			request.readString(requestData, ECSSTCRequestStringSize);
 			Message receivedTCPacket = MessageParser::parseECSSTC(requestData);
 			ScheduledActivity newActivity; // Create the new activity
 
@@ -84,7 +84,7 @@ void TimeBasedSchedulingService::timeShiftAllActivities(Message& request) {
 	                        });
 	// todo: Define what the time format is going to be
 	int32_t relativeOffset = request.readSint32(); // Get the relative offset
-	if ((releaseTimes.first->requestReleaseTime + relativeOffset) < (current_time + ECSS_TIME_MARGIN_FOR_ACTIVATION)) {
+	if ((releaseTimes.first->requestReleaseTime + relativeOffset) < (current_time + ECSSTimeMarginForActivation)) {
 		// Report the error
 		ErrorHandler::reportError(request, ErrorHandler::SubServiceExecutionStartError);
 	} else {
@@ -119,7 +119,7 @@ void TimeBasedSchedulingService::timeShiftActivitiesByID(Message& request) {
 		if (requestIDMatch != scheduledActivities.end()) {
 			// If the relative offset does not meet the restrictions issue an error
 			if ((requestIDMatch->requestReleaseTime + relativeOffset) <
-			    (current_time + ECSS_TIME_MARGIN_FOR_ACTIVATION)) {
+			    (current_time + ECSSTimeMarginForActivation)) {
 				ErrorHandler::reportError(request, ErrorHandler::InstructionExecutionStartError);
 			} else {
 				requestIDMatch->requestReleaseTime += relativeOffset; // Add the time offset
@@ -183,7 +183,7 @@ void TimeBasedSchedulingService::detailReportActivitiesByID(Message& request) {
 
 	// Create the report message object of telemetry message subtype 10 for each activity
 	Message report = createTM(TimeBasedSchedulingService::MessageType::TimeBasedScheduleReportById);
-	etl::list<ScheduledActivity, ECSS_MAX_NUMBER_OF_TIME_SCHED_ACTIVITIES> matchedActivities;
+	etl::list<ScheduledActivity, ECSSMaxNumberOfTimeSchedActivities> matchedActivities;
 
 	uint16_t iterationCount = request.readUint16(); // Get the iteration count, (N)
 	while (iterationCount-- != 0) {
@@ -224,7 +224,7 @@ void TimeBasedSchedulingService::summaryReportActivitiesByID(Message& request) {
 
 	// Create the report message object of telemetry message subtype 13 for each activity
 	Message report = createTM(TimeBasedSchedulingService::MessageType::TimeBasedScheduledSummaryReport);
-	etl::list<ScheduledActivity, ECSS_MAX_NUMBER_OF_TIME_SCHED_ACTIVITIES> matchedActivities;
+	etl::list<ScheduledActivity, ECSSMaxNumberOfTimeSchedActivities> matchedActivities;
 
 	uint16_t iterationCount = request.readUint16(); // Get the iteration count, (N)
 	while (iterationCount-- != 0) {
diff --git a/test/ErrorHandler.cpp b/test/ErrorHandler.cpp
index cf1006f932bf0bfe557998daf7d2fb8e89a575ce..2db17bf40a7f120fa9e8e6b86e8df02c3d815d04 100644
--- a/test/ErrorHandler.cpp
+++ b/test/ErrorHandler.cpp
@@ -17,11 +17,11 @@ TEST_CASE("Error: Failed Acceptance", "[errors]") {
 	CHECK(report.packetType == Message::TM);
 	REQUIRE(report.dataSize == 6);
 
-	CHECK(report.readBits(3) == CCSDS_PACKET_VERSION);
+	CHECK(report.readBits(3) == CCSDSPacketVersion);
 	CHECK(report.readBits(1) == static_cast<uint16_t>(Message::TC));
 	CHECK(report.readBits(1) == 1);
 	CHECK(report.readBits(11) == 47);
-	CHECK(report.readBits(2) == ECSS_SEQUENCE_FLAGS);
+	CHECK(report.readBits(2) == ECSSSequenceFlags);
 	CHECK(report.readBits(14) == failedMessage.packetSequenceCount);
 	CHECK(report.readEnum16() == ErrorHandler::MessageTooShort);
 }
@@ -40,11 +40,11 @@ TEST_CASE("Error: Failed Execution Start", "[errors]") {
 	CHECK(report.packetType == Message::TM);
 	REQUIRE(report.dataSize == 6);
 
-	CHECK(report.readBits(3) == CCSDS_PACKET_VERSION);
+	CHECK(report.readBits(3) == CCSDSPacketVersion);
 	CHECK(report.readBits(1) == static_cast<uint16_t>(Message::TC));
 	CHECK(report.readBits(1) == 1);
 	CHECK(report.readBits(11) == 56);
-	CHECK(report.readBits(2) == ECSS_SEQUENCE_FLAGS);
+	CHECK(report.readBits(2) == ECSSSequenceFlags);
 	CHECK(report.readBits(14) == failedMessage.packetSequenceCount);
 	CHECK(report.readEnum16() == ErrorHandler::UnknownExecutionStartError);
 }
@@ -63,11 +63,11 @@ TEST_CASE("Error: Failed Execution Progress", "[errors]") {
 	CHECK(report.packetType == Message::TM);
 	REQUIRE(report.dataSize == 7);
 
-	CHECK(report.readBits(3) == CCSDS_PACKET_VERSION);
+	CHECK(report.readBits(3) == CCSDSPacketVersion);
 	CHECK(report.readBits(1) == static_cast<uint16_t>(Message::TC));
 	CHECK(report.readBits(1) == 1);
 	CHECK(report.readBits(11) == 56);
-	CHECK(report.readBits(2) == ECSS_SEQUENCE_FLAGS);
+	CHECK(report.readBits(2) == ECSSSequenceFlags);
 	CHECK(report.readBits(14) == failedMessage.packetSequenceCount);
 	CHECK(report.readEnum16() == ErrorHandler::UnknownExecutionProgressError);
 	CHECK(report.readByte() == 0); // stepID
@@ -87,11 +87,11 @@ TEST_CASE("Error: Failed Execution Completion", "[errors]") {
 	CHECK(report.packetType == Message::TM);
 	REQUIRE(report.dataSize == 6);
 
-	CHECK(report.readBits(3) == CCSDS_PACKET_VERSION);
+	CHECK(report.readBits(3) == CCSDSPacketVersion);
 	CHECK(report.readBits(1) == static_cast<uint16_t>(Message::TC));
 	CHECK(report.readBits(1) == 1);
 	CHECK(report.readBits(11) == 56);
-	CHECK(report.readBits(2) == ECSS_SEQUENCE_FLAGS);
+	CHECK(report.readBits(2) == ECSSSequenceFlags);
 	CHECK(report.readBits(14) == failedMessage.packetSequenceCount);
 	CHECK(report.readEnum16() == ErrorHandler::UnknownExecutionCompletionError);
 }
@@ -110,11 +110,11 @@ TEST_CASE("Error: Failed Routing", "[errors]") {
 	CHECK(report.packetType == Message::TM);
 	REQUIRE(report.dataSize == 6);
 
-	CHECK(report.readBits(3) == CCSDS_PACKET_VERSION);
+	CHECK(report.readBits(3) == CCSDSPacketVersion);
 	CHECK(report.readBits(1) == static_cast<uint16_t>(Message::TC));
 	CHECK(report.readBits(1) == 1);
 	CHECK(report.readBits(11) == 71);
-	CHECK(report.readBits(2) == ECSS_SEQUENCE_FLAGS);
+	CHECK(report.readBits(2) == ECSSSequenceFlags);
 	CHECK(report.readBits(14) == failedMessage.packetSequenceCount);
 	CHECK(report.readEnum16() == ErrorHandler::UnknownRoutingError);
 }
diff --git a/test/Helpers/TimeHelper.cpp b/test/Helpers/TimeHelper.cpp
index cca057be3459f519e781c4c758d53483e4a1d32b..e9d0fd1f22d532553de2925a1cb6ccf3657522ec 100644
--- a/test/Helpers/TimeHelper.cpp
+++ b/test/Helpers/TimeHelper.cpp
@@ -242,7 +242,7 @@ TEST_CASE("Time format implementation for CUC", "[CUC]") {
 
 	uint32_t currTime = TimeHelper::utcToSeconds(TimeInfo);
 
-	uint32_t timeFormat = currTime + LEAP_SECONDS;
+	uint32_t timeFormat = currTime + LeapSeconds;
 	CHECK(TimeHelper::generateCUCTimeFormat(TimeInfo) == timeFormat);
 
 	Message message = Message(9, 128, Message::TC, 3);
@@ -259,7 +259,7 @@ TEST_CASE("Time format implementation for CUC", "[CUC]") {
 
 	currTime = TimeHelper::utcToSeconds(TimeInfo);
 
-	timeFormat = currTime + LEAP_SECONDS; // TAI format
+	timeFormat = currTime + LeapSeconds; // TAI format
 	CHECK(TimeHelper::generateCUCTimeFormat(TimeInfo) == timeFormat);
 
 	message = Message(9, 128, Message::TC, 3);
diff --git a/test/MessageParser.cpp b/test/MessageParser.cpp
index 325daf70304338ccda549c6cb1bf302e17192135..93cfa695a26cb1a97455db4c6e6ddf4310ec98c5 100644
--- a/test/MessageParser.cpp
+++ b/test/MessageParser.cpp
@@ -31,7 +31,7 @@ TEST_CASE("TC Message parsing into a string", "[MessageParser]") {
 	std::copy(sourceString.data(), sourceString.data() + sourceString.size(), message.data);
 	message.dataSize = 5;
 
-	String<CCSDS_MAX_MESSAGE_SIZE> createdPacket = MessageParser::compose(message);
+	String<CCSDSMaxMessageSize> createdPacket = MessageParser::compose(message);
 #if ECSS_CRC_INCLUDED
 	CHECK(createdPacket.size() == 18);
 	CHECK(memcmp(createdPacket.data(), wantedPacket, 16) == 0);
@@ -72,7 +72,7 @@ TEST_CASE("TM Message parsing into a string", "[MessageParser]") {
 	String<7> sourceString = "hellohi";
 	std::copy(sourceString.data(), sourceString.data() + sourceString.size(), message.data);
 	message.dataSize = 7;
-	String<CCSDS_MAX_MESSAGE_SIZE> createdPacket = MessageParser::compose(message);
+	String<CCSDSMaxMessageSize> createdPacket = MessageParser::compose(message);
 
 #if ECSS_CRC_INCLUDED
 	CHECK(createdPacket.size() == 20);
diff --git a/test/Services/FunctionManagementService.cpp b/test/Services/FunctionManagementService.cpp
index aae11b01a91bb5608833bcff2fb889b091442cd4..b6548d79b46bbcb482431b602130084874cd10b7 100644
--- a/test/Services/FunctionManagementService.cpp
+++ b/test/Services/FunctionManagementService.cpp
@@ -9,7 +9,7 @@ FunctionManagementService& fms = Services.functionManagement;
 
 uint8_t globalVariable = 10;
 
-void test(String<ECSS_FUNCTION_MAX_ARG_LENGTH> a) {
+void test(String<ECSSFunctionMaxArgLength> a) {
 	globalVariable = a[0];
 }
 
@@ -18,11 +18,11 @@ TEST_CASE("ST[08] - Call Tests") {
 		ServiceTests::reset();
 		globalVariable = 10;
 
-		fms.include(String<ECSS_FUNCTION_NAME_LENGTH>("test"), &test);
+		fms.include(String<ECSSFunctionNameLength>("test"), &test);
 		Message msg(FunctionManagementService::ServiceType, FunctionManagementService::MessageType::PerformFunction,
 			Message::TC, 1);
 
-		msg.appendFixedString(String<ECSS_FUNCTION_NAME_LENGTH>("test"));
+		msg.appendFixedString(String<ECSSFunctionNameLength>("test"));
 		msg.appendByte(199);
 		MessageParser::execute(msg);
 
@@ -34,9 +34,9 @@ TEST_CASE("ST[08] - Call Tests") {
 		ServiceTests::reset();
 		globalVariable = 10;
 
-		fms.include(String<ECSS_FUNCTION_NAME_LENGTH>("test"), &test);
+		fms.include(String<ECSSFunctionNameLength>("test"), &test);
 		Message msg(FunctionManagementService::ServiceType, FunctionManagementService::MessageType::PerformFunction, Message::TC, 1);
-		msg.appendFixedString(String<ECSS_FUNCTION_NAME_LENGTH>("t3st"));
+		msg.appendFixedString(String<ECSSFunctionNameLength>("t3st"));
 		MessageParser::execute(msg);
 
 		CHECK(ServiceTests::get(0).messageType == RequestVerificationService::MessageType::FailedStartOfExecution);
@@ -49,9 +49,9 @@ TEST_CASE("ST[08] - Call Tests") {
 		ServiceTests::reset();
 		globalVariable = 10;
 
-		fms.include(String<ECSS_FUNCTION_NAME_LENGTH>("test"), &test);
+		fms.include(String<ECSSFunctionNameLength>("test"), &test);
 		Message msg(FunctionManagementService::ServiceType, FunctionManagementService::MessageType::PerformFunction, Message::TC, 1);
-		msg.appendFixedString(String<ECSS_FUNCTION_NAME_LENGTH>("test"));
+		msg.appendFixedString(String<ECSSFunctionNameLength>("test"));
 		msg.appendString(String<65>
 		    ("eqrhjweghjhwqgthjkrghthjkdsfhgsdfhjsdjsfdhgkjdfsghfjdgkdfsgdfgsgd"));
 		MessageParser::execute(msg);
@@ -69,9 +69,9 @@ TEST_CASE("ST[08] - Insert Tests") {
 		ServiceTests::reset();
 		std::string name = "test"; // FOR TESTING ONLY!
 
-		for (int i = 0; i < ECSS_FUNCTION_MAP_SIZE + 1; i++) {
+		for (int i = 0; i < ECSSFunctionMapSize + 1; i++) {
 			name += std::to_string(i); // different names to fill up the map
-			fms.include(String<ECSS_FUNCTION_NAME_LENGTH>(name.c_str()), &test);
+			fms.include(String<ECSSFunctionNameLength>(name.c_str()), &test);
 		}
 		CHECK(ServiceTests::thrownError(ErrorHandler::InternalErrorType::MapFull));
 	}
diff --git a/test/Services/LargePacketTransferService.cpp b/test/Services/LargePacketTransferService.cpp
index 889cb40b12276fed597a818c8ef0ca287367bc14..100e7be06eefab28b11f39c6aa1dac58066f72eb 100644
--- a/test/Services/LargePacketTransferService.cpp
+++ b/test/Services/LargePacketTransferService.cpp
@@ -9,7 +9,7 @@
 LargePacketTransferService& lPT = Services.largePacketTransferService;
 
 TEST_CASE("First Downlink Part Report TM[13,1]", "[service][st13]") {
-	String<ECSS_MAX_FIXED_OCTET_STRING_SIZE> string = String<ECSS_MAX_FIXED_OCTET_STRING_SIZE>("12345678");
+	String<ECSSMaxFixedOctetStringSize> string = String<ECSSMaxFixedOctetStringSize>("12345678");
 	lPT.firstDownlinkPartReport(1, 1, string);
 	REQUIRE(ServiceTests::hasOneMessage());
 	Message report = ServiceTests::get(0);
@@ -17,14 +17,14 @@ TEST_CASE("First Downlink Part Report TM[13,1]", "[service][st13]") {
 	CHECK(report.serviceType == LargePacketTransferService::ServiceType);
 	CHECK(report.readUint16() == 1);
 	CHECK(report.readUint16() == 1);
-	uint8_t string2[ECSS_MAX_FIXED_OCTET_STRING_SIZE];
+	uint8_t string2[ECSSMaxFixedOctetStringSize];
 	report.readOctetString(string2);
-	auto a = String<ECSS_MAX_FIXED_OCTET_STRING_SIZE>(string2, 8);
+	auto a = String<ECSSMaxFixedOctetStringSize>(string2, 8);
 	CHECK(string.compare(a) == 0);
 }
 
 TEST_CASE("Intermediate Downlink Part Report TM[13,2]", "[service][st13]") {
-	String<ECSS_MAX_FIXED_OCTET_STRING_SIZE> string = String<ECSS_MAX_FIXED_OCTET_STRING_SIZE>("12345678");
+	String<ECSSMaxFixedOctetStringSize> string = String<ECSSMaxFixedOctetStringSize>("12345678");
 	lPT.intermediateDownlinkPartReport(1, 1, string);
 	REQUIRE(ServiceTests::hasOneMessage());
 	Message report = ServiceTests::get(0);
@@ -32,14 +32,14 @@ TEST_CASE("Intermediate Downlink Part Report TM[13,2]", "[service][st13]") {
 	CHECK(report.serviceType == LargePacketTransferService::ServiceType);
 	CHECK(report.readUint16() == 1);
 	CHECK(report.readUint16() == 1);
-	uint8_t string2[ECSS_MAX_FIXED_OCTET_STRING_SIZE];
+	uint8_t string2[ECSSMaxFixedOctetStringSize];
 	report.readOctetString(string2);
-	auto a = String<ECSS_MAX_FIXED_OCTET_STRING_SIZE>(string2, 8);
+	auto a = String<ECSSMaxFixedOctetStringSize>(string2, 8);
 	CHECK(string.compare(a) == 0);
 }
 
 TEST_CASE("Last Downlink Part Report TM[13,3]", "[service][st13]") {
-	String<ECSS_MAX_FIXED_OCTET_STRING_SIZE> string = String<ECSS_MAX_FIXED_OCTET_STRING_SIZE>("12345678");
+	String<ECSSMaxFixedOctetStringSize> string = String<ECSSMaxFixedOctetStringSize>("12345678");
 	lPT.lastDownlinkPartReport(1, 1, string);
 	REQUIRE(ServiceTests::hasOneMessage());
 	Message report = ServiceTests::get(0);
@@ -47,9 +47,9 @@ TEST_CASE("Last Downlink Part Report TM[13,3]", "[service][st13]") {
 	CHECK(report.serviceType == LargePacketTransferService::ServiceType);
 	CHECK(report.readUint16() == 1);
 	CHECK(report.readUint16() == 1);
-	uint8_t string2[ECSS_MAX_FIXED_OCTET_STRING_SIZE];
+	uint8_t string2[ECSSMaxFixedOctetStringSize];
 	report.readOctetString(string2);
-	auto a = String<ECSS_MAX_FIXED_OCTET_STRING_SIZE>(string2, 8);
+	auto a = String<ECSSMaxFixedOctetStringSize>(string2, 8);
 	CHECK(string.compare(a) == 0);
 }
 
@@ -81,7 +81,7 @@ TEST_CASE("Split function", "[no][service]") {
 		uint16_t partSequenceNumber = i;
 		CHECK(largeMessageTransactionIdentifier == ServiceTests::get(i).readUint16());
 		CHECK(partSequenceNumber == ServiceTests::get(i).readUint16());
-		CHECK(ECSS_MAX_FIXED_OCTET_STRING_SIZE == ServiceTests::get(i).readUint16());
+		CHECK(ECSSMaxFixedOctetStringSize == ServiceTests::get(i).readUint16());
 		for (int j = 0; j < 256; j++){
 			message5.appendUint8(ServiceTests::get(i).readUint8());
 		}
diff --git a/test/Services/MemoryManagementService.cpp b/test/Services/MemoryManagementService.cpp
index eba53b9e1e38f64149fd046ca2508d430255f734..5e99f191027fae3b4d2ed6c9f9608b8a14a3aa74 100644
--- a/test/Services/MemoryManagementService.cpp
+++ b/test/Services/MemoryManagementService.cpp
@@ -35,7 +35,7 @@ TEST_CASE("TC[6,5]", "[service][st06]") {
 	uint8_t testString_2[8] = "SecStrT";
 	uint8_t testString_3[2] = {5, 8};
 
-	uint8_t checkString[ECSS_MAX_STRING_SIZE];
+	uint8_t checkString[ECSSMaxStringSize];
 	uint16_t readSize = 0, checksum = 0;
 
 	Message receivedPacket = Message(MemoryManagementService::ServiceType, MemoryManagementService::MessageType::DumpRawMemoryData, Message::TC, 1);
diff --git a/test/Services/RequestVerificationService.cpp b/test/Services/RequestVerificationService.cpp
index caa88329ad13c6a32bf5fae65be6774cd768997e..223cd1169c9d2688083d4b2dd7090a1e6d5b8254 100644
--- a/test/Services/RequestVerificationService.cpp
+++ b/test/Services/RequestVerificationService.cpp
@@ -18,11 +18,11 @@ TEST_CASE("TM[1,1]", "[service][st01]") {
 	CHECK(response.applicationId == 0);
 	REQUIRE(response.dataSize == 4); // dataSize is the number of bytes of data array
 	// Check for the value that is stored in <<data>> array(data-member of object response)
-	CHECK(response.readEnumerated(3) == CCSDS_PACKET_VERSION); // packet version number
+	CHECK(response.readEnumerated(3) == CCSDSPacketVersion); // packet version number
 	CHECK(response.readEnumerated(1) == Message::TC); // packet type
 	CHECK(response.readBits(1) == 1); // secondary header flag
 	CHECK(response.readEnumerated(11) == 3); // application process ID
-	CHECK(response.readEnumerated(2) == ECSS_SEQUENCE_FLAGS); // sequence flags
+	CHECK(response.readEnumerated(2) == ECSSSequenceFlags); // sequence flags
 	CHECK(response.readBits(14) == 0); // packet sequence count
 }
 
@@ -39,11 +39,11 @@ TEST_CASE("TM[1,2]", "[service][st01]") {
 	CHECK(response.applicationId == 0);
 	REQUIRE(response.dataSize == 6); // dataSize is the number of bytes of data array
 	// Check for the value that is stored in <<data>> array(data-member of object response)
-	CHECK(response.readEnumerated(3) == CCSDS_PACKET_VERSION); // packet version number
+	CHECK(response.readEnumerated(3) == CCSDSPacketVersion); // packet version number
 	CHECK(response.readEnumerated(1) == Message::TC); // packet type
 	CHECK(response.readBits(1) == 1); // secondary header flag
 	CHECK(response.readEnumerated(11) == 3); // application process ID
-	CHECK(response.readEnumerated(2) == ECSS_SEQUENCE_FLAGS); // sequence flags
+	CHECK(response.readEnumerated(2) == ECSSSequenceFlags); // sequence flags
 	CHECK(response.readBits(14) == 0); // packet sequence count
 	CHECK(response.readEnum16() == ErrorHandler::UnknownAcceptanceError); // error code
 }
@@ -61,11 +61,11 @@ TEST_CASE("TM[1,3]", "[service][st01]") {
 	CHECK(response.applicationId == 0);
 	REQUIRE(response.dataSize == 4); // dataSize is the number of bytes of data array
 	// Check for the value that is stored in <<data>> array(data-member of object response)
-	CHECK(response.readEnumerated(3) == CCSDS_PACKET_VERSION); // packet version number
+	CHECK(response.readEnumerated(3) == CCSDSPacketVersion); // packet version number
 	CHECK(response.readEnumerated(1) == Message::TC); // packet type
 	CHECK(response.readBits(1) == 1); // secondary header flag
 	CHECK(response.readEnumerated(11) == 3); // application process ID
-	CHECK(response.readEnumerated(2) == ECSS_SEQUENCE_FLAGS); // sequence flags
+	CHECK(response.readEnumerated(2) == ECSSSequenceFlags); // sequence flags
 	CHECK(response.readBits(14) == 0); // packet sequence count
 }
 
@@ -82,11 +82,11 @@ TEST_CASE("TM[1,4]", "[service][st01]") {
 	CHECK(response.applicationId == 0);
 	REQUIRE(response.dataSize == 6); // dataSize is the number of bytes of data array
 	// Check for the value that is stored in <<data>> array(data-member of object response)
-	CHECK(response.readEnumerated(3) == CCSDS_PACKET_VERSION); // packet version number
+	CHECK(response.readEnumerated(3) == CCSDSPacketVersion); // packet version number
 	CHECK(response.readEnumerated(1) == Message::TC); // packet type
 	CHECK(response.readBits(1) == 1); // secondary header flag
 	CHECK(response.readEnumerated(11) == 3); // application process ID
-	CHECK(response.readEnumerated(2) == ECSS_SEQUENCE_FLAGS); // sequence flags
+	CHECK(response.readEnumerated(2) == ECSSSequenceFlags); // sequence flags
 	CHECK(response.readBits(14) == 0); // packet sequence count
 	CHECK(response.readEnum16() == ErrorHandler::UnknownExecutionStartError); // error code
 }
@@ -104,11 +104,11 @@ TEST_CASE("TM[1,5]", "[service][st01]") {
 	CHECK(response.applicationId == 0);
 	REQUIRE(response.dataSize == 5); // dataSize is the number of bytes of data array
 	// Check for the value that is stored in <<data>> array(data-member of object response)
-	CHECK(response.readEnumerated(3) == CCSDS_PACKET_VERSION); // packet version number
+	CHECK(response.readEnumerated(3) == CCSDSPacketVersion); // packet version number
 	CHECK(response.readEnumerated(1) == Message::TC); // packet type
 	CHECK(response.readBits(1) == 1); // secondary header flag
 	CHECK(response.readEnumerated(11) == 3); // application process ID
-	CHECK(response.readEnumerated(2) == ECSS_SEQUENCE_FLAGS); // sequence flags
+	CHECK(response.readEnumerated(2) == ECSSSequenceFlags); // sequence flags
 	CHECK(response.readBits(14) == 0); // packet sequence count
 	CHECK(response.readByte() == 0); // step ID
 }
@@ -126,11 +126,11 @@ TEST_CASE("TM[1,6]", "[service][st01]") {
 	CHECK(response.applicationId == 0);
 	REQUIRE(response.dataSize == 7); // dataSize is the number of bytes of data array
 	// Check for the value that is stored in <<data>> array(data-member of object response)
-	CHECK(response.readEnumerated(3) == CCSDS_PACKET_VERSION); // packet version number
+	CHECK(response.readEnumerated(3) == CCSDSPacketVersion); // packet version number
 	CHECK(response.readEnumerated(1) == Message::TC); // packet type
 	CHECK(response.readBits(1) == 1); // secondary header flag
 	CHECK(response.readEnumerated(11) == 3); // application process ID
-	CHECK(response.readEnumerated(2) == ECSS_SEQUENCE_FLAGS); // sequence flags
+	CHECK(response.readEnumerated(2) == ECSSSequenceFlags); // sequence flags
 	CHECK(response.readBits(14) == 0); // packet sequence count
 	CHECK(response.readByte() == 0); // step ID
 	CHECK(response.readEnum16() == ErrorHandler::UnknownExecutionProgressError);
@@ -149,11 +149,11 @@ TEST_CASE("TM[1,7]", "[service][st01]") {
 	CHECK(response.applicationId == 0);
 	REQUIRE(response.dataSize == 4); // dataSize is the number of bytes of data array
 	// Check for the value that is stored in <<data>> array(data-member of object response)
-	CHECK(response.readEnumerated(3) == CCSDS_PACKET_VERSION); // packet version number
+	CHECK(response.readEnumerated(3) == CCSDSPacketVersion); // packet version number
 	CHECK(response.readEnumerated(1) == Message::TC); // packet type
 	CHECK(response.readBits(1) == 1); // secondary header flag
 	CHECK(response.readEnumerated(11) == 3); // application process ID
-	CHECK(response.readEnumerated(2) == ECSS_SEQUENCE_FLAGS); // sequence flags
+	CHECK(response.readEnumerated(2) == ECSSSequenceFlags); // sequence flags
 	CHECK(response.readBits(14) == 0); // packet sequence count
 }
 
@@ -169,11 +169,11 @@ TEST_CASE("TM[1,8]", "[service][st01]") {
 	CHECK(response.applicationId == 0);
 	REQUIRE(response.dataSize == 6); // dataSize is the number of bytes of data array
 	// Check for the value that is stored in <<data>> array(data-member of object response)
-	CHECK(response.readEnumerated(3) == CCSDS_PACKET_VERSION); // packet version number
+	CHECK(response.readEnumerated(3) == CCSDSPacketVersion); // packet version number
 	CHECK(response.readEnumerated(1) == Message::TC); // packet type
 	CHECK(response.readBits(1) == 1); // secondary header flag
 	CHECK(response.readEnumerated(11) == 3); // application process ID
-	CHECK(response.readEnumerated(2) == ECSS_SEQUENCE_FLAGS); // sequence flags
+	CHECK(response.readEnumerated(2) == ECSSSequenceFlags); // sequence flags
 	CHECK(response.readBits(14) == 0); // packet sequence count
 	CHECK(response.readEnum16() == ErrorHandler::UnknownExecutionCompletionError); // error code
 }
@@ -191,11 +191,11 @@ TEST_CASE("TM[1,10]", "[service][st01]") {
 	CHECK(response.applicationId == 0);
 	REQUIRE(response.dataSize == 6); // dataSize is the number of bytes of data array
 	// Check for the value that is stored in <<data>> array(data-member of object response)
-	CHECK(response.readEnumerated(3) == CCSDS_PACKET_VERSION); // packet version number
+	CHECK(response.readEnumerated(3) == CCSDSPacketVersion); // packet version number
 	CHECK(response.readEnumerated(1) == Message::TC); // packet type
 	CHECK(response.readBits(1) == 1); // secondary header flag
 	CHECK(response.readEnumerated(11) == 3); // application process ID
-	CHECK(response.readEnumerated(2) == ECSS_SEQUENCE_FLAGS); // sequence flags
+	CHECK(response.readEnumerated(2) == ECSSSequenceFlags); // sequence flags
 	CHECK(response.readBits(14) == 0); // packet sequence count
 	CHECK(response.readEnum16() == ErrorHandler::UnknownRoutingError); // error code
 }
diff --git a/test/Services/TimeBasedSchedulingService.cpp b/test/Services/TimeBasedSchedulingService.cpp
index 420deabfb606e9dfa2fb01e794387aecb05f112c..c1f601b671e184b1d7db352b5f8f1487c0e9a7f3 100644
--- a/test/Services/TimeBasedSchedulingService.cpp
+++ b/test/Services/TimeBasedSchedulingService.cpp
@@ -70,19 +70,19 @@ auto activityInsertion(TimeBasedSchedulingService& timeService) {
 
 	// Test activity 1
 	receivedMessage.appendUint32(currentTime + 1556435);
-	receivedMessage.appendMessage(testMessage1, ECSS_TC_REQUEST_STRING_SIZE);
+	receivedMessage.appendMessage(testMessage1, ECSSTCRequestStringSize);
 
 	// Test activity 2
 	receivedMessage.appendUint32(currentTime + 1957232);
-	receivedMessage.appendMessage(testMessage2, ECSS_TC_REQUEST_STRING_SIZE);
+	receivedMessage.appendMessage(testMessage2, ECSSTCRequestStringSize);
 
 	// Test activity 3
 	receivedMessage.appendUint32(currentTime + 1726435);
-	receivedMessage.appendMessage(testMessage3, ECSS_TC_REQUEST_STRING_SIZE);
+	receivedMessage.appendMessage(testMessage3, ECSSTCRequestStringSize);
 
 	// Test activity 4
 	receivedMessage.appendUint32(currentTime + 17248435);
-	receivedMessage.appendMessage(testMessage4, ECSS_TC_REQUEST_STRING_SIZE);
+	receivedMessage.appendMessage(testMessage4, ECSSTCRequestStringSize);
 
 	// Insert activities in the schedule. They have to be inserted sorted
 	timeService.insertActivities(receivedMessage);
@@ -273,8 +273,8 @@ TEST_CASE("TC[11,9] Detail report scheduled activities by ID", "[service][st11]"
 			uint32_t receivedReleaseTime = response.readUint32();
 
 			Message receivedTCPacket;
-			uint8_t receivedDataStr[ECSS_TC_REQUEST_STRING_SIZE];
-			response.readString(receivedDataStr, ECSS_TC_REQUEST_STRING_SIZE);
+			uint8_t receivedDataStr[ECSSTCRequestStringSize];
+			response.readString(receivedDataStr, ECSSTCRequestStringSize);
 			receivedTCPacket = MessageParser::parseECSSTC(receivedDataStr);
 
 			if (i == 0) {
@@ -377,8 +377,8 @@ TEST_CASE("TC[11,16] Detail report all scheduled activities", "[service][st11]")
 		uint32_t receivedReleaseTime = response.readUint32();
 
 		Message receivedTCPacket;
-		uint8_t receivedDataStr[ECSS_TC_REQUEST_STRING_SIZE];
-		response.readString(receivedDataStr, ECSS_TC_REQUEST_STRING_SIZE);
+		uint8_t receivedDataStr[ECSSTCRequestStringSize];
+		response.readString(receivedDataStr, ECSSTCRequestStringSize);
 		receivedTCPacket = MessageParser::parseECSSTC(receivedDataStr);
 
 		REQUIRE(receivedReleaseTime == scheduledActivities.at(i)->requestReleaseTime);