Externes EEPROM am PIC16F877A Codeproblem

[Enrock]

Servus Michael,

vielen Dank für die Hilfe. Ich bin leider immer noch nicht weiter mit dem Problem. Also ich habe die Pegel nachgemessen und die Datenleitung ist dauerhaft auf LOW gezogen... Habe bisher leider keine Idee wo da der Fehler liegt.
Trotzdem Danke!

Gruß Daniel

[Enrock]

Guten Morgen,

also ich habe gerade eine heiße Konstruktion entworfen um mir die Pins RC3+RC4 vom Kontroller abzugreifen. Und siehe da, das Schreiben auf den EEPROM funktioniert.
Ich weiß jetzt nicht ob ich mich freuen soll, da das nun bedeutet, dass ein Bauteil auf meinem Board kaputt ist.
Ich benutze das PICDEM 2 Plus Board... tja und irgendwas zieht den Pegel von RC4 auf Low. Hat jemand dasselbe Board und könnte mal die Pegel an U5 dem Temperaturfühler messen. Also an der Datenleitung.
Ich nehme nicht an, dass der Fehler am EEPROM liegt, da diese auf meiner Zusatzplatine funktioniert.

Danke
Gruß Daniel

[marcemich]

Hi, Hier mal der code, den ich mit dem 24AA1025 verwendet habe:

	#define	ADR_EEPROM1_TX		b'10100000'		
	#define	ADR_EEPROM1_RX		b'10100001'






eeprom Lesen

DATEN_LESEN_B2
;			bcf	INTCON,GIE
			call	I2C_WAIT_EEPROM_NOT_BUSY_B2				; Weiter, wenn eeprom nicht busy
			call	I2C_ON_B2
			movlw	ADR_EEPROM1_TX						; EEPROM zum Schreiben Adressieren
			call	I2C_TX_B2
			movfw	EEPROM_ADR_HBYTE					; Speicheradresse Senden
			call	I2C_TX_B2
			movfw	EEPROM_ADR_LBYTE
			call	I2C_TX_B2 


			call	I2C_RESTART_B2						; Restart
			movlw	ADR_EEPROM1_RX						; EEPROM zum Lesen Adressieren
			call	I2C_TX_B2
	
			call	I2C_RX_B2							; Datenbyte Empfangen	
			movfw	SSPBUF								; speichern
			movwf	STARTBYTE;1
			call	I2C_ACK_B2							; ACK Senden

.
.hier lese ich eigentlich noch ca.30 weitere bytes ein
.
.

			call	I2C_RX_B2							; Datenbyte Empfangen	
			movfw	SSPBUF								; speichern
			movwf	KRAFT_BCD_Z;32
			call	I2C_ACK_B2							; ACK Senden			
			call	I2C_RX_B2							; Datenbyte Empfangen	
			movfw	SSPBUF								; speichern
			movwf	KRAFT_BCD_E;33
			call	I2C_NACK_B2							; NOT- ACK Senden
			call	I2C_OFF_B2							; Bus freigeben
			
			return							
;**********************************************************************************************************




; eeprom beschreiben


;Datensatz Speichern
			call	I2C_WAIT_EEPROM_NOT_BUSY_B2			; Weiter, wenn eeprom nicht busy			
			call	I2C_ON_B2
			movlw	ADR_EEPROM1_TX						; EEPROM zum Schreiben Adressieren
			call	I2C_TX_B2
			movfw	EEPROM_ADR_HBYTE					; Speicheradresse Senden
			call	I2C_TX_B2
			movfw	EEPROM_ADR_LBYTE
			call	I2C_TX_B2					;datensatz senden

			
			movfw	DATUM_BCD_Z
			call	I2C_TX_B2
			movfw	DATUM_BCD_E
			call	I2C_TX_B2
			movfw	MONAT_BCD_Z
			call	I2C_TX_B2
			movfw	MONAT_BCD_E
			call	I2C_TX_B2
			movfw	JAHR_BCD_Z
			call	I2C_TX_B2
			movfw	JAHR_BCD_E
			call	I2C_TX_B2
.
.
.
.			
	
						
			movfw	KRAFT_BCD_ZT
			call	I2C_TX_B2		
			movfw	KRAFT_BCD_T
			call	I2C_TX_B2		
			movfw	KRAFT_BCD_H
			call	I2C_TX_B2		
			movfw	KRAFT_BCD_Z
			call	I2C_TX_B2		
			movfw	KRAFT_BCD_E
			call	I2C_TX_B2		
			call	I2C_OFF_B2							; Busfreigabe
			call	I2C_WAIT_EEPROM_NOT_BUSY_B2			; Warten, bis speichervorgang abgeschlossen ist
	return						
;**********************************************************************************************************


;**********************************************************************************************************
; I2C Unterprogramme
;
; I2C Bus im Master Mode Übernehmen
I2C_ON_B2
			bcf		PIR1, SSPIF					; Interrupt flag löschen
			bsf		STATUS, RP0
			bsf		SSPCON2, SEN					; Bus übernahme anweisen
			bcf		STATUS, RP0
			goto	I2C_WARTE_B2
; I2C Bus Restart
I2C_RESTART_B2
			bcf		PIR1, SSPIF					; Interrupt flag löschen
			bsf		STATUS, RP0
			bsf		SSPCON2, RSEN					; Bus Restart anweisen
			bcf		STATUS, RP0
			goto	I2C_WARTE_B2
; ein Byte aus W senden 
I2C_TX_B2 
			movwf	SSPBUF							; -> zum I2C-Slave übertragen 
			goto	I2C_WARTE_B2

;ein Byte vom Slave empfangen (nach SSPBUF) 
I2C_RX_B2 
			bsf		STATUS, RP0 
			bsf		SSPCON2, RCEN					; Daten Empfang einschalten 
			bcf		STATUS, RP0 
			goto	I2C_WARTE_B2 


; Warte, bis eeprom nicht busy
I2C_WAIT_EEPROM_NOT_BUSY_B2
			bcf		STATUS,RP0	
	
		
			call	I2C_RESTART_B2
			movlw	ADR_EEPROM1_TX			
			call	I2C_TX_B2
			bsf		STATUS,RP0
			btfsc	SSPCON2,ACKSTAT						; Wenn ACK empfangen: BEENDEN
			goto	I2C_WAIT_EEPROM_NOT_BUSY_B2
			bcf		STATUS,RP0	
			call	I2C_OFF_B2
			nop
			nop
			nop
			nop
			return
;ein Byte vom Slave empfangen (nach SSPBUF) 
I2C_ACK_B2 
			bsf		STATUS, RP0 
			bcf		SSPCON2, ACKDT
			bsf		SSPCON2, ACKEN						; ACK senden
			bcf		STATUS, RP0 
			goto	I2C_WARTE_B2 
;ein Byte vom Slave empfangen (nach SSPBUF) 
I2C_NACK_B2 
			bsf		STATUS, RP0 
			bsf		SSPCON2, ACKDT						; NOTACK senden 
			bsf		SSPCON2, ACKEN
I2C_NACK1_B2
			btfsc	SSPSTAT,R_W
			goto	I2C_NACK1_B2
			bcf		STATUS, RP0 
			goto	I2C_WARTE_B2 
; I2C-Bus wieder freigeben 
I2C_OFF_B2 
			bsf		STATUS, RP0 
			bsf		SSPCON2, PEN						; Bus Freigabe anweisen 
			bcf		STATUS, RP0 

I2C_WARTE_B2 
			btfss	PIR1, SSPIF							; SSPIF == 1 ? 
			goto	I2C_WARTE_B2							; nein->sprung
			bcf		PIR1, SSPIF						; SSPIF =0 
			return 

;**********************************************************************************************************

wichtig ist, dass du beim lesen nach dem senden der Speicheradresse einen RESTART sendest das ist zwar prinzipiell das gleiche wie ein STOP gefolgt von einem START aber der zeitliche ablauf ist dabei einzuhalten. also: restart verwenden.

ausserdem verwende ich vor jedem Zugriff eine funktion, die das ACHNOWLEDGE Polling durchführt und damit sicherstellt, dass das eeprom nicht noch mit schreiben beschäftigt ist.

Ich dachte auch erst, dass mein eeprom def ist, lag aber dann doch an der ansteuerung meinerseits.... so wie das doch meistens ist...

habe auch noch ein PDF von microchip angehängt, in dem der umgang mit pic und eeprom über I2C erklärt anschaulich mit code-beispielen weklärt wird. -- doch nicht. das pdf ist mit ~650kb zu gross aber ich sende es dir per e-mail, wenn du mir deine Adresse zukommen lässt...

[Hartwig]

Hallo Marcemich,
welches Dokument genau meintest Du denn?
magst Du mir das auch zuschicken, oder vielleicht den Link dazu?
Viele Grüße,
Hartwig

[marcemich]

Hallo Hartwig,

es handelt sich bei dem Dokument um einen Microchip Vortrag zum Thema I2C. es besteht aus den Vortrags-Folien und den jeweiligen Erklärungen dazu.
Einen Link dazu habe ich nicht. ich kann es dir aber gerne senden, wenn du mir deine e-mail adresse zukommen lässt.

gruss, ME

[Enrock]

Servus,

ich kann das nur empfehlen! Nochmal danke!

Gruß

[Enrock]

Servus,

ich bräuchte noch mal Hilfe.
Und zwar beschäftige ich mich mal wieder mit dem EEPROM 24LC256. Bisher schreibe ich alle Daten einzeln, also Byteweise ins EEPROM. Nun habe ich irgendwo gelesen, dass es geschickter sei, wenn man immer die gleiche Anzahl an zu schreibenden Bytes hat, das Ganze Page-Weise zu machen.
Im Datenblatt habe ich gelesen, dass ich bis zu 64 Byte gleichzeitig übertragen kann. Bedeutet das, dass ich auch weniger also beispielsweise bloß 7 Byte übertragen kann? Oder wird immer erst die komplette Page, wenn diese mit 64 Byte voll ist, geschrieben? Falls das so ist und ich vorher den Stecker ziehe, gehen dann ja meine Daten verloren?!
Wie ist denn das mit den Pages? Ich habe absichtlich eine ungerade Zahl als Beispiel gewählt. Wenn ich nun das neunte Mal 7 Byte geschrieben habe, fehlt ja noch ein Byte um die Page voll zu machen. Wenn ich nun aber erneut die 7 Bytes sende, wird dann eine neue Page begonnen oder wie funktioniert das?
Das Auslesen kann ich ja wieder Byteweise machen oder?
Des Weiter habe ich gelesen, dass diese Schreibart weniger belastend für den EEPROM sei und die Lebensdauer verlängert. Wieso? Weil die Anzahl des Schreibzyklus geringer ist?!
Gibt es sonst noch Vor- oder Nachteile?

Danke
Gruß

[MichaelM]

Hallo,
du kannst maximal 64 Bytes auf einmal schreiben. Der Baustein hat intern ein RAM mit 64 Byte. Wenn jetzt ein Schreibbefehl kommt werden die ankommenden Bytes erstmal in das RAM geschrieben. Wenn die Datenübertragung abgeschlossen ist werden die Bytes ins EEPROM geschrieben, das dauert etwa 1 bis 10 ms. Wenn du nun immer 7 Bytes schreibst werden diese 7 Bytes immer im RAM an die gleiche Adresse gelegt (was dir eigentlich egal sein kann ...) und anschließend diese 7 Bytes ab der angegebenen Adresse ins EEPROM geschrieben. Wenn du also in deinem Schreibbefehl die Adresse 50 angibst werden die 7 Bytes zunächst im RAM an Adresse 0 bis 6 und anschließend im EEPROM an Adresse 50 bis 56 geschrieben. Wenn du nun 15 Bytes schreibst landen die eben an Adresse 0 bis 14 im RAM und 50 bis 64 im EEPROM. Für das EEPROM ist es egal ob ein oder 64 Bytes geschrieben werden, es hält etwa 100000 dieser Prozeduren aus.

Gruß,
Michael

Die Zahlen habe ich jetzt nicht nachgeprüft, ich vertraue dir voll und ganz

[Enrock]

Guten Morgen,

na das nenn ich mal ne Antwort auf meine Fragen!
Noch eine Frage...
Habe ich das richtig verstanden, dass ich mich um die Adresse im RAM nicht zu kümmen brauche? Für mich ist nur die Adressierung der EEPROM-Zellen interessant, ja?
Hm alles klar, dann ist es, wie erwartet, besser mit Blöcken zu arbeiten. Na dann leg ich gleich mal los.

Gruß und DANKE!

[MichaelM]

Hallo,
jawoll das RAM ist für dich völlig belanglos. Das einzig interessante daran ist die Größe, also wieviele Bytes man auf einmal schreiben kann.
Gruß,
Michael