Hallo Leute! Ich habe eine Kurze frage. Ich möchte mittels I2C auf ein EEProm schreiben. Muss ich jedes mal eine Adresse angeben wenn ich das EEProm anspreche oder hat das Teil einen zähler der hochzählt? Wie teile ich dem Ding aber eine 16 Bit Adresse mit? Mache das im Assembler und habe einen PIC mit i2c! LG Blackpuma
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.
In der Regel hat man die Möglichkeit einen größeren Block zu schreiben. Also mehrere Bytes mit einem Befehl. Dann gibt es auch noch die Möglichkeit ohne vorher angegebene Adresse zu schreiben. Dann nimmt er einfach den aktuellen "Pointer" und erhöt ihn um eins.
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.
Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.