Visor de profundidade de perfuração com sensor giroscópio
Componentes e suprimentos
| × | 1 |
Ferramentas e máquinas necessárias
|
Aplicativos e serviços online
|
Sobre este projeto
Se você precisa perfurar uma certa profundidade para um projeto, você precisa de uma furadeira de bancada com visor de profundidade. A maioria dos exercícios de bancada tem uma régua com uma flecha para leitura. O sucesso da perfuração depende da precisão com que você pode ler a posição desejada. Neste projeto Arduino, apresento uma proposta alternativa:Um display de profundidade de perfuração com um sensor giroscópio e um display de 7 segmentos com suporte para Arduino.
A máquina que uso com mais frequência em minha oficina não é uma serra ou retificadora. É de longe o exercício de bancada. Independentemente do projeto, na verdade sempre é usado. Se eu precisar de uma certa profundidade de perfuração, posso usar a régua embutida na máquina. E lembre-se da profundidade que preciso perfurar. Na verdade, funciona bem.
Mas com o aumento da idade - sim, sim, sim - fica cada vez mais difícil para mim ler a profundidade com precisão milimétrica. E se a luz não for forte o suficiente, é quase impossível lê-la. Mas é só colocar óculos para isso? E após a perfuração, onde guardam os óculos? Ainda não estou tão longe.
Fiel ao lema de Paul Akers de "2 Secon Lean":
Tem que haver uma solução melhor, você só precisa pensar e fazer.
Medindo possibilidades
Eu poderia, é claro, colocar uma lupa na frente da escala para tornar a régua mais fácil de ler. Melhoraria a leitura, mas não ajudaria se eu tivesse que me lembrar da medição em cada caso. E se você está fazendo artesanato, deve ser divertido também.
É por isso que uma solução eletrônica é muito melhor. De preferência em um espaço pequeno para que tudo caiba próximo ao botão liga / desliga da furadeira. Nesses casos, gosto de usar um Arduino Nano. Ele tem pinos suficientes para controlar quase tudo e é correspondentemente pequeno.
Mas como você mede a profundidade de perfuração? Existem várias possibilidades para uma medição de comprimento. Instalar uma medição ultrassônica? Pode funcionar, mas apenas com um pouco de mecânica, que se move junto com a broca como uma superfície de reflexão. Ou usar um codificador acionado por fio? Seria possível, mas muito complexo, se você mesmo construí-lo:com uma mesa giratória, barreiras de luz em garfo e retorno de mola. Melhor pegar um codificador rotativo imediatamente? Isso significaria muito menos componentes - sim, mas seria muito grosso, você teria que instalar engrenagens para uma tradução.
Ok, então pense mais sobre isso.
Minha furadeira, como a maioria, tem um volante na lateral para ajustar a profundidade. Pode ser girado aprox. 270 °. Portanto, nem mesmo uma volta completa.
Isso é perfeito para uma medição de ângulo com um sensor de giroscópio. A conexão do cabo não pode torcer e apenas um componente barato é necessário. O sensor giroscópico também pode ser conectado facilmente diretamente ao eixo rotativo do volante.
Conceito
Eu sempre procedo da mesma forma ao especificar uma profundidade de perfuração:raspe a superfície com a broca, anote a coordenada, então acrescente a profundidade de perfuração desejada e finalmente fure até que a profundidade seja alcançada.
Eu gostaria de manter o processo básico. Para não perfurar muito fundo, gostaria de receber informações sobre quando a profundidade de perfuração foi atingida.
Um botão assume esta função. Quando você pressiona, o Arduino salva a posição de perfuração atual como um valor de parada e sempre pode me lembrar dela quando for alcançada posteriormente.
Os componentes restantes ocupam mais espaço e pesam significativamente mais. Felizmente, a caixa da minha máquina é feita de metal. É por isso que uso um ímã de neodímio para consertar.
A questão permanece:como o sensor deve ser conectado à máquina?
O eixo da broca possui uma porca sextavada SW17. Portanto, preciso apenas de um componente impresso em 3D que aceite o sensor e possa ser conectado à porca sextavada.
Componentes necessários
- Arduino Nano
- Sensor giroscópio GY-521
- Módulo de 7 segmentos com 8 dígitos (versão SPI com MAX7219 IC)
- Botão de pressão
- Botão liga / desliga
- Fonte de alimentação:clipes de bateria para baterias AA ou AAA ou banco de energia
- caixa impressa em 3D
- Ímã de neodímio
Conexão do sensor giroscópio
O sensor giroscópio é conectado via I2C. Portanto, temos que usar A5 e A4 para o Nano.
- VCC -> 5V
- GND -> GND
- SCL -> A5
- SDA -> A4
- XDA -> não conectado
- XCL -> não conectado
- ADO -> não conectado
- INT -> não conectado
Módulo de 7 segmentos
Qualquer pino digital pode ser usado ao conectar o módulo de 7 segmentos. Os pinos são definidos usando o esboço do Arduino.
- VCC -> 3,3 V
- GND -> GND
- DIN -> D12
- CS -> D10
- CLK -> D11
Botão
O pino de entrada do botão também pode ser selecionado livremente. Estou usando o pino D9.
Fonte de alimentação
Para fonte de alimentação, uso 6 pilhas AA. Após a chave liga / desliga, fornecem eletricidade a todo o sistema.
Invólucro
Eu projetei o case com o Autodesk Fusion 360. Criei a impressão 3D com um Anycubic i3 Mega.
O ímã de neodímio para fixação na máquina é colado. Se todo o visor de profundidade de perfuração atrapalhar, tudo é removido rapidamente.
Arduino Sketch
Usei o LedControl.h biblioteca para controlar o display de 7 segmentos. Se você ainda não os instalou, primeiro deve instalá-los usando o gerenciador de biblioteca.
O sensor giroscópio é conectado através do barramento I2C. Ao procurar possíveis bibliotecas para o sensor, decidi não usar nenhuma. A comunicação é feita via Wire.h .
No final do artigo você encontrará alguns links que me ajudaram a entender.
O controle do display de 7 segmentos funciona muito bem com o LedControl .
Após a inicialização com os pinos, o procedimento de configuração só precisa de alguns preparativos para ativar o visor e ajustar a intensidade.
Na parte do loop, o display mostra apenas a profundidade de perfuração atual e, se configurada, a posição de parada, também como números.
O display espera cada dígito como um tipo de caractere. Eu gostaria de usar uma casa decimal como uma precisão. A função dtostrf converte um float em uma matriz de caracteres. Em seguida, em uma string para mostrá-lo em caracteres no visor.
dtostrf (currentPos, 4,1, txt);
s ='' + String (txt);
lc. setChar (0,4, veja charAt (veja length () -1), false);
lc. setChar (0.5, veja charAt (veja length () -3), true);
lc. setChar (0.6, veja charAt (veja length () -4), false);
lc. setChar (0.7, veja charAt (veja length () -5), false);
Quando a posição de parada é alcançada, "StOP" aparece no visor. O pequeno "t" pode ser gerado usando o setRow procedimento e o padrão de bits apropriado B00001111.
A leitura do sensor giroscópio funciona por meio de funções da biblioteca de fios. Eu só uso o acelerômetro para determinar a posição angular.
Ao trabalhar com conexão USB para o IDE do Arduino, tudo funcionou perfeitamente. Após desconectar e conectar à fonte de alimentação externa, o sensor não forneceu quaisquer dados. Só funcionou novamente após uma reinicialização do Arduino.
Isso me deu a maior dor de cabeça em todo o projeto. Você poderia dizer que o indicador de profundidade da broca pode ter salvado meus olhos, mas é por isso que arranquei quase todo o meu cabelo!
Depois de uma longa busca, instalar um tempo de espera após despertar o sensor foi a solução. Isso torna o atraso (1000) o comando mais importante em todo o código-fonte.
// preparar o sensor GY-521
// usamos apenas dados do acelerador
Wire.begin ();
Wire.beginTransmission (MPU);
Wire .write (0x6B);
Wire.write (0x00); // acorda MPU
Wire.endTransmission (true);
// este retardo foi muito necessário no meu caso!
delay (1000);
Wire.beginTransmission(MPU);
Wire.write (0x1C); // registrar ACCEL_CONFIG
Wire.write (0x10); // Definido como 00010000 para +/- 8g de escala completa
Wire.endTransmission (true);
Os valores de compensação devem ser determinados para o sensor no início, caso contrário, os valores irão flutuar. Na parte de configuração, 100 valores são medidos e os desvios são calculados.
Calcular o ângulo a partir dos dados do sensor não é tão fácil. Mas existem muitas instruções sobre como fazer os cálculos.
O ângulo X em graus é calculado usando esta fórmula:
AccAngleX =(atan ((AccY) / sqrt (pow ((AccX), 2) + pow ((AccZ), 2))) * rad_to_deg);
No entanto, os valores do sensor de aceleração variam muito. Portanto, o valor calculado atualmente tem a média do valor anterior de 50% cada.
TotalAngleX =0,5 * TotalAngleX + 0,5 * AccAngleX;
Os valores de ângulo são emitidos de -90 ° a + 90 ° pelo sensor. Mas preciso de um ângulo de 0 ° a 360 ° para a conversão em profundidade de perfuração.
Ainda não encontrei uma solução simples para isso. Para minha aplicação, entretanto, é suficiente ver se os dados do sensor Z e Y são positivos ou negativos. E converta o ângulo de acordo.
delta =0;
if ((AccZ <0)) {
delta =180.0-TotalAngleX * 2.0;
}
if ((AccZ> 0 ) &&(AccY <0)) {
delta =360.0;
}
DrillingMachineAngle =TotalAngleX + delta;
// se próximo a 360 °, exibir melhor 0 °
if (DrillingMachineAngle> 350) {DrillingMachineAngle =0;}
O que ainda falta é o ângulo máximo de rotação possível que o volante permite. A maneira mais fácil de fazer isso é ter a saída do ângulo determinado por meio de um Serial.print e anotar o valor máximo.
Para mim é 316 °. Com uma profundidade máxima de perfuração de 50 mm, a posição atual é calculada da seguinte forma:
currentPos =50.0 / 316.0 * DrillingMachineAngle;
Se o botão for pressionado, o Arduino salva a posição de perfuração atual. 8888 é mostrado no visor e há uma breve espera de 1 segundo.
Se uma posição de parada for definida, a profundidade de perfuração restante até a parada é mostrada no visor direito.
Montagem e teste
O sensor giroscópico é melhor fixado com um ponto de cola quente. Passe os cabos de conexão pela tampa. É isso para esta parte.
No primeiro teste, o sensor giroscópio deve primeiro ser alinhado. Eu instalei horizontalmente. Uma vez que o suporte é projetado para ser giratório, ele pode ser facilmente ajustado até que 0,0 seja exibido no visor.
Então, o primeiro teste pode começar.
No geral, estou muito feliz com a solução. O sensor reage muito rapidamente e os valores calculados correspondem exatamente à profundidade da perfuração.
E graças ao grande display de LED, não preciso me preocupar com óculos de até 85 anos para ler a profundidade exata da broca.
Portanto, lembre-se sempre do que Paulo diz:conserte o que o incomoda!
Divirta-se construindo!
___________________________________________________________
Alguns links úteis:
https://medium.com/@kavindugimhanzoysa/lets-work-with-mpu6050-gy-521-part1-6db0d47a35e6
ou https://playground.arduino.cc/Main/MPU-6050/
ou também https://circuitdigest.com/microcontroller-projects/mpu6050-gyro-sensor-interfacing-with-arduino/
Biblioteca de GY-521 de Rob Tilaart:https://github.com/RobTillaart/GY521
E verifique o livro de Paul Akers em https://paulakers.net/books/2-second-lean
Das Projekt gibt es auch auf Deutsch unter:https://techpluscode.de/bohrtiefenanzeige-mit-gyro-sensor/
Código
- profundidade de perfuração.ino
drill-depth.ino Arduino
/ * programa:drill-depth.ino * autor:Thomas Angielsky * versão:2021-03-20 * * https://techpluscode.de/ * https://techpluscode.de/bohrtiefenanzeige-mit-gyro- sensor / * * este esboço mede a profundidade de perfuração de uma máquina de perfuração de mesa * usando dados do sensor giroscópio GY-521 * a profundidade é visualizada por um display de 7 segmentos * * ideia de compensação de erro de cálculo de electronoobs.com - obrigado! * * / # 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; // LEDs de inicialização:pino D12, pino D11, pino D10, 1 moduleLedControl lc =LedControl (12,11,10,1); void setup () {// preparar conexão serial / /Serial.begin(9600); // valores iniciais stopPos =0.0; currentPos =0,0; rad_to_deg =180 / PI; // prepara o sensor GY-521 // usamos apenas dados do acelerador Wire.begin (); Wire.beginTransmission (MPU); Wire.write (0x6B); Wire.write (0x00); // ativa MPU Wire.endTransmission (true); // esse atraso foi muito necessário no meu caso! atraso (1000); Wire.beginTransmission (MPU); Wire.write (0x1C); // registra ACCEL_CONFIG Wire.write (0x10); // Definido como 00010000 para +/- 8g do intervalo de escala completa Wire.endTransmission (true); // calcula o erro de dados do acelerador // faz 100 medições para (int a =0; a <100; a ++) {Wire.beginTransmission (MPU); Wire.write (0x3B); Wire.endTransmission (false); Wire.requestFrom (MPU, 6, verdadeiro); 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ão preparar:pino D9 pinMode (9, INPUT_PULLUP); // prepara a exibição de 7 segmentos 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, verdadeiro); 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 o ângulo x para 360 usando +/- de X, Y, Z delta =0; if ((AccZ <0)) {delta =180.0-TotalAngleX * 2.0; } if ((AccZ> 0) &&(AccY <0)) {delta =360.0; } DrillingMachineAngle =TotalAngleX + delta; // se estiver perto de 360, exibir melhor 0 if (DrillingMachineAngle> 350) {DrillingMachineAngle =0;} // calcular a profundidade de perfuração // profundidade máxima de perfuração:50 mm (medido na máquina) // ângulo máximo da roda manual:316 (medido com dados 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ão pressionado? if (digitalRead (9) ==LOW) {// armazena a posição 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("Buttonpressed "); atraso (1000); } if (stopPos> 0) {// posição de parada alcançada? if (currentPos> =stopPos) {// sim:exibe STOP (5t0P) no lado direito lc.setChar (0,3, '5', false); lc.setRow (0,2, B00001111); lc.setChar (0,1, '0', falso); lc.setChar (0,0, 'P', falso); } else {// não:exibe a distância para a posição de parada dtostrf (stopPos-currentPos, 4,1, txt); s ='' + String (txt); lc.setChar (0,0, s.charAt (s.length () - 1), falso); lc.setChar (0,1, s.charAt (s.length () - 3), verdadeiro); lc.setChar (0,2, s.charAt (s.length () - 4), falso); lc.setChar (0,3, s.charAt (s.length () - 5), falso); }} else {// não exibe nada lc.setChar (0,3, '', false); lc.setChar (0,2, '', falso); lc.setChar (0,1, '', falso); lc.setChar (0,0, '', falso); } // exibe a profundidade de perfuração atual no lado esquerdo // formate como string dtostrf (currentPos, 4,1, txt); s ='' + String (txt); lc.setChar (0,4, s.charAt (s.length () - 1), falso); lc.setChar (0,5, s.charAt (s.length () - 3), verdadeiro); lc.setChar (0,6, s.charAt (s.length () - 4), falso); lc.setChar (0,7, s.charAt (s.length () - 5), falso); atraso (200);}
Peças personalizadas e gabinetes
drill-depth-3d-model_Yn2q0MSNa4.zipEsquemas
Processo de manufatura
- A integração dos dados do sensor com o microprocessador Raspberry Pi
- Sensor de rastreamento de linha com RPi
- API do sensor ambiental com um RPi
- Aeroponia com Raspberry Pi e sensor de umidade
- Raspberry Pi GPIO com sensor de movimento PIR:Melhor tutorial
- Usando o sensor de radar pulsado A111 com um Raspberry Pi
- Interface do sensor de movimento HC-SR501 PIR com Raspberry Pi
- Python / MicroPython Sensor Logger com Planilhas Google
- Sensor Portenta e Termopar (com MAX6675)
- Dispositivo de medição de pressão de fluxo de ar com sensor analógico