HardwareSerial.h

/****
 * Sming Framework Project - Open Source framework for high efficiency native ESP8266 development.
 * Created 2015 by Skurydin Alexey
 * http://github.com/anakod/Sming
 * All files of the Sming Core are provided under the LGPL v3 license.
 *
 * HardwareSerial.h
 *
 ****/

#ifndef _SMING_CORE_HARDWARE_SERIAL_H_
#define _SMING_CORE_HARDWARE_SERIAL_H_

#include "WiringFrameworkDependencies.h"
#include "Data/Stream/ReadWriteStream.h"
#include "Delegate.h"
#include "espinc/uart.h"

#define UART_ID_0 0 
#define UART_ID_1 1 

#define NUMBER_UARTS UART_COUNT 

class HardwareSerial;

typedef Delegate<void(Stream& source, char arrivedChar, uint16_t availableCharsCount)> StreamDataReceivedDelegate;

typedef Delegate<void(HardwareSerial& serial)> TransmitCompleteDelegate;

class CommandExecutor;

enum SerialConfig {
    SERIAL_5N1 = UART_5N1,
    SERIAL_6N1 = UART_6N1,
    SERIAL_7N1 = UART_7N1,
    SERIAL_8N1 = UART_8N1,
    SERIAL_5N2 = UART_5N2,
    SERIAL_6N2 = UART_6N2,
    SERIAL_7N2 = UART_7N2,
    SERIAL_8N2 = UART_8N2,
    SERIAL_5E1 = UART_5E1,
    SERIAL_6E1 = UART_6E1,
    SERIAL_7E1 = UART_7E1,
    SERIAL_8E1 = UART_8E1,
    SERIAL_5E2 = UART_5E2,
    SERIAL_6E2 = UART_6E2,
    SERIAL_7E2 = UART_7E2,
    SERIAL_8E2 = UART_8E2,
    SERIAL_5O1 = UART_5O1,
    SERIAL_6O1 = UART_6O1,
    SERIAL_7O1 = UART_7O1,
    SERIAL_8O1 = UART_8O1,
    SERIAL_5O2 = UART_5O2,
    SERIAL_6O2 = UART_6O2,
    SERIAL_7O2 = UART_7O2,
    SERIAL_8O2 = UART_8O2,
};

enum SerialMode { SERIAL_FULL = UART_FULL, SERIAL_RX_ONLY = UART_RX_ONLY, SERIAL_TX_ONLY = UART_TX_ONLY };

#ifndef DEFAULT_RX_BUFFER_SIZE
#define DEFAULT_RX_BUFFER_SIZE 256
#endif

#ifndef DEFAULT_TX_BUFFER_SIZE
#define DEFAULT_TX_BUFFER_SIZE 0
#endif

enum SerialStatus {
    eSERS_BreakDetected = UIBD, 
    eSERS_Overflow = UIOF,      
    eSERS_FramingError = UIFR,  
    eSERS_ParityError = UIPE,   
};

class HardwareSerial : public ReadWriteStream
{
public:
    HardwareSerial(int uartPort) : uartNr(uartPort)
    {
    }

    ~HardwareSerial();

    void setPort(int uartPort)
    {
        end();
        uartNr = uartPort;
    }

    int getPort()
    {
        return uartNr;
    }

    void begin(uint32_t baud = 9600)
    {
        begin(baud, SERIAL_8N1, SERIAL_FULL, 1);
    }

    void begin(uint32_t baud, SerialConfig config)
    {
        begin(baud, config, SERIAL_FULL, 1);
    }

    void begin(uint32_t baud, SerialConfig config, SerialMode mode)
    {
        begin(baud, config, mode, 1);
    }

    void begin(uint32_t baud, SerialConfig config, SerialMode mode, uint8_t txPin);

    void end();

    size_t setRxBufferSize(size_t size);

    size_t setTxBufferSize(size_t size);

    void setTxWait(bool wait)
    {
        bitWrite(options, UART_OPT_TXWAIT, wait);
        uart_set_options(uart, options);
    }

    void swap()
    {
        swap(1);
    }

    void swap(uint8_t tx_pin)
    {
        uart_swap(uart, tx_pin);
    }

    void setTx(uint8_t tx_pin)
    {
        uart_set_tx(uart, tx_pin);
    }

    void pins(uint8_t tx, uint8_t rx)
    {
        uart_set_pins(uart, tx, rx);
    }

    int available() override
    {
        return (int)uart_rx_available(uart);
    }

    int read() override
    {
        return uart_read_char(uart);
    }

    uint16_t readMemoryBlock(char* buf, int max_len) override
    {
        return uart_read(uart, buf, max_len);
    }

    bool seek(int len) override
    {
        return false;
    }

    bool isFinished() override
    {
        return false;
    }

    int peek() override
    {
        return uart_peek_char(uart);
    }

    void clear(SerialMode mode = SERIAL_FULL)
    {
        uart_flush(uart, uart_mode_t(mode));
    }

    void flush() override // Stream
    {
        uart_wait_tx_empty(uart);
    }

    using Stream::write;

    size_t write(const uint8_t* buffer, size_t size) override
    {
        return uart_write(uart, buffer, size);
    }

    void systemDebugOutput(bool enabled);

    void commandProcessing(bool reqEnable);

    bool setCallback(StreamDataReceivedDelegate dataReceivedDelegate)
    {
        return onDataReceived(dataReceivedDelegate);
    }

    bool onDataReceived(StreamDataReceivedDelegate dataReceivedDelegate)
    {
        this->HWSDelegate = dataReceivedDelegate;
        return updateUartCallback();
    }

    bool onTransmitComplete(TransmitCompleteDelegate transmitCompleteDelegate)
    {
        this->transmitComplete = transmitCompleteDelegate;
        return updateUartCallback();
    }

    __forceinline void setUartCallback(uart_callback_t callback, void* param = nullptr)
    {
        uart_set_callback(uart, callback, param);
    }

    bool isTxEnabled()
    {
        return uart_tx_enabled(uart);
    }

    bool isRxEnabled()
    {
        return uart_rx_enabled(uart);
    }

    uint32_t baudRate()
    {
        return uart_get_baudrate(uart);
    }

    uint32_t setBaudRate(uint32_t baudrate)
    {
        return uart_set_baudrate(uart, baudrate);
    }

    operator bool() const
    {
        return uart != nullptr;
    }

    int indexOf(char c) override
    {
        return uart_rx_find(uart, c);
    }

    uart_t* getUart()
    {
        return uart;
    }

    unsigned getStatus()
    {
        return uart_get_status(uart);
    }

private:
    int uartNr = -1;
    TransmitCompleteDelegate transmitComplete = nullptr; 
    StreamDataReceivedDelegate HWSDelegate = nullptr;   
    CommandExecutor* commandExecutor = nullptr;          
    uart_t* uart = nullptr;
    uart_options_t options = _BV(UART_OPT_TXWAIT);
    size_t txSize = DEFAULT_TX_BUFFER_SIZE;
    size_t rxSize = DEFAULT_RX_BUFFER_SIZE;
    volatile uint16_t statusMask = 0;    
    volatile uint16_t callbackStatus = 0; 
    volatile bool callbackQueued = false;

    static void IRAM_ATTR staticCallbackHandler(uart_t* uart, uint32_t status);
    static void staticOnStatusChange(uint32_t param);
    void invokeCallbacks();

    bool updateUartCallback();
};

extern HardwareSerial Serial;

#endif /* _SMING_CORE_HARDWARE_SERIAL_H_ */