Skocz do zawartości

Przeszukaj forum

Pokazywanie wyników dla tagów 'elektronika'.

  • Szukaj wg tagów

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

Typ zawartości


Kategorie forum

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

Szukaj wyników w...

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


Data utworzenia

  • Rozpocznij

    Koniec


Ostatnia aktualizacja

  • Rozpocznij

    Koniec


Filtruj po ilości...

Data dołączenia

  • Rozpocznij

    Koniec


Grupa


Znaleziono 29 wyników

  1. Witam. Mam problem z wyposażeniem mojego warsztatu elektronicznego, więc posiadam już zestawy podstaw Arduino poziom 1 oraz dwa poziomy kursu podstaw elektroniki. Mam też zepsutą kartę sieciową. Niestety karta ma dużą ilość elementów SMD, więc proszę żeby ktoś jak może napisał jak je wylutować. Jeśli ktoś ma nie używane części elektroniczne i chciałby się ich pozbyć to z chęcią przyjmę. Proszę też o informację jak tanio a najlepiej za darmo uzyskać części elektroniczne. Z góry dziękuję za odpowiedź, wither
  2. Witajcie! Czekając na paczkę z zestawem do pierwszej części kursu elektroniki, naszła mnie myśl czy wrzucanie na forum swoich spostrzeżeń po każdej lekcji jest dobrym pomysłem. Co prawda w kursach jest zachęcanie do dzielenia się tym na forum, ale nie do końca wiem w jakim konkretnym dziale mógłbym zrobić taką mini recenzję kursu przy okazji pisząc swoje spostrzeżenia i prawdopodobnie zadając pytania jeśli coś będzie dla mnie nie jasne. Gdzie mógłbym coś takiego pisać w jakim dziale się to najlepiej sprawdzi? Czy pytania lepiej pisać gdzieś indziej czy razem z przemyśleniami o kursie? Pozdrawiam Ruby
  3. 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:
  4. Witam Elektroniką zajmuję się od dwóch miesięcy, kiedy to po raz pierwszy zaświeciłem diodą z kursu: FORBOT - podstawy elektroniki - zestaw elementów + kurs ON-LINE. Kurs tak mi się spodobał że ukończyłem go w dwa dni i kupiłem 4 kolejne: FORBOT - podstawy elektroniki 2 - zestaw elementów + kurs ON-LINE, FORBOT - technika cyfrowa - zestaw elementów + kurs ON-LINE, FORBOT - zestaw do nauki lutowania elementów THT oraz FORBOT - zestaw do kursu podstaw Arduino + gadżety i Box (wersja PLUS). Jak tylko je połknąłem pojawił mi się w głowie pomysł na pierwszy projekt którym chciałbym się Wami podzielić. Projekt został oparty o Arduino Pro Mini i jest to Szachownica która gra za mną w szachy Bardzo zależało mi żeby była to tradycyjna duża drewniana szachownica, którą będę się mógł cieszyć przez lata. Całość prezentuje się tak: Najpierw należało zacząć od wykrywania pozycji bierek. Do tego zdecydowałem się (być może nieco pochopnie) na użycie małego ładnego zgrabnego komponentu o nazwie sg-2bc. SG-2BC to nic innego jak dioda IR i fototranzystor w jednej małej (4mm średnicy) ceramicznej obudowie. Ma jednak jedną wadę w zastosowaniu do którego go potrzebowałem - jego fototranzystor jest bardzo wrażliwy na światło słoneczne. Musiałem więc odróżnić jakoś światło słoneczne od światła odbitego diody IR. Zaprojektowałem w tym celu prosty obwód oparty o ne555, który generuje sygnał PWM o częstotliwości około 32kHz i wypełnieniu 33%. Układ ten daje sygnał na diodę IR oraz sprawdza za pomocą 3 komparatorów (dwa lm393 - 2 komparatory na układ) i filtra RC czy odebrał sygnał o odpowiedniej charakterystyce po stronie fototranzystora (czyli na polu stoi bierka). Na wyjściu wystawia stan wysoki jeśli to mu się udało. W ten sposób powstał mój pierwszy w życiu projekt płytki drukowanej Oczywiście zdarzyło mi się wlutować jeden z komparatorów odwrotnie a potem to poprawiać. I tu uwaga do Forbota: w kursie lutowania brakuje informacji i praktyki w wylutowywaniu układów scalonych - na prawdę by się przydało! Jakoś to jednak poszło i efekt był taki: Z racji uśredniania na filtrze RC który jest częścią obwodu czas odpowiedzi na sygnał to 3ms. Oczywiście nie chciałem takiego obwodu powtarzać dla każdego testowanego pola szachownicy, zastosowałem więc multipleksowanie - obwód załączany jest tranzystorami kolejno do wszystkich czujników, co jak łatwo policzyć daje <200ms na zeskanowanie stanu szachownicy (uwzględniając szybkość I2C i czasy przełączania w praktyce są to 3 pełne skany na sekundę - wystarcza). Skoro już umiałem testować pojedyncze pole, nadszedł czas na zaprojektowanie płytek do samej szachownicy. Tu użyłem ekspandera wyprowadzeń MCP23017 oraz demultiplexera MC74HC154. Skoro i tak nie mogę testować więcej niż jednego pola na raz, demultiplexer zapewnił mi rozsądne wykorzystanie wyprowadzeń MCP23017 - dzięki temu wystarczył jeden ekspander na 16 pól szachownicy (każde ma jedną diodę świecącą i jeden czujnik wspomniany wczesniej SG-2BC). Prototyp tego rozwiązania wyglądał następująco: Projekt płytki pokrywającej 16 pól (przed ułożeniem ścieżek, wizualizacja ze ścieżkami, gotowe płytki): Na całą szachownicę użyłem 4 takich samych równolegle połączonych płytek: Czemu nie dwóch - po jednej na stronę szachownicy? Z tej oto przyczyny że darmowa licencja DIPTrace pozwala na 300 padów na płytkę Po polutowaniu i zmontowaniu całości otrzymałem taki oto efekt: W montażu najtrudniejsze okazało się jednoczesne wcelowanie 32-ma okrągłymi elementami w wywiercone otwory: Aby tego dokonać ułatwić płytki umieściłem na mosiężnych dystansach 1cm przyklejonych klejem na ciepło do wewnętrznej strony szachownicy, przewlokłem diody i czujniki przez płytkę, zakleilłem otwory w szachownicy od jej frontowej strony przezroczystą taśmą klejącą i manewrowałem cierpliwie elementami oraz samą płytkę aż wskoczyły na swoje miejsce. Dopiero wtedy płytkę przykręcałem a nóżki elementów lutowałem. Pozostało to oprogramować Jako że programuję od ponad 20 lat i do tej pory nie pisałem jeszcze enginu szachów, postanowiłem nie używać „cudzego” i napisać własny. Biorąc pod uwagę ograniczenia Arduino było to naprawdę fajnym wyzwaniem i zajęło mi około 2 tygodnie. Zaimplementowałem mini-max z przycinaniem alpha-beta i iteracyjnym pogłębianiem. Engine nie alokuje żadnej pamięci dynamicznie, a ze stosu bierze nie więcej niż 600B, co uważam za swój sukces. Ostatecznie wygrywa nie tylko ze mną (żaden ze mnie wybitny szachista), ale i z Stockfishem na poziomie 3, z czego jestem dumny Ostateczny kształt szachownicy w działaniu wygląda tak: Szachownica rozpoznaje ustawienie początkowe i sygnalizuje to spiralnym zaświeceniem wszystkich diod. Grę rozpoczynamy białymi lub sygnalizujemy szachownicy ze chcemy grać czarnymi poprzez podniesienie na chwile czarnego króla. Po podniesieniu bierki gracza, szachownica pokazuje dostępne pola na które figura ta może się ruszyć umieszczonymi w ich rogach diodami (mój niespełna 6-cio letni syn bardzo to docenia). Ruch szachownicy również sygnalizowany jest diodami i szachownica czeka aż zostanie wykonany. Dodatkowe dwie małe diody na krawędzi szachownicy sygnalizują po czyjej stronie jest ruch. Zdjęcie dwóch własnych bierek z szachownicy jest dla niej gestem do zapisania stanu gry do EEPROMU. Po tym można ją wyłączyć i wznowić grę np. za tydzień. Po włączeniu szachownica czyta stan z EEPROMU i czeka aż jeden ze stanów (początkowy lub zapisany) zostanie ustawiony na szachownicy. Jeśli nie była w tym czasie składana, a bierki nie były ściągane - grę można kontynuować natychmiast po włączeniu. Szachownicę można normalnie składać, niestety nie mieszczą się już do niej szachy Mam nadzieje mój pierwszy projekt się Wam spodobał, ja jeszcze wciąż się nim cieszę jak dziecko. Chciałbym przy tym podziękować Forbotowi za naprawdę świetne kursy które nie tylko dały mi niezbędną w realizacji wiedzę, ale też zainspirowały to zrobienia tejże zabawki. Pozdrawiam, Okjak
  5. Cześć, modyfikuje właśnie swój zasilacz warsztatowy (atx), próbując dodać do niego możliwość regulacji napięcia, chce to zrobić za pośrednictwem stabilizatora LM317 i borykam się z problemem spalających się potencjometrów To jest schemat używanej przeze mnie aplikacji: Potencjometr ma 1/8W i spala się (wewnętrznie, bez dymu) przy oporze równym zeru, trochę mi szkoda elementów na metodę prób i błędów (zwłaszcza, że w szafie już ich za dużo nie mam), dlatego chciałbym trochę podpytać o wiedze teoretyczną. Zastanawiam się czy kondensator C3 tutaj nie wadzi? Czy nie próbuje się rozładować przez potencjometr kiedy ten ma 0Ω? Ponieważ wtedy na anodzie tego kondensatora napięcie wynosi 0V? Myślałem też nad wprowadzeniem takiego zabezpieczenia do układu, aby potencjometr zatrzymywał się maksymalnie na 10Ω, ale nie jestem pewien czy to by zadziałało tak jak bym chciał, a mówię o czymś takim: A może wystarczy tylko użyć elementu większej mocy?
  6. Cześć! Jako początkujący elektronik nie zdawałem sobie początkowo zbytnio sprawy z szkodliwości wdychania dymu powstającego przy lutowaniu, dlatego przy pracy nie używałem dotychczas żadnego wentylatora, siłą rzeczy opary leciały wprost na mnie i po kilku godzinach w takich warunkach najczęściej wieczorem pojawiały się np. bóle głowy, kaszel, już nie myśląc o tym jakie skutki przyniosło by to przyszłości. Postanowiłem coś w tym kierunku w końcu zrobić i wzorując się na układzie AVT3215 chciałbym przedstawić bardzo prosty w założeniu jak i konstrukcji projekt odciągacza oparów, który można zbudować tanim kosztem: Sterowanie wentylatorem odbywa się poprzez regulowany stabilizator LM317, kręcąc potencjometrem zmieniamy napięcie dostarczane do wentylatora, możemy dzięki temu płynnie zmniejszyć lub zwiększyć jego obroty, chociaż szczerze powiedziawszy ta funkcja jest mała przydatna w moim odczuciu, ponieważ i tak zawsze lutuje przy największych obrotach. Całość jest zasilana z zewnętrznego zasilacza 12V 0,5A, który zapożyczyłem od lampki biurkowej. Dużym atutem tego układu jest to, że można go zbudować dosłownie z części znalezionych w szafie, osobiście musiałem dokupić gniazdo DC oraz stabilizator na co w sumie wydałem +/- 10 zł (gdzie kupiłem sobie od razu kilka sztuk na zapas) Wentylator nie jest przymocowany na stałe, dzięki temu można go złożyć i łatwiej przechować np. w szufladzie. Jako podstawkę wykorzystałem tą, która została mi z kursu arduino, akurat pasowały mi otwory, także uznałem, że dam jej 'drugie życie' Lista potrzebnych komponentów: gniazdo DC płytka uniwersalna 2x diody LED 2x rezystory 1k 2x rezystory 330Ω 2x kondensatory elektrolityczne 220uF 1x kondensator elektrolityczny 47uF 2x kondensatory ceramiczne 100nF potencjometr 5K regulowany stabilizator LM317 złącze ARK wentylator na 12V Schemat ideowy: Działanie w praktyce:
  7. Cześć, Jestem tu nowy i zielony w te klocki dlatego proszę Was o pomoc i wyrozumiałość. Słyszałem że jak podepnę Arduino Uno złączem DC to z jednego pinu Digital mogę uzyskać do 30mA ale jeśli zasilę Arduino przez Vin będę mógł budować układy które wymagają większego natężenia. Moje pytanie brzmi jak podłączyć Arduino przez Vin? Czy potrzebuje jakiś dodatkowych elementów ? Posiadam zasilacz 12v 1A czy taki zasilacz się nada do zasilania przez DC i Vin ? Jestem na etapie kupowania czujników, przewodów, diod led itp więc chciałbym od razu kupić wszytko za jednym razem jeżeli okazało by się że coś potrzebuje do tego zasilania Arduino. A.. i jeszcze jedno, kupuje też tranzystory, kondensatory- zestawy (różnych po trochu) i znalazłem też zestaw rezystorów (wiem że ludzie używają je jak coś budują z Arduino albo jak się porostu uczą- nie wiem jeszcze co to robi i jest to dla mnie dziwne, ale z czasem to ogarnę ) czy możecie zobaczyć czy ten zestaw na wasze oko jest spoko jak na początek ? link do tego zestawu --> https://abc-rc.pl/product-pol-12082-Zestaw-tranzystorow-bipolarnych-NPN-PNP-200szt.html czy może taki --> https://allegro.pl/oferta/zestaw-180-sztuk-tranzystorow-bipolarnych-pnp-npn-8591976509 Dzięki za odp.
  8. Po dzisiejszej zabawie z lutownicą wlutowałem z płytki parę komponentów: chyba parę rezystorów, jakiś dziwny mały rezystor oraz coś co wygląda jak cewka i dioda prostownicza. Moglibyście mi pomóc identyfikacją ich?
  9. Słowem wstępu, wyobraźmy sobie że jesteśmy na słonecznej, piaszczystej plaży wzdłuż której rosną wysokie, bogate w orzechy kokosowe palmy. Pod jedną z nich stoi lokalny, doświadczony, zbieracz kokosów, u którego mamy zamiar nauczyć się tego ciężkiego rzemiosła. Jako zaledwie początkujący adepci tej trudnej sztuki, nie mamy jednak zielonego pojęcia jak się do tego zabrać. Dlatego nasz nowy mentor musi nam wytłumaczyć co i jak powinniśmy zrobić. Może on nam wytłumaczyć wszystko krok po kroku. Opisać dokładne pozycje naszych kończyn, prędkość z jaką będziemy się wspinać i sposób odbierania kokosu. Oczywiście opisanie nam tego na tyle dokładnie, byśmy mogli bezbłędnie przystąpić do pracy wymagałoby dużo czasu i energii. Zamiast tego, może pokazać nam osobiście jak to zrobić i dać nam przystąpić do pracy. W krótkim i bogatym w informacje czasie, będziemy wiedzieli jak przystąpić do pracy. Ten wpis brał udział konkursie na najlepszy artykuł o elektronice lub programowaniu. Sprawdź wyniki oraz listę wszystkich prac » Partnerem tej edycji konkursu (marzec 2020) był popularny producent obwodów drukowanych, firma PCBWay. Po tym ciut przydługawym wstępie, którym starałem się nakreślić pewien problem, możemy przystąpić do właściwego omówienia tematu. Istnieje wiele metod programowania robotów przemysłowych (manipulatorów). Wykonują one precyzyjne prace, wymagające wielu skomplikowanych ruchów. Jednak poza nimi, roboty mogą też wykonywać mniej skomplikowane ruchy np. podczas zmiany pozycji lub przełączenia między poszczególnymi pracami. O ile do wykonania operacji precyzyjnych niezbędny jest szczegółowo opracowany program, o tyle podczas ruchów mniej skomplikowanych czas programowania można ukrócić do metod Online Programming. Krótki film przedstawiający podział metod programowania Metody te pozwalają operatorowi manualnie lub za pomocą odpowiedniego kontrolera ustawić poszczególne pozycje robota, które zostaną przez niego zapamiętane w czasie bieżącym oraz odtworzone w postaci pożądanego przez nas ruchu. Programowanie robota spawalniczego przy pomocy metody teach-in Programowanie robota Festo BionicCobot przy pomocy metody play-back Programowanie play-back opiera się na sczytywaniu przez oprogramowanie pozycji robota, zapisywanie ich oraz odtwarzanie poprzez bezpośrednie poruszanie jego konstrukcją. Aby było to możliwe, każdy stopień swobody robota musi posiadać sensor umożliwiający określenie jego dokładnej pozycji. Oprócz tego napęd robota musi działać w wyrachowany i delikatny sposób, aby konstrukcja była jednocześnie sztywna i można było nią poruszać ręcznie. Programowanie teach-in z kolei polega na ustawieniu robota w ustalonych pozycjach za pomocą odpowiedniego kontrolera, za pomocą którego te pozycje zostaną zapisane a następnie odtworzone. Odtwarzanie kolejno zapisanych pozycji daje w efekcie płynny, ciągły ruch maszyny. Wyżej wspomniane metody omówimy na realnym przykładzie. Za pomocą kontrolera będziemy mogli stosować na prostym manipulatorze metodę teach-in. Robot napędzany jest serwami modelarskimi oraz wykonany w technice druku 3D. Serwa posiadają wbudowane potencjometry sczytujące pozycje kątowe wałów, jednak bez ingerencji w ich budowę ciężko będzie korzystać z tych potencjometrów do określania pozycji robota. Dlatego manualne ustawienie pozycji manipulatora metodą play-back wypada z puli naszych opcji. Poza tym istniałaby duża szansa na uszkodzenie stosowanych w robocie serw. Zamiast tego, posłużymy się kontrolerem, który będzie kinetycznym modelem naszego manipulatora i pozwoli także zahaczyć o ideę play-back. Ramię manipulatora wydrukowane w 3D, poniżej link do źródła https://www.thingiverse.com/thing:1015238 Kontroler odpowiada kinematyce prezentowanego robota i ma umieszczone potencjometry w każdym jego punkcie swobody. Poruszając nim, możemy ustalić rzeczywistą pozycję naszego manipulatora. Budując r obota o mniej skomplikowanej budowie, możemy pozostać przy samych potencjometrach np. zamontowanych na płytce stykowej. Jednak w przypadku tego robota korzystanie z tego rozwiązania byłoby trudniejsze i mniej wygodne w użytku. Model kinematyczny manipulatora Znając już budowę kontrolera oraz manipulatora, należy je już tylko do siebie podłączyć. Oprócz tego do układu dodane zostaną przyciski nagrywania oraz odtwarzania ruchu. Elektronika opiera się o mikrokontroler atmega328p. Zasilanie układu odbywa się z sieci napięciem 230 V. W obudowie znajduje się układ prostujący, przetwornica step-down zasilająca serwomechanizmy oraz płytka arduino ze wspomnianym wcześniej mikrokontrolerem. Dla wygody wszystkie piny arduino zostały wyprowadzone na zewnątrz obudowy. Cały schemat przedstawianej konstrukcji znajduje się poniżej: Schemat układu Lista opisanych komponentów: -S1 – włącznik główny, -S2 – przycisk nagrywania, -S3 – przycisk odtwarzania, -D1 – mostek Graetza 400V ; 4A, -D2 – zielona dioda LED, -C1 – kondensator elektrolityczny 1000µF ; 50V, -C2 – kondensator elektrolityczny 220µF ; 25V, -C3 – kondensator elektrolityczny 22µF ; 25V, -C4 – kondensator ceramiczny 100nF, -C5 – kondensator ceramiczny 22pF, -C6 – kondensator ceramiczny 22pF, -C7 – kondensator ceramiczny 100nF, -R1 – rezystor 150 Ω, -R2, R3, R4 – rezystor 1 kΩ, -POT 1, POT 2, POT 3, POT 4, - 10 kΩ, -Stabilizator napięcia LM7805, -Przetwornica step-down LM2596, -X1 – kwarc 16 MHz, Połączenie układu Po podłączeniu całej elektroniki można przystąpić do omówienia kodu arduino. Program ten został już zaopatrzony w bogatą ilość komentarzy, które na pewno pomogą osobom dopiero rozpoczynającym swoją przygodę z arduino: //biblioteka umożliwiająca nie tylko sterowanie serwami, ale także ich prędkością //nie jest ona koniecznością, wystarczy standardowa biblioteka <servo.h> oraz pozbycie się zmiennej 'predkosc' z koduć #include <VarSpeedServo.h> //definiujemy serwa używane w robocie: VarSpeedServo servo1; VarSpeedServo servo2; VarSpeedServo servo3; VarSpeedServo servo4; //definiujemy przyciski nagrywania i odtwarzania: const int przycisk_A = 2; const int przycisk_B = 3; //definiujemy wartości dla wciśniętych przycisków nagrywania i odtwarzania: int przycisk_A_ON = 0; boolean przycisk_B_ON = false; //definiujemy potencjometry: const int potencjometr1 = A0; const int potencjometr2 = A1; const int potencjometr3 = A2; const int potencjometr4 = A3; //definiujemy zmienne służące do odczytu wartości napięć z potencjometrów: int potencjometr_1_odczyt; int potencjometr_2_odczyt; int potencjometr_3_odczyt; int potencjometr_4_odczyt; //definiujemy zmienne służące do zapisu wartości kąta położenia poszczególnego serwa: int potencjometr_1_zapis; int potencjometr_2_zapis; int potencjometr_3_zapis; int potencjometr_4_zapis; //definiujemy tablice zapisujące położenie serwa: int Pozycja_serva1[]={1,1,1,1,1}; int Pozycja_serva2[]={1,1,1,1,1}; int Pozycja_serva3[]={1,1,1,1,1}; int Pozycja_serva4[]={1,1,1,1,1}; void setup() { //definiujemy piny do których podłączone są serwa: servo1.attach(6); servo2.attach(9); servo3.attach(10); servo4.attach(11); //definiujemy piny wejściowe przycisków nagrywania i odtwarzania: pinMode(przycisk_A, INPUT_PULLUP); pinMode(przycisk_B, INPUT_PULLUP); //inicjalizacja portu szeregowego do podglądu działania programu: Serial.begin(9600); } void loop() { //ustalanie prędkości serw w zakresie od 0 do 180: int predkosc = 90; //zapis formuły umieszczania odczytanej z potencjometrów wartości do tabeli: potencjometr_1_odczyt = analogRead(potencjometr1); potencjometr_1_zapis = map (potencjometr_1_odczyt, 0, 1023, 20, 175); potencjometr_2_odczyt = analogRead(potencjometr2); potencjometr_2_zapis = map (potencjometr_2_odczyt, 0, 1023, 5, 175); potencjometr_3_odczyt = analogRead(potencjometr3); potencjometr_3_zapis = map (potencjometr_3_odczyt, 0, 1023, 5, 175); potencjometr_4_odczyt = analogRead(potencjometr4); potencjometr_4_zapis = map (potencjometr_4_odczyt, 0, 1023, 20, 160); //serwa przyjmują pozycje zapisane w tabelach: servo1.write(potencjometr_1_zapis, predkosc); servo2.write(potencjometr_2_zapis, predkosc); servo3.write(potencjometr_3_zapis, predkosc); servo4.write(potencjometr_4_zapis, predkosc); //przy kolejnym wciśnięciu przycisku nagrywania tabela każdego serwa zostanie //nadpisana, zapamiętując obecną pozycję serwa: if(digitalRead(przycisk_A) == HIGH) { przycisk_A_ON++; switch(przycisk_A_ON) { case 1: Pozycja_serva1[0] = potencjometr_1_zapis; Pozycja_serva2[0] = potencjometr_2_zapis; Pozycja_serva3[0] = potencjometr_3_zapis; Pozycja_serva4[0] = potencjometr_4_zapis; Serial.println("Pozycja pierwsza zapisana"); break; case 2: Pozycja_serva1[1] = potencjometr_1_zapis; Pozycja_serva2[1] = potencjometr_2_zapis; Pozycja_serva3[1] = potencjometr_3_zapis; Pozycja_serva4[1] = potencjometr_4_zapis; Serial.println("Pozycja druga zapisana"); break; case 3: Pozycja_serva1[2] = potencjometr_1_zapis; Pozycja_serva2[2] = potencjometr_2_zapis; Pozycja_serva3[2] = potencjometr_3_zapis; Pozycja_serva4[2] = potencjometr_4_zapis; Serial.println("Pozycja trzecia zapisana"); break; case 4: Pozycja_serva1[3] = potencjometr_1_zapis; Pozycja_serva2[3] = potencjometr_2_zapis; Pozycja_serva3[3] = potencjometr_3_zapis; Pozycja_serva4[3] = potencjometr_4_zapis; Serial.println("Pozycja czwarta zapisana"); break; case 5: Pozycja_serva1[4] = potencjometr_1_zapis; Pozycja_serva2[4] = potencjometr_2_zapis; Pozycja_serva3[4] = potencjometr_3_zapis; Pozycja_serva4[4] = potencjometr_4_zapis; Serial.println("Pozycja piąta zapisana"); break; } } //po wciśnięciu przycisku odtwarzania serwa będą przyjmować zapisane w tabelach pozycje //z odczekaniem 1.5 sekund w każdej pozycji: if(digitalRead(przycisk_B) == HIGH) { przycisk_B_ON = true; } if(przycisk_B_ON) { for(int i=0; i<5; i++) { servo1.write(Pozycja_serva1[i],predkosc); servo2.write(Pozycja_serva2[i],predkosc); servo3.write(Pozycja_serva3[i],predkosc); servo4.write(Pozycja_serva4[i],predkosc); Serial.println("Odtwórz ruchy"); delay(1500); } } //czas opóźnienia działania programu, od jego nastawy zależy płynnośc pracy robota: delay(200); } Program działa w sposób następujący: Po uruchomieniu programu, za pomocą modelu kinematycznego będzie można bezpośrednio kontrolować ruch manipulatora, Jeżeli wciśniemy przycisk S2 (nagrywania), obecnie ustawiona pozycja robota zostanie zapisana, Program umożliwia zapisanie pięciu różnych pozycji, Jeżeli wybierzemy przycisk S3 (odtwarzania), robot zacznie odtwarzać wybrane przez nas pozycje w nieskończonej pętli, Aby wytyczyć nową sekwencję ruchów należy zresetować układ. Efekt działania powyższego kodu przedstawia się następująco: Dzięki funkcji monitora szeregowego w arduino można obserwować pracę manipulatora bezpośrednio: Przepraszam wszystkich czytelników za jakość nagrań wideo, niestety ograniczały mnie możliwości sprzętowe. Przedstawiony wyżej kod jest prosty a przykład nieskomplikowany, jednak doskonale pokazuje podstawy działania tej metody. Nie mniej jednak mam nadzieję, że artykuł okaże się dla wielu osób pomocny. Oprócz tego zostawiam jeszcze bibliotekę <VarSpeedServo> VarSpeedServo-master.zip Powodzenia we wszelkich przyszłych projektach i przygodach z elektroniką!
  10. Dzień dobry zakupiłem zestaw do kursu elektroniki I i zatrzymałem się na prawie Ohma. Zrobiłem, a przynajmniej tak mi się wydaje, dokładnie to samo co jest na tym zdjęciu , a mimo to wynik jest 0,17mA. Jakkolwiek nie próbowałem mierzyć cały czas mam 0,17mA. Nie wiem co mogę zrobić, olać to i iść dalej?
  11. 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.
  12. Cześć! Postawiłem sobie zbudować własny zasilacz do warsztatu, taką niezbyt skomplikowaną wersje zasilaną 12V DC. Generalnie przy schemacie jak i doborze elementów wzorowałem się już gotowym urządzeniu z zestawu AVT, także z tym powinno być wszystko ok. Stwierdziłem, że nie kupie gotowca, tylko dla wprawy spróbuję zbudować go własnoręcznie, od zera. Stworzyłem już projekt samej płytki i byłbym wdzięczny gdyby ktoś ocenił, czy połączenia ścieżkami są w porządku, w sensie czy nie są za blisko siebie, czy nie są za małe itd. Tak dla jasności, szara przestrzeń ma symbolizować radiator Pozdrawiam!
  13. Witam! Mógłby mi ktoś wytłumaczyć jak są ustawione wyprowadzenia w gniazdach DC, w sensie gdzie minus, gdzie plus itd. (w rzeczywistości i na schemacie)? Aż głupio się pytać o takie rzeczy, ale nic nie mogłem znaleźć w internecie na ten temat. Z góry dziękuje i Pozdrawiam!
  14. Witam! Na samym wstępie się może przedstawię, jako że jestem nowy na tym forum. Mam na imię Mikołaj, 17 lat, uczę się jako technik mechatronik i elektroniką samą w sobie zajmuję się dopiero niespełna rok. ============================================================================================ Chciałbym przedstawić swoje pierwszą własną konstrukcje - Miarę ultradźwiękową "Gacek". Podobne urządzenie było przedstawiane w kursach arduino i na bazie jego działania oparłem swoje. Całość chciałem wykonać na podstawie tego co do tej pory się nauczyłem oraz nie mam jeszcze za dużo doświadczenia w robieniu tego typu projektów, dlatego niektóre rozwiązania mogą się wydawać amatorskie. Gabarytowo wyszło mi trochę za wielkie przez to, że kupiłem za dużą obudowę. Wymiary(cm): 11 x 15 x 7 Lista komponentów: Arduino UNO Wyświetlacz lcd 16x2 Czujnik ultradźwiękowy US-015 2x Potencjometry 3x Przyciski Przełącznik Żółty 3mm led Rezystor 1000Ω Obudowa uniwersalna Płytka uniwersalna Wtyk DC do arduino Koszyk na baterię 9V Trochę kabli Większość potrzebnych rzeczy już miałem, musiałem tylko dokupić parę drobiazgów oraz obudowę, w sumie wydałem +/- 70 zł. Całość mieści się w granicach 150-200 zł. Schemat połączeniowy: Kod programu: /////////////////////////////////////////// // Miara ultradźwękowa - "Gacek" // /////////////////////////////////////////// #include <LiquidCrystal.h> // Dodanie biblioteki LiquidCrystal lcd(2, 3, 4, 5, 6, 7); // Piny wyświetlacza #define przycisk1 13 #define przycisk2 12 #define przycisk3 11 #define trig 8 #define echo 9 #define led 10 //////////////////////////////////////////////////////// byte prostokat[8] = { B11111, B11111, B11111, B11111, B11111, B11111, B11111, B11111 }; // Wypełniony prostokąt byte strzalkaP[8] = { B01000, B01100, B01110, B01111, B01110, B01100, B01000, B00000 }; // Strzałka w prawo byte strzalkaL[8] = { B00010, B00110, B01110, B11110, B01110, B00110, B00010, B00000 }; // Strzałka w lewo //////////////////////////////////////////////////////// Dodanie tablic specjalnych znaków boolean kolejnosc1 = false; boolean kolejnosc2 = false; boolean start = false; int tryb = 1; int opcja = 0; int jednostka = 0; int odcinek = 0; //////////////////////////////////////////////////////// Zmienne globalne void setup() { //////////////////////////////////////////////////////// lcd.begin(16, 2); // rozmiar ekranu lcd lcd.createChar(0, prostokat); lcd.createChar(1, strzalkaP); lcd.createChar(2, strzalkaL); // Stworzenie specjalnych znaków na bazie powyższych tablic lcd.clear(); ///////////////////////////////// pinMode(przycisk1, INPUT_PULLUP); pinMode(przycisk2, INPUT_PULLUP); pinMode(przycisk3, INPUT_PULLUP); pinMode(trig, OUTPUT); pinMode(echo, INPUT); pinMode(led, OUTPUT); digitalWrite(led, LOW); //////////////////////////////////////////////////////// Ustawienie pinów lcd.setCursor(0, 0); lcd.write(byte(0)); // wyświetlenie specjalnego znaku (prostokąta) lcd.setCursor(3, 0); lcd.print("GACEK v1.0"); lcd.setCursor(15, 0); lcd.write(byte(0)); ///////////////////////////////////// Ekran powitalny } void loop() { //////////////////////////////////////////////////////// float wynik; int pomiar1, pomiar2, pole, odczyt; pole = 0; odczyt = 0; pomiar1 = 0; pomiar2 = 0; //////////////////////////////////////////////////////// Zmienne lokalne if (start == false) { // Warunek odpowiadający za jednorazowe wyświetlenie delay(3000); // ekranu startowego przy włączeniu urządzenia start = true; } if (tryb < 1) { // Warunki zmniejszące przedział zmiennej do 1-3 tryb = 1; } if (tryb > 3) { tryb = 3; } lcd.clear(); // Czyszczenie ekranu przy powrocie do menu //////////////////////////////////////////////////////// switch (tryb) { case 1: lcd.setCursor(2, 0); lcd.print("Tryb"); lcd.setCursor(2, 1); lcd.print("Miary"); lcd.setCursor(15, 0); lcd.write(byte(1)); lcd.setCursor(15, 1); lcd.print("B"); break; case 2: lcd.setCursor(0, 0); lcd.write(byte(2)); lcd.setCursor(0, 1); lcd.print("A"); lcd.setCursor(2, 0); lcd.print("Tryb"); lcd.setCursor(2, 1); lcd.print("Pomiaru Pola"); lcd.setCursor(15, 0); lcd.write(byte(1)); lcd.setCursor(15, 1); lcd.print("B"); break; case 3: lcd.setCursor(0, 0); lcd.write(byte(2)); lcd.setCursor(0, 1); lcd.print("A"); lcd.setCursor(2, 0); lcd.print("Tryb"); lcd.setCursor(2, 1); lcd.print("Nastawny"); break; } //////////////////////////////////////////////////////// Wybór trybu while (digitalRead(przycisk1) == HIGH && digitalRead(przycisk2) == HIGH && digitalRead(przycisk3) == HIGH) {} // Czekania na wybór operatora //////////////////////////////////////////////////////// if (digitalRead(przycisk1) == LOW) { // Przesuń w lewo tryb = tryb - 1; while (digitalRead(przycisk1) == LOW) {} } if (digitalRead(przycisk2) == LOW) { // Przesuń w prawo tryb = tryb + 1; while (digitalRead(przycisk2) == LOW) {} } if (digitalRead(przycisk3) == LOW) { // Wybierz ten tryb opcja = tryb; while (digitalRead(przycisk3) == LOW) {} } ////////////////////////////////////////////////////////// Sterowanie w menu if (opcja > 0) { // Jeśli wybrano tryb... lcd.clear(); //////////////////////////////////////////////////////// while (opcja == 1) { // Tryb miary //////////////////////////////////////////////////////// pomiar(); if (wynik == pomiar()) { }else{ if (wynik == pomiar() * 0.39) { }else{ if (wynik == pomiar() / 100.0) { }else{ lcd.clear(); } } } //////////////////////////////////////////////////////// Filtr przełączania liczb na ekranie lcd.setCursor(0, 0); lcd.write(byte(0)); lcd.setCursor(1, 0); lcd.print("Pomiar"); lcd.setCursor(7, 0); lcd.write(byte(0)); lcd.setCursor(9, 0); lcd.print("="); //////////////////////////////////////////////////////// switch (jednostka) { case 0: lcd.setCursor(0, 1); lcd.write(byte(0)); lcd.setCursor(1, 1); lcd.print("cm"); lcd.setCursor(3, 1); lcd.write(byte(0)); wynik = pomiar(); lcd.setCursor(11, 0); lcd.print(wynik, 0); break; case 2: lcd.setCursor(0, 1); lcd.write(byte(0)); lcd.setCursor(1, 1); lcd.print("cal"); lcd.setCursor(4, 1); lcd.write(byte(0)); wynik = pomiar(); wynik = wynik * 0.39; lcd.setCursor(12, 0); lcd.print(wynik, 2); break; case 1: lcd.setCursor(0, 1); lcd.write(byte(0)); lcd.setCursor(1, 1); lcd.print("m"); lcd.setCursor(2, 1); lcd.write(byte(0)); wynik = pomiar(); wynik = wynik / 100.0; lcd.setCursor(11, 0); lcd.print(wynik, 2); break; } //////////////////////////////////////////////////////// Wybór jednostki delay(50); if (digitalRead(przycisk3) == LOW) { jednostka = jednostka + 1; lcd.clear(); if (jednostka > 2) { jednostka = 0; } while (digitalRead(przycisk3) == LOW) {} } if (digitalRead(przycisk1) == LOW) { // wyjście do menu opcja = 0; while (digitalRead(przycisk1) == LOW) {} } } //////////////////////////////////////////////////////// Sterowanie wyborem jednostki oraz przycisk wyjścia do menu //////////////////////////////////////////////////////// while (opcja == 2) { // Tryb pomiaru pola //////////////////////////////////////////////////////// lcd.setCursor(0, 0); lcd.write(byte(0)); lcd.setCursor(1, 0); lcd.print("Pomiar1"); lcd.setCursor(8, 0); lcd.write(byte(0)); lcd.setCursor(10, 0); lcd.print("="); lcd.setCursor(0, 1); lcd.write(byte(0)); lcd.setCursor(1, 1); lcd.print("Pomiar2"); lcd.setCursor(8, 1); lcd.write(byte(0)); lcd.setCursor(10, 1); lcd.print("="); //////////////////////////////////////////////////////// if (digitalRead(przycisk1) == LOW) { opcja = 0; pomiar1 = 0; pomiar2 = 0; kolejnosc1 = false; kolejnosc2 = false; pole = 0; while (digitalRead(przycisk1) == LOW) {} } //////////////////////////////////////////////////////// Wyjście do menu if (digitalRead(przycisk2) == LOW) { lcd.clear(); pomiar1 = 0; pomiar2 = 0; kolejnosc1 = false; kolejnosc2 = false; while (digitalRead(przycisk2) == LOW) {} } //////////////////////////////////////////////////////// Reset if (digitalRead(przycisk3) == LOW) { pomiar(); if(pomiar() == 0){ pomiar(); } if(pole > 0){ pole = 0; } while (kolejnosc1 == true && kolejnosc2 == true) { lcd.clear(); pole = pomiar1 * pomiar2; lcd.setCursor(0, 0); lcd.write(byte(0)); lcd.setCursor(1, 0); lcd.print("Pole"); lcd.setCursor(5, 0); lcd.write(byte(0)); lcd.setCursor(7, 0); lcd.print("="); lcd.setCursor(9, 0); lcd.print(pole); lcd.setCursor(0, 1); lcd.print("B"); lcd.setCursor(2, 1); lcd.print("-"); lcd.setCursor(4, 1); lcd.print("RESET"); while (digitalRead(przycisk2) == HIGH && digitalRead(przycisk1) == HIGH) {} if (digitalRead(przycisk1) == LOW) { opcja = 0; pomiar1 = 0; pomiar2 = 0; kolejnosc1 = false; kolejnosc2 = false; pole = 0; lcd.clear(); break; } if (digitalRead(przycisk2) == LOW) { kolejnosc1 = false; kolejnosc2 = false; pomiar1 = 0; pomiar2 = 0; lcd.clear(); break; } } if (kolejnosc1 == true && kolejnosc2 == false && pole == 0) { pomiar2 = pomiar(); lcd.setCursor(12, 1); lcd.print(pomiar2); kolejnosc2 = true; } if (kolejnosc1 == false && pole == 0) { pomiar1 = pomiar(); lcd.setCursor(12, 0); lcd.print(pomiar1); kolejnosc1 = true; } while(digitalRead(przycisk3) == LOW){} while (digitalRead(przycisk1) == HIGH && digitalRead(przycisk2) == HIGH && digitalRead(przycisk3) == HIGH && pole == 0) {} } } ////////////////////////////////////////////////////////// // Opcja nr.2 - Pomiar pola ////////////////////////////////////////////////////////////////// while (opcja == 3) { lcd.setCursor(0, 0); lcd.write(byte(0)); lcd.setCursor(1, 0); lcd.print("Odcinek"); lcd.setCursor(8, 0); lcd.write(byte(0)); lcd.setCursor(10, 0); lcd.print("="); lcd.setCursor(12, 0); lcd.print(odcinek); ///////////////////////////////////////////////// while (digitalRead(przycisk2) == LOW) { odcinek = odcinek + 1; delay(100); lcd.setCursor(12, 0); lcd.print(odcinek); } if (digitalRead(przycisk1) == LOW) { opcja = 0; odcinek = 0; while (digitalRead(przycisk1) == LOW) {} } while (digitalRead(przycisk3) == LOW) { odcinek = odcinek - 1; if(odcinek < 0){ odcinek = 0; } delay(100); lcd.setCursor(12, 0); lcd.print(odcinek); if(odcinek - 1 == 8 || odcinek - 1 == 98 || odcinek - 1 == 998){ // Łatka naprawaiająca mieszanie się liczb na wyświetlaczu lcd.clear(); lcd.setCursor(0, 0); lcd.write(byte(0)); lcd.setCursor(1, 0); lcd.print("Odcinek"); lcd.setCursor(8, 0); lcd.write(byte(0)); lcd.setCursor(10, 0); lcd.print("="); } } if (odcinek > 0) { pomiar(); if (odczyt >= 10 && pomiar() < odczyt || odczyt >= 100 && pomiar() < odczyt){ lcd.clear(); } lcd.setCursor(0, 1); lcd.write(byte(0)); lcd.setCursor(1, 1); lcd.print("Obecnie"); lcd.setCursor(8, 1); lcd.write(byte(0)); lcd.setCursor(10, 1); lcd.print("="); if(pomiar() < 1000){ odczyt = pomiar(); lcd.setCursor(12, 1); lcd.print(odczyt); } if(odcinek == odczyt) { digitalWrite(led, HIGH); }else{ digitalWrite(led, LOW); } if (digitalRead(przycisk1) == LOW) { digitalWrite(led, LOW); lcd.clear(); odcinek = 0; opcja = 0; odczyt = 0; while (digitalRead(przycisk1) == LOW) {} } delay(25); } } ////////////////////////////////////////////////////////////////// // Tryb nr. 3 - Pomiar wymiarowy } } //////////////////////////////////////////////////////// int pomiar() { long czas, dystans; digitalWrite(trig, LOW); delayMicroseconds(2); digitalWrite(trig, HIGH); delayMicroseconds(10); digitalWrite(trig, LOW); czas = pulseIn(echo, HIGH); dystans = czas / 58; dystans = dystans + 11; delay(100); Serial.println(dystans); return dystans; //////////////////////////////////////////////////////// // Program wykonujący pomiary czujnikiem } Po uruchomieniu urządzenia wyświetla się menu wyboru trybu, którym steruje się przyciskami A oraz B, natomiast guzik C zatwierdza wybór. Potencjometry regulują jasność oraz kontrast wyświetlacza lcd. Miara ma trzy tryby pomiarów: Pierwszy z nich to mierzenie ciągłe z dodatkową opcją przeskalowania jednostki na metry oraz cale (w planie miałem także zamiar dodać milimetry, ale pomiary wychodziły bardzo niedokładnie, dlatego zrezygnowałem z tego pomysłu). Jak widać na nagraniu pomiar czasami może się różnić o 1 cm niż w rzeczywistości, może to być wina arduino, które przeskalowuje wynik z czujnika na centymetry przy czym przybliża go do pełnych liczb. Punkt zero znajduje się z tyłu obudowy, a co za tym idzie pomiar nie może być mniejszy niż 14 cm. Aby wrócić do menu wyboru wystarczy przytrzymać przycisk A. Następna opcja to pomiar pola, polega ona na zebraniu dwóch pomiarów, aby następnie na ich podstawie wyliczyć pole. Przy tworzeniu tego trybu napotkałem kilka błędów typu jakieś wyskakujące znikąd zera czy też liczby, ale ostatecznie doszedłem to tego, że problem leży w odświeżaniu wyświetlacza i załatałem ten problem. Ostatnim, trzecim trybem jest miara nastawna, działa ona w ten sposób, że najpierw ustala się na jakiej odległości ma znajdować się mierzony obiekt, po czym manewrujemy tym przedmiotem aż do momentu gdy pomiar czujnika będzie się zgadzał z wcześniej ustaloną wartością o czym poinformuje dioda. W planach mam jeszcze wprowadzenie nowych trybów oraz oczywiście zminiaturyzowania całego urządzenia. Pozdrawiam!
  15. Cześć. Chciałbym się z Wami podzielić projektem, który jak pewnie większość takich projektów – wziął się z pewnej potrzeby. Otóż mój znajomy, który miesza w domku jednorodzinnym ma garaż. Garaż jest otwierany elektrycznie za pomocą m.in. pilota zdalnego sterowania. Często zdarzało się, że w nocy brama garażowa była otwarta bo np. ktoś z domowników miał pilot do garażu w tylnej kieszeni spodni i… po prostu usiadł. Poprosił mnie o pomoc. Chciał po prostu wiedzieć kiedy brama jest otwarta a kiedy zamknięta. Ustaliliśmy, że do sygnalizacji wystarczy prosta dioda LED. Urządzenie pokazujące stan otwarcia bramy miało być w dwóch miejscach w domu: w sypialni i w salonie obok telewizora. Oczywiście nie ma mowy o ciągnięciu jakichś kabli po nowo wybudowanym domu, więc w grę wchodzi tylko komunikacja bezprzewodowa. Zasada działania miała być prosta: Kiedy brama garażowa jest otwarta na odbiornikach widać świecącą diodę w kolorze czerwonym. Gdy jest zamknięta – w zielonym. Układ składał się więc z nadajnika, czyli modułu z kontraktonem, który „wykrywał” czy drzwi są zamknięte, oraz dwóch modułów z diodą RGB, która – w zależności od położenia drzwi – świeciła w odpowiednim kolorze. Nadajnik zbudowany jest z mikrokontrolera – klona ATMEGi, tzn. LGT8F328D (miałem po prostu kilka sztuk), czujnika zamknięcia bramy – czyli kontraktonu i nadajnika radiowego. Wybór mikrokontrolera podyktowany był tym, że w zasadzie sam program jest banalnie prosty i jakoś specjalnie nie wymagający sprzętowo, ale potrzebowałem mikrokontrolera z interfejsem SPI (o czym piszę poniżej) i… taki mikrokontroler po prostu miałem na stanie. Na początku przeprowadziłem testy z prostym nadajnikiem 433MHz, niestety zasięg nie był imponujący i po prostu nie sprawdził się. Nadajnik był zasilany napięciem 5V, mogłem próbować oczywiście zasilić go większym napięciem (12V), ale wtedy układ nieco by się skomplikował… Postawiłem więc na moduł nRF24l01 (stąd potrzeba SPI). Całość zasilana przez zasilacz zewnętrzny 5V. nRF24l01 pracuje na napięciu 3,3V, więc oczywiście w module nie zabrakło LDO, dokładnie AMS1117 3.3V. Mikrokontroler oczywiście też pracuje na napięciu 3.3V, częstotliwość taktowania to 8MHz. Odbiorniki działają na tym samym mikrokontrolerze, również wyposażone są oczywiście w moduł radiowy nRF24L01, oraz diodę LED RGB. Zasada działania układu jest prosta. Nadajnik sprawdza wejście cyfrowe z kontraktonem. Jeżeli jest „1” – tzn. drzwi są zamknięte – wysyła komunikat o treści „ON” co 1 sekundę. Jeżeli są otwarte – wysyła „OFF” co jedną sekundę. Odbiorniki natomiast czekają na komunikat. Jeżeli dostają „ON” - dioda świeci na zielono, jeżeli „OFF” – na czerwono. Jeżeli w ciągu 5 sekund nie dostaną żadnego komunikatu – dioda świeci na niebiesko. W ten oto sposób wiadomo, że nadajnik działa (lub też nie). Prototyp na pro mini służący do testów: Jeżeli chodzi o montaż w garażu, to na bramie garażowej przykleiłem magnes, na naprzeciwko magnesu umieściłem kontrakton, czyli urządzenie mechaniczne, które w polu magnetycznym magnesu zwiera dwa przewody ze sobą. Jako obudowa nadajnika i odbiorników służy zwykła puszka elektryczna. Dla układu nadajnika i odbiorników zaprojektowałem płytkę PCB (tę samą dla nadajnika i odbiorników) i zamówiłem w jednej z chińskich firm zajmujących się produkcją płytek PCB. Po otrzymaniu płytek przylutowałem niezbędne komponenty, podłączyłem i… działa już parę miesięcy. Nadajnik: Odbiornik: Gotowy projekt: Kilka uwag do projektu płytki Schemat: Jest tam kilka elementów nadmiarowych, nie używanych, ale zaprojektowanych „na zapas”. Po pierwsze jest miejsce na rezonator kwarcowy (wraz z odpowiednimi kondensatorami)– nie przylutowany. Mikrokontroler korzysta z wbudowanego oscylatora. Działa stabilnie, więc po co przepłacać Można także zauważyć, że i nadajnik i odbiornik mają wlutowaną diodę LED RGB. Bezpośrednio na nadajniku też widać czy brama jest otwarta, czy zamknięta. W projekcie na wyjściach mikrokontrolera PD5, PD6 i PB1 są tranzystory BC639 – to w wypadku, gdyby okazało się, że dioda RGB LED jest zbyt ciemna – wtedy można podłączyć np. taką diodę 3W, wiadomo – bardziej wymagająca prądowo. Jest jeszcze wyprowadzenie kilku dodatkowych wyjść mikrokontrolera, bo… było miejsce, a płytka może się jeszcze przydać do czegoś innego. Na płytce PCB widać, że nawet przycisku RESET nie przylutowałem… ale jest na niego miejsce. Zamiast LGT8F328D można przylutować na płytkę ATMEGA328P (zwierając odpowiednie wyprowadzone piny mikrokontrolera) lub ATMEGA328PB – tutaj akurat zgodne elektrycznie z LGT. Kodu źródłowego nie publikuję, bo to zaledwie kilka linijek. Kod pisany w środowisku Arduino. Projekt zdecydowanie bardziej hardware’owy. Prosty i skuteczny.
  16. Od dawna interesowały mnie pomiary warunków meteorologicznych w mojej miejscowości, pierwsza stacja meteorologiczna, którą zbudowałem około roku 2010, wykonana była na mikrokontrolerze Atmega32. Do komunikacji z światem wykorzystywała moduł LAN Wiznet 7010a. Stacja ta była oprogramowana w języku BASCOM. Projekt który chcę zaprezentować dzisiaj działa już od roku 2018 i został oprogramowany w środowisku Arduino. Stacja została podzielona na 2 moduły, pierwszy pomiarowy oparty jest na klonie Arduino Nano oraz drugi odbiorczy którego sercem jest ESP8266 NodeMCU v3, służy on również do wyświetlania aktualnych pomiarów na wyświetlaczu LED dot matrix o wymiarach 8x56 punktów. Na pracach stolarskich się nie będziemy skupiać napiszę tylko że klatka meteorologiczna została wykonana z drewna sosnowego i umieszczona na wysokości 2 m. Moduł Pomiarowy Czujniki jakie zastosowałem to dwie sztuki DS18B20 pierwszy zajmuje się pomiarem temperatury przy gruncie na wysokości 5cm, drugi pełni rolę zapasowego czujnika temperatury na wypadek uszkodzenia się głównego czujnika BME280. Do pomiaru prędkości wiatru wykorzystuję wiatromierz firmy Maplin na jeden obrót wiatromierza przypadają 2 impulsy z kontaktronu który jest w nim zamontowany, producent dostarcza również odpowiedni wzór według którego można obliczyć rpm oraz prędkość wiatru w km/h. Dane mierzone przez wiatromierz możemy podzielić na dwie wartości, pierwsza to chwilowa prędkość, druga prędkość w porywach, aby uśrednić wartości mierzone program zlicza impulsy z 5s a następnie dokonuje odpowiednich obliczeń. Zebrane dane przesyłane są do drugiego urządzenia poprzez moduły radiowe które działają na częstotliwości 433,92 MHz. W tym celu zastosowana została biblioteka RCSwitch. Każda mierzona wartość jest wysyłana jako osobna transmisja. aby rozróżnić pomiary z konkretnych czujników mierzona wartość mnożona jest przez 100 a następnie dodawana jest liczba 100 000 dla pierwszego czujnika, 200 000 dla drugiego itd. Przykład kodu który realizuje tę funkcję poniżej: // temperatura sensor BME codetosend = temp * 100 + (1 * 100000); mySwitch.send(codetosend, 24); // wilgotnosc sensor BME codetosend = hum * 100 + (2 * 100000); mySwitch.send(codetosend, 24); Moduł Wewnętrzny Obudowa, która idealnie nadawała się do implementacji wewnętrznego modułu pochodzi z tunera IPTV Motorola VIP1910-9. Przedni panel został wykonany z ciemnego półprzepuszczalnego plastiku który idealnie nadaje się do umieszczenia w nim wyświetlacza. Sercem urządzenia jest układ ESP8266. "Moduł wewnętrzny" został również wyposażony w czujnik temperatury oraz wilgotności DHT22, dodatkowo w celu prezentacji zmierzonych wartości dołączone zostało 7 szt. modułów wyświetlacza LED dot matrix z układem MAX7219. Do obsługi tej matrycy zastosowałem bibliotekę Max72xxPanel.h która współpracuje z biblioteką Adafruit_GFX.h w ten sposób nie byłem zmuszony implementować do rozwiązania własnych czcionek. Matryca ta oprócz modułowej konstrukcji umożliwia również sterowaniem jasnością podświetlania, w tym celu aby uprzyjemnić użytkowanie w porach nocnych odbiornik został wyposażony w fotorezystor dzięki któremu potrafi określić natężenie oświetlenia otoczenia i odpowiednie ustawienie podświetlenia. Na wyświetlaczu w pierwszej kolejności wyświetlam aktualną godzinę oraz temperaturę wewnątrz pomieszczenia oraz wilgotność, po około jednej minucie wyświetlane są informacje odczytane z stacji meteo czyli temperatura wilgotność i ciśnienie, postanowiłem nie wyświetlać tutaj informacji dotyczących prędkości wiatru oraz temperatury przy gruncie. Decyzję tą podjąłem na podstawie użytkowania innego podobnego rozwiązania, akurat jak chcemy odczytać godzinę to wyświetlane są inne informacje. Dodatkowo w godzinach nocnych, które zostały ustawione w sztywnych ramach czasowych między 21:00 a 7:00 informacje odczytane z stacji meteo zostały okrojone tylko do temperatury. W projekcie zostały zastosowane 2 rodzaje animacji pierwsza z nich, przesuwa tekst z prawej strony wyświetlacza na lewą, z możliwością zatrzymania w interesujących momentach. Drugi rodzaj to pionowa animacja. Mikrokontroler również poprzez protokół NTP i bibliotekę time.h pobiera aktualną godzinę i datę. Za odbiór danych z pierwszego układu odpowiedzialny jest moduł radiowy którego obsługą tak jak w poprzednim module zajmuje się biblioteka RCswitch. Poniżej fragment programu który demonstruje w jaki sposób odbierane i dekodowane są dane: rc = mySwitch.getReceivedValue(); // czujnik temperatury powietrza BME280 if (abs(rc)>=50000&& abs(rc)<150000) { rc=(rc-100000)/100; if (rc > -50 and rc < 60) { temp1 = rc; Serial.print("Czujnik BME280 - temperatura: \t"); Serial.println(rc); matrix.drawPixel(55,0,1); matrix.write(); } } // czujnik wilgotności BME280 if (abs(rc)>=150000 && abs(rc)<250000) { rc=(rc-200000)/100; if (rc > 5 and rc <= 100) { hum = rc; Serial.print("Czujnik BME280 - wilgotnowsc: \t"); Serial.println(rc); matrix.drawPixel(55,1,1); matrix.write(); } } Dzięki zastosowaniu zewnętrznej anteny oraz odbiornika opartego na superheterodynie, zasięg w otwartym terenie to około 250 m. Po odebraniu danych z pierwszego układu poprzez moduł radiowy następuje przekazanie ich do serwera z systemem Domoticz. Domoticz to bardzo lekki system automatyki domowej, który pozwala monitorować i konfigurować różne urządzenia, przełączniki, czujniki takie jak temperatura, opady deszczu, wiatr, promieniowanie ultrafioletowe (UV), zużycie energii elektrycznej, zużycie gazu, zużycie wody i wiele więcej. Wykresy dostępne są również na stronie www http://meteo.palowice.net Poniżej film z działania odbiornika, smużenie animacji które występuje na filmiku ludzie oko nie rejestruje. Gdyby kogoś interesował kod to również zamieszczam: meteo.zip
  17. Cześć, Ostatnio zaciekawił mnie temat związany z minikomputerem Raspberry Pi. Możecie mi polecić jakieś książki dla początkujących godne uwagi? Ewentualnie jakieś kursy/ poradniki z przykładowymi projektami?
  18. Witam mam problem z kompilacją gdyż wyskakuje mi taki błąd i nie wiem czemu tak się dzieje. Pomoże ktoś ? #include <Ultrasonic.h> // definicje dla HCSR04 #define TRIGGER_PIN 7 #define ECHO_PIN 4 Ultrasonic ultrasonic(TRIGGER_PIN, ECHO_PIN); // silnik lewy const int kierunekLewy=12; const int hamulecLewy=9; const int predkoscLewy=3; //silnik prawy const int kierunekPrawy=13; const int hamulecPrawy=8; const int predkoscPrawy=11; //ustawienia void setup() { Serial.begin(9600); pinMode(kierunekLewy,OUTPUT); pinMode(kierunekPrawy,OUTPUT); pinMode(hamulecLewy,OUTPUT); pinMode(hamulecPrawy,OUTPUT); pinMode(predkoscLewy,OUTPUT); pinMode(predkoscPrawy,OUTPUT); } //petla glowna programu void loop() { float cmMsec; long microsec = ultrasonic.timing(); cmMsec = ultrasonic.convert(microsec, Ultrasonic::CM); doPrzodu(); delay(50); if (cmMsec<=30) { doTylu(); delay(500); } } void doPrzodu() { analogWrite(predkoscLewy,100); analogWrite(predkoscPrawy,105); //Lewy do przodu digitalWrite(kierunekLewy,HIGH); digitalWrite(hamulecLewy,LOW); //Prawy do przodu digitalWrite(kierunekPrawy,HIGH); digitalWrite(hamulecPrawy,LOW); } void doTylu() { analogWrite(predkoscLewy,200); analogWrite(predkoscPrawy,0); //Lewy do przodu digitalWrite(kierunekLewy,LOW); digitalWrite(hamulecLewy,LOW); //Prawy stop digitalWrite(kierunekPrawy,HIGH); digitalWrite(hamulecPrawy,HIGH); }
  19. Witam, Wykonuje projekt, którego założeniem jest uruchamianie diody przy pomocy przycisku pojemnościowego typu TTP223B. Chciałbym, aby dioda gasła po około 30 sekundach, do tego celu zastosowałem układ czasowy NE555. Do testów użyłem przycisku monostabilnego i wszystko działało prawidłowo, jednak używając przycisku pojemnościowego dioda pali się, kiedy przycisk nie jest dotykany, natomiast gaśnie z opóźnieniem, kiedy przycisk zostanie dotknięty. Sygnał na wyjściu po dotknięciu jest wysoki, sprawdzałem na diodzie. Moje pytanie jest następujące, czy wiecie jak sprawić, żeby to działało na zasadzie ON/OFF czyli po naciśnięciu przycisku pojemnościowego dioda uruchamia się na 30 sekund (kwestie doboru opornika i kondensatora znam) po czym gaśnie. Przy ponowny wciśnięciu natomiast stan zmienia się na niski. Jest to mój pierwszy projekt bez użycia mikrokontrolera i czuje się strasznie zagubiony ..
  20. Cześć! Zakładam, że skoro czytasz ten wpis to zapewne interesuje Ciebie elektronika/robotyka/majsterkowanie i zastanawiasz się jak skonstruować swojego robota. A może szukasz inspiracji? Motywacji do dalszego działania? Jeżeli odpowiedź brzmi tak, to zapraszam Ciebie do przeczytania mojego wpisu. Traktuje on o moim pierwszym elektronicznym projekcie - linefollowerze o wdzięcznym imieniu Ianush88. Wpis podzieliłem na poszczególne fragmenty tak, abyś łatwo trafił do sekcji które Ciebie interesują najbardziej. Początek każdego z nich będzie oznaczony pogrubionym tekstem. To tyle jeżeli chodzi o wstęp, zapraszam do lektury! Ważna uwaga: Ze względu na fakt, że jest to mój pierwszy projekt i ma dla mnie głównie charakter edukacyjny w wielu przypadkach zdecydowałem się na wybór prostych rozwiązań, które o wiele łatwiej zaimplementować i ewentualnie naprawić. Nad optymalizacją konstrukcji postanowiłem się skupić w ewentualnej przyszłej ewolucji tego projektu. Konstrukcja & mechanika Ianush88 to klasyczny przedstawiciel rodziny linefollower - składa się z dwóch płytek PCB połączonych ze sobą dwoma kątownikami z tworzywa sztucznego. Do głównej (większej) płytki PCB przymocowane są silniki prądu stałego Pololu HP z przekładnią 10:1 - standardowy wybór zdecydowanej większości konstruktorów linefollowerów ze względu na optymalny balans między maksymalną prędkością obrotową (3000 obr/min) a generowanym momentem (0,22 kg*cm). Do wałów silników zamocowane są koła Solarbotics RW2 - wybrałem je głównie ze względu na ich bezproblemową dostępność i łatwość w połączeniu z całą konstrukcją. Muszę przyznać, że odpowiednio wyczyszczone generują całkiem sporo przyczepności. Niestety nie mam porównania z oponami mini-z czy odlewanymi z silikonu, ale jestem z nich zadowolony. Przednia płytka PCB zawierająca czujniki linii opiera się na podłożu przy pomocy dwóch tranzystorów THT w obudowie TO-92. Ich nóżki przylutowałem do płytki a obudowy przetarłem lekko papierem ściernym tak, by swoimi krawędziami nie zahaczały o nierówności trasy. Elektronika Robot zasilany jest z akumulatora 2S 7.4V (korzystam z trzech o różnych wartościach pojemności: 150mAh, 250mAh i 800mAh). Napięcie z akumulatora jest stabilizowane i obniżane do 5V przez stabilizator napięcia LM1117. Mózgiem całej konstrukcji jest Atmega16A - wybrana przeze mnie ze względu na moją znajomość tej rodziny mikrokontrolerów. Taktowana jest przez sygnał z kwarcu o częstotliwości 16MHz. Posiada istotne ze względu na projekt peryferia: ośmiokanałowy, 10 - bitowy przetwornik ADC, UART do komunikacji z zewnętrznym urządzeniem oraz trzy timery. Każdy z ośmiu kanałów przetwornika został wykorzystany do pomiarów napięcia z kolektorów czujników odbiciowych KTIR0711S. Znajdują się one na wysuniętej z przodu płytce PCB, umiejscowione symetrycznie po obu stronach. Sygnały między płytkami przekazywane są przy pomocy taśmy i złącz FFC. Timer 1 wykorzystałem do generowania dwóch sygnałów PWM sterujących prędkością każdego z silników. Doprowadzone są one do sterownika silników TB6612FNG, który jest układem z dwoma klasycznymi mostkami H. Do wejść UARTu mikrokontrolera poprowadzone są ścieżki ze złącza goldpin, do którego podłączony jest moduł bluetooth HC-05. Wraz z UART wykorzystuje go do komunikacji między robotem a telefonem lub komputerem. Na głównej płytce znajduje się także 6 - pinowe złącze ISP służące do programowania mikrokontrolera oraz przycisk który można dowolnie zaprogramować (ja używam go do ręcznego startowania/zatrzymywania robota). Dodatkowo na głównej płytce PCB umieściłem 8 LEDów prezentujących wskazania poszczególnych czujników odbiciowych. Całość została zaprojektowana przy użyciu oprogramowania Altium Designer. Obie płytki PCB są jednostronne i rozstawienie wszystkich elementów wraz z ich połączeniem było ogromnym wyzwaniem, co jednak udało się osiągnąć (ostatecznie skorzystałem z tylko jednej "przelotki"). Na płytce z czujnikami widoczne są przeróbki w postaci dolutowanych przewodów - jest to efekt złego zaprojektowania płytki i pośpiechu w przygotowaniach do zawodów... Program Do sterowania robotem zaimplementowałem regulator PD. Wartością zadaną jest w tym przypadku położenie czarnej linii względem robota, a sterowaniem wartości wypełnienia sygnału PWM dla poszczególnych silników. Uchyb wyliczany jest na podstawie pomiarów napięcia na kolektorach poszczególnych czujników odbiciowych. Gdy napięcie przekroczy pewną wartość graniczną, przy której uznajemy, że pod czujnikiem znajduje się już czarna linia do uchybu dodawana jest konkretna wartość błędu. Każdy czujnik ma przypisaną swoją "wagę" i przy każdej iteracji regulatora wyznaczany jest średni błąd, a następnie uchyb i sterowanie. Do regulatora PD dorzuciłem pewne wyjątki, które obsługują takie przypadki jak np. zgubienie linii tak, by robot potrafił na nią z powrotem trafić. Mogę tutaj polecić artykuł "Algorytm linefollowera w C – dla początkujących i nie tylko" , który całkiem dobrze opisuje jak zaimplementować regulator pd do robota typu linefollower. Do zmiany ustawień robota, w tym nastaw regulatora przygotowałem aplikację przy pomocy narzędzia MIT App Inventor. Dobrze jego obsługę prezentuje artykuł: "Tworzenie aplikacji Android". Do komunikacji przygotowałem swój własny protokół o określonej ramce danych. Wprowadzanie danych i naciśnięcie odpowiedniego przycisku powoduje wysłanie wiadomości o konkretnej budowie i zawartości do mikrokontrolera, który ją przetwarza i zmienia wartości odpowiednich parametrów. Przemyślenia Już zaprojektowałem nową płytkę czujników, tym razem mam nadzieję że poprawnie. Teraz będą ustawione zdecydowanie bliżej siebie, ponieważ chcę żeby robot szybciej mógł reagować na zmiany trasy. W przyszłym projekcie na pewno skorzystam już z płytek dwustronnych, co pozwoli na gęstsze upakowanie elektroniki, a co za tym idzie zmniejszenie gabarytów i masy robota. A mniejsza masa = lepsze osiągi. Plus brak problemów z połączeniem wszystkich komponentów. Dostrzegłem także, że kluczową sprawą jest przyczepność mechaniczna - nawet gdy silniki mają duży moment i prędkość obrotową bez przyczepności nie przekłada się to na lepsze wyniki. Dlatego planuję w przyszłości wykorzystanie opon mini-z lub odlewanych z silikonu. Na pewno dojdzie także wykorzystanie enkoderów do pomiarów prędkości obrotowych silników i implementacja regualtorów PID dla silników. Pozwoli to na płynną regulację prędkościami i w konsekwencji mniejszą ilością uślizgów kół. Myślę także o ulepszeniu regulatora dla całego robota, sprawdzeniu kilku ciekawych rozwiązań. To już koniec! Jeżeli masz pytania lub zainteresował Ciebie jakiś temat poruszony w tym wpisie to daj mi znać w komentarzu! Powodzenia przy tworzeniu nowych konstrukcji!
  21. Witam mam na imię Wiktor. Interesuje się elektroniką tworzę różne projekty. Jak każdemu majsterkowiczowi który zajmuje się elektroniką przydał by się zasilacz. Dlatego dzisiaj opiszę jak zrobiłem zasilacz 12v o dużym prądzie. opisywałem już mój projekt zasilacza regulowanego o prądzie do 3a. Ale czasami się zdarza przy różnych większych projektach że przydał by się zasilacz o większym prądzie niż 3a dlatego zbudowałem zasilacz o prądzie do 16,5a. Podczas przeglądanie internetu za zasilaczem stwierdziłem że zasilacz montażowy jest najtańszym zasilaczem o dużym prądzie. Dodatkowo taki zasilacz posiada moc 200W oraz zabezpieczenia: Przeciw zwarciowe Przeciw przeciążeniowe Przeciw wzrostowi napięcia 1. DODATKOWE ZAŁOŻENIA Miał posiadać dodatkowe zabezpieczenia, miał mieć dwa kanały zdalnie sterowane oraz wentylator działający po przekroczeniu zadanej temperatury. 2. BUDOWA Tak wygląda zasilacz z przodu. Ponieważ zasilacz budowałem kilka miesięcy temu nie mam zdjęć z jego budowy. Widok zasilacza z tyłu po prawej są bezpieczniki na dwóch kanałach oraz wentylator. Zasilacz montażowy przymocowałem do płaskownika dzięki czemu zasilacz nie jest bezpośrednio przymocowany do obudowy oraz przykręciłem zestawem śrubek do obudowy. Do regulacji wentylatora zastosowałem termostat który po przekroczeniu 40 oC włącza wentylator na pełną moc. Zastosowałem termostat ponieważ był znacznie tańszy od regulatora obrotów wentylatora. Ustawiłem też alarm na 50 oC. Jednym problemem było że przy małym obciążeniu zasilacz osiągał 40 oC problem usunąłem stosując regulator napięcia, który 12v zmniejsza na 3,3v. Dodatkowo oprócz wentylatora świecącego na niebiesko zamontowałem pasek ledów, który podświetla otwory wentylacyjne oczywiście w tedy gdy termostat się załączy. Czujnik temperatury przykleiłem klejem na gorąco do zasilacza i dodatkowo przykręciłem go metalową blaszką. Oczywiście dołączam też schemat całego zasilacza. 3. OGÓLNE PARAMETRY Napięcie 12v Prąd 16,5a Dwa kanały zdalnie sterowane Regulator obrotów wentylatora sterowany termostatem Zabezpieczenie przeciw zwarciowe zabezpieczenie przeciw przeciążeniowe Zabezpieczenie przeciw wzrostowi napięcia Dziękuję za przeczytanie mojego projektu i proszę o komentarz
  22. Długo zastanawiałem się czy pokazać ten projekt lecz postanowiłem, że jednak napiszę. Moim projektem jest zegar oparty o lampę VFD IW-18. Projekt wykonałem około 5 lat temu kiedy myślałem, że ATMega644P jest niesamowitym potworem. Zegar stał tylko około rok na biurku i od tamtego czasu leży w szafie. Jest to jeden z moich pierwszych w życiu “większych” projektów. Stare polskie przysłowie mówi “Każdy elektronik zrobi kiedyś zegarek” więc zrobiłem i ja. Projektu tego nigdy nie opublikowałem - po pierwszej publikacji wzmacniacza akustycznego na Elektrodzie zostałem tak zjechany, że przestałem się chwalić swoimi postępami publicznie. Teraz jestem starszy, mądrzejszy i na luzie podchodzę do krytyki w Internecie Projekt nie jest mistrzostwem estetyki ani też nie jest pozbawiony błędów. Hardware - komponenty Niestety nie ostał mi się żaden schemat czy zarys projektu, ale na szczęście elementy mają opisy. Oczywiście najważniejszą rzeczą, która mnie przekonała do budowy zegara jest próżniowa lampa fluorescencyjna IW-18. Kiedy ją zobaczyłem pierwszy raz od razu się w niej zakochałem i jak najszybciej kupiłem dwie sztuki u jakiegoś wrocławskiego elektronika. Lampa potrzebuje napięcia minimum 15 V. Przetwornica odpowiedzialna za napięcie podane na lampę to MC34063. Ustawiłem ją na około 30 V. Sercem układu jest wspomniana we wstępie ATMega644P w obudowie DIP. Po kilku latach obcowania z STM32 stwierdzam, że to jest naprawdę wielki kloc. Lampa IW-18 podobnie jak wyświetlacze 7-segmentowe wymaga multipleksowania. Jako, że MCU ma wiele pinów to zrobiłem to w całości na nim. Prądy płynące przez siatkę i segmenty lampy są zbyt duże, aby mogła to obsłużyć “goła” Mega, dlatego zastosowałem układy ULN2803A na portach sterujących wyświetlaniem. No dobra, ale zegar potrzebuje wyświetlać godzinę. Wykorzystałem zewnętrzny zegar RTC PCF8583P. Nie wiem czemu, ale nie wlutowałem gniazda na baterię o.O Oprócz prezentowania daty i godziny warto pokusić się o pomiar kilku parametrów środowiskowych. Postawiłem na temperaturę, wilgotność oraz ciśnienie. Za temperaturę odpowiada szalenie popularny DS18B20. Jako czujnik wilgotności dałem DHT11, a za pomiar ciśnienia odpowiada MPL115A1, który w tamtym czasie był dla mnie nieodpowiedni. Hardware - PCB PCB wykonałem ręcznie przy pomocy termotransferu żelazkowego. Jeszcze nie wiedziałem o patencie z laminarką. Niestety nie doszedłem do takiej wprawy, aby wykonać wszystkie ścieżki bez żadnej wady dlatego wiele z nich poprawione jest drucikiem. Był to też czas w którym zainteresowałem się komponentami SMD(stąd wspomniany wcześniej MPL115A1). Na PCB kilka elementów pasywnych jest w obudowie 1206. Był to też czas eksperymentów z DIY soldermaską wykonywaną farbami do ceramiki. Do dzisiaj mam jeszcze te same buteleczki z różnymi kolorami. Montaż lampy VFD nie jest mojego pomysłu. Kiedyś podpatrzyłem na inne wykonanie i bardzo mi się spodobało. Lampa wlutowana jest w osobną płytkę, a wszystkie piny wyprowadziłem na kątowe złącze goldpin. Obudowa Obudowy nie zrobiłem i było to świadome zagranie. Chciałem, aby cały zegar wyglądał trochę cyberpunkowo(wtedy nie znałem tego określenia). Ma to swój urok, ale niesamowicie przyciąga kurz. Wkręciłem jedynie kołki dystansowe jako nóżki. Software Program na szczęście się uchował i nawet wrzuciłem go jakiś czas temu na GitHub: https://github.com/lamik/IW-18_retro-style_clock Patrząc na niego dzisiaj, to nie jest aż tak źle Najbardziej razi mnie mieszanie języków polskiego i angielskiego. Całość działa w oparciu o timery programowe i jest napisana całkiem nieźle jak tak dzisiaj na to patrzę. Datę i godzinę ustawia się dwoma przyciskami. Pierwszy jest od wyboru menu. Z każdym jego naciśnięciem zegar przechodzi o ustawiania kolejnej zmiennej, która ta w momencie ustawiania szybko miga. Drugi przycisk inkrementuje wybraną daną. Z menu zegar wychodzi sam po upływie kilku sekund. Wcześniej wspomniałem, że MPL115A1 był dla mnie nieodpowiedni. Niestety nie byłem w stanie poznać go od strony programowej. A to wszystko dlatego, że nie potrafiłem go przylutować zwykłą lutownicą Nigdy później do niego nie wróciłem bo na rynku pojawiły się czujniki BMP od Boscha. Błędy Z perspektywy czasu oraz doświadczenia widzę wiele błędów. Niektóre z nich: RTC był szalenie niedokładny. Pamiętam, że wsadziłem zegar do szafy bo potrafił opóźniać się o kilka minut na dzień! Beznadziejna przetwornica wysokiego napięcia. Do MC34063 podchodziłem kilka razy i nigdy nie mogłem się z nią dogadać. To na razie chyba jedyna przetwornica która mnie pokonała. Skoro już o przetwornicy mowa to ustawiłem zdecydowanie na małe napięcie. Zegar jest bardzo słabo widoczny w oświetlonym pomieszczeniu. Grzanie się sekcji zasilania. Liniowy stabilizator 5V plus MOSFET od przetwornicy na jednym radiatorze to solidny grzejnik. Dzisiaj staram się unikać stabilizatorów liniowych. Grzanie się rezystorów na segmentach lampy. Źle je chyba dobrałem Za cienkie ścieżki do termotransferu. Nie wiem czemu, ale zawsze chciałem zrobić PCB podobną do tych profesjonalnych, czyli cienkie i ładne ścieżki. Nigdy to nie wychodziło, a dzisiaj produkcja nawet w Polsce jest tak tania, że szkoda sobie zawracać głowę trawieniem. Soldermaska własnego wykonania nie jest warta zachodu. Nie jest ona tak wytrzymała jak profesjonalne maski. Łatwo się zdziera. Kątowe piny nie łączą się pod kątek prostym. Lampa pod swoim ciężarem opada i jest nierówno Może sam wyłapiesz jeszcze jakieś istotne błędy Podsumowując - projekt mimo, że robiony był przez młodego i mało doświadczonego zapaleńca elektroniki to nauczył mnie wiele. Prawdą jest to, że każdy projekt uczy nas, a przy początkach uczy najwięcej. Dzisiaj szkoda mi jest niszczyć tą konstrukcję i mimo, że nie będę jej używał, to trzymam w szafie. Na szczęście mam jeszcze jedną lampę IW-18. Kiedyś pewnie powstanie coś na miarę moich dzisiejszych możliwości
  23. Jak powszechnie wiadomo, zdecydowana większość samochodów (nawet matizy) posiadają głośniki dość dobrej jakości. Oczywiście, kiedy mój znajomy pozbywał się samochodu na złom, musiałem coś z niego podebrać A oto prezentuję wam sterowniczek do głośników samochodowych DIY. Mogę też wspomnieć, że jest to mój pierwszy projekt nieoparty na mikrokontrolerze (więc dość tani). Funkcjonalność Urządzenie świetnie się nadaje na imprezy - potrzebuje dość dużo prądu, podpinamy się bezprzewodowo za pomocą bluetootha, no i wzmacniacz generuje dobre basy Całość zamyka się w małej obudowie Z23, z wyprowadzonymi złączami głośnikowymi i zasilaniem. Nie chciałem dodawać przycisków, gdyż na chwilę obecną wydawało mi się to zbędne. Urządzenie niestety wymaga aż 2 zasilaczy - 12v i 5v (obniżone do 3,3v za pomocą AMS1117), z powodu tzw. pętli mas, która zakłócała działanie układu BT, BK8000L. Sygnał audio wzmacnia PAM8610, wzmacniacz 2x15W przy impedancji 4ohm. Do wzmacniacza podłączyłem też niezależny, programowy przełącznik mute. Jak wyżej wspomniałem, do urządzenia łączymy się np. telefonem, i możemy bez problemu puścić muzykę z youtuba. Budowa Stabilizator wraz z modułem BT umieściłem na dwustronnej płytce prototypowej, zasilacz wlutowałem na stałe. Wyprowadziłem sygnały L, P i GND a resztę owinąłem taśmą kaptonową. Do wzmacniacza podłączyłem 12V bezpośrednio z zasilacza, przycisk mute do specjalnych wyprowadzeń na płytce, wyjścia podłączyłem do gniazd. Oczywiście całość w kaptonie - ochrona przed zwarciem. Później nożykiem wyrzeźbiłem w obudowie otwory na złącza, wkręciłem wszystko i zamknąłem. Efekty Na zdjęciu podłączyłem głośniki z koreańskiego samochodu Ssang Yong, o dość niskiej impedancji oraz 3 membranami. Całość połączyłem calkiem grubym kablem głośnikowym 1,5mm2. Dźwięk - czysty, basy - mocne, czyli zadanie zaliczone W przyszłości, kiedy znajdę czas (szkoła... ) na pewno pobawię się komendami AT, wydrukuję nową obudowę i dodam przyciski. Postaram się też zasilić całość 1 zasilaczem - jeżeli coś jeszcze będę modyfikował, dam znać. Na specjalną prośbę mogę wysłać filmik prezentujący działanie głośników. Pozdrawiam, Leoneq :3
  24. Swego czasu, kiedy zaczynałem przygodę z elektroniką (6 klasa podstawówki, 2017 rok), zachciało mi się zrobić jakiś "większy" projekt. Padło na dość trudne wyzwanie, zrobienie mini pc z obsługą komend basicopodobnych. Z racji szkoły projektu nie dokończyłem, ale udało mi się zrobić płytkę z atmegą, z wyjściem VGA i wejściem na programator. Urządzenie nazwałem "iNap". Działanie Urządzenie jest podobne do Arduino Pro Mini: "goła" atmega 328 na 16Mhz, na płytce umieszczone zostały umieszczone peryferia takie jak: buzzer podpięty do pinu A0 przez tranzystor, generujący dźwięki diodę led przy pinie 13 (standard) stabilizator 7805 z filtrowaniem wyjście VGA gotowe pod bibliotekę VGAX 5 wyprowadzonych pinów (analogi + pin 2) Całość programujemy za pomocą usbasp z podłączonym zewnętrznym zasilaniem (błąd w pcb, masy są oddzielone). Płytka została zaprojektowana pod bilbiotekę VGAX, dzięki której na Arduino możemy wyświetlać obraz VGA w 4 kolorach (!), w rozdzielczości 120x60px. Na monitorze możemy napisać dowolny tekst, dowolną zmienną czy nawet wyświetlić zdjęcie. Na zdjęciu płytka pracuje z podpiętym zewnętrznym zasilaczem. Na monitorze (od razu przepraszam za bałagan na biurku) możemy zobaczyć przerobiony przykład z biblioteki, który wyświetla 1 kolorowe piksele w losowych miejscach. Samo generowanie VGA zużywa aż 3 timery naszej atmegi, przez co mamy ograniczoną swobodę wykonywania funkcji czasowych, a bufor danych (ramka) zużywa ponad 89% RAMu mikrokontrolera. Budowa Pierwszą płytkę (testową) wykonałem na płytce uniwersalnej (gdzieś ja schowałem, nie wiem gdzie), miała ona uboższe możliwości. Płytkę którą widzicie zaprojektowałem w Eaglu, jeszcze na starym pc, więc plików nie wyślę. Samo PCB wykonałem domowymi sposobami: ścieżki naniosłem metodą termotransferu na laminat, nastepnie wytrawiłem w B327. Nastepnie wiercenie, dopieszczanie i lutowanie. Na końcu zapomniałem pomalować spód lakierem, przez co 2 lata miałem wystawioną gołą miedź. Ale płytka jeszcze dobrze się trzyma Co do peryferiów, buzzer podpiąłem przez tranzystor 2N2222. Same sygnały VGA musiałem ograniczyć rezystorami do odpowiednich napięć (68ohm na vsync i hsync, ok. 220ohm na kolory). Układ stabilizatora wyposażyłem w podwójny przełącznik DIP Switch, który odcina zasilanie i wycisza buzzer. Podsumowanie Był to mój pierwszy tak duży projekt. Moje pierwsze trawienie, pierwsze PCB. Wszystko zadziałało za pierwszym razem, i gdyby nie szkoła, na pewno zrobiłbym coś więcej z tym. Poczułem się deczko zawiedziony, kiedy na instructablesach już ktoś napisał poradnik "jak zrobić mini pc na arduino diy" chyba parę miesięcy temu. Jeżeli ktoś by chciał zrobić podobny projekt, to przede wszystkim na ESP (autor tej biblioteki napisał podobną pod ESP), które oferuje prawdziwe, monochromatyczne 640x480px i dołożyć obsługę klawiatury na PS/2. Życzę szczęścia Pozdrawiam, Leoneq :3
  25. Niskobudżetowy zegar Nixie Każdy elektronik chyba kiedyś widział urządzenie oparte o lampy Nixie. Z racji ich uroku, niepowtarzalnego wyglądu i chęci zrobienia czegoś "wow", i ja taki zbudowałem. Działanie lamp Nixie: Dla tych, którzy nie wiedzą co lampy Nixie, już służę pomocą: lampy Nixie zostały wynalezione w latach 60. ubiegłego wieku. Pierwsza firma która je produkowała tak je nazwała i się ta nazwa przyjęła. Były też to pierwsze wyświetlacze cyfrowe. Ich działanie polega na jonizowaniu się gazu (neonu z domieszkami) wokół katody z przyłożonym napięciem ok. 180V. Zjonizowany gaz powoduje świecenie się, i układa się wokół katody (w tym przypadku cyfry). Na żywo wygląda to bezcennie, lecz należy pamiętać że to wysokie napięcie. Budowa: Ale może najpierw coś o mnie: nazywam się Leon, mam 14 lat, chodzę do 8 klasy podstawówki i interesuję się elektroniką, informatyką, itp. Mam też drukarkę 3D - nie wykorzystałem jej w konstrukcji z racji jej awarii (czekam jeszcze na nowego rampsa ). Przechodząc już do zegara: z racji mojego stosunkowo młodego wieku, nie mam zbyt dużo pieniędzy na projekty więc chciałem na całość przeznaczyć ok. 100 zł zebranych od dziadków. Dlatego miało wyjść tanio i dobrze. Założenia z góry były jasne: multiplexowanie 1 sterownikiem, użycie 4 lamp, oraz materiałów z odzysku. Zacząłem od zrobienia przetwornicy step-up na 200V prądu stałego. Skorzystałem z tego schematu, który się sprawdził dość dobrze. Potem przyszedł mi sterownik 74141, oraz neonówka - mogłem już sprawdzić czy wszystko działa, i działało za pierwszym razem (możecie zacząć budować bunkier na apokalipsę). Następnie przeszedłem do zrobienia płytki głównej - goła atmega 328 z kwarcem 16mhz, ze sterownikiem na jednej płytce. Od razu zamontowałem moduł czasu RTC DS1302 (najtańszy) który lekko zmodyfikowałem - piny dałem z drugiej strony, a na górze zamontowałem koszyczek na dużą baterię od biosa. Do tego doszedł stabilizator 7805 i sterownik katod lamp. Całość wyszła całkiem schludnie - jestem z tego zadowolony. Na końcu doszły mi tranzystory do sterowania anodami lamp. Zastosowałem tu klucz z NPN MPSA42 oraz PNP MPSA92. I tutaj, podczas testów zrobiłem błąd - z racji małego protoboarda zrobiło się zwarcie, przez które zjarałem mój pierwszy rezystor w życiu (!), a tranzystory jakoś działały dalej. Po naprawieniu usterki 1 lampa działała - mogłem wyświetlić wszystkie cyfry od 0 do 9. Mogłem też zmierzyć, że napięcie zapłonu wynosi 180V i obniża się do 140V napięcia pracy. Teraz zostało mi zrobić podstawki - model pod lampy IN-12 do druku mogę udostępnić, ale z racji uszkodzenia płyty musiałem je zrobić sam. Wziąłem więc starą pokrywkę od farby, wyciąłem prostokąty, markerem zaznaczyłem miejsca na piny wdg. datasheetu, mini wiertarką wywierciłem otwory. Musiałem przygotować też same piny do podstawek - użyłem tu rozwierconych pinów z podstawek precyzyjnych, a następnie młotkiem wbiłem we wcześniej przygotowaną podstawę. Elektronika była gotowa, więc zacząłem programować. Po chwili dodałem mikrofon elektretowy, aby po klaśnięciu zegar się sam wyłączył, i od razu przeświecił wszystkie cyfry w celu uniknięcia efektu zatrucia katod. Zauważyłem też, że cewka w przetwornicy się dość mocno grzeje - dałem więc kapkę pasty termoprzewodzącej z domieszkami złota i przykleiłem radiator. Została mi już najgorsza część - obudowa. Normalnie bym takową wydrukował, ale że nie mogłem, wyciąłem ze sklejki listewki które pomalowałem szprejem na czarny mat. Wywierciłem otwory, poskręcałem śrubami M2,5. Wyszło źle, krzywo, niedokładnie - po prostu do d.... , pewnie dlatego że to była moja pierwsza obudowa ze sklejki, i z pewnością wydrukuję później obudowę (post zaktualizuję). Z daleka, jak patrzymy na zegar, wygląda on ciekawie - czarna bryła, lampy rosyjskiej produkcji i to klaśnięcie - wszystko to sprawia, że zegar dodaje niepowtarzalny klimat do pokoju. Zegar robiłem cały tydzień szkolny. Działanie zegara: Zegar wyposażyłem w klawiaturę 3 przycisków - "+", "-", oraz "prog". Przytrzymując przycisk prog możemy nastawić zegar, klikając odpowiednio + i -, oraz kliknąć prog ponownie by nastawić kolejną cyfrę. Podczas zwykłego działania, kliknięcie + spowoduje wyświetlanie się minut oraz sekund, a - będzie wyświetlał godziny i minuty. Dodatkowo, jeżeli podczas uruchamiania zegara przytrzymamy przycisk +, zostanie wywołany efekt "slot machine". Całość programowałem w środowisku Arduino, za pomocą programatora USBASP. Lista zakupów: 4x lampy IN-12 - ok. 10zł/sztuka, 50zł całość (+przesyłka) konwerter step-up - jakieś 20zł za całość sterownik, neonówka i przesyłka - 20zł tranzystory z drobiazgami - 20zł ----------------------------------------------------------------------- Za całość zapłaciłem jakieś 110zł. Resztę elementów już miałem. Dość nieźle, kiedy najtańsze zegary były chyba za ok. 300zł. Cudem jest fakt, że przeżyłem - akurat teraz mnie nic nie kopnęło, ale wcześniej doświadczyłem mocy napięcia gniazdkowego (długa historia). Sam zegar przyniósł mi dużo pochwał, szacunek u kolegów, 6 z fizyki na semestr - to tak jak te cudowne aplikacje na androida Od siebie jeszcze powiem, że na pewno zegar rozbuduję i wzbogacę o nowe funkcje. Co dalej? Mam w planach kalkulator domowej roboty, z kolegą zbudowałem już działający prototyp urządzenia podlewającego rzeżuchę. Oczywiście zachęcam do budowy zegara, ale należy pamiętać o wysokim napięciu. Pozdrawiam, Leoneq :3
×
×
  • Utwórz nowe...