Question

我在微控制器上有不同的逻辑单元，必须能够相互通信。这些单位我将称之为组件。

每个组件都有一个消息队列，在编译时定义了固定大小。我不想要任何动态分配的内存。

每个组件都有一组消息槽。一个插槽可以有三种不同的状态：

未使用的
保留
可加工

如果组件A想要首先向组件B发送消息，则需要保留消息槽。它可以直接写入该槽的消息数据。最后，它需要将插槽设置为可处理的。现在，组件B可以处理数据并将插槽再次设置为未使用。订单很重要，但目前我忽略它。

class CommunicationManager {
public:
    CommunicationManager(ComponentManager& componentManager);
    MessageSlot * getMessageSlot(int componentId);

private:
    ComponentManager& componentManager;
};

class Component {
public:
    Component(CommunicationManager& communicationManager);
    virtual void process() = 0;
    MessageSlot * getMessageSlot();

    virtual ~Component();

protected:
    MessageQueue<5> messageQueue;
    CommunicationManager& communicationManager;
};

使用这些类完成消息传递。

template <int size>
class MessageQueue {
public:
    MessageSlot* reserveMessageSlot();
    MessageSlot * getProcessableMessageSlot();
    bool processableMessageSlotAvailable();

private:
    MessageSlot messageSlots[size];
};

class MessageSlot {
public:
    void reserve();
    bool isReserved();
    bool isProcessable();
    void setProcessable();
    void reset();

    Message * getMessage();
private:
    Message message;

    bool reserved;
    bool processable;
};

class Message {
public:
    int sender;
    int receiver;

    int length;
    char data[8];
};

这种沟通方式现在有效：

// sender part
MessageSlot * slot = communicationManger.getMessageSlot(SPI_COMPONENT_ID);
// fill message with data
slot->setProcessable();

// receiver part
MessageSlot * slot = messageQueue.getProcessableMessageSlot();
if (slot != 0) {
    // process message data
    // if processing was successful reset message slot
    slot->reset();
}

正如您现在所看到的，用户必须使用插槽类。你有任何隐藏实施的想法吗？我不想复制任何数据。

我的目标是这样的：

// sender
Message * msg = communicationManager.reserveMessage(SPI_COMPONENT_ID);
// fill message with data

如何表示可以处理此邮件？我不想要消息数据中的标志。我可以说在调用之后必须填充数据，因为没有真正的并行处理。但我不会这样开心。

// receiver part
Message * msg = messageQueue.getProcessableMessage();
if (msg != 0) {
    // process message data
    // if processing was successful reset message slot
    messageQueue.messageProcessed();
}

Answer 1

我会在这里找RAII。您可以使用在资源超出范围时清除资源的对象。作为一个部分例子：

发送：

class Request {
  friend class CommunicationManager;
  Request(MessageSlot* slot);
  MessageSlot* slot_;

 public:
    Request(Request&&);
    ~Request();
    // Functions to add data into the message
};
Request::Request(Request&& other) : slot_(other.slot_) { other.slot_ = nullptr; }
Request::Request(MessageSlot* slot) : slot_(slot) {}
Request::~Request() {
  if (slot_)
    slot_->setProcessable();
}

收到：

class Message {
  friend class MessageQueue;
  Message(MessageSlot* slot);
  MessageSlot* slot_;

 public:
    Message(Message&&);
    ~Message();
    explicit operator bool();
    // Functions to read data the message
};
Message::Message(Message&& other) : slot_(other.slot_) { other.slot_ = nullptr; }
Message::Message(MessageSlot* slot) : slot_(slot) {}
Message::~Message() {
  if (slot_)
    slot_->reset();
}
Message::operator bool() {
  return nullptr != slot_;
}

<强>用法：

{  // Any scope (function, condition, forced scope)
  Request req = communicationManager.reserveMessage(SPI_COMPONENT_ID);
  // Fill with data
}


{  // Any scope (function, condition, forced scope)
  Message msg = messageQueue.getProcessableMessage();
  if (msg) {
    // process message data
  }
}

静态消息队列

1 个答案: