Problema CCS eeprom EXT

Stai scherzando vero?

Hai postato un listato del tipo

Inizia(); Fai_quello_che_devi_fare(); Finisci();

Come puoi sperare che qualcuno ti possa aiutare? Non hai neanche specificato il modello di PIC.

Cosa vuol dire la scrittura funziona? Come fai a verificarlo? Che siamo tutti indovini qui? Perchè le funzioni scrivi e leggi sono scritte in maiuscolo? Sei sicuro che quel codice venga compilato? Cosa vuol dire uso le librerie CCS in MPLAB? Come hai fatto ad importarle?

Io di solito i problemi con librerie scritte da altri (soprattutto se è roba che ha a che fare coi PIC) li risolvo riscrivendomi a manina il tutto. Ho imparato così a risparmiare tempo e fegato.

Buona fortuna.

Pasu

Me ne sono dimenticato uso un 16F877A, la eeprom è una 24LC256, il tutto è montato sulla PICDEM PLUS quindi escludiamo problemi hardware....

Infatti ho scritto "Facendo il debug però vedo che la scrittura SEMBRA avvenire senza problemi..."

Ho fatto copia/incolla da un programma di esempio della guida del CCS, non è comunque quello il problema perchè eseguendo il programma passo a passo le funzioni vengono richiamate senza problemi...

Il compilatore da ERRORE se non lo compila di solito no???

Importarle??? Mi sa che o io non mi sono spiegato per niente oppure tu non conosci MPLAB e CCS... MPLAB supporta vari compilatori esterni tra qui CCS quindi al momento della compilazione è come se tu lanciassi il compilatore da riga di comando soltando che il tutto viene fatto automaticamente da MPLAB.

Be con quello che costa sto compilatore spero che 2 funzioni scabeccie per la scrittura e la lettura da una EEPROM I2C le abbia giuste...

NeMeSi ha scritto:

Premetto che sono assolutamente ignorante di certi IC ma me la cavo con il C e il C++...

Immagino sia l'ultima riga che sotto debugger ti dia valletto==255 (invece di valletto==5).

Prova ad aggiungergi sotto la riga: while(1); e inserire un breakpoint su "valletto=READ_EXT_EEPROM(Ind);". Se ti ritorna valletto==5 allora il problema era che il debugger si era interrotto perche' le istruzioni erano finite.

In alternativa controlla che non esista una funzione di "rewind" della memoria... Potrebbe essere necessario rileggerla da capo (o a segmenti). Oltre non so' aiutarti perche' non le conosco le librerie CCS.

@Pasu: le parole chiave in maiuscolo sono di solito delle macro, per cui e' sintatticamente corretto.

Saluti, fapo

Esatto

Ho gia provato a fare un ciclo infinito con while(1) mettendo anche una pausa prima del re-inizio del ciclo ma niente, non controllo solamente valletto che mi da 255 ma anche la variabile locale della funzione READ_EXT_EEPROM data che sarebbe quella che poi viene resa con il RETURN, anche quella prende valore 255.

Non ho capito cosa intendi mi spieghi meglio?

NeMeSi ha scritto:

La funzione potrebbe accedere alla memoria in maniera sequenziale (attraverso un puntatore o un registro che incrementa), per cui la "WRITE_EXT_EEPROM(Ind,valore);" farebbe zompare il puntatore dalla posizione 0 alla 99, mentre la "READ_EXT_EEPROM(Ind);" andrebbe a finire nella posizione 198 (100+100)...

Ho trovato per caso un sorgente che mi sembra abbastanza esplicativo:

dai un'occhiata alla funzione "read_ext_eeprom()", i2cstart() potrebbe ad esempio resettare questo puntatore (o registro interno) ed e' quello che intendevo.

Saluti, fapo

Inanzitutto mille grazie perchè sono riuscito a risolvere il problema.. oltrettutto quella libreria che mi hai linkato ce l'ho anche io perchè è una del compilatore CCS.. Ma adesso vorrei capire la differenza tra le 2 funzioni...

Questa è quella non funzionante:

BYTE read_ext_eeprom(BYTE address) { BYTE data;

while(!ext_eeprom_ready()); i2c_start(); i2c_write(0xa0); i2c_write(address); i2c_start(); i2c_write(0xa1); data=i2c_read(0); i2c_stop(); return(data); }

E questa è quella funzionante:

BYTE read_ext_eeprom(long int address) { BYTE data; i2c_start(); i2c_write(0xa0); i2c_write(address>>8); i2c_write(address); i2c_start(); i2c_write(0xa1); data=i2c_read(0); i2c_stop(); return(data); }

Se non capisco male il problema è che io indirizzavo a 8bit mentre invece l'indirizzo era da dare a 16bit e la funzione i2c_write(address>>8); spedisce prima meno significativi e poi con i2c_write(address); vengono mandati i più significativi giusto?

NeMeSi ha scritto:

Esattamente, la prima era probabilmente destinata ai chip a 8 bit e la seconda a 16 bit.

IMHO bisogna controllare se il preprocessore abbia i parametri a posto: secondo me manca una macro per indicare al linker che READ_EXT_EEPROM() debba puntare alla funzione a 16 bit, invece che a quella per gli 8 bit.

Saluti, fapo

e' esattamente il contrario

i2c_write(address>>8) trasmette gli 8 bit PIU' significativi dell'indirizzo ( a 16 bit ) della cella di memoria della EEPROM

i2c_write(address>>8) trasmette gli 8 bit MENO significativi dell'indirizzo

questo sempre che il prototipo della i2c_write sia di questo tipo:

i2c_write(BYTE);

come ragionevolmente e'

per accedere ad una 24256 bisogna trasmettere 3 byte:

I ) byte di selezione della EEPROM ( indirizzo sul bus + selezione lettura/scrittura)

II ) MSB dell'indirizzo della cella

III ) LSB dell'indirizzo della cella

a seguire si puo' realmente scrivere la cella.

per la lettura bisogna prima selezionare la cella con un "dummy write" e poi si possono eseguire le letture anche consecutive su piu' indirizzi.

consiglio caldamente la lettura di un datasheet dell'integrato dove questi fatti sono spiegati con dovizia di particolari

uhm.. ma sei sicuro che quella funzione sia per il bus i2c?? IMHO è per eprom su bus parallelo! Ecco uno stralcio di codice commentato con il quale leggo un sensore di temperatura i2c:

//------------------------------------------------------------------------------ // la lettura IC2 funziona in questo modo: // lancio il comando I2C_start e subito dopo mando sul bus un byte con // l'indirizzo della periferica con cui voglio comunicare; lo standard // prevede indirizzi di 7 bit quindi il bit numero 8 (il meno significativo) // viene usato per specificare alla periferica se intendiamo leggere o // scrivere su di essa.

// esempio (fo una lettura sulla periferica)

----------------------------------- i2c_start(); i2c_write(0b10011011); // l'indirizzo standard del TC74 è 1001101. L'ultimo bit è 1 in quanto mi accingo a leggere temperatura = i2c_read(0); // leggo e salvo il dato sulla periferica; lo "0" indica che dopo non eseguirò altre letture i2c_stop(); // fine sessione; rilascio il bus I2C // --------------------------------

Nel tuo caso immagino sia necessario fare piu scritture: la prima per indicare l'indirizzo della eprom e specificare che vuoi scriverla, la seconda per specificare l'indirizzo da scrivere e la terza con il byte da mandare.. nel datasheet della eprom dovrebbe essere descritto accuratamente il sistema.

Non ci avevo pensato. Ora ha tutto molto più senso.

Grazie

P.