Autonomer Nerf-Wachturm

Notwendige Werkzeuge und Maschinen

	3D-Drucker (generisch)
	Lötkolben (generisch)
	CNC-Router

Apps und Onlinedienste

	Arduino-IDE
	Autodesk Fusion 360

Über dieses Projekt

Idee

Vor ein paar Jahren sah ich ein Projekt, das einen halbautonomen Turm zeigte, der nach dem Zielen selbstständig feuern konnte. Das brachte mich auf die Idee, eine Pixy 2-Kamera zu verwenden, um Ziele zu erfassen und dann automatisch mit der Nerf-Pistole zu zielen, die dann von selbst angreifen und feuern konnte.

Die Komponenten

Für dieses Projekt würde die Waffe Augen benötigen, daher habe ich mich für den Pixy 2 entschieden, da er sich leicht mit dem Mainboard verbinden lässt. Dann brauchte ich einen Mikrocontroller, also habe ich mich aufgrund der vielen Pins für einen Arduino Mega 2560 entschieden.

Da die Pistole zwei Achsen benötigt, Gieren und Nicken, benötigt sie zwei Schrittmotoren. Aus diesem Grund schickte mir DFRobot ihre duale DRV8825-Motortreiberplatine.

CAD

Ich begann damit, Fusion 360 zu laden und eine angebrachte Leinwand der Nerf-Pistole einzufügen. Dann habe ich aus dieser Leinwand einen festen Körper erstellt. Nachdem die Waffe entworfen wurde, habe ich eine Plattform mit einigen lagerbasierten Stützen hergestellt, die es der Waffe ermöglichen würden, sich von links nach rechts zu drehen. Ich habe einen Schrittmotor neben der rotierenden Plattform platziert, um sie anzutreiben.

Aber die größere Frage ist, wie man die Waffe nach oben und unten neigt. Dafür wurde ein Linearantriebssystem mit einem am beweglichen Block befestigten Punkt und einem weiteren Punkt an der Rückseite der Waffe benötigt. Eine Stange würde die beiden Punkte verbinden und es der Waffe ermöglichen, sich entlang ihrer Mittelachse zu drehen.

Herstellung der Teile

Fast alle Teile in meinem Design sollen in 3D gedruckt werden, also habe ich meine beiden Drucker verwendet, um sie zu erstellen. Dann habe ich die bewegliche Plattform erstellt, indem ich zuerst Fusion 360 verwendet habe, um die erforderlichen Werkzeugwege für meinen CNC-Router zu generieren, dann schneide ich die Scheibe aus einer Sperrholzplatte aus.

Montage

Nachdem alle Teile erstellt waren, ging es an den Zusammenbau. Ich begann damit, die Lagerstützen mit der rotierenden Scheibe zu verbinden. Dann habe ich die Linear-Pitch-Baugruppe zusammengebaut, indem ich die 6-mm-Aluminiumstangen und die Gewindestange durch die Stücke führe.

Zuletzt habe ich die Nerf Gun selbst mit einer Stahlstange und zwei Pfosten aus Aluminiumprofilen befestigt.

Programmierung

Nun zum schwierigsten Teil des Projekts:der Programmierung. Eine Maschine zum Abfeuern von Geschossen ist sehr komplex und die Mathematik dahinter kann verwirrend sein. Ich begann damit, den Programmablauf und die Logik Schritt für Schritt aufzuschreiben und detailliert zu beschreiben, was bei jedem Maschinenzustand passieren würde. Die verschiedenen Zustände sind wie folgt:

• Ziel erfassen
• Positioniere die Waffe
• Spulen Sie die Motoren auf
• Feuer die Waffe ab
• Fahren Sie die Motoren herunter

Um das Ziel zu erfassen, muss zuerst der Pixy eingerichtet werden, um neonpinke Objekte als Ziele zu verfolgen. Dann bewegt sich die Waffe, bis das Ziel im Sichtfeld des Pixys zentriert ist, wo dann der Abstand vom Waffenrohr zum Ziel gemessen wird. Unter Verwendung dieser Distanz können die horizontalen und vertikalen Distanzen mithilfe einiger grundlegender trigonometrischer Funktionen ermittelt werden. Mein Code hat eine Funktion namens get_angle(), die diese beiden Distanzen verwendet, um zu berechnen, wie viel Winkel benötigt wird, um dieses Ziel zu treffen.

Die Pistole bewegt sich dann in diese Position und schaltet die Motoren über einen MOSFET ein. Nachdem es fünf Sekunden lang aufgespult ist, bewegt es den Servomotor, um den Abzug zu betätigen. Der MOSFET schaltet dann den Motor aus und die Nerf-Pistole sucht wieder nach Zielen.

Spaß haben

Ich habe eine neonpinke Karteikarte an die Wand gehängt, um die Genauigkeit der Waffe zu testen. Es hat gut funktioniert, da mein Programm den Winkel für die gemessene Entfernung kalibriert und anpasst. Hier ist ein Video, das die Funktionsweise der Waffe demonstriert:

Code

• Schema

SchemaC/C++

#include #include #include "BasicStepperDriver.h"#include #include //X ist Tonhöhe, Y ist yawconst int pins[] ={6,7,8,5,4,12}; //MX STEP, DIR, EN, MY STEP, DIR, ENconst int limit_switch =26, laser_pin =11, spool_pin =10, servo_pin =13, Distance_trig =29, Distance_echo =30;double Velocity =21.336;double Velocity_squared =455.225; float current_angle =0.0;float hyp_distance; // Entfernung von der Waffe zum Ziel in Metern#define X_MID 164#define Y_MID 150#define DEADZONE 15#define G 9,8#define STP_PER_DEG_YAW 3.333#define STP_PER_DEG_PITCH 184859#define MICROSTEPS 32#define RPM 120#define MOSTETOR_define_10_200PS /17.7777 Schritte / GradBasicStepperDriver pitch_stepper(MOTOR_STEPS_X, pins[1], pins[0]);BasicStepperDriver yaw_stepper(MOTOR_STEPS_X, pins[4], pins[3]);Servotrigger;Pixy2I2C pixy;enum States { ACQUIRE, POSITION, SPOOL , FIRE, WIND_DOWN, RETURN};States state =ACQUIRE;void setup () { Serial.begin (115200); init_pins(); Verzögerung (1000); //home_pitch(); pixy.init(); Serial.println ( "Bereit ...");}void loop () { switch (state) { case ACQUIRE:Acquire_target (); Zustand =POSITION; digitalWrite (laser_pin, HOCH); brechen; case POSITION:Serial.println("Positionierung"); position_gun(); Zustand =SPOOL; brechen; case SPOOL:Serial.println("spooling"); digitalWrite(spool_pin,HIGH); Verzögerung (5000); Zustand =FEUER; brechen; Fall FEUER:fire_gun(); Zustand =WIND_DOWN; brechen; case WIND_DOWN:Serial.println ("Abwickeln"); digitalWrite(spool_pin,LOW); Verzögerung (2000); Zustand =ZURÜCK; digitalWrite (laser_pin, LOW); Zustand =ERWERBEN; brechen; }}void fire_gun () {Serial.println ( "Feuerpistole!"); trigger.write(108); Verzögerung (400); trigger.write(90); delay(2000);}void position_gun(){ float x, y; hyp_distance =ping(); hyp_distanz /=100; while(!hyp_distance){hyp_distance =ping(); hyp_distanz /=100; } Serial.println (hyp_distance); x =cos(aktueller_winkel) * hyp_distanz; y =sin(aktueller_winkel) * hyp_distanz; float target_angle =get_angle(x,y); Zielwinkel /=100; Serial.println (target_angle); move_pitch(target_angle - current_angle); current_angle =target_angle;}void Acquisition_target(){ int x=0, y=0; lange steps_taken=0; bool lock =false; while(!lock){pixy.ccc.getBlocks(); if(pixy.ccc.numBlocks){ x =pixy.ccc.blocks[0].m_x; y =pixy.ccc.blocks[0].m_y; Serial.print ("Ziel an Position X gesehen:"); Serial.print (x); Serial.print (", Y:"); Serial.println (y); if(x <=(X_MID - DEADZONE)){//Wenn zu weit links, Pistole nach links bewegen move_yaw(1); aufrechtzuerhalten. Sonst if(x>=(X_MID + DEADZONE)){move_yaw(-1); aufrechtzuerhalten. Sonst if (y <=(Y_MID - DEADZONE)) {//zu weit nach oben, Waffe nach oben bewegen pitch_stepper.move (33152); Schritte_genommen +=33152; aufrechtzuerhalten. Sonst if (y> =(Y_MID + DEADZONE)) { Pitch_stepper.move (33152); Schritte_genommen +=33152; aufrechtzuerhalten. Sonst{ Sperre =wahr; Serial.print ( "Target locked at location X:"); Serial.print (x); Serial.print (", Y:"); Serial.println (y); Serial.print ( "Ausgeführte Schritte:"); Serial.println (steps_taken); } } } current_angle =steps_taken / STP_PER_DEG_PITCH; Serial.print ( "Aktueller Winkel:"); Serial.println (current_angle);}void init_pins () { pinMode (pins [2], OUTPUT); PinMode (Pins [5], AUSGANG); pinMode (limit_switch, INPUT_PULLUP); pinMode (laser_pin, AUSGANG); pinMode (spool_pin, AUSGANG); pinMode (distanz_echo, INPUT); pinMode (Abstand_trig, AUSGANG); digitalWrite (Stifte [2], LOW); digitalWrite (Stifte [5], LOW); digitalWrite (laser_pin, LOW); digitalWrite(spool_pin,LOW); trigger.attach (servo_pin); pitch_stepper.begin (RPM, MIKROSTEPS); yaw_stepper.begin(5, MIKROSTEPS); trigger.write(90);}void move_yaw(float Grad){ yaw_stepper.move(degrees*STP_PER_DEG_YAW*32);}void move_pitch(float Grad){ current_angle +=Grad; pitch_stepper.move(degrees*STP_PER_DEG_PITCH);}float get_angle(float distance, float height){ float i =2 * height * 455.225; Schwimmer j =G * Distanz * Distanz; i + =j; j =9,8 * i; i =sqrt(pow(velocity_squared,2) - j); return atan ((velocity_squared-i) / (G * Distance)) * (180 / PI);} float ping () { Serial.println ( "Abstand erhalten ..."); lange Dauer; digitalWrite (distanz_trig, LOW); VerzögerungMikrosekunden(5); digitalWrite (distanz_trig, HIGH); VerzögerungMikrosekunden(10); digitalWrite (distanz_trig, LOW); Dauer =pulseIn(distanz_echo, HIGH); Rückkehrdauer / 2 / 29,1; // Entfernung in Metern}void home_pitch () {Serial.println (digitalRead (limit_switch)); if (! digitalRead (limit_switch)) {// Wenn der Schalter aktiv ist pitch_stepper.rotate (720); aufrechtzuerhalten. Während (digitalRead (limit_switch)) {//Serial.println (digitalRead (limit_switch)); pitch_stepper.move(-32); } pitch_stepper.rotate(2880*2);}

Kundenspezifische Teile und Gehäuse

Thingiverse-Repository

Schaltpläne