HardwareSerial.h

Go to the documentation of this file.

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

#pragma once

#include <cstdint>
#include <Delegate.h>
#include <Data/Stream/ReadWriteStream.h>
#include <BitManipulations.h>
#include <driver/uart.h>

#define UART_ID_0 0 
#define UART_ID_1 1 

#define NUMBER_UARTS UART_COUNT 

#define SERIAL_PIN_DEFAULT UART_PIN_DEFAULT

class HardwareSerial;

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

using TransmitCompleteDelegate = Delegate<void(HardwareSerial& serial)>;

class CommandExecutor;

// clang-format off
#define SERIAL_CONFIG_MAP(XX) \
    XX(5N1) XX(6N1) XX(7N1) XX(8N1) XX(5N2) XX(6N2) XX(7N2) XX(8N2) XX(5E1) XX(6E1) XX(7E1) XX(8E1) \
    XX(5E2) XX(6E2) XX(7E2) XX(8E2) XX(5O1) XX(6O1) XX(7O1) XX(8O1) XX(5O2) XX(6O2) XX(7O2) XX(8O2)
// clang-format on

enum class SerialFormat {
#define XX(x) Fmt##x = UART_##x,
    SERIAL_CONFIG_MAP(XX)
#undef XX
};

#define XX(x) static constexpr SerialFormat SERIAL_##x{SerialFormat::Fmt##x};
SERIAL_CONFIG_MAP(XX)
#undef XX

enum class SerialMode {
    Full = UART_FULL,
    RxOnly = UART_RX_ONLY,
    TxOnly = UART_TX_ONLY,
};

static constexpr SerialMode SERIAL_FULL{SerialMode::Full};
static constexpr SerialMode SERIAL_RX_ONLY{SerialMode::RxOnly};
static constexpr SerialMode SERIAL_TX_ONLY{SerialMode::TxOnly};

#ifndef DEFAULT_RX_BUFFER_SIZE
#define DEFAULT_RX_BUFFER_SIZE 256
#endif

#ifndef DEFAULT_TX_BUFFER_SIZE
#define DEFAULT_TX_BUFFER_SIZE 0
#endif

#define SERIAL_STATUS_MAP(XX)                                                                                          \
    XX(BreakDetected, "Break condition detected on receive line")                                                      \
    XX(Overflow, "Receive buffer overflowed")                                                                          \
    XX(FramingError, "Receive framing error")                                                                          \
    XX(ParityError, "Parity check failed on received data")

enum class SerialStatus {
#define XX(tag, comment) tag,
    SERIAL_STATUS_MAP(XX)
#undef XX
};

#define XX(tag, comment) static constexpr SerialStatus eSERS_##tag{SerialStatus::tag};
SERIAL_STATUS_MAP(XX)
#undef XX

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

    ~HardwareSerial();

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

    int getPort()
    {
        return uartNr;
    }

    bool begin(uint32_t baud = 9600)
    {
        return begin(baud, SERIAL_8N1, SERIAL_FULL, SERIAL_PIN_DEFAULT);
    }

    bool begin(uint32_t baud, SerialFormat format)
    {
        return begin(baud, format, SERIAL_FULL, SERIAL_PIN_DEFAULT);
    }

    bool begin(uint32_t baud, SerialFormat format, SerialMode mode)
    {
        return begin(baud, format, mode, 1);
    }

    bool begin(uint32_t baud, SerialFormat format, SerialMode mode, uint8_t txPin, uint8_t rxPin = SERIAL_PIN_DEFAULT);

    void end();

    size_t setRxBufferSize(size_t size);

    size_t setTxBufferSize(size_t size);

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

    void swap()
    {
        swap(1);
    }

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

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

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

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

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

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

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

    bool isFinished() override
    {
        return false;
    }

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

    void clear(SerialMode mode = SERIAL_FULL)
    {
        smg_uart_flush(uart, smg_uart_mode_t(mode));
    }

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

    using Stream::write;

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

    void systemDebugOutput(bool enabled);

    void commandProcessing(bool reqEnable);

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

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

    __forceinline void setUartCallback(smg_uart_callback_t callback, void* param = nullptr)
    {
        smg_uart_set_callback(uart, callback, param);
    }

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

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

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

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

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

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

    smg_uart_t* getUart()
    {
        return uart;
    }

    unsigned getStatus();

private:
    int uartNr = UART_NO;
    TransmitCompleteDelegate transmitComplete = nullptr; 
    StreamDataReceivedDelegate HWSDelegate = nullptr;   
    CommandExecutor* commandExecutor = nullptr;          
    smg_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(smg_uart_t* uart, uint32_t status);
    static void staticOnStatusChange(void* param);
    void invokeCallbacks();

    bool updateUartCallback();
};

extern HardwareSerial Serial;