c - UART ISRTxRxアーキテクチャ

Question

私は物事を複雑にしていますか？

私は、8051マイクロからUARTを介して周辺機器と通信するようにコードを設計しています。周辺機器はホストからのコマンドに応答し、一度に1つのコマンドにしか応答できません。これは単純な送受信プロトコルです。（tx1、rx1、tx2、rx2、tx3、rx3）各TXメッセージはCRで終了し、各応答は>で終了します。最後のメッセージへの応答を受信するまで、新しいメッセージを送信できません。そのオプションを有効にすると、応答は最初に元のTXメッセージをエコー印刷することもできます（ただし、これによりトラフィックが増加します）

メッセージの例は次のとおりです。

• TX：こんにちは
• RX：ワールド！>

またはエコーオプション付き...

• TX：こんにちは
• RX：こんにちは\ rWorld！>

オプション AgetHelloなどの関数は、送信と受信の両方で構成されます。並列ISRルーチンは、着信バイトを収集し、「>」文字を受信するとフラグをスローします。

char* getHello(char * buf){
    sendMsg("Hello\r");
    delay(10ms); //wait a little bit

    //wait for receive to come in or timeout to occur
    while(!receiveFlag || !timeoutFlag);  //thrown by ISR
    receiveMsg(buf);
    //parse the message and do some other stuff
    return buf;
}

長所：

• すべてが1つの関数に含まれています。
• デバッグが簡単

短所：

• この関数はブロックされており、ペリフェラルが応答しない場合はハングする可能性があるため、タイムアウトを実装する必要があります。
• メッセージは順不同で受信できません。直列である必要があります（つまり、tx1、rx1、tx2、rx2、tx3、rx3）

オプションB 並列アプローチが採用されています。2つの別々の関数が作成されます。1つはメッセージを送信するためのもので、もう1つはISRからの応答を受信したときに頂点に達するものです。

void sendHello(){
    sendMsg("Hello\r");
    //do some other stuff if needed
}

char* receiveMsg(char * buf){
    //figure out from echo print what the tx message was
    //use a switch statement to decide which response parser to call
    switch(txMessage){ //pseudo code
    case "Hello":
        receiveMsg(buf);
        //parse the message and do some other stuff
        break;
    }
    return buf;
}

長所：

• 解析方法を理解するためにtxメッセージのエコー印刷に依存しているため、順序が狂って戻ってくる並列メッセージを処理できます。（すなわち、tx1、tx2、tx3、rx1、rx2、rx3）

短所：

• デバッグが非常に難しい
• 複数のスレッドを生成します
• たくさんの余分なコード
• メッセージは間違いなく順番に戻ってくるので、それだけの価値はありません

---

現在、オプションBを行っていますが、プロジェクトを続けるうちに、これが非常に複雑になっているように感じ始めます。私はあなたたちがどう思うか興味があります。

ありがとう！

Answer 1

私はこの種のことをする傾向がありますが、Idは別個のシリアルポート「クラス」（構造体+関数）とシリアルポートの上に存在するプロトコルクラスを持っている傾向があります。私はこれらを組み込みシステムで常に使用していました。これにより、ブロッキング同期呼び出しと非同期呼び出しの両方の長所が得られるため、疑似マルチタスクを実行できます。

typedef struct serial_port_s serial_port;
typedef void (*serial_on_recived_proc)(serial_port* p);
typedef struct serial_port_s{
    bool timeoutFlag;
    bool receiveFlag;
    void* context;
    serial_on_recived_proc response_handler;
};

void send_serial(serial_port* p, char* message)
{
    //SendMsg?
}
void receive_serial(serial_port* p, char* response)
{
    //receiveMsg?
}

bool has_data(serial_port* p)
{
    return p->receiveFlag;
}

bool has_timed_out(serial_port* p)
{
    return p->timeoutFlag;
}
bool is_serial_finished(serial_port* p)
{
    return has_data(p) || has_timed_out(p); 
}

bool serial_check(serial_port* p)
{
    if(is_serial_finished(p) && p->response_handler != NULL)
    {
       p->response_handler(p)
       p-> response_handler = NULL;
       return true;
    }
    return false;
}

void send(serial_port* p, char* message, char* response)
{
    p->response_handler=NULL;
    send_serial(p, message);
    while(!is_serial_finished(p));
    receive_serial(p, response);
}

void sendAsync(serial_port* p, char* message, serial_on_recived_proc handler, void* context)
{
    p->response_handler = handler;
    p->context = context;
    send_serial(p, message);
}

void pow_response(serial_port* p)
{
    // could pass a pointer to a struct, or anything depending on what you want to do
    char* r = (char*)p->context;  
    receive_serial(p, r);
    // do stuff with the pow response
}

typedef struct
{
   char text[100];       
   int x;
   bool has_result;
} bang_t;

void bang_parse(bang_t* bang)
{
   bang->x = atoi(bang->text);
}

void bang_response(serial_port* p)
{
    bang_t* bang = (bang_t*)p->context;  
    receive_serial(p, bang->text);
    bang_parse(bang);
    bang->has_result=true;
}

void myFunc();
{
    char response[100];
    char pow[100];
    bang_t bang1;
    bang_t bang2;
    serial_port p; //
    int state = 1;
    // whatever you need to do to set the serial port

    // sends and blocks till a response/timeout
    send(&p, "Hello", response);
    // do what you like with the response

    // alternately, lets do an async send...
    sendAsync(&p, "Pow", pow_response, pow);       

    while(true)
    {
        // non block check, will process the response when it arrives               
        if(serial_check(p))
            {
              // it has responded to something, we can send something else...

              // using a very simple state machine, work out what to send next.
              // in practice I'd use enum for states, and functions for managing state
              // transitions, but for this example I'm just using an int which
              // I just increment to move to the next state
              switch(state)
              {
              case 1: 
                 // bang1 is the context, and will receive the data
                 sendAsync(&p, "Bang1", bang_response, &bang1);
                 state++; 
                 break;
              case 2:
                 // now bang2 is the context and will get the data...
                 sendAsync(&p, "Bang2", bang_response, &bang2);
                 state++; 
                 break;
              default:
                 //nothing more to send....
                 break;
              }
            }
        // do other stuff you want to do in parallel
    }
};

Answer 2

物事を単純にしてください。ISRルーチンは非常に高速である必要があるため、私にとって最善のアプローチは、次のようなグローバルRXBufferを使用することです。

#include <cstdint>
#include <deque>
#include <algorithm>

class RXBuffer {
public:
    friend class ISR;

    typedef std::deque<uint8_t>::const_iterator const_iterator;

    RXBuffer();
    size_t size() const { m_buffer.size(); }

    // read from the buffer in a container in the range [first, last)
    template <typename Iterator>
    void read(Iterator first, Iterator last, Iterator to)
    {
        // how many bytes do you want to read?
        size_t bytes_to_read = std::distance(first, last);

        if (bytes_to_read >= size())
        {
            // read the whole buffer
            std::copy(begin(), end(), first);

            // empty the buffer
            m_buffer.clear();

            return size();
        }
        else
        {
            // copy the data
            copy(begin(), begin() + bytes_to_read, firt);

            // now enque the element
            m_buffer.erase(begin(), begon() + bytes_to_read);

            return bytes_to_read;
        }
    }

private:
    void put(uint8_t data)
    {
        // check buffer overflow
        m_buffer.push_back(data);
    }

    const_iterator begin() const { return m_buffer.begin(); }
    const_iterator end() const { return m_buffer.end(); }

private:
    std::deque<uint8_t> m_buffer;           // buffer where store data
    size_t m_size;                          // effective size of the container
};

class ISR {
public:
    ISR(RXBuffer& buffer) : m_buffer(buffer) {}

    // ISR Routine
    void operator () (uint8_t data)
    {
        m_buffer.put(data);
    } 

private:
    RXBuffer& m_buffer;
};
RXBuffer g_uart1_rx_buffer;

これで、データを検索するISRとRXBufferができたので、UART関数をラップするための何かが必要です。次のように実装できます。

class UART {
public:
    UART(unsigned int uart_device, RXBuffer& rx_buffer) :
        m_uart(uart_device), m_buffer(rx_buffer)
    {
    }

    unsigned int uart_device() const { return m_uart; }

    // set the timeout during a read operation
    void timeout(unsigned ms) { m_timer.countdown(ms); }

    template <typename InputIterator>
    void read(InputIterator first, InputIterator last)
    {
        // start the timer
        m_timer.start();

        size_t size = std::distance(first, last);
        size_t read_bytes = 0;

        while (read_bytes != size && !m_timer.is_expired())
        {
            read_bytes += m_buffer.read(first + read_bytes, last);
        }

        if (read_bytes != size) throw std::exception("timeout");
    }

    template <typename OutputIterator>
    void send(OutputIterator first, OutputIterator last)
    {
        size_t size = std::distance(first, last);
        uart_send(m_uart, &(*first), size);
    }

private:
    unsigned int m_uart;
    RXBuffer& m_buffer;
    timer m_timer;
};