Comment envoyer 4 Pot de valeurs via i2c depuis l'arduino arduino? Comment différencier ces valeurs tout en recevant d'eux?

Ahh ce que nous avons ici est une question de base sur la façon de concevoir communication I2C. Malheureusement, les Exemples I2C maître et de l'esclave inclus dans l'IDE Arduino sont OMI trop limité pour fournir des orientations claires sur cette question.

Tout d'abord dans votre exemple, le maître et les esclaves, les rôles sont échangés et doit être changé. L'esclave doit lire des valeurs des entrées analogiques et maître doit en faire la demande. Pourquoi? Parce que c'est le maître qui doit décider du moment de la demande de valeurs et de décoder correctement la demande. L'esclave doit fournir une réponse à une demande d'éliminer le problème de l'interprétation des données.

Communication I2C est basé sur requestFunction-(attendre)-requestResponse séquence contrôlée par le maître.
Veuillez vous référer à la télémètre exemple sur arduino page. En un mot:

D'abord: le maître demande une fonction de mesure de distance:

  //step 3: instruct sensor to return a particular echo reading 
  Wire.beginTransmission(112); //transmit to device #112
  Wire.write(byte(0x02));      //sets register pointer to echo #1 register (0x02)
  Wire.endTransmission();      //stop transmitting

(parfois esclaves besoin d'un certain temps, par exemple de 10 à 50 ms pour traiter les demandes, mais dans l'exemple que j'référant à un maître ne tardez pas lire)

Deuxième: maître des requêtes de réponse:

  //step 4: request reading from sensor
  Wire.requestFrom(112, 2);    //request 2 bytes from slave device #112

Troisième: maître essaie de lire et d'analyser la réponse.

Vous devriez conception fiable de communication I2C une manière similaire.

Voici comment je le fais; vous pouvez suivre mon modèle et obtenir extensible esclave de la mise en œuvre, support d'une fonction: lecture des entrées analogiques, mais peut facilement être étendue en ajoutant des codes de fonction et de traitement requis de mise en œuvre de l'esclave boucle principale

Remarques initiales

1. une sorte de protocole simple est nécessaire pour contrôler les esclaves d'exemple, il devrait soutenir demandant fonctions. Fonctions d'appui des demandes n'est pas absolument nécessaire dans de tels simmple scénario que la lecture de quatre entrées analogiques, mais ce que je suis en décrivant de façon plus générale le modèle que vous pouvez utiliser dans d'autres projets.

2. Esclave ne doit pas effectuer des actions supplémentaires (comme la lecture des entrées) sur demande de réponse en tant que communication I2C peut casser (en raison de retards) et vous obtiendrez des réponses partielles, etc. Ceci est très important exigence qui affectent l'esclave de la conception.

3. réponse (et demande également si nécessaire) peut contenir des CRC comme si le maître attend pas assez longtemps, il peut obtenir de réponse vide. Si personne d'autre ne va utiliser votre code de telles contre-mesures ne sont pas nécessaires et ne sera pas décrite ici. Autre aspect important, c'est le Fil de tampon de bibliothèque limitation, qui est de 32 octets et la mise en œuvre de somme de contrôle CRC sans modifier la longueur de la mémoire tampon des limites des données disponibles de la longueur de deux octets (si crc16 est utilisé).

esclave:

#include <WSWire.h>  //look on the web for an improved wire library which improves reliability by performing re-init on lockups 
//>> put this into a header file you include at the beginning for better clarity
enum { 
I2C_CMD_GET_ANALOGS = 1
};
enum { 
I2C_MSG_ARGS_MAX = 32,
I2C_RESP_LEN_MAX = 32
};
#define I2C_ADDR                 0             
#define TWI_FREQ_SETTING         400000L       //400KHz for I2C
#define CPU_FREQ                 16000000L     //16MHz
extern const byte supportedI2Ccmd[] = { 
1
};
//<< put this into a header file you include at the beginning for better clarity
int argsCnt = 0;                        //how many arguments were passed with given command
int requestedCmd = 0;                   //which command was requested (if any)
byte i2cArgs[I2C_MSG_ARGS_MAX];         //array to store args received from master
int i2cArgsLen = 0;                     //how many args passed by master to given command
uint8_t i2cResponse[I2C_RESP_LEN_MAX];  //array to store response
int i2cResponseLen = 0;                 //response length
void setup()
{
//>> starting i2c
TWBR = ((CPU_FREQ / TWI_FREQ_SETTING) - 16) / 2;
Wire.begin(I2C_ADDR);                        //join i2c bus 
Wire.onRequest(requestEvent);                //register event
Wire.onReceive(receiveEvent);    
//<< starting i2c
}
void loop()
{
if(requestedCmd == I2C_CMD_GET_ANALOGS){
//read inputs and save to response array; example (not tested) below
i2cResponseLen = 0;
//analog readings should be averaged and not read one-by-one to reduce noise which is not done in this example
i2cResponseLen++;
i2cResponse[i2cResponseLen -1] = analogRead(A0);
i2cResponseLen++;
i2cResponse[i2cResponseLen -1] = analogRead(A1);
i2cResponseLen++;
i2cResponse[i2cResponseLen -1] = analogRead(A2);
i2cResponseLen++;
i2cResponse[i2cResponseLen -1] = analogRead(A3);
//now slave is ready to send back four bytes each holding analog reading from a specific analog input; you can improve robustness of the protocol by including e.g. crc16 at the end or instead of returning just 4 bytes return 8 where odd bytes indicate analog input indexes and even bytes their values; change master implementation accordingly
requestedCmd = 0;   //set requestd cmd to 0 disabling processing in next loop
}
else if (requestedCmd != 0){
//log the requested function is unsupported (e.g. by writing to serial port or soft serial
requestedCmd = 0;   //set requestd cmd to 0 disabling processing in next loop
}
} 
//function that executes whenever data is requested by master
//this function is registered as an event, see setup()
void requestEvent(){
Wire.write(i2cResponse, i2cResponseLen);
}
//function that executes when master sends data (begin-end transmission)
//this function is registered as an event, see setup()
void receiveEvent(int howMany)
{
//digitalWrite(13,HIGH);
int cmdRcvd = -1;
int argIndex = -1; 
argsCnt = 0;
if (Wire.available()){
cmdRcvd = Wire.read();                 //receive first byte - command assumed
while(Wire.available()){               //receive rest of tramsmission from master assuming arguments to the command
if (argIndex < I2C_MSG_ARGS_MAX){
argIndex++;
i2cArgs[argIndex] = Wire.read();
}
else{
; //implement logging error: "too many arguments"
}
argsCnt = argIndex+1;  
}
}
else{
//implement logging error: "empty request"
return;
}
//validating command is supported by slave
int fcnt = -1;
for (int i = 0; i < sizeof(supportedI2Ccmd); i++) {
if (supportedI2Ccmd[i] == cmdRcvd) {
fcnt = i;
}
}
if (fcnt<0){
//implement logging error: "command not supported"
return;
}
requestedCmd = cmdRcvd;
//now main loop code should pick up a command to execute and prepare required response when master waits before requesting response
}

maître:

#include <WSWire.h>
#define I2C_REQ_DELAY_MS         2  //used for IO reads - from node's memory (fast)
#define I2C_REQ_LONG_DELAY_MS    5  //used for configuration etc.
#define TWI_FREQ_SETTING         400000L
#define CPU_FREQ                 16000000L
enum { 
I2C_CMD_GET_ANALOGS = 1
};
int i2cSlaveAddr = 0;
void setup(){
//joining i2c as a master
TWBR = ((CPU_FREQ / TWI_FREQ_SETTING) - 16) / 2;
Wire.begin(); 
}
void loop(){
//requesting analogs read: 
Wire.beginTransmission(i2cSlaveAddr); 
Wire.write((uint8_t)I2C_CMD_GET_ANALOGS);  
Wire.endTransmission();  
delay(I2C_REQ_DELAY_MS);
//master knows slave should return 4 bytes to the I2C_CMD_GET_ANALOGS command
int respVals[4];
Wire.requestFrom(i2cSlaveAddr, 4);
uint8_t respIoIndex = 0;
if(Wire.available())
for (byte r = 0; r < 4; r++)
if(Wire.available()){ 
respVals[respIoIndex] = (uint8_t)Wire.read();
respIoIndex++;      
}
else{
//log or handle error: "missing read"; if you are not going to do so use r index instead of respIoIndex and delete respoIoIndex from this for loop
break;
}
//now the respVals array should contain analog values for each analog input in the same order as defined in slave (respVals[0] - A0, respVals[1] - A1 ...)
}

J'espère que mon exemple. Il est basé sur le code de travail pour les semaines qui en fait 40 lit un deuxième à partir de plusieurs esclaves, cependant je n'ai pas compilé pour tester la fonction dont vous avez besoin.
Veuillez utiliser WSWire bibliothèque comme le Fil (au moins pour Arduino 1.0.3) peut parfois geler votre maître si pour une raison quelconque esclave ne permettra pas de répondre à la demande.

EDIT: La WSWire lib externe requise résistances de pull-up pour l'I2C, sauf si vous modifiez la source et permettre interne pull-ups comme Fil n'.

EDIT: au lieu de créer i2c esclave de la mise en œuvre, vous pouvez essayer l' EasyTransfer de la bibliothèque. Je n'ai pas essayé, mais il peut être plus facile à utiliser si l'envoi de quatre octets est tout ce dont vous avez besoin.

MODIFIER[12.2017]: Il y a un nouveau joueur sur le bloc - PJON - une bibliothèque adaptée pour des configurations multi-master de communication idéal pour l'échange de pot de valeurs (et beaucoup plus). Il a été autour depuis un certain temps, mais a gagné un important développement de la vitesse au cours des derniers mois. Je suis partiellement impliqués dans son développement et de commutation de tous les niveaux de champ et les bus que j'ai utilisé jusqu'à présent (I2C, MODBUS RTU) pour PJON plus seul fil, matériel de série ou RF.

OriginalL'auteur Mr. Girgitt