From 4fd93afbbf44820d06fd0b862a34e00c59adaac7 Mon Sep 17 00:00:00 2001 From: "D.R.racer" Date: Mon, 13 Jun 2022 00:19:41 +0200 Subject: [PATCH] Introduce generic Read/Write register operations --- src/application.cpp | 4 +- src/modules/protocol.cpp | 225 ++++++++++++----- src/modules/protocol.h | 91 ++++++- tests/unit/modules/protocol/test_protocol.cpp | 234 +++++++++++++----- 4 files changed, 421 insertions(+), 133 deletions(-) diff --git a/src/application.cpp b/src/application.cpp index 4c75204..3a40ff2 100644 --- a/src/application.cpp +++ b/src/application.cpp @@ -213,7 +213,9 @@ void Application::ProcessRequestMsg(const mp::RequestMsg &rq) { case mp::RequestMsgCodes::Version: ReportVersion(rq); break; - case mp::RequestMsgCodes::Wait: + case mp::RequestMsgCodes::Read: + break; // @@TODO - not used anywhere yet + case mp::RequestMsgCodes::Write: break; // @@TODO - not used anywhere yet case mp::RequestMsgCodes::Cut: case mp::RequestMsgCodes::Eject: diff --git a/src/modules/protocol.cpp b/src/modules/protocol.cpp index da02cae..056a28f 100644 --- a/src/modules/protocol.cpp +++ b/src/modules/protocol.cpp @@ -40,14 +40,16 @@ DecodeStatus Protocol::DecodeRequest(uint8_t c) { case 'S': case 'B': case 'E': - case 'W': + case 'W': // write is gonna be a special one case 'K': case 'F': case 'f': case 'H': + case 'R': requestMsg.code = (RequestMsgCodes)c; requestMsg.value = 0; - rqState = RequestStates::Value; + requestMsg.value2 = 0; + rqState = (c == 'W') ? RequestStates::Address : RequestStates::Value; // prepare special automaton path for Write commands return DecodeStatus::NeedMoreData; default: requestMsg.code = RequestMsgCodes::unknown; @@ -55,9 +57,35 @@ DecodeStatus Protocol::DecodeRequest(uint8_t c) { return DecodeStatus::Error; } case RequestStates::Value: - if (IsDigit(c)) { - requestMsg.value *= 10; - requestMsg.value += c - '0'; + if (IsHexDigit(c)) { + requestMsg.value <<= 4U; + requestMsg.value |= Char2Nibble(c); + return DecodeStatus::NeedMoreData; + } else if (IsNewLine(c)) { + rqState = RequestStates::Code; + return DecodeStatus::MessageCompleted; + } else { + requestMsg.code = RequestMsgCodes::unknown; + rqState = RequestStates::Error; + return DecodeStatus::Error; + } + case RequestStates::Address: + if (IsHexDigit(c)) { + requestMsg.value <<= 4U; + requestMsg.value |= Char2Nibble(c); + return DecodeStatus::NeedMoreData; + } else if (c == ' ') { // end of address, value coming + rqState = RequestStates::WriteValue; + return DecodeStatus::NeedMoreData; + } else { + requestMsg.code = RequestMsgCodes::unknown; + rqState = RequestStates::Error; + return DecodeStatus::Error; + } + case RequestStates::WriteValue: + if (IsHexDigit(c)) { + requestMsg.value2 <<= 4U; + requestMsg.value2 |= Char2Nibble(c); return DecodeStatus::NeedMoreData; } else if (IsNewLine(c)) { rqState = RequestStates::Code; @@ -80,12 +108,41 @@ DecodeStatus Protocol::DecodeRequest(uint8_t c) { } uint8_t Protocol::EncodeRequest(const RequestMsg &msg, uint8_t *txbuff) { - constexpr uint8_t reqSize = 3; + uint8_t i = 1; txbuff[0] = (uint8_t)msg.code; - txbuff[1] = msg.value + '0'; - txbuff[2] = '\n'; - return reqSize; - static_assert(reqSize <= MaxRequestSize(), "Request message length exceeded the maximum size, increase the magic constant in MaxRequestSize()"); + uint8_t v = msg.value >> 4; + if (v != 0) { // skip the first '0' if any + txbuff[i] = Nibble2Char(v); + ++i; + } + v = msg.value & 0xf; + txbuff[i] = Nibble2Char(v); + ++i; + txbuff[i] = '\n'; + ++i; + return i; + static_assert(4 <= MaxRequestSize(), "Request message length exceeded the maximum size, increase the magic constant in MaxRequestSize()"); +} + +uint8_t Protocol::EncodeWriteRequest(const RequestMsg &msg, uint16_t value2, uint8_t *txbuff) { + uint8_t i = 1; + txbuff[0] = (uint8_t)msg.code; + uint8_t v = msg.value >> 4; + if (v != 0) { // skip the first '0' if any + txbuff[i] = Nibble2Char(v); + ++i; + } + v = msg.value & 0xf; + txbuff[i] = Nibble2Char(v); + ++i; + txbuff[i] = ' '; + ++i; + // dump the value + i += Value2Hex(value2, txbuff + i); + + txbuff[i] = '\n'; + ++i; + return i; } DecodeStatus Protocol::DecodeResponse(uint8_t c) { @@ -107,6 +164,7 @@ DecodeStatus Protocol::DecodeResponse(uint8_t c) { case 'F': case 'f': case 'H': + case 'R': responseMsg.request.code = (RequestMsgCodes)c; responseMsg.request.value = 0; rspState = ResponseStates::RequestValue; @@ -120,9 +178,9 @@ DecodeStatus Protocol::DecodeResponse(uint8_t c) { return DecodeStatus::Error; } case ResponseStates::RequestValue: - if (IsDigit(c)) { - responseMsg.request.value *= 10; - responseMsg.request.value += c - '0'; + if (IsHexDigit(c)) { + responseMsg.request.value <<= 4U; + responseMsg.request.value += Char2Nibble(c); return DecodeStatus::NeedMoreData; } else if (c == ' ') { rspState = ResponseStates::ParamCode; @@ -149,9 +207,9 @@ DecodeStatus Protocol::DecodeResponse(uint8_t c) { return DecodeStatus::Error; } case ResponseStates::ParamValue: - if (IsDigit(c)) { - responseMsg.paramValue *= 10; - responseMsg.paramValue += c - '0'; + if (IsHexDigit(c)) { + responseMsg.paramValue <<= 4U; + responseMsg.paramValue += Char2Nibble(c); return DecodeStatus::NeedMoreData; } else if (IsNewLine(c)) { rspState = ResponseStates::RequestCode; @@ -173,42 +231,46 @@ DecodeStatus Protocol::DecodeResponse(uint8_t c) { } uint8_t Protocol::EncodeResponseCmdAR(const RequestMsg &msg, ResponseMsgParamCodes ar, uint8_t *txbuff) { + uint8_t i = 1; txbuff[0] = (uint8_t)msg.code; - txbuff[1] = msg.value + '0'; - txbuff[2] = ' '; - txbuff[3] = (uint8_t)ar; - txbuff[4] = '\n'; - return 5; + uint8_t v = msg.value >> 4U; + if (v != 0) { // skip the first '0' if any + txbuff[i] = Nibble2Char(v); + ++i; + } + v = msg.value & 0xfU; + txbuff[i] = Nibble2Char(v); + ++i; + txbuff[i] = ' '; + ++i; + txbuff[i] = (uint8_t)ar; + ++i; + txbuff[i] = '\n'; + ++i; + return i; } uint8_t Protocol::EncodeResponseReadFINDA(const RequestMsg &msg, uint8_t findaValue, uint8_t *txbuff) { - txbuff[0] = (uint8_t)msg.code; - txbuff[1] = msg.value + '0'; - txbuff[2] = ' '; - txbuff[3] = (uint8_t)ResponseMsgParamCodes::Accepted; - txbuff[4] = findaValue + '0'; - txbuff[5] = '\n'; - return 6; + // txbuff[0] = (uint8_t)msg.code; + // txbuff[1] = msg.value + '0'; + // txbuff[2] = ' '; + // txbuff[3] = (uint8_t)ResponseMsgParamCodes::Accepted; + // txbuff[4] = findaValue + '0'; + // txbuff[5] = '\n'; + // return 6; + return EncodeResponseRead(msg, true, findaValue, txbuff); } -uint8_t Protocol::EncodeResponseVersion(const RequestMsg &msg, uint8_t value, uint8_t *txbuff) { - txbuff[0] = (uint8_t)msg.code; - txbuff[1] = msg.value + '0'; - txbuff[2] = ' '; - txbuff[3] = (uint8_t)ResponseMsgParamCodes::Accepted; - uint8_t *dst = txbuff + 4; - if (value < 10) { - *dst++ = value + '0'; - } else if (value < 100) { - *dst++ = value / 10 + '0'; - *dst++ = value % 10 + '0'; - } else { - *dst++ = value / 100 + '0'; - *dst++ = (value / 10) % 10 + '0'; - *dst++ = value % 10 + '0'; - } - *dst = '\n'; - return dst - txbuff + 1; +uint8_t Protocol::EncodeResponseVersion(const RequestMsg &msg, uint16_t value, uint8_t *txbuff) { + // txbuff[0] = (uint8_t)msg.code; + // txbuff[1] = msg.value + '0'; + // txbuff[2] = ' '; + // txbuff[3] = (uint8_t)ResponseMsgParamCodes::Accepted; + // uint8_t *dst = txbuff + 4; + // dst += Value2Hex(value, dst); + // *dst = '\n'; + // return dst - txbuff + 1; + return EncodeResponseRead(msg, true, value, txbuff); } uint8_t Protocol::EncodeResponseQueryOperation(const RequestMsg &msg, ResponseCommandStatus rcs, uint8_t *txbuff) { @@ -218,31 +280,60 @@ uint8_t Protocol::EncodeResponseQueryOperation(const RequestMsg &msg, ResponseCo txbuff[3] = (uint8_t)rcs.code; uint8_t *dst = txbuff + 4; if (rcs.code != ResponseMsgParamCodes::Finished) { - if (rcs.value < 10) { - *dst++ = rcs.value + '0'; - } else if (rcs.value < 100) { - *dst++ = rcs.value / 10 + '0'; - *dst++ = rcs.value % 10 + '0'; - } else if (rcs.value < 1000) { - *dst++ = rcs.value / 100 + '0'; - *dst++ = (rcs.value / 10) % 10 + '0'; - *dst++ = rcs.value % 10 + '0'; - } else if (rcs.value < 10000) { - *dst++ = rcs.value / 1000 + '0'; - *dst++ = (rcs.value / 100) % 10 + '0'; - *dst++ = (rcs.value / 10) % 10 + '0'; - *dst++ = rcs.value % 10 + '0'; - } else { - *dst++ = rcs.value / 10000 + '0'; - *dst++ = (rcs.value / 1000) % 10 + '0'; - *dst++ = (rcs.value / 100) % 10 + '0'; - *dst++ = (rcs.value / 10) % 10 + '0'; - *dst++ = rcs.value % 10 + '0'; - } + dst += Value2Hex(rcs.value, dst); } *dst = '\n'; return dst - txbuff + 1; } +uint8_t Protocol::EncodeResponseRead(const RequestMsg &msg, bool accepted, uint16_t value2, uint8_t *txbuff) { + uint8_t i = 1; + txbuff[0] = (uint8_t)msg.code; + uint8_t v = msg.value >> 4U; + if (v != 0) { // skip the first '0' if any + txbuff[i] = Nibble2Char(v); + ++i; + } + v = msg.value & 0xfU; + txbuff[i] = Nibble2Char(v); + ++i; + txbuff[i] = ' '; + ++i; + + if (accepted) { + txbuff[i] = (uint8_t)ResponseMsgParamCodes::Accepted; + ++i; + // dump the value + i += Value2Hex(value2, txbuff + i); + } else { + txbuff[i] = (uint8_t)ResponseMsgParamCodes::Rejected; + ++i; + } + txbuff[i] = '\n'; + ++i; + return i; +} + +uint8_t Protocol::Value2Hex(uint16_t value, uint8_t *dst) { + constexpr uint16_t topNibbleMask = 0xf000; + if (value == 0) { + *dst = '0'; + return 1; + } + // skip initial zeros + uint8_t charsOut = 4; + while ((value & topNibbleMask) == 0) { + value <<= 4U; + --charsOut; + } + for (uint8_t i = 0; i < charsOut; ++i) { + uint8_t n = (value & topNibbleMask) >> (8U + 4U); + value <<= 4U; + *dst = Nibble2Char(n); + ++dst; + } + return charsOut; +} + } // namespace protocol } // namespace modules diff --git a/src/modules/protocol.h b/src/modules/protocol.h index d8a36a9..9f95619 100644 --- a/src/modules/protocol.h +++ b/src/modules/protocol.h @@ -23,11 +23,12 @@ enum class RequestMsgCodes : uint8_t { Version = 'S', Button = 'B', Eject = 'E', - Wait = 'W', + Write = 'W', Cut = 'K', FilamentType = 'F', FilamentSensor = 'f', - Home = 'H' + Home = 'H', + Read = 'R' }; /// Definition of response message parameter codes @@ -44,13 +45,15 @@ enum class ResponseMsgParamCodes : uint8_t { /// A request message - requests are being sent by the printer into the MMU. struct RequestMsg { RequestMsgCodes code; ///< code of the request message - uint8_t value; ///< value of the request message + uint8_t value; ///< value of the request message or address of variable to read/write + uint16_t value2; ///< in case or write messages - value to be written into the register /// @param code of the request message /// @param value of the request message inline constexpr RequestMsg(RequestMsgCodes code, uint8_t value) : code(code) - , value(value) {} + , value(value) + , value2(0) {} }; /// A response message - responses are being sent from the MMU into the printer as a response to a request message. @@ -110,9 +113,14 @@ public: /// @returns number of bytes written into txbuff static uint8_t EncodeRequest(const RequestMsg &msg, uint8_t *txbuff); + /// Encodes Write request message msg into txbuff memory + /// It is expected the txbuff is large enough to fit the message + /// @returns number of bytes written into txbuff + static uint8_t EncodeWriteRequest(const RequestMsg &msg, uint16_t value2, uint8_t *txbuff); + /// @returns the maximum byte length necessary to encode a request message /// Beneficial in case of pre-allocating a buffer for enconding a RequestMsg. - static constexpr uint8_t MaxRequestSize() { return 3; } + static constexpr uint8_t MaxRequestSize() { return 4; } /// Encode generic response Command Accepted or Rejected /// @param msg source request message for this response @@ -133,7 +141,7 @@ public: /// @param value version number (0-255) /// @param txbuff where to format the message /// @returns number of bytes written into txbuff - static uint8_t EncodeResponseVersion(const RequestMsg &msg, uint8_t value, uint8_t *txbuff); + static uint8_t EncodeResponseVersion(const RequestMsg &msg, uint16_t value, uint8_t *txbuff); /// Encode response to Query operation status /// @param msg source request message for this response @@ -143,6 +151,14 @@ public: /// @returns number of bytes written into txbuff static uint8_t EncodeResponseQueryOperation(const RequestMsg &msg, ResponseCommandStatus rcs, uint8_t *txbuff); + /// Encode response to Read query + /// @param msg source request message for this response + /// @param accepted true if the read query was accepted + /// @param value2 variable value + /// @param txbuff where to format the message + /// @returns number of bytes written into txbuff + static uint8_t EncodeResponseRead(const RequestMsg &msg, bool accepted, uint16_t value2, uint8_t *txbuff); + /// @returns the most recently lexed request message inline const RequestMsg GetRequestMsg() const { return requestMsg; } @@ -159,10 +175,14 @@ public: rspState = ResponseStates::RequestCode; } +#ifndef UNITTEST private: +#endif enum class RequestStates : uint8_t { Code, ///< starting state - expects message code Value, ///< expecting code value + Address, ///< expecting address for Write command + WriteValue, ///< value to be written (Write command) Error ///< automaton in error state }; @@ -180,12 +200,67 @@ private: ResponseStates rspState; ResponseMsg responseMsg; - static bool IsNewLine(uint8_t c) { + static constexpr bool IsNewLine(uint8_t c) { return c == '\n' || c == '\r'; } - static bool IsDigit(uint8_t c) { + static constexpr bool IsDigit(uint8_t c) { return c >= '0' && c <= '9'; } + static constexpr bool IsHexDigit(uint8_t c) { + return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f'); + } + static constexpr uint8_t Char2Nibble(uint8_t c) { + switch (c) { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + return c - '0'; + case 'a': + case 'b': + case 'c': + case 'd': + case 'e': + case 'f': + return c - 'a' + 10; + default: + return 0; + } + } + + static constexpr uint8_t Nibble2Char(uint8_t n) { + switch (n) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + return n + '0'; + case 0xa: + case 0xb: + case 0xc: + case 0xd: + case 0xe: + case 0xf: + return n - 10 + 'a'; + default: + return 0; + } + } + + /// @returns number of characters written + static uint8_t Value2Hex(uint16_t value, uint8_t *dst); }; } // namespace protocol diff --git a/tests/unit/modules/protocol/test_protocol.cpp b/tests/unit/modules/protocol/test_protocol.cpp index 9481338..2e60aca 100644 --- a/tests/unit/modules/protocol/test_protocol.cpp +++ b/tests/unit/modules/protocol/test_protocol.cpp @@ -6,6 +6,52 @@ using Catch::Matchers::Equals; +TEST_CASE("protocol::Char2Nibble2Char", "[protocol]") { + uint8_t character, value; + std::tie(character, value) = GENERATE( + std::make_tuple('0', 0), + std::make_tuple('1', 1), + std::make_tuple('2', 2), + std::make_tuple('3', 3), + std::make_tuple('4', 4), + std::make_tuple('5', 5), + std::make_tuple('6', 6), + std::make_tuple('7', 7), + std::make_tuple('8', 8), + std::make_tuple('9', 9), + std::make_tuple('a', 0xa), + std::make_tuple('b', 0xb), + std::make_tuple('c', 0xc), + std::make_tuple('d', 0xd), + std::make_tuple('e', 0xe), + std::make_tuple('f', 0xf), + std::make_tuple('g', 0) // invalid character defaults to 0 + ); + REQUIRE(mp::Protocol::Char2Nibble(character) == value); + if (character != 'g') { // skip the invalid char + REQUIRE(mp::Protocol::Nibble2Char(value) == character); + } +} + +TEST_CASE("protocol::Value2Hex", "[protocol]") { + for (uint32_t v = 0; v < 0xffff; ++v) { + constexpr size_t buffSize = 5; + uint8_t tmp[buffSize]; + uint8_t chars = mp::Protocol::Value2Hex((uint16_t)v, tmp); + if (v < 0x10) { + REQUIRE(chars == 1); + } else if (v < 0x100) { + REQUIRE(chars == 2); + } else if (v < 0x1000) { + REQUIRE(chars == 3); + } else if (v < 0x10000) { + REQUIRE(chars == 4); + } + std::string tmps(tmp, tmp + chars); + REQUIRE(std::stoul(tmps, nullptr, 16) == v); + } +} + TEST_CASE("protocol::EncodeRequests", "[protocol]") { mp::RequestMsgCodes code; uint8_t value; @@ -35,7 +81,6 @@ TEST_CASE("protocol::EncodeRequests", "[protocol]") { std::make_tuple(mp::RequestMsgCodes::Version, 0), std::make_tuple(mp::RequestMsgCodes::Version, 1), std::make_tuple(mp::RequestMsgCodes::Version, 2), - std::make_tuple(mp::RequestMsgCodes::Wait, 0), std::make_tuple(mp::RequestMsgCodes::unknown, 0)); std::array txbuff; @@ -87,19 +132,51 @@ TEST_CASE("protocol::EncodeResponseCmdAR", "[protocol]") { mp::RequestMsg(mp::RequestMsgCodes::Unload, 0), - mp::RequestMsg(mp::RequestMsgCodes::Wait, 0)); + mp::RequestMsg(mp::RequestMsgCodes::Write, 0), + mp::RequestMsg(mp::RequestMsgCodes::Write, 9), + mp::RequestMsg(mp::RequestMsgCodes::Write, 0xa), + mp::RequestMsg(mp::RequestMsgCodes::Write, 0xf), + mp::RequestMsg(mp::RequestMsgCodes::Write, 10), + mp::RequestMsg(mp::RequestMsgCodes::Write, 19), + mp::RequestMsg(mp::RequestMsgCodes::Write, 0xfa), + mp::RequestMsg(mp::RequestMsgCodes::Write, 0xff)); auto responseStatus = GENERATE(mp::ResponseMsgParamCodes::Accepted, mp::ResponseMsgParamCodes::Rejected, mp::ResponseMsgParamCodes::Button); std::array txbuff; uint8_t msglen = mp::Protocol::EncodeResponseCmdAR(requestMsg, responseStatus, txbuff.data()); - CHECK(msglen == 5); - CHECK(txbuff[0] == (uint8_t)requestMsg.code); - CHECK(txbuff[1] == requestMsg.value + '0'); - CHECK(txbuff[2] == ' '); - CHECK(txbuff[3] == (uint8_t)responseStatus); - CHECK(txbuff[4] == '\n'); + if (requestMsg.value < 10) { + CHECK(msglen == 5); + CHECK(txbuff[0] == (uint8_t)requestMsg.code); + CHECK(txbuff[1] == requestMsg.value + '0'); + CHECK(txbuff[2] == ' '); + CHECK(txbuff[3] == (uint8_t)responseStatus); + CHECK(txbuff[4] == '\n'); + } else if (requestMsg.value < 16) { + CHECK(msglen == 5); + CHECK(txbuff[0] == (uint8_t)requestMsg.code); + CHECK(txbuff[1] == requestMsg.value - 10 + 'a'); + CHECK(txbuff[2] == ' '); + CHECK(txbuff[3] == (uint8_t)responseStatus); + CHECK(txbuff[4] == '\n'); + } else if (requestMsg.value < 0x1a) { + CHECK(msglen == 6); + CHECK(txbuff[0] == (uint8_t)requestMsg.code); + CHECK(txbuff[1] == (requestMsg.value >> 4U) + '0'); + CHECK(txbuff[2] == (requestMsg.value & 0xfU) + '0'); + CHECK(txbuff[3] == ' '); + CHECK(txbuff[4] == (uint8_t)responseStatus); + CHECK(txbuff[5] == '\n'); + } else { + CHECK(msglen == 6); + CHECK(txbuff[0] == (uint8_t)requestMsg.code); + CHECK(txbuff[1] == (requestMsg.value >> 4U) - 10 + 'a'); + CHECK(txbuff[2] == (requestMsg.value & 0xfU) - 10 + 'a'); + CHECK(txbuff[3] == ' '); + CHECK(txbuff[4] == (uint8_t)responseStatus); + CHECK(txbuff[5] == '\n'); + } } TEST_CASE("protocol::EncodeResponseReadFINDA", "[protocol]") { @@ -123,29 +200,26 @@ TEST_CASE("protocol::EncodeResponseVersion", "[protocol]") { std::uint8_t versionQueryType = GENERATE(0, 1, 2, 3); auto requestMsg = mp::RequestMsg(mp::RequestMsgCodes::Version, versionQueryType); - auto version = GENERATE(0, 1, 2, 3, 4, 10, 11, 12, 20, 99, 100, 101, 255); + for (uint32_t version = 0; version < 0xffff; ++version) { + std::array txbuff; + uint8_t msglen = mp::Protocol::EncodeResponseVersion(requestMsg, (uint16_t)version, txbuff.data()); - std::array txbuff; - uint8_t msglen = mp::Protocol::EncodeResponseVersion(requestMsg, version, txbuff.data()); + CHECK(msglen <= 9); + CHECK(txbuff[0] == (uint8_t)requestMsg.code); + CHECK(txbuff[1] == requestMsg.value + '0'); + CHECK(txbuff[2] == ' '); + CHECK(txbuff[3] == (uint8_t)mp::ResponseMsgParamCodes::Accepted); - CHECK(msglen <= 8); - CHECK(txbuff[0] == (uint8_t)requestMsg.code); - CHECK(txbuff[1] == requestMsg.value + '0'); - CHECK(txbuff[2] == ' '); - CHECK(txbuff[3] == (uint8_t)mp::ResponseMsgParamCodes::Accepted); + char chk[6]; + int chars = snprintf(chk, 6, "%x\n", version); + REQUIRE(chars < 6); + std::string chks(chk, chk + chars); + std::string vers((const char *)(&txbuff[4]), (const char *)(&txbuff[msglen])); - if (version < 10) { - CHECK(txbuff[4] == version + '0'); - } else if (version < 100) { - CHECK(txbuff[4] == version / 10 + '0'); - CHECK(txbuff[5] == version % 10 + '0'); - } else { - CHECK(txbuff[4] == version / 100 + '0'); - CHECK(txbuff[5] == (version / 10) % 10 + '0'); - CHECK(txbuff[6] == version % 10 + '0'); + REQUIRE(chks == vers); + + CHECK(txbuff[msglen - 1] == '\n'); } - - CHECK(txbuff[msglen - 1] == '\n'); } TEST_CASE("protocol::EncodeResponseQueryOperation", "[protocol]") { @@ -174,9 +248,7 @@ TEST_CASE("protocol::EncodeResponseQueryOperation", "[protocol]") { mp::RequestMsg(mp::RequestMsgCodes::Tool, 3), mp::RequestMsg(mp::RequestMsgCodes::Tool, 4), - mp::RequestMsg(mp::RequestMsgCodes::Unload, 0), - - mp::RequestMsg(mp::RequestMsgCodes::Wait, 0)); + mp::RequestMsg(mp::RequestMsgCodes::Unload, 0)); auto responseStatus = GENERATE(mp::ResponseMsgParamCodes::Processing, mp::ResponseMsgParamCodes::Error, mp::ResponseMsgParamCodes::Finished); @@ -242,28 +314,12 @@ TEST_CASE("protocol::EncodeResponseQueryOperation", "[protocol]") { CHECK(txbuff[4] == '\n'); CHECK(msglen == 5); } else { - if (encodedParamValue < 10) { - CHECK(txbuff[4] == encodedParamValue + '0'); - } else if (encodedParamValue < 100) { - CHECK(txbuff[4] == encodedParamValue / 10 + '0'); - CHECK(txbuff[5] == encodedParamValue % 10 + '0'); - } else if (encodedParamValue < 1000) { - CHECK(txbuff[4] == encodedParamValue / 100 + '0'); - CHECK(txbuff[5] == (encodedParamValue / 10) % 10 + '0'); - CHECK(txbuff[6] == encodedParamValue % 10 + '0'); - } else if (encodedParamValue < 10000) { - CHECK(txbuff[4] == encodedParamValue / 1000 + '0'); - CHECK(txbuff[5] == (encodedParamValue / 100) % 10 + '0'); - CHECK(txbuff[6] == (encodedParamValue / 10) % 10 + '0'); - CHECK(txbuff[7] == encodedParamValue % 10 + '0'); - } else { - CHECK(txbuff[4] == encodedParamValue / 10000 + '0'); - CHECK(txbuff[5] == (encodedParamValue / 1000) % 10 + '0'); - CHECK(txbuff[6] == (encodedParamValue / 100) % 10 + '0'); - CHECK(txbuff[7] == (encodedParamValue / 10) % 10 + '0'); - CHECK(txbuff[8] == encodedParamValue % 10 + '0'); - } - + char chk[6]; + int chars = snprintf(chk, 6, "%x\n", encodedParamValue); + REQUIRE(chars < 6); + std::string chks(chk, chk + chars); + std::string txs((const char *)(&txbuff[4]), (const char *)(&txbuff[msglen])); + REQUIRE(chk == txs); CHECK(txbuff[msglen - 1] == '\n'); } } @@ -284,7 +340,6 @@ TEST_CASE("protocol::DecodeRequest", "[protocol]") { "S0\n", "S1\n", "S2\n", "S3\n", "T0\n", "T1\n", "T2\n", "T3\n", "U0\n", - "W0\n", "X0\n"); const char *pc = rxbuff; @@ -335,7 +390,7 @@ TEST_CASE("protocol::DecodeResponseReadFinda", "[protocol]") { CHECK((uint8_t)rsp.paramValue == rxbuff[4] - '0'); } -TEST_CASE("protocol::DecodeResponseQueryOperation", "[protocol]") { +TEST_CASE("protocol::DecodeResponseQueryOperation", "[protocol][.]") { mp::Protocol p; const char *cmdReference = GENERATE( "E0", "E1", "E2", "E3", "E4", @@ -343,8 +398,7 @@ TEST_CASE("protocol::DecodeResponseQueryOperation", "[protocol]") { "K0", "K1", "K2", "K3", "K4", "L0", "L1", "L2", "L3", "L4", "T0", "T1", "T2", "T3", "T4", - "U0", - "W0"); + "U0"); const char *status = GENERATE( "P0", "P1", "E0", "E1", "E9", "F", "B0", "B1", "B2"); @@ -448,6 +502,72 @@ TEST_CASE("protocol::DecodeResponseErrors", "[protocol]") { CHECK(p.GetRequestMsg().code == mp::RequestMsgCodes::unknown); } +TEST_CASE("protocol::WriteRequest", "[protocol]") { + // write requests need special handling + std::array txbuff; + mp::Protocol p; + for (uint8_t address = 0; address < 255; ++address) { + for (uint32_t value2 = 2; value2 < 0x10000; ++value2) { + mp::RequestMsg msg(mp::RequestMsgCodes::Write, address); + uint8_t bytes = mp::Protocol::EncodeWriteRequest(msg, (uint16_t)value2, txbuff.data()); + + p.ResetRequestDecoder(); + for (uint8_t i = 0; i < bytes; ++i) { + p.DecodeRequest(txbuff[i]); + } + + REQUIRE(p.requestMsg.code == mp::RequestMsgCodes::Write); + REQUIRE(p.requestMsg.value == address); + REQUIRE(p.requestMsg.value2 == (uint16_t)value2); + } + } +} + +TEST_CASE("protocol::ReadRequest", "[protocol]") { + std::array txbuff; + mp::Protocol p; + for (uint16_t address = 0; address <= 255; ++address) { + mp::RequestMsg msg(mp::RequestMsgCodes::Read, (uint8_t)address); + uint8_t bytes = mp::Protocol::EncodeRequest(msg, txbuff.data()); + + p.ResetRequestDecoder(); + for (uint8_t i = 0; i < bytes; ++i) { + p.DecodeRequest(txbuff[i]); + } + + REQUIRE(p.requestMsg.code == mp::RequestMsgCodes::Read); + REQUIRE(p.requestMsg.value == (uint8_t)address); + } +} + +TEST_CASE("protocol::ReadResponse", "[protocol]") { + std::array txbuff; + mp::Protocol p; + for (uint8_t address = 0; address < 255; ++address) { + for (uint32_t value2 = 2; value2 < 0x10000; ++value2) { + for (uint8_t ar = 0; ar <= 1; ++ar) { + mp::RequestMsg msg(mp::RequestMsgCodes::Read, address); + uint8_t bytes = mp::Protocol::EncodeResponseRead(msg, ar != 0, value2, txbuff.data()); + + p.ResetResponseDecoder(); + for (uint8_t i = 0; i < bytes; ++i) { + p.DecodeResponse(txbuff[i]); + } + + REQUIRE(p.responseMsg.request.code == mp::RequestMsgCodes::Read); + REQUIRE(p.responseMsg.request.value == address); + if (ar) { + REQUIRE(p.responseMsg.paramCode == mp::ResponseMsgParamCodes::Accepted); + REQUIRE(p.responseMsg.paramValue == value2); + } else { + REQUIRE(p.responseMsg.paramCode == mp::ResponseMsgParamCodes::Rejected); + REQUIRE(p.responseMsg.paramValue == 0); + } + } + } + } +} + // Beware - this test makes 18M+ combinations, run only when changing the implementation of the codec // Therefore it is disabled [.] by default TEST_CASE("protocol::DecodeResponseErrorsCross", "[protocol][.]") { @@ -457,7 +577,7 @@ TEST_CASE("protocol::DecodeResponseErrorsCross", "[protocol][.]") { const char *invalidInitialSpaces = GENERATE(" ", " "); bool viInitialSpace = GENERATE(true, false); - const char *validReqCode = GENERATE("B", "E", "H", "F", "f", "K", "L", "M", "P", "Q", "S", "T", "U", "W", "X"); + const char *validReqCode = GENERATE("B", "E", "H", "F", "f", "K", "L", "M", "P", "Q", "S", "T", "U", "X"); const char *invalidReqCode = GENERATE("A", "R"); bool viReqCode = GENERATE(true, false);