Fundamental Problem

[ghaug]

Hi Rob,
I just got around to testing the wrapper. Unfortunately it doesn't work and I'm afraid, there is a fundamental problem. The requestFrom functions of TwoWire are not virtual so calls to these functions (e.g. in SHT31, which I used to test) are bound early by gcc. When SHT31.cpp is compiled the only implementation of requestFrom known to gcc is the one in TwoWire and as it is not declared virtual, the compiler inserts a call directly to this implementation.

[RobTillaart]

Sorry for the late reaction, my agenda has filled up and I hope to find some time later this week.

[RobTillaart]

found a split second ;)

did some reading and you are 100% right - https://www.programiz.com/cpp-programming/function-overriding

• you can override non-virtual functions only if called directly from the derived class object
• if you assign a derived class (Pointer) to a base class pointer - which is done in this "experiment" - then the base class function is called. This is not only for the requestFrom() functions and all non-virtual TwoWire functions.

So indeed it will not work.

Now think really hard .........

[RobTillaart]

So it will only work if the base class has its functions declared virtual

So I did just that - as experiment in Wire.h

class TwoWire : public Stream
{
  private:
    static uint8_t rxBuffer[];
    static uint8_t rxBufferIndex;
    static uint8_t rxBufferLength;

    static uint8_t txAddress;
    static uint8_t txBuffer[];
    static uint8_t txBufferIndex;
    static uint8_t txBufferLength;

    static uint8_t transmitting;
    static void (*user_onRequest)(void);
    static void (*user_onReceive)(int);
    static void onRequestService(void);
    static void onReceiveService(uint8_t*, int);
  public:
    TwoWire();
    virtual void begin();
    void begin(uint8_t);
    void begin(int);
    virtual void end();
    virtual void setClock(uint32_t);
    virtual void setWireTimeout(uint32_t timeout = 25000, bool reset_with_timeout = false);
    virtual bool getWireTimeoutFlag(void);
    virtual void clearWireTimeoutFlag(void);
    virtual void beginTransmission(uint8_t);
    virtual void beginTransmission(int);
    virtual uint8_t endTransmission(void);
    virtual uint8_t endTransmission(uint8_t);
    virtual uint8_t requestFrom(uint8_t, uint8_t);
    virtual uint8_t requestFrom(uint8_t, uint8_t, uint8_t);
    virtual uint8_t requestFrom(uint8_t, uint8_t, uint32_t, uint8_t, uint8_t);
    virtual uint8_t requestFrom(int, int);
    virtual uint8_t requestFrom(int, int, int);
    virtual size_t write(uint8_t);
    virtual size_t write(const uint8_t *, size_t);
    virtual int available(void);
    virtual int read(void);
    virtual int peek(void);
    virtual void flush(void);
    void onReceive( void (*)(int) );
    void onRequest( void (*)(void) );

    inline size_t write(unsigned long n) { return write((uint8_t)n); }
    inline size_t write(long n) { return write((uint8_t)n); }
    inline size_t write(unsigned int n) { return write((uint8_t)n); }
    inline size_t write(int n) { return write((uint8_t)n); }
    using Print::write;
};

extern TwoWire Wire;

#endif

Tested with a DHT20 sensor

Type	Humidity (%)	Temp (°C)	Time (µs)	Status
DHT20 	57.2		17.7		46596		OK
ADDR1:56ET1:DHT20 	57.2		17.7		46600		OK
ADDR1:56ET1:DHT20 	57.1		17.7		46592		OK
ADDR1:56ET1:DHT20 	57.0		17.7		46600		OK
ADDR1:56ET1:DHT20 	56.9		17.7		46600		OK
ADDR1:56ET1:DHT20 	56.9		17.7		46600		OK
ADDR1:56ET1:DHT20 	56.8		17.7		46596		OK
ADDR1:56ET1:DHT20 	56.8		17.7		46600		OK
ADDR1:56ET1:DHT20 	56.7		17.7		46600		OK
ADDR1:56ET1:DHT20 	56.6		17.7		46600		OK

So that works...

Question is: how to continue....

[ghaug]

Yes, in fact I had the same idea in the very beginning. I thought it might be possible to derive SoftWire from TwoWire instead of Stream but that failed for the same reason. I don't think it's possible to change TwoWire, so I don't have a solution either.

[RobTillaart]

I don't think it's possible to change TwoWire

did look into the Arduino repo and found this

• Declare TwoWire functions as virtual arduino/ArduinoCore-avr#396 (add virtual)
• Revert "Declare TwoWire functions as virtual" arduino/ArduinoCore-avr#412 (revert 396)

So I think that route has been walked before.

[RobTillaart]

A solution not discussed is to create a SoftwareWire specific SHT31_SW library that does not derive from the current SHT31.

As I have already many libraries, maintaining one more is not a problem (not more than the others), especially as the SHT31 class itself is pretty stable. Not much big issues or PR's (OK this one is :)

This solution

• wont affect the original SHT31 lib in size or dependencies (important for the smaller AVR devices).
• could be optimized for SoftwareWire
• could reuse a lot of the SHT31 code - you already did 90% of that in the derived version, just copy / paste the inherited functions..

It might be an option to start from the SHT85 library as this has a base SHT class and 4 derived ones = SHT30/31/35/85 = so it would provide the family of 4 sensors the SoftwareWire interface. Similar to this class the "missing ones" could be derived from the SHT31_SW base class.

This solution would create a nice result and I am curious to your opinion?
Shall I create a SHT31_SW repo?

[RobTillaart]

(added a label for my own admin)

[RobTillaart]

updated the code to the one "working" with the virtulalized Twowire.h above + 2 additional test sketches.
(archiving purpose)

[ghaug]

I've just updated my PR to your SHT31 repo. It now adds virtual to three functions and two variables protected instead of private in your original class. If we just throw out the rest (i.e. the SHT31sw class) you could either implement a derived class (SHT31sw or how ever you want to call it) in a separate library or users could derive their own class from your library.

[RobTillaart]

As this solution path is not possible I close this issue.