I2C vraagje

SDA wordt alleen maar geaccepteerd als de SCL Hoog is.

Met Google zoeken op “I2C”

Eerste Hit Philips heeft het bedacht.

ja ma, er zijn meerdere componenten op de bus. hoe weet het component ofdat de data voor hem is of niet voor hem?

Identificatie in de datastroom. Gaat snel hoor. Heb je al wat gelezen. Het is nl. te veel om "even" uit te leggen.

Via de SDA wordt zowel de data als de adressering verstuurd. Via die adressering weet een device dus dat het zijn beurt is om iets te doen...

Op 24 juni 2006 18:11:54 schreef the-paradox:
Via de SDA wordt zowel de data als de adressering verstuurd. Via die adressering weet een device dus dat het zijn beurt is om iets te doen...

Helemaal goed.

:9

hmmm dit is wat ik eruit maak in het docu dat ik lees hoe I2C werkt.

-Master controleert of dat de bus vrij is
-master zend een stratbit door dalende flank op de SDA lijn en een 1 op de CLS lijn
-eerste byte is het adres van de slave. Allen die zal de ganse tijd luisteren. Een acknowledge geven ter bevestiging van de ontvangen byte.

Wat er dan gebuert is dan afhankelijk van de R/W bit
Is hij 0 dan zal de master data zenden met telkens een acknowledge van de slave
Is hij 1 dan zal de slave data zenden naar naar de master met telkens een aknowledge van de master. (aknowledge is bevestiging van ontvanging)

-stopbit van de master met stijgende flank van de SDA lijn en SXL lijn die 1 is

(edit)-wanneer geen aknowledge gegeven wordt, wordt er ook een stopbit gegeven door de master

Klopt dit? En geeft de SCL dan de R/W bit?
het docu sta op mn pc, kheb het ooit eens van een site gehaald, maar die vin ik nu niet meer

Ff uit m'n hoofd, de R/W bit is het laatste bitje in het adres. Gaat dus via SDA.

Op 24 juni 2006 18:07:56 schreef Amateur19:
SDA wordt alleen maar geaccepteerd als de SCL Hoog is.

Met Google zoeken op “I2C”

Eerste Hit Philips heeft het bedacht.

behalve voor start en stop. en sda wordt gelatcht op de posedge van de scl

Klopt niet helemaal:

De ACK geeft niet aan dat een byte ontvangen is. De ACK geeft aan of de verzender/ontvanger meer bytes heeft te zenden/wil ontvangen. Als er een ACK (met 0) wordt gegeven, volgt er altijd nog minimaal 1 byte. Als de ACK hoog blijft, geeft dat aan dat er geen bytes meer volgen.

Dit is heel verwarrend, maar kort samengevat: het ACK signaal (1/0) geeft aan 0=meer bytes komen er aan/willen we hebben. 1=huidige byte was de laatste / genoeg bytes binnen.

Op 24 juni 2006 19:10:09 schreef MagicBox:
Klopt niet helemaal:

De ACK geeft niet aan dat een byte ontvangen is. De ACK geeft aan of de verzender/ontvanger meer bytes heeft te zenden/wil ontvangen. Als er een ACK (met 0) wordt gegeven, volgt er altijd nog minimaal 1 byte. Als de ACK hoog blijft, geeft dat aan dat er bytes meer volgen.

Dit is heel verwarrend, maar kort samengevat: het ACK signaal (1/0) geeft aan 0=meer bytes komen er aan/willen we hebben. 1=huidige byte was de laatste / genoeg bytes binnen.

volgens wat ik vertelde is dat de ACK verzonden wordt door de slave als hij ontvangt.(wat dan fout is)
volgens u wordt hij gezonden door de master wanneer er al dan niet data zal volgen. (wat dan correct is)

Op 24 juni 2006 19:10:09 schreef MagicBox:
Klopt niet helemaal:

De ACK geeft niet aan dat een byte ontvangen is. De ACK geeft aan of de verzender/ontvanger meer bytes heeft te zenden/wil ontvangen. Als er een ACK (met 0) wordt gegeven, volgt er altijd nog minimaal 1 byte. Als de ACK hoog blijft, geeft dat aan dat er bytes meer volgen.

Dit is heel verwarrend, maar kort samengevat: het ACK signaal (1/0) geeft aan 0=meer bytes komen er aan/willen we hebben. 1=huidige byte was de laatste / genoeg bytes binnen.

Iedere reeks van 8 bits wordt afgesloten door een acknowledge bit om te kunnen controleren of de data goed is aangekomen. Als alle informatie is aangekomen word er een stopconditie gegenereerd zodat andere IC's ook informatie kunnen uitwisselen. Als een IC een reeks van 8 bits en een acknowledge-bit heeft ontvangen stuurt dat IC een acknowledge-bit terug zodat het verzend-IC weet dat de informatie goed is aangekomen.

dit is wat ik het eerste docu lees op google bij zoeken van I2C

bent u zeker?

Zowel de master als de slave kan ACK/NACK sturen. De zijde die de data ontvangt moet na het ontvangen een 0 of 1 op de bus zetten, het ACK / NACK bit. Dit kan de slave receiver zijn, maar ook een master receiver.

Indien het een slave receiver is, zal deze met 1 antwoorden als hij genoeg had aan het laats verstuurde byte, anders met 0. Het zelfde geldt voor de master receiver.

Stel, we lezen een adres in een I2C eeprom uit:

<Master: Write Eeprom Address>
<Eeprom: ACK (wil meer bytes)>
<Master: Eeprom adres>
<Eeprom: NACK (genoeg ontvangen, adres goed zetten>
<Master met "extended start": Read Eeprom Data>
<Eeprom: NACK (hoeft geen extra bytes, omschakelen naar sendmode>
<Eeprom: Eprom data byte>
<Master: NACK (genoeg aan 1 byte data)>
<Master: Stop>

Dit laat zien hoe het ACK/NACK bit gezet dient te worden door zowel masters als slaves

Edit: Dus ja, het klopt dat de tegenpartij na elk byte een ACK/NACK stuurt, maar welke van de twee hangt dus niet af van of het vorige byte is ontvangen of niet.

google op i2c faq. diene kwiet die dat geschrevne heeft weet waarover hij praat

itkkort komt het hier op neer.

in rust zijn SCL en SDA beide hoog via hun pull up weerstanden ( SDa is bidirectioneel en wordt gestuurd door open collecotr of open drain logica . SCL eigenlijk ook maar das alleen nodgi als je meerdere masters op je bus wilt hebben. 99% van de i2c chips zijn slaves. alleen processorne zijn ( kunnen ) master

een start wek je op door vanuit rusttoestand de clock laag te maken en daarnaa de SDA laag te maken. ALLE aangesloten componentne shcieten dan wakker en beginnen te luisteren.
nu verzend je 8 bits : 7 bits address en een r/w bit. je zit je bitje op SDa en maakt dan SCL hoog en terug laag.
na het verzenden van het R/W bit laat de master de SDA los. die schiet dus terug naar logisch 1 door de pull up weerstand

Na het 8e bit ( het RW bit ) kijken al die componentne of die 8 bit overeenkomen met hun 'address' . Als het niet klopt gaan ze slapen. alleen een START kan ze dan terug wakker maken. ( raar maar waar de state machine in de meest slaves kijkt niet meer nar de stop als het transport niet voor hen bedoeld was. )

Diegene waarvan het address wel klopte antwoordt door op zijn beurt nu de SDA laag te trekken.
De master ( jij dus ) ziet dat die SDA laag is ( jij had hem losgelaten dus is er iemand anders die aant laag trekken ) en besluit daaruit ' he ik heb er ene ! ' de master maakt nu de SCL hoog en terug laag om aan te geven 'ik heb u begrepen . de slave laat daarop de SDA terug los ( en die vliegt weer omhoog door de pull up weerstand

als je nu een schrijf opdracht gegeven had kan je nu de volgende byte sturen : sda juist zetten en clk hoog - clock laag. Na 8e bit weer de SDA loslaten . maak nu je clk hoog. SDa moet nu laag zijn ( jij had hem losgelaten maar nu trekt de slave hem laag ) maak je clk laag en SDA moet weer los zijn. en zovoort. Dat noemt men ACKnowledge : ' ik heb bevestig ontvangst'

als je klaar betn stuur je ene stop. Ja trekt SDA laag , maakt SCL hoog en maakt daarna SDA hoog. ( bij normaal gebruik verandert SDA NIET terwijl de SCK hoog is. als je dat wel doet kun je start en stop maken )

Dat stop commando geeft aan dat de bus vrij is.

Bon . als er gene slave luistert zal dia ACK niet komen ( met andere woorden : jij laat SDA los , maar er zal niemand die laag trekken. )

om te ontvangen ist simpel : jij laat SDa los en je maakt SCK hoog. je kijkt naar de waarde van SDA en maakt SCK terug laag . enzovoort. je doet dit 8 keer.
daarnaa MOET jij SDA laag maken en SCK hoog - SCK laag doen om te melden aan de slave dat je hem begrepen hebt EN dat je nog data wilt. als je geen verdere data meer wilt doe je dit niet maar je maakt SDA laag , SCL hoog en dan SDA hoog ( STOp conditie )

das in 2 woorden wat daar gebeurt.

nu gaan we spelen.

jij schrijft iets naar de slave en je staat op het punt om de ACK fase binnen te gaan. met andere woorden : je laat SDA los en staat klaar om SCL hoog te maken. Je maakt SCL hoog. als je nu kijkt op de bus kan het zijn dat SCL NIET hoog is geworden. De slave trekt die laag. Met andere woorden die rotzak blokkeert de bus !. dit is SCK stretching. asl die slave intern meer tijd nodig heeft om de verzonden data te verwerken kan hij de bus blokkeren. jij kan dan keen SCK meer opwekken en moet wachten.
Alleen EEProms doen dit. als je het commando geeft om een cel te wissne of programmeren dan hebben zij tijd nodig om dat ook effectief te doen. zolang ze bezig zijn blokkeren ze het transport. dit is ene vorm van handshaking

Stel nu dat er 2 masters zijn op de bus en die beginnen maar te praten zonder zich van iets aan te trekken.
Ook daarvoro is een vorozieneing. De regel stelt dat als je de SDA of de SCL lijn loslaat ( en die dus normaal moet hoogvliegen ) je dat ook moet controleren !.
als om een of andere reden de SCK niet hoog wordt EN je zat in ACK fase dan moet je wachten tot dat wel gebeurt ( je slave was bezig )
zat je ergens anders ( nog aant verzenden van ene bit ) , of is het de SDA die niet hoogvliegt als je dat verwacht dan moet je STOPPEN en wachten tot je een STOP conditie ziet passeren. Der is immers iemand anders aant snateren op de bus !
dit is de arbitration.

Wie wint er de arbitratie ? simeplweg diegene die de lijn ( SDa os SCK ) laag aant trekken was. En de datsa is niet corrupt. sterker nog . diegene die 'gewonnen' heeft zal zich zelfs nooit gerealisserd hebben dat er nog een andere master bezig was met tateren.

tis ene elegant systeem waarbij handshaking en arbitration volledig in de hardware gebeurt.

Een ACK wordt gestuurd als ontvangst bevestiging. Kan zowel door master als slave.
Een ontvanger heeft niets te "willen": de master bepaalt adhv een ACK of NACK of de slave nog wel luistert.

Wat er wordt teruggestuurd als ACK of NACK kun je wel degelijk zien als een bevestiging dat er 8-data bits zijn binnengeklokt.
Lees hiervoor de officiele Philips spec's maar.
Wel zijn er componenten die een variatie op het protocol hebben zoals EEproms.
EDIT:
'K zie dat er een volledige uitleg ook net gepost is...

Op 24 juni 2006 19:46:43 schreef the-paradox:
Een ACK wordt gestuurd als ontvangst bevestiging. Kan zowel door master als slave.
Een ontvanger heeft niets te "willen": de master bepaalt adhv een ACK of NACK of de slave nog wel luistert.

Wat er wordt teruggestuurd als ACK of NACK kun je wel degelijk zien als een bevestiging dat er 8-data bits zijn binnengeklokt.
Lees hiervoor de officiele Philips spec's maar.
Wel zijn er componenten die een variatie op het protocol hebben zoals EEproms.

Dat klopt wel, het is echter de context waarin je het bekijkt. Het bit an-sich geeft inderdaad aan dat het vorige byte ontvangen is. Maar wat de bitwaarde zelf betekent kan op meerdere manieren worden geintepreteerd. Een NACK betekent niet dat het vorige byte niet ontvangen is. Het betekent dat de ontvanger genoeg bytes heeft gekregen. In jou woorden, of 'ie nog staat te luisteren. Immers, als 'ie nog staat te luisteren wil 'ie meer bytes. Dus zoals je ziet, zeggen we gewoon het zelfde, alleen heb ik voor mijzelf een duidelijke beschrijving gevonden om de verschillende contexten goed te kunnen onderscheiden.

Edit: Om op het voorbeeldje van die eeprom terug te komen, na het ontvangen van het databyte van het gekozen adres, zal de eeprom de adres teller ophogen. Als nu de master nu blijft antwoorden met ACK, zal de Eeprom steeds het volgende databyte op de bus zetten net zolang totdat de master vertelt dat 'ie zijn buik vol heeft door een NACK terug te geven.

[Bericht gewijzigd door MagicBox op zaterdag 24 juni 2006 19:55:45 ]

Idd, er zijn meerdere manieren om hetzelfde te zeggen.

tis inderdaad op verschillende manieren te interpeteren

in volgende is ACK : De SDA wordt laag gemaakt door de slave als de master SCK hoog maakt. ( dus begin van de ACK cycle)

Na versturen van een adress. De ACK bevestigd dat er iemand luistert.

Na versturen van een byte door master : de ACK bevestigd dat de slave klaar is voor volgende byte. als de SCK niet hoog gemaakt kan worden ; clock stretching. slave is bezig )
als SDa niet hoog wordt : probleem met slave , waarschijnlijk transport error zoals ene clockpuls die niet doorgekomen is.

Als de master een ACK GEEFT ( tijdens lezen van een slave ) wil dit zeggen : STUUR volgend byte.
als de master een NACK geeft ( eigenlijk bestaat die conditie niet officieel. een NACK is het fenomeen wat optreedt als er niemand antwoordt bij addressering of bij ene transport error : Not acknowledge)

als ene master geen verdere bytes meer wil van ene slave dan creert hij ene stop conditie na het 8e ontvangen bit

hoe dan ook trekt de master de SDA laag en maakt de clock hoog. Wat er daarna gebeurt bepaalt wat volgt :

als de SCL terug laag gaat , gaan de slave gewoon verder met bitjes plaatsen. Als daarentegen ondertussen de SDA hoog geworden is , ist gedaan met spelen. ( we hebben nu een STOP binnengekregen )

der zijn kwatongen die beweren dat je ook SDA kan hoog maken een clock pulse geven en dan pas een stop sturen. Ook dat werkt. maar het hoeft niet echt bij mijn weten.
de state machines in de chips zijn zodanig gemaakt dat een STOP absolute prioriteit heeft op eender wat anders. dus of je nu die extra clockpuls doet met SDA hoog of niet maakt geen fluit uit.

[Bericht gewijzigd door free_electron op zaterdag 24 juni 2006 20:33:07 ]