So senden Sie ein 4-Topf-Werte per i2c vom arduino zu arduino? Wie unterscheiden sich diese Werte, wenn Sie zu erhalten?

Ahh, was wir hier haben, ist eine grundlegende Frage, wie design die I2C-Kommunikation. Leider Beispiele für I2C master und slave enthalten in der Arduino IDE sind IMO zu begrenzt, um klare Orientierung bieten in dieser Angelegenheit.

Zunächst in Ihr Beispiel die master-und Slave-Rollen sind ausgetauscht und sollten gewechselt werden. Slave Lesen sollten Werte von der analog-Eingänge und master sollten Sie beantragen. Warum? Weil es den master, die entscheiden sollen, wenn auf Anfrage Werte und decodiert die Anfrage. Slave sollte die richtige Antwort auf eine bestimmte Anfrage, dass das problem der interpretation der Daten.

I2C-Kommunikation basiert auf requestFunction-(warten)-requestResponse-Sequenz gesteuert durch den master.
Bitte entnehmen Sie die Entfernungsmesser Beispiel auf arduino-Seite. Kurz gesagt:

Erste: master fordert eine Funktion zum Messen der Entfernung:

  //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

(manchmal auch Sklaven brauchen einige Zeit, z.B. 10 - 50 ms, Anfragen zu Bearbeiten, aber in dem Beispiel bin ich auf Meister nicht Verzögerung gelesen)

Zweite: master Anfragen Antwort:

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

Dritte: master versucht zu Lesen und zu analysieren Antwort.

Sollten Sie design zuverlässige I2C-Kommunikation in ähnlicher Weise.

Hier ist, wie ich es tun; Sie Folgen können, meine Muster und get extensible slave Implementierung, die Unterstützung einer Funktion: Lesen der analog-Eingänge, kann aber leicht erweitert werden, indem zusätzliche Funktionscodes und erforderliche Verarbeitung mit der Umsetzung der slave-main-loop

Einleitenden Ausführungen

1. irgendeine Art von einfaches Protokoll ist notwendig für die Steuerung von slave - z.B. es sollte Unterstützung ersuchenden Funktionen. Unterstützende Funktionen-Anfragen ist nicht unbedingt nötig, in solchen simmple Szenario wie die Lektüre von vier analoge Eingänge, aber das, was ich beschreibe, ist ein allgemeineres Muster, das Sie verwenden können, die in anderen Projekten.

2. Slave, sollten Sie nicht führen Sie keine weiteren Aktionen (wie Lesen Eingänge) auf Anfrage Antwort wie die I2C-Kommunikation unterbrechen können (aufgrund der Verzögerungen) und du bekommst teilweise Antworten etc. Dies ist eine sehr wichtige Anforderung, welche einen Einfluss auf den slave-design.

3. Antwort (und auch Wunsch, wenn erforderlich) enthalten kann, die CRC als wenn der master wartet nicht lange genug, kann es ein leeres Antwort. Wenn niemand sonst noch Los ist, verwenden Sie Ihren code Gegenmaßnahmen sind nicht erforderlich und wird hier nicht beschrieben werden. Andere wichtige Sache ist die Wire-Bibliothek Puffer Beschränkung von 32 bytes und Durchführung von CRC-Prüfsumme verändern, ohne die Länge des Puffers Grenzen der verfügbaren Daten-Länge von zwei bytes (wenn die crc16 verwendet wird).

slave:

#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
}

master:

#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 ...)
}

Ich hoffe, mein Beispiel hilft. Es basiert auf dem code arbeiten seit Wochen machen 40 liest einen zweiten von mehreren slaves, jedoch habe ich nicht kompiliert, um die Funktion zu testen, die Sie benötigen.
Bitte verwenden Sie WSWire Bibliothek als der Draht (zumindest für Arduino 1.0.3) kann gelegentlich einfrieren, Ihre master -, wenn aus irgendeinem Grund der slave reagiert nicht auf Anfrage.

EDIT: Die WSWire lib benötigt externe pull-up-widerstände für I2C, es sei denn, Sie ändern Sie die Quelle und aktivieren die internen pull-ups wie Draht hat.

EDIT: anstatt i2c-slave-Implementierung Sie können versuchen, die EasyTransfer Bibliothek. Ich habe es nicht ausprobiert, aber kann es einfacher sein, es zu benutzen, wenn senden von vier bytes, ist alles was Sie brauchen.

BEARBEITEN[12.2017]: Es ist ein neuer Spieler auf den block - PJON - eine Bibliothek geeignet für einfache multi-master-Kommunikation ideal zum Austausch poti-Werte (und vieles mehr). Es ist schon seit einiger Zeit, aber gewann eine beträchtliche Geschwindigkeit der Entwicklung in den letzten Monaten. Ich bin teilweise an der Entwicklung beteiligt und wechselte alle Feld-Ebene und der lokalen Busse, die ich bisher verwendet habe (I2C, MODBUS RTU) PJON über single-wire -, seriellen hardware-oder RF.

InformationsquelleAutor Mr. Girgitt