[paulfjujo]

bonsoir,


J'ai deja utilisér une 24LC256, mais je bloque avec l'Eeprom 24C32 située sur le module RTC ( que je n'avais jamais testée!)
La presence device voit bien l'eeprom en @ 0x57 ( pas de ponts sur les 3 pins A0,A1,A2 de l'eeprom)
La RTC et Le LCD ( via PCF8754) sont OK sur le bus I2C1 Hardware RC3 ,RC4
mais le rien à faire avec la 24C32 .. soit je n'obtiens que de 0XFF = Vierge, soit le programme plante !

On est encore avec cet I2C special 18FxxK42 !

24C32_18F27K42_XC8_Problemo_2023-0925.jpg

_18F27K42_Test_I2C_24C32_2023.zip

[satinas]

Bonsoir,
L'eeprom 2432 comporte 4096 octets, il faut envoyer une adresse data 16 bits, high byte en premier.

Essaye de faire : I2C1_WriteNBytes(addr7, tmp, 8);
avec dans tmp -> addr_data_h, addr_data_l, et 6 octets data

Et vérifie à l'oscillo que la trame I2C est correcte, je reste sur la remarque de l'autre fois, utiliser I2C1CNT comme indice de boucle est à manipuler avec précaution car c'est le pic qui le décrémente.

[paulfjujo]

bonsoir Satinas,


Pas moyen de moyenner en lecture 24C32 !

En test presence device sur le bus , l'eeprom repond bien à 0x57 sur 7 bits
0x57 <<1 => 0xAE en 8 bits

L'ecriture me parait OK (test avec SQA analyser)
j'ecris 1,2,3,4,5,6 en asccii + zero

mais rien en lecture ....
il faut bien ecrire d'abord l'adresse à atteindre dans la 24C32 sur 16 bits ( 2 bytes) avec Adresse device 8 bits ici=0xAE
puis passer en lecture ( adresse device 8b =0xAE+1= 0xAF
pour lire les datas !

ecriture_24C32_adresse_16bits_et_datas.jpg

_18F27K42_Test_I2C_24C32_2023-1011.zip

[satinas]

Bonjour Paul,

Oui, la lecture de l'eeprom est plus compliquée car elle se fait en 2 temps, d'abord on écrit l'adresse data, ensuite un Start ou Restart pour lire en continu l'eeprom. L'oscillo peut te dire là où ça capote.
Pour l'écriture, il faut surveiller l'adresse data et si l'on atteint une fin de page eeprom, lancer le cycle d'écriture et attendre. Je le fais dans ce fichier source C voir fonction I2c2EepromWriteBuffer().

Sur le 18F27K42, voilà ce que j'avais fait l'autre fois. Ca tournait, mais en remplaçant l'indice (n--) par (I2C1CNT), une des 2 fonctions ne marchait plus.

Code : Tout sélectionner

//------------------------------------------------------------------------------
void I2cWrite_16(unsigned char addr7, unsigned int addr_data, unsigned char* b, unsigned char n)
//------------------------------------------------------------------------------
{
  while (!I2C1STAT0bits.BFRE) { }       // attente bus libre
  I2C1ADB1 = (unsigned char)(addr7<<1); // adresse chip + W
  I2C1CNT = 2+n;                        // taille envoi adresse data + n data
  I2C1TXB = addr_data>>8;
  I2C1CON0bits.S = 1;                   // envoi Start, adresse chip+W, adresse high data
  while (!I2C1STAT1bits.TXBE) { }
  I2C1TXB = (unsigned char)addr_data;   // envoi adresse low data
  while (n--) {
    while (!I2C1STAT1bits.TXBE) { }
    I2C1TXB = *b++;                     // envoi n data, Stop
  }
}

//------------------------------------------------------------------------------
void I2cRead_16(unsigned char addr7, unsigned int addr_data, unsigned char* b, unsigned char n)
//------------------------------------------------------------------------------
{
  while (!I2C1STAT0bits.BFRE) { }       // attente bus libre
  I2C1ADB1 = (unsigned char)(addr7<<1); // adresse chip + W
  I2C1CNT = 2;                          // taille envoi adresse data
  I2C1TXB = addr_data>>8;
  I2C1PIRbits.PCIF = 0;
  I2C1CON0bits.S = 1;                   // envoi Start, adresse chip+W, adresse high data
  while (!I2C1STAT1bits.TXBE) { }
  I2C1TXB = (unsigned char)addr_data;   // envoi adresse low data, Stop
  while (!I2C1PIRbits.PCIF) { }

  I2C1ADB1 += 1;                        // adresse chip + R
  I2C1CNT = n;                          // on reçoit n data
  I2C1CON0bits.S = 1;                   // envoi Start, adresse chip+R
  while (n--) {
    while (!I2C1STAT1bits.RXBF) { }
    *b++ = I2C1RXB;                     // réception n data, Stop
  }
}

[paulfjujo]

bonjour Satinas et à tous,


il semble bien que mon probleme de fond etait lié à l'usage simultané du LCD I2C (PCF8754)
Sans l'usage du LCD j'obtiens un bon resultat sur L' analyser
mais si j'ai utilisé préalablement le LCD, je retrouve 2 datas intrus dans les premieres data écrites
au lieu de '1' et '2' j'ai 0x29 et 0x00
comme par hasard j'ai aussi une data 0x29 coté LCD !

PB_ecriture_24C32_si_usage_LCD.jpg

retour sur void I2C_PCF8574_Write(unsigned char Adrp, unsigned char value)
utilisait tmp[0]et tmp[1] ...
modif en mettant une table locale tmpx
=>OK plus de probleme

Code : Tout sélectionner

void I2C_PCF8574_Write(unsigned char Adrp,unsigned char value)
{
char tmpx[3];
 tmpx[0]=value;
 tmpx[1]=0;
 I2C1_WriteNBytes(Adrp, tmpx, 1); 
  __delay_us(30);
} 


relecture eeprom :

lecture_24C32_adresse_320_Ok_avec_LCD.jpg

... il faudra que je teste par envoi de page de 32 bytes !
car sensé etre plus rapide des qu'on veut envoyer plus de 2 bytes ..

[paulfjujo]

doublon

[satinas]

I2C1_ReadDataBlock(Addr+1,2,p1,6);

C'est pas bon ça, pourquoi Addr+1 et pas Addr tout court ?

[paulfjujo]

Euh !
où est-ce que tu vois cela ?

[satinas]

dans _18F27K42_Test_I2C_24C32_2023.X\main.c

[paulfjujo]

effectivement , ça ne pouvait pas le faire !

Code : Tout sélectionner


void I2C1_ReadDataBlock(uint8_t address, uint8_t reg, uint8_t *data, uint8_t len)
{
     I2C1ADB1 = (uint8_t)(address << 1);                                         // Load slave address and shift
    I2C1TXB = reg;                                                              // Load slave starting register address 
    I2C1CNT = 1;                                                                // Load count
    I2C1CON0bits.RSEN = 1;                                                      // Set RSEN for master read
    I2C1CON0bits.S = 1;                                                         // Set Start to get things going
    while(!I2C1CON0bits.MDR);                                                   // Wait until master is ready to receive data
    
    address = (uint8_t)(address << 1);
    I2C1ADB1 = (uint8_t)(address | 0x01);                                       // Load address with Read enabled
    I2C1CNT = len;                                                              // Load length of expected packet in bytes
    I2C1CON0bits.S = 1;                                                         // Set Start to begin Restart condition
    I2C1CON0bits.RSEN = 0;                                                      // Clear RSEN 
    while(I2C1CNT)                                                              // While there is a count
    {
        while(!I2C1STAT1bits.RXBF);                                             // Wait until buffer receives data
        *data++ = I2C1RXB;                                                      // Transfer data into array, hardware decrements count
    }
    wait4Stop();                                                                // Wait for hardware to issue a Stop
}
 

le readblock se suffisant à lui meme pour d'abord ecrire l'adresse , puis passer en lecture via
I2C1ADB1 = (uint8_t)(address | 0x01);
... pour la suite

par contre ce readblock ne gere pas les adresses sur 16 bits ...

for heureusement , tes versions I2CRead_16 et I2CWrite_16 comblent cette lacune ..
et va bien ..