Problema de comunicación I2C

International Español Software
1

Hola que tal?

Estoy trabajando en un proyecto en el cualto tengo un atmega328p (transmisor) que obtiene datos, mediante 5 sensores de humedad (analogicos), de 5 macetas con tierra. Enviar esos datos por I2C a un nodemcu8266(receptor) para luego poder tener un monitoreo remoto.

Tengo un problema a la hora de transmitir datos desde atmega328p al nodemcu8266, la idea es transmitir 5 datos de los cuales los obtengo leyendo entradas analógicas.

Cuando yo envió números enteros, el receptor lo recibe correctamente, el problema surge cuando quiero enviar los datos analógicos, el receptor imprime otros datos.

Código del emisor:

#include <Wire.h>

const int sensorP1Cod = 9;
const int sensorP2Cod = 10;
const int sensorP3Cod = A0;
const int sensorP4Cod = A1;
const int sensorP5Cod = A2;


void setup()
{
    Serial.begin(9600);
    Wire.begin(1);
    Wire.onRequest(peticion);
}

 
void loop()
{
    
   
    
}

void peticion(){  
    Serial.println("Enviado");
     int valorHumedadP1 = map(analogRead(sensorP1Cod), 0, 1023, 100, 0);
    int valorHumedadP2 = map(analogRead(sensorP2Cod), 0, 1023, 100, 0);
    int valorHumedadP3 = map(analogRead(sensorP3Cod), 0, 1023, 100, 0);
    int valorHumedadP4 = map(analogRead(sensorP4Cod), 0, 1023, 100, 0);
    int valorHumedadP5 = map(analogRead(sensorP5Cod), 0, 1023, 100, 0);
    int valorHumedadP1 = map(analogRead(sensorP1Cod), 0, 1023, 100, 0);
    Wire.write(valorHumedadP1);  
    Wire.write(valorHumedadP2);  
    Wire.write(valorHumedadP2);    
    Wire.write(valorHumedadP4);
    Wire.write(valorHumedadP5);    
  
  
}

Función que solicita los datos (receptor);

void wireRequest(){
  
 Wire.requestFrom(1,5);
   Serial.println("################");//IMPRIMIMOS EL MENSAJE
   int a = 0;
   while(Wire.available()) {    
       
     dato = Wire.read();//GUARDAMOS EL MENSAJE EN LA CADENA MESAJE 1   
     cadena[a] =dato;
     Serial.println(cadena[a]);//IMPRIMIMOS EL MENSAJE
     a++; 
}

Estos son los datos que llegan:

################
16
127
255
255
255

Como puedo resolver este problema con los datos?

Muchas gracias.

2

Y cual es el proyecto?

Leíste esto: Antes de crear un hilo lee esto?

Leíste las normas? Los códigos van con esta etiqueta </> no con quote.

Hilo movido a Software, lo tuyo es una consulta no un proyecto.

3

Para comenzar los pines analógicos comienzan con Ax o sea A0...A5 en UNO A0...A7 en NANO.

Estos dos pines no son analogicos

const int sensorP1Cod = 9;
const int sensorP2Cod = 10;

de modo que esto esta mal

     int valorHumedadP1 = map(analogRead(sensorP1Cod), 0, 1023, 100, 0);
    int valorHumedadP2 = map(analogRead(sensorP2Cod), 0, 1023, 100, 0);

Ahora un valor entero tiene 2 bytes. Pero por alguna razón tu los inverites con map.

Para contestar porque se leen mal los datos te diré que no publicas todo el código.
Nunca parcialices los códigos. Coloca todo el código del receptor.

Algo mas.
Solo lo envias en el setup() en el transmisor o sea 1 vez.

4

Muchas gracias por contestar y perdón.

Estos dos pines no son analogicos

Esos pines no se pueden utilizar como analógicos?

Algo mas.
Solo lo envias en el setup() en el transmisor o sea 1 vez.

Si lo envió por setup() funciona, los datos son enviados, tengo entendido que es debido a que el receptor envía un request solicitando los datos. No se si esto tiene algo que ver al problema que tengo.

A que se debe que imprima esos valores y no los obtenidos en las lecturas analógicas?

Adjunto código del receptor:

#include <Wire.h>

int dato;//INICIAMOS UNA CADENA
int cadena[5];

void setup() {

Wire.begin();//INICIAMOS EL WIRE (I2C)

}

void loop() {
  
wireRequest();
}

void wireRequest(){
  
   Wire.requestFrom(1,5);
   Serial.println("################");//IMPRIMIMOS EL MENSAJE
   int a = 0;
   while(Wire.available()) {    
       
     dato = Wire.read();//GUARDAMOS EL MENSAJE EN LA CADENA MESAJE 1   
     cadena[a] =dato;
     Serial.println(cadena[a]);//IMPRIMIMOS EL MENSAJE
     a++; 
}

  
 
  //delay(2500);//ESPERAMOS 2 SEGUNDOS Y MEDIO
}

Muchas gracias

5

Bueno, flor de problemas te has creado tu mismo!!!

Usas el puerto I2C o sea tienes A4 y A5 comprometidos para tal función.
Necesitas 5 pines analógicos y el UNO tiene 6 de los cuales 2 estan usados por la interfaz I2C así que decide: cambias a comunicación I2C a Serial o usas un sensor menos conservando la I2C.

const byte sensorP1Cod = A0;
const byte sensorP2Cod = A1;
const byte sensorP3Cod = A2;
const byte sensorP4Cod = A3;

Los pienes analógicos son A0..A1..A2..A3..A4..A5 en el UNO
Hasta A7 en el NANO
Y 16 en el MEGA.

6

Ahora estoy utilizando 3 sensores para probar en los pines A0,A1,A2 para ir probando y avanzar de apoco

Inventigando un poco mas me di cuenta que el I2C transmite valores del 1 al 255. Como hago para poder convertir estos valores que recepciona numero decimal?

Saludos

7

un int son dos bytes. Debes transmitir 2 bytes para recibir la información completa y luego rearmarlo en donde quieras presentarlo.

la forma correcta para enviar sería asi

 Wire.send(valorHumedadP1, sizeof(valorHumedadP1));

entonces eso enviará 2 bytes pero para reconstruirlo tendras que hacerlo manualmente via código.

ya que vas a recibir un entero dividio en su valor MSB (mas significativo) y su LSB (menos significativo)
El MSB * 256 + LSB es la reconstrucción que necesitas.
Asi que todo lo que supere 255 en el LSB estará afectado por un byte != 0 en el MSB.

a ese valor lo debes multiplicar por 256.
Supongamos que solo tienes un MSB = 1 => 1 x 256 mas LSB = a tu número
513 de tu ADC es 513/256 = 2.1 o sea como las divisiones son enteras 2 como MSB y 1 como LSB

recibiras un 2 y luego un 1. La reconstrucción será 2 x 256 + 1 = 512 + 1 = 513.

8 
Wire.send(valorHumedadP1, sizeof(valorHumedadP1));

Cuando lo envico como lo mencionas el IDE me arroja el siguente error:

emisor:35: error: Wire.send() ha sido renombrado a Wire.write()
Como en Arduino 1.0, la función Wire.send() ha sido renombrada a Wire.write() por consistencia con otras librerías.

Wire.send(valorHumedadP3, sizeof(valorHumedadP3));

^

exit status 1
Wire.send() ha sido renombrado a Wire.write()

Corrijo el problema usando Wire.write como lo menciona quedando de la siguente manera:

Wire.write(valorHumedadP1, sizeof(valorHumedadP1));

Y el IDE me arroja otro error relacionado con la sintaxis:

emisor:35: error: call of overloaded 'write(int&, unsigned int)' is ambiguous

Wire.write(valorHumedadP1, sizeof(valorHumedadP1));

^

C:\Users\Gonzalo\Google Drive\SmartIndoor\Hardware\emisor\emisor.ino:35:52: note: candidates are:

In file included from C:\Users\Gonzalo\Google Drive\SmartIndoor\Hardware\emisor\emisor.ino:1:0:

C:\Program Files (x86)\Arduino\hardware\arduino\avr\libraries\Wire\src/Wire.h:67:20: note: virtual size_t TwoWire::write(const uint8_t*, size_t)

virtual size_t write(const uint8_t *, size_t);

^

C:\Program Files (x86)\Arduino\hardware\arduino\avr\libraries\Wire\src/Wire.h:67:20: note: no known conversion for argument 1 from 'int' to 'const uint8_t* {aka const unsigned char*}'

In file included from C:\Program Files (x86)\Arduino\hardware\arduino\avr\cores\arduino/Stream.h:26:0,

from C:\Program Files (x86)\Arduino\hardware\arduino\avr\cores\arduino/HardwareSerial.h:29,

from C:\Program Files (x86)\Arduino\hardware\arduino\avr\cores\arduino/Arduino.h:232,

from sketch\emisor.ino.cpp:1:

C:\Program Files (x86)\Arduino\hardware\arduino\avr\cores\arduino/Print.h:57:12: note: size_t Print::write(const char*, size_t)

size_t write(const char *buffer, size_t size) {

^

C:\Program Files (x86)\Arduino\hardware\arduino\avr\cores\arduino/Print.h:57:12: note: no known conversion for argument 1 from 'int' to 'const char*'

exit status 1
'sensorP1Cod' was not declared in this scope

9

Ok, mi error.. vi una pagina muy vieja y no me di cuenta.

#include <Wire.h>

const int sensorP1Cod = A0;
const int sensorP2Cod = A1;
const int sensorP3Cod = A2;
const int sensorP4Cod = A3;
const int sensorP5Cod = A6; // solo en un NANO
const int sensorP5Cod = A7; // Solo en un NANO

byte miArray[2];

void setup()
{
    Serial.begin(9600);
    Wire.begin(1);
    Wire.onRequest(peticion);
}

 
void loop()
{
    
   
    
}

void peticion(){  
    Serial.println("Enviado");
     int valorHumedadP1 = map(analogRead(sensorP1Cod), 0, 1023, 100, 0);
    int valorHumedadP2 = map(analogRead(sensorP2Cod), 0, 1023, 100, 0);
    int valorHumedadP3 = map(analogRead(sensorP3Cod), 0, 1023, 100, 0);
    int valorHumedadP4 = map(analogRead(sensorP4Cod), 0, 1023, 100, 0);
    int valorHumedadP5 = map(analogRead(sensorP5Cod), 0, 1023, 100, 0);
    int valorHumedadP1 = map(analogRead(sensorP1Cod), 0, 1023, 100, 0);
	convierto(valorHumedadP1);
    Wire.write(miArray, 2);  
    convierto(valorHumedadP2);
    Wire.write(miArray, 2);  
    convierto(valorHumedadP3);
    Wire.write(miArray, 2);  
    convierto(valorHumedadP4);
    Wire.write(miArray, 2);  
    convierto(valorHumedadP5);
    Wire.write(miArray, 2);  
 
}

void convierto (int tmp) {
	miArray[0] = (tmp >> 8) & 0xFF;
	miArray[1] = tmp & 0xFF;
}

corrige desde ahi.

10

Modifique un poco el código y me quedo de la siguiente manera (estoy utilizando ahora 3 entradas analógicas):

Emisor:

#include <Wire.h>
//const int sensorP1Cod = 9;
//const int sensorP2Cod = 10;
const int sensorP3Cod = A0;
const int sensorP4Cod = A1;
const int sensorP5Cod = A2;

byte miArray[2];
void setup()
{
    Serial.begin(9600);
    Wire.begin(1);
    Wire.onRequest(peticion);
}

 
void loop()
{    
}

void peticion(){  
    Serial.println("Enviado");
    
    int valorHumedadP3 = map(analogRead(sensorP3Cod), 0, 1023, 100, 0);
    int valorHumedadP4 = map(analogRead(sensorP4Cod), 0, 1023, 100, 0);
    int valorHumedadP5 = map(analogRead(sensorP5Cod), 0, 1023, 100, 0);
    
   
    convierto(valorHumedadP3);
    Wire.write(miArray, 2);  
    convierto(valorHumedadP4);
    Wire.write(miArray, 2);  
    convierto(valorHumedadP5);
    Wire.write(miArray, 2);     
}

void convierto (int tmp) {
  miArray[0] = (tmp >> 8) & 0xFF;
  miArray[1] = tmp & 0xFF;
}

Cuando compilo no me genero ningún error, pero el receptor recibe los siguientes datos:

################
0
127
255

Otra cosa que me acaboi de dar cuenta probando:

Si imprimo el tamaño del byte (creo que para eso sirge esta funcion) me devuelve 2 en el emisor

Serial.println(sizeof(valorHumedadP3));

2

Ahora cuando corro el mismo comando sobre el receptor (viendo el valor del dato recepcionado) me devuelve 4:

Serial.println(sizeof(dato));

4

11

Bueno pero te explique que el receptor ahora ve dos bytes y debe armar 1 int.
Eso no lo haz hecho, crees que por arte de magia el receptor con el código anterior te va a mostrar lo que tu esperas.

En el receptor esperaba que te dieras cuenta que te vengo hablando que son enviados 2 bytes por cada analogRead entonces en lugar de 5 bytes ahora esperas 10 y que debes reconstruir el entero con los dos bytes enviados.

A ver si esto funciona. No he visto lo que me has indicado.

#include <Wire.h>

int dato;//INICIAMOS UNA CADENA
byte miArray[2];

void setup() {

    Wire.begin();//INICIAMOS EL WIRE (I2C)

}

void loop() {
  
    wireRequest();
}

void wireRequest(){
  
    Wire.requestFrom(1,10);
    Serial.println("################");//IMPRIMIMOS EL MENSAJE
    int a = 0;
    while (Wire.available()) {    
            dato = Wire.read();//GUARDAMOS EL MENSAJE EN LA CADENA MESAJE 1   
            miArray[a] = Wire.read();
            a++;
            miArray[a] = Wire.read();
            dato = miArray[a]*256+miArray{a-1];
            Serial.println(dato);//IMPRIMIMOS EL MENSAJE
    }
}

Ademas esto no es el tamaño del byte, sino el tamaño de la variable valorHumedadP3 que es entera y por lo tanto tiene tamaño 2 y por eso te imprime 2.

12

Ahora cambio un poco el resultado, pero no me sigue imprimiendo los valores correctos:

Me imprime 4 registros (falta 1) y son los siguentes:

################
65311
65535
65535
65535

Código del emisor:

#include <Wire.h>
const int sensorP1Cod = 9;
const int sensorP2Cod = 10;
const int sensorP3Cod = A0;
const int sensorP4Cod = A1;
const int sensorP5Cod = A2;

byte miArray[2];
void setup()
{
    Serial.begin(9600);
    Wire.begin(1);
    Wire.onRequest(peticion);
}

 
void loop()
{    
}

void peticion(){  
    Serial.println("Enviado");
    int valorHumedadP1 = map(analogRead(sensorP1Cod), 0, 1023, 100, 0);
    int valorHumedadP2 = map(analogRead(sensorP2Cod), 0, 1023, 100, 0);
    int valorHumedadP3 = map(analogRead(sensorP3Cod), 0, 1023, 100, 0);
    int valorHumedadP4 = map(analogRead(sensorP4Cod), 0, 1023, 100, 0);
    int valorHumedadP5 = map(analogRead(sensorP5Cod), 0, 1023, 100, 0);
    
   
    convierto(valorHumedadP1);
    Serial.println(valorHumedadP1);
    Wire.write(miArray, 2);  
    convierto(valorHumedadP2);
    Wire.write(miArray, 2);  
    convierto(valorHumedadP3);
    Wire.write(miArray, 2);  
    convierto(valorHumedadP4);
    Wire.write(miArray, 2);  
    convierto(valorHumedadP5);
    Wire.write(miArray, 2);     
}

void convierto (int tmp) {
  miArray[0] = (tmp >> 8) & 0xFF;
  miArray[1] = tmp & 0xFF;
}

Agregando dos Serial.println() en el receptor:

Serial.println(miArray[a]);

Dejando la función de la siguiente manera:

void wireRequest(){
  
    Wire.requestFrom(1,6);
    Serial.println("################");//IMPRIMIMOS EL MENSAJE
    int a = 0;
    while (Wire.available()) {    
            dato = Wire.read();//GUARDAMOS EL MENSAJE EN LA CADENA MESAJE 1   
            miArray[a] = Wire.read();
            Serial.println(miArray[a]);
            a++;
            miArray[a] = Wire.read();
            Serial.println(miArray[a]);
            dato = miArray[a]*256+miArray[a-1];
            Serial.println(dato);//IMPRIMIMOS EL MENSAJE
    }
}

Me devuelve los siguentes resueltados:

################
63 // Valor de miArray[0]
255 // Valor de miArray[1]
65343
63
255
65535

Esto significa que no los convirtió correctamente?

13 
const int sensorP1Cod = 9;
const int sensorP2Cod = 10;

Cambia esto por favor, ya te expliqué que no son pines analógicos.

y cambia esto tambien, por tus respuestas esta al revés como llegan los datos

dato = miArray[a]+miArray[a-1]*256;

Respecto a que llegan 4 y son 5, me dijiste que trabajas con 3, ahora me muestras 5.

Ya veo el error de porque imprime 4 y no 5.
Pero lo que me sorprende es que no aportas nada de tu parte.

void loop() {
  
    wireRequest();
}

void wireRequest(){
  
    Wire.requestFrom(1,10);
    Serial.println("################");//IMPRIMIMOS EL MENSAJE
    int a = 0;
    while (Wire.available()) {    
            dato = Wire.read();//GUARDAMOS EL MENSAJE EN LA CADENA MESAJE 1   
            miArray[0] = Wire.read();
            miArray[1] = Wire.read();
            dato = miArray[0]*256+miArray[1];   // si salen mal inviertes miArray[0] con [1]

            Serial.println(dato);//IMPRIMIMOS EL MENSAJE
    }
}

Cuando uso miArray[2] sigo incrementando el valor de a y hay un punto que ya no puede hacerlo.
hay que poner a = 0; luego del 2do byte

14 
const int sensorP1Cod = 9;

const int sensorP2Cod = 10;





Cambia esto por favor, ya te expliqué que no son pines analógicos.

y cambia esto tambien, por tus respuestas esta al revés como llegan los datos

Ya lo cambie, deje el código de la siguiente manera:

Luego voy a investigar como enviar los otros dos datos restantes. Mi prioridad es poder este tipo de información por I2C de manera correcta, y entender como poder encarar un problema como este

Código emisor:

#include <Wire.h>

const int sensorP3Cod = A0;
const int sensorP4Cod = A1;
const int sensorP5Cod = A2;

byte miArray[2];
void setup()
{
    Serial.begin(9600);
    Wire.begin(1);
    Wire.onRequest(peticion);
}

 
void loop()
{    
}

void peticion(){  
    Serial.println("Enviado");
    int valorHumedadP3 = map(analogRead(sensorP3Cod), 0, 1023, 100, 0);
    int valorHumedadP4 = map(analogRead(sensorP4Cod), 0, 1023, 100, 0);
    int valorHumedadP5 = map(analogRead(sensorP5Cod), 0, 1023, 100, 0);    
   
    convierto(valorHumedadP3);
    Wire.write(miArray, 2);  
    convierto(valorHumedadP4);
    Wire.write(miArray, 2);  
    convierto(valorHumedadP5);
    Wire.write(miArray, 2);     
}

void convierto (int tmp) {
  miArray[0] = (tmp >> 8) & 0xFF;
  miArray[1] = tmp & 0xFF;
}

Al enviar 3 datos, esto da un total de 6 bytes. Cierto?

Por lo tanto el receptor debería cambiar:

Wire.requestFrom(1,10);

por:

Wire.requestFrom(1,6);

Código receptor:

void loop() {
  
    wireRequest();
}

void wireRequest(){
  
    Wire.requestFrom(1,6);
    Serial.println("################");//IMPRIMIMOS EL MENSAJE
    int a = 0;
    while (Wire.available()) {    
            dato = Wire.read();//GUARDAMOS EL MENSAJE EN LA CADENA MESAJE 1   
            miArray[0] = Wire.read();
            miArray[1] = Wire.read();
            dato = miArray[0]*256+miArray[1];   // si salen mal inviertes miArray[0] con [1]

            Serial.println(dato);//IMPRIMIMOS EL MENSAJE
    }
}

Realizando estos cambios obtengo esta salida:

################
65343
65535

Con respecto a esto:

 dato = miArray[0]*256+miArray[1];   // si salen mal inviertes miArray[0] con [1]

Tengo que dejarlo de la siguiente manera?

 dato = miArray[1]*256+miArray[0];   // si salen mal inviertes miArray[0] con [1]

Pero lo que me sorprende es que no aportas nada de tu parte.

Perdon, quiero poder entender mejor.

Si no realizo ese cambio (Wire.requestFrom()), surge lo siguiente:

Cambio:

Código receptor:

void wireRequest(){
  
    Wire.requestFrom(1,10);
    Serial.println("################");//IMPRIMIMOS EL MENSAJE
    int a = 0;
    while (Wire.available()) {    
            dato = Wire.read();//GUARDAMOS EL MENSAJE EN LA CADENA MESAJE 1   
            miArray[0] = Wire.read();
            //Serial.println(miArray[a]);
            //a++;
            miArray[1] = Wire.read();
            //Serial.println(miArray[a]);
            dato = miArray[0]*256+miArray[1];
            Serial.println(dato);//IMPRIMIMOS EL MENSAJE
    }
}

Código emisor:

#include <Wire.h>

const int sensorP3Cod = A0;
const int sensorP4Cod = A1;
const int sensorP5Cod = A2;

byte miArray[2];
void setup()
{
    Serial.begin(9600);
    Wire.begin(1);
    Wire.onRequest(peticion);
}

 
void loop()
{    
}

void peticion(){  
    Serial.println("Enviado");
    int valorHumedadP3 = map(analogRead(sensorP3Cod), 0, 1023, 100, 0);
    int valorHumedadP4 = map(analogRead(sensorP4Cod), 0, 1023, 100, 0);
    int valorHumedadP5 = map(analogRead(sensorP5Cod), 0, 1023, 100, 0);    
   
    convierto(valorHumedadP3);
    Wire.write(miArray, 2);  
    convierto(valorHumedadP4);
    Wire.write(miArray, 2);  
    convierto(valorHumedadP5);
    Wire.write(miArray, 2);     
}

void convierto (int tmp) {
  miArray[0] = (tmp >> 8) & 0xFF;
  miArray[1] = tmp & 0xFF;
}

Salida del receptor:

################
16383
65535
65535
65535

Muchas gracias

15

Bueno veo que nadie me puede ayudar.

Gracias de todas formas.

Hasta luego

16

Como que nadie, y que he hecho hasta ahora?

Leíste la parte de las normas del foro en la que debes ser paciente? Te respondí ayer 11-05-2019, 17:59:51 y ya te estas quejando?

17

Sacando tu aporte, aprendí un poco con los datos me diste. Perdón soy bastante ansioso. Voy a ser mas paciente.

18

Estuve viendo tu problema y me hace exactamente lo mismo. Asi que dejame ver por donde esta la falla, a menos que otro la encuentre.

19

La verdad que agradezco mucho toda la ayuda que me has brindado!!

Saludos

20

Pude resolver el problema basándome en un ejemplo de la siguiente documentación:

Fuente: http://arduwiki.perut.org/wiki/Wire

Puedo enviar 4 lecturas analógicas de la siguiente manera:

Emisor:

#include <Wire.h>

const byte esclavo = 42;
char comando = 0;
int sensor00 = A0;
int sensor01 = A1;
int sensor02 = A2;
int sensor03 = A3;
enum {
    CMD_ID = 1,
    CMD_READ_A0  = 2,
    CMD_READ_A1  = 3,
    CMD_READ_A2  = 4,
    CMD_READ_A3  = 5,
    };

void setup(){
   pinMode(sensor00, INPUT);       //Sensor analogico
   Wire.begin(esclavo);      //Numero del esclavo
   Wire.onReceive(leer);     //Cuando llega mensaje
   Wire.onRequest(pedir);    //Cuando maestro solicita mensaje 
}

void loop(){
   //Nada
}

void sensor0(const byte pin){
   int val = map(analogRead(pin),0,1023,100,0);
   byte buf[2];
   buf[0] = highByte(val);    //Capturamos MSB byte
   buf[1] = lowByte(val);     //Capturamos LSB byte
   Wire.write(buf, 2);        //Envia los 2 byte del sensor en A0
}

void sensor1(const byte pin){
   int val = map(analogRead(pin),0,1023,100,0);
   byte buf[2];
   buf[0] = highByte(val);    //Capturamos MSB byte
   buf[1] = lowByte(val);     //Capturamos LSB byte
   Wire.write(buf, 2);        //Envia los 2 byte del sensor en A1
}

void sensor2(const byte pin){
   int val = map(analogRead(pin),0,1023,100,0);
   byte buf[2];
   buf[0] = highByte(val);    //Capturamos MSB byte
   buf[1] = lowByte(val);     //Capturamos LSB byte
   Wire.write(buf, 2);        //Envia los 2 byte del sensor en A2
}

void sensor3(const byte pin){
   int val = map(analogRead(pin),0,1023,100,0);
   byte buf[2];
   buf[0] = highByte(val);    //Capturamos MSB byte
   buf[1] = lowByte(val);     //Capturamos LSB byte
   Wire.write(buf, 2);        //Envia los 2 byte del sensor en A3
}



void leer(){
   comando = Wire.read();
}

void pedir(){
  switch (comando){
  case CMD_ID:
     Wire.write(42);   //Envia numero del esclavo
     break;
  case CMD_READ_A0: 
     sensor0(sensor00);       //Envia dato sensor en A0
     break;
  case CMD_READ_A1: 
     sensor1(sensor01);       //Envia dato sensor en A1
     break;
  case CMD_READ_A2: 
     sensor2(sensor02);       //Envia dato sensor en A2
     break;
  case CMD_READ_A3: 
     sensor3(sensor03);       //Envia dato sensor en A3
     break;
  } 
}

Receptor:

#include <Wire.h>
const byte esclavo = 42;
int sensor00;
int sensor01;
int sensor02;
int sensor03;

enum {
   CMD_ID = 1,
   CMD_READ_A0 = 2,
   CMD_READ_A1 = 3,
   CMD_READ_A2 = 4,
   CMD_READ_A3 = 5,
};
 
void setup (){
   Serial.begin(9600);
   Wire.begin();   
   sendCommand(CMD_ID, 1);
   if (Wire.available()) {
      Serial.print("Id del esclavo: ");
      Serial.println(Wire.read(), DEC);
   }else{
      Serial.println ("No responde el esclavo");
   }
}

void loop(){
  
  captura();
  delay(5000);
}

void sendCommand (const byte cmd, const byte largo){
   Wire.beginTransmission(esclavo);
   Wire.write(cmd);
   Wire.endTransmission();
   Wire.requestFrom(esclavo, largo);  //No continua hasta que tenga datos en el buffer
}

void captura(){
  
  //00
  sendCommand(CMD_READ_A0, 2);
  sensor00 = Wire.read();   //Recuperamos MSB
  sensor00 <<= 8;           //Desplazamos 8 bits a la izquierda
  sensor00 |= Wire.read();  //Recuperamos LSB
  Serial.print("Valor sensor en A0 del esclavo: ");
  Serial.println(sensor00);  
  
  //01
  sendCommand(CMD_READ_A1, 2);
  sensor01 = Wire.read();   //Recuperamos MSB
  sensor01 <<= 8;           //Desplazamos 8 bits a la izquierda
  sensor01 |= Wire.read();  //Recuperamos LSB
  Serial.print("Valor sensor en A1 del esclavo: ");
  Serial.println(sensor01);
  
  //02
  sendCommand(CMD_READ_A2, 2);
  sensor02 = Wire.read();   //Recuperamos MSB
  sensor02 <<= 8;           //Desplazamos 8 bits a la izquierda
  sensor02 |= Wire.read();  //Recuperamos LSB
  Serial.print("Valor sensor en A2 del esclavo: ");
  Serial.println(sensor02);
  
  //03
  sendCommand(CMD_READ_A3, 2);
  sensor03 = Wire.read();   //Recuperamos MSB
  sensor03 <<= 8;           //Desplazamos 8 bits a la izquierda
  sensor03 |= Wire.read();  //Recuperamos LSB
  Serial.print("Valor sensor en A3 del esclavo: ");
  Serial.println(sensor03);

  
}

Muchas gracias. Problema resuelto.