diff --git a/CMakeLists.txt b/CMakeLists.txt
index d709806f9a52996a68922e321a364f40e032ff64..a6c978bb8f90be6c505788c684b0ad8563498f72 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -23,15 +23,13 @@ add_library(common OBJECT
src/Services/MemoryManagementService.cpp
src/Services/ParameterService.cpp
src/Services/RequestVerificationService.cpp
- src/Services/TestService.cpp
- )
+ src/Services/TestService.cpp)
# Specify the .cpp files for the executables
add_executable(ecss_services
src/main.cpp
$<TARGET_OBJECTS:common>
- src/Platform/x86/Service.cpp
- )
+ src/Platform/x86/Service.cpp)
IF (EXISTS "${PROJECT_SOURCE_DIR}/lib/Catch2/CMakeLists.txt")
# Gather all the .cpp files corresponding to tests
@@ -43,6 +41,5 @@ IF (EXISTS "${PROJECT_SOURCE_DIR}/lib/Catch2/CMakeLists.txt")
$<TARGET_OBJECTS:common>
${test_main_SRC}
${test_SRC})
-
target_link_libraries(tests Catch2::Catch2)
ENDIF ()
diff --git a/inc/ErrorHandler.hpp b/inc/ErrorHandler.hpp
index 56223cacaecfa11b03c0a12b0e3626d0d3d0b7c0..b18ae74466fa8750ca1c4a7b9e4e68eeec3a6062 100644
--- a/inc/ErrorHandler.hpp
+++ b/inc/ErrorHandler.hpp
@@ -81,7 +81,15 @@ public:
* changes.
*/
enum ExecutionErrorType {
- UnknownExecutionError = 0
+ UnknownExecutionError = 0,
+ /**
+ * Checksum comparison failed
+ */
+ ChecksumFailed = 1,
+ /**
+ * Address of a memory is out of the defined range for the type of memory
+ */
+ AddressOutOfRange = 2,
};
/**
diff --git a/inc/Platform/STM32F7/MemoryAddressLimits.hpp b/inc/Platform/STM32F7/MemoryAddressLimits.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..e30651f9373d45912404ca7f33ceceed060b2002
--- /dev/null
+++ b/inc/Platform/STM32F7/MemoryAddressLimits.hpp
@@ -0,0 +1,18 @@
+#ifndef ECSS_SERVICES_MEMORYADDRESSLIMITS_STM32F7_HPP
+#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
+
+#endif //ECSS_SERVICES_MEMORYADDRESSLIMITS_STM32F7_HPP
diff --git a/inc/Services/MemoryManagementService.hpp b/inc/Services/MemoryManagementService.hpp
index 1d2de9be32b3589b84e84b07007f05380e81a062..5cd3c16da1f43a2f62d741553052dbae2eeb319c 100644
--- a/inc/Services/MemoryManagementService.hpp
+++ b/inc/Services/MemoryManagementService.hpp
@@ -1,17 +1,25 @@
#ifndef ECSS_SERVICES_MEMMANGSERVICE_HPP
#define ECSS_SERVICES_MEMMANGSERVICE_HPP
-#include "Service.hpp"
#include <memory>
#include <iostream>
+#include "Service.hpp"
+#include "Helpers/CRCHelper.hpp"
+#include "ErrorHandler.hpp"
+#include "Platform/STM32F7/MemoryAddressLimits.hpp"
+
class MemoryManagementService : public Service {
public:
// Memory type ID's
enum MemoryID {
- RAM = 0,
- FLASH = 1,
- EXTERNAL = 2
+ DTCMRAM = 0,
+ RAM_D1,
+ RAM_D2,
+ RAM_D3,
+ ITCMRAM,
+ FLASH,
+ EXTERNAL
};
MemoryManagementService();
@@ -35,7 +43,8 @@ public:
*
* @details This function loads new values to memory data areas
* specified in the request
- * @param request: Provide the received message as a parameter
+ * @param request Provide the received message as a parameter
+ * @todo Only allow aligned memory address to be start addresses
*/
void loadRawData(Message &request);
@@ -44,12 +53,47 @@ public:
*
* @details This function reads the raw data from the RAM memory and
* triggers a TM[6,6] report
- * @param request: Provide the received message as a parameter
+ * @param request Provide the received message as a parameter
* @todo In later embedded version, implement error checking for address validity for
* different memory types
+ * @todo Only allow aligned memory address to be start addresses
*/
void dumpRawData(Message &request);
+
+ /**
+ * TC[6,9] check raw memory data
+ *
+ * @details This function reads the raw data from the specified memory and
+ * triggers a TM[6,10] report
+ * @param request Provide the received message as a parameter
+ * @todo In later embedded version, implement error checking for address validity for
+ * different memory types
+ * @todo Only allow aligned memory address to be start addresses
+ */
+ void checkRawData(Message &request);
} rawDataMemorySubservice;
+
+private:
+ /**
+ * Check whether the provided address is valid or not, based on the defined limit values
+ *
+ * @param memId The ID of the memory to check is passed
+ * @param address Takes the address to be checked for validity
+ */
+ bool addressValidator(MemoryManagementService::MemoryID memId, uint64_t address);
+
+ /**
+ * Check if the provided memory ID is valid
+ *
+ * @param memId The memory ID for validation
+ */
+ bool memoryIdValidator(MemoryManagementService::MemoryID memId);
+
+ /**
+ * Validate the data according to checksum calculation
+ *
+ */
+ bool dataValidator(const uint8_t *data, uint16_t checksum, uint16_t length);
};
#endif //ECSS_SERVICES_MEMMANGSERVICE_HPP
diff --git a/src/Platform/x86/Service.cpp b/src/Platform/x86/Service.cpp
index 07403e438e1ff884b430c5eafff7d92a7d63c63c..ff9d9d95de57f749996cb8a2fcd7853cebda7813 100644
--- a/src/Platform/x86/Service.cpp
+++ b/src/Platform/x86/Service.cpp
@@ -4,7 +4,9 @@
void Service::storeMessage(const Message &message) {
// Just print it to the screen
- std::cout << "New " << ((message.packetType == Message::TM) ? "TM" : "TC") << "[" << std::dec
+ std::cout << "New " << ((message.packetType == Message::TM) ? "TM" : "TC") << "["
+ << std::hex
+ // << std::dec
<< static_cast<int>(message.serviceType) << ","
<< static_cast<int>(message.messageType) << "] message!\n";
//std::cout << std::hex << std::setfill('0') << std::setw(2);
diff --git a/src/Services/MemoryManagementService.cpp b/src/Services/MemoryManagementService.cpp
index cd84b3dd01df44dac75852009ec90c587c500889..05bd9bdfea50fb1de15ef10b3f8daf919d701c50 100644
--- a/src/Services/MemoryManagementService.cpp
+++ b/src/Services/MemoryManagementService.cpp
@@ -25,25 +25,49 @@ void MemoryManagementService::RawDataMemoryManagement::loadRawData(Message &requ
assert(request.serviceType == 6);
assert(request.messageType == 2);
- // Variable declaration
- uint8_t readData[ECSS_MAX_STRING_SIZE]; // Preallocate the array
-
- uint8_t memoryID = request.readEnum8(); // Read the memory ID from the request
- uint16_t iterationCount = request.readUint16(); // Get the iteration count
-
- if (memoryID == MemoryManagementService::MemoryID::RAM) {
- for (std::size_t j = 0; j < iterationCount; j++) {
- uint64_t startAddress = request.readUint64(); // Start address of the memory
- uint16_t dataLength = request.readOctetString(readData); // Data length to load
- // todo: Error logging has to be included, if memory allocation above fails
- // todo: Continue only if the checksum passes (when the checksum will be implemented)
-
- for (std::size_t i = 0; i < dataLength; i++) {
- *(reinterpret_cast<uint8_t *>(startAddress) + i) = readData[i];
+ // Read the memory ID from the request
+ auto memoryID = MemoryManagementService::MemoryID(request.readEnum8());
+
+ // 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
+ uint16_t iterationCount = request.readUint16(); // Get the iteration count
+
+ if (memoryID == MemoryManagementService::MemoryID::FLASH) {
+ // todo: Define FLASH specific access code when we transfer to embedded
+ } else {
+ for (std::size_t j = 0; j < iterationCount; j++) {
+ uint64_t startAddress = request.readUint64(); // Start address of the memory
+ uint16_t dataLength = request.readOctetString(readData); // Data length to load
+ uint16_t checksum = request.readBits(16); // Get the CRC checksum from the message
+
+ // Continue only if the checksum passes
+ if (mainService.dataValidator(readData, checksum, dataLength)) {
+ if (mainService.addressValidator(memoryID, startAddress) &&
+ mainService.addressValidator(memoryID, startAddress + dataLength)) {
+ for (std::size_t i = 0; i < dataLength; i++) {
+ *(reinterpret_cast<uint8_t *>(startAddress) + i) = readData[i];
+ }
+
+ // Read the loaded data for checksum validation and perform a check
+ for (std::size_t i = 0; i < dataLength; i++) {
+ readData[i] = *(reinterpret_cast<uint8_t *>(startAddress) + i);
+ }
+ if (checksum != CRCHelper::calculateCRC(readData, dataLength)) {
+ ErrorHandler::reportError(request, ErrorHandler::ChecksumFailed);
+ }
+ } else {
+ ErrorHandler::reportError(request, ErrorHandler::ChecksumFailed);
+ }
+ } else {
+ ErrorHandler::reportError(request, ErrorHandler::ChecksumFailed);
+ continue; // Continue to the next command
+ }
}
}
- } else if (memoryID == MemoryManagementService::MemoryID::FLASH) {
- // todo: Define FLASH specific access code when we transfer to embedded
+ } else {
+ // todo: Send a failed start of execution
}
}
@@ -54,35 +78,156 @@ void MemoryManagementService::RawDataMemoryManagement::dumpRawData(Message &requ
// Create the report message object of telemetry message subtype 6
Message report = mainService.createTM(6);
+ uint8_t memoryID = request.readEnum8(); // Read the memory ID from the request
- // Variable declaration
- uint8_t readData[ECSS_MAX_STRING_SIZE]; // Preallocate the array
+ // 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
+ uint16_t iterationCount = request.readUint16(); // Get the iteration count
- uint8_t memoryID = request.readEnum8(); // Read the memory ID from the request
- // todo: Add checks depending on the memory type
+ // Append the data to report message
+ report.appendEnum8(memoryID); // Memory ID
+ report.appendUint16(iterationCount); // Iteration count
- uint16_t iterationCount = request.readUint16(); // Get the iteration count
+ // Iterate N times, as specified in the command message
+ for (std::size_t j = 0; j < iterationCount; j++) {
+ uint64_t startAddress = request.readUint64(); // Data length to read
+ uint16_t readLength = request.readUint16(); // Start address for the memory read
+
+ // Read memory data, an octet at a time, checking for a valid address first
+ if (mainService.addressValidator(MemoryManagementService::MemoryID(memoryID),
+ startAddress) &&
+ mainService.addressValidator(MemoryManagementService::MemoryID(memoryID),
+ startAddress + readLength)) {
+ for (std::size_t i = 0; i < readLength; i++) {
+ readData[i] = *(reinterpret_cast<uint8_t *>(startAddress) + i);
+ }
+
+ // This part is repeated N-times (N = iteration count)
+ report.appendUint64(startAddress); // Start address
+ report.appendOctetString(readLength, readData); // Save the read data
+ report.appendBits(16, CRCHelper::calculateCRC(readData, readLength));
+ } else {
+ ErrorHandler::reportError(request, ErrorHandler::AddressOutOfRange);
+ }
+ }
- // Append the data to report message
- report.appendEnum8(memoryID); // Memory ID
- report.appendUint16(iterationCount); // Iteration count
+ mainService.storeMessage(report); // Save the report message
+ request.resetRead(); // Reset the reading count
+ } else {
+ // todo: Send a failed start of execution
+ }
+}
- // Iterate N times, as specified in the command message
- for (std::size_t j = 0; j < iterationCount; j++) {
- uint64_t startAddress = request.readUint64(); // Data length to read
- uint16_t readLength = request.readUint16(); // Start address for the memory read
+void MemoryManagementService::RawDataMemoryManagement::checkRawData(Message &request) {
+ // Check if we have the correct packet
+ assert(request.serviceType == 6);
+ assert(request.messageType == 9);
- // Read memory data, an octet at a time
- for (std::size_t i = 0; i < readLength; i++) {
- readData[i] = *(reinterpret_cast<uint8_t *>(startAddress) + i);
+ // Create the report message object of telemetry message subtype 10
+ Message report = mainService.createTM(10);
+ uint8_t memoryID = request.readEnum8(); // Read the memory ID from the request
+
+ if (mainService.memoryIdValidator(MemoryManagementService::MemoryID(memoryID))) {
+ // Variable declaration
+ uint8_t readData[ECSS_MAX_STRING_SIZE]; // Preallocate the array
+ uint16_t iterationCount = request.readUint16(); // Get the iteration count
+
+ // Append the data to report message
+ report.appendEnum8(memoryID); // Memory ID
+ report.appendUint16(iterationCount); // Iteration count
+
+ // Iterate N times, as specified in the command message
+ for (std::size_t j = 0; j < iterationCount; j++) {
+ uint64_t startAddress = request.readUint64(); // Data length to read
+ uint16_t readLength = request.readUint16(); // Start address for the memory read
+
+ // Check whether the first and the last addresses are within the limits
+ if (mainService.addressValidator(MemoryManagementService::MemoryID(memoryID),
+ startAddress) &&
+ mainService.addressValidator(MemoryManagementService::MemoryID(memoryID),
+ startAddress + readLength)) {
+ // Read memory data and save them for checksum calculation
+ for (std::size_t i = 0; i < readLength; i++) {
+ readData[i] = *(reinterpret_cast<uint8_t *>(startAddress) + i);
+ }
+
+ // This part is repeated N-times (N = iteration count)
+ report.appendUint64(startAddress); // Start address
+ report.appendUint16(readLength); // Save the read data
+ report.appendBits(16, CRCHelper::calculateCRC(readData, readLength)); // Append CRC
+ } else {
+ ErrorHandler::reportError(request, ErrorHandler::AddressOutOfRange);
+ }
}
- // This part is repeated N-times (N = iteration count)
- report.appendUint64(startAddress); // Start address
- report.appendOctetString(readLength, readData); // Save the read data
+
+ mainService.storeMessage(report); // Save the report message
+ request.resetRead(); // Reset the reading count
+ } else {
+ // todo: Send a failed start of execution report
+ }
+}
+
+
+// Private function declaration section
+bool MemoryManagementService::addressValidator(
+ MemoryManagementService::MemoryID memId, uint64_t address) {
+ bool validIndicator = false;
+
+ switch (memId) {
+ case MemoryManagementService::MemoryID::DTCMRAM:
+ if (address >= DTCMRAM_LOWER_LIM && address <= DTCMRAM_UPPER_LIM) {
+ validIndicator = true;
+ }
+ break;
+ case MemoryManagementService::MemoryID::ITCMRAM:
+ if (address >= ITCMRAM_LOWER_LIM && address <= ITCMRAM_UPPER_LIM) {
+ validIndicator = true;
+ }
+ break;
+ case MemoryManagementService::MemoryID::RAM_D1:
+ if (address >= RAM_D1_LOWER_LIM && address <= RAM_D1_UPPER_LIM) {
+ validIndicator = true;
+ }
+ break;
+ case MemoryManagementService::MemoryID::RAM_D2:
+ if (address >= RAM_D2_LOWER_LIM && address <= RAM_D2_UPPER_LIM) {
+ validIndicator = true;
+ }
+ break;
+ case MemoryManagementService::MemoryID::RAM_D3:
+ if (address >= RAM_D3_LOWER_LIM && address <= RAM_D3_UPPER_LIM) {
+ validIndicator = true;
+ }
+ break;
+ case MemoryManagementService::MemoryID::FLASH:
+ if (address >= FLASH_LOWER_LIM && address <= FLASH_UPPER_LIM) {
+ validIndicator = true;
+ }
+ break;
+
+ default:
+ validIndicator = true; // todo: Implemented so addresses from PC can be read. Remove.
+ break;
}
- // todo: implement and append the checksum part of the reporting packet
- mainService.storeMessage(report); // Save the report message
- request.resetRead(); // Reset the reading count
+ return validIndicator;
+}
+
+inline bool MemoryManagementService::memoryIdValidator(
+ MemoryManagementService::MemoryID memId) {
+ return (memId == MemoryManagementService::MemoryID::RAM_D1) ||
+ (memId == MemoryManagementService::MemoryID::RAM_D2) ||
+ (memId == MemoryManagementService::MemoryID::RAM_D3) ||
+ (memId == MemoryManagementService::MemoryID::DTCMRAM) ||
+ (memId == MemoryManagementService::MemoryID::ITCMRAM) ||
+ (memId == MemoryManagementService::MemoryID::FLASH) ||
+ (memId == MemoryManagementService::MemoryID::EXTERNAL);
+}
+
+inline bool MemoryManagementService::dataValidator(const uint8_t *data, uint16_t checksum,
+ uint16_t length) {
+ return (checksum == CRCHelper::calculateCRC(data, length));
}
diff --git a/src/main.cpp b/src/main.cpp
index de68902f98961a2f8781b450f8fd9a83eb328f2e..0883b6023edfb55e97d1300e4372a3a68039fa0e 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -8,8 +8,10 @@
#include "Message.hpp"
#include "MessageParser.hpp"
#include "Services/MemoryManagementService.hpp"
+#include "Helpers/CRCHelper.hpp"
#include "ErrorHandler.hpp"
+
int main() {
Message packet = Message(0, 0, Message::TC, 1);
@@ -68,7 +70,7 @@ int main() {
MemoryManagementService memMangService;
Message rcvPack = Message(6, 5, Message::TC, 1);
- rcvPack.appendEnum8(MemoryManagementService::MemoryID::RAM); // Memory ID
+ rcvPack.appendEnum8(MemoryManagementService::MemoryID::EXTERNAL); // Memory ID
rcvPack.appendUint16(3); // Iteration count
rcvPack.appendUint64(reinterpret_cast<uint64_t >(string)); // Start address
rcvPack.appendUint16(sizeof(string) / sizeof(string[0])); // Data read length
@@ -83,14 +85,26 @@ int main() {
rcvPack = Message(6, 2, Message::TC, 1);
uint8_t data[2] = {'h', 'R'};
- rcvPack.appendEnum8(MemoryManagementService::MemoryID::RAM); // Memory ID
+ rcvPack.appendEnum8(MemoryManagementService::MemoryID::EXTERNAL); // Memory ID
rcvPack.appendUint16(2); // Iteration count
rcvPack.appendUint64(reinterpret_cast<uint64_t >(pStr)); // Start address
rcvPack.appendOctetString(2, data);
+ rcvPack.appendBits(16, CRCHelper::calculateCRC(data, 2)); // Append the CRC value
rcvPack.appendUint64(reinterpret_cast<uint64_t >(pStr + 1)); // Start address
rcvPack.appendOctetString(1, data);
+ rcvPack.appendBits(16, CRCHelper::calculateCRC(data, 1)); // Append the CRC value
memMangService.rawDataMemorySubservice.loadRawData(rcvPack);
+ rcvPack = Message(6, 9, Message::TC, 1);
+
+ rcvPack.appendEnum8(MemoryManagementService::MemoryID::EXTERNAL); // Memory ID
+ rcvPack.appendUint16(2); // Iteration count
+ rcvPack.appendUint64(reinterpret_cast<uint64_t >(data)); // Start address
+ rcvPack.appendUint16(2);
+ rcvPack.appendUint64(reinterpret_cast<uint64_t >(data + 1)); // Start address
+ rcvPack.appendUint16(1);
+ memMangService.rawDataMemorySubservice.checkRawData(rcvPack);
+
// ST[01] test
diff --git a/test/Services/MemoryManagementService.cpp b/test/Services/MemoryManagementService.cpp
index d59c8de2c6490d99b9113904a08ce313dc25ef26..06bbe264f0ce68c5585dcc158e5f8e8fcec12cf4 100644
--- a/test/Services/MemoryManagementService.cpp
+++ b/test/Services/MemoryManagementService.cpp
@@ -2,6 +2,7 @@
#include <Services/MemoryManagementService.hpp>
#include <Message.hpp>
#include "ServiceTests.hpp"
+#include "Helpers/CRCHelper.hpp"
TEST_CASE("TM[6,2]", "[service][st06]") {
// Required test variables
@@ -14,12 +15,14 @@ TEST_CASE("TM[6,2]", "[service][st06]") {
MemoryManagementService memMangService;
Message receivedPacket = Message(6, 2, Message::TC, 1);
- receivedPacket.appendEnum8(MemoryManagementService::MemoryID::RAM); // Memory ID
+ receivedPacket.appendEnum8(MemoryManagementService::MemoryID::EXTERNAL); // Memory ID
receivedPacket.appendUint16(2); // Iteration count
receivedPacket.appendUint64(reinterpret_cast<uint64_t >(pStr)); // Start address
receivedPacket.appendOctetString(2, data);
+ receivedPacket.appendBits(16, CRCHelper::calculateCRC(data, 2)); // Append CRC
receivedPacket.appendUint64(reinterpret_cast<uint64_t >(pStr + 2)); // Start address
- receivedPacket.appendOctetString(1, data);
+ receivedPacket.appendOctetString(1, data); // Append CRC
+ receivedPacket.appendBits(16, CRCHelper::calculateCRC(data, 1));
memMangService.rawDataMemorySubservice.loadRawData(receivedPacket);
CHECK(pStr[0] == 'h');
@@ -33,43 +36,46 @@ TEST_CASE("TM[6,5]", "[service][st06]") {
uint8_t testString_3[2] = {5, 8};
uint8_t checkString[ECSS_MAX_STRING_SIZE];
- uint16_t readSize = 0;
+ uint16_t readSize = 0, checksum = 0;
MemoryManagementService memMangService;
Message receivedPacket = Message(6, 5, Message::TC, 1);
- receivedPacket.appendEnum8(MemoryManagementService::MemoryID::RAM); // Memory ID
+ receivedPacket.appendEnum8(MemoryManagementService::MemoryID::EXTERNAL); // Memory ID
receivedPacket.appendUint16(3); // Iteration count (Equal to 3 test strings)
receivedPacket.appendUint64(reinterpret_cast<uint64_t >(testString_1)); // Start address
- receivedPacket.appendUint16(sizeof(testString_1)/ sizeof(testString_1[0])); // Data read length
+ receivedPacket.appendUint16(sizeof(testString_1) / sizeof(testString_1[0])); // Data read length
receivedPacket.appendUint64(reinterpret_cast<uint64_t >(testString_2));
- receivedPacket.appendUint16(sizeof(testString_2)/ sizeof(testString_2[0]));
+ receivedPacket.appendUint16(sizeof(testString_2) / sizeof(testString_2[0]));
receivedPacket.appendUint64(reinterpret_cast<uint64_t >(testString_3));
- receivedPacket.appendUint16(sizeof(testString_3)/ sizeof(testString_3[0]));
+ receivedPacket.appendUint16(sizeof(testString_3) / sizeof(testString_3[0]));
memMangService.rawDataMemorySubservice.dumpRawData(receivedPacket);
REQUIRE(ServiceTests::hasOneMessage());
Message response = ServiceTests::get(0);
CHECK(response.serviceType == 6);
CHECK(response.messageType == 6);
- REQUIRE(response.dataSize == 49);
+ REQUIRE(response.dataSize == 55);
- CHECK(response.readEnum8() == MemoryManagementService::MemoryID::RAM);
+ CHECK(response.readEnum8() == MemoryManagementService::MemoryID::EXTERNAL);
CHECK(response.readUint16() == 3);
CHECK(response.readUint64() == reinterpret_cast<uint64_t >(testString_1));
readSize = response.readOctetString(checkString);
- CHECK(readSize == sizeof(testString_1)/ sizeof(testString_1[0]));
+ checksum = response.readBits(16);
+ CHECK(readSize == sizeof(testString_1) / sizeof(testString_1[0]));
CHECK(checkString[0] == 'F');
CHECK(checkString[1] == 'S');
CHECK(checkString[2] == 't');
CHECK(checkString[3] == 'r');
CHECK(checkString[4] == 'T');
CHECK(checkString[5] == '\0');
+ CHECK(checksum == CRCHelper::calculateCRC(checkString, readSize));
CHECK(response.readUint64() == reinterpret_cast<uint64_t >(testString_2));
readSize = response.readOctetString(checkString);
- CHECK(readSize == sizeof(testString_2)/ sizeof(testString_2[0]));
+ checksum = response.readBits(16);
+ CHECK(readSize == sizeof(testString_2) / sizeof(testString_2[0]));
CHECK(checkString[0] == 'S');
CHECK(checkString[1] == 'e');
CHECK(checkString[2] == 'c');
@@ -78,10 +84,50 @@ TEST_CASE("TM[6,5]", "[service][st06]") {
CHECK(checkString[5] == 'r');
CHECK(checkString[6] == 'T');
CHECK(checkString[7] == '\0');
+ CHECK(checksum == CRCHelper::calculateCRC(checkString, readSize));
CHECK(response.readUint64() == reinterpret_cast<uint64_t >(testString_3));
readSize = response.readOctetString(checkString);
- CHECK(readSize == sizeof(testString_3)/ sizeof(testString_3[0]));
+ checksum = response.readBits(16);
+ CHECK(readSize == sizeof(testString_3) / sizeof(testString_3[0]));
CHECK(checkString[0] == 5);
CHECK(checkString[1] == 8);
+ CHECK(checksum == CRCHelper::calculateCRC(checkString, readSize));
+}
+
+TEST_CASE("TM[6,9]", "[service][st06]") {
+ uint8_t testString_1[6] = "FStrT";
+ uint8_t testString_2[8] = "SecStrT";
+ uint16_t readSize = 0, checksum = 0;
+
+ MemoryManagementService memMangService;
+ Message receivedPacket = Message(6, 9, Message::TC, 1);
+ receivedPacket.appendEnum8(MemoryManagementService::MemoryID::EXTERNAL); // Memory ID
+ receivedPacket.appendUint16(2); // Iteration count
+ receivedPacket.appendUint64(reinterpret_cast<uint64_t >(testString_1)); // Start address
+ receivedPacket.appendUint16(sizeof(testString_1) / sizeof(testString_1[0])); // Data read length
+
+ receivedPacket.appendUint64(reinterpret_cast<uint64_t >(testString_2));
+ receivedPacket.appendUint16(sizeof(testString_2) / sizeof(testString_2[0]));
+ memMangService.rawDataMemorySubservice.checkRawData(receivedPacket);
+ REQUIRE(ServiceTests::hasOneMessage());
+
+ Message response = ServiceTests::get(0);
+ CHECK(response.serviceType == 6);
+ CHECK(response.messageType == 10);
+ REQUIRE(response.dataSize == 27);
+
+ CHECK(response.readEnum8() == MemoryManagementService::MemoryID::EXTERNAL);
+ CHECK(response.readUint16() == 2);
+ CHECK(response.readUint64() == reinterpret_cast<uint64_t >(testString_1));
+ readSize = response.readUint16();
+ checksum = response.readBits(16);
+ CHECK(readSize == sizeof(testString_1) / sizeof(testString_1[0]));
+ CHECK(checksum == CRCHelper::calculateCRC(testString_1, readSize));
+
+ CHECK(response.readUint64() == reinterpret_cast<uint64_t >(testString_2));
+ readSize = response.readUint16();
+ checksum = response.readBits(16);
+ CHECK(readSize == sizeof(testString_2) / sizeof(testString_2[0]));
+ CHECK(checksum == CRCHelper::calculateCRC(testString_2, readSize));
}