write a Universal Serial class

Projects Programming
1

hello,

as we know under the hood a serial port can be a HardwareSerial, SoftwareSerial, Serial_ (from mkr series), USBSerial (from stm32 core). We know also that the serial depends on Stream, so i would like to write an agnostic serial class using it but i am facing some problems.

This is the header file UniversalSerial.h I am writing but i am not sure if i am going in the right direction, what do you think?

#ifndef UniversalSerial_h
#define UniversalSerial_h

class UniversalSerial
{
private:
    Stream &stream;

public:
    UniversalSerial(Stream &_stream) : stream(_stream) {}
    int available()
    {
        return stream.available();
    }
    int read()
    {
        return stream.read();
    }
    int flush()
    {
        return stream.flush();
    }

    void write(byte b)
    {
        stream.write(b);
    }

    void print(byte b)
    {
        stream.print(b);
    }

    void println(byte b)
    {
        stream.println(b);
    }
};

#endif

do you see an easier method to achieve this?

2

aster94:
do you see an easier method to achieve this?

What exactly are you trying to achieve? All you're doing here is repeating what Stream already does. I don't see the value added?

3

as we know under the hood a serial port can be a HardwareSerial, SoftwareSerial, Serial_ (from mkr series), USBSerial (from stm32 core).... i would like to write an agnostic serial class

4

IF you write your application correctly, it should neither know nor care what kind of underlying Serial device it is using. That is the entire point of abstraction, which is one of the core principles of object-oriented programming.

Regards,
Ray L.

5

Stream is already the class you want.

6

Juraj:
Stream is already the class you want.

Juraj I am quite luckly you are here, because looks like that the code i was using cames from you.
So the abstraction until Stream made by you is perfect. Now there are two more questions:

How can i abstract untill che class "Print" to have access to the whole "print" and "println" and friends? done!

How can i use the HardwareSerial "begin" and "end"? --> i think that this is a little difficult (or maybe i am just bad at programming) because begin and end cames from hardwareserial and i am using it's parent class (stream) is it possible to call these?

the arduino sketch

#include <uSerial.h>
uSerial aSerial(Serial);


void test_serial(uSerial *port)
{
    port->begin(115200); //Serial.begin(115200); works
    delay(100);
    port->available();
    port->print("test");
    port->peek();
    port->read();
    port->readString();
    port->write(0xFF);
    port->end();
}

void setup() { test_serial(&aSerial); }

void loop() {}

the uSerial.h

#ifndef uSerial_h
#define uSerial_h
// Original idea and code:
// https://arduino.stackexchange.com/questions/55742/passing-hardwareserial-and-softwareserial-as-a-class-property

#include <Arduino.h>

class uSerial
{

private:
    Stream &_stream;
    Print &_print;

public:
    uSerial(Stream &__stream) : _stream(__stream), _print(__stream)  {}

    void begin(unsigned long baudrate, uint16_t config = SERIAL_8N1)
    {
        begin(baudrate, config);
    }
    void end()
    {
        end();
    }
    int available()
    {
        return _stream.available();
    }
    int peek()
    {
        return _stream.peek();
    }
    int read()
    {
        return _stream.read();
    }
    String readString()
    {
        return _stream.readString();
    }
    String readStringUntil(char terminator)
    {
        return _stream.readStringUntil(terminator);
    }
    size_t write(uint8_t b)
    {
        return _stream.write(b);
    }
    size_t print(const char c[])
    {
        return _print.print(c);
    }
};

#endif
7

there is no common prototype for begin(). usually begin() is called before the instance is passed as Stream.

if the Stream instances you plan to use all have begin() with the same parameters then the only way you could call it universally is to use a template

8

I think that i am quite near, now the only thing that i am missing is how to make a template for the HardwareSerial, i tried a few possibilities but none seems to compile

class uSerial
{

private:
    HardwareSerial &_serial;
    Stream &_stream;
    Print &_print;

public:
    uSerial(HardwareSerial &__serial) : _serial(__serial), _stream(__serial), _print(__serial) {}

    void begin(unsigned long baudrate, uint16_t config = SERIAL_8N1)
    {
        _serial.begin(baudrate, config);
    }
    void end()
    {
        _serial.end();
    }
    int available()
    {
        return _stream.available();
    }
    int peek()
    {
        return _stream.peek();
    }
    int read()
    {
        return _stream.read();
    }
    String readString()
    {
        return _stream.readString();
    }
    String readStringUntil(char terminator)
    {
        return _stream.readStringUntil(terminator);
    }
    size_t write(uint8_t b)
    {
        return _stream.write(b);
    }
    size_t print(const char c[])
    {
        return _print.print(c);
    }
};

#endif
9

When you do figure it out, please let us know, I'd be interested to see what you come up with.

10

if you derive your class from Stream you get all functions which Serials inherit from Stream so you don't need to redirect them. Pure virtual function must be implemented (write, read, peek, available) and some functions are implemented in Serials so they should redirect (flush, availableForWrite)

template <class SomeSerial>
class uSerial : public Stream
{

private:
    SomeSerial &_serial;

public:
    uSerial(SomeSerial &__serial) : _serial(__serial) {}

    void begin(unsigned long baudrate, uint16_t config = SERIAL_8N1)
    {
        _serial.begin(baudrate, config);
    }
    void end()
    {
        _serial.end();
    }
    virtual int available()
    {
        return _serial.available();
    }
    virtual int peek()
    {
        return _serial.peek();
    }
    virtual int read()
    {
        return _serial.read();
    }
    virtual size_t write(uint8_t b)
    {
        return _serial.write(b);
    }
    virtual void flush()
    {
      _serial.flush();
    }
    virtual int availableForWrite() {
      return _serial.availableForWrite();
    }

};

uSerial<HardwareSerial> mySerial(Serial1);

void setup() {

}

void loop() {

}
11

I'm still struggling to see what value is being added by defining this new class. How about showing a use case that demonstrates it?

12

If you're writing a class to interface with a device that only operates on one specific baud. You can then use the class to automatically configure the port to that specific baud without the user needing to specify it in the sketch/setup(). If doing this in a library, this makes the code more or less foolproof.

13

Pure virtual function must be implemented (write, read, peek, available)

I understand, it is not impossible to reimplement all of them (it is just a work of copy and paste from the arduino-api repo) but all this just to have "begin" and "end"...

Inherit only Stream (and Print) would be far away simpler and easier to maintain in the case the arduino-api for Stream and Print changes at some point (which i really doubt considering how many application would crash).

Both have pro and contros, I honestly can't decide which one would be better.

I'm still struggling to see what value is being added by defining this new class. How about showing a use case that demonstrates it?

Sure, let's imagine you are writing a library that use the Serial functions (begin, end, print, read, etc) if you doesn't make a workaround as the one we are discussing here your library will complain.

Really when you use the "Serial" on an arduino UNO you are using a class that is called "HardwareSerial" but if you are on a new SAMD the class is called "Serial_". Your library won't work if you don't take care of these different classes.

A common workaround is to use a nested #define list, for exmaple:

#if defined(ARDUINO_ARCH_SAMD)
#define UniversalSerial Serial_
#else
#define UniversalSerial HardwareSerial
#endif

This would work on the 99% of cases, actually the only example which i can think where it won't work is on the STM32 that uses a USBSerial

14

aster94:

class uSerial

{

private:
    HardwareSerial &_serial;
    Stream &_stream;
    Print &_print;

public:
    uSerial(HardwareSerial &__serial) : _serial(__serial), _stream(__serial), _print(__serial) {}

The inheritance structure is HardwareSerial > Stream > Print.
There's no point in saving three different references to the same object, just use a single reference to HardwareSerial.

aster94:
Really when you use the "Serial" on an arduino UNO you are using a class that is called "HardwareSerial" but if you are on a new SAMD the class is called "Serial_". Your library won't work if you don't take care of these different classes.

A common workaround is to use a nested #define list, for exmaple:

#if defined(ARDUINO_ARCH_SAMD)

#define UniversalSerial Serial_
#else
#define UniversalSerial HardwareSerial
#endif




This would work on the 99% of cases, actually the only example which i can think where it won't work is on the STM32 that uses a USBSerial

Why wouldn't this work on STM32?
I still don't understand what you're actually trying to achieve.

There's no need for the preprocessor here, if you're interested in the type of the "Serial" object, you can just use:

using UniversalSerial = decltype(Serial);

Pieter

1 Like
15

As previously mentioned, a much better way to do this is to provide your library with a pointer (or Reference) to a Stream object. It then has the freedom to use all methods defined in the Stream and Print classes.

It's the user's responsibility to initialize the Stream object in their setup() code before using your class. So, if begin() is required, that's where it's called. In exchange for taking on this responsibility, the user gains the flexibility of using any object whose class inherits from Stream that they want. It could be HardwareSerial, SoftwareSerial, usb_serial_class, etc. Your library doesn't need to know, all it cares is that it has a Stream object to work with. That's the whole point of polymorphism.

16

just use a single reference to HardwareSerial

It won't work, try to compile this on a maple mini and tell me what you get

#include <Arduino.h>

void test_serial(HardwareSerial *port)
{
    port->begin(115200);
    delay(100);
    port->print("tes");
    port->write('t');
    port->available();
    port->read();
    port->readString();
    port->peek();
    port->end();
}

void setup() { test_serial(&Serial); }

void loop() {}

the output:

error: cannot convert 'USBSerial*' to 'HardwareSerial*' for argument '1' to 'void test_serial(HardwareSerial*)'

It's the user's responsibility to initialize the Stream object in their setup() code before using your class.

This is not always true. I have application (automotive protocols) that needs to begin and end a serial inside a function

17

aster94:
This is not always true. I have application (automotive protocols) that needs to begin and end a serial inside a function

Only because you're choosing to lock yourself into that inflexible paradigm.

18

why not something like

//#define SAMD_FLOW_CONTROL

// Emulate Serial1 on pins 6/7 if not present
#if defined(ARDUINO_ARCH_AVR) && !defined(HAVE_HWSERIAL1)
#include "SoftwareSerial.h"
SoftwareSerial SerialAT(6, 7); // RX, TX
#define AT_BAUD_RATE 9600
#elif defined(ARDUINO_ARCH_SAMD) && defined(SAMD_FLOW_CONTROL)
#include "wiring_private.h"
Uart SerialAT(&sercom3, 0, 1, SERCOM_RX_PAD_1, UART_TX_PAD_0, 2, 255);
#define AT_BAUD_RATE 115200
#else
#define SerialAT Serial1
#define AT_BAUD_RATE 115200
#endif

?

1 Like
19

aster94:
It won't work, try to compile this on a maple mini and tell me what you get

You'll get a similar error with the code I quoted.

20

gfvalvo:
It's the user's responsibility to initialize the Stream object in their setup() code before using your class.

No, not necessarily. Just because it's a common convention doesn't mean its the best thing to do in all scenarios.