Transformer N'importe Quel Moteur DC en Servo 360° Personnalisé – Guide Pas à Pas

Dans ce tutoriel, nous apprenons à transformer n'importe quel moteur DC en servomoteur autonome custom avec plein de fonctions. Contrairement aux servos classiques limités à 180 ou 270°, celui-ci a une plage illimitée de 360° et on peut ajuster la plage de rotation à la valeur voulue.

C'est bien pratique, et en plus on peut régler le point central du servo. On ajuste donc à la fois le centre et l'amplitude de rotation.

Regardez la vidéo ou suivez le tutoriel écrit.

Autre fonction : réglage de la sensibilité (réactivité). Côté entrées, 3 modes différents.

Contrôle par tension analogique / potentiomètre, par radiocommande RC, ou via port série en entrant des valeurs d'angle dans le moniteur série sur PC/portable.

On peut même combiner : contrôler par le moniteur série ET manuellement via la radiocommande. Le servo connaît sa position en permanence et l'affiche sur le moniteur série.

Cerise sur le gâteau : le mode rotation continue. On contrôle et suit la position du servo même en rotation continue. On peut commander n'importe quelle position avec un nombre infini de tours.

Tout ça grâce à l'encodeur 12 bits AS5600 (capteur de position rotatif magnétique) et au contrôle PID pour piloter le moteur DC.

J'ai conçu cette carte contrôleur servo custom qui intègre son propre microcontrôleur et tout le nécessaire pour transformer n'importe quel moteur DC en servo autonome.

Il suffit de positionner la carte au centre de l'arbre de sortie (avec un aimant spécifique sur l'arbre), connecter n'importe quel moteur DC jusqu'à 3,5 A nominal, alimenter en 12 V, et c'est parti : un servo complet avec toutes ces fonctions.

Je vous guide à travers toute la fabrication de ce servomoteur custom : principe de fonctionnement d'un servo, boucle fermée, PID, conception PCB custom et boîte d'engrenages, explication du code.

Principe de Fonctionnement d'un Servomoteur

Pour comprendre, démontons un servo RC classique.

À l'intérieur : petit moteur DC, carte contrôleur, potentiomètre, connexion 3 fils (2 alimentation, 1 signal). Et des engrenages pour réduire la vitesse et augmenter le couple.

C'est la config standard des servos RC/loisirs. Le potentiomètre est sur l'arbre de sortie et agit comme capteur de position : il dit au contrôleur la position actuelle. La carte contrôle le moteur selon le signal d'entrée (position désirée) et la position réelle (rétroaction potentiomètre). C'est un système à boucle fermée.

Le signal d'entrée (position désirée) est comparé à la position réelle (capteur de rétroaction). La différence (erreur) est traitée par le contrôleur qui commande le moteur jusqu'à atteindre la position désirée.

Comment Fabriquer un Servomoteur Custom

Pour construire notre propre servo avec des moteurs DC plus gros que les servos RC standards, on implémente la même boucle fermée.

Il faut un capteur de position sur l'arbre de sortie et un microcontrôleur pour piloter le moteur DC.

Pour le capteur, la solution simple est un potentiomètre comme dans les servos RC. Problème : rotation limitée à 270°, ce qui limite directement la plage du servo. Il existe des potentiomètres multi-tours pour plus de plage/résolution, mais rotation quand même limitée.

Si on veut une rotation illimitée, il faut un encodeur. Les encodeurs sont des dispositifs électromécaniques qui suivent la position angulaire avec rotation illimitée. Plusieurs types : incrémentaux/absolus, ou selon technologie : optique, magnétique, capacitif. Chacun a ses avantages/inconvénients.

Encodeur AS5600 – Capteur de Position Rotatif Magnétique

J'ai choisi un encodeur magnétique, l'AS5600, car il est très compact, facile à intégrer, et offre haute précision/résolution. Regardez comme ce microchip est petit.

Il a un capteur Hall intégré qui détecte les changements de direction du champ magnétique. Il suffit de coller un aimant sur l'arbre de sortie du moteur et de le placer près du microchip (0,5 à 3 mm).

Quand l'arbre et l'aimant tournent, le capteur Hall capture les changements de direction du champ. Grâce à son convertisseur A/N 12 bits intégré, l'AS5600 sort 4 096 positions par tour (360°).

Soit une détection de variation angulaire de 0,0878°. Très impressionnant, et vu son prix abordable et sa disponibilité, c'est le bon choix pour un servo custom.

Il faut aussi un microcontrôleur et un driver moteur DC. J'ai choisi le driver DRV8871 (jusqu'à 3,5 A) et l'ATmega328.

Version CMS (surface mount) de l'ATmega328, bien plus compacte que DIP. Mon but : PCB custom le plus petit possible intégrant tout pour un servo autonome.

Schéma de Câblage du Servomoteur Custom

Voici le schéma complet de ce servomoteur custom.

Composants nécessaires :

• Encodeur magnétique AS5600 ………………….. Amazon / AliExpress
• Driver DC DRV8871 ……………….…. Amazon / AliExpress
• ATmega328p-AU …………………………………. Amazon / AliExpress
• Oscillateur à quartz 16 MHz …………………….. Amazon / AliExpress
• Régulateur 5 V AMS1117 ………..…. Amazon / AliExpress
• Potentiomètre carré 3386P ………………. Amazon / AliExpress
• Kit condensateurs 0805 …………………………….…. Amazon / AliExpress
• Moteur DC 12 V – ~50 tr/min …………….……. Amazon / AliExpress

Note : Ce sont des liens d'affiliation. En tant qu'associé Amazon, je gagne sur les achats éligibles.

On a l'ATmega328 avec son circuit minimal recommandé : quartz 16 MHz, quelques condos, une résistance.

Pour alimenter le microcontrôleur et les composants 5 V : régulateur AMS1117 qui abaisse 12 V → 5 V.

L'AS5600 avec son circuit recommandé : 2 condos + 2 résistances de pull-up pour la communication I2C.

Le DRV8871 a besoin d'une résistance de limitation de courant et 2 condos de découplage. Puis 2 potentiomètres sur entrées analogiques du micro : un pour régler la plage de rotation, l'autre la sensibilité. Bouton poussoir pour définir le point central. DIP switch 2 voies pour sélectionner les modes de fonctionnement. Connecteur pour entrées servo : tension analogique ou PWM numérique (récepteur RC), avec 5 V et GND. Connecteur pour programmation micro via SPI et port série.

Récap du circuit et flux : l'entrée (position angulaire désirée) arrive sur ces 2 broches, soit tension analogique (potentiomètre) soit PWM numérique (récepteur RC). L'entrée va dans le microcontrôleur, comparée à la position réelle détectée par l'encodeur AS5600 (communication I2C). Le micro calcule l'erreur et envoie un signal PWM au DRV8871 qui pilote le moteur DC jusqu'à la position désirée.

Le tout alimenté en 12 V, l'AMS1117 fournit le 5 V pour le micro et les composants.

Conception du PCB

D'après le schéma, j'ai essayé de faire le PCB le plus petit possible : 40×40 mm.

L'encodeur est au dos, exactement au centre du PCB, pour un montage/alignement facile avec l'arbre de sortie.

Tous les autres composants de l'autre côté pour ne pas gêner l'encodeur et l'arbre.

Commandé chez PCBWay : upload Gerber, choix propriétés, commande prix raisonnable. PCB 4 couches (couches centrales = GND, coût un peu plus). Juste changé couleur = blanc, et accepté finition or chimique (immersion gold) si applicable sans surcoût.

Fichiers Gerber dispo sur communauté PCBWay pour téléchargement ou commande directe.

Quelques jours plus tard, PCB reçus. Qualité excellente, tout conforme au design, finition or chimique obtenue.

Passons au soudage des composants. J'ai commencé par les petits CMS : LED indicatrice, condos, résistances.

C'était ma première fois à souder des CMS aussi petits, et j'étais vraiment nul.

Le plus dur : l'ATmega328, broches minuscules et très rapprochées, mais j'ai réussi tant bien que mal.

L'AS5600 au dos était facile, ainsi que les composants traversants : DIP switch, potentiomètres, borniers, connecteurs.

Voici l'aspect final de la carte contrôleur, qui s'en sort pas mal je trouve.

Maintenant, il faut faire une boîte d'engrenages adaptée au moteur DC et à cette carte contrôleur.

Modèle 3D du Servo Custom

J'ai conçu la boîte d'engrenages pour ce servo custom avec Onshape. Le design dépend du moteur DC. Comme dit, on peut utiliser n'importe quel moteur DC avec la carte contrôleur.

Ici, moteur DC diam. 37 mm avec réducteur intégré sortant à 50 tr/min. 50 tr/min c'est bien pour un servo, mais je voulais un peu plus bas pour plus de couple → boîte d'engrenages avec réduction 3×. J'ai utilisé des engrenages à chevrons (herringbone) : efficaces et faciles à imprimer en 3D.

Bien sûr, on a toute liberté pour designer cette boîte selon le moteur et les vitesses de sortie voulues.

J'ai positionné la carte contrôleur au dos de la boîte, alignée parfaitement au centre de l'arbre de sortie.

Si on veut utiliser l'arbre du moteur directement comme sortie, on met un rapport 1:1 pour suivre la position correctement. Ou un système courroie. Les possibilités sont infinies.

Téléchargement Modèle 3D et Fichiers STL

Visualisez et explorez le modèle 3D de ce servomoteur custom directement dans votre navigateur via Onshape (compte Onshape requis, gratuit pour usage personnel).

Bien sûr, vous pouvez aussi télécharger le modèle 3D et les fichiers STL pour l'impression 3D :

Fichier STEP :

Fichiers STL pour impression 3D :

Assemblage du Servo Custom

Voici les pièces imprimées en 3D pour commencer l'assemblage.

Avec elles : boulons M3, inserts filetés, roulements.

D'abord, je fixe le moteur DC sur la plaque de base avec boulons M3×8 mm.

Puis j'installe les deux engrenages. Le petit directement sur l'arbre du moteur, le gros = sortie du servo. L'arbre de sortie est en deux parties.

Inserts filetés des deux côtés de cette pièce d'arbre : un côté pour fixer l'engrenage, l'autre pour fixer des accessoires sur la sortie.

Inserts filetés aussi sur le petit engrenage pour le bloquer sur l'arbre moteur. On glisse les engrenages appariés en position. Comme ce sont des engrenages à chevrons, il faut les insérer tous les deux en même temps, sinon impossible de les engrener un par un.

Vis sans tête pour bloquer le petit engrenage sur l'arbre moteur. J'applique 12 V au moteur pour vérifier que l'engrenage fonctionne.

On finit la boîte : panneau latéral, roulement pour l'arbre de sortie, couvercle supérieur.

Inserts M3 sur la plaque arrière pour fixer l'ensemble avec boulons M3×20 mm. Test de la boîte : nickel. On voit l'arbre de sortie tourner au dos, et c'est là qu'on met l'aimant que l'AS5600 suivra.

On fixe la carte contrôleur sur la boîte avec boulons/écrous M2. L'AS5600 est maintenant parfaitement aligné avec l'aimant → mesure correcte du champ magnétique à la rotation.

Important : la direction d'aimantation de l'aimant permanent est cruciale. Selon qu'il est aimanté axialement ou diamétralement, on doit positionner l'aimant soit perpendiculaire, soit parallèle à l'AS5600.

J'ai dû changer l'orientation de mon aimant, car son aimantation n'était pas bonne pour l'AS5600.

Ensuite, j'ai soudé 2 fils au moteur DC et connecté au contrôleur via le bornier. Pour l'alimentation, 2 fils sur le bornier d'alimentation, de l'autre côté connecteur DC pour alim 12 V. Et voilà, notre servomoteur custom est fini.

Programmation du Contrôleur

Reste à donner vie à ce servo : programmer le contrôleur. D'abord, graver le bootloader sur l'ATmega328p. Sans bootloader, le micro ne comprend pas le code qu'on lui enverra.

Gravure du Bootloader

Pour graver le bootloader sur l'ATmega328p, il faut une carte Arduino (ici Arduino Nano).

On utilise la communication SPI : connecter les broches SPI correspondantes sur l'Arduino et notre carte contrôleur.

Dans l'IDE Arduino, ouvrir l'exemple ArduinoISP et l'uploader sur le Nano. Avec ce code, le Nano peut graver le bootloader sur l'ATmega328.

Dans le menu Outils, comme programmateur sélectionner « Arduino as ISP » puis cliquer « Graver le bootloader ».

Pendant la gravure, les LED du Nano clignotent beaucoup → gravure réussie.

Upload du Code

Une fois fait, on programme/uploade le code sur la carte contrôleur via un module USB-UART.

La carte a des broches dédiées pour connexion facile comme sur le schéma.

On ouvre le code de ce servo custom et on l'uploade. Mais avant, installer les bibliothèques AS5600 et PID depuis le gestionnaire de bibliothèques de l'IDE Arduino. Une fois upload lancé, le code est écrit sur l'ATmega328 via le module USB-UART.

C'est fini, notre servo custom est prêt. On branche un potentiomètre pour tester. Note : l'entrée analogique va sur la broche « S » de la carte, pas « A » (erreur de routage sur le PCB lors de la conception).

On sélectionne le mode analogique via le DIP switch et on alimente le servo.

Et voilà, on contrôle la position du servomoteur via l'entrée analogique du potentiomètre. On a réussi à transformer notre moteur DC en servomoteur.

Code Source

Regardons le code de ce servomoteur custom :

/* 
 * Servomoteur Custom - Code Arduino
 * par Dejan, www.HowToMechatronics.com
 * 
 * Bibliothèques :
 * AS5600 encodeur: https://github.com/RobTillaart/AS5600
 * Contrôleur PID: https://github.com/br3ttb/Arduino-PID-Library/blob/master/PID_v1.h
 */
#include "AS5600.h"
#include "Wire.h"
#include 
AS5600 as5600; // utilise Wire par défaut
double Pk1 = 2; // vitesse d'atteinte
double Ik1 = 0;
double Dk1 = 0.025;
// Variables pour PID
double Setpoint, Input, Output;
PID myPID(&Input, &Output, &Setpoint, Pk1, Ik1, Dk1, DIRECT);
#define motor_IN1 5
#define motor_IN2 6
#define ch1 2
#define centerSet 7
#define inputSwitch 3
#define modeSwitch 4
int ch1Value;
int encoderValue, inputValue, pwmValue;
String inString = "";
int centerAngle = 2047; // 180 degrés
int angleDifference = 0;
int angleValue = 0;
int leftLimit = 30;
int rightLimit = 4067;
int rangeAdjustment = 0;
float sensitivityAdjustment = 0;
float angle = 0;
int quadrantNumber = 2;
int previousQuadrantNumber = 3;
int numberOfTurns = 0;
float totalAngle = 0;
int error = 0;
char incomingByte = 0;
int intInput = 0;
void setup() {
  Serial.begin(115200);
  Serial.println(__FILE__);
  Serial.print("AS5600_LIB_VERSION: ");
  Serial.println(AS5600_LIB_VERSION);
  Wire.begin();
  pinMode(motor_IN1, OUTPUT);
  pinMode(motor_IN2, OUTPUT);
  // Pull-up internes Arduino
  pinMode(centerSet, INPUT_PULLUP);
  pinMode(inputSwitch, INPUT_PULLUP);
  pinMode(4, INPUT_PULLUP);
  myPID.SetMode(AUTOMATIC);
  // Config PID
  myPID.SetOutputLimits(-255, 255);
  myPID.SetSampleTime(20);
}
void loop() {
  // Lecture encodeur - position actuelle
  encoderValue = as5600.readAngle();
  // Mode rotation continue
  if (digitalRead(modeSwitch) == 0) {
    // Entrée angle désiré via moniteur série
    while (Serial.available() > 0) {
      int inChar = Serial.read();
      if (isDigit(inChar)) {
        inString += (char)inChar;
      }
      if (inChar == '\n') {
        Setpoint = inString.toInt();
        inString = "";
      }
    }
    if (digitalRead(inputSwitch) == 0) {
      // Potentiomètre comme entrée
      inputValue = analogRead(A0);
      if (inputValue < 400) { Setpoint = Setpoint - 0.3; }
      if (inputValue < 300) { Setpoint = Setpoint - 0.3; }
      if (inputValue < 200) { Setpoint = Setpoint - 0.3; }
      if (inputValue > 600) { Setpoint = Setpoint + 0.3; }
      if (inputValue > 700) { Setpoint = Setpoint + 0.3; }
      if (inputValue > 800) { Setpoint = Setpoint + 0.3; }
    } else if (digitalRead(inputSwitch) == 1) {
      inputValue = pulseIn(ch1, HIGH, 30000); // Récepteur RC
      if (inputValue < 1450) { Setpoint--; }
      if (inputValue < 1350) { Setpoint--; }
      if (inputValue < 1250) { Setpoint--; }
      if (inputValue < 1150) { Setpoint--; }
      if (inputValue > 1550) { Setpoint++; }
      if (inputValue > 1650) { Setpoint++; }
      if (inputValue > 1750) { Setpoint++; }
      if (inputValue > 1850) { Setpoint++; }
    }
    // Conversion valeurs brutes encodeur en angle
    angle = encoderValue * 0.087890625;
    // Quadrant 1
    if (angle >= 0 && angle <= 90) { quadrantNumber = 1; }
    // Quadrant 2
    if (angle >= 90 && angle <= 180) { quadrantNumber = 2; }
    // Quadrant 3
    if (angle >= 180 && angle <= 270) { quadrantNumber = 3; }
    // Quadrant 4
    if (angle >= 270 && angle <= 360) { quadrantNumber = 4; }
    if (quadrantNumber != previousQuadrantNumber) {
      // Transition 4→1
      if (quadrantNumber == 1 && previousQuadrantNumber == 4) { numberOfTurns++; }
      // Transition 1→4
      if (quadrantNumber == 4 && previousQuadrantNumber == 1) { numberOfTurns--; }
      previousQuadrantNumber = quadrantNumber;
    }
    if (totalAngle >= 0) {
      totalAngle = (numberOfTurns * 360) + angle;
    } else {
      totalAngle = (numberOfTurns * 360) + angle;
    }
    // Entrée PID
    Input = totalAngle;
  }
  // Mode rotation limitée
  else if (digitalRead(modeSwitch) == 1) {
    rangeAdjustment = analogRead(A1);
    leftLimit = 0 + 30 + rangeAdjustment;
    rightLimit = 4097 - 30 - rangeAdjustment;
    if (digitalRead(inputSwitch) == 0) {
      // Analogique - Potentiomètre
      inputValue = analogRead(A0);
      if (inputValue < 15) { inputValue = 15; }
      if (inputValue > 1008) { inputValue = 1008; }
      Setpoint = map(inputValue, 15, 1008, -255, 255);
    } else if (digitalRead(inputSwitch) == 1) {
      // Numérique - Récepteur RC
      inputValue = pulseIn(ch1, HIGH, 30000);
      Setpoint = map(inputValue, 1000, 2000, -255, 255);
    }
    // Définir point central
    if (digitalRead(centerSet) == LOW) {
      centerAngle = encoderValue;
      angleDifference = 2047 - encoderValue;
      delay(1000);
    }
    // Ajuster valeur angle selon point central (angleDifference)
    if (centerAngle < 2047) {
      angleValue = encoderValue + angleDifference;
      if (encoderValue < 4097 && encoderValue > (4096 - angleDifference)) {
        angleValue = encoderValue - 4097 + angleDifference;
      }
    }
    if (centerAngle > 2047) {
      angleValue = encoderValue + angleDifference;
      if (encoderValue >= 0 && encoderValue < abs(angleDifference)) {
        angleValue = encoderValue + 4097 + angleDifference;
      }
    } else if (centerAngle == 2047) {
      angleValue = encoderValue;
    }
    // Entrée PID
    Input = map(angleValue, leftLimit, rightLimit, -255, 255);
  }
  // Ajustement sensibilité
  Pk1 = analogRead(A2) * 0.002;
  myPID.SetTunings(Pk1, Ik1, Dk1);
  // Calcul PID
  myPID.Compute();
  // Droite
  if (Output > 1) {
    pwmValue = Output;
    if (pwmValue < 30 && pwmValue > 5) { pwmValue = pwmValue + 30; }
    if (pwmValue <= 5) { pwmValue = 0; }
    digitalWrite(motor_IN1, LOW);
    analogWrite(motor_IN2, pwmValue);
  }
  // Gauche
  else if (Output < 1) {
    pwmValue = abs(Output);
    if (pwmValue < 30 && pwmValue > 5) { pwmValue = pwmValue + 30; }
    if (pwmValue <= 5) { pwmValue = 0; }
    analogWrite(motor_IN1, pwmValue);
    digitalWrite(motor_IN2, LOW);
  }
  // Arrêt
  else if (Output > -1 && Output < 1) {
    pwmValue = 0;
    digitalWrite(motor_IN1, LOW);
    digitalWrite(motor_IN2, LOW);
  }
  //Serial.print(Setpoint);
  //Serial.print("\t");
  //Serial.println(totalAngle);
}

Aperçu du Code

Boucle : lecture encodeur → position actuelle.

// Lecture encodeur - position actuelle
encoderValue = as5600.readAngle();

Si mode rotation continue : on accepte valeurs du moniteur série comme consigne (angle désiré) pour PID.

// Entrée angle désiré via moniteur série
while (Serial.available() > 0) {
  int inChar = Serial.read();
  if (isDigit(inChar)) {
    inString += (char)inChar;
  }
  if (inChar == '\n') {
    Setpoint = inString.toInt();
    inString = "";
  }
}

Si mode potentiomètre : lecture entrée analogique, correction consigne selon rotation.

if (digitalRead(inputSwitch) == 0) {
  inputValue = analogRead(A0);
  if (inputValue < 400) { Setpoint = Setpoint - 0.3; }
  if (inputValue < 300) { Setpoint = Setpoint - 0.3; }
  if (inputValue < 200) { Setpoint = Setpoint - 0.3; }
  if (inputValue > 600) { Setpoint = Setpoint + 0.3; }
  if (inputValue > 700) { Setpoint = Setpoint + 0.3; }
  if (inputValue > 800) { Setpoint = Setpoint + 0.3; }
}

Même correction si entrée = récepteur RC.

Conversion valeurs brutes encodeur en angles, suivi du quadrant par ifs.

// Conversion valeurs brutes en angle
angle = encoderValue * 0.087890625;
if (angle >= 0 && angle <= 90) { quadrantNumber = 1; }
if (angle >= 90 && angle <= 180) { quadrantNumber = 2; }
if (angle >= 180 && angle <= 270) { quadrantNumber = 3; }
if (angle >= 270 && angle <= 360) { quadrantNumber = 4; }

Avec ça, on suit la rotation de l'arbre et les tours complets. L'angle total = entrée PID.

if (quadrantNumber != previousQuadrantNumber) {
  if (quadrantNumber == 1 && previousQuadrantNumber == 4) { numberOfTurns++; }
  if (quadrantNumber == 4 && previousQuadrantNumber == 1) { numberOfTurns--; }
  previousQuadrantNumber = quadrantNumber;
}
if (totalAngle >= 0) {
  totalAngle = (numberOfTurns * 360) + angle;
} else {
  totalAngle = (numberOfTurns * 360) + angle;
}
Input = totalAngle;

Sinon mode rotation limitée : d'abord lecture potentiomètre de réglage plage → ajustement limites gauche/droite.

rangeAdjustment = analogRead(A1);
leftLimit = 0 + 30 + rangeAdjustment;
rightLimit = 4097 - 30 - rangeAdjustment;

Si mode potentiomètre : sa valeur comme consigne PID.

if (digitalRead(inputSwitch) == 0) {
  inputValue = analogRead(A0);
  if (inputValue < 15) { inputValue = 15; }
  if (inputValue > 1008) { inputValue = 1008; }
  Setpoint = map(inputValue, 15, 1008, -255, 255);
}

Si mode récepteur RC : lecture PWM → consigne.

else if (digitalRead(inputSwitch) == 1) {
  inputValue = pulseIn(ch1, HIGH, 30000);
  Setpoint = map(inputValue, 1000, 2000, -255, 255);
}

Pour définir un autre point central : on vérifie si bouton poussoir appuyé, on capture cette position comme nouveau centre.

// Définir angle central
if (digitalRead(centerSet) == LOW) {
  centerAngle = encoderValue;
  angleDifference = 2047 - encoderValue;
  delay(1000);
}

Selon ce centre, on ajuste les lectures encodeur en les décalant de la différence d'angle. Cette valeur = entrée PID.

if (centerAngle > 2047) {
  angleValue = encoderValue + angleDifference;
  if (encoderValue >= 0 && encoderValue < abs(angleDifference)) {
    angleValue = encoderValue + 4097 + angleDifference;
  }
} else if (centerAngle == 2047) {
  angleValue = encoderValue;
}
Input = map(angleValue, leftLimit, rightLimit, -255, 255);

L'autre potentiomètre (entrée analogique) règle le gain proportionnel PID, puis on lance le PID pour obtenir la sortie.

// Ajustement sensibilité
Pk1 = analogRead(A2) * 0.002;
myPID.SetTunings(Pk1, Ik1, Dk1);
myPID.Compute();

La sortie pilote le moteur en PWM (gauche/droite/arrêt) selon l'erreur entre position désirée et réelle.

// Droite
if (Output > 1) {
  pwmValue = Output;
  if (pwmValue < 30 && pwmValue > 5) { pwmValue = pwmValue + 30; }
  if (pwmValue <= 5) { pwmValue = 0; }
  digitalWrite(motor_IN1, LOW);
  analogWrite(motor_IN2, pwmValue);
}

Voilà pour cette vidéo. Notez que le code n'est pas optimisé et perfectible.

Si vous recréez ce projet, préparez-vous au débogage. Beaucoup de choses peuvent foirer, surtout la soudure des CMS.

Je n'ai pas eu ce servo fonctionnel du premier coup. Au début, mauvais connexions sur PCB, puis re-commande PCB avec corrections, mais encore plusieurs essais avant que ça marche.

Cette section de l'article est encore en construction, revenez plus tard….