Hallo,
Das war ja auch nicht für dich, sondern gegen den Einwand von Morob.Zitat:
Zitat von HaWe
MfG Peter(TOO)
Druckbare Version
Hallo,
Das war ja auch nicht für dich, sondern gegen den Einwand von Morob.Zitat:
Zitat von HaWe
MfG Peter(TOO)
macht das doch bitte per PM aus! solche OT posts sprengen ständig den Informationsfluss!
also nochmal:
Die Frage war nach einem Code, der eine schnelle i2c Verbindung zwischen Raspi-Master und Arduino-Slave herstellt.
Ausgangsbasis kann der obige Code im oben verlinkten Post sein
- immerhin gibt es ja inzwischen einen, der zumindest funktioniert, wenn auch extremst langsam - :
http://www.mindstormsforum.de/viewto...tart=15#p67908
aber wenn Vorschläge, dann bitte selbst getestet: es ist das exakte Zusammenspiel der beiden i2c-Protokolle, das Probleme macht!
(Und bitte erst recht keine OT-Posts.)
Denn, wie gesagt:
Zitat:
Für alle Tipps bin ich natürlich offen, aber der, der sie vorschlägt, müsste schon in der Lage sein, die Verbindung ebenfalls herzustellen und bei sich selber vor Ort zu testen (d.h. er müsste auch einen Raspi und einen Arduino besitzen und sie entsprechend verbinden und seinen eigenen - bzw. unseren gemeinsamen, auf einander abgestimmten - Code testen können).
hmmm.... scheint, als gäbe es hier im Forum keine wirklichen Fachleute für i2c zwischen Raspi und Arduino.... :-/
Hallo,
wenn das Beispiel zu langsam ist, würde ich die Pausen verkürzen. Aus sleep(1) usleep(100), aus delay(2) delay(1), oder beim Senden vom ARDUINO ganz auf das delay verzichten.
wie gesagt:
Augenblicklich überträgt der Raspi-Master zum Arduino und zurück gerade mal 2 arrays pro Sekunde (!!), per Arduino-Master ist das gleiche Programm > 30x so schnell. Da wird eine Verkürzung um ein paar millis oder micros nichts ausmachen.Zitat:
Für alle Tipps bin ich natürlich offen, aber der, der sie vorschlägt, müsste schon in der Lage sein, die Verbindung ebenfalls herzustellen und bei sich selber vor Ort zu testen (d.h. er müsste auch einen Raspi und einen Arduino besitzen und sie entsprechend verbinden und seinen eigenen - bzw. unseren gemeinsamen, auf einander abgestimmten - Code testen können).
Es liegt vielmehr am Zusammenspiel der beiden i2c-Implementierungen, dem langsamen Arduino und dem prinzipiell schnelleren Raspi, der aber clock-stretching nicht verträgt - damit bricht die Kommunikation ein. Außerdem braucht der Arduino ZWINGEND delays, um überhaupt auf requests reagieren zu können. Die Sache ist also recht kniffelig.
Nicht umsonst habe ich daher oben geschrieben:
vermutlich hast du deinen Vorschlag also nicht getestet...?Zitat:
Für alle Tipps bin ich natürlich offen, aber der, der sie vorschlägt, müsste schon in der Lage sein, die Verbindung ebenfalls herzustellen und bei sich selber vor Ort zu testen (d.h. er müsste auch einen Raspi und einen Arduino besitzen und sie entsprechend verbinden und seinen eigenen - bzw. unseren gemeinsamen, auf einander abgestimmten - Code testen können).
Nein,
aber ich bin in der Lage dazu, da ich die Voraussetzungen alle erfülle ;) Für ein Nachstellen der Situation fehlt mir an diesem WE die Zeit. Ich komm leider nicht mal dazu, an meinem eigenen aktuellen Projekt zu programmieren ;)
Eine 1a Kommunikation zwischen Raspi und AVR klappt per UART. Hier laufen 5 solcher Paare schon eine Zeit lang.
I2C zwischen Raspi und Display sowie ARDUINO und Display läuft bei mir gefühlt verzögerungsfrei. I2C zwischen Raspi und ARDUINO habe ich wegen UART noch nicht gebraucht. Muss es unbedingt I2C sein, wo Clock Stretching, welches dem Raspi zu schaffen macht, wahrscheinlich ist? Und wenn ja, hängen da noch weitere Geräte auf dem Bus? Clock Stretching ist beim Raspi problematisch. Entweder gleich vermeiden, z.B. durch einen langsameren I2C Takt oder I2C zu Fuß per Bit Banging nachbauen. Erfolge soll es auch geben, wenn dem AVR Rechenzeit durch Verzögerung der Read-Ack verschafft wird.
Was, wenn der Raspi erst einen Befehl sendet, dass der ARDUINO weiß, dass er Daten zum Senden parat haben muss, das Lesen der Daten in einer bestimmten Zeit x passiert?
Auf einer Raspi-Zusatzplatine, deren Name mir gerade nicht einfällt, wird das Problem durch einen zusätzlichen Mikrocontroller als I2C -Proxy umgangen.
UART funktioniert perfekt, sogar drahtlos - aber der Raspi hat nur 1 UART, USB ist besetzt, aber viel wichtiger: UART kann nur 1 "slave", i2c aber über 100...
Und UART wird für eine Drahtlos-Fernsteuerung benutzt... (2x HC-05: was war das für eine Höllenqual, bis ich die endlich zum Laufen hatte!)
Ich hab zwar nun keine 100 slaves, aber 2 Arduinos (1x Due, 1x Mega) plus GPS plus IMU plus RTC .... (auch über eine Pixy cam bin ich jetzt wieder gestolpert).
Wenn es also schnell genug ginge, könnten alle an 1 i2c-1, notfalls ein Teil davon an i2c-0.
Wenn du also testen kannst - ich bin gespannt! (y) +1 8-)
hmmm ...
aber sonst scheinen keine weiteren Raspi- und Arduino-Fachleute hier an Bord zu sein, die zufällig außer Ahnung auch noch Zeit haben, sich mitzuteilen?
;)
Hallo,
ich habe mal kurz Zeit gefunden. Das Setup steht soweit. Der Raspi findet den ARDUINO. Von Vorteil wären Deine aktuellen Testprogramme für beide Plattformen. Das, welches Du weiter oben als Basis verlinkt hast, macht von Haus aus schon 120ms Pause jeden Loop. Warum der State auf dem ARDUINO zwischengespeichert wird, habe ich noch nicht verstanden. Das Testprogramm für den Raspi möchte ja die zu sendenden Daten mit übergeben haben. Wird also nicht das sein, womit Du testest.
Meine Pegelwandler sind alle. Habe mir eben welche geordert. Wenn die da sind, teste ich weiter. Der ARDUINO läuft zwar mit 3V3 aber den muss ich sonst vor und nach dem Flashen umstecken. Wenn ich das vergesse, kann es das für den Raspi gewesen sein.
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:
Arduino slave codeCode:// 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 ;
}
- - - Aktualisiert - - -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..
}
also, es läuft jetzt störungsfrei seit etwa ner halben Stunde - da gibt's momentan nichts mehr zu meckern!
(y)