Ma mi chiedo come avviene questo handshaking tra un Master e uno Slave quando lo Slave è il mittente e il Master è il destinatario e solo lo Slave (mittente) sa quando non ci sono più dati da inviare al destinatario?

Questo non dovrebbe accadere. i2c è un protocollo molto definito e ogni dispositivo slave dovrebbe essere noto a ciascun master. In genere, il master richiede allo slave di trasmettere e la dimensione del messaggio è fissa, il messaggio è sequenziale o il messaggio include il numero di byte che verranno inviati.

1. Il master scrive un indirizzo di registro, quindi il master passa alla lettura e lo slave invia un byte. Questo è tutto ciò che il maestro vuole, manda uno stop.

2. Il master scrive un indirizzo di registro, quindi il master passa alla lettura e lo slave invia un byte, quindi il master legge di nuovo, quindi lo slave invia il byte successivo (o lo stesso byte). Il master legge quanti ne vuole, arbitrariamente, quindi invia uno stop.

3. Il master scrive un indirizzo di registro, quindi il master passa alla lettura e lo slave invia un byte. Quel byte dice al master quanti byte dovrebbe avere quel registro. Il master legge e lo slave ne invia altrettanti, quindi il master si ferma.

Tutte le comunicazioni è controllata dal master. Lo schiavo non fa nulla che il padrone non vuole che faccia. Il master controlla la velocità del clock (il clock stretching non resiste) e il numero di byte letti. Lo slave non deve mai tentare di forzare la linea dati quando il master non glielo ha detto. La struttura dei dati dovrebbe essere conosciuta in anticipo.

Queste sono le due opzioni.

Se il ricevitore slave non accetta più dati può NAK il byte, ma il master è comunque responsabile dell'invio della condizione di stop.

Per un trasmettitore slave, non può segnalare a nulla di fermarsi, deve essere noto in anticipo, o potrebbe essere codificato nei dati, ad es.la stringa di testo termina con uno zero in modo che lo slave possa trasmettere gli zeri fino a quando il master non si ferma.

Di solito, questo è raro ed esiste un protocollo noto, quindi il master deve sempre sapere in anticipo quanti byte leggerà o scriverà in una singola transazione, anche se ciò significa trasferire prima un'intestazione di dimensione fissa tra i dispositivi e quanto trasferire.

Supponiamo che uno Slave o Master invii più byte al ricevitore su bus I2C e il numero di byte non è definito a priori. Allora come farà il mittente a dire al destinatario che non ha più dati a cui rivolgersi inviare?

Se Master è il mittente, allora sa quanti byte devono essere inviati. Il Master segnalerà la fine del suo trasferimento dati inviando una condizione di STOP dopo aver inviato l'ultimo byte e terminerà la transazione.

Nota che il Maestro può farlo in qualsiasi momento. Lo slave può inviare NACK per dire che non vuole più ricevere dati. Ma solo il Master decide se interrompere questa transazione.

Ma mi chiedo come avvenga questa stretta di mano tra un Master e Slave quando lo Slave è mittente e il Master è solo ricevitore lo Slave (mittente) sa quando non ci sono più dati da inviare al ricevitore?

Se Slave è il mittente, il Master dovrebbe sapere in anticipo quanti byte devono essere ricevuti. Il Master lo segnalerà inviando un NACK dopo aver ricevuto l'ultimo byte in modo che lo slave non guidi più la linea SDA. Il master può ora avviare una condizione di STOP e terminare la transazione.

Buona lettura qui: TEXAS i2c

Ho intenzione di assimilare l'intero post a poco a poco ...

Supponiamo che uno Slave o Master invii più byte al ricevitore sul bus I2C e il numero di byte non è definito in anticipo.

Ma dovrebbe essere definito. Se sono state inviate o ricevute informazioni casuali, non sarai mai in grado di interpretarle.

Allora come farà il mittente a dire al destinatario che non ha più dati inviare?

Il produttore determina quanti bit deve ricevere dallo slave. Il master è tipicamente scritto da un dispositivo logico come un microcontrollore, una CPU, ecc.

Finora quello che ho capito è che nel caso in cui lo sia il mittente Il Master poi invia un NACK per dire allo Slave (Ricevitore) che c'è non più dati da inviare.

No, non è del tutto corretto. Un "NACK" si verifica quando il master non "sente" nulla dallo slave dopo aver inviato questo bit allo slave. È come essere al telefono e dire: "Ciao, ci sei?"

Ma mi chiedo come avvenga questa stretta di mano tra un Master e Slave quando lo Slave è mittente e il Master è solo ricevitore lo Slave (mittente) sa quando non ci sono più dati da inviare al ricevitore?

La tua definizione di mittente e destinatario è distorta. Sia il master che lo slave agiscono sia come mittente che come destinatario. Il master può sia inviare che ricevere, a seconda rispettivamente delle operazioni di scrittura o lettura.

Suggerimento utile: Considera la possibilità di leggere qualsiasi scheda tecnica slave I2C. Cerca la parola chiave "messaggio". Queste sono le informazioni che il master invia allo slave.

Immagine da qui... non la mia immagine.

Il master dovrebbe essere programmato per leggere la stessa lunghezza del frame dell'indirizzo dello slave, che è definita dal foglio dati dello slave.Potresti anche essere in grado di impostare un indirizzo di uno slave, ma di solito non di molto.Ciò aiuterà ad affrontare il conflitto se due slave condividono lo stesso indirizzo.

Ecco un esempio di una parte con cui ho lavorato di recente, è un controller hot-swap ADM1276.È conforme alle specifiche PMBUS ma la topologia I2C è ancora valida.Ti dice le interazioni di master e slave durante l'invio, la ricezione, la lettura e la scrittura di byte.

Non c'è niente nel protocollo i2c che risolva questo problema.Puoi farlo funzionare, ma utilizzerai alcuni software per farlo.Poiché i2c è stato progettato per la comunicazione hardware, che di solito coinvolge registri di dimensioni fisse, non è stato fornito nulla per gestire i dati di lunghezza variabile.L'ho scoperto da solo e ho dovuto risolvere lo stesso problema che stai considerando.

Dato che il master controlla tutto, tutto ciò che lo slave può fare è inviargli indizi su quanti dati devono inviare.Quello che ha funzionato meglio per me è che lo slave invii la lunghezza come primo byte.Quindi il master sa quanti byte deve chiedere.

Il protocollo stesso non consente tale azione, ma non è nulla che non possa essere risolto con la programmazione.

Due possibili opzioni possibilmente:

1. Che l'insegnante richieda prima un valore in questo caso intero (inferiore a 255) e questa sarà la dimensione dei dati che invierai in seguito alla prossima chiamata che farai.

2. Se sei a conoscenza della lunghezza massima che avranno i dati da inviare, prendila come riferimento, convertili in un array o una stringa e aggiungi un carattere specifico che intendi prendere per contrassegnare dovei dati finiscono e nel master si converte nuovamente nel tipo di dati che si sta utilizzando.Con i dati più piccoli, inserisci il resto della stringa con il tuo carattere speciale e voilà, invierai sempre una stringa con la stessa dimensione.