I2C Fragen und Probleme

[qwerty]

Servus,

ich hab heute mit der I2C implentierung begonnen und da haben sich gleich Fragen aufgetan, vielleicht kann man auch die von anderen sammeln.

Jedenfalls folgendes

 
    if (call Resource.Request() == SUCCESS) debug("req");

    event void Resource.granted()
    {
        debug("granted");
    }

ergibt "req" und "granted" am terminal, wohin hingegen ein immediateRequest

 
    if (call Resource.immediateRequest() == SUCCESS) debug("req");

    event void Resource.granted()
    {
        debug("granted");
    }

nur "req" aber nie "granted" ausgibt... da müsste doch eigentlich entweder ein FAIL oder ein "granted" zurückommen, oder?

[qwerty]

Ich Wurst ... nein, es kommt natürlich kein granted zurück. Warum auch, wenn ein immediateRequest mit SUCCESS zurückkommt bin ich damit schon im Besitz...

[Abschreiber]

Wie komme ich denn zu der Slave Device Address für den read command beim I2CPacket-Interface ?

[qwerty]

Die steht im datenblatt: http://ti.tuwien.ac.at/ecs/teaching/..._download/file
Die 7bit Adresse lautet 0b1101000. das R/W bit wird automatisch mit aufruf von .read() oder .write() gesetzt

[pUnk]

die ist hardcoded, DS1307 manual seite 12: 1101000 bzw 0x68. den lese oder schreibmodus muss man nicht bei der adresse reinhängen, das macht schon der command (hat mich eine stunde gekostet das zu realisieren)

[Abschreiber]

die ist hardcoded, DS1307 manual seite 12: 1101000 bzw 0x68. den lese oder schreibmodus muss man nicht bei der adresse reinhängen, das macht schon der command (hat mich eine stunde gekostet das zu realisieren)

Ok stimmt, das hatte ich übersehen... Was ich aber noch immer nicht ganz verstehe: Wie läuft dann ein Lesevorgang ab? Mir leuchtet nicht ganz ein, wie man das Diagramm auf Seite 13 im DS1307-Manual mit den read- und write-Befehlen umsetzen soll. Wo gebe ich die Adresse von meinem gewünschten Time Register an? Sowohl der read- als auch der write-Befehl verlangen doch nur die slave-adresse

[Tidon]

Dazu musst du dir eine kleine State-maschine bauen:

Zuerst sendest du mit dem I2C-write Befehl die Adresse des zu lesenden Registers an die rtc und wenn dieser Befehl fertig ist, liest du mit dem I2C-read Befehl das Register aus.
Wichtig ist dabei nur, dass du beim write kein I2C_STOP-flag setzt, sonst wird die Übertragung direkt wieder abgebrochen. Das I2C_STOP-flag brauchst du hier also nur beim read-Befehl.

Der Register-Schreibvorgang funktioniert ähnlich, nur kannst du dort die Adresse und die Daten in ein Array packen und gleich auf einmal übertragen.

[qwerty]

Großes Problem, warum nimmt mein I2C.Packet.write keine Parameter?

Aufruf:

call HplDS1307.open();
call HplDS1307.registerWrite(0, 0);

aus einer command funktion

command error_t HplDS1307.registerWrite(uint8_t address, uint8_t data)
    {
        uint8_t write[2] = {address, data};

        call I2CPacket.write(I2C_START | I2C_STOP , DS1307_ADDRESS, 2, &write[0]);
        
        return SUCCESS;

schreibt irgendwas auf den i2c bus? WARUM?

ich hatte das ganz zu beginn schon mal, und hab dann die HplDS1307P nochmal neu geschrieben. Ich versteh aber immer noch nicht, was da los is...


Und das absolut dümmste:

wenn ich

debug("address of data to be sent %p", &write[0]);

vor dem packet.write einfüge, gehts wieder. ich vermute, dass die wirte funktion von einer anderen adresse aus schreibt als ich angebe, wenn das debug fehlt, wie kann ich das verhindern?

[maciej]

Äh, ich weiß nicht ob dir das was hilft: wenn du nur den namen des arrays übergibst (ohne index) dann degeneriert das array automagisch zu einem pointer auf das erste element.

call I2CPacket.write(I2C_START | I2C_STOP , DS1307_ADDRESS, 2, write);

[qwerty]

wäre eine möglichkeit, ich hab ein andres array gefunden, dessen adresse auch dann tastächlich zum schreiben genutzt wird. das array benutze ich für den bulkwrite/read und jetzt eben auch für für single register. was jedenfalls nicht funktioniert hat, war ein ändern der lokalen variable auf auf global. static und volatile brachten auch nix, was mich zur vermutung führt, dass der compiler da in den leckmich-modus geht

[qwerty]

nächstes Problem, ich hab das funktionierende RTC Projekt einfach in den GPS Parser und GLCD GUI integriert, was dazu geführt hat, dass Resource.immediateRequest nur mehr FAIL zurückgibt, gibts dafür mögliche Erklärungen?

EDIT: noch viel besser, am IC Bus werden ununterbochen STOP conditions gesendet... Einfach so, obwohl der selbe I2C code alleine wunderbar funktioniert hat...

LÖSUNG: hab am PORTE abgehört, sprich den I2C zum display zugeschalten.

[s3ns3]

DONE ---------------
Hm ich hänge da irgendwie und zwar mag ich nur ein dämliches registerRead ausführen.

Zuerst öffne ich mit open die Verbindung (immediateRequest) und das geht auch ganz gut, da speichert er auch in Atm128I2CMasterImplP denn currentClient ab.
Wenn ich jetzt aber das registerRead ausführe krieg ich immer ein Fail in Atm128I2CMasterImplP:
async command error_t I2CPacket.write[uint8_t id](i2c_flags_t flags, uint16_t addr, uint8_t len, uint8_t* data)
..
if (currentClient != id) {
return FAIL;
}
...

Weil er dort bei id 0 hat und currentClient ist halt 1.

Aufrufen tue ich das write so:
call I2CPacket.write(.....

Vll rufe ich es auch einfach nur falsch auf? Ich verstehe halt nicht ganz das I2CPacket.write[uint8_t id] <-- uin8_t, muss ich das irgendwo instanzieren?!
-----------------

Hat sich erledigt hab im Config I2C zweimal instanziert, lol^^


lg

[s3ns3]

Hab doch noch eine Frage und zwar hat jemand Tipps zum Bulkread?

call I2CPacket.read(I2C_START|I2C_STOP, addr, 7, data);

Nur so das ganze Packet lesen geht mal nicht so wirklich oder?

[CMD]

Hab doch noch eine Frage und zwar hat jemand Tipps zum Bulkread?

call I2CPacket.read(I2C_START|I2C_STOP, addr, 7, data);

Nur so das ganze Packet lesen geht mal nicht so wirklich oder?

also du möchtest ja lesen von der Slave adresse also 0x68, was bei die addr ist weiss ich nicht, zweitens fällt mir auf der "7" er, wobei wir 8 Bytes lesen und die "data" glaube ich ist bei dir der Pointer der auf die daten vom Bulkread("auf diese Daten") zeigt.

Aber ein Tipp, bevor die Daten gelesen werden können, sollte der Lesepointer mit einem write wieder auf den Anfang gesetzt werden, damit richtig gelesen werden kann.

Lg

[s3ns3]

Also der Spass is bei mir Momentan so...


in bulkRead hab ich folgendes:
call I2CPacket.write(I2C_START, 0x68, 7, (uint8_t*) data);


Dann im Event I2CPacket.writeDone(error_t error, uint16_t addr, uint8_t length, uint8_t* data) folgendes:
Da wird die adresse ja wieder übergeben 0x86.

if(state==BULK_READ)
{
call I2CPacket.read(I2C_START | I2C_STOP, addr, 7, data+1);
}


So wie ich das verstanden habe sollte er doch jetzt das was er gelesen hat in data zurückspielen oder?
Oder muss ich jedes Byte einzeln holen? hmmm

[CMD]

nach deinem read wird readDone aufgerufen dort schickst du ein Signal dass du fertig bist mit dem Lesen und in BulkReadReady eine Ebene hoeher dort holst du dir die Daten wieder in dein Rtc - Strukt zurueck. Aber da ich immer Leds zum debuggen verwendet habe, koenntest du einfach mit leds gucken, ob du auch in die commands bzw. events reinkommst.

einfach DDRL = 0xff
PORTL = 0x00

und in dem jeweiligen command, event PORTL = 0x01 debuggen so siehst du auch ob der Code das macht was du willst, so bin ich zumindest vorgegagen.

Lg

[s3ns3]

Ja genau so mach ichs...nur das ichs momentan noch nicht ins rtc rückspiele weils nix zum spielen gibt...nur ne 64 in hours....

Gebe es übern UART zurück die Debugausgaben, dürfte aber irrelevant sein. Events und Commands werden alle ausgeführt.
Ein einzelnes Read und Write funzt ja auch, also vom Prinzip her müsste es so passen?

So in DS1307C passiert das:

ds1307_time_mem_t read_data;

command error_t Rtc.start(rtc_time_t *data){
...
call HplDS1307.open();    
call HplDS1307.bulkRead(&read_data);
....
} 

in HplDS1307C folgendes:

command error_t HplDS1307.bulkRead(ds1307_time_mem_t *data)    {        
 data->address=0x00;       
  if(opened==SUCCESS) {            
    atomic{           
       state=BULK_READ;            
       printf("Data: %p %d, %d, %d, %d\n", data, data->seconds, data->minutes, data->hour, data->date);           
       call I2CPacket.write(I2C_START, 0x68, 7, (uint8_t*) data);           
     }       
  }       
 return SUCCESS;   
}

async event void I2CPacket.writeDone(error_t error, uint16_t addr, uint8_t length, uint8_t* data)    {        
   if(state==BULK_READ) {            
     printf("Addr: %i\n", addr);            
     call I2CPacket.read(I2C_START | I2C_STOP, addr, 8, (uint8_t*)(data)+1);        
    }    
}

async event void I2CPacket.readDone(error_t error, uint16_t addr, uint8_t length, uint8_t* data)    {        
   if(state==BULKREAD){           
     if(error==SUCCESS){                
       printf("Data1: %d %d, %d, %d, %d\n", data[0], data[1], data[2], data[3], data[4]);               
       //signal HplDS1307.bulkReadReady();            
     }        
}    
} 

Eventuell entdeckt ja jemand etwas Die letzten 5 Std damit zugebracht und nix geht^^

lg

[CMD]

Ein einzelnes Read und Write funzt ja auch, also vom Prinzip her müsste es so passen?

Prinzip passt, aber hier:

in bulkRead hab ich folgendes:
call I2CPacket.write(I2C_START, 0x68, 7, (uint8_t*) data);

beim write, möchtest du ja bevor du liest auf 0x00 von der Slave Adresse 0x68 schreiben, aber du schickst ihm da einen pointer mit daten denke ich mal, aber wenns stimmt und du die Sachen irgendwie anders aufgebaut hast stimmt das Prinzip denke ich mal.

aber laut Tutor: Beim Schreieben: 1 x write 0x00, 1x write daten, Beim Lesen: 1x write 0x00 1x read daten so hats bei mir funktioniert

Lg

[s3ns3]

t und du die Sachen irgendwie anders aufgebaut hast

Mein struct hat an der ersten stelle die addresse:

typedef struct ds1307_time_mem_t{
uint8_t address;
uint8_t seconds;
uint8_t minutes;
uint8_t hour;
uint8_t day;
uint8_t date;
uint8_t year;
} ds1307_time_mem_t;