Discussion :

[Rémi duino]

Bonjour,
Habitué à la programmation I2c en Arduino j'arrive à gérer tout les cas.
Mais pour une application j'utilise Raspberry Pi en python.
Mais il y a 2 cas de trame I2c que je ne sais programmer en python.

1er cas: Par exemple lire 8 octets d'un composant d'adresse I2c 0x48 mais qui n'a pas d'adresse de registre ?

Ecrire 0x48+R puis lire les 8 octets

En Arduino

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
Wire.requestFrom(0x48, 8); 
 
  while (Wire.available()) 
    { 
    tab[0]= Wire.read(); 
    //8 fois    
    }

En Python ?

read_byte (adr)n'utilise pas de registre mais c'est seulement pour un octet.

read_bloc_data (adr, reg) utilise une registre et ne peu correspondre à la trame I2C nécessaire.

2eme cas: Par exemple lire 8 octets d'un composant d'adresse I2c 0x48 mais qui à un registre de 16 bit (par exemple lire à partir de 0x0F00)?

Ecrire 0x48+W / Ecrire 0xF0 / Ecrire0x00 / Ecrire 0x48+R puis lire les 8 octets

En Arduino :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
Wire.beginTransmission(0x48);
Wire.Wire(0xF0);
Wire.Wire(0x00);
Wire.endTransmission();
Wire.requestFrom(0x48, 8);
while (Wire.available()) 
    { 
    tab[0]= Wire.read(); 
    //8 fois
    }

En Python ?

read_bloc_data (0x48, 0xF000) de dois pas fonctionner?


Je ne sais command résoudre ces cas en python ?

[f-leb]

Bonsoir,

Quel composant i2c utilises-tu ?

[Rémi duino]

Le composant I2C ne change pas grand chose car je connais les trames i2c que j'ai indiqué.
Mais pour tout dire.

Dans le 1er cas :

C'est un arduino Esclave I2c qui gère des fonctions de bas niveau et la gestion d'un GPS.
Le programme de l'esclave est le suivant :
Dans le setup :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Wire.begin(0x48); 
Wire.onRequest(requestEvent); // Fonction event

En fonction d'interruption :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
void requestEvent() {
  Wire.write(long_latitudeDegrees&0x000000FF);
  Wire.write((long_latitudeDegrees&0x0000FF00)>>8);
  Wire.write((long_latitudeDegrees&0x00FF0000)>>16);
  Wire.write((long_latitudeDegrees&0xFF000000)>>24);
 
  //faire de même avec Longitude
 
}

Cela fonctionne très bien avec un Arduino maître avec le programme du premier post.
(Ps: Objectif l'esclave Arduino gère le GPS (et autre) et je voudrai récupérer avec le Raspberry Pi zéro les coordonnée GPS pour les associées à l'envoi de photo en 4G qui est fonctionnel)
Mais je ne sais comment récupérer les valeurs en i2c en python avec le Pi Zéro car il n'y a pas d'adresse de registre.

Dans le 1ième cas :

Il s'agir d'une mémoire I2C avec une adresse de registre sur 16bits FRAM MB85RC256V

La trame I2C à construire est la suivante.



Comme le registre d'adresse est sur 16 bites je ne sais pas comment lire la mémoire avec les fonctions python ?

[f-leb]

Bonsoir,

2eme cas: Par exemple lire 8 octets d'un composant d'adresse I2c 0x48 mais qui à un registre de 16 bit (par exemple lire à partir de 0x0F00)?

Ecrire 0x48+W / Ecrire 0xF0 / Ecrire0x00 / Ecrire 0x48+R puis lire les 8 octets

En trichant un peu avec write_block_data peut-être :

write_block_data(i2c_addr, register, data)

Dans register on met l'octet Address High, puis suit un bloc de données data, c-à-d une liste avec un seul octet, Address Low :

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
write_i2c_block_data(0x48, 0xF0, [0x00])
data1 = read_byte(0x48)
data2 = read_byte(0x48)
...
data8 = read_byte(0x48)

[Rémi duino]

Ok je tenterai cela lorsque j'aurai reçut la mémoire mais cela me semble intéressant.

Si vous avez une idée pour le premier cas je suis preneur également.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

write_i2c_block_data(0x48, 0xF0, [0x00])

Pourquoi la Data entre crochet ? [0x00] ?

[f-leb]

Parce que data est une liste en Python.

1er cas: Par exemple lire 8 octets d'un composant d'adresse I2c 0x48 mais qui n'a pas d'adresse de registre ?

Ecrire 0x48+R puis lire les 8 octets

Dans cette doc, on évoque un write_quick(addr) qui pourrait faire l'affaire...