I2C "passthrough" device mit Atmega328

Warum willst du die Nachricht durchschleifen? Monitor doch einfach die 
Pegel der Leitungen und gib das aus.

Eine Hälfte würde ich mit der I2C Library von Peter Fleury lösen - und 
zwar den Soft-I2C Modus.
Fürs Hardware I2C dann eines der vielen Beispiele, z.B. von 
Atmel/Microchip.

Olli Z. schrieb:
> Für mein Retro-TV Projekt, aber sicher auch mal für andere
> I2C-Basteleien geeignet, möchte ich mir ein "Zwischenschaltgerät" für
> ein am I2C Bus bauen. Es soll vor einen zu untersuchenden Baustein in
> die SDA/SCL Leitung eingefügt werden, die Kommunikation durchleiten aber
> zusätzlich auf eine serielle Konsole ausgeben.

Ein Logic Analyzer würde das auch machen, aber das Originalsignal nicht 
beeinflussen. Das wäre ein deutlich sinnvollerer Ansatz.

fchk

Kevin M. schrieb:
> Warum willst du die Nachricht durchschleifen? Monitor doch einfach die
> Pegel der Leitungen und gib das aus.

Sorry, das hätte ich gleich erwähnen sollen: Weil ich in einem zweiten 
Schritt dann nicht nur mitlauschen, sondern auch gezielt eingreifen 
möchte. Z.B. einige Bytes abändern.

Bei so einem "man in the middle" braucht es schon einige Überlegungen 
zur Realisierung.
Man muss z.B. sowohl sda wie auch scl zusätzlich zur 
Hardwareschnittstelle noch auf Portpins legen. Wie sollen sonst beim 
Lesevorgang des Masters die Daten bitweise weitergegeben werden? Der 
Lauscher sieht die Daten ja sonst erst, wenn ein komplettes Byte im 
Datenregister eingetrudelt ist.

Zudem muss man am Beginn der Sitzung die Adresse des Slaves kopieren, 
sonst werden die Daten des Masters einfach ignoriert.

Mitlesen ohne die Verbindung zu unterbrechen ist wesentlich einfacher.

Noch ein Problem zu oben: Ich kann das nicht auf Byte-Ebene 
durchschleifen, sondern muss immer eine ganze Kommunikation (Frame) 
einlesen, da ich sonst Transmission-End Signale falsch setze.
Also müsste ich wohl erstmal alles was der Master zum Slave senden will 
in einen internen Buffer laden (der TWI-HW Buffer dürfte nicht besonders 
groß sein) und dann das zum Slave senden.

1

#include <Wire.h>

2

#include "SoftwareI2C.h"

3

4

SoftwareI2C softwarei2c;

5

6

void setup()

7

{

8

  // Slave simulation, using internal TWI interface

9

  Wire.begin(0x45); // want 7-Bit address

10

  Wire.onReceive(irq_masterSend);

11

  Wire.onRequest(irq_masterRead); 

12

13

  // Master simulation, using Bitbang

14

  // SDA = Port "D2" (green) wh-vt

15

  // SCL = Port "D3" (blue)  bu-gy

16

  softwarei2c.begin(2, 3); // sda, scl

17

}

18

19

/**

20

 * I2C-Master has send data to slave (write)

21

 */

22

void irq_masterSend(int num_received_bytes)

23

{

24

  // read all bytes received into buffer

25

  uint8_t buffer[255];

26

  int i = 0;

27

  while(Wire.available())

28

  {

29

    uint8_t data = Wire.read();

30

    buffer[i++] = data;

31

  }

32

33

  // relay received message to TDA

34

  softwarei2c.beginTransmission(0x45);

35

  softwarei2c.write(num_received_bytes, buffer);

36

  softwarei2c.endTransmission();

37

}

38

...

Eigentlich wäre es für den I2C-Replicator doch besser die Symbole zu 
erkennen und weiterzuleiten, also z.B. START vom Master erkannt, gebe 
START zum Slave, Byte erhalten, sende Byte zum Slave, STOP erkennt, 
sende STOP, Repeated-START erkannt... usw.

Dieter W. schrieb:
> Bei so einem "man in the middle" braucht es schon einige Überlegungen
> zur Realisierung.

Ich würde mich mit dem "Replicator" auf jeweils eine Slave-Adresse 
beschränken. Und ja, es gibt einen Zeitversatz, ganz klar.

Woher kann mein Slave-Code wissen wieviele Bytes der Master denn gern 
lesen möchte? Ich müsste ja beim ersten Receive-Request vom Master 
eigentlich abwechseln selbst den Slave abfragen, dann das Byte senden, 
warten ob der Master noch eines möchte, usw.
Da wüsste ich garnicht wie man das mit der Wire-Lib macht.

Den ganzen Schlunz erst einlesen und dann weitersenden wird sicher 
tricky.

Der originale Master müsste dann zwischen Adresse, Controlword, whatever 
zum Slave schicken und Response lesen die komplette Zeit warten, bis die 
Kommunikation zwischen Replikator und Slave stattgefunden hat. 
Vermutlich ließe sich das mit clockstretching realisieren - wenn der 
Master es denn beherrscht.

Olli Z. schrieb:
> Ich müsste also sowas wie ein Clock-Streching durchführen können um den
> Master hinzuhalten. Dazu habe ich keine Funktion in den Libs gefunden
> die ich mir so angesehen habe.

Das erfolgt automatisch, solange der I2C-Interrupt nicht abgearbeitet 
wurde. Du mußt also nur den I2C-Interrupt solange disablen.