Un convertisseur I2C/PWM pour servomoteur RC (MG995, SG90…) – Exemple de périphérique I2C « esclave »

// ===================================================================================================
//   ______               _                  _///_ _           _                   _
//  /   _  \             (_)                |  ___| |         | |                 (_)
//  |  [_|  |__  ___  ___ _  ___  _ __      | |__ | | ___  ___| |_ _ __ ___  _ __  _  ___  _   _  ___
//  |   ___/ _ \| __|| __| |/ _ \| '_ \_____|  __|| |/ _ \/  _|  _| '__/   \| '_ \| |/   \| | | |/ _ \
//  |  |  | ( ) |__ ||__ | | ( ) | | | |____| |__ | |  __/| (_| |_| | | (_) | | | | | (_) | |_| |  __/
//  \__|   \__,_|___||___|_|\___/|_| [_|    \____/|_|\___|\____\__\_|  \___/|_| |_|_|\__  |\__,_|\___|
//                                                                                      | |
//                                                                                      \_|
// ===================================================================================================
//
//  Nom Projet  :       Convertisseur I2C → PWM pour servomoteur
//  Desc Projet :       Programme "I2C esclave", tournant sur un ATtiny212, permettant de piloter
//                      un servomoteur en PWM, à partir d'instructions reçues sur le bus I2C
//
//  Fichier     :       programmeConvertisseurI2CversPWMservo.ino
//  Créé le     :       08.04.2026
//  Auteur      :       Jérôme TOMSKI
//  Site        :       https://passionelectronique.fr/
//  GitHub      :       https://github.com/PassionElectronique/Programmes-Convertisseur-I2C-PWM-pour-servomoteurs
//  Licence     :       https://creativecommons.org/licenses/by-nc-nd/4.0/deed.fr (BY-NC-ND 4.0 CC)
//
// ===================================================================================================

// Inclusion de la librairie "Wire" (native dans Arduino, donc rien à installer ici)
#include <Wire.h>

// Constantes (ne pas modifier)
#define ADRESSE_I2C_DE_BASE   0x30      // Adresse choisie arbitrairement, pour ce projet
#define BROCHE_DE_SORTIE_PWM  PIN_PA3   // Sortie PWM pour pilotage servomoteur (pin PA3 de l'ATtiny 212)
#define BROCHE_D_ENTREE_A0    PIN_PA7   // Entrée de sélection d'adresse A0 (pin PA7 de l'ATtiny 212)
#define BROCHE_D_ENTREE_A1    PIN_PA6   // Entrée de sélection d'adresse A1 (pin PA6 de l'ATtiny 212)

// Variables
uint8_t adresse_I2C_reelle;  // Tient compte de l'adresse I2C de base spécifiée ci-dessus, et de la position des interrupteurs A0/A1 sur le PCB

// Vérification de sécurité, afin de s'assurer que le timer TCA0 soit bien libre pour nous (sinon, provoque volontairement un message d'erreur à la compilation, avec le message qui suit)
#ifdef MILLIS_USE_TIMERA0
  #error "Ce programme prend la main sur le timer TCA0. Il est donc nécessaire d'utiliser un timer différent dans le menu 'Outils' > 'millis()/micros() Timer', afin de libérer TCA0 !"
#endif


// ========================
// Initialisation programme
// ========================
void setup() {
  
  // Configurations préalables
  configuration_I2C();
  configuration_PWM();

  // Démarrage
  demarrage_I2C_en_mode_ESCLAVE();
}


// =================
// Boucle principale
// =================
void loop() {
  // Rien ici, car "tout" se passe au niveau de l'I2C (ou plus précisément au niveau de la fonction ciblée par "Wire.onReceive", que vous retrouverez tout en bas !)
}


// ============================
// Fonction : configuration_I2C
// ============================
void configuration_I2C() {
  
  // Configuration des entrées de l'ATtiny212 utilisées ici
  pinMode(BROCHE_D_ENTREE_A0, INPUT_PULLUP);
  pinMode(BROCHE_D_ENTREE_A1, INPUT_PULLUP);

  // Petit délai de stabilisation, avant lecture des entrées
  delay(200);

  // Lecture des broches d'entrées A0 et A1, en inversant les niveaux lus
  // (car les interrupteurs A0 et A1 mettent leurs lignes respectives à la masse, lorsqu'actifs)
  int interrupteur_A0 = digitalRead(BROCHE_D_ENTREE_A0) == LOW ? 1 : 0;
  int interrupteur_A1 = digitalRead(BROCHE_D_ENTREE_A1) == LOW ? 1 : 0;

  // Construction de l'adresse I2C finale ("adresse i2c réelle")
  adresse_I2C_reelle = ADRESSE_I2C_DE_BASE | (interrupteur_A1 << 1) | interrupteur_A0;
}

// ============================
// Fonction : configuration_PWM
// ============================
void configuration_PWM() {
  
  // Configuration de la sortie PWM de l'ATtiny212
  pinMode(BROCHE_DE_SORTIE_PWM, OUTPUT);
  digitalWrite(BROCHE_DE_SORTIE_PWM, LOW);  // Avec mise à l'état bas pour commencer, le temps que la configuration PWM soit finalisée

  // Code indispensable à intégrer à notre programme, pour prendre le contrôle de TCA0 "contre" megatinycore
  // (cf. explications techniques 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.)


  // --------------------------------------------
  // Remarques techniques, concernant l'ATtiny212
  // --------------------------------------------
  //  - sur l'ATtiny212, il n'y a qu'un seul port d'E/S : le PORTA (noms de pins = PA0 à PA7, pas toutes exposées sur le boîtier SOIC-8)
  //  - ici, nous allons utiliser la pin PA3 (broche 7 du µC) pour sortir un signal PWM
  //  - par défaut, le timer 16 bits TCA0 est routé sur le PORTA (logique, vu que c'est le seul port disponible, donc pas besoin de toucher à PORTMUX)
  //  - d'après le datasheet, sur PA3, le timer TCA0 permet de sortir les formes d'ondes WO0 et W03
  //  - la forme d'onde sortante (WOx) dépend de la configuration de ce timer, à savoir :
  //      * si TCA0 est configuré en "single mode" (16 bits), alors c'est WO0 (16 bits) qui sortira sur PA3 (notre cas, ici)
  //      * si TCA0 est configuré en "split mode" (2x8 bits), alors :
  //            --> si le comparateur est activé en mode "bas", alors c'est WO0 (8 bits) qui sortira sur PA3
  //            --> si le comparateur est activé en mode "haut", alors c'est WO3 (8 bits) qui sortira sur PA3
  //  - dans notre cas, pour générer un signal PWM 16 bits sur PA3, on va donc utiliser TCA0 en mode "single" et la forme d'onde W00

  // Arrêt du timer TCA0
  TCA0.SINGLE.CTRLA = 0;


  // -------------------------------------------------------------------------------------------
  // Avant d'aller plus loin, je rappelle qu'un servomoteur à commande PWM :
  //  - a besoin d'un signal PWM de fréquence 50 Hz, donc de période 20 ms (1/50), soit 20000 µs
  //  - a besoin d'une durée à l'état haut PWM de :
  //          * 1   ms (soit 1000 µs) pour touner "à fond à gauche"
  //          * 1,5 ms (soit 1500 µs) pour être au centre (position médiane)
  //          * 2   ms (soit 2000 µs) pour touner "à fond à droite"
  // -------------------------------------------------------------------------------------------


  // ------------------------------------------------------
  // Calcul de la valeur PER, pour définir la fréquence PWM
  // ------------------------------------------------------
  // Hypothèses de départ :
  //    - on va faire tourner le CPU interne à l'ATtiny212 à 16 MHz
  //    - on va générer un signal PWM de 50 Hz (normalisé), pour piloter notre servomoteur
  //
  // Formule de calcul "fréquence PWM" (f_PWM), issue du datasheet de l'ATtiny212 :
  //      f_pwm = F_CPU / (prescaler * (PER + 1))
  // d'où
  //      PER = (F_CPU / (f_pwm * prescaler)) - 1
  //
  // Dans notre cas :
  //    - comme F_CPU = 16 MHz
  //    - comme f_pwm = 50 Hz
  //    - si on opte pour prescaler = 16 (division de la vitesse du timer A par 16)
  //    - alors PER = (16000000 / (50 * 16)) - 1 = 19999
  TCA0.SINGLE.CTRLA = TCA_SINGLE_CLKSEL_DIV16_gc;
  TCA0.SINGLE.PER = 19999;  // Pour avoir nos 50 Hz de fréquence PWM (donc 20 ms de période)

  // Fixation du servomoteur "au centre", pour commencer (pour cela, il faut envoyer une impulsion de 1.5ms,
  // en sachant que la période PWM est de 20ms ; au niveau du timer TCA0, il faudra donc prendre 1.5/20 de la valeur max qu'on a choisi)
  TCA0.SINGLE.CMP0 = 1499;  // Formule de calcul exacte : CMP0 = ((PER+1) * 1.5 / 20) - 1 (avec le PER=19999 précédent, on obtient CMP0=1499)

  // Ainsi, avec PER=19999 et CMP0=1499, on aura un signal PWM de période=20000 avec impulsion haute=1500 (valeurs en µs). On retrouve bien
  // nos 20000 µs (soit 20 ms de période) donc 50 Hz de fréquence PWM, et nos 1500 µs (soit 1,5 ms) du temps à l'état haut, ce qui est requis
  // par notre servomoteur pwm pour se mettre en "position neutre" (centrale/médiane)
  

  // ---------------
  // Remarque/astuce
  // ---------------
  //
  // Le fait d'avoir choisi une fréquence CPU de 16 MHz (et un réglage de prescaler sur /16) n'est pas un hasard, je pense que vous l'aurez deviné !
  //
  // En effet, en optant pour une fréquence d'horloge CPU de 16 MHz et une division d'horloge du timer TCA0 par 16,
  // on obtient une vitesse de fonctionnement de 1 MHz (16 MHz/16) pour le timer TCA0. Dit autrement, TCA0 aura
  // une période de fonctionnement de 1 µs (1/1 000 000 Hz). Ainsi, la valeur max de comptage de TCA0 (registre PER)
  // et la valeur du registre de comparaison de TCA0 (registre CMP0) seront, dans ce cas précis/particulier,
  // des valeurs exprimables en microsecondes. En clair, par exemple :
  //    - si on veut que la fréquence PWM soit de 50 Hz (soit une période de 1/50 = 20 ms = 20 000 µs),
  //      alors il suffira de mettre la valeur 20000 dans le registre PER (ou plutôt 19999, car il compte depuis 0 !)
  //    - si on veut que les impulsions hautes du signal PWM ne durent que 1.5 ms (1500 µs) pour que le servomoteur
  //      se mette en position "centrale", alors il suffit de mettre la valeur 1500 dans le registre CMP0 (ou plutôt 1499,
  //      car le compteur TCA0 compte depuis 0 !)
  //
  // Pour la suite, on va donc simplement entrer le nombre de microsecondes d'impulsions PWM souhaité dans CMP0,
  // pour obtenir le signal pwm persistant correspondant !

  // Activation du mode "single slope", et activation du comparateur CMP0 (pour W00, donc)
  TCA0.SINGLE.CTRLB = TCA_SINGLE_WGMODE_SINGLESLOPE_gc | TCA_SINGLE_CMP0EN_bm;

  // Activation du timer TCA0 (et donc de la génération de forme d'onde, et donc d'un signal PWM sur PA3 !), sans écraser la configuration du prescaler
  TCA0.SINGLE.CTRLA = TCA0.SINGLE.CTRLA | TCA_SINGLE_ENABLE_bm;

  // Petit délai de stabilisation, avant de passer à la suite
  delay(200);
}


// ========================================
// Fonction : demarrage_I2C_en_mode_ESCLAVE
// ========================================
void demarrage_I2C_en_mode_ESCLAVE() {
  
  // Initialisation d'un connexion I2C
  Wire.begin(adresse_I2C_reelle);

  // Configuration en mode "esclave" (à l'écoute, donc, avec appel d'une fonction lorsque des données sont reçues)
  Wire.onReceive(fonction_a_executer_en_cas_de_donnees_I2C_recues);
}

// ===========================================================
// Fonction : fonction_a_executer_en_cas_de_donnees_I2C_recues
// ===========================================================
void fonction_a_executer_en_cas_de_donnees_I2C_recues(int nombre_d_octets_recus) {
  
  // Remarque : ici, on va attendre 2 octets de données via l'I2C, spécifiant le nombre de micro-secondes que les impulsions PWM devront avoir.
  // Comme cette valeur d'impulsion sera située entre 1000 (servo complètement "tourné à gauche") et 2000 (tourné "à fond à droite"), et que
  // cela dépasse la capacité d'un octet (2^8 max, donc 255 max), cela est codé sur 2 octets (2^16 max, donc 65535 max). On attend donc 2 octets
  // à chaque fois !
  
  if (nombre_d_octets_recus >= 2) {
    
    // Lecture de 2 octets (faisant 8 bits chacun, donc !)
    uint8_t octet_de_poids_faible = Wire.read();  // Réception de la partie "basse" en premier ("little-endian" choisi, comme du côté "maître I2C")
    uint8_t octet_de_poids_fort = Wire.read();    // Réception de la partie "haute" en second

    // Reconstruction de la valeur de consigne 16 bits (valeur comprise entre 1000 et 2000, pour rappel)
    uint16_t valeur_impulsion_pwm = (octet_de_poids_fort << 8) | octet_de_poids_faible;

    // Mise à jour du comparateur CMP0, pour ajuster le rapport cyclique de notre signal PWM (donc la durée de ses impulsions à l'état haut)
    TCA0.SINGLE.CMP0BUF = valeur_impulsion_pwm;

    // Nota : ici, on utilise le registre tampon "TCA0.SINGLE.CMP0BUF", plutôt que de toucher directement au registre "TCA0.SINGLE.CMP0".
    // En fait, ceci est indispensable, pour que la mise à jour de la valeur du comparateur CMP0 ne soit pas modifiée au beau milieu
    // d'une période de génération de signal PWM. Sans quoi, il pourrait y avoir des couacs/bugs (glitches, en anglais), au moment de la
    // modification des bits de ce registre, et donc, de potentiels comportements aléatoires au niveau du servomoteur (se traduisant généralement
    // par des tremblements, au niveau de l'axe de rotation du servo). Donc on fait les choses correctement, pour éviter cela ;)
  } 
}

// ==============================================================================================================
//  Fichier     :       programmeConvertisseurI2CversPWMservoSansCommentaire.ino
//  Créé le     :       13.04.2026
//  Auteur      :       Jérôme TOMSKI
//  Site        :       https://passionelectronique.fr/
//  Licence     :       https://creativecommons.org/licenses/by-nc-nd/4.0/deed.fr (BY-NC-ND 4.0 CC)
// ==============================================================================================================

#include <Wire.h>

#define ADRESSE_I2C_DE_BASE   0x30
#define BROCHE_DE_SORTIE_PWM  PIN_PA3
#define BROCHE_D_ENTREE_A0    PIN_PA7
#define BROCHE_D_ENTREE_A1    PIN_PA6

uint8_t adresse_I2C_reelle;

void setup() {  
  configuration_I2C();
  configuration_PWM();
  demarrage_I2C_en_mode_ESCLAVE();
}

void loop() {
}

void configuration_I2C() {
  pinMode(BROCHE_D_ENTREE_A0, INPUT_PULLUP);
  pinMode(BROCHE_D_ENTREE_A1, INPUT_PULLUP);
  delay(200);

  int interrupteur_A0 = digitalRead(BROCHE_D_ENTREE_A0) == LOW ? 1 : 0;
  int interrupteur_A1 = digitalRead(BROCHE_D_ENTREE_A1) == LOW ? 1 : 0;
  adresse_I2C_reelle = ADRESSE_I2C_DE_BASE | (interrupteur_A1 << 1) | interrupteur_A0;
}

void configuration_PWM() {
  pinMode(BROCHE_DE_SORTIE_PWM, OUTPUT);
  digitalWrite(BROCHE_DE_SORTIE_PWM, LOW);

  PORTMUX.CTRLC = PORTMUX_TCA00_DEFAULT_gc;
  takeOverTCA0();

  TCA0.SINGLE.CTRLA = 0;
  TCA0.SINGLE.CTRLA = TCA_SINGLE_CLKSEL_DIV16_gc;
  TCA0.SINGLE.PER = 19999;
  TCA0.SINGLE.CMP0 = 1499;
  TCA0.SINGLE.CTRLB = TCA_SINGLE_WGMODE_SINGLESLOPE_gc | TCA_SINGLE_CMP0EN_bm;
  TCA0.SINGLE.CTRLA = TCA0.SINGLE.CTRLA | TCA_SINGLE_ENABLE_bm;
  delay(200);
}


void demarrage_I2C_en_mode_ESCLAVE() {
  Wire.begin(adresse_I2C_reelle);
  Wire.onReceive(fonction_a_executer_en_cas_de_donnees_I2C_recues);
}

void fonction_a_executer_en_cas_de_donnees_I2C_recues(int nombre_d_octets_recus) {
  if (nombre_d_octets_recus >= 2) {
    uint8_t octet_de_poids_faible = Wire.read();
    uint8_t octet_de_poids_fort = Wire.read();
    uint16_t valeur_impulsion_pwm = (octet_de_poids_fort << 8) | octet_de_poids_faible;
    TCA0.SINGLE.CMP0BUF = valeur_impulsion_pwm;
  } 
}

// ===================================================================================================
//   ______               _                  _///_ _           _                   _
//  /   _  \             (_)                |  ___| |         | |                 (_)
//  |  [_|  |__  ___  ___ _  ___  _ __      | |__ | | ___  ___| |_ _ __ ___  _ __  _  ___  _   _  ___
//  |   ___/ _ \| __|| __| |/ _ \| '_ \_____|  __|| |/ _ \/  _|  _| '__/   \| '_ \| |/   \| | | |/ _ \
//  |  |  | ( ) |__ ||__ | | ( ) | | | |____| |__ | |  __/| (_| |_| | | (_) | | | | | (_) | |_| |  __/
//  \__|   \__,_|___||___|_|\___/|_| [_|    \____/|_|\___|\____\__\_|  \___/|_| |_|_|\__  |\__,_|\___|
//                                                                                      | |
//                                                                                      \_|
// ===================================================================================================
//
//  Nom Projet  :       Convertisseur I2C → PWM pour servomoteur
//  Desc Projet :       Programme "I2C maître", tournant sur Arduino Uno, permettant d'envoyer des
//                      commandes de test sur le bus I2C, à destination d'un convertisseur I2C → PWM,
//                      pilotant un servomoteur PWM
//
//  Fichier     :       programmeDeTestServoI2C.ino
//  Créé le     :       09.04.2026
//  Auteur      :       Jérôme TOMSKI
//  Site        :       https://passionelectronique.fr/
//  GitHub      :       https://github.com/PassionElectronique/Programmes-Convertisseur-I2C-PWM-pour-servomoteurs
//  Licence     :       https://creativecommons.org/licenses/by-nc-nd/4.0/deed.fr (BY-NC-ND 4.0 CC)
//
// ===================================================================================================


//-----------------------------------------------
// Où trouver les lignes I2C sur un Arduino Uno ?
//-------------------------------------------------------
//    - on retrouve SDA sur la broche A4 de l'Arduino Uno
//    - on retrouve SCL sur la broche A5 de l'Arduino Uno
//-------------------------------------------------------


// Inclusion de la librairie "Wire" (native dans Arduino, donc rien à installer ici)
#include <Wire.h>

// Constantes
#define ADRESSE_I2C_DU_CONVERTISSEUR_PWM_SERVO  0x30      // Adresses possibles : 0x30, 0x31, 0x32, ou 0x33 (selon configuration des microswitches)


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

  // Initialisation du bus I2C (indispensable, pour fonctionnement en "maître I2C")
  Wire.begin();
  
  // Petite pause, avant de passer à la fonction loop
  delay(1000);
}


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

  // -----------
  // POUR RAPPEL
  // -------------------------------------------------------------------------------------------------------------------
  // Un servomoteur PWM requiert un signal pwm dont les durées d'impulsions (états hauts) doivent être comprises entre :
  //    - 1ms (servo tourné "tout à gauche")
  //    - et 2ms (servo tourné "tout à droite")
  //
  // Entre ces deux positions, on peut prendre toutes les valeurs qu'on veut, en sachant que 1.5ms
  // représente la position "médiane" (axe du servo au centre, si vous préférez)
  // -------------------------------------------------------------------------------------------------------------------


  // Tourner le servomoteur "vers la gauche" (-90°) -> pour cela, on demande au convertisseur I2C/PWM de générer des impulsions PWM de 1ms (soit 1000 µs)
  envoyer_valeur_16bits_via_bus_I2C(1000);
  delay(1000);

  // Mettre le servomoteur "au centre" (0°) -> pour cela, on demande au convertisseur I2C/PWM de générer des impulsions PWM de 1.5ms (soit 1500 µs)
  envoyer_valeur_16bits_via_bus_I2C(1500);
  delay(1000);

  // Tourner le servomoteur "vers la droite" (+90°) -> pour cela, on demande au convertisseur I2C/PWM de générer des impulsions PWM de 2ms (soit 2000 µs)
  envoyer_valeur_16bits_via_bus_I2C(2000);
  delay(1000);

  // Mettre le servomoteur "au centre" (0°) -> pour cela, on demande au convertisseur I2C/PWM de générer des impulsions PWM de 1.5ms (soit 1500 µs)
  envoyer_valeur_16bits_via_bus_I2C(1500);
  delay(1000);

  // Pause supplémentaire, entre chaque bouclage (infini)
  delay(2000);


  // ----------------------------------------
  // Remarques importantes, d'aspect pratique
  // -------------------------------------------------------------------------------------------------------------------------------------------------------
  // 1) suivant le modèle de servomoteur que vous avez, il se peut que "tourner à gauche" de mon côté corresponde à "tourner à droite" du vôtre !
  // 2) suivant le modèle de servomoteur que vous avez, il se peut également que les valeurs 1000 (1 ms) et 2000 (2 ms) ne correspondent pas à +/- 90° ;
  //    dans ce cas, il convient d'augmenter ou diminuer ces valeurs, pour atteindre l'angle souhaité (dans mon cas, j'ai dû descendre la valeur 1000 à 500,
  //    et augmenter la valeur 2000 à 2500, pour que mon servo atteigne respectivement les angles -90° et +90° environ)
  // 3) si vous changez l'adresse I2C côté "convertisseur I2C/PWM" (via les microswitches), il faudra aussi penser à mettre à jour cette adresse I2C ici,
  //    tout en haut du programme, et de faire un reset aussi bien côté "maître I2C" (Arduino Uno), que "esclave I2C" (ATtiny212)
  // -------------------------------------------------------------------------------------------------------------------------------------------------------
  
}


// ============================================
// Fonction : envoyer_valeur_16bits_via_bus_I2C
// ============================================
void envoyer_valeur_16bits_via_bus_I2C(uint16_t valeur) {
  
  Wire.beginTransmission(ADRESSE_I2C_DU_CONVERTISSEUR_PWM_SERVO); // Début de la transmission I2C (envoi de l'adresse i2c cible / mode écriture sur le bus I2C)
  Wire.write(lowByte(valeur));                                    // Envoi du 1er  octet de données (octet de poids faible, car "little-endian" choisi pour "maître" et "esclave" I2C ici)
  Wire.write(highByte(valeur));                                   // Envoi du 2ème octet de données (octet de poids fort, cette fois-ci)
  Wire.endTransmission();                                         // Fin de la transmission I2C
}

// ================================================================================================
//  Fichier     :       programmeDeTestServoI2CSansCommentaire.ino
//  Créé le     :       13.04.2026
//  Auteur      :       Jérôme TOMSKI
//  Site        :       https://passionelectronique.fr/
//  Licence     :       https://creativecommons.org/licenses/by-nc-nd/4.0/deed.fr (BY-NC-ND 4.0 CC)
// ================================================================================================

#include <Wire.h>
#define ADRESSE_I2C_DU_CONVERTISSEUR_PWM_SERVO  0x30

void setup() {
  Wire.begin();
  delay(1000);
}

void loop() {
  envoyer_valeur_16bits_via_bus_I2C(1000);  delay(1000);
  envoyer_valeur_16bits_via_bus_I2C(1500);  delay(1000);
  envoyer_valeur_16bits_via_bus_I2C(2000);  delay(1000);
  envoyer_valeur_16bits_via_bus_I2C(1500);  delay(1000);
  delay(2000);
}

void envoyer_valeur_16bits_via_bus_I2C(uint16_t valeur) {  
  Wire.beginTransmission(ADRESSE_I2C_DU_CONVERTISSEUR_PWM_SERVO);
  Wire.write(lowByte(valeur));
  Wire.write(highByte(valeur));
  Wire.endTransmission();
}