Raspi C/C++, Raspi als I2C-Master: byte arrays zu Arduino slave hin + her schicken?

[HaWe]

hallo,
da hast du es ja immerhin ein ganz gewaltiges Stück weiter geschafft als ich!

Danke die aber ganz herzlich für dein Engagement und deine ganzen Posts, schon an deinen letzten Codes kann man noch ein Riesen Stück lernen!

Gruß
Helmut

[peterfido]

Hallo,

Danke. Ich lass die Codes mal drin, obwohl nicht optimiert und aufgeräumt.

Meinem LA nach scheint der MEGA bzw. der Wire-Code vom ARDUINO Slave mindestens ein bestimmtes Problem nicht zu erkennen und abzufangen. Evtl. läuft es ohne Pegelwandler stabiler.? Das habe ich nicht mehr probiert.

Der BitBang-Code eignet sich gut, um die Toleranz des ARDUINO-Codes, bzw. des MEGA seiner TWI-Einheit auszutesten. Wenn man sich die Bytes anzeigen lässt, indem man den auskommentierten Code wieder aktiviert, dann liegt bei einem Takt von 100.000 oft nur ein Bit von den 240 Bytes quer. Spielt man mit dem Taktwert, dann steigt die Fehlerquote. Man könnte noch einen langsameren Takt probieren, wenn der ARDUINO-Code das unterstützt. Die weiter Oben erwähnten Flanken kann ich ohne Oszi leider nicht analysieren.

Beim Testen kam mir die Ausgabe vom ARDUINO-MEGA etwas verzögert vor. Kann aber auch an den vielen Bytes liegen. Auch möglich, dass da Interrupts zwischen funken. Da wird viel von der Wire-Bibliothek gemacht. Da das wohl seit 10 Jahren unverändert ist, kann man entweder nicht weiter optimieren oder es hat noch keiner wirklich für Dauereinsätze gebraucht. Im ARDUINO-Forum habe ich nicht gestöbert.

Interessant wäre der Bascom-Slave Code. Allerdings kostet die Bibliothek extra. Das macht für einen reinen kurzen Test für mich keinen Sinn. Oder halt die Datenblätter durchstöbern und selbst was programmieren.

[peterfido]

Hallo,

es geht nur zuverlässig mit der BitBang-Methode.

Folgende Codes laufen bei mir seit einiger Zeit fehlerfrei durch:

MEGA

// Wire Slave Receiver
// by Nicholas Zambetti <http://www.zambetti.com>

// Demonstrates use of the Wire library
// Receives data as an I2C/TWI slave device
// Refer to the "Wire Master Writer" example for use with this

// Created 29 March 2006

// This example code is in the public domain.
//

#include <Wire.h>

#define REGSIZE 240

byte rspeicher[REGSIZE];
byte wspeicher[REGSIZE];
byte puffer[5];
byte Register=1;
byte block=0;
byte pos=0;
byte fertig=0;
long dg=0;
long timeout=0;

void setup() {
  Wire.begin(4);                // join I2C bus with address #8
  Wire.onReceive(receiveEvent); // register event
  Wire.onRequest(requestEvent); // register event
  Serial.begin(57600);           // start serial for output

  Serial.println();  
  Serial.println("Starte I2C-Test");  
}


byte chksum(byte arr[], byte anzahl)
{
  byte i;
  byte sum=0;
  
  for(i = 0; i < anzahl; i++){
    sum+=arr[i];
  }
  return sum;
}


void loop() {
  byte i=0;
  delay(100);
  timeout++;
  if (timeout==90){
      timeout=0;
      Wire.begin(4); 
      Serial.println("TimeOut!");
      dg=0;
  }
  

  if (fertig !=0){
    fertig=0;
    timeout=0;
    dg++;
    Serial.println(dg);
    
    for (i=0;i<REGSIZE;i++){
      Serial.print(rspeicher[i]);
      Serial.print (" ");
    }
    Serial.println();
  }
}

 void TWIRESET(){
  Wire.begin(4); 
 }

// function that executes whenever data is received from master
// this function is registered as an event, see setup()
void receiveEvent(int howMany) {
    byte x[4];
    byte i;
    if(howMany == 4){
        for (i=0;i<4;i++){
          x[i]=Wire.read();
          Serial.print (x[i]);
          Serial.print (" ");
        }
        if (x[0]==137){
          if (chksum(x,3)==x[3]){
            if (x[1]<REGSIZE){
              block=x[1];
              rspeicher[block]=x[2];
              wspeicher[block]=rspeicher[block];
            }
            if (x[1]==REGSIZE-1){
              fertig=1;
            }
            Serial.println(" - Summe OK");
          }else{
            Serial.println(" - Summe fehlerhaft");
          }
        }
      }else{
        if (howMany==2){
          for (i=0;i<2;i++){
            x[i]=Wire.read();
            if (x[0]==87 && x[1]==56){
              TWIRESET();         
            }
          }        
        }else{
        Serial.print ("Anzahl Daten: ");
        Serial.println(howMany);
        while (0 < Wire.available()) { //überflüssiges lesen
            x[4]=Wire.read();
        }
      }
    }
}

// function that executes whenever data is requested by master
// this function is registered as an event, see setup()
void requestEvent() {
  byte i;
  
  puffer[0]=block;
  puffer[1]=wspeicher[block];
  puffer[2]=chksum(puffer,2);
  Wire.write(puffer,3);
  for (i=0;i<3;i++){
    Serial.print (puffer[i]);
    Serial.print (" ");
  }
  Serial.println();

  
}

Raspi:

// GCC -Wall -pthread -o /var/scripte/bbi2cmaster1012 /var/scripte/bbi2cmaster1012.c -lpigpio -lrt
// /var/scripte/bbi2cmaster1012
//I2C mit pipgio
//peterfido
//V1.012
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pigpio.h>

#define SDA 2
#define SCL 3
#define TAKT 100000
#define PAUSEN 5000
#define ADDRESS 0x04
#define MSGSIZE  240



char empfdata[MSGSIZE];  // 
char senddata[MSGSIZE];
char commando[20];
char puffer[12];
unsigned int ARDUPOS=0;

unsigned int laenge=0;

volatile sig_atomic_t done = 0;
 
void term(int signum)
{
    done = 1;
}

int I2CResetBus(void)
{
    char i;
    int res=0;
    if(gpioRead(SDA) && gpioRead(SCL)) {
        return 0;
    }
    gpioSetMode(SCL, PI_INPUT);
    gpioSetMode(SDA, PI_INPUT);
    gpioSetPullUpDown(SDA, PI_PUD_UP);   // Sets SDA pull-up.
    gpioSetPullUpDown(SCL, PI_PUD_UP);   // Sets SDA pull-up.       
    usleep(50);
    if(!gpioRead(SCL)) {
        return -1; /* SCL wird extern auf Low gehalten, nix zu machen */
    }
    for(i = 0; i<9; i++) { 
        gpioSetMode(SCL, PI_OUTPUT);
        gpioWrite(SCL, 0);
        usleep(50);
        gpioSetMode(SCL, PI_INPUT);
        gpioSetPullUpDown(SCL, PI_PUD_UP);   // Sets SDA pull-up.       
        usleep(50);
        if(gpioRead(SDA)) {
            break; /* SDA ist high STOP */
        }
    } /* for */
    if(!gpioRead(SDA)) {
        return -1; 
    }
    commando[0]= 3;    //stop
    commando[1]= 0;    // Fertig
    res=bbI2CZip(SDA,commando,2,NULL,0);
    if (res!=0){
        printf("Fehler beim Reset!\n");
    }
    if(gpioRead(SDA) && gpioRead(SCL)){  
        return 0;
    }else{
        return -1;  
    }
}

char chksum(char arr[], int anzahl)
{
    int i;
    char sum=0;
    
    for(i = 0; i < anzahl; i++){
        sum+=arr[i];
    }
    return sum;
    
}

int syncen() {
    
    int erg=0;
    int res=0;
    int i=0;

    commando[0]= 4;    //'Adresse setzen ankündigen
    commando[1]= 4;    //'Adresse übergeben
    commando[2]= 2;    //start
    commando[3]= 7;    //'Bytes senden
    commando[4]= 4;    //'Anzahl 
    commando[5]= 137;    //Position
    commando[6]= ARDUPOS;    //Position
    commando[7]= senddata[ARDUPOS];    //Position
    commando[8]= chksum(&commando[5],3);    //Position
    commando[9]= 3;    //stop
    commando[10]= 0;    //keine weiteren Parameter
    
    printf("Gesendet: ");
    for(i=6;i<8;i++){
        printf("%d ",commando[i]);
    }    
    printf("\n");    
    
    
    res=I2CResetBus();
    res=bbI2CZip(SDA,commando,20,puffer,12);    
    usleep(50000);
    commando[0]= 4;    //'Adresse setzen ankündigen
    commando[1]= 4;    //'Adresse übergeben
    commando[2]= 2;    //start
    commando[3]= 6;    //Bytes lesen
    commando[4]= 3;    //Anzahl
    commando[5]= 3;    //stop
    commando[6]= 0;    //keine weiteren Parameter
    res=I2CResetBus();
    res=bbI2CZip(SDA,commando,20,puffer,12);    
    
    printf("Empfangen:");
    for(i=0;i<2;i++){
        printf("%d ",puffer[i]);
    }    
    if (puffer[2] == chksum(puffer,2)){
        printf(" - Summe OK");
    }else{
        printf(" - Summe fehlerhaft %d",chksum(puffer,2));

    }
    if (res==3){
        if (puffer[0]==ARDUPOS && puffer[2] == chksum(puffer,2)){
            empfdata[ARDUPOS]=puffer[1];
            erg=0;
        }else{
            printf(" - E Falsche Blocknummer. Erwartet: %d, bekommen: %d, Wert: %d\n",ARDUPOS,puffer[0],puffer[1]);
            erg=1;
        }
    }else{
        printf(" - E Fehler beim Blockeinlesen. Block: %d, Fehler: %d\n",ARDUPOS,res);
        erg=1;
    }
    return erg;
}

void ARDURESET(){
    commando[0]= 4;    //'Adresse setzen ankündigen
    commando[1]= 4;    //'Adresse übergeben
    commando[2]= 2;    //start
    commando[3]= 7;    //'Bytes senden
    commando[4]= 2;    //'Anzahl 
    commando[5]= 87;    //RESET-Sequenz
    commando[6]= 56;    //RESET-Sequenz
    commando[7]= 3;    //stop
    commando[8]= 0;    //keine weiteren Parameter
    I2CResetBus();
    bbI2CZip(SDA,commando,20,NULL,0);
    usleep(50000);
}

int main(int argc, char **argv)
{
    int res=0;
    long dg=1;
    long maxdg=0;
    unsigned int Fehler=0;

    struct sigaction action;
    memset(&action, 0, sizeof(struct sigaction));
    action.sa_handler = term;
    sigaction(SIGINT, &action, NULL);
    sigaction(SIGTERM, &action, NULL);
    
    if (gpioInitialise() < 0)
    {
        printf("Fehler beim Initialisieren von gpio!");
        gpioTerminate();
    }else{
        res=bbI2COpen(SDA,SCL,TAKT);
        res=res+gpioSetMode(SDA, PI_INPUT);  // Set SDA as input.
        res=res+gpioSetMode(SCL, PI_INPUT);  // Set SDA as input.
        res=res+gpioSetPullUpDown(SDA, PI_PUD_UP);   // Sets SDA pull-up.
        res=res+gpioSetPullUpDown(SCL, PI_PUD_UP);   // Sets SDA pull-up. 
        srand(time(NULL));
        if(res==0){
            printf("\n\n\nStarte I2C-Test\n\n");
            while (!done)
            {    
                
                senddata[ARDUPOS]=rand() % 255;
                res=syncen();

                if (senddata[ARDUPOS]==empfdata[ARDUPOS]){
                        printf(" - Daten OK %ld (%ld)\n",dg,maxdg);
                        Fehler=0;
                        dg++;
                }else{
                    printf(" - Daten fehlerhaft ****************************************** %ld \n",dg);
                //    ARDURESET();
                    Fehler++;
                    dg=0;
                    if (dg>maxdg){
                        maxdg=dg;
                    }

                    if (Fehler==100){
                        break;
                    }
                }
                
                if (res==0){
                    ARDUPOS++;
                    if (ARDUPOS >= MSGSIZE){
                        ARDUPOS=0;
                        //usleep(500000);//Dem ARDUINO Zeit für die Anzeige geben
                        //sleep(2);//Dem ARDUINO Zeit für die Anzeige geben
                    }
                
                }
                
                usleep(5000);
            }
        }else{
            printf("E Fehler beim Oeffnen\n");    
        }
    }
    res=bbI2CClose(SDA);
    
    if (res!=0){
        printf("E Fehler beim Schliessen: %d\n", res);
    }else{
        printf("E Schliessen OK\n");
    }

    gpioTerminate();
    
    return 0;
}

Es läuft hier mit Pegelwandler.

Es wird in der Sub 'Sync' (Evtl. sollte diese noch einen anderen Namen bekommen. Der Name Sync ist bei HardwareI2C schon belegt...) bei jedem Aufruf nur ein DatenByte geschrieben und gelesen. Es gibt ein Startbyte und eine Prüfsumme um Kommunikationsfehler zu erkennen.

Wie es sich mit Interrupts auf dem MEGA verträgt, habe ich nicht getestet. Ob die TWIRESET Sub auf dem Mega immer zuverlässig läuft, kann ich nicht sagen. Evtl. kann man die Pausen verkürzen, wenn der MEGA nix weiter zu tun hat oder sie müssen verlängert werden, wenn Fehler z.B. wegen vieler Interrupts auftreten.


Hardware I2C verträgt sich mit dem (meinem) ARDUINO MEGA irgendwie nicht.

[HaWe]

hallo,
danke für's Update!

das ist aber jetzt noch immer nicht mein ursprünglicher i2c-Job mit je 32 bytes vom Raspi aus abwechselnd vom Arduino lesen / an Arduino schreiben, mit je 10ms delay dazwischen, oder?

Mein Arduino-Slave code muss unbedingt so bleiben wie er war!

//  Arduino code to send/receive byte arrays
//  Arduino as an I2C slave
//
//  ver. 0.002b


#include  <Wire.h>

#define  SLAVE_ADDRESS 0x04
#define  MSGSIZE  32
byte     recvarray[MSGSIZE];  // 0=0xff; 1=chksum; ...data...; MSGSIZE-1=SLAVE_ADDRESS
byte     sendarray[MSGSIZE];

volatile int8_t  flag=0;


//=====================================================================================
//=====================================================================================
void setup() {
   int32_t  i=0;

   // Serial terminal window
   i=115200;
   Serial.begin(i);
   Serial.print("Serial started, baud=");
   Serial.println(i);

   // Wire (i2c)
   Wire.begin(SLAVE_ADDRESS);     // start Arduino as a I2C slave, addr=0x04 (7-bit coded)
   
   Wire.onReceive(receiveData );  // event when master array is sent
   Wire.onRequest(sendData );     // event when master requests array to read
   
   memset(sendarray, 0, sizeof(sendarray) );  // init send- and recv arrays
   memset(recvarray, 0, sizeof(recvarray) );   
   
   Serial.print("I2C init: my slave address= ");
   Serial.println(SLAVE_ADDRESS);
   Serial.println("I2C init: done.");
   Serial.println();
   
   Serial.println("setup(): done.");   

}


//=====================================================================================


uint8_t  calcchecksum(uint8_t array[]) {   
  int32_t  sum=0;
  for(int i=2; i<MSGSIZE; ++i) sum+=(array[i]);
  return (sum & 0x00ff);
}

//=====================================================================================

void loop()
{
   char sbuf[128];

   Serial.println(); Serial.println();

   // do something with the received data
   // and then do something to build the sendarray [3]...[MSG_SIZE-2]
   
   if (flag==1) {
       //debug
       sendarray[4] +=1;   
   }

   sendarray[0] = 0xff;                        // 0 = start: 0xff == msg start flag
   sendarray[2] = flag;                        // 2 = send back msg error flag   
   sendarray[MSGSIZE-1] = SLAVE_ADDRESS;       // end of array: ID check     
   
   sendarray[1] = calcchecksum(sendarray);     // 1 = calc new chksum
   flag=0;   
   
   // debug output
   sprintf(sbuf, "Sendarr[4]=%4d,   [5]=%4d,   Recvarr[4]=%4d,  [5]=%4d",
                  sendarray[4], sendarray[5],  recvarray[4],    recvarray[5]) ;
   Serial.println(sbuf);

   delay(1);                                     // short break for the cpu and the bus
}


//=====================================================================================

void receiveData(int byteCount) {
    int32_t i;
    byte val;

    while(Wire.available()<MSGSIZE) ;           // wait for all bytes to complete
    i=0;                                        // init counter var
    while(Wire.available()&& (i<MSGSIZE) )      // read all recv array bytes
    {
      val=Wire.read();
      recvarray[i++]=val;
    }
   
    // check for transmission error
    if(  (recvarray[0]  == 0xff)
      && (recvarray[1]  == calcchecksum(recvarray))
      && (recvarray[MSGSIZE-1] == SLAVE_ADDRESS  ) )
         flag=1;        // data ok
    else
         flag=127;      // data faulty => handle rcv-error => flag =127
}

//=====================================================================================

void sendData(){
  // Wire.write writes data from a slave device in response to a request from a master
  Wire.write(sendarray, MSGSIZE);    // send own byte array back to master..

[peterfido]

Hallo,

nein. Das ist ein alternatives Protokoll. Getestet mit 240 Nutzbytes. Das kannst Du an Deine Zwecke anpassen und testen. Ich hatte es so verstanden, dass 30 Bytes nicht ausreichen.

Evtl. läuft es mit 32 Bytes immer noch fehlerfrei. Wobei Du die Slave-Adresse nicht mitschicken brauchst, da er ja nur auf seine Slave-Adresse reagiert bzw. reagieren sollte. Aufpassen musst Du darauf, dass nach der Prüfsummenbildung die Bytes nicht mehr verändert werden. Das ist bei dem Testcode nicht der Fall, kann später, wenn der MEGA ein paar Bytes mit anderen ICs austauscht, Zeitprobleme mitbringen. Wenn alles bis zur nächsten senddata-Bildung noch zwischengespeichert werden muss. Da lässt sich Zeit sparen, wenn die Prüfsumme gleich beim Array-Zusammenbau mit berechnet wird.

Ich habe mich mal über den DUE informiert. Dieser spielt in einer ganz anderen Liga als der MEGA. Wenn Du für den ARDUINO ein Display vorgesehen hast, werden die 10 ms-Lücken zwischen I2C-Datenaustausch für Display, die Ansteuerung weiterer IC´s über evtl. UART ISP und I2C sowie Speicherkopiererei und evtl. TimerInterrupts bei den 16MHz des MEGA etwas knapp.

Ich mache es immer umgekehrt. Der Raspi ist der Kommunikative und dient dem AVR per UART als Gateway zu allen sonstiges Gerätchen. Vor Allem Ethernet bzw. WLAN fehlen den AVRs. Leider auch dem DUE, obwohl es der Mikrocontroller quasi mitbringt. Dann übernimmt der Raspi neben dem Webinterface oft noch Lautsprecher und die farbige Anzeige auf Bilderrahmen über lcd4linux per USB.

Deine Projekt kenne ich nicht und weiß nicht, was da zeitkritisches vor sich gehen soll, bzw. warum das Timing so brisant ist.

Das schnellste ist ganz klar SPI. Danach kommt UART, wenn man ein Baudratenquartz hat, danach dann I2C. Parallel ist theoretisch 8 mal so schnell wie UART, wird aber von der Hardware nicht unterstützt und läuft ohne Puffer nicht ganz so zuverlässig. Benötigt aber auch die meisten PortPins. Bei SPI geht Dein Protokoll aber nicht, da bei jedem Senden auch gleichzeitig empfangen wird.

[HaWe]

achso - sogar 240 statt 32 Bytes - das ist ntl ein dicker Pluspunkt, und dass das SPI-Display hier ein Zeitproblemwerden könnte, stimmt auch, das habe ich noch gar nicht ausgetestet. Ich wollte die ILI9341_due lib verwenden, die soll angeblich auch mit dem Mega laufen - selber gemacht habe ich es damit aber nicht, nur mit dem Due. Wäre in der Tat ein weiterer Knackpunkt.
Danke nochmal für die Erklärungen und Tipps!

- - - Aktualisiert - - -

es geht im Prinzip darum, Arduinos sowohl als Sensor-Multiplexer als auch für Fernsteuerungen zu nutzen, und darum, gleichzeitig auch noch weitere spezielle I2C und UART-Sensoren an den Raspi anzuschließen (IMU- GPS, RTC - vllt sogar mal nen LIDAR).
UART alleine reicht dazu nicht aus, weil nur ein "slave" angeschlossen werden kann, bei I2C dagegen dutzende am selben Port. Je mehr Geräte am Bus hängen, desto schneller muss aber jedes einzelne Gerät arbeiten und gesteuert werden können.

[peterfido]

Hallo,

das klingt nach ein paar interessante Aufgaben. IMU, GPS und LIDAR nach einem selbstfahrenden Fahrzeug. Wenn GPS vorhanden ist, kann die RTC wegfallen. Wobei der Raspi ja auch eine Uhr hat. So braucht die RTC nur gelegentlich abgeglichen werden. Der Raspi selbst hat mehrere UARTs. Ein USB-Hub dran und daran ein paar FTDI anschließen. Dutzende I2C Slaves teilen sich die Geschwindigkeit von 100k. Soll der Bus schneller laufen, müssen alle mit der höheren Geschwindigkeit klar kommen.

Bei einem selbst gebauten Protokoll, können an einem UART auch mehrere 'Slaves' hängen. Einfach einen Ring aufbauen. Der Nachteil ist, dass alle Slaves die Daten weiterreichen müssen. Also überall Mikrocontroller dran. Diese können über einen zweiten UART andere Geräte bedienen. Das (mein) Protokoll (an welchem ich nicht weiter arbeite) ist etwas trickreich oder es müssen entsprechend große Buffer verwendet werden. Daher nehme ich lieber die Lösung mit mehreren UARTs.

Deine Idee, I2C zu nutzen, gefällt mir. Mich stören eher meine Testergebnisse. Evtl. arbeite ich da nochmal weiter dran. Dafür muss ich aber erstmal investieren. Evtl. habe ich sogar noch einen 'alten' Raspi irgendwo rum(f)liegen, damit einer mal als Slave dienen kann. Einen DUE-Nachbau plus SPI-Display habe ich mir heute geordert. Während meines Bestellvorgangs ging die Anzahl der Verfügbaren nach unten. Evtl. lesen hier welche mit und kaufen nun ein

Ich selbst habe viel mit AVRs gebaut. Eigene Platinen mit Löten und so. Das mach mir immer weniger Spass. (Brille ab, Brille auf, Lupe,... - Das brauchte ich 'früher' alles nicht) Bei den ARDUINOs reicht zusammenstecken und programmieren. Wobei es mir aktuell mehr ums programmieren (wenn es draußen ungemütlich ist) an sich geht. Allerdings habe ich da auch noch ein paar Windows-Tools in der Pipeline...