Question

在我的项目中，我从RFID标签中读取唯一ID，结果采用uint8_t TagRead[4]形式。

将结果与许多预定义的标签ID值进行比较，以确定已读取的标签。

例如：

uint8_t RED1[4] = { 0x73, 0xD5, 0xB7, 0xAC };
uint8_t RED2[4] = { 0x7E, 0x27, 0x49, 0x4E };
uint8_t RED3[4] = { 0x02, 0xFD, 0x06, 0x40 };
uint8_t GREEN1[4] = { 0xAB, 0xEC, 0x68, 0x80 };
uint8_t GREEN2[4] = { 0xEE, 0x20, 0x50, 0x4E };
uint8_t GREEN3[4] = { 0x27, 0x06, 0x40, 0x73 };

if (*((uint32_t *)TagRead) == *((uint32_t *)RED2)) {
    // RED2 tag has been read
}

else if (*((uint32_t *)TagRead) == *((uint32_t *)GREEN3)) {
    // GREEN3 tag has been read
}

我的问题涉及能够将类型/类别分配给一组标签，以便可以根据已扫描的标签的颜色执行操作。

当扫描RED标签时，我们可能会打开红色LED，当扫描绿色标签时，我们会打开蓝色LED。

因为每种颜色大约有50个标签，所以我不想在If语句中列出所有标签名称。相反，是否可以将颜色分配给标签？

然后可以这样做：

如果扫描的标签是RED类型，请执行红色操作。如果扫描标签的类型为GREEN，请执行绿色操作。

感谢您的帮助。

Answer 1

首先，您的比较是未定义的行为。正确的方法是使用std::memcmp。你还需要照顾字节序。

为了将属性（如颜色）附加到标记，只需定义结构：

struct rfid_tag
{
    uint8_t value[4];
    enum { ... } color;
};

获得结构后，您可以使用operator==对其进行丰富，以便您可以使用std::find()在一行中查找相应的标记：

#include <iostream>
#include <array>
#include <algorithm>
#include <cstring>

struct rfid_tag
{
    enum color_type { red = 10, blue = 11 };

    std::array<uint8_t, 4> value;
    color_type             color;
};

bool operator==(std::array<uint8_t, 4> const& tagvalue, rfid_tag const& rhs)
{
    return std::memcmp(tagvalue.data(), rhs.value.data(), rhs.value.size()) == 0;
}

bool operator==(rfid_tag const& lhs, std::array<uint8_t, 4> const& tagvalue)
{
    return tagvalue == lhs;
}


static const std::array<rfid_tag, 3> known_tags = {
    rfid_tag{ { 0x00, 0x01, 0x02, 0x03 }, rfid_tag::red },
    rfid_tag{ { 0x10, 0x11, 0x12, 0x13 }, rfid_tag::blue },
    rfid_tag{ { 0x20, 0x21, 0x22, 0x23 }, rfid_tag::red }
};

int main()
{
    const std::array<uint8_t, 4> tag_to_find{ 0x10, 0x11, 0x12, 0x13 };
    std::cout << std::find(begin(known_tags), end(known_tags), tag_to_find)->color << "\n"; // outputs "11" as expected
}

demo

Answer 2

您可以使用id和颜色枚举创建结构：

enum class Color { red, green };

struct Tag
{
    uint8_t id[4];
    Color color;
};

Tag RED1 = { { 0x73, 0xD5, 0xB7, 0xAC }, Color::red } ;
Tag RED2 = { { 0x7E, 0x27, 0x49, 0x4E }, Color::red } ;
Tag RED3 = { { 0x02, 0xFD, 0x06, 0x40 }, Color::red } ;
Tag GREEN1 = { { 0xAB, 0xEC, 0x68, 0x80 }, Color::green } ;
Tag GREEN2 = { { 0xEE, 0x20, 0x50, 0x4E }, Color::green } ;
Tag GREEN3 = { { 0x27, 0x06, 0x40, 0x73 }, Color::green } ;

void test(Tag tag)
{
    if (tag.color == Color::red)
    {
        //
    }
    else if (tag.color == Color::green)
    {

    }
}

Answer 3

有多种方式。

您可以编写一个包含您的标记以及颜色的结构，如下所示：

struct ColoredTag
{
    uint8_t[4] value;
    std::string color;

} typename ColoredTag_t;

ColoredTag_t RED1 = {{ 0x73, 0xD5, 0xB7, 0xAC }, "Red"};
ColoredTag_t RED2 = {{ 0x7E, 0x27, 0x49, 0x4E }, "Red"};
ColoredTag_t RED3 = {{ 0x02, 0xFD, 0x06, 0x40  }, "Red"};
ColoredTag_t GREEN1 = {{ 0xAB, 0xEC, 0x68, 0x80 }, "Green"};
ColoredTag_t GREEN2 = {{ 0xEE, 0x20, 0x50, 0x4E }, "Green"};
ColoredTag_t GREEN3 = {{ 0x27, 0x06, 0x40, 0x73 }, "Green"};

或者，您可以使用std::map为标记指定颜色，例如

std map<uint8_t[4], std::string> tags;

public void fillTags()
{
    tags[RED1] = "Red";
    tags[RED2] = "Red";
    //...

}

std::string getColor(uint8_t tag)
{
    return tags[tag];

}

对于这个问题可能还有一些解决方案，但这些是我首先想到的。

将类型分配给uint8_t值

3 个答案: