TP 7 — Le bus I²C : température, accéléromètre et gyroscope

Objectifs

comprendre le bus I²C : deux fils, des adresses, des registres ;
trouver les composants présents sur un bus, et vérifier leur identité ;
lire le capteur de température de la carte et convertir sa mesure ;
configurer et lire une centrale inertielle (accéléromètre et gyroscope).

Durée indicative : deux séances de 3 h. Prérequis : TP 1 — Allumer une LED, lire un bouton.

Ce qu’il faut savoir

Le bus I²C

L’I²C relie un maître (le microcontrôleur) à plusieurs esclaves (les capteurs) par deux fils seulement : SCL, l’horloge, que le maître impose, et SDA, les données, dans les deux sens. Les deux lignes sont tirées au +3,3 V par des résistances, et chaque composant ne sait que les mettre à 0 : c’est ce qui permet à plusieurs composants de partager les mêmes fils.

Figure made with TikZ

Le bus I²C2 : deux fils partagés, tirés au +3,3 V.

Chaque esclave a une adresse sur 7 bits. Une transaction commence par l’adresse : seul le composant qui la reconnaît répond, en acquittant (ACK). La plupart des capteurs se lisent comme une petite mémoire : on écrit le numéro d’un registre, puis on lit un ou plusieurs octets à partir de lui. La HAL fournit les deux opérations :

HAL_I2C_Mem_Read (&hi2c2, adresse << 1, registre, I2C_MEMADD_SIZE_8BIT,
                  tampon, nombre_d_octets, delai_ms);
HAL_I2C_Mem_Write(&hi2c2, adresse << 1, registre, I2C_MEMADD_SIZE_8BIT,
                  tampon, nombre_d_octets, delai_ms);

Figure made with TikZ

Une lecture de registre (HAL_I2C_Mem_Read) : écrire le numéro du registre, puis lire.

Important

La HAL attend l’adresse décalée d’un bit à gauche : l’adresse 7 bits 0x48 se passe 0x48 << 1, soit 0x90. Oublier le décalage est l’erreur la plus fréquente avec l’I²C.

Les capteurs de la carte

Composant	Bus et broches	Adresse 7 bits	Rôle
TMP102 (U3)	I2C2 : SCL PB10, SDA PB11	0x48	capteur de température, soudé sur la carte
LSM6DSOX	I2C3 : SCL PA8, SDA PC9	0x6A ou 0x6B	centrale inertielle (accéléromètre et gyroscope), sur un petit module relié au connecteur J9

Sur un robot complet, d’autres composants partagent le bus I2C2, comme le capteur de distance avant. Seul le TMP102 est toujours présent.

Étape 1 — Configurer l’I²C2 et chercher les composants

Créez un projet tp07_i2c comme au TP 1 (STM32H750VBTx, SYS → Debug : Serial Wire, horloge par défaut).
Dans Connectivity → I2C2, choisissez I2C. Vérifiez que CubeMX a placé SCL et SDA sur PB10 et PB11 (sinon, cliquez sur ces broches et choisissez I2C2_SCL et I2C2_SDA). Gardez la vitesse Standard Mode (100 kHz).
Générez le code.
Écrivez un balayage du bus : pour chaque adresse de 1 à 127, demandez si un composant répond, et gardez la liste de ceux qui répondent :
```
if (HAL_I2C_IsDeviceReady(&hi2c2, adresse << 1, 2, 5) == HAL_OK) {
    /* un composant a acquitté à cette adresse */
}
```
Affichez le nombre de composants trouvés sur les LED de façade, ou lisez la liste dans le débogueur.

Questions

Quelles adresses répondent ? Retrouvez-les dans le tableau ci-dessus.
Que se passe-t-il si l’on oublie le décalage << 1 ?

Étape 2 — Vérifier qu’on parle bien au TMP102

Qu’un composant acquitte à l’adresse 0x48 ne prouve pas que ce soit un TMP102. Pour le vérifier, lisez un registre dont la valeur est connue : le registre de configuration (numéro 0x01), qui vaut 0x60A0 au démarrage, d’après la fiche technique du TMP102.

Lisez 2 octets à partir du registre 0x01, et reconstituez la valeur sur 16 bits : le premier octet reçu est l’octet de poids fort.
Comparez-la à 0x60A0.

Étape 3 — Lire la température

Le registre de température (numéro 0x00) contient une mesure sur 12 bits, cadrée à gauche dans deux octets, en complément à deux (les températures négatives sont des nombres négatifs). Un pas vaut 0,0625 °C.

Lisez 2 octets à partir du registre 0x00.
Reconstituez la mesure : assemblez les deux octets, décalez de 4 bits à droite, puis étendez le signe si le bit 11 est à 1.
Convertissez en millièmes de degré, avec des entiers : un pas vaut 62,5 m°C.
Lisez la température toutes les secondes. Posez le doigt sur le TMP102 (repère U3, près du microcontrôleur) et regardez-la monter.

Questions

Quelle température lisez-vous ? Est-ce la température de la pièce ? Pourquoi ?
Le doigt fait-il monter la mesure tout de suite ? De combien, et en combien de temps ?
Pourquoi faut-il étendre le signe ? Que lirait-on à −10 °C sans le faire ?

Étape 4 — La centrale inertielle

Cette étape demande le module de centrale inertielle branché sur J9.

Activez I2C3 dans CubeMX, sur PA8 (SCL) et PC9 (SDA), en Standard Mode. Régénérez le code.
L’adresse. Selon le câblage de sa broche SA0, le LSM6DSOX répond en 0x6A ou en 0x6B. Essayez les deux avec HAL_I2C_IsDeviceReady.
L’identité. Lisez le registre WHO_AM_I (numéro 0x0F) : il doit valoir 0x6C.

La configuration. Au démarrage, les capteurs sont éteints. Écrivez :

Registre	Numéro	Valeur	Effet
CTRL3_C	0x12	0x44	mise à jour des données par blocs (BDU), adresse qui s’incrémente à chaque octet lu
CTRL1_XL	0x10	0x48	accéléromètre à 104 Hz, pleine échelle ±4 g
CTRL2_G	0x11	0x40	gyroscope à 104 Hz, pleine échelle ±250 °/s

La lecture. Lisez 6 octets à partir de OUTX_L_A (0x28) pour l’accéléromètre, et 6 octets à partir de OUTX_L_G (0x22) pour le gyroscope : trois axes X, Y, Z de 16 bits chacun, octet de poids faible en premier, en complément à deux.
Les unités. D’après la fiche technique : 0,122 mg par pas pour l’accéléromètre à ±4 g, 8,75 m°/s par pas pour le gyroscope à ±250 °/s.

Questions

Carte posée à plat et immobile, que vaut l’accélération sur chaque axe ? Lequel mesure la gravité ? Avec quel signe ? Qu’en déduire sur l’orientation du module ?
Immobile, le gyroscope devrait lire zéro. Que lit-il ? Comment corriger ce décalage, appelé biais ?
Pourquoi le réglage BDU est-il important quand on lit les deux octets d’une mesure en deux fois ?

Solution de l’étape 4

#define IMU_WHO_AM_I  0x0Fu
#define IMU_CTRL1_XL  0x10u
#define IMU_CTRL2_G   0x11u
#define IMU_CTRL3_C   0x12u
#define IMU_OUTX_L_G  0x22u
#define IMU_OUTX_L_A  0x28u

static int imu_init(void)
{
    static const uint16_t addrs[2] = { 0x6Au << 1, 0x6Bu << 1 };
    uint8_t v;

    g_imu_addr = 0u;
    for (uint32_t k = 0u; k < 2u; k++)           /* SA0 à 0 ou à 1 */
    {
        if (HAL_I2C_IsDeviceReady(&hi2c3, addrs[k], 2u, I2C_TIMEOUT_MS) == HAL_OK)
        {
            g_imu_addr = addrs[k];
            break;
        }
    }
    if (g_imu_addr == 0u) { return 0; }

    if (HAL_I2C_Mem_Read(&hi2c3, g_imu_addr, IMU_WHO_AM_I, I2C_MEMADD_SIZE_8BIT,
                         &v, 1u, I2C_TIMEOUT_MS) != HAL_OK) { return 0; }
    g_who_am_i = v;
    if (v != 0x6Cu) { return 0; }                 /* ce n'est pas un LSM6DSOX */

    v = 0x44u;   /* CTRL3_C : BDU + IF_INC, en premier */
    HAL_I2C_Mem_Write(&hi2c3, g_imu_addr, IMU_CTRL3_C, I2C_MEMADD_SIZE_8BIT, &v, 1u, I2C_TIMEOUT_MS);
    v = 0x48u;   /* CTRL1_XL : 104 Hz, ±4 g */
    HAL_I2C_Mem_Write(&hi2c3, g_imu_addr, IMU_CTRL1_XL, I2C_MEMADD_SIZE_8BIT, &v, 1u, I2C_TIMEOUT_MS);
    v = 0x40u;   /* CTRL2_G : 104 Hz, ±250 °/s */
    HAL_I2C_Mem_Write(&hi2c3, g_imu_addr, IMU_CTRL2_G, I2C_MEMADD_SIZE_8BIT, &v, 1u, I2C_TIMEOUT_MS);
    return 1;
}

/* Trois axes de 16 bits, octet de poids faible en premier. */
static int imu_read3(uint8_t reg, int16_t out[3])
{
    uint8_t b[6];

    if (HAL_I2C_Mem_Read(&hi2c3, g_imu_addr, reg, I2C_MEMADD_SIZE_8BIT,
                         b, 6u, I2C_TIMEOUT_MS) != HAL_OK) { return 0; }
    for (uint32_t k = 0u; k < 3u; k++)
    {
        out[k] = (int16_t)(((uint16_t)b[2u * k + 1u] << 8) | b[2u * k]);
    }
    return 1;
}

et dans la boucle, dix fois par seconde :

int16_t a[3], g[3];

if ((g_imu_addr != 0u) && imu_read3(IMU_OUTX_L_A, a) && imu_read3(IMU_OUTX_L_G, g))
{
    for (uint32_t k = 0u; k < 3u; k++)
    {
        g_acc_mg[k]    = ((int32_t)a[k] * 122) / 1000;   /* 0,122 mg / pas */
        g_gyro_mdps[k] = ((int32_t)g[k] * 875) / 100;    /* 8,75 m°/s / pas */
    }
}
HAL_Delay(100);

Décoder 0x48 (CTRL1_XL). En binaire, 0100 1000 : les 4 bits de gauche (0100) choisissent la fréquence, 104 Hz ; les deux suivants (10) la pleine échelle, ±4 g. La fiche technique du LSM6DSOX donne ces tableaux de bits, registre par registre.

Lire 6 octets d’un coup marche grâce au bit IF_INC de CTRL3_C : après chaque octet lu, le capteur passe tout seul au registre suivant (OUTX_L, OUTX_H, OUTY_L…). Une seule transaction I²C pour trois axes : plus rapide, et les trois valeurs viennent du même échantillon.

Ici, l’ordre des octets est inversé par rapport au TMP102 : poids faible en premier (little-endian). Chaque composant a sa convention : on la lit dans sa fiche technique, on ne la devine jamais.

Le transtypage en int16_t fait de lui-même l’extension de signe : les 16 bits assemblés sont interprétés comme un nombre signé, ce qui est exactement le format du capteur.

Exercices supplémentaires

Ces exercices n’ont pas de correction.

Alerte de température : le TMP102 a une sortie ALERT reliée à PE15. Réglez ses seuils (registres 0x02 et 0x03) pour qu’elle s’active au-dessus de 30 °C, et allumez une LED quand elle passe à 0.
Niveau à bulle : les quatre LED indiquent de quel côté la carte penche, d’après l’accéléromètre.
Détecteur de choc : une LED s’allume (et le buzzer sonne) quand l’accélération dépasse 2 g sur un axe horizontal.
Cap : intégrez la vitesse de rotation du gyroscope autour de l’axe vertical pour obtenir un angle, et observez sa dérive en quelques minutes.

Après le TP

Pour rendre la carte au robot, voir Remettre la carte en état RatBot.