Servus 
Kurz und Knapp:
In meiner main->setup initialisiere ich meine Klasse I2CConn über eine Instanz.
Beim erstellen der Instanz in I2CConn wird
Wire.begin(9);
Wire.onReceive(receiveEvent);
aufgerufen.
Soweit passt alles.
In meiner Callback Funktion onReceive will ich die Empfangene Nachricht wieder in meine Klasse zurückführen.
Deshalb rufe ich auch hier die Instanz für I2CConn plus eine Funktion in der Klasse auf.
Jetzt ist aber das Problem dass er die vorherige Instanz verschmeißt und ein neues Instanz Objekt mit anderer Adresse erstellt.
Das passiert aber nur einmalig. Nachdem onReceive einmal die Instanz verwirft und ein neues Objekt erstellt kann ich von egal wo ganz normal auf die Instanz zugreifen nur eben mit der neuen Adresse.
Nachdem ich das jetzt weiß ist es nicht so dramatisch da ich es dann abfangen kann aber warum zeigt das Objekt nach dem Aufruf von onReceive auf eine neue Adresse?
Ich bin nicht sehr gut im Beschreiben von Sachen. Hoffe es ist einigermaßen verständlich 
Ich bin nicht sehr gut im Beschreiben von Sachen. Hoffe es ist einigermaßen verständlich
Irgendwie nicht....
Ich nenne das Prosa.
Viele Worte, aber keins, welches zum Fehler führt.
(nicht falsch verstehen, ich liebe Prosa! Aber zur Fehlersuche nicht ausreichend)
Tipp:
Wenn du einen Fehler im Programm hast, dann wird dieser Fehler auf deinem Monitor erscheinen.
Auch wenn du ihn dort nicht erkennen magst.
Abhilfe:
Deinen Monitor bis zu mir nach Hause tragen.
Alternativ:
Ein Minimalprogramm HIER zeigen, so dass man/ich SEHEN kann und testen kann, was falsch läuft.
noiasca:
Aber wenn du im Setup() eine Instanz anlegst, ist sie am Ende von Setup weg.
Imho works as as designed.
Singleton Instanzen kann man nicht erzeugen.
Das muss dieses Singleton schon selber tun.
Sonst ist es kein "richtiges" Singleton.
So in etwa ist es in der Definition des Design Pattern nachlesbar.
Hier mal ein solches "Experiment" aus meiner Wühlkiste:
#include <Streaming.h>
template<typename ClientClass>
class Singleton
{
private:
static ClientClass *client;
protected:
Singleton(){}
Singleton(const Singleton<ClientClass>&) =delete;
Singleton(Singleton<ClientClass>&&) =delete;
Singleton & operator=(const Singleton<ClientClass>&) =delete;
Singleton & operator=(Singleton<ClientClass>&&) =delete;
public:
static ClientClass &instance()
{
if (!client) client = new ClientClass;
return *client;
}
virtual ~Singleton()
{
delete client;
client = nullptr;
}
};
template<typename ClientClass> ClientClass* Singleton<ClientClass>::client = nullptr;
class Adc : public Singleton<Adc>
{
protected:
friend class Singleton<Adc>;
Adc(){}
public:
using Singleton<Adc>::operator=;
Adc(const Adc&) =delete;
Adc(Adc&&) =delete;
int messung(byte pin)
{
return analogRead(pin);
}
};
void setup()
{
Serial.begin(9600);
Serial << "Start: "<< __FILE__ << endl;
// Adc adc; // verboten
// Adc adc = Adc::instance(); // verboten
// Adc adc {Adc::instance()}; // verboten
// Adc adc(Adc::instance()); // verboten
Adc &adc = Adc::instance(); // erlaubt
Serial.println(adc.messung(A0));
}
void loop()
{
Serial.println(Adc::instance().messung(A0)); // erlaubt
}