Przeszukaj forum

Cześć, przedstawiam projekt dla fanów drinków dla których zachowanie proporcji jest niezmiernie istotne. Postanowiłem, że robot będzie nalewał trzy różne substancje (jak na domowego barmana w zupełności wystarczy). Wykorzystałem w tym celu pompki membranowe, które są stosunkowo tanie, jednak warto użyć zaworów zwrotnych przy każdym z węży ponieważ "na postoju" nie są szczelne i ciecze powoli kapią z dysz robota. Przy innym projekcie zdarzyło mi się, że pompka była nieszczelna, więc w tym zamontowałem je w miejscu w którym ewentualny wyciek nie narobi szkód. We wcześniejszych konstrukcjach ustawiałem lanie zależne od zadanego czasu, jednak po testach (wspierając się wagą kuchenną) stwierdziłem, że odmierzane wartości nie są powtarzalne. Wtedy postanowiłem dodać wbudowaną wagę. Użyłem belki tensometrycznej do 1kg oraz wzmacniacza HX711. Robot zasilany jest zasilaczem wtykowym 12V a jego serce to Arduino Mega - ze względu na zapotrzebowanie na dużą liczbę wejść/wyjść. Do sterowania pompek użyłem gotowego Shielda - sterownika L293D – może sterować czterema silnikami DC i zajmuje mało miejsca w obudowie, a chciałem żeby konstrukcja była zwarta i jak najmniejsza. Początkowo użyłem wyświetlacza 2x16, jednak wyświetlane dane nie były tak przejrzyste, jakbym tego chciał więc zamontowałem wyświetlacz 4x16. Teraz każdy składnik ma swoją nieskróconą nazwę i ma swoją osobną linijkę. Wartości danych substancji ustawia się przy pomocy trzech potencjometrów. Wyskalowałem wartość każdego od 0 do 150g. W przypadku przekroczenia sumy trzech substancji powyżej 250g, zamontowane diody RGB świecą na czerwono (jest to tylko sygnał ostrzegawczy, nie blokuje nalewania). Diody te również „ubarwiają” proces tworzenia drinka (efekt widoczny na załączonym filmie). Po ustawieniu ulubionych proporcji wciskamy START i nalewanie odbywa się automatycznie, przed nalaniem każdego składnika waga samoczynnie się taruje. Można również korzystać z manualnego nalewania oraz tarowania, gdy stworzony drink nie spełnia wszystkich wymagań. Obudowę wydrukowałem na drukarce 3D. Składa się z wielu elementów, żeby był łatwiejszy dostęp do podzespołów oraz żeby pojedynczy wydruk krócej się drukował. Umieściłem z jednej strony okno rewizyjne żeby móc się w razie potrzeby podłączyć do Arduino. Części których użyłem do budowy robota: Arduino ATmega2560 - 1szt. wyświetlacz LCD 4x20 - Niebieski - ze sterownikiem kompatybilnym z HD44780 - QC2004A konwerter I2C do wyświetlacza LCD HD44780 wzmacniacz do belki tensometrycznej HX711 - 1szt. belka tensometryczna 1kg - 1szt pompa do cieczy 12V 110l/h - 7mm – 3szt moduł sterownika silnika L293 UNO MEGA shield - 1szt moduł diody RGB 5V - 2szt, wtyk DC 2,1/5,5mm z zaciskami skręcanymi – 1szt. gniazdo DC 2,1/5,5 do obudowy plastikowe -1szt. zasilacz wtyczkowy UMEC impulsowy 12V 30W 2,5A - 1szt. przełącznik kołyskowy 15x10mm – 1 szt przewody połączeniowe przycisk podświetlany - 1szt. przycisk okrągły monostabilny chwilowy czerwony - 4szt. potencjometr liniowy 1K – 3szt. .zawór zwrotny - 3szt. wężyk silikonowy 1,5m Oto kod, z którym się najdłużej męczyłem, ale działa #include <HX711.h> #include <Wire.h> #include <LiquidCrystal_I2C.h> #include <AFMotor.h> #define I2C_ADDR 0x3F #define start 52 #define manpom1 50 #define manpom2 46 #define manpom3 44 #define tara 48 #define redl 24 #define bluel 22 #define greenl 26 #define redr 30 #define bluer 28 #define greenr 32 HX711 waga; LiquidCrystal_I2C lcd(I2C_ADDR, 2, 1, 0, 4, 5, 6, 7); int led = 13; float ciezar; int ml1 = 0; int ml2 = 0; int ml3 = 0; int czasMigania = 250; int predkoscNalewania = 200; char odczyt[8]; AF_DCMotor pompa1 (3); AF_DCMotor pompa2 (2); AF_DCMotor pompa3 (1); void setup() { Serial.begin(9600); pinMode(start, INPUT_PULLUP); pinMode(manpom1, INPUT_PULLUP); pinMode(manpom2, INPUT_PULLUP); pinMode(manpom3, INPUT_PULLUP); pinMode(tara, INPUT_PULLUP); pinMode(redl, OUTPUT); pinMode(bluel, OUTPUT); pinMode(greenl, OUTPUT); pinMode(redr, OUTPUT); pinMode(bluer, OUTPUT); pinMode(greenr, OUTPUT); lcd.begin(20, 4); lcd.setBacklightPin(3, POSITIVE); digitalWrite(led, HIGH); lcd.setBacklight(HIGH); lcd.clear(); lcd.setCursor(0, 0); lcd.print("Witaj!"); lcd.setCursor(0, 1); lcd.print("Chlapnij sobie!"); lcd.setCursor(13, 3); lcd.print("Kasztan"); delay(1000); pinMode(led, OUTPUT); waga.begin(A1, A2); waga.set_scale(419341.0 / 200.0); waga.tare(5); pompa1.setSpeed(predkoscNalewania); pompa2.setSpeed(predkoscNalewania); pompa3.setSpeed(predkoscNalewania); } void loop() { pomiar(); ekran(); if ((ml1 + ml2 + ml3) > 250) { czerwona(); delay(500); ciemno (); } else { ciemno(); } if (digitalRead(start) == LOW) { waga.tare(); ekran(); Serial.println("zeruje"); if (ml1 >= 0) { waga.tare(10); pomiar(); ekran(); Serial.println("nalewam promile"); while (ciezar <= ml1) { pomiar(); ekran(); pompa1.run(FORWARD); led1(); } pompa1.run(RELEASE); Serial.println("promile przerwa"); delay(100); if (ml2 >= 0) { waga.tare(10); pomiar(); ekran(); Serial.println("nalewam rozcienczacz"); while (ciezar <= ml2) { pomiar(); ekran(); pompa2.run(FORWARD); led2(); } pompa2.run(RELEASE); Serial.println("rozcienczacz przerwa"); delay(100); if (ml3 >= 0) { waga.tare(10); pomiar(); ekran(); Serial.println("nalewam kwas"); while (ciezar <= ml3) { pomiar(); ekran(); pompa3.run(FORWARD); led3(); } pompa3.run(RELEASE); Serial.println("kwaas przerwa"); delay(100); } } } waga.tare(); pomiar(); kolorowo(); ciemno(); } if (digitalRead(manpom1) == LOW) { pompa1.run(FORWARD); led1(); } else { pompa1.run(RELEASE); } if (digitalRead(manpom2) == LOW) { pompa2.run(FORWARD); led2(); } else { pompa2.run(RELEASE); } if (digitalRead(manpom3) == LOW) { pompa3.run(FORWARD); led3(); } else { pompa3.run(RELEASE); } if (digitalRead(tara) == LOW) { waga.tare(10); } } void pomiar() { ml1 = analogRead(A5); ml1 = map(ml1, 1020, 0, 0, 150); ml2 = analogRead(A4); ml2 = map(ml2, 1020, 0, 0, 150); ml3 = analogRead(A3); ml3 = map(ml3, 1020, 0, 0, 150); ciezar = waga.get_units(); dtostrf(ciezar, 5, 0, odczyt); } void ekran() { lcd.clear(); lcd.setCursor(0, 0); lcd.print("1.Alkohol:"); lcd.print(ml1); lcd.setCursor(0, 1); lcd.print("2.Dodatek:"); lcd.print(ml2); lcd.setCursor(0, 2); lcd.print("3.Kwas:"); lcd.print(ml3); lcd.setCursor(0, 3); lcd.print("Waga:"); lcd.print(odczyt); lcd.print("g"); Serial.println(ml1); Serial.println(ciezar); } void ciemno() { digitalWrite(redl, LOW); digitalWrite(greenl, LOW); digitalWrite(bluel, LOW); digitalWrite(redr, LOW); digitalWrite(greenr, LOW); digitalWrite(bluer, LOW); } void czerwona () { digitalWrite(redl, HIGH); digitalWrite(greenl, LOW); digitalWrite(bluel, LOW); digitalWrite(redr, HIGH); digitalWrite(greenr, LOW); digitalWrite(bluer, LOW); } void zielona () { digitalWrite(redl, LOW); digitalWrite(greenl, HIGH); digitalWrite(bluel, LOW); digitalWrite(redr, LOW); digitalWrite(greenr, HIGH); digitalWrite(bluer, LOW); } void niebieska () { digitalWrite(redl, LOW); digitalWrite(greenl, LOW); digitalWrite(bluel, HIGH); digitalWrite(redr, LOW); digitalWrite(greenr, LOW); digitalWrite(bluer, HIGH); } void kolorowo () { digitalWrite(redl, HIGH); delay(czasMigania); digitalWrite(greenl, HIGH); delay(czasMigania); digitalWrite(bluel, HIGH); delay(czasMigania); digitalWrite(redr, HIGH); delay(czasMigania); digitalWrite(greenr, HIGH); delay(czasMigania); digitalWrite(bluer, HIGH); delay(czasMigania); delay(500); } void led1 () { digitalWrite(redl, HIGH); digitalWrite(greenl, HIGH); digitalWrite(bluel, LOW); digitalWrite(redr, HIGH); digitalWrite(greenr, HIGH); digitalWrite(bluer, LOW); } void led2 () { digitalWrite(redl, LOW); digitalWrite(greenl, HIGH); digitalWrite(bluel, HIGH); digitalWrite(redr, LOW); digitalWrite(greenr, HIGH); digitalWrite(bluer, HIGH); } void led3 () { digitalWrite(redl, HIGH); digitalWrite(greenl, LOW); digitalWrite(bluel, HIGH); digitalWrite(redr, HIGH); digitalWrite(greenr, LOW); digitalWrite(bluer, HIGH); } Link do filmu:

Cześć, przedstawiam projekt inspirowany życiem Często wietrzymy w domu i nikt nie pamięta żeby zamknąć okno balkonowe. Akurat w ciągu dnia siedzę pod balkonem i zawsze mi zimno. Na zmianę nawyków nie liczę Wpadłem za to na pomysł żeby zrobić z tego co mam pod ręką małe urządzenie na okno, które będzie przypominać że czas skończyć wietrzenie. Elektronika Chciałem zrobić coś małego, co: będzie wisieć na oknie, da się zasilać z baterii, będzie pokazywać ile jeszcze zostało, będzie wkurzające kiedy zacznie się przypominanie. Wolałem skorzystać z płytki, bo wolę programować urządzenia przez USB. Z małych płytek miałem tylko klona Digispark Attiny 85 i takiego użyłem. Buzzer był oczywistym wyborem do sygnalizacji, miałem ten z zestawu do techniki cyfrowej o najgłośniejszej częstotliwości ~4 kHz. Kontrakron na okno wybrałem po prostu najmniejszy, dodałem do niego kondensator 100nF i rezystor żeby przy zamkniętym oknie schodziło mniej energii. Niewiele pomogło, ale cóż.. Pojawił się problem z sygnalizacją. Płytka Attiny85 ma tylko 6 pinów, dodatkowo jeden jest używany jako reset i nie chciałem go używać. Buzzer plus kontaktron zabierają dwa piny i zostaję z trzema. To trochę mało do pokazywania postępu - jeśli wietrzenie ma trwać 30 minut to ciężko pokazać ile już minęło. Wymyśliłem żeby skorzystać z układu CD4017B, który liczy do dziesięciu i aktywuje po jednym pinie w zależności od wartości. Podłączyłem do niego wykres LEDowy i już mam wyświetlacz, który aktywuje wybrany pasek. Udało się zmieścić w trzech pinach (clock, reset i odłączane zasilanie z attiny85). To ma też taki plus, że wszystkie diody obsługuje jeden rezystor, a jak się okaże później i tak zabrakło miejsca Na attiny85 piny P3 i P4 są też używane jako szyna danych USB i nie mogłem programować płytki kiedy były podłączone. Dodałem do nich włącznik (dokładnie ten - jest fajny bo można nim włączać dwie rzeczy po obu stronach. Oprócz tego włącznik do zasilania i finalnie skończyłem z takim schematem: Tak wyglądał pierwszy prototyp: 10 LEDów nie mieści się na płytce, więc zrobiłem taką małą macierz z czterech czerwonych diod. Dodałem też dwa przyciski do scalaka żeby sprawdzić "na sucho" czy wszystko dobrze podłączyłem. Oprogramowanie Do CD4017B napisałem prostą klasę, która w gruncie rzeczy po prostu wysyła impulsy góra-dół. Wyświetlacz można wyłączać odłączając zasilanie na jednym pinie - uznałem, że skoro świeci się tylko jedna dioda na raz to będzie działać. I działa. Do tego dodałem prostą klasę korzystającą z arduino-timer, która podnosi pasek o jeden co 10% oczekiwania. Buzzer jest bardzo standardowy - również skorzystałem z biblioteki arduino-timer, która włącza dźwięk funkcją tone co określony czas. Kontaktron jest obsługiwany przerwaniem sprzętowym (Digispark ma jedno). W oczekiwaniu na otwarcie okna płytka miała przechodzić w stan uśpienia. Niestety działa to tylko na Arduino Nano i Digispark nie wybudza płytki po przerwaniu, więc po prostu skorzystałem z delay - w przypadku otwarcia okna kilka-kilkanaście dodatkowych sekund opóźnienia nie robi różnicy. Na najwyższym poziomie oprogramowanie to prosta maszyna stanów - po otwarciu okna uruchamia licznik i zaczyna zliczanie, a kiedy skończy się zliczanie uruchamia buzzer. Cały kod jest dostępny w repozytorium: https://github.com/kantoniak/airing-scheduler Sprawdziłem na prototypie, że diody ładnie się palą (jak na zdjęciu poniżej) i przeszedłem do składania. Składanie urządzenia To była chyba najgorsza część tego projektu. Chciałem się zmieścić na płytce 30x70 mm i musiałem bardzo długo przestawiać elementy zanim mi się udało. Tak wyglądał kandydat do składania: Musiałem parę rzeczy przypiłować, buzzer jest nad płytką i jeden włącznik jest przycięty, ale wszystko się zmieściło. No prawie - bateria wystaje z jednej strony, ale nie jest najgorzej. Z lutowaniem wyszło OK, ale trwało to prawie cały dzień. Na koniec miałem tylko nadzieję, że będzie działać. Następnym razem zamówię PCB Na koniec wydrukowałem jeszcze obudowę. Niestety pomyliłem się z dziurką na buzzer, ale wszystko działa i szkoda mi filamentu. Obudowa ma miejsce na jedną śrubkę - płytka jest lekka i takie mocowanie daje radę: Całość działa jak na poniższym filmiku: Projekt miał być prosty, ale jednak trochę się namęczyłem. Nie mniej trzeba się było trochę nagłówkować i cieszę się że udało mi się złożyć urządzenie z tego co miałem pod ręką

Chyba każdy elektronik powinien mieć dogodne źródło zasilania - zasilacz laboratoryjny. Najtańsze gotowce kosztują conajmniej 130zł. Ja, jak większość elektroników-hobbystów - przerobiłem stary zasilacz komputerowy ATX na "warsztatówkę". Budowa Wymagania miałem małe: zmieścić się w budżecie (ok. 40zł), mieć po kilka wyjść różnych napięć, obudowa miała być ładna, i mieć jedno regulowane (najlepiej jak natężenie też by było regulowane). Więc zacząłem od rozkręcenia starego ATXa (ratujmy planetę, nie wyrzucajmy elektroniki ) i wyczyszczenia "flaków". Po sprawdzeniu, czy zasilacz podaje dobre napięcia (a podawał) wkręciłem go do obudowy Z17 - kosztowała ona ok. 15zł. Następnie zająłem się modułem regulacji napięcia, oparty na dobrze znanym LM317. Miał on być połączony z woltomierzem i amperomierzem panelowym, lecz taki miernik kosztował 30zł - zakupiłem więc sam woltomierz (ok. 10zł). Regulowanie napięcia umożliwia potencjometr znajdujący się na froncie, obok woltomierza i gniazd bananowych. Wyprowadziłem 4 masy, napięcie regulowane, 3.3v, 5v, oraz 12v. Po prawej stronie zamieściłem diodę LED RGB w plastikowej oprawce, aby można było zobaczyć stan zasilacza (czerwona - zasilacz jest podłączony, zielona - zasilacz jest włączony). Do tego dochodzi sam przełącznik panelowy za ok. 3zł - akurat taki, bo wygląda jak w filmach Z tyłu umieściłem wentylator SilentiumPC 80x80mm wraz z osłonką wydrukowaną w 3D (białe PLA), gniazdko oraz jego włącznik. Funkcjonalność Zasilacz podaje kilka różnych napięć "naraz" - można do niego bez dodatkowego okablowania do 4 urządzeń. Napięcia stałe radziły sobie dobrze ze sztucznym obiążeniem - rezystor 10W - ale 1 amper LM317 już tu nie wystarczył (co spowodowało wyłączenie urządzenia). Bez problemu mogę podłączyć do tego elektronikę, arduino, czy grzałkę kiedy zimno Obsługuje też bez problemu przerobiony dysk twardy na szlifierkę. Zabezpieczenia działają, w przypadku przeciążenia i zwarcia zasilacz wyłącza się. Całość robiłem z dobre 2 dni, gdzie najdłużej zajmowało dłubanie w plastiku aby zrobić otwory (wiertarki jeszcze nie miałem). Urządzenie jest bardzo praktyczne i przydatne - od ładowania akumulatorów żelowych po zasilanie prototypów. Zachęcam do tworzenia podobnych urządzeń - niezastąpione przy każdym warsztacie. Pozdrawiam, Leoneq :3

Krótki wstęp: Witam, chciałbym przedstawić wam projekt, który nosi nazwę mikrofon paraboliczny. Każdy z nas poza domem słyszał hałasy, śpiewające ptaki itd, albo miałeś ochotę podsłuchać kogoś z dalszej odległości. Występują dźwięki, których ich słyszalność już nie jest, aż taka wyraźna. Dlatego za pomocą tego urządzenia możesz wyłapać te głosy. Sprzęt osobiście polecam dla miłośników wsłuchujących się w przyrodę. Zasada działania oraz schemat: W streszczeniu: Mikrofon odbiera dźwięki, które są przekształcane w sygnał elektryczny, następnie wzmacniane i przekazywane do odbiornika. Dla dociekliwych: Warto zacząć, że cały układ jest zasilany z akumulatora 12V. Za pomocą mikrofonu elektretowego, który kupiłem w sklepie Botland , obieramy fale dźwiękowe, które są zamieniane na sygnały elektryczne. Mikrofon jest zasilany z dodatniej szyny przez rezystor R1. Odebrany i przetworzony sygnał płynie przez kondensator C6, którego zadaniem jest nie przepuszczanie prądu stałego. Układ regulacji głośności tworzą elementy PR1 oraz C5, po czym sygnał trafia do wejścia wzmacniacza. Układ scalony jaki został tu wykorzystany jest dobrze każdemu znany LM386, który można kupić za małe grosze. Wartość wzmocnienia układu zależy od kondensatora C1, przez co napięcie wyjściowe jest około 200 razy wyższe od wejściowego. Za pomocą kondensatora C7 unikamy przemian obieranych sygnałów w mieszankę niewyraźnych dźwięków. Dwójnik C9, R2 tworzą tzw. rezerwuar sygnału wyjściowego, czyli kondensator jest ładowany/rozładowywany w zależności od wzrostu/spadku natężenia pobieranego prądu. Kondensator C8 ma za zadanie odseparować składową stałą. Sposób wykonania: Ja do swojego projektu użyłem zwykłej płytki uniwersalnej, którą możemy nabyć w sklepie z elektroniką, można również wytrawić samemu taką płytkę. Podczas lutowania układu zastosowałem złącza ARK po to abym mógł bezpośrednio poprowadzić przewody do wejścia mikrofonu oraz wyjścia na słuchawki. Na sam koniec lutowania specjalnie zostawiłem potencjometr, abym mógł poprowadzić kable do niego i swobodnie umieścić go w górnej części obudowy. Tuż przed wykonaniem tej czynności wywierciłem dziury w obudowie na wyjście słuchawek, potencjometr, włącznik oraz na złącza banankowe. Następnie przymocowałem układ na tulejkach i przylutowałem przewody do poszczególnych pinów. Do mojej wkładki mikrofonu użyłem złącz banankowych, przez co mogę wypiąć, wpiąć mikrofon. Moim odbiornikiem są zwykłe przerobione słuchawki na Mono. Tuż przed złączami na obudowie do mikrofonu widać jest kolejne, które służą do ładowania akumulatora znajdującego się w środku. Dodatki wykorzystane w sprzęcie: Na schemacie poza wzmacniaczem do naszego mikrofonu parabolicznego możemy dostrzec Transformator wraz z mostkiem oraz drugi układ, służący do wskazywania napięcia naładowania naszego akumulatora, który nie został wykorzystany w moim sprzęcie, ze względu na brak potrzeby, gdyż akumulator ładuje bezpośrednio z zasilacza. Wracając do wskaźnika naładowania akumulatora ma on za zadania załączyć diodę w zależności od tego czy nasze napięcie na akumulatorze jest już wystarczające czy niskie. Jego zasadę można opisać w następujący sposób: Gdy napięcie na akumulatorze jest większe to DZ zaczyna przewodzić co powoduje załączanie tranzystora Q1 co powoduje zwarcie pinu 2 do masy, na wyjściu NE555 pojawia się stan wysoki, czyli akumulator dobry, w całym procesie dioda D1 również przechodzi w stan przewodzenia powodując włączenie tranzystora Q2. Obniżające się napięcie poniżej 12V powoduje wyłączenie Q1. Kondensator jest ładowany, gdy osiągnie określoną wartość pojawia się stan niski co powoduje zapalnie diody czerwonej. Zalecenia: Aby uzyskać jak najlepszy efekt, zalecam kupienia talerza parabolicznego i umieszczenie w nim wkładki mikrofonowej. Całość powinna być nie ruchoma, tak samo jak i odbiorca. Odbieranie dźwięków polecam przy ładnej pogodzie oraz braku odczuwalnego wiatru. Przy tworzeniu wersji jak na zdjęciach, należy wykorzystać Transformator o min Mocy = 6VA. Do podłączenia słuchawek w obudowie wykorzystałem gniazdo Jack. Całość proponuje umieścić w obudowie. Zastrzeżenia/Uwagi: Przed założeniem słuchawek należy wyregulować poziom głośności na minimalną i stopniowo ją zwiększać. W przypadku zdejmowaniu słuchawek wykonać tą samą czynność! Unikaj głośnych dźwięków, które są odbierane blisko mikrofonu! Zalety: Niski poziom szumów. Wysoka czułość. Maksymalny zasięg około 40m. Mały prąd spoczynkowy. Wady: Waga. Tzw. strzał wynikający z załączenia układu. Wrażliwy na uderzenia, wiatr, deszcz. Zakończenie: Tak więc się prezentuje mikrofon paraboliczny czy tzw. podsłuchiwacz. Zachęcam do skonstruowania sobie takiego sprzętu za małe pieniądze. Pozdrawiam i czekam na pierwsze komentarze.

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

Głównym założeniem tego projektu było stworzenie urządzenia wyświetlającego liczbę klatek na sekundę w grach komputerowych, jak i również innych informacji o obciążeniu komputera. Zdaje sobie sprawę, że projekty podobnego to tego pojawiały się już nie raz w sieci pod różnymi postaciami. W tym projekcie skupiłem się jednak na tym, aby całość zmieściła w małej kompaktowej obudowie, którą można w elegancki sposób zamontować pod monitorem. Możliwość wyświetlania FPS również jest tutaj czynnikiem wyróżniającą ten projekt na tle innych. Jest tak głównie dlatego że o ile informacje o wykorzystywanej ilości pamięci RAM, czy też obciążeniu procesora można dosyć łatwo pozyskać za pomocą różnych bibliotek w programie po stronie komputera, tak z klatkami na sekundę jest trochę trudniej. Użyte komponenty Sama budowa tego monitorka jest naprawdę prosta. Zostały w nim użyte właściwie tylko 3 komponenty: Arduino nano wyświetlacz OLED 128x32 przycisk dotykowy Pierwotnie zakładałem również użycie diody LED do sygnalizacji pewnych błędów, czy też wciśnięcia przycisku dotykowego. Uznałem jednak, że w tym przypadku nie miało by to większego sensu zważając na potrzebę minimalizacji. Można byłoby się zastanowić czemu wybór padł na arduino nano, a nie np. arduino pro micro. Arduino pro micro jest mniejsze, prawda? Zgadza się, dlatego też użyłem tego mikrokontrolera w pierwszej wersji tego wyświetlacza, który skończył dość marnie. Było tak dlatego, że przez przypadek chcąc poprawić przewód HDMI za monitorem, szarpnąłem niechcący za przewód idący do arduino. No i stało się, wyrwałem wtyk micro USB z płytki. Chcąc uniknąć ponownie takiej wpadki w następnej wersji użyłem mikrokontrolera, który kosztem ciut większej wielkości jest tańszy oraz posiada lepiej zamontowany na płytce wtyk USB mini. Jeśli chodzi o wyświetlacz to sprawa była prosta. Taki OLED 128x32 nie tylko rozmiarami idealnie pasuje do całego projektu, ale też po prostu prezentuje się ładnie i daje dużo możliwości. No i na koniec czujnik dotykowy. Dostępny w wielu rozmiarach, tani oraz przede wszystkim nie wymagający praktycznej żadnej siły do jego aktywacji. Ukryty w prawym boku obudowy dodaje estetyczności, nie zmniejszając przy tym komfortu użytkowania. Obudowa Obudowa została w całości wydrukowana na drukarce 3D. Sam model do druku zaprojektowałem w programie Fusion 360. Tak jak już pisałem, zależało mi na niewielkich rozmiarach. Dlatego cały model przeszedł przez wiele iteracji, a w każdej z nich starałem się zminimalizować jego wielkość. Zadbałem tutaj również o to, aby każdy z elementów w środku miał dopasowane pod siebie miejsce celem łatwego montażu. Po historii z wyrwaniem wejścia na płytce, finalnie dodałem jeszcze mały uchwyt na przewód mający minimalizować ryzyko ponownego uszkodzenia portu USB. Software Oprogramowanie po stronie komputera to prosty skrypt napisany w pythonie. Poza łączeniem się z arduino i przesyłaniem mu danych, musi te dane jeszcze skądś brać. I tutaj pojawił się mały problem, jeśli chodzi o pobranie ilości klatek w aktualnie włączonej grze. Nie da się od tak wyliczyć takiej wartości w programie, nie ma też na to gotowej funkcji. Z pomocą przyszedł popularny program o nazwie Msi AfterBurner. Nie wchodząc w szczegóły, program ten pozwala na monitorowanie zasobów komputera ( RAM, CPU, GPU itp.), jak i również uzyskanie potrzebnych nam FPS w aktualnie włączonej grze/programie. Teraz już tylko wystarczyło użyć wbudowanej w program funkcji do logowania tych danych do pliku, oraz odczytać je w pythonie i przesłać do arduino. Czy taki sposób jest wydajny? Cały proces wykorzystania pliku jako bufora do danych nie powinien w znaczący sposób obciążyć komputera, jednak lepszą opcją byłoby wykorzystywanie współdzielenia pamięci między dwoma programami. Aby to jednak osiągnąć potrzebna jest trochę większa wiedza z programowania w C++/C#, której niestety jeszcze nie posiadam. W przypadku arduino program po za odczytaniem danych oraz ich wyświetleniem, obsługuje również dotykowy przycisk. Pojedyncze dotknięcie przycisku zmienia wyświetlaną zawartość na 1 z 6 ekranów, zaś przytrzymanie przycisku powoduje zmianę ekranu co jedną sekundę. Dostępnymi ekranami są: klatki na sekundę, użycie CPU i GPU, temperatura CPU i GPU, użycie pamięci RAM i VRAM, prędkość wentylatora oraz ekran główny powodujący wygaszenie ekranu po paru sekundach. Dalsze plany W przyszłości planuje jeszcze większą minimalizacje wielkości obudowy, bo jest na tym polu jeszcze dużo do zrobienia. Mam zamiar również poduczyć się C++, aby móc wykorzystać współdzieloną pamięć między programami, rezygnując z odczytywać danych z pliku.

Witam chciał bym zaprezentować , drugą "lepszą wersję " kierownicy do komputera opartej na Arduino Leonardo. Film pokazujący jak dziala kierownica i Force Feedback: Jest to wersja elektronicznie taka sama jak poprzednia, wszystko opisane wcześniej link do poprzedniej tutaj : W tej wersji zmieniłem obudowę na znacznie mniejszą , lżejszą , łatwa do zamocowania przy stole, biurku itp. Obudowa została wykorzystana z kupionej przeze mnie za 50 zł kierownicy Logitech Formula Force Ex o obrocie 180* i Force Feedback. Dzięki temu że kierownica miała już przekładnie i ogólnie jest prosta w budowie , bardzo łatwo i tanio można ją przerobić tak aby miala kąt skrętu taki jak ustawimy sobie w programie np 720*,900* i Force Feedback do tego kąta obrotu. Tutaj link do gotowego software na Arduino Leonardo , od razu mówię że na Arduino Uno nie zadziała , link do pobrania w opisie filmu: Ja zrobiłem to tak: Na początku przez środek starej przekładni , dodałem pręt gwintowany o średnicy 10mm ,do którego z jednej strony mocowana jest kierownica, a z drugiej enkoder z drukarki canon ip2770. Aby zamocować enkoder musiałem wyciąć dziure jak widać na zdjęciu poniżej : Aby enkoder nie tarł o blat , dodałem plastikowe podkładki : A tak wygląda już gotowa sama kierownica: Wyjścia enkodera i do silnika , zostały przerobione na standardowych wyjściach które były w kierownicy i wchodzą do dodatkowej skrzynki w której znajduje się reszta elektroniki czyli w sumie tylko Arduino Leonardo i sterownik silników BTS7960: Jeszcze pedal box został przerobiony na taki aby miał 3 jednakowe pedały więc musiałem dokupić drugie takie same i wyciąć jeden i dokleić tak jak na zcjeciach . Schemat podłączenia wszystkiego w linku do wcześniejszej wersji. Efekt końcowy (pedały jeszcze stare): To by było na tyle , jeśli czegoś ktoś potrzebuje , śmiało pisać

Witam wszystkich czytelników. Zainspirowałem się w wakacje postem użytkownika @Krzysiek97, który przedstawił swoją kierownice do gier na bazie arduino leonardo: Kierownica PC - wersja 2. Z racji tego że lubię grać w gry wyścigowe i symulatory postanowiłem zbudować własną kierownicę z dodatkowymi akcesoriami. Nie chciałem przerabiać starej gotowej kierownicy do komputera, więc wpadłem na pomysł aby zbudować całe stanowisko. Materiał o tym stanowisku/ projekcie znajduję się na moim kanale na YT do którego was zapraszam Kierownica do komputera na bazie arduino Chciałem aby w tym stanowisko znajdowała się kierownica o kącie obrotu 900 stopni, sprzęgło, gaz, hamulec, 8 biegów + wsteczny (8 biegów ponieważ tyle mają niektóre samochody np. w Forza Horizon 4), hamulec ręczny, 2 joystiki (do sterowania maszynami w Farming Simualtor), button matrix 4x5 = 20 przycisków (przypisanych do rożnych akcji w grach) i zegary do wyświetlania prędkości i obrotów. Tak więc gdzieś w połowie lipca zacząłem szukać potrzebne części. Pierwszym problemem z którym się spotkałem była niewystarczająca ilość wejść w arduino leonardo. Ktoś na tym forum podsunął mi płytki Nucleo 64 na STM32, obawiałem się jednak czy programy które wcześniej znalazłem w internecie będą z nimi współpracować. Bawiłem się naco wcześniej arduino lecz nucleo nie stąd moja niepewność ponieważ zaczynałem dopiero wtedy zabawę z tym wszystkim. Zdecydowałem się jednak zostać przy arduino i zakupiłem 3 płytki, po jednej dla każdego programu który obsługuję inną część stanowiska, ponieważ i tak nie ma prgoramu który ogarnie wszystkie moje rzeczy na raz. A więc tak: Arduino Leonardo - program EMC Utility Lite (z początku korzystałem z RFR Whell Configuration elcz sprawiał on problemy) - obsługuję kierownicę, pedały, hamulec ręczny - Link do programu EMC, Jak zainstalować program Pierwsze Arduino Pro Micro - program MMJoy2 - obsługuję button matrix i 2 joysticki - Link do programu MMJoy2, Jak zainstalować program Drugie Arduino Pro Micro - program SimHub - obsługuję zegary/wyświetlacze - Link do programu SimHub Zamówiłem też 20 guzików (push button) 10 styczników krańcowych 2 Joysticki 2 wyświetlacze Tm1638, 1 wyświetlacz Max7219 (zamówiłem też sterownik silnika BTS7960 lecz na razie nie zakładałem FFB). Rzeczy które miałem w domu to: 2 potencjometry 10k Ohm, stycznik krańcowy ls-11s, kable kawałki plastiku, materiału i gumy. Za postawę stanowiska posłużyła mi deska rozdzielcza i fotel od mazdy mx-5 i kierownica od mazdy 626. Całość jest przyspawana do rurki i przykręcona do euro palety. Z racji tego że deska pochodzi z anglika to nie mogłem zamontować zwykłych zegarów w miejscu poduszki pasażera. Zamieszczam tutaj schematy podłączeń danych elementów: Drugim problemem który chce tu opisać, było przeniesienie/ zczytanie obrotu z kierownicy do arduino. Na początku chciałem wykorzystać enkoder optyczny z swojej starej drukarki, lecz gubił się on często i nie działał dokładnie, więc kupiłem enkoder inkrementalny 600ppr. Nie będę się już tak rozpisywał co jak i gdzie jest skręcone dlatego wszystko pokazane i omówione jest w filmiku do którego link jest na początku posta. Więc to jest dodatkowy materiał dla ciekawych. Podsumowując: koszt budowy stanowiska zamknął się dla mnie w kwocie 300zl, czas realizacji od pierwszego pomysłu do zbudowania całości i upewnienia się że wszystko jest sprawne to 6 miesięcy. Tak oto prezentuję się kierownica i jej działanie w grze Forza Horizon 4 Na koniec pytanie głownie do administratora, czy i kiedy będzie znowu dostępny konkurs Opisz elektroniczne DIY i odbierz 50 zł rabatu do Botland?

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.

Witam! To mój pierwszy wpis w dziale DIY. Projektem jest (a właściwie dopiero będzie) mini konsolka do gier na STM32F1. Robię ten projekt dla mojego 3-letniego synka. Docelowo będę mu wgrywać na nią różne napisane przeze mnie gry, ale na początek zacznę od klasyki, czyli gra w węża Robiłem już podobny projekt przy okazji kursu SMT32 na Forbocie, więc szybko powinienem napisać niezbędny kod. Tym razem ma to być gotowe urządzenie które bez problemu będzie mógł obsłużyć 3-latek. Założenia projektu: 1. Mikrokontroler STM32F1 2. Ekran TFT kolorowy 240x320 3. Zasilanie bateryjne LiPo z ładowaniem przez gniazdo USB (więcej szczegółów w moim wątku w dziale Zasilanie - szczególnie ostatni mój post) 4. Obudowa w całości drukowana w 3D 5. Żadnych gotowych modułów. Własny projekt PCB i własny montaż. 6. Klawiatura: Krzyżyk, przycisk A, przycisk B oraz przycisk POWER, jak w starych Game - Boy'ach 7. Dzwięk: Nad tym jeszcze nie myślałem, brak I2S oraz DACa na mojej płytce Nucleo trochę utrudnia sprawę. Może będzie coś na Timerach i PWM. Zobaczymy. Teraz po kolei. Pierwsze co musiałem zrobić to ogarnąć wyświetlanie na TFT. Zakupiłem trochę w ciemno kilka wyświetlaczy 2,8" na ILI9341. Mój brak doświadczenia z TFT natychmiast się zemścił. Po odbiorze przesyłki okazało się że obsługa SPI wcale nie jest oczywista i jestem skazany na 16-bitową magistralę. Nie znalazłem nigdzie driverów na STM32 do sterowania tym kontrolerem przy takim połączeniu, ale znalazłem kilka projektów na GitHub'ie gdzie było sterowanie przez magistralę 8-bitową. Postanowiłem więc na podstawie tych projektów napisać własne drivery i procedury wyświetlania podstawowych kształtów. W trakcie prac nad optymalizacją wyświetlania okazało się że jednak 16-bitowa magistrala to doskonały pomysł i jest 4-krotnie szybsza od 8-bitowej. Dlaczego? Już tłumaczę: Gdy używa się 8-bitowej szyny danych to wysłanie piksela wygląda następująco (już po ustawieniu adresu): - Ustawiamy pierwsze 8 bitów koloru - WR strobe - czyli szybka zmiana linii WR na 0 i powrót 1 - Ustawiamy kolejne 8 bitów koloru - WR strobe - czyli szybka zmiana linii WR na 0 i powrót 1 I powtarzamy do czasu wypełnienia zaadresowanego okienka. Czyli na każdy piksel przypadają 4 kroki. Gdy używamy 16-bitowej magistrali - wygląda to następująco: - Ustawiamy 16 bitów koloru - WR strobe - czyli szybka zmiana linii WR na 0 i powrót 1 I powtarzamy do czasu wypełnienia zaadresowanego okienka. Czyli na każdy piksel przypadają 2 kroki. Ale przecież pisałem że jest 4 razy szybciej, a tu wychodzi że 2 razy No więc łatwo można zauważyć, że przy 16 bitach raz ustawiony kolor na linii danych możemy zostawić do czasu aż będziemy musieli użyć innego koloru. Więc jeżeli mamy kilkaset pikseli do wypełnienia jednym kolorem to raz go ustawiamy, a później już tylko WR strobe tak długo jak potrzebujemy Czyli realnie wykonujemy tylko jeden krok. Zaimplementowałem to w moich driverach i rezultaty były doskonałe. Na tyle dobre że odpadła mi konieczność posiadania pamięci pod bufor klatki. Wszystko wyświetla się błyskawicznie: Aktualnie mogę wyświetlać do 8Mpix/s, co teoretycznie pozwala odświeżyć ekran 240x320 ponad 100 razy na sekundę na STM32F1 taktowanym 64MHz. Czyli mogę jeszcze podnieść tą częstotliwość do 72 MHz i jeszcze zwiększyć transfery. Niestety chwilowo mam odcięty programator od płytki Nucleo i muszę kożystać z wewnetrznego oscylatora który pozwala rozkręcić mikroprocesor do 64MHz. Kolejnym problemem z którym musiałem się zmierzyć to mała ilość flash na grafiki do gier. Jak łatwo policzyć jedna pełnoekranowa grafika to 153600 bajty, a mam tylko 128k do dyspozycji. A jeszcze musi się zmieścić program. Rozwiązaniem problemu jest kompresja. Tu znów musiałem od zera napisać program do kompresji grafiki który spełniałby moje wymagania. Kompresor został napisany w Pythonie. A szybki dekoder zaimplementowany w C w driverach na STM32. Pisałem program praktycznie od zera wg mojego pomysłu. Otóż dzieli on grafikę na bloki o jednolitych kolorach, a ich metadane zapisuje w binarnym pliku wyjściowym, albo w pliku C. Bloki są następujące: pozioma linia, pionowa linia, prostokąt. Pojedynczy piksel to pozioma linia o długości 1. Kompresja odbywa się przez rozkład grafiki na takie bloki, a następnie zapisaniu ich parametrów do pliku wyjściowego. Procedurę dekompresji zaimplementowałem w driverach do wyświetlacza, a każdy blok łatwo można wysłać bezpośrednio do pamięci ekranu, gdzie obraz zostaje odtworzony. Kolejną funkcją którą zaimplementowałem w kompresorze jest możliwość kodowania różnicy pomiędzy dwoma grafikami. Tzn jeżeli robię animację to program kompresuje tylko piksele które różnią dwie klatki. Poniżej proces odtwarzania obrazka na wyświetlaczu w zwolnionym tempie: Skoro miałem już ograne wyświetlanie grafiki, przyszedł czas na prototypowanie konsoli i pisanie samego kodu gry Aktualnie moje stanowisko pracy wygląda następująco: Sama gra jest na etapie tworzenia grafiki. Na razie mam animacje na intro: To tyle na dzisiaj. Wraz z postępami będę aktualizował ten wątek. Pozdrawiam, Marek

Witam chciałem wam przedstawić wykonaną przeze mnie kierownicę do komputera PC. Kierownica nie jest jeszcze do końca wykonana tak jak bym chciał , ale jest skończona działa można ją będzie jeszcze rozbudować Budowa od strony elektronicznej: Do budowy kierownicy użyłem jako podstawę Arduino Leonardo. Opierałem się o podobny projekt który znalazłem na yt . Lecz ja zrobiłem to trochę ładniej niż tamten chociaż nie ma rewelacji mogło być lepiej , ale w przyszłości myślę zrobić jeszcze jedną lepszą Oprócz Arduino Leonardo , zamiast jakiś potencjometrów i kombinowania z przekładniami użyłem enkoder z drukarki Canon IP2700. Ogólnie to oprócz enkodera to jeszcze parę przycisków potencjometry do pedałów i jakieś diody na podświetlenie. Poniżej schemat jak to podłączone. Oprogramowanie gotowe znalazłem pod tym filmem z którego się wzorowałem, wystarczyło wgrać XLoaderem i to wszystko podłączyć jak na schemacie. Od strony mechanicznej wygląda to tak: Odbijanie i blokada zostały zrobione na sprężynie niestety nie mam zdjęć . Dodam link do filmu na którym jest pokazane jak to działa. Ręczny przerobiony ze starej kierownicy . Elementy skrzyni biegów wydrukował mi kolega w 3D. i wygląda to tak: Pedały ze starej kierownicy , dorobiony jeden sprzęgłowy z innej kierownicy: Ostatecznie wygląda to tak: Link do filmu jak to działa i jak zrobione niektóre rzeczy: To by było na tyle w planach zrobienie Force Feed Back , na silniku DC 12v i przekładniach Pozdrawiam Krzysiek

Jakiś czas temu próbowałem już zbudować światłoluba, jedna z moich nieudolnych prób pojawiła się w jednym z postów na forum. Ale wiele nieudanych prób nie satysfakcjonowało mnie. Aż w końcu powstał robot, nad którym pracowałem około miesiąca. Jego właśnie opisuję tutaj. Podwozie powstało z kartonu, który wkrótce zostanie zastąpiony czymś twardszym. Nic szczególnego. Jednak chciałem, aby zajmowało jak najmniej miejsca. Zastosowałem pewien układ silników, który przy moich silnikach Dagu był najkorzystniejszy. Wybrałem te silniki, ponieważ była to najlepsza opcja kiedy je zamawiałem. Układ zmontowałem na wytrawionym przeze mnie PCB pochodzącej z tego miejsca. Trochę rzeczy zostało zniszczone. Rozmiar podwozia (bez kół) to 14x6 cm. Największym sukcesem jest to, że działa nie topiąc pojemnika na baterie. Może nie jest to najładniejszy robot na forum, jest niczym przysłowiowy ,,odgrzewany kotlet", ale jestem z niego bardzo dumny. Nad wyglądem popracuję w najbliższych dniach, napiszę o tym w postach poniżej .

Witam wszystkich. Chciałbym wam przedstawić mój projekt mieszadełka magnetycznego z regulowaną prędkością obrotów.Oprócz przedstawionego poniżej urządzenia trzeba się zaopatrzyć w dodatkowy magnes pokryty teflonem. Z tego co widziałem może być również jakiś zwykły podłużny, walcowy magnes ale mieszając coś do celów spożywczych poleca się ten pierwszy. Konstrukcja od strony elektronicznej nie jest zbyt skomplikowana dlatego myślę, że każdy nawet początkujący jest w stanie sobie z nią poradzić. Zasilanie jest dostarczane z zewnętrznego zasilacza sieciowego, poprzez gniazdo DC przykręcone do obudowy, przez włącznik, do płytki sterującej obrotami silniczka. Na frontowym panelu jest również dioda sygnalizująca zasilanie, oraz potencjometr, którym regulujemy obroty. Układ jest oparty na popularnym i tanim timerze NE555. Dokładnego schematu niestety zapomniałem sobie zapisać, a mieszadełko trafiło do znajomego, ale jestem przekonany, że jest bardzo zbliżony do tego: Uwagę trzeba również zwrócić przy konstruowaniu obudowy. W moim przypadku po kupieniu obudowy zorientowałem się, że wkręt łączący górę z dołem obudowy jest jeden i to w dodatku na samym środku, gdzie powinien znajdować się silniczek. Na szczęście za pomocą drukarki 3D wydrukowałem nowe tulejki montażowe, ale można również kupić gotowe. Oprócz tulejek wydrukowałem również „śmigło”, które jest osadzone na silniczku i w którym znajdują się magnesy neodymowe. Bardzo ważne jest dobre rozmieszczenie magnesów na „śmigle” aby były zamontowane symetrycznie i nie tworzyły tak zwanego „bicia” silnika. Trzeba pamiętać aby w razie przerabiania elementów łączących części obudowy, tulejki znajdowały się w takiej odległości od śmigła aby te o nie, nie haczyło. Silnik jak widać na zdjęciach jest przykręcony do kawałka blaszki, a ta, przykręcona do obudowy. Pomiędzy blaszką a obudową znajdują się kawałki pianki aby wytłumić drgania. Silniczek znajduje się możliwie jak najwyżej, tzn. tak aby śmigło było jak najbliżej górnej części obudowy. Dzięki temu, mieszadełko teflonowe znajdujące się w kubku, zlewce lub czymkolwiek, mocniej przyciąga się z magnesami na śmigle. Zasilacz trzeba dobrać w zależności od zastosowanego silniczka. U mnie był to silniczek na 5V i jak widać na filmiku poniżej, bez problemu radzi sobie z niecałym litrem płynu. Dzięki niewielkiej ilości podzespołów i elementów, każdy może sobie wykonać takie mieszadełko nawet jako gadżet do mieszania kawy lub po prostu do ozdoby dodając od spodu diodę LED - widziałem gdzieś filmik i przy przezroczystym płynie np. wodzie daje w ciemności bardzo ciekawy efekt A oto efekt końcowy:

Od kiedy tylko ludzie zaczęli interesować się akwarystyką od tego momentu postanowili na każdym kroku ułatwiać sobie pracę. Powstawały coraz to nowsze urządzenia – napowietrzacze, filtry, oświetlenia i tym podobne. Także w tej dziedzinie pojawiły się urządzenia w pełni zautomatyzowane (sterowane za pomocą różnego rodzaju przełączników oraz czujników). Przykładem takiego rozwiązania był chociażby sterownik akwariowy “Skalar”. Jako że powstał on w czasach gdy o diodach mało kto słyszał a sterowanie PWM już chyba nikt postanowiłem stworzyć własny sterownik akwariowy Bella. Jest to kompletny sterownik oparty na Arduino Nano v3. Sterownik akwariowy Bella – lista materiałów do budowy Obudowa uniwersalna Z1W Panel przedni MN-Tech Panel tylny MN-Tech Płytka prototypowa Bella Compact 1.1 moduł pod driver PWM firmy Meanwell (5 kanał) – opcjonalny arduino nano wraz z programem sterownika akwariowego Bella zegar ds1307 wyświetlacz LCD 20×4 znaki na szynie I2C termometr DS18b20 wodoodporny na kablu – 1 szt drivery firmy Meanwell serii LDD (dowolny model) (max 5 szt) przekaźnik 1 kanałowy – 2 szt przekaźnik 4 kanałowy – 1 szt kable połączeniowe FF długości 20cm do podłączenia modułów (30 szt – liczone z zapasem) gniazdo na goldpin 3 pinowe – 8 szt gniazdo na goldpin 4 pinowe – 2 szt (do wyświetlacza) gniazdo na goldpin 5 pinowe – 1 szt (do klawiatury) gniazdo na goldpin 6 pinowe – 2 szt (przekaźnik 4 kanałowy) zworka 2 pinowa (używana w przypadku braku sondy pH) przycisk chwilowy – 4 szt (jako klawiatura) włącznik kołyskowy okrągły – 2 szt gniazdo montażowe płaskie (GS-035) – 6 szt gniazdo zasilające na kabel ósemka – 1 szt gniazdo + wtyk 3 pinowy mini CB (termometr) gniazdo + wtyk 2 pinowy mini CB do podłączenia zasilania driverów 2x gniazdo + 2x wtyk 4 pinowy CB na listwę led (każde na 2 kanały oświetlenia) lub 1 gniazdo CB 8 pinowe na 4 kanały gniazdo montażowe do zasilania arduino 5,5/2,1 gniazdo bezpiecznikowe – 1 szt śruby czarne M3 długość 12mm – około 30szt nakrętki M3 – około 60 sztuk Oświetlenie Najważniejszym założeniem sterownika akwariowego Bella było oczywiście sterowanie oświetleniem. Sterownik obsługuje 5 kanałów PWM. Na samej płytce jest miejsce na zamontowanie 5 driverów z firmy Meanwell (dowolnych od LDD-300L do LDD-1500H). 4 z nich znajdują się na płytce natomiast piąty można zamontować osobno na dodatkowej płytce. Napięcie zasilania driverów jest w zakresie od 12 do 48V. Na płytce zostały wyciągnięte piny pwm oraz masy do podłączenia dodatkowych driverów. Moc każdego kanału można ustawić dowolnie w granicy 0-100% (wartości 0-255 na wyświetlaczu). Wszystkie kanały włączają się jednocześnie i gaszą o tej samej godzinie (wyjątkiem są kanały 1 i 2, które w przypadku ustawienia oświetlenia nocnego gaszą się dopiero o północy. W przypadku kiedy moc któregoś z kanałów jest zmniejszona jego ściemnianie / rozjaśnianie działa tak samo długo lecz jest proporcjonalnie wolniejsze (skoki są mniejsze). Długości i zakresy które można ustawić w tym dziale zostaną opisane w ostatnim akapicie “Zakresy”. Termostat Kolejnym punktem jest zastosowanie wodoodpornego termometru DS18b20 i możliwość podłączenia do niego dwóch niezależnych urządzeń (np grzałki oraz chłodnicy czy też wentylatora). Jak w poprzednim punkcie zakresy zostały opisane na końcu. W przypadku awarii / odpięcia termometru temperatura na wyświetlaczu znika (zostaje zastąpiona przez znaki –. Dodatkowo w ramach zabezpieczenia w takim przypadku gniazda zarówno grzania jak i chłodzenia zostają odłączone od zasilania. W przypadku tej funkcjonalności mamy dostępne 2 zmienne. Pierwsza to temperatura (oznaczająca temperaturę dolną) poniżej której uruchomiona zostanie grzałka. Druga to histereza. Główną wartością jest temperatura – jest to deklarowana wartość dolna poniżej której uruchomiony zostanie przekaźnik odpowiadający za grzałkę. Na wyświetlaczu zmieni się opis z G-OFF na G- ON. Temperatura będzie rosła do momentu przekroczenia 1x histerezy w górę. W przypadku jeśli temperatura przekroczy wartość zadaną + 2x histerezę uruchomi się chłodzenie i będzie działać do momentu w którym włączyło się grzanie (T+H). Stycznik 1 oraz stycznik 2 Stycznik 1 może zostać ustawiony w 2 trybach – pierwszym z nich jest to tryb pracy do sterowania elektrozaworem do CO2 (sterowanie uruchamia się automatycznie po podłączeniu sondy pH). Drugim trybem jest uruchamianie się 1x dziennie na dowolny okres (od 1 minuty do 23 godzin i 59 minut). W przypadku gdy nie ma podpiętej sondy pH do sterownika należy zrobić mostek pomiędzy pinem A7 a pinem GND – program automatycznie zmienia działanie stycznika na tryb pracy 1x dziennie. Stycznik 2 działa tylko jako uruchamiany 1x dziennie (jak wyżej). Stycznik 3 oraz stycznik 4 Działają one automatycznie w zależności od pór dnia. Stycznik numer 3 uruchamia się w momencie rozpoczęcia świtu i wyłącza w momencie gdy kończy się zmrok. Stycznik numer 4 uruchamia się tylko w czasie trwania dnia. Sonda pH Program obsługuje sondy pH opisane w tym artykule. Podpinana jest ona do pinu A7. Za jej pomocą sterowany jest stycznik numer 1 do którego można podpiąć jak pisałem powyżej elektrozawór dozujący CO2. W momencie w którym nie mamy podpiętej sondy pH należy zewrzeć piny A7 oraz GND. Dzięki temu stycznik nr 1 przełącza się na działanie 1x dziennie. Wartości które możemy zmieniać to dolna granica pH oraz histereza. Po przekroczeniu górnej granicy uruchomiony zostaje stycznik (do którego można podłączyć elektrozawór dozujący CO2) i działa on do momentu obniżenia pH poniżej zadanej wartości. Oświetlenie awaryjne Pin analogowy A6 został przygotowany jako uruchamianie oświetlenia awaryjnego. W przypadku gdy pin zwarty jest do masy (za pomocą rezystora 10kOhm program działa w normalnym trybie. Gdy włącznik zostanie uruchomiony i zwarty do pinu 5V oświetlenie zacznie świecić na około 50% mocy (na tyle mocno żeby było widać lecz aby nie oślepiać). W tryb pracy awaryjnej zostaną uruchomione kanały 1 oraz 2. Do uruchomienia oświetlenia awaryjnego służy przycisk na boku obudowy (z przodu) po stronie wyświetlacza. Wyłącznik oświetlenia Istnieje także możliwość wyłączenia całkowicie napięcia podawanego na diody. Do tego celu służy przełącznik znajdujący się z boku obudowy (od strony wyświetlacza z tyłu). Dzięki temu możemy w sytuacji w której jest potrzeba odpięcia oświetlenia od sterownika odłączyć całkowicie zasilanie driverów. Wyświetlacz LCD Sterownik akwariowy Bella oferuje dwa tryby działania. Pierwszym z nich jest tryb wyświetlania informacji znajdujących się na sterowniku. Poniżej znajduje się właśnie taki układ. Na żółto zostały oznaczone pola odpowiednio od góry: Grzałka, Wentylator, Stycznik 1 (jeśli używamy sondy pH zmienia się jego nazwa z S na C – można podpiąć do niego elektrozawór CO2) oraz Stycznik S2. Styczniki S3 oraz S4 (ich godziny działania) wyświetlane są w menu rotacyjnym na dole ekranu. Kolejnym trybem w jakim pracuje ten sterownik akwariowy jest tryb menu. Aby go uruchomić należy jednocześnie przytrzymać przyciski + oraz – (góra i dół). W tym momencie układ wyświetlacza zmieni się całkowicie na prezentowany poniżej: Funkcje menu (nazwa, dostępne wartości oraz ich skoki) W trybie ustawień zmieniają się dwa dolne wiersze na wyświetlaczu. Na górnym jest informacja o aktualnie zmienianej funkcji oraz jej wartości. W dolnym rzędzie pokazany jest dostępny zakres w jakim może być on zmieniany. Dokładna struktura menu zakresy oraz skoki są dostępne w tabeli poniżej. Po uzyskaniu maksymalnej wartości (dla przykładu PWM1 – 255) jeśli nadal będzie włączony przycisk + wartości będą liczone dalej od najniższej. Podobnie dzieje się w przypadku uzyskania najniższej wartości i trzymania przycisku -. W tym przypadku wartość zmieni się na największą. Więcej informacji znajdziecie w filmie:

Witam chciałem przedstawić wam mój projekt który ostatnio zbudowałem jest to prosta ręka robota oparta o 3 serwach sg90 są to proste serva modelarskie pozwalające na precyzyjne ruchy oraz są stosunkowo tanie. do sterowania układem zastosowałem Arduino Uno Rev3 ale może być to każdy inny moduł, w moim projekcje zastosowałem również moduł bluetooth, przydadzą się również płytka stykowa i kable połączeniowe. Dodatkowo postanowiłem wykonać pudełko drewnianych patyczków. Cały projekt przedstawia się następująco: Teraz trochę o podłączeniu Same podłączenie nie powinno stanowić problemu. Trzeba jednak pamiętać, że pin TX na arduino do pinu RX na module bluetooth a RX do TX Uwaga!!! jeśli macie płytkę Arduino Uno musicie podłączyć konwerter napięć gdyż posiada ono informacje na 5V a moduł bluetooth przyjmuje 3,3V ale możecie drobić taki z dwóch rezystorów przestawiony po niżej, ważne by te rezystory wynosiły minimum 10kΩ Dzielnik napięć Schemat projektu Kod projektu #include<Servo.h> // dodajemy bibliotekę do sterowania serwomechanizmem Servo servo; Servo servo2; // twożymy 3 obiekty klasy servo Servo servo3; void setup() { Serial.begin(9600); //rospoczynamy komunikację z prętkością 9600 botów servo.attach(2); servo2.attach(3); servo3.attach(4);// podpisujemy serva pod odpowiednie piny servo3.write(0); // ustawiamy servo 3 do poziomu startowego } char cmd[100]; byte cmdIndex; // przechwytujemy znaki z telefonu void execmd(){ if(cmd[0] =='a') // dla indeksu a wykonujemy poniższe polecenia { unsigned int val = atof(cmd+2); servo.write(val); // w zależności od zmiennej z indeksem a obracamy servem } if(cmd[0] =='b') { unsigned int val = atof(cmd+2); servo2.write(val); } if(cmd[0] =='c') { servo3.write(180); } if(cmd[0] =='d') { servo3.write(0); }} void loop() { if(test==0){ if(Serial.available() >0) { char c =(char)Serial.read(); if (c == '\n') { cmd[cmdIndex]=0; execmd(); cmdIndex=0; }else{ cmd[cmdIndex]=c; if(cmdIndex<99){cmdIndex++;} } } } } Aplikacja Do obsługi ramienia użyłem aplikacji RoboRemoFree jest to darmowa aplikacja ze sklepu play poniżej przesyłam konfigurację tej aplikacji Myślę ze każdy może wykonać taki projekt nie jest to trudne a nauczy nas trochę o samej komunikacji bluetooth z arduino. PS. jest to mój 1 post tutaj więc jeśli ktoś ma jakieś sugestię lub uwagi to był bym wdzięczy z konstruktywną krytykę

Witam serdecznie wszystkich czytelników. Chciałbym wam dziś przedstawić mój projekt jaki wykonałem na zakończenie technikum. Mianowicie zaprojektowałem i zbudowałem router sieciowy wyposażony w 5 portów ethernet oraz WIFI 2,4Ghz i 2x2 MIMO. Projekt zacząłem od wybrania jednostki sterującej , znajomy elektronik polecił mi SKW92a. Jest to mały moduł idealny do tego typu zastosowań. Można na nim uruchomić OpenWRT, bardzo ekonomiczna w zajmowane miejsce na dysku( tylko około 8 MB) wersja Linuxa. Tak więc użyłem tego modułu do budowy tego urządzenia. Następną rzeczą do zrobienia było dobranie zasilania. Chciałem aby router mógł być zasilany z np.takiej oto ładowarki , gdyż wejście microUSB i 5V jest dość popularne w dzisiejszych czasach. SKW92a działa jednak na zasilaniu 3,3V, konieczne więc było dodanie przetwornicy z 5V na 3,3V. Postanowiłem dodać jeszcze LEDy , aby służyły jako wskaźniki oraz port USB który będzię mógł posłużyć do podłączenia pamięci zewnętrznej w razie potrzeby przywrócenia systemu. Na końcu oczywiście też filtry dopasowujące transmisje ethernet i porty szeregowe do debuggowania. Projekt PCB routera Zaprojektowałem płytkę w Ki-Cadzie, dodałem swoje logo i wysłałem do produkcji ( sam proces projektowania PCB , rysowania footprintów itp. zajął około 30 h). Po polutowaniu wszystkiego router zaczął nabierać kształtu. Wszystko na miejscu Niestety pierwsze uruchomienie nie poszło zbyt kolorowo, gdyż mimo poboru prądu nie dało się wejść przez UART do SKW , po dogłębnej diagnostyce okazało się że nie jest to błąd portu szeregowego ale przetwornicy która była wadliwa.Musiałem umieścić tam osobną przetwornice step-down na osobnej płytce. Po tym zabiegu router zaczął działać wyśmienicie. Działający router Zainstalowanie OpenWRT nie było większym problemem, a także późniejsza konfiguracja była dość prosta. Z pomocą znajomego odkryliśmy że bez problemu można także przełączyć router w tryp switcha i można nawet tworzyć VLANy. Ostatnią rzeczą do zrobienia zostało zrobić ładną obudowę, którą zaprojektowałem w programie Designspark mechanical i wydrukowałem w drukarce 3D. Obudowa A tak wygląda w pełni działający router Dziękuję za uwagę i zapraszam do zadawania pytań w komentarzach

Mam w domu licznik prądu starego typu. Kiedy rachunki za prąd wzrosły powyżej 150 zł / mieś stwierdziłem, że czas na poszukiwanie przyczyn tego stanu rzeczy. Zacząłem od chińskiego watomierza, który doprowadził mnie do amplitunera Technics który w trybie standby zżera 30W. Byłem jednak ciekaw ile pobiera cały system monitoringu, lampy ogrodowe, NAS i kocioł itp. w rozkładzie godzinowym. Rozważałem zmianę taryfy z G11 na G12 lub G12W. Potrzebowałem danych. Ręczne spisywanie stanów licznika jest nużące i nudne. Przyszedł czas na emeocv - Electric meter with OpenCV. To darmowa biblioteka udostępniona na github. Pozwala na odczyt licznik na podstawie analizy zdjęć i zapis do RRD (Round Robin Database). Program napisany jest w C++ i korzysta ze znanej biblioteki OpenCV. Uruchomienie odczytów zajęło mi sporo czasu i nie dawało satysfakcjonujących wyników z uwagi na potrzebę dostosowania wielu zmiennych i rekalibracji po nawet delikatnej zmianie położenia kamerki. Przyszedł czas na instalację IDE pod C++ i wydanie własnej wersji programu. Krótka lista ficzerów: analiza zdjęć licznika dostarczanych z kamerki trening algorytmu poprzez ręczną klasyfikację przykładowego materiału zapis danych do CSV wewnętrzna kontrola jakości danych możliwość zapisu zdjęć do plików i późniejszą analizę statystyki Przejdźmy do rzeczy. Potrzebujesz: Raspberry PI (Zero, Zero W, testowałem też na RPI4b) z kartą pamięci. Alternatywnie: wystarczy dowolny komputer z pochodną Debiana (np. Ubuntu albo Linux Mint) oraz telefon komórkowy z Androidem. Kamerki (ja korzystałem z ArduCam OV5647 5Mpx) Uchwytu do kamerki - ja skorzystałem z połamanego uchwytu do telefonu (można kupić na allegro za 5-10 zł) Źródła światła (np.Lampka LED za mniej niż 5 zł) - musiałem dodać do niej rezystor bo świeciła zbyt mocno ja potrzebowałem hub'a USB żeby zasilić lampkę i malinkę z jednego zasilacza (koszt ok 10zł) Kolorowych karteczek samoprzylepnych Aplikacji Emeocv2 (moja własna wersja aplikacji wspomnianej powyżej) Dobrego nastroju i trochę czasu Wersja dla Raspberry PI Przygotowanie sprzętu: zamocuj kamerkę na statyw lub uchwyt, podłącz do malinki, ustaw światło tak aby niezależnie od światła dziennego licznik był równomiernie oświetlony. Ważne żeby nie świecić na wprost na szybkę licznika, bo pojawią się silne refleksy które utrudnią odczyt. Potem przyklej do licznika dwa kolorowe (najlepiej niebieskie) markery z karteczek samoprzylepnych (jeśli będą odpadać - użyj taśmy dwustronnej). Dzięki nim pogram bedzie w stanie ustalić obszar na którym znajdują się cyfry do analizy. Na zdjęciu poniżej widać przykładowy setup. Nie jest to za piękne ale to nie dzieło sztuki Instalacja: 1. Zainstaluj czystego Raspbiana na swoje malince 2. Podłącz kamerkę do Raspberry PI i włącz poprzez komendę raspi-config 3. Połącz się z RPI przez SSH (lub VNC) i pobierz Emeocv2 z https://github.com/wof2/emeocv2 4. Wejdź do katalogu głównego Emeocv2 i uruchom: ./debian_ubuntu_dependencies.sh Skrypt pobierze potrzebne zależności (przede wszystkim OpenCV) 5. Zbuduj make RELEASE=true 6. Wejdź do katalogu Release chmod +x emeocv 7. Zrób trochę zdjęć z kamerki aplikacją raspistill i zapisz pliki .png do wybranego katalogu. Hint: jeśli twój licznik znajduje się w pomieszczeniu gdzie zmieniają się warunki oświetlenia to jak będziesz wygładzał parametry najlepiej skorzystaj z trybu timelapse żeby zebrać zdjęcia z całej doby (np. co 15 min.). Najlepiej rób zdjęcia w rozdzielności nie większej niż 800x600. 8. Uruchom aplikację w trybie 'adjust' (najlepiej przeczytaj help do komendy - opal ją bez parametrów: ./emeocv) wskazując katalog w którym zapisałeś wcześniej zdjęcia. Pewnie analiza zakończy się błędem - musisz dostosować kilka parametrów - w katalogu Release edytuj plik config.yml. Najważniejsze parametry to: rotationDegrees: 0 #obraca obraz przed analizą cannyThreshold1: 120 # dolna granica dla algorytmu znajdowania konturów dostosuj metodą prób i błędów. Możesz zapisywać plik yml w trakcie analizy w trybie 'adjust' - co zdjęcie konfiguracja wczytywana jest ponownie. cannyThreshold2: 260 # górna granica znajdowania konturów. digitYAlignment: 20 # maksymalne różnie z położeniu kolejnych cyfr w osi Y mierzone w pikselach. counterMarkerHLOW: 85 # kolor markera (karteczki) w skali HSL (poczytaj w necie). Domyślne wartości ustawione są na detekcję niebieskiego. Wartość H (Hue) min. counterMarkerHHI: 110 # jak wyżej tylko max counterMarkerSLOW: 120 # wartość minimalnego nasycenia (Saturation) counterMarkerVLOW: 120 # minimalne V (Value) koloru karteczki. maxImageHeight: 600 # automatyczne przeskalowanie w dół - ustaw jeśli karmisz program dużymi obrazkami. digitCount: 7 # Łączna liczba cyfr na liczniku (łącznie z tą po przecinku) 9. Kiedy będziesz miał satysfakcjonujące wyniki z wcześniej zapisanych zdjęć to pora na trening naszego algorytmu. Uruchom emeocv z opcją -l (Learn). Teraz program będzie pokazywał serię zdjęć i pytał cię o klasyfikację zdjęć poszczególnych cyfr do skali 0-9. Potrzebujesz z grubsza tyle samo próbek dla każdej z cyfr. Możesz skorzystać z opcji emeocv -p żeby pokazać statystyki nauki. ./emeocv -p OCR stats: Trained responses: 1094 Trained responses histogram: Digit '0'->167 Digit '1'->184 Digit '2'->152 Digit '3'->148 Digit '4'->64 Digit '5'->60 Digit '6'->60 Digit '7'->112 Digit '8'->73 Digit '9'->74 10. Pora na automatyczne rozpoznanie cyfr na całym zbiorze zdjęć i pokazanie wyników ./emeocv -t -i obrazki/ -vDEBUG -s 10 11. Jeśli wyniki są ok to produkcyjnie odpalamy robienie zdjęć (np. co 2 minuty), analizę i wyplucie wyników do CSV. Służy do tego opcja -w (Write). Dla kamerki raspberry PI polecam wykorzystanie operacji -k, która pobiera zdjęcia z wyniku działania komendy w pliku config.yml. Domyślnie jest to raspistill czyli miniprogram na raspbianie do robienia zdjęć: cliCaptureCommand: raspistill -w 800 -h 600 -n -o Teoretycznie możesz tu nawet wsadzić pobieranie zdjęć z innego urządzenia. Alternatywnie użyj operacji -c (czyli Camera, podaj nr kamery np. -c0). Opcja wykorzystuje API openCV do odczytu z kamery. Mnie się ta opcja nie sprawdziła bo zdjęcia wychodziły albo za ciemne, albo poszczególne odczyty bardzo różniły się od siebie. 12. Wyniki będą się pojawiać w pliku emeocv.csv w katalogu Release. Patrz w logi emeocv.log i nie przejmuj się jeśli po kilkunastu przeanalizowanych zdjęciach plik jest pusty. Program cache'uje wyniki z ostatnich chyba 12 wyników i dopiero kiedy uzyska sensowną niemalejącą serię odczytów to dokonuje zapisu do pliku. Plik CSV możesz potem wciągnąć gdzie chcesz np. do arkuszy Google. Skorzystaj z mojego. Więcej informacji znajdziesz na https://github.com/wof2/emeocv2 Wersja z wykorzystaniem telefonu komórkowego - wkrótce

Robot unikający przeszkód z regulacją napędu silników prądu stałego Cześć! Ponad rok temu skonstruowałem w ramach przedmiotu na studiach robota unikającego przeszkody. Po czasie pomyślałem, że konstrukcją warto podzielić się na Forbocie. Zakres projektu Robot porusza się na dwóch kołach i omija przeszkody wykrywane za pomocą czujnika ultradźwiękowego. Dużo pracy włożono w sterowanie silnikami prądu stałego, które stanowią napęd robota. Mimo że zakres zachowań platformy nie jet zbyt szeroki, to wartość projektu leży w algorytmach teorii sterowania, które skonstruowano by zwiększyć precyzję ruchów. W zakres prac projektowych weszły: projekt platformy robota i jej wykonanie w technologii druku 3D (Fusion 360), projekt układu drukowanego z mikroprocesorem Atmega32u4, mostkiem H oraz paroma innymi peryferiami (Autodesk Eagle), oprogramowanie robota pozwalające na wykrywanie i omijanie przeszkód (biblioteki i bootlader Arduino), konstrukcja pętli sprzężenia zwrotnego dla silników oparta na użyciu enkoderów szczelinowych, algorytm regulatora PI do synchronizacji prędkości kół przy jeździe na wprost (poprawia utrzymanie kierunku jazdy), algorytm zagnieżdżonego regulatora obrotu platformy o zadany kąt (algorytm podobny jak ten stosowany w serwomechanizmach), prosta identyfikacja parametrów transmitancji użytych silników i trochę rozważań na temat możliwości strojenia regulatorów przy pomocy metody linii pierwiastkowych. W ramach zaliczenia projektu powstał dosyć długi raport, gdzie jest opisane jak zrealizowano poszczególne części projektu, dlatego nie ma chyba potrzeby przedstawiać w poście szczegółów po raz drugi. Gdyby ktoś szukał informacji o przenoszeniu swojego projektu z Arduino na własną płytkę PCB (z działającym USB na Atmedze32u4), konstrukcji systemów regulacji w praktyce, czy budowy własnych serwomechanizmów to można tam znaleźć działające przykłady. Kod projektu i dokumentację można znaleźć na GitHubie. Oczywiście projekt nie jest idealny, szczególnie że powstał już jakiś czas temu, a wraz ze zdobywaniem doświadczenia dostrzega się coraz więcej błędów. Na koniec dorzucam parę grafik i gifów, więcej można znaleźć w podlinkowanym raporcie i repozytorium. Ujęcia na robota z różnych stron Wierzchnia strona płytki PCB, spód oraz schemat elektryczny w raporcie Utrzymywanie kierunku jazdy Obrót o zadany kąt

Cześć razem z kolegą pracujemy nad robotem na konkurs RoboRave w łęgowie. Robot będzie startował w kategori firefighting. Będzie miał za zadanie zgaszenie 4 losowo rozmieszczonych świeczek na wysokości od 10cm do 45cm. Jest opart na arduino a za szkielet posłużą nitowane płytki. Dodatkowe elementy takie jak zaokrąglenia rogów podstawy pochodzą z drukarki 3d. Gdy robot będzie gotowy wstawię dokładniejszy opis.

Arduino jest taką fajną platformą, że chyba podoba się tylko osobom zainteresowanym. Dlatego też moja żona zawsze skacze z radości, gdy dokupuje sobie nowe przekaźniki, czujniki czy też „cholerne kable walające się po szafkach”. Ja natomiast uwielbiam wykonywania przedmiotów użytkowych, mających zastosowanie w życiu codziennym. Wiem, że system podlewający zioła nie jest niczym nowym i skomplikowanym, jednakże wbrew pozorom dla człowieka nie mającego wiele wspólnego z programowaniem i elektroniką, może być kłopotliwe. Tym bardziej, że informacje ułatwiające złożenie takiego zestawu są rozproszone w sieci i nie znalazłem jeszcze dobrego tutorial -a po polsku. Dlatego postaram się opisać to jak najdokładniej, aby ktoś taki jak ja mógł to zrozumieć Projekt na początku miał kilka założeń: Znalezienie doniczki, która będzie dobrze wyglądała (nie zostanie skazana na banicję przez innego mieszkańca) Doniczka musi mieć zbiorniki na wodę na tyle duże, żebym nie musiał martwić się podlewaniem ziół w kuchni, które umierały mi bardzo szybko – albo za mało wody albo odwrotnie. System podlewania ma być indywidualny dla każdego rodzaju z ziół i działać raz lub dwa dziennie. Wszystko musi być najtańsze jak się da. Projekt musi dobrze wyglądać. Znalezienie odpowiedniej doniczki, która zmieści się na szafce (i będzie dobrze wyglądać) okazał się niemożliwy do zrealizowania. Nic takiego na rynku nie ma, dlatego też musiałem zrobić ją sam. Najkorzystniejszym cenowo materiałem okazało się PCV o grubości 3 mm. Występuje w kolorze białym i czarnym, są sklepy internetowe gdzie możemy zamówić już przycięte formatki. Poniżej pokazuję projekt doniczki i rozpisane wielkości formatek. Formatki z PCV potrzebne do wykonania doniczki ze zbiornikiem wody (wymiary w mm, grubość 3 mm): 183 x 200 mm – 2 szt 400 x 180 mm – 2 szt 400 x 200 mm – 1 szt 392 x 120 mm – 3 szt Zdjęcia i projekt: Elementy kleimy najpierw kropelką/super glue lub innym klejem kontaktowym. Później uszczelniamy połączenia poprzez nakładanie kleju do rur PCV (z atestem dla instalacji wodnej) za pomocą strzykawki. Po prostu nabieramy klej i grubą warstwę wciskamy w szczeliny. Klej schnie 24h, a każdy z elementów trzeba zabezpieczyć oddzielnie, co więcej nie ma możliwości aby zrobić to już po złożeniu doniczki – nie będziemy mieć dostępu do niektórych krawędzi. Dlatego uszczelniać klejem do PCV należy etapami. Na końcu warto zrobić test szczelności, w moim przypadku robiłem 3 poprawki. Również warto przed wklejeniem tylnej ściany doniczki zamontować do niej pompki wody oraz wyprowadzić okablowanie na zewnątrz. W moim przypadku po prostu wywierciłem dziurę, którą uszczelniłem klejem do PCV. Pompki mogą być dowolne, pracujące z odpowiednim napięciem dla naszego źródła zasilania (u mnie 5V) Ponieważ doniczka z PCV nie spełnia przynajmniej dwóch punktów z założeń projektu. Musiałem wykombinować osłonkę, która będzie wodoodporna i umożliwi dolewanie wody od góry pojemnika. Padło na hexagonalną sklejkę, akurat najdroższy z elementów tego projektu. Formatki, osłonka drewniana (wymiary w mm, grubość 15 mm): 220 x 215 – 2 szt 415 x 215 – 1 szt 415 x 40 – 1 szt 415 x 190 – 1 szt 50 x 415 – 1 szt 35 x 415 – 1 szt Wszystko jest połączone na konfirmaty bo tak mi pasowało wizualnie. Można zastosować też wkręty lub po prostu ją skleić na kołki. Elementy elektroniczne: Wemos D1 mini (lub inna płytka oparta na ESP8266, np. NodeMCU) Czujnik wilgotności gleby Przekaźnik z logiką 3,3V Moduł z zasilaniem 5v i 3,3V Pompki akwarystyczne zasilane z 5V Przetwornik ADC - ADS1115 Tylna ściana doniczki specjalnie ma niepełne plecy, aby łatwo było zamontować całą elektronikę. Do sterowania wykorzystałem D1 Mini oparty na ESP8266 ze względu na wbudowane wifi. Ponieważ wykorzystuje 3 sztuki czujników wilgotności gleby, niezbędny był przetwornik ADS1115, który może odczytywać sygnał ADC dla czterech urządzeń. To ma znaczenie bo D1 Mini mógłby obsługiwać tylko jeden z nich, więc musiałbym w projekcie wykorzystać aż 4 takie urządzenia. Dodatkowo wprowadziłem zewnętrzny układ zasilania (pompki nie dawały rady przy natężeniu prądu z D1) oraz przekaźniki uruchamiające pompki w zależności od wilgotności. Sterowanie oparłem na gotowym rozwiązaniu ESP Easy z którego korzystam już przy innych czujnikach i które trochę już znam. Tak jak pisałem wcześniej, nie potrafię programować i nie to mnie kręci w tej platformie. Natomiast ESP Easy posiada web UI i ogólnie jest łatwo konfigurowalne bez znajomości języka programowania. W tym projekcie jedyne czego trzeba się nauczyć to reguły, banalnie proste do zrozumienia. Instalacja i konfiguracja jest dobrze opisana na stronie głównej projektu: https://www.letscontrolit.com/wiki/index.php/ESPEasy Tak wygląda strona z urządzeniami w ESP po odpowiedniej konfiguracji. Pierwsze trzy to czujniki wilgotności, kolejne trzy to przełączniki do sterowania przekaźnikami uruchamiającymi pompki. Jest jedna rzecz, której nie znalazłem w żadnym poradniku dotyczącym przygotowania systemu do podlewania kwiatków. Jest to kalibracja czujników. Powinno to być oczywiste i logiczne, jednak dla mnie nie było. Na początku przyjąłem, że wartości maksymalne przetwornika należy przyjąć jako referencyjne i na podstawie tego określać procent wilgotności gleby. Mój błąd był większy niż moje samozadowolenie. Dopiero po ciemnej stornie anglojęzycznego internetu znalazłem informacje o kalibracji i jej sposobie. Należy sprawdzić jego wskazania w suchej ziemi oraz w mokrej. Więc najlepszym sposobem jest wysuszenie odpowiedniej ilości w piekarniku: Zanotowaniu wskazań dla wysuszonej i ostygniętej ziemi ( przesypałem ją do słoika żeby odpowiednio wsadzić czujnik). A później powtórzeniu pomiarów dla ziemi mokrej ale bez stojącej gleby. Później wystarczy wpisać nasze wskazania w webUI ESP Easy, która ma już dwupunktową kalibrację dla przetwornika ADS1115 i wskazaniu naszych pomiarów. Przy pomiarze gdzie była sucha ziemia wpisujemy 0, przy mokrej 100. Dzięki temu mamy od razu podany wynik w procentach. Ostatnim etapem jest napisanie reguł sterujących podlewaniem. W moim przypadku codziennie o 7.00 rano dokonywany jest pomiar wilgotności gleby, jeśli wilgotność jest niższa niż 55% (lub 45% w przypadku jednego z nich) uruchamiana jest pompka na czas kilku sekund. Później odczekuje 30 sek i znowu dokonuje pomiaru. Jeśli wilgotność jest niższa, znowu dostarczana jest woda. Algorytm powtarza się łącznie 3 razy dla każdego z czujników. Wystarcza to spokojnie aby utrzymać odpowiednią wilgotność gleby. Oczywiście można było się pokusić o wprowadzenie zmiennych zależnych od odchylenia od normy. Nawet nie byłoby to bardzo trudne, jednakże całość miała być prosta. Reguły: On Clock#Time=All,07:00 do // codziennie o 7.00 rano wykoanć taskrun,1 // pomiar z zadania nr 1 if [Z1#Analog]<55 // sprawdzić czy jest niższy niż 55 pulse,14,0,20000 // jeśli jest to uruchomić pompkę na 20 sek, jeśli nie nie podejmuje zadań endif timerSet,1,30 // timer uruchominy na 30 sek aby woda mogła wsiąknąć taskrun,1 // pomiar z zadania nr 1 if [Z1#Analog]<55 // itd... pulse,14,0,10000 endif timerSet,2,30 taskrun,1 if [Z1#Analog]<55 pulse,14,0,8000 endif endon taskrun,2 if [Z2#Analog]<55 pulse,13,0,10000 endif timerSet,3,30 taskrun,2 if [Z2#Analog]<55 pulse,13,0,5000 endif timerSet,4,30 taskrun,2 if [Z2#Analog]<55 pulse,13,0,5000 endif endon taskrun,3 if [Z3#Analog]<45 pulse,12,0,10000 endif timerSet,5,30 taskrun,3 if [Z3#Analog]<45 pulse,12,0,5000 endif timerSet,6,30 taskrun,3 if [Z3#Analog]<45 pulse,12,0,5000 endif endon Pewnie kilka rzeczy zrobiłem w sposób trudniejszy niż można było to zrobić albo niezgodnie ze sztuką ale chyba to w tej całej zabawie jest najfajniejszego.

Dziś sprzątałem w szafce i znalazłem starą pozytywkę z kartki urodzinowej, niestety bez głośniczka. Pomyślałem żeby coś z tym zrobić i wyszło to: na tym zdjęciu jest układ scalony pozytywki, a na tym stare słuchawki. Składniki to: Stare słuchawki, pozytywka z kartki urodzinowej, folia alumniowa, gumka recepturka, taśma klejąca. Wszystko działa w słuchawkach słychać "twinkle, twinkle little star".

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

Cześć wszystkim. To mój pierwszy temat na tym forum, Więc przy okazji witam wszystkich Pokaże wam dzisiaj bardzo prosty sposób wykorzystania Raspberry Pi jako konsoli do gier, ja osobiście dzięki temu projektowi zacząłem interesować się elektroniką. O ile sama elektronika nie jest tutaj zbyt zaawansowana to będziemy potrzebować minimalnych umiejętności posługiwania się elektronarzędziami. Zaczynamy. Na początku potrzebujemy Raspberry Pi, Ja osobiście użyłem Raspberry Pi 3 B+ ponieważ pozwala nam zagrać w gry z lepszą grafiką, nawet niektóre tytuły z PSP, jak i w miarę wygodnie korzystać z przeglądarki internetowej. Możecie jednak bez problemu korzystać ze słabszych wersji. Oprogramowanie naszej konsoli znajdziecie w tym linku Retropie możecie też użyć podobnej wersji oferującej praktycznie to samo z tego linku Recalbox Jednak w tym poradniku skupię się na tej pierwszej. Porównanie obu znajdziecie na Youtube. Na temat instalacji samego oprogramowania nie będę pisał bo jest to dość proste i wszystko znajdziecie w tym linku instalacja Powiem jedynie żeby oprócz konsoli nie zapomnieć o możliwości przejścia do Rasbiana, znajdziecie też filmy jak uruchomić dodatkowe konsole i wgrać kodi. O ile tutaj wszystko jest jasne, to trudniejsza częścią jest zabudowa naszej konsoli. Osobiście użyłem Starego automatu który znalazłem na śmietnisku .Nie była to maszyna do gier arcade, a tak zwany jednoręki bandyta, taki jak jak na zdjęciu numer 2 (niestety nie mam zdjęcia jak wyglądał przed). Jednak nie każdy ma do takiego dostęp dlatego wrzucam wymiary mojej, byście mogli wyciąć taką np ze sklejki i poskładać samemu. Jeśli jest to dla was za duży kawał mebla to znajdziecie w na Youtube czy w Google projekty trochę bardziej poręcznych, ale już nie robiących takiego wrażenia. Jako że ja swoją przerabiałem musiałem najpierw zrobić w naklejce na szybie wycięcie na monitor (17cali od starego komputera) i pozbyć się pozostałych w środku resztek starego systemu. Później musimy zamontować przyciski i joystick, są w pełni kompatybilne z konsolą. W moim przypadku zostawiłem 2 działające przyciski Start i Payout z oryginału. Mała rada by przedni panel zrobić otwierany, w przypadku drobnych modyfikacji nie musimy odsuwać szafy od ściany. Trzeba zadbać teraz o audio, u mnie sprawę załatwia mała wieża podłączona pod Raspberry, z oddzielnym wyjściem aux by podłączyć telefon. Otwory na głośniki należy wyciąć w płycie. Nie zapomnij o wnetylatorach i otworach wentylacyjnych. Ponieważ w zamkniętej obudowie potrafi się zrobić gorąco. Ładnie pochowaj, wyprowadź kable i zamontuj raspberry. W przednim panelu zamontowałem atrapę komputera dla wyglądu. Wyprowadź też kable usb by można było podłączyć pady. Ja schowałem je w miejscu na wypłatę monet. W schowku na dole jest szuflada na różne rzeczy jak i mała schładzarka do napojów. Do tego użyłem podobnego zestawu zestawu chłodzącego. Daję radę, ale bardziej do podtrzymywania zimnej temperatury, max udało mi się osiągnąć 13 stopni dlatego polecam użyć większego, trochę droższego zestawu. Schładzarkę należy czymś wyłożyć by zapewnić izolację i w miarę szczelnie zamknąć by nie uciekała nam temperatura. Ja użyłem starej karimaty ale są na pewno lepsze sposoby. Naszą szafę dobrze jest wyłożyć matami głuszącymi dla cichej pracy. Na końcu montujemy Ledy. Projekt można rozwijać o np. licznik monet, panel dotykowy i co tylko przyjdzie do głowy. W przyszłości mam zamiar poprawić lodówkę by działała lepiej, zmienić monitor i dodać trochę więcej przycisków. Mam nadzieję że projekt wam się podoba. Czekam na wasze sprzęty grające.

Idea działania Komora jonizacyjna, to urządzenie składające się z dwóch elektrod do których doprowadzane jest stałe napięcie, co powoduje powstanie pola elektrycznego w jej środku. Gdy kwant promieniowania "uderzy" w atom gazu znajdującego się w komorze, "rozbija" go na dwa jony (dodatni i ujemny), które są przyciągane do elektrod (dodatni do ujemnej i vice versa). Mierząc prąd płynący między dodatnią, a ujemną elektrodą, będzie on proporcjonalny do ilości tych jonów, zaś to będzie proporcjonalne do mierzonego promieniowania. Utrudnieniem jest, że wspomniane prądy są małe, więc wymagają dużego wzmocnienia, co zaś wymaga m.in. starannego filtrowania zasilania, oraz ekranowania, by urządzenie się nie wzbudzało. Poniżej znajduje się schemat blokowy prezentowanego rozwiązania. Część elektroniczna Pierwotnie do wytworzenia napięcia polaryzującego, miałem w planach użycie przetwornicy, jednak okazało się, że napięcie 12V z baterii jest wystarczające. Sygnał z komory trafia do wzmacniacza transimpedancyjnego, w pętli sprzężenia znajdują się szeregowo dwa rezystory o wartości aż 50G. Połączenie owych rezystorów, elektrody komory jonizacyjnej i nóżki wzmacniacza musi być wykonane w powietrzu, by uniknąć pasożytniczych rezystancji. Poniżej znajduje się render w KiCADie, oraz rzeczywiste urządzenie (wiem, fotka jest dość niskiej jakości). Część programistyczna Sygnał analogowy trafia do przetwornika ADC, i jest zbierany przez procek - tu użyłem dość mało popularnego STM8. Zaskoczeniem było dla mnie, że GCC nie obsługuje tych procesorów, zaś poświęcony im SDCC nie umie wycinać z binarki funkcji, które nie są używane! Do komunikacji z hardwarem użyłem stdperiph. Komunikacja z światem zewnętrznym jest jednokierunkowa (urządzenie wysyła pomiary co kilka sekund) za pomocą UARTa. Założeniem było, by urządzenie można było pozostawić same sobie i zdalnie je flashować, czy też pobierać z niego dane. W skrócie, wolę programować leżąc w łóżku, niż garbiąc się nad stołem pełnym kabli :) Zostało to zrealizowane przez dodanie Raspberry Pi, do której podpięty jest zarówno programator, jak i przelotka UART/USB. Soft na procka napisałem w C. Pobieranie danych po stronie maliny jest wykonywane przez skrypt w Pythonie, dane są wizualizowane skryptem w R. Użyłem R, mimo, że Python też ma biblioteki do tworzenia wykresów, bo bardzo podobają mi się wykresy w R. Dokumentacja powstała w LATEXie. Całość dostępna jest na GitHubie - zapraszam do odwiedzenia Wyniki Poniżej znajdują się dane pomiarowe zebrane za pomocą urządzenia.

Sam tytuł mówi prawie wszystko na temat tej zabawki. Co do genezy to od jakiegoś czasu miałem chęć zrobić pada opartego o arduino. Sam pad nie miał służyć do grania a bardziej do sterowania czymś innym. Całość najpierw powstała w SimulIDE Tak jak widać do każdego przycisku są przypisane diody czyli 4 po lewej jedna po prawej (plus led na pinie13) i cztery diody sygnalizacyjne na środku. Po dostarczeniu zasilania diody zaświecają się jedna po drugiej a naszym celem jest wcisnąć odpowiadający danej diodzie przycisk co powoduje jej zgaszenie. Jeśli nie wciśniemy przycisku lub wciśniemy go po czasie zapala się dioda sygnalizacyjna. Możemy pominąć trzy diody a przy czwartej jest game over . W raz z postępem rozgrywki diody gasną i zapalają się coraz szybciej. Cel był taki żeby rozgrywka była możliwie krótka a stopień trudności narastał dając nam odczuć wyraźną zmianę. tak wygląda efekt końcowy. Chciałem kupić diody w kształcie kwadrat 12x12mm ale nie było ich w sklepie więc trudno. Za brakujące elementy zapłaciłem 7 zł resztę miałem. W załączniku przesyłam plik do simulIDE wraz z kodem (całym). Można skompilować i wgrać bezpośrednio z simulIDE i zobaczyć jak to działa w symulacji. void setup() { Serial.begin(9600); DDRC = 15; // A0..A3 Output DDRB = 48; //D8...D11 INPUT, D12 and D13 Output PORTB = 15; //D8...D11 High impedance DDRD = 60; //D2...D5 OUTPUT PORTD = 192; //D6 D7 High impedance PCICR = 5; // enable pin change interrupt bank 0 and 2 PCMSK0 = 15; //enable pin change interrupt PCINT0...PCINT3/D8...D11 PCMSK2 =192; // enable pin change interrupt D6 D7 } void loop() { start(randomPin,ledOn,ledOff); } ISR(PCINT0_vect) { for (byte i=0; i<4; i++) { if (bitRead(PINB,i)==0 && bitRead(PIND,2+i)==1) {score++; bitClear(PORTD, 2+i);} } } ISR(PCINT2_vect) { for (byte i=0; i<2; i++) { if (bitRead(PIND,i+6)==0 && bitRead(PINB,i+4)==1) {score++; bitClear(PORTB,i+4);} } } Polecam zrobienie podglądu w rejestry (jeśli ktoś wcześniej tego nie robił) z poziomu simulIDE naprawdę bardzo przydatna sprawa. I to by było na tyle. A co do samego refleksu to udało mi się zgasić ponad 100 diod. Pin_interruptPad.zip