STM32F407 Mikrocontroller, CooCox. Problem

[Thomas P. (wirra)]

Hallo.
Ich muss am Montag ein Projekt in meiner Schule abgeben.
Bei diesem Projekt handelt es sich um eine Wetterstation, 2 der 4 werte 
möchte ich mit dem Luftdruck & Temperatur Sensor Hp03s auslesen.
Die Berechnung von Druck und Temperatur klappt soweit mit 
voreingestellten Werten, wie in der Beschreibung des Sensors.
-----------------
Beschreibung: https://www.pollin.de/shop/downloads/D810119B.PDF
-----------------
Zur Verfügung habe ich nur meinen Stm32f407 µC mit Discovery Board und 
LCD Display. Als IDE darf ich nur CooCox CooIDE verwenden.

Das Problem: Ich weiss nicht, wie ich per I²C die erforderlichen 
Koeffizienten und Messwerte einlesen kann.
Für I²C  hab ich bereits eine Initialisierungsroutine geschrieben. 
Jedoch werde ich aus der Beschreibung nicht schlau, wie ich die 
Koeefizienten und Werte auslesen kann.

Mein Initialisierungsfile sieht wie folgt aus:

void LuftdruckuTempI2C_Init(ui32 n){
  Resources__ExBoard_init(_, n, "Druck & Temp");

  RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE); /* Enable the 
I2C1 peripheral clock */
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);

  GPIO_InitTypeDef
  GPIO_InitStructure            = {0};
  GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
  GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_NOPULL;
  GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_6 | GPIO_Pin_9;
  GPIO_Init(GPIOB, &GPIO_InitStructure);

  GPIO_PinAFConfig(GPIOB, GPIO_PinSource6, GPIO_AF_I2C1); /* I2C SCL pin 
Configuration */
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource9, GPIO_AF_I2C1); /* I2C SDA pin 
Configuration */

  /* I2C1 peripheral configuration */
  I2C_DeInit(I2C1);

  I2C_InitTypeDef
  I2C_InitStructure                         = {0};
  I2C_InitStructure.I2C_Mode                = I2C_Mode_I2C;
  I2C_InitStructure.I2C_DutyCycle           = I2C_DutyCycle_2;
  I2C_InitStructure.I2C_OwnAddress1         = 0x33;
  I2C_InitStructure.I2C_Ack                 = I2C_Ack_Enable;
  I2C_InitStructure.I2C_AcknowledgedAddress = 
I2C_AcknowledgedAddress_7bit;
  I2C_InitStructure.I2C_ClockSpeed          = 32768;
  I2C_Init(I2C1, &I2C_InitStructure);

  I2C_Cmd(I2C1, ENABLE);


--------------------------------
--------------------------------
Da ich dieses Projekt am Montag abgeben muss, ist es ziemlich dringend.

Ich würde mich sehr über schnelle und hilfreiche Antworten freuen.

mit freundlichen Grüßen
wirra

[aSma>> (Gast)]

Servus,

> I2C_InitStructure.I2C_OwnAddress1         = 0x33;
Du bist der Master! Also ...

> Das Problem: Ich weiss nicht, wie ich per I²C die erforderlichen
> Koeffizienten und Messwerte einlesen kann.

hier ein Beispiel für C1
>C1 (MSB:LSB)0x10:0x11  Sensitivity coefficient 0x100--0xFFFF 256--65535

//header datei .h

//Addresse
#define EEPROM_24C02_ADDR             0xA0  //Addr 0b1000000(R/W)
#define HP03S_ADC_ADDR                0xEE

//Konstanten
#define EEPROM_24C02_CONST_C1_MSB     0x10  //Sensitivity coefficient
#define EEPROM_24C02_CONST_C1_LSB     0x11

//Konstanten Cast
#define EEPROM_24C02_CAST_C1          0xFFFF

...

#define HP03S_DELAY_MS                40    //min 40ms delay read ADC

//XCLR_Output_Pin
#define XCLR_PORT                     GPIOA
#define XCLR_PIN                      GPIO_Pin_1

#define XCLR_EEPROM()                 GPIO_ResetBits( XCLR_PORT, XCLR_PIN )
#define XCLR_HP03S()                  GPIO_SetBits( XCLR_PORT, XCLR_PIN )


#define GET_VAL_MSB_LSB (msb, lsb)     (uint16_t)((8<<msb)|(lsb))  //ungetestet

typedef struct{
  uint16_t C1,C2...;
  uint8_t A,B,C,D;
}24C02_CONST_t;

//kann man auch als typedef struct schreiben
uint16_t D1; //Luftdruck
uint16_t D2; //Temperatur


//hier deine funktionen schreiben (besser noch mit DMA):
uint8_t i2c_read(uint8_t slave_adr, uint8_t reg, uint8_t addr);
void i2c_write(uint8_t slave_adr, uint8_t reg, uint8_t addr);

24C02_CONST_t Read_Const(void);
uint16_t Luftdruck(24C02_CONST_t c);
uint16_t Temperatur(24C02_CONST_t c);

//main .c
(*Das I²C Interface wird sowohl für das Auslesen der 
Kalibrierungsdaten aus dem EEPROM, als auch für das Auslesen der  
Messwerte vom AD-Wandler verwendet.*)
24C02_CONST_t Read_Const(void){   //Werte aus EEPROM nur auslesen 
  24C02_CONST_t 24C02_CONST;
  uint8_t msb, lsb;
 
  XCLR_EEPROM();  //set low
  msb = i2c_read(EEPROM_24C02_ADDR, EEPROM_24C02_CONST_C1_MSB, 0);
  lsb = i2c_read(EEPROM_24C02_ADDR, EEPROM_24C02_CONST_C1_LSB, 0);
  24C02_CONST.C1 = GET_VAL_MSB_LSB(msb, lsb) & EEPROM_24C02_CAST_C1;
  ...

return 24C02_CONST;
}

uint16_t Luftdruck(24C02_CONST_t c){
   XCLR_HP03S();  //high
...
}

uint16_t Temperatur(24C02_CONST_t c){
   XCLR_HP03S();   //high
...
}

int main (void){
...
return 0;
}

Den Rest schaffst du schon. Ist eigentlich eine Sache von 1std.

mfg

[dasrotemopped (Gast)]

welcher Unmensch von Lehrer gibt denn nur 4 Tage Zeit für ein solches 
Projekt ? Und dann noch mit solch genauen Vorgaben, und die Schüler dazu 
verpflichten, sich selbstständig in der kurzen Projektzeit auch noch ins 
Thema einzuarbeiten.

[aSma>> (Gast)]

dasrotemopped schrieb:
> welcher Unmensch von Lehrer gibt denn nur 4 Tage Zeit für ein solches
> Projekt ? Und dann noch mit solch genauen Vorgaben, und die Schüler dazu
> verpflichten, sich selbstständig in der kurzen Projektzeit auch noch ins
> Thema einzuarbeiten.

Tierquälerei.

Ach ja, es müssten noch zwei weitere Funktionen erstellet werden:

extern void SysTick_Handler(void);
void Delay_ms(uint32_t cnt);

Dann hau rein in die Tasten.

mfg

[Thomas P. (wirra)]

Vielen Dank für die Antworten! Nun habe ich das Problem, dass der Sensor 
eine Masterclock benötigt. Da ich keinen externen Quarz zur Verfügung 
habe, müsste ich also auf dem µC einen Takt erstellen, und diesen über 
einen Portpin ausgeben. Kann mir da jemand helfen?
Und nochmals vielen Dank, für die bisherigen Antworten, die haben mir 
bereits geholfen.

mfg
wirra

[Reginald L. (Firma: HEGRO GmbH) (reggie)]

Schau mal im Reference Manual nach "MCO". Damit kannst du eine Clock 
ausgeben. Ansonsten kannst du das auch mit einem Timer, so in die 
Richtung PWM.

[Peter (Gast)]

Schon lange her, aber jenachdem ganz nützliche I2C Routinen...
Beitrag "STM32F4 Discovery mit I2C-Bus EEPROM"

[Thomas P. (wirra)]

Ok. Das mit der Clock habe ich jetzt.
Jetzt habe ich noch ein Problem, beziehungsweise eine Frage.
Ich muss von jedem Koeffizient und Wert immer MSB und LSB auslesen. Dass 
ich diese zusammenfügen kann, muss ich nur den MSB um 8 nach links 
verschieben, und dann den LSB damit addieren, oder?

Vielen Dank übrigens, dieses Forum und ganz besonders Ihr, rettet mir 
grad wahrscheinlich meine Semesternote.

mfg
wirra

[Reginald L. (Firma: HEGRO GmbH) (reggie)]

Lukas W. schrieb:
> Vielen Dank übrigens, dieses Forum und ganz besonders Ihr, rettet mir
> grad wahrscheinlich meine Semesternote.
Die 4 gewinnt!

Und Nee, wenn du wirkluch einmal lsb und einmal msb reinbekommst (was 
seltsam wäre) musst du dann die BitReihenfolge einer der variablen 
umkehren.

[Thomas P. (wirra)]

Nach dem stand der dinge, brauchte ich jetzt wirklich jemanden, der mir 
das komplette programm schreibt, weil ich an meinen grenzen angelangt 
bin. ich kann die vorschläge hier nicht umsetzen, und bin fertig mit 
meinen nerven

Falls irgendjemand das echt machen würde, wär ich ihm sehr dankbar, aber 
allzuviel hoffnung mach ich mir nichtmehr

mfg
wirra

[Reginald L. (Firma: HEGRO GmbH) (reggie)]

Wo ist denn das Problem?

[Thomas P. (wirra)]

Ich programmiere jetzt seit 52 stunden fast durchgehend, und komm auf 
keinen grünen zweig. Die Berechnung der Werte klappt ja... aber ich kann 
die Werte nicht einlesen. Ich kann keine clock erzeugen und auf einem 
portpin ausgeben, und darum bekomm ich irgendwelche werte.
Abgesehen davon weiss ich nicht, ob das einlesen so überhaupt 
funktionieren kann.
Beispiel C1:
 //C1 - Sensitivity coefficient
 I2C_GenerateSTART(I2C1, ENABLE);
 I2C_SendData(I2C1, 0xA0); //EEPROM Schreiben
 I2C_SendData(I2C1, 0x10);
 I2C_GenerateSTART(I2C1, ENABLE);
 I2C_SendData(I2C1, 0xA1);//EEPROM lesen
 C1_MSB = I2C_ReceiveData(I2C1);
 I2C_SendData(I2C1, 0xA0);
 I2C_SendData(I2C1, 0x11);
 I2C_SendData(I2C1, 0xA1);
 C1_LSB = I2C_ReceiveData(I2C1);

int C1zwischen = (C1_MSB<<8);
int C1 = C1zwischen + C1_LSB;

Bin wie gesagt fertig mit meinen Nerven. Wenn das Programm bis Montag 
nicht funktioniert, fall ich durch.

mfg
wirra

[Reginald L. (Firma: HEGRO GmbH) (reggie)]

Hast du ein Oszi?

[aSma>> (Gast)]

Servus,
so funktioniert kein Forum. Niemand macht für dich deine Hausaufgaben.
Du musst konkrete Fragen stellen oder du bezahlst Geld für die Arbeit.

Anbei ist das Datenblatt des EEPROMS. Hier habe ich sogar ein Fehler
gemacht. Wenn man i2c Protokoll kennt, dann weiß man, dass das letzte
Bit der Addresse R/!W hier als MSB und LSB genannt wird. Ein "schreiben" 
des EEPROMS ist nicht erlaubt! Mit einer ausgeklügelten Schleife kann 
die ganzen Konstanten aufeinmal erschlagen.

Weiterhin sind Arbeiten bei einen Bussystem ohne einen LA sehr mühselig.

Wo genau hast du Probleme?

mfg

[Reginald L. (Firma: HEGRO GmbH) (reggie)]

Also ich habe mir das Datenblatt des Sensors und deinen Code mal grob 
angeschaut, falls du kein Oszi hast, versuche mal das:
- Die IC2 Clock nicht auf 32.768kHz setzen, setze die mal auf 100kHz 
oder auch weniger.
- Die Leitungen SCL und SDA jeweils mit einem Widerstand von 1kOhm gegen 
V+ setzen
- Am µC per Timer die Clock an einem Pin ausführen, ich würde das 
einfach mal per Software machen, also in einem Interrupt den Pin 
abwechselnd setzen und wieder löschen. Hier musst du auf deine 32.768kHz 
kommen

[aSma>> (Gast)]

Lukas W. schrieb:
> Ich kann keine clock erzeugen und auf einem
> portpin ausgeben, und darum bekomm ich irgendwelche werte.

Guck dir die englische Datenblätter an.
>MCLK  T     30 <= 32768 <=   35    KHz

Erstelle eine PWM mit dieser Frequenz.

Lukas W. schrieb:
> I2C_SendData(I2C1, 0xA0); //EEPROM Schreiben
>  I2C_SendData(I2C1, 0x10);
>  I2C_GenerateSTART(I2C1, ENABLE);
>  I2C_SendData(I2C1, 0xA1);//EEPROM lesen
>  C1_MSB = I2C_ReceiveData(I2C1);
>  I2C_SendData(I2C1, 0xA0);
>  I2C_SendData(I2C1, 0x11);
>  I2C_SendData(I2C1, 0xA1);
>  C1_LSB = I2C_ReceiveData(I2C1);

Mit der Funktion:

I2C_Send7bitAddress(I2C1, slave_adr, I2C_Direction_Transmitter);

Wird automatisch das R/W bit auf NULL gesetzt!

I2C_Send7bitAddress(I2C1, slave_adr, I2C_Direction_Receiver);

Wird automatisch das R/W bit auf "1" gesetzt!

I2C_SendData(I2C1, 0xA0); //EEPROM !lesen schreiben ist nicht erlaubt

Danach kann das nicht funktionieren was du machst. Wie sieht deine 
Funktion: I2C_SendData(I2C1, 0xA0); aus?

mfg

[Thomas P. (wirra)]

Tut mir leid für meine Ausrucksweise, natürlich hab ich nicht erwartet, 
dass mir hier jemand das komplette programm schreibt. Tut mir wirklich 
leid.

Die funktion I2C_SendData(I2C1, 0xA0); sieht so aus:

void I2C_SendData(I2C_TypeDef* I2Cx, uint8_t Data)
{
  /* Check the parameters */
  assert_param(IS_I2C_ALL_PERIPH(I2Cx));
  /* Write in the DR register the data to be sent */
  I2Cx->DR = Data;

Ich komme einfach nicht weiter, ich weiss wirklich nicht wie ich die 
Werte einlesen kann. Kann mir jemand einen Codeschnipsel zur verfügung 
stellen, wie das in CooCox mit den Werten einlesen geht? Also in meinem 
konkreten fall.
Wäre für jede Hilfe dankbar.

mfg
wirra

[Thomas P. (wirra)]

Diese Befehle stammen von einem "Betriebssystem" das mein Lehrer für 
diesen µC geschrieben hat. Aber natürlich dürfen wir auch standart 
CooCox Befehle verwenden.

[aSma>> (Gast)]

Da hast du nicht tief genug in das Reference Manual geguckt. Das wird so 
nie im Leben funktionieren. Zuerst muss immer das Startbit gesetzt 
werden!

I2C_GenerateSTART(I2Cx, ENABLE);

Danach müssen immer die passenden Register ausgelesen werden, damit die 
Geschichte läuft...

Ich rate dir auf die schneller mal eine funktionstüchtige lib runter zu 
laden: http://mikrocontroller.bplaced.net/wordpress/?page_id=720

Danach:

//Beispiel C1
int16_t msb, lsb;
uint16_t C1;

msb = UB_I2C1_ReadByte(0xA0, 0x10); //C1 msb
if (msb<0){//error}
lsb = UB_I2C1_ReadByte(0xA0, 0x11); //C1 lsb
if (msb<0){//error}

C1 = (uint16_t)((8<<msb)|(lsb));

Den MCLK machst du zwischen 30-35khz und CLK auf 100khz. Die Pullups 
hast du hoffentlich nicht vergessen, sonst wird das nichts.

So, ich gehe jetzt raus an die Sonne.

mfg

[Thomas P. (wirra)]

O mein GOTT!!! Danke, mit dieser library und deinen Befehlen klappt das 
Einlesen der Werte! Vielen Vielen herzlichen Dank :)
Ich weiss nicht wie ich mich bedanken soll, du hast mir grad meine 
semesternote gerettet. DAAAAANKE!

mfg
wirra

[Thomas P. (wirra)]

Das einzige was jetzt noch fehlt, ist eben der Takt über einen Portpin. 
Ich weiss nicht wie ich den per pwm oder interrupts generieren kann. 
Kann mir da vielleicht jemand helfen? Bzw den einen oder anderen code 
schnippsel spendieren? Muss ja nicht der ganze sein, nur dass ich das 
kapiere.

Bin jedem hier dankbar, ganz besonderer Dank gilt natürlich aSma>> denn 
ohne ihn hätte ich das nicht geschafft. Danke

mfg
wirra

[Thomas P. (wirra)]

Edit: Es war natürlich nicht das einzige was fehlte (War ja klar, ich 
Holzkopf (/.-) ), Denn im Datenblatt des Sensors steht ein für mich zu 
komplexer Vorgang um die Parameter D1 und D2 einzulesen... also 
letztendlich die Messwerte. Hierbei würde ich noch hilfe benötigen, da 
ich nicht weiss, wie ich ein Acknowledge Bit senden kann, und wie ich 
eines vom Slave (dem Sensor) empfangen kann. Und wie generell der ganze 
Vorgang aussehen muss, um die Werte zu lesen.

mfg
wirra

[aSma>> (Gast)]

Servus,
so jetzt habe ich Sonne und reichlich Bier getankt.

> Das einzige was jetzt noch fehlt, ist eben der Takt über einen Portpin.
> Ich weiss nicht wie ich den per pwm oder interrupts generieren kann.

Ich bitte dich ein wenig Eigeninitiative wäre nicht schlecht.
Das musst du selber hinkriegen!

> Denn im Datenblatt des Sensors steht ein für mich zu
> komplexer Vorgang um die Parameter D1 und D2 einzulesen

Lach. Was ist da Komplex???

   UB_I2C1_WriteByte(0xEE, 0xFF, 0xF0); 
   Delay_ms(41);   //sysTick Handler >40ms
 
   //Diese Fkt musst du erstellen und das Stopbit entfernen!
   UB_I2C1_WriteOneByte(0xEE, 0xFD);

   //Diese Fkt musst du bearbeiten!
   UB_I2C1_ReadByte(uint8_t slave_adr, uint8_t adr); 

zu:
   UB_I2C1_ReadByte(0xEE); 
   
...
UB_I2C1_ReadByte(0xEE){
...
}

[Thomas P. (wirra)]

Tut mir leid falls ich dich enttäusche, aber ich sitze jetzt schon lange 
genug daran. Und nein, ich habe es nicht hingekriegt. Auch das mit D1 
und D2 noch nicht

[Reginald L. (Firma: HEGRO GmbH) (reggie)]

Lukas W. schrieb:
> aber ich sitze jetzt schon lange genug daran
Dann bist du im Studium aber falsch ?

Du musst dich in die Thematik reinarbeiten. Aber vllt hast du auch Glück 
und jemand hier erbarmt sich ☺

[Thomas P. (wirra)]

Das ist kein Studium, das ist ein Nebenzweig meiner Schule. Ich habe 
hier eine Ausbildung zum Elektrotechniker. Die Fachinformatik und somit 
dieses Projekt ist ein Nebenzweig den ich machen muss.

mfg
wirra

[Thomas P. (wirra)]

Und die Zeile:
UB_I2C1_WriteOneByte(0xEE, 0xFD);
lässt sich bei mir so nicht compilieren, muss ich die zuerst erstellen? 
Wenn ja: wie?
Bin echt am verzweifeln, bin über jede hilfe dankbar. Ich kann mir jetzt 
vorstellen wie das Auslesen von D1 und D2 funktioniert. Nur brauchte ich 
eben noch dieses
UB_I2C1_WriteOneByte(0xEE, 0xFD);

und eine Clock mit 30-35kHz


Falls mir da irgendjemand helfen kann (und will), ihr seid gerne 
willkommen :)

mfg
wirra

[Thomas P. (wirra)]

kann ich anstatt von

 UB_I2C1_WriteOneByte(0xEE, 0xFD);

auch einfach

             I2C_SendData(I2C1, 0xEE);
                I2C_SendData(I2C1, 0xFD);

schreiben? Wenn das so funktioniert, fehlt mir nurnoch die Clock. Ich 
fände es echt genial, wenn sich jemand meiner erbarmen würde :(

mfg
wirra

[aSma>> (Gast)]

Servus,
du hast einfach keine Ahnung von der Materie, deshalb fällst du zurecht 
durch. Guck dir die mal die Funktionen an. Diese sind super 
dokumentiert:

//--------------------------------------------------------------
// Beschreiben einer Adresse (16bit) per I2C von einem Slave
// slave_adr => I2C-Basis-Adresse vom Slave
// adr       => Register Adresse die beschrieben wird
// wert      => Bytewert der geschrieben wird
//
// Return_wert :
//    0   , Ok
//  < 0   , Error
//--------------------------------------------------------------
int16_t UB_I2C1_WriteByte16(uint8_t slave_adr, uint16_t adr, uint8_t wert)
{
  int16_t ret_wert=0;
  uint32_t timeout=I2C1_TIMEOUT;
  uint8_t lo,hi;
  
  // Hi und Lo Adresse
  lo=(adr&0x00FF);
  hi=(adr>>8);  

  // Start-Sequenz
  I2C_GenerateSTART(I2C1, ENABLE); 

  timeout=I2C1_TIMEOUT;
  while (!I2C_GetFlagStatus(I2C1, I2C_FLAG_SB)) {
    if(timeout!=0) timeout--; else return(P_I2C1_timeout(-1));
  } 

  // Slave-Adresse senden (write)
  I2C_Send7bitAddress(I2C1, slave_adr, I2C_Direction_Transmitter);

  timeout=I2C1_TIMEOUT;
  while (!I2C_GetFlagStatus(I2C1, I2C_FLAG_ADDR)) {
    if(timeout!=0) timeout--; else return(P_I2C1_timeout(-2));
  }  

  // ADDR-Flag löschen
  I2C1->SR2;

  timeout=I2C1_TIMEOUT;
  while (!I2C_GetFlagStatus(I2C1, I2C_FLAG_TXE)) {
    if(timeout!=0) timeout--; else return(P_I2C1_timeout(-3));
  }

  // Adresse (hi) senden
  I2C_SendData(I2C1, hi);

  timeout=I2C1_TIMEOUT;
  while (!I2C_GetFlagStatus(I2C1, I2C_FLAG_TXE)) {
    if(timeout!=0) timeout--; else return(P_I2C1_timeout(-4));
  }
  
  // Adresse (lo) senden
  I2C_SendData(I2C1, lo);

  timeout=I2C1_TIMEOUT;
  while (!I2C_GetFlagStatus(I2C1, I2C_FLAG_TXE)) {
    if(timeout!=0) timeout--; else return(P_I2C1_timeout(-4));
  }  

  // Daten senden
  I2C_SendData(I2C1, wert);

  timeout=I2C1_TIMEOUT;
  while ((!I2C_GetFlagStatus(I2C1, I2C_FLAG_TXE)) || (!I2C_GetFlagStatus(I2C1, I2C_FLAG_BTF))) {
    if(timeout!=0) timeout--; else return(P_I2C1_timeout(-5));
  }

  // Stop-Sequenz
  I2C_GenerateSTOP(I2C1, ENABLE);

  ret_wert=0; // alles ok

  return(ret_wert);
}

Wenn du jetzt nicht fähig bist diese Funktion an dein Sensor anzupassen, 
dann fehlen mir die Worte. Ich habe sogar dir ein Bildchen gemalt.

In einen Forum postet man was man hat und dann wird hoffentlich Einen 
geholfen. Du hast keine Ahnung von µC. Deshalb bin ich raus!

mfg

[Thomas P. (wirra)]

Vielen Dank! Ich habe es jetzt geschafft, so eine Funktion zu 
implementieren. Ich bin nicht böse auf dich, ich weiss ja, dass ich 
nicht der begabteste darin bin. Tut mir leid dass du so viel geduld mit 
mir haben musstest. Jetzt fehlt wirklich nurnoch eine Clock mit 32kHz 
und da blicke ich wirklich nicht durch. Ich habe halt zuvor noch nie 
etwas mit I²C gemacht. Ein Denkanstoss wie das mit der Clock 
funktioniert, wäre mir schon ne große Hilfe.

mfg
wirra