HeadsetMouse selbst gebastelt -DIY-

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    • Huhu... die Version 0.0.2 ist da :)

      Ein guter alter Kumpel von mir ist Schuld das ich eine zweite HSM (HeadSetMouse) bauen musste.

      Da dachte ich mir, "Machste gleich eine Tutorial draus... für Jederman"
      Mein Anspruch ist es das jeder mit etwas Grundkenntnissen in der Programmierung und handwerklichen Geschick in die Lage versetzt wird, an Hand dieser Anleitung eine funktionstüchtige HSM zu bauen.

      Ich würde mir freuen wenn die Leute die diese Anleitung nutzen auch Feedback geben könnten, wo es trotz der Anleitung "klemmte".
      Hier entsteht jetzt eine Schritt für Schritt Anleitung mit Bildern und Tips plus dem zugehörigen Code.
      Am Ende werde ich noch ein paar Sachen/Überlegungen/Verbesserungen aufführen die mir im Betrieb oder dem Aufbau aufgefallen sind und Ansätze wie man sie umsetzten könnte.


      Vorbereitung für die Hardware

      Spoiler anzeigen


      • CD-Maker
      • Lötfett
      • Lötzinn
      • Kabel in vorzugsweise in 5 verschieden Farben
      • Taster
      • Lochrasterplatine
      • Arduino + Stiftleisten (12 Einheiten)
      • MPU6050 + Stiftleisten (8 Einheiten)
      • kleinen Maden-Schraubendreher
      • kleine Seitenschneider
      • Lupe
      :!:
      Hilfreich

      • weiche Unterlage (Tuch)
      • kleine Zange
      • feine Feile
      • grober Pinsel
      • Entlötpumpe
      • Entlölitze
      • Dremel mit Trennscheibe oder kleine Metallsäge (z.B. Puksäge)
      • Multimeter







      Stiftleisen und Taster auf der Lochplatine befestigen


      Die Stiftleisten einfach mit dem kurzen Beinen durch die Platine stecken und an einer Stelle anlötend damit sie nicht mehr rausfallen.
      Anschließend habe ich mit dem kleinen Schreibendreher das Lötfett auf die Beine sehr dünn aufgetragen.


      Ein weiches Tuch als Unterlage verhinder das wegrutschen der Platine beim löten ganz gut.

      :!:
      Achtet beim festlöten darauf das die Stiftleiste auf der Platine direkt aufliegt.
      Die Kupferaugen können sich sehrleicht lösen wenn man später von der Oberseite Druck ausübt.
      Achtet beim löten darauf das ihr die Stellen nicht zu sehr erhitzt.


      Tip:
      Ich halte meißt das Zinn auf die eine Seite und den Lötkolben auf die andere Seite von dem Punkt den ich löten möchte.
      Dann setzte ich den Lötkolben an den Pin oben an und fahre damit langsam runter Richtung Platine bis auf das Kupferauge.
      So erhitzt sich die Lötstelle gleichmässig.
      Dann von links das Lötzinn kurz ranhalten und das Zinn sollte sich schön gleichmäßig verteilen.
      Es ist etwas Übung nötig aber das wird schon. ;)

      Das Ergebniss sollte in etwa so aussehen.


      Leider habe ich für den nächsten Einzelschritt vergessen Bilder zu machen aber das Prinzip sollte aber klar sein. ;(

      Nun kommt Stiftleiste für den MPU6050.
      Sie hat 8 Stifte und kann direkt an die schon festgelöteten Stiftleisten für den Arduino angesetzt werden, so das sich eine Linie ergibt.

      Ersatzbild:
      Der schwarze Stich markiert den Übergang von links nach rechts: Arduino | MPU6050 | Taster


      :!:
      Prüft vor dem Löten ob der Arduino und der MPU6050 anschliessend auch spannungsfrei auf den Leisten aneinander anliegen können.
      Ich habe mit eine feinen Feile den Arduino und MPU eh etwas entgratet, da noch Grate (Ecken und Kanten) vorhanden waren.
      In der Regel sollte es aber passen.

      Der Taster
      Ganz nach dem Motto: "Passt nicht, gibs nicht."
      Mein Taster, den ich in meiner Grabbelkiste gefunden hatte, passte aufgrund des Lochabstandes nicht in die Platine. Besser gesagt immer nur 1 Beinchen.
      Also kurzer mit dem Multimeter durchgemessen, wie der Taster aufgebaut ist, und welches Bein ich amputieren kann.
      In userem Fall ist es egal wie wir ihn verwenden (Öffner/Schließer), da wie im Code selbst festlegen können welchen Zustand wir erwarten um darauf zu regagieren.
      Wichtig ist nur das ihr den Eingang nicht erwischt.

      Erklärung:
      Ein Taster hat meist 1 "Eingang" (mitte) und 2 Ausgänge (oben, unten).
      So hat man die Möglichkeit die Taster als "Öffner" oder "Schließer" zu nutzen.


      *knips*


      Nun wird der Taste mit etwas Abstand zum MPU6050 auf die Platine gesteckt und markiert wo die Pin´s rauskommen.
      Dazu musste ich allerding die Löcher etwas aufweiten da die Beinchen minimal breiter waren.
      Ich habe dafür ein kleinen Kreuzschraubendreher genutzt.

      Da ich die Kabel gerne zwischen der Platine und dem Aufbau (Arduino und MPU) haben wollte musste ich vor dem löten noch die Kabel für den Taster anbringen.
      Da ich das vergessen hatte musste ich später den Taster nochmal ablöten.
      Beim Punkt "Das verkabeln" wird es verständlicher. :)

      Bevor es nun an das verkabel geht werden nochmal alle Teile aufgesteckt und geschaut das sie möglichst ohne Spannung sitzen.



      Das verkabeln.

      Das ist das fummligste.
      Wo was hin hinkommt kann man auf der Übersicht gut entnehmen.
      Hier bietet es sich natürlich an für jedes Kabel eine andere Farbe zu nutzen um so besser ihre Funktion besser auseinander halten zu können
      • rot 5V [Plus]
        • Arduino Pin (VCC) --> MPU6050 Pin (VCC)
      • schwarz [Minus]
        • Arduino Pin (GND) --> MPU6050 Pin (GND)
      • weiß ["Datenleitung"]
        • Arduino Pin (3) --> MPU6050 Pin (SCL)
      • gelb["Datenleitung"]
        • Arduino Pin (2) --> MPU6050 Pin (SDA)
      • TASTER:
      • schwarz [Minus]
        • Taster Pin (egal ("richtiger" den Eingang)) --> Pin irgendein GND von Arduino oder MPU6050
      • rosa [getastete Ader]
        • Arduino Pin (9) --> Taster Pin (egal ("richtiger" den Ausgang bzw.Schließer))

      Ich habe erstmal nur eine Seite der Adern auf der Arduinoseite bzw. Taster-Seite gelötet um es besser darzustellen.

      Dazu habe ich das Kabel etwa 3-5mm abgesetzt (Isolierung entfernt) und von oben durch die Platine gesteckt.
      Anschließend habe ich mit einer kleinen Zange oder einem kleinen Maden-Schraubendreher die Ader in Richtung des Pin´s gebogen mit der sie verbunden werden soll.


      Dann wieder mit etwas Lötfett bestreichen und zusammen löten.
      Eventuelle Überstände werden später noch abgeschnitten.


      Das Ergebniss.



      Nun kommt die andere Seite der Ader dran. Achtet darauf wo was hinkommt (Schaltplan).
      :!:
      Teilweise kann sich die Isolierung der Adern beim löten zurückziehen.
      Achtet darauf das keine blanken Stellen sich nicht berühren.
      Hier kann man nach dem Durchmessen auf Fehler gerne mit Heißkleber für zusätzliche Sicherheit sorgen.



      Überstände entfernen und auf Fehler prüfen

      Einfach mit dem Seitenschneider alles weg was länger als ca. 2mm ist.
      Anschliesend habe ich alle Lötstellen nocheinmal erwärmt bis das Zinn flüssig war, um schafe Kanten zu entfernen.
      Dann mit einem groben Pinsel Reste und überschüssiges Lötfett wegbürsten.



      Mit einem Multimeter prüfen wir nun ob auch nur die Stellen miteinander verbunden sind die es auch sollen.

      Dazu stellen wir auf dem Messgerät auf "Durchgangsprüfung". Das sollte da sein wo man Widerstände misst.

      Die meisten Geräte piepen auch wenn man die Messspitzen zusammen hält.


      Die Punkte die durch eine Linie verbunden sind dürfen piepen, die anderen eben nicht.



      Wenn alles ohne Fehler ist kann man nun die Platine auf die Größe anpassen die man möchte.

      Ich habe dafür einen Dremel mit Trennscheibe benutzt, es geht aber auch mit einer Puksäge.



      Jetzt nochmal alle scharfen Kanten abfeilen und mit dem groben Pinsel säubern.




      Nun kann auch der Heißkleber zum stabilisieren drauf. Nur nicht zu dick.



      Jetzt noch den Arduino und den MPU6050 auf die Stiftleisten und verlötet und die Hardware ist geschafft. :thumbsup:




      Da ich das Teil (HeadSetMouse(HSM)) auf meinem Headset festmachen möchte, habe ich mir noch ein kleines "Softcase" gebastelt. :D

      So wird verhindert das die Lötstellen den Headset-Bügel zerkratzen und es liegt besser auf da die Rundung des Bügels ausgeglichen werden.

      Da nix an der HSM heiß wird passiert da auch nichts 8)








      Der Code

      Hier der überarbeitete Code mit Kommentaren zur freien Verwendung.

      Wie ihr das nun auf den Arduino bekommt erläutere ich hier später wenn gewünscht.

      Aber Google sollte da eigentlich schon reichen ;)






      Spoiler anzeigen

      C-Quellcode

      1. /* HeadSetMouse
      2. * EldaRion
      3. */
      4. #include <Wire.h> // https://www.arduino.cc/en/Reference/Wire
      5. #include <I2Cdev.h> // https://platformio.org/lib/show/107/I2Cdevlib-MPU6050
      6. #include <MPU6050.h> // https://playground.arduino.cc/Main/MPU-6050
      7. #include <Mouse.h> // https://www.arduino.cc/reference/en/language/functions/usb/mouse/
      8. MPU6050 mpu; // MPU6050 initialisieren
      9. int16_t ax, ay, az, gx, gy, gz; // Variablen fuer die X-; Y-; Z-; Achse initialisieren
      10. int vx, vy, vz;
      11. const int Button_OnOff = 9; // Pin am Arduino (Taster (LOW = gedrückt))
      12. const int LedOnBord = 17; // Pin am Arduino (linke/untere (TX) LED (LOW = an))
      13. bool headMouseAktive = false; // HeadMous aktive/inaktiv
      14. // Funktion wird nur 1x beim 'einschalten' oder 'Reset' des Arduinos ausgefuehrt
      15. void setup() {
      16. pinMode(Button_OnOff, INPUT_PULLUP); // Anschluss (9) als Eingang definieren und Pull Up Widerstand aktivieren
      17. pinMode(LedOnBord, OUTPUT); // Anschluss (17) als Ausgang definieren
      18. //Serial.begin(9600); // Serielle Uebertragung oeffnen
      19. Wire.begin(); // IC2-kommunikation aktivieren
      20. }
      21. //##### Hilfsfunktionen #####
      22. void LED_on() { // Funktion zum EIN-schalten der LED
      23. digitalWrite(LedOnBord, LOW); // LED an
      24. }
      25. void LED_off() { // Funktion zum AUS-schalten der LED
      26. digitalWrite(LedOnBord, HIGH); // LED aus
      27. }
      28. bool check_Button_OnOff() { // Funktion zum pruefen ob der Taster gedrueckt wurde
      29. if (digitalRead(Button_OnOff) == LOW) {
      30. // Button geschlossen
      31. return true;
      32. } else {
      33. // Button offen
      34. return false;
      35. }
      36. }
      37. void headMouse_onOff() { // Funktion zum pruefen ob headSetMouse aktiv ist
      38. Serial.begin(9600); // Serielle Uebertragung oeffnen
      39. if (digitalRead(Button_OnOff) == LOW) {
      40. // Button gedrückt
      41. LED_on(); // LedOnBoard EIN-schalten
      42. if (Serial1) { // pruefen ob eine serielle Verbindung besteht
      43. Serial.println("LED: on"); // Ausgabe auf dem seriellen Monitor
      44. }
      45. } else {
      46. // Button offen
      47. LED_off(); // LedOnBoard AUS-schalten
      48. if (Serial1) { // pruefen ob eine serielle Verbindung besteht
      49. Serial.println("LED: off"); // Ausgabe auf dem seriellen Monitor
      50. }
      51. }
      52. Serial.end(); // Serielle Uebertragung schliessen
      53. }
      54. void toggle_HeadSetMouse_OnOff() {
      55. Serial.begin(9600); // Serielle Uebertragung oeffnen
      56. if (headMouseAktive == true) {
      57. headMouseAktive = false;
      58. LED_off(); // LedOnBoard AUS-schalten
      59. if (Serial1) { // pruefen ob eine serielle Verbindung besteht
      60. Serial.println("LED: off"); // Ausgabe auf dem seriellen Monitor
      61. }
      62. } else {
      63. headMouseAktive = true;
      64. LED_on(); // LedOnBoard EIN-schalten
      65. if (Serial1) { // pruefen ob eine serielle Verbindung besteht
      66. Serial.println("LED: on"); // Ausgabe auf dem seriellen Monitor
      67. }
      68. }
      69. Serial.end(); // Serielle Uebertragung schliessen
      70. delay(1000); // warte 1000 Millisekunden (verhindert das zu schnelle umschalten zwische ein-/aus durch den Taster)
      71. }
      72. //##### Endlosschleife fuer das eigentliche 'Programm' #####
      73. void loop() {
      74. if (check_Button_OnOff()) { // wurde der Taster gedrueckt
      75. toggle_HeadSetMouse_OnOff(); // HeadSetMouse umschalten
      76. }
      77. if (headMouseAktive == HIGH) { // ist die HeadSetMouse aktiv
      78. mpu.initialize(); // initialisiere mpu
      79. if (!mpu.testConnection()) {
      80. while (1); // prueft ob MPU6050 Daten liefert; sonst warten
      81. }
      82. mpu.getMotion6(&ax, &ay, &az, &gx, &gy, &gz); // MPU alle 3 Beschleunigungens-Werte (X-,Y-,Z-, /-Achse) holen
      83. /* Erklaerung
      84. ##### vx = (gx + 300) / 150; #####
      85. - vx = Variable
      86. - gx = Wert aus dem Gyro
      87. - '+300' zum kalibrieren der Achse in "Ruhestellung"
      88. - '/ 150' Multiplikator für die Bewegegung der Maus (Geschwindigkeit/Empfindlichkeit)
      89. */
      90. //vx = (gx + 300) / 150; // (nicht benoetigt) vor-zurueck ("+150") zum kalibrieren der X-Achse
      91. vy = -((gy - 675) / 200) * -1; // links-rechts ("-675") zum kalibrieren der Y-Achse
      92. vz = ((gz + 165) / 200) * -1; // hoch-runter ("+165") zum kalibrieren der Z-Achse
      93. if (Serial1) {
      94. // Ausgabe auf dem seriellen Monitor
      95. Serial.println("HeadSetMouse: aktiv");
      96. // X-Achse
      97. //Serial.print("gx = ");
      98. //Serial.print(gx);
      99. //Serial.print(" | X = ");
      100. //Serial.println(vx);
      101. // Y-Achse
      102. Serial.print("gy = ");
      103. Serial.print(gy);
      104. Serial.print(" | Y = ");
      105. Serial.println(vy);
      106. // Z-Achse
      107. Serial.print("gz = ");
      108. Serial.print(gz);
      109. Serial.print(" | Z = ");
      110. Serial.println(vz);
      111. // Ausgabe auf dem seriellen Monitor ENDE
      112. Mouse.move(vz, vy); // Maus um die uebergebenen Werte bewegen
      113. } else {
      114. if (Serial1) {
      115. Serial.println("HeadMouse: aus");
      116. }
      117. }
      118. delay(20);
      119. }
      120. }
      Alles anzeigen


      Sachen die mir noch aufgefallen sind, Verbesserungen die ich noch machen möchte und weiterführende Ideen werde ich ein anderes mal hier aufführen.

      Ich hoffe das ich die Anleitung so gestaltet habe, das es nun jedem möglich ist eine HSM zu bauen. :saint:

      Viel Spaß
      Bilder
      • 19.fertig_2_20180221_111902.jpg

        452,82 kB, 1.978×632, 41 mal angesehen
      • alle_Kabel_geloetet_20180220_173033.jpg

        413,83 kB, 900×1.599, 40 mal angesehen
      • 9.Kabel_vorbereiten_vorn_20180220_165736.jpg

        145,5 kB, 475×844, 38 mal angesehen
      MfG EldaRion
    • So meine Lieben, ein "Mini-Update" ?( ist da. 8o 8o 8o

      Anlass ist das Update von Cattle and Crops und die Erfahrung von meinem langjährigen Kumpel @Goettervater.

      Das Update von CnC (Auszug)
      Changelog:
      • NEU: Head-Tracking wird jetzt auf Basis des FreeTrack 2.0 Protokolls unterstützt. Dieses Protokoll wird u.a. von FreeTrackNoIR, OpenTrack und TrackIR unterstützt.
        Wie üblich bei Head-Tracking-Lösungen, muss dafür unter Windows die Head-Tracking Software im Hintergrund laufen.
        Unter Linux wird Head-Tracking per Linux Track unterstützt
      Als Erfahrungsbericht erhielt ich von Götti das er sich die ein oder andere Funktion wünschte. Zum Beispiel das zurücksetzten der "Nullposition" des Kopfes, kalibrieren über ein Interface und so weiter und so fort. 8| Anwender eben :P
      Auch hielt die Freude nicht lange an ;( , da sich der Micro-USB-Anschluss des Arduinos als "Schwachstelle" herausstellte. Sie hat sich schlicht vom Boad gelöst.

      Da dachte ich mir... Die Grundlage ist ja da, also ran ans Werk und kompatibel "OpenTrack" machen.
      Das ist eine open-source Software die so ziemlich alles als Eingabe frist was man irgendwie an den PC anstöpseln kann und die Ausgabe beliebig anpassen kann.

      Dabei bin ich auf eine sehr umfangreiche und ausführlich Anleitung gestossen, allerdings auf englisch. EdTracker.
      Der RIESEN Vorteil bei seinem Projekt ist, das man kein bisschen programieren muss.
      Seine Software bietet alles was man in meinem Projekt "händisch" machen musste. Also selbst auf dem Microcontroller programieren.
      Also alles SEHER Anwenderfreundlich...selbst meine "Einkaufsliste" bleibt gleich.

      Also habe mich mal ein Tag hingesetzt und geschaut in wie fern ich mein Projekt anpassen muss um die Software nutzen zu können.
      Warum soll man das Rad 2,3..., 1000 mal neu erfinden ?( und da das Projekt auch open-source ist, lag es nahe die "Vorarbeit" zu nutzen.

      Das Ergebnis von einem Tag fummeln mit meiner Hardware, funktionierte tatsächlich alles wie es sollte. 8o

      Da ich mit meinem Hardwarelayout noch nicht 100% zufrieden war, auch wegen dem USB-Anschluss, habe ich mir auch mal ein "Bauvorschlag" von ihm, bzw anderen "Mitbastlern" angeschaut und am zweiten Tag umgesetzt.

      Hier das Ergebnis... :thumbsup:
      Ich nenne es liebevoll "Sandwich-HeadSetMouse" :D
      Ok, ok... meim nächsten mal arbeite ich sauberer was die Lötarbeit angeht X/



      Hier nochmal das Ganze im Betrieb.


      Ich hab es auch schon auf die schnelle mal in Cattle and Crops ausprobiert, und wie soll ich es sagen :/
      Es geht :thumbup:

      Ok, ganz fertig ist es noch nicht.
      Die Achszuweisung passt noch nicht 100 prozentig aber das ja bei jeder neuen Hardware so. :saint:
      Aber ich denke, auch das werde ich noch schaffen. Ich wollte es nur erstmal schon berichten. :)

      Wenn wer hilfe brauch bei der Umsetzung,
      oder ich mir nochmal die Mühe machen soll ein neu Anleitung zu basteln,
      einfach hier mal melden. ;)
      MfG EldaRion
      -Gadarol.de Werbung-
    • Und wieder habe ich ein kleines Update für euch. ;)


      Was haben wir hier eigentlich gemacht?

      Wir wollten uns eine Möglichkeit schaffen Kopfbewegungen in ein Spiel zu übertragen.
      Sogenanntes HeadTracking.

      Was ist HeadTracking eigentlich und wie funktioniert es?

      Im Grunde lesen wir nur Werte ein (Sensor), interpretieren und verarbeiten sie (Software) und geben sie als Steuerbefehl an den PC aus.
      Eingabe-Verarbeitung-Ausgabe (EVA(kommt mir irgendwie bekannt vor :D))

      Da gibt es verschiedene Ansätze.

      Auf dem Markt wird gene die Variante des IR-Trackings genutzt.
      Hierbei werden mindestens 3 IR-LED´s (Infrarot) genutz um die Position des Kopfes anhand der Ausrichtung der LED´s zu einem Empfänger zu erfassen.
      Ein bisschen Auswertung also Verarbeitung (Software) und schon kann der PC was damit anfangen.
      Ein Nachteil der mir gleich in den Kopf schoss, "Was ist wenn die der Empfänger geblendet wird?". Durch Sonne oder einfach weil es zu hell ist?
      Auch die Lagebestimmung anhand von 3 Punkten in Raum und deren programmiertechnische Umsetztung erschien mir etwas zu komplex. :/

      Da ich schon einige Erfahrung mit basteln habe und viel mit Gyros rumexperiemtierte (RC-Hubschrauber), dachte ich mir 'nimmste halt ein Gyro'.
      Der Nachteil mit dem Licht haben wir hier nicht da ein Gyro grundlegend anders funktioniert. Massenträgheit. Wiki hilft da sicher weiter :P
      Allerdings muss man dazusagen das auch hier äußere Einflüsse den Sensor stören können. Die Drehung der Erde zum Beispiel.
      Sie lassen sich aber wesentlich eleganter und leichter ausgleichen.

      Was macht ein Gyro?

      Einfach ausgedrückt erfasst ein Gyro die Lage (Ausrichtung) im Raum und geben sie schön aufbereitet mit mindestens 3 Werten wieder.
      Neigung der X-, Y-, Z- Achse.

      Auf die Kopfbewegung übersetzt:
      • nicken (Pitch)
      • drehen (Yaw)
      • Kopf auf die Schulter legen (Roll)
      Damit kann man schon eine ganze Menge machen, da ich nun weiß wie viel Grand sich mein Kopf um welche Achse gedreht hat.
      Gyros geben auch noch die Beschleunigung (G-Werte) der einzelnen Achsen wieder. Aber für unseren Zweck reichen die 3 Werte.
      Jetzt brauchen wir nur noch die Sensordaten kalibrieren. Also welcher Wert entspricht der 'Nullposition' auf jeder Achse.
      Interessant ist das auf der "Kopf drehen Achse" (Yaw), denn "die Erde dreht sich doch". 8o
      Im HeadTracking-Zusammenhang spricht man hier von dem Yaw-Drift. Durch die Drehung der Erde verändert sich dieser "Nullpunkt" quasi immer.
      Aber da sich die Erde dank des Mondes, der Neigung der Erdachse und vieler anderer tollen Sachen im All, schön gleichmäßig bewegt kann man diesen Drift sehr gut 'wegrechnen'.
      Stark vereinfacht ausgedrückt... Der Yaw-Wert vergrößert sich auf Grund des Drift pro Sekunde um 1 also verringere ich pauschal diesen Wert pro Sekunde um 1.
      Schon steht die Erde still... ach ne das war ja der Kopf :D

      Die "Software" bei meinem ersten Prototype war halt wirklich sehr einfach und befand sich auf dem Arduino direkt zusammen mit dem Sensor.
      Der Arduino selbst übernahm auch zeitgleich die Ausgabe der Steuerbefehle in dem er als Maus agierte.
      Fehler finden konnte da ganz schön nervig werden, da man keine direkte Ausgabe hatte. Es sei den man schreibt sie sich selbst und lässt es sich irgendwie ausgeben.
      Und bei jeder Änderung im Code... kompilieren und auf den Arduino übertragen.
      Anwenderfreundlicher ist natürlich eine extra Software die im Hintergrund auf dem PC läuft um die Roh-Sensordaten aufzubereiten.
      Der Arduino dient dann "nur noch" als Datensender der Sensordaten.
      Wie die Sensordaten dann interpretieren und was passieren soll, ist dann leichter zu händeln.
      Wenn alles im Arduino 'passiert' (Prototype 1) war halt der 'Nachteil' das man jedes mal die Software neu kompilieren und auf den Arduino übertragen werden musste.
      Das kalibrieren des Sensors kann dann schon mal nerven und eine Menge Zeit kosten.
      Hat man aber die Software auf dem PC, kann man sich ein schönes Userinterface basteln um auf Veränderungen einzugehen, und sie anders verarbeiten um die gewünschten 'Ausgabe' zu erhalten.

      Nun teilen wir das EVA-Prinzip anders auf.
      Eingabe: Hardware (Sensor und Arduino als Sender) auf dem Kopf
      Verarbeitung: Software auf dem PC
      Ausgabe: Maus- oder Joystick-bewegung

      Da ich nicht sehr geschickt bin in der UI-Gestaltung habe ich mich im Netzt weiter dazu belesen und bin auf verschieden Ansätze gestoßen.
      Und da man in der Programmierung das Rad nicht ständig neu erfindet, habe ich mir das für mich einfachste rausgefischt und meine Sachen daraufhin angepasst.

      Zwei Open-Source Projekte lieferten im Grunde das was ich wollte.
      Das erste OpenTrack. Es ist in der Lage verschiedenste 'Eingaben' so aufzubereiten, das man sinnvolle Ausgaben erhält. Und das alles mit einer schönem "KlickiBuntiInterface". :rolleyes:
      Alle möglichen Werte werden in Echtzeit angezeigt und mit einem kleinen Modell dargestellt um zu sehen ob die Ausgabe so ist wie erwartet.
      Unterstützt ein Spiel HeadTracking via OpenTrack muss OpenTrack im Hintergrund mitlaufen.

      Nun fehlte noch eine Programm um die Software für den Arduino anwenderfreundlich auf den Arduino zu bekommen um als Sensor und Datenlieferant zu dienen.
      Im Idealfall ohne Programmierkenntnisse. Auch hier habe ich ein Open-Source Projekt gefunden.

      EdTrackerUI. Mit diesem kleine Tool braucht man nur noch den Arduino+Sensor via USB anschließen.
      Der aktuellste Code wird aus Git-Hub runtergeladen, kompilieren und auf den Arduino übertragen.
      Auch hier hat man dann die Möglichkeit die Rohdaten des Sensors zu sehen und welche Ausgabe daraus erfolgt. Sehr sehr nützlich ist die Kalibrierungsmöglichkeit.

      Im Grunde kann man die OpenTrack-Software nun weg lassen, da der Arduino nun als Joystick mit 3 Achsen am PC erkannt wird.
      OpenTrack ist aber kompatibel mit der 'Eingabe' des so vorbereiteten Arduinos und erleichtert das feinjustieren der Achsen durch Kurven.
      Also ab wann wird eine Kopfbewegung als solche erkannt und wie groß soll die Auswirkung im Spiel sein.


      Nach dem ich nun 2 Tage an dem Beitrag geschrieben hab da mit ich nicht ganz so viel Blödsinn schreibe kommt nun "der Knaller" und das eigentliche Update. :D

      Anfangs hatte ich schon im Kopf das man ja an Stelle des Arduinos und dem Sensor als 'Eingabe' auch einfach ein Smartphone nehmen kann.
      Schließlich hat ein Smartphone in der Regel auch ein Gyro eingebaut welches unter anderen für die Navigation verwendet wird.
      So spart man sich extra Hardware, Lötarbeiten. Zusätzlich hat es ein Akku und mit der richtigen App könnte man die Daten via Funk übertragen.
      Also keine Kabel die nerven.
      Diese Variante habe ich mir bewusst bis zum Schluss aufgehoben da ich ja basteln wollte und ich kein Bock hatte mich auch noch mit der App-Entwicklung und ihren, ich nenne es mal "Feinheiten", also Stolperfallen auseinander zu setzten. ^^

      Also habe ich einfach mal im App-Store gestöbert und ratet mal was ich gefunden hab... ne App welche die Daten via WLAN oder USB an die OpenTrack-Software schicken kann. :D
      Die nächsten Schritte waren dann noch einfacher.

      1. mein erstes Smartphone was ich je bessen habe, Galaxy S, rausgekramt :)
      2. Handy ins WLAN gestopft
      3. App 'HeadTracker' installiert
      4. mit "Mama´s Schlüppergummi" das Handy auf das Headset getüddelt (Gummis oder Klettbänder tuhen es auch) :D
      5. OpenTrack konfiguriert :|
      6. Funktion getestet =O
      7. und gefreut :D
      8. Es funktioniert! :thumbsup:


      Mein Resümee.
      - mit neuen Sachen beschäftigt ?(
      - neue Sachen gelernt :thumbup:
      - bereits erlerntes und neu erlerntes in verschiedensten Varianten/ Zusammenhängen angewendet :wacko:

      Ich glaube das nennt man Entwicklung, und es hat mir nicht geschadet... denke ich ;)

      Da ich davon ausgehe das heutzutage eigentlich jeder ein Smartphone hat und OpenTrack kostenlos ist, genau wie die App im Store ist das einzige was man investieren muss ca. 10 Minuten Zeit.
      Und das beste:
      Man spart eine Menge Geld für Hardware (~150€ für Varianten am Markt) die faktisch nix "besser" machen wie die DIY-Variante (10€-15€) oder
      man benutzt seinen Kopf, verwendet das was man hat und Entwickelt was 'neues' draus.

      Projekt abgeschlossen
      MfG EldaRion
    • Ich habe das Projekt die ganze Zeit mit viel Spannung verfolgt und war über die Prototypen begeistert.
      Die Idee mit dem Handy finde ich ebenfalls super, aber nun bin ich leicht enttäuscht. :( Arduino und co finde ich viel Spannender. :D Vl hast du ja nochmal Lust das ganze weiter zu entwickeln?
      Ich könnte mit durchaus vorstellen das mal nachzubauen und vl sogar mitm 3D Drucker ein Gehäuse zu erschaffen.

      LG
      Cedric
    • Die Variante mit dem Handy ist für die gedacht die halt ein schnelles Ergebnis wollen. :)
      Für mich ist das aber auch nicht wirklich was. Ich löse auch lieber die Probleme selber oder setzte mich lieber damit mal auseinander. ^^

      Aus der Nutzung des eigenen Prototyps kamen wirklich immer neue Probleme und auch mein nächster Schritt wäre das Gehäuse aus dem 3D-Drucker gewesen.
      Nur leider habe ich keinen. Aber mein 'Beta-Tester' @Goettervater kennt da wohl jemanden.
      Wenn ich mal wieder nicht weiß was ich tun soll hab ich schon überlegt mal so ein 3D-Modell vorzubereiten.
      Braucht man ja eh, egal ob man es selber druckt oder drucken lässt.

      Hier mal ein paar Fotos meiner letzten Variante die ich nun nutze wenn ich ETS, Cattle and Crops oder LS mit Lenkrad zocke.





      Als Gehäuse dient mir hier eine kleine Plastikschachtel vom Flickzeug für das Fahrrad.
      Es bot sich an da es ein Klappdeckel hat, die Plastik relativ flexibel ist, sprich nicht so schnell bricht wie harte Plastik.
      Zudem lässt es sich wunderbar mit einem Dremel bearbeiten. Man nimmt halt was man da hat. :D

      Da ja bei der ersten Variante das Problem mit der nichtvorhanden Zugentlastung bestand, welches dazu führte das sich die Micro-USB-Buchse vom Arduino löste habe ich mir hier auch eine schnelle Lösung einfallen lassen.

      Das Kabel habe ich seitlich unten eingeführt und und wird zusätzlich von einem Kabelbinder auf der Rückseite gehalten. Zusätzlich kann man die Schlaufe im Gehäuse auch noch etwas vergrößern. So kann man gerne auch mal 10 cm Kabel aus dem Gehäuse reißen ohne das die Buchse am Arduino leidet.
      Im zuge dessen habe ich mich auch gleich für ein gesleevtes (Stoffummanteltes) USB-Kabel entschieden um abknicken bzw. Kabelbrüchen vorzubeugen.
      Perfekt ist es so nicht aber hält wenn man es normal benutzt.

      Weiterführend würde ich als nächstes eigentlich das USB-Kabel direkt an den Arduino löten um eine weiter Fehlerquelle auszuschließen.
      Denn jede Verbindung ist eine potenzielle Fehlerquelle.
      Das würde ich aber erst machen wenn ich ein eigenes Gehäuse habe wo ich das Kabel mittels Schraubzugentlastung am Gehäuse fixieren kann.
      Desweitern würde ich Schlitze vorsehen um zwei Klettbänder durch die Gehäuseunterseite zu führen um es so bequem und stabil auf dem Headset zu monieren.

      Und weil ich mal wieder zu voreilig war :/ würde ich das nächste Gehäuse liegend ausführen.
      So wie es jetzt ist steht es hochkannt auf dem Headset :thumbdown: ... Geht, ist aber nicht schön, da es so leicht kippeln kann.
      Passiert wenn man nicht bis zu ende denkt oder sich nicht mal die ein oder andere Pause gönnt

      Aber was genau verstehst du denn unter "weiterentwickeln". Was vermisst du denn?
      Ich liefer gerne Ideen ;)
      MfG EldaRion
      -Gadarol.de Werbung-
    • Nun ich meine genau solche Sachen. :D
      Neues Gehäuse, Kabel anlöten, verbessertes Kabel etc,
      Vl LEDs zum "debuggen" die den aktuellen Winkel anzeigen (ala 4rote1grün3rot) (hoffe das ist verständlich) oder auch nen Knopf um die Achsen zu "nullen". Dadurch wäre das Kalibrieren nach dem aufsetzen sicherlich bissl angenehmer.
      Oder aber vl auch nen Akku einbauen (zum Beispiel einen dieser RC Akkus) und nen Bluetooth Chip einbauen um das zusätzliche Kabel zu sparen etc.

      Sowas halt :D Stetige Entwicklung ist spannend und Unterhaltsam.

      LG
      Cedric

      PS: Und wenn das mit dem Bekannten mit dem Drucker net hinhaut, schreib mir. :) Um das Gehäuse zu designen empfehle ich übrigens Fusion 360 von Autodesk, als Privatperson spendieren die dir ne kostenlose Lizenz (1 Jahr gültig, kann jedes Jahr verlängert werden).
    • HeadsetMouse selbst gebastelt -DIY-

      Ein Knopf zum kalibrieren ist aber schon drauf ;) Die LED's auf dem Arduino selbs kann man ansteuern. Und ja... in meinem ersten Script werden die auch genutzt um den Zustand 'Maus de-/aktiviert' zu signalisieren. Aber wenn man das Ding auf dem Kopf hat sieht man die LED's eh nicht. Zumindest ich nicht da meine Augen nach vorne aus den Kopf schauen. :D Evtl. eine starke Flash-LED nach vorne, spiegelt dann sicher im Bild *lach*

      Aber ich weiß was du meinst. Ich habe hier noch 2 bzw. 4 zeilige LCD-Displays. Wenn man einfach ein paar frei Pin's vom Arduino auf eine Buchse aus dem Gehäuse führt, könnte man dann so bei bedarf das Display anschließen und so die Werte ohne PC anzeigen lassen. Aber bei dieser Art der Verwendung, so denke ich, ist es nicht komfortabel. Bei einem selbst ausbalancierten Roboter aber sicher sinvoll.

      Aber ich denke das reicht für heute. Ich wünsche eine gute Nacht.

      gesendet mit Tapatalk, vom Balkon oder unterwegs
      MfG EldaRion