I2C Schreiben und Lesen

Kommt auf "das Ding" an...

Auf welches Ding kommt es an????

I2C sollte doch überall gleich sein. Ich habe ein EEPROM von Microchip. 
Muss erst schaun was für eines.

I²C ist nur das Busprotokoll, wie der Chip was bewertet steht...
...im Datenblatt.

Also das EEPROM ist ein 24128 von Microchip. Steht das auch im 
Datenblatt ob das Teil den Pointer automatisch um 1 erhöht?

Heißt das ich kann es beim ersten mal auf die Adresse 0 setzten und dann 
brauch ich nur mehr hineinschreiben und der pointer wird immer um eines 
erhöht sodas er immer eine neue speicheradresse nimmt bis das teil voll 
ist?

@ Andreas Riegebauer (blackpuma)

>Also das EEPROM ist ein 24128 von Microchip. Steht das auch im
>Datenblatt ob das Teil den Pointer automatisch um 1 erhöht?

Sicher.

>Heißt das ich kann es beim ersten mal auf die Adresse 0 setzten und dann
>brauch ich nur mehr hineinschreiben und der pointer wird immer um eines
>erhöht sodas er immer eine neue speicheradresse nimmt bis das teil voll
>ist?

Nein. So ein EEPROM hat sog. Pages, Speicherseiten, die je nacht Typ 
8....ganz viele Bytes langs sind. Der Pointer wird nur inerhalb einer 
Page erhöht, läuft er darüber hinaus fängt er am Anfang der Page wieder 
an. Steht alles im Datenblatt.

MFG
Falk

So. Hab mich mal durch das Datenblatt gewühlt.

Der Counter wird immerhalb der Page um 1 erhöht. Wenn er voll ist fängt 
er wieder bei 0 an. OK

Wie das Teil die Adresse haben will is auch klar:
Kontrollbyte_Adress.high_Adress.low_datenbyte


Wie kann ich das Brauchbar realisieren?
2 byte im Prozessor in dem die Adresse steht. Nach jedem Schreiben wird 
das um 1 erhöht und diese Adressbytes dann immer mitschicken?

LG
Andreas

@ Andreas Riegebauer (blackpuma)

>Wie kann ich das Brauchbar realisieren?
>2 byte im Prozessor in dem die Adresse steht. Nach jedem Schreiben wird
>das um 1 erhöht und diese Adressbytes dann immer mitschicken?

???
Du hast es doch gerade ricgtig gesagt. Innerhalb einer Seite schickst du 
EINMAL die Adresse, dann N Bytes, der Zähler wird automatisch 
hochgezählt. Wenn du mehr als eine Page schreiben willst musst du eine 
neue Adresse schicken und das Gleiche nochmal.

MfG
Falk

Falk Brunner wrote:

> hochgezählt. Wenn du mehr als eine Page schreiben willst musst du eine
> neue Adresse schicken und das Gleiche nochmal.


Du mußt nach dem letzten Byte einer Page vor allem erstmal ein Stop 
schicken, damit das Schreiben überhaupt veranlaßt wird.

Und dann entweder die maximale Zeit warten oder den Chip solange 
adressieren, bis er sich nicht mehr tot stellt (kein NACK).


Peter

Wenn ich möchte das gesamte EEPROM vollschreiben. Ich starte bei Adresse 
0 und dann inkrementiere ich die Adresse. Wenn ich nur 256 
Speicherstellen beschreiben will wird das kein Problem sein. Wenn ich 
nun aber die 257 stelle beschreiben will wie mache ich das am besten?

1

while(1)

2

{

3

   adresse++;    // bis 256 kein Problem dann fängts ja wieder bei 0 an.

4

   schreibe_i2c(zeichen);

5

}

Wie kann ich das am einfachsten lösen?

Danke
Andreas

Hab mal was geschrieben. Vielleicht könnt ihr mir sagen ob das so passt 
das ich von Adresse 0 bis 65k das gesamte eeprom vollschreibe.

Weiß auch nicht ob das mit der Globalen Var so passt. Brauche das 
anscheinend das ich sie für den Anfang auf 0 setzten kann.

Compiler ist cc5x.

1

uns16 address = 0;    // Weiß nicht ob das so funktioniert. Globale Var??

2

3

// **************************************************************************************

4

// eeprom_rs232: Schreibt den gemessenen Wert in das EEPROM. (ADRESH, ADRESL)

5

// **************************************************************************************

6

7

void eeprom_rs232()

8

{

9

  int high, low;

10

11

  address++;

12

  high = address.high8;

13

  low  = address.low8;

14

15

  bstart();          // Start Bedingung

16

  schreib(160);      // Bauteiladresse senden (zum schreiben)

17

  schreib(high);     // Höhere Adresse Übertragen (0..127)

18

  schreib(low);      // Niedrigere Adresse Übertragen (0..255)

19

  schreib(ADRESH);   // Schreibe das Zeichen

20

  bstop();           // Stop Bedingung

21

22

  address++;

23

  high = address.high8;

24

  low  = address.low8;

25

26

  bstart();          // Start Bedingung

27

  schreib(160);      // Bauteiladresse senden (zum schreiben)

28

  schreib(high);     // Höhere Adresse Übertragen (0..127)

29

  schreib(low);      // Niedrigere Adresse Übertragen (0..255)

30

  schreib(ADRESL);   // Schreibe das Zeichen

31

  bstop();           // Stop Bedingung

32

33

} //eeprom_rs232

34

35

// **************************************************************************************

36

// main: Hauptprogrammm. 

37

// **************************************************************************************

38

39

void main()

40

{

41

  init();

42

43

  while (1) {        // Endlosschleife

44

45

  pause(1000);       // 1 Sekunde Pause

46

47

  adc();             // AD Wert Messen

48

49

  eeprom_rs232();      // Sende Messwert an eeprom

50

51

  } //while

52

} //main

Danke
Andreas

Datum: 01.08.2007 14:27
Datum: 04.08.2008 09:18

Das hat ja lange gedauert, 1 Jahr für so eine Funktion? :P

Spass bei Seite, passt vom Grundprinzip, ob deine Funktionen so 
funktionieren, musst du feststellen. Ich habe übrigens den gleichen 
EEPROM verwendet, finde das Ding zu Kotzen langsam. Es gibt auch I2C/SPI 
Flash Bausteine mit 16 und mehr MBits die sich viel schneller 
beschreiben lassen.

Ich brauch das nicht so schnell. Ich möchte einen Drucksensor Messen 10 
od. 100 mal pro Sekunde und für das sollte es schon schnell genug sein. 
Die I2C Funktion ist auch eine Softwarelösung. Die funktioniert 
allerdings schon.

Bei SPI finde ich das blöd mit dem CS. Das ist bei I2C besser gelöst 
finde ich.

>Ich möchte einen Drucksensor Messen 10 od. 100 mal pro Sekunde und für
>das sollte es schon schnell genug sein.
Das das EEPROM irgendwann kaputt geht wen du zu oft schreibst ist dir 
klar?
Für höhere Schreibgeschwindigkeit und längere Lebensdauer wäre evt. ein 
FRAM interessant. Gibt's als 1:1 ersatz für I²C EEPROMs.

Is mir klar das es nach 100k mal schreiben kaputt sein kann. es zeichnet 
die daten nur auf beim flug. und das wird max. 10 mal sein.

Wie ist das beim FRAM? wenn da die spannung weg ist sind aber auch die 
daten weg oder?

>wenn da die spannung weg ist sind aber auch die daten weg oder?
Nein, die bleiben erhalten.

Da die FRAMs die Daten auch sofort nach erhalt schreiben gibt's da auch 
keine Pages auf die man achten müsste. Du kannst das Ding einfach von 
vorn bis hinten am Stück vollschreiben.