Multibyte write

[max (Gast)]

Hallo

Ich habe da eine kurze Frage:

Ich habe die Funktion

HAL_I2C_Master_Transmit(&hi2c1, ep1_address_write, &FORCE_ANA_CTRL_SIGS, sizeof(FORCE_ANA_CTRL_SIGS), 1000);

Dabei ist ep1_address_write die Deviceadresse
&FORCE_ANA_CTRL_SIGS die Adresse des Registers vom Sensor, das geändert 
werden soll (angegeben als Daten)

und im Anschluss müsste ich noch bevor das Parity-Bit kommt, noch 
weitere Daten übertragen können, damit das Register geschrieben wird.
Wie bewerkstellige ich das genau?
Ich habe jetzt lediglich das Gerät und dessen Register angesprochen, 
jedoch noch nicht geschrieben..
Muss ich da eine neue Fkt. verwenden?

Sorry für die blöde Frage.

[Oliver J. (skriptkiddy)]

max schrieb:
> Ich habe die FunktionHAL_I2C_Master_Transmit(&hi2c1, ep1_address_write,
> &FORCE_ANA_CTRL_SIGS, sizeof(FORCE_ANA_CTRL_SIGS), 1000);

Wie ist die Signatur der Funktion? Um welchen Sensor handelt es sich?

Grüße Oliver

[Jim M. (turboj)]

max schrieb:
> und im Anschluss müsste ich noch bevor das Parity-Bit kommt,

Bei I2C? Du sprichst in Rätseln. Wie der I²C Bus funktioniert steht in 
ein paar alten Phillips Dokumenten, die findet Google normalerweise.

max schrieb:
> Muss ich da eine neue Fkt. verwenden?

Normal nich, aber ich sehe das Datenblatt Deines Sensors nicht.

[max (Gast)]

Hallo

Der Sensor ist der epc901.
Beim multibyte write ist dort beschrieben, dass man zuerst die 
Deviceadresse, dann die Registeradresse schicken muss und darauffolgend 
die Daten bis ein Parity Bit kommt.


 zum i2c weiss ich: start = data geht low waehrend clock high ist
stop = data geht high wenn clock highnist
daten kiennen nur bearbeitet bzw gesendet werden, wenn der clock high 
ist
nach jedem 8 bit datentransfer kommt ein acknowledge

Ich haette es jetzt so gemacht, dass ich das ich den start eingeleitet 
haette dann die deviceadresse geschickt und ack abgewartet
dann die registeradresse geschickt u ack abgewartet
dann die daten u ack abgewartet
und am schluss stop eingeleitet

aber der prof hat mir gesagt dass man das gerade bei stm32 nicht selbst 
machen muss.
und sehe ich in die obige fkt. ist das auch so.
Ich verstehe nur nicht wie ich das dann mit dieser funktion 
bewerkstelligen kann ohne den vorgang selbst in die hand zu nehmen.

sorry dass ich mich so dumm anstelle

[fop (Gast)]

FORCE_ANA_CTRL_SIGS dürfte ein Array of Bytes sein. Häng' doch die 
anderen Bytes, die Du senden willst hinter die vorhandenen an das Array 
an.
Oder falls das noch wo anders benötigt wird, erstelle ein neues 
konstantes Array, und übergib einen Zeiger auf das neue und natürlich 
auch die Länge des neuen.

[Marc V. (Firma: Vescomp) (logarithmus)]

max schrieb:
> Ich habe die FunktionHAL_I2C_Master_Transmit(&hi2c1, ep1_address_write,
> &FORCE_ANA_CTRL_SIGS, sizeof(FORCE_ANA_CTRL_SIGS), 1000);

 Wieso ep1_address_write ?
 ep1_adress genügt vollkommen, HAL setzt oder rücksetzt das bit für
 dich, je nachdem ob du liest oder schreibst.


> Beim multibyte write ist dort beschrieben, dass man zuerst die
> Deviceadresse, dann die Registeradresse schicken muss und darauffolgend
> die Daten bis ein Parity Bit kommt.

 Das ist kein Parity sondern STOP und es wird ohne dein Zutun 
gesendet.


> Ich haette es jetzt so gemacht, dass ich das ich den start eingeleitet
> haette dann die deviceadresse geschickt und ack abgewartet
> dann die registeradresse geschickt u ack abgewartet
> dann die daten u ack abgewartet
> und am schluss stop eingeleitet

 Das wird alles von der entspr. Funktion gemacht, du brauchst nur die
 Adressen und Länge anzugeben.


> aber der prof hat mir gesagt dass man das gerade bei stm32 nicht selbst
> machen muss.
> und sehe ich in die obige fkt. ist das auch so.
> Ich verstehe nur nicht wie ich das dann mit dieser funktion
> bewerkstelligen kann ohne den vorgang selbst in die hand zu nehmen.


 So:

#define ANA_TEST_MODE_EN_0 0xD0
#define FORCE_ANA_CTRL_SIGS 0xD6
uint8_t I2C_Arr[63] = 0;
HAL_StatusTypeDef lStat;

/* Ein Byte (Register FORCE_ANA_CTRL_SIGS) schreiben */ 
 I2C_Arr[0] = FORCE_ANA_CTRL_SIGS;
 I2C_Arr[1] = 0x2C;

  lStat = HAL_I2C_Master_Transmit (&hi2c1, ep1_address, I2C_Arr, 2, 500);
  if(lStat == HAL_OK) {
     ...
  }


/* Acht Bytes (Register ANA_TEST_MODE_EN_0 bis FORCE_ANA_CTRL_SIGS) schreiben */ 
 I2C_Arr[0] = ANA_TEST_MODE_EN_0;
 I2C_Arr[1] = 0x2C; I2C_Arr[2] = 0x2C; I2C_Arr[3] = 0x2C; I2C_Arr[4] = 0x2C;
 I2C_Arr[5] = 0x2C; I2C_Arr[6] = 0x2C; I2C_Arr[7] = 0x2C; I2C_Arr[8] = 0x2C;
  lStat = HAL_I2C_Master_Transmit (&hi2c1, ep1_address, I2C_Arr, 9, 500);
  if(lStat == HAL_OK) {
     ...
  }

 P.S.
 Natürlich aus dem Kopf, nicht probiert.

[fop (Gast)]

Marc V. schrieb:
> max schrieb:
>> Ich habe die FunktionHAL_I2C_Master_Transmit(&hi2c1, ep1_address_write,
>> &FORCE_ANA_CTRL_SIGS, sizeof(FORCE_ANA_CTRL_SIGS), 1000);
>
>  Wieso ep1_address_write ?
>  ep1_adress genügt vollkommen, HAL setzt oder rücksetzt das bit für
>  dich, je nachdem ob du liest oder schreibst.
Glaube ich eher nicht. Die Funktion sendet eine vorgegebene Anzahl Bytes 
raus. Die hat keine Ahnung, ob danach noch ein Lesen kommt.

>> Beim multibyte write ist dort beschrieben, dass man zuerst die
>> Deviceadresse, dann die Registeradresse schicken muss und darauffolgend
>> die Daten bis ein Parity Bit kommt.
>
>  Das ist kein Parity sondern STOP und es wird ohne dein Zutun
> gesendet.
Ich sage mal ein NAK. Wer bietet mehr...

[Marc V. (Firma: Vescomp) (logarithmus)]

fop schrieb:
>>  Wieso ep1_address_write ?
>>  ep1_adress genügt vollkommen, HAL setzt oder rücksetzt das bit für
>>  dich, je nachdem ob du liest oder schreibst.
> Glaube ich eher nicht. Die Funktion sendet eine vorgegebene Anzahl Bytes
> raus. Die hat keine Ahnung, ob danach noch ein Lesen kommt.

 Solltest du aber.
 HAL_I2C_Master_Transmit schreibt und HAL_I2C_Master_Receive liest.
 Dementsprechend wird von der Funktion auch R/W bit gesetzt oder
 rückgesetzt.

fop schrieb:
>>  Das ist kein Parity sondern STOP und es wird ohne dein Zutun
>> gesendet.
> Ich sage mal ein NAK. Wer bietet mehr...

 Und liegst wieder falsch.
 Beim schreiben sendet Slave nach jedem empfangenem Byte ein ACK - bis
 ein STOP vom Master kommt.

 Beim lesen wird vom Master n-1 Bytes ein ACK und beim letzten Byte wird
 dann ein NACK gesendet.

 In beiden Fällen wird STOP vom MASTER generiert, da der Slave gar nicht
 wissen kann wieviele Bytes gelesen bzw. geschrieben werden.