Affichage précis de profondeur de perçage avec capteur gyro et Arduino Nano

Composants et fournitures

Composant	Quantité
Arduino Nano R3	1

Autres composants non listés dans le tableau original mais nécessaires :

• Capteur gyro/accéléromètre GY-521 (MPU-6050)
• Module afficheur 7 segments 8 digits (SPI avec MAX7219)
• Bouton poussoir
• Interrupteur marche/arrêt
• Alimentation : pinces pour piles AA/AAA ou power bank
• Boîtier imprimé en 3D
• Aimant néodyme

Outils et machines nécessaires

• Imprimante 3D (générique, ex. Anycubic i3 Mega)

Applications et services en ligne

• Arduino IDE

À propos de ce projet

Si vous devez percer à une profondeur précise, une perceuse à colonne avec affichage de profondeur est idéale. La plupart ont une règle graduée avec un curseur. La réussite dépend de la précision de votre lecture. Voici une alternative : un afficheur de profondeur de perçage avec capteur gyro et afficheur 7 segments piloté par Arduino.

La machine que j'utilise le plus dans mon atelier n'est pas une scie ou une meuleuse, c'est la perceuse à colonne. Quel que soit le projet, elle sert toujours. Pour une profondeur précise, j'utilise la règle intégrée et mémorise la cible. Ça marche bien.

Mais avec l'âge – oui, oui, oui – il devient de plus en plus difficile de lire la profondeur au millimètre près. Et si la lumière est faible, c'est presque impossible. Mettre des lunettes juste pour ça ? Et où les ranger après ? Je n'en suis pas encore là.

Fidèle à la devise de Paul Akers (« 2 Second Lean ») : Il doit exister une meilleure solution, il suffit de la réfléchir et de la faire.

Possibilités de mesure

Une loupe devant l'échelle améliorerait la lecture, mais pas le fait de devoir mémoriser la mesure. Et le bricolage doit rester amusant.

Une solution électronique est bien meilleure, de préférence compacte pour tenir près de l'interrupteur marche/arrêt. L'Arduino Nano est parfait : assez de broches, très petit.

Comment mesurer la profondeur ? Plusieurs options :

• Ultrason : possible, mais nécessite une mécanique mobile servant de réflecteur.
• Encodeur à fil (wire-actuated encoder) : complexe à fabriquer soi-même (plateau tournant, barrières optiques, rappel à ressort).
• Encodeur rotatif : moins de composants, mais trop grossier, il faudrait des engrenages pour la réduction.

Réfléchissons autrement. Ma perceuse, comme la plupart, a un volant latéral pour régler la profondeur. Il tourne d'environ 270° (pas même un tour complet).

C'est parfait pour une mesure d'angle avec un capteur gyro. Le câble ne peut pas s'enrouler, un seul composant peu coûteux suffit. Le capteur se fixe facilement directement sur l'axe du volant.

Concept

Ma procédure habituelle pour définir une profondeur : effleurer la surface avec le foret, noter la position, ajouter la profondeur voulue, puis percer jusqu'à l'atteinte.

Je veux garder ce processus de base. Pour ne pas percer trop profond, je veux être informé quand la profondeur cible est atteinte.

Un bouton assume cette fonction : quand on appuie, l'Arduino mémorise la position actuelle comme valeur d'arrêt et peut me le rappeler quand elle est atteinte.

Les autres composants (Arduino, afficheur, batterie) prennent plus de place et pèsent plus. Heureusement, le corps de ma machine est en métal. J'utilise un aimant néodyme pour le fixer. Si l'ensemble gêne, on l'enlève vite.

Reste la fixation du capteur sur la machine. L'axe du foret a un écrou hexagonal de 17 mm (SW17). Il suffit d'une pièce imprimée en 3D qui reçoit le capteur et s'emboîte sur l'écrou hexagonal.

Composants requis

• Arduino Nano
• Capteur gyro GY-521 (MPU-6050)
• Module 7 segments 8 digits (version SPI avec MAX7219)
• Bouton poussoir
• Interrupteur marche/arrêt
• Alimentation : pinces piles AA/AAA ou power bank
• Boîtier imprimé 3D
• Aimant néodyme

Connexion du capteur gyro

Le GY-521 communique en I2C. On utilise donc les broches A5 et A4 du Nano.

• VCC → 5V
• GND → GND
• SCL → A5
• SDA → A4
• XDA → non connecté
• XCL → non connecté
• ADO → non connecté
• INT → non connecté

Module 7 segments

Toutes les broches numériques conviennent. Les broches sont définies dans le sketch.

• VCC → 3,3V
• GND → GND
• DIN → D12
• CS → D10
• CLK → D11

Bouton

La broche d'entrée du bouton est libre. J'utilise D9.

Alimentation

J'utilise 6 piles AA. Après l'interrupteur, elles alimentent tout le système.

Boîtier

Conçu avec Autodesk Fusion 360. Imprimé sur Anycubic i3 Mega. L'aimant néodyme pour la fixation sur la machine est collé dans le boîtier. Si l'affichage gêne, on l'enlève rapidement.

Sketch Arduino

J'ai utilisé la bibliothèque LedControl.h pour piloter l'afficheur 7 segments. Si pas installée, l'installer via le gestionnaire de bibliothèques.

Le capteur gyro est sur le bus I2C. Pour les bibliothèques possibles, j'ai décidé de n'en utiliser aucune. La communication se fait via Wire.h.

En fin d'article, quelques liens utiles.

Le pilotage de l'afficheur 7 segments fonctionne très bien avec LedControl. Après l'initialisation avec les broches, le setup() ne fait que quelques préparatifs : réveiller l'afficheur et régler l'intensité.

Dans loop(), l'afficheur montre seulement la profondeur actuelle et, si définie, la position d'arrêt.

L'afficheur attend chaque chiffre en type caractère. Je veux une décimale pour la précision. La fonction dtostrf convertit un float en tableau de caractères, puis en String pour l'afficher chiffre par chiffre.

dtostrf(currentPos, 4, 1, txt);
s = ' ' + String(txt);
lc.setChar(0, 4, s.charAt(s.length()-1), false);
lc.setChar(0, 5, s.charAt(s.length()-3), true);  // point décimal
lc.setChar(0, 6, s.charAt(s.length()-4), false);
lc.setChar(0, 7, s.charAt(s.length()-5), false);

Quand la position d'arrêt est atteinte, « StOP » s'affiche. Le petit « t » est généré via setRow avec le motif binaire B00001111.

La lecture du gyro se fait via les fonctions de la bibliothèque Wire. J'utilise uniquement l'accéléromètre pour déterminer la position angulaire.

Problème majeur : Avec la connexion USB à l'IDE Arduino, tout fonctionnait parfaitement. Après débranchement et alimentation externe, le capteur ne renvoyait plus de données. Il ne refonctionnait qu'après un reset de l'Arduino.

Cela m'a donné le plus de fil à retordre dans tout le projet. On pourrait dire que l'indicateur de profondeur a sauvé mes yeux, mais m'a fait arracher presque tous mes cheveux !

Après de longues recherches, ajouter un temps d'attente après le réveil du capteur a été la solution. Ce delay(1000) est la commande la plus importante de tout le code source.

// Préparation capteur GY-521
// On utilise seulement les données accéléromètre
Wire.begin();
Wire.beginTransmission(MPU);
Wire.write(0x6B);
Wire.write(0x00); // Réveil MPU
Wire.endTransmission(true);

// CE DÉLAI ÉTAIT INDISPENSABLE DANS MON CAS !
delay(1000);

Wire.beginTransmission(MPU);
Wire.write(0x1C); // Registre ACCEL_CONFIG
Wire.write(0x10); // 00010000 pour plage ±8g
Wire.endTransmission(true);

Des valeurs d'offset doivent être déterminées au démarrage, sinon les valeurs fluctuent. Dans setup(), 100 mesures sont faites et les écarts sont moyennés.

Calculer l'angle à partir des données du capteur n'est pas trivial. Beaucoup de tutoriels existent.

L'angle X en degrés se calcule ainsi :

AccAngleX = (atan(AccY / sqrt(pow(AccX, 2) + pow(AccZ, 2))) * rad_to_deg);

Mais les valeurs de l'accéléromètre fluctuent beaucoup. On moyenne donc la valeur actuelle avec la précédente à 50 % chacune :

TotalAngleX = 0.5 * TotalAngleX + 0.5 * AccAngleX;

Le capteur sort des angles de -90° à +90°. Mais j'ai besoin de 0° à 360° pour la conversion en profondeur. Pas trouvé de solution simple. Pour mon usage, il suffit de tester les signes de Z et Y et de convertir en conséquence :

delta = 0;
if (AccZ < 0) {
  delta = 180.0 - TotalAngleX * 2.0;
}
if (AccZ > 0 && AccY < 0) {
  delta = 360.0;
}
DrillingMachineAngle = TotalAngleX + delta;

// Si proche de 360°, afficher 0°
if (DrillingMachineAngle > 350) { DrillingMachineAngle = 0; }

Il manque l'angle maximal de rotation du volant. Le plus simple : faire afficher l'angle déterminé via Serial.print et noter le maximum. Pour moi, c'est 316°. Avec une profondeur max de 50 mm, la position actuelle se calcule :

currentPos = 50.0 / 316.0 * DrillingMachineAngle;

Si le bouton est pressé, l'Arduino mémorise la position actuelle. « 8888 » s'affiche et on attend 1 seconde.

Si une position d'arrêt est définie, la profondeur restante jusqu'à l'arrêt s'affiche sur l'afficheur de droite.

Assemblage et test

Le capteur gyro se fixe idéalement avec un point de colle chaude. Faire passer les fils de connexion par le couvercle. C'est tout pour cette partie.

Au premier test, le capteur gyro doit être aligné. Je l'ai installé horizontalement. Comme le support est rotatif, on l'ajuste facilement jusqu'à ce que « 0.0 » s'affiche.

Puis le premier test peut commencer.

Dans l'ensemble, je suis très satisfait. Le capteur réagit très vite et les valeurs calculées correspondent exactement à la profondeur de perçage.

Et grâce au grand affichage LED, je n'aurai pas besoin de lunettes jusqu'à 85 ans pour lire une profondeur exacte !

Rappelez-vous toujours ce que dit Paul : Répare ce qui t'agace !

Amusez-vous bien à le construire !

___________________________________________________________

Liens utiles :

• Travailler avec MPU6050 GY-521 (partie 1)
• Arduino Playground MPU-6050
• Interfaçage MPU6050 avec Arduino
• Bibliothèque GY-521 par Rob Tillaart
• Livre de Paul Akers « 2 Second Lean »
• Version allemande : techpluscode.de

Code

drilling-depth.ino – Sketch Arduino complet :

/* program: drilling-depth.ino
 * author: Thomas Angielsky
 * version: 2021-03-20
 * https://techpluscode.de/
 * https://techpluscode.de/bohrtiefenanzeige-mit-gyro-sensor/
 * this sketch measures the drilling depth of a table drilling
 * machine by using data of GY-521 gyro sensor
 * depth is viewed by 7 segment display
 * idea of calc error compensation from electronoobs.com - thanks!
 */
#include <Wire.h>
#include <math.h>
#include "LedControl.h"

#define MPU 0x68
char txt[8];
String s;
float currentPos, stopPos;
float rad_to_deg;
float AccX, AccY, AccZ;
float AccAngleX, AccAngleY;
float AccAngleErrorX, AccAngleErrorY;
float TotalAngleX, TotalAngleY;
float DrillingMachineAngle, delta;

// Init LED's: pin D12, pin D11, pin D10, 1 module
LedControl lc = LedControl(12, 11, 10, 1);

void setup() {
  // Serial.begin(9600);
  stopPos = 0.0;
  currentPos = 0.0;
  rad_to_deg = 180 / PI;

  // Préparation capteur GY-521 (accéléromètre seulement)
  Wire.begin();
  Wire.beginTransmission(MPU);
  Wire.write(0x6B);
  Wire.write(0x00); // wake up MPU
  Wire.endTransmission(true);

  // CE DÉLAI ÉTAIT INDISPENSABLE DANS MON CAS !
  delay(1000);

  Wire.beginTransmission(MPU);
  Wire.write(0x1C); // registre ACCEL_CONFIG
  Wire.write(0x10); // 00010000 pour ±8g
  Wire.endTransmission(true);

  // Calculer l'erreur accéléromètre (100 mesures)
  for (int a = 0; a < 100; a++) {
    Wire.beginTransmission(MPU);
    Wire.write(0x3B);
    Wire.endTransmission(false);
    Wire.requestFrom(MPU, 6, true);
    AccX = (Wire.read() << 8 | Wire.read()) / 4096.0;
    AccY = (Wire.read() << 8 | Wire.read()) / 4096.0;
    AccZ = (Wire.read() << 8 | Wire.read()) / 4096.0;
    AccAngleErrorX += (atan(AccY / sqrt(pow(AccX, 2) + pow(AccZ, 2))) * rad_to_deg);
  }
  AccAngleErrorX /= 100;

  // Bouton: pin D9
  pinMode(9, INPUT_PULLUP);

  // Afficheur 7 segments
  lc.shutdown(0, false);
  lc.setIntensity(0, 8);
  lc.clearDisplay(0);
}

void loop() {
  Wire.beginTransmission(MPU);
  Wire.write(0x3B);
  Wire.endTransmission(false);
  Wire.requestFrom(MPU, 6, true);
  AccX = (Wire.read() << 8 | Wire.read()) / 4096.0;
  AccY = (Wire.read() << 8 | Wire.read()) / 4096.0;
  AccZ = (Wire.read() << 8 | Wire.read()) / 4096.0;

  AccAngleX = (atan(AccY / sqrt(pow(AccX, 2) + pow(AccZ, 2))) * rad_to_deg) - AccAngleErrorX;

  // Lissage
  TotalAngleX = 0.5 * TotalAngleX + 0.5 * AccAngleX;

  // Convertir en angle 0-360°
  delta = 0;
  if (AccZ < 0) {
    delta = 180.0 - TotalAngleX * 2.0;
  }
  if (AccZ > 0 && AccY < 0) {
    delta = 360.0;
  }
  DrillingMachineAngle = TotalAngleX + delta;
  if (DrillingMachineAngle > 350) { DrillingMachineAngle = 0; }

  // Calculer profondeur
  // Profondeur max: 50 mm (mesuré sur machine)
  // Angle max volant: 316° (mesuré via Serial.print)
  currentPos = 50.0 / 316.0 * DrillingMachineAngle;

  // Bouton pressé ?
  if (digitalRead(9) == LOW) {
    stopPos = currentPos;
    lc.setChar(0, 3, '8', false);
    lc.setChar(0, 2, '8', false);
    lc.setChar(0, 1, '8', false);
    lc.setChar(0, 0, '8', false);
    delay(1000);
  }

  if (stopPos > 0) {
    if (currentPos >= stopPos) {
      // Position d'arrêt atteinte : afficher STOP (5t0P) à droite
      lc.setChar(0, 3, '5', false);
      lc.setRow(0, 2, B00001111); // petit 't'
      lc.setChar(0, 1, '0', false);
      lc.setChar(0, 0, 'P', false);
    } else {
      // Afficher distance restante
      dtostrf(stopPos - currentPos, 4, 1, txt);
      s = ' ' + String(txt);
      lc.setChar(0, 0, s.charAt(s.length()-1), false);
      lc.setChar(0, 1, s.charAt(s.length()-3), true);
      lc.setChar(0, 2, s.charAt(s.length()-4), false);
      lc.setChar(0, 3, s.charAt(s.length()-5), false);
    }
  } else {
    // Rien à afficher à droite
    lc.setChar(0, 3, ' ', false);
    lc.setChar(0, 2, ' ', false);
    lc.setChar(0, 1, ' ', false);
    lc.setChar(0, 0, ' ', false);
  }

  // Afficher profondeur actuelle à gauche
  dtostrf(currentPos, 4, 1, txt);
  s = ' ' + String(txt);
  lc.setChar(0, 4, s.charAt(s.length()-1), false);
  lc.setChar(0, 5, s.charAt(s.length()-3), true);
  lc.setChar(0, 6, s.charAt(s.length()-4), false);
  lc.setChar(0, 7, s.charAt(s.length()-5), false);

  delay(200);
}

Pièces personnalisées et boîtiers

drilling-depth-3d-model_Yn2q0MSNa4.zip – Modèle 3D du boîtier et support capteur (Fusion 360).

Schémas