Hallo,

ich sehe da ein Problem im ARDUINO-Code.

Der hängt sich weg, auch wenn man zwischen Senden und Empfangen eine Sekunde Pause einlegt.
Demnach läuft kein Puffer über, aber irgendetwas ist.

Meine aktuellen Codes:
MEGA:
Code:
// 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[32];
byte Register=1;
byte rdblock=0;
byte wrblock=0;
byte pos=0;
byte fertig=0;

void setup() {
  Wire.begin(4);                // join I2C bus with address #8
  Wire.onReceive(receiveEvent); // register event
//  Wire.onReceive(receiveEventRoh); // register event
  Wire.onRequest(requestEvent); // register event
  Serial.begin(57600);           // start serial for output
/*  for(byte i=0;i<REGSIZE;i++){
    wspeicher[i]=i;
    
  }*/
  Serial.println();  
  Serial.println("Starte I2C-Test");  
}

void loop() {
  byte i=0;
  delay(100);
  if (fertig !=0){
    fertig=0;
    for (i=0;i<REGSIZE;i++){
      wspeicher[i]=rspeicher[i];
      Serial.print(rspeicher[i]);
      Serial.print (" ");
    }
    Serial.println();
  }
}

// function that executes whenever data is received from master
// this function is registered as an event, see setup()
void receiveEvent(int howMany) {
    rdblock = Wire.read();
    if (rdblock<=7){
      pos=0;
      while (0 < Wire.available()) { 
        if (pos<30){
          rspeicher[rdblock*30+pos] = Wire.read(); 
          pos++;
        }
      }
      if (rdblock==7){
        fertig=1;
      }
    }else{
      if (rdblock >=10 && rdblock <=17){
        wrblock=rdblock-10;
        Serial.print("Leseblock: ");
        Serial.println(wrblock);
      }
    }
}

// function that executes whenever data is received from master
// this function is registered as an event, see setup()
void receiveEventRoh(int howMany) {
  while (0 < Wire.available()) { 
    byte x=Wire.read();
    Serial.print (x);
    Serial.print (" ");
  }
  Serial.println();
}

// function that executes whenever data is requested by master
// this function is registered as an event, see setup()
void requestEvent() {
  //Wire.write(speicher[Register],1);
  memcpy( &puffer[1],&wspeicher[wrblock * 30],30);
  puffer[0]=wrblock;
  Wire.write(puffer,31);
}
Raspberry Pi:
Code:
// GCC -Wall -pthread -o /var/scripte/i2cmaster01 /var/scripte/i2cmaster01.c -lpigpio -lrt
// /var/scripte/i2cmaster01
//I2C mit pipgio
//peterfido
//V0.0.1
#include <stdio.h>
#include <stdlib.h>
//#include <stdarg.h>
#include <string.h>
//#include <ctype.h>
#include <unistd.h>

#include <signal.h>
#include <pigpio.h>


//#define SDA 3
//#define SCL 5
#define BAUD 100
#define ADDRESS 0x04
#define MSGSIZE  240
#define LOOPS 30
char empfdata[MSGSIZE];  // 
char senddata[MSGSIZE];
char commando[32];

int handle=0;
int handles=-1;
unsigned int laenge=0;

void handleSigInt( int parameter );


void handleSigInt( int parameter )
{
    int res=0;
    int dl=0;
    if (handles >= 0){
        for (dl=0;dl<handles;dl++){
            res=i2cClose(dl);    
            printf("%d geschlossen: %d\n",dl, res);
        }
    }
    gpioTerminate();
    printf( "\nSIGINT wurde augeloest - Programm wird beendet\n" );

    exit( 1 );
}

void senden() {
    
    int res=0;
    int i=0;
    char wrblock=0;

    for (wrblock=0;wrblock<=7;wrblock++){
        handle=i2cOpen(1,ADDRESS,0);
        handles ++;
        if (handle>=0){
            laenge=31;
            printf("Oeffnen OK %d\n",handle);
            res=0;
            memcpy( &commando[1],&senddata[wrblock * 30],laenge);
            commando[0]=wrblock;
            res=res+i2cWriteDevice(handle,commando,laenge);
            usleep(5000);

            for(i=0;i<laenge;i++){
                printf("%d ",commando[i]);
            }                    
            printf("\n");
            
            if (res==0){
                printf("Senden OK\n");

            }else{
                printf("I2C-Fehler: %d\n", res);
            }
            res=i2cClose(handle);
            
            if (res!=0){
                printf("Fehler beim schliessen: %d\n", res);
            }else{
                handles--;
            }
        }else{
            printf("Fehler beim oeffnen: %d\n", res);
        }    
    }    
}

void empfangen() {
    
    int res=0;
    int i=0;
    char rdblock=0;    
    for (rdblock=0;rdblock<=7;rdblock++){
        handle=i2cOpen(1,ADDRESS,0);
        handles ++;
        if (handle>=0){
            laenge=31;
            printf("Oeffnen OK %d\n",handle);
            commando[0]=rdblock+10;
            res=i2cWriteDevice(handle,commando,1);
            if (res==0){
                
                usleep(30000);
                res=i2cReadDevice(handle,commando,laenge);
                if (res>0){
/*                printf("Empfangen:\n");
                    for(i=0;i<laenge;i++){
                        printf("%d ",commando[i]);
                    }                    
                    printf("\n");*/
                //    memcpy( &commando[1],&empfdata[commando[0] * 30],laenge-1);
                    for (i=0;i<laenge-1;i++){
                        empfdata[commando[0]*30+i]=commando[i+1];
                    }                
                }else{
                    printf("Fehler beim Blockeinlesen: %d\n", res);
                }
            }else{
                printf("Fehler beim Leseblock schreiben %d\n", rdblock);
            }
                res=i2cClose(handle);//+i2cClose(handle1);
                
                if (res!=0){
                    printf("Fehler beim schliessen: %d\n", res);
                }else{
                    handles--;
                }

        }else{
            printf("Fehler beim oeffnen: %d\n", res);
        }    
    }    
    printf("Empfangen:\n");
    for(i=0;i<MSGSIZE;i++){
        printf("%d ",empfdata[i]);
    }                    
}

int vergleichen()
{
    unsigned int i=0;
    int ret=0;
    for (i=0;i<MSGSIZE;i++){
        if (empfdata[i]!=senddata[i]){
            ret=-1;
            break;
        }
    }
    return ret;
}

int main(int argc, char **argv)
{
    int i=0;
    int dg=0;
    
/*    for(i=0;i<MSGSIZE;i++){
        senddata[i]=i;
    }*/
    signal( SIGINT, &handleSigInt );
    signal( SIGTERM, &handleSigInt );
    if (gpioInitialise() < 0)
    {
        printf("Fehler beim Initialisieren von gpio!");
        gpioTerminate();
    }else{
        for(dg=0;dg<LOOPS;dg++)
        {    
            srand(time(NULL));
            for(i=0;i<MSGSIZE;i++){
                 senddata[i]=rand() % 255;
            }        
            senden();
//            usleep(100000);
            sleep(1);
            empfangen();
//            usleep(100000);
            sleep(1);
            if (vergleichen()==0){
                    printf("Daten OK\n");
            }else{
                printf("Daten fehlerhaft\n");
            }
        }
    }

    gpioTerminate();
    
    return 0;
}