Wie mehrere Bytes über TWI / I2C übertragen?

Einen wunderschönen Samstag Vormittag wünsche ich euch,

hab da gerade noch ein kleines Verständnissproblem beim TWI. Nach folgendem Schema von Peter Fleury übertrage ich bisher meine Daten vom Master zum Slave:

// übertrage Motorgeschwindigkeit
i2c_start_wait(Motor_1 + I2C_WRITE); // set device address and write mode
i2c_write(Motor_Speed); // write address = 5
i2c_stop(); // set stop conditon = release bus

Nun meine Frage: Wie ist es nun möglich mehrere Bytes nacheinander übertragen? Ich hab ja nur einen i2c_write Befehl. Wenn ich nun Beispielweise den Code wie folgt umschreibe:

// übertrage Motorgeschwindigkeit
i2c_start_wait(Motor_1 + I2C_WRITE); // set device address and write mode
i2c_write(Motor_Speed); // write address = 5
i2c_write(0x75);
i2c_stop(); // set stop conditon = release bus

Dann überschreibt er doch den zuvor übermittelten Wert? Oder wird er dann irgendwo anders gespeichert? Wenn Ja, wo?

Sorry falls ich mich grad ein bissel dämlich anstelle, aber ich seh da grad echt nicht durch.

Gruß Andi

Hallo,

Nein, wenn du noch ein Byte schreibst, dann wirst es in den nächsten Speicher geschrieben, du kannst ohne bedenken das i2c_write()
mehrmals hintereinander ausführen.

MfG avrrobot

Ok das klingt super! Wieviel Bytes kann ich maximal übertragen? Und wie kann ich die Bytes dann wieder auslesen?

Als Beispiel:
Übertragen vom Master:

// Übertrage
i2c_start_wait(Motor_1 + I2C_WRITE); // set device address and write mode
i2c_write(Byte_1); // Übertragen des ersten Datenbytes
i2c_write(Byte_2); // Übertragen des zweiten Datenbytes
i2c_stop(); // set stop conditon = release bus

Empfangen vom Slave:

//Daten empfangen
case TW_SR_DATA_ACK: /*TW_SR_DATA_ACK = data received, ACK returned.
Vom Master gesendete Daten wurden empfangen
und es wurde mit Acknowledge geantwortet*/

Byte_1 = TWDR; /*Übertragen der Daten*/
Byte_2 = TWDR; /*Übertragen der Daten*/

TWCR |= (1<<TWINT); /*Löschen des für die TWI Übertragung nötigen
Interruptflags.*/

i2c_timeout = 0; /*Variable "i2c_timeout" wird auf "0" gesetzt.
Also zurückgesetzt.*/

return; //Interrupt verlassen

Könnte das so funktionieren?

Gruß Andi

Ich weiß nicht so genau, ich verwende immer die lib aus dem RN_Wissen: http://www.rn-wissen.de/index.php/TWI_Slave_mit_avr-gcc
Dort kann man die Anzahl der Bytes zwischen 2 und 254 oder so einstellen.

Habs mir gerade mal angesehen, hätte ich das früher gesehen hätte ich mir wahrscheinlich viel Arbeit mit dem Master ersparen können. Leider seh ich bei dem Slave Code nicht wirklich durch, bin wahrscheinlich schon zusehr auf meinen eingespielt. Weiß vielleicht sonst jemand wie man beim Slave die vom Master gesendeten Daten empfangen kann? Ich werds heute Abend definitiv mal mit den TWCR Anweisungen nacheinander versuchen, vielleicht klappts ja :)

Auf jeden Fall mal vielen Dank an "avrrobot" hast mir echt super weitergeholfen, vielleicht kann ich mich ja irgendwann mal bei dir revangieren.

Zitat:

Zitat von Teslafan

... wie man beim Slave die vom Master gesendeten Daten empfangen kann ...

Das steht ja im R N-W issen-Link zum TWI-Slave drin wie im Link oben genannt. WENN der Slave bereit zum Schreiben ist (Achtung - wenn er das nicht ist, bleibt hier der Master natürlich hängen!) dann schreibste einfach die gewünschten Bytes - beliebig viele im Rahmen des maximal reservierten Speicherplatzes >>an den richtigen Speicherort im Slave<<. Bei mir (klick für mehr) sieht das so aus:

Code:

// - - - - - - - - - - - - - - - - - - - - - - - - // if(!(i2c_start(SLAVE_ADR+I2C_WRITE))) //Slave bereit zum schreiben? { // i2cdmy = i2c_write (0x01); // Buffer Startadresse 01 setzen i2cdmy = i2c_write (byte1); // zum Schreiben. 01 {0, 10} i2cdmy = i2c_write (byte2); i2cdmy = i2c_write (byte3); i2c_stop(); // Zugriff beenden // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

und danach kann ich die Daten im Slave auch vom Master wieder zurücklesen - sozusagen als Kontrolle, siehe dieses Beispiel (hier wird im Zielfeld ab Position 1 geschrieben, ABER ab Position 0 zurückgelesen !!)

......Bild hier

Diese Daten können dann (an der selben Stelle *gg*) im Slave natürlich auch ausgelesen werden.

Hab mir deinen Code angesehen und auch was versucht, hab auch noch weng im Netz gelesen aber auch erfolglos. Ich glaube mein Problem liegt darin das mein Slave die Werte nur im durch den TWI verursachten Interrupt lesen kann. Mein Slave ist ein Brushless Controller. Hier mal der Codepart in dem ich lese:

ISR (TWI_vect) //Wird ausgelöst wenn der Master etwas senden will.
//################################################## ##########################
{
switch (TWSR & 0xF8) //TW_STATUS
{
//Adresse empfangen
case TW_SR_SLA_ACK: /*TW_SR_SLA_ACK = SLA+W received, ACK returned.
Also "MT-Kommando SLA+W" wurde empfangen und
es wurde mit Acknowledge geantwortet*/
TWCR |= (1<<TWINT); /*Löschen des für die TWI Übertragung nötigen
Interruptflags.*/
return; //Interrupt verlassen

//Daten empfangen
case TW_SR_DATA_ACK: /*TW_SR_DATA_ACK = data received, ACK returned.
Vom Master gesendete Daten wurden empfangen
und es wurde mit Acknowledge geantwortet*/

Motor_Speed = TWDR; /*Übertragen der Daten*/

TWCR |= (1<<TWINT); /*Löschen des für die TWI Übertragung nötigen
Interruptflags.*/

i2c_timeout = 0; /*Variable "i2c_timeout" wird auf "0" gesetzt.
Also zurückgesetzt.*/

return; //Interrupt verlassen

}

Vielleicht hat das so in der art ja schon mal jemand gemacht. Ich versteh nicht ganz ob der Master am Slave für jedes Byte nen Interrupt auslöst.
Bin für jede Hilfe dankbar.

Sorry der Code war echt schlecht dargestellt, hier nochmal sauber:

Code:

//############################################################################ ISR (TWI_vect) //Wird ausgelöst wenn der Master etwas senden will. //############################################################################ { switch (TWSR & 0xF8) //TW_STATUS { //Adresse empfangen case TW_SR_SLA_ACK: TWCR |= (1<<TWINT); return; //Daten empfangen case TW_SR_DATA_ACK: Motor_Speed = TWDR; TWCR |= (1<<TWINT); i2c_timeout = 0; return;

Zitat:

Zitat von Teslafan

Code:

//######################################################## ISR (TWI_vect) //Wird ausgelöst wenn der Master etwas senden will. //######################################################## ...

Irgendwie raff ich das nicht. WER löst den Interrupt aus, wenn der Master etwas senden will?? WENN der (jedenfalls mein) MASTER sendet, dann wird er aktiv - also RE-Agiert er nicht, er agiert. Da stell ich mir die Frage, wer dann bei Dir für den Interrupt verantwortlich ist . . . . Oder versteh ich so spät am Abend die Controller nicht mehr?

Das ist ein Auszug aus Ulrich Radigs Code vom Brushless Controller.Stand aber auch so im Datenblatt vom Controller drin.Das der Interrupt bei einem Signal an der SDA Leitung gestartet wird. Sorry kann auch sein das ich da was durcheinander gebracht habe,bin nch im Lernprozess!
Funktioniert auch wunderbar mit dem Lesen von einem Byte, nur leider kann ich mir nicht erklären wie ich da mehrere Auslesen kann.