Nauwkeurige boordiepteweergave met gyroscoopsensor & Arduino Nano

Onderdelen en benodigdheden

Arduino Nano R3

×

1

Benodigde tools en machines

• 3D-printer (generiek)

Apps en online diensten

• Arduino IDE

Over dit project

Als je een bepaalde boordiepte nodig hebt voor een project, heb je een tafelboormachine met diepteweergave nodig. De meeste tafelboormachines hebben een liniaal met een pijl voor aflezen. Het succes hangt af van hoe nauwkeurig je de gewenste positie kunt aflezen. In dit Arduino-project presenteer ik een alternatief: een boordiepteweergave met een gyroscoopsensor en 7-segmentdisplay met Arduino-ondersteuning.

De machine die ik het meest gebruik in mijn werkplaats is niet een zaag of slijpmachine. Het is verreweg de tafelboormachine. Ongeacht het project, wordt hij eigenlijk altijd gebruikt. Als ik een bepaalde boordiepte nodig heb, kan ik de ingebouwde liniaal gebruiken. En de diepte onthouden waar ik moet boren. Dat werkt eigenlijk goed.

Maar met toenemende leeftijd – ja, ja, ja – wordt het steeds moeilijker voor me om de diepte met millimeter-nauwkeurigheid af te lezen. En als het licht niet helder genoeg is, is het bijna onmogelijk. Maar gewoon een bril opzetten voor dit? En na het boren, waar de bril bewaren? Ik ben er nog niet zo ver.

Volgens de motto van Paul Akers uit "2 Second Lean":

Er moet een betere oplossing zijn, je hoeft er maar over na te denken en het te maken.

Meetmogelijkheden

Ik kon een vergrotingsglas voor de schaal plaatsen om de liniaal beter leesbaar te maken. Dat zou de leesbaarheid verbeteren, maar helpt niet dat ik de meting telkens moet onthouden. En als je klust, moet het ook leuk zijn.

Daarom is een elektronische oplossing veel beter. Liever in een kleine vormfactor zodat alles naast de aan/uit-schakelaar van de boormachine past. Voor zulke gevallen gebruik ik graag een Arduino Nano. Het heeft voldoende pinnen om vrijwel alles te sturen en is entsprechlijk klein.

Maar hoe meet je de boordiepte? Er zijn verschillende mogelijkheden voor lengtemeting. Ultrasonische meting installeren? Kan werken, maar vereist wat mechanica die mee beweegt met de boor als reflectie-oppervlak. Of een draad-encoder? Mogelijk, maar heel complex als je het zelf bouwt: met een draaitafel, vorklichtsluisen en veerterugkeer. Beter direct een draaiencoder? Dat zou veel minder componenten betekenen – ja, maar te grof, je zou tandwielen voor een vertaling moeten monteren.

Ok, verder nadenken.

Mijn boormachine heeft, als de meeste, een handwiel aan de zijkant voor diepte-instelling. Dit kan ongeveer 270° gedraaid worden. Dus niet eens een volle draai.

Dit is perfect voor een hoekmeting met een gyroscoopsensor. De kabelverbinding kan niet verwringen en er is slechts één goedkope component nodig. De gyroscoopsensor kan ook heel eenvoudig direct op de draai-as van het handwiel worden gemonteerd.

Concept

Ik ga altijd op dezelfde manier te werk bij het bepalen van een boordiepte: het oppervlak aanprikken met de boor, de coördinaat noteren, dan de gewenste boordiepte erbij optellen en tot die diepte boren.

Ik wil het basisproces behouden. Om niet te diep te boren, wil ik informatie krijgen wanneer de boordiepte bereikt is.

Een knop overneemt deze functie. Wanneer je hem indrukt, slaat de Arduino de huidige boorpositie op als stopwaarde en kan me later herinneren wanneer die bereikt wordt.

De overige componenten nemen meer ruimte in en wegen zwaarder. Gelukkig is de behuizing van mijn machine van metaal. Daarom gebruik ik een neodymiummagneet om het te fixeren.

De vraag blijft: hoe moet de sensor aan de machine bevestigd worden?

De as van de boor heeft een SW17 zeskantmoer. Ik heb dus alleen een 3D-geprint onderdeel nodig dat de sensor accepteert en op de zeskantmoer past.

Benodigde componenten

• Arduino Nano
• Gyroscoopsensor GY-521 (MPU-6050)
• 7-segment module met 8 digits (SPI versie met MAX7219 IC)
• Drukknop
• Aan/uit schakelaar
• Voeding: batterijclippen voor AA/AAA batterijen of powerbank
• 3D-geprinte behuizing
• Neodymiummagneet

Aansluiting gyroscoopsensor (I2C)

• VCC → 5V
• GND → GND
• SCL → A5
• SDA → A4
• XDA → niet aangesloten
• XCL → niet aangesloten
• ADO → niet aangesloten
• INT → niet aangesloten

7-segment module (SPI)

Elke digitale pin kan gebruikt worden. Pinnen worden in de sketch ingesteld.

• VCC → 3.3V
• GND → GND
• DIN → D12
• CS → D10
• CLK → D11

Knop

Ingangspin van de knop is vrij te kiezen. Ik gebruik pin D9.

Voeding

Ik gebruik 6 AA-batterijen. Na de aan/uit-schakelaar voeden ze het hele systeem.

Behuizing

De behuizing is ontworpen met Autodesk Fusion 360. De 3D-print is gemaakt met een Anycubic i3 Mega. De neodymiummagneet voor bevestiging aan de machine is ingelijmd. Als de hele boordiepteweergave in de weg zit, is alles snel verwijderd.

Arduino Sketch

Ik gebruikte de LedControl.h bibliotheek voor het 7-segmentdisplay. Als nog niet geïnstalleerd, installeer via de bibliotheekbeheerder.

De gyroscoopsensor communiceert via de I2C-bus. Bij zoeken naar bibliotheken besloot ik geen te gebruiken. Communicatie loopt via Wire.h.

Aan het einde van het artikel vind je enkele nuttige links.

De besturing van het 7-segmentdisplay werkt prima met LedControl. Na initialisatie met de pinnen, hoeft de setup alleen het display wakker te maken en de intensiteit in te stellen.

In de loop toont het display alleen de huidige boordiepte en, indien ingesteld, de stoppositie, als getallen.

Het display verwacht elk cijfer als karaktertype. Ik wil één decimaal voor nauwkeurigheid. De functie dtostrf zet een float om in een karakterarray. Dan naar een String voor karakter-voor-karakter weergave op het display.

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);  // decimaalteken
lc.setChar(0, 6, s.charAt(s.length() - 4), false);
lc.setChar(0, 7, s.charAt(s.length() - 5), false);

Wanneer de stoppositie bereikt is, verschijnt "StOP" op het display. Het kleine "t" wordt gegenereerd met setRow en bitpatroon B00001111.

Uitlezen van de gyroscoopsensor werkt via functies van de Wire-bibliotheek. Ik gebruik alleen de versnellingsmeter voor de hoekbepaling.

Belangrijk: Met USB-verbinding naar de Arduino IDE werkte alles perfect. Na uithalen en aansluiten op de externe voeding, gaf de sensor geen data. Het werkte pas na een reset van de Arduino.

Dit gaf me de meeste hoofdpijn in het hele project. Je kunt zeggen dat de boordiepte-indicator misschien mijn ogen redde, maar daardoor haalde ik bijna al mijn haar uit!

Na lang zoeken was een wachttijd na het ontwaken van de sensor de oplossing. Dit maakt de delay(1000) de belangrijkste commando in de hele broncode.

// GY-521 sensor voorbereiden
// We gebruiken alleen versnellingsmeter data
Wire.begin();
Wire.beginTransmission(MPU);
Wire.write(0x6B);
Wire.write(0x00); // Wake up MPU
Wire.endTransmission(true);

// Deze delay was in mijn geval absoluut noodzakelijk!
delay(1000);

Wire.beginTransmission(MPU);
Wire.write(0x1C); // Register ACCEL_CONFIG
Wire.write(0x10); // Instellen als 00010000 voor +/- 8g full scale range
Wire.endTransmission(true);

Offset-waarden moeten aan het begin bepaald worden, anders fluctueren de waarden. In de setup worden 100 metingen gedaan en de afwijkingen gemiddeld.

De hoek berekenen uit sensordata is niet triviaal. Er zijn veel handleidingen voor de berekeningen.

De X-hoek in graden wordt berekend met:

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

De versnellingsmeterwaarden fluctueren sterk. Daarom wordt de nu berekende waarde gemiddeld met de vorige waarde (50% elk).

TotalAngleX = 0.5 * TotalAngleX + 0.5 * AccAngleX;

De hoekwaarden lopen van -90° tot +90°. Maar ik heb 0° tot 360° nodig voor de omrekening naar boordiepte.

Ik heb nog geen simpele oplossing gevonden. Voor mijn toepassing is het voldoende om te kijken of sensordata Z en Y positief of negatief zijn, en de hoek om te rekenen.

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

// Als dichtbij 360°, toon beter 0°
if (DrillingMachineAngle > 350) { DrillingMachineAngle = 0; }

Wat ontbreekt is de maximale draaihoek die het handwiel toelaat. Eenvoudigste manier: de berekende hoek via Serial.print uit laten geven en de maximumwaarde noteren.

Bij mij is dat 316°. Met een maximale boordiepte van 50 mm wordt de huidige positie berekend als:

currentPos = 50.0 / 316.0 * DrillingMachineAngle;

Als de knop wordt ingedrukt, slaat de Arduino de huidige boorpositie op. Op het display verschijnt 8888 en er is een korte wachttijd van 1 seconde.

Als een stoppositie is ingesteld, wordt de resterende boordiepte tot de stop op het rechterdisplay getoond.

Montage en test

De gyroscoopsensor wordt het beste met een puntje lijmpistool vastgezet. Leid de verbindingsdraden door het deksel. Dat is alles voor dit deel.

Bij de eerste test moet de gyroscoopsensor eerst uitgelijnd worden. Ik monteerde hem horizontaal. Omdat de houder draaibaar is, kan hij eenvouwig worden aangepast tot 0.0 op het display wordt getoond.

Dan kan de eerste test beginnen.

Over het algemeen ben ik erg tevreden met de oplossing. De sensor reageert heel snel en de berekende waarden komen precies overeen met de boordiepte.

En dankzij het grote LED-display hoef ik me geen zorgen te maken over een bril tot 85 jaar om een exacte boordiepte af te lezen.

Onthoud altijd wat Paul zegt: Los wat je irriteert!

Veel bouwplezier!

---

Misschien nuttige links:

• MPU6050 GY-521 handleiding deel 1
• Arduino Playground MPU-6050
• MPU6050 gyroscoop interfacing met Arduino
• GY-521 bibliotheek van Rob Tillaart
• Paul Akers boek over 2 Second Lean
• Dit project is ook in het Duits beschikbaar: techpluscode.de

Code

De complete Arduino-sketch drilling-depth.ino:

/* program: drilling-depth.ino
 * author: Thomas Angielsky
 * version: 2021-03-20
 * https://techpluscode.de/
 * https://techpluscode.de/bohrtiefenanzeige-mit-gyro-sensor/
 * meet boordiepte van tafelboormachine met GY-521 gyroscoopsensor
 * diepte zichtbaar op 7-segment display
 * idee voor foutcompensatie van electronoobs.com - dank!
 */
#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 LEDs: pin D12, D11, D10, 1 module
LedControl lc = LedControl(12, 11, 10, 1);

void setup() {
  // Startwaarden
  stopPos = 0.0;
  currentPos = 0.0;
  rad_to_deg = 180 / PI;

  // GY-521 sensor voorbereiden (alleen versnellingsmeter)
  Wire.begin();
  Wire.beginTransmission(MPU);
  Wire.write(0x6B);
  Wire.write(0x00); // Wake up MPU
  Wire.endTransmission(true);

  // DEZE DELAY WAS IN MIJN GEVAL ABSOLUUT NODIG!
  delay(1000);

  Wire.beginTransmission(MPU);
  Wire.write(0x1C); // Register ACCEL_CONFIG
  Wire.write(0x10); // Instellen als 00010000 voor +/- 8g full scale range
  Wire.endTransmission(true);

  // Versnellingsmeter data fout berekenen (100 metingen)
  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;

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

  // 7-segment display
  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;

  // Waarden gladstrijken
  TotalAngleX = 0.5 * TotalAngleX + 0.5 * AccAngleX;

  // X-hoek omrekenen naar 360 graden met +/- van 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;

  // Als dichtbij 360°, toon 0°
  if (DrillingMachineAngle > 350) { DrillingMachineAngle = 0; }

  // Boordiepte berekenen
  // Max boordiepte: 50 mm (gemeten op machine)
  // Max hoek handwiel: 316° (gemeten met Serial.print data)
  currentPos = 50.0 / 316.0 * DrillingMachineAngle;

  // Knop ingedrukt?
  if (digitalRead(9) == LOW) {
    // Stoppositie opslaan
    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) {
    // Stoppositie bereikt?
    if (currentPos >= stopPos) {
      // Ja: toon STOP (5t0P) op rechterdisplay
      lc.setChar(0, 3, '5', false);
      lc.setRow(0, 2, B00001111); // kleine 't'
      lc.setChar(0, 1, '0', false);
      lc.setChar(0, 0, 'P', false);
    } else {
      // Nee: toon afstand tot stoppositie
      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 {
    // Niets tonen
    lc.setChar(0, 3, ' ', false);
    lc.setChar(0, 2, ' ', false);
    lc.setChar(0, 1, ' ', false);
    lc.setChar(0, 0, ' ', false);
  }

  // Huidige boordiepte tonen op linker display
  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);
}

3D-print bestanden

drilling-depth-3d-model_Yn2q0MSNa4.zip

Schema's