comunicacion i2c bidireccional

Buenas noches esoy intententando realizar un programa en el que el maestro envie una cadena de caracteres y el esclavo la compare con una referencia interna, al encontrar coincidencia envia una cadena al maestro informando que todo esta ok, cuando el maestro recive esa cadena envia los datos.
Esto es lo que llevo de codigo:
Maestro

//I2C Master
#include <Wire.h>
int ingreso=0;
int sensor[5];
void setup() 
{
  Wire.begin();
  Serial.begin(9600);
}
//funcion que se encarga de crear el vector con el valor del sensor
int convertir(int a, int b)
{
  int x,y;
  switch (b)
  {
    case 0:
    x=a/1000;
    break;

    case 1:
    y=a/1000;
    x=(a/100)-(y*10);
    break;

    case 2:
    y=a/100;
    x=(a/10)-(y*10);
    break;

    case 3:
    y=a/10;
    x=a-(y*10);
  }
  return x;
}
//funsion que realiza el envio de la informacion al esclavo
void transmitir (byte r)
{
  Wire.beginTransmission(1);
  switch (r)
  {
    case 0:
    Wire.write("ABC1");
    break;

    case 1:
    Wire.write("2CBA");
    break;
  }Wire.endTransmission();
   evaluar:
  Wire.requestFrom(1,5);
  while(Wire.available())
  {
   char c=Wire.read();  
   ingreso++;     
  }
  //se supone que primero debe recivir el mensaje del esclavo para luego ahy si enviar los datos
  //como no puedo hacer una comparacion valido su ingreso con una variable
  if (ingreso>4)
  {
    Serial.println("enviando valores");
    Wire.beginTransmission(1);
    for(int z=0;z<=3;z++)
    {
      Wire.write(sensor[z]);
    }
    ingreso=0;
  }
  else
  {
    goto evaluar;
  }
  Wire.endTransmission();
}
//funcion con la que llamo a la funcion encargada de generar el vector y retornarme los valores para ser guardados en el vector
void cadena(int a)
{
  for (int d=0;d<=3;d++)
  {
    sensor[d]=convertir(a,d);
  }
}
//funcion que pone en cero todas los campos del vector para poder utilizar un vector con todos los sensores
void anular ()
{
  for (int m=0;m<=4;m++)
  {
    sensor[m]=0;
  }
}
//funcion con la que se supone trabajo con los datos que corresponden al primer sensor
void temperatura ()
{
  int p;
  p=analogRead(A0);
  Serial.print("valor medido: ");
  Serial.println(p);
  anular();
  cadena(p);
  transmitir(0);
}
//funcion con la que se supone trabajo con los datos que corresponden al segundo sensor
void humo ()
{
  int j;
  j=analogRead(A1);
  Serial.print("valor medido: ");
  Serial.println(j);
  anular();
  cadena(j);
  transmitir(1);
}
void loop() 
{
  temperatura();
  //humo();
}

Esclavo

//I2C Slave
#include <Wire.h>
byte a;
int valor[5],datos[2][4];
int pin,posicion=0;
byte nDato = 0;
char Cadena[18];
char Humo[]="2CBA";      
char Temperatura[]="ABC1";        
bool flag = false;

void setup() 
{
  Wire.begin(1);
  Serial.begin(9600);
  pinMode(2,OUTPUT);
  pinMode(3,OUTPUT);
  pinMode(4,OUTPUT);
  pinMode(5,OUTPUT);
}
void loop() {
  //recive los caracteres enviados desde el maestro
  Wire.onReceive(receiveName);
  //envia caracyteres al mastro
  Wire.onRequest(requestEvent);
  //recive y guarda los datos enviados del maestro 
  Wire.onReceive(receiveEvent);
  //guarda los valores en una matriz
  for (int f=0;f<=4;f++)
  { 
    datos[posicion][f]=valor[5];
  }
}
//funcion que realiza la comparacion de la cadena generada con los datos enviados por el maestro con una de referncia
void CompararCadenas()
{
  if(strcmp(Cadena, Humo) == 0){ // Compara la entrada para encender el LED
    posicion=1;
  }
  
  if(strcmp(Cadena, Temperatura) == 0){ // Compara la entrada para apagar el LED
    posicion=2;
  }  
}
//funcion para recivir y comparar la cadena enviada del maestro
void receiveName()
{
  nDato = 0;
  a=0;
  strcpy(Cadena,"");
  while(Wire.available())   
  {
    char dato = Wire.read(); // Recibe la palabra del i2c tx
    if (dato != '\0')   {
    Cadena[nDato] = dato;
    nDato++;
    }
    else
        break;
  }
  Cadena[nDato] = '\0' ;
  Serial.println(Cadena);
  flag = true;
  if (flag) 
  {
      CompararCadenas();  
      flag = false;
  }
}

//funcion que pone los campos del vector que guarda los datos enviados del maestro en 0
void anular ()
{
  for (int m=0;m<=4;m++)
  {
    valor[m]=0;
  }
}
//funcion que envia los caracteres del esclavo al maestro
void requestEvent()
{
  if(posicion!=0)
  {
    Wire.write("TODOK");
  }
  else
  {
    Wire.write("Error");
  }
  Serial.println("mensaje enviado");
  a=1;
}
//funcion con la que se leen y guardan los datos enviados del maestro
void receiveEvent()
{
  anular();
  while(Wire.available())
{
  
    for(int i=0;i<=3;i++)
      {
        valor[i]=Wire.read();
        Serial.print("valor variable");
        Serial.print(i);
        Serial.print(": ");
        Serial.println(valor[i]);
      }
     valor[4]=(valor[0]*1000)+(valor[1]*100)+(valor[2]*10)+valor[3];
     Serial.print("valor sensor");
     Serial.println(valor[4]);
    }
}

Todo lo e estado simulando en proteus con simulino, esta es una imagen del resultado de la simulación:

Agradezco cualquier colaboración, quedo atento.

Your statements are simple; but, the codes are not that much simple.

Master sends Hello! to slave.
In response, Slave returns OK! to Master.
In turn, Master sends 0x12 to Slave.

1. Build the following I2C circuit between UNO-Master and MEGA-Slave. (I have these hardware.)
i2c-Mega.png

2. Upload the following sketches.
Master Sketch:

#include <Wire.h>
char testArray[] = "Hello!";
char myChar[10] = "";

void setup()
{
  Serial.begin(115200);
  Wire.begin();
 
  //-------------------------
  Wire.beginTransmission(0b0100000);  //slave address
  Wire.print(testArray);  //sending Hello!
  byte busStatus = Wire.endTransmission();
  if(busStatus != 0)
  {
    Serial.print("Communication problem...!");
    while(1);
  }
  Serial.println("Slave found...!");
  
  byte n = Wire.requestFrom(0b0100000, 3); //expecting 3-byte: OK!
  for (int i = 0; i < n; i++)
  {
    myChar[i] = Wire.read();
  }
  Serial.print(myChar);
  //------------------------
  Wire.beginTransmission(0b0100000);  //slave address
  Wire.write(0x12);  //sending data - 0x12
  Wire.endTransmission();
  //------------------------
}

void loop()
{

}

Slave Sketch:

#include <Wire.h>
char myChar[10] = "";
volatile bool flag1 = false;
volatile bool flag2 = false, flag3 = false, flag4 = false;

byte x;

void setup()
{
  Serial.begin(115200);
  Wire.begin(0b0100000); //0x20
  Wire.onReceive(receiveEvent);
  Wire.onRequest(sendEvent);
}

void loop()
{
  if (flag4 == true)
  {
    Serial.println(x, HEX);
    flag1 = false;
    flag2 = false;
    flag3 = false;
    flag4 = false;
  }
  else
  {
    if (flag1 == true)
    {
      Serial.println(myChar);
      flag1 = false;
      flag2 = true;      //Hello! is printed
    }
  }
}


void receiveEvent(int howMany)
{
  if (flag3 == false)
  {
    for (int i = 0; i < howMany; i++)
    {
      myChar[i] = Wire.read();
    }
    int x = strcmp(myChar, "Hello!");
    if (x == 0)
    {
      flag1 = true;     //Hello! received
    }
  }
  else
  {
    x = Wire.read();
    flag4 = true;
  }
}

void sendEvent()
{
  if (flag2 == true)
  {
    Wire.print("OK!");
    flag2 = false;
    flag3 = true;
  }
}

3. Master Screenshot
smMega.png

4. Slave Screenshot
smslave.png

i2c-Mega.png

smMega.png

smslave.png

¡Gracias!

for transmitting several data types with some error detection you can use a struct, e.g.