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

[HaWe]

120ms Pause ?
wo?
hast du diesen Code hier von diesem Link?

http://www.mindstormsforum.de/viewto...tart=15#p67908

der Raspi-Teil stammt von Gordon Henderson -
Frage:
was macht sleep(1)? 1 ms ? oder etwa 1sec ?


ps
(edit: )
Ja, du hast Recht!

Der Raspi hat eingebaute Pullups, die auf 3.3V hochziehen, aber beim Mega verbleiben 10k Board-Pullups, die machen es grenzwertig, auch wenn man die internen disabled. Tatsächlich sind beim mega Levelshifter sicherer!


- - - Aktualisiert - - -

hahaha, das war's!

Gordon hatte 1 sek Wartezeit drin, nicht 1 ms!

ich hab jetzt auf delay(10) geändert - das rauscht nur so durch, dass man gar nicht hinterher kommt !!

das muss ich mir jetzt erstmal genauer angucken!

- - - Aktualisiert - - -

update:

schaut absolut grandios aus. Kein Transmission-Fehler erkennbar. Mal gucken, wie lang die I2C Verbindung hält oder ob sie abbricht:

Raspi Master Code:

//  Raspberry Pi Master code to send/receive byte arrays
//  to an Arduino as an I2C slave
// 
//  ver. 0.001b
//  protected under the friendly Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
//  http://creativecommons.org/licenses/by-nc-sa/3.0/   //

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <wiringPi.h>
#include <wiringPiI2C.h>

#include <errno.h>
#include <string.h>

#define MSGSIZE 30


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



int main (void)
{
   
  int fd, i ;
  unsigned char test=0;
  unsigned char data [MSGSIZE] ;

  if ((fd = wiringPiI2CSetup (0x04) ) < 0)
  {
    fprintf (stderr, "Can't open RTC: %s\n", strerror (errno)) ;
    exit (EXIT_FAILURE) ;
  }


  for (;;)
  {
    read (fd, data, MSGSIZE) ;
    if( data[1] != calcchecksum( data ) ) {
         // handle transmission error !
    }    
    printf ("read:  ");
    for (i = 0 ; i < MSGSIZE ; ++i)
      printf ("  %3d", data [i]) ;
    printf ("\n") ;
    delay(10);
   
    memset(data, 0, sizeof(data) );
    data[5]=  test++;
    data[0]=  0xff;
    data[MSGSIZE-1]= 0x04;
    data[1] = calcchecksum( data );
   
    write(fd, data, MSGSIZE) ;
    printf ("write: ");
    for (i = 0 ; i < MSGSIZE ; ++i)
      printf ("  %3d", data [i]) ;
    printf ("\n\n") ;
    delay(10);
  }

  return 0 ;
}

Arduino slave code

//  Arduino code to send/receive byte arrays
//  Arduino as an I2C slave
//  compiles for MEGA and DUE, IDE 1.6.5
//  ver. 0.001b
//  (c) HaWe 2016
//
//  protected under the friendly Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
//  http://creativecommons.org/licenses/by-nc-sa/3.0/   //


#include  <Wire.h>

#define  SLAVE_ADDRESS 0x04
#define  MSGSIZE  30
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..
}

- - - Aktualisiert - - -

also, es läuft jetzt störungsfrei seit etwa ner halben Stunde - da gibt's momentan nichts mehr zu meckern!

(y)