Skocz do zawartości

Przeszukaj forum

Pokazywanie wyników dla tagów 'druk 3D'.

  • Szukaj wg tagów

    Wpisz tagi, oddzielając przecinkami.
  • Szukaj wg autora

Typ zawartości


Kategorie forum

  • Elektronika i programowanie
    • Elektronika
    • Arduino i ESP
    • Mikrokontrolery
    • Raspberry Pi
    • Inne komputery jednopłytkowe
    • Układy programowalne
    • Programowanie
    • Zasilanie
  • Artykuły, projekty, DIY
    • Artykuły redakcji (blog)
    • Artykuły użytkowników
    • Projekty - DIY
    • Projekty - DIY roboty
    • Projekty - DIY (mini)
    • Projekty - DIY (początkujący)
    • Projekty - DIY w budowie (worklogi)
    • Wiadomości
  • Pozostałe
    • Oprogramowanie CAD
    • Druk 3D
    • Napędy
    • Mechanika
    • Zawody/Konkursy/Wydarzenia
    • Sprzedam/Kupię/Zamienię/Praca
    • Inne
  • Ogólne
    • Ogłoszenia organizacyjne
    • Dyskusje o FORBOT.pl
    • Na luzie

Kategorie

  • Quizy o elektronice
  • Quizy do kursu elektroniki I
  • Quizy do kursu elektroniki II
  • Quizy do kursów Arduino
  • Quizy do kursu STM32L4
  • Quizy do pozostałych kursów

Szukaj wyników w...

Znajdź wyniki, które zawierają...


Data utworzenia

  • Rozpocznij

    Koniec


Ostatnia aktualizacja

  • Rozpocznij

    Koniec


Filtruj po ilości...

Data dołączenia

  • Rozpocznij

    Koniec


Grupa


Imię


Strona

Znaleziono 12 wyników

  1. 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:
  2. Opisywałem kiedyś takie małe "coś" podłączone do RPi, które pełniło rolę dodatkowych klawiszy i LED do Octoprinta. To coś działało sobie bez problemu przez parę lat, okazało się niesamowicie przydatne, i pewnie bym nie wtykał palców do czegoś co działa gdyby bnie jeden drobiazg: potrzebowałem RPi w wersji co najmniej 3b. Jako że zakup RPi to na chwilę obecną temat raczej na opowiadanie SF, postanowiłem wyjąć z drukarki 3b+ i w jego miejsce podłączyć terminal Wyse.Miałem co prawda jeden "luźny" Zero W, ale ten podobno kaszle już przy prostym drukowaniu, a obsługa dwóch drukarek jednocześnie jest raczej poza jego możliwościami... Zainstalowałem Debiana, Octoprinta, skonfigurowałęm - ruszyło od strzału. Tylko problem: to swoje urządzenie podłączałem do GPIO, a terminal takowego nie posiada... Postanowiłem więc lekko przerobić program i zrobić nowe urządzenie. Po przeszukaniu szuflady okazało się, że mam do dyspozycji: Arduino Pro Mini (co prawda z upalonym jednym pinem, ale to akurat mały problem) Konwerter USB/UART na kabelku (coś takiego), który leżał sobie parę lat nieużywany Dwa wyświetlacze 4x7seg (z czego jeden okazał się bezużyteczny, bo nie wiem czemu nie chciał współpracować z Arduino, mimo że z ESP nie miał problemów) No i oczywiście jakieś pstryczki. Postanowiłem więc zagospodarować Arduino i konwerter. Na początek oczywiście konfiguracja konieczna do działania całości. Ponieważ obie drukarki mam na CH340, nusiałem trochę pokombinować z rozróżnianiem. Na szczęście zrobiłem to już wcześniej, tak że wystarczyło dodanie dwóch linijek do reguł udeva: ACTION=="add", SUBSYSTEMS=="usb", ATTRS{idProduct}=="7523", ATTRS{idVendor}=="1a86", ATTRS{bcdDevice}=="0260", RUN+="/bin/systemctl kill -s USR1 watchprinter", SYMLINK+="ttyUSB98" ACTION=="add", SUBSYSTEMS=="usb", ATTRS{idProduct}=="7523", ATTRS{idVendor}=="1a86", ATTRS{bcdDevice}=="0254", RUN+="/bin/systemctl kill -s USR2 watchprinter", SYMLINK+="ttyUSB99" przy czym demon watchprinter (służący do poinformowania octoprinta, że drukarka została włączona) był prawie taki sam, jak poprzednio, z tą różnicą, że łączył się z jedną z dwóch instancji octoprinta. Ogólnie urządzenie wyszło mi nawet całkiem ładnie (przepraszam za jakość zdjęcia, ale moja komórka nie chciała mi złapać ostrości przy wyświetlaczu świecącym prosto w obiektyw). Przy okazji wyszło na to, że wystarczy mi jeden demon z programem (w starej wersji miałem dwa, jeden sterował diodami, drugi przyjmował polecenia od klawiszy). Ponieważ wyświetlacz daje dużo więcej możliwości, postanowiłem wyświetlić jakieś sensowne komunikaty: nc -- brak połączenia z demonem -- -- drukarka wyłączona IDLE - drukarka włączona, bezczynna HEAT - grzanie stołu/hontendu PAUS - wydruk wstrzymany (np. ręczna zmiana koloru filamentu) Cncl - wydruk anulowany Przy drukowaniu naprzemiennie wyświetlają się pozostały czas i procent wydruku. Klawisze realizują bardzo proste funkcje: PAU - spauzowanie wydruku PAU (long press) - wyłączenie silników RUN - wznowienie wydruku RUN (long press) - podłączenie drukarki do octoprinta (np. po restarcie octoprinta, gdy drukarka jest włączona). Załączam kody zarówno demonów watchprinter i octan, jak i szkic dla Arduino: octan.zip Jedna uwaga: co prawda urządzenie miało obsługiwać dwa wyświetlacze i cztery klawisze, ale z uwagi na posiadanie jednego sprawnego wyświetlacza część kodu pozostała w strefie pobożnych życzeń. Mam nadzieję jednak, że jeśli ktoś będzie chciał coś podobnego zrobić nie będzie mu to przeszkadzać (albo skontaktuje się z informacją, że bez wersji na dwie drukarki życie mu niemiłe i muszę brakującą część kodu dopisać) 🙂 Schematu nie podaję - miejsca podłączenia dwóch klawiszy i wyświetlacza można określić na podstawie pliku .ino (a do tego sprowadza się całość). Ogólnie mogę powiedzieć, że na Wyse Zx0D (2 GB RAM, 16 GB SDD) chodzi to lepiej niż na RPi (który miał czasami problemy z dogadaniem się z drukarką z przyczyny takiej, że miał problemy).
  3. Witam Znudzony ręcznym ustawianiem napięć na przetwornicy, mierzeniem prądu miernikiem stwierdziłem że stworze urządzenie które będzie to robić za mnie. Właśnie projekt zbudowany pod tym pretekstem chciałbym przedstawić. Projekt ten jest w zasadzie zasilaczem laboratoryjnym, tylko że zasilacz AC DC może być dowolny, podłączany właśnie do tego modułu, a w środku modułu ochrona przeciw zbyt wysokimi napięciami, prądami jest zarządzana przez płytkę blue pill której interfejsy do programowania są wyprowadzone na zewnątrz, co umożliwia wiele, np: Nie wyłączenie przepływu prądu jeżeli prąd skoczył ponad limit na czas mniejszy niż ustawiony Wyrzucanie pomiarów przez UART do późniejszej analizy Podłączenie czegokolwiek dodatkowo przez interfejs I2C, np pomiaru temperatury, natężenia światła i dodatkowe warunki do działania urządzenia na podstawie tych danych ( Właśnie do tego jest "dziura" po prawej stronie, do montowania dodatkowych modułów w razie potrzeby ) IO na sterydach: podłączenie potężnych tranzystorów do IO mikrokontrolera i sterowanie nimi ( np, by włączyć drugie urządzenie parę sekund po pierwszym ) Samo urządzenie prezentuje się tak: W środku znajduje się przetwornica na układ LM2596 i to od niej zależą parametry prądowe całego urządzenia, druga przetwornica na 5V do zasilania mikrokontrolera, oraz do szybkiego dostępu do 5V, które można zmienić przełącznikiem który jest ukryty na lewo od ekranu. To właśnie ta przetwornica miała zintegrowany układ do pokazywania napięcia na wyświetlaczu 7 segmentowy który wykorzystałem. Oczywiście odpowiedni bezpiecznik, tranzystory o których już wspominałem, oraz układ INA219 który mierzy prąd poprzez I2C, bardzo fajny układ. Urządzenie ma wiele skutków wątpliwych decyzji, choć na pierwszy rzut oka nie mają sensu, postaram się wytłumaczyć: Złączki wago z przodu - moim zdaniem to najlepsze wielorazowe połączenia kabli, bardzo bym chciał by istniały moduły gdzie jeden kabel da się przylutować od tyłu do jakieś blaszki. potencjometr ukryty pod plastikowym zakryciem miał nie istnieć, ale moduł potencjometra cyfrowego albo dotarł do mnie zepsuty, albo sam go zepsułem. I tak ustawianie napięć teraz jest szybsze. Połączenia XT30 użyłem by można łatwo używać przetwornicy z akumulatorami dla dronów. Porty USB są ze sobą połączone liniamy zasilania, więc można użyć tej "przetwornicy" jako zewnetrznego zasilania dla urządzeń USB. Minusem jest to że na portach USB może pojawić się wyższe napięcie, ale jest to w praktyce niemożliwe - oprogramowanie pilnuje docelowego napięcia. Zworki, piny i przycisk na drugim planie służą do programowania mikro kontrolera w środku, jak już wspominałem. I może się już ktoś zastanawiał, ale istnieje powód dla którego nie pokazałem jeszcze środka urządzenia... Więc jak można zauważyć, masa rzeczy na suficie urządzenia, a ich źródło na dole może się źle skończyć dla wyglądu wewnętrznego. Może kogoś zainteresuję jak zwykły mikro kontroler jest w stanie włączać i wyłączać przetwornicę na tym typowym układzie. Rozwiązaniem było podniesienie pinu 5 o dosłownej nazwie ON/OFF, i podłączenie go do pinu IO mikrokontrolera. Niestety pełne oprogramowanie jeszcze nie jest gotowe, a chciałbym choćby snake'a zagrać. Choć dodałem już pewną funkcję - do oscylowania silnikami z różnych śmieci, testowania ich. Rezultat był nieoczekiwany - Ekran OLED z sterownikiem SSD1306 jest wrażliwy na tyle, że czasami krzaczki pojawiały się na ekranie. Najczęściej jednak cała komunikacja I2C padała, ekran albo nic nie wyświetlał, albo wyświetlał zerowe pomiary napięć, które także były pobierane przez I2C jak już wcześniej wspominałem. Obudowę także sam zaprojektowałem i wydrukowałem na drukarce 3D, oto przecięcie modelu: Oto obecne główne menu, zabezpieczenie przeciw prądowe i okablowanie w środku 😉 Zapraszam do zadawania pytań, gdyby takie się znalazły.
  4. Cześć, tytułem wstępu: jestem kompletnym laikiem jeśli chodzi o druk 3D (co prawda w pracy mamy drukarkę 3D za kilkanaście tysięcy, ale kolega mechanik ciągle na niej drukuje jakieś prototypowe części i jest cały czas zajęta). Nie mam żadnego doświadczenia ani z samym drukiem 3D, ani z software'm do tworzenia modeli 3D do druku. Powoli dojrzewam do tego, aby kupić sobie pierwszą drukarkę 3D do domu. Potrzebuję jej głównie do drukowania obudów do układów elektronicznych oraz prostych części np. uchwyt do kamery, do czujników itp. Nie oczekuję ani dużej dokładności ani wysokiej prędkości wydruku, bardziej istotna jest dla mnie niska cena takiej drukarki. Przeglądając jakie model są dostępne w chińskim sklepie Banggood.com znalazłem kilka tanich modeli: https://www.banggood.com/Creality-3D-Ender-3-Pro-DIY-3D-Printer-Kit-220x220x250mm-Printing-Size-With-Magnetic-Removable-Platform-Sticker-or-Power-Resume-Function-or-Off-line-Print-or-Patent-MK10-Extruder-or-Simple-Leveling-p-1346320.html?rmmds=search&cur_warehouse=ES https://www.banggood.com/HOMERS-or-TEVO-Tarantula-Pro-3D-Printer-Kit-with-235x235x250mm-Printing-Size-MKS-GenL-Mainboard-0_4mm-Volcano-Nozzle-Support-1_75mm-Filament-p-1470655.html?rmmds=search&cur_warehouse=ES https://www.banggood.com/Geeetech-A10-Aluminum-Prusa-I3-3D-Printer-220+220+260mm-Printing-Size-p-1329872.html?rmmds=detail-left-hotproducts__3&cur_warehouse=CZ https://www.banggood.com/TWO-TREES-BLUER-3D-Printer-DIY-Kit-235+235+280mm-Print-Size-Support-Auto-level-or-Filament-Detection-or-Resume-Print-with-TMC2208-Silent-Driver-or-MKS-ROBIN-NANO-Mainboard-p-1566275.html?rmmds=search&cur_warehouse=CN https://www.banggood.com/Anet-A6-3D-Printer-DIY-Kit-1_75mm-0_4mm-Support-ABS-PLA-HIPS-p-1130754.html?rmmds=search&cur_warehouse=CN Najbardziej podoba mi się model: Creality 3D® Ender-3 Pro (pierwszy link), ale właśnie na forum Forbot'a są posty mówiące o różnych problemach właśnie z tym typem drukarki (chociaż opinie w sklepie dotyczące tej drukarki są dobre). Pod uwagę biorę jeszcze tych kilka wymienionych wyżej modeli, ale jak mówię nie mam żadnego doświadczenia z drukiem 3D, więc jesli ktoś mógłby mi polecić sprawdzony model w cenie do 800 PLN to będę bardzo wdzięczny. Jestem pod wrażeniem postu kolegi @Kredek, który sam zbudował budżetową drukarkę 3D: . Na początku myślałem , aby pójść tą samą drogą, ale z braku doświadczenia wolę nie ryzykować i kupić gotowy kit do złożenia. Drugie moje pytanie dotyczy oprogramowania do tworzenia modeli 3D, kolega mechanik (z pracy) powiedział, że nie ma co brać pod uwagę darmowego softu (on używa "Inventora"), ale ja jestem innego zdania. Szczególnie zainteresował mnie "Fusion 360", który jest darmowy do użytku nie-komercyjnego: https://www.autodesk.com/products/fusion-360/personal Może ktoś mógłby podać jeszcze inne darmowe alternatywy z jakimś krótkim ich porównaniem (mocne i słabe strony) - za wszelkie komentarze będę bardzo wdzięczny. Pozdrawiam
  5. Witam, proszę o wrzucanie doświadczeń związanych z wykańczaniem wydruków 3D z różnych materiałów. Drukarkę mam 3 tygodnie i zaczynam swoją przygodę. Na razie drukowałem z PLA i zamierzam zrobić testy pokrycia wydruku żywicą epoksydową. Najpierw wydruk delikatnie przytrę papierem ściernym. Chcę uzyskać gładką i jednolitą powierzchnię.
  6. Słowem wstępu, projekt ten został wykonany w czasie pandemicznego wymogu pozostania w domu, kiedy to zbliżał się koniec semestru na mojej uczelni. Był to mój projekt zaliczeniowy z przedmiotu o wdzięcznej nazwie: "Układy mikroprocesorowe". Prowadzący udostępnił listę urządzeń, z której każdy może wybrać jedno. Po dokonaniu wyboru należało wykonać je w warunkach domowych do końca wówczas trwającego miesiąca. Jako że był to dość niewygodny moment do wychodzenia po części do sklepu, a na zamówienie ich i czekanie nie chciałem marnować czasu, zrobiłem szybki przegląd swojego warsztatu. Wśród przewalających się podzespołów i elementów udało mi się dostrzec czujnik gazów MQ-2, który kiedyś kupiłem w promocji wraz z czujnikami alkoholu MQ-3. Jako że na liście widniał czujnik gazów, niewiele myśląc zebrałem to co miałem i przystąpiłem do pracy. Efektem tej pracy jest właśnie... DETEKTOR GAZÓW W POWIETRZU ATMOSFERYCZNYM OPARTY NA CZUJNIKU MQ-2 Detektor gazów przystosowano do pomiaru stężeń czterech gazów: LPG, dymu, CO oraz H2. Urządzenie zaprojektowano tak, by miało kompaktową obudowę i prosty, intuicyjny interfejs użytkownika. Wszystkie elementy tego interfejsu opisano na rysunku 1. Gaz którego odczyt ma zostać dokonany, zostaje wybrany za pomocą pokrętła głównego. Zgodnie z jego nastawą detektor będzie przeliczał odczyty czujnika pod wybrany gaz i wyświetli wynik na skali ledowej, znajdującej się po lewej stronie urządzenia. Wartości zmierzonych stężeń przelicza się na jednostkę PPM (Part Per Milion). W zależności od wysokości stężenia, skala LED pokazuje nie tylko zakres, ale także za pomocą odpowiedniej barwy pokazuje czy dany gaz znajduje się w strefie małego, umiarkowanego czy też dużego niebezpieczeństwa. rysunek 1. opis elementów detektora Urządzenie nie jest skomplikowane zarówno w swojej budowie, ale także w działaniu. Cały proces zachodzący pod obudową wykonaną z PLA opisuje schemat algorytmu na rysunku 2. rysunek 2. schemat algorytmu detektora Czytając schemat elektryczny umieszczony na rysunku 3., od lewej strony widzimy źródło zasilania, którym są akumulatory li-ion o napięciu 4.2 [V] każdy. Układ może być zamiast z akumulatorów zasilany z zasilacza o napięciu od 9 do 12 [V], o wydajności minimum 1.5 [A]. Po załączeniu układu przyciskiem “start” zasilanie prowadzone jest na dwa stabilizatory liniowe LM7805. Jeden z nich zasila mikrokontroler oraz interfejs urządzenia, a drugi odpowiada za zasilenie czujnika MQ-2. Zastosowanie dwóch stabilizatorów wiąże się z zapotrzebowaniem czujnika na prąd. Aby nie wprowadzać zakłóceń w działaniu mikrokontrolera, czujnik zasilany jest osobno a sam stabilizator jest chłodzony dodatkowo radiatorem. Sercem urządzenia jest mikrokontroler Atmega328PU. Zastosowano go ze względu na odpowiednio dużą liczbę dostępnych portów oraz wbudowany przetwornik analogowo- cyfrowy. Mikrokontroler przyjmuje sygnał analogowy z czujnika gazów na pin A1, analizuje go, sprawdza nastawę przełącznika “S1” po przez weryfikację stanów portów A2-A5, a na koniec wyświetla wynik za pomocą diod LED podpiętych pod porty PD0-PD7 oraz PB0. Oprócz tego, układ podłączony jest do 10-cio pinowego gniazda CANDA, które umożliwia programowanie mikrokontrolera bez konieczności rozbierania urządzenia i wyjmowania Atmegi328PU. rysunek 3. schemat elektryczny detektora gazów Płytę główną detektora zaprojektowano przy pomocy programu Cadsoft Eagle. Wykonany w nim wzór został przeniesiony na miedziany laminat za pomocą metody termicznej, a następnie wytrawiony nadsiarczanem sodowym. rysunek 4. Po lewej projekt PCB, po prawej zmontowana płytka Obudowa została zaprojektowana w programie Fusion360. Rzut na model złożony w programie cadowskim ukazano na rysunku 5. Na podstawie utworzonego modelu wykonano wydruki 3D, które po oszlifowaniu oraz wyczyszczeniu skompletowały projekt i umożliwiły zabudowę elektroniki w kompaktowej obudowie. rysunek 5. model obudowy w Fusion360 Jednym z najważniejszych etapów konstruowania detektora było wyprowadzenie liniowej zależności na stężenie gazu. Nota katalogowa czujnika przedstawia charakterystykę PPM w skali logarytmicznej. Wyprowadzenie wzoru było konieczne aby umożliwić mikrokontrolerowi wykonywanie obliczeń: a) wyprowadzenie zależności ogólnej: a = (Y2 – Y1) : (X2 – X1) Y - Y1 = a*(X- X1) X= ((Y – Y1) : a) + X1 logX= ((log(Y – Y1)) : a) + X1 X = 10^ (((log(Y – Y1)) : a) + X1) gdzie: X= PPM, Y= Rs: Ro PPM = 10^ (((log((Rs: Ro) – Y1)) : a) + X1) b) przykład aplikacji wzoru dla odczytu stężenia gazu LPG w powietrzu: X1 = 200, X2 = 10000, Y2 = 1,6, Y1 = 0,26 X1 = log200 = 2,3 X2 = log10000 = 4 Y1 = log1,6 = 0,2 Y2 = log0,26 = -0,58 PPM = 10^ (((log((Rs: Ro) – 0,2)) : (-0,58)) + 2,3) rysunek 6. po lewej charakterystyka PPM= f(Rs/Ro) z datasheet MQ-2, po prawej charakterystyka PPM=f(Uo) wykonana na bazie obliczeń w programie Graph 4.4.2 Film z prezentacji działania urządzenia: Na koniec udostępniam jeszcze kod napisany w środowisku Atmel Studio: #define F_CPU 16000000 #include <avr/io.h> #include <avr/interrupt.h> #include <util/delay.h> int main(void) { //Deklaracja portów wyjściowych DDRD = (1 << PORTD0) | (1 << PORTD1) | (1 << PORTD2) | (1 << PORTD3) | (1 << PORTD4) | (1 << PORTD5) | (1 << PORTD6) | (1 << PORTD7); DDRB = (1 << PORTB0) | (1 << PORTB1); //Deklaracja portów wejściowych DDRC = 0x00; //Załączenie rezystorów podciągających do portów A2- A5 PORTC = 0x3C; //Skala ledowa zaczyna się ładować, aby po dotarciu do wartości maksymalnej uruchamić krótki, podwójny brzęk buzzera informujący o rozpoczęciu kalibracji czujnika PORTB |= (1<<PORTB0); _delay_ms(300); PORTD |= (1<<PORTD7); _delay_ms(300); PORTD |= (1<<PORTD6); _delay_ms(300); PORTD |= (1<<PORTD5); _delay_ms(300); PORTD |= (1<<PORTD4); _delay_ms(300); PORTD |= (1<<PORTD3); _delay_ms(300); PORTD |= (1<<PORTD2); _delay_ms(300); PORTD |= (1<<PORTD1); _delay_ms(300); PORTD |= (1<<PORTD0); _delay_ms(300); PORTB |= (1<<PORTB1); _delay_ms(300); PORTB &= ~(1<<PORTB1); _delay_ms(300); PORTB |= (1<<PORTB1); _delay_ms(300); PORTB &= ~(1<<PORTB1); _delay_ms(100); //Ustawienia rejestrów do obsługi przetwornika analogowo-cyfrowego: ADMUX = (1 << REFS0) | ( 1 << MUX0 ); ADCSRA = (1 << ADEN) | (1 << ADIE) | (1 << ADPS0) | (1 << ADPS1) | (1 << ADPS2); DIDR0 = (1 << ADC0D); ADCSRA |= (1 << ADSC); TCCR0B = (1 << CS00) | (1 << CS02); //Deklaracja mierzonej wartości napięcia: double pomiar_V; //Parametry krzywej gazu LPG: double LPG_X1 = 2.3; double LPG_Y1 = 0.2; double LPG_a = 0.46; //Parametry krzywej dymu: double SMOKE_X1 = 2.3; double SMOKE_Y1 = 0.56; double SMOKE_a = 0.5; //Parametry krzywej tlenku węgla: double CO_X1 = 2.3; double CO_Y1 = 0.7; double CO_a = 0.31; //Parametry krzywej wodoru: double H2_X1 = 2.3; double H2_Y1 = 0.32; double H2_a = 0.45; //Parametry kalibracji czujnika: double ilosc_probek_kalibracyjnych = 60; double czas_probkowania_kalibracyjnego = 500; double rezystancja_Robc = 5.6; double wsp_czystosci_powietrza = 9.83; //Parametry próbkowania napięcia: double ilosc_probek_pomiarowych = 60; double czas_probkowania_pomiarowego = 5; double Rs_do_Ro = 0; //Zmienna zliczania: int i = 0; //Zmienna zliczająca- suma: int suma = 0; //Deklaracja Ro: double Ro = 0; //***********************kalibracja czujnika**************************: //W pętli "for" odczytywane jest napięcie z czujnika gazu. Czujnik jest //wystawiony na czyste powietrze. Kalibracja polega na wyznaczeniu rezy- //stanchi Ro dla czystego powietrza. Po kazdej pętli odczytane napięcie //jest sumowane. Suma tych napięć po zakończeniu pętli jest dzielona //przez liczbę próbek, otrzymując średnią wartość rezystancji. Wartość ta //podzielona przez współczynnik czystego powietrza (9.83) daje rezysta- //ncje Ro, na której będą oparte następne obliczenia. Obliczenia te wy- //konywane są raz. for (i=0;i<ilosc_probek_kalibracyjnych;i++) { pomiar_V = ADC; ADCSRA |= (1 << ADSC); Ro = ((1024-pomiar_V)/pomiar_V)*rezystancja_Robc; _delay_ms(czas_probkowania_kalibracyjnego); suma = suma+Ro; } Ro = suma/ilosc_probek_kalibracyjnych; Ro = Ro/wsp_czystosci_powietrza; //Opadanie wskazania ledowego i podwójny sygnał z buzzera informuje użytkownika o zakończeniu klibracji urządzenia PORTD &= ~(1<<PORTD0); _delay_ms(300); PORTD &= ~(1<<PORTD1); _delay_ms(300); PORTD &= ~(1<<PORTD2); _delay_ms(300); PORTD &= ~(1<<PORTD3); _delay_ms(300); PORTD &= ~(1<<PORTD4); _delay_ms(300); PORTD &= ~(1<<PORTD5); _delay_ms(300); PORTD &= ~(1<<PORTD6); _delay_ms(300); PORTD &= ~(1<<PORTD7); _delay_ms(300); PORTB &= ~(1<<PORTB0); _delay_ms(300); PORTB |= (1<<PORTB1); _delay_ms(300); PORTB &= ~(1<<PORTB1); _delay_ms(300); PORTB |= (1<<PORTB1); _delay_ms(300); PORTB &= ~(1<<PORTB1); _delay_ms(100); while(1) { //Zmienna zliczania: int j = 0; //Zmienna zliczająca- razem: int razem = 0; //Deklaracja liczonej rezystancji czujnika: double Rs = 0; //************************pomiar z czujnika************************: //W pętli "for" wyliczana jest wartość rezystancji na podstawie na- //pięcia z czujnika gazu. Obliczane rezystancje są sumowane. Po za- //kończeniu pętli, suma rezystancji jest dzielona przez liczbę pró- //bek i otrzymujemy przybliżony odczyt rezystancji czujnika. for (j=0;j<ilosc_probek_pomiarowych;j++) { pomiar_V = ADC; ADCSRA |= (1 << ADSC); Rs = ((1024-pomiar_V)/pomiar_V)*rezystancja_Robc; razem = razem + Rs; _delay_ms(czas_probkowania_pomiarowego); } Rs = razem/ilosc_probek_pomiarowych; //Znając Rs oraz Ro obliczamy ich stosunek i podstawiamy do wzoru //na zawartość cząstek LPG w powietrzu. Rs_do_Ro = Rs/Ro; _delay_ms(10); //Zawartość PPM gazu LPG w powietrzu: if (!(PINC & 0b00100000)) { double PPM = 0; PPM = pow(10,((log(Rs_do_Ro - LPG_Y1)/((-1)*LPG_a)) + LPG_X1)); _delay_ms(10); if ((PPM >= 0)&&(PPM <= 500)) { PORTB = 0b00000001; PORTD = 0b00000000; } if ((PPM >= 500)&&(PPM <= 1000)) { PORTB = 0b00000001; PORTD = 0b10000000; } if ((PPM >= 1000)&&(PPM <=2000)) { PORTB = 0b00000001; PORTD = 0b11000000; } if ((PPM >= 2000)&&(PPM <=5000)) { PORTB = 0b00000001; PORTD = 0b11100000; } if ((PPM >= 5000)&&(PPM <=7500)) { PORTB = 0b00000001; PORTD = 0b11110000; } if ((PPM >= 7500)&&(PPM <=10000)) { PORTB = 0b00000001; PORTD = 0b11111000; } if ((PPM >= 10000)&&(PPM <=15000)) { PORTB = 0b00000001; PORTD = 0b11111100; } if ((PPM >= 15000)&&(PPM <=20000)) { PORTB = 0b00000001; PORTD = 0b11111110; } if (PPM >= 20000) { PORTB = 0b00000001; PORTD = 0b11111111; } } //Zawartość PPM dymu w powietrzu: if (!(PINC & 0b00010000)) { double PPM = 0; PPM = pow(10,((log(Rs_do_Ro - SMOKE_Y1)/((-1)*SMOKE_a)) + SMOKE_X1)); _delay_ms(10); if ((PPM >= 0)&&(PPM <= 500)) { PORTB = 0b00000001; PORTD = 0b00000000; } if ((PPM >= 500)&&(PPM <= 1000)) { PORTB = 0b00000001; PORTD = 0b10000000; } if ((PPM >= 1000)&&(PPM <=2000)) { PORTB = 0b00000001; PORTD = 0b11000000; } if ((PPM >= 2000)&&(PPM <=5000)) { PORTB = 0b00000001; PORTD = 0b11100000; } if ((PPM >= 5000)&&(PPM <=7500)) { PORTB = 0b00000001; PORTD = 0b11110000; } if ((PPM >= 7500)&&(PPM <=10000)) { PORTB = 0b00000001; PORTD = 0b11111000; } if ((PPM >= 10000)&&(PPM <=15000)) { PORTB = 0b00000001; PORTD = 0b11111100; } if ((PPM >= 15000)&&(PPM <=20000)) { PORTB = 0b00000001; PORTD = 0b11111110; } if (PPM >= 20000) { PORTB = 0b00000001; PORTD = 0b11111111; } } //Zawartość PPM CO w powietrzu: if (!(PINC & 0b00001000)) { double PPM = 0; PPM = pow(10,((log(Rs_do_Ro - CO_Y1)/((-1)*CO_a)) + CO_X1)); _delay_ms(10); if ((PPM >= 0)&&(PPM <= 500)) { PORTB = 0b00000001; PORTD = 0b00000000; } if ((PPM >= 500)&&(PPM <= 1000)) { PORTB = 0b00000001; PORTD = 0b10000000; } if ((PPM >= 1000)&&(PPM <=2000)) { PORTB = 0b00000001; PORTD = 0b11000000; } if ((PPM >= 2000)&&(PPM <=5000)) { PORTB = 0b00000001; PORTD = 0b11100000; } if ((PPM >= 5000)&&(PPM <=7500)) { PORTB = 0b00000001; PORTD = 0b11110000; } if ((PPM >= 7500)&&(PPM <=10000)) { PORTB = 0b00000001; PORTD = 0b11111000; } if ((PPM >= 10000)&&(PPM <=15000)) { PORTB = 0b00000001; PORTD = 0b11111100; } if ((PPM >= 15000)&&(PPM <=20000)) { PORTB = 0b00000001; PORTD = 0b11111110; } if (PPM >= 20000) { PORTB = 0b00000001; PORTD = 0b11111111; } } //Zawartość PPM H2 w powietrzu: if (!(PINC & 0b00100000)) { double PPM = 0; PPM = pow(10,((log(Rs_do_Ro - H2_Y1)/((-1)*H2_a)) + H2_X1)); _delay_ms(10); if ((PPM >= 0)&&(PPM <= 500)) { PORTB = 0b00000001; PORTD = 0b00000000; } if ((PPM >= 500)&&(PPM <= 1000)) { PORTB = 0b00000001; PORTD = 0b10000000; } if ((PPM >= 1000)&&(PPM <=2000)) { PORTB = 0b00000001; PORTD = 0b11000000; } if ((PPM >= 2000)&&(PPM <=5000)) { PORTB = 0b00000001; PORTD = 0b11100000; } if ((PPM >= 5000)&&(PPM <=7500)) { PORTB = 0b00000001; PORTD = 0b11110000; } if ((PPM >= 7500)&&(PPM <=10000)) { PORTB = 0b00000001; PORTD = 0b11111000; } if ((PPM >= 10000)&&(PPM <=15000)) { PORTB = 0b00000001; PORTD = 0b11111100; } if ((PPM >= 15000)&&(PPM <=20000)) { PORTB = 0b00000001; PORTD = 0b11111110; } if (PPM >= 20000) { PORTB = 0b00000001; PORTD = 0b11111111; } } //Po dotarciu do końca komendy, pętla rozpoczyna się od począ- //tku mierząc jeszcze raz napięcie na czujniku. _delay_ms(100); } return(0); } Jeżeli dotrwaliście aż do tego momentu, to bardzo dziękuje wam za uwagę. Mam nadzieję, że ten projekt będzie pomocny dla każdej osoby rozpoczynającej swoje przygody z czujnikiem gazu MQ-2. Osobiście jestem zadowolony z rezultatu jaki osiągnąłem tym projektem. Mam jednak do niego sporo zastrzeżeń i kiedy będę miał możliwość, planuję do niego wrócić wprowadzając następujące zmiany: Skala ledowa zostanie zastąpiona wyświetlaczem 2x16 aby widzieć dokładny odczyt PPM wybranego gazu. Urządzenie zostanie wyposażone we własne źródło zasilania. Atmega328 będzie zastąpiona przez mikrokontroler atmega8. Obudowa zostanie lepiej uszczelniona. Czujnik zostanie wyprowadzony na długim przewodzie jako sonda, którą można umieścić w dowolnym miejscu. W programie napisane zostanie proste menu, dzięki czemu będzie można wygodnie wybrać gaz, przeprowadzić kalibrację (aby wyeliminować czekanie po uruchomieniu i pamiętać stałą wartość czujnika) oraz opcjonalnie zmienić współczynnik czystego powietrza. Przydatny link: Wyjaśnienie działania czujnika MQ-2 https://sandboxelectronics.com/?p=165
  7. Trochę gorącego kleju i jazda! Takim stwierdzeniem kierowałem się podczas budowy tej drukarki. Pewnie sporo drukarzy 3D zbije mnie za to, ale już lecę z wyjaśnieniem 🙃. Od paru lat marzyła mi się drukarka 3D, chociażby do drukowania obudów do przyszłych projektów, ale również jako produkcja użytecznych rzeczy "na już" - no prawie, ponieważ drukowanie nie jest natychmiastowe. Niestety ze względu na to, że mam dość mały budżet i rodzice niezbyt byli przychylni do kolejnego sprzętu w domu oraz wierzyli w moją "twórczość", nie mogłem kupić firmowej sztuki. Dopiero jak po kilku miesiącach na discordzie znalazłem grupkę osób zajmująca się właśnie drukiem jak i samą elektroniką, postanowiłem się zabrać do roboty. Po kilku dniach przemyślania i projektowania wziąłem trzy napędy DVD i za pomocą kleju na gorąco złożyłem "coś co wytłaczało plastik i wiecznie się psuło". Szczątkowe zdjęcie "tego czegoś" wygrzebane z odmętów mojego dysku twardego. Jak w końcu się zepsuło w taki sposób, że straciłem chęci do dalszych zabaw w tym kierunku, dałem sobie spokój, ale nie na długo. Po dwóch tygodniach znowu zajrzałem i natknąłem się na technologię RepRap. Dla nie wiedzących polega to na tym, że części do nowej drukarki drukuje się na pierwotnej. Poszedłem więc do lokalnego sklepu budowlanego kupić części do budowy ramy. Dokładnie to: 3 Profile aluminiowe o przekroju kwadratowym 15mm dużo kątowników (sam już nie wiem ile ich nakupiłem) 3 profile aluminiowe o przekroju okrągłym 10mm (jako prowadnice) WIEM, WIEM budowanie drukarki na takich profilach i prowadnicach to grzech, ale DZIAŁA! Nie mając warsztatu, udałem się do dziadka, z pomocą którego udało mi się złożyć dolną część ramy. Naprawdę PRZEPRASZAM, ale to są zdjęcia archiwalne, więc stąd taka jakość. Przez całą budowę drukarki posługiwałem się tylko brzeszczotem, wiertarką no i gwintownikiem, choć tego ostatniego odradzam przy profilach aluminiowych, bo sam się na tym przejechałem i zerwałem dwa gwinty🤦‍♂️. Tak czy siak z pomocą kleju na gorąco i taśmy klejącej jakoś się udało. Tydzień później znowu przyszedłem do dziadka dokończyć budowę. Po kilku godzinach składania wyszła rama, która wymagała tylko zamontowania elementów i powinno działać. Silniki kupiłem na na popularnym serwisie aukcyjnym za skromne 8zł za sztukę. Działają, nie mam zarzutów, poza tym, że musiałem zdjąć oryginalne koła zębate i zeszlifować wał, aby zamontować koła GT2. Gdy tylko przyniosłem ramę do domu, zabrałem się za dalszą część montażu. Zamontowałem hotend, ekstruder, paski i wiele innych mniej lub bardziej przydatnych elementów. Gotowy sprzęt, który już działał i wymagał tylko kalibracji Na płytę główną Creality3D v1.1.4 (dokładnie ta co występuje w Enderze 3 lub CR-10) wgrałem oprogramowanie marlin, które wspiera dowolną zmianę sprzętową m.in. Serwomechanizmy, czujniki i wiele więcej. Niestety nie zamontowałem wyświetlacza ze względu na problemy sprzętowe, lecz jak będę wymieniać płytę główną zapewne go zamontuję, bo go posiadam. Po istotnych kalibracjach ze względu na kończące się próbki filamentu zakupione do starej drukarki, zakupiłem jednokilogramową szpulę filamentu. Parę dni później, gdy paczka do mnie dotarła, zacząłem drukować części, które zastąpią gorący klej. Były to głównie mocowania na łożyska, nowa karetka oraz nóżki. Zauważyłem dość sporą różnicę w jakości wydruków, co mnie jeszcze bardziej zmotywowało do dalszych ulepszeń. Po lewej spoiwo z kleju/Po prawej jego wydrukowany odpowiednik Na dzień dzisiejszy drukarka pracuje, postawiłem serwer druku na Raspberry Pi, nadal trwają nad nią prace, głównie konserwacyjne i drobne ulepszenia, lecz projekt uważam za zakończony. Bez problemu można drukować obudowy do projektów, ale też jakieś figurki. Obudowa do wzmacniacza gitarowego (nie będę opisywać, bo uważam go za zbyt niski poziom) Jak na powyższym zdjęciu widać, jedna szpula poszła na zepsute wydruki, wydruki kalibracyjne oraz jakieś zabawki. Dlatego warto zaopatrzyć się w 1kg filamentu jak buduje się tego typu drukarkę. W przyszłości mam zamiar zmienić malinkę prawdopodobnie na ESP8266. Zauważyłem też, że dzięki zbudowaniu takiego sprzętu nauczyłem się baardzo dużo w tym temacie. Morał z tego projektu jest taki: Staraj się nie robić gwintów w profilach aluminiowych - są mało wytrzymałe. jak kupujesz rurki aluminiowe na prowadnice w sklepie budowlanym to idź z suwmiarką, bo u mnie powodem luzów na karetce była zbyt mała średnica jednej z prowadnic. Nie kupuj najtańszej głowicy, bo jej jakość może być bardzo dyskusyjna. Gorący klej nie nadaje się do wszystkiego 😁 Warto robić projekty DIY Specjalne podziękowania kieruję do: Staszka, matika i wiele innych osób z discorda :3 Dziadka, który mi pomógł od strony planowania Leoneq'a, który mnie namówił, aby wstawić tu ten projekt ;3 Tak to wygląda na chwilę obecną 😀 Z góry przepraszam za ewentualne błędy językowe czy literówki, ale orłem z Polskiego nie jestem, więc proszę o wybaczenie😄. Naturalnie zapraszam do dyskusji w komentarzach pod postem. Pozdrawiam.
  8. Słowem wstępu, wyobraźmy sobie że jesteśmy na słonecznej, piaszczystej plaży wzdłuż której rosną wysokie, bogate w orzechy kokosowe palmy. Pod jedną z nich stoi lokalny, doświadczony, zbieracz kokosów, u którego mamy zamiar nauczyć się tego ciężkiego rzemiosła. Jako zaledwie początkujący adepci tej trudnej sztuki, nie mamy jednak zielonego pojęcia jak się do tego zabrać. Dlatego nasz nowy mentor musi nam wytłumaczyć co i jak powinniśmy zrobić. Może on nam wytłumaczyć wszystko krok po kroku. Opisać dokładne pozycje naszych kończyn, prędkość z jaką będziemy się wspinać i sposób odbierania kokosu. Oczywiście opisanie nam tego na tyle dokładnie, byśmy mogli bezbłędnie przystąpić do pracy wymagałoby dużo czasu i energii. Zamiast tego, może pokazać nam osobiście jak to zrobić i dać nam przystąpić do pracy. W krótkim i bogatym w informacje czasie, będziemy wiedzieli jak przystąpić do pracy. Ten wpis brał udział konkursie na najlepszy artykuł o elektronice lub programowaniu. Sprawdź wyniki oraz listę wszystkich prac » Partnerem tej edycji konkursu (marzec 2020) był popularny producent obwodów drukowanych, firma PCBWay. Po tym ciut przydługawym wstępie, którym starałem się nakreślić pewien problem, możemy przystąpić do właściwego omówienia tematu. Istnieje wiele metod programowania robotów przemysłowych (manipulatorów). Wykonują one precyzyjne prace, wymagające wielu skomplikowanych ruchów. Jednak poza nimi, roboty mogą też wykonywać mniej skomplikowane ruchy np. podczas zmiany pozycji lub przełączenia między poszczególnymi pracami. O ile do wykonania operacji precyzyjnych niezbędny jest szczegółowo opracowany program, o tyle podczas ruchów mniej skomplikowanych czas programowania można ukrócić do metod Online Programming. Krótki film przedstawiający podział metod programowania Metody te pozwalają operatorowi manualnie lub za pomocą odpowiedniego kontrolera ustawić poszczególne pozycje robota, które zostaną przez niego zapamiętane w czasie bieżącym oraz odtworzone w postaci pożądanego przez nas ruchu. Programowanie robota spawalniczego przy pomocy metody teach-in Programowanie robota Festo BionicCobot przy pomocy metody play-back Programowanie play-back opiera się na sczytywaniu przez oprogramowanie pozycji robota, zapisywanie ich oraz odtwarzanie poprzez bezpośrednie poruszanie jego konstrukcją. Aby było to możliwe, każdy stopień swobody robota musi posiadać sensor umożliwiający określenie jego dokładnej pozycji. Oprócz tego napęd robota musi działać w wyrachowany i delikatny sposób, aby konstrukcja była jednocześnie sztywna i można było nią poruszać ręcznie. Programowanie teach-in z kolei polega na ustawieniu robota w ustalonych pozycjach za pomocą odpowiedniego kontrolera, za pomocą którego te pozycje zostaną zapisane a następnie odtworzone. Odtwarzanie kolejno zapisanych pozycji daje w efekcie płynny, ciągły ruch maszyny. Wyżej wspomniane metody omówimy na realnym przykładzie. Za pomocą kontrolera będziemy mogli stosować na prostym manipulatorze metodę teach-in. Robot napędzany jest serwami modelarskimi oraz wykonany w technice druku 3D. Serwa posiadają wbudowane potencjometry sczytujące pozycje kątowe wałów, jednak bez ingerencji w ich budowę ciężko będzie korzystać z tych potencjometrów do określania pozycji robota. Dlatego manualne ustawienie pozycji manipulatora metodą play-back wypada z puli naszych opcji. Poza tym istniałaby duża szansa na uszkodzenie stosowanych w robocie serw. Zamiast tego, posłużymy się kontrolerem, który będzie kinetycznym modelem naszego manipulatora i pozwoli także zahaczyć o ideę play-back. Ramię manipulatora wydrukowane w 3D, poniżej link do źródła https://www.thingiverse.com/thing:1015238 Kontroler odpowiada kinematyce prezentowanego robota i ma umieszczone potencjometry w każdym jego punkcie swobody. Poruszając nim, możemy ustalić rzeczywistą pozycję naszego manipulatora. Budując r obota o mniej skomplikowanej budowie, możemy pozostać przy samych potencjometrach np. zamontowanych na płytce stykowej. Jednak w przypadku tego robota korzystanie z tego rozwiązania byłoby trudniejsze i mniej wygodne w użytku. Model kinematyczny manipulatora Znając już budowę kontrolera oraz manipulatora, należy je już tylko do siebie podłączyć. Oprócz tego do układu dodane zostaną przyciski nagrywania oraz odtwarzania ruchu. Elektronika opiera się o mikrokontroler atmega328p. Zasilanie układu odbywa się z sieci napięciem 230 V. W obudowie znajduje się układ prostujący, przetwornica step-down zasilająca serwomechanizmy oraz płytka arduino ze wspomnianym wcześniej mikrokontrolerem. Dla wygody wszystkie piny arduino zostały wyprowadzone na zewnątrz obudowy. Cały schemat przedstawianej konstrukcji znajduje się poniżej: Schemat układu Lista opisanych komponentów: -S1 – włącznik główny, -S2 – przycisk nagrywania, -S3 – przycisk odtwarzania, -D1 – mostek Graetza 400V ; 4A, -D2 – zielona dioda LED, -C1 – kondensator elektrolityczny 1000µF ; 50V, -C2 – kondensator elektrolityczny 220µF ; 25V, -C3 – kondensator elektrolityczny 22µF ; 25V, -C4 – kondensator ceramiczny 100nF, -C5 – kondensator ceramiczny 22pF, -C6 – kondensator ceramiczny 22pF, -C7 – kondensator ceramiczny 100nF, -R1 – rezystor 150 Ω, -R2, R3, R4 – rezystor 1 kΩ, -POT 1, POT 2, POT 3, POT 4, - 10 kΩ, -Stabilizator napięcia LM7805, -Przetwornica step-down LM2596, -X1 – kwarc 16 MHz, Połączenie układu Po podłączeniu całej elektroniki można przystąpić do omówienia kodu arduino. Program ten został już zaopatrzony w bogatą ilość komentarzy, które na pewno pomogą osobom dopiero rozpoczynającym swoją przygodę z arduino: //biblioteka umożliwiająca nie tylko sterowanie serwami, ale także ich prędkością //nie jest ona koniecznością, wystarczy standardowa biblioteka <servo.h> oraz pozbycie się zmiennej 'predkosc' z koduć #include <VarSpeedServo.h> //definiujemy serwa używane w robocie: VarSpeedServo servo1; VarSpeedServo servo2; VarSpeedServo servo3; VarSpeedServo servo4; //definiujemy przyciski nagrywania i odtwarzania: const int przycisk_A = 2; const int przycisk_B = 3; //definiujemy wartości dla wciśniętych przycisków nagrywania i odtwarzania: int przycisk_A_ON = 0; boolean przycisk_B_ON = false; //definiujemy potencjometry: const int potencjometr1 = A0; const int potencjometr2 = A1; const int potencjometr3 = A2; const int potencjometr4 = A3; //definiujemy zmienne służące do odczytu wartości napięć z potencjometrów: int potencjometr_1_odczyt; int potencjometr_2_odczyt; int potencjometr_3_odczyt; int potencjometr_4_odczyt; //definiujemy zmienne służące do zapisu wartości kąta położenia poszczególnego serwa: int potencjometr_1_zapis; int potencjometr_2_zapis; int potencjometr_3_zapis; int potencjometr_4_zapis; //definiujemy tablice zapisujące położenie serwa: int Pozycja_serva1[]={1,1,1,1,1}; int Pozycja_serva2[]={1,1,1,1,1}; int Pozycja_serva3[]={1,1,1,1,1}; int Pozycja_serva4[]={1,1,1,1,1}; void setup() { //definiujemy piny do których podłączone są serwa: servo1.attach(6); servo2.attach(9); servo3.attach(10); servo4.attach(11); //definiujemy piny wejściowe przycisków nagrywania i odtwarzania: pinMode(przycisk_A, INPUT_PULLUP); pinMode(przycisk_B, INPUT_PULLUP); //inicjalizacja portu szeregowego do podglądu działania programu: Serial.begin(9600); } void loop() { //ustalanie prędkości serw w zakresie od 0 do 180: int predkosc = 90; //zapis formuły umieszczania odczytanej z potencjometrów wartości do tabeli: potencjometr_1_odczyt = analogRead(potencjometr1); potencjometr_1_zapis = map (potencjometr_1_odczyt, 0, 1023, 20, 175); potencjometr_2_odczyt = analogRead(potencjometr2); potencjometr_2_zapis = map (potencjometr_2_odczyt, 0, 1023, 5, 175); potencjometr_3_odczyt = analogRead(potencjometr3); potencjometr_3_zapis = map (potencjometr_3_odczyt, 0, 1023, 5, 175); potencjometr_4_odczyt = analogRead(potencjometr4); potencjometr_4_zapis = map (potencjometr_4_odczyt, 0, 1023, 20, 160); //serwa przyjmują pozycje zapisane w tabelach: servo1.write(potencjometr_1_zapis, predkosc); servo2.write(potencjometr_2_zapis, predkosc); servo3.write(potencjometr_3_zapis, predkosc); servo4.write(potencjometr_4_zapis, predkosc); //przy kolejnym wciśnięciu przycisku nagrywania tabela każdego serwa zostanie //nadpisana, zapamiętując obecną pozycję serwa: if(digitalRead(przycisk_A) == HIGH) { przycisk_A_ON++; switch(przycisk_A_ON) { case 1: Pozycja_serva1[0] = potencjometr_1_zapis; Pozycja_serva2[0] = potencjometr_2_zapis; Pozycja_serva3[0] = potencjometr_3_zapis; Pozycja_serva4[0] = potencjometr_4_zapis; Serial.println("Pozycja pierwsza zapisana"); break; case 2: Pozycja_serva1[1] = potencjometr_1_zapis; Pozycja_serva2[1] = potencjometr_2_zapis; Pozycja_serva3[1] = potencjometr_3_zapis; Pozycja_serva4[1] = potencjometr_4_zapis; Serial.println("Pozycja druga zapisana"); break; case 3: Pozycja_serva1[2] = potencjometr_1_zapis; Pozycja_serva2[2] = potencjometr_2_zapis; Pozycja_serva3[2] = potencjometr_3_zapis; Pozycja_serva4[2] = potencjometr_4_zapis; Serial.println("Pozycja trzecia zapisana"); break; case 4: Pozycja_serva1[3] = potencjometr_1_zapis; Pozycja_serva2[3] = potencjometr_2_zapis; Pozycja_serva3[3] = potencjometr_3_zapis; Pozycja_serva4[3] = potencjometr_4_zapis; Serial.println("Pozycja czwarta zapisana"); break; case 5: Pozycja_serva1[4] = potencjometr_1_zapis; Pozycja_serva2[4] = potencjometr_2_zapis; Pozycja_serva3[4] = potencjometr_3_zapis; Pozycja_serva4[4] = potencjometr_4_zapis; Serial.println("Pozycja piąta zapisana"); break; } } //po wciśnięciu przycisku odtwarzania serwa będą przyjmować zapisane w tabelach pozycje //z odczekaniem 1.5 sekund w każdej pozycji: if(digitalRead(przycisk_B) == HIGH) { przycisk_B_ON = true; } if(przycisk_B_ON) { for(int i=0; i<5; i++) { servo1.write(Pozycja_serva1[i],predkosc); servo2.write(Pozycja_serva2[i],predkosc); servo3.write(Pozycja_serva3[i],predkosc); servo4.write(Pozycja_serva4[i],predkosc); Serial.println("Odtwórz ruchy"); delay(1500); } } //czas opóźnienia działania programu, od jego nastawy zależy płynnośc pracy robota: delay(200); } Program działa w sposób następujący: Po uruchomieniu programu, za pomocą modelu kinematycznego będzie można bezpośrednio kontrolować ruch manipulatora, Jeżeli wciśniemy przycisk S2 (nagrywania), obecnie ustawiona pozycja robota zostanie zapisana, Program umożliwia zapisanie pięciu różnych pozycji, Jeżeli wybierzemy przycisk S3 (odtwarzania), robot zacznie odtwarzać wybrane przez nas pozycje w nieskończonej pętli, Aby wytyczyć nową sekwencję ruchów należy zresetować układ. Efekt działania powyższego kodu przedstawia się następująco: Dzięki funkcji monitora szeregowego w arduino można obserwować pracę manipulatora bezpośrednio: Przepraszam wszystkich czytelników za jakość nagrań wideo, niestety ograniczały mnie możliwości sprzętowe. Przedstawiony wyżej kod jest prosty a przykład nieskomplikowany, jednak doskonale pokazuje podstawy działania tej metody. Nie mniej jednak mam nadzieję, że artykuł okaże się dla wielu osób pomocny. Oprócz tego zostawiam jeszcze bibliotekę <VarSpeedServo> 😉 VarSpeedServo-master.zip Powodzenia we wszelkich przyszłych projektach i przygodach z elektroniką!
  9. Projekt maszynki do domowej produkcji filamentu ze starych wydruków oraz odpadków. Jak zrobić ma ktoś pomysł?? Może to być innowacyjne i EKOLOGICZNE. Chętnych zapraszam do dyskusji. 😀😀😀😀😀😀😀
  10. Cześć, jakiś czas temu postanowiłem zaprojektować robota, którego mógłby zbudować każdy z dostępem do drukarki 3d i dość skromnym budżetem. Rozwiązania konstrukcyjne częściowo opierałem na BCN3D MOVEO i innych podobnych konstrukcjach, jednak chciałem żeby manipulator był bardziej precyzyjny w czym miało pomóc zastosowanie łożysk w każdej z osi. Przekładnie w pierwszej i czwartej osi to wydrukowane koła zębate, przełożenia kolejno 1:7 i 1:6, w osiach 3 i 5 zastosowano przekładnie pasowe zębate, przełożenia kolejno 1:8,435 i 1:6.125. Jak widać manipulator jest jeszcze nie skończony, brak mu osi drugiej. Początkowo oś 2 i 3 miały być takie same, jednak ze względu na większe obciążenia, musiałem przeprojektować drugą oś, zastosować większy pasek (T5x10 zamiast gt2x6mm) oraz dodatkową przekładnię planetarną. Oś druga jest jeszcze w fazie projektowej. Koszt (bez kosztów przesyłki): "mechanika": silniki krokowe używane z allegro: około 40zł łożyska: około 60 zł śruby/nakrętki: około 50 zł filament do drukarki ABS 2x 1kg: 120 zł serwomechanizm do chwytaka (wziąłem jaki miałem pod ręka, ale można użyć tańszy): 50 zł co daje około 320 zł elektronika: Płytka zgodna z Arduino Mega: 40 zł RAMPS 1.4: 20 zł StepSticki : 30 zł Zasilacz 250W: 48 zł = 138 + przewody czyli powiedzmy 160 zł W sumie wyszło około 480 zł czyli trochę drożej niż planowałem jednak można przyoszczędzić np. nie kupując nowego zasilacza itp. Obecnie planuję: skończyć projekt osi drugiej i zrobić prototyp oraz przetestować go razem z całym robotem wydrukować i zamontować przekładnie planetarną do osi trzeciej dokończyć komunikację robota z ROSem przez bibliotekę rosserial arduino
  11. Witam, jestem początkujący oraz jest to mój pierwszy projekt. Dałem sobie za zadanie zrobienie przez wakacje maszyny, która policzy mi ile jest w moim zbiorze groszy, ale chciałem zrobić to trochę inaczej niż projekty, które widziałem. Wpadłem na pomysł że skoro grosze (1, 2, 5) są różnych średnic to jeżeli ułoży się monetę miedzy fotorezystorem a diodą led to będzie można przypisać jej daną wartość. Tak też zrobiłem i po chwili powstał mały cylinder na bazie Arduino Uno potrafiący rozpoznać monetę. Następnie zacząłem pracę nad tym aby moja maszyna brała monety z podajnika i liczyła je automatycznie. Wyszło że cylinder z ustawionym centralnie serwomechanizmem to najlepsza opcja. Projektowałem na programie Design Spark Mechanical, drukowałem Anet A8. Po wielu nieudanych wydrukach, wkońcu wyszedł ten właściwy i mogłem wszystko odczepić od Arduino Uno... zaczeło się lutowanie do Arduino nano, jak mozna się spodziewać po początkującym długie i mało umiejętne. Po wydrukowaniu całego mechanizmu zaprojektowałem obudowę, a następnie zrobiłem adaptacje do warunków oświetleniowych panujących w jej wnętrzu. Z uwagi na małą precyzję mojego czujnika maszynka czasem się myli, o jakiś grosz/dwa na złotówkę, jednakże jestem zadowolony z mojego pierwszego projektu :)) A oto krótki i prosty kod : #include <Servo.h> #include <Wire.h> #include <LiquidCrystal_I2C.h> LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); Servo servo; int odczytanaWartosc = 0; int tlo = 0; float wartosc = 0; float kwota = 0; void setup() { lcd.begin(16,2); lcd.backlight(); lcd.setCursor(0,0); pinMode(6, OUTPUT); Serial.begin(9600); digitalWrite(6,HIGH); servo.attach(9); } void loop() { kwota = wartosc / 100; lcd.setCursor(0,0); lcd.print("KWOTA"); lcd.setCursor(7,0); lcd.print(kwota); servo.write(180); delay(400); servo.write(80); delay(300); odczytanaWartosc = analogRead(A1); if(odczytanaWartosc > 30 && odczytanaWartosc < 50){wartosc = wartosc + 1;} if(odczytanaWartosc > 22 && odczytanaWartosc < 30){wartosc = wartosc + 2;} if(odczytanaWartosc < 22 && odczytanaWartosc > 3){wartosc = wartosc + 5;} servo.write(0); delay(400);}
  12. O czymś podobnym myślałem praktycznie od chwili kupna drukarki. I pewnie dalej bym myślał, gdyby nie projekt na Majsterkowie, opisujący podobną (prostszą) konstrukcję. A i tak przymierzałem się do tego jak pies do jeża, zawsze cos mi przeszkadzało (a to nie potrafiłem rozwiązać problemu zasilania, a to miałem coś pilniejszego do roboty, a to nie miałem jakiegoś tam elementu...). Ale po zrobieniu mojej przystawki do OctoPrinta i (całkiem udanych) próbach druku w wielu kolorach - a co się z tym wiąże koniecznością ręcznej zmiany filamentu w odpowiednim momencie - potrzeba stała się raczej pilna. Zacząłem więc od sprecyzowania założeń. Monitorek miał przede wszystkim wyświetlać aktualne dane na temat wydruku (temperatury, stan drukarki, postęp). Jako że główną jego funkcją miało być zwrócenie uwagi na coś ważnego (np. konieczność zmiany filamentu czy wychłodzenie stołu wystarczające do zdjęcia wydruku) w czasie, kiedy byłem zajęty innymi Wielce Ważnymi Rzeczami (np. oglądaniem najnowszego odcinka przygód bohaterskiego Hannibala Smitha czy innego McGyvera) sygnalizacja powinna być głosowa. Jednocześnie najważniejsze parametry (temperatura i postęp) powinny być wyświetlane w czytelny sposób nawet dla krótkowidza bez okularów - czyli żadne nawet największe cyferki, jakiś pasek postępu w kontrastowych kolorach albo jakiś inny czytelny glif. Zasilanie akumulatorowe (na stoliku przy telewizorze nie mam jak podłączyć zasilacza), z możliwością podłączenia ładowarki. Nadałem więc urządzeniu roboczą nazwę OctoMon, wymęczyłem na forum że ktoś mi wreszcie wyoślił temat ładowarki (dzięki @marek1707!) i zabrałem się do konkretnego projektowania. Miałem już wyświetlacz, moduł ESP8266E i parę innych potrzebnych drobiazgów. Początkowo chciałem ESP umieścić na płytce podłączanej bezpośrednio do pinów wyświetlacza - niestety, jakbym ścieżek nie prowadził i tak jednostronna płytka wychodziła mi za duża. Postanowiłem więc dać sobie spokój, zastosować adapter i użyć po prostu płytki uniwersalnej. Ponieważ tego modelu wyświetlacza już uzywałem, eksperymenty z dźwiękiem też się powiodły (przynajmniej w zakresie wystarczającym do uruchomienia gadacza) - mogłem mieć pewność, że od strony programu nie będę już miał żadnych niespodzianek. Postanowiłem więc zaprojektować całą (niezbyt skomplikowaną zresztą) elektronikę. Jako że akurat w Botlandzie pojawił się moduł MAX9837A postanowiłem go wykorzystać jako DAC i wzmacniacz dźwięku. Niestety nie zdał egzaminu... ale o tym później. Zasilanie rozwiązałem w najprostszy chyba z możliwych sposób. Akumulator połączony z ładowarką, do tego przetwornica MT3608 ustawiona na 5V. Wyświetlacz i DAC zasilane bezpośrednio z 5V, ESP przez stabilizator LM1117, połączony z resztą świata jak na schemacie poniżej. Teoretycznie powinno to działać... ...No i już na wstępie pojawił się problem. Podłączony bezpośrednio (znaczy się kabelkami) do ESP i zasilany z USB moduł dźwiękowy pokazał co potrafi - czyli jak mi zepsuć dobry humor. Z powodów niewiadomych raz działał raz nie... a do tego owo niedziałanie powodowane było chyba fanaberiami motylków w Brazylii albo aktualna pogodą na Marsie. Doszedłem do wniosku, że USB to niespecjalnie dobry sposób zasilania, po prowizorycznym podłączeniu jakichś uczciwych 5V wydawało mi się, że działa. Postanowiłem więc sprawdzić wszystko później już na gotowym układzie. Może się to komuś wydać dziwaczne i ryzykowne... ale miałem w odwodzie sprawdzone rozwiązanie które co prawda dawało niższą jakość dźwięku, ale za to nie okazywało żadnych fanaberii 🙂 Reszta elektroniki to praktycznie tylko połączenie tego wszystkiego do kupy - mogłem się więc zabrać za projekt obudowy. Nie chciałem się bawić w wymyślanie jakichś skomplikowanych kształtów, a więc obudowa została wydrukowana w kilku częściach i skręcona śrubkami M2. Początkowo urządzenie miało mieć jeden klawisz, ale okazało się, że mam wolne dwa piny GPIO, mogłem więc połączyć dwa. Płytę czołową postanowiłem umieścić pod kątem ze względu na wyświetlacz (który nie lubi jak patrzy się na niego lekko z boku, masz się gapić prosto i już!). Oprócz wyświetlacza miały tam się znaleźć głośnik i klawisze. W sumie więc górna część obudowy wygląda na projekcie tak: Otwory obok głośnika są przelotowe - od zewnątrz jest do nich przykręcona kratka mocująca i osłaniająca głośnik. Mocowanie klawiszy jest dopasowane do ratra płytki uniwersalnej (podobnie zresztą, jak mocowania płytki pod ESP8266). Cała reszta elektroniki oprócz DAC-a została umieszczona w dolnej części obudowy: Oprócz koszyka na akumulator są tam mocowania dla ładowarki, przetwornicy i małej płytki pod ESP. Po złożeniu cały układ wygląda tak: Niestety - po złożeniu wszystkiego w całość okazało się, że DAC nie bardzo chce ze mną współpracować. Co prawda wyczyniał swoje hece to dużo rzadziej, ale jednak. Postanowiłem więc wypróbować inny układ: wzmacniacz (wykorzystana połowa układu) oraz prosty filtr: Okazało się, że działa to całkiem znośnie - prawdopodobnie potrzebna by była jeszcze dodatkowa filtracja na zasilaniu (w głośniku słychać czasem ciche trzaski) ale bez tego już mogłem się obejść. Po złożeniu całość wygląda tak: I tu uwaga: ponieważ wątpię, aby ktoś kto chciałby zrobić to urządzonko miał dokładnie takie same elementy jak ja i identycznie spaczone poczucie estetyki - nie zamieszczam STL-i tylko plik dla OpenSCAD-a. Są w nim zawarte wymiary poszczególnych elementów i może być przydatny. No i kilka słów o programie. Program łączy się z serwerem OctoPrint i okresowo odpytuje o stan drukarki i (w przypadku gdy jest to drukowanie) o postęp. Oprócz podstawowych stanów sygnalizowanych przez serwer odróżniane są: Offline - drukarka jest wyłączona lub serwer nie odpowiada Rozgrzewanie stołu Rozgrzewanie dyszy Studzenie stołu - gdy po zakończeniu drukowania temperatura jest nie niższa niż 30°. Wciśnięcie pierwszego klawisza w trybie pauzy powoduje, że monitorek przestanie się odzywać. Bez tego co chwila będzie krzyczał że masz zmienić filament. W trybie studzenia powoduje przejście w tryb bezczynności. Wciśnięcie drugiego klawisza spowoduje podanie głosowo godziny. Dłuższe wciśnięcie pozwala na zmianę gadatliwości programu. Serwer WWW pozwala na zmianę wszystkich ważnych parametrów w dowolnej chwili. W trybie "drukowanie" wyświetlane są informacje o temperaturze dyszy i stołu, postępie w procentach oraz czasu dotychczasowanego i prognozowanego. Dodatkowo wyświetlane są: Adres IP monitora Bieżąca godzina Stan naładowania akumulatora Poziom gadatliwości (tylko wydarzenia/postęp/postęp i pozostały czas) Włączenie OTA Siła sygnału WiFi W trybie Offline monitor zachowuje się jak zegarek - wyświetla bieżące godzinę i datę Jeśli w czasie resetu urządzenia przytrzymamy pierwszy klawisz, startuje ono w trybie AccessPoint. Pod podanym adresem zgłasza się serwer WWW, gdzie można zapisać wszystkie potrzebne parametry. Jeśli w czasie resetu urządzenia przytrzymany drugi klawisz, startuje ono w trybie awaryjnym. W tym trybie nie będzie działać nic oprócz OTA. Przydatne, jeśli coś tak naknocimy w programie że nie będziemy mieli dostępu do OTA w normalnym trybie. Program został napisany z pomocą Arduino IDE. Biblioteka syntezy mowy jest na githubie. Pozostałe biblioteki instalowane były "po bożemu" poprzez managera bibliotek. Syntezator mowy to zwykły syntezator formantowy (użyłem w większości oryginalnego kodu D. Klatta z początku lat 80-tych), dostosowany kiedyś przeze mnie do języka polskiego. Dostosowanie nie jest może najlepsze - ale i syntezator Klatta nie jest mistrzem dykcji 🙂 Kalibrację miernika poziomu akululatora należy przeprowadzić włączając opcję DEBUG w Octomon.h i podając w pliku wifi.cpp adres i port , na którym będziemy odbierać komunikaty UDP. Należy do wejścia przetwornicy podłączyć woltomierz, odczytać komunikat "Volts=..." i w pliku "display.cpp" w funkcji displayBattery() w linijce: ivolt = ivolt * 413 / 753; podstawić właściwe wartości (czyli napięcie akumulatora w setnych wolta oraz wartość odczytaną a przetwornika A/C). W moim przypadku jak widać woltomierz podał 4.13V a przetwornik zinterpretował to jako wartość 753 🙂 Aby program działał, należy w Arduino IDE ustawić zegar 160 MHz, tryb pamięci QIO oraz częstotliwość Flash 80 MHz. Dołączony programik bmconvert.py pozwala na zapisanie jako tablicę w C obrazka PNG. Obrazek powinien być zapisany w trybie indeksowanej palety kolorów bez przezroczystości, będzie przetworzony na skompresowaną w RLE tablicę, a do jego wyświetlenia należy użyć funkcji drawBitMap() z pliku display.cpp (lub analogicznej). Sprawdzony na Linuksie, ale powinien działać na wszystkim gdzie się da zainstalować Pythona 2.7 i PIL. Urządzenia używam od jakichś dwóch tygodni, na razie jest bardzo przydatne. octomon.zip
×
×
  • Utwórz nowe...

Ważne informacje

Ta strona używa ciasteczek (cookies), dzięki którym może działać lepiej. Więcej na ten temat znajdziesz w Polityce Prywatności.