HardwareSerial.h

Go to the documentation of this file.

 
#ifndef HardwareSerial_h
#define HardwareSerial_h
 
 
#ifndef YIELD
#define YIELD
#endif
 
#include "wirish.h"
#include <inttypes.h>
#include "Stream.h"
 
//Includes
#if defined(STM32F103xB)
//#include "stm32f1xx_hal.h"
 
#elif defined(STM32F031x6) || defined(STM32F070xB) || defined(STM32F070x6) || defined(STM32F030x6)
//#include "stm32f0xx_hal.h"
 
#elif defined(STM32L031xx)
//#include "stm32l0xx_hal.h"
 
#elif defined(STM32L432xx)
//#include "stm32l4xx_hal.h"
 
#else
#error "This library does not supports selected MCU." //This is here only, because some methods may not works with that chip.
#endif
 
#if defined(HAL_UART_MODULE_ENABLED) || defined(DOXYGEN_FORCED)
 
#define HS_RX_BUF_SIZE 128
 
 
#ifndef IS_LPUART_INSTANCE
#define IS_LPUART_INSTANCE(instance) (true)
#endif
 
//STM32F1xx have its own library and structures for USART and UART, so we need to implement it somehow
 
enum SerialMode {
    SERIAL_FULL = UART_MODE_TX_RX,
    SERIAL_RX_ONLY = UART_MODE_RX,
    SERIAL_TX_ONLY = UART_MODE_TX
};
 
typedef UART_InitTypeDef SerialConfig;
 
#ifdef __STM32F1xx_HAL_USART_H //code for STM32F1xx
 
typedef USART_InitTypeDef SSerialConfig;
#endif
 
#if !defined(__STM32F1xx_HAL_UART_H) && !defined(__STM32F1xx_HAL_USART_H) //code not for STM32F1xx
 
typedef UART_AdvFeatureInitTypeDef AdvSerialConfig;
#endif
 
class HardwareSerial: public Stream
{
public:
 
    HardwareSerial(UART_HandleTypeDef& uart);
 
#ifdef __STM32F1xx_HAL_USART_H //code for STM32F1xx
    HardwareSerial(USART_HandleTypeDef& usart);
 
#endif
 
    ~HardwareSerial();
 
 
    bool connectDMAtoRx(DMA_HandleTypeDef &DMA_handle);
 
    bool connectDMAtoTx(DMA_HandleTypeDef &DMA_handle);
 
    bool disconnectDMAfromRx(){
        return disconnectDMAfromRx(true);
    }
 
    bool disconnectDMAfromTx();
 
    bool isDMAconnectedToRx(void);
 
    bool isDMAconnectedToTx(void);
 
    bool begin();
 
    bool begin(unsigned long baud);
 
    bool begin(unsigned long baud, SerialMode mode);
 
#if defined(__STM32F1xx_HAL_USART_H) //code for STM32F1xx
 
    bool begin(SSerialConfig config);
 
    bool begin(unsigned long baud, SSerialConfig config);
#endif
 
    bool begin(SerialConfig config);
 
    bool begin(unsigned long baud, SerialConfig config);
 
#if !defined(__STM32F1xx_HAL_UART_H) && !defined(__STM32F1xx_HAL_USART_H) //code not for STM32F1xx
 
    bool begin(SerialConfig config, AdvSerialConfig advConfig);
 
 
    bool begin(unsigned long baud, AdvSerialConfig advConfig);
 
    bool begin(unsigned long baud, SerialConfig config, AdvSerialConfig advConfig);
 
    bool begin(unsigned long baud, SerialMode mode, AdvSerialConfig advConfig);
 
    bool begin(unsigned long baud, SerialConfig config, SerialMode mode, AdvSerialConfig advConfig);
#endif
 
 
    void end();
 
    bool updateBaudRate(unsigned long baud);
 
    size_t getRxBufferSize()
    {
        return HS_RX_BUF_SIZE;
    }
 
    int available(void) override;
 
 
    bool bufferOverflowed();
 
    int peek(void) override;
 
    int read(void) override;
 
    size_t read(char* buffer, size_t size);
 
    size_t read(uint8_t* buffer, size_t size)
    {
        return read((char*)buffer, size);
    }
 
    size_t readBytes(char* buffer, size_t size) override;
 
    size_t readBytes(uint8_t* buffer, size_t size) override
    {
        return readBytes((char*)buffer, size);
    }
 
    void flush(uint32_t timeout = 0);
 
    size_t write(uint8_t c) override;
 
    size_t write(const uint8_t *buffer, size_t size) override;
 
    size_t writeNonBlocking(const uint8_t* buffer, size_t size);
 
    size_t writeNonBlocking(const char* buffer, size_t size);
 
    bool isSending();
 
 
    using Print::write; // Import other write() methods to support things like write(0) properly
 
 
    operator bool() const
    {
#ifdef __STM32F1xx_HAL_USART_H //code for STM32F1xx
        if(!_isUart){ //usart
            return (_usart != NULL) && ((IS_UART_INSTANCE(_usart->Instance)) || (IS_LPUART_INSTANCE(_usart->Instance)));
        }
        else{ //uart
            return (_uart != NULL) && ((IS_UART_INSTANCE(_uart->Instance)) || (IS_LPUART_INSTANCE(_uart->Instance)));
        }
#else
        return (_uart != NULL) && ((IS_UART_INSTANCE(_uart->Instance)) || (IS_LPUART_INSTANCE(_uart->Instance)));
#endif
    }
 
    inline bool instanceExists(){
#ifdef __STM32F1xx_HAL_USART_H //code for STM32F1xx
        if(!_isUart){ //usart
            return (_usart != NULL) && ((IS_UART_INSTANCE(_usart->Instance)) || (IS_LPUART_INSTANCE(_usart->Instance)));
        }
        else{ //uart
            return (_uart != NULL) && ((IS_UART_INSTANCE(_uart->Instance)) || (IS_LPUART_INSTANCE(_uart->Instance)));
        }
#else
        return (_uart != NULL) && ((IS_UART_INSTANCE(_uart->Instance)) || (IS_LPUART_INSTANCE(_uart->Instance)));
#endif
    }
 
    bool isTxEnabled(void)
    {
#ifdef __STM32F1xx_HAL_USART_H //code for STM32F1xx
        if(!_isUart){ //usart
            return _usart->Init.Mode == SERIAL_FULL || _usart->Init.Mode == SERIAL_TX_ONLY;
        }
        else{ //uart
            return _uart->Init.Mode == SERIAL_FULL || _uart->Init.Mode == SERIAL_TX_ONLY;
        }
#else
        return _uart->Init.Mode == SERIAL_FULL || _uart->Init.Mode == SERIAL_TX_ONLY;
#endif
 
    }
 
    bool isRxEnabled(void)
    {
#ifdef __STM32F1xx_HAL_USART_H //code for STM32F1xx
        if(!_isUart){ //usart
            return _usart->Init.Mode == SERIAL_FULL || _usart->Init.Mode == SERIAL_RX_ONLY;
        }
        else{ //uart
            return _uart->Init.Mode == SERIAL_FULL || _uart->Init.Mode == SERIAL_RX_ONLY;
        }
#else
        return _uart->Init.Mode == SERIAL_FULL || _uart->Init.Mode == SERIAL_RX_ONLY;
#endif
    }
 
    uint32_t getClockInstFrequency();
 
    int baudRate(void)
    {
#ifdef __STM32F1xx_HAL_USART_H //code for STM32F1xx
        if(!_isUart){ //usart
            return _usart->Init.BaudRate;
        }
        else{ //uart
            return _uart->Init.BaudRate;
        }
#else
        return _uart->Init.BaudRate;
#endif
    }
 
    bool hasError(void)
    {
#ifdef __STM32F1xx_HAL_USART_H //code for STM32F1xx
        if(!_isUart){ //usart
            return _usart->ErrorCode != HAL_USART_ERROR_NONE;
        }
        else{ //uart
            return _uart->ErrorCode != HAL_UART_ERROR_NONE;
        }
#else
        return _uart->ErrorCode != HAL_UART_ERROR_NONE;
#endif
 
    }
 
   void  setWriteDoneCallback(void (* WriteDoneCallback_)() );
 
    //Advanced funkcie potrebné pre RXFULL callback
 
    static inline void handleRxFullCallback(USART_TypeDef* instance);
 
    static inline void handleRxFullCallback(uint32_t UARTIndex);
 
    static inline void handleTxDoneCallback(USART_TypeDef* instance);
 
    static inline void handleTxDoneCallback(uint32_t UARTIndex);
 
    static uint32_t getUARTIndex(USART_TypeDef* instance);
 
    static HardwareSerial** getUARTInstances(); //returns pointer to instances
 
    static uint8_t getAvailableUARTsCount();
 
    UART_HandleTypeDef& getHAL_UART_Struct(){
        return *_uart;
    }
 
#ifdef __STM32F1xx_HAL_USART_H //code for STM32F1xx
 
    USART_HandleTypeDef& getHAL_USART_Struct(){
        return *_usart;
    }
#endif
 
 
protected:
    UART_HandleTypeDef* _uart;
 
#ifdef __STM32F1xx_HAL_USART_H //code for STM32F1xx
 
    USART_HandleTypeDef* _usart;
 
 
    bool _isUart;
#endif
 
 
    uint8_t rxBuf[HS_RX_BUF_SIZE];
 
 
    volatile uint16_t rxBufOVFCNT = 0;
 
 
    uint16_t RxBufferReadPos = 0;
 
#ifdef __STM32F1xx_HAL_USART_H //code for STM32F1xx
 
    void UART_EndRxTransfer(USART_HandleTypeDef *huart);
 
    void UART_EndTxTransfer(USART_HandleTypeDef *huart);
#endif
 
    void UART_EndRxTransfer(UART_HandleTypeDef *huart);
 
    void UART_EndTxTransfer(UART_HandleTypeDef *huart);
 
    void abortDMARx();
 
    void abortDMATx();
 
    bool disconnectDMAfromRx(bool startRxIT = true);
 
    void (* WriteDoneCallback)() = NULL;
 
    void UART_RxFullCallback();
 
 
    void addThisToInstArr();
 
    void removeThisFromInstArr();
 
    static HardwareSerial* instances[]; //There are stored pointers to all created instances of this class
 
    static uint8_t availableUARTsCount;
 
    size_t widthCheck(size_t width_) override;
};
 
void HS_UART_AbortReceive_IT(UART_HandleTypeDef* huart);
 
#ifdef __STM32F1xx_HAL_USART_H //code for STM32F1xx
 
void HS_UART_AbortReceive_IT(USART_HandleTypeDef* huart);
#endif
 
#endif
#endif