Rechtlich betrachtet sind Bartagamen nur Sachen, die man zwar nicht quälen darf, die sonst aber wenig geschützt sind.
Wer solche Tiere hält, sollte sie aber über den rechtlichen Rahmen hinaus lieben und seiner Verantwortung mehr als gerecht werden. Das setze ich als selbstverständlich voraus 
Daher sollten Sicherheiten eingebaut und auch ausgiebig getestet werden. Aus eigener Erfahrung weiß ich, man kann nicht so dumm denken, wie es kommen kann 
An I²C könnten beim Mega2560 auch Sensoren als Slaves dranhängen, da stellt sich die Frage, wer Master sein soll. Wenn es der ESP32 sein soll, dann könnte der auch gleich die Meßwerte lesen und verarbeiten. Oder muß der ESP32 die Meßwerte an den Mega2560 schicken, damit dann da was passiert. Oder doch den Mega2560 als Master, damit der die Initiative ergreifen kann?
Ergänzung 20220301 15:17:
Der ESP32 möchte mit Core 1.0.6 kein Slave sein, mit Core 2.0.1 funktioniert es hingegen. Wenn man in den IDE-Voreinstellungen bei "Zusätzliche Boardverwalter-URLs" "https://dl.espressif.com/dl/package_esp32_index.json" durch "https://github.com/espressif/arduino-esp32/releases/download/2.0.1/package_esp32_index.json" ersetzt, wird im Boardverwalter nach Suche von "ESP32" auch Core 2.0.1 angeboten.
Mega2560 als I2C-MASTER
#include <Wire.h>
const byte SLAVEADDRESS = 8;
const byte BYTEZAHL = 2 * sizeof(int);
union {
byte bytes[BYTEZAHL];
struct {
uint16_t Wert_1;
uint16_t Wert_2;
};
} tx;
void loop()
{
uint32_t jetzt = millis();
static uint32_t vorhin = jetzt;
if (jetzt - vorhin >= 1000)
{
vorhin = jetzt;
tx.Wert_1 = random(150, 300);
tx.Wert_2 = random(0, 1000);
Wire.beginTransmission(SLAVEADDRESS);
Wire.write(tx.bytes, sizeof(tx));
Wire.endTransmission();
Serial.print(F("\ttx.Wert_1: ")); Serial.print(tx.Wert_1); Serial.print(F("\ttx.Wert_2: ")); Serial.println(tx.Wert_2);
}
}
void setup()
{
Wire.begin();
Serial.begin(115200);
//Wire.setClock(400000L); //setzt die I²C Taktfrequenz auf 400kHz
delay(1000);
Serial.println(F("\nStart"));
Serial.print(F("BYTEZAHL Byte für int: ")); Serial.println(sizeof(int));
}
ESP32 als I2C-SLAVE
#include <Wire.h>
const byte SLAVEADDRESS = 8;
const byte BYTEZAHL = 4;
union {
byte bytes[BYTEZAHL];
struct {
int16_t Wert_1;
int16_t Wert_2;
};
} rx;
volatile int32_t rxWert_1 = 0;
volatile int32_t rxWert_2 = 0;
bool neu = false;
void setup()
{
Wire.begin(SLAVEADDRESS);
Wire.onReceive(receiveEvent);
Serial.begin(115200);
Serial.println(F("\nStart"));
}
void receiveEvent(int numBytes)
{
if (BYTEZAHL == numBytes)
{
for (byte j = 0; j < numBytes; j++)
{
rx.bytes[j] = Wire.read();
}
rxWert_1 = rx.Wert_1;
rxWert_2 = rx.Wert_2;
neu = true;
}
}
void loop()
{
if (neu)
{
neu = false;
for (byte j = 0; j < BYTEZAHL; j++)
{
Serial.print(rx.bytes[j], HEX); Serial.print(' ');
}
Serial.print(F("\trxWert_1: ")); Serial.print(rxWert_1); Serial.print(F("\trxWert_2: ")); Serial.println(rxWert_2);
}
}
Anzeige Mega2560:
tx.Wert_1: 193 tx.Wert_2: 427
tx.Wert_1: 182 tx.Wert_2: 444
tx.Wert_1: 241 tx.Wert_2: 198
tx.Wert_1: 152 tx.Wert_2: 856
Anzeige ESP32:
C1 0 AB 1 rxWert_1: 193 rxWert_2: 427
B6 0 BC 1 rxWert_1: 182 rxWert_2: 444
F1 0 C6 0 rxWert_1: 241 rxWert_2: 198
98 0 58 3 rxWert_1: 152 rxWert_2: 856
Ergänzung 20220301 16:46:
Mega2560 als UART-Sender
uint16_t wert_1;
uint16_t wert_2;
void loop()
{
uint32_t jetzt = millis();
static uint32_t vorhin = jetzt;
if (jetzt - vorhin >= 1000)
{
vorhin = jetzt;
wert_1 = random(150, 300);
wert_2 = random(0, 1000);
char buf[100] = {"\0"};
snprintf(buf, sizeof(buf), "W1:%u;W2:%u\n", wert_1, wert_2);
Serial2.print(buf);
Serial.print(buf);
}
}
void setup()
{
Serial.begin(115200);
Serial.println(F("\nStart"));
Serial2.begin(9600);
}
ESP32 als UART-Empfänger
const unsigned int READ_BUFFER_SIZE = 100; // an die Bedürfnisse anpassen!
char * readLine(Stream& stream) {
static byte index;
static char buffer[READ_BUFFER_SIZE];
while (stream.available()) {
char c = stream.read();
if (c == '\n') { //wenn LF eingelesen
buffer[index] = '\0'; //String terminieren
index = 0;
return buffer; //melden dass String fertig eingelesen wurde
}
else if (c >= 32 && index < READ_BUFFER_SIZE - 1) { //solange noch Platz im Puffer ist
buffer[index++] = c; //Zeichen abspeichern und Index inkrementieren
}
}
return nullptr; //noch nicht fertig
}
void loop()
{
int16_t wert_1 = 0;
int16_t wert_2 = 0;
char * eingabe = readLine(Serial2);
if ( nullptr != eingabe )
{
Serial.println(eingabe);
if ( 1 < sscanf ( eingabe, "W1:%u;W2:%u", &wert_1, &wert_2 ))
{
char buf[READ_BUFFER_SIZE] = {"\0"};
snprintf( buf, sizeof(buf), "Wert 1: %u\tWert 2: %u", wert_1, wert_2 );
Serial.println(buf);
}
}
}
void setup()
{
Serial.begin(115200);
Serial.println(F("\nStart"));
Serial2.begin(9600);
}
Ausgabe Mega2560:
16:48:49.431 -> W1:251;W2:285
16:48:50.434 -> W1:171;W2:526
16:48:51.390 -> W1:222;W2:63
16:48:52.394 -> W1:174;W2:806
Ausgabe ESP32:
16:48:49.431 -> W1:251;W2:285
16:48:49.431 -> Wert 1: 251 Wert 2: 285
16:48:50.434 -> W1:171;W2:526
16:48:50.434 -> Wert 1: 171 Wert 2: 526
16:48:51.437 -> W1:222;W2:63
16:48:51.437 -> Wert 1: 222 Wert 2: 63
16:48:52.441 -> W1:174;W2:806
16:48:52.441 -> Wert 1: 174 Wert 2: 806
Nun hast Du die Qual der Wahl 
Ich finde, Deine Bartagamen haben sich ein extra Leckerli verdient 
