-         
Seite 2 von 2 ErsteErste 12
Ergebnis 11 bis 20 von 20

Thema: Externes EEPROM am PIC16F877A Codeproblem

  1. #11
    Erfahrener Benutzer Fleißiges Mitglied
    Registriert seit
    19.11.2007
    Alter
    37
    Beiträge
    140
    Anzeige

    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

  2. #12
    Erfahrener Benutzer Fleißiges Mitglied
    Registriert seit
    19.11.2007
    Alter
    37
    Beiträge
    140
    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

  3. #13
    Neuer Benutzer Öfters hier
    Registriert seit
    12.01.2008
    Ort
    Bensheim
    Alter
    40
    Beiträge
    12
    Hi, Hier mal der code, den ich mit dem 24AA1025 verwendet habe:


    Code:
    	#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...
    *** Theorie und Praxis - Zwei Welten prallen aufeinander... ***

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

  5. #15
    Neuer Benutzer Öfters hier
    Registriert seit
    12.01.2008
    Ort
    Bensheim
    Alter
    40
    Beiträge
    12
    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
    *** Theorie und Praxis - Zwei Welten prallen aufeinander... ***

  6. #16
    Erfahrener Benutzer Fleißiges Mitglied
    Registriert seit
    19.11.2007
    Alter
    37
    Beiträge
    140
    Servus,

    ich kann das nur empfehlen! Nochmal danke!

    Gruß

  7. #17
    Erfahrener Benutzer Fleißiges Mitglied
    Registriert seit
    19.11.2007
    Alter
    37
    Beiträge
    140
    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ß

  8. #18
    Erfahrener Benutzer Fleißiges Mitglied
    Registriert seit
    26.05.2007
    Beiträge
    193
    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

  9. #19
    Erfahrener Benutzer Fleißiges Mitglied
    Registriert seit
    19.11.2007
    Alter
    37
    Beiträge
    140
    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!

  10. #20
    Erfahrener Benutzer Fleißiges Mitglied
    Registriert seit
    26.05.2007
    Beiträge
    193
    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

Seite 2 von 2 ErsteErste 12

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •