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.
 ****/

#ifndef _HARDWARESERIAL_H_
#define _HARDWARESERIAL_H_

#include "../Wiring/WiringFrameworkDependencies.h"
#include "../Wiring/Stream.h"
#include "../SmingCore/Delegate.h"
#include "../Services/CommandProcessing/CommandProcessingIncludes.h"

#define UART_ID_0   0 
#define UART_ID_1   1 

#define NUMBER_UARTS 2 

#define SERIAL_SIGNAL_DELEGATE  0 
#define SERIAL_SIGNAL_COMMAND   1 
#define SERIAL_QUEUE_LEN        10 


// Delegate constructor usage: (&YourClass::method, this)
typedef Delegate<void(Stream &source, char arrivedChar, uint16_t availableCharsCount)> StreamDataReceivedDelegate;

class CommandExecutor;

typedef struct
{
    StreamDataReceivedDelegate HWSDelegate; 
    CommandExecutor* commandExecutor = nullptr; 
} HWSerialMemberData;

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
};

class HardwareSerial : public Stream
{
public:
    HardwareSerial(const int uartPort);
    ~HardwareSerial();

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

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

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

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

    /*
     * @brief De-inits the current UART if it is already used
     */
    void end();

    /*
     * @brief Sets receiving buffer size
     * @param size_t requested size
     * @retval size_t actual size
     */
    size_t setRxBufferSize(size_t size);

    /*
     * @brief Toggle between use of GPIO13/GPIO15 or GPIO3/GPIO(1/2) as RX and TX
     * @note UART0 uses pins GPIO1 (TX) and GPIO3 (RX). It may be swapped to GPIO15 (TX) and GPIO13 (RX) by calling .swap() after .begin. C
     * @note Calling swap again maps UART0 back to GPIO1 and GPIO3.
     */
    void swap()
    {
        swap(1);
    }

    /*
     * @brief Toggle between use of GPIO13/GPIO15 or GPIO3/GPIO(1/2) as RX and TX
     * @param uint8_t Pin number.
     */
    void swap(uint8_t tx_pin);

    /*
     * @brief Toggle between use of GPIO1 and GPIO2 as TX on UART 0.
     * @note: UART 1 can't be used if GPIO2 is used with UART 0!
     * @note: If UART1 is not used and UART0 is not swapped - TX for UART0 can be mapped to GPIO2 by calling .setTx(2) after
     *        .begin or directly with .begin(baud, config, mode, 2).
     *
     */
    void setTx(uint8_t tx_pin);

    /*
     * @brief Sets the transmission and receiving PINS
     * @param uint8_t tx Transmission pin number
     * @param uint8_t rx Receiving pin number
     * @note UART 0 possible options are (1, 3), (2, 3) or (15, 13)
     * @note UART 1 allows only TX on 2 if UART 0 is not (2, 3)
     */
    void pins(uint8_t tx, uint8_t rx);


    int available();

    int read();

    int readMemoryBlock(char* buf, int max_len);

    int peek();

    void flush();

    size_t write(uint8_t oneChar);

    using Stream::write;

    void systemDebugOutput(bool enabled);

    void commandProcessing(bool reqEnable);

    bool setCallback(StreamDataReceivedDelegate reqCallback);

    void resetCallback();

    bool isTxEnabled(void);

    bool isRxEnabled(void);

    int baudRate(void);

    operator bool() const;

private:
    int uartNr;
    static HWSerialMemberData memberData[NUMBER_UARTS];

    uart_t* uart = nullptr;
    size_t rxSize;

    static os_event_t *serialQueue;

    static bool init;

    static void IRAM_ATTR callbackHandler(uart_t *arg);

    static void delegateTask (os_event_t *inputEvent);
};

extern HardwareSerial Serial;

#endif /* _HARDWARESERIAL_H_ */