Affichage de la profondeur de forage avec capteur gyroscopique

Outils et machines nécessaires

Imprimante 3D (générique)

Applications et services en ligne

Arduino IDE

À propos de ce projet

Si vous devez percer une certaine profondeur pour un projet, vous avez besoin d'une perceuse d'établi avec affichage de la profondeur. La plupart des exercices d'établi ont une règle avec une flèche pour la lecture. Le succès du perçage dépend de la précision avec laquelle vous pouvez lire la position souhaitée. Dans ce projet Arduino, je présente une proposition alternative :un affichage de la profondeur de forage avec un capteur gyroscopique et un affichage à 7 segments avec prise en charge Arduino.

La machine que j'utilise le plus souvent dans mon atelier n'est pas une scie ou une rectifieuse. C'est de loin la perceuse d'établi. Quel que soit le projet, il est en fait toujours utilisé. Si j'ai besoin d'une certaine profondeur de perçage, je peux utiliser la règle intégrée sur la machine. Et n'oubliez pas la profondeur à laquelle je dois forer. Cela fonctionne vraiment bien.

Mais avec l'âge - oui, oui, oui - il devient de plus en plus difficile pour moi de lire la profondeur avec une précision millimétrique. Et si la lumière n'est pas assez vive, il est presque impossible de la lire. Mais juste mettre des lunettes pour ça ? Et après perçage, où ranger les lunettes ? Je ne suis pas encore si loin.

Fidèle à la devise de Paul Akers de "2 Secon Lean":

Il doit y avoir une meilleure solution, il suffit d'y penser et de la faire.

Mesurer les possibilités

Je pourrais bien sûr mettre une loupe devant la balance pour faciliter la lecture de la règle. Cela améliorerait la lecture, mais cela n'aiderait pas que je doive me souvenir de la mesure dans chaque cas. Et si vous faites de l'artisanat, ça devrait être amusant aussi.

C'est pourquoi une solution électronique est bien meilleure. De préférence dans un petit espace pour que tout rentre à côté de l'interrupteur marche/arrêt de la perceuse. Pour de tels cas, j'aime utiliser un Arduino Nano. Il a suffisamment de broches pour contrôler à peu près tout et est donc petit.

Mais comment mesurer la profondeur de forage ? Il existe plusieurs possibilités pour une mesure de longueur. Installer une mesure par ultrasons ? Pourrait fonctionner, mais seulement avec un peu de mécanique, qui se déplace avec la perceuse comme une surface de réflexion. Ou utiliser un encodeur à fil ? Serait possible, mais très complexe, si vous le construisez vous-même :avec une platine, des barrières lumineuses à fourche et un ressort de rappel. Mieux vaut prendre un encodeur rotatif tout de suite ? Cela signifierait beaucoup moins de composants - oui, mais ce serait trop grossier, il faudrait installer des engrenages pour une traduction.

D'accord, alors réfléchissez-y davantage.

Ma perceuse, comme la plupart, a un volant sur le côté pour régler la profondeur. Il peut être tourné d'env. 270°. Donc même pas un tour complet.

C'est parfait pour une mesure d'angle avec un capteur gyroscopique. La connexion par câble ne peut pas se tordre et un seul composant bon marché est nécessaire. Le capteur gyroscopique peut également être fixé très facilement directement sur l'axe de rotation du volant.

Notion

Je procède toujours de la même manière lorsque je précise une profondeur de perçage :gratter la surface avec la perceuse, noter la coordonnée, puis ajouter la profondeur de perçage souhaitée et enfin percer jusqu'à atteindre la profondeur.

Je voudrais garder le processus de base. Afin de ne pas forer trop profondément, je souhaite recevoir des informations sur le moment où la profondeur de forage a été atteinte.

Un bouton prend en charge cette fonction. Lorsque vous appuyez dessus, l'Arduino enregistre la position de perçage actuelle en tant que valeur d'arrêt et peut toujours me la rappeler lorsqu'elle sera atteinte plus tard.

Les autres composants prennent plus de place et pèsent nettement plus. Heureusement, le boîtier de ma machine est en métal. C'est pourquoi j'utilise un aimant néodyme pour le réparer.

La question demeure, comment le capteur doit-il être fixé à la machine ?

L'axe de la perceuse a un écrou hexagonal SW17. Je n'ai donc besoin que d'un composant imprimé en 3D qui accepte le capteur et peut être branché sur l'écrou hexagonal.

Composants requis

• Arduino Nano
• Capteur gyroscopique GY-521
• Module à 7 segments à 8 chiffres (version SPI avec MAX7219 IC)
• Bouton poussoir
• Interrupteur marche/arrêt
• Alimentation :pinces pour piles AA ou AAA ou batterie externe
• Boîtier imprimé en 3D
• Aimant néodyme

Connexion du capteur gyroscopique

Le capteur gyroscopique est connecté via l'I2C. Nous devons donc utiliser A5 et A4 pour le Nano.

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

Module à 7 segments

N'importe quelle broche numérique peut être utilisée lors de la connexion du module à 7 segments. Les broches sont définies à l'aide du croquis Arduino.

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

Bouton

La broche d'entrée du bouton peut également être sélectionnée librement. J'utilise la broche D9.

Alimentation

Pour l'alimentation, j'utilise 6 piles AA. Après l'interrupteur marche / arrêt, ils alimentent l'ensemble du système en électricité.

Boîtier

J'ai conçu le boîtier avec Autodesk Fusion 360. J'ai créé l'impression 3D avec un Anycubic i3 Mega.

L'aimant en néodyme pour la fixation sur la machine est collé. Si tout l'affichage de la profondeur de perçage gêne, tout est rapidement retiré.

Esquisse Arduino

J'ai utilisé le LedControl.h bibliothèque pour contrôler l'affichage à 7 segments. Si vous ne les avez pas encore installés, vous devez d'abord les installer à l'aide du gestionnaire de bibliothèque.

Le capteur gyroscopique est connecté via le bus I2C. Lors de la recherche de bibliothèques possibles pour le capteur, j'ai alors décidé de n'en utiliser aucune. La communication se fait via Wire.h .

A la fin de l'article, vous trouverez quelques liens qui m'ont aidé à comprendre.

Le contrôle de l'affichage 7 segments fonctionne très bien avec LedControl .

Après l'initialisation avec les broches, la procédure de configuration n'a besoin que de quelques préparations pour réveiller l'affichage et régler l'intensité.

Dans la partie boucle, l'écran affiche uniquement la profondeur de perçage actuelle et, si elle est définie, la position d'arrêt, également sous forme de nombres.

L'affichage attend chaque chiffre comme type de caractère. Je voudrais utiliser une décimale comme précision. La fonction dtostrf convertit un flottant en un tableau de caractères. Puis dans une chaîne pour l'afficher au niveau des caractères à l'écran.

dtostrf ( currentPos, 4,1, txt );
s ='' + String ( txt );
lc. setChar ( 0,4, voir charAt ( voir length () -1 ) , false );
lc. setChar ( 0.5, voir charAt ( voir length () -3 ) , true );
lc. setChar ( 0.6, voir charAt ( voir length () -4 ) , false );
lc. setChar ( 0.7, voir charAt ( voir length () -5 ) , false ); 

Lorsque la position d'arrêt est atteinte, "StOP" apparaît sur l'écran. Le petit "t" peut être généré en utilisant le setRow procédure et le modèle binaire approprié B00001111.

La lecture du capteur gyroscopique fonctionne via les fonctions de la bibliothèque de fils. Je n'utilise que l'accéléromètre pour déterminer la position angulaire.

Lorsque vous travaillez avec une connexion USB à l'IDE Arduino, tout fonctionnait parfaitement. Après avoir débranché et connecté la source d'alimentation externe, le capteur n'a fourni aucune donnée. Cela n'a fonctionné à nouveau qu'après une réinitialisation de l'Arduino.

Cela m'a donné le plus de maux de tête dans l'ensemble du projet. On pourrait dire que l'indicateur de profondeur de forage aurait pu sauver mes yeux, mais c'est pourquoi j'ai arraché presque tous mes cheveux !

Après une longue recherche, installer un temps d'attente après le réveil du capteur était la solution. Cela rend le retard (1000) la commande la plus importante de tout le code source.

//préparer le capteur GY-521
//nous n'utilisons que les données de l'accélérateur
Wire.begin();
Wire.beginTransmission(MPU);
Wire .write(0x6B);
Wire.write(0x00); // réveiller le MPU
Wire.endTransmission(true);

//ce délai était très nécessaire dans mon cas !
delay(1000);

Wire.beginTransmission(MPU);
Wire.write(0x1C); //enregistrer ACCEL_CONFIG
Wire.write(0x10); //Définir comme 00010000 pour une plage pleine échelle de +/- 8g
Wire.endTransmission(true); 

Les valeurs de décalage doivent être déterminées pour le capteur au début, sinon les valeurs fluctuent. Dans la partie configuration, 100 valeurs sont mesurées et les écarts sont moyennés.

Le calcul de l'angle à partir des données du capteur n'est pas si facile. Mais il existe de nombreuses instructions sur la façon de faire les calculs.

L'angle X en degrés est calculé à l'aide de cette formule :

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

Cependant, les valeurs du capteur d'accélération fluctuent fortement. Par conséquent, la valeur actuellement calculée est moyennée avec la valeur précédente à 50 % chacune.

TotalAngleX =0.5 * TotalAngleX + 0.5 * AccAngleX ; 

Les valeurs d'angle sont sorties de -90 ° à + 90 ° par le capteur. Mais j'ai besoin d'un angle de 0° à 360° pour la conversion en profondeur de perçage.

Je n'ai pas encore trouvé de solution simple à ce problème. Pour mon application, cependant, il suffit de voir si les données du capteur Z et Y sont positives ou négatives. Et convertissez l'angle 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°, meilleur affichage 0 °
if (DrillingMachineAngle>350) {DrillingMachineAngle=0;} 

Ce qui manque encore, c'est l'angle de rotation maximum possible que permet le volant. La façon la plus simple de le faire est de faire sortir l'angle déterminé via un Serial.print et de noter la valeur maximale.

Pour moi c'est 316°. Avec une profondeur de perçage maximale de 50 mm, la position actuelle est calculée comme suit :

currentPos=50.0/316.0*DrillingMachineAngle ; 

Si le bouton est enfoncé, l'Arduino enregistre la position de perçage actuelle. 8888 s'affiche à l'écran et il y a une courte attente de 1 seconde.

Si une position de butée est définie, la profondeur de perçage restante jusqu'à la butée est indiquée sur l'écran de droite.

Assemblage et test

Le capteur gyroscopique est mieux fixé avec un point de colle chaude. Faites passer les câbles de connexion à travers le couvercle. C'est tout pour cette partie.

Lors du premier test, le capteur gyroscopique doit d'abord être aligné. Je l'ai installé horizontalement. Étant donné que le support est conçu pour être rotatif, il peut être facilement ajusté jusqu'à ce que 0.0 s'affiche à l'écran.

Ensuite, le premier test peut commencer.

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

Et grâce au grand écran LED, je n'ai pas à me soucier des lunettes jusqu'à 85 ans pour lire une profondeur de perçage exacte.

Alors, souvenez-vous toujours de ce que dit Paul :corrigez les problèmes qui vous dérangent !

Amusez-vous à le construire !

___________________________________________________________

Quelques liens peut-être utiles :

https://medium.com/@kavindugimhanzoysa/lets-work-with-mpu6050-gy-521-part1-6db0d47a35e6

ou https://playground.arduino.cc/Main/MPU-6050/

ou aussi https://circuitdigest.com/microcontroller-projects/mpu6050-gyro-sensor-interfacing-with-arduino/

Bibliothèque de GY-521 par Rob Tilaart :https://github.com/RobTillaart/GY521

Et consultez le livre de Paul Akers sur https://paulakers.net/books/2-second-lean

Das Projekt gibt es auch auf Deutsch unter :https://techpluscode.de/bohrtiefenanzeige-mit-gyro-sensor/

Code

• profondeur de forage.ino

drilling-depth.inoArduino

/* programme :drill-depth.ino * auteur :Thomas Angielsky * version :2021-03-20 * * https://techpluscode.de/ * https://techpluscode.de/bohrtiefenanzeige-mit-gyro- capteur/ * * ce croquis mesure la profondeur de perçage d'une table de perçage * machine à l'aide des données du capteur gyroscopique GY-521 * la profondeur est visualisée par l'affichage à 7 segments * * idée de compensation d'erreur de calcul d'électronoobs.com - merci ! * */#include #include #include "LedControl.h"#define MPU 0x68char 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:broche D12, broche D11, broche D10, 1 moduleLedControl lc=LedControl(12,11,10,1);void setup() { //préparer la connexion série / /Serial.begin(9600); //valeurs de départ stopPos=0.0; CurrentPos=0.0 ; rad_to_deg =180/PI ; //préparer le capteur GY-521 //nous utilisons uniquement les données de l'accélérateur Wire.begin(); Wire.beginTransmission(MPU); Wire.write(0x6B); Wire.write(0x00); // réveille MPU Wire.endTransmission(true); //ce délai était bien nécessaire dans mon cas ! retard(1000); Wire.beginTransmission(MPU); Wire.write(0x1C); //enregistrer ACCEL_CONFIG Wire.write(0x10); //Définir comme 00010000 pour une plage pleine échelle de +/- 8g Wire.endTransmission(true); //calculer l'erreur de données de l'accélérateur //faire 100 mesures pour(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=AccAngleErrorX+((atan((AccY)/sqrt(pow((AccX),2)+pow((AccZ),2)))*rad_to_deg)); //AccAngleErrorY=AccAngleErrorY+((atan(-1*(AccX)/sqrt(pow((AccY),2)+pow((AccZ),2)))*rad_to_deg)); } AccAngleErrorX=AccAngleErrorX/100 ; //AccAngleErrorY=AccAngleErrorY/100; //Préparer le bouton :broche D9 pinMode(9, INPUT_PULLUP); //prépare l'affichage à 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; //AccAngleY=(atan(-1*(AccX)/sqrt(pow((AccY),2)+pow((AccZ),2)))*rad_to_deg)-AccAngleErrorY; //valeurs lisses TotalAngleX=0.5*(TotalAngleX)+0.5*AccAngleX; //AngleTotalY=0,5*(AngleTotalY)+0,5*AccAngleY; //calculer l'angle x à 360 en utilisant +/- de X,Y,Z delta=0; if ((AccZ<0)) { delta=180.0-TotalAngleX*2.0; } si ((AccZ>0)&&(AccY<0)) { delta=360.0; } DrillingMachineAngle=TotalAngleX+delta; //si proche de 360, afficher mieux 0 si (DrillingMachineAngle>350) {DrillingMachineAngle=0;} //calculer la profondeur de perçage //profondeur de perçage max :50 mm (mesurée sur la machine) //angle max du volant :316 (mesuré avec les données Serial.print) currentPos=50.0/316.0*DrillingMachineAngle ; /* Serial.print("X / X / Y / Z / E :BOHRTIEFE"); Serial.print(TotalAngleX); Serial.print(" "); Serial.print(AccX); Serial.print(" "); Serial.print(AccY); Serial.print(" "); Serial.print(AccZ); Serial.print(">> "); Serial.print(DrillingMachineAngle); Serial.print(">> "); Serial.print(currentPos); Serial.println(" ");*/ //bouton appuyé ? if (digitalRead(9)==LOW) { //stocker la position d'arrêt 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); //Serial.println("Bouton enfoncé"); retard(1000); } if (stopPos>0) { //position d'arrêt atteinte ? if (currentPos>=stopPos) { //yes:affiche STOP (5t0P) sur le côté droit lc.setChar(0,3,'5',false); lc.setRow(0,2,B00001111) ; lc.setChar(0,1,'0',false); lc.setChar(0,0,'P',false); } else { // non :afficher la distance jusqu'à la position d'arrêt dtostrf(stopPos-currentPos,4,1,txt); s=' '+Chaîne(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 { // n'affiche rien lc.setChar(0,3,' ',false); lc.setChar(0,2,' ',false); lc.setChar(0,1,' ',false); lc.setChar(0,0,' ',false); } //afficher la profondeur de forage actuelle sur le côté gauche //format en tant que chaîne dtostrf(currentPos,4,1,txt); s=' '+Chaîne(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); retard (200);}

Pièces et boîtiers personnalisés

Schémas