Pantalla de profundidad de perforación con sensor giroscópico

Acerca de este proyecto

Si tiene que perforar una cierta profundidad para un proyecto, necesita un taladro de banco con pantalla de profundidad. La mayoría de los ejercicios de banco tienen una regla con una flecha para leer. El éxito de la perforación depende de la precisión con la que pueda leer la posición deseada. En este proyecto de Arduino presento una propuesta alternativa:una pantalla de profundidad de perforación con un sensor giroscópico y una pantalla de 7 segmentos con soporte para Arduino.

La máquina que utilizo con más frecuencia en mi taller no es una sierra ni una rectificadora. Es, con mucho, el ejercicio de banco. Independientemente del proyecto, en realidad siempre se usa. Si necesito una cierta profundidad de perforación, puedo usar la regla incorporada en la máquina. Y recuerda la profundidad a la que tengo que perforar. De hecho, funciona bien.

Pero con el aumento de la edad, sí, sí, sí, se me hace cada vez más difícil leer la profundidad con precisión milimétrica. Y si la luz no es lo suficientemente brillante, es casi imposible leerla. ¿Pero ponte anteojos para esto? Y después de taladrar, ¿dónde guardar los vasos? No estoy tan lejos todavía.

Fiel al lema de Paul Akers de "2 Secon Lean":

Tiene que haber una solución mejor, solo tienes que pensar y crearla.

Medición de posibilidades

Por supuesto, podría poner una lupa delante de la escala para facilitar la lectura de la regla. Mejoraría la lectura, pero no ayudaría que tenga que recordar la medida en cada caso. Y si está haciendo manualidades, también debería ser divertido.

Por eso una solución electrónica es mucho mejor. Preferiblemente en un espacio reducido para que todo encaje junto al interruptor de encendido / apagado del taladro. Para tales casos, me gusta usar un Arduino Nano. Tiene suficientes pines para controlar casi todo y es correspondientemente pequeño.

Pero, ¿cómo se mide la profundidad de perforación? Hay varias posibilidades para medir la longitud. ¿Instalar una medición ultrasónica? Podría funcionar, pero solo con un poco de mecánica, que se mueve junto con el taladro como superficie de reflexión. ¿O utilizar un codificador accionado por cable? Sería posible, pero muy complejo, si lo construyes tú mismo:con plato giratorio, barreras de luz de horquilla y retorno por resorte. ¿Es mejor tomar un codificador rotatorio de inmediato? Eso significaría muchos menos componentes, sí, pero sería demasiado burdo, tendrías que instalar engranajes para una traducción.

Bien, piénsalo más.

Mi taladro, como la mayoría, tiene un volante en el lateral para ajustar la profundidad. Se puede girar aprox. 270 °. Así que ni siquiera una vuelta completa.

Esto es perfecto para una medición de ángulos con un sensor giroscópico. La conexión del cable no se puede torcer y solo se requiere un componente económico. El sensor giroscópico también se puede acoplar muy fácilmente directamente al eje giratorio del volante.

Concepto

Siempre procedo de la misma manera cuando especifico una profundidad de perforación:raspe la superficie con la broca, anote la coordenada, luego agregue la profundidad de perforación deseada y finalmente perfore hasta alcanzar la profundidad.

Me gustaría mantener el proceso básico. Para no perforar demasiado profundo, me gustaría recibir información sobre cuándo se alcanzó la profundidad de perforación.

Un botón se hace cargo de esta función. Cuando lo presiona, Arduino guarda la posición de perforación actual como un valor de parada y siempre me lo puede recordar cuando se alcanza más tarde.

Los componentes restantes ocupan más espacio y pesan mucho más. Afortunadamente, la carcasa de mi máquina está hecha de metal. Por eso utilizo un imán de neodimio para arreglarlo.

La pregunta sigue siendo, ¿cómo se debe conectar el sensor a la máquina?

El eje del taladro tiene una tuerca hexagonal SW17. Así que solo necesito un componente impreso en 3D que acepte el sensor y se pueda conectar a la tuerca hexagonal.

Componentes necesarios

• Arduino Nano
• Sensor giroscópico GY-521
• Módulo de 7 segmentos con 8 dígitos (versión SPI con MAX7219 IC)
• Botón pulsador
• Interruptor de encendido / apagado
• Fuente de alimentación:clips de batería para baterías AA o AAA o banco de energía
• Carcasa impresa en 3D
• Imán de neodimio

Conexión del sensor giroscópico

El sensor giroscópico está conectado a través del I2C. Entonces tenemos que usar A5 y A4 para el Nano.

• VCC -> 5V
• GND -> GND
• SCL -> A5
• SDA -> A4
• XDA -> no conectado
• XCL -> no conectado
• ADO -> no conectado
• INT -> no conectado

Módulo de 7 segmentos

Se puede utilizar cualquier pin digital al conectar el módulo de 7 segmentos. Los pines se establecen utilizando el boceto de Arduino.

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

Botón

El pin de entrada del botón también se puede seleccionar libremente. Estoy usando el pin D9.

Fuente de alimentación

Para la fuente de alimentación utilizo 6 pilas AA. Después del interruptor de encendido / apagado, suministran electricidad a todo el sistema.

Carcasa

Diseñé la carcasa con Autodesk Fusion 360. Creé la impresión 3D con una Anycubic i3 Mega.

El imán de neodimio para fijarlo a la máquina está pegado. Si toda la pantalla de profundidad de perforación se interpone, todo se retira rápidamente.

Bosquejo de Arduino

Usé el LedControl.h biblioteca para controlar la pantalla de 7 segmentos. Si aún no los ha instalado, primero debe instalarlos usando el administrador de la biblioteca.

El sensor giroscópico está conectado a través del bus I2C. Al buscar posibles bibliotecas para el sensor, decidí no usar ninguna. La comunicación se realiza a través de Wire.h .

Al final del artículo, encontrará algunos enlaces que me ayudaron a comprender.

El control de la pantalla de 7 segmentos funciona muy bien con LedControl .

Después de la inicialización con los pines, el procedimiento de configuración solo necesita algunos preparativos para activar la pantalla y ajustar la intensidad.

En la parte del bucle, la pantalla solo muestra la profundidad de perforación actual y, si está configurada, la posición de parada, también como números.

La pantalla espera cada dígito como un tipo de carácter. Me gustaría usar un lugar decimal como precisión. La función dtostrf convierte un flotante en una matriz de caracteres. Luego, en una cadena para mostrarlo en forma de caracteres en la pantalla.

  dtostrf (currentPos, 4,1, txt); 
 s ='' + String (txt); 
 lc. setChar (0,4, ver charAt (ver longitud () -1), falso); 
 lc. setChar (0.5, ver charAt (ver length () -3), verdadero); 
 lc. setChar (0.6, ver charAt (ver longitud () -4), falso); 
 lc. setChar (0.7, ver charAt (ver longitud () -5), falso);  

Cuando se alcanza la posición de parada, aparece "StOP" en la pantalla. La "t" pequeña se puede generar usando setRow procedimiento y el patrón de bits apropiado B00001111.

La lectura del sensor giroscópico funciona a través de las funciones de la biblioteca de cables. Solo uso el acelerómetro para determinar la posición angular.

Al trabajar con conexión USB al Arduino IDE, todo funcionó a la perfección. Después de desconectar y conectar a la fuente de alimentación externa, el sensor no proporcionó ningún dato. Solo funcionó nuevamente después de un reinicio del Arduino.

Eso me dio más dolor de cabeza en todo el proyecto. Se podría decir que el indicador de profundidad de perforación podría haber salvado mis ojos, ¡pero por eso me arranqué casi todo el cabello!

Después de una larga búsqueda, la solución fue instalar un tiempo de espera después de despertar el sensor. Esto hace que el retraso (1000) el comando más importante de todo el código fuente.

  // prepara el sensor GY-521 
 // usamos solo datos del acelerador 
 Wire.begin (); 
 Wire.beginTransmission (MPU); 
 Wire .escribir (0x6B); 
 Wire.write (0x00); // despierta MPU 
 Wire.endTransmission (true); 
 
 // ¡este retraso fue muy necesario en mi caso! 
 delay (1000); 
 
Wire.beginTransmission(MPU); 
 Wire.write (0x1C); // registra ACCEL_CONFIG 
 Wire.write (0x10); // Establecer como 00010000 para +/- 8g rango de escala completa 
 Wire.endTransmission (true);  

Los valores de compensación deben determinarse para el sensor al principio; de lo contrario, los valores fluctuarán. En la parte de configuración, se miden 100 valores y se promedian las desviaciones.

Calcular el ángulo a partir de los datos del sensor no es tan fácil. Pero hay muchas instrucciones sobre cómo hacer los cálculos.

El ángulo X en grados se calcula usando esta fórmula:

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

Sin embargo, los valores del sensor de aceleración fluctúan mucho. Por lo tanto, el valor calculado actualmente se promedia con el valor anterior al 50% cada uno.

  TotalAngleX =0.5 * TotalAngleX + 0.5 * AccAngleX;  

Los valores de ángulo se emiten desde -90 ° a + 90 ° por el sensor. Pero necesito un ángulo de 0 ° a 360 ° para convertirlo en una profundidad de perforación.

Todavía no he encontrado una solución simple para esto. Para mi aplicación, sin embargo, es suficiente ver si los datos del sensor Z e Y son positivos o negativos. Y convierta el ángulo en consecuencia.

  delta =0; 
 if ((AccZ <0)) {
 delta =180.0-TotalAngleX * 2.0; 
} 
 if ((AccZ> 0 ) &&(AccY <0)) {
 delta =360.0; 
} 
 DrillingMachineAngle =TotalAngleX + delta; 
 
 // si está cerca de 360 ​​°, visualice mejor 0 ° 
 if (DrillingMachineAngle> 350) {DrillingMachineAngle =0;}  

Lo que todavía falta es el máximo ángulo de giro posible que permite el volante. La forma más sencilla de hacer esto es tener la salida del ángulo determinado a través de un Serial.print y anotar el valor máximo.

Para mí es 316 °. Con una profundidad máxima de perforación de 50 mm, la posición actual se calcula de la siguiente manera:

  currentPos =50.0 / 316.0 * DrillingMachineAngle;  

Si se presiona el botón, Arduino guarda la posición de perforación actual. 8888 se muestra en la pantalla y hay una breve espera de 1 segundo.

Si se establece una posición de parada, la profundidad de perforación restante hasta la parada se muestra en la pantalla derecha.

Ensamblaje y prueba

El sensor giroscópico se fija mejor con un punto de pegamento caliente. Guíe los cables de conexión a través de la tapa. Eso es todo por esta parte.

En la primera prueba, primero se debe alinear el sensor giroscópico. Lo instalé horizontalmente. Dado que el soporte está diseñado para ser giratorio, se puede ajustar fácilmente hasta que se muestre 0.0 en la pantalla.

Entonces puede comenzar la primera prueba.

En general, estoy muy contento con la solución. El sensor reacciona muy rápidamente y los valores calculados coinciden exactamente con la profundidad de perforación.

Y gracias a la gran pantalla LED, no tengo que preocuparme por anteojos de hasta 85 años para leer una profundidad de perforación exacta.

Así que recuerde siempre lo que dice Paul:¡Arregle lo que le molesta!

¡Diviértete construyéndolo!

___________________________________________________________

Algunos enlaces quizás útiles:

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

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

o también https://circuitdigest.com/microcontroller-projects/mpu6050-gyro-sensor-interfacing-with-arduino/

Biblioteca de GY-521 de Rob Tilaart:https://github.com/RobTillaart/GY521

Y consulte el libro de Paul Akers en https://paulakers.net/books/2-second-lean

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

Código

• profundidad de perforación.ino

profundidad de perforación.ino Arduino

 / * programa:drill-depth.ino * autor:Thomas Angielsky * versión:2021-03-20 * * https://techpluscode.de/ * https://techpluscode.de/bohrtiefenanzeige-mit-gyro- sensor / * * este boceto mide la profundidad de perforación de una máquina de perforación de mesa * usando datos del sensor giroscópico GY-521 * la profundidad se ve en una pantalla de 7 segmentos * * idea de compensación de error de cálculo de electronoobs.com - ¡gracias! * * / # include  #include  #include "LedControl.h" #define MPU 0x68char txt [8]; String s; float currentPos, stopPos; float rad_to_deg; float AccX, AccY, AccZ; flotar AccAngleX, AccAngleY; flotar AccAngleErrorX, AccAngleErrorY; float TotalAngleX, TotalAngleY; float DrillingMachineAngle, delta; // LED de inicio:pin D12, pin D11, pin D10, 1 moduleLedControl lc =LedControl (12,11,10,1); void setup () {// preparar la conexión en serie / /Serial.begin(9600); // valores de inicio stopPos =0.0; currentPos =0.0; rad_to_deg =180 / PI; // preparar el sensor GY-521 // usamos solo datos del acelerador Wire.begin (); Wire.beginTransmission (MPU); Wire.write (0x6B); Wire.write (0x00); // despierta MPU Wire.endTransmission (verdadero); // ¡este retraso fue muy necesario en mi caso! retraso (1000); Wire.beginTransmission (MPU); Wire.write (0x1C); // registra ACCEL_CONFIG Wire.write (0x10); // Establecer como 00010000 para +/- 8g rango de escala completa Wire.endTransmission (true); // calcula el error de datos del acelerador // realiza 100 mediciones para (int a =0; a <100; a ++) {Wire.beginTransmission (MPU); Wire.write (0x3B); Wire.endTransmission (falso); Wire.requestFrom (MPU, 6, verdadero); 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; // botón de preparación:pin D9 pinMode (9, INPUT_PULLUP); // prepara la pantalla de 7 segmentos lc.shutdown (0, false); lc.setIntensity (0,8); lc.clearDisplay (0);} bucle vacío () {Wire.beginTransmission (MPU); Wire.write (0x3B); Wire.endTransmission (falso); Wire.requestFrom (MPU, 6, verdadero); 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; // valores suaves TotalAngleX =0.5 * (TotalAngleX) + 0.5 * AccAngleX; //TotalAngleY=0.5*(TotalAngleY)+0.5*AccAngleY; // calcula el ángulo x a 360 usando +/- 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 está cerca de 360, mostrar mejor 0 si (DrillingMachineAngle> 350) {DrillingMachineAngle =0;} // calcular la profundidad de perforación // profundidad máxima de perforación:50 mm (medido en la máquina) // ángulo máximo de la rueda manual:316 (medido con datos de 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 (""); * / // botón presionado? if (digitalRead (9) ==LOW) {// almacenar la posición de parada stopPos =currentPos; lc.setChar (0,3, '8', falso); lc.setChar (0,2, '8', falso); lc.setChar (0,1, '8', falso); lc.setChar (0,0, '8', falso); //Serial.println("Button pressed "); retraso (1000); } if (stopPos> 0) {// ¿Se ha alcanzado la posición de parada? if (currentPos> =stopPos) {// sí:muestra STOP (5t0P) en el lado derecho lc.setChar (0,3, '5', false); lc.setRow (0,2, B00001111); lc.setChar (0,1, '0', falso); lc.setChar (0,0, 'P', falso); } else {// no:muestra la distancia hasta la posición de parada dtostrf (stopPos-currentPos, 4,1, txt); s ='' + Cadena (txt); lc.setChar (0,0, s.charAt (s.length () - 1), falso); lc.setChar (0,1, s.charAt (s.length () - 3), verdadero); lc.setChar (0,2, s.charAt (s.length () - 4), falso); lc.setChar (0,3, s.charAt (s.length () - 5), falso); }} else {// no muestra nada lc.setChar (0,3, '', false); lc.setChar (0,2, '', falso); lc.setChar (0,1, '', falso); lc.setChar (0,0, '', falso); } // muestra la profundidad de perforación actual en el lado izquierdo // formato como cadena dtostrf (currentPos, 4,1, txt); s ='' + Cadena (txt); lc.setChar (0,4, s.charAt (s.length () - 1), falso); lc.setChar (0,5, s.charAt (s.length () - 3), verdadero); lc.setChar (0,6, s.charAt (s.length () - 4), falso); lc.setChar (0,7, s.charAt (s.length () - 5), falso); retraso (200);} 

Piezas y carcasas personalizadas

drill-depth-3d-model_Yn2q0MSNa4.zip

Esquemas

Mini levitación acústica Grifo de agua automático basado en Arduino con sensor de infrarrojos