Newsgroup: it.hobby.elettronica.digitale
Titolo: Compilatore PIC C Microchip

Utilizzo un PIC18F2525 e vorrei scrivere e leggere la
memoria interna EEProm visto che ne possiede 1024 byte.
Esistono delle routine in C MCC18 Microchip per questi compiti?
Grazie saluti.


#ifndef __EEPROM_H
#define __EEPROM_H
int readIntEE(unsigned char address);
void writeIntEE(unsigned char address, int dataInt);
char EEDataR(unsigned char address);
void EEDataW(unsigned char address, unsigned char data);
int readIntEE(unsigned char address){
	union INTCHAR {
		int i;
		unsigned char c[2];
	}INTCHAR;
	INTCHAR.c[0]=EEDataR(address);
	INTCHAR.c[1]=EEDataR(address+1);
	return INTCHAR.i;
}
void writeIntEE(unsigned char address, int dataInt){
	union INTCHAR {
		int i;
		unsigned char c[2];
	}INTCHAR;
	INTCHAR.i=dataInt;
	EEDataW(address, INTCHAR.c[0]);
	EEDataW((address+1), INTCHAR.c[1]);
}
float readFloatEE(unsigned char address){
	union FLOATCHAR {
		float f;
		unsigned char c[4];
	}FLOATCHAR;
	FLOATCHAR.c[0]=EEDataR(address);
	FLOATCHAR.c[1]=EEDataR(address+1);
	FLOATCHAR.c[2]=EEDataR(address+2);
	FLOATCHAR.c[3]=EEDataR(address+3);
	return FLOATCHAR.f;
}
void writeFloatEE(unsigned char address, float dataFloat){
	union FLOATCHAR {
		float f;
		unsigned char c[4];
	}FLOATCHAR;
	FLOATCHAR.f=dataFloat;
	EEDataW(address, FLOATCHAR.c[0]);
	EEDataW((address+1), FLOATCHAR.c[1]);
	EEDataW((address+2), FLOATCHAR.c[2]);
	EEDataW((address+3), FLOATCHAR.c[3]);
}
char EEDataR(unsigned char address){
	EEADR = address;
	EECON1bits.EEPGD = 0;
	EECON1bits.CFGS = 0;
	EECON1bits.RD = 1;
	return EEDATA;
}
void EEDataW(unsigned char address, unsigned char data){
	char tempIntconState;
	EEADR = address;
	EEDATA = data;
	EECON1bits.EEPGD = 0;
	EECON1bits.CFGS = 0;
	EECON1bits.WREN = 1;
	tempIntconState=INTCON;
	INTCONbits.GIE = 0;
	EECON2 = 0x55;
	EECON2 = 0xAA;
	EECON1bits.WR = 1;
	while (EECON1bits.WR);
	EECON1bits.WREN=0;
	INTCON=tempIntconState;
}
#endif

 ha scritto nel messaggio 
news:ad9d61f0-4cc2-49db...@m3g2000hsc.googlegroups.com...


 	}INTCHAR;
Qui e dopo: non è bene usare le union in questo modo, non sono pensate 
per fare queste cose, potresti incappare in bug di ottimizzazione del 
compilatore.
Oltre a questo c'è un approccio che non mi piace molto: per ogni tipo 
che vuoi leggere/scrivere hai fatto una funzione apposita. E se ti 
capita di salvare un tipo diverso? Ogni volta aggiungi la coppia di 
lettura/scrittura per il nuovo tipo? Non è molto efficiente.
Di solito si procede in un altro modo, creando 2 sole funzioni (lo 
faccio per la scrittura, per la lettura è uguale).
Ammesso di avere la EEDataW che scrive un carattare, poi ti basta
questa:
void EEDataWBuf(unsigned char address, const void* _buf, size_t len)
{
	const unsigned char *buf = (const unsigned char *)_buf;
	while (len--)
		EEDataW(address++, *buf++);	
}
E con questa scrivi tutto quello che vuoi.
Es. se 'f' è un float, la chiami in questo modo:
EEDataWBuf(address, &f, sizeof(f));
Ciao
-- 
  _|/ Francesco Sacchi - Develer S.r.l., R&D dept.
   |\ 
http://www.develer.com/
 - 
http://www.bertos.org

 }
Per tutti i frequentatori del NG: non sono un granchè come firmwarista, 
ma so riconoscere un maestro! Quest'uomo è da tenere in grande 
considerazione :-) 
Più vi sembra ovvio, allora più io sono un firmwarista d'acqua 
dolce :-) :-) 

 dolce :-) :-) 
Sei in buona compagnia, tranquillo :)
Marco / iw2nzm

Ho eseguito delle prove con il codice proposto da Francesco Sacchi
ma ho dei dubbi sui parametri e poi sui dati scritti sulla EEProm.
Alcuni parametri non sono definiti come tipo.
Poi non ho ben capito cosa fanno dei parametri della funzione EEDataWBuff:
unsigned char address: Ok è l'indirizzo dove andare a scrivere.
const void* _buf:       Cosa serve?.
size_t:  Manca il tipo. Cosa serve?
len: Manca il tipo.      Cosa serve?
Ho provato cosi:
//...Ciclo principale......................................
EEDataWBuf(10,5,0,0); Chiamata.
 ciclo:
  goto ciclo;
 }
//*****************************************************************
//Questo codice non è accettato perchè a   (size_t) e (len) manca il tipo,
segnala errore!
//*****************************************************************
void EEDataWBuf(unsigned char address, const void* _buf, size_t len)
{
       const unsigned char *buf = (const unsigned char *)_buf;
       while (len--)
       EEDataW(address++, *buf++);
}
//*****************************************************************
//HO DEFINITO (int_size) E (len) COME  int.
//COSI IL CODICE  VIENE COMPILATO PERO'
//SCRIVE nella EEProm delle COSE ASSURDE.
//--------------------------------------------------------- 
void EEDataWBuf(unsigned char address, const void* _buf, int size_t, int
len)
{
       const unsigned char *buf = (const unsigned char *)_buf;
       while (len--)
       EEDataW(address++, *buf++);
}
//---------------------------------------------------------
void EEDataW(unsigned char address, unsigned char data)
{
       char tempIntconState;
       EEADR= address;
       EEDATA = data;
       EECON1bits.EEPGD=0;
       EECON1bits.CFGS =0;
       EECON1bits.WREN = 1;
       tempIntconState=INTCON;
       INTCONbits.GIE=0;
       EECON2 =0x55;
       EECON2 = 0xAA;
       EECON1bits.WR = 1;
       while (EECON1bits.WR);
       EECON1bits.WREN = 0;
       INTCON =tempIntconState;
}
Grazie per l'aiuto.
Saluti.

 len: Manca il tipo.      Cosa serve?
size_t *è* il tipo di len. Di solito i compilatori ANSI lo definiscono 
nel file stddef.h.
E' un tipo che serve per specificare lunghezze di aree di memoria.
La variabile 'len' specifica la lunghezza dei dati da scrivere in EEPROM.
Se il tuo compilatore non fornisce size_t, sostituiscilo con il tipo 
base senza segno sufficiente ad indirizzare tutta la memoria per la 
tua piattaforma (suppongo unsigned int).
I parametri devono essere solo 3: addr, buf e len.
