Skocz do zawartości

Przeszukaj forum

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

  • Szukaj wg tagów

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

Typ zawartości


Kategorie forum

  • Elektronika i programowanie
    • Elektronika
    • Arduino, 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 48 wyników

  1. W zeszłym roku, jakoś przed świętami Bożego Narodzenia kupiłem gniazdka zdalnie sterowane za pomocą pilota na 433MHz. Kupiłem je głównie z myślą, żeby nie musieć się schylać każdorazowo przy wyłączaniu oświetlenia na choince. Któregoś dnia wpadłem na pomysł, żeby dorobić do tego sterowanie z pomocą smartfona i szczerze wątpiłem, że mi się uda. Ale się udało! W elektronice nie siedzę jakoś długo, raczej jest to dodatkowa "pasja" uzupełniająca programowanie, którym zawodowo się zajmuję. Tak się złożyło, że szybko uciekłem od Arduino Pro Mini na rzecz płytek prototypowych z ESP8266. Przed tym projektem zrobiłem przetarcie w projektowaniu PCB za pomocą płytki zrobionej w interfejsie webowym EasyEDA. Na PCB osadziłem stabilizator napięcia i diodę. Jedyne do czego tej płytki użyłem, to mruganie tą diodą i testowanie programowania układu. Były to dobre pierwsze kroki, które pozwoliły przesiąść się na KiCAD'a. Kupiłem moduły do 433Mhz dla Arduino i zacząłem pisać prototypowy kod Dzięki modułom mogłem wyśledzić, co jest nadawane "w eter" i podsłuchać kody, które są przesyłane gdy na pilocie wciskamy przyciski, gdyż płytka PCB pilota nie mówiła nic (zdjęcie powyżej). Szybko okazało się, że gotowe wzory implementacji są w internecie a protokół, jaki jest używany znany jest z gniazdek Kaku Power Switch oraz Nexa Power Switch, który bazuje na kodzie manchester. Podsłuchane kody zadziałały na płytce prototypowej, czas było to przenieść na docelowe ESP8266 / ESP-12. Przyszedł czas na przeniesienie się na własne PCB Zaprojektowałem płytkę PCB, w roli modułu radiowego użyłem RFM110W, który ładnie pasował i nie powiększał znacząco wymiarów płytki. Przylutowany powierzchniowo nie odstaje od PCB i wydaje się być jej integralną częścią. Urządzenie zasilane jest z gniazda microUSB, z którego prąd wędruje do stabilizatora napięcia a następnie do pozostałych części urządzenia - czyli modułu ESP12 oraz RFM110W. Na płytce pozostało miejsce na pin-socket odbiornika, natomiast praktyka pokazała, że podsłuchanie kodów lepiej zrealizować osobnym urządzeniem, więc gniazdo to nie jest wykorzystywane. Software - czyli najbardziej czasochłonna sprawa Program pisałem kilka razy, początkowo korzystając z biblioteki Blynk, którą porzuciłem na rzecz MQTT (PubSubClient). Protokół MQTT pozwala na uniwersalną komunikację, potrafi przechowywać stany w "tematach", działa podobnie do chatów, gdzie w tematach możemy publikować wiadomości. Napisałem również aplikację na peceta w C#, do sterowania gniazdami. Efekt końcowy Jak się podoba?
  2. 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
  3. 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.
  4. Zaczynając przygodę z elektroniką, prawdopodobnie każdy z nas jako jedno pierwszych narzędzi jakie kupił to sprzęt lutowniczy. Zazwyczaj zaczynamy od taniej "transformatorówki" lub zwykłej lutownicy kolbowej. Z czasem do coraz bardziej zaawansowanych projektów/napraw zaczyna brakować nam wielu funkcji w takim sprzęcie lub zwyczajnie chcemy czegoś lepszego i zastanawiamy się nad zakupem stacji lutowniczej. Tak wyglądał też mój początek z lutownicami.Pierwsze stacje które miałem, to popularne chińczyki które szybko się psuły lub zużywały. Po przepaleniu którejś kolby z rzędu, powiedziałem basta! Po dość długich poszukiwaniach, stwierdziłem że sprzęt który mnie zaspokoi jest dość drogi i zostaje DIY, tak właśnie stworzyłem idealną stację lutowniczą dla siebie, wzorując się na ciekawych i gotowych już pomysłach z sieci. Uwaga! W niektórych miejscach na płycie występują napięcia 230V! Niezachowanie ostrożności może grozić śmiercią! Założenia jakie miałem: Możliwość podłączenia różnych kolb lutowniczych( 24V z termoparą) Funkcja uśpienia(stacja przechodzi w tryb 180 stopni) Pamięć 3 najczęściej używanych temperatur Sterowanie pochłaniaczem dymu z poziomu stacji Wyświetlanie wszystkich informacji w czytelny sposób na LCD Niska awaryjność(pisze ten artykuł po kilku latach użytkowania stacji i póki co zero problemów) Niewielkie koszty Myślę że założenia udało mi się spełnić idealnie. Do stacji można podłączyć dowolną kolbę z grzałką na 24V. Posiada pamięć 3 zaprogramowanych wcześniej temperatur. Po 15 minutach od odłożenia kolby przechodzi w tryb uśpienia, co za tym idzie temperatura spada do 180 stopni i jest podtrzymywana, tak aby po podniesieniu kolby szybko się rozgrzać do poprzedniej temperatury, dodatkowo w trybie uśpienia wyświetlacz się wygasza. Po 30 minutach bezczynności stacja wyłącza się. Na tyle obudowy jest dodatkowe wyjście 230V pod które możemy podłączyć wyciąg powietrza, załączamy je odpowiednią kombinacją klawiszy. Dwie diody służą do sygnalizacji nagrzewania grzałki i załączenia wyjścia 230V. Obecnie pracuję na taniej kolbie firmy Zhaoxin ze względu na fakt, że posiadam bardzo duży zapas grotów i chcę je wykorzystać. Jednak gorąco polecam Solomon SL-30, którą używam w pracy i zdecydowanie dużo lepiej się nią lutuje. Układ załączania grzałki oparty jest na triaku i optotriaku który dodatkowo wykrywa przejście sieci przez zero. Jako ciekawe rozwiązanie warto tu wspomnieć o układzie włącznika. Podając impuls przyciskiem włączającym układ, tak naprawdę zawieramy styki przekaźnika na chwilę, procesor w ułamku sekundy wystawia stan wysoki na tranzystor który steruje przekaźnikiem załączającym zasilanie na całej płycie. Wyłączenie polega na wystawieniu stanu niskiego na tranzystor i odłączenie zasilania przez przekaźnik. Dodatkowe wyjście 230V również zbudowane zostało na popularnym układzie triak+optotriak. Wyświetlacz LCD w czytelny sposób prezentuje interesujące nas informacje takie jak stan podniesionej kolby, temperatura grota jak i żądaną, tryb pracy czy stan wyjścia 230V. Program do stacji został zaczerpnięty z innego projektu stacji który znalazłem w sieci, wspólnie z autorem dokonaliśmy kilku poprawek i modyfikacji. Po dopracowaniu całości i długich testach urządzenia prezentuje wam moim zdaniem najlepsza stacje lutownicza DIY. Poniżej zdjęcia i link ze szczegółowymi informacjami oraz plikami do konstrukcji Szczegółowy opis i materiały do pobrania
  5. Budowa tego projektu zaczęła się od tego, że znajomy zapytał, czy bym czegoś nie wymyślił, ponieważ on posiada w domu piec na ekogroszek z zasobnikiem na węgiel i czasem zapomina dosypywać węgla i gaśnie mu w piecu. Wykonałem więc nadajnik z ultradźwiękowym czujnikiem odległości HC-SR04 , który przekazuje dane do odbiornika bezprzewodowo za pomocą modułu nRF24L01. Gotowy odbiornik i nadajnik wygląda tak, jak na zdjęciu niżej. Do budowy wykorzystałem: Dwie sztuki Arduino Pro Mini 328 - 5V/16MHz Dwie sztuki moduł radiowy nRF24L01 Ultradźwiękowy czujnik odległości HC-SR04 Buzzer z generatorem 5V 12mm Zestaw diod LED 5mm Rezystory 100 ohm, 110 ohm i 190 ohm Dwie sztuki Stabilizator LDO 3,3V Dwie sztuki Kondensator elektrolityczny 10uF/50V Dwie sztuki Zasilacz impulsowy 5V / 1,2A Obudowy plastikowe Całość zmontowałem na płytkach z OSH Park MySensor 3.3V Pro Mini or 5V Pro Mini Diody LED i buzzer zamontowałem na płytce uniwersalnej. Schemat nadajnika. Schemat odbiornika. Kod programu Arduino nadajnika. #include <SPI.h> #include "RF24.h" int msg[1]; const uint64_t pipe = 0xF0F0F0F0A1LL; RF24 radio(9,10); #define trigPin 3 #define echoPin 4 void setup(){ Serial.begin (9600); pinMode(trigPin, OUTPUT); //Pin, do którego podłączymy trig jako wyjście pinMode(echoPin, INPUT); //a echo, jako wejście radio.begin(); radio.openWritingPipe(pipe); radio.setPALevel(RF24_PA_MAX); //Maxymalna moc nadajnika } void loop(){ long czas, dystans; digitalWrite(trigPin, LOW); delayMicroseconds(2); digitalWrite(trigPin, HIGH); delayMicroseconds(10); digitalWrite(trigPin, LOW); czas = pulseIn(echoPin, HIGH); dystans = czas / 58; Serial.print(dystans); Serial.println(" cm"); msg[0] = dystans; radio.write(msg, 1); // Wysylanie wartosci ze zmiennej msg delay(500); } Kod programu do odbiornika. #include <SPI.h> #include "RF24.h" const uint64_t pipe = 0xF0F0F0F0A1LL; RF24 radio(9,10); int msg[1]; void setup(){ //Serial.begin (9600); pinMode(3, OUTPUT); //led czerwona pinMode(4, OUTPUT); //led zolta pinMode(5, OUTPUT); //led pierwsza zielona pinMode(6, OUTPUT); //led druga zielona pinMode(7, OUTPUT); //led trzecia zielona pinMode(8, OUTPUT); // buzer radio.begin(); radio.openReadingPipe(1,pipe); radio.startListening(); } void loop(){ if(radio.available()){ radio.read(msg, 1); Serial.print(msg[0]); Serial.println(" cm"); if (msg[0] >= 57) { //odlegolsc max kiedy wlacza sie buzer digitalWrite(3, HIGH); digitalWrite(4, LOW); digitalWrite(5, LOW); digitalWrite(6, LOW); digitalWrite(7, LOW); digitalWrite(8, HIGH); delay(5000); digitalWrite(3, HIGH); digitalWrite(4, LOW); digitalWrite(5, LOW); digitalWrite(6, LOW); digitalWrite(7, LOW); digitalWrite(8, LOW); delay(1800000); } else { digitalWrite(3, HIGH); digitalWrite(4, HIGH); digitalWrite(5, HIGH); digitalWrite(6, HIGH); digitalWrite(7, HIGH); digitalWrite(8, LOW); } if (msg[0] >= 43 && msg[0] <57) { digitalWrite(3, HIGH); digitalWrite(4, HIGH); digitalWrite(5, LOW); digitalWrite(6, LOW); digitalWrite(7, LOW); digitalWrite(8, LOW); } if (msg[0] >= 29 && msg[0] < 43) { digitalWrite(3, HIGH); digitalWrite(4, HIGH); digitalWrite(5, HIGH); digitalWrite(6, LOW); digitalWrite(7, LOW); digitalWrite(8, LOW); } if (msg[0] >= 15 && msg[0] < 29) { digitalWrite(3, HIGH); digitalWrite(4, HIGH); digitalWrite(5, HIGH); digitalWrite(6, HIGH); digitalWrite(7, LOW); digitalWrite(8, LOW); } if (msg[0] >= 15 && msg[0] < 2) { digitalWrite(3, HIGH); digitalWrite(4, HIGH); digitalWrite(5, HIGH); digitalWrite(6, HIGH); digitalWrite(7, HIGH); digitalWrite(8, LOW); } } delay(500); } Kod programu odbiornika, jest napisany tak, że gdy poziom węgla spadnie do 57 cm od góry, włącza się buzer na 5 sekund i świeci czerwona dioda i jeżeli nie dosypiemy węgla, buzer włączy się znowu za pół godziny na 5 sekund, po dosypaniu węgla trzeba nacisnąć przycisk reset, który wyprowadziłem za pomocą przycisku na obudowie lub odczekać pół godziny. Zasobnik na węgiel wygląda tak. Zmontowany nadajnik z ultradźwiękowym czujnikiem odległości HC-SR04. Nadajnik jest zamontowany na górze metalowego zasobnika na węgiel, przed montażem zostały wywiercone 2 otwory w zasobniku, tak aby pasowały wystające okrągłe elementy czujnika HC-SR04. Zmontowany układ na płytce MySensors dostępnej w OSH Park, długość to około 10 cm. Ponieważ zastosowałem 5 diod, które informują o stanie węgla, to 57 cm podzieliłem na 4, co daje około 14 cm i gdy poziom węgla spadnie o 14 cm gasną kolejne diody, aż do 57 cm i wtedy świeci się czerwona dioda i włącza buzer na 5 sekund. Program możemy dowolnie modyfikować, aby dostosować do wysokości pojemnika na węgiel. Działanie całości widać na poniższym filmie. Całość działa już 2 lata bez awarii i na czas dosypywania ekogroszku, nadajnik jest zdejmowany i czasem przedmuchany z pyłu.
  6. Witam, jestem zupełnie zielony, niedługo po kursie elektroniki, jaki odbyłem na Forbot, natchniony zdobytą wiedzą postanowiłem zrobić swój pierwszy projekt (trochę posiłkując się też internetem). Chciałem zrobić czujnik poziomu wody, który pokazywałby na diodach jaki poz iom w zbiorniku osiągnęła woda. Mój zbiornik ma utrudniony dostęp - jedynie przez rurkę PCV o średnicy 3/4 cala. W zasadzie jest to dolna część skrzyni w której rosną rośliny. Wodę wlewam na dno i stamtąd podsiąka do gleby nawadniając całość. Nie mogłem znaleźć niczego co byłoby w miarę niedrogie, umożliwiało wprowadzeni przez rurkę 3/4 cala i jeszcze spełniało moje wymagania. W założeniu miało to wyglądać następująco (załączam też schemat): 4 diody LED (LED2 - LED 5) miały wskazywać 4 poziomy wody, a dodatkowo jedna (LED1) wskazuje, że układ jest pod napięciem. Przewód "Common" miał być cały czas zanurzony w wodzie (najniższe położenie), a kolejne, połączone z bazami tranzystorów miały znajdować się coraz wyżej i w miarę podnoszenia się poziomu wody włączać poszczególne diody. Stabilizator napięcia podłączony do diody zielonej (LED4) miał w przyszłości posłużyć do wyprowadzenia sygnału do Arduino (małe marzenie na przyszłość ,ale na tej funkcji bardzo mi zależy). Całość planowałem zasilać (przynajmniej na początku) baterią 9V. Na płytce stykowej całość działała dobrze, więc zlutowałem układ na płytce uniwersalnej (pierwsze lutowanie w życiu, ale wyszło)- pierwsze testy wypadły pomyślnie. Zanurzałem po prostu kolejne przewody w szklance a diody zapalały się i gasły po wyjęciu przewodu. Przykleiłem następnie przewody do plastikowej płytki i wsunąłem do mojego zbiornika. W miarę podnoszenia się poziomu wody zapalały się kolejne diody. Woda powoli opadała wsiąkając w glebę, ale diody nie gasły całkowicie. Założyłem, że na powierzchni plastiku pozostaje cienka warstwa wody, która umożliwia przewodzenie i kilka razy zmodyfikowałem projekt części wsuwanej do zbiornika (odsunąłem niezaizolowane części przewodów od powierzchni plastiku). Niestety w dalszym ciągu przy dłuższym zanurzeniu diody nie gasły całkowicie - żarzyły się (szczególnie fioletowa i czerwona). Używanie baterii stało się nieekonomiczne, bo wyczerpywały się po 2-4 dniach, więc kupiłem najprostszy zasilacz, w którym mogłem ustawić napięcie 9 V (tabliczka znamionowa podaje prąd wyjściowy 600mA). W tym momencie po podłączeniu okazało się, że nawet bez zanurzenia cały czas żarzą się diody: fioletowa i czerwona (ta druga słabiej). Przy okazji odkryłem, ze dotknięcie dowolnego przewodu (podłączonego do bazy) powoduje włączenie odpowiadającej mu diody. W niektórych przypadkach nawet dotknięcie zaizolowanej części. Stworzyłem więc "klawisze indukcyjne" wbrew zamierzeniom. Czy mój projekt da się jakoś uratować? Bardzo proszę o pomoc i sugestie - być może zrobiłem jakiś głupi błąd, który dla kogoś bardziej zaawansowanego jest oczywisty, a dla mnie niedostrzegalny. 2019.04.28 schemat Water level indicator.pdf Pozdrawiam Ernest
  7. 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
  8. W tym projekcie chciałbym opisać krok po kroku proces podłączenia licznika samochodowego od Forda Galaxy do naszego Arduino. Potrzebne elementy: Zasilacz 12V Arduino Przewody męsko-żeńskie Licznik samochodowy Zestaw wskaźników od Forda Galaxy posiada 2 wtyczki - czerwoną oraz czarną. Nas w tym projekcie interesuje tylko czerwona wtyczka gdyż znajdują się w niej piny zasilające oraz dostarczające dane do silników krokowych w liczniku. Najpierw zajmijmy się zasilaniem. Do pinu 3 oraz do pinu 4 na liczniku wpinamy 2 przewody i podłączamy je do minusa na naszym zasilaczu a kolejne 2 przewody wpięte w pin 14 oraz w pin 15 podłączamy do +. Jako zasilacz może nam posłużyć zwykły zasilacz komputerowy kub jakikolwiek o napięciu 12V. Dalej zajmijmy się podłączeniem silniczków od wskazówek. obrotomierz - 10 pin prędkościomierz - 27 pin wskaźnik poziomu paliwa - 21 pin wskaźnik temperatury cieczy - 23 pin (pin 1 jest w lewym dolnym rogu wtyczki) Następnie przewody te wpinamy w wejścia cyfrowe do Arduino. W moim przypadku obrotomierz wpiąłem w wejście oznaczone 2, prędkościomierz w wejście nr 3, wskaźnik poziomu paliwa 4 a temp. cieczy w wejście 5. Jeżeli po podpięciu zasilania licznik zadziała (wskazówki ustawią się w położeniu 0 oraz włączy się podświetlenie) to możemy przejść do konfiguracji. Pobieramy oprogramowanie SimHub i instalujemy je. Po uruchomieniu programu przechodzimy do zakładki Arduino a następnie klikamy na zakładkę "My hardware". Wybieramy "Single Arduino" i klikamy "Open arduino setup tool". Następnie definiujemy w jakie wejścia wpięliśmy nasze wskaźniki. Wybieramy z jakiego arduino korzystamy (w moim przypadku jest to UNO) oraz wybieramy port komunikacyjny. Gdy wszystko mamy już zrobione klikamy Upload to arduino i czekamy aż program zostanie wgrany na Arduino. Jeżeli program wgrał się poprawnie przechodzimy do zakładki "Gauges" i kalibrujemy nasz licznik. Wartości liczbowe są indywidualne dla każdego licznika ale to co musimy ustawić do każdego licznika to MAX Tachometer RPM na 7 (jeżeli zakres na tarczy obrotomierza jest inny to podajemy maksymalną liczbę, jeśli jest to 5 to podajemy 5) oraz tachometer cylinders na 6. Warto zaznaczyć opcję "Always use tachometer full range" jednak jeśli sprawia ona problemy możemy ją wyłączyć. Resztę wartości musimy ustawić tak, żeby wskazówka poprawnie wskazywała położenie min i max. Niestety nie ma uniwersalnych wartości i prędkościomierz u mnie wskazuje poprawnie 240 km/h przy wartości 222 (speedo gauge maximum output) jednak w innym liczniku może być to wartość ciut większa lub mniejsza. Na samym końcu wybieramy grę w którą chcemy zagrać z zakładki "Games". Następnie uruchamiamy naszą grę i cieszymy się rozgrywką z naszym licznikiem. Ktoś mi może powiedzieć "Przecież można napisać kod", zgodzę się z tym tylko ja gram od ETS 2 przez Dirt 4 na Forzie kończąc. O wiele łatwiej jest jednym kliknięciem zmienić grę w simhubie niż pisać osobny kod eksportujący dane z telemetrii do Arduino. Jeżeli ktoś potrzebuje tylko licznika do jednej gry to ma to sens jednak w moim przypadku mija się to z celem. Koszt takiego licznika może zamknąć się w okolicach 50 zł. Możemy wykorzystać klona arduino (klon nano możemy kupić za mniej niż 15zł), a licznik możemy znaleźć na portalach aukcyjnych za ok 20zł. Jest to niedrogi i fajny bajer a na dodatek jest bardzo praktyczny. Poniżej znajdują się zdjęcia i gif pokazujący pracę urządzenia.
  9. 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ć
  10. 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!
  11. 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.
  12. Witam! Chciałbym zaprezentować Wam lodówkę, którą sam zrobiłem. Elementy z których zbudowałem lodówkę: Sklejka 6mm styropian 30mm Zestaw radiatorów Wentylatory Ogniwo Peltiera 5A Przekaźnik Arduino UNO Czujnik temperatury DS18B20 2 przełączniki Gniazdo DC 5,5x2,5mm Zasilana jest zasilaczem 12V 7A. Tak duży prąd potrzebny jest do zasilania 5A ogniwa Peltiera , 2 wentylatorów i LED'ów. Nie był potrzebny aż tak mocny, ale tylko taki miałem pod ręką. Do zasilania "zabezpieczenia" używam 2A ładowarki. niestety za późno zorientowałem się, że będzie potrzebne, przez co nie podpiąłem bezpośrednio do zasilacza. Niestety, kupując zasilacz o tak wysokim natężeniu prądu nie przewidziałem, że nie posiadam odpowiedniego kabla zasilającego. W domu znalazłem tylko taki, który da MAX 2,5A. Obudowa jest wykonana ze sklejki o grubości 6mm pomalowanej czarną matową farbą do drewna. Wyłożona jest styropianem o grubości 3cm a drzwiczki zrobione są z 4mm pleksy. Po między pleksą a styropianem jest uszczelka, która choć częściowo zapobiega uciekaniu zimna. Lodówka posiada magnesy dzięki którym drzwiczki są przyciśnięte do uszczelki. W środku zamontowałem LED'y w dwóch kolorach: białym zimnym i niebieskim. Niebieski zapala się gdy drzwiczki są zamknięte a biały, gdy są są otwarte. Z tyłu obudowy są dwa przełączniki. Jeden służy do włączania LED'ów a drugi włącza wentylatory i ogniwo Peltiera. Do chłodzenia lodówki użyłem modułu wentylatora z radiatorami przeznaczonego do ogniwa Peltiera. Niestety od zimnej strony ogniwa, mniejszy radiator nie ma wentylatora, więc musiałem go dokupić. Jego wymiary to 40mm x 40mm x10mm Obok przycisków jest otwór przez który wlatuje powietrze. Radiator z tyłu obudowy bardzo się grzał przez co musiałem wymyślić coś dzięki czemu temperatura była by stabilizowana i ograniczana. Wpadłem na pomysł aby przy temperaturze 45°C ogniwo było odłączone na 100 sekund(wentylatory wciąż pracują). W tym czasie wentylator chłodzi radiator. Do odłączenia zasilania ogniwa użyłem przekaźnika, Arduino UNO i czujnika temperatury DS18B20+. Chciałem użyć Nano, ale jak na złość wszystkie były uszkodzone. Do Arduino wgrałem odpowiedni program i podłączyłem wszystko na płytce stykowej. Dodatkowo temperaturę można sprawdzać na komputerze komunikując się z płytką przez interfejs UART. #include <OneWire.h> #include <DallasTemperature.h> OneWire oneWire(A3); //Podłączenie do A3 DallasTemperature sensors(&oneWire); //Przekazania informacji do biblioteki #define przekaznik 7 void setup(void) { pinMode(przekaznik, OUTPUT); Serial.begin(9600); sensors.begin(); //Inicjalizacja czujnikow } void loop(void) { sensors.requestTemperatures(); //Pobranie temperatury czujnika Serial.print("Temperatura radiatora to: "); Serial.println(sensors.getTempCByIndex(0)); delay(1000); if(sensors.getTempCByIndex(0) >45){//Jesli temperatura radiatira jest wyzsza niz 45 stopni digitalWrite(przekaznik, HIGH); delay(100000); digitalWrite(przekaznik,LOW); } } Niestety, na ten moment nie posiadam termometru, którym mógł bym sprawdzić różnicę temperatury. Ale po około 30 min pracy napój w puszce lekko się schłodził. Może nie jest bardzo wydajna ale mi wystarcza.
  13. Napiszę na wstępie IPhone ma swoich zwolenników i przeciwników, bardzo proszę by ten temat nie stał się polem dyskusji "Dlaczego Apple to zło a Android jest super". Posiadam Iphone i mam swoje przemyślenia ale nigdzie ich nie ujawnię by nie rozpętać burzy . A teraz przechodzimy do sedna Aplikacji do zarządzania smarthomem na system android jest mnóstwo, ale co jest dostępne dla użytkowników iOS? Apple udostępniło protokół HAP (HomeKit Accessory Protocol) aby móc połączyć urządzenia trzecich firm do aplikacji dom. Można samemu stworzyć odpowiedni kod który połączy nasze esp z aplikacją ale można wykorzystać tak zwany mostek który to zrobi za nas. Mostek komunikuje się z naszymi urządzeniami na esp za pomocą protokołu HTTP oraz z urządzeniam firmy Apple za pomocą HAP. Połączenie to jest od początku do końca szyfrowane. Ja przedstawię instalację, krótką konfigurację mostku oraz coś jeszcze Zapewne znacie sterownik rolety lub sterownik oświetlenia wykonany przeze mnie na popularnym module ESP8266. Postanowiłem lekko zmienić w nich oprogramowanie żeby były zgodne z homebridge. Ale nie będę opisywał tutaj zmian jakie dokonałem tylko sposób instalacji tak zwanego mostku na Raspberry PI Zero W. Wybrałem model z końcówką W po to żeby nie być ograniczonym kablem Ethernet. Dodatkowo dokupiłem sobie radiator i wiatraczek. Zapewne zastanawiacie się po co mi sam wentylator bez uchwytu, ale o tym w dalszej części . Aby uruchomić malinkę potrzebujemy karty micro sd (ja wybrałem wersje 32 gb), dobrej klasy gdyż to z niej będzie uruchamiany system więc im wolniejsza karta tym wolniej będzie się ładował system. Najnowszą wersję oprogramowania pobieramy ze strony Raspberry Pi dodatkowo potrzebujemy program Etcher aby nagrać system na kartę pamięci. Po wszystkim wkładamy kartę do malinki i podłączamy zasilanie. O tym jak skonfigurować możliwość połączenia ssh możecie przeczytać tutaj. Gdy mamy skonfigurowane ssh logujemy się na naszą malinkę. ssh pi@192.168.0.3 i podajemy hasło użytkownika pi (pamiętajcie że to jest adres ip raspberry pi u mnie Wy będziecie mieli inny , aby połączyć się z systemu windows potrzebny jest program putty). Teraz warto najpierw zaaktualizować system sudo apt-get update sudo apt-get upgrade Następnie możemy zająć się instalacją homebridge Sudo apt-get install curl curl -sL https://deb.nodesource.com/setup_8.x | sudo -E bash - sudo apt-get install -y nodejs sudo apt-get install libavahi-compat-libdnssd-dev sudo npm install -g --unsafe-perm homebridge Homebridge powinien nam wystartować i powinniśmy dostać kod QR wraz z pinem używamy ich do połączenia. Teraz możemy zająć się instalacją pakietów. Możemy je znaleźć na tej stronie. Na przykład plugin do sterowania żarówką znajduje się pod tym linkiem. Przedstawiona jest również komenda za pomocą której należy zainstalować pakiet sudo npm install -g homebridge-http-lightbulb Dodatkowo jest opisana konfiguracja pliku config.json który znajduje się w katalogu ~/.homebridge/ Dzięki przykładowej konfiguracji widzimy jakie zapytania powinien realizować nasz sterownik. Dla żarówki są to Status Turn on Turn off Po skonfigurowaniu pliku config.json należy zresetować homebridge. Ja używam komendy sudo systemctl restart homebridge Za każdym razem kiedy wyłączymy malinkę i ją uruchomimy homebridge sam wystartuje. Zaraz po instalacji homebridge zainstalowałem plugin, który wystawia stronę dzięki której mamy dostęp do pliku config.json bez potrzeby używania terminala. Dodatkowo możemy dokonać aktualizacji oprogramowania, zresetować system czy zobaczyć aktualne wykorzystanie procesora. Źródło https://www.npmjs.com/package/homebridge-config-ui-x Możemy również skonfigurować sobie podgląd logów. Źródło https://www.npmjs.com/package/homebridge-config-ui-x Dodatkowo jest tam wyszukiwarka pakietów NPN do instalacji. Źródło https://www.npmjs.com/package/homebridge-config-ui-x A teraz czas na sposób montażu wentylatora Z racji tego że w końcu zakupiłem sobie wymarzoną Anetkę to zaprojektowałem obudowę do RPI zero. Dodatkowo nie chciałem podpinać wtyku usb gdyż zajmuje ono dużo miejsca pod długości oraz łatwo bym mógł uszkodzić gniazdo. Sprawdziłem że pod gniazdem na RPI są dwa pady jeden z nich to minus a drugi to plus przylutowałem w to miejsce dwa kabelki które następnie poprowadziłem do wtyku dc. Następnie zrobiłem sobie kabelek usb typ A na wtyk dc i takim kabelkiem zasilam malinkę. Jeśli macie jakieś problemy z instalacją albo pytania to piszcie śmiało będę starał się pomagać Aha i jeśli dodacie nowe urządzenie to wystarczy, że zrestartujecie homebridge i pojawi się ono w aplikacji dom w iOs.
  14. Większość osób myśląc o cyfrowej telekomunikacji, myśli o współczesne mikroelektronice: smartfonach, komputerach i Internecie. Nie każdy zdaje sobie sprawę z tego, że idea przesylania informacji zakodowanej w ciągach zer i jedynek jest dużo, dużo starsza. Pierwszym urządzeniem tego rodzaju był telegraf skonstruowany przez Emille'a Baudot w latach siedemdziesiątych XIX wieku. Urządzenie po stronie nadajnika posiadało klawiaturę złożoną z pięciu przycisków, które operator musiał wciskać w różnych kombinacjach. Urządzenie wysyłało na linię ciąg impulsów, odpowiadających wciśniętej kombinacji. Odbiornik interpretował ten sygnał drukując na papierowej taśmie odpowiednią literę lub cyfrę, w jej naturalnej formie. Na początku XX wieku idea to została udoskonalona. Nadajnik został wyposażony w klawiaturę podobną do tych stosowanych w maszynach do pisania. Tak narodził się dalekopis. Transmisja danych pomiędzy tymi urządzeniami przypominała standardowy interfejs szeregowy. Z tą różnicą, że z przeciwieństwie do TTL UART-a czy RS323 poszczególne stany logiczne nie były kodowane przez wartości napięć, ale przez fakt przepływu (bądź nie) prądu w obwodzie. Normalnie przez linię płynął prąd o ustalonej wartości (zazwyczaj 60, 40 lub 20 mA). To był stan domyślny. Rozpoczęcie nadawania kolejnego znaku wymagało nadania bitu startu, czyli chwilowego przerwania obwodu. Potem nadajnik oczekiwał na pięć bitów z kodem znaku w alfabecie Baudot (zwanym także międzynarodowym alfabetem telegraficznym). Na końcu pojawiały się bity stopu w trakcie których odebrany znak był drukowany na papierze. Ktoś zapewne zauważył już, że używając pięciu bitów można było zakodować maksymalnie 32 znaki - zdecydowanie za mało, aby pomieścić wszystkie litery alfabetu, cyfry i znaki interpunkcyjne. To prawda. Stosowano pewną sztuczkę - dwie kombinacje bitów były zarezerwowane do przełączania pomiędzy dwoma rejestrami zawierającymi litery oraz cyfry i inne znaki. Ne stosowano także rozróżnienia na male i duże litery. Dalekopis chociaż w pełni cyfrowy, był urządzeniem elektromechanicznym, radzącym sobie bez pojedynczego tranzystora (chociaż oczywiście w latach osiemdziesiątych i dziewięćdziesiątych produkowano nowoczesne, elektroniczne wersje). Dalekopisy były powszechnie używane do przesyłania wiadomości przez wojsko i państwowe służby. Poczta wykorzystywała je do transmisji telegramów. Stosowano je także w roli terminali komputerowych, przed pojawieniem się monitorów CRT. Ślad tej zaszłości historycznej zachował się w nomenklaturze stosowanej w systemach uniksowych, gdzie terminal jest oznaczany skrótem TTY - od angielskiego słowa "teletype", czyli właśnie dalekopis. Przepraszam za ten przydługi wstęp, nie byłem jednak pewien, czy wszyscy będą jeszcze kojarzyć o jakie urządzenie chodzi... Przechodząc do sedna sprawy. Na co dzień pracuję w krakowskim Muzeum Inżynierii Miejskiej. Jakiś czas temu został nam przekazany dalekopis T100, wyprodukowany w latach siedemdziesiątych w Czechoslowacji, na licencji Siemensa. Ponieważ posiadaliśmy już taki eksponat, zostałem poproszony o sprawdzenie możliwości uruchomienia go i wykorzystywania w roli interaktywnej instalacji, zamiast "martwego" eksponatu ukrytego w muzealnej gablocie. Tak rozpoczęły się moje eksperymenty. Najpierw skonstruowałem prosty interfejs USB, oparty na starym mikrokontrolerze AT89C2051 i układzie FTDI. Do generowania pętli prądowej 40 mA używałem zestawu kilku baterii 9V oraz rezystorów o dużej mocy. Komunikacja z dalekopisem ruszyła bez problemu - pojawiła się jednak inna trudność. Okazało się, że uszkodzony jest moduł wzywaka - urządzenia odpowiedzialnego m.in. za zdalne włączanie silnika dalekopisu przy połączeniu przychodzącym, sygnalizowanym odwróceniem kierunku przepływu prądu w linii. Naprawa tego modułu okazała się bardziej skomplikowana niż początkowo sądziłem, ostatecznie postanowiłem więc wymontować wadliwą część i sterować silnikiem za pomocą przekaźnika, zamontowanego w moim interfejsie. Finalna wersja interfejsu zawiera mikrokontroler PIC32MX270F256B oraz moduł GSM SIM800L. Wykorzystałem także 2MB pamięć SPI flash, do wykonywania elektronicznej kopii przychodzących wiadomości. W osobnej obudowie znajduje się generator pętli prądowej, złożony z zasilacza transformatorowego oraz zestawu kondensatorów. Całość można obecnie oglądać na wystawie "Uwaga! Nieprzyjaciel podsłuchuje." w Muzeum Inżynierii Miejskiej w Krakowie. Po wysłaniu SMS-a na podany numer można oglądać dalekopis podczas pracy.
  15. Cyfrowa stacja lutownicza Jest to mój 2 prolekt po 12 letniej przerwie z elektroniką. Była to okazja do poznania Eagle oraz podstaw programowania mikroprocesorów. Obecnie wiele rzeczy bym poprawił i docelowo tak się chyba stanie. Działanie stacji oceniam bardzo pozytywnie. Obecnie mam 3 stacje lutownicze, więc już mogę coś na ten temat napisać ale to już dłuższy temat. Projekt polecam wszystkim, którzy mają niewykorzystane trafo 2x12V 60VA (minimum) oraz LCD1602 i procesor Atmega8. Są to chyba 3 najdroższe elementy (pomijając kolbę 907A, którą przez internet można kupić poniżej 30zł z kosztami wysyłki). Docelowo schemat podzieliłem na 2 zasadnicze części: 1. Płytka zasilająca 2.Płytka sterowania Wzory płytek w Eagle standardowo dostępne są w załączniku. A tutaj jeszcze foto gotowych płytek: Aby ułatwić możliwość wymiany procesora i wzmacniacza operacyjnego, zostały one umieszczone w podstawkach. Płytka sterująca oraz płytka zasilająca zostały połączone za pomocą złącza goldpin. Obudowa została wykonana z płyt meblowych oklejonych fornirem dębowym. Dodatkowo składałem dla znajomego CNC z chin i w ramach testów wykonałem panel przedni oraz tylni na tym CNC (materiał to 1,5mm blacha aluminiowa). Efekty pracy widać na poniższych zdjęciach: Zasilanie 230V trafia na gniazdo komputerowe oraz włącznik (pozyskane z zasilacza ATX). Następnie mamy bezpiecznik szklany i transformator toroidalny 50VA 2x12V. Transformator miał wymienione uzwojenia wtórne. Miałem transformator z tylko jednym uzwojeniem o napięciu 10,5V, więc od nowa zostały nawinięte uzwojenia 2x12V. Takie napięcia są wprowadzone zgodnie z zamieszczonym schematem na płytkę zasilającą. Zastosowałem najprostszą kolbę 907A z termoparą. Wykorzystałem dostępne w sieci oprogramowanie stacji lutowniczej RL-1 zawierające algorytm PID do sterowania grzałką. Konstrukcja nie jest pozbawiona wad: Obudowa nie jest dokładnie spasowana z panelami czołowym i tylnym (miała być tymczasowa, a wyszło jak zwykle). Słaby obieg powietrza w obudowie (pomimo tego faktu nic się nie przegrzewa przy długiej pracy. Oto film prezentujący rozgrzewanie grota od temperatury 38 stopni do 320 stopni: Już w 22 sekundzie grzałka osiąga temperaturę zadaną. Od 35 sekundy przykładam do grota cynę o grubości 0,7mm. Cyna zaczyna się topić ok. 50 sekundy. Temperatura grota została zestrojona ze wskazaniem stacji za pomocą termopary i procedury opisanej w dokumentacji stacji RL-1 (w załączniku AVT987). A to obecnie przeze mnie posiadane stacje lutownicze: Jak już wcześniej wspomniałem, wykonałbym kilka zmian. Najważniejsza to zmniejszenie wymiarów stacji. Trafo zajmuje 1/3-1/4 obudowy. Obecnie całość znalazłaby się na jednym PCB, wszystkie elementy SMD, cała stacja zmieściłaby się za LCD. Do tego trafo i wymiar całości zmniejszony minimum o połowę. Poza tym, prócz najdłuższego rozgrzewania i braku mocy przy lutowaniu dużych pól masy stacja działa nad wyraz dobrze. EAGLE_Moja stacja lutownicza.zip AVT987.pdf Cyfrowa_Stacja_Lutownicza_RL1 - do wgrania.zip Cyfrowa_Stacja_Lutownicza_RL1 - edytowalne oprogramowanie.zip Cyfrowa stacja lutownicza RL1.zip
  16. Od momentu poznania ESP8266 bardzo spodobał mi się ten układ. Gdy skończyłem robić pierwszy projekt oparty na tym układzie od razu zacząłem wymyślać kolejny. Dzisiaj chciałbym Wam przedstawić sterownik oświetlenia. Współpracuje on ze zwykłym włącznikiem świecznikowym i mieści się w puszce fi60, dzięki czemu (nad każdym włącznikiem światła mam puszkę fi70) w puszcze fi70 zostaje jeszcze sporo miejsca na kable. Po zaprojektowaniu płytki w programie Eagle zleciłem wyprodukowanie jej firmie jlcpcb. Wszystko trwało tydzień (zamawiałem również inne płytki dlatego tyle to trwało ). Płytki wysłali w piątek po południu czasu lokalnego a w poniedziałek płaciłem już vat u kuriera z DHL . Płytki wyglądają bardzo dobrze (sami możecie ocenić jakość produktu ) Po odebraniu płytek zacząłem wszystko składać w całość. ESP8266 12F zostało wykorzystane jako "mózg" płytki. Jako zasilacz służy Hi-Link HLK-PM01 230V na 5V. Za załączenie napięcia odpowiedzialne są dwa przekaźniki z cewką na 5V. Dodatkowo do każdego przekaźnika dołożyłem diodę prostowniczą. ESP jest zasilane napięciem 3.3v przez co musiałem zastosować LDO. Dodatkowo na wejściu fazy do układu zamontowałem bezpiecznik firmy bel fuse. Żeby esp mogło załączać przekaźnik musiałem wykorzystać tranzystor bc817 w wersji smd. Do tego potrzebowałem jedno złącze ark raster 5mm podwójne, oraz dwa złącza ark raster 5mm potrójne. Całość po zlutowaniu i umieszczeniu w puszcze fi60 wygląda następująco: Teraz przyszła kolej na oprogramowanie. Zdecydowałem się zrobić prostą stronę konfiguracyjną na której możemy: zmienić hasło do urządzenia zmienić dane serwera mqtt (sterowanie z każdego miejsca na świecie ) zmienić przyłączenie do sieci wi-fi zobaczyć jak długo pracuje nasz układ wybrać ilość podpiętych włączników (jedno albo dwa) Całość jest również sterowana z telefonu z systemem android. Teraz przymierzam się do zrobienia wersji v2 tego sterownika, chcę by był oparty na triakach i optotriakach (z tego co wyliczyłem to żarówka led o mocy 15W pobiera tylko 60mA a świeci jak zwykła żarówka 120W) oraz będzie posiadała wsparcie dla dotykowych podświetlanych włączników (moduły httm oraz panele marki weilak, wszystko mam tylko projekt został ) Jestem bardzo ciekaw Waszych opinii, dajcie znać w komentarzach co myślicie mo jej konstrukcji
  17. Jako, że zbliżały się pierwsze urodziny pewnego młodego człowieka w mojej rodzinie wpadłem na pomysł, żeby wreszcie z długiej fazy mówienia o jakimś projekcie przejść do fazy robienia go. I tak o to padł pomysł zbudowania kolorowej lampki nocnej. Koncepcja Jako, że lampka to bardziej mebel niż zabawka to całość musiała być solidna a przy tym najlepiej nie brzydka. Jako klosz (obudowa) na początku myślałem o użyciu rury z plexi ale cena okazała się niestety nie akceptowalna. Wpadłem na pomysł użycia opakowania spożywczego z plastiku. Przeszukałem kilka sklepów gospodarstwa domowego i znalazłem pasujące pudełko. No to już z górki. Potem jeszcze trochę diod led,jakieś zasilanie i sterowanie. Dno lampki przykręcone jest na dwie śruby M3 ze stożkowym łbem, wewnątrz przyklejone są dwie tulejki dystansowe robiące za gwint. Wnętrze "klosza" to "choinka" zbudowana z plastikowej rurki, jej podstawy oraz łańcucha diod. Podstawa całości oraz choinki to płytki wycięte z deski do krojenia kupionej właśnie w tym celu. Nie jest to sztywne tworzywo ale do takiego zastosowania sprawdza się super, łatwo się obrabia, wygląda dobrze i trudno zgadnąć z czego to jest Całość pomalowana sprejem na jasny niebieski (celowałem w błękitny, chyba nie wyszło źle). Elektronika Potrzebna była, przede wszystkim, pełna dowolność koloru a jako, że nie chciałem bawić się w skomplikowane (w sensie kabelkologii) sterowanie tradycyjnymi ledami RGB padło na diody WS2811. Kupiłem łańcuch 50 diod 12mm. Całość może pobrać do 15W (50 x 60mA przy 5V) więc zastosowałem zasilacz 12V 2A oraz trzy moduły przetwornic na układach LM2596. Dlaczego aż trzy? Widząc grubość tych przewodów w łańcuchu obawiałem się, że na końcu może być już zauważalnie niższa jasność. Żeby tego uniknąć podzieliłem go na 3 sekcje zasilania bez rozłączania przewodu sygnałowego ze wspólna masą (przetwornice są nieizolowane). Do sterowania diodami wziąłem arduino pro mini (w moim przypadku klona), peryferiami się trochę marnuje ale to akurat miałem w szufladzie a cena jest bardzo atrakcyjna. Jako interfejs użytkownika użyłem enkodera z przyciskiem, poza tym jest tylko włącznik zasilania na tyle obudowy. Schemat jako taki nigdy nie powstał, jest to dość prosta konstrukcja, wszystkie połączenia można wywnioskować z kodu. Arduino jest zasilane z jedn z przetwornic, miałem jakiś problem z zasilaniem go z 12V, podłączyłem do 5V i działa (a już myślałem, że odejdzie do krainy wiecznych łowów, na szczęście nie). Program Napisany w arduino z bibliotekami do obsługi enkodera, diod i przyciśnięć (tutaj podziękowania dla @ethanak, sam bym nie wpadł, żeby takiej biblioteki poszukać). Dzięki nim nie musiałem się zajmować szczegółami ich sterowania zwłaszcza, że orłem programowania to ja nie jestem. Dzięki nim poszło w miarę szybko a efekty są co najmniej zadowalające. Jeżeli chodzi o efekty świetlne to na początku bazowałem na przykładach od adafruit ale niestety są one oparte na delayach a tutaj jest to nie do przyjęcia. Później, kiedy nie udało mi się samodzielnie przerobić ich, żeby je usunąć znalazłem w internecie ten kod , który temat rozwiązał. Menu napisałem sam z użyciem biblioteki Rotary.h oraz PMButton.h. Obsługa lampki Lampka domyślnie jest wyłączona (diody się nie świecą, arduino jest zasilone) dwu sekundowe przytrzymanie przycisku włącza lampkę z domyślnym trybem pierwszym w menu oraz najmniejszą jasnością. Jednorazowe kliknięcie to zmiana trybu, kręcenie enkoderem zmienia jasność świecenia. Kolejne dwusekundowe przytrzymanie wyłącza świecenie. W czasie pracy na maksymalnej mocy dół lampki nagrzewa się do ok 30*C, uważam to za bardzo dobry wynik. Dławiki przetwornic mają ok. 30-35*C. Trudności, przemyślenia Z całego tego projektu najprostsza okazała się część elektroniczna, kawałek płytki uniwersalnej, 4 moduły i trochę czasu. Trudności zaczęły się gdy przyszło do wykończenia obudowy, bardzo obawiałem się wiercenia w tym plastiku z obawy o pęknięcie. Swoją drogą robienie małych otworów też nie jest takie proste, dremel na najmniejszych obrotach i tak kręci się za szybko, topi plastik i trzeba wiercić na kilka razy. Wycinanie otworu na gniazdo zasilające poszło gładko, diamentowa tarcza dała sobie radę bez problemu. Pozostałą szparę nad nim zakleiłem klejem montażowym. Jak już się z całą resztą uporałem to przeszedłem do pisania programu. Bardzo doceniam wszystkich twórców, którzy wstawiają swoje, działające, kody do internetu, bardzo pomogły i ten etap przeszedłem z tarczą. W sumie to z tego też powodu źródło zostawiam w załączniku, jak ktoś potrzebuje jakiś kawałek albo chce sobie zbudować (a może nawet ulepszyć) to można brać do woli. Podsumowanie Budowa tej lampki zajęła mi około miesiąca i cieszę się, że wreszcie zbudowałem coś takiego od początku do końca. Młodemu (a w szczególności jego rodzicom) się bardzo spodobało więc myślę, że cel zrealizowany. Ja też się trochę nauczyłem i za to bardzo sobie to cenię. Kilka zdjęć z budowy: Niestety zapomniałem o zdjęciu lampki w całości, w działaniu. Postaram się to nadrobić. Jeżeli macie jakieś pytania albo czegoś nie napisałem/napisałem niezrozumiale to proszę o zwrócenie uwagi, odpowiem i uzupełnię opis. lampaRGB.zip
  18. Witam, od kiedy kupiłem swoje arduino (było to ze trzy lata temu) to chciałem zbudować frezerkę do płytek pcb. Obejrzałem w Internecie wiele projektów i w końcu postanowiłem zbudować swoją własną frezarkę :). Pochłonęła ona dużo pieniędzy i jeszcze więcej czasu. Swoje prace zacząłem od kupienia profili 25mmx 1.5mm x 2000mm (dwie sztuki) i kilkanaście kątowników. Wymierzyłem całą konstrukcję i zacząłem składać stelarz stołu a następnie go pomalowałem podkładem i czarną farbą matową. Gdy farba schła zamówiłem wsporniki wałków, wałki fi 12, łożyska oraz kupiłem skleję 10mm na stół. następnym krokiem było położenie blachy na stół żeby nie zniszczyć sklejki potem zacząłem składać oś Z z wałków fi 8 Kilkanaście dni później kontrukcja wyglądała następująco została postawiona brama, została ona wzmocniona zastrzałami z tyły oraz lewa i prawa strona bramy została połączona płaskownikiem stalowym 4mm x 20mm. Cała konstrukcja była bardzo solidna. Pozostało pomalowanie bramy na kolor czarny mat ale to dopiero w wakacje jak zrobi się ciepło Dzisiaj odbyły się pierwsze testy bezpieczeństwo przede wszystkim Całość wymaga oczywiście kalibracji oraz muszę kupić nakrętki bezluzowe na śruby trapezowe. Całość jest sterowana a pomocą GCode. Obszar roboczy to 40cm x 40cm. Elementy potrzebne do budowy to: 4 wałki fi12 (dwa na oś X i dwa na oś Y) 2 wałki fi8 8 wsporników wałków fi 12 4 wsporniki wałków fi 8 profile na stelarz blacha aluminiowa na oś Z trzy zestawy składające się z śruby trapezowej wraz z nakrętką, uchwytem nakrętki, łożyskami samonastawnymi, sprzęgła elastycznego (po komplecie na każdą oś) 3 silniki krokowe 3 mocowania silników arduino 3 sterowniki silnków krokowych CNC shield zasilacz 12V 4A frezy V 20 stopni komplet wierteł od 0.6mm do 1.5mm Potrzebujemy jeszcze silnik do wrzeciona, ja użyłem "pisaka" i dremela. Kosztów nie liczę gdyż nie chcę się załamać ale frajda z budowy była ogromna. Płytki pcb projektuje w Eaglu następnie tworzę gerbery które ląduję do programu flatcam. W tym programie ustawiam wymiary frezu, wierteł i generuje gcode który przesyłam do Arduino za pomocą programu source rabbit gcode sender. Ważna rzecz, przed zaladaowanie pliku drill do flatcamu musimy się upewnić ze każda współrzędna składa się z takiej samej ilości znaków jeśli nie to musimy dopisać odpowiednią ilość zer na początku (tzn po X lub Y ) następnie gdy załamujemy plik drill do flatcamu musimy zmniejszyć skalę tego pliku. Wchodzimy właściwości> scale i ustawiamy na 0.1
  19. Ze zrobieniem tego typu urządzenie nosiłem się od dłuższego czasu. Przeznaczenie oczywiście dla dzieci i tak jak w tytule są to podstawowe działania matematyczne. Zanim powstał ten projekt sam program był już napisany w codeblocksie. Smartfon całkowicie się nie sprawdził bo córkę interesowało wszystko tylko nie nauka prostych zadań. Na PC już lepiej to wyglądało ale nadal te ikonki w tle trochę odciągały uwagę a samo włączanie komputera tylko dla uruchomienia takiego prostego programu chwilami było irytujące. Więc powstało coś takiego... Wiem, że dla wielu osób może okazać się to śmieszne ale u mnie sprawdziło się idealnie. Nie muszę włączać komputera dziecko zajmuje się tylko tym co powinno bo niema tu niczego co mogło by odciągać uwagę. Nawet wieczorem przed snem można na chwilę włączyć tą zabawkę i poćwiczyć. Opcji jest niewiele a w zasadzie tylko te najpotrzebniejsze czyli zmiana zakresu liczb co jeden w górę i w dół i wyłączenie/włączenie podświetlenia. tak prawie wygląda bez podświetlenia. Napisałem prawie bo zdjęcie było robione z włączonym podświetleniem ale w rzeczywistości wygląda dokładnie tak samo. Zanim za zabawka powstała to było to coś nieokreślonego co służyło w różnych celach tam gdzie potrzebny był wyświetlacz i klawiatura. Wyglądało to tak... Takie były tego początki chyba dwa lata temu. Obudowa powycinana mało estetycznie aczkolwiek trudno jest to zrobić ręcznie w lepszy sposób. Celem zamaskowania i zabezpieczenia została oklejona taśmą Następnie przykleiłem paski z taśmy obustronnie klejącej (do wklejania LCD) i przykleiłem szablon , który widać na pierwszych zdjęciach. I w zasadzie to by było tyle od zewnątrz a od środka najpierw wyglądało to tak. Wiele tu nie trzeba mówić natomiast w takiej konfiguracji obudowy nie dało się zamknąć. Zarówno arduino jak i konwerter lcd wystawały ponad obrys obudowy. Konwerter z wyświetlaczem był połączony na "wsuwki" więc musiałem wylutować goldpiny i zalutować konwerter na wyświetlacz i tak pomału jeden za jednym zostawiłem tylko zworkę od podświetlenia. Następnie zastanawiałem się jak to zrobić z tą klawiaturą żeby pozbyć się tych kabli bo jak by nie było to wprowadzają sporo zamętu. I tak sobie pomyślałem , że może by spróbować zalutować arduino na goldpiny od klawiatury tak jak konwerter lcd. Mialem akurat arduino pro mini , które przymierzyłem na piny od klawiatury i bomba pasowało idealnie. Jak tak na to popatrzyłem to na początku zastanawiałem się co by tu zrobić i tym wolnym miejsce bo zrobiło się go naprawdę sporo. I na początku myślałem o czytniku kart SD pod SPI ale ostatecznie stwierdziłem , że zrobię to w najprostszy możliwy sposób. Zasilanie było już na miejscu więc zostało wgranie skecza przez konwerter. Całość świetnie się sprawdziła. Można wygodnie położyć na łóżku i obserwować postępy jakie robi dziecko i to bez komputera czy smartfona.
  20. Cześć W ramach zabicia czasu zbudowałem tracker do gry Fortnite, który chciałbym Wam przedstawić. Urządzenie łączy się z siecią WIFI za pomocą modułu ESP - Wemos D1. Za za wyświetlacz robi - dotykowy LCD TFT 2.4" ze sterownikiem ILI9341. Zasilanie to bateria lipol wraz z modułem ładowania. Podsumowując jest to taki składak z gotowych modułów Obudowa została wydrukowana na drukarce 3D a oprogramowanie napisałem w Arduino. Całość ściąga aktualne dane z sieci za pomocą API i wyświetla je na ekranie. Uprzedzając pytania - nick gracza jest przypadkowy:)
  21. W moim poprzednim projekcie niektórzy przeczytali zapewne wzmiankę o tym , że powstała jego oddzielna wersja z modułem GSM , który całkiem nieźle sobie radził. Pomyślałem więc , że czemu by go tutaj nie opisać w końcu sam projekt został ukończony. tutaj początki czyli zlutowany moduł neoway a w tle genuine arduino uno , które w początkowej fazie zostało wykorzystane do przetestowania coś na zasadzie "czy to będzie działać". Okazało się , że tak aczkolwiek trzeba było dokonać zmiany baud rate na 9600 bit/s. Pod arduino jest bateria ze smartfona z , której zasilany jest moduł. Natomiast na arduino nakładka , która dała łatwiejszy dostęp (powielony) do pinów zasilania i masy. Na płytce stykowej widać konwerter poziomów logicznych przez który odbywa się komunikacja (SoftwareSerial). Piny IO modułu neoway pracują z napięciem 2,85V ale tolerują napięcie do 3,3V. Dobrze jest sprawdzić napięcie na pinie 3,3V przed podaniem go na konverter (w orginalnym uno nie będzie raczej problemu ale jeśli to będzie klon to możecie się zaskoczyć). Po kilku testach postanowiłem całość nieco zmniejszyć. to w zasadzie dalej jest to samo tyle , że model arduino uno zastąpiłem nano jeszcze z ATMega 168. Tact switch nad modemem to przycisk on/off , który uruchamia modem po dłuższym przytrzymaniu. tutaj już prawie wszystko było gotowe. Nad modemem przetwornica step-up regulowana. Wyjście z przetwornicy ustawione na 4,89V. Pewnie zastanawiacie się czemu na nie na 5V a to dlatego, że w tym modelu na pinie 3,3V jest 3,4V to wolałem nie ryzykować i lekko obniżyłem napięcie zasilania co dało pożądany rezultat w postaci spadku napięcia na pinie 3,3V nawet lekko poniżej 3,3V. ogniwo 18650 które widzicie pojawiło się tylko tymczasowo jako źródło zasilania aczkolwiek gdyby obudowa była większa to pewnie bym je zostawił. Na płytce znajdują się 4 DIP switch'e i tak pierwszy od góry włącza/wyłącza przetwornicę i tym samym doprowadza napięcie do wszystkich modułów poza modemem gsm (modem jest zasilany bezpośrednio z ogniwa). Następnie dwa DIP switch'e obok siebie wlączają/wyłączają piny TX i RX arduino od bluetooth. Ostatni DIP switch odcina napięcie do arduino. W ten sposób można wgrywać skecze do arduino po usb bez rozłączania kabli. Po prawej stronie mamy czujnik ruchu a po lewej to ten "stary telefon" w , którym nie działa dotyk ale można do niego podłączyć mysz. tutaj widać kolejno, start modemu, sprawdzenie rejestracji do sieci , siłę i jakość sygnału, a na koniec napięcie ogniwa. void skalaAku() { int aku2 = analogRead(A6); if ((aku2 == 860) && (charging == 0)) { digitalWrite(4, HIGH); //wyłączamy przekaźnik zasilania tp4056 Serial.println("Ogniwo max"); skala = 0; charging++; } else if ((aku2 == 790) && (skala == 0)) { m590.write("AT+CMGS=\"111222333\"\r"); // podajemy nr telefonu delay(300); getm590(); m590.write("Ogniwo 3,9V"); //podajemy treśc wiadomości m590.write(26); // Kod 26 = CTRL+Z delay(2000); // czekamy na wysłanie getm590(); // sprawdzamy czy poszło czy error skala++; } else if ((aku2 == 720) && (skala == 1)) { //740 OK m590.write("AT+CMGS=\"111222333\"\r"); // podajemy nr telefonu delay(300); getm590(); m590.write("Ogniwo 3,5V"); //podajemy treśc wiadomości m590.write(26); // Kod 26 = CTRL+Z delay(2000); // czekamy na wysłanie getm590(); // sprawdzamy czy poszło czy error digitalWrite(4, LOW); //włączamy przekaźnik zasilania tp4046 charging = 0; skala++; delay(300); } else if ((aku2 == 705) && (skala == 2)) { m590.write("AT+CPWROFF\r"); } } Tutaj mamy funkcję, która była wykonywana przez około tydzień czasu no i raz nie dostałem sms'a. Czas pracy na jednym cyklu ładowania to było jakieś 17h jak dobrze pamiętam więc wychodziło 2 smsy na dobę. Jeżeli ktoś chciał by z tej funkcji skorzystać to trzeba... void getm590() { if (m590.available() > 0) { Serial.print(m590.readString()); } } najpierw wpisać tą funkcję albo przynajmniej wcześniej zadeklarować , że funkcja getm590() wystąpi oraz zadeklarować dwie zmienne typu int , które występują w funkcji skalaAku() a to "świeże zdjęcie" dzisiaj zrobione na potrzeby opisu ale sam projekt tak wyglądał już w lipcu 2018 i tak jak wyżej pisałem bateria ze smartfona wróciła pod płytkę a zaoszczędzone miejsce zostało przeznaczone na moduł z dwoma przekaźnikami i od góry ładowarka tp 4056. Jeden przekaźnik może trochę dziwnie wykorzystany ale chciałem żeby ładowarka była wyłączana przed przekroczeniem napięcia 4,2V na baterii co widać w kodzie. tak to wyglądało po zamknięciu i jedynym problemem było to , że PIR sam się wzbudzał co kilka godzin pracy nawet po próbie przeniesienia go poza obudowę. Przyczyn dalszych nie szukałem bo tak jak napisałem na początku projekt powstał aby przetestować sam modem a ten nawet całkiem dobrze radził sobie z raportowaniem stanu naładowania baterii.
  22. witam kupiłem Geekcreit® DIY Biaxial Spherical Rotating LED Kit z banggood i mam problem z pomiarem obrotów i przez to urządzenie nie chce działać wydaje mi się że problem powstaje w układzie zasilającym ale niestety nie mogę dojść do tego co konkretnie szwankuje Chińczyk wysłał instrukcję naprawiania błędów punkt 4: ④. Użyj multimetru, aby sprawdzić napięcie modułu mocy, czy wynosi ono około 4V. Jeśli nie, sprawdź moduł mocy zgodnie z instrukcją. u mnie bez obciążenia jest 12 a z 1 w czym może być problem ja nie wiem . chyba że to problem z odbiornikiem : cały schemat Proszę o pomoc przejrzałem chyba wszystkie luty i ustawienia elementów . i nie wiem co dalej robić jeszcze takie pytanie co oznacza symbol na obrazku w czerwonym prostokącie? Dziękuję za wszelką pomoc. LED debug instruction V1.0.pdf Schematic diagram.pdf dopiero zaczynam z elektroniką więc mogę jeszcze nie wszystko zrozumieć
  23. Jakiś czas temu w moje ręce trafił dość specyficzny zabytek techniki - układ MCY7880, będący jedynym mikroprocesorem produkowanym seryjnie w Polsce. Element ten był klonem intelowskiego procesora 8080, wytwarzanym przez nieistniejące już przedsiębiorstwo CEMI. Początkowo potraktowałem go jako kolejną elektroniczną ciekawostkę do kolekcji, po jakimś czasie zacząłem się jednak zastanawiać, czy nie będę w stanie wykorzystać go w bardziej konstruktywny sposób. Zacząłem więc gromadzić pozostałe elementy potrzebne do zbudowania prostego systemu mikroprocesorowego, jednocześnie wczytując się w dokumentację i literaturę komputerową z epoki. Właściwa konstrukcja zaczęła powstawać niewiele później. Z uwagi na mocno eksperymentalny charakter przedsięwzięcia zdecydowałem się pominąć etap projektowania PCB i od razu przystąpić do montażu komputera na płytce prototypowej. Najpierw wlutowane zostały podstawki pod układy scalone, potem grubszą srebrzanką poprowadziłem masę i linie zasilające. Należy tutaj nadmienić, że MCY7880 jest dość kłopotliwym procesorem, jeśli chodzi o zasilanie. Nie tylko pobór prądu jest duży jak na obecne standardy, ale także konieczne jest dotarczenie trzech różnych napięć: +12, +5 oraz -5V. Dodatkowo muszą być one podane w odpowiedniej kolejności, niedopełnienie tego obowiązku grozi uszkodzeniem procesora. Oryginalnie systemy mikroprocesorowe na MCY7880 były zasilane z dużych zasilaczy transformatorowych. Była to pierwsza z kilku kwestii, co do których zdecydowałem się na drobny kompromis i zastosowałem nieco uwspółcześnione podejście. I tak napięcie 12V jest generowane przez przetwornicę boost na MC34063A, a -5V jest pobierane z pompy ICL7660. Głowna linia zasilająca o napięciu 5V jest zasilana bezpośrednio ze współczesnego, stabilizowanego zasilacza impulsowego. Po poprowadzeniu masy i zasilania, a także wlutowaniu wszystkich elementów pasywnych, przyszedł czas na najbardziej mozolny etap projektu. Łączenie linii sygnałowych przy pomocy kynaru. Bardzo dużej ilości kynaru. Zajęło mi to kilka wieczorów. O dziwo pomyliłem się tylko raz, zapominając o podciągnięciu jednego z wyprowadzeń EPROM-u do 5V. Po przebadaniu magistrali oscyloskopem i analizatorem stanów logicznych stwierdziłem, że procesor zachowuje się prawidłowo pracując "na luzie" (szyna danych pociągnięta w sposób wymuszający ciągłe wykonywanie instrukcji NOP i zwiększanie licznika instrukcji). Przyszedł więc czas na zaprogramowanie pamięci EPROM. Na potrzeby tego projektu zaopatrzyłem się w chiński programator oraz urządzenie do kasowania tych zabytkowych pamięci. Zapoznałem się także z podstawami asemblera 8080. Pierwszy napisany program służył rzecz jasna do migania diodą podłączoną do znajdującego się na płytce układu 8255. Potem zabrałem się za portowanie TinyBASIC-a, który po jakimś czasie udało mi się odpalić na tym komputerze. Obecnie POLON 7880 może komunikować się ze światem jedynie przez port szeregowy RS232, zrealizowany za pomocą układu 8251 oraz konwertera MAX232. W planach na bliżej nieokreśloną przyszłość jest budowa dodatkowej płytki z interfejsem monitora CRT i klawiatury, a być może także i sterownikiem stacji dyskietek. Pozwoliłoby mi to na uruchomienie systemu operacyjnego CP/M - organizacja pamięci komputera jest do tego przystosowana. Oczywiście najprostszym rozwiązaniem byłoby symulowanie układów I/O za pomocą jakiegoś współczesnego mikrokontrolera, wolałbym jednak wykorzystać w tym celu oryginalne układy scalone z epoki.
  24. Witam! Na wstępie chcę zaznaczyć, że mam 13 lat. Chciał bym zaprezentować mój projekt. Jest nim zegar, który oprócz czasu pokazuje temperaturę z dwóch czujników oraz sterownie podczerwienią przekaźnik. Potrzebne części: Płytka Arduino (ja użyłem nano ale inne też się sprawdzą) Zegar czasu rzeczywistego DS3231 RTC Dwa czujnik temperatury DS18B20 Przekaźnik 1-kanałowy Czujnik podczerwieni z serii TSOP (używałem TSOP2238) Przycisk (np. tact swich) Wyświetlacz 16x2 z konwerterem I2C Potencjometr 10k Rezystor 4,7k Niestety nie mam możliwości dodać schematu. Podłączenie elementów do Arduino: Wszystkie GND i VCC należy podłączyć do GND i +5V SCL (Zegar + wyświetlacz) - A5 SDA (Zegar + wyświetlacz)-A4 Pin sygnałowy przekaźnika - 10 Przycisk - GND i 6 Dwa sygnały z czujników temperatury - A0 Sygnał czujnika podczerwieni - 11 Potencjometr należy przyczepić na konwerterze I2C ekranu zamiast zworki( dwa piny połączone zworką) Uwaga! Należy wstawić rezystor 4,7k pomiędzy pin sygnałowy a VCC czujników temperatury. Jego brak może uniemożliwić pomiar temperatury. Wystarczy umieścić jeden na oba czujniki. Kod zegara: #include <RTClib.h>//Dodawanie bibliotek #include <OneWire.h> #include <DallasTemperature.h> #include <Wire.h> #include <LiquidCrystal_I2C.h> #include <IRremote.h> #define irPin 11 IRrecv irrecv(irPin); decode_results results; #define prz 10 int przStatus = LOW; OneWire oneWire(A0); //Podłączenie do A0 DallasTemperature sensors(&oneWire); //Przekazania informacji do biblioteki DateTime now;//Now to jest data i czas char daysOfTheWeek[7][12] = {"Ndz", "Pon", "Wt", "Sr", "Czw", "Pt", "Sob"}; RTC_DS3231 rtc; LiquidCrystal_I2C lcd(0x3F, 16, 2); //Ustawianie wyswietlacza lcd void showDate(void);//Ustawianie dayt czasu i dnia void showTime(void); void showDay(void); int przycisk = 6;//Przycisk do wyswietlania temperatury void setup () { Serial.begin(9600);// Ustawianie transmisji UART pinMode(przycisk, INPUT_PULLUP);//Ustawianie przycisku jako wejscie lcd.begin();//Wloczenie lcd lcd.backlight();//Wloczenie podswietlenia lcd sensors.begin();//Wloczenie czujnikow irrecv.enableIRIn(); pinMode(prz, OUTPUT);//Ustawienie if (! rtc.begin()) //Jesli nie moze znalesc RTC wyswietl { Serial.println("Nie moge znalesc RTC"); while (1); } if (rtc.lostPower()) //Jesli RTC nie ma zasilania to wyswietl { Serial.println("RTc nie ma zasilania ustaw godzine!"); rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); } rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); } void loop () { if (irrecv.decode(&results)) { //Jesli czujnik odbirze sygnał switch (results.value) { case 0xFF21DE: przStatus = ~przStatus; digitalWrite(prz, przStatus); delay(250); break; } irrecv.resume(); } if(digitalRead(przycisk)== LOW)//Jesli przycisk jest wcisniety { lcd.clear(); lcd.setCursor(0, 0); lcd.print("Temp(W)"); lcd.setCursor(9, 0); lcd.print("Temp(Z)"); sensors.requestTemperatures(); lcd.setCursor(1, 1); lcd.print(sensors.getTempCByIndex(0)); lcd.setCursor(10, 1); lcd.print(sensors.getTempCByIndex(1)); delay(4000); lcd.clear(); } now = rtc.now();//Ustawianie pętli showDate(); showDay(); showTime(); } void showDate()//Kod petli showDate { lcd.setCursor(0,0); lcd.print(now.day()); lcd.print('-'); lcd.print(now.month()); lcd.print('-'); lcd.print(now.year()); } void showDay()//Kod petli showDay { lcd.setCursor(11,0); lcd.print(daysOfTheWeek[now.dayOfTheWeek()]); } void showTime()//Kod petli showTime { lcd.setCursor(4,1); lcd.print(now.hour()); lcd.print(':'); lcd.print(now.minute()); lcd.print(':'); lcd.print(now.second()); lcd.print(" "); } Po kliknięciu przycisku na wyświetlaczu pojawia się temperatura wewnątrz i zewnątrz. Czujnik najlepiej dobrać do własnych potrzeb. Ja wybrałem DS18B20 ponieważ jest on dokładny oraz występuje w wygodnej wodoodpornej osłonce oraz bez niej . Jeśli wszystko działa to przy pomocy potencjometru powinna zmieniać się jasność wyświetlacza. Ja użyłem zegara czasu rzeczywistego DS3231 RTC ale jeśli macie możliwość zakupu DS1307 RTC albo RTC PCF8563 to kupcie jeden z tych dwóch. Ja z mojego nie jestem zadowolony ,ponieważ przysporzył mi wiele problemów. W 65 linijce kodu jest zawarty numer przycisku na pilocie "0xFF21DE". Każdy przycisk na pilocie ma swój indywidualny numer. Program sprawdzający takowy jest taki: #include <IRremote.h> #define irPin 11 IRrecv irrecv(irPin); decode_results results; void setup() { Serial.begin(9600); irrecv.enableIRIn(); } void loop() { if (irrecv.decode(&results)) { Serial.print("0x"); Serial.println(results.value, HEX); delay(250); irrecv.resume(); } } Po kliknięciu przycisku na pilocie przekaźnik zmieni swój stan. Jest wiele dobrych pilotów. Lecz jest jedna ważna sprawa. Mianowicie używamy tu czujnika działającego na częstotliwości 38kHz więc pilot tego typu działa świetnie ,ponieważ działa na tej samej częstotliwości. Lecz jeśli z jakiegokolwiek powodu nie macie pilota albo czujnika działającego na 38kHz to nie ma się czym przejmować. Sam używam innego pilota i wszystko działa. Wyświetlacz można dobrać dowolnej wielkości. Trzeba tylko zmienić ustawienia wyświetlacza. Pozdrawiam!
×
×
  • Utwórz nowe...