Proste i inteligentne ramię robota używające Arduino !!!: 5 kroków (ze zdjęciami)

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:31

W tym instruktażu zrobię proste ramię robota. Będzie to kontrolowane za pomocą ramienia głównego. Ramię zapamiętuje ruchy i gra po kolei. Koncepcja nie jest nowa. Pomysł wzięłam z "mini robota ramienia - by Stoerpeak" Chciałem to zrobić od dawna, ale wtedy byłem totalnym noobem i nie miałem wiedzy na temat programowania. Teraz wreszcie buduję jeden, zachowując prostotę, tanio i dzielę się nim z wami wszystkimi.

Więc zacznijmy….

Krok 1: Rzeczy, których będziesz potrzebować:-

Oto lista rzeczy, których będziesz potrzebować:-

1. Serwosilniki x 5 Link dla USA:- https://amzn.to/2OxbSH7Link dla Europy:-

2. Potencjometry x 5 (użyłem 100k.)Link dla USA:- https://amzn.to/2ROjhDMLink dla Europy:-

3. Arduino UNO. (Możesz też użyć Arduino Nano) Link dla USA: - https://amzn.to/2DBbENWLink dla Europy: -

4. Deska do krojenia chleba. (Proponuję ten zestaw)Link dla USA:- https://amzn.to/2Dy86w4Link dla Europy:-

5. Bateria. (opcjonalnie, używam adaptera 5v)

6. Tektura / drewno / deska do opalania / akryl, cokolwiek jest dostępne lub łatwe do znalezienia.

Będziesz także potrzebował zainstalowanego Arduino IDE.

Krok 2: Wykonanie ramienia:-

Tutaj użyłem patyczków Popsicle do wykonania ramienia. Możesz użyć dowolnego materiału, który jest dla ciebie dostępny. Możesz wypróbować różne konstrukcje mechaniczne, aby uzyskać jeszcze lepsze ramię. mój projekt nie jest zbyt stabilny.

Właśnie użyłem dwustronnej taśmy, aby przykleić serwa do kija Popsicle i przymocować je za pomocą śrub.

Do ramienia Master przykleiłem potencjometry do patyczków do lodów i wykonałem ramię.

Nawiązanie do zdjęć da Ci lepszy pomysł.

Wszystko zamontowałem na płóciennej planszy formatu A4 używanej jako podstawa.

Krok 3: Nawiązywanie połączeń:-

W tym kroku wykonamy wszystkie niezbędne połączenia, patrz zdjęcia powyżej.

• Najpierw podłącz wszystkie serwa równolegle do zasilania (czerwony przewód do +ve i czarny lub brązowy przewód do Gnd)
• Następnie podłącz przewody sygnałowe tj. żółty lub pomarańczowy przewód do pinu PWM arduino.
• Teraz podłącz potencjometry równolegle do +5v i Gnd arduino.
• Podłącz środkowy zacisk do pinu analogowego ardunio.

Tutaj cyfrowe piny 3, 5, 6, 9 i 10 służą do sterowania serwami

Piny analogowe A0 do A4 są używane do wejścia z potencjometrów.

Serwo podłączone do pinu 3 będzie sterowane potencjometrem podłączonym do A0

Serwo podłączone do pinu 5 będzie sterowane potencjometrem na A1 i tak dalej….

Uwaga: - Mimo że serwa nie są zasilane przez arduino, upewnij się, że podłączyłeś Gnd serw do arduino, w przeciwnym razie ramię nie zadziała.

Krok 4: Kodowanie:-

Logika tego kodu jest dość prosta, wartości potencjometrów są przechowywane w tablicy, a następnie rekordy są przeszukiwane za pomocą pętli for, a serwa wykonują kroki zgodnie z wartościami. Możesz sprawdzić ten samouczek, którego użyłem jako odniesienia „Kontrola i pamięć potencjometru Arduino”

Kod:- (Plik do pobrania załączony poniżej.)

Najpierw zadeklarujemy wszystkie niezbędne zmienne globalnie, abyśmy mogli ich używać w całym programie. Nie jest do tego potrzebne żadne specjalne wyjaśnienie

#włączać

//Serwoobiekty Serwo Servo_0; Serwo Serwo_1; Serwo Serwo_2; Serwo Serwo_3; Serwo Serwo_4; //Obiekty potencjometrów int Pot_0; int Pot_1; int Pot_2; wewn Pot_3; wewn Pot_4; //Zmienna do przechowywania pozycji Servo int Servo_0_Pos; int Serwo_1_Poz; int Servo_2_Pos; int Servo_3_Pos; int Servo_4_Pos; //Zmienna do przechowywania wartości poprzednich pozycji int Prev_0_Pos; int Poprzedni_1_Poz; int Poprzedni_2_Poz; int Poprzedni_3_Poz; int Poprzedni_4_Poz; //Zmienna do przechowywania aktualnych wartości pozycji int Current_0_Pos; int Current_1_Pos; int Bieżąca_2_Poz; int Current_3_Pos; int Bieżąca_4_Poz; int Servo_Position; //Przechowuje kąt int Servo_Number; //Przechowuje nr serwomechanizmu int Storage[600]; //Tablica do przechowywania danych (Zwiększenie rozmiaru tablicy zużywa więcej pamięci) int Index = 0; // Indeks tablicy zaczyna się od 0 pozycji char data = 0; //zmienna do przechowywania danych z wejścia szeregowego.

Teraz napiszemy funkcję setup, w której ustawiamy piny i ich funkcje. Jest to główna funkcja, która jest wykonywana jako pierwsza

pusta konfiguracja()

{ Szeregowy.początek(9600); //Do komunikacji szeregowej między arduino a IDE. //Obiekty Servo są dołączone do pinów PWM. Serwo_0.attach(3); Serwo_1.attach(5); Servo_2.attach(6); Serwo_3.attach(9); Serwo_4.attach(10); //Serwa są ustawione na 100 pozycji podczas inicjalizacji. Servo_0.write(100); Serwo_1.zapis(100); Servo_2.write(100); Servo_3.write(100); Servo_4.write(100); Serial.println("Naciśnij 'R', aby nagrywać i 'P', aby odtworzyć"); }

Teraz musimy odczytać wartości potencjometrów za pomocą pinów wejścia analogowego i zmapować je na serwa sterujące. W tym celu zdefiniujemy funkcję i nazwiemy ją Map_Pot();, możesz nazwać go, jak chcesz, jest to funkcja zdefiniowana przez użytkownika

nieważna mapa_pot()

{ /* Serwa obracają się o 180 stopni, ale używanie ich do granic nie jest dobrym pomysłem, ponieważ powoduje to ciągłe brzęczenie serw, co jest denerwujące, więc ograniczamy ruch serwa do: 1-179 */ Pot_0 = analogRead(A0); // Odczytaj dane wejściowe z pot i zapisz je w Variable Pot_0. Servo_0_Pos = mapa(Pot_0, 0, 1023, 1, 179); //Odwzoruj serwa według wartości od 0 do 1023 Servo_0.write(Servo_0_Pos); //Przenieś serwo do tej pozycji. Pot_1 = odczyt analogowy (A1); Servo_1_Pos = mapa(Pot_1, 0, 1023, 1, 179); Servo_1.write(Servo_1_Pos); Pot_2 = odczyt analogowy (A2); Servo_2_Pos = mapa(Pot_2, 0, 1023, 1, 179); Servo_2.write(Servo_2_Pos); Pot_3 = odczyt analogowy (A3); Servo_3_Pos = mapa(Pot_3, 0, 1023, 1, 179); Servo_3.write(Servo_3_Pos); Pot_4 = odczyt analogowy (A4); Servo_4_Pos = mapa(Pot_4, 0, 1023, 1, 179); Servo_4.write(Servo_4_Pos); }

Teraz napiszemy funkcję pętli:

pusta pętla()

{ Mapa_Potencjometr(); //Wywołanie funkcji do odczytu wartości puli while (Serial.available() > 0) { data = Serial.read(); if (data == 'R') Serial.println("Nagrywanie ruchów…"); if (data == 'P') Serial.println("Odtwarzanie zarejestrowanych ruchów…"); } if (data == 'R') //Jeśli wprowadzono 'R', rozpocznij nagrywanie. { //Zapisz wartości w zmiennej Prev_0_Pos = Servo_0_Pos; Poprzedni_1_Poz = Serwo_1_Poz; Poprzedni_2_Poz = Serwo_2_Poz; Poprzedni_3_Poz = Serwo_3_Poz; Poprzedni_4_Poz = Serwo_4_Poz; Mapa_Doniczka(); // Funkcja mapowania przywoływana do porównania, jeśli (abs(Prev_0_Pos == Servo_0_Pos)) // wartość bezwzględna jest uzyskiwana przez porównanie { Servo_0.write(Servo_0_Pos); // Jeśli wartości pasują do serwa jest przesunięte if (Current_0_Pos != Servo_0_Pos) // Jeżeli wartości nie pasują { Storage[Indeks] = Servo_0_Pos + 0; // Wartość jest dodawana do tablicy Index++; // Wartość indeksu zwiększona o 1 } Current_0_Pos = Servo_0_Pos; } /* Podobnie porównanie wartości jest wykonywane dla wszystkich serwomechanizmów, do każdego wpisu dodawane jest +100 jako wartość różnicowa. */ if (abs(Prev_1_Pos == Servo_1_Pos)) { Servo_1.write(Servo_1_Pos); if (Current_1_Pos != Servo_1_Pos) { Storage[Indeks] = Servo_1_Pos + 100; Indeks++; } Bieżąca_1_Poz = Serwo_1_Poz; } if (abs(Prev_2_Pos == Servo_2_Pos)) { Servo_2.write(Servo_2_Pos); if (Current_2_Pos != Servo_2_Pos) { Storage[Indeks] = Servo_2_Pos + 200; Indeks++; } Bieżąca_2_Poz = Serwo_2_Poz; } if (abs(Poprzedni_3_Poz == Serwo_3_Poz)) { Serwo_3.write(Serwo_3_Poz); if (Current_3_Pos != Servo_3_Pos) { Storage[Indeks] = Servo_3_Pos + 300; Indeks++; } Bieżąca_3_Poz = Serwo_3_Poz; } if (abs(Poprzednia_4_Poz == Serwo_4_Poz)) { Serwo_4.write(Serwo_4_Poz); if (Current_4_Pos != Servo_4_Pos) { Storage[Indeks] = Servo_4_Pos + 400; Indeks++; } Bieżąca_4_Poz = Serwo_4_Poz; } /* Wartości są drukowane na monitorze szeregowym, '\t' służy do wyświetlania wartości w formacie tabelarycznym */ Serial.print(Servo_0_Pos); Serial.print(" \t "); Serial.print(Servo_1_Pos); Serial.print(" \t "); Serial.print(Servo_2_Pos); Serial.print(" \t "); Serial.print(Servo_3_Pos); Serial.print(" \t "); Serial.println(Servo_4_Pos); Serial.print ("Indeks = "); Serial.println(Indeks); opóźnienie(50); } if (data == 'P') //IF 'P' jest wprowadzone, Rozpocznij odtwarzanie nagranych ruchów. { for (int i = 0; i < Index; i++) //Przejdź przez tablicę za pomocą pętli for { Numer_serwera = Pamięć / 100; // Znajduje liczbę serwo Servo_Position = Storage % 100; // Znajduje pozycję przełącznika serwa(Servo_Number) { case 0: Servo_0.write(Servo_Position); przerwa; przypadek 1: Servo_1.write(Servo_Position); przerwa; przypadek 2: Servo_2.write(Servo_Position); przerwa; przypadek 3: Servo_3.write(Servo_Position); przerwa; przypadek 4: Servo_4.write(Servo_Position); przerwa; } opóźnienie(50); } } }

Gdy kod będzie gotowy, teraz wgraj go na płytę arduino

Ramię Smart jest gotowe do pracy. Funkcja nie jest jeszcze tak płynna, jak ta wykonana przez Stoerpeak.

Jeśli możesz ulepszyć kod lub masz dla mnie jakieś sugestie, daj mi znać w sekcji komentarzy.

Powiedziawszy to, przejdźmy do testowania….

Krok 5: Testowanie:-

Po pomyślnym wgraniu kodu na tablicę otwórz 'Serial Monitor' możesz go znaleźć w opcji Narzędzia. Po uruchomieniu monitora szeregowego arduino zresetuje się. Teraz możesz sterować ramieniem robota za pomocą ramienia głównego. Ale nic nie jest rejestrowane.

Aby rozpocząć nagrywanie, wpisz „R” na monitorze, teraz możesz wykonywać ruchy, które chcesz nagrać.

Po wykonaniu ruchów musisz wpisać „P”, aby odtworzyć nagrane ruchy. Serwa będą wykonywać ruchy, dopóki tablica nie zostanie zresetowana.