fly316/PX4-Autopilot
7
0
Fork 0
mirror of https://gitee.com/mirrors_PX4/PX4-Autopilot.git synced 2026-10-26 16:53:34 +08:00
Code Issues Packages Projects Releases Wiki Activity

Style fix: All constants are CamelCase now

Browse Source
This commit is contained in:
Pavel Kirienko
2014-02-21 18:45:23 +04:00
parent a155e6f859
commit 47a2b01a14
41 changed files with 473 additions and 472 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libuavcan/include/uavcan/can_driver.hpp
+10 -10
View File
@@ -18,10 +18,10 @@ namespace uavcan
#pragma pack(push, 1)
struct CanFrame
{
static const uint32_t MASK_STDID = 0x000007FF;
static const uint32_t MASK_EXTID = 0x1FFFFFFF;
static const uint32_t FLAG_EFF = 1 << 31; ///< Extended frame format
static const uint32_t FLAG_RTR = 1 << 30; ///< Remote transmission request
static const uint32_t MaskStdID = 0x000007FF;
static const uint32_t MaskExtID = 0x1FFFFFFF;
static const uint32_t FlagEFF = 1 << 31; ///< Extended frame format
static const uint32_t FlagRTR = 1 << 30; ///< Remote transmission request
uint32_t id; ///< CAN ID with flags (above)
uint8_t data[8];
@@ -48,21 +48,21 @@ struct CanFrame
return (id == rhs.id) && (dlc == rhs.dlc) && std::equal(data, data + dlc, rhs.data);
}
bool isExtended() const { return id & FLAG_EFF; }
bool isRemoteTransmissionRequest() const { return id & FLAG_RTR; }
bool isExtended() const { return id & FlagEFF; }
bool isRemoteTransmissionRequest() const { return id & FlagRTR; }
enum StringRepresentation { STR_TIGHT, STR_ALIGNED };
std::string toString(StringRepresentation mode = STR_TIGHT) const;
enum StringRepresentation { StrTight, StrAligned };
std::string toString(StringRepresentation mode = StrTight) const;
// TODO: priority comparison for EXT vs STD frames
bool priorityHigherThan(const CanFrame& rhs) const
{
return (id & CanFrame::MASK_EXTID) < (rhs.id & CanFrame::MASK_EXTID);
return (id & CanFrame::MaskExtID) < (rhs.id & CanFrame::MaskExtID);
}
bool priorityLowerThan(const CanFrame& rhs) const
{
return (id & CanFrame::MASK_EXTID) > (rhs.id & CanFrame::MASK_EXTID);
return (id & CanFrame::MaskExtID) > (rhs.id & CanFrame::MaskExtID);
}
};
#pragma pack(pop)
libuavcan/include/uavcan/internal/data_type.hpp
+9 -9
View File
@@ -12,31 +12,31 @@ namespace uavcan
enum DataTypeKind
{
DATA_TYPE_KIND_SERVICE,
DATA_TYPE_KIND_MESSAGE,
NUM_DATA_TYPE_KINDS
DataTypeKindService,
DataTypeKindMessage,
NumDataTypeKinds
};
struct DataTypeHash
{
enum { NUM_BYTES = 16 };
uint8_t value[NUM_BYTES];
enum { NumBytes = 16 };
uint8_t value[NumBytes];
DataTypeHash()
{
std::fill(value, value + NUM_BYTES, 0);
std::fill(value, value + NumBytes, 0);
}
DataTypeHash(const uint8_t source[NUM_BYTES])
DataTypeHash(const uint8_t source[NumBytes])
{
std::copy(source, source + NUM_BYTES, value);
std::copy(source, source + NumBytes, value);
}
bool operator!=(const DataTypeHash& rhs) const { return !operator==(rhs); }
bool operator==(const DataTypeHash& rhs) const
{
return std::equal(value, value + NUM_BYTES, rhs.value);
return std::equal(value, value + NumBytes, rhs.value);
}
};
libuavcan/include/uavcan/internal/dynamic_memory.hpp
+18 -18
View File
@@ -34,10 +34,10 @@ public:
};
template <int MAX_POOLS>
template <int MaxPools>
class PoolManager : public IAllocator, Noncopyable
{
IPoolAllocator* pools_[MAX_POOLS];
IPoolAllocator* pools_[MaxPools];
static bool sortComparePoolAllocators(const IPoolAllocator* a, const IPoolAllocator* b)
{
@@ -56,7 +56,7 @@ public:
{
assert(pool);
bool retval = false;
for (int i = 0; i < MAX_POOLS; i++)
for (int i = 0; i < MaxPools; i++)
{
assert(pools_[i] != pool);
if (pools_[i] == NULL || pools_[i] == pool)
@@ -67,13 +67,13 @@ public:
}
}
// We need to keep the pools in order, so that smallest blocks go first
std::sort(pools_, pools_ + MAX_POOLS, &PoolManager::sortComparePoolAllocators);
std::sort(pools_, pools_ + MaxPools, &PoolManager::sortComparePoolAllocators);
return retval;
}
void* allocate(std::size_t size)
{
for (int i = 0; i < MAX_POOLS; i++)
for (int i = 0; i < MaxPools; i++)
{
if (pools_[i] == NULL)
break;
@@ -86,7 +86,7 @@ public:
void deallocate(const void* ptr)
{
for (int i = 0; i < MAX_POOLS; i++)
for (int i = 0; i < MaxPools; i++)
{
if (pools_[i] == NULL)
{
@@ -103,37 +103,37 @@ public:
};
template <std::size_t POOL_SIZE, std::size_t BLOCK_SIZE>
template <std::size_t PoolSize, std::size_t BlockSize>
class PoolAllocator : public IPoolAllocator, Noncopyable
{
union Node
{
uint8_t data[BLOCK_SIZE];
uint8_t data[BlockSize];
Node* next;
};
Node* free_list_;
uint8_t pool_[POOL_SIZE] __attribute__((aligned(16))); // TODO: compiler-independent alignment
uint8_t pool_[PoolSize] __attribute__((aligned(16))); // TODO: compiler-independent alignment
// Noncopyable
PoolAllocator(const PoolAllocator&);
PoolAllocator& operator=(const PoolAllocator&);
public:
static const int NUM_BLOCKS = int(POOL_SIZE / BLOCK_SIZE);
static const int NumBlocks = int(PoolSize / BlockSize);
PoolAllocator()
: free_list_(reinterpret_cast<Node*>(pool_)) // TODO: alignment
{
memset(pool_, 0, POOL_SIZE);
for (int i = 0; i < NUM_BLOCKS - 1; i++)
memset(pool_, 0, PoolSize);
for (int i = 0; i < NumBlocks - 1; i++)
free_list_[i].next = free_list_ + i + 1;
free_list_[NUM_BLOCKS - 1].next = NULL;
free_list_[NumBlocks - 1].next = NULL;
}
void* allocate(std::size_t size)
{
if (free_list_ == NULL || size > BLOCK_SIZE)
if (free_list_ == NULL || size > BlockSize)
return NULL;
void* pmem = free_list_;
free_list_ = free_list_->next;
@@ -156,10 +156,10 @@ public:
{
return
ptr >= pool_ &&
ptr < (pool_ + POOL_SIZE);
ptr < (pool_ + PoolSize);
}
std::size_t getBlockSize() const { return BLOCK_SIZE; }
std::size_t getBlockSize() const { return BlockSize; }
int getNumFreeBlocks() const
{
@@ -168,7 +168,7 @@ public:
while (p)
{
num++;
assert(num <= NUM_BLOCKS);
assert(num <= NumBlocks);
p = p->next;
}
return num;
@@ -176,7 +176,7 @@ public:
int getNumUsedBlocks() const
{
return NUM_BLOCKS - getNumFreeBlocks();
return NumBlocks - getNumFreeBlocks();
}
};
libuavcan/include/uavcan/internal/impl_constants.hpp
+5 -5
View File
@@ -15,19 +15,19 @@ namespace uavcan
* fit this size; otherwise compilation fails.
*/
#if UAVCAN_MEM_POOL_BLOCK_SIZE
enum { MEM_POOL_BLOCK_SIZE = UAVCAN_MEM_POOL_BLOCK_SIZE };
enum { MemPoolBlockSize = UAVCAN_MEM_POOL_BLOCK_SIZE };
#else
enum { MEM_POOL_BLOCK_SIZE = 32 + sizeof(void*) * 2 };
enum { MemPoolBlockSize = 32 + sizeof(void*) * 2 };
#endif
enum { MEM_POOL_ALIGNMENT = 8 };
enum { MemPoolAlignment = 8 };
typedef char _alignment_check_for_MEM_POOL_BLOCK_SIZE[((MEM_POOL_BLOCK_SIZE & (MEM_POOL_ALIGNMENT - 1)) == 0) ? 1 : -1];
typedef char _alignment_check_for_MEM_POOL_BLOCK_SIZE[((MemPoolBlockSize & (MemPoolAlignment - 1)) == 0) ? 1 : -1];
template <typename T>
struct IsDynamicallyAllocatable
{
static void check() { StaticAssert<sizeof(T) <= MEM_POOL_BLOCK_SIZE>::check(); }
static void check() { StaticAssert<sizeof(T) <= MemPoolBlockSize>::check(); }
};
}
libuavcan/include/uavcan/internal/map.hpp
+8 -8
View File
@@ -20,9 +20,9 @@ namespace uavcan
* Both key and value must be copyable, assignable and default constructible.
* Key must implement a comparison operator.
* Key's default constructor must initialize the object into invalid state.
* Size of Key + Value + padding must not exceed MEM_POOL_BLOCK_SIZE.
* Size of Key + Value + padding must not exceed MemPoolBlockSize.
*/
template <typename Key, typename Value, unsigned int NUM_STATIC_ENTRIES>
template <typename Key, typename Value, unsigned int NumStaticEntries>
class Map : Noncopyable
{
#pragma pack(push, 1)
@@ -37,7 +37,7 @@ class Map : Noncopyable
struct KVGroup : LinkedListNode<KVGroup>
{
enum { NUM_KV = (MEM_POOL_BLOCK_SIZE - sizeof(LinkedListNode<KVGroup>)) / sizeof(KVPair) };
enum { NUM_KV = (MemPoolBlockSize - sizeof(LinkedListNode<KVGroup>)) / sizeof(KVPair) };
KVPair kvs[NUM_KV];
KVGroup()
@@ -76,11 +76,11 @@ class Map : Noncopyable
LinkedListRoot<KVGroup> list_;
IAllocator& allocator_;
KVPair static_[NUM_STATIC_ENTRIES];
KVPair static_[NumStaticEntries];
KVPair* find(const Key& key)
{
for (unsigned int i = 0; i < NUM_STATIC_ENTRIES; i++)
for (unsigned int i = 0; i < NumStaticEntries; i++)
if (static_[i].match(key))
return static_ + i;
@@ -101,7 +101,7 @@ class Map : Noncopyable
{
// Looking for first EMPTY static entry
KVPair* stat = NULL;
for (unsigned int i = 0; i < NUM_STATIC_ENTRIES; i++)
for (unsigned int i = 0; i < NumStaticEntries; i++)
{
if (static_[i].match(Key()))
{
@@ -232,7 +232,7 @@ public:
{
unsigned int num_removed = 0;
for (unsigned int i = 0; i < NUM_STATIC_ENTRIES; i++)
for (unsigned int i = 0; i < NumStaticEntries; i++)
{
if (!static_[i].match(Key()))
{
@@ -280,7 +280,7 @@ public:
unsigned int getNumStaticPairs() const
{
unsigned int num = 0;
for (unsigned int i = 0; i < NUM_STATIC_ENTRIES; i++)
for (unsigned int i = 0; i < NumStaticEntries; i++)
if (!static_[i].match(Key()))
num++;
return num;
libuavcan/include/uavcan/internal/marshalling/bit_stream.hpp
+4 -4
View File
@@ -18,7 +18,7 @@ extern "C" void bitarray_copy(const unsigned char *src_org, int src_offset, int
class BitStream
{
enum { MAX_BYTES_PER_RW = 16 };
enum { MaxBytesPerRW = 16 };
ITransferBuffer& buf_;
int bit_offset_;
@@ -34,12 +34,12 @@ class BitStream
}
public:
enum { MAX_BITS_PER_RW = MAX_BYTES_PER_RW * 8 };
enum { MaxBitsPerRW = MaxBytesPerRW * 8 };
enum
{
RESULT_OUT_OF_BUFFER = 0,
RESULT_OK = 1
ResultOutOfBuffer = 0,
ResultOk = 1
};
BitStream(ITransferBuffer& buf)
libuavcan/include/uavcan/internal/marshalling/scalar_codec.hpp
+36 -36
View File
@@ -18,10 +18,10 @@ class ScalarCodec
{
BitStream& stream_;
template <int SIZE>
static void swapByteOrder(uint8_t (&bytes)[SIZE])
template <int Size>
static void swapByteOrder(uint8_t (&bytes)[Size])
{
for (int i = 0, j = SIZE - 1; i < j; i++, j--)
for (int i = 0, j = Size - 1; i < j; i++, j--)
{
const uint8_t c = bytes[i];
bytes[i] = bytes[j];
@@ -29,9 +29,9 @@ class ScalarCodec
}
}
template <int BITLEN, int SIZE>
static typename EnableIf<(BITLEN > 8)>::Type
convertByteOrder(uint8_t (&bytes)[SIZE])
template <int BitLen, int Size>
static typename EnableIf<(BitLen > 8)>::Type
convertByteOrder(uint8_t (&bytes)[Size])
{
#if defined(BYTE_ORDER) && defined(BIG_ENDIAN)
static const bool big_endian = BYTE_ORDER == BIG_ENDIAN;
@@ -50,50 +50,50 @@ class ScalarCodec
swapByteOrder(bytes);
}
template <int BITLEN, int SIZE>
static typename EnableIf<(BITLEN <= 8)>::Type
convertByteOrder(uint8_t (&bytes)[SIZE])
template <int BitLen, int Size>
static typename EnableIf<(BitLen <= 8)>::Type
convertByteOrder(uint8_t (&bytes)[Size])
{
(void)bytes;
}
template <int BITLEN, typename T>
static typename EnableIf<std::numeric_limits<T>::is_signed && ((sizeof(T) * 8) > BITLEN)>::Type
template <int BitLen, typename T>
static typename EnableIf<std::numeric_limits<T>::is_signed && ((sizeof(T) * 8) > BitLen)>::Type
fixTwosComplement(T& value)
{
StaticAssert<std::numeric_limits<T>::is_integer>::check(); // Not applicable to floating point types
if (value & (T(1) << (BITLEN - 1))) // The most significant bit is set --> negative
value |= 0xFFFFFFFFFFFFFFFF & ~((T(1) << BITLEN) - 1);
if (value & (T(1) << (BitLen - 1))) // The most significant bit is set --> negative
value |= 0xFFFFFFFFFFFFFFFF & ~((T(1) << BitLen) - 1);
}
template <int BITLEN, typename T>
static typename EnableIf<!std::numeric_limits<T>::is_signed || ((sizeof(T) * 8) == BITLEN)>::Type
template <int BitLen, typename T>
static typename EnableIf<!std::numeric_limits<T>::is_signed || ((sizeof(T) * 8) == BitLen)>::Type
fixTwosComplement(T& value)
{
(void)value;
}
template <int BITLEN, typename T>
static typename EnableIf<((sizeof(T) * 8) > BITLEN)>::Type
template <int BitLen, typename T>
static typename EnableIf<((sizeof(T) * 8) > BitLen)>::Type
clearExtraBits(T& value)
{
value &= (T(1) << BITLEN) - 1; // Signedness doesn't matter
value &= (T(1) << BitLen) - 1; // Signedness doesn't matter
}
template <int BITLEN, typename T>
static typename EnableIf<((sizeof(T) * 8) == BITLEN)>::Type
template <int BitLen, typename T>
static typename EnableIf<((sizeof(T) * 8) == BitLen)>::Type
clearExtraBits(T& value)
{
(void)value;
}
template <int BITLEN, typename T>
template <int BitLen, typename T>
void validate()
{
StaticAssert<((sizeof(T) * 8) >= BITLEN)>::check();
StaticAssert<(BITLEN <= BitStream::MAX_BITS_PER_RW)>::check();
StaticAssert<std::numeric_limits<T>::is_signed ? (BITLEN > 1) : 1>::check();
StaticAssert<((sizeof(T) * 8) >= BitLen)>::check();
StaticAssert<(BitLen <= BitStream::MaxBitsPerRW)>::check();
StaticAssert<std::numeric_limits<T>::is_signed ? (BitLen > 1) : 1>::check();
}
public:
@@ -101,10 +101,10 @@ public:
: stream_(stream)
{ }
template <int BITLEN, typename T>
template <int BitLen, typename T>
int encode(const T value)
{
validate<BITLEN, T>();
validate<BitLen, T>();
union ByteUnion
{
T value;
@@ -112,19 +112,19 @@ public:
} byte_union;
byte_union.value = value;
clearExtraBits<BITLEN>(byte_union.value);
convertByteOrder<BITLEN>(byte_union.bytes);
clearExtraBits<BitLen>(byte_union.value);
convertByteOrder<BitLen>(byte_union.bytes);
// Underlying stream class assumes that more significant bits have lower index, so we need to shift some.
byte_union.bytes[BITLEN / 8] <<= (8 - (BITLEN % 8)) & 7;
byte_union.bytes[BitLen / 8] <<= (8 - (BitLen % 8)) & 7;
return stream_.write(byte_union.bytes, BITLEN);
return stream_.write(byte_union.bytes, BitLen);
}
template <int BITLEN, typename T>
template <int BitLen, typename T>
int decode(T& value)
{
validate<BITLEN, T>();
validate<BitLen, T>();
union ByteUnion
{
T value;
@@ -132,14 +132,14 @@ public:
} byte_union;
std::fill(byte_union.bytes, byte_union.bytes + sizeof(T), 0);
const int read_res = stream_.read(byte_union.bytes, BITLEN);
const int read_res = stream_.read(byte_union.bytes, BitLen);
if (read_res <= 0)
return read_res;
byte_union.bytes[BITLEN / 8] >>= (8 - (BITLEN % 8)) & 7; // As in encode(), vice versa
byte_union.bytes[BitLen / 8] >>= (8 - (BitLen % 8)) & 7; // As in encode(), vice versa
convertByteOrder<BITLEN>(byte_union.bytes);
fixTwosComplement<BITLEN>(byte_union.value);
convertByteOrder<BitLen>(byte_union.bytes);
fixTwosComplement<BitLen>(byte_union.value);
value = byte_union.value;
return read_res;
libuavcan/include/uavcan/internal/transport/can_io.hpp
+7 -7
View File
@@ -29,14 +29,14 @@ struct CanRxFrame : public CanFrame
, iface_index(0)
{ }
std::string toString(StringRepresentation mode = STR_TIGHT) const;
std::string toString(StringRepresentation mode = StrTight) const;
};
class CanTxQueue : Noncopyable
{
public:
enum Qos { VOLATILE, PERSISTENT };
enum Qos { Volatile, Persistent };
struct Entry : public LinkedListNode<Entry> // Not required to be packed - fits the block in any case
{
@@ -49,7 +49,7 @@ public:
, frame(frame)
, qos(uint8_t(qos))
{
assert(qos == VOLATILE || qos == PERSISTENT);
assert(qos == Volatile || qos == Persistent);
IsDynamicallyAllocatable<Entry>::check();
}
@@ -116,13 +116,13 @@ public:
class CanIOManager : Noncopyable
{
public:
enum { MAX_IFACES = 3 };
enum { MaxIfaces = 3 };
private:
ICanDriver& driver_;
ISystemClock& sysclock_;
CanTxQueue tx_queues_[MAX_IFACES];
CanTxQueue tx_queues_[MaxIfaces];
// Noncopyable
CanIOManager(CanIOManager&);
@@ -138,9 +138,9 @@ public:
: driver_(driver)
, sysclock_(sysclock)
{
assert(driver.getNumIfaces() <= MAX_IFACES);
assert(driver.getNumIfaces() <= MaxIfaces);
// We can't initialize member array with non-default constructors in C++03
for (int i = 0; i < MAX_IFACES; i++)
for (int i = 0; i < MaxIfaces; i++)
{
tx_queues_[i].~CanTxQueue();
new (tx_queues_ + i) CanTxQueue(&allocator, &sysclock);
libuavcan/include/uavcan/internal/transport/crc.hpp
+3 -1
View File
@@ -16,10 +16,12 @@ namespace uavcan
*/
class Crc16
{
static const uint16_t TABLE[256];
static const uint16_t Table[256];
uint16_t value_;
public:
enum { NumBytes = 2 };
Crc16()
: value_(0x0000)
{ }
libuavcan/include/uavcan/internal/transport/dispatcher.hpp
+1 -1
View File
@@ -37,7 +37,7 @@ class Dispatcher : Noncopyable
};
public:
enum Mode { UNIQUE_LISTENER, MANY_LISTENERS };
enum Mode { UniqueListener, ManyListeners };
bool add(TransferListenerBase* listener, Mode mode);
void remove(TransferListenerBase* listener);
libuavcan/include/uavcan/internal/transport/outgoing_transfer_registry.hpp
+4 -4
View File
@@ -31,12 +31,12 @@ public:
, transfer_type_(transfer_type)
, destination_node_id_(destination_node_id)
{
assert((transfer_type == TRANSFER_TYPE_MESSAGE_BROADCAST) == destination_node_id.isBroadcast());
assert((transfer_type == TransferTypeMessageBroadcast) == destination_node_id.isBroadcast());
/* Service response transfers must use the same Transfer ID as matching service request transfer,
* so this registry is not applicable for service response transfers at all.
*/
assert(transfer_type != TRANSFER_TYPE_SERVICE_RESPONSE);
assert(transfer_type != TransferTypeServiceResponse);
}
bool operator==(const OutgoingTransferRegistryKey& rhs) const
@@ -59,7 +59,7 @@ public:
};
template <int NUM_STATIC_ENTRIES>
template <int NumStaticEntries>
class OutgoingTransferRegistry : public IOutgoingTransferRegistry, Noncopyable
{
#pragma pack(push, 1)
@@ -88,7 +88,7 @@ class OutgoingTransferRegistry : public IOutgoingTransferRegistry, Noncopyable
}
};
Map<OutgoingTransferRegistryKey, Value, NUM_STATIC_ENTRIES> map_;
Map<OutgoingTransferRegistryKey, Value, NumStaticEntries> map_;
public:
OutgoingTransferRegistry(IAllocator& allocator)
libuavcan/include/uavcan/internal/transport/transfer.hpp
+26 -26
View File
@@ -12,15 +12,15 @@
namespace uavcan
{
enum { MAX_TRANSFER_PAYLOAD_LEN = 439 }; ///< According to the standard
enum { MaxTransferPayloadLen = 439 }; ///< According to the standard
enum TransferType
{
TRANSFER_TYPE_SERVICE_RESPONSE = 0,
TRANSFER_TYPE_SERVICE_REQUEST = 1,
TRANSFER_TYPE_MESSAGE_BROADCAST = 2,
TRANSFER_TYPE_MESSAGE_UNICAST = 3,
NUM_TRANSFER_TYPES = 4
TransferTypeServiceResponse = 0,
TransferTypeServiceRequest = 1,
TransferTypeMessageBroadcast = 2,
TransferTypeMessageUnicast = 3,
NumTransferTypes = 4
};
@@ -28,18 +28,18 @@ class NodeID
{
enum
{
VALUE_BROADCAST = 0,
VALUE_INVALID = 0xFF
ValueBroadcast = 0,
ValueInvalid = 0xFF
};
uint8_t value_;
public:
enum { BITLEN = 7 };
enum { MAX = (1 << BITLEN) - 1 };
enum { BitLen = 7 };
enum { Max = (1 << BitLen) - 1 };
static const NodeID BROADCAST;
static const NodeID Broadcast;
NodeID() : value_(VALUE_INVALID) { }
NodeID() : value_(ValueInvalid) { }
NodeID(uint8_t value)
: value_(value)
@@ -49,9 +49,9 @@ public:
uint8_t get() const { return value_; }
bool isValid() const { return value_ <= MAX; }
bool isBroadcast() const { return value_ == VALUE_BROADCAST; }
bool isUnicast() const { return (value_ <= MAX) && (value_ != VALUE_BROADCAST); }
bool isValid() const { return value_ <= Max; }
bool isBroadcast() const { return value_ == ValueBroadcast; }
bool isUnicast() const { return (value_ <= Max) && (value_ != ValueBroadcast); }
bool operator!=(NodeID rhs) const { return !operator==(rhs); }
bool operator==(NodeID rhs) const { return value_ == rhs.value_; }
@@ -63,8 +63,8 @@ class TransferID
uint8_t value_;
public:
enum { BITLEN = 3 };
enum { MAX = (1 << BITLEN) - 1 };
enum { BitLen = 3 };
enum { Max = (1 << BitLen) - 1 };
TransferID()
: value_(0)
@@ -73,7 +73,7 @@ public:
TransferID(uint8_t value) // implicit
: value_(value)
{
value_ &= MAX;
value_ &= Max;
assert(value == value_);
}
@@ -82,12 +82,12 @@ public:
void increment()
{
value_ = (value_ + 1) & MAX;
value_ = (value_ + 1) & Max;
}
uint8_t get() const
{
assert(value_ <= MAX);
assert(value_ <= Max);
return value_;
}
@@ -111,11 +111,11 @@ class Frame
bool last_frame_;
public:
enum { DATA_TYPE_ID_MAX = 1023 };
enum { INDEX_MAX = 62 }; // 63 (or 0b111111) is reserved
enum { MaxDataTypeID = 1023 };
enum { MaxIndex = 62 }; // 63 (or 0b111111) is reserved
Frame()
: transfer_type_(TransferType(NUM_TRANSFER_TYPES)) // That is invalid value
: transfer_type_(TransferType(NumTransferTypes)) // That is invalid value
, data_type_id_(0)
, payload_len_(0)
, frame_index_(0)
@@ -134,10 +134,10 @@ public:
, transfer_id_(transfer_id)
, last_frame_(last_frame)
{
assert((transfer_type == TRANSFER_TYPE_MESSAGE_BROADCAST) == dst_node_id.isBroadcast());
assert(data_type_id <= DATA_TYPE_ID_MAX);
assert((transfer_type == TransferTypeMessageBroadcast) == dst_node_id.isBroadcast());
assert(data_type_id <= MaxDataTypeID);
assert(src_node_id != dst_node_id);
assert(frame_index <= INDEX_MAX);
assert(frame_index <= MaxIndex);
}
int getMaxPayloadLen() const;
libuavcan/include/uavcan/internal/transport/transfer_buffer.hpp
+26 -26
View File
@@ -99,8 +99,8 @@ class DynamicTransferBufferManagerEntry : public TransferBufferManagerEntry,
{
struct Block : LinkedListNode<Block>
{
enum { SIZE = MEM_POOL_BLOCK_SIZE - sizeof(LinkedListNode<Block>) };
uint8_t data[SIZE];
enum { Size = MemPoolBlockSize - sizeof(LinkedListNode<Block>) };
uint8_t data[Size];
static Block* instantiate(IAllocator& allocator);
static void destroy(Block*& obj, IAllocator& allocator);
@@ -124,7 +124,7 @@ public:
, max_write_pos_(0)
, max_size_(max_size)
{
StaticAssert<(Block::SIZE > 8)>::check();
StaticAssert<(Block::Size > 8)>::check();
IsDynamicallyAllocatable<Block>::check();
IsDynamicallyAllocatable<DynamicTransferBufferManagerEntry>::check();
}
@@ -145,18 +145,18 @@ public:
/**
* Standalone static buffer
*/
template <unsigned int SIZE>
template <unsigned int Size>
class StaticTransferBuffer : public ITransferBuffer
{
uint8_t data_[SIZE];
uint8_t data_[Size];
unsigned int max_write_pos_;
public:
StaticTransferBuffer()
: max_write_pos_(0)
{
StaticAssert<(SIZE > 0)>::check();
std::fill(data_, data_ + SIZE, 0);
StaticAssert<(Size > 0)>::check();
std::fill(data_, data_ + Size, 0);
}
int read(unsigned int offset, uint8_t* data, unsigned int len) const
@@ -182,11 +182,11 @@ public:
assert(0);
return -1;
}
if (offset >= SIZE)
if (offset >= Size)
return 0;
if ((offset + len) > SIZE)
len = SIZE - offset;
assert((offset + len) <= SIZE);
if ((offset + len) > Size)
len = Size - offset;
assert((offset + len) <= Size);
std::copy(data, data + len, data_ + offset);
max_write_pos_ = std::max(offset + len, max_write_pos_);
return len;
@@ -196,7 +196,7 @@ public:
{
max_write_pos_ = 0;
#if UAVCAN_DEBUG
std::fill(data_, data_ + SIZE, 0);
std::fill(data_, data_ + Size, 0);
#endif
}
@@ -207,10 +207,10 @@ public:
/**
* Statically allocated storage for buffer manager
*/
template <unsigned int SIZE>
template <unsigned int Size>
class StaticTransferBufferManagerEntry : public TransferBufferManagerEntry
{
StaticTransferBuffer<SIZE> buf_;
StaticTransferBuffer<Size> buf_;
void resetImpl()
{
@@ -238,19 +238,19 @@ public:
// Resetting self and moving all data from the source
TransferBufferManagerEntry::reset(tbme->getKey());
const int res = tbme->read(0, buf_.getRawPtr(), SIZE);
const int res = tbme->read(0, buf_.getRawPtr(), Size);
if (res < 0)
{
TransferBufferManagerEntry::reset();
return false;
}
buf_.setMaxWritePos(res);
if (res < int(SIZE))
if (res < int(Size))
return true;
// Now we need to make sure that all data can fit the storage
uint8_t dummy = 0;
if (tbme->read(SIZE, &dummy, 1) > 0)
if (tbme->read(Size, &dummy, 1) > 0)
{
TransferBufferManagerEntry::reset(); // Damn, the buffer was too large
return false;
@@ -294,18 +294,18 @@ public:
/**
* Buffer manager implementation.
*/
template <unsigned int MAX_BUF_SIZE, unsigned int NUM_STATIC_BUFS>
template <unsigned int MaxBufSize, unsigned int NumStaticBufs>
class TransferBufferManager : public ITransferBufferManager, Noncopyable
{
typedef StaticTransferBufferManagerEntry<MAX_BUF_SIZE> StaticBufferType;
typedef StaticTransferBufferManagerEntry<MaxBufSize> StaticBufferType;
StaticBufferType static_buffers_[NUM_STATIC_BUFS];
StaticBufferType static_buffers_[NumStaticBufs];
LinkedListRoot<DynamicTransferBufferManagerEntry> dynamic_buffers_;
IAllocator& allocator_;
StaticBufferType* findFirstStatic(const TransferBufferManagerKey& key)
{
for (unsigned int i = 0; i < NUM_STATIC_BUFS; i++)
for (unsigned int i = 0; i < NumStaticBufs; i++)
{
if (static_buffers_[i].getKey() == key)
return static_buffers_ + i;
@@ -350,7 +350,7 @@ class TransferBufferManager : public ITransferBufferManager, Noncopyable
* This should never happen during normal operation because dynamic buffers are limited in growth.
*/
UAVCAN_TRACE("TransferBufferManager", "Storage optimization: MIGRATION FAILURE %s MAXSIZE %u",
dyn->getKey().toString().c_str(), MAX_BUF_SIZE);
dyn->getKey().toString().c_str(), MaxBufSize);
assert(0);
sb->reset();
break;
@@ -362,8 +362,8 @@ public:
TransferBufferManager(IAllocator& allocator)
: allocator_(allocator)
{
StaticAssert<(MAX_BUF_SIZE > 0)>::check();
StaticAssert<(NUM_STATIC_BUFS > 0)>::check();
StaticAssert<(MaxBufSize > 0)>::check();
StaticAssert<(NumStaticBufs > 0)>::check();
}
~TransferBufferManager()
@@ -403,7 +403,7 @@ public:
TransferBufferManagerEntry* tbme = findFirstStatic(TransferBufferManagerKey());
if (tbme == NULL)
{
DynamicTransferBufferManagerEntry* dyn = DynamicTransferBufferManagerEntry::instantiate(allocator_, MAX_BUF_SIZE);
DynamicTransferBufferManagerEntry* dyn = DynamicTransferBufferManagerEntry::instantiate(allocator_, MaxBufSize);
tbme = dyn;
if (dyn == NULL)
return NULL; // Epic fail.
@@ -454,7 +454,7 @@ public:
unsigned int getNumStaticBuffers() const
{
unsigned int res = 0;
for (unsigned int i = 0; i < NUM_STATIC_BUFS; i++)
for (unsigned int i = 0; i < NumStaticBufs; i++)
{
if (!static_buffers_[i].isEmpty())
res++;
libuavcan/include/uavcan/internal/transport/transfer_listener.hpp
+5 -5
View File
@@ -95,7 +95,7 @@ class TransferListenerBase : public LinkedListNode<TransferListenerBase>
protected:
TransferListenerBase(const DataTypeDescriptor& data_type)
: data_type_(data_type)
, crc_base_(data_type.hash.value, DataTypeHash::NUM_BYTES)
, crc_base_(data_type.hash.value, DataTypeHash::NumBytes)
{ }
virtual ~TransferListenerBase() { }
@@ -114,12 +114,12 @@ public:
/**
* This class should be derived by transfer receivers (subscribers, servers, callers).
*/
template <unsigned int MAX_BUF_SIZE, unsigned int NUM_STATIC_BUFS, unsigned int NUM_STATIC_RECEIVERS>
template <unsigned int MaxBufSize, unsigned int NumStaticBufs, unsigned int NumStaticReceivers>
class TransferListener : public TransferListenerBase, Noncopyable
{
typedef TransferBufferManager<MAX_BUF_SIZE, NUM_STATIC_BUFS> BufferManager;
typedef TransferBufferManager<MaxBufSize, NumStaticBufs> BufferManager;
BufferManager bufmgr_;
Map<TransferBufferManagerKey, TransferReceiver, NUM_STATIC_RECEIVERS> receivers_;
Map<TransferBufferManagerKey, TransferReceiver, NumStaticReceivers> receivers_;
void handleFrame(const RxFrame& frame)
{
@@ -185,7 +185,7 @@ public:
, bufmgr_(allocator)
, receivers_(allocator)
{
StaticAssert<(NUM_STATIC_RECEIVERS >= NUM_STATIC_BUFS)>::check(); // Otherwise it would be meaningless
StaticAssert<(NumStaticReceivers >= NumStaticBufs)>::check(); // Otherwise it would be meaningless
}
~TransferListener()
libuavcan/include/uavcan/internal/transport/transfer_receiver.hpp
+9 -9
View File
@@ -15,15 +15,15 @@ namespace uavcan
class TransferReceiver
{
public:
enum ResultCode { RESULT_NOT_COMPLETE, RESULT_COMPLETE, RESULT_SINGLE_FRAME };
enum ResultCode { ResultNotComplete, ResultComplete, ResultSingleFrame };
static const uint32_t DEFAULT_TRANSFER_INTERVAL = 500 * 1000UL;
static const uint32_t MIN_TRANSFER_INTERVAL = 1 * 1000UL;
static const uint32_t MAX_TRANSFER_INTERVAL = 10 * 1000 * 1000UL;
static const uint32_t DefaultTransferInterval = 500 * 1000UL;
static const uint32_t MinTransferInterval = 1 * 1000UL;
static const uint32_t MaxTransferInterval = 10 * 1000 * 1000UL;
private:
enum TidRelation { TID_SAME, TID_REPEAT, TID_FUTURE };
enum { IFACE_INDEX_NOTSET = 0xFF };
enum TidRelation { TidSame, TidRepeat, TidFuture };
enum { IfaceIndexNotSet = 0xFF };
uint64_t prev_transfer_ts_monotonic_;
uint64_t this_transfer_ts_monotonic_;
@@ -35,7 +35,7 @@ private:
uint8_t iface_index_;
uint8_t next_frame_index_;
bool isInitialized() const { return iface_index_ != IFACE_INDEX_NOTSET; }
bool isInitialized() const { return iface_index_ != IfaceIndexNotSet; }
TidRelation getTidRelation(const RxFrame& frame) const;
@@ -51,10 +51,10 @@ public:
: prev_transfer_ts_monotonic_(0)
, this_transfer_ts_monotonic_(0)
, first_frame_ts_utc_(0)
, transfer_interval_(DEFAULT_TRANSFER_INTERVAL)
, transfer_interval_(DefaultTransferInterval)
, this_transfer_crc_(0)
, buffer_write_pos_(0)
, iface_index_(IFACE_INDEX_NOTSET)
, iface_index_(IfaceIndexNotSet)
, next_frame_index_(0)
{ }
libuavcan/include/uavcan/internal/transport/transfer_sender.hpp
+3 -3
View File
@@ -16,7 +16,7 @@ namespace uavcan
class TransferSender
{
static const uint64_t DEFAULT_MAX_TRANSFER_INTERVAL = 60 * 1000 * 1000;
static const uint64_t DefaultMaxTransferInterval = 60 * 1000 * 1000;
const uint64_t max_transfer_interval_;
const DataTypeDescriptor& data_type_;
@@ -27,11 +27,11 @@ class TransferSender
public:
TransferSender(Dispatcher& dispatcher, const DataTypeDescriptor& data_type, CanTxQueue::Qos qos,
uint64_t max_transfer_interval = DEFAULT_MAX_TRANSFER_INTERVAL)
uint64_t max_transfer_interval = DefaultMaxTransferInterval)
: max_transfer_interval_(max_transfer_interval)
, data_type_(data_type)
, qos_(qos)
, crc_base_(data_type.hash.value, DataTypeHash::NUM_BYTES)
, crc_base_(data_type.hash.value, DataTypeHash::NumBytes)
, dispatcher_(dispatcher)
{ }
libuavcan/include/uavcan/internal/util.hpp
+2 -2
View File
@@ -12,7 +12,7 @@ namespace uavcan
* Usage:
* StaticAssert<expression>::check();
*/
template <bool VALUE>
template <bool Value>
struct StaticAssert;
template <>
@@ -44,7 +44,7 @@ template<typename T>
struct EnableIf<true, T> { typedef T Type; };
template <bool COND, typename TrueType, typename FalseType>
template <bool Condition, typename TrueType, typename FalseType>
struct StaticIf;
template <typename TrueType, typename FalseType>
libuavcan/src/can_driver.cpp
+11 -11
View File
@@ -10,17 +10,17 @@
namespace uavcan
{
const uint32_t CanFrame::MASK_STDID;
const uint32_t CanFrame::MASK_EXTID;
const uint32_t CanFrame::FLAG_EFF;
const uint32_t CanFrame::FLAG_RTR;
const uint32_t CanFrame::MaskStdID;
const uint32_t CanFrame::MaskExtID;
const uint32_t CanFrame::FlagEFF;
const uint32_t CanFrame::FlagRTR;
std::string CanFrame::toString(StringRepresentation mode) const
{
using std::snprintf;
assert(mode == STR_TIGHT || mode == STR_ALIGNED);
assert(mode == StrTight || mode == StrAligned);
static const int ASCII_COLUMN_OFFSET = 36;
@@ -28,17 +28,17 @@ std::string CanFrame::toString(StringRepresentation mode) const
char* wpos = buf, *epos = buf + sizeof(buf);
std::fill(buf, buf + sizeof(buf), 0);
if (id & FLAG_EFF)
if (id & FlagEFF)
{
wpos += snprintf(wpos, epos - wpos, "0x%08x ", (unsigned int)(id & MASK_EXTID));
wpos += snprintf(wpos, epos - wpos, "0x%08x ", (unsigned int)(id & MaskExtID));
}
else
{
const char* const fmt = (mode == STR_ALIGNED) ? " 0x%03x " : "0x%03x ";
wpos += snprintf(wpos, epos - wpos, fmt, (unsigned int)(id & MASK_STDID));
const char* const fmt = (mode == StrAligned) ? " 0x%03x " : "0x%03x ";
wpos += snprintf(wpos, epos - wpos, fmt, (unsigned int)(id & MaskStdID));
}
if (id & FLAG_RTR)
if (id & FlagRTR)
{
wpos += snprintf(wpos, epos - wpos, " RTR");
}
@@ -47,7 +47,7 @@ std::string CanFrame::toString(StringRepresentation mode) const
for (int dlen = 0; dlen < dlc; dlen++) // hex bytes
wpos += snprintf(wpos, epos - wpos, " %02x", (unsigned int)data[dlen]);
while (mode == STR_ALIGNED && wpos < buf + ASCII_COLUMN_OFFSET) // alignment
while (mode == StrAligned && wpos < buf + ASCII_COLUMN_OFFSET) // alignment
*wpos++ = ' ';
wpos += snprintf(wpos, epos - wpos, " \'"); // ascii
libuavcan/src/marshalling/bit_stream.cpp
+8 -8
View File
@@ -12,11 +12,11 @@ namespace uavcan
int BitStream::write(const uint8_t* bytes, const int bitlen)
{
// Temporary buffer is needed to merge new bits with cached unaligned bits from the last write() (see byte_cache_)
uint8_t tmp[MAX_BYTES_PER_RW + 1];
uint8_t tmp[MaxBytesPerRW + 1];
// Tmp space must be large enough to accomodate new bits AND unaligned bits from the last write()
const int bytelen = bitlenToBytelen(bitlen + (bit_offset_ % 8));
assert(MAX_BYTES_PER_RW >= bytelen);
assert(MaxBytesPerRW >= bytelen);
tmp[0] = tmp[bytelen - 1] = 0;
std::fill(tmp, tmp + bytelen, 0);
@@ -39,29 +39,29 @@ int BitStream::write(const uint8_t* bytes, const int bitlen)
if (write_res < 0)
return write_res;
if (write_res < bytelen)
return RESULT_OUT_OF_BUFFER;
return ResultOutOfBuffer;
bit_offset_ = new_bit_offset;
return RESULT_OK;
return ResultOk;
}
int BitStream::read(uint8_t* bytes, const int bitlen)
{
uint8_t tmp[MAX_BYTES_PER_RW + 1];
uint8_t tmp[MaxBytesPerRW + 1];
const int bytelen = bitlenToBytelen(bitlen + (bit_offset_ % 8));
assert(MAX_BYTES_PER_RW >= bytelen);
assert(MaxBytesPerRW >= bytelen);
const int read_res = buf_.read(bit_offset_ / 8, tmp, bytelen);
if (read_res < 0)
return read_res;
if (read_res < bytelen)
return RESULT_OUT_OF_BUFFER;
return ResultOutOfBuffer;
std::fill(bytes, bytes + bitlenToBytelen(bitlen), 0);
copyBitArray(tmp, bit_offset_ % 8, bitlen, bytes, 0);
bit_offset_ += bitlen;
return RESULT_OK;
return ResultOk;
}
std::string BitStream::toString() const
libuavcan/src/transport/can_io.cpp
+7 -7
View File
@@ -55,10 +55,10 @@ std::string CanTxQueue::Entry::toString() const
std::string str_qos;
switch (qos)
{
case VOLATILE:
case Volatile:
str_qos = "<volat> ";
break;
case PERSISTENT:
case Persistent:
str_qos = "<perst> ";
break;
default:
@@ -196,7 +196,7 @@ bool CanTxQueue::topPriorityHigherOrEqual(const CanFrame& rhs_frame) const
*/
int CanIOManager::sendToIface(int iface_index, const CanFrame& frame, uint64_t monotonic_tx_deadline)
{
assert(iface_index >= 0 && iface_index < MAX_IFACES);
assert(iface_index >= 0 && iface_index < MaxIfaces);
ICanIface* const iface = driver_.getIface(iface_index);
if (iface == NULL)
{
@@ -216,7 +216,7 @@ int CanIOManager::sendToIface(int iface_index, const CanFrame& frame, uint64_t m
int CanIOManager::sendFromTxQueue(int iface_index)
{
assert(iface_index >= 0 && iface_index < MAX_IFACES);
assert(iface_index >= 0 && iface_index < MaxIfaces);
CanTxQueue::Entry* entry = tx_queues_[iface_index].peek();
if (entry == NULL)
return 0;
@@ -246,14 +246,14 @@ uint64_t CanIOManager::getTimeUntilMonotonicDeadline(uint64_t monotonic_deadline
int CanIOManager::getNumIfaces() const
{
const int num = driver_.getNumIfaces();
assert(num > 0 && num <= MAX_IFACES);
return std::min(std::max(num, 0), (int)MAX_IFACES);
assert(num > 0 && num <= MaxIfaces);
return std::min(std::max(num, 0), (int)MaxIfaces);
}
uint64_t CanIOManager::getNumErrors(int iface_index) const
{
ICanIface* const iface = driver_.getIface(iface_index);
if (iface == NULL || iface_index >= MAX_IFACES || iface_index < 0)
if (iface == NULL || iface_index >= MaxIfaces || iface_index < 0)
{
assert(0);
return std::numeric_limits<uint64_t>::max();
libuavcan/src/transport/crc.cpp
+2 -2
View File
@@ -9,7 +9,7 @@ namespace uavcan
{
// print ', '.join(map(lambda x: '%04x' % x, map(lambda x: int(x, 0), c.crc_ccitt_tab)))
const uint16_t Crc16::TABLE[256] =
const uint16_t Crc16::Table[256] =
{
0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
@@ -47,7 +47,7 @@ const uint16_t Crc16::TABLE[256] =
uint16_t Crc16::add(uint8_t byte)
{
value_ = (value_ << 8) ^ TABLE[((value_ >> 8) ^ byte) & 0xFF];
value_ = (value_ << 8) ^ Table[((value_ >> 8) ^ byte) & 0xFF];
return value_;
}
libuavcan/src/transport/dispatcher.cpp
+12 -12
View File
@@ -13,7 +13,7 @@ namespace uavcan
*/
bool Dispatcher::ListenerRegister::add(TransferListenerBase* listener, Mode mode)
{
if (mode == UNIQUE_LISTENER)
if (mode == UniqueListener)
{
TransferListenerBase* p = list_.get();
while (p)
@@ -68,7 +68,7 @@ void Dispatcher::handleFrame(const CanRxFrame& can_frame)
return;
}
if ((frame.getDstNodeID() != NodeID::BROADCAST) &&
if ((frame.getDstNodeID() != NodeID::Broadcast) &&
(frame.getDstNodeID() != getSelfNodeID()))
{
return;
@@ -76,16 +76,16 @@ void Dispatcher::handleFrame(const CanRxFrame& can_frame)
switch (frame.getTransferType())
{
case TRANSFER_TYPE_MESSAGE_BROADCAST:
case TRANSFER_TYPE_MESSAGE_UNICAST:
case TransferTypeMessageBroadcast:
case TransferTypeMessageUnicast:
lmsg_.handleFrame(frame);
break;
case TRANSFER_TYPE_SERVICE_REQUEST:
case TransferTypeServiceRequest:
lsrv_req_.handleFrame(frame);
break;
case TRANSFER_TYPE_SERVICE_RESPONSE:
case TransferTypeServiceResponse:
lsrv_resp_.handleFrame(frame);
break;
@@ -145,32 +145,32 @@ void Dispatcher::cleanup(uint64_t ts_monotonic)
bool Dispatcher::registerMessageListener(TransferListenerBase* listener)
{
if (listener->getDataTypeDescriptor().kind != DATA_TYPE_KIND_MESSAGE)
if (listener->getDataTypeDescriptor().kind != DataTypeKindMessage)
{
assert(0);
return false;
}
return lmsg_.add(listener, ListenerRegister::MANY_LISTENERS); // Multiple subscribers are OK
return lmsg_.add(listener, ListenerRegister::ManyListeners); // Multiple subscribers are OK
}
bool Dispatcher::registerServiceRequestListener(TransferListenerBase* listener)
{
if (listener->getDataTypeDescriptor().kind != DATA_TYPE_KIND_SERVICE)
if (listener->getDataTypeDescriptor().kind != DataTypeKindService)
{
assert(0);
return false;
}
return lsrv_req_.add(listener, ListenerRegister::UNIQUE_LISTENER); // Only one server per data type
return lsrv_req_.add(listener, ListenerRegister::UniqueListener); // Only one server per data type
}
bool Dispatcher::registerServiceResponseListener(TransferListenerBase* listener)
{
if (listener->getDataTypeDescriptor().kind != DATA_TYPE_KIND_SERVICE)
if (listener->getDataTypeDescriptor().kind != DataTypeKindService)
{
assert(0);
return false;
}
return lsrv_resp_.add(listener, ListenerRegister::MANY_LISTENERS); // Multiple callers may call same srv
return lsrv_resp_.add(listener, ListenerRegister::ManyListeners); // Multiple callers may call same srv
}
void Dispatcher::unregisterMessageListener(TransferListenerBase* listener)
libuavcan/src/transport/transfer.cpp
+24 -24
View File
@@ -12,7 +12,7 @@ namespace uavcan
/**
* NodeID
*/
const NodeID NodeID::BROADCAST(VALUE_BROADCAST);
const NodeID NodeID::Broadcast(ValueBroadcast);
/**
* TransferID
@@ -21,9 +21,9 @@ int TransferID::forwardDistance(TransferID rhs) const
{
int d = int(rhs.get()) - int(get());
if (d < 0)
d += 1 << BITLEN;
d += 1 << BitLen;
assert(((get() + d) & MAX) == rhs.get());
assert(((get() + d) & Max) == rhs.get());
return d;
}
@@ -34,13 +34,13 @@ int Frame::getMaxPayloadLen() const
{
switch (getTransferType())
{
case TRANSFER_TYPE_MESSAGE_BROADCAST:
case TransferTypeMessageBroadcast:
return sizeof(payload_);
break;
case TRANSFER_TYPE_SERVICE_RESPONSE:
case TRANSFER_TYPE_SERVICE_REQUEST:
case TRANSFER_TYPE_MESSAGE_UNICAST:
case TransferTypeServiceResponse:
case TransferTypeServiceRequest:
case TransferTypeMessageUnicast:
return sizeof(payload_) - 1;
break;
@@ -69,7 +69,7 @@ inline static uint32_t bitunpack(uint32_t val)
bool Frame::parse(const CanFrame& can_frame)
{
if ((can_frame.id & CanFrame::FLAG_RTR) || !(can_frame.id & CanFrame::FLAG_EFF))
if ((can_frame.id & CanFrame::FlagRTR) || !(can_frame.id & CanFrame::FlagEFF))
return false;
if (can_frame.dlc > sizeof(CanFrame::data))
@@ -81,7 +81,7 @@ bool Frame::parse(const CanFrame& can_frame)
/*
* CAN ID parsing
*/
const uint32_t id = can_frame.id & CanFrame::MASK_EXTID;
const uint32_t id = can_frame.id & CanFrame::MaskExtID;
transfer_id_ = bitunpack<0, 3>(id);
last_frame_ = bitunpack<3, 1>(id);
frame_index_ = bitunpack<4, 6>(id);
@@ -94,15 +94,15 @@ bool Frame::parse(const CanFrame& can_frame)
*/
switch (transfer_type_)
{
case TRANSFER_TYPE_MESSAGE_BROADCAST:
dst_node_id_ = NodeID::BROADCAST;
case TransferTypeMessageBroadcast:
dst_node_id_ = NodeID::Broadcast;
payload_len_ = can_frame.dlc;
std::copy(can_frame.data, can_frame.data + can_frame.dlc, payload_);
break;
case TRANSFER_TYPE_SERVICE_RESPONSE:
case TRANSFER_TYPE_SERVICE_REQUEST:
case TRANSFER_TYPE_MESSAGE_UNICAST:
case TransferTypeServiceResponse:
case TransferTypeServiceRequest:
case TransferTypeMessageUnicast:
if (can_frame.dlc < 1)
return false;
if (can_frame.data[0] & 0x80) // RESERVED, must be zero
@@ -133,7 +133,7 @@ bool Frame::compile(CanFrame& out_can_frame) const
return false;
}
out_can_frame.id = CanFrame::FLAG_EFF |
out_can_frame.id = CanFrame::FlagEFF |
bitpack<0, 3>(transfer_id_.get()) |
bitpack<3, 1>(last_frame_) |
bitpack<4, 6>(frame_index_) |
@@ -143,14 +143,14 @@ bool Frame::compile(CanFrame& out_can_frame) const
switch (transfer_type_)
{
case TRANSFER_TYPE_MESSAGE_BROADCAST:
case TransferTypeMessageBroadcast:
out_can_frame.dlc = payload_len_;
std::copy(payload_, payload_ + payload_len_, out_can_frame.data);
break;
case TRANSFER_TYPE_SERVICE_RESPONSE:
case TRANSFER_TYPE_SERVICE_REQUEST:
case TRANSFER_TYPE_MESSAGE_UNICAST:
case TransferTypeServiceResponse:
case TransferTypeServiceRequest:
case TransferTypeMessageUnicast:
assert((payload_len_ + 1) <= sizeof(CanFrame::data));
out_can_frame.data[0] = dst_node_id_.get();
out_can_frame.dlc = payload_len_ + 1;
@@ -168,15 +168,15 @@ bool Frame::isValid() const
{
// Refer to the specification for the detailed explanation of the checks
const bool invalid =
(frame_index_ > INDEX_MAX) ||
((frame_index_ == INDEX_MAX) && !last_frame_) ||
(frame_index_ > MaxIndex) ||
((frame_index_ == MaxIndex) && !last_frame_) ||
(!src_node_id_.isUnicast()) ||
(!dst_node_id_.isValid()) ||
(src_node_id_ == dst_node_id_) ||
((transfer_type_ == TRANSFER_TYPE_MESSAGE_BROADCAST) != dst_node_id_.isBroadcast()) ||
(transfer_type_ >= NUM_TRANSFER_TYPES) ||
((transfer_type_ == TransferTypeMessageBroadcast) != dst_node_id_.isBroadcast()) ||
(transfer_type_ >= NumTransferTypes) ||
(payload_len_ > getMaxPayloadLen()) ||
(data_type_id_ > DATA_TYPE_ID_MAX);
(data_type_id_ > MaxDataTypeID);
return !invalid;
}
libuavcan/src/transport/transfer_buffer.cpp
+2 -2
View File
@@ -45,7 +45,7 @@ void DynamicTransferBufferManagerEntry::Block::read(uint8_t*& outptr, unsigned i
unsigned int& total_offset, unsigned int& left_to_read)
{
assert(outptr);
for (int i = 0; (i < Block::SIZE) && (left_to_read > 0); i++, total_offset++)
for (int i = 0; (i < Block::Size) && (left_to_read > 0); i++, total_offset++)
{
if (total_offset >= target_offset)
{
@@ -59,7 +59,7 @@ void DynamicTransferBufferManagerEntry::Block::write(const uint8_t*& inptr, unsi
unsigned int& total_offset, unsigned int& left_to_write)
{
assert(inptr);
for (int i = 0; (i < Block::SIZE) && (left_to_write > 0); i++, total_offset++)
for (int i = 0; (i < Block::Size) && (left_to_write > 0); i++, total_offset++)
{
if (total_offset >= target_offset)
{
libuavcan/src/transport/transfer_listener.cpp
+3 -3
View File
@@ -97,17 +97,17 @@ void TransferListenerBase::handleReception(TransferReceiver& receiver, const RxF
{
switch (receiver.addFrame(frame, tba))
{
case TransferReceiver::RESULT_NOT_COMPLETE:
case TransferReceiver::ResultNotComplete:
return;
case TransferReceiver::RESULT_SINGLE_FRAME:
case TransferReceiver::ResultSingleFrame:
{
SingleFrameIncomingTransfer it(frame);
handleIncomingTransfer(it);
return;
}
case TransferReceiver::RESULT_COMPLETE:
case TransferReceiver::ResultComplete:
{
const ITransferBuffer* tbb = tba.access();
if (tbb == NULL)
libuavcan/src/transport/transfer_receiver.cpp
+26 -27
View File
@@ -8,24 +8,23 @@
#include <algorithm>
#include <uavcan/internal/debug.hpp>
#include <uavcan/internal/transport/transfer_receiver.hpp>
#include <uavcan/internal/transport/crc.hpp>
namespace uavcan
{
static const int CRC_LEN = 2;
const uint32_t TransferReceiver::DEFAULT_TRANSFER_INTERVAL;
const uint32_t TransferReceiver::MIN_TRANSFER_INTERVAL;
const uint32_t TransferReceiver::MAX_TRANSFER_INTERVAL;
const uint32_t TransferReceiver::DefaultTransferInterval;
const uint32_t TransferReceiver::MinTransferInterval;
const uint32_t TransferReceiver::MaxTransferInterval;
TransferReceiver::TidRelation TransferReceiver::getTidRelation(const RxFrame& frame) const
{
const int distance = tid_.forwardDistance(frame.getTransferID());
if (distance == 0)
return TID_SAME;
if (distance < ((1 << TransferID::BITLEN) / 2))
return TID_FUTURE;
return TID_REPEAT;
return TidSame;
if (distance < ((1 << TransferID::BitLen) / 2))
return TidFuture;
return TidRepeat;
}
void TransferReceiver::updateTransferTimings()
@@ -40,7 +39,7 @@ void TransferReceiver::updateTransferTimings()
(prev_transfer_ts_monotonic_ >= prev_prev_ts))
{
uint64_t interval = prev_transfer_ts_monotonic_ - prev_prev_ts;
interval = std::max(std::min(interval, uint64_t(MAX_TRANSFER_INTERVAL)), uint64_t(MIN_TRANSFER_INTERVAL));
interval = std::max(std::min(interval, uint64_t(MaxTransferInterval)), uint64_t(MinTransferInterval));
transfer_interval_ = static_cast<uint32_t>((uint64_t(transfer_interval_) * 7 + interval) / 8);
}
}
@@ -57,13 +56,13 @@ bool TransferReceiver::validate(const RxFrame& frame) const
if (iface_index_ != frame.getIfaceIndex())
return false;
if (frame.isFirst() && !frame.isLast() && (frame.getPayloadLen() < CRC_LEN))
if (frame.isFirst() && !frame.isLast() && (frame.getPayloadLen() < Crc16::NumBytes))
{
UAVCAN_TRACE("TransferReceiver", "CRC expected, %s", frame.toString().c_str());
return false;
}
if ((frame.getIndex() == Frame::INDEX_MAX) && !frame.isLast())
if ((frame.getIndex() == Frame::MaxIndex) && !frame.isLast())
{
UAVCAN_TRACE("TransferReceiver", "Unterminated transfer, %s", frame.toString().c_str());
return false;
@@ -76,7 +75,7 @@ bool TransferReceiver::validate(const RxFrame& frame) const
return false;
}
if (getTidRelation(frame) != TID_SAME)
if (getTidRelation(frame) != TidSame)
{
UAVCAN_TRACE("TransferReceiver", "Unexpected TID (current %i), %s", tid_.get(), frame.toString().c_str());
return false;
@@ -91,13 +90,13 @@ bool TransferReceiver::writePayload(const RxFrame& frame, ITransferBuffer& buf)
if (frame.isFirst()) // First frame contains CRC, we need to extract it now
{
if (frame.getPayloadLen() < CRC_LEN) // Must have been validated earlier though. I think I'm paranoid.
if (frame.getPayloadLen() < Crc16::NumBytes) // Must have been validated earlier though. I think I'm paranoid.
return false;
this_transfer_crc_ = (payload[0] & 0xFF) | (uint16_t(payload[1] & 0xFF) << 8); // Little endian.
const int effective_payload_len = payload_len - CRC_LEN;
const int res = buf.write(buffer_write_pos_, payload + CRC_LEN, effective_payload_len);
const int effective_payload_len = payload_len - Crc16::NumBytes;
const int res = buf.write(buffer_write_pos_, payload + Crc16::NumBytes, effective_payload_len);
const bool success = res == effective_payload_len;
if (success)
buffer_write_pos_ += effective_payload_len;
@@ -128,7 +127,7 @@ TransferReceiver::ResultCode TransferReceiver::receive(const RxFrame& frame, Tra
updateTransferTimings();
prepareForNextTransfer();
this_transfer_crc_ = 0; // SFT has no CRC
return RESULT_SINGLE_FRAME;
return ResultSingleFrame;
}
// Payload write
@@ -139,14 +138,14 @@ TransferReceiver::ResultCode TransferReceiver::receive(const RxFrame& frame, Tra
{
UAVCAN_TRACE("TransferReceiver", "Failed to access the buffer, %s", frame.toString().c_str());
prepareForNextTransfer();
return RESULT_NOT_COMPLETE;
return ResultNotComplete;
}
if (!writePayload(frame, *buf))
{
UAVCAN_TRACE("TransferReceiver", "Payload write failed, %s", frame.toString().c_str());
tba.remove();
prepareForNextTransfer();
return RESULT_NOT_COMPLETE;
return ResultNotComplete;
}
next_frame_index_++;
@@ -154,14 +153,14 @@ TransferReceiver::ResultCode TransferReceiver::receive(const RxFrame& frame, Tra
{
updateTransferTimings();
prepareForNextTransfer();
return RESULT_COMPLETE;
return ResultComplete;
}
return RESULT_NOT_COMPLETE;
return ResultNotComplete;
}
bool TransferReceiver::isTimedOut(uint64_t ts_monotonic) const
{
static const uint64_t INTERVAL_MULT = (1 << TransferID::BITLEN) / 2 + 1;
static const uint64_t INTERVAL_MULT = (1 << TransferID::BitLen) / 2 + 1;
const uint64_t ts = this_transfer_ts_monotonic_;
if (ts_monotonic <= ts)
return false;
@@ -174,7 +173,7 @@ TransferReceiver::ResultCode TransferReceiver::addFrame(const RxFrame& frame, Tr
(frame.getMonotonicTimestamp() < prev_transfer_ts_monotonic_) ||
(frame.getMonotonicTimestamp() < this_transfer_ts_monotonic_))
{
return RESULT_NOT_COMPLETE;
return ResultNotComplete;
}
const bool not_initialized = !isInitialized();
@@ -188,8 +187,8 @@ TransferReceiver::ResultCode TransferReceiver::addFrame(const RxFrame& frame, Tr
const bool need_restart = // FSM, the hard way
(not_initialized) ||
(receiver_timed_out) ||
(same_iface && first_fame && (tid_rel == TID_FUTURE)) ||
(iface_timed_out && first_fame && (tid_rel == TID_FUTURE));
(same_iface && first_fame && (tid_rel == TidFuture)) ||
(iface_timed_out && first_fame && (tid_rel == TidFuture));
if (need_restart)
{
@@ -206,12 +205,12 @@ TransferReceiver::ResultCode TransferReceiver::addFrame(const RxFrame& frame, Tr
if (!first_fame)
{
tid_.increment();
return RESULT_NOT_COMPLETE;
return ResultNotComplete;
}
}
if (!validate(frame))
return RESULT_NOT_COMPLETE;
return ResultNotComplete;
return receive(frame, tba);
}
libuavcan/test/can_driver.cpp
+5 -5
View File
@@ -14,7 +14,7 @@ TEST(CanFrame, FrameProperties)
EXPECT_FALSE(makeCanFrame(0, "", STD).isRemoteTransmissionRequest());
uavcan::CanFrame frame = makeCanFrame(123, "", STD);
frame.id |= uavcan::CanFrame::FLAG_RTR;
frame.id |= uavcan::CanFrame::FlagRTR;
EXPECT_TRUE(frame.isRemoteTransmissionRequest());
}
@@ -22,17 +22,17 @@ TEST(CanFrame, ToString)
{
uavcan::CanFrame frame = makeCanFrame(123, "\x01\x02\x03\x04""1234", EXT);
EXPECT_EQ("0x0000007b 01 02 03 04 31 32 33 34 '....1234'", frame.toString());
EXPECT_TRUE(frame.toString() == frame.toString(uavcan::CanFrame::STR_ALIGNED));
EXPECT_TRUE(frame.toString() == frame.toString(uavcan::CanFrame::StrAligned));
frame = makeCanFrame(123, "z", EXT);
EXPECT_EQ("0x0000007b 7a 'z'", frame.toString(uavcan::CanFrame::STR_ALIGNED));
EXPECT_EQ("0x0000007b 7a 'z'", frame.toString(uavcan::CanFrame::StrAligned));
EXPECT_EQ("0x0000007b 7a 'z'", frame.toString());
EXPECT_EQ(" 0x141 61 62 63 64 aa bb cc dd 'abcd....'",
makeCanFrame(321, "abcd""\xaa\xbb\xcc\xdd", STD).toString(uavcan::CanFrame::STR_ALIGNED));
makeCanFrame(321, "abcd""\xaa\xbb\xcc\xdd", STD).toString(uavcan::CanFrame::StrAligned));
EXPECT_EQ(" 0x100 ''",
makeCanFrame(256, "", STD).toString(uavcan::CanFrame::STR_ALIGNED));
makeCanFrame(256, "", STD).toString(uavcan::CanFrame::StrAligned));
EXPECT_EQ("0x100 ''",
makeCanFrame(256, "", STD).toString());
libuavcan/test/common.hpp
+1 -1
View File
@@ -50,6 +50,6 @@ public:
enum FrameType { STD, EXT };
static uavcan::CanFrame makeCanFrame(uint32_t id, const std::string& str_data, FrameType type)
{
id |= (type == EXT) ? uavcan::CanFrame::FLAG_EFF : 0;
id |= (type == EXT) ? uavcan::CanFrame::FlagEFF : 0;
return uavcan::CanFrame(id, reinterpret_cast<const uint8_t*>(str_data.c_str()), str_data.length());
}
libuavcan/test/map.cpp
+1 -1
View File
@@ -30,7 +30,7 @@ TEST(Map, Basic)
using uavcan::Map;
static const int POOL_BLOCKS = 3;
uavcan::PoolAllocator<uavcan::MEM_POOL_BLOCK_SIZE * POOL_BLOCKS, uavcan::MEM_POOL_BLOCK_SIZE> pool;
uavcan::PoolAllocator<uavcan::MemPoolBlockSize * POOL_BLOCKS, uavcan::MemPoolBlockSize> pool;
uavcan::PoolManager<2> poolmgr;
poolmgr.addPool(&pool);
libuavcan/test/transport/can/io.cpp
+13 -13
View File
@@ -12,8 +12,8 @@ static bool rxFrameEquals(const uavcan::CanRxFrame& rxframe, const uavcan::CanFr
if (static_cast<const uavcan::CanFrame&>(rxframe) != frame)
{
std::cout << "Frame mismatch:\n"
<< " " << rxframe.toString(uavcan::CanFrame::STR_ALIGNED) << "\n"
<< " " << frame.toString(uavcan::CanFrame::STR_ALIGNED) << std::endl;
<< " " << rxframe.toString(uavcan::CanFrame::StrAligned) << "\n"
<< " " << frame.toString(uavcan::CanFrame::StrAligned) << std::endl;
}
return (static_cast<const uavcan::CanFrame&>(rxframe) == frame) &&
(rxframe.ts_monotonic == timestamp) && (rxframe.iface_index == iface_index);
@@ -127,11 +127,11 @@ TEST(CanIOManager, Transmission)
/*
* Simple transmission
*/
EXPECT_EQ(2, iomgr.send(frames[0], 100, 0, ALL_IFACES_MASK, CanTxQueue::VOLATILE)); // To both
EXPECT_EQ(2, iomgr.send(frames[0], 100, 0, ALL_IFACES_MASK, CanTxQueue::Volatile)); // To both
EXPECT_TRUE(driver.ifaces.at(0).matchAndPopTx(frames[0], 100));
EXPECT_TRUE(driver.ifaces.at(1).matchAndPopTx(frames[0], 100));
EXPECT_EQ(1, iomgr.send(frames[1], 200, 100, 2, CanTxQueue::PERSISTENT)); // To #1
EXPECT_EQ(1, iomgr.send(frames[1], 200, 100, 2, CanTxQueue::Persistent)); // To #1
EXPECT_TRUE(driver.ifaces.at(1).matchAndPopTx(frames[1], 200));
EXPECT_EQ(0, clockmock.monotonic);
@@ -148,7 +148,7 @@ TEST(CanIOManager, Transmission)
// Sending to both, #0 blocked
driver.ifaces.at(0).writeable = false;
EXPECT_LT(0, iomgr.send(frames[0], 201, 200, ALL_IFACES_MASK, CanTxQueue::PERSISTENT));
EXPECT_LT(0, iomgr.send(frames[0], 201, 200, ALL_IFACES_MASK, CanTxQueue::Persistent));
EXPECT_TRUE(driver.ifaces.at(1).matchAndPopTx(frames[0], 201));
EXPECT_EQ(200, clockmock.monotonic);
EXPECT_EQ(200, clockmock.utc);
@@ -158,11 +158,11 @@ TEST(CanIOManager, Transmission)
// Sending to both, both blocked
driver.ifaces.at(1).writeable = false;
EXPECT_EQ(0, iomgr.send(frames[1], 777, 300, ALL_IFACES_MASK, CanTxQueue::VOLATILE));
EXPECT_EQ(0, iomgr.send(frames[1], 777, 300, ALL_IFACES_MASK, CanTxQueue::Volatile));
EXPECT_EQ(3, pool.getNumUsedBlocks()); // Total 3 frames in TX queue now
// Sending to #0, both blocked
EXPECT_EQ(0, iomgr.send(frames[2], 888, 400, 1, CanTxQueue::PERSISTENT));
EXPECT_EQ(0, iomgr.send(frames[2], 888, 400, 1, CanTxQueue::Persistent));
EXPECT_EQ(400, clockmock.monotonic);
EXPECT_EQ(400, clockmock.utc);
EXPECT_TRUE(driver.ifaces.at(0).tx.empty());
@@ -176,7 +176,7 @@ TEST(CanIOManager, Transmission)
// Sending to #1, both writeable
driver.ifaces.at(0).writeable = true;
driver.ifaces.at(1).writeable = true;
EXPECT_LT(0, iomgr.send(frames[0], 999, 500, 2, CanTxQueue::PERSISTENT)); // One frame per each iface will be sent
EXPECT_LT(0, iomgr.send(frames[0], 999, 500, 2, CanTxQueue::Persistent)); // One frame per each iface will be sent
EXPECT_TRUE(driver.ifaces.at(0).matchAndPopTx(frames[1], 777)); // Note that frame[0] on iface #0 has expired
EXPECT_TRUE(driver.ifaces.at(1).matchAndPopTx(frames[0], 999)); // In different order due to prioritization
EXPECT_TRUE(driver.ifaces.at(0).tx.empty());
@@ -202,9 +202,9 @@ TEST(CanIOManager, Transmission)
driver.ifaces.at(1).writeable = false;
// Sending 5 frames, one will be rejected
EXPECT_EQ(0, iomgr.send(frames[2], 2222, 1000, ALL_IFACES_MASK, CanTxQueue::PERSISTENT));
EXPECT_EQ(0, iomgr.send(frames[0], 3333, 1100, 2, CanTxQueue::PERSISTENT));
EXPECT_EQ(0, iomgr.send(frames[1], 4444, 1200, ALL_IFACES_MASK, CanTxQueue::VOLATILE)); // One frame kicked here
EXPECT_EQ(0, iomgr.send(frames[2], 2222, 1000, ALL_IFACES_MASK, CanTxQueue::Persistent));
EXPECT_EQ(0, iomgr.send(frames[0], 3333, 1100, 2, CanTxQueue::Persistent));
EXPECT_EQ(0, iomgr.send(frames[1], 4444, 1200, ALL_IFACES_MASK, CanTxQueue::Volatile)); // One frame kicked here
// State checks
EXPECT_EQ(4, pool.getNumUsedBlocks()); // TX queue is full
@@ -247,7 +247,7 @@ TEST(CanIOManager, Transmission)
// Select failure
driver.select_failure = true;
EXPECT_EQ(-1, iomgr.receive(rx_frame, 2000));
EXPECT_EQ(-1, iomgr.send(frames[0], 2100, 2000, ALL_IFACES_MASK, CanTxQueue::VOLATILE));
EXPECT_EQ(-1, iomgr.send(frames[0], 2100, 2000, ALL_IFACES_MASK, CanTxQueue::Volatile));
EXPECT_EQ(1200, clockmock.monotonic);
EXPECT_EQ(1200, clockmock.utc);
@@ -257,7 +257,7 @@ TEST(CanIOManager, Transmission)
driver.ifaces.at(1).writeable = true;
driver.ifaces.at(0).tx_failure = true;
driver.ifaces.at(1).tx_failure = true;
EXPECT_GE(0, iomgr.send(frames[0], 2200, 0, ALL_IFACES_MASK, CanTxQueue::PERSISTENT)); // Non-blocking - return < 0
EXPECT_GE(0, iomgr.send(frames[0], 2200, 0, ALL_IFACES_MASK, CanTxQueue::Persistent)); // Non-blocking - return < 0
ASSERT_EQ(2, pool.getNumUsedBlocks()); // Untransmitted frames will be buffered
libuavcan/test/transport/can/tx_queue.cpp
+17 -17
View File
@@ -33,22 +33,22 @@ static bool isInQueue(uavcan::CanTxQueue& queue, const uavcan::CanFrame& frame)
TEST(CanTxQueue, Qos)
{
uavcan::CanTxQueue::Entry e1(makeCanFrame(100, "", EXT), 1000, uavcan::CanTxQueue::VOLATILE);
uavcan::CanTxQueue::Entry e2(makeCanFrame(100, "", EXT), 1000, uavcan::CanTxQueue::VOLATILE);
uavcan::CanTxQueue::Entry e1(makeCanFrame(100, "", EXT), 1000, uavcan::CanTxQueue::Volatile);
uavcan::CanTxQueue::Entry e2(makeCanFrame(100, "", EXT), 1000, uavcan::CanTxQueue::Volatile);
EXPECT_FALSE(e1.qosHigherThan(e2));
EXPECT_FALSE(e2.qosHigherThan(e1));
EXPECT_FALSE(e1.qosLowerThan(e2));
EXPECT_FALSE(e2.qosLowerThan(e1));
e2.qos = uavcan::CanTxQueue::PERSISTENT;
e2.qos = uavcan::CanTxQueue::Persistent;
EXPECT_FALSE(e1.qosHigherThan(e2));
EXPECT_TRUE(e2.qosHigherThan(e1));
EXPECT_TRUE(e1.qosLowerThan(e2));
EXPECT_FALSE(e2.qosLowerThan(e1));
e1.qos = uavcan::CanTxQueue::PERSISTENT;
e1.qos = uavcan::CanTxQueue::Persistent;
e1.frame.id -= 1;
EXPECT_TRUE(e1.qosHigherThan(e2));
@@ -86,7 +86,7 @@ TEST(CanTxQueue, TxQueue)
/*
* Priority insertion
*/
queue.push(f4, 100, CanTxQueue::PERSISTENT);
queue.push(f4, 100, CanTxQueue::Persistent);
EXPECT_FALSE(queue.isEmpty());
EXPECT_EQ(1, pool32.getNumUsedBlocks());
EXPECT_EQ(f4, queue.peek()->frame);
@@ -94,13 +94,13 @@ TEST(CanTxQueue, TxQueue)
EXPECT_TRUE(queue.topPriorityHigherOrEqual(f4)); // Equal
EXPECT_FALSE(queue.topPriorityHigherOrEqual(f3));
queue.push(f3, 200, CanTxQueue::PERSISTENT);
queue.push(f3, 200, CanTxQueue::Persistent);
EXPECT_EQ(f3, queue.peek()->frame);
queue.push(f0, 300, CanTxQueue::VOLATILE);
queue.push(f0, 300, CanTxQueue::Volatile);
EXPECT_EQ(f0, queue.peek()->frame);
queue.push(f1, 400, CanTxQueue::VOLATILE);
queue.push(f1, 400, CanTxQueue::Volatile);
EXPECT_EQ(f0, queue.peek()->frame); // Still f0, since it is highest
EXPECT_TRUE(queue.topPriorityHigherOrEqual(f0)); // Equal
EXPECT_TRUE(queue.topPriorityHigherOrEqual(f1));
@@ -125,28 +125,28 @@ TEST(CanTxQueue, TxQueue)
* QoS
*/
EXPECT_FALSE(isInQueue(queue, f2));
queue.push(f2, 100, CanTxQueue::VOLATILE); // Non preempting, will be rejected
queue.push(f2, 100, CanTxQueue::Volatile); // Non preempting, will be rejected
EXPECT_FALSE(isInQueue(queue, f2));
queue.push(f2, 500, CanTxQueue::PERSISTENT); // Will override f1 (f3 and f4 are presistent)
queue.push(f2, 500, CanTxQueue::Persistent); // Will override f1 (f3 and f4 are presistent)
EXPECT_TRUE(isInQueue(queue, f2));
EXPECT_FALSE(isInQueue(queue, f1));
EXPECT_EQ(4, getQueueLength(queue));
EXPECT_EQ(2, queue.getNumRejectedFrames());
EXPECT_EQ(f0, queue.peek()->frame); // Check the priority
queue.push(f5, 600, CanTxQueue::PERSISTENT); // Will override f0 (rest are presistent)
queue.push(f5, 600, CanTxQueue::Persistent); // Will override f0 (rest are presistent)
EXPECT_TRUE(isInQueue(queue, f5));
EXPECT_FALSE(isInQueue(queue, f0));
EXPECT_EQ(f2, queue.peek()->frame); // Check the priority
// No volatile frames left now
queue.push(f5a, 700, CanTxQueue::PERSISTENT); // Will override f5 (same frame, same QoS)
queue.push(f5a, 700, CanTxQueue::Persistent); // Will override f5 (same frame, same QoS)
EXPECT_TRUE(isInQueue(queue, f5a));
EXPECT_FALSE(isInQueue(queue, f5));
queue.push(f6, 700, CanTxQueue::PERSISTENT); // Will be rejected (lowest QoS)
queue.push(f6, 700, CanTxQueue::Persistent); // Will be rejected (lowest QoS)
EXPECT_FALSE(isInQueue(queue, f6));
EXPECT_FALSE(queue.topPriorityHigherOrEqual(f0));
@@ -165,19 +165,19 @@ TEST(CanTxQueue, TxQueue)
* Expiration
*/
clockmock.monotonic = 101;
queue.push(f0, 800, CanTxQueue::VOLATILE); // Will replace f4 which is expired now
queue.push(f0, 800, CanTxQueue::Volatile); // Will replace f4 which is expired now
EXPECT_TRUE(isInQueue(queue, f0));
EXPECT_FALSE(isInQueue(queue, f4));
EXPECT_EQ(6, queue.getNumRejectedFrames());
clockmock.monotonic = 1001;
queue.push(f5, 2000, CanTxQueue::VOLATILE); // Entire queue is expired
queue.push(f5, 2000, CanTxQueue::Volatile); // Entire queue is expired
EXPECT_TRUE(isInQueue(queue, f5));
EXPECT_EQ(1, getQueueLength(queue)); // Just one entry left - f5
EXPECT_EQ(1, pool32.getNumUsedBlocks()); // Make sure there is no leaks
EXPECT_EQ(10, queue.getNumRejectedFrames());
queue.push(f0, 1000, CanTxQueue::PERSISTENT); // This entry is already expired
queue.push(f0, 1000, CanTxQueue::Persistent); // This entry is already expired
EXPECT_EQ(1, getQueueLength(queue));
EXPECT_EQ(1, pool32.getNumUsedBlocks());
EXPECT_EQ(11, queue.getNumRejectedFrames());
@@ -185,7 +185,7 @@ TEST(CanTxQueue, TxQueue)
/*
* Removing
*/
queue.push(f4, 5000, CanTxQueue::VOLATILE);
queue.push(f4, 5000, CanTxQueue::Volatile);
EXPECT_EQ(2, getQueueLength(queue));
EXPECT_TRUE(isInQueue(queue, f4));
EXPECT_EQ(f4, queue.peek()->frame);
libuavcan/test/transport/dispatcher.cpp
+17 -17
View File
@@ -34,7 +34,7 @@ static const uavcan::NodeID SELF_NODE_ID(64);
TEST(Dispatcher, Reception)
{
uavcan::PoolAllocator<uavcan::MEM_POOL_BLOCK_SIZE * 8, uavcan::MEM_POOL_BLOCK_SIZE> pool;
uavcan::PoolAllocator<uavcan::MemPoolBlockSize * 8, uavcan::MemPoolBlockSize> pool;
uavcan::PoolManager<1> poolmgr;
poolmgr.addPool(&pool);
@@ -52,10 +52,10 @@ TEST(Dispatcher, Reception)
*/
static const uavcan::DataTypeDescriptor TYPES[4] =
{
makeDataType(uavcan::DATA_TYPE_KIND_MESSAGE, 1),
makeDataType(uavcan::DATA_TYPE_KIND_MESSAGE, 2),
makeDataType(uavcan::DATA_TYPE_KIND_SERVICE, 1),
makeDataType(uavcan::DATA_TYPE_KIND_SERVICE, 1)
makeDataType(uavcan::DataTypeKindMessage, 1),
makeDataType(uavcan::DataTypeKindMessage, 2),
makeDataType(uavcan::DataTypeKindService, 1),
makeDataType(uavcan::DataTypeKindService, 1)
};
typedef TestSubscriber<512, 2, 2> Subscriber;
@@ -92,16 +92,16 @@ TEST(Dispatcher, Reception)
const Transfer transfers[9] =
{
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 10, DATA[0], TYPES[0]),
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 11, DATA[1], TYPES[1]),
emulator.makeTransfer(uavcan::TRANSFER_TYPE_SERVICE_REQUEST, 12, DATA[2], TYPES[2]),
emulator.makeTransfer(uavcan::TRANSFER_TYPE_SERVICE_RESPONSE, 13, DATA[3], TYPES[3]),
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 14, DATA[4], TYPES[0]),
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 15, DATA[5], TYPES[1]),
emulator.makeTransfer(uavcan::TransferTypeMessageBroadcast, 10, DATA[0], TYPES[0]),
emulator.makeTransfer(uavcan::TransferTypeMessageUnicast, 11, DATA[1], TYPES[1]),
emulator.makeTransfer(uavcan::TransferTypeServiceRequest, 12, DATA[2], TYPES[2]),
emulator.makeTransfer(uavcan::TransferTypeServiceResponse, 13, DATA[3], TYPES[3]),
emulator.makeTransfer(uavcan::TransferTypeMessageUnicast, 14, DATA[4], TYPES[0]),
emulator.makeTransfer(uavcan::TransferTypeMessageBroadcast, 15, DATA[5], TYPES[1]),
// Wrongly addressed:
emulator.makeTransfer(uavcan::TRANSFER_TYPE_SERVICE_RESPONSE, 10, DATA[0], TYPES[3], 100),
emulator.makeTransfer(uavcan::TRANSFER_TYPE_SERVICE_REQUEST, 11, DATA[1], TYPES[2], 101),
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 12, DATA[2], TYPES[1], 102)
emulator.makeTransfer(uavcan::TransferTypeServiceResponse, 10, DATA[0], TYPES[3], 100),
emulator.makeTransfer(uavcan::TransferTypeServiceRequest, 11, DATA[1], TYPES[2], 101),
emulator.makeTransfer(uavcan::TransferTypeMessageUnicast, 12, DATA[2], TYPES[1], 102)
};
/*
@@ -183,7 +183,7 @@ TEST(Dispatcher, Reception)
TEST(Dispatcher, Transmission)
{
uavcan::PoolAllocator<uavcan::MEM_POOL_BLOCK_SIZE * 8, uavcan::MEM_POOL_BLOCK_SIZE> pool;
uavcan::PoolAllocator<uavcan::MemPoolBlockSize * 8, uavcan::MemPoolBlockSize> pool;
uavcan::PoolManager<1> poolmgr;
poolmgr.addPool(&pool);
@@ -201,10 +201,10 @@ TEST(Dispatcher, Transmission)
// uint_fast16_t data_type_id, TransferType transfer_type, NodeID src_node_id, NodeID dst_node_id,
// uint_fast8_t frame_index, TransferID transfer_id, bool last_frame = false
uavcan::Frame frame(123, uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, SELF_NODE_ID, 2, 0, 0, true);
uavcan::Frame frame(123, uavcan::TransferTypeMessageUnicast, SELF_NODE_ID, 2, 0, 0, true);
frame.setPayload(reinterpret_cast<const uint8_t*>("123"), 3);
ASSERT_EQ(2, dispatcher.send(frame, TX_DEADLINE, 0, uavcan::CanTxQueue::VOLATILE));
ASSERT_EQ(2, dispatcher.send(frame, TX_DEADLINE, 0, uavcan::CanTxQueue::Volatile));
/*
* Validation
libuavcan/test/transport/incoming_transfer.cpp
+1 -1
View File
@@ -10,7 +10,7 @@
static uavcan::RxFrame makeFrame()
{
uavcan::RxFrame frame(
uavcan::Frame(123, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 1, uavcan::NodeID::BROADCAST, 0, 1, true),
uavcan::Frame(123, uavcan::TransferTypeMessageBroadcast, 1, uavcan::NodeID::Broadcast, 0, 1, true),
123, 456, 0);
uint8_t data[8];
for (unsigned int i = 0; i < sizeof(data); i++)
libuavcan/test/transport/outgoing_transfer_registry.cpp
+5 -5
View File
@@ -18,11 +18,11 @@ TEST(OutgoingTransferRegistry, Basic)
static const int NUM_KEYS = 5;
const OutgoingTransferRegistryKey keys[NUM_KEYS] =
{
OutgoingTransferRegistryKey(123, uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 42),
OutgoingTransferRegistryKey(123, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 0),
OutgoingTransferRegistryKey(123, uavcan::TRANSFER_TYPE_SERVICE_REQUEST, 2),
OutgoingTransferRegistryKey(123, uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 4),
OutgoingTransferRegistryKey(456, uavcan::TRANSFER_TYPE_SERVICE_REQUEST, 2)
OutgoingTransferRegistryKey(123, uavcan::TransferTypeMessageUnicast, 42),
OutgoingTransferRegistryKey(123, uavcan::TransferTypeMessageBroadcast, 0),
OutgoingTransferRegistryKey(123, uavcan::TransferTypeServiceRequest, 2),
OutgoingTransferRegistryKey(123, uavcan::TransferTypeMessageUnicast, 4),
OutgoingTransferRegistryKey(456, uavcan::TransferTypeServiceRequest, 2)
};
ASSERT_EQ(0, otr.accessOrCreate(keys[0], 1000000)->get());
libuavcan/test/transport/transfer.cpp
+28 -28
View File
@@ -13,7 +13,7 @@ TEST(Transfer, TransferID)
using uavcan::TransferID;
// Tests below are based on this assumption
ASSERT_EQ(8, 1 << TransferID::BITLEN);
ASSERT_EQ(8, 1 << TransferID::BitLen);
/*
* forwardDistance()
@@ -40,7 +40,7 @@ TEST(Transfer, TransferID)
TransferID tid;
for (int i = 0; i < 999; i++)
{
ASSERT_EQ(i & ((1 << TransferID::BITLEN) - 1), tid.get());
ASSERT_EQ(i & ((1 << TransferID::BitLen) - 1), tid.get());
const TransferID copy = tid;
tid.increment();
ASSERT_EQ(1, copy.forwardDistance(tid));
@@ -63,7 +63,7 @@ TEST(Transfer, FrameParseCompile)
(1 << 3) | // Last Frame
(29 << 4) | // Frame Index
(42 << 10) | // Source Node ID
(uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST << 17) |
(uavcan::TransferTypeMessageBroadcast << 17) |
(456 << 19); // Data Type ID
const std::string payload_string = "hello";
@@ -72,7 +72,7 @@ TEST(Transfer, FrameParseCompile)
* Parse
*/
// Invalid CAN frames
ASSERT_FALSE(frame.parse(CanFrame(can_id | CanFrame::FLAG_RTR, (const uint8_t*)"", 0)));
ASSERT_FALSE(frame.parse(CanFrame(can_id | CanFrame::FlagRTR, (const uint8_t*)"", 0)));
ASSERT_FALSE(frame.parse(makeCanFrame(can_id, payload_string, STD)));
// Valid
@@ -82,7 +82,7 @@ TEST(Transfer, FrameParseCompile)
EXPECT_TRUE(frame.isLast());
EXPECT_EQ(29, frame.getIndex());
EXPECT_EQ(uavcan::NodeID(42), frame.getSrcNodeID());
EXPECT_EQ(uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, frame.getTransferType());
EXPECT_EQ(uavcan::TransferTypeMessageBroadcast, frame.getTransferType());
EXPECT_EQ(456, frame.getDataTypeID());
EXPECT_EQ(payload_string.length(), frame.getPayloadLen());
@@ -131,25 +131,25 @@ TEST(Transfer, FrameParsing)
/*
* SFT broadcast
*/
can.id = CanFrame::FLAG_EFF |
(2 << 0) | (1 << 3) | (0 << 4) | (42 << 10) | (uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST << 17) | (456 << 19);
can.id = CanFrame::FlagEFF |
(2 << 0) | (1 << 3) | (0 << 4) | (42 << 10) | (uavcan::TransferTypeMessageBroadcast << 17) | (456 << 19);
ASSERT_TRUE(frame.parse(can));
ASSERT_TRUE(frame.isFirst());
ASSERT_TRUE(frame.isLast());
ASSERT_EQ(0, frame.getIndex());
ASSERT_EQ(NodeID(42), frame.getSrcNodeID());
ASSERT_EQ(NodeID::BROADCAST, frame.getDstNodeID());
ASSERT_EQ(NodeID::Broadcast, frame.getDstNodeID());
ASSERT_EQ(456, frame.getDataTypeID());
ASSERT_EQ(TransferID(2), frame.getTransferID());
ASSERT_EQ(uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, frame.getTransferType());
ASSERT_EQ(uavcan::TransferTypeMessageBroadcast, frame.getTransferType());
ASSERT_EQ(sizeof(CanFrame::data), frame.getMaxPayloadLen());
/*
* SFT addressed
*/
can.id = CanFrame::FLAG_EFF |
(2 << 0) | (1 << 3) | (0 << 4) | (42 << 10) | (uavcan::TRANSFER_TYPE_MESSAGE_UNICAST << 17) | (456 << 19);
can.id = CanFrame::FlagEFF |
(2 << 0) | (1 << 3) | (0 << 4) | (42 << 10) | (uavcan::TransferTypeMessageUnicast << 17) | (456 << 19);
ASSERT_FALSE(frame.parse(can)); // No payload - failure
@@ -167,39 +167,39 @@ TEST(Transfer, FrameParsing)
ASSERT_EQ(NodeID(127), frame.getDstNodeID());
ASSERT_EQ(456, frame.getDataTypeID());
ASSERT_EQ(TransferID(2), frame.getTransferID());
ASSERT_EQ(uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, frame.getTransferType());
ASSERT_EQ(uavcan::TransferTypeMessageUnicast, frame.getTransferType());
ASSERT_EQ(sizeof(CanFrame::data) - 1, frame.getMaxPayloadLen());
/*
* MFT invalid - unterminated transfer
*/
can.id = CanFrame::FLAG_EFF |
(2 << 0) | (0 << 3) | (Frame::INDEX_MAX << 4) | (42 << 10) |
(uavcan::TRANSFER_TYPE_MESSAGE_UNICAST << 17) | (456 << 19);
can.id = CanFrame::FlagEFF |
(2 << 0) | (0 << 3) | (Frame::MaxIndex << 4) | (42 << 10) |
(uavcan::TransferTypeMessageUnicast << 17) | (456 << 19);
ASSERT_FALSE(frame.parse(can));
/*
* MFT invalid - invalid frame index
*/
can.id = CanFrame::FLAG_EFF |
(2 << 0) | (0 << 3) | (63 << 4) | (42 << 10) | (uavcan::TRANSFER_TYPE_MESSAGE_UNICAST << 17) | (456 << 19);
can.id = CanFrame::FlagEFF |
(2 << 0) | (0 << 3) | (63 << 4) | (42 << 10) | (uavcan::TransferTypeMessageUnicast << 17) | (456 << 19);
ASSERT_FALSE(frame.parse(can));
/*
* Malformed frames
*/
can.id = CanFrame::FLAG_EFF |
(2 << 0) | (1 << 3) | (0 << 4) | (42 << 10) | (uavcan::TRANSFER_TYPE_MESSAGE_UNICAST << 17) | (456 << 19);
can.id = CanFrame::FlagEFF |
(2 << 0) | (1 << 3) | (0 << 4) | (42 << 10) | (uavcan::TransferTypeMessageUnicast << 17) | (456 << 19);
can.dlc = 3;
can.data[0] = 42;
ASSERT_FALSE(frame.parse(can)); // Src == Dst Node ID
can.data[0] = 41;
ASSERT_TRUE(frame.parse(can));
can.id = CanFrame::FLAG_EFF | // cppcheck-suppress duplicateExpression
(2 << 0) | (1 << 3) | (0 << 4) | (0 << 10) | (uavcan::TRANSFER_TYPE_MESSAGE_UNICAST << 17) | (456 << 19);
can.id = CanFrame::FlagEFF | // cppcheck-suppress duplicateExpression
(2 << 0) | (1 << 3) | (0 << 4) | (0 << 10) | (uavcan::TransferTypeMessageUnicast << 17) | (456 << 19);
ASSERT_FALSE(frame.parse(can)); // Broadcast Src Node ID
}
@@ -218,12 +218,12 @@ TEST(Transfer, RxFrameParse)
ASSERT_FALSE(rx_frame.parse(can_rx_frame));
// Valid
can_rx_frame.id = CanFrame::FLAG_EFF |
can_rx_frame.id = CanFrame::FlagEFF |
(2 << 0) | // Transfer ID
(1 << 3) | // Last Frame
(29 << 4) | // Frame Index
(42 << 10) | // Source Node ID
(uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST << 17) |
(uavcan::TransferTypeMessageBroadcast << 17) |
(456 << 19); // Data Type ID
ASSERT_TRUE(rx_frame.parse(can_rx_frame));
@@ -233,14 +233,14 @@ TEST(Transfer, RxFrameParse)
can_rx_frame.ts_monotonic = 123;
can_rx_frame.iface_index = 2;
Frame frame(456, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 1, uavcan::NodeID::BROADCAST, 0, 0);
Frame frame(456, uavcan::TransferTypeMessageBroadcast, 1, uavcan::NodeID::Broadcast, 0, 0);
ASSERT_TRUE(frame.compile(can_rx_frame));
ASSERT_TRUE(rx_frame.parse(can_rx_frame));
ASSERT_EQ(123, rx_frame.getMonotonicTimestamp());
ASSERT_EQ(2, rx_frame.getIfaceIndex());
ASSERT_EQ(456, rx_frame.getDataTypeID());
ASSERT_EQ(uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, rx_frame.getTransferType());
ASSERT_EQ(uavcan::TransferTypeMessageBroadcast, rx_frame.getTransferType());
}
@@ -254,9 +254,9 @@ TEST(Transfer, FrameToString)
EXPECT_EQ("dtid=0 tt=4 snid=255 dnid=255 idx=0 last=0 tid=0 payload=[] ts_m=0 ts_utc=0 iface=0", rx_frame.toString());
// RX frame max len
rx_frame = RxFrame(Frame(Frame::DATA_TYPE_ID_MAX, uavcan::TRANSFER_TYPE_MESSAGE_UNICAST,
uavcan::NodeID::MAX, uavcan::NodeID::MAX - 1, Frame::INDEX_MAX,
uavcan::TransferID::MAX, true),
rx_frame = RxFrame(Frame(Frame::MaxDataTypeID, uavcan::TransferTypeMessageUnicast,
uavcan::NodeID::Max, uavcan::NodeID::Max - 1, Frame::MaxIndex,
uavcan::TransferID::Max, true),
0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 3);
uint8_t data[8];
libuavcan/test/transport/transfer_buffer.cpp
+10 -10
View File
@@ -75,7 +75,7 @@ static bool matchAgainstTestData(const uavcan::ITransferBuffer& tbb, unsigned in
TEST(TransferBuffer, TestDataValidation)
{
ASSERT_LE(4, TEST_DATA.length() / uavcan::MEM_POOL_BLOCK_SIZE);
ASSERT_LE(4, TEST_DATA.length() / uavcan::MemPoolBlockSize);
uint8_t local_buffer[50];
std::copy(TEST_DATA.begin(), TEST_DATA.begin() + sizeof(local_buffer), local_buffer);
ASSERT_FALSE(allEqual(local_buffer));
@@ -134,7 +134,7 @@ TEST(DynamicTransferBufferManagerEntry, Basic)
static const int MAX_SIZE = TEST_BUFFER_SIZE;
static const int POOL_BLOCKS = 8;
uavcan::PoolAllocator<uavcan::MEM_POOL_BLOCK_SIZE * POOL_BLOCKS, uavcan::MEM_POOL_BLOCK_SIZE> pool;
uavcan::PoolAllocator<uavcan::MemPoolBlockSize * POOL_BLOCKS, uavcan::MemPoolBlockSize> pool;
uavcan::PoolManager<2> poolmgr;
poolmgr.addPool(&pool);
@@ -234,7 +234,7 @@ TEST(TransferBufferManager, Basic)
using uavcan::ITransferBuffer;
static const int POOL_BLOCKS = 8;
uavcan::PoolAllocator<uavcan::MEM_POOL_BLOCK_SIZE * POOL_BLOCKS, uavcan::MEM_POOL_BLOCK_SIZE> pool;
uavcan::PoolAllocator<uavcan::MemPoolBlockSize * POOL_BLOCKS, uavcan::MemPoolBlockSize> pool;
uavcan::PoolManager<1> poolmgr;
poolmgr.addPool(&pool);
@@ -242,18 +242,18 @@ TEST(TransferBufferManager, Basic)
std::auto_ptr<TransferBufferManagerType> mgr(new TransferBufferManagerType(poolmgr));
// Empty
ASSERT_FALSE(mgr->access(TransferBufferManagerKey(0, uavcan::TRANSFER_TYPE_MESSAGE_UNICAST)));
ASSERT_FALSE(mgr->access(TransferBufferManagerKey(127, uavcan::TRANSFER_TYPE_MESSAGE_UNICAST)));
ASSERT_FALSE(mgr->access(TransferBufferManagerKey(0, uavcan::TransferTypeMessageUnicast)));
ASSERT_FALSE(mgr->access(TransferBufferManagerKey(127, uavcan::TransferTypeMessageUnicast)));
ITransferBuffer* tbb = NULL;
const TransferBufferManagerKey keys[5] =
{
TransferBufferManagerKey(0, uavcan::TRANSFER_TYPE_MESSAGE_UNICAST),
TransferBufferManagerKey(1, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST),
TransferBufferManagerKey(2, uavcan::TRANSFER_TYPE_SERVICE_REQUEST),
TransferBufferManagerKey(127, uavcan::TRANSFER_TYPE_SERVICE_RESPONSE),
TransferBufferManagerKey(64, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST)
TransferBufferManagerKey(0, uavcan::TransferTypeMessageUnicast),
TransferBufferManagerKey(1, uavcan::TransferTypeMessageBroadcast),
TransferBufferManagerKey(2, uavcan::TransferTypeServiceRequest),
TransferBufferManagerKey(127, uavcan::TransferTypeServiceResponse),
TransferBufferManagerKey(64, uavcan::TransferTypeMessageBroadcast)
};
// Static 0
libuavcan/test/transport/transfer_listener.cpp
+33 -33
View File
@@ -30,12 +30,12 @@ public:
TEST(TransferListener, BasicMFT)
{
uavcan::DataTypeDescriptor type(uavcan::DATA_TYPE_KIND_MESSAGE, 123, uavcan::DataTypeHash());
for (int i = 0; i < uavcan::DataTypeHash::NUM_BYTES; i++)
uavcan::DataTypeDescriptor type(uavcan::DataTypeKindMessage, 123, uavcan::DataTypeHash());
for (int i = 0; i < uavcan::DataTypeHash::NumBytes; i++)
type.hash.value[i] = i | (i << 4);
static const int NUM_POOL_BLOCKS = 12; // This number is just enough to pass the test
uavcan::PoolAllocator<uavcan::MEM_POOL_BLOCK_SIZE * NUM_POOL_BLOCKS, uavcan::MEM_POOL_BLOCK_SIZE> pool;
uavcan::PoolAllocator<uavcan::MemPoolBlockSize * NUM_POOL_BLOCKS, uavcan::MemPoolBlockSize> pool;
uavcan::PoolManager<1> poolmgr;
poolmgr.addPool(&pool);
@@ -62,11 +62,11 @@ TEST(TransferListener, BasicMFT)
TransferListenerEmulator emulator(subscriber, type);
const Transfer transfers[] =
{
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 1, DATA[0]),
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 1, DATA[1]), // Same NID
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 2, DATA[2]),
emulator.makeTransfer(uavcan::TRANSFER_TYPE_SERVICE_REQUEST, 3, DATA[3]),
emulator.makeTransfer(uavcan::TRANSFER_TYPE_SERVICE_RESPONSE, 4, DATA[4]),
emulator.makeTransfer(uavcan::TransferTypeMessageBroadcast, 1, DATA[0]),
emulator.makeTransfer(uavcan::TransferTypeMessageUnicast, 1, DATA[1]), // Same NID
emulator.makeTransfer(uavcan::TransferTypeMessageUnicast, 2, DATA[2]),
emulator.makeTransfer(uavcan::TransferTypeServiceRequest, 3, DATA[3]),
emulator.makeTransfer(uavcan::TransferTypeServiceResponse, 4, DATA[4]),
};
/*
@@ -87,8 +87,8 @@ TEST(TransferListener, BasicMFT)
TEST(TransferListener, CrcFailure)
{
uavcan::DataTypeDescriptor type(uavcan::DATA_TYPE_KIND_MESSAGE, 123, uavcan::DataTypeHash());
for (int i = 0; i < uavcan::DataTypeHash::NUM_BYTES; i++)
uavcan::DataTypeDescriptor type(uavcan::DataTypeKindMessage, 123, uavcan::DataTypeHash());
for (int i = 0; i < uavcan::DataTypeHash::NumBytes; i++)
type.hash.value[i] = i | (i << 4);
uavcan::PoolManager<1> poolmgr; // No dynamic memory
@@ -98,8 +98,8 @@ TEST(TransferListener, CrcFailure)
* Generating transfers with damaged payload (CRC is not valid)
*/
TransferListenerEmulator emulator(subscriber, type);
const Transfer tr_mft = emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 42, "123456789abcdefghik");
const Transfer tr_sft = emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 11, "abcd");
const Transfer tr_mft = emulator.makeTransfer(uavcan::TransferTypeMessageBroadcast, 42, "123456789abcdefghik");
const Transfer tr_sft = emulator.makeTransfer(uavcan::TransferTypeMessageUnicast, 11, "abcd");
std::vector<uavcan::RxFrame> ser_mft = serializeTransfer(tr_mft);
std::vector<uavcan::RxFrame> ser_sft = serializeTransfer(tr_sft);
@@ -132,8 +132,8 @@ TEST(TransferListener, CrcFailure)
TEST(TransferListener, BasicSFT)
{
uavcan::DataTypeDescriptor type(uavcan::DATA_TYPE_KIND_MESSAGE, 123, uavcan::DataTypeHash());
for (int i = 0; i < uavcan::DataTypeHash::NUM_BYTES; i++)
uavcan::DataTypeDescriptor type(uavcan::DataTypeKindMessage, 123, uavcan::DataTypeHash());
for (int i = 0; i < uavcan::DataTypeHash::NumBytes; i++)
type.hash.value[i] = i | (i << 4);
uavcan::PoolManager<1> poolmgr; // No dynamic memory. At all.
@@ -142,15 +142,15 @@ TEST(TransferListener, BasicSFT)
TransferListenerEmulator emulator(subscriber, type);
const Transfer transfers[] =
{
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 1, "123"),
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 1, "456"), // Same NID
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 2, ""),
emulator.makeTransfer(uavcan::TRANSFER_TYPE_SERVICE_REQUEST, 3, "abc"),
emulator.makeTransfer(uavcan::TRANSFER_TYPE_SERVICE_RESPONSE, 4, ""),
emulator.makeTransfer(uavcan::TRANSFER_TYPE_SERVICE_RESPONSE, 2, ""), // New TT, ignored due to OOM
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 2, "foo"), // Same as 2, not ignored
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 2, "123456789abc"),// Same as 2, not SFT - ignore
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 2, "bar"), // Same as 2, not ignored
emulator.makeTransfer(uavcan::TransferTypeMessageBroadcast, 1, "123"),
emulator.makeTransfer(uavcan::TransferTypeMessageUnicast, 1, "456"), // Same NID
emulator.makeTransfer(uavcan::TransferTypeMessageUnicast, 2, ""),
emulator.makeTransfer(uavcan::TransferTypeServiceRequest, 3, "abc"),
emulator.makeTransfer(uavcan::TransferTypeServiceResponse, 4, ""),
emulator.makeTransfer(uavcan::TransferTypeServiceResponse, 2, ""), // New TT, ignored due to OOM
emulator.makeTransfer(uavcan::TransferTypeMessageUnicast, 2, "foo"), // Same as 2, not ignored
emulator.makeTransfer(uavcan::TransferTypeMessageUnicast, 2, "123456789abc"),// Same as 2, not SFT - ignore
emulator.makeTransfer(uavcan::TransferTypeMessageUnicast, 2, "bar"), // Same as 2, not ignored
};
emulator.send(transfers);
@@ -169,8 +169,8 @@ TEST(TransferListener, BasicSFT)
TEST(TransferListener, Cleanup)
{
uavcan::DataTypeDescriptor type(uavcan::DATA_TYPE_KIND_MESSAGE, 123, uavcan::DataTypeHash());
for (int i = 0; i < uavcan::DataTypeHash::NUM_BYTES; i++)
uavcan::DataTypeDescriptor type(uavcan::DataTypeKindMessage, 123, uavcan::DataTypeHash());
for (int i = 0; i < uavcan::DataTypeHash::NumBytes; i++)
type.hash.value[i] = i | (i << 4);
uavcan::PoolManager<1> poolmgr; // No dynamic memory
@@ -180,8 +180,8 @@ TEST(TransferListener, Cleanup)
* Generating transfers
*/
TransferListenerEmulator emulator(subscriber, type);
const Transfer tr_mft = emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 42, "123456789abcdefghik");
const Transfer tr_sft = emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 11, "abcd");
const Transfer tr_mft = emulator.makeTransfer(uavcan::TransferTypeMessageBroadcast, 42, "123456789abcdefghik");
const Transfer tr_sft = emulator.makeTransfer(uavcan::TransferTypeMessageUnicast, 11, "abcd");
const std::vector<uavcan::RxFrame> ser_mft = serializeTransfer(tr_mft);
const std::vector<uavcan::RxFrame> ser_sft = serializeTransfer(tr_sft);
@@ -225,20 +225,20 @@ TEST(TransferListener, Cleanup)
TEST(TransferListener, MaximumTransferLength)
{
uavcan::DataTypeDescriptor type(uavcan::DATA_TYPE_KIND_MESSAGE, 123, uavcan::DataTypeHash());
for (int i = 0; i < uavcan::DataTypeHash::NUM_BYTES; i++)
uavcan::DataTypeDescriptor type(uavcan::DataTypeKindMessage, 123, uavcan::DataTypeHash());
for (int i = 0; i < uavcan::DataTypeHash::NumBytes; i++)
type.hash.value[i] = i | (i << 4);
uavcan::PoolManager<1> poolmgr;
TestSubscriber<uavcan::MAX_TRANSFER_PAYLOAD_LEN * 2, 2, 2> subscriber(type, poolmgr);
TestSubscriber<uavcan::MaxTransferPayloadLen * 2, 2, 2> subscriber(type, poolmgr);
static const std::string DATA_OK(uavcan::MAX_TRANSFER_PAYLOAD_LEN, 'z');
static const std::string DATA_OK(uavcan::MaxTransferPayloadLen, 'z');
TransferListenerEmulator emulator(subscriber, type);
const Transfer transfers[] =
{
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 1, DATA_OK),
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 1, DATA_OK)
emulator.makeTransfer(uavcan::TransferTypeMessageUnicast, 1, DATA_OK),
emulator.makeTransfer(uavcan::TransferTypeMessageBroadcast, 1, DATA_OK)
};
emulator.send(transfers);
libuavcan/test/transport/transfer_receiver.cpp
+30 -30
View File
@@ -29,8 +29,8 @@ struct RxFrameGenerator
uint8_t transfer_id, uint64_t ts_monotonic, uint64_t ts_utc = 0)
{
const uavcan::NodeID dst_nid =
(bufmgr_key.getTransferType() == uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST) ?
uavcan::NodeID::BROADCAST : TARGET_NODE_ID;
(bufmgr_key.getTransferType() == uavcan::TransferTypeMessageBroadcast) ?
uavcan::NodeID::Broadcast : TARGET_NODE_ID;
uavcan::Frame frame(data_type_id, bufmgr_key.getTransferType(), bufmgr_key.getNodeID(),
dst_nid, frame_index, transfer_id, last);
@@ -41,7 +41,7 @@ struct RxFrameGenerator
}
};
const uavcan::TransferBufferManagerKey RxFrameGenerator::DEFAULT_KEY(42, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST);
const uavcan::TransferBufferManagerKey RxFrameGenerator::DEFAULT_KEY(42, uavcan::TransferTypeMessageBroadcast);
template <unsigned int BUFSIZE>
@@ -85,15 +85,15 @@ static bool matchBufferContent(const uavcan::ITransferBuffer* tbb, const std::st
}
#define CHECK_NOT_COMPLETE(x) ASSERT_EQ(uavcan::TransferReceiver::RESULT_NOT_COMPLETE, (x))
#define CHECK_COMPLETE(x) ASSERT_EQ(uavcan::TransferReceiver::RESULT_COMPLETE, (x))
#define CHECK_SINGLE_FRAME(x) ASSERT_EQ(uavcan::TransferReceiver::RESULT_SINGLE_FRAME, (x))
#define CHECK_NOT_COMPLETE(x) ASSERT_EQ(uavcan::TransferReceiver::ResultNotComplete, (x))
#define CHECK_COMPLETE(x) ASSERT_EQ(uavcan::TransferReceiver::ResultComplete, (x))
#define CHECK_SINGLE_FRAME(x) ASSERT_EQ(uavcan::TransferReceiver::ResultSingleFrame, (x))
TEST(TransferReceiver, Basic)
{
using uavcan::TransferReceiver;
Context<32> context;
RxFrameGenerator gen(789, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST);
RxFrameGenerator gen(789, uavcan::TransferTypeMessageBroadcast);
uavcan::TransferReceiver& rcv = context.receiver;
uavcan::ITransferBufferManager& bufmgr = context.bufmgr;
uavcan::TransferBufferAccessor bk(context.bufmgr, RxFrameGenerator::DEFAULT_KEY);
@@ -101,14 +101,14 @@ TEST(TransferReceiver, Basic)
/*
* Empty
*/
ASSERT_EQ(TransferReceiver::DEFAULT_TRANSFER_INTERVAL, rcv.getInterval());
ASSERT_EQ(TransferReceiver::DefaultTransferInterval, rcv.getInterval());
ASSERT_EQ(0, rcv.getLastTransferTimestampMonotonic());
/*
* Single frame transfer with zero ts, must be ignored
*/
CHECK_NOT_COMPLETE(rcv.addFrame(gen(0, "Foo", 0, true, 0, 0), bk));
ASSERT_EQ(TransferReceiver::DEFAULT_TRANSFER_INTERVAL, rcv.getInterval());
ASSERT_EQ(TransferReceiver::DefaultTransferInterval, rcv.getInterval());
ASSERT_EQ(0, rcv.getLastTransferTimestampMonotonic());
/*
@@ -120,7 +120,7 @@ TEST(TransferReceiver, Basic)
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(TransferReceiver::DefaultTransferInterval, rcv.getInterval()); // Not initialized yet
ASSERT_EQ(100, rcv.getLastTransferTimestampMonotonic());
/*
@@ -138,8 +138,8 @@ TEST(TransferReceiver, Basic)
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_GT(TransferReceiver::DefaultTransferInterval, rcv.getInterval());
ASSERT_LT(TransferReceiver::MinTransferInterval, rcv.getInterval());
ASSERT_EQ(1000, rcv.getLastTransferTimestampMonotonic());
ASSERT_FALSE(rcv.isTimedOut(1000));
ASSERT_FALSE(rcv.isTimedOut(5000));
@@ -153,7 +153,7 @@ TEST(TransferReceiver, Basic)
CHECK_SINGLE_FRAME(rcv.addFrame(gen(0, "qwe", 0, true, 2, 2200), bk));
ASSERT_FALSE(bufmgr.access(gen.bufmgr_key)); // Buffer must be removed
ASSERT_GT(TransferReceiver::DEFAULT_TRANSFER_INTERVAL, rcv.getInterval());
ASSERT_GT(TransferReceiver::DefaultTransferInterval, rcv.getInterval());
ASSERT_EQ(2200, rcv.getLastTransferTimestampMonotonic());
CHECK_SINGLE_FRAME(rcv.addFrame(gen(0, "", 0, true, 3, 2500), bk));
@@ -195,9 +195,9 @@ TEST(TransferReceiver, Basic)
ASSERT_FALSE(rcv.isTimedOut(1000));
ASSERT_FALSE(rcv.isTimedOut(900000200));
ASSERT_TRUE(rcv.isTimedOut(1000 * 1000000));
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_LT(TransferReceiver::DefaultTransferInterval, rcv.getInterval());
ASSERT_LE(TransferReceiver::MinTransferInterval, rcv.getInterval());
ASSERT_GE(TransferReceiver::MaxTransferInterval, rcv.getInterval());
ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), "345678qwe"));
ASSERT_EQ(0x5678, rcv.getLastTransferCrc());
@@ -213,7 +213,7 @@ TEST(TransferReceiver, Basic)
TEST(TransferReceiver, OutOfBufferSpace_32bytes)
{
Context<32> context;
RxFrameGenerator gen(789, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST);
RxFrameGenerator gen(789, uavcan::TransferTypeMessageBroadcast);
uavcan::TransferReceiver& rcv = context.receiver;
uavcan::ITransferBufferManager& bufmgr = context.bufmgr;
uavcan::TransferBufferAccessor bk(context.bufmgr, RxFrameGenerator::DEFAULT_KEY);
@@ -248,18 +248,18 @@ TEST(TransferReceiver, OutOfBufferSpace_32bytes)
TEST(TransferReceiver, UnterminatedTransfer)
{
Context<512> context;
RxFrameGenerator gen(789, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST);
RxFrameGenerator gen(789, uavcan::TransferTypeMessageBroadcast);
uavcan::TransferReceiver& rcv = context.receiver;
uavcan::ITransferBufferManager& bufmgr = context.bufmgr;
uavcan::TransferBufferAccessor bk(context.bufmgr, RxFrameGenerator::DEFAULT_KEY);
std::string content;
for (int i = 0; i <= uavcan::Frame::INDEX_MAX; i++)
for (int i = 0; i <= uavcan::Frame::MaxIndex; i++)
{
CHECK_NOT_COMPLETE(rcv.addFrame(gen(1, "12345678", i, false, 0, 1000 + i), bk)); // Last one will be dropped
content += "12345678";
}
CHECK_COMPLETE(rcv.addFrame(gen(1, "12345678", uavcan::Frame::INDEX_MAX, true, 0, 1100), bk));
CHECK_COMPLETE(rcv.addFrame(gen(1, "12345678", uavcan::Frame::MaxIndex, true, 0, 1100), bk));
ASSERT_EQ(1000, rcv.getLastTransferTimestampMonotonic());
ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), std::string(content, 2)));
ASSERT_EQ(0x3231, rcv.getLastTransferCrc());
@@ -269,7 +269,7 @@ TEST(TransferReceiver, UnterminatedTransfer)
TEST(TransferReceiver, OutOfOrderFrames)
{
Context<32> context;
RxFrameGenerator gen(789, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST);
RxFrameGenerator gen(789, uavcan::TransferTypeMessageBroadcast);
uavcan::TransferReceiver& rcv = context.receiver;
uavcan::ITransferBufferManager& bufmgr = context.bufmgr;
uavcan::TransferBufferAccessor bk(context.bufmgr, RxFrameGenerator::DEFAULT_KEY);
@@ -290,7 +290,7 @@ TEST(TransferReceiver, OutOfOrderFrames)
TEST(TransferReceiver, IntervalMeasurement)
{
Context<32> context;
RxFrameGenerator gen(789, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST);
RxFrameGenerator gen(789, uavcan::TransferTypeMessageBroadcast);
uavcan::TransferReceiver& rcv = context.receiver;
uavcan::ITransferBufferManager& bufmgr = context.bufmgr;
uavcan::TransferBufferAccessor bk(context.bufmgr, RxFrameGenerator::DEFAULT_KEY);
@@ -320,7 +320,7 @@ TEST(TransferReceiver, IntervalMeasurement)
TEST(TransferReceiver, Restart)
{
Context<32> context;
RxFrameGenerator gen(789, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST);
RxFrameGenerator gen(789, uavcan::TransferTypeMessageBroadcast);
uavcan::TransferReceiver& rcv = context.receiver;
uavcan::ITransferBufferManager& bufmgr = context.bufmgr;
uavcan::TransferBufferAccessor bk(context.bufmgr, RxFrameGenerator::DEFAULT_KEY);
@@ -362,7 +362,7 @@ TEST(TransferReceiver, Restart)
TEST(TransferReceiver, UtcTransferTimestamping)
{
Context<32> context;
RxFrameGenerator gen(789, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST);
RxFrameGenerator gen(789, uavcan::TransferTypeMessageBroadcast);
uavcan::TransferReceiver& rcv = context.receiver;
uavcan::ITransferBufferManager& bufmgr = context.bufmgr;
uavcan::TransferBufferAccessor bk(context.bufmgr, RxFrameGenerator::DEFAULT_KEY);
@@ -412,15 +412,15 @@ TEST(TransferReceiver, UtcTransferTimestamping)
TEST(TransferReceiver, HeaderParsing)
{
Context<32> context;
RxFrameGenerator gen(789, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST);
RxFrameGenerator gen(789, uavcan::TransferTypeMessageBroadcast);
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::TransferTypeMessageUnicast,
uavcan::TransferTypeServiceRequest,
uavcan::TransferTypeServiceResponse
};
uavcan::TransferID tid;
@@ -430,7 +430,7 @@ TEST(TransferReceiver, HeaderParsing)
*/
{
gen.bufmgr_key =
uavcan::TransferBufferManagerKey(gen.bufmgr_key.getNodeID(), uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST);
uavcan::TransferBufferManagerKey(gen.bufmgr_key.getNodeID(), uavcan::TransferTypeMessageBroadcast);
uavcan::TransferBufferAccessor bk1(context.bufmgr, gen.bufmgr_key);
CHECK_NOT_COMPLETE(rcv.addFrame(gen(0, "12345678", 0, false, tid.get(), 1), bk1));
@@ -472,7 +472,7 @@ TEST(TransferReceiver, HeaderParsing)
{
gen.bufmgr_key =
uavcan::TransferBufferManagerKey(gen.bufmgr_key.getNodeID(), uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST);
uavcan::TransferBufferManagerKey(gen.bufmgr_key.getNodeID(), uavcan::TransferTypeMessageBroadcast);
uavcan::TransferBufferAccessor bk(context.bufmgr, gen.bufmgr_key);
const uavcan::RxFrame frame = gen(0, SFT_PAYLOAD_BROADCAST, 0, true, tid.get(), 1000);
libuavcan/test/transport/transfer_sender.cpp
+20 -20
View File
@@ -45,14 +45,14 @@ TEST(TransferSender, Basic)
*/
static const uavcan::DataTypeDescriptor TYPES[2] =
{
makeDataType(uavcan::DATA_TYPE_KIND_MESSAGE, 1),
makeDataType(uavcan::DATA_TYPE_KIND_SERVICE, 1)
makeDataType(uavcan::DataTypeKindMessage, 1),
makeDataType(uavcan::DataTypeKindService, 1)
};
uavcan::TransferSender senders[2] =
{
uavcan::TransferSender(dispatcher_tx, TYPES[0], uavcan::CanTxQueue::VOLATILE),
uavcan::TransferSender(dispatcher_tx, TYPES[1], uavcan::CanTxQueue::PERSISTENT)
uavcan::TransferSender(dispatcher_tx, TYPES[0], uavcan::CanTxQueue::Volatile),
uavcan::TransferSender(dispatcher_tx, TYPES[1], uavcan::CanTxQueue::Persistent)
};
static const std::string DATA[4] =
@@ -71,27 +71,27 @@ TEST(TransferSender, Basic)
*/
static const uint64_t TX_DEADLINE = 1000000;
sendOne(senders[0], DATA[0], TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 0);
sendOne(senders[0], DATA[1], TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, RX_NODE_ID);
sendOne(senders[0], "123", TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 0);
sendOne(senders[0], "456", TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, RX_NODE_ID);
sendOne(senders[0], DATA[0], TX_DEADLINE, 0, uavcan::TransferTypeMessageBroadcast, 0);
sendOne(senders[0], DATA[1], TX_DEADLINE, 0, uavcan::TransferTypeMessageUnicast, RX_NODE_ID);
sendOne(senders[0], "123", TX_DEADLINE, 0, uavcan::TransferTypeMessageBroadcast, 0);
sendOne(senders[0], "456", TX_DEADLINE, 0, uavcan::TransferTypeMessageUnicast, RX_NODE_ID);
sendOne(senders[1], DATA[2], TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_SERVICE_REQUEST, RX_NODE_ID);
sendOne(senders[1], DATA[3], TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_SERVICE_RESPONSE, RX_NODE_ID, 1);
sendOne(senders[1], "", TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_SERVICE_REQUEST, RX_NODE_ID);
sendOne(senders[1], "", TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_SERVICE_RESPONSE, RX_NODE_ID, 2);
sendOne(senders[1], DATA[2], TX_DEADLINE, 0, uavcan::TransferTypeServiceRequest, RX_NODE_ID);
sendOne(senders[1], DATA[3], TX_DEADLINE, 0, uavcan::TransferTypeServiceResponse, RX_NODE_ID, 1);
sendOne(senders[1], "", TX_DEADLINE, 0, uavcan::TransferTypeServiceRequest, RX_NODE_ID);
sendOne(senders[1], "", TX_DEADLINE, 0, uavcan::TransferTypeServiceResponse, RX_NODE_ID, 2);
static const Transfer TRANSFERS[8] =
{
Transfer(TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 0, TX_NODE_ID, 0, DATA[0], TYPES[0]),
Transfer(TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 0, TX_NODE_ID, RX_NODE_ID, DATA[1], TYPES[0]),
Transfer(TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 1, TX_NODE_ID, 0, "123", TYPES[0]),
Transfer(TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 1, TX_NODE_ID, RX_NODE_ID, "456", TYPES[0]),
Transfer(TX_DEADLINE, 0, uavcan::TransferTypeMessageBroadcast, 0, TX_NODE_ID, 0, DATA[0], TYPES[0]),
Transfer(TX_DEADLINE, 0, uavcan::TransferTypeMessageUnicast, 0, TX_NODE_ID, RX_NODE_ID, DATA[1], TYPES[0]),
Transfer(TX_DEADLINE, 0, uavcan::TransferTypeMessageBroadcast, 1, TX_NODE_ID, 0, "123", TYPES[0]),
Transfer(TX_DEADLINE, 0, uavcan::TransferTypeMessageUnicast, 1, TX_NODE_ID, RX_NODE_ID, "456", TYPES[0]),
Transfer(TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_SERVICE_REQUEST, 0, TX_NODE_ID, RX_NODE_ID, DATA[2], TYPES[1]),
Transfer(TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_SERVICE_RESPONSE, 1, TX_NODE_ID, RX_NODE_ID, DATA[3], TYPES[1]),
Transfer(TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_SERVICE_REQUEST, 1, TX_NODE_ID, RX_NODE_ID, "", TYPES[1]),
Transfer(TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_SERVICE_RESPONSE, 2, TX_NODE_ID, RX_NODE_ID, "", TYPES[1])
Transfer(TX_DEADLINE, 0, uavcan::TransferTypeServiceRequest, 0, TX_NODE_ID, RX_NODE_ID, DATA[2], TYPES[1]),
Transfer(TX_DEADLINE, 0, uavcan::TransferTypeServiceResponse, 1, TX_NODE_ID, RX_NODE_ID, DATA[3], TYPES[1]),
Transfer(TX_DEADLINE, 0, uavcan::TransferTypeServiceRequest, 1, TX_NODE_ID, RX_NODE_ID, "", TYPES[1]),
Transfer(TX_DEADLINE, 0, uavcan::TransferTypeServiceResponse, 2, TX_NODE_ID, RX_NODE_ID, "", TYPES[1])
};
/*
libuavcan/test/transport/transfer_test_helpers.cpp
+12 -12
View File
@@ -8,14 +8,14 @@
TEST(TransferTestHelpers, Transfer)
{
uavcan::PoolAllocator<uavcan::MEM_POOL_BLOCK_SIZE * 8, uavcan::MEM_POOL_BLOCK_SIZE> pool;
uavcan::PoolAllocator<uavcan::MemPoolBlockSize * 8, uavcan::MemPoolBlockSize> pool;
uavcan::PoolManager<1> poolmgr;
poolmgr.addPool(&pool);
uavcan::TransferBufferManager<128, 1> mgr(poolmgr);
uavcan::TransferBufferAccessor tba(mgr, uavcan::TransferBufferManagerKey(0, uavcan::TRANSFER_TYPE_MESSAGE_UNICAST));
uavcan::TransferBufferAccessor tba(mgr, uavcan::TransferBufferManagerKey(0, uavcan::TransferTypeMessageUnicast));
uavcan::RxFrame frame(uavcan::Frame(123, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 1, 0, 0, 0, true), 0, 0, 0);
uavcan::RxFrame frame(uavcan::Frame(123, uavcan::TransferTypeMessageBroadcast, 1, 0, 0, 0, true), 0, 0, 0);
uavcan::MultiFrameIncomingTransfer mfit(10, 1000, frame, tba);
// Filling the buffer with data
@@ -32,12 +32,12 @@ TEST(TransferTestHelpers, Transfer)
TEST(TransferTestHelpers, MFTSerialization)
{
uavcan::DataTypeDescriptor type(uavcan::DATA_TYPE_KIND_MESSAGE, 123, uavcan::DataTypeHash());
for (int i = 0; i < uavcan::DataTypeHash::NUM_BYTES; i++)
uavcan::DataTypeDescriptor type(uavcan::DataTypeKindMessage, 123, uavcan::DataTypeHash());
for (int i = 0; i < uavcan::DataTypeHash::NumBytes; i++)
type.hash.value[i] = i;
static const std::string DATA = "To go wrong in one's own way is better than to go right in someone else's.";
const Transfer transfer(1, 100000, uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 2, 42, 127, DATA, type);
const Transfer transfer(1, 100000, uavcan::TransferTypeMessageUnicast, 2, 42, 127, DATA, type);
const std::vector<uavcan::RxFrame> ser = serializeTransfer(transfer);
@@ -63,30 +63,30 @@ TEST(TransferTestHelpers, MFTSerialization)
TEST(TransferTestHelpers, SFTSerialization)
{
uavcan::DataTypeDescriptor type(uavcan::DATA_TYPE_KIND_MESSAGE, 123, uavcan::DataTypeHash());
for (int i = 0; i < uavcan::DataTypeHash::NUM_BYTES; i++)
uavcan::DataTypeDescriptor type(uavcan::DataTypeKindMessage, 123, uavcan::DataTypeHash());
for (int i = 0; i < uavcan::DataTypeHash::NumBytes; i++)
type.hash.value[i] = i;
{
const Transfer transfer(1, 100000, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 7, 42, 0, "Nvrfrget", type);
const Transfer transfer(1, 100000, uavcan::TransferTypeMessageBroadcast, 7, 42, 0, "Nvrfrget", type);
const std::vector<uavcan::RxFrame> ser = serializeTransfer(transfer);
ASSERT_EQ(1, ser.size());
std::cout << "Serialized transfer:\n\t" << ser[0].toString() << "\n";
}
{
const Transfer transfer(1, 100000, uavcan::TRANSFER_TYPE_SERVICE_REQUEST, 7, 42, 127, "7-chars", type);
const Transfer transfer(1, 100000, uavcan::TransferTypeServiceRequest, 7, 42, 127, "7-chars", type);
const std::vector<uavcan::RxFrame> ser = serializeTransfer(transfer);
ASSERT_EQ(1, ser.size());
std::cout << "Serialized transfer:\n\t" << ser[0].toString() << "\n";
}
{
const Transfer transfer(1, 100000, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 7, 42, 0, "", type);
const Transfer transfer(1, 100000, uavcan::TransferTypeMessageBroadcast, 7, 42, 0, "", type);
const std::vector<uavcan::RxFrame> ser = serializeTransfer(transfer);
ASSERT_EQ(1, ser.size());
std::cout << "Serialized transfer:\n\t" << ser[0].toString() << "\n";
}
{
const Transfer transfer(1, 100000, uavcan::TRANSFER_TYPE_SERVICE_RESPONSE, 7, 42, 127, "", type);
const Transfer transfer(1, 100000, uavcan::TransferTypeServiceResponse, 7, 42, 127, "", type);
const std::vector<uavcan::RxFrame> ser = serializeTransfer(transfer);
ASSERT_EQ(1, ser.size());
std::cout << "Serialized transfer:\n\t" << ser[0].toString() << "\n";
libuavcan/test/transport/transfer_test_helpers.hpp
+9 -9
View File
@@ -149,12 +149,12 @@ std::vector<uavcan::RxFrame> serializeTransfer(const Transfer& transfer)
bool need_crc = false;
switch (transfer.transfer_type)
{
case uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST:
case uavcan::TransferTypeMessageBroadcast:
need_crc = transfer.payload.length() > sizeof(uavcan::CanFrame::data);
break;
case uavcan::TRANSFER_TYPE_SERVICE_RESPONSE:
case uavcan::TRANSFER_TYPE_SERVICE_REQUEST:
case uavcan::TRANSFER_TYPE_MESSAGE_UNICAST:
case uavcan::TransferTypeServiceResponse:
case uavcan::TransferTypeServiceRequest:
case uavcan::TransferTypeMessageUnicast:
need_crc = transfer.payload.length() > (sizeof(uavcan::CanFrame::data) - 1);
break;
default:
@@ -165,7 +165,7 @@ std::vector<uavcan::RxFrame> serializeTransfer(const Transfer& transfer)
std::vector<uint8_t> raw_payload;
if (need_crc)
{
uavcan::Crc16 payload_crc(transfer.data_type.hash.value, uavcan::DataTypeHash::NUM_BYTES);
uavcan::Crc16 payload_crc(transfer.data_type.hash.value, uavcan::DataTypeHash::NumBytes);
payload_crc.add(reinterpret_cast<const uint8_t*>(transfer.payload.c_str()), transfer.payload.length());
// Little endian
raw_payload.push_back(payload_crc.get() & 0xFF);
@@ -196,7 +196,7 @@ std::vector<uavcan::RxFrame> serializeTransfer(const Transfer& transfer)
frm.makeLast();
offset += spres;
EXPECT_GE(uavcan::Frame::INDEX_MAX, frame_index);
EXPECT_GE(uavcan::Frame::MaxIndex, frame_index);
frame_index++;
const uavcan::RxFrame rxfrm(frm, ts_monotonic, ts_utc, 0);
@@ -213,7 +213,7 @@ std::vector<uavcan::RxFrame> serializeTransfer(const Transfer& transfer)
uavcan::DataTypeDescriptor makeDataType(uavcan::DataTypeKind kind, uint16_t id)
{
uavcan::DataTypeDescriptor dtd(kind, id, uavcan::DataTypeHash());
for (int i = 0; i < uavcan::DataTypeHash::NUM_BYTES; i += 2)
for (int i = 0; i < uavcan::DataTypeHash::NumBytes; i += 2)
{
dtd.hash.value[i] = id & 0xFF;
dtd.hash.value[i + 1] = id >> 8;
@@ -243,8 +243,8 @@ public:
uavcan::NodeID dst_node_id_override = uavcan::NodeID())
{
ts_ += 100;
const uavcan::NodeID dst_node_id = (transfer_type == uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST)
? uavcan::NodeID::BROADCAST
const uavcan::NodeID dst_node_id = (transfer_type == uavcan::TransferTypeMessageBroadcast)
? uavcan::NodeID::Broadcast
: (dst_node_id_override.isValid() ? dst_node_id_override : dst_node_id_);
const Transfer tr(ts_, ts_ + 1000000000ul, transfer_type, tid_, source_node_id, dst_node_id, payload, type);
tid_.increment();