fullduplexserial.h

Go to the documentation of this file.

 
#pragma once
 
#include <PropWare/PropWare.h>
#include <PropWare/serial/uart/uartcommondata.h>
#include <PropWare/hmi/output/printcapable.h>
#include <PropWare/hmi/input/scancapable.h>
 
namespace PropWare {
 
void *get_full_duplex_serial_driver ();
 
class FullDuplexSerial : public PrintCapable,
                         public ScanCapable {
    public:
        typedef enum {
            INVERT_RX            = BIT_0,
            INVERT_TX            = BIT_1,
            OPEN_DRAIN_SOURCE_TX = BIT_2,
            IGNORE_TX_ECHO_ON_RX = BIT_3
        } Mode;
 
        static const size_t BUFFER_SIZE = 16;
 
    public:
        FullDuplexSerial (const int rxPinNumber = _cfg_rxpin, const int txPinNumber = _cfg_txpin,
                          const uint32_t mode = 0, const int baudrate = _cfg_baudrate)
                : m_transmitLock(locknew()),
                  m_stringLock(locknew()),
                  m_cogID(-1),
                  m_receivePinNumber(rxPinNumber),
                  m_transmitPinNumber(txPinNumber),
                  m_mode(mode),
                  m_bitTicks(CLKFREQ / baudrate),
                  m_bufferPointer((uint32_t) this->m_receiveBuffer) {
        }
 
        ~FullDuplexSerial () {
            if (-1 != this->m_cogID)
                cogstop(this->m_cogID);
            lockret(this->m_transmitLock);
            lockret(this->m_stringLock);
        }
 
        int start () {
            return this->m_cogID = cognew(get_full_duplex_serial_driver(), (int32_t) (&this->m_receiveHead));
        }
 
        void truncate () {
            char c;
            while (this->get_char_non_blocking(c));
        }
 
        bool receive_ready () const {
            return this->m_receiveHead != this->m_receiveTail;
        }
 
        bool get_char_non_blocking (char &c) {
            if (this->receive_ready()) {
                c = this->m_receiveBuffer[this->m_receiveTail];
                this->m_receiveTail = (this->m_receiveTail + 1) & 0xf;
                return true;
            } else
                return false;
        }
 
        bool get_char (char &c, const unsigned int timeout) {
            const unsigned int startTime = CNT;
            bool               success;
            while (!(success = this->get_char_non_blocking(c))
                    && ((CNT - startTime) < timeout));
            return success;
        }
 
        char get_char () {
            char c;
            while (!this->get_char_non_blocking(c));
            return c;
        }
 
        void put_char (const char c) {
            // Send byte (may wait for room in buffer)
            while (lockset(this->m_transmitLock));
            while (this->m_transmitTail == ((this->m_transmitHead + 1) & 0xf));
            this->m_transmitBuffer[this->m_transmitHead] = c;
            this->m_transmitHead = (this->m_transmitHead + 1) & 0xf;
            lockclr(this->m_transmitLock);
            if (this->m_mode & IGNORE_TX_ECHO_ON_RX)
                this->get_char();
        }
 
        void puts (const char string[]) {
            const unsigned int length = strlen(string);
            while (lockset(this->m_stringLock));
            for (unsigned int i = 0; i < length; i++)
                this->put_char((string++)[0]);
            lockclr(this->m_stringLock);
        }
 
    protected:
        const uint8_t m_transmitLock;
        const uint8_t m_stringLock;
        int32_t       m_cogID;
        char          m_receiveBuffer[BUFFER_SIZE];
        char          m_transmitBuffer[BUFFER_SIZE];
 
        // These variables must appear in this order. The assembly code relies on the exact order
        volatile uint32_t m_receiveHead;
        volatile uint32_t m_receiveTail;
        volatile uint32_t m_transmitHead;
        volatile uint32_t m_transmitTail;
        const int         m_receivePinNumber;
        const int         m_transmitPinNumber;
        const uint32_t    m_mode;
        const uint32_t    m_bitTicks;
        const uint32_t    m_bufferPointer;
};
 
}