Przeszukaj forum

Dzień dobry. Mam problem z silnikami DC w moim linefollowerze - a mianowicie taki, że się psują. Parametry mojego robota to: - masa: 207 g - wymiary: długość 200 mm, szerokość od koła do koła 187 mm - zasilanie: 2 x Li - Po (w pełni naładowane łącznie 8,4 V) https://botland.com.pl/akumulatory-li-pol-1s-37v/15618-akumulator-li-pol-akyga-1100mah-1s-37v-zlacze-jst-bec-gniazdo-55x32x62mm-5904422343613.html - sterownik silników: DRV8835 (ciągły prąd 1.2 A, chwilowy 1.5 A, zakres napięć 2 - 11 V) https://botland.com.pl/sterowniki-silnikow-dc/851-drv8835-dwukanalowy-sterownik-silnikow-11v12a-pololu-2135-5904422367220.html Zdjęcia robota: Jak widać, robot ma dwa tylnie koła, a z przodu "ślizga" się na tej małej kulce (ona się nie obraca jak ball caster, robot się po prostu ślizga) Dotychczas robot był napędzany tymi silnikami: https://botland.com.pl/silniki-micro-n20-seria-mp-medium-power/12555-silnik-n20-bt16-micro-101-2000rpm-9v-5904422306564.html Maksymalne napięcie zasilania to 8.4 V, a realne napięcie wystawiane przez sterownik silników przy największej prędkości to 6.8 V (mierzone multimetrem). Niestety mimo że te napięcia zawierają się w zakresie napięć tego modelu silnika (3 - 9 V) to silnik się psuje - wał silnika bardzo ciężko obrócić i nie chce startować. Dlatego proszę o pomoc w dobraniu odpowiednich parametrów silnika DC do mojego robota, lub (jeszcze lepiej) konkretnego modelu silnika. Najlepiej jakby miał takie same wymiary co dotychczas, żebym nie musiał zmieniać podwozia robota. Jeśli pominąłem coś ważnego to odpowiem na dalsze pytania, z góry dziękuję za wszelką pomoc.

Hej! Jeszcze jestem zielony, ale walczę. 😉 Moja wiedza to na razie kurs Arduino I i coś tam echem o millis. Jestem w trakcie modyfikacji robota z forbotowego kursu, oprócz zmian w budowie, wprowadzam też zmiany w programie. Jednym z założeń jest eliminacja wstrzymujących program delayów. Aktualnie pracuję nad sekcją jazdy autonomicznej. Popełniłem działający program z millisami, ale kolega @ethanak wskazał mi, że no nie do końca. 😉 Zatem, na początku kody z kursu (żeby w jednym miejscu było): Kontaktowe wykrywania/omijanie przeszkód: if (digitalRead(L_SIDE_SENSOR) == LOW) { //Jesli przeszkoda po lewej stronie //Jedz wstecz i wydawaj dzwiek leftMotor(-40); rightMotor(-40); digitalWrite(BUZZER, 1); delay(800); //Obrot w miejscu w prawo leftMotor(40); rightMotor(-40); digitalWrite(BUZZER, 0); delay(140); //Koniec warunku wracamy do jazdy prosto } if (digitalRead(R_SIDE_SENSOR) == LOW) { //Jesli przeszkoda po prawej stronie //Jedz wstecz i wydawaj dzwiek leftMotor(-40); rightMotor(-40); digitalWrite(BUZZER, 1); delay(800); //Obrot w miejscu w lewo leftMotor(-40); rightMotor(40); digitalWrite(BUZZER, 0); delay(140); //Koniec warunku wracamy do jazdy prosto } Wykrywanie przeszkód czujnikiem ultradźwiękowym: void loop() { //Czy wykryto przeszkode w zakresie 0-40 cm if (zmierzOdleglosc() > 40) { leftMotor(40); //Jesli nie, to jedz prosto rightMotor(40); } else { //Jesli przeszkoda stopMotors(); //Zatrzymaj robota serwo.write(20); //Skrec czujnikiem w prawo delay(800); //Poczekaj 800ms dla ustabilizowania konstrukcji //Sprawdz, czy po prawej stronie jest przeszkoda if (zmierzOdleglosc() > 40) { //Jesli jest pusto leftMotor(40); rightMotor(-40); delay(400); //Obracaj w prawo przez 400 ms } else { //Jeśli po prawej jest przeszkoda serwo.write(160); //Obroc czujnik w lewo delay(800); //Poczekaj 800ms dla ustabilizowania konstrukcji //Sprawdz, czy po lowej stronie jest przeszkoda if (zmierzOdleglosc() > 40) { //Jesli jest pusto leftMotor(-40); rightMotor(40); delay(400); //Obracaj w lewo przez 400 ms } else { //Jesli z przodu, z lewej i prawej jest przeszkoda digitalWrite(BUZZER, 1); delay(500); digitalWrite(BUZZER, 0); //Daj sygnal buzzerem } } //Po sprawdzeniu przeszkod po bokach //Ustaw czujnik prosto serwo.write(90); } //Opoznienie 100ms, ponieważ nie ma potrzeby sprawdzać przeszkod czesciej delay(100); } Aktualnie popełniłem taką funkcję, łączącą wykrywanie przeszkód przez krańcówki i sonar: void jazdaAuto() { //Funkcja jazdy autonomicznej ekspander.digitalWrite(LEDjazda, 1); unsigned long kontakt = 0; //Zmienne przechowująca czas startu unsigned long przeszkoda = 0; if (digitalRead(lewySensor) == LOW) { //Jeżeli przeszkoda po lewej zatrzymajSilniki(); kontakt = millis(); //Aktualizuj czas startu while (millis() - kontakt < 100) {} //Poczekaj 100 ms lewySilnik(-80); //Cofnij kawałek prawySilnik(-80); kontakt = millis(); //Aktualizuj czas startu while (millis() - kontakt < 800) {} //Cofaj przez 800 ms lewySilnik(80); //Skręć w prawo prawySilnik(-80); kontakt = millis(); //Aktualizuj czas startu while (millis() - kontakt < 800) {} //Skręcaj przez 800 ms zatrzymajSilniki(); kontakt = millis(); //Aktualizuj czas startu while (millis() - kontakt < 100) {} //Poczekaj 100 ms } if (digitalRead(prawySensor) == LOW) { //Jeżeli przeszkoda po prawej zatrzymajSilniki(); kontakt = millis(); //Aktualizuj czas startu while (millis() - kontakt < 100) {} //Poczekaj 100 ms lewySilnik(-80); //Cofnij kawałek prawySilnik(-80); kontakt = millis(); //Aktualizuj czas startu while (millis() - kontakt < 800) {} //Cofaj przez 800 ms lewySilnik(-80); //Skręć w lewo prawySilnik(80); kontakt = millis(); //Aktualizuj czas startu while (millis() - kontakt < 800) {} //Skręć w lewo przez 800 ms zatrzymajSilniki(); kontakt = millis(); //Aktualizuj czas startu while (millis() - kontakt < 100) {} //Poczekaj 100 milisekund } if (sonarDystans() > 30) { // Jeżeli w odległości 30 cm nie ma przeszkody lewySilnik(90); // To jedź prosto prawySilnik(90); } else { // Jeżeli wykryłeś przeszkodę serwo.attach(SERWO_PIN); // Podłącz serwo zatrzymajSilniki(); serwo.write(700); // Skręć czujnikiem w prawo przeszkoda = millis(); while(millis() - przeszkoda < 800) {}; //Poczekaj 800 ms if (sonarDystans() > 30) { // Jeżeli w odległości 30 cm nie ma przeszkody lewySilnik(70); // Skręcaj w prawo prawySilnik(-70); serwo.write(1400); // Ustaw serwo do pozycji domyślnej przeszkoda = millis(); while(millis() - przeszkoda < 800) {}; // Skręcaj przez 800 ms serwo.detach(); // Odłącz serwo } else { // Jeżeli wykryłeś przeszkodę serwo.write(2100); // Skręć czujnikiem w lewo przeszkoda = millis(); while(millis() - przeszkoda < 800) {}; //Poczekaj 800 ms if (sonarDystans() > 30) { // Jeżeli w odległości 30 cm nie ma przeszkody lewySilnik(-70); // Skręcaj w lewo prawySilnik(70); serwo.write(1400); // Ustaw serwo domyślnie przeszkoda = millis(); while(millis() - przeszkoda < 800) {}; // Skręcaj przez 800 ms serwo.detach(); // Odłącz serwo } else { // Jeżeli z każdej strony jest przeszkoda serwo.write(1400); // Ustaw serwo domyślnie digitalWrite(BUZZER, 1); // Daj sygnał buzzerem przeszkoda = millis(); while(millis() - przeszkoda < 500) {}; //Buzzer włączony przez 500 ms digitalWrite(BUZZER, 0); //Wyłącz buzzer serwo.detach(); //Odłącz serwo } } } przeszkoda = millis(); while (millis()-przeszkoda < 100) {} //Opóźnienie 100 ms dla wykrywania przeszkód }

Cześć, chcemy przedstawić wam projekt robota kroczącego Honey Badger. Na początek powiemy krótko o tym kim jesteśmy, naszej historii i czym się zajmujemy, następnie przedstawimy naszą najnowszą konstrukcję. Od razu dodamy, że jeśli będziecie mieli jakieś pytania to śmiało zadawajcie je w komentarzach - postaramy się na wszystkie odpowiedzieć 😄 MAB Robotics założyliśmy z myślą o komercjalizacji technologii robotów mobilnych i technologii napędowych dla robotyki w 2019. Sam pomysł i prace nad budową robotów kroczących rozpoczęliśmy już w trakcie studiów na Politechnice Poznańskiej gdy byliśmy członkami koła naukowego KN Mechatron. Pierwszy prototyp robota pokazał, że tego typu konstrukcje, w niektórych warunkach mają lepsze możliwości ruchowe niż dotychczas najpopularniejsze na lądzie roboty jeżdżące. Z pomocą dr inż. Krzysztofa Walasa (wykładowcy robotyki na Politechnice Poznańskiej), zdobyliśmy finansowanie z Akademickiego Inkubatora PP i w efekcie w 2019 roku powstała spółka MAB Robotics. Rok później zainwestował w nas fundusz inwestycyjny YouNick Mint co pozwoliło na przejście ze studenckiego projektu w firmę zajmującą się zaawansowanymi pracami badawczo rozwojowymi w obszarze robotyki i rozpoczęcie działań związanych z komercjalizacją opracowanych technologii. Dużą motywacją do działań był udział i nagrody jakie zdobywaliśmy w zawodach robotycznych w Polsce i za granicą - głównie w kategorii freestyle. Z naszymi robotami byliśmy m.in. na RoboticArena we Wrocławiu, Trójmiejskim Turnieju Robotów w Gdańsku, Sumo Challenge w Łodzi, Robomaticon w Warszawie, ROBOCOMP w Krakowie czy Robot Challenge w Pekinie. Niemal wszędzie zdobywaliśmy nagrody, zawsze poznawaliśmy ciekawych ludzi i gromadziliśmy bezcenne doświadczenie. Dziś pracujemy nad systemem inspekcyjnym, którego jedną z części jest robot Honey Badger. System rozwijany jest z myślą o prowadzeniu prac inspekcyjnychi serwisowych wewnątrz podziemnych sieci jakie występują pod ulicami każdego miasta. Obecnie wykorzystywane technologie, oparte najczęściej o jeżdżące platformy nie pozwalają dostać się wszędzie, mają stosunkowo niewielki zasięg i są drogie w użyciu. Dzięki przejściu z kół na nogi roboty MAB Robotics będą w stanie wejść niemal w każde miejsce, niosąc na grzbiecie sensory analizujące stan techniczny instalacji oraz narzędzia umożliwiające wykonywanie drobnych prac naprawczych od wewnątrz - pozwala to ograniczyć wykopy i prace drogowe w na ulicach miast. Teraz ta, pewnie ciekawsza część dotycząca technologii, którą zaczniemy od krótkiej prezentacji najnowszego robota: Zaprezentowany robot Honey Badger posiada 12 stopni swobody - po 3 na każdą z nóg. Napędy zbudowane są z silnika bezszczotkowego, przekładni planetarnej i sterownika silnika MD80. Taki rodzaj napędu dostarcza wystarczającego momentu obrotowego aby unieść robota i jednocześnie zapewnia wysoką dynamikę umożliwiającą np. podskoki. Istotnym aspektem jest wirtualna podatność napędu realizowana przez sterowanie impedancyjne. Dzięki odpowiedniemu sterowaniu, silnik symuluje dynamikę sprężyny. Korpus robota jest wodo i pyłoszczelny, dzięki czemu robot może pracować w trudnym środowisku nieprzyjaznym dla elektroniki - utrudnia to jednak chłodzenie układów. Wewnątrz znajduje się komputer sterujący lokomocją robota oraz dodatkowa jednostka umożliwiająca przetwarzanie danych z sensorów takich jak np. kamera głębi lub lidar. W korpus wbudowana jest również bateria, moduł komunikacyjny, moduł zarządzania energią i AHRS. Cała konstrukcja mechaniczna i wszystkie moduły elektroniczne zostały zaprojektowane przez zespół MAB. Elementy mechaniczne wykonane są metodami obróbki CNC aluminium i włókna węglowego dla elementów przenoszących obciążenia oraz druku 3D dla elementów stylistycznych oraz nieprzynoszących dużych obciążeń jak np. prowadniki przewodów wewnątrz korpusu. Wymiary robota to 0.25-0.5x0.4x0.6 [m] (HxWxL), a jego masa to 10kg. Robot ma gabaryty niewielkiego psa lub dużego kota, zależnie od preferencji 🙂 Robot do swojej pracy wykorzystuje kilka sensorów. W napędy wbudowane są enkodery zwracające pozycję kątową napędu oraz elektronika, która pozwala na estymację momentu obrotowego generowanego przez napęd - wiemy dzięki temu z jaką siłą stopa robota naciska na podłoże. Dodatkowo, moduł AHRS wewnątrz korpusu wskazuje pozycję kątową oraz pozwala określić przemieszczenia i prędkości korpusu względem świata. Podstawą oprogramowania jest firmware mikrokontrolerów we wszystkich modułach robota. Odpowiada m.in. za sterowanie silnikami, kontrolę zasilania oraz komunikację między układami - napisany jest w języku C, na platformie STM32. Następny poziom to software sterujący pracą robota - tutaj liczone jest jak robot ma poruszać nogami by podążać w wyznaczonym kierunku z zadaną prędkością zachowując równowagę. Najwyższy poziom to oprogramowania wyznacza ścieżkę ruchu robota, analizuje otoczenie i interpretuje polecenia operatora. Dwa ostatnie poziomy wykorzystują ROS2 co bardzo ułatwia pracę i daje wiele możliwości, wykorzystujemy tutaj C++. Na zakończenie ostatni filmik 🙂 Mamy nadzieję, że temat jest dla was ciekawy, trochę dowiedzieliście się z tego krótkiego wpisu i zmotywowaliśmy was do dalszej (lub rozpoczęcia) pracy z robotami. Jeśli macie pytania to chętnie na nie odpowiemy! Serdecznie zapraszamy: - do zwiedzenia naszej strony internetowej: MAB Robotics, - na nasz kanał na YouTube, gdzie wrzucamy dłuższe filmy, - na nasze social media: instagram, facebook i twitter.

Cześć, Zaprezentuje swojego robota albo raczej prototyp, który powstał głównie do stworzenia i testowania oprogramowania do zarządzania robotem. Natomiast drugim celem było zebranie danych dla sieci neuronowej. Zadaniem robota było jeżdżenie miedzy liniami i zebranie danych z kamery i sterownika silników. I ostatnim celem było wykorzystanie nauczonej sieci prowadzania robota między liniami. Elektronika i zasilanie: Raspberry Pi 4B WiFi 4GB RAM kamera HD OV5647 5Mpx sterownik silników TB6612FNG siniki i przekładnia (344,2:1) to jakaś stara Tamiya power bank 20000mAh,2A MAX chyba Części mechaniczne i konstrukcyjne: gąsienice i koła wydrukowane (pobrane ze strony: www.printables.com) mocowanie do kamery drukowane Oprogramowanie: https://github.com/noxgle/pt2 Problemy: Sterownik silników jest zasilany bezpośrednio z Raspberry co powdowiało że przy pełnym wypełnieniu pwm "brakowało prądu" i następował restart. Zmniejszenie wypełnienia pwm do 50% pomogło do momentu większego rozładowanie baterii. Robotem podczas zbierania danych sterowała aplikacja uruchomiona na laptopie po sieci WiFI. Dane z kamery były obrabiane były wykorzystaniem biblioteki OpenCV. Sterowanie robotem z nauczoną siecią też odbywało się z wykorzystaniem laptopa. Do nauki została wykorzystana biblioteka fast.ai

Mocne postanowienie: na podstawie doświadczeń z lalkami zrobić coś, co pozbawione jest błędów poprzednich konstrukcji 🙂 Robot początkowo miał być czarownicą, ale okazało się, że dzieci w przedszkolu negatywnie reagują na postacie tego typu (młodsze się wręcz boją czarownicy czy czarodzieja), dlatego ma być to kolejny Krasnolud. Tym razem nie Tolkienowski mieszkaniec podziemi, a sympatyczny Krasnal mieszkający w lesie, z ładną czerwona czapeczką i miłym dla oka szlafroczkiem. Ponieważ sprawę podwozia mam na razie nie do końca rozwiązaną, postanowiłem, że będzie to stary Krasnolud, jeżdżący w fotelu na kółkach. Takie rozwiązanie zwalnia mnie z konieczności ukrywania kół napędowych, a jednocześnie pozwala na użycie większych i tańszych silników (NEMA 17, kupione po 7 PLN na Allegro). Ponownie chcę użyć akumulatora Parkside (bardzo dobrze sprawdził się w poprzednim Krasnoludzie), tym razem nie kombinuję z EasyDriverami tylko wstawiłem stare dobre A4988. Zostawiam sobie jednak możliwość zastosowania TMC 2209 (o ile eksperyment pokaże, że detekcja zatrzymania silnika będzie działała poprawnie). Na razie mam złożone podwozie: Silniki które kupiłem miały założone zębatki na wałach, dlatego taka a nie inna konstrukcja kół napędowych. Teoretycznie mają półtora ampera na cewkę, na sterownikach ustawiłem na razie 0.7A a i tak są za mocne. Ale dokładniej będę mógł ustawić dopiero na zakończenie. I tu ciekawostka: koła wyposażone w łożyska 6mm miały być osadzone na wspólnej osi. Niestety, okazało się że gwintowany (podobno M6) pręt który mam ma jakieś 5.4mm średnicy i nie bardzo chciał współpracować z łożyskami. Użyłem pojedynczych śrub wymontowanych ze starej kanapy (jak dobrze sobie zostawić takie drobiazgi). A co z resztą? Głowę mam w połowie gotową. Dzisiaj powinny przyjść serwa HD1440A (zależy mi zarówno na wymiarach, jak i najmniejszym możliwym poborze prądu). W sumie jest tu pięć serw: po jednym HD1370A umieszczonych wewnątrz gałki ocznej, jedno do pionowego wspólnego ruchu oczu, jedno do skłonu głowy (uczciwe cięgło a nie jakieś wydumane zębatki) i jedno do obrotu (tym razem przekładnia zębata 1:2, sprawdziła się bardzo dobrze w poprzednich konstrukcjach). Jak tylko uda mi się zamontować serwa wrzucę jakąś ładną fotkę. Ręce - a właściwie ręka, bo tylko prawa ma być w pełni animowana. Zrobiłem bardzo ambitne założenie sześciu stopni swobody, zobaczymy co z tego wyjdzie. Serwa do napędu ręki mam. Kombinuję jeszcze z jakimś wyhamowaniem oscylacji na głównym serwie barkowym, być może uda mi się to osiągnąć programowo tylko musiałbym dodać jakieś sprzężenie zwrotne... no cóż, zobaczymy co z tego wyjdzie. Jeśli nic, zawsze mogę skorzystać ze sprawdzonego rozwiązania (ograniczenie prędkości ruchu serwa). No i oczywiście "drobiazgi": żyroskop/akcelerometr, kamera (do patrzenia na twarz rozmówcy), czujnik odległości (tym razem nie tylko do wykrywania przeszkód ale również do ustalania zbieżności oczu), syntezator mowy i takie tam różności. Zdalne sterowanie na razie poprzez UDP (ESP32 pracujący w trybie AP_STA, czyli z możliwością zarówno podłączenia do domowej sieci WiFi jak i do pracującego w trybie STA sterownika). Pozwala mi to na odłożenie zaprojektowania sterownika na sam koniec i sterowanie na razie prostą aplikacją na pececie. No cóż - sam jestem ciekaw co mi z tego wyjdzie 🙂

No cześć, kilka miesięcy wzlotów i upadków, kłótni z żoną i w końcu jest .... ESPoBOT 🙂 Robot gąsienicowy RC z kamerą FPV i chwytakiem. Sterowanie oparte o ESP32-wroom 32D. Zacząłem od Arduino, ale z uwagi na problemy z komunikacją dwustronną NRF24L01, przesiadłem się na ESP32. Napędem są 2 silniki 9Vdc z przekładnią 87:1 na podwoziu gąsienicowym z regulacją prześwitu, kontrolowane przez sterownik oparty o układ TB6612. Prędkość silników regulowana płynnie w zakresie 0-30cm/s (1km/h). Robot wyposażony w chwytak umożliwiający chwycenie detalu, podniesienie/opuszczenie z użyciem 3 serw. Kontrola zaciśnięcia chwytaka zrealizowana poprzez pomiar prądu serwa. Regulacja prędkości serw. Zainstalowana kamera 1200TVL do przekazywania obrazu fpv 5.8GHz na telefon, PC lub wyświetlacz AV. Zasięg nadajnika do 500m. Robot wyposażony w oświetlenie LED RGB. Całość zasilana z akumulatora LiPo 1800mAh 11,1V 20C i zabezpieczona bezpiecznikiem polimerowym 4A. Dodatkowo akumulator zabezpieczony programowo przed rozładowaniem. Komunikacja dwustronna z padem na częstotliwości 2.4GHz (ESP-NOW) i zasięgu do 250m. Pad wyposażony w 2 joysticki, 6 guzików, potencjometr, enkoder oraz wyświetlacz OLED 128x64 do wyświetlania parametrów urządzenia. Zasilany z akumulatora 9V 650mAh USB.

Cześć. Chciałem wam pokazać projekt nad którym pracuję: PENETRATOR Trochę konkretów: aluminiowy kadłub napęd: dwa silniki elektryczne szczotkowe 9V zasilanie 2 x 18650 + 2 x 18650 ukryte pod kadłubem kontroler: Raspberry Pi 3 A+ wizja: moduł kamery 1080p emitery IR umożliwiające kamerze pracę w ciemnościach łączność: WiFi (access point i serwer HTTP) język programowania : Python 3 sterowanie i obraz: autorska aplikacja webowa (w przeglądarce) umożliwiająca wyświetlanie obrazu z kamery i sterowanie robotem W PLANACH: mechaniczne ramię 7DOF oparte na serwomechanizmach MG996R obracanie kamery w 2 płaszczyznach przy pomocy serwomechanizmów mam też ochotę pobawić się sztuczną inteligencją, stąd wybór raspberry a nie np. esp8266 Przy okazji, podziękowania dla Forbot.pl za podstawy które wprowadziły mnie do świata robotyki

Witam mam następujący problem- Posiadam robota alphabot https://botland.com.pl/waveshare-roboty-edukacyjne/8077-alphabot-2-kolowa-platforma-robota-z-czujnikami-i-napedem-dc-waveshare-12249-5903351240291.html takiego jak w linku gdy wgrywam kod do sterowania ir kod nie działa czytałem że trzeba po przełączać jakieś zworki ale które nie wiem wstawiam również kod bo może to jest jego wina dodam że kod jest dołączony w instrukcji od robota z góry dziękuję za odpowiedź 🙂 #include "AlphaBot.h" #define KEY2 0x18 //Key:2 #define KEY8 0x52 //Key:8 #define KEY4 0x08 //Key:4 #define KEY6 0x5A //Key:6 #define KEY1 0x0C //Key:1 #define KEY3 0x5E //Key:3 #define KEY5 0x1C //Key:5 #define SpeedDown 0x07 //Key:VOL- #define SpeedUp 0x15 //Key:VOL+ #define ResetSpeed 0x09 //Key:EQ #define Repeat 0xFF //press and hold the key #define IR 4 //he infrare remote receiver pin unsigned long n = 0; AlphaBot ArduinoCar = AlphaBot(); unsigned char t[30]; unsigned char results; char IR_decode(unsigned char code); void translateIR(); void setup() { Serial.begin(115200); pinMode(IR, INPUT); ArduinoCar.SetSpeed(150); } void loop() { if (IR_decode(&results)) { translateIR(); } if (millis() - n > 200) { ArduinoCar.Brake(); } } /*-----( Declare User-written Functions )-----*/ void translateIR() // takes action based on IR code received // describing KEYES Remote IR codes { n = millis(); ; switch (results) { case KEY1: ArduinoCar.LeftCircle(); break; case KEY2: ArduinoCar.Forward(); break; case KEY3: ArduinoCar.RightCircle(); break; case KEY4: ArduinoCar.Left(); break; case KEY5: ArduinoCar.Brake(); break; case KEY6: ArduinoCar.Right(); break; case KEY8: ArduinoCar.Backward(); break; case Repeat: break; default: ArduinoCar.Brake(); }// End Case } //END translateIR char IR_decode(unsigned char * code) { char flag = 0; unsigned int count = 0; unsigned char i, index, cnt = 0, data[4] = {0, 0, 0, 0}; if (digitalRead(IR) == LOW) { count = 0; while (digitalRead(IR) == LOW && count++ < 200) //9ms delayMicroseconds(60); t[0] = count; count = 0; while (digitalRead(IR) == HIGH && count++ < 80) //4.5ms delayMicroseconds(60); t[1] = count; for (i = 0; i < 32; i++) { count = 0; while (digitalRead(IR) == LOW && count++ < 15) //0.56ms delayMicroseconds(60); count = 0; while (digitalRead(IR) == HIGH && count++ < 40) //0: 0.56ms; 1: 1.69ms delayMicroseconds(60); if (count > 20)data[index] |= (1 << cnt); if (cnt == 7) { cnt = 0; index++; } else cnt++; } if (data[0] + data[1] == 0xFF && data[2] + data[3] == 0xFF) //check { code[0] = data[2]; Serial.println(code[0], HEX); flag = 1; } if (data[0] == 0xFF && data[1] == 0xFF && data[2] == 0xFF && data[3] == 0xFF) { code[0] = 0xFF; Serial.println("rep"); flag = 1; } } return flag; }

Witam jaki obliczyć jakie parametry powinny mieć 4 silniki dc, które napędzały by 4 kołową platformę o wadze 10 kg i mogły ją rozpędzić do prędkości 6 km/h?

Dzień dobry, na wstępie opiszę z grubsza założenia projektu - w przyszłości pracy inżynierskiej. Priorytetowym zadaniem, jakie ma stanąć przed moim robotem jest okrążenie kampusu mojej uczelni. Teren nie jest prosty, robot będzie miał do pokonania wyboiste drogi(częściowo przejazd przez las), krawężniki, trawniki i parkingi. Sterowanie ma być ręczne, realizowane zdalnie, za pośrednictwem internetu. Okrążenie to około 3km, zakładany czas przejazdu to niecała godzina. Konstrukcja opiera się na ramie zbudowanej z profili alu, o wymiarach 400x600. Do ramy będzie przymocowane większość osprzętu robota. Zawieszenie niezależne, 4 wahacze wzdłużne zawieszone na amortyzatorach do samochodów rc. Jako napęd 4 silniki wraz z przekładniami od samochodów dla dzieci. Koła 12 cali od wózka dziecięcego Część elektroniczna składa się z: Raspberry Pi 3, ICSTATION UNO, 4xmostek H VNH2SP30, przetwornica napięcia 5v USB, czujniki odległości(jeszcze nie wybrane), kamera(prawdopodobnie internetowa usb) Tyle z założeń, robot jest już w zaawansowanej fazie budowy. Zaczęło się od projektu w semestrze zimowym 2019/2020, projekt został zaliczony, jego dokumentacja tutaj(dokumentacja), a filmik zaliczeniowy z pierwszej jazdy terenowej poniżej Na tej fazie robot całą elektronikę miał zamontowaną "na taśmę", ze względu na zamówienie niewłaściwych kołków do pcb, a termin gonił. Obecnie robot jest rozebrany z całej elektroniki, powstaje miejsce w którym pojawią się akumulatory i elektronika(puszka elektryczna), osobny wyłącznik awaryjny oraz doprowadzenie kabli do silników. Poniższe zdjęcie przedstawia obecny stan robota: Aktualnie czekam na osłony na silniki wydrukowane w 3d, po zamontowaniu wszystkiego z zewnątrz będę mógł przejść do środka. W środku planuję zrobić ramkę z kątownika alu 20x20, w której będą miejsca na akumulatory(dwa akumulatory umieszczone po bokach), a pomiędzy nimi ma zostać umieszczona elektronika w sposób warstwowy(poziom 1: mostki H, poziom 2: ICSTATION UNO, poziom 3: Raspberry Pi 3). Poza tymi warstwami muszę znaleźć jeszcze miejsce na przetwornicę napięcia i mobilny ruter wifi. Całą ramkę chcę umieścić na gąbce, która by amortyzowała wstrząsy, tak samo zabezpieczyłbym moduł od góry. Dziękuję za uwagę, postępy i pytania będę starał się wrzucać tu na bieżąco.

Witam Próbuję zaimplementować algorytm podążania robota mobilnego 2-kołowego po trajektorii zadanej z góry wzorem na podstawie znalezionych materiałów. materiały: https://www.researchgate.net/publication/225543929_Control_of_Wheeled_Mobile_Robots_An_Experimental_Overview (strona 16 - Nonlinear Control Design) https://kcir.pwr.edu.pl/~mucha/Pracki/Rafal_Cyminski_praca_magisterska.pdf (strona 38) Problem polega na tym, że robot albo jedzie tylko część trajektorii albo ruch wynikowy nie przypomina ani trochę trajektorii wynikowej. void lissajousInit(lissajousTypedef *liss,trajectoryTypedef *traj, sampsonTypedef *samp) { traj->ts = 0.01F; robotMove1.ts = traj->ts; liss->amplitudeX_f32 = 0.5F; liss->amplitudeY_f32 = 0.6F; liss->paramA_u8 = 1.0F; liss->paramB_u8 = 2.0F; liss->paramDelta_f32 = M_PI/2; samp->Kp_f32 = 0.526; samp->Kd_f32 = 0.00263; traj->translationDesigned_f32 = integrateTrapz(0, M_TWOPI, 1000.0F, lissajousTrajectoryVelocitySpecial); } void lissajousTrajectoryGenarate(lissajousTypedef *liss,trajectoryTypedef *traj, sampsonTypedef *samp, robotMoveTypedef *robMov) { if(robMov->translationMeters <= traj->translationDesigned_f32) { traj->time_f32 += traj->ts;//M_PI_DIV; traj->trajRunning_u8 = 1; lissajousTrajectoryPath(traj, liss); calcAngleRadians(traj); trajectoryVelocity(traj); trajectoryAcceleration(traj); samp->angleNow_f32 = robMov->robotAngleDiff; samp->angleErr_f32 = (traj->angleRadiansDiff_f32- robMov->robotAngleDiff); samp->xErr_f32 = (traj->px_f32 - robMov->x); samp->yErr_f32 = (traj->py_f32 - robMov->y); samp->progrVelDesigned_f32 = traj->vxy_f32; samp->angVelDesigned_f32 = ((traj->ay_f32*traj->vx_f32) - (traj->ax_f32*traj->vy_f32))/traj->vxy_f32; sampsonAlgorithm(samp); } else { traj->trajRunning_u8 = 0; //robMov->translationMeters = traj->translationDesigned_f32; } } void lissajousTrajectoryPath(trajectoryTypedef *traj, lissajousTypedef *liss) { traj->pxPrev_f32 = traj->px_f32; traj->pyPrev_f32 = traj->py_f32; traj->px_f32 = liss->amplitudeX_f32*arm_sin_f32(liss->paramA_u8*traj->time_f32 + liss->paramDelta_f32); traj->py_f32 = liss->amplitudeY_f32*arm_sin_f32(liss->paramB_u8*traj->time_f32); } void trajectoryVelocity(trajectoryTypedef *traj) { if(lisTraj.amplitudeX_f32 > 0) { traj->vx_f32 = lisTraj.amplitudeX_f32*lisTraj.paramA_u8*cosf(lisTraj.paramA_u8*traj->ts + lisTraj.paramDelta_f32); traj->vy_f32 = lisTraj.amplitudeY_f32*lisTraj.paramB_u8*cosf(lisTraj.paramB_u8*traj->ts); } else { //for anothor purpose traj->vxPrev_f32 = traj->vx_f32; traj->vyPrev_f32 = traj->vy_f32; traj->vx_f32 = (traj->pxPrev_f32 - traj->px_f32)/traj->ts; traj->vy_f32 = (traj->pyPrev_f32 - traj->py_f32)/traj->ts; if(traj->velocityDesigned_f32) { if(traj->vx_f32 != 0) traj->vx_f32 = (traj->velocityDesigned_f32/traj->vx_f32)*traj->vx_f32; if(traj->vy_f32 != 0) traj->vy_f32 = (traj->velocityDesigned_f32/traj->vy_f32)*traj->vy_f32; } } float32_t sumOfSqares = (traj->vx_f32*traj->vx_f32) + (traj->vy_f32*traj->vy_f32); traj->vxy_f32 = sqrtf(sumOfSqares); } void trajectoryAcceleration(trajectoryTypedef *traj) { if(lisTraj.amplitudeX_f32 > 0) { traj->ax_f32 = -lisTraj.amplitudeX_f32*lisTraj.paramA_u8*lisTraj.paramA_u8*sinf(lisTraj.paramA_u8*traj->ts + lisTraj.paramDelta_f32); traj->ay_f32 = -lisTraj.amplitudeY_f32*lisTraj.paramB_u8*lisTraj.paramB_u8*sinf(lisTraj.paramB_u8*traj->ts); } else { //for anothor purpose traj->ax_f32 = (traj->vxPrev_f32 - traj->vx_f32)/traj->ts; traj->ay_f32 = (traj->vyPrev_f32 - traj->vy_f32)/traj->ts; } float32_t sumOfSqares = (traj->ax_f32*traj->ax_f32) + (traj->ay_f32*traj->ay_f32); traj->axy_f32 = sqrtf(sumOfSqares); } void calcAngleRadians(trajectoryTypedef *traj) { traj->angleRadiansPrev_f32 = traj->angleRadians_f32; traj->angleRadians_f32 = atan2f(traj->py_f32, traj->px_f32); traj->angleRadiansDiff_f32 = traj->angleRadians_f32 - traj->angleRadiansPrev_f32; } float deg2rad(float num) { return num * (M_PI / M_PI_DEG); } float rad2deg(float num) { return num * (M_PI_DEG / M_PI); } static float32_t lissajousTrajectoryVelocitySpecial(float32_t mytime) { static float32_t vxySpecial; trajectory1.vx_f32 = lisTraj.amplitudeX_f32*lisTraj.paramA_u8*cosf((lisTraj.paramA_u8*mytime) + lisTraj.paramDelta_f32); trajectory1.vy_f32 = lisTraj.amplitudeY_f32*lisTraj.paramB_u8*cosf(lisTraj.paramB_u8*mytime); float32_t sumOfSqares = (trajectory1.vx_f32*trajectory1.vx_f32) + (trajectory1.vy_f32*trajectory1.vy_f32); vxySpecial = sqrtf(sumOfSqares); return vxySpecial; } float32_t integrateTrapz(float32_t xp, float32_t xk, uint16_t N, float32_t(*f)(float32_t)) { float32_t dx = 0, s = 0; s = 0; dx = (xk - xp) / N; for (int i = 1; i < N; i++) { s += (*f)(xp + i * dx); } s = (s + ((*f)(xp) + (*f)(xk)) / 2) * dx; return s; } Algorytm omawiany w wyżej wymienionych publikacjach: void sampsonAlgorithm(sampsonTypedef *alg) { alg->xTrackErr_f32 = cosf(alg->angleNow_f32)*alg->xErr_f32 + sinf(alg->angleNow_f32)*alg->yErr_f32; alg->yTrackErr_f32 = -sinf(alg->angleNow_f32)*alg->xErr_f32 + cosf(alg->angleNow_f32)*alg->yErr_f32; if(alg->angleErr_f32 == 0) alg->angleErr_f32 = FLT_MIN; //very small number - 0 casued NaN (Not a Number) alg->progrVelRef_f32 = alg->Kp_f32*alg->xTrackErr_f32 + alg->progrVelDesigned_f32*cosf(alg->angleErr_f32); alg->angVelRef_f32 = alg->angVelDesigned_f32 + (alg->Kd_f32*alg->angleErr_f32) + (alg->progrVelDesigned_f32*alg->yTrackErr_f32*(sinf(alg->angleErr_f32)/alg->angleErr_f32)); alg->velLeftWheel_f32 = alg->progrVelRef_f32 - (ROBOT_LENGHT/2)*alg->angVelRef_f32; alg->velRightWheel_f32 = alg->progrVelRef_f32 + (ROBOT_LENGHT/2)*alg->angVelRef_f32; alg->velLeftWheelTicks_f32 = (convertMetersToTicks(alg->velLeftWheel_f32)/100.0F); alg->velRightWheelTicks_f32 = (convertMetersToTicks(alg->velRightWheel_f32)/100.0F); } Obliczanie pozycji robota: void calculateRobotKinematics(encoderTypedef *encLeft, encoderTypedef *encRight, robotMoveTypedef *robMov) { robMov->translationMeters = (encLeft->distanceMeters_f32 + encRight->distanceMeters_f32)/2; robMov->translationMetersDiff = (encLeft->distanceMetersDiff_f32 + encRight->distanceMetersDiff_f32)/2; MPU6050_Read_Gyro(&hi2c3, &MPU6050); if(fabsf(MPU6050.Gz) < 0.1F) //high-pass filter [deg] { MPU6050.Gz = 0.0F; } robMov->rotationRadians += deg2rad(MPU6050.Gz)*robMov->ts; // (encRight->distanceMeters - encLeft->distanceMeters)/ROBOT_LENGHT; robMov->rotationRadiansDiff = robMov->rotationRadians - robMov->rotationRadiansPrev; //może *ts ??? robMov->robotAngleDiff = robMov->robotAngle - robMov->robotAnglePrev; //może *ts ??? robMov->x = robMov->translationMeters*cosf(robMov->rotationRadians); robMov->y = robMov->translationMeters*sinf(robMov->rotationRadians); robMov->robotAngle = atan2f(robMov->y, robMov->x); robMov->rotationRadiansPrev = robMov->rotationRadians; robMov->robotAnglePrev = robMov->robotAngle; } Wywołanie całości (co 10ms --> f = 100Hz): if(START_PILOT_VIENNA || START_PILOT_JSUMO) { lissajousTrajectoryGenarate(&lisTraj,&trajectory1, &sampsonData, &robotMove1); PIDwheelVelocity(&pidLeftWheel, &encoderLeft, sampsonData.velLeftWheelTicks_f32); PIDwheelVelocity(&pidRightWheel, &encoderRight, sampsonData.velRightWheelTicks_f32); if(trajectory1.trajRunning_u8) { MotorSpeed(pidLeftWheel.PWMout, pidRightWheel.PWMout); } else { MotorSpeed(0,0); } } else { MotorSpeed(0,0); }

Witam! Rozpoczynam nowy projekt, którym będzie próba zbudowania robota balansującego. Będzie to mój pierwszy robot. Ponieważ temat jest obszerny, oraz sama elektronika robota będzie modułowa, więc postanowiłem podzielić projekt na kilka worklogów. Zaczynam od modułu sterowania silników i tego będzie dotyczyć ten worklog. Założenia: 1. Dwa kanały (2 silniki BLDC - do gimbali) 2. Sterowanie FOC z enkoderem magnetycznym 3. Zintegrowany mikrokontroler który będzie tylko do sterowania silnikami (utrzymywanie równowagi i zadanych parametrów ruchu) 4. Zintegrowany akcelerometr i żyroskop 5. Monitorowanie max prądu silników (zabezpieczenie przed przeciążeniem) Zdecydowałem się na następujące główne komponenty: 1. Silniki BLDC do gimbali - 5208 - 2 szt. 2. Driver silników L6234 - 2 szt. 3. Enkodery magnetyczne AS5600 - 2 szt. 4. Akcelerometr i żyroskop - MPU6050 - 1 szt. 5. Mikrokontroler STM32F103RG (wersja XL-density bo ma dwa zaawansowane timery TIM1 i TIM8) Pozdrawiam, Marek

Witam, Moim celem jest stworzenie robota kontrolowanego przez pilot z łącznością przez moduł radiowy FS100A Od strony technicznej wszystko mam zaplanowane lecz nie potrafię zaprogramować arduino z modułem radiowym jedyne co narazie mam to Kod Nadajnika: #include <VirtualWire.h> #define led_pin 11 #define transmit_pin 10 #define pot_pin A0 void setup() { vw_set_tx_pin(transmit_pin); vw_setup(2000); pinMode(led_pin, OUTPUT); } void loop() { int pot = analogRead(pot_pin); String toSend = (String(pot, DEC)); char msg[23]; toSend.toCharArray(msg, toSend.length() + 1); digitalWrite(led_pin, HIGH); vw_send((uint8_t *)msg, strlen(msg)); vw_wait_tx(); digitalWrite(led_pin, LOW); delay(1000); } Kod odbiornika: #include <VirtualWire.h> #define led_pin 13 #define receive_pin 11 #define pwm_pin 3 void setup() { Serial.begin(9600); Serial.println("setup"); vw_set_rx_pin(receive_pin); vw_setup(2000); vw_rx_start(); pinMode(led_pin, OUTPUT); pinMode(pwm_pin, OUTPUT); } void loop() { uint8_t buf[VW_MAX_MESSAGE_LEN]; uint8_t buflen = VW_MAX_MESSAGE_LEN; if (vw_get_message(buf, &buflen)) { int i,pwm,wartosc; String liczba; digitalWrite(led_pin, HIGH); for (i = 0; i < buflen; i++) { liczba+=char(buf); } wartosc = liczba.toInt(); pwm = map(wartosc,0,1023,0,255); Serial.print(wartosc); Serial.print(" "); Serial.println (pwm); analogWrite(pwm_pin, pwm); digitalWrite(led_pin, LOW); } } Tyle że jest to program przesyłający dane jednego potencjometru a la potrzebuje trzecz potencjometrów i dwóch przełączników ,nie mam pojęcia jak to przerobić pomoże ktoś???

Cześć, jestem początkujący, jestem w trakcie budowy czteronożnego robota kroczącego, używam Arduino Uno oraz 16 kanałowego sterownika PWM do sterowania 12 serwomechanizmami Tower Pro 9g. Problem pojawił się z doborem odpowiedniego zasilania dla serw. Potrzebuję w miarę kompaktowego zasilania 5/6 V oraz 4/5 A. Bardzo proszę o pomoc. Zastanawiam się nad użyciem dwóch ogniw litowo-jonowych 18650 (3,7V maksymalny prąd rozładowania 4A), tylko w jaki sposób doprowadzić do odpowiedniego napięcia,?

Witam wszystkich mam takie pytanko i problem jestem zielony w akumulatorach a mam do podmianki baterie do odkurzacza automatycznego czy da się podmienić cztery akumulatory widoczne na zdięciu i co to za płytka z układem jest połączona z bateriami ?? Dzięki za odpowiedz.

Witam wszystkich. Jako, że na temat mojej pracy inżynierskiej wybrałem budowę manipulatora - plotera rysującego po powierzchni do której jest zamocowany, chciałbym prosić o kilka porad. Dodam też, że jestem w tym kompletnie zielony ale mam jeszcze około rok więc myślę, że się uda. Chciałbym żeby z wyglądu był zbliżony do KUKI. 1. Jako, że robot musi mieć funkcję plotera, w czym najlepiej to zaprogramować? (Kilka osób mi poleciło raspberry pi z pythonem). Będzie to nauka od postaw więc proszę o polecenie książek do nauki tego języka. 2. Jakie książki, dzięki którym będę wiedział jak budować danego robota, jaką elektronikę, jakie silniki itd. 3. Jeśli coś ważnego pominąłem to również proszę to napisać. 🙂

Ahoj. Byłbym szaleńczo wdzięczny za sugestie od graczy bardziej doświadczonych w zasilaniu rzeczy rozmaitych. Chciałbym zmontować pojazd wymachujący ramieniem i zaopatrzyłem się w 10 serwomechanizmów, z których większości powinno wystarczyć 5V, ale kilku chętnie posłałbym 6V, jednemu nawet powyżej 7V, jeśli to ma zwiększyć ich udźwig. Powinny utrzymywać pozycję w razie obciążeń, więc zakładam, że to nie będą skromne miliampery. Przyglądam się takiej opcji jak Dualsky 11.1V 25C, bo rozumiem, że wersja 7.4V mogłaby nie wystarczyć, a o bateriach 9V nie czytam wiele dobrego w kwestii poboru prądu. Ale jakie byłyby opcje na rozprowadzenie takiej mocy do dalszej regulacji, nie walcząc z projektowaniem oryginalnego PCB? Czy sterowniki + Arduino + osobne baterie to najlepsze wyjście z mniej skomplikowanych? Bo tu ładowanie tego wszystkiego na bagażnik brzmi trochę brutalnie. Chciałbym się ograniczać i z przestrzenią, i kosztami, i czasochłonnością rozwiązań. Nawet jeśli mistrzować jakiś PCB, to też wypadałoby to potestować w fazie programowania, a mój substytut Arduino nie daje rady zasilić nawet jednego serwa. Czy nie byłoby szans, by taki układ z jednym akumulatorem, regulatorami, mikrokontrolerami, modułem Bluetooth itd., polutować na takim wynalazku jak płytka uniwersalna? (I czy w takim wypadku istnieje jakiś stabilizator dla serwa 6–8.4V, które może pociągnąć pewnie i z 4A?)

Drodzy Technicy! Typowe ramię robota tylko pozornie naśladuje nasze ludzkie. Mobilność naszych kończyn jest daleko większa gdyż mamy bardziej ruchliwe stawy. A co by było gdyby i robot miał możliwość realizowania wielu stopni swobody w ramach tylko jednego przegubu?... ... To pytanie zadałem sobie po raz pierwszy dawno, dawno temu, u schyłku poprzedniego tysiąclecia, kiedy to komórki były w cebuli i na ziemniaki. W owych straszliwych, bezfejsowych czasach, pacholęciem będąc, usłyszałem o bajecznej chirurgii laparoskopowej. Dziurka od klucza te sprawy... Zafascynował mnie ten temat w stopniu większym niźli przysługiwał memu smarkaczowatemu stanowi. Pooglądałem sobie narzędzia jakie są używane i byłem niezmiernie zbulwersowany, że wśród nich brak jest takich, które by działały wystarczająco dobrze... Było dla mnie oczywistym, że przegub, który występuje w tego typu instrumentach, winien pracować podobnie jak nadgarstek, gałka oczna czy staw ramienny lub biodrowy. W takim brzuchu czy innym sercu jest klaustrofobicznie ciasno, więc należy mieć możliwość działania swobodnie w każdym kierunku bez przeszkód. Istniejące konstrukcje dają wolność w wymiarze albo w lewo albo w prawo i dopiero przy następnym przegubie mamy ponownie jedynie słuszną dowolność albo w lewo albo w prawo… No ale tam, w tych trzewiach, przecie nie ma miejsca na taką gburowatość w ruchach! O jakże potężną moc ma dziecięcy gniew!... Zanurkowałem w bezkresnym bałaganie mojego pokoju i cudem odnalazłem w miarę całą i nadal względnie kulistą piłeczkę pingpongową i zacząłem kombinować… O dziwo udało mi się znaleźć rozwiązanie. Działało! Ale niestety nie działało dość dobrze… Konstrukcja żerowała na wytrzymałości bardzo finezyjnych, delikatnych i trudnych w wykonaniu elementach. Wiedziałem już wtedy, że jeżeli coś ma być do medycyny to ma być solidne, niezawodne i nade wszystko tanie!… Początkowy gniew, po którym nastał złudny sukces, ostatecznie przeobraził się z wieloletnią, dojmującą rozpacz bezowocnych poszukiwań… Aż tu nagle, razu pewnego, jadłem na kolację jajecznicę. Lubuję się w takiej technologii spożycia rzeczonej jajecznicy, gdy niezmiennie pozostaje ona na patelni a ta z kolei spoczywa uroczyście na gazecie aby zadość uczynić stołowemu, kuchennemu bhp… Pozwalam sobie o tym wspomnieć tylko dlatego, że wystąpił w tamtym momencie ów decydujący czynnik katalizujący me pragnienia – gazeta! A dokładniej skrawek jej, marginesem zwany, wciąż niedoceniany, który aż się prosi aby przelać nań jakąś ważną myśl. Z takiego zaproszenia skwapliwie skorzystałem bo właśnie wtedy napadła mnie bardzo ważna myśl, jakże utęskniona… Otóż rozwiązanie patowego problemu, który dręczył mnie całe dziecieństwo, że o okresie gołowąsowości nie wspomnę, okazało się bezczelnie proste – stos rurek, rozmieszczonych współosiowo kubek w kubek, uzębionych na końcu, przenosi ruch w oś stawu, na którym nanizana jest adekwatna ilość kół zębatych, a te z kolei, przenoszą napęd dalej... Każda rurka, wraz z przypisanym sobie kołem odpowiada za inną funkcję, której sobie życzymy… Wszelkie ruchliwości mogą być realizowane osobno lub jednocześnie - jednakowoż sterowanie ich jest niezależne, z możliwościami (zaletami i wadami) i precyzją układów zębatych… czyli klasyka mechaniki w nieco odświeżonej, cudacznej formie... Po etapie gazetowym nastąpiła już czysta formalność – zasiadłem do warsztatu, pozbierałem kilka rurek, kilka zębatek wypreparowałem z maszyn, które liczyły czasy słusznie minione… Nad ranem dysponowałem ruchliwą ilustracją mojego pomysłu. Oddam pod łaskawy osąd drogich Forumowiczów, czy to drugie podejście, które nastąpiło po wielu latach rozkmin podprogowych, może osuszyć wcześniejsze łzy… Proszę o słowa możliwie merytoryczne i krytyczne. Oczywistym jest, że rozwiązanie to namieszać może w robotyce jako takiej. Pierwotnie skupiłem się na medycynie bo tam jest najtrudniej i tam też najprędzej nowe rozwiązania powinny trafiać. Nota bene stąd wynikają rozmiary prototypu, który naprędce zmajstrowałem.. Docelowo produkcja tych urządzeń miała być realizowana za pomocą lasera femtosekundowego (popularne dziś stenty, przedmioty o podobnych rozmiarach i klasie dokładności są tak wykonywane). Ja wtedy miałem tylko rękę uzbrojoną w pilnik – stąd żałosna dokładność... Wyzwań, którym trzeba by sprostać jest wiele – opracowanie odpowiedniego modułu zęba (audi ma na koncie niezłą propozycję, co najważniejsze przećwiczoną), wybór materiału (metal, ceramika?), w końcu wybór systemu łożyskowania… Owszem, sporo zabawy! Jednakże śmiem twierdzić, że rozwiązanie jakie pozwoliłem sobie zaproponować pod wieloma względami jest nader atrakcyjne – daje nieznane dotychczas, nowe możliwości. Ochoczo przyjmę wszelkie uargumentowane za i przeciw. Szczególnie będę wdzięczny za wskazanie gdzie takie rozwiązanie w przemyśle już występuje. Przyznam się, że na tamten czas, przeprowadziłem gruntowne poszukiwania przynajmniej śladów podobnych koncepcji, gdyż byłem przekonany, że tak prosty mechanizm musi już gdzieś występować. Dopiero później odnalazłem lakoniczny schemat rysunkowy zamieszczony bodaj na stronie pewnej japońskiej uczelni. Niestety, nie było żadnych zdjęć czy filmu dokumentujących prace badawcze nad tego typu konstrukcją. Życzę owocnych rozmyślań i z góry dziękuję za rozpoczęcie dyskusji! Szczegóły zębatki:

Cześć, jestem samoukiem i szukam małej pomocy. Chcę zbudować prosty samochodzik do omijania przeszkód na trasie od punktu do punktu wykorzystaniem Raspberry Pi oraz lidaru. Nie do końca jednak orientuję się w temacie lidarów. Czy mógłby ktoś mi polecić lidar do 800 złoty, najlepiej obrotowy w miarę przystępną dokumentacją i możliwie gotowymi bibliotekami do użycia? Jednocześnie, jeśli ktoś zna fajne źródła wiedzy na temat lidarów, mógłby mi podlinkować także? Z góry dziękuję wszystkim za pomoc :D

Cześć, jesteśmy grupą studentów, którzy na swój projekt inżynierski postanowili stworzyć niedużego robota sterowanego za pomocą interaktywnej maty. Robot sterowany jest za pomocą sekwencji, które wprowadzamy na wyżej wymienionej macie. Możemy dawać mu proste komendy pozwalające na poruszanie się. Alternatywnym trybem jest jazda swobodna pozwalająca na sterowanie robotem w czasie rzeczywistym. Mata jest urządzeniem posiadającym układ przycisków 4x4 i ekran pokazujący aktualnie wpisywaną sekwencję. Posiadając podstawową wiedzę na temat programowania i elektroniki, będziesz mógł skonstruować taki zestaw sam, w zaciszu swojego domu. Bardziej szczegółowe informacje na temat samego projektu znajdziesz w samym poradniku. Repozytorium jest podzielone na pięć folderów. Dzielą się one na: Kod robota - znajduje się tu gotowy kod, dzięki któremu robot będzie w stanie się poruszać. Kod maty - znajduje się tu gotowy kod, dzięki któremu będziemy w stanie wysyłać komendy z maty do robota. Schemat robota - wymagane pliki do zamówienia płytki pcb do robota. Schemat maty - wymagane pliki do zamówienia płytki pcb do robota. Instruktaż - szczegółowy poradnik zawierający wymagane materiały oraz opis budowy robota i maty. Zalecamy z zapoznaniem się dokładnie z poradnikiem przed próbą konstrukcji. Spis treści znajdziesz w pliku README w folderze "Instruktaż". Powodzenia! Chcielibyśmy tutaj jeszcze dodać, że wykonując projekt trzeba liczyć się z pewnymi wydatkami. Orientacyjne koszty na dzień 16 stycznia 2020: Robot - koszt wszystkich części robota to około 130zł, jeśli kupujemy na botlandzie. Można zmniejszyć koszta kupując części na przykład na aliexpress, jednak wydłuży to czas w jakim części do nas przyjdą. Mata - koszt wszystkich części maty wynosi około 205zł, podobna sytuacja jak z częściami u robota, koszty można zmniejszyć kupując części na przykład z allegro lub aliexpress. Zdjęcia końcowe produktów: Robot Mata Więcej informacji na temat projektu oraz poradnik ze wszystkimi potrzebnymi plikami znajdują się w repozytorium PS. Schemat do robota zostanie jeszcze zaktualizowany w ciągu kilku najbliższych dni, ponieważ wykryliśmy błąd. Mogą również nastąpić mniejsze zmiany w samych opisach.

Researcher jest robotem badawczym przeznaczonym do badania składu gleby oraz powietrza. Robot jest wyposażony w łamane ramię z łyżką przeznaczoną do pobierania próbek gleby oraz umieszczania próbek w specjalnych pojemniczkach wyposażonych w czujniki składu gleby (np. wilgotności, ph). Próbki mogą być pobierane z głębokości 10 cm dzięki zastosowaniu wiertła zamontowanego na siłowniku liniowym o wysuwie 10cm. Za obroty wiertłem jest odpowiedzialny silnik DC. Element wiertniczy jest zamontowany na zawiesie i mocowany na jedną śrubę, ułatwia to transport robota. Za działanie ramienia odpowiedzialne są 4 serwa, ramię jest wykonane z aluminium, dzięki czemu jest wytrzymałe i lekkie. Aby odciążyć serwo odpowiedzialne za obracanie ramieniem zastosowaliśmy płytę przymocowaną do podwozia, poruszają się po niej kułeczka zamocowane do części ruchomej. Konstrukcja robota jest wykonana w całości z aluminium i stali. Obudowa i podstawka pod elektronikę są wykonane z polisterynu. Robot jest w stanie poruszać się po trudnym terenie i wjeżdżać na krawężniki, umożliwia mu to zastosowanie zawieszenia biegunowego dla dwóch przednich osi. Tylna oś jest zamocowana na amortyzatorach. Za ruch silników odpowiedzialnych jest 6 silników DC zamontowanych do płaskowników aluminiowych za pomocą obejm i śrub. W tylnej części zamontowany wspornik mocujący do czujników wiatru. Robot waży około 13 kilogramów i ma 70 cm długości i ok 40 cm szerokości. Za pracę odpowiada moduł Arduino MEGA 2560, w robocie zastosowaliśmy 4 sterowniki silników jednokanałowych po jednym na każdą stronę robota (po 3 silniki do jednego) 2 pozostałem odpowiadają za ruch siłownikiem oraz silnikiem w module wiertniczym. Zastosowaliśmy czujniki temperatury powietrza i gleby, składu powietrza i gleby. Aby nie uszkodzić robota zastosowaliśmy czujniki odległości dzięki którym robot nie wjeżdża w ściany i większe przeszkody. Do komunikacja pomiędzy robotem a aparaturą używamy modułu radiowego. Do sterowania używamy przerobionej aparatury. Znajduje się w niej Arduino UNO, 3 gałki analogowe, wyświetlacz i płytka dotykowa z przyciskami oraz da przełączniki dźwigniowe do zmiany trybu sterowania. Całego robota budowaliśmy około 10 miesięcy w 3 osobowym zespole, uczestniczyliśmy w licznych zawodach m in East Robo, Mikrobot, Explory. Do sukcesów można zaliczyć 4 miejsce w Konkursie El Robo Mech dzięki któremu zdobyliśmy indeksy na studia. Zastosowaniem robota ma być wykorzystywany do badania gleb w miejscach trudno dostępnych oraz jako robot ratunkowy w wypadku skażeń chemicznych i biologicznych. Robot mógłby zbadać glebę i powietrze na terenie skażonym, a dzięki czujnikom kierunku i prędkości wiatru można będzie oszacować przemieszczanie się chmur z zanieczyszczeniem. Operator robota może odczytywać dane z czujników z wyświetlacza na kontrolerze oraz mieć podgląd z kamery umieszczonej na robocie.

Dzień dobry, po przeczytaniu książki "Budowa robotów dla początkujących" chciałbym skonstruować robota zawartego w tej książce i jestem obecnie na etapie kompletowania podzespołów jednak nie wiem jaki tranzystor dobrać. Silniki będą zasilane przez koszyk baterii mieszczący 4 szt. baterii AA co daje minimum 6V. Moje propozycje silników: 1. https://botland.com.pl/pl/silniki-dc-katowe-z-przekladnia/2490-silnik-dc-dagu-dg01d-l-481-45v-z-podwojnym-walem-2szt-6952581600930.html 2. https://botland.com.pl/pl/silniki-dc-katowe-z-przekladnia/121-silnik-dc-1201-120rpm-katowy.html Zgodnie z treścią książki w linefolowerze komparator będzie przełączał tranzystor który będzie połączony z silnikiem. Jaki tranzystor dobrać by tranzystor wytrzymał prąd startu i obciążenia silnika? Czy uwzględniać też prąd przy zatrzymanym wale?

Witam Jestem bardziej niż początkującym w tematach mikrokontrolerów i elektroniki, więc proszę o wyrozumiałość. Od jakiegoś czasu planuje zrobić robota wykorzystującego czujnik ultradźwiękowy (między innymi) do mapowania terenu. Ale dopiero od paru dni zacząłem szperać i czytać jak to zrobić krok po kroku. Ha. Nawet znalazłem coś podobnego na forum https://forbot.pl/forum/topic/11454-prosty-ultradzwiekowy-skaner-otoczenia-2d-360-stopni/ Rozbiłem się już na początkowych pytaniach, ale w tym temacie chciałbym zapytać konkretnie o jeden z nich: 1. Mianowicie jeżeli mam już arduino (z kursu arduino, który do teraz zbierał u mnie kurz) to co mi jest potrzebne prócz serwa pracy ciągłej do zbudowania obrotowej wieżyczki na której będą zamontowane czujniki ultradźwiękowe? Rozumiem, że zależy od serwa, ale łączy się je przez shieldy, albo tworzy się jakieś układy, albo zasila niezależnie od arduino? Czy to przez pobór prądu? 2. Czy dostępne w różnych sklepach ( botland, kamami) shieldy do silników obsłużą też serwo? Czy muszę mieć konkretnie shield ze sterownikiem serw? 3. Czy jeżeli servo będzie miało duży pobór prądu to nie zakłóci w jakiś sposób pracy czujników? Wiem, że pytania banalne, ale może Panowie potraficie mnie choć naprowadzić na trop. Sam w miarę czasu i możliwości w chwilach wolnych od roboty staram się szperać po książkach i necie, ale temat niby prosty a jednak masę wiedzy należy sobie gdzieś ze szkoły przypomnieć, a większości przypadków od zera się uczyć.

Witam mam problem z kompilacją gdyż wyskakuje mi taki błąd i nie wiem czemu tak się dzieje. Pomoże ktoś ? #include <Ultrasonic.h> // definicje dla HCSR04 #define TRIGGER_PIN 7 #define ECHO_PIN 4 Ultrasonic ultrasonic(TRIGGER_PIN, ECHO_PIN); // silnik lewy const int kierunekLewy=12; const int hamulecLewy=9; const int predkoscLewy=3; //silnik prawy const int kierunekPrawy=13; const int hamulecPrawy=8; const int predkoscPrawy=11; //ustawienia void setup() { Serial.begin(9600); pinMode(kierunekLewy,OUTPUT); pinMode(kierunekPrawy,OUTPUT); pinMode(hamulecLewy,OUTPUT); pinMode(hamulecPrawy,OUTPUT); pinMode(predkoscLewy,OUTPUT); pinMode(predkoscPrawy,OUTPUT); } //petla glowna programu void loop() { float cmMsec; long microsec = ultrasonic.timing(); cmMsec = ultrasonic.convert(microsec, Ultrasonic::CM); doPrzodu(); delay(50); if (cmMsec<=30) { doTylu(); delay(500); } } void doPrzodu() { analogWrite(predkoscLewy,100); analogWrite(predkoscPrawy,105); //Lewy do przodu digitalWrite(kierunekLewy,HIGH); digitalWrite(hamulecLewy,LOW); //Prawy do przodu digitalWrite(kierunekPrawy,HIGH); digitalWrite(hamulecPrawy,LOW); } void doTylu() { analogWrite(predkoscLewy,200); analogWrite(predkoscPrawy,0); //Lewy do przodu digitalWrite(kierunekLewy,LOW); digitalWrite(hamulecLewy,LOW); //Prawy stop digitalWrite(kierunekPrawy,HIGH); digitalWrite(hamulecPrawy,HIGH); }

Cześć! Zakładam, że skoro czytasz ten wpis to zapewne interesuje Ciebie elektronika/robotyka/majsterkowanie i zastanawiasz się jak skonstruować swojego robota. A może szukasz inspiracji? Motywacji do dalszego działania? Jeżeli odpowiedź brzmi tak, to zapraszam Ciebie do przeczytania mojego wpisu. Traktuje on o moim pierwszym elektronicznym projekcie - linefollowerze o wdzięcznym imieniu Ianush88. Wpis podzieliłem na poszczególne fragmenty tak, abyś łatwo trafił do sekcji które Ciebie interesują najbardziej. Początek każdego z nich będzie oznaczony pogrubionym tekstem. To tyle jeżeli chodzi o wstęp, zapraszam do lektury! Ważna uwaga: Ze względu na fakt, że jest to mój pierwszy projekt i ma dla mnie głównie charakter edukacyjny w wielu przypadkach zdecydowałem się na wybór prostych rozwiązań, które o wiele łatwiej zaimplementować i ewentualnie naprawić. Nad optymalizacją konstrukcji postanowiłem się skupić w ewentualnej przyszłej ewolucji tego projektu. Konstrukcja & mechanika Ianush88 to klasyczny przedstawiciel rodziny linefollower - składa się z dwóch płytek PCB połączonych ze sobą dwoma kątownikami z tworzywa sztucznego. Do głównej (większej) płytki PCB przymocowane są silniki prądu stałego Pololu HP z przekładnią 10:1 - standardowy wybór zdecydowanej większości konstruktorów linefollowerów ze względu na optymalny balans między maksymalną prędkością obrotową (3000 obr/min) a generowanym momentem (0,22 kg*cm). Do wałów silników zamocowane są koła Solarbotics RW2 - wybrałem je głównie ze względu na ich bezproblemową dostępność i łatwość w połączeniu z całą konstrukcją. Muszę przyznać, że odpowiednio wyczyszczone generują całkiem sporo przyczepności. Niestety nie mam porównania z oponami mini-z czy odlewanymi z silikonu, ale jestem z nich zadowolony. Przednia płytka PCB zawierająca czujniki linii opiera się na podłożu przy pomocy dwóch tranzystorów THT w obudowie TO-92. Ich nóżki przylutowałem do płytki a obudowy przetarłem lekko papierem ściernym tak, by swoimi krawędziami nie zahaczały o nierówności trasy. Elektronika Robot zasilany jest z akumulatora 2S 7.4V (korzystam z trzech o różnych wartościach pojemności: 150mAh, 250mAh i 800mAh). Napięcie z akumulatora jest stabilizowane i obniżane do 5V przez stabilizator napięcia LM1117. Mózgiem całej konstrukcji jest Atmega16A - wybrana przeze mnie ze względu na moją znajomość tej rodziny mikrokontrolerów. Taktowana jest przez sygnał z kwarcu o częstotliwości 16MHz. Posiada istotne ze względu na projekt peryferia: ośmiokanałowy, 10 - bitowy przetwornik ADC, UART do komunikacji z zewnętrznym urządzeniem oraz trzy timery. Każdy z ośmiu kanałów przetwornika został wykorzystany do pomiarów napięcia z kolektorów czujników odbiciowych KTIR0711S. Znajdują się one na wysuniętej z przodu płytce PCB, umiejscowione symetrycznie po obu stronach. Sygnały między płytkami przekazywane są przy pomocy taśmy i złącz FFC. Timer 1 wykorzystałem do generowania dwóch sygnałów PWM sterujących prędkością każdego z silników. Doprowadzone są one do sterownika silników TB6612FNG, który jest układem z dwoma klasycznymi mostkami H. Do wejść UARTu mikrokontrolera poprowadzone są ścieżki ze złącza goldpin, do którego podłączony jest moduł bluetooth HC-05. Wraz z UART wykorzystuje go do komunikacji między robotem a telefonem lub komputerem. Na głównej płytce znajduje się także 6 - pinowe złącze ISP służące do programowania mikrokontrolera oraz przycisk który można dowolnie zaprogramować (ja używam go do ręcznego startowania/zatrzymywania robota). Dodatkowo na głównej płytce PCB umieściłem 8 LEDów prezentujących wskazania poszczególnych czujników odbiciowych. Całość została zaprojektowana przy użyciu oprogramowania Altium Designer. Obie płytki PCB są jednostronne i rozstawienie wszystkich elementów wraz z ich połączeniem było ogromnym wyzwaniem, co jednak udało się osiągnąć (ostatecznie skorzystałem z tylko jednej "przelotki"). Na płytce z czujnikami widoczne są przeróbki w postaci dolutowanych przewodów - jest to efekt złego zaprojektowania płytki i pośpiechu w przygotowaniach do zawodów... Program Do sterowania robotem zaimplementowałem regulator PD. Wartością zadaną jest w tym przypadku położenie czarnej linii względem robota, a sterowaniem wartości wypełnienia sygnału PWM dla poszczególnych silników. Uchyb wyliczany jest na podstawie pomiarów napięcia na kolektorach poszczególnych czujników odbiciowych. Gdy napięcie przekroczy pewną wartość graniczną, przy której uznajemy, że pod czujnikiem znajduje się już czarna linia do uchybu dodawana jest konkretna wartość błędu. Każdy czujnik ma przypisaną swoją "wagę" i przy każdej iteracji regulatora wyznaczany jest średni błąd, a następnie uchyb i sterowanie. Do regulatora PD dorzuciłem pewne wyjątki, które obsługują takie przypadki jak np. zgubienie linii tak, by robot potrafił na nią z powrotem trafić. Mogę tutaj polecić artykuł "Algorytm linefollowera w C – dla początkujących i nie tylko" , który całkiem dobrze opisuje jak zaimplementować regulator pd do robota typu linefollower. Do zmiany ustawień robota, w tym nastaw regulatora przygotowałem aplikację przy pomocy narzędzia MIT App Inventor. Dobrze jego obsługę prezentuje artykuł: "Tworzenie aplikacji Android". Do komunikacji przygotowałem swój własny protokół o określonej ramce danych. Wprowadzanie danych i naciśnięcie odpowiedniego przycisku powoduje wysłanie wiadomości o konkretnej budowie i zawartości do mikrokontrolera, który ją przetwarza i zmienia wartości odpowiednich parametrów. Przemyślenia Już zaprojektowałem nową płytkę czujników, tym razem mam nadzieję że poprawnie. Teraz będą ustawione zdecydowanie bliżej siebie, ponieważ chcę żeby robot szybciej mógł reagować na zmiany trasy. W przyszłym projekcie na pewno skorzystam już z płytek dwustronnych, co pozwoli na gęstsze upakowanie elektroniki, a co za tym idzie zmniejszenie gabarytów i masy robota. A mniejsza masa = lepsze osiągi. Plus brak problemów z połączeniem wszystkich komponentów. Dostrzegłem także, że kluczową sprawą jest przyczepność mechaniczna - nawet gdy silniki mają duży moment i prędkość obrotową bez przyczepności nie przekłada się to na lepsze wyniki. Dlatego planuję w przyszłości wykorzystanie opon mini-z lub odlewanych z silikonu. Na pewno dojdzie także wykorzystanie enkoderów do pomiarów prędkości obrotowych silników i implementacja regualtorów PID dla silników. Pozwoli to na płynną regulację prędkościami i w konsekwencji mniejszą ilością uślizgów kół. Myślę także o ulepszeniu regulatora dla całego robota, sprawdzeniu kilku ciekawych rozwiązań. To już koniec! Jeżeli masz pytania lub zainteresował Ciebie jakiś temat poruszony w tym wpisie to daj mi znać w komentarzu! Powodzenia przy tworzeniu nowych konstrukcji!