Skocz do zawartości

Tablica liderów


Popularna zawartość

Pokazuje zawartość z najwyższą reputacją od 09.02.2011 we wszystkich miejscach

  1. 34 punktów
    Przedstawiamy naszego Line Followera o nazwie Impact. Projekt robota powstał w tegoroczne wakacje, a pierwszy start miał miejsce na zawodach Sumo Challenge 2011 w Łodzi. A teraz kilka słów o samej konstrukcji. Elektronika Robotem steruje mikrokontroler firmy Atmel z rodziny AVR ATmega128A . Rolę sterowników silników, podobnie jak w naszych poprzednich konstrukcjach pełnią dwukanałowe mostki H TB6612 . Po jednym mostku na jeden silnik (kanały zostały połączone w celu uzyskania większej wydajności prądowej). Silnikiem bezszczotkowym znajdującym się w napędzie tunelowym steruje gotowy moduł zakupiony w sklepie HK. Regulatorem napięcia jest układ przetwornicy step-down (ST1S10PHR) . Stabilizatory impulsowe charakteryzują się wyższą sprawnością niż ich liniowe odpowiedniki. Do wykrywania linii użyte zostały czujniki KTIR0711S (15 czujników ułożonym po okręgu oraz dwa wysunięte do przodu i dwa do tyłu po bokach). Analogowy sygnał z sensorów zamieniany jest na cyfrowy przy użyciu komparatorów LM339 następnie podawany na piny mikrokontrolera. Na płytce z czujnikami umieszczony został także czujnik odległości. Do komunikacji z modułem LCD oraz komputerem został wyprowadzony interfejs UART, który jest również złączem do programowania mikrokontrolera. Pozwoliło to zaoszczędzić miejsce na płytce oraz ilość wyprowadzeń mikrokontrolera. Drugi mikrokontroler wraz z odbiornikiem podczerwieni, służące do dekodowania sygnału z pilota (RC5) znajdują się na płytce, która tworzy most łączący czujniki z płyta główna. Zostało na niej także przewidziane miejsce na żyroskop. PCB wykonane w firmie Satland Prototype. Mechanika Konstrukcja oparta jest na laminacie, dodatkowo do łączenia czujników z płytką główną wykorzystane zostały listwy węglowe. Robot napędzany jest przez dwa silniki Pololu HP 10:1. W celu uzyskania dodatkowego docisku zastosowana została turbina z silnikiem bezszczotykowym - EDF27. Koła składają się z felg wytoczonych z poliamidu oraz opon Mini-Z. Płytka z czujnikami podparta została przez dwa Ball Castery 3/8". Konstrukcja wraz z baterią waży ok. 140g. Zasilanie i soft Całość zasilana jest z pakietu Li-Pol 2S 7,4V, jego poziom kontrolowany jest przez ADC oraz wyświetlany na LCD. Program został napisany w języku C. Do sterownia wykorzystywany jest algorytm PD. Regulator silnika bezszczotkowego obsługuje się w sposób bardzo podobny do obsługi serw modelarskich (f=50Hz, regulacja obrotów w zakresie 1-2 ms). Wszystkie ważne parametry są wyświetlane oraz ustawiane (zapisywane w pamięci EEPROM) przy pomocy modułu wyświetlacza LCD wyposażonego w 4 przyciski. Osiągnięcia 3. miejsce - Sumo Challenge 2011 Łódź - Line Follower 2. czas - Sumo Challenge 2011 Łódź - Line Follower z przeszkodami (poza konkurencją) 2. miejsce - ASTOR Robot Challenge - Line Follower 3. miejsce – Robotic Arena 2011 – Line Follower Zdjęcia Kilka zdjęć wykonanych z pomocą mikroskopu: Filmy https://www.youtube.com/watch?v=wydRW_vmjWUhttps://www.youtube.com/watch?v=RDJmhSkCdxc
  2. 26 punktów
    Rapid jest moją drugą konstrukcją micromouse. Zawiera ona kilka poprawek względem pierwszej (robot Wariat), z których najważniejszą jest użycie żyroskopu. Konstrukcja mechaniczna i zasilanie Robot zbudowany jest na płytce PCB, która stanowi jego podwozie. Założeniem projektu było uzyskanie nisko położonego środka cieżkości oraz jak najmniejszej masy. Dodatkowym atutem robota miała być jego mała szerokość, która pozwalałaby na poruszanie się po "skosie". Napędem robota są silniki Pololu 10:1 sterowane przez dwa mostki TB6612. Jako zasilanie wykorzystywane są akumulatory litowo-polimerowe o jak najmniejszym rozmiarze i niewielkiej masie. Z powodu małych pojemności konieczna jest częsta wymiana i ładowanie pakietów. W robocie używane są różne pakiety, różnych producentów. Mikrokontroler Sercem robota jest mikrokontroler STM32F405RGT6. O wyborze zdecydowała chęć nauki programowania mikrokontrolerów STM32 z najpotężniejszym rdzeniem Cortex-M4F oraz najmniejsza obudowa spośród wszystich procesorów rodziny STM32F4. Najważniejszymi cechami mikrokontrolera są: taktowanie 168MHz, 192kB RAM, 1MB flash, bardzo duża liczba timerów (m.in. ze sprzętową obsługą PWM oraz wyjść kwadraturowych enkoderów), wiele kanałów przetwornika ADC, DMA, sprzętowa obsługa liczb zmiennoprzecinkowych, wiele dostępnych interfejsów komunikacyjnych. Czujniki W robocie wykorzystano trzy rodzaje czujników: dalmierze optyczne, enkodery oraz żyroskop. Jako czujniki odległości wykorzystano diody SFH4511 oraz fototranzystory TEFT4300 (podłączenie takie samo jak w przypadku robota MIN7 autorstwa Ng Beng Kiat). Diody są sterowane impulsowo, każda z osobna. Wybranym żyroskopem jest analogowy czujnik ISZ-650 firmy Invensense. Jego zakres pomiarowy to +-2000st/s. O jego wyborze zdecydowała głównie dostępność i cena podczas zakupu. Podczas testów robota uszkodzono sensor, dlatego konieczna była wymiana. Zdecydowano się na moduł z żyroskopem L3GD20. Do podłączenia wykorzystano miejsce na wyświetlacz N3310 wraz z wyprowadzonym interfejsem SPI. Zamontowanie enkoderów obrotowych z magnesami na osiach silników powodowałoby poszerzenie całej konstrucji, więc zdecydowano się na użycie enkoderów liniowych wraz z odpowiednimi magnesami. Wykorzystane enkodery AS5304 oraz zamocowane magnesy na kołach robota przedstawiono na rysunkach poniżej. Użyte enkodery pozwalają uzyskać rozdzielczość 3520 impulsów na obrót koła, co daje w wyniku 0.028 mm/impuls. Interfejs użytkownika Założeniem projektu było wykorzystanie joysticka oraz wyświetlacza z telefonu Nokia 3310. Obecnie oprogramowanie nie zawiera obsługi wyświetlacza, dlatego nie jest on zamontowany. Do wyboru prostych komend służy joystick oraz zamontowany buzzer. Buzzer służy także jako powiadomienie o charakterystycznych sytuacjach w labiryncie, np. wykrycie ścianki, dojechanie do środka labiryntu. Oprogramowanie Program opiera się o cykliczne wywoływanie funkcji z częstotliwością 1kHz. W funkcji tej wykonywane są pomiary czujników, aktualizowana jest pozycja robota oraz wyliczane są wartości współczynnika wypełnienia PWM na silniki. Robot posiada trapezoidalny profil sterowania prędkością. Implementacja i zasada działania jest bardzo podobna jak w artykule [Programowanie] Sterowanie robotem mobilnym klasy (2,0). Przeszukiwanie robota odbywa się z użyciem algorytmu floodfill. Po znalezieniu środka labiryntu, robot rozpoczyna wyznaczanie najszybszej ścieżki. Do tego celu użyto zmodyfikowanego algorytmu floodfill, którego wagami jest czas przejazdu. Podsumowanie Robot Rapid zachowuje się w labiryncie dosyć stabilnie i przewidywalnie. Jest to bardzo ważna cecha, ponieważ pozwala na dalszą pracę nad konstrukcją oraz rozwijanie oprogramowania. Pomysłów na poprawienie działania robota jest wiele. Ograniczeniem jest jedynie poświęcony temu czas. Galeria Osiągnięcia I miejsce w kategorii Micromouse na zawodach Robotic Arena 2012 II miejsce w kategorii Micromouse na zawodach Robomaticon 2013 I miejsce w kategorii Micromouse na zawodach Trójmiejski Turniej Robotów 2013 I miejsce w kategorii Micromouse na zawodach ROBO~motion 2013
  3. 24 punktów
    Witam Chciałbym przedstawić wam robota Silver Shaft klasy line follower (nazywany też SS skrót powstał podczas bardziej luźnych rozmów na chacie ). Postęp prac można było śledzić w worklogu. Prace nad robotem zacząłem w sierpniu 2011 roku, później prace mocno spowolniły z powodu braku czasu. Od połowy lutego tego roku wziąłem się do pracy zrobiłem płytkę, którą już wcześniej zaprojektowałem, polutowałem, napisałem pierwszą wersję programu i przeprowadziłem pierwsze próby. W marcu wystartował w zawodach Robomaticon zajmując 13 miejsce, co i tak było sukcesem jak na 3 dni (a właściwie popołudnia) na napisanie programu od podstaw i przeprowadzenie pierwszych prób. Szczerze mówiąc robot zaczął przyzwoicie jeździć w dzień zawodów ok.2 w nocy . Od tego czasu wprowadziłem kilka modyfikacji, zarówno sprzętowych jak i programowych. Kończąc wstęp, przejdźmy do konkretów. SPECYFIKACJA Wymiary: 120x80x32mm Waga samego robota: 75g Waga robota z akumulatorkiem: 86g Średni pobór prądu logiki: 130mA Średni pobór prądu logiki bez czujników linii: 45mA Coś dla miłośników anaglifów: Proces lutowania: MECHANIKA Konstrukcja mechaniczna jest bardzo prosta i powiedziałbym typowa dla robotów tej klasy. Robot składa się z trzech płytek drukowanych, głównej, płytki z czujnikami linii i z cyfrowym dalmierzem. Płyta główna ma 1,5mm grubości, pozostałe są jednostronne i mają grubość 0,8mm. Płyta główna jest jednocześnie podwoziem robota. Wykonanie płytki głównej zajęło mi dużo czasu z powodu złych ustawień drukarki (Pierwsza płytka dwustronna na nowej drukarce). Po zmianie ustawień i zmarnowaniu 3 płytek wielkości robota, płyta główna wyszła idealnie, bez żadnych zerwanych ścieżek i tylko z jednym, w sumie nieistotnym zwarciem przy podświetleniu led, oraz przesunięciem między warstwami <0,5mm, które jak na trzecią dwuwarstwówkę było i tak niewielkie. Napęd robota stanowią dwa silniczki pololu HP z przekładnią 30:1 wraz ze standardowymi kołami 32mm. i mocowaniami, które swoją drogą były kompletnym niewypałem (łącznie złamały się 8 razy, za każdym razem w innym miejscu). Rolę podpory przodu stanowi plastikowa kulka 3/8 cala. MONTAŻ Płytka została pocynowana „mechaniczne”, własnej roboty pasta + tasiemka odsysająca + trochę cyny i wprawy. Większość elementów typu rezystory, czy kondensatory są w obudowach 0805, wyjątek stanowią 4 rezystory 330R ograniczające prąd diod Ir w transoptorach. Pierwotnie były tam rezystorki o mniejszej wartości, jednak z powodu grzania się KTIR’ów zostały wymienione, a jako, że nie miałem odpowiedniej ilości w 0805, zostały zastąpione większymi wersjami 1206. Całość polutowana grotówką. Płytka z czujnikami została zamontowana na stałe i trzyma się na listwie goldpin, która jednocześnie stanowi połączenie elektryczne między nią a płytą główną. ZASILANIE Całego robota zasila pakiet Li-Pol 2s zlutowany z dwóch pojedynczych ogniw 450mAh firmy Batimex. Tu chciałem zaznaczyć, że wiem o istnieniu pakietów 2s. Złożyłem je sam, ponieważ potrzebowałem pakietu o nietypowych wymiarach, a nie miałem czasu na zamawianie w HK. Logika zasilana ze stabilizatora LM1117 na 5V, silniki z przetwornicy ST1S10PHR ustawionej na 6V, lub bezpośrednio z pakietu (wybór zworką). W tylnej części płytki mieści się wyłącznik zasilania z sygnalizacją włączenia i układ pomiaru baterii z diodą led informującą o spadku napięcia poniżej ok.6,6v – wtedy to na wyjściu przetwornicy napięcie zaczyna spadać poniżej 6v. Akumulator starcza na ok. 15-20 min testów. ELEKTRONIKA Schemat i wzór pcb eksportowany z programu EAGLE. Mózgiem robota jest ATMega32 taktowana zegarem 16MHz. Rolę czujników linii stanowi 8 transoptorów odbiciowych KTIR0711S, odczyt na wbudowanym w atmege adc.Tu muszę zaznaczyć, że trafiłem na wadliwą sztukę KTIR’a miał lekko zdeformowane „szybki” pod diodą Ir i fototranzystorem, i dawał zawyżone wartości (ok. 150 więcej 10 bitowego adc) mała korekta w programie zniwelowała rozbieżności, niemniej uważam, że czujniki są świetne. Sterowanie silnikami odbywa się za pomocą mostka H TB6612 jeden na oba silniki. Pwm o częstotliwości trochę ponad 7Khz. Na przodzie robota znajduje się zamontowany stosunkowo niedawno dalmierz cyfrowy sharp 10 cm GP2Y0D810Z0F. Nie spotkałem się z nim w żadnym innym lf’ie. Przyznam, że wątpiłem w jego praktyczną użyteczność, okazało się jednak, że robot jest w stanie wyhamować z pełnej prędkości w ok. 2-3cm, a czujnik działa na tyle szybko, że mam jeszcze spory zapas przed przeszkodą. Czujnik może pełnić dwie funkcje (wybierane zworką). Chamowanie i wznowienie jazdy dopiero po usunięciu przeszkody, lub omijanie jej. Dzięki temu, robot może startować w konkurencji line follower z przeszkodami. Do komunikacji użytkownik – robot, zamontowane zostały dwie diody led, dwa przyciski, odbiornik Ir TSOP4836, oraz złącze 10 pinowe na którym poza wyprowadzeniem zasilania i spi do programowania jest I2C i uart, umożliwiające podpięcie dodatkowych modułów (w tej kwestii wypowiem się, gdy napiszę i opublikuje pewien artykuł ) PROGRAM Program napisany w Bascomie, na dzień dzisiejszy zawiera nieco ponad 600 linijek kodu i jest to 6 wersja programu, zajmuje 10% z 32KB pamięci Flash. Program można podzielić na dwie główne części: 1.Część odpowiedzialną za jazdę a.Sprawdzenie stanu dalmierza b.Odczyt analogowy z czujników linii c.Konwersja wartości analogowych na binarne d.Wyliczenie położenia linii metodą średniej e.Przekazanie uchybu regulatorom f.Naniesienie korekty pwm na silniki 2.Część serwisowa a.Wyłączenie podświetlenia, wprowadzenie mostka w stan stanby b.Wysłanie zapytania i oczekiwania na odpowiedź po uart z aplikacji PC c.W razie braku odpowiedzi, przejście do trybu konsolowego d.Oczekiwanie na id zmiennej i jej wartości e.Zapis nowej wartości zmiennej do pamięci Regulator Proporcjonalno Różniczkujący, z czego człon D wymaga jeszcze dopieszczenia. Pojawił się już w 2 wersji programu, jednak do niedawna bardziej przeszkadzał, niż pomagał, dlatego podczas większości testów był wyłączany. Aktualizacje w kolejnych wersjach: 1.-; 2.Dodanie regulatora D, trybu serwisowego, odliczania przed startem, 3.Naprawienie błędu uniemożliwiającego pokonanie kąta prostego, efekty led przy starcie i zatrzymywaniu 4.Dodanie obsługi dalmierza 5.okiełznanie D, dynamiczne omijanie przeszkód, 6.poprawa wydajności programu - uproszczenie liczenia uchybu, integracja z programem PC w planach: Ulepszenie D, rozwinięcie możliwości komunikacji z PC, płynne i łatwo regulowane omijanie przeszkód, optymalizacja kodu oraz coś o czym dowiecie się przy publikacji artykułu OSIĄGNIĘCIA 13 Miejsce na Robomaticonie 2012 w kategorii Line Follower. Kilka zdjęć i filmików z robotem. Silver Shaft na starszym bracie "drewnobocie" Ok godziny po pierwszej jeździe z czujnikami: 3 dni później: Jazda próbna na torze Robomaticonu w Warszawie: Jedna z ostatnich jazd: Tor w wersji z przeszkodami- przy drugim okrążeniu lekko zawadził o przeszkodę, ale wielkość łuku była podyktowana wielkościami pierwszej trasy, i jest "na styk": (nagrywał sosnus) PODZIĘKOWANIA Dziękuję wszystkim, którzy przedstawili sugestię i krytykę, w worklogu. W szczególności Sabre, oraz jego robotowi Tsubame, który był poniekąd inspiracją dla tego lf'a. Dziękuję osobom z chatu za pomoc w mniejszych problemach, np. grzanie się ktirów, czy problem z komunikacją po spi, przede wszystkim bobb'iemu i KD93. Dziękuję Turlaczowi za "troskę" i codzienne pytanie "jak tam SS?" Dziękuję Sosnusowi, za pomoc w teoretycznych aspektach dokładności liczenia uchybu, wspólne testowanie robota i zmian w programie, oraz mile spędzony weekend. Czekam na słowa krytyki, oceny i pytania. Dziękuję
  4. 21 punktów
    Przedstawiam robota typu linefollower, którego razem z kolegą wykonaliśmy w ramach projektu "Roboty mobilne" na PWr. Cechą odróżniającą go od innych konstrukcji tego typu jest możliwość zapamiętywania trasy. Robot wykonuje pierwszy przejazd ze stosunkowo wolną prędkością i dla każdego punktu trasy oblicza maksymalną możliwą prędkość, która pozwoli na przejazd bez poślizgu. Wiedza ta jest używana w celu zoptymalizowania czasu przejazdu podczas drugiego pokonywania trasy. Sercem robota jest mikrokontroler STM32F103RBT6. Do napędu służą silniki Pololu 10:1 HP (przy okazji - są beznadziejne) wspomagane enkoderami AS5040. Do wykrywania linii przewidziano 12 czujników KTIR, przy czym aktualnie używanych jest 8 (resztę przyjarałem hotem podczas lutowania i nie działają ). Napięcie 3,3V dla logiki pochodzi z przetwornicy MCP16301, natomiast silniki są zasilane bezpośrednio z akumulatora poprzez mostek MC33932. Oprócz tego na płytce zainstalowany jest akcelerometr/żyroskop MPU6050 (aktualnie niewykorzystany), 4 ledy, 3 przyciski oraz wyprowadzone złącza UART i SPI (dla modułu radiowego NRF24L01). Algorytm sterowana obejmuje regulatory PID dla prawego i lewego koła oraz regulator PID dla rotacji. Wartość translacji jest ustalana na sztywno lub jest uzależniona od aktualnego położenia robota na trasie (w przypadku drugiego przejazdu). Jazda ze sztywno zadaną prędkością, zdaje się 1,8m/s Zapamiętywanie trasy (film zawiera lokowanie produktu) Jeśli chodzi o robota to jestem bardzo pozytywnie zaskoczony działaniem zapamiętywania trasy. Do zrobienia pozostało uwzględnianie przyspieszeń liniowych przy wyznaczaniu profilu przejazdu, gdyż aktualnie obliczane jest tylko przyspieszenie dośrodkowe. Głównym problemem przy konstrukcji robota były notorycznie palące się silniki. Dwa spaliły się całkowicie, w jednym wytarła się zębatka, a szczotki były wymieniane chyba z pięć razy. W następnych konstrukcjach mam zamiar używać tylko silników BLDC. edit: Schemat Layout płytki głownej bom.txt
  5. 19 punktów
    Infinitum to trzeci robot w mojej karierze i najlepszy jaki udało mi się zbudować do tej pory. Robot powstawał stosunkowo długo (ponieważ w tym roku matura), jednak najwięcej do zrobienia było przed RoboticArena 2011, gdy na PCB wkradł się błąd, który oczywiście został usunięty. Robot powstawał przy współpracy z firmą Woszym , która zajmuje się montażem obwodów drukowanych. Również pomogli w krytycznej sytuacji. Elektronika: Standardowo użyłem mikrokontrolera firmy atmel- Atmega16, mostki to dwa TB6612, stabilizator L7805 wersji SMD, za oczy robią cyfrowe Sharpy GP2Y0D340K, komparator LM339D oraz KTIR0711S plus pozostałe drobne elementy. Robota wyposażyłem w LCD 8x2- jednym się ten pomysł podobał, innym nie, ale ja jestem zadowolony bo spełnił swoją funkcję- można sprawdzić aktualny stan aku, ustawić PWM jak i zobaczyć, za ile zacznie się walka Program: Program powstał w środowisku eclipse, napisany został w C, którego się dopiero zacząłem uczyć, więc jest to pierwszy mój program w tym języku. Nie wiedziałem, że jest taki fajny. W robocie jest przewijane menu, które obsługuje się trzema przyciskami - jeden enter, a dwa pozostałem służą do przewijania. Żeby wyjść do głównego menu trzeba przytrzymać te dwa przyciski do przewijania przez 3s. Mechanika: Obudowa Infinitum została wcięta z aluminium i profesjonalnie polakierowana przez lakiernika. Po walkach odprysków praktycznie nie ma więc się postarał . Silniki to HP 50:1 z pololu. Robot na zawodach ważył około 375g. Podsumowanie: Jak wspominałem jestem z niego bardzo zadowolony-udało się wyjść z grupy na RA11! Dla ciekawych nazwa wzięła się stąd, że były roboty Inferno i Mefisto to stwierdziłem, że musi być coś anty(w Google translator można sprawdzić ). Konstrukcja ma tylko 3 minusy: przyczepność, ilość śrubek i umiejscowienie włącznika – przy następnych konstrukcjach zwrócę na to większą uwagę . Filmiki: Znajdują się tu niektóre z wygranych walk https://www.youtube.com/watch?v=uGfYsFS2aMw
  6. 17 punktów
    Przedstawiam Wam robota „Rush” klasy minisumo. Prace nad nim rozpocząłem w listopadzie w 2012r. i po ok. 5 miesiącach konstrukcja była gotowa. Pierwszym turniejem robota miał być Robomaticon, lecz z powodu awarii silnika nie mogłem wystartować. A teraz kilka słów o nim... Elektronika Całość elektroniki znajduje się na jednej płytce, która stanowi jednocześnie podstawę konstrukcji. Mózgiem robota jest procesor Atmega32 o taktowaniu zewnętrznym 16MHz. Jako czujnik przeciwnika wykorzystane zostały czujniki cyfrowe Sharp o zasięgu 40cm, ułożone w półokręgu, jeden patrzący w przód, dwa pod kątem 45° i 2 patrzące na boki. Do wykrywania linii służą cztery KTIRy, dwa z przodu i dwa z tyłu, podłączone do procesora przez komparator. Do zatrzymywania robota służy odbiornik TSOP. Sterowaniem silników zajmują się dwa mostki TB6612, po jednym na silnik. Robot zasilany jest z pakietu Li-pol 2S 700mAh. Płytka została wykonana w firmie Satland Prototype. Mechanika Podstawą konstrukcji jest płytka z elektroniką o grubości 1,5mm, do której przymocowane są silniki i metalowa obudowa. Robot napędzany jest dwoma silnikami Pololu HP 30:1. Koła składają się z felg wykonanych metodą druku 3D oraz opon odlanych z silikonu. Robot waży 470g. Program Program napisany został w bascomie. Robotem steruje regulator P. Osiągnięcia 3. miejsce – ROBO~motion 2013 Rzeszów Podsumowanie Ogólnie jestem zadowolony z konstrukcji, choć zawiera ona kilka niedociągnięć. Założenia zostały spełnione, nabrałem nowego doświadczenia, które na pewno przyda się przy budowie kolejnego robota. Zapraszam do zadawania pytań. Zdjęcia Filmiki (po więcej filmików zapraszam na kanał)
  7. 15 punktów
    Witam. Po dłuższym czasie mojej nieobecności na forum postanawiam przedstawić mojego (z kilku na które przyjdzie czas by je zaprezentować ) robota. Zwie się on FRodo i jest robotem o niekonwencjonalnej budowie. Strona techniczna FRodo posiada przekładnię Tamiya i gąsienice pololu. Mimo tak słabego napędu robot mało co nie rwie gruntu dzięki ustawieniu go na najmniejsze przełożenie i dołożenie mu mocniejszych silników. Podwozie to płyta główna na której znalazły się tradycyjne mostki L293Dx2, sharp 340K oraz atmega32. Brakuje tam czujnika odbiciowego ale to sprawia że robot niczego się nie boi. Nad podwoziem znajduje się owa przekładnia ,bateria(500mAh) ,trochę ołowiu i coś czego jeszcze nie było w żadnej maszynie czyli podnośnik. Znajduje się tam także 3-kierunkowy przełącznik z cd-roma do wcześniejszego wpisania do pamięci gdzie znajduje się przeciwnik. Podnośnik i wola powstania Siedząc raz na lekcji wpadłem na pomysł jak przeważyć na przeciwnikiem przy użyciu serwa i kawałka laminatu. Wykonałem na szybko płytę główną. Ze złomu znalezionego z rozebranych starych robotów zmontowałem nowe podwozie o wysokości 3,5cm i zainstalowałem serwo po czym doczepiłem do niego kawałek laminatu.Tak oto powstał FRodo wtedy jeszcze figurujący pod nazwą player1. Po kłopotach z silnikami w przekładni oraz znacznej modyfikacji tej maszyny nazwałem go FRodo. Tryb koło włącznika funkcjonuje jako łożysko do podnośnika aby serwo zbytnio się nie męczyło. Oprogramowanie Soft został napisany w bascomie zajmuje on 25% pamięci. Kod ma ponad 550 linijek i zakłada on wliczanie kontu przyłożenia oraz tworzy tablicę obecności przeciwnika właśnie z takiego powodu mam tylko jeden czujnik ponieważ przy większej ilości musiał bym strwożyć nowe tablice danych a gromadzenie większej ilości danych zabiera takty procesora i wymaga bardziej rozbudowanego kodu. Skrypt ten zastosowałem w obydwu moich nowych minisumo i obydwa nie powalają sposobem wykonania ale za to dostały się do półfinałów. Pod podnośnikiem znajduje się deska rozdzielcza na której znajdują się złącza jednym z nich jest rs232. Podłączam do niego moją elektroniczną ściągę i mogę zmieniać wypełnienie PWM oraz wprowadzać wartości rożnych zmiennych takich jak współrzędne na dohyo. Wnioski z budowy robota Ogólnie jestem zadowolony z maszyny. Fakt że wydałem na niego tylko 60zł jest tym śmieszniejszy że odbywając 3 walki z robotem Enova wygrałem 2 więc śmiało stwierdzam że ta maszyna jest czarnym koniem zawodów w Rzeszowie. W przyszłości dołożę więcej czujników i wymienię podnośnik na metalowy. Poniżej dodaję zdjęcia.
  8. 14 punktów
    Witam serdecznie, tematyką robót bezwykopowych zajmuję się już 3 lata. Chciałem przedstawić jeden z projektów - pojazd do inspekcji kanalizacji. Jeśli nazwałbym go robotem pewnie byłoby to przesadą. System składa się z panelu operatorskiego (z reguły duży samochód z agregatem, monitorami - do wyświetlania tego co widzi kamera umieszczona na pojeździe, drukarką, nagrywarką, ogrzewaniem etc.) oraz małego pojazdu poruszającego się w rurach. Połączenie realizuje się przewodowo (bardzo rzadko bezprzewodowo), co czyni "prawie robota" pojazdem sterowanym przez teleoperatora. Czy inspekcja rurociągów często się zdarza? Całkiem sporo się tego wykonuje - podczas odbioru rurociągu oraz gdy się stanie coś złego. Pojazd Sterownik pojazdu: układ oparty o uC ATmega32 Komunikacja: RS-485, sterowanie prędkością pojazdu, kierunkiem, intensywnością oświetlenia Napęd: 4 silniki Sanyo Denki 103G770 Sterowniki silników: 4 układy oparte o L297 i L298 Koła: wytoczone z aluminium PA11 na tokarce, opony z LEGO System wizyjny: dowolna kamera pozwalająca osiągnąć wyraźny obraz, nie ma sparametryzowanych wymagań (użyłem płytkowej kamery SHARP) Oświetlenie: w kanałach jest ciemno; równomierne oświetlenie uzyskane dzięki pierścieniowi LED Obudowa: tutaj są ścisłe wymagania na kształt, materiał, szczelność; w moim przypadku w pełni zaprojektowana, nie wykonana ze względu na koszta Zasilanie: 24V DC przekazywane przewodami Panel operatorski - interfejs Obudowa: walizka z demobilu Monitor: LG 15.1" Procesor: dwurdzeniowy Intel Atom 1.6 GHz Karta graficzna, dźwiękowa etc. : zintegrowana na płycie głównej Łapanie obrazu: karta DVR Interfejs użytkownika: w pełni wodoodporna klawiatura ze zintegrowaną myszą Dysk: SSD 32 GB Zasilacz ATX (fajna zabawka!): napięcie wejściowe 6-30 V, moc 300 W Panel operatoski - zasilanie w ogóle 350 Watt'ów tylko i wyłącznie z pasywnym chłodzeniem, dzięki czemu cała walizka może być wodoodporna
  9. 13 punktów
    Dane techniczne: Robot czteronożny o konstrukcji aluminiowej (własnego projektu) – waga 670 gramów. Wymiary nogi robota w stanie rozłożonym od osi serwa do końca nogi to 19 cm. Body o wymiarach 8 x 8 cm. A na pokładzie mamy: - Kontroler robota to Baby Orangutan B-328 Robot Controller – programowany w oparciu o dobrze znane nam środowisko Arduino wersja 0021. - 2 x sterowniki serw Pololu Micro Serial Servo Controller do sterowania serwami, - 12 mini serwomechanizmów Tower Pro MG-16R – mocne serwa metalowe o momencie ok. 2,7 kg / cm, - 4 Sharp’y GP2Y0A21YK0F – jako czujniki odległości. Zasięg prezentowany przez producenta to 10-80cm. W rzeczywistości spokojnie można sobie analizować otoczenie powyżej 1 m. - Czujnik przyspieszeń MMA7341L 3-Axis Accelerometer ±3/11g z własnym regulatorem napięcia, - 4 czujniki dotyku w oparciu o włączniki, - MOBOT-RCR-V2 -Moduł radiowy 868MHz – do połączenia bezprzewodowego z rękawicą. - Robot jest zasilany z Pakietu LiPol 3E Model 1300mAh 11,1V 15C, - Regulator Pololu Step-Down Voltage Regulator D15V35F5S3 do zasilania serw, - Stabilizator AVT MOD13 do zasilania elementów nie posiadających własnego regulatora. Sterowanie robotem poprzez rękawicę ( w fazie testów) zawierającą na swoim pokładzie: - Kontroler Orangutan SV-328 z wyświetlaczem LCD - MOBOT-RCR-V2 -Moduł radiowy 868MHz – do połączenia bezprzewodowego z robotem. - Czujnik przyspieszeń MMA7341L 3-Axis Accelerometer ±3/11g z własnym regulatorem napięcia za pomocą, którego są prowadzone odczyty. Robot obecnie przeszedł pozytywnie fazę testów poszczególnych elementów po złożeniu i jest oprogramowywany. Przewidziano 2 podstawowe typy pracy: 1. Sterowanie z rękawicy – tj. odczyty z czujnika przyspieszeń przekazywane są do robota za pomocą modułu radiowego gdzie następuje zaprogramowana reakcja. 2. Praca autonomiczna – robot dokonując odczytów ze swoich czujników reaguje na zmiany otoczenia podczas poruszania się.
  10. 12 punktów
    Kurs BASCOM - lekcja1-wstęp Kurs BASCOM - lekcja2 - pierwsze kroki Kurs BASCOM - lekcja3 - zaczynamy programować Kurs BASCOMZ powodu dużego zapotrzebowania na kurs programowania w języku ms basic postanowiłem napisać ciąg artykułów uczących podstaw programowania w tym właśnie języku. Artów będzie 3 lub 4 w zależności od tego jak podzielę materiał i jakim wolnym czasem będę dysponował. Kurs będzie dotyczył rodziny µC AVR. Jak wiadomo nie licząc robotów beam to robotyka by nie istniała bez programowania. Wiec każdy robotyk musi umieć programować chociaż w najprostszym języku jakim jest ten właśnie opisywany przeze mnie. Tak więc „Alea iacta est”(kości zostały rzucone). Zacznę od potrzebnego sprzętu: Programator: Na sam początek powinniśmy się zaopatrzyć w programator (my będziemy używać programatora isp). Najprostszy to cztery oporniki wtyk lpt i kawałek kabelka: Ale warto jest zabezpieczyć port lpt przed zepsuciem i zbudować bądź kupić stk200 : Są też programatory na port rs232 (com): Jeśli nie masz w komputerze portu lpt ani com co teraz jest coraz szerzej spotykanym zjawiskiem (niestety te dwa ważne porty dla elektronika powoli odchodzą w zapomnienie) Są też programatory pod usb. Na przykład usbasp którego można zobaczyć na tej stronie. Ale jeśli nie czujesz się na siłach aby coś takiego zbudować kup sobie programator, taki jak stk200 można w znanym serwisie aukcyjnym kupić już za 15 zł. To są tylko niektóre z programatorów, jest jeszcze ich wiele. Te które wymieniłem wydaja mi się najlepsze ale mogę się mylić ponieważ nie za wszystkich korzystałem-oparłem się na opinii użytkowników. Procesor: Ja proponuje na sam początek attinny2313. Czemu? Ponieważ jest wystarczający na rozpoczęcie przygody z mikrokontrolerami, jeżeli twój pierwszy program nie zmieści się w jego pamięci to mówię Ci mistrzu. Nie potrzebuje kwarcu- może pracować na wewnętrznym oscylatorze. Moim zdaniem na kilka pierwszych programów jest aż za dobry. W związku z pojawiającymi się wątpliwościami (wcześniej wydawało mi się to oczywiste) dodaje, że wyprowadzenia procesora podłączamy do tak samo nazywających się wyprowadzeń programatora. Kompilator: Kompilatorem języka ms basic którego będziemy używać będzie BASCOM-AVR. Można go pobrać z tej strony Obsługa programu: Po zainstalowaniu i uruchomieniu programu pokaże nam się okno główne: 1.Pasek menu 2.Pasek narzędzi 3.Lista zdefiniowanych etykiet 4.Lista zdefiniowanych procedur 5.”Nawigacja”mikroklocka 6.Pasek stanu 7.Obszar edytora kodu Funkcje ikon paska narzędzi: - nowy program - otwórz - zapisz - zapisz w nowym pliku - drukuj - podgląd wydruku - wytnij - kopiuj - wklej - wstaw wcięcie zaznaczonego fragmentu tekstu - usuń wcięcie zaznaczonego fragmentu tekstu - wyszukaj tekst - sprawdź poprawność programu - kompiluj - raport z kompilacji - symulator - uruchom programator - emulator terminala - zeruj układ - pomoc - exit Paweł “Ikar” Stankiewicz PS: jak zauważycie błędy to dajcie znać
  11. 10 punktów
    Witam, chciałbym przedstawić robota klasy Line Follower, będącego jednocześnie moją pierwszą konstrukcją. Miał to być prosty robot, który z mniejszym lub większym powodzeniem będzie w stanie poruszać się po linii. Założenia projektowe zmieniły się jednak z biegiem czasu i ostatecznie Serdel wystartował na turnieju Robomaticon w Warszawie zajmując tam 8 miejsce oraz na Robot Challenge, gdzie odpadł w jednej ósmej finału. Mechanika Robot zbudowany jest w oparciu o odpowiednio przycięte i połączone śrubkami kawałki laminatu będące kolejno podwoziem, nadwoziem utrzymującym elektronikę, płytką z czujnikami. Napędzany jest silnikami Pololu HP 30:1, na których wały założono koła tej samej firmy o średnicy 32mm. Z powodu słabej przyczepności ich opon zostały wymienione podczas Robot Challenge na koła odlane z poliuretanu. Elektronika Płytka została zaprojektowana oraz wykonana przeze mnie techniką montażu przewlekanego. Mózgiem robota jest mikrokontroler ATmega88. Do sterowania silnikami wykorzystano mostek L298, co uważam za największy błąd w projekcie. Spadek napięcia sięgający 2V skutecznie uniemożliwia wykorzystanie pełnej mocy silników. Z przodu robota znajduje się 5 czujników linii CNY70 ułożonych w kształt litery V, z których odczyt przekazywany jest do przetwornika analogowo-cyfrowego mikrokontrolera. Po czasie stwierdzam, że jest to zbyt mała ilość czujników. Robot zasilany jest pakietem dwoch ogniw litowo-polimerowych firmy Kokam o pojemności 640mAh. Algorytm Program napisany został w całości w języku C. Robot wykorzystuje algorytm regulacji PD. Zdjęcia Podsumowanie Jestem stosunkowo zadowolony z przedstawionej konstrukcji, mimo iż nie jest ona pozbawiona wad. Przy projektowaniu opisanego robota wiele się nauczyłem i nabrałem doświadczenia, które wykorzystane zostanie przy kolejnym, bardziej już złożonym projekcie, mającym miejmy nadzieję szanse na lepsze osiągi. Chętnie odpowiem na wszelkie pytania.
  12. 8 punktów
    Witam. W wolnej chwili postanowiłem opisać konstrukcję diy segwaya. Myślę ze można go zaliczyć do kategorii robotów i opisać na tym forum. Zrobiliśmy z kolega 2 szt żeby nie było niejasności z prawami do użytkowania między nami. Wykonane zostały w tamtym roku i do tej pory jeżdżą. Krótki opis: - Konstrukcja stalowa, elementy wycinane laserowo z blachy ok 1,5mm. Całość ocynkowana. - Koła w jednym modelu od taczek , w drugim alusy od skutera - Elektronika - wheelie 2. Zmiany jakie wprowadziłem to dołożyłem i oprogramowałem wskaźnik baterii oraz zrobiony na nim balance indicator dzięki któremu zawsze w tej samej pozycji można na segwaya stanąć. Dodatkowo dołożyłem moduł BT żeby na bieżąco monitorować na laptopie parametry. Dodatkowo oprogramowałem czujniki prądu ACS ( w oryginale wcale nie są oprogramowane). Dzięki temu blokując koła nie palą się od razu tranzystory w driverach tylko płynie max koło 40A. Dodatkowo zamiast czujników hala na zębatkach zastosowałem zrobione z tcrt5000 czujniki optyczne włożone do wnętrza silnika. Doświadczalnie też dołożyłem żyroskop osi z i wstępnie oprogramowałem. Dzięki temu zjazd jednym kołem z jakiegoś krawężnika czy jakieś inne obniżenie czy podwyższenie stabilizuje obrót. - Drivery - również ze schematu wheelie 2 z lekkimi modyfikacjami. - Napęd - 2 tanie silniki 500W 24V napędzające poprzez przekładnie chyba 11/80 zębów i łańcuch. Testowaliśmy też z przekładniami zębatymi wykonanymi na laserze ale głośność i drżenie były poza granicami akceptowalności. - Zasilanie 2 akumulatory żelowe 12V 20Ah. Na początku planowaliśmy li-ion'y lub li-pol'e ale z racji ceny nie do pobicia stanęło na żelówkach. Co to dużo gadać. Zapraszam do oglądnięcia kilku fotek oraz filmiku.
  13. 7 punktów
    Artykuł przeznaczony do wszystkich zapaleńców druku 3D. Można nie kupować dość drogi filament do swojej drukarki 3D, a produkować w domu własny filament z zużytych butelek PET od napojów. Przy tym nieważne, jeżeli butelka jest pognieciona, ona również się nadaje do domowej produkcji filamentu. Filament z butelek ma sporo zalet w porównaniu z firmowym filamentem kupowanym – ABS albo PLA. Przede wszystkim, że produkowany filament nic nie kosztuje, jest po prostu darmowy Produkowany pręt filamentu Jest bardzo sztywny i absolutnie nie łamliwy, wytrzymuje sporo ostrych przegięć. Filament własnej produkcji jest sporo mocniejszy i twardszy, jak na rozciąganie tak i o wiele bardziej odporny na uderzenie. Absolutnie nie pochłania wody, czyli nie trzeba go ani suszyć, ani chronić w zamkniętym zabezpieczonym od nawilżania się opakowaniu. Praktycznie nie skurcze się przy ochłodzeniu w trakcie druku. Nie wymaga chłodzenia drukowanej warstwy. Nie wymaga stołu podgrzewanego. Dla przyczepności wystarczy miejsce na stole posmarować cienką warstwą kleju w sztyfcie na przykład typu „Glue Stick” Wydrukowane detal można obklejać od razu po skończeniu wydruku. Taki filament jest bardzo odporny na działanie rozpuszczalników i środków chemicznych. Jak widać filament produkcji własnej ma sporo zalet w porównaniu z filamentami kupowanymi, a najważniejsze – że jest darmowy. Niżej przedstawiono zdjęcia maszynki do produkcji filamentu: Do domowej produkcji filamentu wykorzystywane zużyte butelki od napojów. Ale butelki muszą być czyste, resztki kleju do nalepki powinni być usuwane. Technologia produkcji jest bardzo prosta i składa się z trzech następujących operacji: Poprawa zgniecionych butelek i butelek z ryflowaną powierzchnią tak, żeby ścianka boczna butelki była gładka. Nacinanie butelek na paski o określonej szerokości, od 5mm do 12mm w zależności od grubości ścianki butelki. Produkcja pręta filamentu z nacinanych pasków na specjalnej maszynce z nawijaniem na bębenek odbiorczy. Na tych wideo można obejrzeć prace maszynki i przyrządu do nacinania pasków z butelek: Zębatka drukowanie:
  14. 7 punktów
    Jakiś czas temu na forum pojawiło się kilka wpisów krytykujących Raspberry Pi jako platformę sprzętową. Nie próbuję nawet wmawiać, że malinka jest idealna - jednak niektóre problemy można rozwiązać bardzo (albo chociaż dość) łatwo. Problemy o których piszę to np. zużywanie kart SD, długi czas uruchamiania płytki, problemy z systemem plików jeśli nagle odłączymy zasilanie, długi czas kompilacji programów, czy brak możliwości uruchomienia systemu z pamięci USB. Wiele z opisanych niedogodności wynika ze sposobu używania malinki. Większość osób stara się zrobić z niej mały komputer PC - i nie ma w tym nic złego, w końcu na Forbocie właśnie tak opisywaliśmy kurs Raspberry Pi. Jednak malinka nie we wszystkim może zastąpić komputer stacjonarny i czasem nieco inne podejście może dawać nieco lepsze rezultaty. Komputer stacjonarny, a komputer wbudowany Pierwsza istotna sprawa to rozróżnienie między rozwiązaniami wbudowanymi (embedded), a komputerem stacjonarnym (desktop/laptop). Urządzenia wbudowane są konstruowane do spełniania jednej, z góry określonej funkcji - przykłady to procesor w ekspresie do kawy, bankomacie, czy samochodzie. Oprogramowanie można aktualizować, nawet zmieniać na własne (tym zajmują się hackerzy), ale nadal program ma ściśle określone zadanie do wykonania. System ogólnego przeznaczenia, to nasze komputery stacjonarne lub przenośne - czyli zupełne przeciwieństwo wbudowanych. Można na nich grać w pasjansa, Wiedźmina, a nawet inne gry, przeglądać internet, pisać programy i robić miliony innych rzeczy. Instalacja nowych programów jest łatwa, niekiedy nawet udaje się je odinstalować. Arduino jest kolejnym przykładem platformy wbudowanej. Program kompilujemy na PC, wgrywamy na płytkę i ma on wykonywać to co sobie zaplanowaliśmy - migać diodą, sterować robotem, itd. Ale już nowych progamów nie dodamy, nie będziemy na Arduino kompilować kodu, ani grać w pasjansa (chyba że to jest główna funkcja naszego układu). Raspberry Pi natomiast jest najczęściej używane jako mały komputer PC. Instalujemy na karcie SD Raspbiana (lub inną dystrybucję) i dalej używamy tak samo jak komputer stacjonarny. Może gier jest mniej, ale minecraft działa całkiem fajnie, RetroPie pozwala na emulację starych komputerów i konsol, a użwanie kompilatora (np. gcc) nikogo nie dziwi. Raspberry Pi całkiem dobrze sobie z takimi zadaniami radzi, ale to wbrew pozorom nadal głównie komputer wbudowany. W niniejszym artykule chciałbym chociaż wprowadzić w nową opcję, czyli użycie malinki jako komputera wbudowanego - mającego jedno zadanie, które dobrze wykonuje. System operacyjny Wszyscy wiemy jak działa Raspberry Pi - na karcie SD mamy ulubioną dystrybucję, kartę umieszczamy w czytniku, podłączanie zasilanie, czekamy, chwilę jeszcze czekamy, a może jeszcze jedną chwilę... i mamy pulpit z ikonkami albo chociaż konsolę do wydawania poleceń. Programy pobieramy z sieci (repozytorium), apt jest prosty i sympatyczny w użyciu. A gdybyśmy tak spróbowali przygotować własną, mniejszą ale dopasowaną do naszych potrzeb wersję systemu? Okazuje się że nie jest to aż tak trudne (chociaż proste też nie jest), w nagrodę będziemy za to mogli pozbyć się problemów o których wspominałem na początku artykułu. Yocto Własną dystrybucję Linux-a można przygotować zupełnie od podstaw - zaczynając od kompilacji kompilatora. Jest to jednak dość złożony proces, świetny do nauki, ale niekoniecznie wygodny. Na szczęście znajdziemy gotowe projekty przygotowujące naszą dystrybucję linuksa od podstaw. Buildroot (https://buildroot.org/) jest jednym z takich projektów - pozwala on na łatwe wybranie potrzebnych nam programów oraz ich skompilowanie ze źródeł. Ostatnio coraz większą popularność zyskuje jednak inny projekt - Yocto (https://www.yoctoproject.org/). Działa o wiele wolniej niż buildroot (jak to z narzędziamy opartymi o Pythona bywa), ale lepiej sprawdza się w dużych projektach. W następnym wpisie postaram się opisać jak można użyć Yocto to przygotowania własnej wersji systemu dla malinki. Jeszcze dwa słowa odnośnie buildroot-a. Dawno, dawno temu opisywałem jak użyć go podczas instalowania linuksa na netbook-u domyślnie pracującym z Androidem: https://forbot.pl/blog/sprawdz-jak-tanio-zbudowac-robota-z-systemem-linux-id7751 To co chcę teraz opisać to bardzo podobne rozwiązanie, ale zamiast netbook-a jest Raspberry Pi, a rolę Androida zajmuje Raspbian. No i po tych kilku latach yocto uzyskało pewną przewagę na buildrootem, więc też będzie użyte. Szybki start Żeby nie zanudzić najpierw szybki i dość ogólny opis. Celem będzie utworzenie podstawowego obrazu systemu, z którego wystartuje malinka. Najpierw należy przygotować odpowiedni komputer PC oraz system operacyjny. System to oczywiście Linux - wspierane są dystrybucje Debian, Ubuntu, Fedora, OpenSUSE oraz CentOS. Prawdopodobnie użycie innej dystrybucji jest też możliwe, może jednak wymagać dodatkowych kroków. W zależności od posiadanej wersji musimy zainstalować odpowiednie pakiety oprogramowania, wszystko znajdziemy opisane tutaj: https://www.yoctoproject.org/docs/2.5/ref-manual/ref-manual.html#required-packages-for-the-host-development-system Yocto można używać w systemie Windows lub MacOS wykorzystując maszynę wirtualną. Jednak takie rozwiązanie ma znaczącą wadę - bardzo spowalnia i tak czasochłonną kompilację obrazu systemu. Nie polecam takiego rozwiązania, lepiej używać natywnego linux-a i poszukać możliwie mocnego komputera - 4 rdzenie to raczej minimum, ale yocto potrafi nawet 44 wykorzystać (tyle testowałem), więc im silniejszy komputer tym lepiej i szybciej - a maszyny wirtualne pod względem wydajności niestety nie oszałamiają. Oprócz szybkiego procesora o możliwie wielu rdzeniach, będziemy potrzebowali również sporo miejsca na dysku. Minimum to ok. 30 GB, ale nieco bardziej rozbudowana konfiguracja może potrzebować i 100GB. Oczywiście szybki dysk ma swoje zalety, więc jeśli mamy miejsce na dysku SSD, warto go użyć. Ja wykorzystuję dysk SSD podłączany przez USB. To całkiem wydajne rozwiązanie, a możliwość odłączenia dysku od stacji roboczej i podłączenia do laptopa bardzo się przydaje. Dlatego u mnie ścieżka do projektu jest nieco długa: /mnt/usbssd/raspberry/yocto W tym katalogu należy pobrać sam projekt yocto, czyli wykonać: git clone -b sumo git://git.yoctoproject.org/poky.git Potrzebne będą jeszcze dwie tzw. warstwy, czyli powiedzmy biblioteki: meta-openembedded oraz meta-raspberrypi. Pobiera się je poleceniami: git clone -b sumo git://git.yoctoproject.org/meta-raspberrypi git clone -b sumo git://git.openembedded.org/meta-openembedded Teraz w katalogu /mnt/usbssd/raspberry/yocto znajdziemy trzy podkatalogi: poky, meta-raspberrypi, meta-openembedded. Pierwszy z nich jest dla nas najważniejszy więc wchodzimy do niego, a następnie wczytujemy zmienne ze skryptu oe-init-build-env: cd poky source oe-init-build-env Na ekranie widzimy podpowiedź co zrobić dalej, jednak zanim do tego przejdziemy musimy poprawić domyślną konfigurację yocto. Plik conf/bblayers.conf zawiera listę wybranych wartstw (bibliotek). Musimy dopisać używane przez nas, dopisujemy więc: BBLAYERS ?= " \ /mnt/usbssd/raspberry/yocto/poky/meta \ /mnt/usbssd/raspberry/yocto/poky/meta-poky \ /mnt/usbssd/raspberry/yocto/poky/meta-yocto-bsp \ /mnt/usbssd/raspberry/yocto/meta-raspberrypi \ /mnt/usbssd/raspberry/yocto/meta-openembedded/meta-oe \ /mnt/usbssd/raspberry/yocto/meta-openembedded/meta-multimedia \ /mnt/usbssd/raspberry/yocto/meta-openembedded/meta-networking \ /mnt/usbssd/raspberry/yocto/meta-openembedded/meta-python \ " Kolejny krok to edycja głównego pliku konfiguracyjnego o nazwie conf/local.conf. Domyślnie zawiera on dużo komentarzy, uproszczona wersja wygląda następująco: MACHINE = "raspberrypi3-64" DL_DIR = "${TOPDIR}/downloads" DISTRO ?= "poky" PACKAGE_CLASSES ?= "package_ipk" EXTRA_IMAGE_FEATURES ?= "debug-tweaks" USER_CLASSES ?= "buildstats image-mklibs image-prelink" CONF_VERSION = "1" RPI_USE_U_BOOT = "1" ENABLE_UART = "1" Pierwsza linia ustala typ naszej "maszyny", czyli Raspberry Pi 3 w wersji 64-bitowej. Jeśli używamy innej wersji, musimy odpowiednio zmodyfikować ten wpis. Co ciekawe cała dystrybucja będzie wykorzystywała ustawienia zoptymalizowane dla naszgo procesora - domyślnie Raspbian jest kompilowany tak, aby programy działały na najmniejszym wspólnym mianowniku, czyli starym Raspberry 1 - używając yocto nie tylko jądro, ale i cały system zostanie skompilowany pod nasze potrzeby. Nie zadziała na starszych płytkach, ale na naszej wykorzysta jej potencjał. Kolejny ważny parametr to ustawienie RPI_USE_U_BOOT. Dzięki niemu zostanie użyty bootloader u-boot, co pozwoli na załadowanie systemu przez sieć (TFTP), podłączenie dysku sieciowego (NFS), albo nawet użycie pamięci USB. Jest to pierwszy etap pozwalający na pozbycie się usterek na które wiele osób narzeka. W tym pliku można również wymusić użycie systemu "tylko do odczytu". Jedna dodatkowa linijka i karta SD będzie działać prawie w nieskończoność - do tego wrócimy później. Na razie czas zacząć kompilację i zrobić sobie (długą) przerwę. Wydajemy polecenie: bitbake core-image-minimal Yocto pobierze z sieci źródła wszystkich programów a następnie je skompiluje. Taki proces wymaga szybkiego łącza i trwa... od 20min do 4h. Na szczęście później jest już szybciej, ale za pierwszym razem można sobie zrobić przerwę na lunch. Po zjedzeniu lunchu, albo chociaż przerwie mamy gotowy obraz naszego systemu. Wynikowe pliki znajdziemy w katalogu tmp/deploy/images/raspberrypi3-64: Tym co na początek nas zainteresuje to plik z gotowym obrazem całej karty SD, czyli core-image-minimal-raspberrypi3-64.rpi-sdimg. Warto zwrócić uwagę na wielkość obrazu - u mnie wyszło 56 MB. To nadal bardzo dużo, ale domyślny Raspbian wymaga kilku GB. Kartę SD przygotujemy poleceniem dd, u mnie urządzenie /dev/sdh odpowiada karcie, więc polecenie: sudo dd if=tmp/deploy/images/raspberrypi3-64/core-image-minimal-raspberrypi3-64.rpi-sdimg of=/dev/sdh bs=4M Pozwala na nagranie obrazu na nośnik. Teraz można umieścić kartę w czytniku Raspberry Pi i wystartować system: Uruchomienie sytemu zajmuje znacznie mniej czasu niż w przypadku domyślnego systemu. To nadal bardzo daleka od optymalnej konfiguracja, ale i tak linux jest gotowy do pracy w kilka sekund. To co otrzymaliśmy to pierwsza, minimalna wersja systemu - mała ale zoptymalizowana dla naszego sprzętu. Nie znajdziemy na niej minecrafta, ani nawet interfejsu graficznego, ale to co wybraliśmy działa szybko i wydajnie. Mając taki system jako punkt wyjścia możemy przygotować bardziej rozbudowaną wersję, wyposażoną w potrzebne nam programy i biblioteki. Warto natomiast zwrócić uwagę na nieco inny sposób pracy z systemem. Całą kompilację wykonujemy na komputerze stacjonarnym, malinka tylko wykonuje przygotowane programy. Działa więc tak jak Arduino, a nie typowy Raspbian.
  15. 7 punktów
    Witajcie! Bolt to robot klasy Linefollower Standard. Został zaprojektowany, zbudowany oraz zaprogramowany przez kolegę Hubert.M oraz mnie. Jest on naszą najnowszą konstrukcją. Konstrukcja mechaniczna. Robot składa się z 2 płytek PCB, wykonanych przez firmę SATLAND Prototype. Płytki połączone są dwiema węglowymi listewkami, a z tyłu robota znajduje się aluminiowa podpórka zabezpieczająca przed przewróceniem się robota. Podpórkami listwy czujników są tranzystory w obudowie TO92. Silniki użyte w robocie to popularne Pololu HP 10:1. Koła wykonał dla nas hungrydevil. Masa robota z baterią wynosi 69 gramów. Elektronika. Zdecydowaliśmy się na mikrokontroler STM32F103C8T6. Silniki sterowane są układem TB6612. Zastosowane czujniki linii to KTIR0711. Czujników na chwilę obecną jest 9. Zastosowaliśmy moduł bluetooth HC-05. Zastosowanie modułu znacznie ułatwiło strojenie robota. Ponadto stan każdego czujnika jest odzwierciedlony diodą LED. Robot zasilany jest pakietem Li-pol o pojemności 150mAh. Część logiczna robota zasilana jest napięciem 3.3V. Program. Algorytm robota jest napisany w języku C. Zastosowano regulator PD. Dzięki modułowi BT wszystkie nastawy regulatora mogą być ustawiane bez ponownego programowania robota. Ponadto, program pozwala na np. zdalne sterowanie robota po połączeniu z komputerem. Do zażądania robotem napisaliśmy 2 aplikacje – na telefony z systemem android, aplikacja pozwala na wystartowanie robota, a także na jego zatrzymanie. Z Kolei aplikacja na PC oprócz podstawowej funkcjonalności pozwala na dobieranie nastaw robota. Ponadto można za jej pomocą rysować wykresy uchybu i pochodnej z uchybu. Bolt ma brata bliźniaka, o nazwie Bez Nazwy. Jest on nieco szybszy od Bolta (bo czerwony). Osiągnięcia i plany na przyszłość. - 2 miejsce na Konkursie robotów SEP Gdańsk 2015 - 4 miejsce na SUMO Challenge 2015 W robocie planujemy jeszcze bardziej poprawić jakość sterowania, oraz rozważamy wykonanie węższej listwy czujników z czujnikiem odległości, aby móc startować w kategorii LF Enhanced. Film z przejazdu:
  16. 7 punktów
    Konstrukcja linefollowera jest oparta o laminat szklano-epoksydowy stanowiący jednocześnie płytkę drukowaną elektroniki. Konstrukcja przystosowana jest również do jeżdżenia po torach z przeszkodami. Robot posiada możliwość regulowania wysunięcia czujników linii, jak również wysokość czujników nad torem. Sterowany jest nowoczesnym mikrokontrolerem ATXmega128A1. Silniki pozwalają robotowi osiągać prędkości ponad 1,5m/s co stawia go w czołówce najszybszych polskich robotów typu Lf. Oryginalny design wraz z efektami świetlnymi powoduje, że robot świetnie się prezentuje na torze. Przedstawiam robota klasy Linefollower, którego wykonałem razem z TIMONKiem. Jak wszystkie moje konstrukcje robot po ustaleniu koncepcji i wszystkich założeń konstrukcji został zaprojektowany w programie Autodesk Inventor. Oto kilka renderów z Inventora a w załączniku plik złożeniowy wraz ze wszystkimi plikami. Dla tych co mają inną wersję Inventora lub używają innego programu załączam również plik .step: Elektronika robota składa się z dwóch płytek drukowanych i wyświetlacza. Obwody drukowane zostały zaprojektowane w programie Altium Designer. Poniżej kilka zrzutów ekranu. W załączniku dołączam schematy w formacie PDF oraz pliki Altiuma. Widok 3D płytki nie będzie działał, ponieważ projekt jest powiązany na stałe z plikami inventora. Po ominięciu kilku wyskakujących błędów powinien działać widok 2D obwodu. Kilka zdań o konstrukcji mechanicznej: Jak widać na zdjęciach robot składa się z dwóch płytek drukowanych, dzięki czemu możliwa jest regulacja odległości czujników od osi napędowej. Możemy w ten sposób ustalić empirycznie optymalną odległość między osią kół a czujnikami. Z naszych obserwacji wynika, że robot, który ma większą odległość czujników od kół lepiej sprawdza się na szybszych trasach, które mają łagodniejsze zakręty. Płytki są ze sobą połączone przy pomocy 20 żyłowej taśmy. Środek ciężkości robota został umieszczony w miarę nisko nad ziemią, ok. 6mm oraz w odległości około 14mm przed osią kół. Cała konstrukcja waży ok. 100g (dokładną wagę podam w przyszłym tygodniu). W Linefollowerze zostały zastosowane silniki z Pololu w wersji HP z przekładnią 30:1, ich specyfikacja dostępna jest tutaj: http://www.pololu.com/catalog/product/1093. Silniki zostały zamocowane na podstawkach wyciętych laserowo z plexi, tak aby środek ciężkości znajdował się jak najniżej i aby płytka z elektroniką była umieszczona równolegle do podłoża. Kulka podpierająca przód robota również została kupiona w sklepie Pololu. Zastosowane koła to kółka z mobot.pl po mojej małej przeróbce. Do robota pasują również koła z Pololu, które widać na niektórych filmikach i zdjęciach. Słów parę o elektronice: Na przedniej płytce znajduje się 16 transoptorów odbiciowych KTIR0711S, 4 diody LED, czujnik Sharp gp2y0d340k wraz z niezbędnymi elementami (filtr LC na zasilaniu, dzielnik rezystorowy na wyjściu oraz zworka do włączania czujnika), dwa kondensatory odsprzęgające napięcia +3,3V i +5V oraz 20-pinowe złącze taśmy. Na tylnej płytce: -układ zasilania złożony z dwóch połączonych kaskadowo stabilizatorów L7805ACDT (+5V) i LF33 (+3,3V). Przed stabilizatorami znajduje się dodatkowo włącznik i dioda prostownicza FR3 zabezpieczająca przed odwrotnym podłączeniem akumulatora. Ze stabilizatorami współpracują kondensatory tantalowe SMD. -procesor ATXmega128A1 wraz z ośmioma kondensatorami odsprzedającymi i dwoma filtrami LC filtrującymi napięcie dołączone do nóżek AVcc. -dwa mostki H VNH3SP30 sterujące silnikami. -komparator sygnalizujący rozładowanie akumulatora poniżej 50% poprzez zapalenie zielonej (zielona aby się wyróżniała) diody LED. Na wejścia komparatora podane są przez dzielniki rezystorowe napięcia akumulatora i napięcie ze stabilizatora +3,3V. Dodatkowo wyjście komparatora zostało podłączone do jednego z wyprowadzeń mikrokontrolera, aby można było programowo zareagować na rozładowanie akumulatora. -6-pinowe złącze programatora „micromatch” (wykorzystane tylko 4 piny) -scalony odbiornik podczerwieni TSOP32156, do współpracy z pilotem -złącze wyświetlacza LCD, na które wyprowadzony został cały port F (na schemacie jest narysowane tylko 7 linii, ale na płytce można podłączyć 8 linię robiąc małą zworkę z cyny), dzięki czemu złącze te może być wykorzystane również do rozbudowy robota. -trzy microswitche -3 czerwone diody sygnalizujące poprawne pojawienie się w układzie napięć: akumulatora, +5V, +3,3V. -dwie diody LED SMD RGB wraz z tranzystorami sterującymi. Diody zostały zamontowane od spodu robota i mają za zadanie oświetlanie toru (efekt wizualny). Tranzystory sterowane są sześcioma sygnałami PWM, dzięki czemu na diodach można uzyskać dowolny kolor bez obciążania procesora. -18 sztuk czerwonych diod LED SMD 0603, służących do generowania efektów wizualnych -20-pinowe złącze taśmy łączącej obie płytki Trasa: Trasa dla robota wykonana została z laminowanej płyty paździerzowej zakupionej w Castoramie. Płyta została pocięta na kawałki ok. 1x1m, a następnie skręcona przy pomocy stalowych płaskowników. Boki pociętej płyty zabezpieczyliśmy tzw. obrzeżami meblowymi. Linia po której jeździć ma robot wyklejona została izolacją o szerokości 19mm. Bandy toru wykonane zostały z samoprzylepnych klinów z gąbki. Filmiki z pierwszych testów: Drugie testy: Robot nie jeździ jeszcze z maksymalną prędkością, widać jak czasami wariuje na łączeniach płyt. Oprogramowanie jest cały czas rozwijane więc z czasem będzie jeździł szybciej. Ta odstająca do góry taśma jest tylko tymczasowo, później będzie założona taśma na wymiar. OSIĄGNIĘCIA: Inferno wraz z bratem bliźniakiem Mefisto wziął udział w zawodach LF i LF z przeszkodami na SumoChallenge w Łodzi oraz w zawodach LF na RoboticArena we Wrocławiu osiągając: Sumochallenge2010: 1. miejsce dla robota Mefisto w kategorii Linefollower. 2. miejsce dla robota Inferno w kategorii Linefollower. 1. miejsce dla robota Inferno w kategorii Linefollower z przeszkodami. 3. miejsce dla robota Mefisto w kategorii Linefollower z przeszkodami. Film z eliminacji na SumoChallenge: RoboticArena2010: 1. miejsce dla robota Inferno w kategorii Linefollower. Podsumowując: mój i TIMONKa debiut w kategorii Linefollowerów uznajemy za udany Film nagrany podczas dni otwartych Politechniki Poznańskiej 27 listopada: schematy.rar LF.rar LF.rar robot.rar
  17. 7 punktów
    Witam wszystkich forumowiczów. Chciałbym przedstawić moja pierwszą jeżdżącą konstrukcje. Jest to samobieżna platforma sterowana poprzez bluetooth poprzez laptopa/PC lub telefon. WSAD: Wsad do mikro-kontrolera powstawał najwięcej czasu z racji braku doświadczenia w pisaniu wsadów, wiem na pewno że da się go zrobić prościej i schludniej ale mi wystarczy zadowolenie że działa. Jest on bardzo wzorowany na sterowniku bluetooth opublikowanym w EdW 01/09 i kopią wsadu do konstrukcji bluerider opublikowanej na innym forum. Działania wsadu nie będę opisywać ponieważ jest w nim dodanych wiele komentarzy opisującym całe sekcje i za co są one odpowiedzialne. W kilku miejscach powstaje małe zamieszanie w przypisywaniu portów ale wszystko to poprzez dalsze prace nad konstrukcją ramienia z chwytakiem które zostały wstrzymane do stycznia. Gorąco polecam samo zapoznanie się z możliwościami takiego starowinka bluetooth. PROGRAM PC/KOMÓRKA: Twórca tych programów jest osoba która jest autorem całego artykułu o którym pisałem wcześniej. Jeśli jest ktoś zainteresowany programem należy na stronie: http://www.elportal.pl/index.php?module=ContentExpress&func=display&btitle=CE&mid=&ceid=93 odszukać: Do pobrania z EdW 1/2009 a następnie wybrać odnośnik do: Sterownik Bluetooth - płytka drukowana, oprogramowanie (ZIP, 2100kB) . NAPĘD: Do napędzenia robota posłużyły dwa przerobione serwa modelarskie sterowane poprzez podwójny scalony mostek typu H. Serwa bezpośrednio przekazują napęd na łańcuch pełniący role gąsienic. Myślę że nie ma co się tutaj rozpisywać, istnieje wiele rodzajów napędów i sposobów na przenoszenie go ale mi ten najbardziej pasował. ZASILANIE: Całość jest zasilana z 8 akumulatorków energizer, wybrałem takie zasilanie ponieważ miałem ich dużo i chciałem je jakoś wykorzystać. W projekcie są użyte dwa stabilizatory 7805 oraz 7808 do zasilania silników. ELEKTRONIKA: Całością steruje mikro-kontroler atmega8. Procesor znajduje się w pętli do loop, oczekując na komunikaty od BTM. Jeżeli odbierze prawidłowy znak, ustawia stan na odpowiednim porcie procesora, a następnie wysyła do modułu informację o stanie wszystkich wyjść. Do sterownika dołączone jest napięcie 5V oraz 8V. Stabilizacja odbywa się w innym module. Budowa elektroniki w systemie modułowania sekcji była wymuszona przez bardzo małą ilość miejsca w która musiałem zmieścić cała elektronikę. KOMUNIKACJA: Podzespołem odpowiedzialnym za komunikacje pomiędzy platforma a PC/komórka jest moduł bluetooth btm-222. Wzór PCB został pobrany z: http://www.elektroda.pl/rtvforum/viewtopic.php?t=1414894&highlight= natomiast dokładny opis komunikacji jak i działania samego modułu znajduje się na stronie http://www.elektroda.pl/rtvforum/topic1433390.html#7043207. Dodam jedynie że moduł wymaga napięcia 3,3V przez co zastosowany jest konwerter napięć oraz że warto jednak wybrać PCB z wbudowanymi diodami( od razu widać czy komunikacja odbywa się prawidłowo). W mojej konstrukcji zastosowany jest dokładnie moduł btm-220A nie różni się on niczym od opisywanym wcześniej btm-222, pracuje on w klasie 1( do 100m zasięgu) faktycznie testowałem na 30m i działał bez problemu dodana jest także antena od zwykłego access point'a taka zwykła za 9 zł. PCB: Zostały one wykonane przeze mnie na podstawie dokumentacji technicznych bibliotek oraz materiałów dostępnych w internecie. Płytki są jednostronne poza modułem bluetooth, PCB pobrana z sieci, jedynie przerobiona na moje potrzeby( dodane gniazdo antenowe) i można je spokojnie wykonać w domowych warunkach. KONSTRUKCJA: Całość została upchnięta w uniwersalna obudowę dodany został tez kątownik aluminiowy odpowiedzialny za wzmocnienie osi pojazdu na których znajduje się całe obciążenie. Budowa ramienia z chwytakiem ciągle w budowie. ZAŁĄCZNIK: W załączniku znajdują się wszystkie wzory PCB oraz wsad do atmegi. Do goldpinu JP1( plik RAT1) należy podłączyć sterowanie PWN lub tak jak u mnie napięcie 5V. UWAGA!!! w projekcie RAT1 znajduje się błąd elementy bc848 należy przylutować napisem do PCB. Mam nadzieje że o niczym ważnym nie zapomniałem, jest to moja pierwsza konstrukcja którą opisuje wiec tez mam nadzieje że niczym nie zdenerwowałem moderatorów i nie złamałem kilku punktów regulaminu. Na koniec film i parę zdjęć: Teraz kilka zdjęć z budowy ramienia: RAT.rar
  18. 6 punktów
    Od dawna interesowały mnie pomiary warunków meteorologicznych w mojej miejscowości, pierwsza stacja meteorologiczna, którą zbudowałem około roku 2010, wykonana była na mikrokontrolerze Atmega32. Do komunikacji z światem wykorzystywała moduł LAN Wiznet 7010a. Stacja ta była oprogramowana w języku BASCOM. Projekt który chcę zaprezentować dzisiaj działa już od roku 2018 i został oprogramowany w środowisku Arduino. Stacja została podzielona na 2 moduły, pierwszy pomiarowy oparty jest na klonie Arduino Nano oraz drugi odbiorczy którego sercem jest ESP8266 NodeMCU v3, służy on również do wyświetlania aktualnych pomiarów na wyświetlaczu LED dot matrix o wymiarach 8x56 punktów. Na pracach stolarskich się nie będziemy skupiać napiszę tylko że klatka meteorologiczna została wykonana z drewna sosnowego i umieszczona na wysokości 2 m. Moduł Pomiarowy Czujniki jakie zastosowałem to dwie sztuki DS18B20 pierwszy zajmuje się pomiarem temperatury przy gruncie na wysokości 5cm, drugi pełni rolę zapasowego czujnika temperatury na wypadek uszkodzenia się głównego czujnika BME280. Do pomiaru prędkości wiatru wykorzystuję wiatromierz firmy Maplin na jeden obrót wiatromierza przypadają 2 impulsy z kontaktronu który jest w nim zamontowany, producent dostarcza również odpowiedni wzór według którego można obliczyć rpm oraz prędkość wiatru w km/h. Dane mierzone przez wiatromierz możemy podzielić na dwie wartości, pierwsza to chwilowa prędkość, druga prędkość w porywach, aby uśrednić wartości mierzone program zlicza impulsy z 5s a następnie dokonuje odpowiednich obliczeń. Zebrane dane przesyłane są do drugiego urządzenia poprzez moduły radiowe które działają na częstotliwości 433,92 MHz. W tym celu zastosowana została biblioteka RCSwitch. Każda mierzona wartość jest wysyłana jako osobna transmisja. aby rozróżnić pomiary z konkretnych czujników mierzona wartość mnożona jest przez 100 a następnie dodawana jest liczba 100 000 dla pierwszego czujnika, 200 000 dla drugiego itd. Przykład kodu który realizuje tę funkcję poniżej: // temperatura sensor BME codetosend = temp * 100 + (1 * 100000); mySwitch.send(codetosend, 24); // wilgotnosc sensor BME codetosend = hum * 100 + (2 * 100000); mySwitch.send(codetosend, 24); Moduł Wewnętrzny Obudowa, która idealnie nadawała się do implementacji wewnętrznego modułu pochodzi z tunera IPTV Motorola VIP1910-9. Przedni panel został wykonany z ciemnego półprzepuszczalnego plastiku który idealnie nadaje się do umieszczenia w nim wyświetlacza. Sercem urządzenia jest układ ESP8266. "Moduł wewnętrzny" został również wyposażony w czujnik temperatury oraz wilgotności DHT22, dodatkowo w celu prezentacji zmierzonych wartości dołączone zostało 7 szt. modułów wyświetlacza LED dot matrix z układem MAX7219. Do obsługi tej matrycy zastosowałem bibliotekę Max72xxPanel.h która współpracuje z biblioteką Adafruit_GFX.h w ten sposób nie byłem zmuszony implementować do rozwiązania własnych czcionek. Matryca ta oprócz modułowej konstrukcji umożliwia również sterowaniem jasnością podświetlania, w tym celu aby uprzyjemnić użytkowanie w porach nocnych odbiornik został wyposażony w fotorezystor dzięki któremu potrafi określić natężenie oświetlenia otoczenia i odpowiednie ustawienie podświetlenia. Na wyświetlaczu w pierwszej kolejności wyświetlam aktualną godzinę oraz temperaturę wewnątrz pomieszczenia oraz wilgotność, po około jednej minucie wyświetlane są informacje odczytane z stacji meteo czyli temperatura wilgotność i ciśnienie, postanowiłem nie wyświetlać tutaj informacji dotyczących prędkości wiatru oraz temperatury przy gruncie. Decyzję tą podjąłem na podstawie użytkowania innego podobnego rozwiązania, akurat jak chcemy odczytać godzinę to wyświetlane są inne informacje. Dodatkowo w godzinach nocnych, które zostały ustawione w sztywnych ramach czasowych między 21:00 a 7:00 informacje odczytane z stacji meteo zostały okrojone tylko do temperatury. W projekcie zostały zastosowane 2 rodzaje animacji pierwsza z nich, przesuwa tekst z prawej strony wyświetlacza na lewą, z możliwością zatrzymania w interesujących momentach. Drugi rodzaj to pionowa animacja. Mikrokontroler również poprzez protokół NTP i bibliotekę time.h pobiera aktualną godzinę i datę. Za odbiór danych z pierwszego układu odpowiedzialny jest moduł radiowy którego obsługą tak jak w poprzednim module zajmuje się biblioteka RCswitch. Poniżej fragment programu który demonstruje w jaki sposób odbierane i dekodowane są dane: rc = mySwitch.getReceivedValue(); // czujnik temperatury powietrza BME280 if (abs(rc)>=50000&& abs(rc)<150000) { rc=(rc-100000)/100; if (rc > -50 and rc < 60) { temp1 = rc; Serial.print("Czujnik BME280 - temperatura: \t"); Serial.println(rc); matrix.drawPixel(55,0,1); matrix.write(); } } // czujnik wilgotności BME280 if (abs(rc)>=150000 && abs(rc)<250000) { rc=(rc-200000)/100; if (rc > 5 and rc <= 100) { hum = rc; Serial.print("Czujnik BME280 - wilgotnowsc: \t"); Serial.println(rc); matrix.drawPixel(55,1,1); matrix.write(); } } Dzięki zastosowaniu zewnętrznej anteny oraz odbiornika opartego na superheterodynie, zasięg w otwartym terenie to około 250 m. Po odebraniu danych z pierwszego układu poprzez moduł radiowy następuje przekazanie ich do serwera z systemem Domoticz. Domoticz to bardzo lekki system automatyki domowej, który pozwala monitorować i konfigurować różne urządzenia, przełączniki, czujniki takie jak temperatura, opady deszczu, wiatr, promieniowanie ultrafioletowe (UV), zużycie energii elektrycznej, zużycie gazu, zużycie wody i wiele więcej. Wykresy dostępne są również na stronie www http://meteo.palowice.net Poniżej film z działania odbiornika, smużenie animacji które występuje na filmiku ludzie oko nie rejestruje. Gdyby kogoś interesował kod to również zamieszczam: meteo.zip
  19. 6 punktów
    Jakiś czas temu na portalu z ogłoszeniami natknąłem się na ofertę sprzedaży zabytkowego układu scalonego AY-3-8500. Jest to dość specyficzny element, wykorzystywany na przełomie lat siedemdziesiątych i osiemdziesiątych do budowy konsol do gier pierwszej generacji. Układ scalony zawiera w swojej strukturze kompletną logikę, niezbędną do generowania kilku prostych gier, m.in. kultowego "Ponga". Wykorzystywany był m.in. w kultowym ELWRO/Ameprod TVG-10 - jedynej polskiej konsoli do gier, jaka trafiła do masowej sprzedaży. Oczywiście nie byłbym sobą, gdybym go wtedy nie kupił i nie spróbował odpalić. Zacząłem więc szukać w Sieci informacji na temat tego układu. Efekty tych poszukiwań przeszły moje oczekiwania - natknąłem się na stronę, której autor zajął się podobnym projektem. Była tam cała niezbędna dokumentacja, karty katalogowe, a także projekt płytki drukowanej konsoli wykorzystującej posiadany przeze mnie układ scalony. No cóż... Postanowiłem nie wyważać otwartych drzwi i wykorzystałem ten wzór, prowadzając jednakże pewne modyfikacje w swojej implementacji tego projektu. Największa z nich dotyczyła kontrolerów , które zbudowałem w oparciu o niewielkie, plastikowe obudowy. Musze przyznać, że tworzą one całkiem poręczne "pady". Każdy z kontrolerów jest wyposażony w potencjometr służący do kontrolowania położenia paletki oraz przycisk do serwowania. Sama konsola została umieszczona w typowej plastikowej skrzynce. Na przednim panelu znajdują się przełączniki dźwigniowe dwu i trzypozycyjne służące do konfiguracji trybu rozgrywki, a także przełącznik obrotowy, do wyboru właściwej gry. Układ AY-3-8500 pozwala na korzystanie z pistoletu świetlnego. Dwie z generowanych przez niego gier wymagają posiadania takiego sterownika. Zdecydowałem się jednak zrezygnować z jego budowy. Na płytce są wyprowadzone odpowiednie piny, więc w przyszłości będzie możliwa taka rozbudowa. Niestety strona na której znalazłem oryginalny projekt niedługo później przestała działać, jednak wciąż można się do niej dostać przez Wayback Machine. Konsola przez jakiś czas była dostępna na wystawie "Game start/game over" w krakowskim Muzeum Inżynierii Miejskiej. Przetrwała - grupy gimnazjalistów nie były w stanie jej zniszczyć. W ramach ciekawostki mogę dodać, że mojemu sześcioletniemu siostrzeńcowi spodobała się ta gra sprzed kilku dekad.
  20. 6 punktów
    Witam. W kilku kolejnych częściach kursu chciałbym przedstawić proces tworzenia własnej aplikacji na telefon, tablet lub inne urządzenie z system Android. Aplikacja będzie miała za zadanie sterować naszym robotem, lub dowolną inną konstrukcją, oraz będzie mogła przedstawiać aktualny stan, oraz wybrane parametry / odczyty urządzenia. Wszystko to za pomocą łączności bezprzewodowej, niewielkim kosztem i za pomocą stosunkowo szybko zrobionej własnej aplikacji na popularne ostatnimi czasy urządzenia z system od google’a. [blog]https://forbot.pl/blog/artykuly/programowanie/tworzenie-aplikacji-android-1-wstep-id4486[/blog]
  21. 6 punktów
    Chociaż program Eagle firmy CadSoft posiada preinstalowaną, bardzo bogatą bibliotekę elementów, a dodatkowo w internecie można znaleźć "gotowca" do większości części, pojawia się czasami konieczność zaprojektowania własnej obudowy lub nawet wykonania biblioteki elementu od zera. Obiecaną trzecią część kursu chciałbym poświęcić właśnie tworzeniu biblioteki od zera. Przed rozpoczęciem prac warto zajrzeć do poprzednich części, jest tam szczegółowo omówiona większość podstawowych funkcji Eagle. Dodatkowo zachęcam do eksperymentowania w trakcie wykonywania kolejnych kroków - w razie problemów zawsze można cofnąć kilka ostatnich kroków (Ctrl + Z). Jako przykład wybrałem zyskujący coraz większą popularność w robotyce transoptor odbiciowy (czujnik linii) KTIR0711S. [blog]https://forbot.pl/blog/cadsoft-eagle-czesc-3-tworzenie-biblioteki-id1605[/blog]
  22. 6 punktów
    Witam serdecznie, konstrukcja którą stworzyłem jest pierwszym doświadczeniem tego typu, ponieważ bardzo interesują mnie roboty mobilne którymi można sterować ze znacznej odległości i wykonywać różnego rodzaje prace, tym bardziej fascynuje mnie to iż najprawdopodobniej tak będzie wyglądała nasza przyszłość gdzie większość czynności będą wykonywały zdalnie sterowane roboty, a także te ze sztuczną inteligencją. Dlatego też postanowiłem stworzyć niewielkim kosztem pojazd który będzie w stanie coś podnieść, przenieść, sfilmować z niewielkiej odległości. Długi czas myślałem nad rozwiązaniem jakie zastosować podwozie, idealne wydawało mi się podwozie gąsienicowe Tamiya, lecz było zbyt małe, dlatego też zastosowałem podwozie z koparki które dodatkowo posiada możliwość obrotu kabiną, niepotrzebną górę i cały korpus zdemontowałem i delikatnie przebudowałem aby powstała możliwość zainstalowania ramy nośnej wszystkich elementów, powstała tzw nadbudówka z wykorzystaniem plastikowych obudów w której znalazły się wszystkie elementy elektroniczne - ma to też taką korzyść że nie są narażone na czynniki zewnętrzne. Przystępując do pracy mając odpowiednie elementy takie jak serwa modelarskie, części mechaniczne, oraz chwytak zmontowałem ramię: Następnie konstrukcja zaczynała przypominać to co w chwili obecnej: lecz pojawiły się pierwsze problemy z jakimi musiałem walczyć, mianowicie było to mocowanie ramienia do ramy głównej i przeniesienie odpowiedniej siły, by nie opadało automatycznie pod własnym ciężarem, do tego też serwo chwytaka i obrotnika to Futaba o momencie 3,2kg, natomiast dwa kolejne są z metalowymi zębatkami Tower Pro 996R o momencie 12kg, a zastosowanie odpowiedniego przeniesienia mocy poskutkowało znakomicie co widać na zdjęciach: ramię nie opada samoczynnie, choć trochę waży. Kolejne etapy to planowanie rozłożenia poszczególnych elementów tak by całość nie przypominała stosu kabli. wtedy także pojawił się kolejny problem jakim było zasilanie wszystkich elementów, obecnie zostałem przy koszyku 6xAA choć to stanowczo za mało, niebawem spróbuję kupić koszyk na minimum 8sztuk lub pakiet około 11V, ponieważ jest trochę "odbiorników prądu" pod względem elektronicznym są to kolejno idąc od zasilania: 1.przetwornica oraz stabilizator napięcia z wyświetlaczem LED 2. Miniaturowa przetwornica napięcia 5V 800mAh - dla zasilania wentylatorka 3.Programator USB komunikacyjny z Arduino Mini Pro 4. Wyświetlacz LED mierzący napięcie wyjściowe drugiego obwodu zasilającego takie elementy jak oświetlenie LED oraz Arduino 5. Dodatkowa przetwornica napięcia 5V 800mAh dedykowana dla Arduino 6. Główny moduł Arduino Mini Pro ATmega328 z zegarem 16Mhz 7. Sterownik serwomechanizmów Mini Maestro Polulu 6-kanałowy 8. Sterownik bipolarnego silnika krokowego w wyposażeniu lecz aktualnie brak zastosowania Elektronika została podłączona w ten sposób by całość mogła być sterowana z poziomu Arduino, czyli sterownik serwomechanizmów Mini Maestro ma dwie możliwości kontroli nad serwami: pierwsza to bezpośrednio kablem USB, a druga to sterowanie przez moduł Arduino i tak np zapisanie na nim odpowiednich komend i ich późniejsze odtwarzanie, całość została zmontowana tak że można go wyposażyć o np czujniki odległości SHARP'a i napisać odpowiednie sekwencje ruchów, przekaźnik nie pełni tu istotnej roli w danej chwili gdyż odpowiada tylko za migotanie niebieskiej diody, pod moduł Arduino podłączony jest zestaw diod LED które migotają na pomarańczowo oraz czerwono, a także sterownik bipolarnego silnika krokowego którym można łatwo sterować, ale póki co nie znalazłem dla niego zastosowania. Po zmontowaniu całości i wyposażeniu w kamerkę oraz zastosowaniu w niej czerwonej migającej diody prezentuje się świetnie zwłaszcza w tak pomalowanym "bojowym" kolorze militarnym
  23. 6 punktów
    Wielce nieprawdopodobnym jest, by ktoś związany z branżą elektroniczną, robotyczną lub informatyczną nie słyszał o „superkomputerze Raspberry Pi” i wcale nie jest to coś zadziwiającego, ponieważ na długo przed fazą produkcji zaczęły zawiązywać się malinowe fankluby i społeczności wyznające malinową religię. [blog]https://forbot.pl/blog/raspberry-pi-w-robotyce-amatorskiej-1-wprowadzenie-id1254[/blog]
  24. 6 punktów
    Witam chciałbym wam przedstawić mojego pierwszego robota o nazwie MacLiner.Cała konstrukcja oparta na laminacie 3mm, która jest jednocześnie płytką drukowaną elektroniki. Robot jest w kształcie Koła. MECHANIKA Tradycyjnie jak prawie w każdym robocie tej klasy zastosowane zostały dwa silniki Pololu 30:1, ball caster który stanowi tylną podporę a także koła o średnicy 32mm tej samej firmy. ELEKTRONIKA Jako "mózg" został użyty mikrokontroler firmy Atmel z rodziny AVR ATmega32 z taktowaniem 16Mhz. Za sterowanie silnikami odpowiedzialny jest dwukanałowy mostek L298. Z początku obawiałem się użycia go ze względu na duży spadek napięcia, lecz jak się potem okazało w tej konstrukcji w zupełności wystarczał.Do wykrywania linii użyte zostały czujniki KTIR0711S (5 czujników ułożonych po okręgu ). Sygnał analogowy z sensorów zamieniany jest na cyfrowy przy użyciu komparatorów LM324 następnie podawany na piny atmegi. Za stabilizacje napięcia odpowiedzialny jest układ 7805, który dostawał napięcie w prost z 4 baterii alkalicznych 1,5v.Płytka została wykonana w warunkach domowych. Od razu odpowiem na pytanie(zapewne takie padnie). Z czego zrobiona jest soldermaska? Otóż jest to najzwyklejsza farba do witraży. STEROWANIE Myślę, że największą wadą tego robota jest właśnie program. Można było zauważyć to na zawodach SUMO CHALLENGE w Łodzi (zakręty pokonywał w moim odczuciu doskonale, lecz na prostych wyglądało to jak by jechał po sinusoidzie). Został wgrany regulator na samym członie P pisany w środowisku Bascom. PODSUMOWANIE Reasumując zebrałem dużo cennego doświadczenia, na pewno więcej czasu muszę poświęcić na napisaniu programu a także to że softem ciężko jest naprawić błędy mechaniczne/konstrukcyjne. Zapomniał bym o jeszcze jednej cennej praktyce, którą zdobyłem podczas budowy: zarywanie nocek przy projekcie dobrze się nie kończy co widać na jednym ze zdjęć(mam na myśli te źle rozmieszczone pady pod diody) Zdjęcia: MACLINER TEST [Youtube] [/Youtube][Youtube] [/Youtube]Autor projektu: *Mateusz Góra MacLiner.pdf
  25. 6 punktów
    Witam chciał bym przedstawić mojego pierwszego robota minisumo szamana 4 Robot ten powstał z myślą o zawodach, ale jak na razie jest w fezie testów.Robiłem go 3 dni ale pomysł powstał 1 miesiąc wcześniej. Elektronika. Robot jest sterowany atmegą8, wybrałem ją z powodu jej posiadania w domu. Czujniki to 2x GP2Y0D340K i 1x tcrt1000 podpięty do wzmacniacza operacyjnego i zainstalowanego z przodu.Zrezygnowałem z 4 czujników ponieważ sam jeden spełnia swoje zadanie.sterownikiem napędu jest mostek 293dne. Program. Program jest w całości napisany w języku bascom,na płycie głównej robota znajduje się złącze programistyczne(ISP). Napęd. Jako napędu użyłem przekładnię tamitya i koła z pololu jednakże, ogumienie nie spełniało moich oczekiwań zastosowałem własne gumy z drukarki . Zasilanie. Zasilanie stanowią 4 akumulatorki NI-MH 2500mAh firmy tronic.Całość jest stabilizowana stabilizatorem 5v Zrezygnowałem z robienia płytek bo nie lubię bawić się w wytrawianie. Na ich miejsce weszły płytki uniwersalne co okazało się głupim pomysłem . filmik z pracy oto kilka zdjęć autor Bartłomiej Zuba (zuba1)
  26. 5 punktów
    LiPol Charger v1.0 / v2.0 Szanowni czytelnicy forum w tym krótkim artykule przedstawię Wam projekt ładowarki do akumulatorów litowo-polimerowych 2 celowych (7,4V). Prace nad projektem rozpoczęły się bardzo dawno temu, co można było śledzić w tym wątku. Dużą rolę w trakcie projektowania samego układu odegrał kolega @marek1707. Tak naprawdę ostateczna forma pierwszej wersji ładowarki została bardzo mocno zasugerowana przez niego dzięki temu działa ona niezawodnie. Układy zostały zaprojektowane wedle następujących założeń: możliwość ładowania akumulatorów 2 celowych przy pomocy źródła zasilania o napięciu 5V i natężeniu prądu nie większym niż 1A (na tyle pozwalały zastosowane elementy elektroniczne) oraz ładowanie z wykorzystaniem 2 paneli słonecznych 6V/300mA, które aktualnie miałem pod ręką - stąd zastosowano układ przetwornicy typu boost, zastosowanie przewodowej lub bezprzewodowej komunikacji z komputerem PC, wykorzystanie diod LED do sygnalizacji stanów pracy ładowarki, (v2.0) wyświetlanie informacji na wyświetlaczu alfanumerycznym 2x16, (v2.0) dodanie przycisków do ręcznej interakcji użytkownika z urządzeniem, (v2.0) wbudowanie prototypu prostego balansera ogniw, (v2.0) wyprowadzenie padów do programowej kalibracji przetwornika ADC. LiPol charger v1.0 Wersja pierwsza ładowarki jest wersją niekombinowaną oraz dość niezawodną. Pełny cykl ładowania akumulatora obejmuje zarówno fazę CC (stałoprądową) oraz CV (stałonapięciową). Cykl ten świetnie obrazuje WYKRES, który podrzucił mi kolega @marek1707 i który zapamiętam do końca swojego życia Zasadę działania przetwornicy boost wydaje mi się, że każdy elektronik powinien znać. Jeśli jednak czytelniku nie miałeś okazji zapoznać się z tym rodzajem przetwornic podsyłam ciekawe artykuły na ten temat: LINK, LINK. W skrócie - na wejściu przetwornica otrzymuje napięcie maksymalne 6V oraz prąd maksymalny 1A. Sygnał PWM generowany przez mikrokontroler ze stałą częstotliwością, a zmiennym wypełnieniem otwiera lub zamyka tranzystor kluczujący przetwornicę, który dzięki temu reguluje napięcie lub prąd wyjściowy przetwornicy w zależności od fazy algorytmu ładowania CC/CV. Zastosowano w tym celu najzwyklejszy regulator proporcjonalny. Mikrokontroler ma możliwość pomiaru potrzebnych parametrów tj. napięcia i prądy wejściowe/wyjściowe oraz napięcie międzyogniwowe. Napięcia są mierzone poprzez dzielniki napięciowe natomiast pomiar prądów odbywa się z wykorzystaniem układów bocznikowych. Komunikacja z komputerem odbywa się poprzez moduł Bluetooth (BTM222 lub HC-05) lub z wykorzystaniem przejściówki USB-UART. Dodatkowo domowymi metodami wykonałem shield umożliwiający podłączenie wyświetlacza alfanumerycznego 2x16. Ostatecznie wykorzystując źródło napięcia stałego 5V/1A udało się uzyskać przetwornicę o sprawności ok. 65%. Całkiem niezły wynik jak na prototyp. Straty mocy są związane ze stratami na diodzie, indukcyjności oraz NIE zastosowaniu kondensatorów typu Low ESR. Wszystkie te parametry można jeszcze trochę poprawić przez co możliwe jest zwiększenie sprawności samej przetwornicy. Wykorzystanie do ładowania paneli słonecznych zmusiło do zastosowania najprostszego algorytmu MPPT - śledzenia punktu maksymalnej mocy. Panele słoneczne połączone są równolegle przez co uzyskano większy prąd wejściowy na przetwornicę. W tym połączeniu maksymalny prąd wejściowy wynosi 600 mA dla posiadanych przeze mnie paneli 6V/300mA. Biorąc pod uwagę to, że w polskich warunkach z tych paneli jestem w stanie wyciągnąć maksymalnie 70-80% całkowitej sprawności przy bezchmurnej pogodzie prąd ładowania akumulatorów jest niewielki. Dlatego ten tryb ładowania sprawdza się raczej przy niewielkich akumulatorach. Ale najważniejsze, że się sprawdza LiPol charger v2.0 Druga wersja ładowarki nie została jeszcze przetestowana!!! Natomiast wzbogaciłem ją o kilka praktycznych dodatków, których brakowało mi w poprzedniej wersji. Wersja v2.0 została wzbogacona o prototyp balansera złożonego z dwóch oporników dużej mocy oraz tranzystorów sterowanych z poziomu mikrokontrolera, który na podstawie pomiaru napięcia międzyogniwowego decyduje o tym, który obwód „strat mocy” załączyć. Jeśli któryś z tranzystorów zostaje otwarty, przez rezystor przepływa prąd, natomiast ładowanie danego ogniwa akumulatora jest pomijane. Dzięki temu możliwe jest wyrównanie poziomów napięć na obu ogniwach. Dodatkowo wyprowadzone zostały pady pomiarowe, które znacznie ułatwiają kalibrację odczytów z przetwornika ADC. Wbudowano również konwerter USB-UART na podstawie chipu FT230XQ, wyprowadzono również piny Rx i Tx w celu podłączenia np. modułu Bluetooth. W tym projekcie udało się znacząco zmniejszyć wymiary ładowarki. Kompletne schematy obu wersji ładowarki udostępniam w pdf’ach poniżej. LiPolCharger_v1_0.pdf LiPolCharger_v2_0.pdf Wykaz ważniejszych elementów wykorzystanych w układach ładowarek: mikrokontroler ATmega32 tranzystor kluczujący MOSFET-N STS12NF30L driver MOSFET MCP1402T cewka 220 uH wzmacniacze operacyjne LM358 wyświetlacz alfanumeryczny 2x16 konwerter USB-UART FT230XQ, tranzystory bipolarne NPN i PNP dowolne, pod warunkiem, że maksymalny prąd kolektor-emiter będzie większy niż 1A. Jeśli ktoś z czytelników będzie zainteresowany tematem owych ładowarek serdecznie zapraszam do zadawania pytań w komentarzach, a także ewentualnego krytykowania (oczywiście konstruktywnego) mojego projektu.
  27. 5 punktów
    Pojawiła się potrzeba wykonania prostego sterownika do bramy garażowej, który miałby powiadamiać mieszkańców czy aktualnie garaż jest zamknięty czy otwarty oraz w dowolnej chwili sprawdzić status. Tak powstało niewielkie urządzenie montowane na szynę DIN. Jest zasilane z dowolnej ładowarki od telefonu, posiada zabezpieczenie przed odwrotną polaryzacja zasilania. Sterownik ma kilka wejść/wyjść; IN1 - dolna krańcówka od zamknięcia garażu. IN2 - górna krańcówka od pełnego otwarcia garażu. wyjście przekaźnikowe NO do zdalnego otwierania/zamykania bramy. RS485 - pozwala podłączyć czujnik odległości wykrywający czy auto jest w garażu. czujnik temperatury DS18B20. przycisk do resetowania ustawień WiFi i uruchomienia ponownej konfiguracji. W sterowniku zastosowałem popularny układ ESP8266 w wersji WemosD1 mini. Jak widać za wiele rzeczy tu nie ma, oprócz ESP znajduje się przekaźnik, DS18B20 oraz transceiver RS485. Projekt miał być prosty, szybki i jednostkowy dlatego nie zastosowałem dodatkowych stopni ochrony wejść w postaci np. optoizolacji. Tradycyjnie płytka powstała na żelazku i wytrawiona w kwasie. Polutowana i zabezpieczona lakierem do PCB. Schemat ideowy: Wspomniany wcześniej czujnik odległości jest zbudowany z wykorzystaniem ultradźwiękowego czujnika HC-SR04 i Arduino Nano, które cyklicznie wysyła informacje do głównego sterownika. Schemat czujnika: Sterownik ma zaimplementowany serwer WWW co pozwala na sterowanie praktycznie dowolnym urządzeniem z przeglądarką. A panel sterowania prezentuje się tak: Dodałem obsługę powiadomień push na telefon z wykorzystaniem mechanizmu IFTTT (if this then that). Wystarczy zainstalować tą aplikacje na telefonie, a w sterowniku wprowadzić unikalny klucz aplikacji powiązany z konkretnym telefonem. Aktualizacja oprogramowanie wykorzystuje mechanizm OTA i sprowadza się do wgrania pliku przez panel www. Dodatkowo wystawione jest proste API, które pozwala na integracje z większością systemów smart home typu Domoticz, Home Assistant itp.
  28. 5 punktów
    Cześć, Jestem z Koła Naukowego Robotyków z Politechniki Warszawskiej. Niedawno stwierdziliśmy, że w sumie fajnie by było opisać gdzieś nasze konstrukcje. Jako, że zdarza nam się korzystać z zasilaczy z czarnej listy, padło na forbota . Na pierwszy ogień chcieliśmy wypuścić jedną ze starszych maszyn – Minotaura. Jego historia była dość ciekawa – na 3 tygodnie przed ubiegłorocznymi zawodami Robomaticon razem z kolegą stwierdziliśmy, że może fajnie byłoby wystawić tam jakiegoś Micromouse’a. Postawiliśmy zatem na jak najprostsze rozwiązania, które z jednej strony pozwoliłyby nam przetestować różne algorytmy jazdy, z drugiej zaś zaoszczędziłyby czasu na wykonanie oraz programowanie. Dzięki temu jednak konstrukcja jest dość prosta i może być dobrym projektem dla początkujących robotyków. Mechanika Bazę montażową dla całego robota stanowi obudowa wydrukowana na drukarce 3D. Pierwsza wersja zakładała, że podstawa robota będzie rozpostarta na kwadracie o długości 110 mm o zaokrąglonych narożach. Po wykonaniu prototypu oraz pierwszych testach bardzo szybko okazało się jednak, że robot jest zdecydowanie za duży. Z uwagi na to, że możliwe okazało się zmniejszenie odległości pomiędzy silnikami bez uszczerbku na działaniu enkoderów magnetycznych, zdecydowano się znacznie ograniczyć wymiary robota. Kolejna (ostateczna) wersja robota miała już w podstawie kwadrat o boku 80 mm. Aby móc ograniczyć wymiary, zdecydowano się na węższe ścianki boczne. Z uwagi na dużą łamliwość, zrezygnowano z drukowanych mocowań do płytek z elektroniką i zastąpiono je gotowymi, plastikowymi dystansami. Ostateczny wynik można oglądać na zdjęciu poniżej: W robocie Minotaur zdecydowano się na zastosowanie silników POLOLU z metalową mikroprzekładnią 50:1 z obustronnym wałem. Pozwoliło to na zastosowanie enkoderów magnetycznych tej samej firmy. Na wałach silników zamocowano wykonane metodą druku 3D koła. W pierwszej wersji zastosowano opony odlewane z silikonu, jednak później (ze względu na dość szybkie zużywanie się silikonowych) zdecydowano się na wykorzystanie opon Kyosho Mini-Z. Pozwoliło to zminimalizować poślizgi. Dodatkowymi elementami są elementy podporowe, oklejone taśmą teflonową oraz górna pokrywa robota, do której jest mocowana bateria. Elektronika Ze względu na małe zasoby czasowe oraz dostępność części w laboratorium elektronika robota Minotaur została oparta na Arduino Uno. Prawie cała pozostała elektronika (z wyjątkiem sensorów) została umiejscowiona na shieldzie wpinanym w Arduino. Poza wspomnianymi wcześniej silnikami z enkoderami, zastosowano jedynie kilka komponentów. mostki TB6612FNG, które (ze względu na przykre doświadczenia w poprzednich konstrukcjach) zastosowano po jednym dla każdego silnika (zwarto wyprowadzenia). Za interfejs użytkownika służyły 1 przycisk oraz 1 dioda. Poza tym za pomocą dzielnika napięcia monitorowano stan baterii. Aby poprawić jazdę, zdecydowano się na zastosowanie czujnika IMU (Pololu Mini-IMU 9), który znaleźliśmy w laboratorium. Jednak, nawet przy wyłączonym żyroskopie robot radził sobie w labiryncie. Wypinany moduł Bluetooth służył głównie do doboru nastaw podczas programowania (obecnie nie jest on wykorzystywany). W robotach zastosowano czujniki odległości stworzone z 2 diód IR oraz fototranzystora. Światło emitowane przez diodę IR odbija się od ściany labiryntu i wraca do fototranzystora. Zastosowano jedynie 3 takie czujniki, umiejscowione na środku ścian robota. Jeden z nich ma za zadanie sprawdzać, czy ściana jest na wprost. Pozostałe 2 umiejscowione na bokach sprawdzają, czy ścianka istnieje z boku. Pozwalają także robotowi utrzymać stałą odległość pomiędzy ściankami. Innym ich wykorzystaniem jest snapowanie – jeżeli robot ma mały błąd kątowy (liczony na bieżąco), to w momencie gdy jakaś ścianka mu się kończy, aktualizuje swoje położenie. Algorytm Podobnie jak w większości konstrukcji, które nie poruszają się metodą prawej/lewej dłoni, w robocie został zaimplementowany algorytm „flood fill” - zalewania wodą (Bellmana - Forda). Naszą jedyną modyfikacją, była preferencja jazdy prosto (obrót jest dla nas bardziej kosztowny). Aby nie zmuszać bardziej zaawansowanych czytelników do przewijania, początkujących odsyłam do linku: [LINK] Aby móc choć nieco przystosować się do warunków zmiennego oświetlenia, na początku każdego przejazdu dokonujemy kalibracji. Aby robot mógł swobodnie poruszać się po labiryncie powinien on potrafić wykonywać 2 podstawowe ruchy: jazda do przodu oraz skręt (o 90o w prawo i lewo, obrót o 180o). Przed jazdą powinien on jednak skalibrować czujniki. Do obrotu wykorzystywane są dwa czujniki: enkodery oraz żyroskop. Wiodącym czujnikiem jest żyroskop, z którego po scałkowaniu prędkości otrzymujemy kąt obrotu. Enkodery wykorzystywane są głównie do kontroli prędkości obrotowej kół, aby robot obracał się w miejscu bez zbędnego przemieszczenia (jeśli oba koła kręcą się z ta samą szybkością wówczas robot obraca się wokół swojego środka). Aby zminimalizować szanse kolizji robota ze ścianami labiryntu podczas jazdy wykorzystuje się odczyty z trzech typów czujników: odległości, enkoderów oraz żyroskopu. Każda z tych wartości jest uwzględniana z odpowiednią wagą, która została dobrana w sposób eksperymentalny. Wagi nie są jednak stałe, ale zależne od ułożenia ścianek lub ich braku. Do utrzymywania kierunku wykorzystywane są enkodery oraz żyroskop, natomiast czujniki odległości służą do utrzymywania robota w równych odstępach od bocznych ścianek niwelując niedokładności obrotów. Do jazdy na wprost podobnie jak podczas obrotu wykorzystywany jest regulator PD. Innym ważnym aspektem jest pokonywanie zadanego dystansu, jest to długość pojedynczej komórki. Błędy podczas pomiaru odległości mogą skutkować złym zmapowaniem labiryntu bądź kolizją ze ścianką. Korzystając z faktu, że kształt labiryntu jest znormalizowany możemy bazować robota do punktów charakterystycznych (w tym wypadku jest to początek bądź koniec ścianki). Korzystając z bazowania co pewien czas zerowany jest błąd położenia (np. w miejscach pokazanych na rys. poniżej). I na koniec coś co wszyscy lubią najbardziej, czyli robot w akcji. Niestety nie jest to najnowsze wideo, ale na pewno w najlepszej jakości, czyli przejazd robota podczas zawodów ISTROBOT w Bratysławie.
  29. 5 punktów
    Ostatnio zauważyłem duże zainteresowanie tematem wykorzystania laminarek do przenoszenia termotransferu. Temat rozpoczął Nawyk i od tego momentu pojawiały się pytania. Nawyk polecał laminarkę Lervia KH4410, której używał bez przeróbek. Co jakiś czas poszukiwałem na Allegro tego modelu laminarki, lecz nic znaleźć nie umiałem. W końcu jednemu z użytkowników forum (chwalić się, który ) znalazł tą laminarkę - jej nazwa nie jest ujęta w tytule aukcji, stąd problem. Namiary na aukcję: LAMINARKA dwustopniowa na Gorąco i Zimno PODAJNIK Sprzedający: tanieAGD Cena: 59zł bez wysyłki. Bez dłuższego namysłu laminarkę zakupiłem. W paczce była laminarka, "podstawka" (prowadnica?) na papier (która się do płytek nie przyda) oraz po 10 folii w 3 rozmiarach. Wypadła jakaś luźna śrubka, nie wiem gdzie miała przynależeć, ale nic złego się na razie nie dzieje. Sprzęcior wygląda tak: Jak widać zbytniej filozofii nie ma. Z prawej dwa przełączniki, do włączania laminarki oraz przełącznik temperatur (używamy najwyższej). Z lewej strony chwilowy przycisk do zatrzymywania wałków. Po włączeniu laminarki wałki kręcą się cały czas, nagrzanie się do odpowiedniej temperatury jest sygnalizowane przez zielona diodkę nad przełącznikiem. Czas było coś wykonać. Płytka dwustronna, laminat 1,5mm. Dwie warstwy zwyczajowo najpierw spasowałem pod światło, potem złączyłem zszywaczem w kilku miejscach, spłaszczyłem zszywki kombinerkami i między papier wsunąłem wyczyszczony uprzednio laminat. Taki pakiet przeszedł 15 przejść przez laminarkę. Przy niektórych przejściach laminarka trzeszczy, ale nic niepokojącego się nie dzieje - widocznie wałki muszą się nieco rozejść. Filmik (w jakości HD ) pokazuje pojedyncze przejście laminatu przez laminarkę, słychać wyraźnie trzeszczenie: Fragment płytki po zdjęciu papieru kredowego (płytka jeszcze mokra, widać resztki papieru - płytka lądowała później w occie): Wnioski: Laminarka prawdopodobnie posłuży już tylko do płytek, ponieważ wałki po czasie się rozejdą. Przy brzegach nagrzewa słabo - trzeba sobie zostawić margines, ponieważ w przeciwnym wypadku ścieżki przy krawędziach prawdopodobnie odejdą. Zaoszczędzamy sporo nerwów swoich i właściciela żelazka, którego używamy do termotransferu. Płytki są powtarzalne, docisk jest mniej-więcej taki sam na całej powierzchni, przez co nie ma już tak, że na części toner jest rozlany, a gdzie indziej odchodzi. Dokładność lepsza niż żelazkiem, nie próbowałem jakie najcieńsze ścieżki da się wykonać, z tego co pamiętam Nawyk taki test przeprowadzał, zdjęcie jest gdzieś na forum (piwo dla znalazcy ). Podsumowanie: Przydatne narzędzie dla wygodnych, przy większej wprawie bardzo zbliżone efekty można pewnie uzyskać żelazkiem (pytanie - po ilu próbach). Ja osobiście mogę polecić. Aby zamknąć wszystkie pytania na temat zastosowania laminarek do produkcji płytek w jednym miejscu, proszę się pytać w tym temacie.
  30. 4 punkty
    Manipulator "Copernicus" to mój najnowszy projekt, model 4-osiowego robota przemysłowego z ssawką podciśnieniową jako efektorem. Bezpośrednim przyczyną rozpoczęcia budowy był zachwyt nad tego typu profesjonalnymi konstrukcjami, typu Kuka, ABB, Fanuc itd., a które można podziwiać między innymi na różnych targach przemysłowych Robot powstawał w ekspresowym jak dla mnie tempie, około 2 miesięcy, a jego budowa nie byłaby możliwa bez wsparcia sponsorów, którym chciałbym w tym miejscu serdecznie podziękować: Agencji Pracy MONDI Polska, która w ramach programu stypendialnego Mondi Wspiera Talenty sfinansowała większość niezbędnych elementów i części; Firmie IGUS Polska, która jako próbkę udostępniła mi przekładnię ślimakową RL-D-30; Firmie STMicroelectronics, dzięki której otrzymałem płytkę Nucleo; Zespołowi Szkół Łączności im. M. Kopernika w Poznaniu, również za pomoc finansowo-merytoryczną. Dobrze, na początek kilka zdjęć ogólnie przedstawiających robota - przepraszam za nienajlepsze tło, zdecydowanie lepiej ideę pracy robota wyjaśniają filmy Konstrukcja jest trójmodułowa, pierwsze cztery zdjęcia ilustrują właściwego robota, piąte przedstawia stację generującą podciśnienie, dwa ostatnie to sterownik robota Mechanika Podstawę robota stanowi prostokąt plexiglass'u 10mm. Pierwsza oś swobody jest pryzmatyczna, składa się z dwóch prowadnic liniowych ø10 i listwy zębatej. Następnie, na wózku z łożyskami liniowymi DryLin, również firmy Igus, znajduje się pierwsza oś obrotowa z wspomnianą już przekładnią ślimakową. Następnie, trzecią oś swobody, a drugą obrotową stanowi silnik z przekładnią planetarną oraz paskiem zębatym HTD. Ostatnią, czwartą oś, służąca ustawieniu ssawki prostopadle do powierzchni, stanowi ssawka podciśnieniowa Festo, bezpośrednio obracana przez silnik krokowy NEMA17. Taki sam silnik napędza przekładnię ślimakową, natomiast w pierwszej i trzeciej osi wykorzystałem, jak wspomniałem, silniki z wbudowaną przekładnią planetarną. Elektronika Sterownik robota jest trójpoziomowy - na pierwszym z nich znajduje się gniazdo trapezowe, sygnalizatory napięć i 2 zasilacze - 24V/8,5A oraz 12V/5A. Ten pierwszy zasila tylko silniki, natomiast drugi - pompkę podciśnieniową, elektrozawór i wszystkie pozostałe elementy, wykorzystując w tym celu przetwornicę step-down (dającą na wyjściu 5V DC - Nucleo wykorzystuje własny, znajdujący się na płytce stabilizator 3,3V). Na drugim poziomie znajdziemy wspomniane Nucleo F103 i przetwornicę, 2 przekaźniki do sterowania pompką i elektrozaworem, płytkę dystrybuującą zasilanie oraz 4 sterowniki silników krokowych TB6560. Na trzecim poziomie - przycisk bezpieczeństwa i 2 wentylatory. Płyty w sterowniku wykonane są również z plexi 5mm. Do połączeń sterownik-robot-stacja generująca podciśnienie używam w większości złącz wielopinowych dedykowanych automatyce. Robot posiada czujniki krańcowe, potrafi się zerować. Oprogramowanie Napisałem program w Arduino IDE, który zawiera kinetykę odwrotną liczoną z zależności geometrycznych oraz korzystając z biblioteki AccelStepper() steruje "na sztywno" wszystkimi czterema silnikami krokowymi. Następnie wpisałem kilkanaście punktów, i tak robot układa krążki i rozkłada, i tak w pętli... Osiągnięcia, dalsze plany i film Aktualnie, robot może pochwalić się wzięciem udziału w RoboDay 2019 (pokazy na Politechnice Poznańskiej) i II miejscem na µBot (zawody organizowane przez V LO Kraków). Projekt jest aktualnie zamknięty, ale myślę nad rozwojem konstrukcji, na przykład dodaniem kamery PixyCam2. Opis jest dość zwięzły - gdybyście mieli jakiekolwiek pytania, chętnie dopowiem szczegóły Pozdrawiam, wn2001
  31. 4 punkty
    Krótki opis mojego projektu, zamieszczony również na zaprzyjaźnionym forum, a za pomoc i zaangażowanie, teraz i w przyszłości, dziękuję wszystkim pomocnym z forum FORBOTa : Do zbudowania układu posłużyły mi: klon Arduino MEGA, ethernet Shield do wyżej wymienionego, kilka(podłączony na razie jeden) czujników temperaturyDS18B20, dwa czujniki typu DHT11, ale zamienię je chyba na DHT22, czujnik ciśnienia i temperatury BMP280 I2C, moduł zegarowy RTC1307 I2C, enkoder z przyciskiem, wyświetlacz LCD 20×4 I2C, listwa diod programowalnych 8szt (będzie zamieniona na dwie po 4 szt), czujnik deszczu, buzzer bez generatora, tablet. Układ mierzy temperaturę w dwóch miejscach w domu, na zewnątrz temperaturę w słońcu, przy gruncie i 1m nad gruntem w cieniu. Dodatkowo mierzy ciśnienie atmosferyczne, wilgotność zewnętrzną i wewnętrzną oraz temperaturę wody w CO. Funkcją dodatkową jest alarm wywoływany przy pierwszych opadach deszczu, a także (na wyraźne życzenie żony) alarm informujący kiedy pralka w piwnicy skończyła pracę. Kolejną funkcją układu jest sterowanie pracą 8 przekaźników obsługujących min. bramę, furtkę, oświetlenie. O stanie pracy przekaźników informują programowalne diody LED. Enkoder służy do poruszania się po menu na LCD20x4(prawo, lewo, przycisk), każdy obrót i wciśnięcie jest sygnalizowane przez buzzer. Docelowo planuję dołożyć czujnik zanieczyszczenia powietrza, mierzący pył PM2,5, PM10. Wszystkie dane z czujników są na bieżąco wyświetlane i przewijane na LCD 20×4, po wciśnięciu przycisku enkodera wchodzimy w menu opcje gdzie możemy na LCD20x4 sprawdzić najwyższy i najniższy odczyt każdego z czujników, datę tego odczytu oraz zresetować pamięć dla każdego odczytu i czujnika z osobna. Pierwszą pozycją w menu opcje jest kolejne podmenu Włączniki, w którym możemy sterować poprzez enkoder wszystkimi ośmioma przekaźnikami. Każdy z przekaźników jest sterowany sygnałem z arduino idącym przez bramki OR do których dochodzą także sygnały z zewnętrznych włączników naściennych. Dopiero sygnał za bramką OR idzie do przekaźnika oraz dodatkowo jako potwierdzenie wraca do arduino. Dioda led informuje o włączeniu przekaźnika także, kiedy tenże jest włączony „poza arduino” przez włącznik naścienny. Informacja o tym fakcie wraca do arduino powodując odpowiednie zmiany zmiennych i na bieżąco aktualizując diody led i informacje wyświetlane na LCD 20×4. Osobną sprawą jest BLYNK który miał służyć początkowo tylko do kontroli przez telefon nad przekaźnikami, ale po poznaniu jego możliwości, całkowicie zmieniłem założenia i teraz to tablet z zainstalowanym Blynkiem jest głównym wyświetlaczem i sterownikiem całego układu. Na tablecie mam podmenu: przekaźniki, czujniki, max i min, historia, alarmy. W menu przekaźniki sterujemy z tableta i telefonu, w dowolnym miejscu na świecie, przekaźnikami, otrzymując z powrotem informację o faktycznym włączeniu przekaźnika(zmiana koloru widgeta oraz wyświetlonego na nim napisu) , także przez kogoś innego(przez włącznik ścienny, lub drugie urządzenie:tablet lub telefon). Choć poprzez udostępnienie tokena do naszego projektu takich urządzeń może być więcej. Drugie menu to wyświetlanie danych z wszystkich czujników odświeżane co 1 min, oraz mała „dioda led” migająca i informująca o prawidłowej komunikacji apka-arduino. Kolejne menu to ekran z rozwijanym podmenu na którym wyświetlone są nazwy wszystkich czujników i poprzez wybór któregoś z nich możemy sprawdzić(podobnie jak to było na LCD20x4), najniższą i najwyższą wartość i zresetować pamięć dla każdego czujnika osobno. Następne menu to historia, ja mam ustawione wyświetlanie na wykresach historii odczytów ciśnienia atmosferycznego i wigotności. Ostatnie menu to alarmy. Po pojawieniu się na odpowiednim pinie arduino sygnału z czujnika deszczu lub sygnału o końcu pracy pralki, na wyświetlaczu LCD20x4 przestaje się przewijać informacja o dacie, godzinie i odczytach z czujników, a wyświetla się info o alarmie z odpowiednią treścią, albo o pralce albo o deszczu. Dodatkowo listwa diod led miga jak szalona wszystkimi kolorami i sposobami. Po wciśnięciu enkodera lub upływie ustawionego czasu alarm wyłącza się. Informacja o alarmie pojawia się też na tablecie i telefonie, w sposób wizualny i dźwiękowy, poprzez wybraną melodię z pamięci talefonu/tableta. Dodam jeszcze, że do tabletu dam dorobić fajną ramkę, w której tenże tablet umocuję, dodatkowo w ramce umoieszczę listwy led informujące o stanie przekaźników, niezależnie od tabletu i wyświetlanego na nim menu, a ramka przy okazji będzie też kryć kabel zasilający tablet:-) To chyba tyle, jakby coś to pytajcie i doradzajcie:-)
  32. 4 punkty
    Ze względu na cenę, prostotę, wystarczającą do latania jakość i małe opóźnienia systemy FPV posługują się pradawnym standardem telewizji analogowej PAL. Dlatego na wyjściu takiego odbiornika dostajesz sygnał tzw. composite video po jednym drucie i to wprowadzasz do monitora, którym może być zwykły telewizor z odpowiednim wejściem, gogle itp. Jeśli chcesz taki sygnał wciagnąć do komputera (niechby i do Maliny) potrzebujesz tzw. frame grabbera czyli urządzenia, które "rozumie" analogowy sygnał CVSB, "rozpakowuje go" na kolejne ramki obrazu, ew. kompresuje i udostępnia w postaci cyfrowej np. przez USB. Poszukaj hasła "usb frame grabber" lub np. "usb video capture" - powinno pomóc. EDIT: Pierwszy z brzegu: https://rc-planeta.pl/pl/okablowanie-i-akcesoria/666-konwerter-fpv-usb-grabber-konwerter-video.html ale jest tego pełno.Szukaj w sklepach modelarskich albo RTV/AGD w działach video lub na aukcjach.
  33. 4 punkty
    RozZuBeN – Robot z Zupełnie Bezsensowną Nazwą Jest to robot klasy nanosumo, który został stworzony na wiosnę 2018 roku przez Pojemnika i mnie - wtedy uczniów pierwszej klasy VIII LO w Poznaniu. Zainteresowaliśmy się tą kategorią na Robomaticonie 2018, gdzie nie było żadnego sumo w tej skali. Pomyśleliśmy, że gdybyśmy mieli akumulator z silnikiem, to byśmy łatwo zgarnęli nagrodę za ostatnie (pierwsze!) miejsce. Tak powstał ten robot. Przestudiowaliśmy regulaminy różnych zawodów i wyodrębniliśmy minimalne założenia które musi spełniać nasz robot podczas zawodów: Poruszanie się Nieporuszanie się (przed startem) Po starcie nie może się zatrzymać na dłużej niż 30 sekund Czekanie 5 sekund po starcie Fajnie by było, gdyby sam z siebie nie wypadał z ringu Udało nam się spełnić wszystkie 5 punktów. Płytka: O ile 1, 2 i 3 punkt założeń projektowych można rozwiązać jednym przełącznikiem, to do czwartego potrzebne by było jakieś opóźnienie (układ RC lub popularny NE555 z tranzystorem). 5 punkt przekonał nas do użycia mikrokontolera. Zastosowaliśmy attiny84, które ilością pinów cyfrowych zapewniło nam dużą elastyczność w projektowaniu płytki. Taktowany jest wewnętrznym oscylatorem (miał być zewnętrzny generator kwarcowy ale nie mogliśmy go polutować). Umieściliśmy sterownik silników A3901 z którego wykorzystujemy tylko jeden z dwóch kanałów, dwa czujniki KTIR0711s jako czujniki krawędzi ringu podłączone bezpośrednio do ADC mikrokontrolera, dwa ledy sygnalizacyjne (zielony i bursztynowy, który jest w praktyce pomarańczowy ), przełącznik do startowania robota, dzielnik rezystorowy do mierzenia napięcia akumulatora (chyba nawet niewykorzystany), złącze do programowania (2x3 żeńskie goldpiny precyzyjne) i stabilizator napięcia na 3,3V w obudowie SOT23 (nie pamiętamy oznaczenia). W Eaglu zrobiliśmy kwadrat 25x25mm, rozmieściliśmy elementy „na oko”, połączyliśmy ścieżkami, i wysłaliśmy do OSH Parku. Zajęło nam to dwie godziny. Był to koniec marca, płytka przyszła w połowie maja. Wcześniej zamówiliśmy wszystkie elementy, ale oczywiście pomyliliśmy attiny84 z attiny88, więc złożenie potrwało trochę dłużej niż przewidywaliśmy. Płytkę lutowało się całkiem dobrze, choć do drobnych elementów chyba jednak lepsze są płytki cynowane zamiast złoconych (niby złoto lepiej przewodzi prąd ale cynę najlepiej się lutuje do innej cyny). Praktycznie od razu płytka dogadała się z programatorem (co nie było takie oczywiste w naszych poprzednich robotach). Konstrukcja mechaniczna: Mieliśmy kilka pomysłów na spełnienie pierwszego założenia projektu: silniczek wibracyjny z jakiegoś telefonu, żeby robot tylko drgał (przecież ruch to ruch) albo umieszczenie dwóch silników tak by stykały się wałami z podłożem, aby nie była potrzebna przekładnia, mechanizmy sprężynowe chyba też były... Porządna przekładnia z zębatek odpadała, bo nie wiedzieliśmy jak ją zrobić. Ostatecznie wykorzystaliśmy przekładnię cierną. Wał silnika z nałożoną rurką termokurczliwą (dla lepszego tarcia) jest przyciśnięty do opony jedynego w robocie kółka wyciągniętego z jakiejś zabawki. Brzmi to okropnie i tak też zostało to zmontowane. „Felga” kółka trze o korpus silnika, więc to miejsce musi być często smarowane wazeliną techniczną, żeby robot nie zaciął się podczas walki. Wszystko jest zalane gorącym klejem z drucikami z goldpinów tworzącymi swego rodzaju usztywnienie. Czasem gorący klej sprawiał problemy czujnikom przeciwników (nie wiemy dlaczego). Robot o jednym kółku nie przewraca się, ponieważ na całej podstawie ma przyklejony kawałek styropianowej tektury znaleziony w szufladzie. Przed i za kołem znalazło się też trochę miejsca na ktiry. Wszystko połączyliśmy kabelkami, przykleiliśmy akumulator (Li-Po 1S 150 mAh) (oczywiście też na gorący klej) i włączyliśmy. Okazało się, że silnik jest za mocny i wywraca robota tuż po starcie, ale i tak byliśmy dumni, że robot porusza się całkiem skutecznie. Zrezygnowaliśmy też z przełącznika, który był bardzo niewygodny i zastąpiliśmy go odbiornikiem IR. Nie chcieliśmy się bawić z dekodowaniem sygnałów, więc sygnał połączyliśmy dużym kondensatorem do masy zmieniającym dane na jedną dłuuugą jedynkę odczytywaną przez procesor. Program: Po wielu próbach doszliśmy do wniosku, że najlepiej jest poruszać się metodą krótkich „skoków” polegających na szybkim włączeniu i wyłączeniu silnika (wtedy robot nigdy się nie przewracał). Po każdym „skoku” robot sprawdza czy jest na krawędzi. Jeśli tak to zaczyna poruszać się w drugą stronę i zapala bursztynowego leda. Po 10 sekundach ruchu robot zatrzymuje się na równe 10 sekund aby to przeciwnik zużywał akumulator. Całość powtarzana jest aż do utraty zasilania. Ta technika działa zaskakująco dobrze w przypadku konfrontacji z robotem, który też jest „ślepy”. Podczas ruchu może niechcący wypchnąć przeciwnika, a kiedy stoi bardzo ciężko jest go ruszyć (chyba, że przeciwnik jest rozpędzony lub ma dobre silniki). Akumulator starcza na bardzo dużo często remisowych walk. Zwykle ładujemy go przed zawodami do 4,20V a po walkach nadal ma ponad 4,10V. Osiągnięcia: 2018: 3. miejsce Bałtyckie Bitwy Robotów 3. miejsce Robocomp 2. miejsce Sumo Challenge 2019: 4. miejsce Robotic Arena 1. miejsce Robomaticon Robot tylko na Robotic Arena zajął ostatnie miejsce. Na każdych zawodach miał 3 przeciwników, więc na Robomaticonie wygrał ze wszystkimi! (z czego z jednym walkowerem) Wnioski: Robot spisuje się niespodziewanie dobrze, co obrazuje niestety poziom konkurencji w Polsce. Aktualnie kończymy prace nad kolejną konstrukcją, która tym razem będzie miała dwa kółka i będzie widzieć przeciwnika, co pozwoli liczyć na walkę a nie tylko łut szczęścia. Mamy nadzieję, że aktywnie zawalczy o pierwsze miejsca. Kilka filmów z zawodów: Chętnie odpowiemy na wszystkie pytania dotyczące robota.
  34. 4 punkty
    Cześć, od kiedy opisałem swojego robota Pika na forum, minęło już troszkę. W tym czasie zdążyło powstać kilka kolejnych konstrukcji, zarówno bez turbiny jak i z turbiną. W tym poście chciałbym przybliżyć Wam moją najnowszą konstrukcję - robota klasy Linefollower Turbo o nazwie Spark. Głównym założeniem, jakie przyświecało mi podczas projektowania była chęć nauczenia się wektorowego sterowania silnikami BLDC oraz wykorzystanie właśnie takich silników jako napęd bezpośredni w robocie. Podczas opisu założeń konstrukcyjnych posłużę się modelem 3D robota. Jak można zauważyć na powyższym zdjęciu, ogólna konstrukcja nie różni się od znanego wszystkim standardu. Na przedzie delikatna i lekka listewka z 14 czujnikami linii KTIR0711S. Centralnie umieszczona turbina QX-Motor 14000 kv o średnicy 30 mm. Dwa silniki hexTronik 1300KV umieszczone w tylnej części w taki sposób, aby możliwe było uniesienie przodu celem wjazdu na pochylnię/rampę w kategorii Linefollower Enchanced. Sercem robota jest mikrokontroler STM32H743VIT6. Jest on oparty na rdzeniu Cortex M7 oraz taktowany z prędkością 400 MHz. Wybór tak potężnej jednostki sterującej podyktowany był chęcią wydajnego obliczania komutacji sterowania wektorowego dla każdego z silników jezdnych oraz realizacji algorytmu jazdy przy pomocy tylko jednej jednostki. Dodatkowo tak szybki mikrokontroler pozwolił na zatuszowanie moich niedoskonałości w optymalizacji kodu Głównym elementem konstrukcyjnym jest 4-warstwowy obwód drukowany. W trakcie projektowania falowników do sterowania silnikami powstały dwa prototypy, w których miałem problem z przegrzewającymi się tranzystorami dlatego w docelowym PCB zastosowałem aż 4 warstwy. Dodatkową zaletą takiego obwodu jest jego większa odporność na zakłócenia elektromagnetyczne. Podświetlony obszar to miedź na wszystkich czterech warstwach połączonych setkami przelotek chłodząca tranzystory. Do sterowania każdym z silników wykorzystałem 6 tranzystorów w układzie pełnego mostka 3-fazowego. Posłużyły mi do tego półmostkowe układy BSG0813NDI za których udostępnienie serdecznie dziękuję firmie Infineon (oraz za tranzystory i drivery, które spaliłem w prototypach - ok 60 sztuk, nie od razu Rzym zbudowano ) Ostatecznie jako drivery wykorzystane zostały układy MIC4607-2 ze względu na możliwość sterowania całym mostkiem przy pomocy tylko jednego układu. Do odczytywania pozycji wirnika służy enkoder magnetyczny AMS5045B. Całość zasila akumulator Li-Po Tattu 450mAh 7.4V 75C. Za komunikację bezprzewodową odpowiada stary dobry moduł HC05. W celu zapewnienia pod robotem podciśnienia wywoływanego turbiną, zwiększającego nacisk kół na podłoże obrys uszczelniony został wydrukowaną w 3D ścianą. Do usztywnienia konstrukcji tak, aby opierała się ona o podłoże tylko kołami i ślizgaczami z przodu, posłużyły wałki węglowe o średnicy 4 mm. Do połączenia ze sobą poszczególnych elementów konstrukcyjnych wykorzystane zostały aluminiowe mocowania wykonane w technologii WEDM. Poniżej kilka fotek. Prototyp 1: Ratowanie prototypu 1 (rezystory bramkowe? A na co to potrzebne ) : Prototyp 2: Elementy konstrukcyjne: Pierwsze ruchy silnika: Poszukiwanie granic: Opona wykonana z poliuretanu 20': Aluminiowa felga wciśnięta na wirnik (Pololki dla skali): Zamontowana felga wraz z oponami (Mini-Z 20'): Turbina po dezintegracji (podczas jazdy eksplodowała): Przejazd w konkurencji Linefollower Drag podczas Bałtyckich Bitw Robotów 2018: Próby podczas RobotChallenge 2018 w Pekinie: Wnioski: Konstrukcja waży 250 g. To zdecydowanie za dużo, gdyż opony nie są w stanie zapewnić wystarczającej przyczepności na zakrętach i robot wpada w poślizg na zakrętach przez co osiągnięcie prędkości średniej na krętej trasie powyżej 3 m/s jest bardzo trudne. Zastosowanie silników BLDC jako direct-drive umożliwia rozpędzenie robota do ogromnych prędkości liniowych (15 m/s+) lecz aby posiadały one zadowalający moment przy niskich obrotach konieczny do gwałtownych zwrotów muszą być duże i ciężkie. Lepiej zastosować małe silniki z przekładnią. Nowa konstrukcja już się tworzy! Dziękuję za przejrzenie albumu, który utworzyłem i zapraszam do zadawania pytań w komentarzach
  35. 4 punkty
    Witajcie! Mam przyjemność przedstawić mojego "nowego" robota minisumo - Predator. Stworzyłem go mianowicie w II Liceum (2016-17) ale jako, że jest teraz czas sesji to jako wzorowy student postanowiłem go tutaj opisać. Koncepcja, projektowanie konstrukcji i późniejsze jej wykonanie oraz zaprogramowanie układu sterującego zajęło do 6 miesięcy. Robot wziął udział w swoim pierwszym turnieju na Cyberbocie w Poznaniu, po czym przeszedł na urlop aż do obecnego roku gdzie wziął udział w Robotic Arenie we Wrocławiu. Mechanika: Konstrukcja składa się głównie z laminatu i stali. Podwozie robota zbudowane jest z 2 płyt 10x10 (z docięciami na koła i śruby) o szer. 2mm i 3mm jedna na drugiej, przy czym na końcu ostatniej zamocowane jest ostrze kupione jako "nóż do strugarek HSS". Reszta obudowy to laminat zlutowany ze sobą i połączony śrubami z elektroniką i podwoziem. Obudowa pomalowana czarnym sprayem (głównie dla estetyki, ale też aby był cięższy do wykrycia). Napęd w robocie stanowią 2 silniki micro Pololu 50:1 a sterują nimi 2 mostki H TB6612. Felgi zostały zrobione na zamówienie przez użytkownika HungryDevil, a opony są odlane z silikonu. Sam projekt był tworzony w Inventorze, niestety wraz z rozpoczęciem studiów zmieniłem komputer, a stary był sformatowany Elektronika: Płytki PCB zaprojektowane zostały w programie Eagle i wytrawione domowymi sposobami. Sercem robota jest Atmega328P w wersji SMD. Układy zasilane są z LiPo'la 2s, 20c, 3,85Wh przez stabilizator liniowy 5V 7805. Czujnikami zastosowanymi do wykrywania przeciwnika są legendarne cyfrowe czujniki Sharp 40cm w liczbie czterech. Planowane były również czujniki linii, jednak płytki z czujnikami nie działały przed zawodami tak jak powinny także usunąłem je na czas zawodów Cyberbot. Ich implementacja miała się odbyć tuż po zawodach, ale z dzisiejszej perspektywy po 2 latach mogę powiedzieć, że raczej Predator się ich już nie doczeka Na górnej płytce, oprócz wejścia programatora i wejścia na moduł startowy, znajdują się przełączniki, których zadaniem miało być wyłączanie/pomijanie czujników które doznały awarii podczas walki (w praktyce nie użyte ani razu). Software: Program napisany w Atmel Studio. Raczej nie należy do zaawansowanych i w głównej mierze został wykonany metodą prób i błędów. Strategia robota to często używane tzw. "Tornado". Robot obraca się dopóki nie wykryje przeciwnika a po jego znalezieniu, rusza prosto na niego. Podsumowanie: Predator nie do końca wyszedł w taki sposób jaki miał. Posiada sporo wad, jako główną podałbym oczywiście brak czujników podłoża. Dodatkowo niedokładność konstrukcji spowodowała delikatne wystawanie przednich czujników poza obudowe. Mimo tego jestem bardzo zadowolony z niego, ponieważ jest to dopiero mój drugi robot, którego zbudowałem. Mam nadzieję, że ten post pomoże innym początkującym konstruktorom. Osiągnięcia: I miejsce na XI Robotic Arena 2019 we Wrocławiu Tu dorzucam jeszcze parę dodatkowych zdjęć: Pozdrawiam i do zobaczenia na kolejnych zawodach, Paweł
  36. 4 punkty
    Witam serdecznie, Chciałbym zaprezentować mój projekt którym jest czworonożny robot kroczący sterowany za pomocą kolna arduino - nano V3. Głównym celem powstania tej konstrukcji było zabicie wolnego czasu oraz wykorzystanie nowo zamówionych części. Cały proces tworzenia od koncepcji do gotowego czworonoga trwał poniżej tygodnia. Funkcjonalność robota skupiała się na chodzeniu do przodu oraz pokonywaniu małych przeszkód. Elektronika Do stworzenia projektu potrzebny był kontroler - wspomniane już wcześniej arduino nano lub jego klon. W mojej opinii jest to najbardziej użyteczne arduino do projektów DIY, ze względu na jego małą wielkość i masę oraz identyczne możliwości obliczeniowe jak jego więksi bracia. Arduino zostało zamontowane na płytce rozszerzającej z wieloma wyprowadzeniami dla serw i nie tylko. Ten element jest bardzo uniwersalny i ułatwia podłączenie wielu komponentów bez potrzeby tworzenia odpowiedniej płytki PCB lub używania płytki stykowej. Motoryka została oparta o małe serwomechanizmy - po dwa na nogę, łącznie 8 sztuk. Dodatkowo na końcach nóg zostały zamontowane czujniki krańcowe w celu wykrywania kolizji z podłożem i optymalizacji ruchu. Siła serwomechanizmów okazała się być wystarczająca, jednakże, problemem okazało się być zasilanie. Duża ilość serwomechanizmów działających jednocześnie mocno obciąża arduino, dlatego też, serwomechanizmy powinny mieć własne źródło zasilania. W tym przypadku ograniczenie prędkości ruchów ograniczyło ten problem, ale wskazuje to na popełniony przy projektowaniu błąd. Konstrukcja Konstrukcja składa się z korpusu głównego do którego przymocowano arduino oraz 4 nóg. Jedna noga składa się z dwóch segmentów, a jeden segment z dwóch elementów łączonych śrubą. Lepiej wyjaśni to poniższe zdjęcie. Robot jest tu przedstawiony leżący na swoich plecach. Poniżej znajdują się jeszcze dwa zdjęcia pokazujące jego posturę. W pozycji leżącej, ze wszystkimi nogami skierowanymi względem siebie pod kątem prostym, robot ma przekątną około 30 cm. Powyższe elementy zostały wydrukowane przy pomocy drukarki 3D. Trwało to około 10 godzin. Kod Ze względu na krótki czas rozwoju projektu, jego funkcjonalność nie jest duża. Postało kilka wersji programu, dopasowanych do konkretnego podłoża. Nie różnią się one znacząco, więc przedstawię główny program służący do pokonywania płaskiego terenu w najszybszy i najstabilniejszy sposób. Na początek trochę definicji. Zmienne nazwane są od numeru nogi oraz jej stopnia. Przykładowo tl1 - top-left-1, oraz br2 - bottom-right-2. #include <Servo.h> Servo tr1; Servo tr2; Servo tl1; Servo tl2; Servo br1; Servo br2; Servo bl1; Servo bl2; #define br A1 #define tr A2 #define tl A3 #define bl A4 int i=0; int o=50; int p=20; int h=70; int t=10; int k=0; int l=0; int n=0; int m=0; int timer=0; int d=0; int x=50; int y=50; void setup() { Serial.begin(9600); pinMode(A1, INPUT_PULLUP); pinMode(A2, INPUT_PULLUP); pinMode(A3, INPUT_PULLUP); pinMode(A4, INPUT_PULLUP); tl1.attach(8); tl2.attach(4); bl1.attach(9); bl2.attach(5); tr1.attach(10); tr2.attach(6); br1.attach(11); br2.attach(7); tr1.write(90); tr2.write(75); tl1.write(90); tl2.write(90); br1.write(90); br2.write(90); bl1.write(90); bl2.write(90); } Kolejnym elementem kodu są definicje funkcji. void ltl(int a, int b){ tl1.write(map(a+3, 0, 100, 10, 150)); tl2.write(map(b, 100, 0, 5, 180)); } void ltr(int a, int b){ tr1.write(map(a, 100, 0, 30, 170)); tr2.write(map(b-9, 0, 100, 0, 177)); } void lbl(int a, int b){ bl1.write(map(a, 0, 100, 30, 150)); bl2.write(map(b+1, 0, 100, 0, 178)); } void lbr(int a, int b){ br1.write(map(a, 100, 0, 30, 150)); br2.write(map(b+4, 100, 0, 8, 180)); } void move(){ lbr(100-i,100-k-d); i++; if(i==100){ i=0; k=y; } if(k>0){ if(digitalRead(br)==HIGH){ k--; } } lbl(100-o,100-l-d); o++; if(o==100){ o=0; l=y; } if(l>0){ if(digitalRead(bl)==HIGH){ l--; } } ltr(100-p,100-n-d); p++; if(p==100){ p=0; n=x; l=l+10; k=k+10; } if(n>0){ if(digitalRead(tr)==HIGH){ n--; } } ltl(100-h,100-m-d);; h++; if(h==100){ h=0; m=x; k=k+10; l=l+10; } if(m>0){ if(digitalRead(tl)==HIGH){ m--; } } delay(t); } Przykładowo, nazwa funkcji ltl oznacza leg-top-left i służy do ujednolicenia określania położenia nogi, gdyż niektóre serwa położone są przeciwnie i wysoka wartość sygnału PWM oznacza dla nich przeciwne położenia. Funkcja move to gówna funkcja służąca do poruszania się. Działa ona tak, że wszystkie nogi poruszają się cały czas do tyłu, jednakże, początkowe położenia wszystkich nóg są różne. Gdy noga poruszając się do tyłu dojdzie do płożenia końcowego, podnosi się ona i przemieszcza do maksymalnego płożenia do przodu, wtedy zbliża się ona do podłoża aż do napotkania oporu odebranego przez czujnik krańcowy lub osiągnięcia pozycji maksymalnej, wtedy porusza się znów do tyłu. W ten sposób wszystkie nogi cały czas znajdują się w ruchu, który jest bardzo płynny. Brak 3 stopnia swobody w nodze wpływa jednak na to, że ślizganie jest nieuniknione. Ostatnia część kodu służy jedynie do egzekwowania funkcji move pod pewnymi warunkami. void loop() { if(analogRead(br)==LOW or analogRead(tr)==LOW or analogRead(bl)==LOW or analogRead(tl)==LOW && timer<50){ timer=200; } timer--; if(timer>0){ move(); }else{ lbl(50,50); lbr(50,50); ltl(50,50); ltr(50,50); } } Kod w funkcji loop powoduje również, że w razie podniesienia robota na pewien czas, przestaje on dalej iść. Gdy robot zostanie podniesiony, żaden czujnik krańcowy nie sygnalizuje, że stoi na ziemi, powoduje to spadek licznika timer do 0 i przejście robota w stan spoczynkowy, aż do aktywacji przez ponowne wciśnięcie któregoś czujnika. Gotowy robot Poniżej przedstawiam kilka zdjęć z postępu składania konstrukcji. Niestety nie posiadam dużo zdjęć tego projektu, gdyż serwa i mikrokontrolery szybko zmieniają u mnie właściciela. Podczas testów robot pokonał najwyższy próg o wysokości nieco ponad 4 cm. Może nie jest to imponująca wartość, ale biorąc pod uwagę, że nie może on biegać ani skakać, a maksymalna wysokość własna na jakiej znajduje się jego korpus wynosi około 4,5 cm jest to taki sam wyczyn jak pokonanie przez człowieka, z marszu, przeszkody sięgającej mu do pasa. A tu jeszcze jedno zdjęcie gotowego projektu (słaba jakość, klatka z filmu). Pozdrawiam, i czekam na pytania i porady.
  37. 4 punkty
    A co tu pisać... Ivona to nie jest, zwykły syntezator Klatta, trochę uproszczony (wywalone filtry dla 16 kHz), przystosowany do naszego pięknego języka i przełożony na C++. Kod jest na https://github.com/ethanak/ESP8266-Lektor - muszę poprawić README.md bo się lekko zdezaktualizowało (autorzy uprzejmie poprawili babola w funkcjach i2s). Karmi się go tekstem w utf-8, potrafi sterować np. paskiem led lub serwem od szczęki, może generować predeklarowane kształty ust. Da się skompilować pod Linuksem żeby posłuchać jak gada. Co do dokumentacji... chyba faktycznie coś skopali, bo nie mogę znaleźć paru rzeczy które kiedyś same się pchały w oczy.
  38. 4 punkty
    Miałem okazję pobawić się trochę płytką rozwojową, czyli https://www.seeedstudio.com/Air602-WiFi-Development-Board-p-3140.html postaram się więc napisać kilka słów o tym co zauważyłem. Zacznijmy od tego co fajne, czyli samego chip-a W600 firmy WinnerMicro. Jego opis znalazłem tutaj: http://www.winnermicro.com/en/upload/1/editor/1538987833915.pdf Układ wygląda bardzo fajnie - 1MB flash, 288kB RAM, taki nieźle wypasiony STM32, ale za bardzo niską cenę i jeszcze z WiFi. Wydaje mi się, że ten układ ma potencjał i jeszcze o nim usłyszymy. Znalazałem nawet nieoficjalne SDK i przykłady do niego: https://github.com/w600/sdk Następny etap to moduł Air602. Czyli https://m.seeedstudio.com/productDetail/3139 - moduł moim zdaniem mocno taki sobie. Po pierwsze nie ma anteny. Po drugie z 16 pinów GPIO, które oferuje W600 wyprowadzono 7. Pewnie był projektowany do użycia w większych projektach - dodajemy go do PCB i tyle. Sam w sobie chyba nie ma zastosowania. Nie dość że mało pinów to jeszcze trzeba chcieć i umieć zaprojektować antenę. No i na koniec zostaje "zestaw deweloperski", czyli to co dostałem. Płytka zawiera konwerter USB-UART, stabilizator 3.3V, antenę oraz moduł Air602. Brzmi fajnie, ale... jest trochę do niczego. Po pierwsze trzeba mieć USB-host. Nie ma dostępu do UART-a, więc nawet z Arduino tego nie zepniemy. Można podłączyć do laptopa lub Raspberry, tylko po co? Przecież WiFi i tak już jest. Oczywiście możemy kombinować, lutować itd. ale w najlepszym wypadku dostaniemy mniej niż ESP-01. W każdym razie podłączając ten zestaw deweloperski do laptopa możemy cieszyć się komendami AT i komunikacją przez WiFi. Nie jest to zbyt absorbujące, spróbowałem więc wykorzystać zestaw deweloperski do napisania własnej aplikacji. Mamy rdzeń Cortex-M3, więc zapowiadało się dobrze. Co więcej producent zestawu udostępnia własne SDK: https://github.com/SeeedDocument/Outsourcing/raw/master/113990576/AirM2M_W600_SDK_20180824.zip Niestety moja radość trwała krótko. Okazuje się, że wymagany jest kompilator Keil, a kod wynikowy jest na tyle duży, że nie wystarczy wersja darmowa. Nie miałem akurat ~2000 euro na zbyciu na zakup licencji, więc zostało mi uwierzyć na słowo, że SDK działa. Okazało się za to, że nieoficjlane SDK działa z gcc. Udało mi się więc chociaż przykład z migającą diodą uruchomić. Podsumowując: * zestaw deweloperski niezbyt nadaje się do własnych projektów, a moduł wymaga sporo pracy i umiejętności * dostępny firmware działa na komendach AT * oprogramowanie użytkowe jest po chińsku... seedstudio oferuje obrazkową instrukcję zamiast tłumaczenia http://wiki.seeedstudio.com/Air602_Firmware_Programming_Manual/ * SDK wymaga licencji na Keil 5 * dostępne jest nieoficjalne SDK, które działa z gcc, ale kurs podstaw mandaryńskiego jest mocno wskazany Moim zdaniem W600 to bardzo ciekawy układ. Niestety jest na takim etapie jak ESP8266 było kilka lat temu. Jeśli pojawi się lepsze oprogramowanie, będzie pewnie ciekawą konkurencją. Niestety to co zaoferowało seeedstudio wymaga jeszcze sporo poprawek.
  39. 4 punkty
    Interfejs SPI używany jest do komunikacji między mikrokontrolerami AVR lubi innymi urządzeniami jak zewnętrzne pamięci EEPROM, zewnętrzne przetworniki analogowo - cyfrowe, czujniki itp. Może więc nam się przydać przy budowie robota dlatego warto zapoznać się z nim bliżej by móc potem bez większych problemów wykorzystywać go w budowanych konstrukcjach. Urządzenia komunikujące się za pomocą interfejsu SPI dzieli się na dwie podstawowe grupy. Pierwsze to urządzenia Master ( Wyższy ), które inicjują i kontrolują wysyłanie danych oraz urządzenia Slave ( Niewolnik ), które odbierają dane wysyłane przez Master'a ale mogą je do niego także w tym samym czasie wysyłać. Zazwyczaj w prostych rozwiązaniach mamy jeden układ typu Master, który wysyła i odbiera dane od jednego lub kilku układów typu Slave. Najważniejszą część interfejsu SPI stanowi 8-bitowy rejestr przesuwny, który występuje zarówno w urządzeniu skonfigurowanym jako Master jak i Slave oraz sygnał zegarowy generowany przez urządzenie Master. A oto jak przebiega transmisja. Powiedzmy, że Master chce wysłać do układu Slave jakiś bajt nazwijmy go M oraz odebrać od niego również pewien bajt danych nazwijmy go S. Zanim rozpocznie się komunikacja oba urządzenia umieszczają swoje bajty w swoich rejestrach przesuwnych. Zostało to przedstawione poglądowo na rysunku poniżej M0..M7 oznaczają kolejne bity bajtu M podobnie ma się sprawa z bajtem S. Następnie Master generuje 8 pulsów zegara na linii SCK i zawartość rejestru przesuwnego Master'a ( bajt M ) jest wysyłany w takt pulsów zegarowych do Slave oraz w tym samym czasie nadchodzi do Master'a bajt wysyłany przez Slave ( bajt S ). Po pierwszym impulsie zegar sytuacja wygląda tak jak na obrazku niżej. Po następnym impulsie zegarowym mamy taką sytuację. Po 8 pulsach zegara Master ma bajt S a Slave bajt M. To, że transmisja zachodzi w tym samym czasie w obu kierunkach nazywa się w pełni dwukierunkowym transferem danych ( full duplex data transfer ). W mikrokontrolerach AVR cztery piny są używane przy komunikacji SPI : - MISO ( Master in Slave out ) - Tą linią Slave przesyła dane do Master - MOSI ( Master out Slave in ) - Tą drogą docierają dane od Master do Slave - SCK ( Serial Colock ) - To jest linia na, której generowany jest sygnał zegarowy przez urządzenie Master i odbierany przez Slave, zegar jest niezbędny do poprawnego działania SPI gdyż synchronizuje komunikacje to właśnie w takt zegara przesuwane są poszczególne bity w rejestrach przesuwnych. - SS' ( Slave Select ) - W zależności od tego jak skonfigurujemy nasze urządzenie jako Master lub Slave ta linia ma różne znaczenia w obu przypadkach : • SS' dla Slave - Mając w układzie więcej urządzeń Slave niż jedno Master musi mieć możliwość wybrania do którego w danym momencie mają trafić dane a do których nie. Po to właśnie jest linia SS'. Jeżeli SS' jest w stanie wysokim to dany Slave jest niejako nieaktywny i nie odbiera nadchodzących danych natomiast gdy SS' jest w stanie niskim to jest aktywny i nadchodzące dane będą odbierane o ile SPI został poprawnie skonfigurowany. Program Master'a musi kontrolować SS' każdego Slave tak by wysyłać dane tylko do wybranych urządzeń w danym momencie. • SS' dla Master – W tym przypadku mamy jeszcze dwie możliwości w zależności od tego czy pin SS' skonfigurowano jako wejście czy jako wyjście. Jeżeli SS' jest skonfigurowane jako wyjście to czy jest w stanie niskim czy w stanie wysokim nie wpływa na interfejs SPI jest on w obu przypadkach aktywny. Natomiast gdy SS' jest wejściem to musi być trzymane w stanie wysokim by urządzenie pracowało jako Master. Gdy natomiast wystąpi sytuacja, że na SS' będącym wejściem pojawi się stan niski zostanie to zinterpretowane tak jakby inny Master wybrał naszego Master'a jako Slave i rozpoczął z nim komunikacje. Taka sytuacja ( więcej niż jeden Master w układzie ) jest niebyt ciekawa i o ile to nie potrzebne lepiej jej unikać. Jeżeli jest nam to niepotrzebne lepiej konfigurować SS' Master'a jako wyjście wtedy będziemy mieli pewność, że sytuacje tego typu nie wystąpią. W przypadku gdy mamy w układzie tylko jedno urządzenie Slave nie musimy się martwić implementowaniem w programie dla Master'a możliwości przestawiania stanu SS' Slave gdyż i tak nie mamy, żadnego wyboru bo Slave jest tylko jeden. Można wówczas na stałe dołączyć linie SS' Slave do masy wówczas będzie on stale gotów do komunikacji z Master'em. Natomiast pin SS' urządzenia Master można pozostawić niepołączony należy jednak zadbać by był wyjściem gdyż wtedy to w jakim jest stanie ( wysokim czy niskim ) nie ma znaczenia i w obu przypadkach SPI jest aktywne o czym już wyżej wspomniałem. Gdyby był wejściem to nieprzewidziane zmiany stanu mogą skutecznie zablokować komunikacje wystarczy by w jakiś nieprzewidziany sposób stan zmienił się na SS' Master'a na niski i SPI nie będzie działać poprawnie. Pozostałe linie łączymy tak jak na rysunku niżej. Gdy natomiast mamy 2 lub więcej Slave'ów musimy mieć możliwość wybrania jednego konkretnego Slave'a gdy będziemy chcieli wysłać dane tylko do niego. Jak już wiadomo linia SS' w stanie niskim powoduje, że Slave jest aktywny i może komunikować się z Master'em natomiast SS' w stanie wysokim powoduje, że Slave jest nieaktywny i nie odbiera ani nie wysyła, danych. Najprościej więc do wyboru Slave posłużyć się dodatkowymi pinami układu Master podłączonymi do SS' Slave'ów i zmieniając ich stan na wysoki blokować dane Slave'y a na niski uaktywniać je. Pomocny może okazać się poniższy rysunek. Należy tutaj zauważyć, że nazwy MISO, MOSI, SCK, SS' są używane w mikrokontrolerach AVR ale inne urządzenia np. zewnętrzne EEPEROM'y mogą mieć te nazwy inne należy więc sprawdzić w dokumentacji danego urządzenia jak nazywają się odpowiedniki powyższych i z nimi je połączyć. To czy piny używane podczas komunikacji SPI są wejściami czy wyjściami zależy od tego czy urządzenie skonfigurowano jako Master czy jako Slave. Są tutaj dwie możliwości albo mamy narzucone, ustawienie danego pinu jako wejście albo kierunek pinu musi być ustalony przez programistę zgodnie z tym jaką funkcje pełni. Pomocna może być poniższa tabela. Przed przystąpieniem do analizy kodu przykładowych programów należy jeszcze podać minimum informacji na temat rejestrów sterujących SPI tak aby kody były dla wszystkich zrozumiałe. Do sterowania interfejsem SPI w mikrokontrolerach AVR ATmega8 służą 3 rejestry SPCR, SPSR oraz SPDR. Nie będę na razie podawał znaczenia wszystkich bitów danych rejestrów podam tylko te niezbędne do zrozumienia kodów reszta zostanie uzupełniona później. Na pierwszy ogień weźmy rejestr SPCR ( SPI Control Register ) będą nas tu na razie interesować następujące bity : - SPE ( SPI Enable ) - Bit ten musi być ustawiony kiedy chcemy używać interfejsu SPI gdyż ustawienie tego bitu powoduje po prostu włączenie interfejsu SPI. - SPIE ( SPI Interrupt Enable ) – Bit ten ustawiamy kiedy chcemy aby przerywania pochodzące od interfejsu SPI były włączone jeżeli nie chcemy korzystać z przerywań bit powinien mieć wartość 0. Należy pamiętać, że aby korzystać z przerywań należy w rejestrze SREG ustawić wcześniej bit I co czyni w asemblerze instrukcja sei a w C funkcja sei(). - MSTR ( Master / Slave Select ) - Nadanie bitowi wartości 1 powoduje, że urządzenie pracuje jako Master natomiast nadanie mu wartości 0 powoduje pracą urządzenia jako Slave. - SPR1 i SPR0 – Bity te służą do konfiguracji częstotliwości sygnału zegara SPI generowanego przez Master'a na linii SCK. Jeżeli urządzenie skonfigurowano jako Master to można zmieniając wartości tych bitów ustawiać dzielnik przez, który zostanie podzielona częstotliwość oscylatora mikrokontrolera i tak otrzymaną częstotliwość będzie miał sygnał zegarowy generowany przez Master. Z racji, że dane są przesyłane w takt zegara zmieniając wartości bitów a co za tym idzie częstotliwość zegara SPI można zmieniać szybkość przesyłanych danych. Należy zauważyć, że jeżeli urządzenie skonfigurowano jako Slave to ustawienie tych bitów nie ma znaczenia gdyż Slave tylko odbiera sygnał, który generuje Master. Nie można jednak zapomnieć o ograniczeniach narzucanych przez sam sprzęt, które powodują, że częstotliwość zegara SPI nie może być większa niż fosc / 4 gdyż wtedy dane nie będą poprawnie odbierane. Poniższa tabelka przedstawia możliwości ustawienia dzielnika za pomocą bitów SPR1 i SPR0. Pora na rejestr SPSR ( SPI Status Register ) na razie będzie nas interesował tylko bit SPIF tego rejestru. - SPIF ( SPI Interrupt Flag ) - Jest to bit, który można tylko odczytywać nie można więc go ustawiać lub kasować programowo gdyż to sprzęt nim steruje. Jest on ustawiany przez sprzęt kiedy transfer SPI dobiegnie końca . Jest on kasowany przez sprzęt kiedy zostanie zgłoszone przerywanie od SPI ( SPI_STC ) i zaczyna się procedura jego obsługi lub jest kasowany wtedy gdy nastąpi odczytanie bitu SPIF i zawartości rejestru SPDR. Na koniec rejestr SPDR - Do tego rejestru zapisujemy dane do wysłania przez Master lub Slave oraz z tego rejestru odczytujemy nadchodzące dane po stwierdzeniu końca komunikacji, do czego może posłużyć wyżej opisana flaga SPIF lub przerywanie SPI_STC. Po poprawnym zainicjowaniuinterfejsu SPI wystarczy tylko wpisać do tego rejestru wartość do wysłania aby transmisja została rozpoczęta. Teraz przejdziemy do części praktycznej zostaną przedstawione dwa proste przykłady użycia interfejsu SPI. Pierwszy z nich prezentuje użycie interfejsu SPI w bardzo prosty sposób. Drugi na przykładzie urządzenia Slave pokazuje wykorzystanie przerywania SPI_STC ( Spi Transfer Complete ) do wykrycia końca transmisji danych. Żeby móc przetestować pokazane przykłady wystarczy złożyć następujący prosty układ : Gdybym się pomylił lub o czymś zapomniał przy rysowaniu schematu to napisze jeszcze słowami, że w sumie nie chodzi o nic więcej jak tylko połączenie ze sobą pinów MISO, MOSI, SCK obu układów pin SS' Slave łączymy z masą a do jego PortuD dołączamy diody ledukłady oczywiście podłączamy do napięcia 5V i dodajemy kondensatory odsprzęgające o wartościach C4 i C3 100nF ceramiczne oraz C5 i C6 10uF elektrolity natomiast reset łączymy z vcc przez rezystor 10k i z minusem przez kondensator 100nF. Układ jest dość prosty a dane, które będzie otrzymywał Slave od Master'a są wyświetlane na 8 diodach połączonych do pinów portu D. Możemy dzięki temu stwierdzić czy interfejs działa poprawnie i czy wszystko zostało dobrze złożone. Do przykładów wykorzystano 2 AVR'y Atmega8 i na takich właśnie mikrokontrolerach kody będą działać poprawnie przy stosowaniu innych należy zgodnie z dokumentacją zmienić część kodu. Układ testowy został złożony na płytce stykowej ale oczywiście można go także złożyć na płytce uniwersalnej lub na płytce drukowanej. Programy zostały napisane w 2 językach programowania w AVR Asemblerze i AVR – GCC. Pierwszy program ( animacja ) działa tak, że na diodach led wyświetlane są kolejne bajty wysyłane przez Master te bajty to nic innego jak coraz większe ( o jeden ) liczby od 0 do 255 z racji, że master po wysłaniu bajtu odczekuje ok. 1 sekundy efektem jest prosta animacja. Najpierw kody dla urządzenia Master. Wersja ASM .include "m8def.inc" .cseg .org 0x000 rjmp Start Start: ldi r16, low( RAMEND ) out SPL, r16 ldi r16, high( RAMEND ) out SPH, r16 Inicjajcja_spi: ldi r16, ( 1 << PB3 )|( 1 << PB5 ) | ( 1 << PB2 ) //MOSI, SCK, SS' jako wyjścia out DDRB, r16 ldi r16, ( 1<<SPE )|( 1<<MSTR )|( 1<<SPR0 ) | ( 1 << SPR1 ) //Włączamy SPI, układ Master out SPCR, r16 //Najmniejsza częstotliwość SCK fosc / 128 ldi r19, 0 main: //Pętla nieskończona out SPDR, r19 //Wysyłamy zawartość r19 inc r19 //Zwiększamy wartość w r19 o 1 Czekaj_na_wyslanie: //Oczekujemy na zakończenie transmisji ( do ustawienia SPIF ) sbis SPSR, SPIF //Przez sprzęt rjmp Czekaj_na_wyslanie ldi r16, 250 //Czekamy ok. 1 sek rcall Czekaj ldi r16, 250 rcall Czekaj ldi r16, 250 rcall Czekaj ldi r16, 250 rcall Czekaj rjmp main Czekaj: //Procedura opóźniająca o 1 * r16 [ ms ] P2: ldi r17, 10 P1: ldi r18, 25 P0: nop dec r18 brne P0 dec r17 brne P1 dec r16 brne P2 ret Wersja C #define F_CPU 1000000UL #include<avr/io.h> #include<util/delay.h> void Inicjacja_spi() { DDRB = ( 1 << PB5 ) | ( 1 << PB3 ) | ( 1 << PB2 ); //MOSI, SCK, SS' jako wyjścia SPCR = ( 1 << SPE ) | ( 1 << MSTR ) | ( 1 << SPR1 ) | ( 1 << SPR0 ); //Włączamy SPI, } //układ Master, najmniejsza częstotliwość SCK fosc / 128 void Wyslij_spi(char bajt) { SPDR = bajt; //Wysyłamy zawartość zmiennej bajt while( ! bit_is_set( SPSR, SPIF ) ); //Oczekujemy na zakończenie transmisji ( do ustawienia SPIF ) przez sprzęt } int main() { char bajt = 0; Inicjacja_spi(); while(1) //Pętla nieskończona { Wyslij_spi(bajt); _delay_ms(250); //Czekamy ok. 1 sek _delay_ms(250); _delay_ms(250); _delay_ms(250); bajt++; //Zwiększamy wartość w bajt o 1 } return 0; } Teraz kod dla Slave Wersja ASM .include "m8def.inc" .cseg .org 0x00 Inicjajcja_spi: ldi r16, ( 1 << PB4 ) //MISO jako wyjście out DDRB, r16 ldi r16, ( 1 << SPE ) //Włączamy SPI out SPCR, r16 ldi r17, 0xff //Cały PortD jako wyjście out DDRD, r17 ldi r17, 0x00 //W stanie niskim out PORTD, r17 main: sbis SPSR,SPIF //Czekamy na koniec transmisji danych ( do ustawienie flagi SPIF ) rjmp main in r16, SPDR //Wpisujemy to co przyszło od Master do r16 out PORTD, r16 //Wysyłamy to na PortD ( diody led ) rjmp main //I tak bez końca Wersja C #include<avr/io.h> void Inicjacja_spi() { DDRB = ( 1 << PB4 ); //MISO jako wyjście SPCR = ( 1 << SPE ); //Włączamy SPI } char Odbieraj_spi() { //Czekamy na koniec transmisji danych while ( ! bit_is_set( SPSR, SPIF ) ); // ( aż do ustawienie flagi SPIF ) return SPDR; //Zwracamy to co dostaliśmy do SPDR } //Czyli to co wysłał Master int main() { DDRD = 255; PORTD = 0; Inicjacja_spi(); while(1) { char bajt = Odbieraj_spi(); PORTD = bajt; //Wysyłamy to co dostaliśmy od Master'a na } //PortD ( diody led ) return 0; } Programy nie są trudne ale warto przenieść je na język ludzki na listę czynności które wykonują tak by widzieć co po kolei należy zrobić by wysyłać dane przez SPI. Master 1. Najpierw inicjujemy SPI ustawiając MOSI ( PB3 ) , SCK ( PB5 ), SS' ( PB2 ) jako wyjścia co jest zrozumiałe gdyż sygnał zegarowy generuje Master a Slave go odbiera więc jeśli u Slave jest on ustawiany jako wejście zgodnie z wcześniejszą tabelką to u Master pasuje by był wyjściem podobnie ma się rzecz z MOSI a co do SS' to już było pisane, że ustawienie jako wyjście pozwala nam unikać przykrych sytuacji. Ta część wymaga zmian przy innych mikrokontrolerach bo mogą one mieć MISO, MOSI, SCK, i SS' na innych pinach niż Atmega8. 2. W dalszej części inicjacja ustawiamy odpowiednie bity w rejestrze SPCR czyli SPE ( włączamy SPI ) MSTR ( układ to Master ) SPR0 i SPR1 ustawiają najmniejszą częstotliwość SPI fosc / 128 co pozwala zminimalizować ryzyko zakłóceń do minimum i być może oszczędzić niektórym niepotrzebnych nerwów. 3. Następnie program wysyła bajt do Master rozpoczęcie wysyłania jest równoznaczne z wpisaniem bajtu do rejestru SPDR. 4. Następnie odczekujemy na koniec transmisji danych chodź nie jest to w 100 procentach potrzebne gdyż program i tak czeka potem 1 sekundę ale co nam szkodzi robimy to poprzez oczekiwanie na zmianę stanu SPIF na 1 co zrobi sprzęt gdy transmisja bajtu dobiegnie końca gdy to się stanie możemy już wysyłać kolejny bajt. Slave 1. Najpierw inicjujemy SPI ustawiając MISO ( PB3 ) jako wyjście. 2. W dalszej części inicjacji włączamy SPI ustawiając bit SPE 3. Wpadamy w pętle w której oczekujemy na koniec transmisji ( odebranie danych od master ) o czym da znać bit SPIF mający wartość jeden. 4. Jeśli SPIF ma wartość jeden oznacza to, że dane dotarły i możemy je odczytać gdyż są teraz w rejestrze SPDR więc i to robimy. Teraz druga wersja programu robi w sumie to samo co pierwsza tyle, że urządzenie Slave wykorzystuje przerywanie SPI_STC do wykrycia końca transmisji danych. Kody dla Master są w tym przypadku takie same zmienia się tylko kod dla Slave. Oto one : Wersja ASM .include "m8def.inc" .cseg .org 0x000 rjmp Start .org 0x00A rjmp SPI_Int SPI_Int: //Ten kod zostanie wykonany po zgłoszeniu przerywania SPI_STC in r16, SPDR //Pobieramy wartość wysłaną przez Master out PORTD, r16 //Wysyłamy na PortD ( wyświetlamy ją na diodach led ) reti Start: ldi r16, low( RAMEND ) out SPL, r16 ldi r16, high( RAMEND ) out SPH, r16 sei //Włączamy przerywania ldi r16, ( 1 << PB3 ) //Inicjacja Slave jak poprzednio out DDRB, r16 ldi r16, ( 1 << SPIE ) | ( 1 << SPE ) //Włączamy przerywania i interfejs SPI out SPCR, r16 ldi r16, 0xff out DDRD, r16 ldi r16, 0x00 out PORTD, r16 main: rjmp main Wersja C #include<avr/io.h> #include<avr/interrupt.h> ISR(SPI_STC_vect) //Kod wykonywany po zgłoszeniu przerywania SPI_STC { char bajt = SPDR; //Pobieramy wartość wysłaną przez Master PORTD = bajt; //Wysyłamy na PortD ( wyświetlamy ją na diodach led ) } void Inicjacja_spi() { DDRB = ( 1 << PB4 ); //Jak poprzednio SPCR = ( 1 << SPIE ) | ( 1 << SPE ); //Włączamy przerywania i interfejs SPI } int main() { DDRD = 255; PORTD = 0; Inicjacja_spi(); sei(); //Włączamy przerywania for (;;); return 0; } W sumie nie ma tu wielkich różnic więc nie ma co się rozpisywać bo przecież tłumaczenie jak obsługiwać przerywania nie należy do tego tematu i wszyscy powinni już to wiedzieć chyba, że są tacy co zaczynają stawiać dom od dachu. Wiedzieć należy jednak to, że po zgłoszeniu przerywania od SPI program skacze do adresu 0x00A, natomiast w C powinniśmy do funkcji obsługującej przerywania podać nazwę SPI_STC_vect . W sumie jedyną nowością jest ustawienie w rejestrze SPCR bitu SPIE, który włącza przerywania od SPI. Na razie tyle ciąg dalszy nastąpi wkrótce.
  40. 4 punkty
    Początek drogi z zarówno robotyką jak i elektroniką, nie jest prosty. Początkujący często mają problemy z obsługą programową np. wyświetlacza oraz problemy z podłączeniem urządzeń zewnętrznych takich jak mostki, czujniki itp. Również to że niektórzy myślą, że pisanie programów w C obsługujących np. wyświetlacz jest „kosmosem”. Artykuł zawiera schematy podłączania oraz opis niektórych często używanych urządzeń zewnętrznych w robotyce amatorskiej. Pod niektórymi podzespołami są przykładowe kody obsługi w języku C; między innymi wyświetlacz ze sterownikiem HD44780. Opisany jest również interfejs 1-wire. W każdym kodzie są szczegółowe komentarza dotyczące programu/funkcji obsługi danego podzespołu. I tak, po kolei będę opisywał: 1. HD44780; wyświetlacz alfanumeryczny 2. Mostki: L298N, L293D, TB6612 3. GP2Y0D340K – czujnik odległości 4. DS18B20 – termometr oparty na 1-wire 5. Transoptory refleksyjne np. CNY70, KTIR0711S, TCRT1000 itp. 6. TSOP312xx 7. Generowanie fali 36kHz za pomocą mikrokontrolera Zaczynamy! 1 Wyświetlacz oparty o sterownik HD44780. Może służyć np. do modyfikowania wypełnienia PWM pomiędzy jazdami LF lub walkami robotów sumo. Schemat poniżej przedstawia podłączanie wyświetlacza 2x16 sterowanego w trybie 4-bitowym z zapisem do układu. Jak widać, linie danych są podłączone od D4…D7. Pin E oraz RS również do uC. Pin R/W do masy. Oznaczają one: - D4, D5, D6, D7 – linie danych, którymi będziemy przesyłać komendy i dane do sterownika HD44780 poprzez odpowiednie ustawianie ich w stan niski lub wysoki - R/W – pin odpowiadający za odczyt/zapis, poszczególne jego stany odpowiadają za: R/W = 0 do HD44780 można zapisywać dane R/W = 1 z HD44780 można odczytywać dane - R/S – pin odpowiadający za rejestry w HD44780, odpowiednio: R/S = 0 rejestr instrukcji (do zapisu) lub do odczytu licznika adresu R/S = 1 rejestr danych (do zapisu lub odczytu) - E – pin odpowiadający za zapoczątkowanie zapisu/odczytu do HD44780. Tłumacząc: najpierw ustawimy wysoki stan na E, potem ustawimy odpowiednie wyjścia (D4…D7), na końcu, aby spowodować zapis do wyświetlacza, ustawimy stan niski na E. Tryb 4-bitowy oznacza, że dane 8-bitowe wysyłamy w dwóch pół-bajtach poczynając od jego starszej połówki. Przejdźmy teraz do implementacji kodu obsługi w C. Zdefiniujmy na początku poszczególne piny, aby łatwiej się nimi posługiwać: #define DDR_D4 DDRD // jest to port, do którego będzie podpięty pin D4 #define PORT_D4 PORTD #define D4 PD2 #define DDR_D5 DDRD #define PORT_D5 PORTD #define D5 PD3 #define DDR_D6 DDRD #define PORT_D6 PORTD #define D6 PD4 #define DDR_DB7 DDRD #define PORT_DB7 PORTD #define D7 PD5 #define DDR_RS DDRD #define PORT_RS PORTD #define RS PD0 #define DDR_E DDRD #define PORT_E PORTD #define E PD1 Instrukcje ustawiania (SET) oraz resetowania pinu (CLR) też zrealizujemy na instrukcjach preprocesora C - #define #define SET_DB4 PORT_D4 |= _BV(D4) #define CLR_DB4 PORT_D4 &= ~_BV(D4) #define SET_DB5 PORT_D5 |= _BV(D5) #define CLR_DB5 PORT_D5 &= ~_BV(D5) #define SET_DB6 PORT_D6 |= _BV(D6) #define CLR_DB6 PORT_D6 &= ~_BV(D6) #define SET_DB7 PORT_D7 |= _BV(D7) #define CLR_DB7 PORT_D7 &= ~_BV(D7) #define SET_E PORT_E |= _BV(E) #define CLR_E PORT_E &= ~_BV(E) #define SET_RS PORT_RS |= _BV(RS) #define CLR_RS PORT_RS &= ~_BV(RS) Teraz funkcja wystawiająca pół-bajt na magistrale danych D4…D7: void set_half_byte(char x) { if(x & _BV(0)) SET_D4; else CLR_D4; /* jeżeli w pół-bajcie pierwszy bit jest 1, to ustaw pin D4, jeżeli jest zero wyczyść pin D4*/ if(x & _BV(1)) SET_D5; else CLR_D5; /* jeżeli w pół-bajcie drugi bit jest 1, to ustaw pin D5, jeżeli jest zero wyczyść pin D5 itd. */ if(x & _BV(2)) SET_D6; else CLR_D6; if(x & _BV(3)) SET_D7; else CLR_D7; } Teraz funkcja, która dzieli i wysyła te pół-bajty do funkcji poprzedniej, aby mogła ona ustawić odpowiednie piny w uC: void write_to_lcd(char x) { SET_E; // na E stan wysoki set_half_byte (x >> 4); /* ustawienie na szynę danych starszej połówki bajtu; tłumacząc: jeżeli mamy bit x który wynosi w systemie binarnym: 01001011, to po wykonaniu operacji: x>>4, otrzymamy bit który wynosi: 00000100, wtedy funkcja wystawi te bity (pogrubiona czcionka): 0100 po prostu przesuwamy bity w prawo o 4 pozycje */ CLR_E; // opadające zbocze na E powoduje zapis do wyświetlacza SET_E; //na E stan wysoki set_half_byte (x); /* wystawienie na szynę danych młodszej połówki bajtu, wtedy funkcja wystawi na magistralę (linię danych) następujące bity (pogrubione): 1011 CLR_E; // opadające zbocze na E powoduje zapis do wyświetlacza _delay_ms(1); /* opóźnienie ok 1ms jest niezbędne, aby wyświetlacz mógł zapisać dane które przed chwilą wysłaliśmy */ } W ten sposób zapisaliśmy cały bajt do wyświetlacza. Proste, prawda? Następne funkcje będą się opierały w zasadzie tylko na odpowiednim ustawianiu linii R/S oraz wysyłaniu funkcją write_to_lcd() bajtów rozkazów lub danych do wyświetlacza. I tak, teraz funkcja zapisująca komendę do HD44780: // Funkcja zapisu rozkazu do wyświetlacza void write_command(char x) { CLR_RS; // gdy R/S = 0, do wyświetlacza można zapisywać komendy write_to_lcd(x); // zapis do LCD komendy x } Funkcja zapisująca pojedynczy znak do wyświetlacza (ta funkcja będzie potrzebna przy zapisywaniu tekstu): void write_char(char x) { SET_RS; // gdy R/S = 1, do wyświetlacza moża zapisywać dane write_to_lcd(x); // zapis do LCD danej x } Funkcja zapisująca tekst do wyświetlacza: void write_text(char * s) { while(*s) /* wskaźnik wskazujący na kolejny znak tekstu; funkcja będzie się wykonywała dopóki znak jest różny od zera, w przeciwnym razie, gdy s=0, oznacza to że jest koniec tekstu i funkcja poprzestanie zapisywaniu tekstu */ { write_char(*s); // zapisz znak wskazywany przez s na LCD s++; // inkrementuj s (przygotuj następny znak do wysłania) } } Funkcja ustawiająca kursor w wybranym położeniu (x,y) na wyświetlczu. Współżędna x odpowiada za kolumny (0...15), y za wiersze (0...1). void LCDxy(char x,char y) { unsigned char com=0x80; com|=(x|(y<<6)); write_command(com); } Czyszczenie ekranu: void lcd_clear(void) { write_command(0x01); // komenda 0x01 odpowiada za wyczyszczenie ekranu } I teraz najważniejsze: inicjalizacja tą funkcję musimy wywołać gdzieś w funkcji main() głównego programu aby móc korzystać z wyświetlacza; nie ma potrzeby wywoływania jej kilka razy, np. w pętli while(1). void lcd_init(void) { DDR_D4 |= _BV(D4); // wszystkie linie sterujące wyjściowe DDR_D5 |= _BV(D5); DDR_D6 |= _BV(D6); DDR_D7 |= _BV(D7); DDR_E |= _BV(E); DDR_RS |= _BV(RS); // _delay_ms(20); /* czekamy 20ms na ustabilizowanie się napięcia zasilającego (w datasheet układu jest napisane że minimum 15 ms */ CLR_E; // E = 0 CLR_RS; // RS = 0 char i; /* zmianna licznikowa do pętli for(), instrukcje w niej zawarte muszę for(i = 0; i < 3; i++) się wykonać 3 razy służy to inicjalizacji */ { SET_E; // E = 1 set_half_byte(0x03); // wysłanie instrukcji 0x03 wymagane podczas inicjalizacji CLR_E; // E = 0 _delay_ms(5); // czekaj 5ms wymagane podczas inicjalizacji } SET_E; // E = 1 out_nibble(0x02); CLR_E; // E = 0 _delay_ms(1); // czekaj 1ms write_command(0x28); // interfejs 4-bity, 2-linie, znak 5x7 write_command(0x08); // wyłącz LCD, kursor i miganie write_command(0x01); // wyczyść LCD write_command(0x06); // ustaw bez przesuwania w prawo write_command(0x0C); // włącz LCD, bez kursora i mrugania } To na tyle z obsługą wyświetlacza. Jakbym chciał szczegółowo opisać sterownik HD44780 i jego komendy to zajęło by cały artykuł. Pora przejść dalej. 2 Mostki: L298N, L293D i TB6612 Służą do sterowania silnikami. L293D ma wydajność prądową na kanał 600mA ciągłego prądu, L298N wydajność 2A na kanał. TB6612 do 1,2A Nie wolno przekraczać tych wartości. Schemat podłączenia mostków: Piny CURRENT SENSING A i B (L298N) można podłączyć przez rezystory do masy, zmniejszając w ten sposób prąd płynący przez silniki. Jeżeli chcemy, aby do silników płynął maksymalny prąd, podłączamy te wyjścia po prostu do masy. Dobrą rzeczą jest dawać przy wejściach napięcia zasilania silników kondensatory* low ESR, tantalowy, które zapewnią dobrą filtrację napięcia. I oczywiście mały kondensatorek ceramiczny np. 100nF. Kondensatorek 100nF dobrze jest również dawać tuż przy wyprowadzeniach z silnika. Diody (L298N) muszą być bardzo szybkie - SCHOTTKY - i o prądzie minimalnym równym maksymalnemu prądowi który pobiera silnik - ja wybrałem 1N5822 o prądzie do 3A. Mostkami steruje się bardzo prosto. Wejścia/wyjścia poszczególnych mostków są następujące: (nazwy pinów) ...............................L293D...... L298N....TB6612 Wejście kanał 1....| 1A, 2A | input 1,2 | AIN 1,2 Wejście kanał 2....| 3A, 4A | input 3,4 | BIN 1,2 PWM 1.................| 1,2EN | ENABLE A | PWMA PWM 2 ................| 3,4EN | ENABLE B | PWMB Silnik 1................| 1Y, 2Y | output 1,2 | AO 1,2 Silnik 2................| 3Y, 4Y | output 3,4 | AO 3,4 Teraz tylko wystarczy podawać na odpowiednie piny (wejścia) logiczne 0 lub 1. np. 1A = 1; 2A = 0 (silnik kręci się w jedną stronę) 1A = 0; 2A = 1 (silnik kręci się w drugą stronę) 1A = 0; 2A = 0 (silnik hamuje) Podając stan wysoki na obydwa piny, spowodujemy (wg noty L293D) szybkie hamowanie. *Uwaga do kondensatorów elektrolitycznych: wartości na schematach są przykładowe, jeśli silniki pobierają większy prąd, powinno się dawać większe. 3 GP2Y0D340K Jest to często wykorzystywany czujnik odległości, działa na odległości ok. 40cm. Jeżeli czujnik wykryje przeszkodę, na wyjściu będzie stan L. I schemat podłączenia: 4 DS18B20 Obsługa interfejsu 1-wire często sprawia problemy, więc postanowiłem go opisać w skrócie, a w między czasie napiszemy kod obsługi, na przykładzie termometru DS18B20. Dlaczego opisuję 1-wire, a nie np. SPI gdzie jest więcej zastosowań? Ponieważ na forum już jest bardzo obszerny artykuł z kodami obsługi C jak i Asembler SPI, a 1-wire nie ma. Myślę, że warto go znać. Linia danych musi być podciągnięta rezystorem ok. 4,7k do VCC (pull-up). Inicjalizacja składa się z dwóch rzeczy: master wysyła RESET PULSE przez ustawienie magistrali w stan niski przez min. 480us; następnie układ slave odpowiada mu PRESENCE PULSE po 15-60us przez ustawienie w stan niski na 60 – 240us. Najpierw ustalmy makra żeby łatwiej obsługiwać pin I/O do którego będzie podłączony DS18B20: #define SET_WIRE PORTB |= (1<<PB1) // ustawia stan H #define CLR_WIRE PORTB &= ~(1<<PB1) // ustawia stan L #define IS_SET PINB & (1<<PB1) // maskuje bit pinu, do kórego podłączony jest DS #define OUT_DDR DDRB |= (1<<PB1) // ustawia pin jako wyjście #define IN_DDR DDRB &= ~(1<<PB1) // ustawia pin jako wejście Poniższa funkcja zwraca 1 gdy układ odpowiedział; 0 gdy nie odpowiedział (uszkodzony lub nie łączy linia danych): unsigned char DS_Reset(void) { unsigned char presence; OUT_DDR; // wyjście CLR_WIRE; // stan niski _delay_us(500); // na 500us SET_WIRE; // zwalnia magistrale ustawia stan początkowy czyli wysoki _delay_us(70); // czekamy na odpowiedź min. 60us, my czekamy 70us IN_DDR; // wejście if(!(IS_SET)) // jezeli DS ustawił stan niski presence = 1; // ustaw zmienną na 1 else // jeżeli nie odpowiedział presence = 0; // ustaw zmienną na 0 _delay_us(500); // czekamy na zakończenie trwania PRESENCE IMPULS return presence; // zwróć presence: 1-układ jest; 0-układu nie ma } Aby zapisać bit, należy postępować zgodnie z WRITE TIME SLOT. Trwa on minimum 60us, z przerwą min. 1us pomiędzy kolejnymi bitami. Po 15us od rozpoczęcia WRITE TIME SLOT, DS sprawdza stan magistrali w ciągu 45us; jeżeli będzie stan wysoki zapisywana jest jedynka, w przeciwnym razie 0. Więc zapisywanie 1 powinno wyglądać tak: CLR_WIRE; // stan niski _delay_us(7); // czekamy 7us SET_WIRE; //stan wysoki _delay_us(70); // czekamy na zakończenie write time slot Żeby zapisać cały bajt, użyjemy funkcji która jest podobna do algorytmu wyżej, tylko dodane jest zapisywanie 0 i przesuwanie bitów, żeby wysyłać od najmłodszego: void DS_Write(unsigned char byte) { unsigned char i; // zmienna licznikowa for (i=0; i<8; i++) // pętla wykonuje się 8 razy, aby wysłać bit po bicie cały bajt { OUT_DDR; // pin wyjściowy if (byte & 0x01) // jeżeli trzeba wysłać 1 { CLR_WIRE; // stan niski _delay_us(7); // czekamy 7us SET_WIRE; // stan wysoki _delay_us(70); // czekamy do końca write time slot } else // jeżeli trzeba wysłać 0 { CLR_WIRE; // stan niski _delay_us(70); // czekamy 70us SET_WIRE; // stan wysoki _delay_us(7); // czekamy 7us do następnego write time slot } byte >>= 1; /* przesuwamy bity w prawo, aby znów wysłać kolejny bit; działa tak: jeżeli mamy bajt: 01110101 to po wykonianiu byte >>=1 bajt staje się taki: 00111010 /* } } Aby zapisać bit, należy postępować zgodnie z READ TIME SLOT. Podobnie jak poprzednio trwa on minimum 60us, z przerwą min. 1us pomiędzy kolejnymi bitami. Trzeba zainicjować Read Time Slot w następujący sposób: ustawiamy magistralę w stan niski przez minimum 1us, następnie zwalniamy. Po tym układ DS zaczyna generować dane, które są dostępne 15us po rozpoczęciu inicjacji. Kiedy w tym czasie stan magistrali jest wysoki transmitowane jest 1; kiedy jest niski – 0. Funkcja odbierająca bajt z układu wygląda następująco: unsigned char DS_Read(void) { unsigned char i, byte = 0; // zmienne: licznikowa oraz przechowująca odebrany bajt OUT_DDR; // pin jako wejście for (i=0; i<8; i++) /* pętla wykonuje się 8 razy odbiera bit po bicie { zaczynając od najstarszego /* CLR_WIRE; // stan niski _delay_us(3); // czekamy 3us SET_WIRE; // stan wysoki - zwalniamy magistrale _delay_us(7); // czekamy 7us if(IS_SET) byte |= 0x01<<i; /* jeżeli stan wysoki to ustaw bit 1, po czym przesuń w lewo, żeby ten pierwszy był najstarszy */ _delay_us(70); // czekaj na zakończenie Read Time Slot } return byte; // zwróć odebrany bajt } Teraz tylko minimum kodu, aby odczytać temperaturę z układu (poszczególne instrukcje zapisywane do układu będą tylko w skrócie omówione, po resztę zapraszam do zapoznania się z datasheet). unsigned char temp1 = 0; // zmienne przechowujące wartości unsigned char temp2 = 0; // odebraną z ds18b20 unsigned char DS_gotowy = 0; // zmienna gotowości DS int main() { if(DS_Reset()) // jeżeli układ jest na linii i odpowiedział { DS_Write(0xcc); // SKIP ROM DS_Write(0x44); // CONVERT T DS_gotowy = 1; /* ustawiamy zmienną oznaczającą gotowość układu będzie potrzebna później */ } else // jeżeli układ nie odpowiedział DS_gotowy = 0; // ustaw zmienną gotowości na 0 _delay_ms(200); _delay_ms(200); /* czekamy na zakończenie konwersji temperatury; fabrycznie _delay_ms(200); konwersja ustawiona jest na 12bit, która trwa do 750ms; _delay_ms(200); my poczekamy 800ms if(DS_gotowy == 1) // jeżeli układ był na linii { if(DS_Reset()) // trzeba ponownie zresetować układ i jeżeli odpowiedział { DS_Write(0xcc); // SKIP ROM DS_Write(0xbe); // READ SCRATCHPAD temp1 = DS_Read(); // czytaj 2 bajty temperatury temp2 = DS_Read(); a = DS_Reset(); // reset - koniec czytania } } 5 Transoptory refleksyjne Są to często stosowane czujniki linii w LF, Minisumu itp. Na jednym schemacie jest pokazane podłączenie przez komparatory, dzięki czemu otrzymujemy od razu cyfrowe wyniki; jest to najszybszy sposób na sprawne otrzymywanie wyników. Drugi schemat przedstawia podłączenie do przetwornika analogowo-cyfrowego mikrokontrolera. Jest to nieco wolniejszy sposób, jednak do początkowych konstrukcji jak i nawet tych lepszych jest to rozwiązanie często stosowane. Potencjometrem regulujemy próg przełączania komparatora. Do wyjścia LM339 konieczne jest dołączenie rezystora pull-up o wartości ok. 100k lub włączyć w uC wewnętrzny pull-up gdyż ma wyjście typy „otwarty kolektor”. Gdy czujnik wykryje linię, na wyjściu pojawi się stan wysoki. Żeby zaprojektować płytkę z tym czujnikiem, należy tylko w nocie katalogowej odnaleźć gdzie jest katoda, anoda i można rysować. 6 TSOP312xx Są to często stosowane odbiorniki modulowanej podczerwieni. Końcówka xx oznacza daną częstotliwość, np. TSOP31236 oznacza odbiornik na 36kHz. Gdy odbiornik wykryje falę podczerwoną 36kHz, na wyjściu pojawia się stan niski. Schemat podłączenia przedstawia poniższy schemat: Rezystor R1, zgodnie z datasheet powinien mieć od 33R do 1k. Natomiast kondensator C1 powinien mieć wartość większą od 100nF. Ważną rzeczą o której należy wspomnieć jest to, że TSOP ten ma opóźnienie w sygnale wyjściowym (stan niski, gdy wykryje 36kHz) wynoszące od 7 do 15 okresów fali. 7 Modulowanie sygnału 36kHz Na koniec jeszcze krótki program pozwalający na modulowanie 36kHz diodą podczerwoną. Wykorzystamy tutaj tryb CTC Timera1. Bity WGM(13:0) ustawione są na 4. Dzięki temu otrzymujemy tryb CTC z maksymalną wartością zliczaną do OCR1A. Przekształcając wzór podany w datasheet, otrzymujemy, że przy oscylatorze 8MHz, preskalerze 1, do OCR1A wpisujemy 111. Wtedy otrzymamy w przybliżeniu 36 036 Hz, co jest bardzo bliskie 36kHz (TSOPy na szczęście mają pewną tolerancje częstotliwości). #include <avr/io.h> int main(void) { DDRB = 0x02; // Pin PB1 jako wyjście OCR1A = 111; // wartość wpisana do OCR1A TCCR1A |= (1 << COM1A0); // przy zrównaniu przełacz stan pinu na przeciwny TCCR1B |= (1 << WGM12) | (1 << CS10); // tryb CTC - max. OCR1A, preskaler 1 while(1) // pusta pętla programu {} } Jeszcze do tego schemat, jak podłączyć diodę. Podłączamy ją przez tranzystor. Narysowałem schemat tak, aby przez diodą płynął prąd ok 58mA. Zakończnie. Pisząc artykuł, posiłkowałem się prawie tylko notami katalogowymi układów; poza bibliotekami (HD44780, DS18B20), które już posiadałem. I link do artykułu na forum o użyciu SPI (tak jak napisałem przy 1-wire): Obsługa SPI Dla początkujących: Zachęcam bardzo gorąco do korzystania z not katalogowych przed napisaniem nowego tematu. O ile znalezienie informacji po polsku o prostych układach jest proste, to bardziej skomplikowane układy są dostępne często jedynie w wersji anglojęzycznej. Jeżeli nie rozumiesz, co jest w nocie napisane, spróbuj to przetłumaczyć w „Tłumacz Google”, a jak jeszcze nie rozumiesz, wtedy napisz temat na forum. Z początku, jak słabo znasz angielski, będzie to trudne. Jednak gdy będziesz często z tego korzystał, szybko nauczysz się zwrotów i słówek po angielsku, a wtedy poznawanie i zrozumienie nowych, lepszych układów będzie o wiele prostsze. Starałem się opisać ważniejsze układy stosowane w robotyce amatorskiej. Wszystkich nie byłem w stanie, bo powstał by niezły esej. Tyle na ten temat. Liczę na krytykę i sugestie dotyczące artykułu. Pozdrawiam, bartek1333 __________ Komentarz dodany przez: Treker Dodałem brakujący załącznik.
  41. 4 punkty
    No cóż... Nie ma czegoś takiego jak "teoria Xweldoga" ale, dzięki za nobilitację. Sądzisz, że nim napisałem bazowy art. Mostki H wcześniej nie zadałem sobie trudu by zbadać f dla PWM na kilku różnych silniczkach ? ( poza niskoindukcyjnymi do Heli ale na początku art. jest podane do jakich silniczków się odnosi co wciąż ignorujesz bo psułoby Ci Twe pesudoteorie ). Sądzisz, że nie zadałem sobie trudu by zmierzyć jaką f stosują producenci wkrętarek tylko, np. jechałem sobie rowerem, wywaliłem się, wyrżnąłem głową o krawężnik i wymyśliłem sobie 200Hz ? Słyszałeś o czymś takim, jak hamowanie elektrodynamiczne ? Rys. A jest poglądowy, nie radzę nikomu silniczkom przełączać obroty z "full prawo" od razu, bez wyhamowania, na "full lewo". Ale popatrz na B i E. W B silnik zawsze po "full" będzie miał zwierane końce. Natomiast w E można przerwać przepływ prądu albo przez przerzucenie przekaźnika albo zaprzestanie podawania PWM. W pierwszym stanie praktycznie natychmiast, w drugim przez chwilę będzie się kręcił bezwładnością ect. Skoro uważasz, że rzekomo nie ma czegoś takiego jak "z" i "bez hamowania" to sam zaproponuj nazwy albo to Ty nie pisz bzdur. Wiem, że np. silniki do wózków inwalidzkich mają osobne uzwojenie do hamowania a piszę to tu by uprzedzić ew. insynuacje że mi się te hamowania pomyliły czy co tam jeszcze jesteś w stanie wymyślić. Tam gdzie wsio jest proste i oczywiste, piszesz b.dużo i niejasno albo po prostu nie wiesz, po co wymyślono i zastosowano PWM. To jest jedyny sposób zmniejszania obrotów silnikom DC z zachowaniem max momentu obrotowego. Zawsze f do PWM wiązałem z małym duty. Zamiast wymyślać jakieś quasi-naukowe teorie nt. rzekomych mych błędów badawczych ( mam Ge na XR2206 chodzący do 1MHz ), zrób to o czym piszę nie wiem już który raz, banalnie prosty test: Ge z duty 20% i zwiększaj jakiemuś typowemu, najczęściej używanemu przez tutejszych forumowiczy silniczkowi ( prócz nich możesz też od heli, na pewno z takiego badania porównawczego będzie większy pożytek niż z całej tej Twej pisaniny ) f od zera do np. 10kHz. Przerasta Ciebie zrobienie tak prostego testu ? Znów Ci się coś pomyliło bo temat z mostkiem na 30A przeniósł się gdzie indziej ale, jeszcze nie skończyłem optymalizacji szczegółów a już masz jakieś "być może". Na jednym forum ( nie podam jakim bo autoreklama ) od dawna jest mój schemat w którym do dużych prądów, prócz transila, zalecam RC. Zdecydowanie więcej pożytku było by dla forumowiczy i mnie, gdybym nawiązał tu merytoryczną dyskusję z kimś kto coś takiego już robił a nie z kimś, kto przypuszcza jak co może się zachować. Drivery ? Do czego ? Do kilkuset Hz ? Stosuj je sobie Ty... Owszem, gdzieś tak w kHz zaczyna się potrzeba ich stosowania ale, do silników z wkrętarek nie są potrzebne kHz.
  42. 4 punkty
  43. 3 punkty
    Witam! Chciałbym się pochwalić moim pierwszym stworzonym projektem, a mianowicie systemem monitorowania środowiska. Interesuję się IoT i jego obszarami działania. Stworzyłem system, który składa się z urządzenia pomiarowego, chmury internetowej oraz aplikacji mobilnej. Struktura systemu została podzielona na 3 etapy, odpowiednia: warstwa sprzętowa, chmury i aplikacji. Warstwa sprzętowa Urządzenie ma za zadanie pobieranie danych z otoczenia oraz pobieranie ich do zewnętrznego serwera. Badane czynniki to: temperatura, wilgotność, opady atmosferyczne i ruch. Do wykonania urządzenia wykorzystano poniższe podzespoły: Arduino Uno Rev3, Czujnik temperatry i wilgotności DHT11, Czujnik ruchu PIR HC-SR501, Czujnik opadów deszczu YL-83, Moduł sieciowy Ethernet ENC28J60 mini, przewody połączeniowe, płytkę stykową. Projekt urządzenia wygląda następująco: Oraz urządzenie wykonane zgodnie z projektem: Następnie funkcje sensorowe urządzenia zostały przetestowane. Na płytkę został wgrany poniższy kod: #include <dht11.h> #define CzujnikTempWilgPin 2 //definicja numerów pinów #define CzujnikOpadAnalogPin A0 #define CzujnikOpadDigitalPin 4 #define CzujnikRuchPin 8 int wartosc_A0; int wartosc_D0; int wilgotnosc; int temperatura; int ruch; dht11 DHT11; int interwal = 30000; void setup() { Serial.begin(9600); //inicjalizacja monitora szeregowego pinMode(CzujnikOpadDigitalPin, INPUT);//konfiguracja zachowania pinów pinMode(CzujnikRuchPin, INPUT); } void loop() { DHT11.read(CzujnikTempWilgPin); //odczyt danych z czujnika DHT11 wilgotnosc = DHT11.humidity; Serial.print("Wilgotnosc (%): "); Serial.print((float)wilgotnosc, 0); temperatura = DHT11.temperature; Serial.print(" Temperatura (C): "); Serial.println((float)temperatura, 0); ruch = digitalRead(CzujnikRuchPin); //odczyt danych z czujnika ruchu if(ruch == HIGH){ Serial.println("Wykryto ruch"); } else { Serial.println("Nie wykryto ruchu"); } wartosc_A0 = analogRead(CzujnikOpadAnalogPin); wartosc_D0 = digitalRead(CzujnikOpadDigitalPin); if (wartosc_D0 == LOW) { Serial.print("DESZCZ PADA Z INTENSYWNOŚCIĄ "); Serial.println(wartosc_A0); } else { Serial.println("DESZCZ NIE PADA"); } delay(interwal); } Test monitorowania parametrów: Konieczna była regulacja czujników, aby mierzone wartości były jak najbardziej dokładne. Warstwa chmury Jako chmurę przechowującą i analizującą dane wybrano serwis Thingspeak.com. Jako sposób komunikacji wybrano interfejs REST API. W pierwszej kolejności założono konto oraz publiczny kanał wyposażony w 5 pól: temperatura, wilgotność, ruch, opady atmosferyczne i intensywność opadów. Sprawdzono również klucze danych odpowiedzialne za zapis i odczyt danych. Poniższa grafika przedstawia przesłane dane z urządzenia pomiarowego. Warstwa aplikacji Końcowym elementem systemu jest urządzenie z systemem Android. Stworzono aplikację, dzięki której możliwe jest połączenie z kanałem na thingspeak.com oraz pobranie danych. Aplikacja została zaopatrzona we wszystkie wyżej wymienione wykresy oprócz wykresu intensywności opadów. Projekt aplikacji został przedstawiony powyżej. Wszystkie wykresy zostały umieszczone w panelu przesuwnym. Do stworzenia wykresów wykorzystano biblioteki graficzne na system android: biblioteka do tworzenia kanału thingspeak.com oraz bibliotekę do tworzenia wykresów. Cały kod stworzonej aplikacji na system android. Agregacja całego systemu Następnie przyłączono urządzenie do sieci oraz został wgrany poniższy kod: #include <dht11.h> #include <UIPEthernet.h> #define CzujnikTempWilgPin 2 #define CzujnikOpadAnalogPin A0 #define CzujnikOpadDigitalPin 4 #define CzujnikRuchPin 8 byte mac[] = { 0x54, 0x34, 0x41, 0x30, 0x30, 0x31 };//adres MAC urządzenia EthernetClient client; char server[] = "api.thingspeak.com";//adres api thingspeak int wartosc_A0; int wartosc_D0; int wilgotnosc; int temperatura; int ruch; int interwal = 30000; dht11 DHT11; void setup() { Ethernet.begin(mac); //rozpoczęcie połączenia pinMode(CzujnikOpadDigitalPin, INPUT); pinMode(CzujnikRuchPin, INPUT); } void loop() { DHT11.read(CzujnikTempWilgPin); wilgotnosc = DHT11.humidity; temperatura = DHT11.temperature; ruch = digitalRead(CzujnikRuchPin); wartosc_A0 = analogRead(CzujnikOpadAnalogPin); wartosc_D0 = digitalRead(CzujnikOpadDigitalPin); if (client.connect(server, 80)) {//składanie komendy get client.print("GET /update?"); client.print("key=POZ0YSHN2VGMKS05"); client.print("&field1="); client.print(temperatura); client.print("&field2="); client.print(wilgotnosc); client.print("&field3="); client.print(wartosc_D0); if(wartosc_D0==LOW) { client.print("&field4="); client.print(wartosc_A0); } client.print("&field5="); client.print(ruch); client.println( " HTTP/1.1"); client.print( "Host: " ); client.println(server); client.println( "Connection: close" ); client.println(); client.println(); client.stop();// } delay(interwal); } System funkcjonował prawidłowo dane były przesyłane na serwer. Następnie uruchomiono aplikację mobilną. Oto kilka screenów: Dodatkowymi funkcjami apikacji jest przesuwanie oraz przybliżanie wykresów oraz odczytywanie dokładnych wartości po kliknięciu w punkt wykresu. Mam nadzieję, że przedstawiłem to w ciekawy i przejrzysty sposób. :) Pozdrawiam
  44. 3 punkty
    Dodając krok po kroku trochę automatyki w mieszkaniu powstał projekt i realizacja sterownika rolet zewnętrznych. Główne cechy urządzenia: obsługa 7 rolet zdalny dostęp z dowolnego miejsca na świecie sterowanie przez Wifi sterowanie przez Bluetooth sterowanie przez sieć CAN automatyczny pomiar czasu pracy poszczególnych rolet harmonogram otwierania/zamykania rolet sterowanie grupowe tworzenie scen pobieranie aktualnego czasu z serwera NTP Sterownik został podzielony na dwie części, pierwsza to płytka z przekaźnikami i zasilaniem, druga płytka to układ sterowania wraz z modułami komunikacyjnymi. Główne elementy wykorzystane w sterowniku to: STM32F103C8T6 jako moduł Bluepill Moduł Wifi ESP-12 Bluetooth HC-05 Największym wyzwanie okazało się wykrywanie zakończenia pracy rolety. Było to niezbędne do automatycznego pomiaru czasu pracy, które jest wykorzystywane do określania pozycji pośrednich. Na początku testowałem wykrywanie prądu z wykorzystaniem modułu ACS711, ale niewielki prąd pobierany przez roletę podczas pracy powodował niestabilne pomiary z układu ACS711. Drugim pomysłem było wykorzystanie przekładników prądowych. Pomiary były stabilne, ale to rozwiązanie odpadło ze względu na fizyczne rozmiary takich przekładników, potrzebowałem użyć ich aż siedem sztuk. Ostatecznie zastosowałem rozwiązanie polegające na spadku napięcia na diodach, które aktywuje transoptor PC814. Rolety które posiadam mają wewnętrzne zabezpieczenie przed podaniem napięcia na oba uzwojenia silnika (góra, dół), jednak tak zaprojektowałem układ, aby sprzętowo nie było to możliwe. Pokazane jest to na poniższym rysunku. Program został napisany w C++ z wykorzystanie Arduino Core. ESP-12 pełni rolę konwertera komunikacyjnego, od strony wifi oferuje RestApi, konwertuje otrzymane wiadomości/zapytania na komunikację uart i wysyła do głównego procesora STM32. Na drugim porcie uart w STM32 jest podobna komunikacja z wykorzystaniem modułu bluetooth. Moduł BT aktualnie służy do przeglądania bieżących logów. Ponadto moduł posiada opcję komunikacji z wykorzystaniem sieci CAN, jestem bardziej fanem rozwiązań przewodowych tam gdzie jest to możliwe. Jak w mieszkaniu pojawi się więcej elementów automatyki to będę chciał całość przepiąć na sieć CAN zamiast Wifi. Sterowanie modułem odbywa się jak wspomniałem wyżej zapytaniami REST, na Banana Pro posiadam domowy serwer www, dołożyłem do niego prostą stronę w PHP, która pozwala w wygodny sposób wysyłać zapytania do sterownika. Do połączenia się ze sterownikiem poza domową siecią wykorzystuje OpenVPNa.
  45. 3 punkty
    Nie wierzę!. 30 lat temu AutoLISP to była podstawa ujarzmiania AutoCAD'a. O ile pamiętam, jego początki dotyczyły sztucznej inteligencji. Aż się łza w oku kręci. Zalety? Wówczas dla mnie: notacja polska zapisu wyrażeń, dyscyplina kodu, nie puszczał niechlujstwa: Lost in Stupid Parentheses. Po Fortranie, to była dla mnie prawdziwa rewolucja i postawiłem w życiu sporo "nawiasów", choć nie jestem zawodowym programistą - inna branża. Będę to śledził
  46. 3 punkty
    Ja mam trochę inną prośbę. Moderatorowi pewnie nie wypada ubijać wątku, który poza poziomem wypowiedzi nic złego nie zawiera. Więc proponowałbym po prostu ignorować kolejne wpisy i nie karmić więcej trola (tutaj prośba do kolegi @Belferek, kończ waść wstydu oszczędź).
  47. 3 punkty
    Od dość dawna na Forbocie nie pojawił się żaden nowy robot klasy Sumo. Dlatego postanowiłem opisać swoją konstrukcję, która debiutowała na Robocompie 2015. Konstrukcja mechaniczna: Efektem prac nad robotem klasy Standard Sumo jest robot o nazwie Puszek. Mieści się on w wymiarach 20x20cm i wadze 3kg. Jego podwozie stanowi stalowa blacha o grubości 5mm. Z przodu umieszczony jest nóż ze stali HSS, który powinien wytrzymać starcia z innymi robotami. Koła mają średnicę 55mm i składają się z wydrukowanych felg i opon odlanych z silikonu. Dzięki miękkiemu silikonowi uzyskana została dość dobra przyczepność, jednak opony takie łatwo ulegają uszkodzeniom i po pewnym czasie wymagają wymiany. Każde koło napędzane jest osobnym silnikiem Robotus Titan. Zasilane są one z LiPo 4s 3.3Ah. Jednak mimo napięcia wyższego niż znamionowe, silniki są zbyt słabe, żeby robot nawiązał równą walkę z dużo mocniejszymi konstrukcjami. Niestety podczas składania okazało się, że robot będzie zbyt ciężki, dlatego blacha stanowiąca podwozie została nawiercona, co widać na zdjęciu poniżej: Elektronika: Mózgiem robota jest Arduino Mini, czyli popularna Atmega328p. Odpowiada ona za odczyty 4 czujników przeciwnika Sharp GP2Y0A21YK0F, 2 czujników linii KTIR0711S oraz odpowiednie wysterowanie silników poprzez mostki oparte na półmostkach BTS7960B. Są to najtańsze mostki H z ebay, o teoretycznie wystarczającej mocy. Jak do tej pory wszystko jest z nimi ok. Cała elektronika zasilana jest poprzez stabilizator LM7805, który wymagał założenia dodatkowego radiatora. Za odpowiednie wysterowanie silników odpowiada regulator typu P, którego sygnałem wejściowym jest błąd obliczany na podstawie odczytów z czujników przeciwnika, natomiast wyjściem jest sygnał PWM oraz kierunek obrotów silników. Kilka filmików z YT nagranych w Łodzi przez użytkownika ps19: Osiągnięcia: 1. I miejsce Robocomp 2015 2. II miejsce SumoChallenge 2015 W przyszłości planuje stworzyć konstrukcję na dużo mocniejszych silnikach, z którą będę mógł się również pokazać i powalczyć w Wiedniu.
  48. 3 punkty
    Typowa oś małych silników to 3.2mm: https://www.gotronik.pl/mini-wiertarka-12v-do-plytek-drukowanych-pcb-p-5067.html https://www.gotronik.pl/uchwyt-samozaciskowy-0-3-3-50mm-do-wiertarki-adapter-p-5065.html
  49. 3 punkty
    Wykładowca miał rację. Układ jest teoretycznie symetryczny, ale ma dwa stany stabilne i któryś musi wybrać. Po włączeniu zasilania, mimo dobrej baterii napięcie (i prąd) nie pojawia się od razu. Gdybyś obejrzał to pod mikroskopem (no dobra, na ekranie oscyloskopu) to zauważysz, że narastanie zachodzi z pewną skończoną prędkością. Całość ma bowiem jakąś pojemność i indukcyjność (przewody, elementy półprzewodnikowe, oporniki, wszystko). Są to nieduże wartości, ale jednak niezerowe a to opóźnia stromość zbocza i to jest właśnie czas w którym następuje podjęcie "decyzji". Ponieważ masz tu silne sprzężenie zwrotne dodatnie, to każda niesymetria jest powielana do ostatecznego zwycięstwa którejś strony. A w tak prostym układzie każdy element się liczy. Na poziomie zasilania rzędu 0.5V, gdy tranzystory są jeszcze oba wyłączone, baza każdego z nich jest zasilana przez "przeciwną" diodę LED i jej opornik. Mamy więc aż cztery elementy wpływające na prąd bazy: dwa rezystory, LED i złącze BE tranzystora. Do tego dochodzi wzmocnienie samego tranzystora czyli to jak dobrze "spożytkuje" on prąd swojej bazy na prąd kolektora. Ponieważ nie jest możliwe, by ten zestaw był identyczny w obu gałęziach, któryś umożliwia przepływ większego prądu i ten tranazystor delikatnie zaczyna przewodzić lepiej. A wystarczy 0.1% różnicy gdzieś przy zasilaniu 1 czy 2V by dany tranzystor "popuścił" trochę prądu kolektora. Ten prąd "wysysa" dopływający z góry prąd z gałęzi LED i przydusza do masy (obniża) napięcie kolektora. To z kolei zmniejsza prąd bazy konkurenta i dalszy proces jest lawinowy - to właśnie jest to dodatnie sprzężenie zwrotne. Gdy raz układ wejdzie w tunel niesymetrycznego rozpływu prądów, nie ma odwrotu, musi zapaść się w lewy lub prawy dołek. Nie wiadomo który element jest kluczowy. Typowe oporniki mają tolerancje 1-5%, diody LED w ogóle nie są określane w ten sposób - tam raczej bazujesz na ogólnym wykresie prądu od napięcia, ale nikt nie podaje dokładnych napięć przewodzenia i zachowania się LEDa przy prądach np. 1uA, bo i tak sensownie świecić zaczyna dopiero przy setkach uA. Proces produkcji tranzystorów także ma jakieś rozrzuty: po pierwsze powstały z dwóch różnych kawałków monokryształu krzemu, po drugie domieszkowanie warstw może zachodzić różnie w różnych miejscach płytki, do tego dochodzi cięcie, bonding czyli lutowanie doprowadzeń, różnice w położeniui na elemencie nośnym, Twój montaż czyli kabelki, połączenia, fizyczna geometria układu, itd itp. Gdybyś chciał się dowiedzieć co determinuje zachowanie układu, musiałbyś kolejno zamieniać parami elementy z gałęzi tak jak sugerował prowadzący, ale nie tylko tranzystory - to dotyczy wszystkiego. Niestety być może jest tak, że to dany zestaw jest kluczowy bo tu liczy się suma parametrów jego elementów. Zamienianie części w łańcuszku zasilania bazy w końcu doprowadzi do odwrócenia, ale nie musi to być czarno-białe i możesz mieć sytuację, w której druga strona zacznie przeważać, ale nie w 100% przypadków. Z punktu widzenia aplikacji - o ile nie robisz generatora szumu - układ zachowujący się losowo jest słaby. A przecież problem stanu początkowego dotyczy wszystkich układów dwustanowych. Przecież z takich 2- lub 4-tranzystorowych modułów zrobione są np. statyczne pamięci RAM czy przerzutniki będące elementami liczników, timerów czy rejestrów mikroprocesorów. Po włączeniu zasilania ich stan jest przypadkowy, ale o ile w pamięci śmieci nie przeszkadzają - program pobierany i wykonywany np. z FLASHa może po starcie RAM wyzerować, o tyle stan wewnętrzny procesora nie może być nieznany bo wszystko się posypie. Dlatego właśnie tak ważna jest generacja sygnału RESET. Wszystkie przerzutniki mają dodatkowe wejście zerowania wymuszające przejście do jednego, określonego stanu. Kiedyś musiałeś sam zadbać, by wygenerować sygnał zerowania procesora po włączeniu. Dziś takie układy nadzoru są wbudowywane w kostki i to własnie te bloczki produkują RESET zaraz po włączeniu Vcc. Dodatkowa nóżka umożliwia restart systemu na żądanie, ale podstawowe wyczyszczenie stanu wszystkich przerzutników i poprawny start programu od adresu zero odbywa się na żądanie jakiegoś niepozornego modułu ukrytego wewnątrz struktury mikrokontrolera. Wykrywa on narastanie zasilania i jego stabilizację na określonym poziomie i wysyła wszystkim wokół impuls/sygnał RESET. Po jego zakończeniu (trwa to zwykle kilka-naście-dziesiąt milisekund) procesor jest w stanie początkowym i może zacząć przewidywalne działanie. Ty możesz to samo wbudować w swój przerzutnik i cieszyć się jego wymuszonym determinizmem, bo to co masz teraz to czysta losowość. I nie polega ona na tym, że po włączeniu masz różne stany ale na tym, że budując układ nie jesteś w stanie przewidzieć która gałąź zwycięży. Zakładając, że konstruujesz np. licznik i chcesz 4 takie przerzutniki to chciałbyś pewnie, by po włączniu licznik był wyzerowany a tego nie zagwarantujesz wprost. Możesz żmudnie dobierać elementy co sprowadza się do wbudowania pewnej niesymetrii (która jest szkodliwa), ale możesz po prostu doprowadzić sygnał RESET z przycisku albo z układu RC i zerować licznik automatycznie bez oglądania się na to który przerzutnik woli który stan startowy.
  50. 3 punkty
    Wstawiam zatem tajne zdjęcia mojego skomplikowanego mechanizmu pozwalającego zamocować Proxxona do zwykłego (lepszego?) statywu do wiertarki. Zatem, należy wyprodukować takie oto coś: Jak widać, jest to tuleja, która z zewnątrz ma 43mm (mocowanie do zwykłej wiertarki), a wewnątrz powinien wchodzić pasownie uchwyt Proxxona (który deklaruje 20mm). Tuleję należy rozciąć wzdłuż. Kołnierzyk służy tylko i wyłącznie do tego, aby wygodniej wkładać tuleję do statywu. Ta tulejka jest akurat z aluminium, ale przypuszczam że z tworzywa albo ze stali będzie się sprawdzała równie dobrze. Tutaj oto możemy zauważyć, jak bardzo pomocny jest ergonomiczny kołnierzyk, dzięki któremu tulejka nie pitła na dół i mogłem na przykład zrobić powyższe zdjęcie. Po włożeniu Proxxona do tulejki i zaciśnięciu uchwytu na statywie, powinna nam się delikatnie ścisnąć również tulejka, a co za tym idzie unieruchomić Proxxona. Z góry uprzedzam, że z tego co mierzyłem otwór wewnętrzny aluminiowej tulejki zmniejszył się o jakieś 0,3mm. Jeśli otwór jest zrobiony z dobrą tolerancją, to jest to całkowicie wystarczające. Teraz można już rzucać statywem w teściową nie martwiąc się, że szlifierka wypadnie. Jeśli ktoś pomyślał sobie "co za debil, przecież jakby tulejka była krótsza to miałby dostęp do uchwytu wiertarskiego i nie musiał wyjmować szlifierki przy każdej zmianie narzędzia" to może sobie w nagrodę kupić piwo, gdyż jest to prawda. Jednakże, ponieważ pierwszą tulejkę zepsułem, obie robiłem późnym wieczorem, są wakacje oraz jestem leniem, to nie mam zamiaru poprawiać tego błędu.
Tablica liderów jest ustawiona na Warszawa/GMT+02:00
×
×
  • Utwórz nowe...