Arduino Spider Robot (vierfach)

Komponenten und Verbrauchsmaterialien

Arduino Nano R3

Bluetooth Low Energy (BLE)-Modul (generisch)

OLED-Erweiterung der Onion Corporation

RGB diffundierte gemeinsame Kathode

Angepasste JLCPCB-Leiterplatte

Über dieses Projekt

Hallo Leute! Hier ist ein neues Tutorial, das Sie Schritt für Schritt führt, während Sie diese Art von super erstaunlichen elektronischen Projekten machen, den "Crawler-Roboter", der auch als "Spider-Roboter" oder "Vierbein-Roboter" bekannt ist.

Da jeder die rasante Entwicklung der Robotiktechnologie bemerkt hat, haben wir uns entschieden, euch auf ein höheres Niveau in Robotik und Roboterbau zu bringen. Wir haben vor einiger Zeit damit begonnen, einige grundlegende elektronische Projekte und grundlegende Roboter wie PICTO92, den Linienfolger-Roboter, zu entwickeln, um Sie mit den elektronischen Dingen vertraut zu machen und in der Lage zu sein, Ihre eigenen Projekte zu erfinden.

Auf einer anderen Ebene haben wir mit diesem Roboter begonnen, der ein grundlegendes Konzept darstellt, aber etwas kompliziert wird, wenn Sie tiefer in sein Programm einsteigen. Und da diese Gadgets im Webstore so teuer sind, bieten wir diese Schritt-für-Schritt-Anleitung um euch bei der Erstellung eures eigenen Spiderbots zu unterstützen .

Dieses Projekt ist besonders praktisch, nachdem Sie die kundenspezifische Leiterplatte erhalten haben, die wir bei JLCPCB bestellt haben, um das Erscheinungsbild unseres Roboters zu verbessern. Außerdem enthält dieses Handbuch genügend Dokumente und Codes, damit Sie Ihren Crawler einfach erstellen können.

Wir haben dieses Projekt in nur 7 Tagen durchgeführt, nur zwei Tage, um die Hardwareherstellung und den Zusammenbau abzuschließen, dann fünf Tage, um den Code und die Android-App vorzubereiten. um den Roboter dadurch zu steuern. Bevor wir beginnen, schauen wir zuerst

Was Sie lernen werden:

Auswahl der richtigen Komponenten in Abhängigkeit von Ihren Projektfunktionalitäten

Erstellen der Schaltung, um alle ausgewählten Komponenten zu verbinden

Bauen Sie alle Projektteile zusammen

Skalierung der Roboterwaage

Mit der Android-App. um sich über Bluetooth zu verbinden und das System zu manipulieren

Schritt 1:Was ist ein "Spider-Roboter"?

Wie der Name schon sagt, ist unser Roboter eine grundlegende Darstellung der Sippenbewegungen, aber er führt nicht genau die gleichen Körperbewegungen aus, da wir nur vier statt acht Beine verwenden.

Wird auch als Vierfüßler bezeichnet Da der Roboter vier Beine hat und seine Bewegungen mit diesen Beinen ausführt, wird die Bewegung jedes Beins mit den anderen Beinen in Beziehung gesetzt, um die Körperposition des Roboters zu identifizieren und auch das Gleichgewicht des Roboterkörpers zu kontrollieren.

Roboter mit Beinen kommen mit Gelände besser zurecht als ihre Gegenstücke mit Rädern und bewegen sich auf vielfältige und animalische Weise. Dies macht Roboter mit Beinen jedoch komplizierter und für viele Hersteller weniger zugänglich. und auch die Herstellungskosten und die hohen Kosten, die ein Hersteller aufwenden sollte, um einen Ganzkörper-Vierbeiner zu schaffen, da er auf Servomotoren oder Schrittmotoren basiert und beide teurer sind als Gleichstrommotoren, die in Radrobotern verwendet werden könnten.

Vorteile

Vierbeiner finden Sie in der Natur reichlich, denn vier Beine ermöglichen passive Stabilität oder die Möglichkeit, ohne aktive Positionsverstellung stehen zu bleiben. Das gleiche gilt für Roboter. Ein vierbeiniger Roboter ist billiger und einfacher als ein Roboter mit mehr Beinen, kann aber dennoch Stabilität erreichen.

Schritt 2:Servomotoren sind die Hauptaktuatoren

Ein Servomotor, wie in Wikipedia definiert, ist ein Drehantrieb oder Linearantrieb, der eine präzise Steuerung der Winkel- oder Linearposition, Geschwindigkeit und Beschleunigung ermöglicht.[1]Er besteht aus einem geeigneten Motor, der mit einem Sensor zur Positionsrückmeldung gekoppelt ist. Es erfordert auch eine relativ ausgeklügelte Steuerung, oft ein spezielles Modul, das speziell für die Verwendung mit Servomotoren entwickelt wurde.

Servomotoren sind keine spezielle Motorklasse, obwohl der Begriff Servomotor oft verwendet wird, um sich auf einen Motor zu beziehen, der für den Einsatz in einem geschlossenen Regelkreis geeignet ist.

Im Allgemeinen ist das Steuersignal eine Rechteckwellen-Impulsfolge. Übliche Frequenzen für Steuersignale sind 44 Hz, 50 Hz und 400 Hz. Die positive Impulsbreite bestimmt die Servoposition. Eine positive Impulsbreite von etwa 0,5 ms bewirkt, dass das Servohorn so weit wie möglich nach links ausgelenkt wird (im Allgemeinen etwa 45 bis 90 Grad je nach Servo). Eine positive Impulsbreite von ca. 2,5ms bis 3,0ms bewirkt, dass das Servo so weit wie möglich nach rechts auslenkt. Eine Impulsbreite von ca. 1,5 ms bewirkt, dass das Servo die Neutralstellung bei 0 Grad hält. Die Ausgangshochspannung liegt im Allgemeinen zwischen 2,5 Volt und 10 Volt (bei 3 V typisch). Die Ausgangsniederspannung reicht von -40 mV bis 0 V.

Schritt 3:Die PCB-Herstellung (hergestellt von JLCPCB)

Über JLCPCB

JLCPCB (Shenzhen JIALICHUANG Electronic Technology Development Co., Ltd.) ist das größte Unternehmen für PCB-Prototypen in China und ein Hightech-Hersteller, der sich auf schnelle PCB-Prototypen und PCB-Kleinserienproduktion spezialisiert hat.

Mit über 10 Jahren Erfahrung in der PCB-Herstellung hat JLCPCB mehr als 200.000 Kunden im In- und Ausland mit über 8.000 Online-Bestellungen für PCB-Prototyping und PCB-Produktion in kleinen Stückzahlen pro Tag. Die jährliche Produktionskapazität beträgt 200.000 qm. für verschiedene 1-Layer-, 2-Layer- oder Multi-Layer-Leiterplatten. JLC ist ein professioneller PCB-Hersteller, der sich durch groß angelegte Brunnenausrüstung, strenges Management und überragende Qualität auszeichnet.

Zurück zu unserem Projekt

Um die Leiterplatte herzustellen, habe ich die Preise vieler Leiterplattenhersteller verglichen und ich habe JLCPCB als den besten Leiterplattenlieferanten und den billigsten Leiterplattenanbieter ausgewählt, um diese Schaltung zu bestellen. Alles, was ich tun muss, sind ein paar einfache Klicks, um die Gerber-Datei hochzuladen und einige Parameter wie Farbe und Menge der Leiterplattendicke einzustellen. Dann habe ich nur 2 Dollar bezahlt, um meine Leiterplatte nach nur fünf Tagen zu erhalten.

Wie es das Bild des zugehörigen Schemas zeigt, habe ich einen Arduino Nano verwendet, um das gesamte System zu steuern, und ich habe die Roboterspinnenform entworfen, um dieses Projekt viel besser zu machen.

Hier können Sie die Circuit-Datei (PDF) herunterladen. Wie Sie in den obigen Bildern sehen können, ist die Platine sehr gut verarbeitet und ich habe die gleiche PCB-Spinnenform, die wir entworfen haben, und alle Etiketten und Logos sind da, um mich während der Lötschritte zu leiten.

Sie können hier auch die Gerber-Datei für diese Schaltung herunterladen, falls Sie eine Bestellung für das gleiche Schaltungsdesign aufgeben möchten.

Schritt 4:Zutaten

Lassen Sie uns nun die notwendigen Komponenten überprüfen, die wir für dieses Projekt benötigen. Wie ich bereits sagte, verwende ich einen Arduino Nano, um alle 12 Servomotoren der vier Beine des Roboters zu betreiben. Das Projekt umfasst auch ein OLED-Display zur Anzeige der Cozmo-Gesichter und ein Bluetooth-Modul zur Steuerung des Roboters über eine Android-App.

Um diese Art von Projekten zu erstellen, benötigen wir:

- Die Leiterplatte, die wir bei JLCPCB bestellt haben

- 12 Servomotoren wie Sie sich erinnern 3 Servos für jedes Bein:https://amzn.to/2B25XbG

- Ein Arduino Nano:https://amzn.to/2MmZsVg

- HC-06 Bluetooth-Modul:https://amzn.to/2B1Z3CY

- Ein OLED-Bildschirm:https://amzn.to/2OySnyn

- 5 mm RGB-LEDs:https://amzn.to/2B56hq3

- Einige Header-Verbindungen:https://amzn.to/2nyZg7i

- Und die Roboterkörperstücke, die Sie brauchen, um sie mit einem 3D-Drucker zu drucken

Schritt 5:Der Roboter zusammenbauen

Jetzt haben wir die Platine fertig und alle Komponenten sind sehr gut gelötet, danach müssen wir den Roboterkörper zusammenbauen, das Verfahren ist so einfach, also befolge einfach die Schritte, die ich zeige, wir müssen zuerst jedes Bein einer Seite vorbereiten und machen Eine LED benötigen wir zwei Servomotoren für die Gelenke und die gedruckten Teile von Coxa, Femur und Tibia mit diesem kleinen Befestigungsteil.

Über die Körperteile des Roboters können Sie seine STL-Dateien hier herunterladen.

Beginnen Sie mit dem ersten Servo, setzen Sie es in seine Buchse und halten Sie es mit seinen Schrauben fest, dann drehen Sie die Servos-Axt um 180°, ohne die Schraube für die Attaches zu platzieren und gehen Sie zum nächsten Teil, dem Femur, um es mit der Tibia zu verbinden mit der ersten Servogelenkaxt und dem Aufsatzstück. Der letzte Schritt, um das Bein zu vervollständigen, ist das Platzieren des zweiten Gelenks, ich meine das zweite Servo, um den dritten Teil des Beins zu halten, das das Coxa-Stück ist.

Wiederholen Sie nun dasselbe für alle Beine, um vier Beine fertig zu machen. Danach nehmen Sie das obere Chassis und stecken die restlichen Servos in die Buchsen und verbinden dann jedes Bein mit dem entsprechenden Servo. Es gibt nur ein letztes gedrucktes Teil, das das untere Roboterchassis ist, in dem wir unsere Platine platzieren

Schritt 6:Die Android-App

Wenn Sie über Android sprechen, können Sie

Verbinden Sie sich über Bluetooth mit Ihrem Roboter und machen Sie Vorwärts- und Rückwärtsbewegungen sowie Links-Rechts-Kurven. Außerdem können Sie die Lichtfarbe des Roboters in Echtzeit steuern, indem Sie die gewünschte Farbe aus diesem Farbrad auswählen.

Sie können die Android-App kostenlos über diesen Link herunterladen:hier

Schritt 7:Der Arduino-Code und die Testvalidierung

Jetzt haben wir den Roboter fast fahrbereit, aber wir müssen zuerst die Gelenkwinkel einstellen. Laden Sie also den Setup-Code hoch, mit dem Sie jedes Servo in die richtige Position bringen können, indem Sie die Servos in 90 Grad anbringen. Vergessen Sie nicht, die 7V anzuschließen Gleichstrombatterie, um den Roboter zu betreiben.

Als nächstes müssen wir das Hauptprogramm hochladen, um den Roboter mit der Android-App zu steuern. Beide Programme können Sie über die folgenden Links herunterladen:

- Skalierung des Servocodes:Download-Link - Spider-Roboter-Hauptprogramm:Download-Link

Nach dem Hochladen des Codes habe ich das OLED-Display angeschlossen, um das Cozmo-Roboterlächeln anzuzeigen, das ich im Hauptcode gemacht habe.

Wie Sie auf den Bildern oben sehen können, befolgt der Roboter alle Anweisungen, die von meinem Smartphone gesendet wurden, und muss noch einige andere Verbesserungen durchführen, um ihn viel besser zu machen.

Code

Spinnenroboter-Hauptcode

Spider Robot HauptcodeArduino

/************************************************ ************************************************* ************************************************* ********************* * - Autor :BELKHIR Mohamed * * - Beruf :(Elektroingenieur) MEGA DAS Inhaber * * - Hauptzweck :Industrielle Anwendung * * - Copyright (c) Inhaber :Alle Rechte vorbehalten * * - Lizenz :BSD 2-Clause-Lizenz * * - Datum :20.04.2017 * * ****************** ************************************************* ************************************************* ************************************************/ /*********************************** HINWEIS ************* ************************* /// Weiterverbreitung und Verwendung in Quell- und Binärform, mit oder ohne// Modifikation, sind unter der Voraussetzung gestattet, dass:Bedingungen sind erfüllt:// * Weiterverbreitungen des Quellcodes müssen den obigen Copyright-Hinweis, diese// Liste der Bedingungen und den folgenden Haftungsausschluss enthalten.// * Weiterverbreitungen in binärer Form müssen reproduziert werden Siehe den obigen Copyright-Hinweis,// diese Liste der Bedingungen und den folgenden Haftungsausschluss in der Dokumentation// und/oder anderen Materialien, die mit der Verteilung bereitgestellt werden.// DIESE SOFTWARE WIRD VON DEN URHEBERRECHTSINHABERN UND MITARBEITERN „WIE BESEHEN“ BEREITGESTELLT// UND ALLE AUSDRÜCKLICHEN ODER STILLSCHWEIGENDEN GARANTIEN, EINSCHLIESSLICH, ABER NICHT BESCHRÄNKT AUF DIE// STILLSCHWEIGENDE GARANTIEN DER MARKTGÄNGIGKEIT UND EIGNUNG FÜR EINEN BESTIMMTEN ZWECK WERDEN AUSGESCHLOSSEN/* */#include //zur Definition und Steuerung von Servos#include2 . //um einen Timer zu setzen um alle Servos zu verwalten#include #include #include // OLED Display TWI Adresse#define OLED_ADDR 0x3CAdafruit_SSD1306 Display(-1); /* Servos ------------------------------------------------------------ ---------------------* ///Definiere 12 Servos für 4 BeineServo Servo[4][3];//Definiere Servos' portsconst int servo_pin[4] [3] ={ {11, 12, 13}, {2, 4, 7}, {14, 15, 16}, {8, 9, 10} };/* Größe des Roboters ------ -------------------------------------------------- -*/const float l ength_a =50;const float length_b =77.1;const float length_c =27.5;const float length_side =71;const float z_absolute =-28;/* Konstanten für Bewegung ---------------- ------------------------------------*/const float z_default =-50, z_up =-30, z_boot =z_absolute;const float x_default =62, x_offset =0;const float y_start =0, y_step =40;const float y_default =x_default;/* Variablen für Bewegung --------------- -------------------------------------*/volatile float site_now[4][3]; //Echtzeitkoordinaten des Endes jedes legvolatile float site_expect[4][3]; // erwartete Koordinaten des Endes jedes Legfloat temp_speed[4][3]; // Die Geschwindigkeit jeder Achse muss vor jeder Bewegung neu berechnet werden float move_speed; // Bewegungsgeschwindigkeitfloat speed_multiple =1; // Bewegungsgeschwindigkeit multipleconst float spot_turn_speed =4;const float leg_move_speed =8;const float body_move_speed =3;const float stand_seat_speed =1;volatile int rest_counter; //+1/0.02s, für automatische Pause//Funktionsparameterconst float KEEP =255;//define PI für Berechnungconst float pi =3.1415926;/* Konstanten für Drehung ------------- -------------------------------------------------------* ///temp lengthconst float temp_a =sqrt(pow(2 * x_default + length_side, 2) + pow(y_step, 2));const float temp_b =2 * (y_start + y_step) + length_side;const float temp_c =sqrt(pow(2 * x_default + length_side , 2) + pow(2 * y_start + y_step + length_side, 2));const float temp_alpha =acos((pow(temp_a, 2) + pow(temp_b, 2) - pow(temp_c, 2)) / 2 / temp_a / temp_b); // Site für turnconst float turn_x1 =(temp_a - length_side) / 2;const float turn_y1 =y_start + y_step / 2;const float turn_x0 =turn_x1 - temp_b * cos(temp_alpha);const float turn_y0 =temp_b * sin (temp_alpha) - turn_y1 - length_side;const int lightR=3;const int lightG=5;const int lightB=6;int LedR=0;int LedG=0;int LedB=0;char SerialData; // Verwenden Sie diese Variable, um jedes Zeichen zu lesen, das über die serielle Schnittstelle empfangen wirdString data="";void setup () { Serial.begin (9600); display.begin (SSD1306_SWITCHCAPVCC, OLED_ADDR); display.clearDisplay(); display.display(); Verzögerung (10000); set_site(0, x_default - x_offset, y_start + y_step, z_boot); set_site(1, x_default - x_offset, y_start + y_step, z_boot); set_site(2, x_default + x_offset, y_start, z_boot); set_site(3, x_default + x_offset, y_start, z_boot); for (int i =0; i <4; i++) { for (int j =0; j <3; j++) { site_now[i][j] =site_expect[i][j]; } } // Servo-Dienst starten FlexiTimer2::set (20, servo_service); FlexiTimer2::start(); // Servos initialisieren servo_attach (); Stand(); // Verzögerung (3000); // Sit(); // Verzögerung (3000); // Stand(); // Verzögerung (3000); glücklich(); Verzögerung (zufällig (500, 1000)); cierra(); Verzögerung (150); enfado(); Verzögerung (zufällig (1000, 3000)); cierra(); Verzögerung (150); entorna(); Verzögerung (zufällig (1000, 3000)); cierra(); Verzögerung (150); enfado1(); Verzögerung (zufällig (1000, 3000)); cierra(); Verzögerung (150); triste(); Verzögerung (zufällig (1000, 3000)); cierra(); Verzögerung (150); abre(); Verzögerung (zufällig (500, 3000)); cierra(); Verzögerung (150); glücklich(); delay (random (500, 1000));}void loop () { while (Serial.available ()) // Solange serielle Daten verfügbar sind, speichern wir sie { delay (10); SerialData=Serial.read(); if(SerialData=='b') LedR=Serial.parseInt(); sonst if(SerialData=='g') LedG=Serial.parseInt(); sonst if(SerialData=='r') LedB=Serial.parseInt(); sonst Daten+=SerielleDaten; } if(data=="f") // Wenn die gespeicherten Daten eine Vorwärtsbewegung sind { cierra(); Verzögerung (150); glücklich(); step_forward(1); } if(data=="p") // Wenn die gespeicherten Daten eine Rückwärtsbewegung sind { cierra(); Verzögerung (150); triste(); step_back(1); } if(data=="l") // Wenn die gespeicherten Daten das Auto links abbiegen sollen { cierra(); Verzögerung (150); enfado1(); turn_left(1); } if(data=="m") // Wenn die gespeicherten Daten das Auto rechts abbiegen sollen { cierra(); Verzögerung (150); enfado(); turn_right(5); } Daten=""; analogWrite (lightR, LedR); analogWrite (lightG, LedG); analogWrite(lightB,LedB);}void servo_attach(void){ for (int i =0; i <4; i++) { for (int j =0; j <3; j++) { servo[i][j]. befestigen(servo_pin[i][j]); Verzögerung (100); }}}void servo_detach(void){ for (int i =0; i <4; i++) { for (int j =0; j <3; j++) {servo[i][j].detach(); Verzögerung (100); } }}void sit (void) {move_speed =stand_seat_speed; for (int leg =0; leg <4; leg++) { set_site(leg, KEEP, KEEP, z_boot); } wait_all_reach();}/* - stand - Sperrfunktion ------------------------------------------------- --------------------------------------*/void stand(void){ move_speed =stand_seat_speed; for (int leg =0; leg <4; leg++) { set_site(leg, KEEP, KEEP, z_default); } wait_all_reach();}/* - Spot links abbiegen - Blockierfunktion - Parameterschritt Schritte wollte abbiegen -------------------------- ------------------------------------------------*/ void turn_left (unsigned int step) {move_speed =spot_turn_speed; while (step--> 0) { if (site_now[3][1] ==y_start) {//leg 3&1 move set_site(3, x_default + x_offset, y_start, z_up); wait_all_reach(); set_site(0, turn_x1 - x_offset, turn_y1, z_default); set_site(1, turn_x0 - x_offset, turn_y0, z_default); set_site(2, turn_x1 + x_offset, turn_y1, z_default); set_site(3, turn_x0 + x_offset, turn_y0, z_up); wait_all_reach(); set_site(3, turn_x0 + x_offset, turn_y0, z_default); wait_all_reach(); set_site(0, turn_x1 + x_offset, turn_y1, z_default); set_site(1, turn_x0 + x_offset, turn_y0, z_default); set_site(2, turn_x1 - x_offset, turn_y1, z_default); set_site(3, turn_x0 - x_offset, turn_y0, z_default); wait_all_reach(); set_site(1, turn_x0 + x_offset, turn_y0, z_up); wait_all_reach(); set_site(0, x_default + x_offset, y_start, z_default); set_site(1, x_default + x_offset, y_start, z_up); set_site(2, x_default - x_offset, y_start + y_step, z_default); set_site(3, x_default - x_offset, y_start + y_step, z_default); wait_all_reach(); set_site(1, x_default + x_offset, y_start, z_default); wait_all_reach(); aufrechtzuerhalten. } else {//leg 0&2 set_site(0, x_default + x_offset, y_start, z_up); wait_all_reach(); set_site(0, turn_x0 + x_offset, turn_y0, z_up); set_site(1, turn_x1 + x_offset, turn_y1, z_default); set_site(2, turn_x0 - x_offset, turn_y0, z_default); set_site(3, turn_x1 - x_offset, turn_y1, z_default); wait_all_reach(); set_site(0, turn_x0 + x_offset, turn_y0, z_default); wait_all_reach(); set_site(0, turn_x0 - x_offset, turn_y0, z_default); set_site(1, turn_x1 - x_offset, turn_y1, z_default); set_site(2, turn_x0 + x_offset, turn_y0, z_default); set_site(3, turn_x1 + x_offset, turn_y1, z_default); wait_all_reach(); set_site(2, turn_x0 + x_offset, turn_y0, z_up); wait_all_reach(); set_site(0, x_default - x_offset, y_start + y_step, z_default); set_site(1, x_default - x_offset, y_start + y_step, z_default); set_site(2, x_default + x_offset, y_start, z_up); set_site(3, x_default + x_offset, y_start, z_default); wait_all_reach(); set_site(2, x_default + x_offset, y_start, z_default); wait_all_reach(); } }}/* - Spot rechts abbiegen - Sperrfunktion - Parameterschritt Schritte wollte abbiegen ------------------------------------------ ---------------------------------------------------------*/void turn_right( unsigned int step) {move_speed =spot_turn_speed; while (step--> 0) { if (site_now[2][1] ==y_start) {//leg 2&0 move set_site(2, x_default + x_offset, y_start, z_up); wait_all_reach(); set_site(0, turn_x0 - x_offset, turn_y0, z_default); set_site(1, turn_x1 - x_offset, turn_y1, z_default); set_site(2, turn_x0 + x_offset, turn_y0, z_up); set_site(3, turn_x1 + x_offset, turn_y1, z_default); wait_all_reach(); set_site(2, turn_x0 + x_offset, turn_y0, z_default); wait_all_reach(); set_site(0, turn_x0 + x_offset, turn_y0, z_default); set_site(1, turn_x1 + x_offset, turn_y1, z_default); set_site(2, turn_x0 - x_offset, turn_y0, z_default); set_site(3, turn_x1 - x_offset, turn_y1, z_default); wait_all_reach(); set_site(0, turn_x0 + x_offset, turn_y0, z_up); wait_all_reach(); set_site(0, x_default + x_offset, y_start, z_up); set_site(1, x_default + x_offset, y_start, z_default); set_site(2, x_default - x_offset, y_start + y_step, z_default); set_site(3, x_default - x_offset, y_start + y_step, z_default); wait_all_reach(); set_site(0, x_default + x_offset, y_start, z_default); wait_all_reach(); aufrechtzuerhalten. aufrechtzuerhalten. Else { // Leg 1 &3 verschieben set_site (1, x_default + x_offset, y_start, z_up); wait_all_reach(); set_site(0, turn_x1 + x_offset, turn_y1, z_default); set_site(1, turn_x0 + x_offset, turn_y0, z_up); set_site(2, turn_x1 - x_offset, turn_y1, z_default); set_site(3, turn_x0 - x_offset, turn_y0, z_default); wait_all_reach(); set_site(1, turn_x0 + x_offset, turn_y0, z_default); wait_all_reach(); set_site(0, turn_x1 - x_offset, turn_y1, z_default); set_site(1, turn_x0 - x_offset, turn_y0, z_default); set_site(2, turn_x1 + x_offset, turn_y1, z_default); set_site(3, turn_x0 + x_offset, turn_y0, z_default); wait_all_reach(); set_site(3, turn_x0 + x_offset, turn_y0, z_up); wait_all_reach(); set_site(0, x_default - x_offset, y_start + y_step, z_default); set_site(1, x_default - x_offset, y_start + y_step, z_default); set_site(2, x_default + x_offset, y_start, z_default); set_site(3, x_default + x_offset, y_start, z_up); wait_all_reach(); set_site(3, x_default + x_offset, y_start, z_default); wait_all_reach(); } }}/* - vorwärts gehen - Funktion blockieren - Parameterschritt Schritte wollten gehen -------------------------------- -------------------------------------------------------*/void step_forward(unsigned int Schritt) {move_speed =leg_move_speed; while (step--> 0) { if (site_now[2][1] ==y_start) {//leg 2&1 move set_site(2, x_default + x_offset, y_start, z_up); wait_all_reach(); set_site(2, x_default + x_offset, y_start + 2 * y_step, z_up); wait_all_reach(); set_site(2, x_default + x_offset, y_start + 2 * y_step, z_default); wait_all_reach(); move_speed =body_move_speed; set_site(0, x_default + x_offset, y_start, z_default); set_site(1, x_default + x_offset, y_start + 2 * y_step, z_default); set_site(2, x_default - x_offset, y_start + y_step, z_default); set_site(3, x_default - x_offset, y_start + y_step, z_default); wait_all_reach(); Bewegungsgeschwindigkeit =Beinbewegungsgeschwindigkeit; set_site(1, x_default + x_offset, y_start + 2 * y_step, z_up); wait_all_reach(); set_site(1, x_default + x_offset, y_start, z_up); wait_all_reach(); set_site(1, x_default + x_offset, y_start, z_default); wait_all_reach(); aufrechtzuerhalten. Else {//leg 0&3 set_site(0, x_default + x_offset, y_start, z_up); wait_all_reach(); set_site(0, x_default + x_offset, y_start + 2 * y_step, z_up); wait_all_reach(); set_site(0, x_default + x_offset, y_start + 2 * y_step, z_default); wait_all_reach(); move_speed =body_move_speed; set_site(0, x_default - x_offset, y_start + y_step, z_default); set_site(1, x_default - x_offset, y_start + y_step, z_default); set_site(2, x_default + x_offset, y_start, z_default); set_site(3, x_default + x_offset, y_start + 2 * y_step, z_default); wait_all_reach(); Bewegungsgeschwindigkeit =Beinbewegungsgeschwindigkeit; set_site(3, x_default + x_offset, y_start + 2 * y_step, z_up); wait_all_reach(); set_site(3, x_default + x_offset, y_start, z_up); wait_all_reach(); set_site(3, x_default + x_offset, y_start, z_default); wait_all_reach(); } }}/* - zurück - Sperrfunktion - Parameterschritt Schritte wollte gehen -------------------------------- -------------------------------------------------------*/void step_back(unsigned int Schritt) {move_speed =leg_move_speed; while (step--> 0) { if (site_now[3][1] ==y_start) {//leg 3&0 move set_site(3, x_default + x_offset, y_start, z_up); wait_all_reach(); set_site(3, x_default + x_offset, y_start + 2 * y_step, z_up); wait_all_reach(); set_site(3, x_default + x_offset, y_start + 2 * y_step, z_default); wait_all_reach(); move_speed =body_move_speed; set_site(0, x_default + x_offset, y_start + 2 * y_step, z_default); set_site(1, x_default + x_offset, y_start, z_default); set_site(2, x_default - x_offset, y_start + y_step, z_default); set_site(3, x_default - x_offset, y_start + y_step, z_default); wait_all_reach(); Bewegungsgeschwindigkeit =Beinbewegungsgeschwindigkeit; set_site(0, x_default + x_offset, y_start + 2 * y_step, z_up); wait_all_reach(); set_site(0, x_default + x_offset, y_start, z_up); wait_all_reach(); set_site(0, x_default + x_offset, y_start, z_default); wait_all_reach(); aufrechtzuerhalten. aufrechtzuerhalten. Else { // Leg 1 &2 verschieben set_site (1, x_default + x_offset, y_start, z_up); wait_all_reach(); set_site(1, x_default + x_offset, y_start + 2 * y_step, z_up); wait_all_reach(); set_site(1, x_default + x_offset, y_start + 2 * y_step, z_default); wait_all_reach(); move_speed =body_move_speed; set_site(0, x_default - x_offset, y_start + y_step, z_default); set_site(1, x_default - x_offset, y_start + y_step, z_default); set_site(2, x_default + x_offset, y_start + 2 * y_step, z_default); set_site(3, x_default + x_offset, y_start, z_default); wait_all_reach(); Bewegungsgeschwindigkeit =Beinbewegungsgeschwindigkeit; set_site(2, x_default + x_offset, y_start + 2 * y_step, z_up); wait_all_reach(); set_site(2, x_default + x_offset, y_start, z_up); wait_all_reach(); set_site(2, x_default + x_offset, y_start, z_default); wait_all_reach(); } }} // von RegisHsuvoid hinzufügen body_left (int i) { set_site (0, site_now [0][0] + i, KEEP, KEEP); set_site(1, site_now[1][0] + i, BEHALTEN, BEHALTEN); set_site(2, site_now[2][0] – i, BEHALTEN, BEHALTEN); set_site(3, site_now[3][0] – i, BEHALTEN, BEHALTEN); wait_all_reach();}void body_right(int i){ set_site(0, site_now[0][0] - i, KEEP, KEEP); set_site(1, site_now[1][0] – i, BEHALTEN, BEHALTEN); set_site(2, site_now[2][0] + i, BEHALTEN, BEHALTEN); set_site(3, site_now[3][0] + i, BEHALTEN, BEHALTEN); wait_all_reach();}void hand_wave(int i){ float x_tmp; float y_tmp; float z_tmp; Bewegungsgeschwindigkeit =1; if (site_now[3] [1] ==y_start) { body_right (15); x_tmp =site_now[2][0]; y_tmp =site_now[2][1]; z_tmp =site_now[2][2]; move_speed =body_move_speed; for (int j =0; j i / 4)// move_speed =body_dance_speed * 2;// if (j> i / 2)// move_speed =body_dance_speed * 3;/ / set_site(0, KEEP, y_default – 20, KEEP);// set_site(1, KEEP, y_default + 20, KEEP);// set_site(2, KEEP, y_default – 20, KEEP);// set_site(3, KEEP, y_default + 20, KEEP); // wait_all_reach(); // set_site(0, KEEP, y_default + 2 0, KEEP); // set_site (1, KEEP, y_default - 20, KEEP); // set_site (2, KEEP, y_default + 20, KEEP); // set_site (3, KEEP, y_default - 20, KEEP); // wait_all_reach();// }// move_speed =body_dance_speed;// head_down(30);//}/* - Microservos-Dienst /Timer-Interrupt-Funktion/50Hz - Wenn die Site erwartet wird, verschiebt diese Funktion den Endpunkt dorthin in einer geraden Linie - temp_speed[4][3] sollte eingestellt werden, bevor der erwartete Standort festgelegt wird. Stellen Sie sicher, dass sich der Endpunkt in einer geraden Linie bewegt, und bestimmen Sie die Bewegungsgeschwindigkeit. -------------------------------------------------- --------------------------*/void servo_service (void) { sei(); statische Gleitkommazahl Alpha, Beta, Gamma; for (int i =0; i <4; i++) { for (int j =0; j <3; j++) { if (abs(site_now[i][j] - site_expect[i][j])>=abs(temp_speed[i][j])) site_now[i][j] +=temp_speed[i][j]; else site_now[i][j] =site_expect[i][j]; } cartesian_to_polar(alpha, beta, gamma, site_now[i][0], site_now[i][1], site_now[i][2]); polar_to_servo(i, Alpha, Beta, Gamma); } rest_counter++;}/* - setze einen der Endpunkte der erwarteten Site - diese Funktion setzt gleichzeitig temp_speed[4][3] - nicht blockierende Funktion -------------- -------------------------------------------------- ----------*/void set_site(int leg, float x, float y, float z) { float length_x =0, length_y =0, length_z =0; if (x !=KEEP) length_x =x - site_now[leg][0]; if (y !=KEEP) length_y =y - site_now[leg][1]; if (z !=KEEP) length_z =z - site_now[leg][2]; Float-Länge =sqrt(pow(Länge_x, 2) + pow(Länge_y, 2) + pow(Länge_z, 2)); temp_speed[leg][0] =length_x / length * move_speed * speed_multiple; temp_speed[leg][1] =length_y / length * move_speed * speed_multiple; temp_speed[leg][2] =length_z / length * move_speed * speed_multiple; if (x !=KEEP) site_expect[leg][0] =x; if (y !=KEEP) site_expect[leg][1] =y; if (z !=KEEP) site_expect[leg][2] =z;}/* - warten, dass sich einer der Endpunkte zum erwarteten Standort bewegt - Blockierfunktion ----------------- -------------------------------------------------- --------*/void wait_reach(int leg){ while (1) if (site_now[leg][0] ==site_expect[leg][0]) if (site_now[leg][1] ==site_expect[leg][1]) if (site_now[leg][2] ==site_expect[leg][2]) break;}/* - warte, dass sich alle Endpunkte bewegen, um die Site zu erwarten - Blockierfunktion ---- -------------------------------------------------- ---------------------*/void wait_all_reach(void){ for (int i =0; i <4; i++) wait_reach(i);}/* - Transsite von Kartesisch zu Polar - Mathematisches Modell 2/2 ------------------------------------------------- --------------------------------------*/void cartesian_to_polar(volatile float &alpha, volatile float &beta , volatile float &gamma, volatile float x, volatile float y, volatile float z) {// berechnen wz Grad float v, w; w =(x>=0 ? 1 :-1) * (sqrt(pow(x, 2) + pow(y, 2))); v =w - Länge_c; alpha =atan2(z, v) + acos((pow(Länge_a, 2) - pow(Länge_b, 2) + pow(v, 2) + pow(z, 2)) / 2 / Länge_a / sqrt(pow(v , 2) + pow(z, 2))); beta =acos((pow(length_a, 2) + pow(length_b, 2) - pow(v, 2) - pow(z, 2)) / 2 / length_a / length_b); // x-y-z-Grad-Gamma berechnen =(w>=0) ? atan2(y, x):atan2(-y, -x); // trans Grad pi -> 180 alpha =alpha / pi * 180; Beta =Beta / Pi * 180; gamma =gamma / pi * 180;}/* - Trans-Site von Polar zu Mikroservos - Mathematische Modellkarte zu Tatsache - die im eeprom gespeicherten Fehler werden hinzugefügt ----------------- -------------------------------------------------- --------*/void polar_to_servo (int leg, float alpha, float beta, float gamma) { if (leg ==0) { alpha =90 - alpha; Beta =Beta; Gamma +=90; aufrechtzuerhalten. Sonst wenn (Bein ==1) {Alpha +=90; Beta =180 - Beta; Gamma =90 - Gamma; aufrechtzuerhalten. Sonst wenn (Bein ==2) {Alpha +=90; Beta =180 - Beta; Gamma =90 - Gamma; aufrechtzuerhalten. Sonst wenn (Bein ==3) {Alpha =90 - Alpha; Beta =Beta; Gamma +=90; } servo[Bein][0].write(alpha); servo[Bein][1].write(beta); servo[leg][2].write(gamma);}void abre() {display.clearDisplay(); display.fillCircle (50, 15, 12, WEISS); //ojo izquierdo grande display.fillCircle (82, 20, 7, WEISS); //ojo derecho pequeo display.display();}void cierra() { display.clearDisplay(); display.drawFastHLine(40, 15, 20, WEISS); display.drawFastHLine(72, 20, 15, WEISS); display.display();}void entorna() { display.clearDisplay(); display.fillCircle (42, 10, 20, WEISS); //ojo izquierdo grande display.fillCircle (82, 10, 15, WEISS); //ojo derecho pequeo display.fillRect (0, 0, 128, 15, BLACK); //ceja superior display.fillRect (0, 40, 128, 15, BLACK); //ceja minderwertig display.display();}void triste() { display.clearDisplay(); display.fillCircle (42, 10, 17, WEISS); //ojo izquierdo grande display.fillCircle (82, 10, 17, WEISS); //ojo derecho pequeo display.fillTriangle (0, 0, 0, 35, 78, 0, SCHWARZ); //ceja superior display.fillTriangle (50, 0, 128, 35, 128, 0, BLACK); //ceja superior display.display();}void happy() { display.clearDisplay(); display.fillCircle (42, 25, 15, WEISS); //ojo izquierdo grande display.fillCircle (82, 25, 15, WEISS); //ojo derecho pequeo display.fillCircle (42, 33, 20, BLACK); //ojo izquierdo grande display.fillCircle (82, 33, 20, BLACK); //ojo derecho pequeo display.display();}void enfado() { display.clearDisplay(); display.fillCircle (42, 10, 18, WEISS); //ojo izquierdo grande display.fillCircle (82, 10, 12, WEISS); //ojo derecho pequeo display.fillTriangle (0, 0, 54, 26, 118, 0, BLACK); //ceja superior display.display();}void enfado1() { display.clearDisplay(); display.fillCircle (42, 10, 18, WEISS); //ojo izquierdo grande display.fillCircle (82, 10, 12, WEISS); //ojo derecho pequeo display.fillTriangle (0, 0, 65, 15, 120, 0, SCHWARZ); //ceja überlegen display.display();}

Kundenspezifische Teile und Gehäuse

Schaltpläne

Gesichtsmasken-Desinfektionsgerät — Needlab Arduino, Überwachung der Türöffnung über Gmail

Herstellungsprozess

3d Drucken

Automatisierungssteuerung System

Industrietechnik