diff --git a/libuavcan/include/uavcan/internal/transport/transfer_receiver.hpp b/libuavcan/include/uavcan/internal/transport/transfer_receiver.hpp index 726e7f1c67..5e11974a33 100644 --- a/libuavcan/include/uavcan/internal/transport/transfer_receiver.hpp +++ b/libuavcan/include/uavcan/internal/transport/transfer_receiver.hpp @@ -29,6 +29,8 @@ private: uint64_t this_transfer_ts_monotonic_; uint64_t first_frame_ts_utc_; uint32_t transfer_interval_; + uint16_t this_transfer_crc_; + uint16_t buffer_write_pos_; TransferID tid_; uint8_t iface_index_; uint8_t next_frame_index_; @@ -41,6 +43,7 @@ private: void prepareForNextTransfer(); bool validate(const RxFrame& frame) const; + bool writePayload(const RxFrame& frame, TransferBufferBase& buf); ResultCode receive(const RxFrame& frame, TransferBufferAccessor& tba); TransferReceiver(const TransferReceiver&); // = delete (not needed) @@ -51,6 +54,8 @@ public: , this_transfer_ts_monotonic_(0) , first_frame_ts_utc_(0) , transfer_interval_(DEFAULT_TRANSFER_INTERVAL) + , this_transfer_crc_(0) + , buffer_write_pos_(0) , iface_index_(IFACE_INDEX_NOTSET) , next_frame_index_(0) { } @@ -62,7 +67,11 @@ public: uint64_t getLastTransferTimestampMonotonic() const { return prev_transfer_ts_monotonic_; } uint64_t getLastTransferTimestampUtc() const { return first_frame_ts_utc_; } + uint16_t getLastTransferCrc() const { return this_transfer_crc_; } + uint32_t getInterval() const { return transfer_interval_; } + + static bool extractSingleFrameTransferPayload(const RxFrame& frame, uint8_t* out_data, unsigned int& out_len); }; #pragma pack(pop) diff --git a/libuavcan/src/transport/transfer_receiver.cpp b/libuavcan/src/transport/transfer_receiver.cpp index 0d22141c37..ae409b12b8 100644 --- a/libuavcan/src/transport/transfer_receiver.cpp +++ b/libuavcan/src/transport/transfer_receiver.cpp @@ -47,6 +47,7 @@ void TransferReceiver::prepareForNextTransfer() { tid_.increment(); next_frame_index_ = 0; + buffer_write_pos_ = 0; } bool TransferReceiver::validate(const RxFrame& frame) const @@ -86,22 +87,71 @@ bool TransferReceiver::validate(const RxFrame& frame) const return true; } +bool TransferReceiver::writePayload(const RxFrame& frame, TransferBufferBase& buf) +{ + if (frame.frame_index == 0) + { + unsigned int payload_offset = 0; + unsigned int crc_offset = 0; + + switch (frame.transfer_type) + { + case TRANSFER_TYPE_MESSAGE_BROADCAST: + payload_offset = 2; + crc_offset = 0; + break; + case TRANSFER_TYPE_SERVICE_RESPONSE: // Addressed transfers have 1-byte overhead for Destination Node ID + case TRANSFER_TYPE_SERVICE_REQUEST: + case TRANSFER_TYPE_MESSAGE_UNICAST: + payload_offset = 3; + crc_offset = 1; + break; + default: + UAVCAN_TRACE("TransferReceiver", "Invalid transfer type, %s", frame.toString().c_str()); + return RESULT_NOT_COMPLETE; + } + + this_transfer_crc_ = + (frame.payload[crc_offset] & 0xFF) | + (uint16_t(frame.payload[crc_offset + 1] & 0xFF) << 8); // little endian + + const int effective_payload_len = frame.payload_len - payload_offset; + const int res = buf.write(buffer_write_pos_, frame.payload + payload_offset, effective_payload_len); + const bool success = res == effective_payload_len; + if (success) + buffer_write_pos_ += effective_payload_len; + return success; + } + else + { + const int res = buf.write(buffer_write_pos_, frame.payload, frame.payload_len); + const bool success = res == frame.payload_len; + if (success) + buffer_write_pos_ += frame.payload_len; + return success; + } +} + TransferReceiver::ResultCode TransferReceiver::receive(const RxFrame& frame, TransferBufferAccessor& tba) { + // Transfer timestamps are derived from the first frame if (frame.frame_index == 0) { this_transfer_ts_monotonic_ = frame.ts_monotonic; first_frame_ts_utc_ = frame.ts_utc; } - if ((frame.frame_index == 0) && frame.last_frame) // Single-frame transfer + // Single-frame transfer + if ((frame.frame_index == 0) && frame.last_frame) { tba.remove(); updateTransferTimings(); prepareForNextTransfer(); + this_transfer_crc_ = 0; // SFT has no CRC return RESULT_SINGLE_FRAME; } + // Payload write TransferBufferBase* buf = tba.access(); if (buf == NULL) buf = tba.create(); @@ -111,11 +161,9 @@ TransferReceiver::ResultCode TransferReceiver::receive(const RxFrame& frame, Tra prepareForNextTransfer(); return RESULT_NOT_COMPLETE; } - - const int res = buf->write(Frame::PAYLOAD_LEN_MAX * frame.frame_index, frame.payload, frame.payload_len); - if (res != frame.payload_len) + if (!writePayload(frame, *buf)) { - UAVCAN_TRACE("TransferReceiver", "Buffer write failure [%i], %s", res, frame.toString().c_str()); + UAVCAN_TRACE("TransferReceiver", "Payload write failed, %s", frame.toString().c_str()); tba.remove(); prepareForNextTransfer(); return RESULT_NOT_COMPLETE; @@ -172,6 +220,8 @@ TransferReceiver::ResultCode TransferReceiver::addFrame(const RxFrame& frame, Tr iface_index_ = frame.iface_index; tid_ = frame.transfer_id; next_frame_index_ = 0; + buffer_write_pos_ = 0; + this_transfer_crc_ = 0; if (!first_fame) { tid_.increment(); @@ -185,4 +235,37 @@ TransferReceiver::ResultCode TransferReceiver::addFrame(const RxFrame& frame, Tr return receive(frame, tba); } +bool TransferReceiver::extractSingleFrameTransferPayload(const RxFrame& frame, uint8_t* out_data, + unsigned int& out_len) +{ + if (out_data == NULL) + { + assert(0); + return false; + } + + out_len = 0; + unsigned int offset = 0; + switch (frame.transfer_type) + { + case TRANSFER_TYPE_MESSAGE_BROADCAST: + offset = 0; + break; + case TRANSFER_TYPE_SERVICE_RESPONSE: // Addressed transfers have 1-byte overhead for Destination Node ID + case TRANSFER_TYPE_SERVICE_REQUEST: + case TRANSFER_TYPE_MESSAGE_UNICAST: + offset = 1; + break; + default: + return false; + } + + if (frame.payload_len < offset) + return false; + + out_len = frame.payload_len - offset; + std::copy(frame.payload + offset, frame.payload + offset + out_len, out_data); + return true; +} + } diff --git a/libuavcan/test/transport/transfer_receiver.cpp b/libuavcan/test/transport/transfer_receiver.cpp index 56ba9a7100..c1bf7f448e 100644 --- a/libuavcan/test/transport/transfer_receiver.cpp +++ b/libuavcan/test/transport/transfer_receiver.cpp @@ -6,6 +6,10 @@ #include #include +/* + * Beware! + * The code you're about to look at desperately needs some cleaning. + */ struct RxFrameGenerator { @@ -48,7 +52,7 @@ struct RxFrameGenerator } }; -const uavcan::TransferBufferManagerKey RxFrameGenerator::DEFAULT_KEY(42, uavcan::TRANSFER_TYPE_MESSAGE_UNICAST); +const uavcan::TransferBufferManagerKey RxFrameGenerator::DEFAULT_KEY(42, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST); template @@ -122,10 +126,11 @@ TEST(TransferReceiver, Basic) * Valid compound transfer * Args: iface_index, data, frame_index, last, transfer_id, timestamp */ - CHECK_NOT_COMPLETE(rcv.addFrame(gen(0, "12345678", 0, false, 0, 100), bk)); + CHECK_NOT_COMPLETE(rcv.addFrame(gen(0, "\x34\x12" "345678", 0, false, 0, 100), bk)); CHECK_COMPLETE(rcv.addFrame(gen(0, "foo", 1, true, 0, 200), bk)); - ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), "12345678foo")); + ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), "345678foo")); + ASSERT_EQ(0x1234, rcv.getLastTransferCrc()); ASSERT_EQ(TransferReceiver::DEFAULT_TRANSFER_INTERVAL, rcv.getInterval()); // Not initialized yet ASSERT_EQ(100, rcv.getLastTransferTimestampMonotonic()); @@ -134,7 +139,7 @@ TEST(TransferReceiver, Basic) */ CHECK_NOT_COMPLETE(rcv.addFrame(gen(0, "qwe", 0, false, 0, 300), bk)); // Previous TID, rejected CHECK_NOT_COMPLETE(rcv.addFrame(gen(1, "rty", 0, false, 0, 300), bk)); // Previous TID, wrong iface - CHECK_NOT_COMPLETE(rcv.addFrame(gen(0, "12345678", 0, false, 1, 1000), bk)); + CHECK_NOT_COMPLETE(rcv.addFrame(gen(0, "\x9a\x78" "345678", 0, false, 1, 1000), bk)); CHECK_NOT_COMPLETE(rcv.addFrame(gen(0, "qwertyui", 0, false, 1, 1100), bk)); // Old FI CHECK_NOT_COMPLETE(rcv.addFrame(gen(0, "abcdefgh", 1, false, 1, 1200), bk)); CHECK_NOT_COMPLETE(rcv.addFrame(gen(0, "45678910", 1, false, 2, 1300), bk)); // Next TID, but FI > 0 @@ -142,7 +147,8 @@ TEST(TransferReceiver, Basic) CHECK_NOT_COMPLETE(rcv.addFrame(gen(0, "", 31,true, 1, 1300), bk)); // Unexpected FI CHECK_COMPLETE( rcv.addFrame(gen(0, "", 2, true, 1, 1300), bk)); - ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), "12345678abcdefgh")); + ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), "345678abcdefgh")); + ASSERT_EQ(0x789A, rcv.getLastTransferCrc()); ASSERT_GT(TransferReceiver::DEFAULT_TRANSFER_INTERVAL, rcv.getInterval()); ASSERT_LT(TransferReceiver::MIN_TRANSFER_INTERVAL, rcv.getInterval()); ASSERT_EQ(1000, rcv.getLastTransferTimestampMonotonic()); @@ -192,7 +198,7 @@ TEST(TransferReceiver, Basic) ASSERT_EQ(100000100, rcv.getLastTransferTimestampMonotonic()); ASSERT_TRUE(rcv.isTimedOut(900000000)); - CHECK_NOT_COMPLETE(rcv.addFrame(gen(1, "12345678", 0, false, 11, 900000000), bk));// Global timeout + CHECK_NOT_COMPLETE(rcv.addFrame(gen(1, "\x78\x56" "345678", 0, false, 11, 900000000), bk));// Global timeout CHECK_NOT_COMPLETE(rcv.addFrame(gen(0, "12345678", 0, false, 11, 900000100), bk));// Wrong iface CHECK_NOT_COMPLETE(rcv.addFrame(gen(0, "qwe", 1, true, 11, 900000200), bk));// Wrong iface CHECK_COMPLETE( rcv.addFrame(gen(1, "qwe", 1, true, 11, 900000200), bk)); @@ -203,7 +209,8 @@ TEST(TransferReceiver, Basic) ASSERT_LT(TransferReceiver::DEFAULT_TRANSFER_INTERVAL, rcv.getInterval()); ASSERT_LE(TransferReceiver::MIN_TRANSFER_INTERVAL, rcv.getInterval()); ASSERT_GE(TransferReceiver::MAX_TRANSFER_INTERVAL, rcv.getInterval()); - ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), "12345678qwe")); + ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), "345678qwe")); + ASSERT_EQ(0x5678, rcv.getLastTransferCrc()); /* * Destruction @@ -225,26 +232,27 @@ TEST(TransferReceiver, OutOfBufferSpace_32bytes) /* * Simple transfer, maximum buffer length */ - CHECK_NOT_COMPLETE(rcv.addFrame(gen(1, "12345678", 0, false, 10, 100000000), bk)); // 8 - CHECK_NOT_COMPLETE(rcv.addFrame(gen(1, "12345678", 1, false, 10, 100000100), bk)); // 16 - CHECK_NOT_COMPLETE(rcv.addFrame(gen(1, "12345678", 2, false, 10, 100000200), bk)); // 24 - CHECK_NOT_COMPLETE(rcv.addFrame(gen(1, "12345678", 3, false, 10, 100000300), bk)); // 32 - CHECK_COMPLETE( rcv.addFrame(gen(1, "", 4, true, 10, 100000400), bk)); // 32 + CHECK_NOT_COMPLETE(rcv.addFrame(gen(1, "12345678", 0, false, 10, 100000000), bk)); // 6 + CHECK_NOT_COMPLETE(rcv.addFrame(gen(1, "12345678", 1, false, 10, 100000100), bk)); // 14 + CHECK_NOT_COMPLETE(rcv.addFrame(gen(1, "12345678", 2, false, 10, 100000200), bk)); // 22 + CHECK_NOT_COMPLETE(rcv.addFrame(gen(1, "12345678", 3, false, 10, 100000300), bk)); // 30 + CHECK_COMPLETE( rcv.addFrame(gen(1, "12", 4, true, 10, 100000400), bk)); // 32 ASSERT_EQ(100000000, rcv.getLastTransferTimestampMonotonic()); - ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), "12345678123456781234567812345678")); + ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), "34567812345678123456781234567812")); + ASSERT_EQ(0x3231, rcv.getLastTransferCrc()); // CRC from "12", which is 0x3231 in little endian /* * Transfer longer than available buffer space */ - CHECK_NOT_COMPLETE(rcv.addFrame(gen(1, "12345678", 0, false, 11, 100001000), bk)); // 8 - CHECK_NOT_COMPLETE(rcv.addFrame(gen(1, "12345678", 1, false, 11, 100001100), bk)); // 16 - CHECK_NOT_COMPLETE(rcv.addFrame(gen(1, "12345678", 2, false, 11, 100001200), bk)); // 24 - CHECK_NOT_COMPLETE(rcv.addFrame(gen(1, "12345678", 3, false, 11, 100001200), bk)); // 32 - CHECK_NOT_COMPLETE(rcv.addFrame(gen(1, "12345678", 4, true, 11, 100001300), bk)); // 40 // EOT, ignored - lost sync + CHECK_NOT_COMPLETE(rcv.addFrame(gen(1, "12345678", 0, false, 11, 100001000), bk)); // 6 + CHECK_NOT_COMPLETE(rcv.addFrame(gen(1, "12345678", 1, false, 11, 100001100), bk)); // 14 + CHECK_NOT_COMPLETE(rcv.addFrame(gen(1, "12345678", 2, false, 11, 100001200), bk)); // 22 + CHECK_NOT_COMPLETE(rcv.addFrame(gen(1, "12345678", 3, false, 11, 100001200), bk)); // 30 + CHECK_NOT_COMPLETE(rcv.addFrame(gen(1, "12345678", 4, true, 11, 100001300), bk)); // 38 // EOT, ignored - lost sync - ASSERT_EQ(100000000, rcv.getLastTransferTimestampMonotonic()); - ASSERT_FALSE(bufmgr.access(gen.bufmgr_key)); // Buffer should be removed + ASSERT_EQ(100000000, rcv.getLastTransferTimestampMonotonic()); // Timestamp will not be overriden + ASSERT_FALSE(bufmgr.access(gen.bufmgr_key)); // Buffer should be removed } @@ -264,7 +272,8 @@ TEST(TransferReceiver, UnterminatedTransfer) } CHECK_COMPLETE(rcv.addFrame(gen(1, "12345678", uavcan::Frame::FRAME_INDEX_MAX, true, 0, 1100), bk)); ASSERT_EQ(1000, rcv.getLastTransferTimestampMonotonic()); - ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), content)); + ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), std::string(content, 2))); + ASSERT_EQ(0x3231, rcv.getLastTransferCrc()); } @@ -284,7 +293,8 @@ TEST(TransferReceiver, OutOfOrderFrames) CHECK_COMPLETE( rcv.addFrame(gen(1, "abcd", 2, true, 10, 100000400), bk)); ASSERT_EQ(100000000, rcv.getLastTransferTimestampMonotonic()); - ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), "12345678qwertyuiabcd")); + ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), "345678qwertyuiabcd")); + ASSERT_EQ(0x3231, rcv.getLastTransferCrc()); } @@ -306,7 +316,8 @@ TEST(TransferReceiver, IntervalMeasurement) CHECK_NOT_COMPLETE(rcv.addFrame(gen(1, "qwertyui", 1, false, tid.get(), timestamp), bk)); CHECK_COMPLETE( rcv.addFrame(gen(1, "abcd", 2, true, tid.get(), timestamp), bk)); - ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), "12345678qwertyuiabcd")); + ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), "345678qwertyuiabcd")); + ASSERT_EQ(0x3231, rcv.getLastTransferCrc()); ASSERT_EQ(timestamp, rcv.getLastTransferTimestampMonotonic()); timestamp += INTERVAL; @@ -339,7 +350,8 @@ TEST(TransferReceiver, Restart) CHECK_NOT_COMPLETE(rcv.addFrame(gen(1, "12345678", 1, false, 0, 13000300), bk));// 3 sec later, iface timeout CHECK_COMPLETE( rcv.addFrame(gen(1, "12345678", 2, true, 0, 13000400), bk));// OK nevertheless - ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), "123456781234567812345678")); + ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), "3456781234567812345678")); + ASSERT_EQ(0x3231, rcv.getLastTransferCrc()); /* * Begins OK, gets an iface timeout, switches to another iface @@ -353,7 +365,8 @@ TEST(TransferReceiver, Restart) CHECK_NOT_COMPLETE(rcv.addFrame(gen(0, "12345678", 1, false, 2, 16000900), bk));// Continuing CHECK_COMPLETE( rcv.addFrame(gen(0, "12345678", 2, true, 2, 16000910), bk));// Done - ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), "123456781234567812345678")); + ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), "3456781234567812345678")); + ASSERT_EQ(0x3231, rcv.getLastTransferCrc()); } @@ -372,7 +385,7 @@ TEST(TransferReceiver, UtcTransferTimestamping) CHECK_NOT_COMPLETE(rcv.addFrame(gen(1, "qwertyui", 1, false, 0, 2, 0), bk)); CHECK_COMPLETE( rcv.addFrame(gen(1, "abcd", 2, true, 0, 3, 0), bk)); - ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), "12345678qwertyuiabcd")); + ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), "345678qwertyuiabcd")); ASSERT_EQ(1, rcv.getLastTransferTimestampMonotonic()); ASSERT_EQ(0, rcv.getLastTransferTimestampUtc()); @@ -383,7 +396,7 @@ TEST(TransferReceiver, UtcTransferTimestamping) CHECK_NOT_COMPLETE(rcv.addFrame(gen(1, "qwertyui", 1, false, 1, 5, 0), bk)); // Following are ignored CHECK_COMPLETE( rcv.addFrame(gen(1, "abcd", 2, true, 1, 6, 42), bk)); - ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), "12345678qwertyuiabcd")); + ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), "345678qwertyuiabcd")); ASSERT_EQ(4, rcv.getLastTransferTimestampMonotonic()); ASSERT_EQ(123, rcv.getLastTransferTimestampUtc()); @@ -401,7 +414,113 @@ TEST(TransferReceiver, UtcTransferTimestamping) CHECK_NOT_COMPLETE(rcv.addFrame(gen(0, "qwertyui", 1, false, 1, 100000001, 300000000), bk)); CHECK_COMPLETE( rcv.addFrame(gen(0, "abcd", 2, true, 1, 100000002, 900000000), bk)); - ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), "12345678qwertyuiabcd")); + ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), "345678qwertyuiabcd")); ASSERT_EQ(100000000, rcv.getLastTransferTimestampMonotonic()); ASSERT_EQ(800000000, rcv.getLastTransferTimestampUtc()); } + + +TEST(TransferReceiver, HeaderParsing) +{ + Context<32> context; + RxFrameGenerator gen(789, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST); + uavcan::TransferReceiver& rcv = context.receiver; + uavcan::ITransferBufferManager& bufmgr = context.bufmgr; + + static const uavcan::TransferType ADDRESSED_TRANSFER_TYPES[3] = + { + uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, + uavcan::TRANSFER_TYPE_SERVICE_REQUEST, + uavcan::TRANSFER_TYPE_SERVICE_RESPONSE + }; + + uavcan::TransferID tid; + + /* + * MFT, message broadcasting + */ + { + gen.bufmgr_key = + uavcan::TransferBufferManagerKey(gen.bufmgr_key.getNodeID(), uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST); + uavcan::TransferBufferAccessor bk1(&context.bufmgr, gen.bufmgr_key); + + CHECK_NOT_COMPLETE(rcv.addFrame(gen(0, "12345678", 0, false, tid.get(), 1), bk1)); + CHECK_COMPLETE( rcv.addFrame(gen(0, "abcd", 1, true, tid.get(), 2), bk1)); + + ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), "345678abcd")); + ASSERT_EQ(0x3231, rcv.getLastTransferCrc()); + + tid.increment(); + bk1.remove(); + } + + /* + * MFT, message unicast, service request/response + */ + for (int i = 0; i < int(sizeof(ADDRESSED_TRANSFER_TYPES) / sizeof(ADDRESSED_TRANSFER_TYPES[0])); i++) + { + gen.bufmgr_key = + uavcan::TransferBufferManagerKey(gen.bufmgr_key.getNodeID(), ADDRESSED_TRANSFER_TYPES[i]); + uavcan::TransferBufferAccessor bk2(&context.bufmgr, gen.bufmgr_key); + + const uint64_t ts_monotonic = i + 10; + + CHECK_NOT_COMPLETE(rcv.addFrame(gen(0, "12345678", 0, false, tid.get(), ts_monotonic), bk2)); + CHECK_COMPLETE( rcv.addFrame(gen(0, "abcd", 1, true, tid.get(), ts_monotonic), bk2)); + + ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), "45678abcd")); + ASSERT_EQ(0x3332, rcv.getLastTransferCrc()); // Second and third bytes + + tid.increment(); + bk2.remove(); + } + + /* + * SFT, message broadcasting + */ + static const std::string SFT_PAYLOAD = "12345678"; + + { + gen.bufmgr_key = + uavcan::TransferBufferManagerKey(gen.bufmgr_key.getNodeID(), uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST); + uavcan::TransferBufferAccessor bk(&context.bufmgr, gen.bufmgr_key); + + const uavcan::RxFrame frame = gen(0, SFT_PAYLOAD, 0, true, tid.get(), 1000); + + CHECK_SINGLE_FRAME(rcv.addFrame(frame, bk)); + ASSERT_EQ(0x0000, rcv.getLastTransferCrc()); // Default value - zero + + uint8_t payload[uavcan::Frame::PAYLOAD_LEN_MAX]; + unsigned int payload_len = 0xFFFF; + ASSERT_TRUE(uavcan::TransferReceiver::extractSingleFrameTransferPayload(frame, payload, payload_len)); + + // All bytes are payload, zero overhead + ASSERT_TRUE(std::equal(SFT_PAYLOAD.begin(), SFT_PAYLOAD.end(), payload)); + + tid.increment(); + } + + /* + * SFT, message unicast, service request/response + */ + for (int i = 0; i < int(sizeof(ADDRESSED_TRANSFER_TYPES) / sizeof(ADDRESSED_TRANSFER_TYPES[0])); i++) + { + gen.bufmgr_key = + uavcan::TransferBufferManagerKey(gen.bufmgr_key.getNodeID(), ADDRESSED_TRANSFER_TYPES[i]); + uavcan::TransferBufferAccessor bk(&context.bufmgr, gen.bufmgr_key); + + const uavcan::RxFrame frame = gen(0, SFT_PAYLOAD, 0, true, tid.get(), i + 10000); + + CHECK_SINGLE_FRAME(rcv.addFrame(frame, bk)); + ASSERT_EQ(0x0000, rcv.getLastTransferCrc()); // Default value - zero + + uint8_t payload[uavcan::Frame::PAYLOAD_LEN_MAX]; + unsigned int payload_len = 0xFFFF; + ASSERT_TRUE(uavcan::TransferReceiver::extractSingleFrameTransferPayload(frame, payload, payload_len)); + + // First byte must be ignored + ASSERT_TRUE(std::equal(SFT_PAYLOAD.begin() + 1, SFT_PAYLOAD.end(), payload)); + + tid.increment(); + } +}