HardwareSerial Class Reference

#include <HardwareSerial.h>

Inheritance diagram for HardwareSerial:

Collaboration diagram for HardwareSerial:

Public Member Functions
	HardwareSerial (void *peripheral)
void	begin (unsigned long baud)
void	begin (unsigned long, uint8_t)
virtual int	available (void)
virtual int	peek (void)
virtual int	read (void)
virtual void	flush (void)
virtual size_t	write (uint8_t)
	operator bool ()
Public Member Functions inherited from Stream
	Stream ()
void	setTimeout (unsigned long timeout)
unsigned long	getTimeout (void)
bool	find (const char *target)
bool	find (const uint8_t *target)
bool	find (const char *target, size_t length)
bool	find (const uint8_t *target, size_t length)
bool	find (char target)
bool	findUntil (const char *target, const char *terminator)
bool	findUntil (const uint8_t *target, const char *terminator)
bool	findUntil (const char *target, size_t targetLen, const char *terminate, size_t termLen)
bool	findUntil (const uint8_t *target, size_t targetLen, const char *terminate, size_t termLen)
long	parseInt (LookaheadMode lookahead=SKIP_ALL, char ignore=NO_IGNORE_CHAR)
float	parseFloat (LookaheadMode lookahead=SKIP_ALL, char ignore=NO_IGNORE_CHAR)
virtual size_t	readBytes (char *buffer, size_t length)
size_t	readBytes (uint8_t *buffer, size_t length)
virtual size_t	readBytesUntil (char terminator, char *buffer, size_t length)
size_t	readBytesUntil (char terminator, uint8_t *buffer, size_t length)
String	readString ()
String	readStringUntil (char terminator)
Public Member Functions inherited from Print
	Print ()
int	getWriteError ()
void	clearWriteError ()
size_t	write (const char *str)
virtual size_t	write (const uint8_t *buffer, size_t size)
size_t	write (const char *buffer, size_t size)
size_t	print (const __FlashStringHelper *)
size_t	print (const String &)
size_t	print (const char[])
size_t	print (char)
size_t	print (unsigned char, int=DEC)
size_t	print (int, int=DEC)
size_t	print (unsigned int, int=DEC)
size_t	print (long, int=DEC)
size_t	print (unsigned long, int=DEC)
size_t	print (double, int=2)
size_t	print (const Printable &)
size_t	println (const __FlashStringHelper *)
size_t	println (const String &s)
size_t	println (const char[])
size_t	println (char)
size_t	println (unsigned char, int=DEC)
size_t	println (int, int=DEC)
size_t	println (unsigned int, int=DEC)
size_t	println (long, int=DEC)
size_t	println (unsigned long, int=DEC)
size_t	println (double, int=2)
size_t	println (const Printable &)
size_t	println (void)
void	println (int64_t, uint8_t=DEC)
void	print (int64_t, uint8_t=DEC)
void	println (uint64_t, uint8_t=DEC)
void	print (uint64_t, uint8_t=DEC)

Additional Inherited Members
Protected Member Functions inherited from Stream
int	timedRead ()
int	timedPeek ()
int	peekNextDigit (LookaheadMode lookahead, bool detectDecimal)
long	parseInt (char ignore)
float	parseFloat (char ignore)
int	findMulti (struct MultiTarget *targets, int tCount)
Protected Member Functions inherited from Print
void	setWriteError (int err=1)
Protected Attributes inherited from Stream
unsigned long	_timeout
unsigned long	_startMillis

Constructor & Destructor Documentation

HardwareSerial()

HardwareSerial::HardwareSerial

(

void *

peripheral

)

                                               {
}

Member Function Documentation

begin() [1/2]

void HardwareSerial::begin

(

unsigned long

baud

)

                                             {
}

begin() [2/2]

void HardwareSerial::begin	(	unsigned long	baud,
		uint8_t	config
	)

                                                          {
}

available()

int HardwareSerial::available ( void  )

virtual

Implements Stream.

                                  {
    return rbufc;
}

peek()

int HardwareSerial::peek ( void  )

virtual

Implements Stream.

                             {
    return -1;
}

read()

int HardwareSerial::read ( void  )

virtual

Implements Stream.

                             {
    int ch = -1;
    if (rbufc) {
        ch = rbuff[rbufi++];
        rbufc--;
    }
    if (ch == -1)
        DBG(" rx -1");
    else
        DBG(" rx %02hhx %d", (uint8_t)ch, rbufc);
    return ch;
}

flush()

void HardwareSerial::flush ( void  )

virtual

Implements Stream.

                           {
}

write()

size_t HardwareSerial::write ( uint8_t  c )

virtual

Implements Print.

                                      {
    static int cnt = 0;
    static uint8_t buf[10];
    uint8_t buf2[20] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
    int len = 4;
    buf[cnt++] = c;
    if ((cnt > 2) && (buf[2] & 0x80))
        len = 8;
    if (cnt >= len) {
        int retry = 3;
        while (retry--) {
            if (len == 4)
                HAL_UART_Receive_DMA(&huart2, buf2, 12);
            else if (len == 8)
                HAL_UART_Receive_DMA(&huart2, buf2, 4);
            HAL_UART_Transmit(&huart2, buf, len, HAL_MAX_DELAY);
            if (len == 4) //
            {
                DBG("tx %02x %02x %02x %02x", buf[0], buf[1], buf[2], buf[3]);
                osEvent ose;
                if ((ose = osSignalWait(4, 100)).status == osEventSignal) {
                    DBG("signal, received %d", 12);
                    DBG("rx %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x", buf2[0], buf2[1], buf2[2], buf2[3], buf2[4], buf2[5], buf2[6], buf2[7], buf2[8], buf2[9], buf2[10], buf2[11]);
                    memcpy(rbuff, buf2 + 4, 8);
                    rbufi = 0;
                    rbufc = 8;
                    retry = 0;
                } else if (ose.status == osEventTimeout) {
                    DBG("timeout, received %d", hdma_usart2_rx.Instance->NDTR);
                    HAL_UART_AbortReceive(&huart2);
                }
            } else if (len == 8) //
            {
                DBG("tx %02x %02x %02x %02x %02x %02x %02x %02x", buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7]);
                osEvent ose;
                if ((ose = osSignalWait(4, 100)).status == osEventSignal) {
                    DBG("signal, received %d", 4);
                    DBG("rx %02x %02x %02x %02x", buf2[0], buf2[1], buf2[2], buf2[3]);
                    memcpy(rbuff, buf2, 8);
                    rbufi = 0;
                    rbufc = 4;
                    retry = 0;
                } else if (ose.status == osEventTimeout) {
                    DBG("timeout, received %d", hdma_usart2_rx.Instance->NDTR);
                    HAL_UART_AbortReceive(&huart2);
                }
            } else {
                DBG("error - (len!=4) && (len!=8)");
                HAL_UART_AbortReceive(&huart2);
            }
        }
        cnt = 0;
    }
    return 1;
}

Here is the call graph for this function:

operator bool()

HardwareSerial::operator bool

(

)

                              {
    return true;
}