next topic »

[on:]

Ciao a tutti , visto che l'attiny 45 non ha l'eeprom ho dovuto ,per una mia applicazione , aggiungerla esternamente , la scelta é ricaduta sulle 24c02 - 04 - 08 , soon EEPROM i2c per cui utilizzo la libreria i2c per attiny In versione master http://arduino.cc/playground/Code/USIi2c
E il seguente codice per scrivere sulla eeprom

Code:

  void i2c_eeprom_write_byte( int deviceaddress, unsigned int eeaddress, byte data ) {
    int rdata = data;
    TinyWireM.beginTransmission(deviceaddress);
    TinyWireM.send((int)(eeaddress >> 8)); // MSB
    TinyWireM.send((int)(eeaddress & 0xFF)); // LSB
    TinyWireM.send(rdata);
    TinyWireM.endTransmission();
  }

  // WARNING: address is a page address, 6-bit end will wrap around
  // also, data can be maximum of about 30 bytes, because the Wire library has a buffer of 32 bytes
  void i2c_eeprom_write_page( int deviceaddress, unsigned int eeaddresspage, byte* data, byte length ) {
    TinyWireM.beginTransmission(deviceaddress);
    TinyWireM.send((int)(eeaddresspage >> 8)); // MSB
    TinyWireM.send((int)(eeaddresspage & 0xFF)); // LSB
    byte c;
    for ( c = 0; c < length; c++)
      TinyWireM.send(data[c]);
    TinyWireM.endTransmission();
  }

Modificato da http://arduino.cc/playground/Code/I2CEEPROM
Per leggere i dati dalla eeprom stó utilizzando ic prog http://www.ic-prog.com/
Ho fatto diversi tentativi , sia utilizzando write byte che write page ma riesco a scrivere solo sulla prima riga , ( address 0x0000 - 0x0008) tutte le altre sembrano inaccessibili , ho provato a passare alla funzione valori decimali , esadecimali e binari ma sempre con lo stesso risultato , inoltre molto spesso i dati registrati non sono gli stessi che io desidero , come posso fare?
Ringrazio in anticipo per l'aiuto
Ciao Niko

[Reply #1 on:]

Il 24c02 ha pagine di 16 Byte; http://datasheet.sii-ic.com/en/serial_eeprom/S24C01C_02C_E.pdf
Il datasheet della Atmel dice che il
24c02 ha pagine da 8Byte e i
24c04 / 24c08 hanno pagine da 16Byte
http://www.atmel.com/Images/doc0180.pdf

Non so cosa é giusto per il Tuo EEprom 24c02. Puoi usare un page write di 8 Byte o provare di scrivere 16 byte tutti differenti al indirizzo 0 e leggere cosa é stato memorizzato. Se scrivi 0 0 0 0 0 0 0 0 8 8 8 8 8 8 8 8 e Ti ritrovi con 8 nella cella 0 devi usare page write a 8 Byte.

Se il 24c04 é della Atmel de viusare l' indirizzo I2C per selezionare il blocco della memoria che vuoi indirizzare:

Device Addressing The 1K, 2K, 4K, 8K and 16K EEPROM devices all require an 8-bit device address word
following a start condition to enable the chip for a read or write operation (refer to Figure
7).
The device address word consists of a mandatory one, zero sequence for the first four
most significant bits as shown. This is common to all the EEPROM devices.
The next 3 bits are the A2, A1 and A0 device address bits for the 1K/2K EEPROM.
These 3 bits must compare to their corresponding hard-wired input pins.
The 4K EEPROM only uses the A2 and A1 device address bits with the third bit being a
memory page address bit. The two device address bits must compare to their corresponding
hard-wired input pins. The A0 pin is no connect.
The 8K EEPROM only uses the A2 device address bit with the next 2 bits being for
memory page addressing. The A2 bit must compare to its corresponding hard-wired
input pin. The A1 and A0 pins are no connect.
The 16K does not use any device address bits but instead the 3 bits are used for memory
page addressing. These page addressing bits on the 4K, 8K and 16K devices
should be considered the most significant bits of the data word address which follows.
The A0, A1 and A2 pins are no connect.

L' indirizzo mandato nel comando I2C non sono 2 byte come scrivi Tu nello sketch ma solo 1Byte insieme a seconda della grandezza del EEprom a alcuni byte del indirizzo I2C (vedi sopra)


Per fare un Page write devi:
1) iniziare col indirizzo di partenza a multipli di 8 o rispettivamente 16
2) trasferire 8 o rispettivamente 16 byte di dati.

Se non rispetti l' indirizzo a multipli della grandeza della pagina i dati sopra la grandezza della pagina vengono non scritti sulla pagina sucessiva ma all indirizzo della stessa pagina.

Esempi:
Usi un 24c02: se vuoi scrivere dati sulla seconda pagina:
indirizzo da 0x08 a 0x0f
8 Byte di dati che vengono scritti nelle memorie da 0x08 a 0x0f

Se per esempio parti dal indirizzo 0x0a i 8 byte di dati verranno scritto nelle celle
0x0a a 0x0f e i restanti da 0x08 a 0x09.

puoi comunque iniziare in mezzo an una pagina e scriver dati fine alla fine di quella pagina.
nel precedente esempio sarebbe:
indirrizzo 0x0a e 6 byte di dati che saranno memorizzati nelle celle 0x0a a 0x0f.

Ciao Uwe

[Reply #2 on:]

Grazie uwe per le delucidazioni , ho testato ora il solito codice tenendo conto del nuovo indirizzamento , credo peró che il fatto di aver adattato un codice per una i2c hardware ad una porta puramente software possa causare dei problemi , che ne pensi? Inoltre ciò potrebbe causare dei problemi a causa del minor numero di byte di buffer disponibili per l'i2c dell'attiny rispetto all'atmega?
Inoltre non sono molto esperto in comunicazione byte by byte ma i dati non dovrebbero essere compresi fra msb e lsb invece che seguire lsb?
Ciao Niko

[Reply #3 on:]

Non so aiutarti nella implementazione della emulazione della porta I2C sul ATtiny.
Leo potrebbe rispionderti.
Ciao Uwe

[Reply #4 on:]

Io ho usato la TinyWire modificata (se vedi la mia guida).
Effettivamente ha un buffer software ma non credo rappresenti un grosso problema a meno che la velocità di trasmissione sia superiore a quella di gestione dei dati o gli stessi siano in quantità elevata. Comunque puoi aumentarla: c'è un define nell'header. Mi pare che di default sia a 16 byte .

[Reply #5 on:]

leo ha risposto   
Ciao Uwe

[Reply #6 on:]

Grazie Leo , la modifica l'ho fatta seguendo la tua guida , complimenti 
Per quanto riguarda la trasmissione dei byte msb e lsb , nel mio codice precedente erano trasmessi nel giusto ordine ? Il buffer é  byte 16 , infatti se scrivo piú di 14 byte non funziona piú niente ( 2 byte sono usati dalla libreria giusto?)
Ciao Niko

[Reply #7 on:]

Se il programma non è avido in risorse (ossia non hai molte variabili), prova aumentando il buffer a 32 byte. I 2 byte dovrebbero essere per l'indirizzo del dispositivo e per il comando da spedire.