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)>;
 
// 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)
    {
    }
 
    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) 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) SMING_DEPRECATED
    {
    }
 
    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;   
    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;