Kopplung TXT mit TX über I2C (mit Teensy)

Alles rund um TX(T) und RoboPro, mit ft-Hard- und Software
Computing using original ft hard- and software
Forumsregeln
Bitte beachte die Forumsregeln!
Antworten
jodeka
Beiträge: 20
Registriert: 10 Dez 2019, 22:09

Kopplung TXT mit TX über I2C (mit Teensy)

Beitrag von jodeka » 07 Apr 2020, 19:07

Hallo,

Ich habe einen TXT mit einem TX über I2C mit Hilfe von einem Teensy 3.6 miteinander verbunden.
Sowohl der TXT als auch der TX sind I2C-Master. Der Teensy 3.6. ist für beide I2C Schnittstellen der
Slave.

Der TXT und TX sind in RoboPro programmiert. Schreibe- und Lesebefehle an der I2C Schnittstelle werden
alle 200 ms abgesetzt. Der Teensy verarbeitet die Receive und Requestanfragen per Interrupt.

Beim TX ist ein Levelshifter (von 5V auf 3.3V) vorgeschaltet. Die Schnittstelle arbeitet ohne Probleme.
Man braucht auch keine zusätzlichen Pull-Up Widerstände bei einer Geschwindigkeit von 100 kHz.

LG jode

vleeuwen
Beiträge: 1230
Registriert: 31 Okt 2010, 22:23
Wohnort: Enschede (NL)

Re: Kopplung TXT mit TX über I2C (mit Teensy)

Beitrag von vleeuwen » 11 Apr 2020, 11:12

TXT and TX-C are not I2C multimaster so your are using probably two slave inputs on your micro controller.
The master is dictating the bus clock speed (400khz only for the TXT because of a bug in the firmware.)
Connecting both the TXT and TX-C on the same bus is asking for stability problem because the I2C-bus specification does not support this.
You are using the I2C slaves here as a kind of share memory.
Both master are polling the shared memory.
But what is your higher level communication (software) protocol?
How does the T1 signal the T2 that there is a new message available?
How does the T2 sees that there is a new message?
How does the T1 knows that his message has been seen by T2?
=================Google translate========================================
TXT und TX-C sind keine I2C-Multimaster, daher verwenden Sie wahrscheinlich zwei Slave-Eingänge an Ihrem Mikrocontroller.
Der Master diktiert die Bustaktrate (400 kHz nur für den TXT aufgrund eines Fehlers in der Firmware.)
Das Anschließen von TXT und TX-C an denselben Bus führt zu Stabilitätsproblemen, da die I2C-Busspezifikation dies nicht unterstützt.
Sie verwenden die I2C-Slaves hier als eine Art Freigabespeicher.
Beide Master fragen den gemeinsam genutzten Speicher ab.
Aber wie lautet Ihr übergeordnetes Kommunikationsprotokoll (Software)?
Wie signalisiert der T1 dem T2, dass eine neue Nachricht verfügbar ist?
Wie sieht der T2, dass eine neue Nachricht vorliegt?
Woher weiß der T1, dass seine Nachricht von T2 gesehen wurde?
=================Google translate========================================
TXT en TX-C zijn geen I2C-multimaster, dus u gebruikt waarschijnlijk twee slave-ingangen op uw microcontroller.
De master dicteert de kloksnelheid van de bus (400 kHz alleen voor de TXT vanwege een bug in de firmware.)
Het verbinden van zowel de TXT als de TX-C op dezelfde bus vraagt om stabiliteitsproblemen omdat de I2C-bus specificatie dit niet ondersteunt.
Je gebruikt de I2C-slaves hier als een soort gedeelde geheugen.
Beide masters pollen het gedeelde geheugen.
Maar wat is uw communicatie- (software) protocol op hoger niveau?
Hoe signaleert de T1 de T2 dat er een nieuw bericht beschikbaar is?
Hoe ziet de T2 dat er een nieuw bericht is?
Hoe weet de T1 dat zijn bericht door T2 is gezien?

jodeka
Beiträge: 20
Registriert: 10 Dez 2019, 22:09

Re: Kopplung TXT mit TX über I2C (mit Teensy)

Beitrag von jodeka » 13 Apr 2020, 19:17

Hallo,

der TXT und TX hängen nicht am gleichen I2C Bus.
TXT hängt an den Pins 18, 19 mit dem Objekt Wire.
TX hängt an den Pins 38, 37 mit dem Objekt Wire1.

Die Verbindung läuft sehr stabil (halbe Stunde ohne Fehler).
Ob die Frequenz 400kHz ist, muss ich noch (per Logikanalyser)
überprüfen.

Das Protokoll ist einfach. Das Programm für den Teensy ist nachfolgend
aufgeführt:

]#include <i2c_t3.h>

// Function prototypes
void receiveEventA(size_t count);
void requestEventA(void);
void receiveEventB(size_t count);
void requestEventB(void);
int leseA1;
int leseA2;
int schreibeA;
int leseB1;
int leseB2;
int schreibeB;
boolean receivedA;
boolean requestA;
boolean receivedB;
boolean requestB;

void setup() {
//start serial connection
Serial.begin(9600);
// Setup for Slave mode, address 0x41, pins 18/19, external pullups, 100kHz
Wire.begin(I2C_SLAVE, 0x41, I2C_PINS_18_19, I2C_PULLUP_EXT, 100000);
// Setup for Slave mode, address 0x42, pins 38/37, external pullups, 100kHz
Wire1.begin(I2C_SLAVE, 0x42, I2C_PINS_37_38, I2C_PULLUP_EXT, 100000);
Wire.onReceive(receiveEventA);
Wire.onRequest(requestEventA);
Wire1.onReceive(receiveEventB);
Wire1.onRequest(requestEventB);
receivedA = false;
requestA = false;
receivedB = false;
requestB = false;
schreibeA = 0;
schreibeB = 0;
delay(500);
Serial.println("Start");
}

void loop() {
if(receivedA) {
Serial.print("A Empfang: ");
Serial.print(leseA1);
Serial.print(" , ");
Serial.println(leseA2);
receivedA = false;
}
if(requestA) {
Serial.print("A Sende: ");
// Serial.println(schreibeA);
Serial.println(leseB1);
requestA = false;
}
if(receivedB) {
Serial.print("B Empfang: ");
Serial.print(leseB1);
Serial.print(" , ");
Serial.println(leseB2);
receivedB = false;
}
if(requestB) {
Serial.print("B Sende: ");
// Serial.println(schreibeB);
Serial.println(leseA1);
requestB = false;
}

}


void receiveEventA(size_t count)
{
leseA1 = Wire.read(); // lesen 1. Byte vom Wire0
leseA2 = Wire.read(); // lesen 2. Byte vom Wire0
receivedA = true; // set received flag to count, this triggers print in main loop
}

void requestEventA(void)
{
// Wire.write(schreibeA);
Wire.write(leseB1); // schreiben Wire0
requestA = true;
// schreibeA = schreibeA + 1;
// if(schreibeA > 255) { schreibeA = 0; }
}

void receiveEventB(size_t count)
{
leseB1 = Wire1.read(); // lesen 1. Byte vom Wire1
leseB2 = Wire1.read(); // lesen 2. Byte vom Wire1
receivedB = true; // set received flag to count, this triggers print in main loop
}

void requestEventB(void)
{
// Wire1.write(schreibeB);
Wire1.write(leseA1); // schreiben Wire1
requestB = true;
// schreibeB = schreibeB + 1;
// if(schreibeB > 255) { schreibeB = 0; }
}


LG jode

vleeuwen
Beiträge: 1230
Registriert: 31 Okt 2010, 22:23
Wohnort: Enschede (NL)

Re: Kopplung TXT mit TX über I2C (mit Teensy)

Beitrag von vleeuwen » 14 Apr 2020, 17:05

How the microcontroller handles the data between two slaves is clear to me. It's just a pass-through.
But according to the I2C protocol shows that the master takes the initiative for communication. So how M1 sends data to its slave, S1, is clear.
But M2 cannot act as a listener, M2 must also ask its slave, S2 for data. Only then can S2 forward the data.
And after receiving the data, M2 should acknowledge receipt of this data via S2 and S1 to M1.
How does M1 know that M2 has received the correct data block?
How does the microcontroller deal with these specification requirements?

Thus, there seems to be a need for a higher level protocol needed for both masters to have meaningful and reliable communication.
For example, take a bidirectional protocol, such as RS232, and implement it with the two I2C masters.

======Google translate for what it is+++++++++++++++++++++++++++++++++++++++
Wie der Mikrocontroller mit den Daten zwischen zwei Slaves umgeht, ist mir klar. Es ist nur ein Durchgang.
Laut zeigt das I2C-Protokoll jedoch, dass der Master die Initiative zur Kommunikation ergreift. Es ist also klar, wie M1 Daten an seinen Slave S1 sendet.
Aber M2 kann nicht als Listener fungieren, M2 muss auch seinen Slave S2 nach Daten fragen. Nur dann kann S2 die Daten weiterleiten.
Und nach dem Empfang der Daten sollte M2 den Empfang dieser Daten über S2 und S1 bis M1 bestätigen.
Woher weiß M1, dass M2 den richtigen Datenblock empfangen hat?
Wie geht der Mikrocontroller mit diesen Spezifikationsanforderungen um?

Daher scheint ein Protokoll auf höherer Ebene erforderlich zu sein, damit beide Master eine aussagekräftige und zuverlässige Kommunikation haben.
Nehmen Sie beispielsweise ein bidirektionales Protokoll wie RS232 und implementieren Sie es mit den beiden I2C-Mastern.

Antworten