UARTRX_Demo.cpp

Write "Hello world!" out via UART protocol and receive an echo

cmake_minimum_required(VERSION 3.12)
find_package(PropWare REQUIRED)
 
project(UARTRX_Demo)
 
create_simple_executable(${PROJECT_NAME} UARTRX_Demo.cpp)

 
#include <PropWare/concurrent/runnable.h>
#include <PropWare/PropWare.h>
#include <PropWare/gpio/simpleport.h>
#include <PropWare/serial/uart/uartrx.h>
#include <PropWare/serial/uart/uarttx.h>
#include <PropWare/hmi/output/synchronousprinter.h>
 
using PropWare::Port;
using PropWare::Pin;
using PropWare::UART;
using PropWare::Runnable;
using PropWare::UARTTX;
using PropWare::UARTRX;
using PropWare::SimplePort;
 
// Create the test string - useful when testing with a terminal
static const char                   TEST_STRING[] = "Hello, world!\n";
static const uint32_t               BAUD_RATE     = 115200;
static const Port::Mask   TX_PIN        = Port::Mask::P12;
static const Port::Mask   RX_PIN        = Port::Mask::P13;
static const UART::Parity PARITY        = UART::Parity::NO_PARITY;
 
static void error (const PropWare::ErrorCode err);
 
class Listener : public Runnable {
    public:
        template<size_t N>
        Listener (const uint32_t (&stack)[N])
                : Runnable(stack) {
        }
 
        void run () {
            PropWare::ErrorCode err;
            int32_t             receivedLength;
 
            this->init();
            pwSyncOut.printf("Ready to receive!\n");
 
            while (1) {
                receivedLength = sizeof(this->m_buffer);
                if ((err       = this->m_listener.fgets(this->m_buffer, &receivedLength)))
                    error(err);
 
                pwSyncOut.printf("Data (%d chars): \"%s\"\n", receivedLength, this->m_buffer);
            }
        }
 
        void init () {
            this->m_listener.set_rx_mask(RX_PIN);
            this->m_listener.set_baud_rate(BAUD_RATE);
            this->m_listener.set_parity(PARITY);
 
            // A very short wait to ensure the main cog has finished printing its "I'm ready" statement before we start
            // printing ours
            waitcnt(20 * MILLISECOND + CNT);
        }
 
    private:
        UARTRX m_listener;
        char             m_buffer[sizeof(TEST_STRING)];
};
 
int main () {
    uint32_t         threadStack[256];
    Listener         listener(threadStack);
    UARTTX speaker(TX_PIN);
 
    // Start our new cog and initialize the speaking UART
    speaker.set_baud_rate(BAUD_RATE);
    speaker.set_parity(PARITY);
    pwSyncOut.printf("New cog ID: %d. Ready to send!!!\n", Runnable::invoke(listener));
 
    while (1) {
        waitcnt(200 * MILLISECOND + CNT);
        speaker.puts(TEST_STRING);
    }
}
 
void error (const PropWare::ErrorCode err) {
    SimplePort debugLEDs(Port::P16, 8, Pin::Dir::OUT);
 
    pwSyncOut.printf("Unknown error: %u\n", err);
 
    while (1) {
        debugLEDs.write((uint32_t) err);
        waitcnt(100 * MILLISECOND);
        debugLEDs.write(0);
        waitcnt(100 * MILLISECOND);
    }
}