Un adaptateur I2C pour capteur à ultrason HC-SR04, pour faciliter les mesures de distances !

// ===================================================================================================
//   ______               _                  _///_ _           _                   _
//  /   _  \             (_)                |  ___| |         | |                 (_)
//  |  [_|  |__  ___  ___ _  ___  _ __      | |__ | | ___  ___| |_ _ __ ___  _ __  _  ___  _   _  ___
//  |   ___/ _ \| __|| __| |/ _ \| '_ \_____|  __|| |/ _ \/  _|  _| '__/   \| '_ \| |/   \| | | |/ _ \
//  |  |  | ( ) |__ ||__ | | ( ) | | | |____| |__ | |  __/| (_| |_| | | (_) | | | | | (_) | |_| |  __/
//  \__|   \__,_|___||___|_|\___/|_| [_|    \____/|_|\___|\____\__\_|  \___/|_| |_|_|\__  |\__,_|\___|
//                                                                                      | |
//                                                                                      \_|
// ===================================================================================================
//
//  Nom Projet  :       Adaptateur I2C pour Capteur à ultrasons HC-SR04
//
//  Desc Projet :       Programme "i2c esclave", tournant sur un ATtiny412, permettant d'effectuer
//                      des mesures continuelles de distance (écho) via un HC-SR04, et permettant de
//                      retourner la dernière valeur lue, à la demande, via le bus I2C
//
//  Fichier     :       prgAdaptateurI2CpourHCSR04.ino
//  Créé le     :       10.05.2026
//  Auteur      :       Jérôme TOMSKI
//  Site        :       https://passionelectronique.fr/
//  GitHub      :       https://github.com/PassionElectronique/Programmes-Adaptateur-I2C-pour-capteur-HCSR04
//  Licence     :       https://creativecommons.org/licenses/by-nc-nd/4.0/deed.fr (BY-NC-ND 4.0 CC)
//
// ==============================================================================================================
//
//  Prérequis   :       Avoir installé "megatinycore" dans Arduino IDE
//  Prog ATtiny :       Impérativement régler 'Clock' sur '20 MHz internal', dans le menu 'Outils' d'Arduino IDE,
//                      avant d'uploader ce code dans l'ATtiny412 (explications du pourquoi avoir choisi 20 MHz
//                      pour le CPU ATtiny dans la fonction 'configureHorlogePeripheriquesInternesATtiny')
//
// ==============================================================================================================


// Constantes
#define ADRESSE_I2C_DE_BASE        0x30   // Adresse i2c de base, choisie arbitrairement ici, pour ce projet
#define BROCHE_DE_SORTIE_TRIG   PIN_PA3   // Sortie PWM pour envoyer des impulsions de 10 µs toutes les 100 ms environ, sur la ligne TRIG du HC-SR04 (demandes de mesures automatiques/perpétuelles)
#define BROCHE_D_ENTREE_ECHO    PIN_PA7   // Nota : n'importe quelle pin libre aurait pu convenir ici (grâce à EVSYS, qui peut relier n'importe pin au timer TCB0, qui nous intéresse ici)
#define BROCHE_D_ENTREE_ADC     PIN_PA6   // Entrée ADC, permettant de définir l'adresse I2C souhaitée parmi 8 adresses possibles (celle de base, décrite un peu plus haut, et les 7 suivantes)

// Variables
uint8_t adresse_I2C_reelle;  // Tient compte de ADRESSE_I2C_DE_BASE spécifiée ci-dessus (0x30), et BROCHE_D_ENTREE_ADDR (permet d'ajouter de 0 à 7, pour avoir le choix entre 8 adresses i2c différentes)

uint8_t index_buffer_verrouille = 0;              // On utilise 2 buffers ici, car la valeur 16 bits (2 octets) peut être altérée en lecture au moment d'une interruption (ISR)
uint16_t buffer_0_distance_mesuree_en_mm = 0;
uint16_t buffer_1_distance_mesuree_en_mm = 0;

volatile uint8_t index_octet_a_envoyer = 0;       // Permet d'envoyer un octet après l'autre (si égal 0, alors le LSB va être envoyé ensuite ; si égal 1, alors c'est au tour du MSB)

// Vérification de sécurité, afin de s'assurer que le timer TCD0 est bien choisi pour millis() etc
#ifndef MILLIS_USE_TIMERD0
  #error "Ce programme nécessite que le timer TCD0 soit utilisé pour millis()/micros(). Configurez-le dans le menu 'Outils' > 'millis()/micros() Timer'."
#endif


// ========================
// Initialisation programme
// ========================
void setup() {
  
  // Configurations préalables
  configureHorlogePeripheriquesInternesATtiny();
  determineAdresseI2Csouhaitee();
  configureCommunicationsI2CenModeEsclave();
  configureSytemeDeCaptureLigneECHO();
  configurePwmPersistantSurLigneTRIG();

  // Activation des interruptions, et passage à la boucle loop
  sei();
}


// =================
// Boucle principale
// =================
void loop() {
  // Rien ici, car une fois les configurations initiales passées, "tout" se passe au niveau des ISR (en cas de capture sur la ligne ECHO, ou requête I2C)
}


// ======================================================
// Fonction : configureHorlogePeripheriquesInternesATtiny
// ======================================================
void configureHorlogePeripheriquesInternesATtiny() {

  // ------------------------------------------------------------------------------------------------------------------------------------------------------------------
  // Explications techniques
  // ------------------------------------------------------------------------------------------------------------------------------------------------------------------
  // But de cette fonction :
  //    -> fixer la vitesse d'avancement des timers internes de l'ATtiny à 1/16ème de la fréquence principale (1/16ème de 20 MHz, soit 1,25 MHz donc).
  //       Ainsi, chaque timer sera incrémenté de 1 toutes les 0.8 µs (1 / 1,25 MHz). Et comme les timer A et B qui seront utilisés dans ce programme
  //       sont codés sur 16 bits (comptant de 0 à 65535, donc), la période totale pour ces timers sera de 0,052428 seconde (soit 52 ms environ)
  // Pourquoi avoir choisi 20 MHz comme fréquence principale ATtiny, et une division de fréquence par 16 pour les périphériques internes (timers, etc) ?
  //    -> car ces 52 ms de période couvrent bien les 38 ms MAX du signal ECHO retourné par le capteur HC-SR04 (timeout correspondant à une distance de 6,5m environ)
  //    -> car ces 52 ms de période, si multipliés par 2, nous donnent 104 ms de période, ce qui nous permettra de faire une mesure HC-SR04 toutes les 100ms environ
  //       (en sachant qu'il faut respecter un temps d'attente d'environ 60ms entre deux lectures, ces 100ms sont tout bonnement parfaits !)
  // ------------------------------------------------------------------------------------------------------------------------------------------------------------------
  
  CPU_CCP = CCP_IOREG_gc;                                     // Levée éphémère de la protection du registre protégé suivant (MCLKCTRLB)
  CLKCTRL.MCLKCTRLB = CLKCTRL_PDIV_16X_gc | CLKCTRL_PEN_bm;   // Fixation du prescaler d'horloge sur DIVISON par 16, et activation de ce prescaler (PEN)
}


// =======================================
// Fonction : determineAdresseI2Csouhaitee
// =======================================
void determineAdresseI2Csouhaitee() {
  
  // ------------------------------------------------------------------------------------------------------------------------------------------------------------------
  // Explications techniques
  // ------------------------------------------------------------------------------------------------------------------------------------------------------------------
  // But de cette fonction :
  //    -> déterminer l'adresse I2C "finale" de cet ATtiny, parmi 8 possibles (en partant d'une adresse de base donnée tout en haut)
  // Difficulté :
  //    -> l'ATtiny412 n'a que 8 broches, dont 7 sont déjà réservées (VCC, GND, UPDI, SDA, SCL, entrée_ECHO, et sortie_TRIG) ; cela ne laisse donc qu'une SEULE pin disponible
  // Solution :
  //    -> passer par une tension analogique, à 8 niveaux de tension différente grâce à un réseau R/2R et 3 bits de commande (3 cavaliers/jumpers inverseurs en fait, sur PCB)
  //    -> lire cette tension analogique via une entrées analogique sur l'ATtiny, et la convertir en valeur numérique (paliers allant de 0 à 7, pour avoir au final 8 adresses i2c possibles)

  // Petite pause de stabilisation (tension d'alim, et partie ADC)
  delay(100);

  // Constantes locales
  const uint8_t nombre_de_lectures_ADC = 10;
  const float   tension_d_alim_ATtiny = 5.0;
  const uint8_t pause_entre_chaque_lecture_ADC_en_millisecondes = 20;
  const uint8_t nombre_de_niveaux_de_tension_ADC = 8;     // Nos 3 cavaliers sur PCB nous donnent 3 bits de commande, soit 2 puissance 3 possibilités (2^3 = 8)
  const float   plage_de_tension_d_un_palier_ADC = tension_d_alim_ATtiny / nombre_de_niveaux_de_tension_ADC;  // Avec Valim=5V et NbNiveaux=8, alors on aura 0,625 V par palier

  // Relevé de la tension ADC (plus précisément : réalisation de 10 lectures ADC successives, espacées de 10 ms chacune, et calcul d'une valeur moyenne, pour filtrer les éventuelles parasites)
  float tension_moyenne_ADC = 0.0;
  for (uint8_t i = 0; i < nombre_de_lectures_ADC ; i++) {
    int valeur_brute_entree_ADC = analogRead(BROCHE_D_ENTREE_ADC);    // Lecture ADC (sur 10 bits, soit une valeur entre 0 et 1023 compris, sur un ATtiny)
    float tension_mesuree_sur_ADC = valeur_brute_entree_ADC * (tension_d_alim_ATtiny / 1023.0);
    tension_moyenne_ADC += tension_mesuree_sur_ADC;
    delay(pause_entre_chaque_lecture_ADC_en_millisecondes);
  }
  tension_moyenne_ADC /= nombre_de_lectures_ADC;

  // Remarques :
  //    -> les 8 tensions (paliers) théoriques possibles seront les suivantes : 0, 0.625V, 1.25V, 1.875V, 2.5V, 3.125V, 3.75V, et 4.375V
  //    -> on va donc considérer 8 plages possibles à partir de ces tensions, en acceptant une tension comprise entre -1/2 pas < tension_mesuree < +1/2 pas (en sachant qu'un pas vaut 0,625V)
  //       ainsi, si la tension mesurée n'est pas pile-poil sur sa valeur théorique, on pourra la retrouver en laissant un peu de marge dessus/dessous

  // Détermination du palier choisi (entre 0 et 7 compris, qui se rajouteront à l'adresse I2C de base)
  uint8_t numero_de_palier = 0;
  for (uint8_t i = 0; i < nombre_de_niveaux_de_tension_ADC ; i++) {
    float tension_basse_du_palier_i = (i == 0) ? 0 : (i - 0.5) * plage_de_tension_d_un_palier_ADC;  // Nota : exception pour le "niveau 0", sinon ça donnerait une tension négative
    float tension_haute_du_palier_i = (i + 0.5) * plage_de_tension_d_un_palier_ADC;
    if (tension_moyenne_ADC >= tension_basse_du_palier_i && tension_moyenne_ADC < tension_haute_du_palier_i) {
      numero_de_palier = i;
      break;
    }
  }

  // Enregistrement de l'adresse I2C finale, dans variable globale
  adresse_I2C_reelle = ADRESSE_I2C_DE_BASE + numero_de_palier;        // Si 0x30 est l'adresse I2C de base, alors l'adresse I2C finale pourra être 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, ou 0x37
}


// ==================================================
// Fonction : configureCommunicationsI2CenModeEsclave
// ==================================================
void configureCommunicationsI2CenModeEsclave() {

  // -----------------------------------------------------------------------------------------------------------------------------------------------------------------------
  // Explications techniques
  // -----------------------------------------------------------------------------------------------------------------------------------------------------------------------
  // But de cette fonction :
  //    -> configurer l'ATtiny en mode "esclave I2C", avec l'adresse i2c qui va bien (fonction de l'adresse de base spécifiée en haut, et de la position des switchs sur PCB
  // Remarques :
  //    -> sur un ATtiny412 (SOIC-8), on a pin_PA1=SDA et pin_PA2=SCL ; mais nul besoin de configurer ces pins PA1/PA2 en sortie manuellement, car le TWI s'en charge
  // -----------------------------------------------------------------------------------------------------------------------------------------------------------------------

  // Adresse I2C "esclave" (pour rappel, les adresses I2C sont codées sur 7 bits, auxquelles on rajoute un bit pour dire lecture ou écriture ; et ces 7 bits doivent figurer
  // en premier dans "l'octet d'adresse i2c", on doit décaler ces bits d'une position vers la gauche)
  TWI0.SADDR = (adresse_I2C_reelle << 1);

  // Configuration du registre SCTRLA
  TWI0.SCTRLA = TWI_ENABLE_bm           // Bit 0 : active l'I2C slave
              | TWI_SMEN_bm             // Bit 1 : active le "Smart Mode" (simplifie le code, au niveau de l'ISR)
              | TWI_PIEN_bm             // Bit 5 : active les interruptions sur "Stop", si la ligne suivante (adresse ou stop) est active
              | TWI_APIEN_bm            // Bit 6 : active les interruptions sur "Address ou Stop" (début ou fin de transmission i2c)
              | TWI_DIEN_bm;            // Bit 7 : active les interruptions sur "Data" ("milieu" des transmissions I2C)
}


// ============================================
// Fonction : configureSytemeDeCaptureLigneECHO
// ============================================
void configureSytemeDeCaptureLigneECHO() {
  
  // ----------------------------------------------------------------------------------------------------------------------------------------------------------
  // Explications techniques
  // ----------------------------------------------------------------------------------------------------------------------------------------------------------
  // But de cette fonction :
  //    -> Permettre de mesurer de manière automatique les durées d'impulsions sur la ligne ECHO, et de déclencher une interruption après chaque impulsion détectée
  // Rappel :
  //    -> les timers de notre ATtiny sont de base rythmés à 1,25 MHz (F_MAIN=20MHz et prescaler DIV/16) ; soit 52ms de période (en sachant que chaque impulsion sur
  //       la ligne ECHO fera au maximum 38ms, classiquement sur les HC-SR04)
  // Remarques :
  //    -> On va utiliser l'Event System ATtiny (EVSYS) pour connecter la pin PA2 (retour ECHO de notre capteur ultrason HC-SR04) à l'entrée de capture du TimerB ATtiny (TCB0)
  //    -> Puis on va configurer ce timer TCB0 en mode "input capture pulse-width measurement" pour qu'il :
  //          - mette à zéro son compteur CNT à chaque front montant détecté (mode "normal" du pulse-width de ce timer, en fait)
  //          - déclenche une interruption (ISR) à chaque front descendant détecté (la valeur CNT sera automatiquement copiée dans CCMP à ce moment là)
  //    -> Et le nombre de ticks comptés (CCMP) par ce compteur TCB0 nous donnera la durée d'impulsion ECHO (en admettant qu'il n'y ait pas le moindre débordement de comptage,
  //       et du fait qu'on connait la vitesse d'avance du compteur TCB0, qui est fonction de F_MAIN=20MHz et du prescaler principal réglé en division de fréquence par 16)
  // ----------------------------------------------------------------------------------------------------------------------------------------------------------
  
  // Configuration de l'Event System
  EVSYS.ASYNCCH0 = EVSYS_ASYNCCH0_PORTA_PIN7_gc;        // Relie Pin_PA7 à Event_CH0 (nota : on aurait pu prendre CH1, CH2, ou CH3 … c'était pareil ! J'ai arbitrairemnt pris CH0 ici)
  EVSYS.ASYNCUSER0 = EVSYS_ASYNCUSER0_ASYNCCH0_gc;      // Relie Event_CH0 à TCB0 (nota : ASYNCUSER0=TCB0, en fait)

  // Configuration du timer TCB0
  TCB0.CTRLB = TCB_CNTMODE_PW_gc;                       // Sélection du mode "Pulse Width measurement"
  TCB0.EVCTRL = TCB_CAPTEI_bm;                          // Active le système de capture d'événements (provoque : reset CNT à chaque front montant, et ISR à chaque front descendant avec valeur CCMP dispo)
  TCB0.INTCTRL = TCB_CAPT_bm;                           // Active les interruptions (ISR) sur capture effective
  TCB0.CTRLA = TCB_CLKSEL_CLKDIV1_gc | TCB_ENABLE_bm;   // Prescaler d'horloge TCB0 sur division par 1 (pas de ralentissement ici, donc) et activation du timer TCB0
}


// =============================================
// Fonction : configurePwmPersistantSurLigneTRIG
// =============================================
void configurePwmPersistantSurLigneTRIG() {

  // ----------------------------------------------------------------------------------------------------------------------------------------------------------
  // Explications techniques
  // ----------------------------------------------------------------------------------------------------------------------------------------------------------
  // But de cette fonction :
  //    -> générer un signal PWM persistant sur la ligne TRIG, d'une fréquence de 10 Hz pour avoir une période de 100ms (le capteur HC-SR04A devant éviter d'être
  //       piloté à moins de 60ms d'intervalle, pour éviter les échos parasites)
  // Rappel :
  //    -> les timers de notre ATtiny sont de base rythmés à 1,25 MHz (F_MAIN=20MHz et prescaler DIV/16) ; cela correspond à 52 ms environ de période
  // Remarques :
  //    -> ici, pour générer une impulsion de 10µs (requis sur la ligne TRIG) toutes les 100ms, on va encore diviser la fréquence d'horloge timer par 2,
  //       pour arriver à une fréquence de 5 Hz, soit une période de 104 ms (qu'on va limiter à 100 ms, en fixant le registre PER du timer)
  //    -> on utilisera le timer TCA0, en mode "single-slope PWM"
  //    -> du fait de la division de fréquence par deux supplémentaire, le timer TCA0 avancera à un rythme de 625 kHz (1.25MHz/2), soit toutes les 1,6 µs exactement
  //    -> on utilisera les registres PERBUF et CMP0BUF au lieu de PER et CMP0, car c'est une "bonne pratique" pour mettre à jour la durée de période/impulsion PWM
  //       de manière synchrone, pour éviter les indésirables/transitoires (bien que ce soit inutile ici, du fait qu'on configure le timer une fois pour toute au démarrage,
  //       sans mise à jour ultérieure des registres ; mais comme c'est une "bonne façon de faire", je vous la montre !)
  // ----------------------------------------------------------------------------------------------------------------------------------------------------------
  
  // Code indispensable, pour prendre le contrôle de TCA0 "contre" megatinycore // (cf. explications ici : https://github.com/SpenceKonde/megaTinyCore/blob/master/megaavr/extras/TakingOverTCA0.md)
  PORTMUX.CTRLC = PORTMUX_TCA00_DEFAULT_gc; // Désactive le déplacement de WO0 sur PA7 via PORTMUX (fait par megatinycore, de base), en ramenant WO0 sur PA3 (indispensable sur les ATtiny à 8 broches, ayant WO0 et WO3 sur la même pin)
  takeOverTCA0();                           // Désactive les fonctionnalités megatinycore utilisant le timer TCA0, et réinitialise ce timer (pour éviter le forçage en mode split 2x8 bits de megatinycore, etc.)

  // Configuration de la broche PA3 en sortie (c'est sur cette pin que sortira le signal PWM à destination de la pin TRIG)
  PORTA.DIRSET = PIN3_bm;

  // Configuration du timer TCA0
  TCA0.SINGLE.CTRLB = TCA_SINGLE_CMP0EN_bm                // Active la sortie de génération de signal WO0 (qui va ressortir sur la pin PA3 de l'ATtiny)
                    | TCA_SINGLE_WGMODE_SINGLESLOPE_gc;   // Active le mode "Single-Slope PWM Generation" (dans ce cas, CMP définit la durée d'impulsion, et PER la durée totale période)
  TCA0.SINGLE.PERBUF  = 62499;                            // Permet d'avoir une période PWM égale à 100 ms <--- (62499+1)*1,6µs = 0,1 seconde (soit 100 ms)
  TCA0.SINGLE.CMP0BUF = 7;                                // Permet d'avoir une durée d'impulsion PWM égale à 11.2 µs <--- 7*1,6µ = 11,2 µs (pour rappel : il faut au moins 10 µs pour le HC-SR04)
  TCA0.SINGLE.CTRLA = TCA_SINGLE_CLKSEL_DIV2_gc           // Divise la fréquence d'horloge reçue encore par 2 (donc 20MHz / 16 / 2 = 625 kHz)
                    | TCA_SINGLE_ENABLE_bm;               // Active le timer TCA0, maintenant que tout est bien configuré !
}


// ========================================================================
// Interruption TCB0 (survient à chaque front descendant sur ECHO/PA2, ici)
// ========================================================================
ISR(TCB0_INT_vect)
{
  // Lecture de la valeur capturée par TCB0
  uint16_t nbre_de_ticks_ecoules = TCB0.CCMP;
    
  // Effacement du drapeau d'interruption (impératif, sur tinyAVR)
  TCB0.INTFLAGS = TCB_CAPT_bm;
    
  // Conversion du nombre de ticks (TCB0.CCMP) en millimètres (mm). Pour cela, nous avons comme données :
  //    - un tick sur TCB0 équivaut à 0,8 µs (16/20MHz)
  //    - la vitesse du son est de 343.2 m/s (soit 0.3432 mm/µs)
  // On peut ainsi en déduire le temps d'aller/retour (soit 0.27456 mm/0.8µs), et le temps d'un aller ou retour seul (la distance réelle à mesurer, donc) = 0.27456/2=0.13728 mm/0.8µs
  // Donc pour 1 tick de 0.8 µs, la distance sera ainsi de 0.13728 mm.
  // Du coup, si on fait TCB0.CCMP*0.13728, on obtient la distance en mm, séparant le capteur à ultrason HC-SR04 de l'obstacle réfléchissant
    
  // Remarque technique : l'ATtiny412 n'ayant pas d'unité de calcul flottant, on évite ici de passer par des nombres à virgule (float),
  // histoire d'aller vite pour ne pas perdre de temps dans cet ISR (sinon on risquerait de potentiellement retarder une interruption I2C.
  // On préfère donc faire ici une multiplication puis division entière sur 32 bits (d'où les nombres marqués 'UL' ci-dessous, signifiant "unsigned long")
  
  if (index_buffer_verrouille == 0) {			// Pour éviter les données corrompues
  	 buffer_1_distance_mesuree_en_mm = (nbre_de_ticks_ecoules * 13728UL) / 100000UL;   // Nota : 13728 / 100000 = 0.13728 (astuce pour aller vite, dans le traitement des "nombres à virgule")
  } else {
     buffer_0_distance_mesuree_en_mm = (nbre_de_ticks_ecoules * 13728UL) / 100000UL;
  }
}


// ======================================================
// Interruption I2C (survient à chaque "appel du maître")
// ======================================================
ISR(TWI0_TWIS_vect)
{
  // Remarque : les interruptions I2C sont vraiment multiples ici ! En effet, on en aura une :
  //                - lorsqu'une adresse est reçue (sous-entendu qui correspond à l'adresse "esclave i2c" de ce projet, ou à l'adresse générale 0x00)
  //                - lorsque des données sont reçues
  //                - lorsqu'une erreur de bus est survenue
  //                - si un arrêt (STOP) a été détecté
  //                - etc
  uint8_t status = TWI0.SSTATUS;              // Nota : TWI0.SSTATUS est le registre du contrôleur TWI (Two-Wire Interface / I²C)
  
  if (status & TWI_APIF_bm) {                 // Cas "Address" ou "Stop"
    if (status & TWI_AP_bm) {                 // Cas "Address"
      if (status & TWI_DIR_bm) {              // Cas "Address" + "Master Read"
        index_buffer_verrouille ^= 1;         // Demande de lecture par le maître => on bascule de buffer (ce qui permet de travailler ici sur des données qui ne vont pas bouger malgré les ISR de TCB0, le temps que la transmission I2C soit achevée)
        TWI0.SCTRLB = TWI_SCMD_RESPONSE_gc;   // Répond pour poursuivre la transmission
      } else {                                // Cas "Address" + "Master Write" (cas qui ne doit jamais arriver ici, sauf en cas d'utilisation d'un 'scanner I2C', c'est pourquoi j'ai géré ce cas ici)
        TWI0.SCTRLB = TWI_SCMD_COMPTRANS_gc;  // Termine la transmission
      }
    } else {                                  // Cas "Stop"
      TWI0.SCTRLB = TWI_SCMD_COMPTRANS_gc;    // Termine la transmission
      index_octet_a_envoyer = 0;              // Réinitialise l'index de pointage d'octet, pour le tour d'après !
    }
  } else if (status & TWI_DIF_bm) {           // Cas "Data byte" (uniquement en "Read")
    if (index_octet_a_envoyer == 0) {         // Envoi du LSB (partie basse du mot de 16 bits)
      if (index_buffer_verrouille == 0) TWI0.SDATA = (uint8_t)buffer_0_distance_mesuree_en_mm;           // LSB du buffer #0
      if (index_buffer_verrouille == 1) TWI0.SDATA = (uint8_t)buffer_1_distance_mesuree_en_mm;           // LSB du buffer #1
      index_octet_a_envoyer = 1;              // Passage de l'index à 0->1, pour que la fois d'après, ce soit le MSB qui soit envoyé
    }
    else if (index_octet_a_envoyer == 1) {    // Envoi du MSB (partie haute du mot de 16 bits)
      if (index_buffer_verrouille == 0) TWI0.SDATA = (uint8_t)(buffer_0_distance_mesuree_en_mm >> 8);    // MSB du buffer #0
      if (index_buffer_verrouille == 1) TWI0.SDATA = (uint8_t)(buffer_1_distance_mesuree_en_mm >> 8);    // MSB du buffer #1
      index_octet_a_envoyer = 2;              // Valeur quelconque, différente de 0 ou 1, pour filtrer le "NACK du maître", qui déclenche une interruption également ici
    } else {
      TWI0.SDATA = 0;                         // Remarque : ce SDATA à 0 ne sera pas envoyé. Il est juste là pour ne pas bloquer la transmission avant de l'interrompre au niveau du cas "Stop" suivant
    }                                         //            (puisque nos deux octets ont déjà été envoyés, on devrait juste avoir un passage par là, lors du NACK du maître)
  }
}

Le croquis utilise 2060 octets (50%) de l'espace de stockage de programmes. Le maximum est de 4096 octets.
Les variables globales utilisent 15 octets (5%) de mémoire dynamique, ce qui laisse 241 octets pour les variables locales. Le maximum est de 256 octets.

pymcuprog.programmer - INFO - Verifying...
Verify successful. Data in flash matches data in specified hex-file

// ===================================================================================================
//   ______               _                  _///_ _           _                   _
//  /   _  \             (_)                |  ___| |         | |                 (_)
//  |  [_|  |__  ___  ___ _  ___  _ __      | |__ | | ___  ___| |_ _ __ ___  _ __  _  ___  _   _  ___
//  |   ___/ _ \| __|| __| |/ _ \| '_ \_____|  __|| |/ _ \/  _|  _| '__/   \| '_ \| |/   \| | | |/ _ \
//  |  |  | ( ) |__ ||__ | | ( ) | | | |____| |__ | |  __/| (_| |_| | | (_) | | | | | (_) | |_| |  __/
//  \__|   \__,_|___||___|_|\___/|_| [_|    \____/|_|\___|\____\__\_|  \___/|_| |_|_|\__  |\__,_|\___|
//                                                                                      | |
//                                                                                      \_|
// ===================================================================================================
//
//  Nom Projet  :       Scanner I2C
//
//  Desc Projet :       Permet de scanner toutes les adresses I2C (de 1 à 126, du fait que 0 et 127 sont réservées),
//                      à partir d'un Arduino Uno ou équivalent
//
//  Fichier     :       prgScannerI2C.ino
//  Créé le     :       05.08.2026
//  Auteur      :       Jérôme TOMSKI
//  Site        :       https://passionelectronique.fr/
//  GitHub      :       https://github.com/PassionElectronique/Programmes-Adaptateur-I2C-pour-capteur-HCSR04
//  Licence     :       https://creativecommons.org/licenses/by-nc-nd/4.0/deed.fr (BY-NC-ND 4.0 CC)
//
// =========================================================================================================

// Bibliothèque à inclure
#include <Wire.h>

// ========================
// Initialisation programme
// ========================
void setup() {
  
  // Initialisation des communications séries
  Serial.begin(9600);
  Wire.begin();

  // Affichage de démarrage, à destination du moniteur série d'Arduino IDE
  Serial.println("===========");
  Serial.println("Scanner I2C");
  Serial.println("===========");
  Serial.println();
  Serial.println("Démarrage du scan...");

  // Initialisation compteur de périphériques I2C trouvés
  byte nombreDePeripheriquesTrouves = 0;

  // Scanne les adresses I2C n°0 à 127, ou plutôt 1 à 126, du fait que les adresses 0 et 127 sont réservées
  for (byte adresse_I2C = 1; adresse_I2C <= 126; adresse_I2C++) {

    // Initialise la communication i2c
    Wire.beginTransmission(adresse_I2C);
    byte retour_I2C = Wire.endTransmission();

    // Si "endTransmission" retourne la valeur 0, alors on signale le périphérique détecté à l'adresse en cours
    if (retour_I2C == 0) {
      Serial.print("Périphérique détecté à l'adresse 0x");

      if (adresse_I2C < 16) Serial.print("0");
      Serial.print(adresse_I2C, HEX);
      Serial.print("  (decimal : ");
      Serial.print(adresse_I2C);
      Serial.println(")");

      nombreDePeripheriquesTrouves++;
    }
    // Si "endTransmission" retourne une valeur différente de 0, alors on n'en tient pas compte (erreur ou périphérique absent, dans ce cas)
    else {
      // Ne rien faire
    }
  }

  // Affichage du nombre de périphériques trouvés, sur le moniteur série
  Serial.println("Scan terminé !");
  Serial.println("");
  Serial.print("Bilan = ");
  if (nombreDePeripheriquesTrouves == 0) Serial.println("aucun périphérique I2C détecté");
  else if (nombreDePeripheriquesTrouves == 1) Serial.println("1 seul périphérique détecté");
  else {
    Serial.print(nombreDePeripheriquesTrouves);
    Serial.println(" périphériques détectés");
  }

  // Fin
  Serial.println("");
  Serial.println("(appuyez sur la touche RESET de votre arduino, pour relancer le scan, si besoin !)");
  
}


// =================
// Boucle principale
// =================
void loop() {
   // Vide, car tout se passe dans la fonction setup()
}

// ===================================================================================================
//   ______               _                  _///_ _           _                   _
//  /   _  \             (_)                |  ___| |         | |                 (_)
//  |  [_|  |__  ___  ___ _  ___  _ __      | |__ | | ___  ___| |_ _ __ ___  _ __  _  ___  _   _  ___
//  |   ___/ _ \| __|| __| |/ _ \| '_ \_____|  __|| |/ _ \/  _|  _| '__/   \| '_ \| |/   \| | | |/ _ \
//  |  |  | ( ) |__ ||__ | | ( ) | | | |____| |__ | |  __/| (_| |_| | | (_) | | | | | (_) | |_| |  __/
//  \__|   \__,_|___||___|_|\___/|_| [_|    \____/|_|\___|\____\__\_|  \___/|_| |_|_|\__  |\__,_|\___|
//                                                                                      | |
//                                                                                      \_|
// ===================================================================================================
//
//  Nom Projet  :       Adaptateur I2C pour Capteur à ultrasons HC-SR04
//
//  Desc Projet :       Programme de test pour l'adpatateur I2C pour module HC-SR04,
//                      fonctionnant sur Arduino Uno
//
//  Fichier     :       prgTestAdaptateurI2CpourHCSR04.ino
//  Créé le     :       05.08.2026
//  Auteur      :       Jérôme TOMSKI
//  Site        :       https://passionelectronique.fr/
//  GitHub      :       https://github.com/PassionElectronique/Programmes-Adaptateur-I2C-pour-capteur-HCSR04
//  Licence     :       https://creativecommons.org/licenses/by-nc-nd/4.0/deed.fr (BY-NC-ND 4.0 CC)
//
// =========================================================================================================

// Bibliothèque à inclure
#include <Wire.h>

// Constantes
#define ADRESSE_I2C_ADAPTATEUR_HCSR04 0x30


// ========================
// Initialisation programme
// ========================
void setup() {

  // Initialisation des communications séries
  Serial.begin(9600);
  Wire.begin();

  // Affichage de démarrage, à destination du moniteur série d'Arduino IDE
  Serial.println("=================================================");
  Serial.println("Programme de test /// adaptateur I2C pour HC-SR04");
  Serial.println("=================================================");
  Serial.println();

  // Petite pause, pour laisser le temps à l'adaptateur I2C pour HCSR04 de démarrer/se stabiliser
  delay(1000);
}


// =================
// Boucle principale
// =================
void loop() {

  // Interrogation de l'adaptateur I2C (demande 2 octets en retour)
  Wire.requestFrom(ADRESSE_I2C_ADAPTATEUR_HCSR04, 2);

  if (Wire.available() >= 2) {
    // Si deux octets reçus, on les lit
    uint8_t premier_octet = Wire.read();
    uint8_t deuxieme_octet = Wire.read();

    // Puis on en déduit la distance
    uint16_t distance_mm = (uint16_t)deuxieme_octet << 8 | premier_octet;

    // Et affichage (avec octets bruts en hexa, pour diagnostic temporaire)
    Serial.print("Octets recus : 0x");
    if (premier_octet < 0x10) Serial.print("0");
    Serial.print(premier_octet, HEX);
    Serial.print(" 0x");
    if (deuxieme_octet < 0x10) Serial.print("0");
    Serial.print(deuxieme_octet, HEX);
    Serial.print("  =>  Distance : ");
    Serial.print(distance_mm / 10.0, 1);  // Division par 10 pour passer en 'centimètres', puis passage en valeur 'float' au passage, et affichage avec 1 chiffre après la virgule
    Serial.println(" cm");

  } else {
    // Si l'adaptateur I2C n'a pas répondu, alors on affiche le fait qu'il n'y a pas de réponse retournée sur le bus I2C
    Serial.println("[ERREUR] pas de réponse reçue...");
  }

  // Attend 1 seconde, et reboucle
  delay(1000);
}