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 27 wyników

  1. 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.
  2. Julek

    Zaawansowany zegar

    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!
  3. atlantis86

    6502 jako mikrokontroler

    Zdecydowałem się przestawić swój kolejny projekt utrzymany w klimatach retro. Wszystko zaczęło się jakiś rok temu, gdy przypadkowo odkryłem, że sprzedawcy na popularnych chińskim serwisie aukcyjnym posiadają podejrzanie duże ilości podejrzanie tanich układów MOS6502. Wydało mi się to zbyt piękne, aby było prawdziwe. Z ciekawości zamówiłem kilka sztuk, płacąc za nie kilka dolarów i zapomniałem o całej sprawie, licząc na to, że pewnie otrzymam podróbki z wygrawerowanymi laserowo oznaczeniami. Jak bardzo się myliłem! Po uruchomieniu na płytce prototypowej okazały się być prawdziwymi układami MOS6502, wykonanymi w technice NMOS. Zabrałem się więc za projektowanie właściwej płytki, myśląc o stworzeniu swojego własnego komputera pracującego pod kontrolą języka BASIC. Ten projekt ciągle jest w realizacji, ale nie o nim chcę tutaj napisać. W międzyczasie bowiem w mojej głowie pojawił się jeszcze jeden pomysł. Chciałem sprawdzić jak ta rodzina procesorów sprawdza się w roli mikrokontrolera. Albo innymi słowy - byłem ciekaw co by było, gdyby Arduino powstało trzydzieści lat temu. Tym razem od brytyjskiego sprzedawcy na eBay-u zamówiłem kilka sztuk nowszych procesorów WDC65C02, wykonanych w technologii CMOS. Zastosowanie tej wersji układów nie tylko zmniejszało znacznie pobór prądu, ale także upraszczało układ, niwelując konieczność stosowania bufora szyny adresowej. Za punkt wyjścia do tego projektu posłużyła płyta procesorowa mojego ciągle powstającego komputera na MOS6502, która została poddana pewnym modyfikacjom. Przede wszystkim zmieniła się organizacja pamięci - zwiększyłem ilość EPROM-u kosztem RAM-u, dodana została także pamięć EEPROM. Organizacja pamięci wygląda następująco, zaczynając od 0x000: 8 kB pamięci RAM 8 kB przestrzeni adresowej I/O 8 kB pamięci EEPROM 8 kB układ EPROM (dodatkowa pamięć, obecnie niewykorzystywana) 32 kB EPROM (główna pamięć, przechowująca program, dane i adresy wektorów) Urządzenie pracuje z prędkością 4 MHz. Sygnał taktowania pochodzi z jednoukładowego generatora kwarcowego. Układ DS1232 odpowiada za obsługę wejścia RST (likwidacja drgań styków i obsługa power-on reset). Urządzenie posiada także port wyjściowy na 74HCT373 - można za jego pomocą migać dwiema diodami, pozostałe linie są wyprowadzone na złącze IDC-40. Dekoder adresów jest zrealizowany na układach 74HCT138 i 74HCT139. Dodatkowo kilka bramek układu 74HCT00 posłużyło do generowania sygnałów !RD i !WR, wykorzystywanych w układach kompatybilnych z magistralą intela (a więc także zastosowanych pamięciach). Wszystkie sygnały szyny danych, adresowej, te związane z obsługą przerwań oraz wyjścia dekodera adresów są wyprowadzone na złącze IDC-40. Moim zamiarem było stworzenie płytki, która nie tylko będzie mogła służyć do eksperymentów z historyczną rodziną procesorów, ale także będzie mogła posłużyć jako podstawa do budowy jakiegoś użytecznego projektu, poprzez dodanie odpowiednich modułów, na wzór shieldów Arduino - z tą różnicą, że podpinanych bezpośrednio do magistrali procesora za pomocą taśmy IDC-40. Na pierwszy ogień poszła płytka zawierająca wyświetlacz HD44780 (4x20) oraz kilka przycisków tact switch. Wyświetlacz pracuje bezpośrednio na magistrali procesora - do tego w końcu został zaprojektowany. Konieczne było tylko dodanie prostej logiki, generującej sygnały sterujące. Od strony programowej obsługa wyświetlacza w takich systemach jest nawet prostsza niż obecnie - wystarczy jedynie wpisywać odpowiednie wartości pod odpowiednie adresy w przestrzeni adresowej procesora. Przyciski posiadają własny port wejściowy, zrealizowany na 74HCT245. Praca nad tym projektem była dla mnie także okazją do zapoznania się z asemblerem 6502, chociaż prawdę mówiąc większość kodu napisałem w C posługując się kompilatorem cc65, uzupełniając go o asemblerowe wstawki. Co prawda jest to dość prosty kompilator i być może nie nadaje się do pisania gier pod Commodore C64, ale w w tego typu zastosowaniach sprawdza się całkiem nieźle.
  4. Telegram – darmowy, niekomercyjny bazujący na chmurze obliczeniowej komunikator internetowy. Użytkownicy mogą wysyłać wiadomości, zdjęcia, filmy, naklejki, nagrania oraz pliki różnego typu. Internet rzeczy od dawna wkracza w codzienne życie - inteligentny dom, inteligentny telewizor, a nawet inteligentny czajnik. Podstawą naszych projektów będzie płyta NodeMCU z wbudowanym układem ESP. Jak również małe rzeczy, które ma każdy inżynier elektronik: diody LED, przewody łączące, płytka prototypowa i przewód microUSB do flashowania i zasilania płyty. Schemat podłączenia: Krótka noga diody LED w ziemi, długa szpilka D3. Nie zapominaj, że płyta ma kilka cech w kategorii pinów, więc dołączam pinout. Dodanie nodemcu do Arduino IDE (połączenie pakietu esp8266). Instalacja pakietu ESP8266 będzie konieczna, abyśmy mogli pracować z nodemcu w IDE Arduino. Przed zainstalowaniem pakietu upewnij się, że nie masz zainstalowanej innej wersji. W przeciwnym razie pamiętaj o usunięciu go przed instalacją. A następnie wykonaj proste czynności: Uruchom środowisko programistyczne - Arduino IDE Otwórz ustawienia W polu "Dodatkowe linki do Menedżera płyt" wklej link do pakietu esp8266 http://arduino.esp8266.com/versions/2.3.0/package_esp8266com_index.json Idź do Narzędzia - Płyty- Menedżera płyt Przewiń w dół. Znajdź esp8266. Wybierz wersję 2.3.0. Zainstaluj. W Narzędzia - zakładka wybierz nodemcu. Reszta ustawień płyty zostanie ustawiona automatycznie. Zdjęcia są po-rosyjsku, ale interfejs jest taki sam. Zainstaluj bibliotekę telegram Aby nasz elektroniczny przyjaciel pojawił się na tablicy, będziesz potrzebować biblioteki https://github.com/CasaJasmina/TelegramBot-Library Tworzenie bota telegramu Nadszedł czas, aby stworzyć naszego cyfrowego przyjaciela, który będzie wiernie i łagodnie obsługiwał wszystkie nasze zespoły. Otwórz bot @BotFather. Aby utworzyć nowego bota write /newbot. Postępuj zgodnie z instrukcjami, wybierz nazwę i zaloguj się na nią, a na koniec skopiuj token bota, będziesz potrzebować go podczas flashowania tablicy nodemcu. Oprogramowanie Łączymy potrzebne biblioteki. #include <ESP8266WiFi.h> #include <WiFiClientSecure.h> #include <TelegramBot.h> Wskazujemy pin diody, wifi sieć token bota. #define LED 0 //D3 const char* ssid = "ssid"; const char* password = "password"; const char BotToken[] = "token:token"; Wskazujemy bota WiFiClientSecure net_ssl; TelegramBot bot (BotToken, net_ssl); W void setup ustawiamy szybkość komunikacji z komputerem, spróbujemy połączyć się z Wi-Fi, wpisujemy adres IP urządzenia w sieci, uruchamiamy bota i konfigurujemy pinmode dla diody LED. void setup() { Serial.begin(9600); WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } Serial.println(""); Serial.println("WiFi connected"); Serial.println(WiFi.localIP()); bot.begin(); pinMode(LED, OUTPUT); } Patrzymy do void loop. Sprawdzamy, czy mamy nowe wiadomości. message m = bot.getUpdates(); Czytamy wiadomość i robimy odpowiednie żądanie. if (m.text.equals("on")){ digitalWrite(LED, HIGH); bot.sendMessage(m.chat_id, "The Led 1 is now ON"); }else if (m.text.equals("off")){ digitalWrite(LED, LOW); bot.sendMessage(m.chat_id, "The Led 1 is now OFF"); } Szkic: https://drive.google.com/open?id=1QAi0px4sz3RTfgBjZFvs_rP2KBU84z7O Wgrywamy szkic do płyty. Testujemy Gdy, szkic jest na płycie i obwód jest podłączony do źródła prądu, możemy przetestować urządzenie. Wyślijmy “on” lub “off” aby włączyć lub wyłączyć diodę. Druga część artykułu to prototyp domu inteligentnego. Przed rozpoczęciem montażu określmy funkcje tego urządzenia: Kontrola obciążenia AC Sterowanie taśmą LED RGB Informacje o wizycie w lokalu Ekran z notatkami i czasem Informacje o temperaturze, ciśnieniu i wilgotności gleby Pierwszym krokiem w montażu urządzenia wieloskładnikowego będzie praca z chłodzeniem, prototypowaniem i zasilaniem. Zalecam zainstalowanie na chipie radiatore esp12, ponieważ sam układ na płycie nodemcu nagrzewa się nawet bez podłączonych czujników. Planujemy podłączyć dużą liczbę urządzeń I / O i jednocześnie przesyłać dane przez Internet, co bez dodatkowego chłodzenia doprowadzi do awarii. Grzejnik jest mocowany w najprostszy możliwy sposób za pomocą dwustronnej taśmy przewodzącej ciepło (można ją kupić od Chińczyków za 2,5 USD). Jako grzejnik można użyć dowolnego profilu aluminiowego. 2) Dla wygody podłączenia płytki i urządzeń, proponuję podzielić standardową płytkę na części. Bierzemy jedną dużą płytkę i dzielimy ją na pół. Z jednej strony oderwij linię energetyczną. Bierzemy każdy kawałek sklejki i przyklejamy uzyskane części, jak sobie życzysz, ale radzę skupić się na drutach łączących. Dla wygody możesz podpisać linię energetyczną markerem. Najważniejszą częścią przygotowania do montażu - jest zasilianie. Powinno wystarczyć, więc bierzemy ładowarkę na 2 ampery. Wtyczka zasilania powinna być tak umieszczona, abyś mógł wygodnie pracować. Najpierw obróć niepotrzebny przewód USB do zasilacza. Z jednej strony powinna być wtyczka USB, az drugiej dwie nogi z 5 V i ziemią. Dołącz go do linii 5V. OD niej podłącz nodemcu za pomocą czarnego i czerwonego przewodów. 3.3V weźmiemy od płyty, bo ona ma przetwornik napięcia ams1117, który da 800mA, czego nam wystarczy. Weź od płytki 3,3 V i i podłączyć do odpowiedniej linii energetycznej za pomocą czarnych i pomarańczowych przewodów. Prace przygotowawcze zostały zakończone, oznacza to, że nadszedł czas, aby rozpocząć selekcję komponentów w celu rozwiązania tych celów. Zarządzanie gniazdami: aby kontrolować prąd przemienny, potrzebujemy relay. Zarządzanie paskiem LED RGB: aby kontrolować pasek LED, będziemy potrzebować 3 tranzystorów mosfet , 3 rezystorów o 100 om i 3 o 10 kom każdy. Fiksacja ruchu: aby fiksować ruch, potrzebujemy czujnika ruchu PIR. Informacje o temperaturze: do pomiaru temperatury użyjemy czujnika ds18b20. Informacje o ciśnieniu: do pomiaru ciśnienia użyjemy czujnika bmp180. Informacje o wilgotności gleby roślinnej: do pomiaru wilgotności gleby używamy odpowiedniego czujnika. Wyświetl czas i notatki: Aby wyświetlić czas i notatki, potrzebujesz ekranu LCD. Dodatkowe małe rzeczy Problem z breadboardem rozwiązany, ale do niego nadal potrzebne przewody tata-tata i tata-mama. Opornik 4,7 kΩ i pięć diody LED. Wybrano składniki. Łączmy je wszystkie razem. Przed montażem zwracam uwagę na to, że wszystkie moduły będą zasilane 5 woltami, z wyjątkiem ds18b20. Zasilanie uziemienia i taśmy LED muszą być podłączone. Koniecznie sprawdź adres ekranu i2c i adresy czujników temperatury. Oryginalny schemat i obrazek. Czas rzucić szkic na mikrokontroler. Zainstaluj wszystkie niezbędne biblioteki w IDE Arduino. Archiwum biblioteki można pobrać tutaj. Aby zainstalować, po prostu przenieś całą zawartość do folderu z bibliotekami. Uzupełnij adresy czujników temperatury, ekranu, pinów wszystkich modułów, ustawień sieci Wi-Fi, tokena bota. Szkic (nie zapomnij secrerts.h) Teraz, gdziekolwiek jesteś, możesz uzyskać informacje o swoim domu za pomocą telegram bota. Lista działań Relayon - włączyć rele Relayoff - wyłączyć rele Setnote text - zrobić notatkę na lcd Deletenote - usunąć notatkę RGB taśma Red - czerwony Green - zielony Blue - niebieski Off - wyłączyć taśmę Otrzymanie danych Pressure - ciśnienie Temp1 - temperatura pierwszego czujnika Temp2 - temperatura drugiego czujnika Plant - nawilżenie ziemi Last - ostatnia wizyta Timeon - czas uruchomienia systemu Łącząc odrobinę wyobraźni, możesz stworzyć wiele różnych ciekawych urządzeń, a Twój dom będzie naprawdę inteligentny. Na przykład kilka urządzeń z nodeMCU (i dowolną inną odpowiednią płytą) może wysyłać wiadomości o swoich wskaźnikach do telegramu-bota i reagować na te wskaźniki. Na przykład czujnik temperatury napisał do bota, że temperatura w pomieszczeniu wynosi 29 stopni Celsjusza. Urządzenie odpowiedzialne za włączenie wentylatora lub klimatyzatora rozważyło tę informację i zdecydowało włączyć lub wyłączyć chłodzenie, gdy stało się chłodniej. Jako zadanie domowe musisz wykonać automatyczną kontrolę odczytów z czujników, a w przypadku ważnych zdarzeń (gleba stała się sucha lub ktoś przyszedł do twojego domu), aby powiadomić cię przez telegram bota. Na wyniki muszą pisać w komentarzach. To bardzo interesujące, co zrobiłeś.
  5. Urządzenie MIDI na Arduino Pro Micro Czas na zrobienie fajnego urządzenia. W tym artykule postaram się zadowolić ludzi związanych z tworzeniem muzyki. Stwórzmy mikser Midi i podłączymy go do programu dla DJ-ów (Traktor Pro 2). Urządzenie będzie miało 8 obrotowych potencjometrów, które pozwalają kontrolować głośność, niskie, średnie i wysokie częstotliwości korektora oraz 2 przyciski odtwarzania / pauzy. Komponenty Podstawą naszego projektu będzie płyta arduino pro micro (lub arduino leonardo). Będziemy kontrolować potencjometry obrotowe. Na nich nakładamy kolorowe czapki. Będziesz potrzebował dwóch przycisków i dużego kondensatora przy 4700 UF (od 6V). Wpichnijmy to wszystko do pudełka. Elektroniczny obwód i montaż. Najpierw przygotujmy pudełko. Konieczne jest przecięcie 8 otworów o średnicy 6 milimetrów, po dwa otwory po 12 milimetrów i otwór na tylną ściankę. Kolejny etap to montowanie potencjometrów i przycisków. Włóż część i dokręć nakrętkę. Nadszedł czas na lutowanie komponentów razem. Zrobiłem wszystko na zielonej płycie prototypowej. Możesz to zrobić na bredboardzie lub wytrawić / zamówić płytkę. Nie ignoruj kondensatora, bez niego urządzenie nie zadziała! Szkic Algorytm programu jest prosty. Przeszukujemy potencjometry i przyciski, wysyłamy dane do komputera. #include <frequencyToNote.h> #include <MIDIUSB.h> #include <pitchToFrequency.h> #include <pitchToNote.h> #define n_pots 8 int val; int last_val[n_pots]={0,0,0,0,0,0,0,0}; int pot_pins[n_pots]={0,1,2,3,6,7,8,9}; #define btn0pin 2 #define btn1pin 3 void setup() { Serial.begin(9600); pinMode(btn0pin, INPUT); pinMode(btn1pin, INPUT); } void loop() { for (int i =0; i<n_pots;i++){ val = (int)analogRead(pot_pins[i])/8; if (val != last_val[i]) { last_val[i] = val; controlChange(0, i, val); } } if (digitalRead(btn0pin)){ controlChange(0,9,1); while(digitalRead(btn0pin)){} } if (digitalRead(btn1pin)){ controlChange(0,10,1); while(digitalRead(btn1pin)){} } delay(30); } void controlChange(byte channel, byte control, byte value) { midiEventPacket_t event = {0x0B, 0xB0 | channel, control, value}; MidiUSB.sendMIDI(event); MidiUSB.flush(); } Można zrobic 3d obudowę do miksera. Tak wygląda moja , ale jej plik źródłowy tu nie zostawię, bo jest dużo błędów. Kształt jest fajny, ale techniczna strona nie. Użycie: dla przykładu użycia wziąłem traktor pro 2. Otwórz go, a następnie znajdź w nim "controller manager". Tutaj wiążemy potencjometry z dźwigniami interfejsu. Naciśnij “Add device” - “Generic MIDI”. Wybierz wejscie - “Arduino Leonardo”. Teraz musisz określić wszystkie elementy sterujące. Istnieją dwa kanały, z których każdy ma: głośność, wysokie, średnie i niskie częstotliwości oraz przycisk "Play/Pause". Kliknij "Add in" i znajdź Volume / High / Mid / Low. Wybierz kanał (A lub B). Kliknij “learn”. Przekręć potencjometr. Kliknij “learn”. Zrób to z wszystkimi elementami. Dodajemy przycisk “Play/Pause”. Dodajcie go, analogicznie potencjometru. Zmienimy tryb pracy przyciska do “Toggle”. I filmik demonstracja (niestety słowa rosyjskie, ale pracę można zobaczyć): Będę czekał na komentarze!
  6. Wstęp: Na wstępie chciałbym zaznaczyć, iż jest to mój pierwszy projekt, w którym miałem możliwość wykorzystać software do projektu własnej płytki PCB i skonstruować coś co nie bazuje na płytce Arduino i nie jest plątaniną przewodów na płytce stykowej. Proszę o wyrozumiałość, a zarazem o konstruktywną krytykę i cenne wskazówki, które mogą być przydatne przy tworzeniu kolejnych projektów. Wykonany prze ze mnie projekt nie jest innowacyjny, ale dzięki niemu mogłem spróbować swoich przede wszystkim w wytrawieniu pierwszej płytki PCB. Opis: Wynikiem końcowym projektu jest niewielkie pudełko/sejf do przechowywania drobnych rzeczy, które można otworzyć po wpisaniu hasła, bądź przyłożeniu karty. Sercem układu jest mikrokontroler, który można spotkać w Arduino UNO R3. Ze względu na prostotę środowiska ArduinoIDE zdecydowałem się na implementację kodu właśnie w tym programie. W związku z tym wybór padł na mikrokontroler ATmega328P z wgranym bootloaderem dla Adruino. Takie rozwiązanie pozwoliło mi na wykorzystanie gotowych bibliotek do obsługi modułu RFID i klawiatury numerycznej. Zdecydowałem się na brak wewnętrznego źródła zasilania. Został wyprowadzony przewód USB, dzięki któremu urządzenie można podpiąć pod dowolne wyjście USB (powerbank, port USB w komputerze, ładowarka sieciowa). Urządzenie jest więc zasilane napięciem 5V DC. Wykorzystane elementy: Na projekt składają się wymienione wcześniej elementy, tj.: ATmega328P moduł RFID klawiatura numeryczna 4x3 konwerter poziomów logicznych oraz: stabilizator napięcia LF33CV rezonator kwarcowy 16MHz serwomechanizm rezystory 22Ohm oraz 10kOhm kondensatory 100nF diody LED (czerwona i zielona) + oprawki przewód USB + odgiętka na przewód przewody połączeniowe drewniane pudełko (brak linku, elementy znaleziony w piwnicy w trakcie porządków) dystans nylonowy Budowa: Po przetestowaniu działania urządzenia na płytce prototypowej znalazłem odpowiednie pudełko, w którym zmieści się układ i będzie stosunkowo estetycznie wszystko rozmieszczone. Wyciąłem miejsce na klawiaturę, miejsce na blokadę serwomechanizmu oraz wywierciłem otwory na oprawki na diody. W kolejnym kroku pokryłem pudełko matową farbą i wnętrze wypełniłem materiałem zbliżonym do okleiny na głośnikach i tubach basowych. Po wykonaniu płytki przystąpiłem do lutowania elementów. Klawiatura, moduł RFID, diody, serwomechanizm oraz złącze zasilania zostały połączone z płytką poprzez przewody połączeniowe z końcówką żeńską. Płytka PCB została umieszczona w górnej części pudełka na nylonowych dystansach. Pod płytką znalazło się miejsce na moduł RFID oraz klawiaturę i diody. Na koniec wyciąłem odpowiedni fragment deseczki balsowej z miejscem na serwomechanizm, aby ukryć przewody połączeniowe. Deseczkę balsową okleiłem tym samym materiałem co wnętrze pudełka. Oprogramowanie: Kod programu został napisany w środowisku ArduinoIDE z wykorzystaniem następujących bibliotek: Servo.h Keypad.h Password.h SPI.h MFRC522.h Kod programu: #include <Servo.h> #include <Keypad.h> #include <Password.h> #include <SPI.h> #include <MFRC522.h> //Servo Servo servo; //Password Password password = Password("1234"); //RFID const byte UID1[] = {0x70, 0xC3, 0xF9, 0x65}; const byte UID2[] = {0x35, 0xDC, 0xD7, 0x65}; const byte ROWS = 4; const byte COLS = 3; char keys[ROWS][COLS] = { {'1', '2', '3'}, {'4', '5', '6'}, {'7', '8', '9'}, {'#', '0', '*'} }; byte rowPins[ROWS] = {4, 3, 2, 0}; byte colPins[COLS] = {8, 7, 6}; Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS ); MFRC522 rfid(10, 5); MFRC522::MIFARE_Key key; void setup() { Serial.begin(9600); SPI.begin(); rfid.PCD_Init(); pinMode(A0,OUTPUT); pinMode(A1,OUTPUT); servo.attach(9); servo.write(0); keypad.addEventListener(keypadEvent); digitalWrite(A0,HIGH); digitalWrite(A1,LOW); } void loop() { keypad.getKey(); if (rfid.PICC_IsNewCardPresent() && rfid.PICC_ReadCardSerial()) { if (rfid.uid.uidByte[0] == UID1[0] && rfid.uid.uidByte[1] == UID1[1] && rfid.uid.uidByte[2] == UID1[2] && rfid.uid.uidByte[3] == UID1[3]) { servo.write(90); digitalWrite(A0, LOW); digitalWrite(A1, HIGH); } else if (rfid.uid.uidByte[0] == UID2[0] && rfid.uid.uidByte[1] == UID2[1] && rfid.uid.uidByte[2] == UID2[2] && rfid.uid.uidByte[3] == UID2[3]) { servo.write(90); digitalWrite(A0, LOW); digitalWrite(A1, HIGH); } } } void keypadEvent(KeypadEvent eKey) { switch (keypad.getState()) { case PRESSED: Serial.println(eKey); switch (eKey) { case '#': checkPassword(); delay(1); break; case '*': closeBox(); delay(1); break; default: password.append(eKey); delay(1); } } } void checkPassword() { if (password.evaluate()) { servo.write(90); digitalWrite(A0, LOW); digitalWrite(A1, HIGH); } else { servo.write(0); digitalWrite(A0, HIGH); digitalWrite(A1, LOW); } } void closeBox() { password.reset(); servo.write(0); digitalWrite(A0, HIGH); digitalWrite(A1, LOW); } Działanie programu: Aby odblokować serwomechanizm i otworzyć pudełko należy wpisać odpowiedni kod zdefiniowany w programie i zatwierdzić znakiem "*" lub przyłożyć odpowiednią kartę (zdefiniowane są dwie karty). Po odblokowaniu gaśnie dioda czerwona, zapala się dioda czerwona i serwomechanizm zmienia położenie. Aby zamknąć pudełko należy wcisnąć przycisk "#". Podsumowanie: Projekt uważam za prawie zakończony. Po złożeniu całego urządzenia zwróciłem uwagę na brak możliwości zmiany kodu oraz dodania nowej karty (możliwe jedynie poprzez przeprogramowanie ATmegi). Projekt płytki zapewne pozostawia sporo do życzenia, dlatego liczę na cenne wskazówki aby nie popełniać błędów w przyszłości. Za wadę uważam też brak dodatkowej filtracji zasilania (stwierdziłem, że skoro biorę zasilanie z USB to nie trzeba nic dodawać). Zaletą (albo i wadą ) urządzenia są małe gabaryty. Ja wykorzystuje je do przechowywania zdjęć wykonanych Instaxem. Załączniki: W projekcie załączam kod programu, wykorzystane biblioteki i projekt Eagle do płytki PCB. Zdjęcia: safe_box_eagle.zip safe_box_software.zip
  7. Cześć W ramach organizowanej akcji postanowiłem opisać projekt, który wykonałem już jakiś czas temu. WPROWADZENIE Projekt to stacja meteorologiczna montowana na wyrzutni rakiet zaprojektowana i wykonana przeze mnie w ramach rekrutacji do Sekcji Rakietowej Studenckiego Koła Astronautycznego (działającego na Politechnice Warszawskiej). Wymagania wobec stacji: pomiar prędkości i kierunku wiatru, pomiar temperatury i ciśnienia, pomiar położenia oraz orientacji wyrzutni i kąta nachylenia ramienia, komunikacja bezprzewodowa z bazą, zasięg 500-700m, aplikacja na PC wyświetlająca i rejestrująca odbierane dane. ELEKTRONIKA Ogólny diagram sprzętowy wygląda następująco: Do realizacji 'mózgu' stacji wykorzystałem Arduino Pro Mini (zarówno w nadajniku, jak i odbiorniku). Komunikacja bezprzewodowa zrealizowana jest poprzez moduły NRF24L01+ ze wzmacniaczem mocy (w przeprowadzonych na poligonie testach bez problemu uzyskiwały zasięg 700m). Do pomiaru ciśnienia i temperatury zastosowałem moduł z układem BMP180. Pomiar prędkości i kierunku wiatru jest wykonywany przez zestaw stacji pogodowej. Do pomiaru kąta nachylenia wyrzutni zastosowałem moduł z układem MPU-6050. Położenie wyrzutni jest mierzone poprzez standardowy moduł GPS (NEO-7M-C firmy Waveshare). Urządzenie montowane na wyrzutni zasilane jest dwoma ogniwami litowo-jonowymi, a odbiornik jest zasilany przez komputer za pośrednictwem USB. Do generacji napięcia 5V w nadajniku wykorzystałem moduł przetwornicy D24V6F5 z Pololu. Z przeprowadzonych pomiarów wynika, że jedno ładowanie baterii pozwala działać stacji przez około 30 godzin. Schemat jednostki głównej: Ciekawą sprawą jest pomiar prędkości wiatru. Anemometr raz na obrót zwiera styk, a prędkość obrotowa jest proporcjonalna do prędkości wiatru (1Hz przekłada się na 2.4km/h). Mierząc więc okres pomiędzy kolejnymi krawędziami, można określić prędkość wiatru. Aby pomiar był możliwie dokładny, wykorzystałem przerwania. Jednak jak to z mechanicznymi stykami bywa, pojawiały się drgania styków: Aby zniwelować ten efekt zastosowałem dwie bramki NOT z przerzutnikami Schmitta i filtrem RC (o stałej czasowej około 1ms). Układ sprawia, że na pinie mikrokontrolera pojawiają się ładne, pojedyncze zbocza (czerwony to wyjście anemometru, a niebieski przebieg to sygnał podłączony do pinu mikrokontrolera): Na pokładzie zamontowany jest również magnetometr (znajdujący się poza główną obudową, w oddzielnej obudowie), który miał służyć do pomiaru azymutu wyrzutni (przy startach rakiet bardzo istotne są dwa kąty: azymut oraz nachylenie ramienia wyrzutni). Ostatecznie jednak nie został wykorzystany ze względu na problemy z kalibracją (magnetometr musiałby być za każdym razem montowany dokładnie tak samo na wyrzutni, co nie jest wykonalne). Odbiornik jest stosunkowo prostym urządzeniem: Zawiera tylko mikrokontroler (na module Arduino Pro Mini) oraz moduł radiowy. Komunikacja z PC wykonywana jest przez konwerter USB-UART. Odbiornik wyposażony jest też w diodę, która jest zapalana na chwilę w momencie odebrania pakietu. Bardzo to pomaga przy rozstawianiu stacji. Oba układy zmontowałem na płytkach prototypowych. OPROGRAMOWANIE Oprogramowanie projektu jest dość rozbudowane, gdyż składa się z dwóch projektów na systemy wbudowane (nadajnik i odbiornik) oraz oprogramowania na PC. Oprogramowanie nadajnika Kod napisany oczywiście z wykorzystaniem środowiska i bibliotek Arduino dla przyspieszenia developmentu Wykorzystałem dodatkowe biblioteki: MPU6050 (konfiguracja i odczytywanie danych z akcelerometru) HMC5883L (konfiguracja i odczytywanie danych z magnetometru) I2Cdev (wykorzystywane przez bibliotekę MPU6050) TinyGPS (parsowanie danych z GPS) RF24 (komunikacja z modułem radiowym) Adafruit_BMP085 (konfiguracja i odczytywanie danych z barometru) Oprogramowanie odbiornika Zadaniem programu uruchomionego na odbiorniku jest odczytanie danych z modułu radiowego i przerzucenie ich od razu na port szeregowy. Nic skomplikowanego. Kod na systemy wbudowane jest w repozytorium: https://github.com/Lukaszm94/rocketLauncherDAQ_embedded Oprogramowanie na PC Program do uruchamiany na PC służy do odbierania danych z odbiornika, wyświetlania ich i zapisywania do pliku CSV. Do zrealizowania powyższych zadań wykorzystałem język C++, framework Qt i bibliotekę Qwt. Kod znajduje się w repozytorium: https://github.com/Lukaszm94/RocketLauncherDataAcquisitionApp Na temat samej implementacji nie będę się rozpisywał. Kilka ciekawszych funkcji programu to wyznaczanie wartości średniej prędkości wiatru (z możliwością ustalenia z jakiego okresu ma być wyliczana średnia) oraz podmuchu (chwilowa maksymalna prędkość wiatru). Dodatkowo, jeżeli któryś sensor działa niepoprawnie (np. akcelerometr jest niepodłączony albo GPS nie ma fixa), to wartość z tego sensora jest wyświetlana w kolorze czerwonym. Widok okna programu: MECHANIKA Wszystkie obudowy i elementy mocujące zaprojektowałem w Autodesk Inventor i wykonałem z wykorzystaniem drukarki 3D. Na wyrzutni montowane są trzy urządzenia: jednostka główna, moduł kompasu i moduł akcelerometru. W czasie projektowania kierowałem się łatwością montażu w warunkach polowych (stąd np. zastosowanie nakrętek motylkowych do mocowania obejm) oraz zapewnienie możliwie wysokiej odporności na wodę. Render głównej obudowy: Render odbiornika: Nadajnik: Wnętrze nadajnika: Wnętrze odbiornika: Ciekawy patent, jaki mogę pokazać, to wykonanie złącz do świata zewnętrznego. Wykorzystałem złącza męskie KK254, które przylutowane są do odpowiednio wyciętej płytki prototypowej. W płytce są dwa otwory pod śruby M3, analogiczne otwory są w obudowie. Płytka jest mocowana od wewnątrz do ścianki urządzenia z wykorzystaniem dwóch śrub. Całość od zewnątrz wygląda elegancko i jest wytrzymała. Cała jednostka główna zmontowana: WNIOSKI I PODSUMOWANIE Projekt spełnia większość założeń i uważam, że został zrealizowany z sukcesem. Wykorzystany został już wielokrotnie na poligonie i w zasadzie za każdym razem system działał poprawnie. Jeśli chodzi o wady, to główny problem jaki zaobserwowałem, to uszkadzanie się modułów radiowych (konkretniej to wzmacniaczy mocy) w momencie włączenia urządzenia bez podłączonej anteny - co niestety zdarzyło się kilkukrotnie (przypadkowe włączenie). Drugi problem to brak pomiaru orientacji wyrzutni, związany z opisaną wcześniej kłopotliwą kalibracją. Przykładowy wykres uzyskany z wykorzystaniem stacji (na zawodach CanSatów w 2016 jeśli dobrze pamiętam): Krótki opis projektu jest też na mojej stronie internetowej: http://lukemeyer.me/rldaq.php Na koniec mogę pokazać ładne zdjęcie ze startu rakiety TuCAN (jak się dokładnie przyjrzycie, to widać stację zamontowaną na wyrzutni ). W projekcie TuCAN również brałem udział, zajmowałem się całością systemów elektronicznych w rakiecie. Jakby ktoś był zainteresowany, to mam mały opis na mojej stronie: http://lukemeyer.me/tucan.php
  8. Chyba każdy elektronik powinien mieć dogodne źródło zasilania - zasilacz laboratoryjny. Najtańsze gotowce kosztują conajmniej 130zł. Ja, jak większość elektroników-hobbystów - przerobiłem stary zasilacz komputerowy ATX na "warsztatówkę". Budowa Wymagania miałem małe: zmieścić się w budżecie (ok. 40zł), mieć po kilka wyjść różnych napięć, obudowa miała być ładna, i mieć jedno regulowane (najlepiej jak natężenie też by było regulowane). Więc zacząłem od rozkręcenia starego ATXa (ratujmy planetę, nie wyrzucajmy elektroniki ) i wyczyszczenia "flaków". Po sprawdzeniu, czy zasilacz podaje dobre napięcia (a podawał) wkręciłem go do obudowy Z17 - kosztowała ona ok. 15zł. Następnie zająłem się modułem regulacji napięcia, oparty na dobrze znanym LM317. Miał on być połączony z woltomierzem i amperomierzem panelowym, lecz taki miernik kosztował 30zł - zakupiłem więc sam woltomierz (ok. 10zł). Regulowanie napięcia umożliwia potencjometr znajdujący się na froncie, obok woltomierza i gniazd bananowych. Wyprowadziłem 4 masy, napięcie regulowane, 3.3v, 5v, oraz 12v. Po prawej stronie zamieściłem diodę LED RGB w plastikowej oprawce, aby można było zobaczyć stan zasilacza (czerwona - zasilacz jest podłączony, zielona - zasilacz jest włączony). Do tego dochodzi sam przełącznik panelowy za ok. 3zł - akurat taki, bo wygląda jak w filmach Z tyłu umieściłem wentylator SilentiumPC 80x80mm wraz z osłonką wydrukowaną w 3D (białe PLA), gniazdko oraz jego włącznik. Funkcjonalność Zasilacz podaje kilka różnych napięć "naraz" - można do niego bez dodatkowego okablowania do 4 urządzeń. Napięcia stałe radziły sobie dobrze ze sztucznym obiążeniem - rezystor 10W - ale 1 amper LM317 już tu nie wystarczył (co spowodowało wyłączenie urządzenia). Bez problemu mogę podłączyć do tego elektronikę, arduino, czy grzałkę kiedy zimno Obsługuje też bez problemu przerobiony dysk twardy na szlifierkę. Zabezpieczenia działają, w przypadku przeciążenia i zwarcia zasilacz wyłącza się. Całość robiłem z dobre 2 dni, gdzie najdłużej zajmowało dłubanie w plastiku aby zrobić otwory (wiertarki jeszcze nie miałem). Urządzenie jest bardzo praktyczne i przydatne - od ładowania akumulatorów żelowych po zasilanie prototypów. Zachęcam do tworzenia podobnych urządzeń - niezastąpione przy każdym warsztacie. Pozdrawiam, Leoneq :3
  9. Kryptowaluty zdobyły już dość dużą popularność, dlatego pomyślałem, że ciekawym projektem byłoby zrobienie z pomocą maliny wyświetlacza aktualnego kursu kryptowalut. W paru krokach postaram się przedstawić jak wykonać taki projekt. Do budowy wykorzystałem: Raspberry pi 3B+ Wyświetlacz LCD 4x20 znaków niebieski + konwerter I2C Konwerter poziomów logicznych dwukierunkowy Płytka stykowa Przewody żeńsko-męskie Etapy wykonania projektu: 1. Podłączenie wyświetlacza 2. Uruchomienie I2C Użyłem Raspbiana Jessie Lite jako systemu do naszej maliny, pierwszym krokiem będzie uruchomienie I2C: - wpisujemy w konsolę sudo raspi-config - następnie wybieramy opcję numer 5 - później przechodzimy do zakładki I2C - i wybieramy yes - wychodzimy z configu maliny i wykonujemy restart wpisując: sudo reboot - jeśli wszystko wykonaliśmy poprawnie powinniśmy ujrzeć to po wpisaniu komendy (przedstawiony adres może się różnić od waszego) i2cdetect -y 1 3. Pobranie biblioteki do obsługi ekranu - po uruchomieniu I2C w Raspberry należy pobrać bibliotekę komendą: git clone https://gist.github.com/6ad9020b3c84bc65b53119b21a4bc37d.git i2c_lcd - po pobraniu wchodzimy do folderu z tą biblioteką: cd i2c_lcd - teraz należy ustawić adres I2C w pliku i2c_lcd.py: sudo nano i2c_lcd.py - w tym miejscu wpisujemy adres, który ujrzeliśmy wcześniej przy używaniu komendy i2cdetect: - nie wychodząc z edytora zmieniamy wyświetlaną szerokość na 20: - wychodzimy i zapisujemy plik naciskając kolejno CTRL+X Y Enter - uruchamiamy test naszego wyświetlacza: python i2c_lcd.py - jeśli wykonaliśmy wszystko poprawie to powinniśmy ujrzeć coś takiego: 4. Program do odczytu i wyświetlania kryptowalut - tworzymy plik crypto.py komendą: sudo nano crypto.py - i wklejamy kod: import i2c_lcd import requests import time space = 6 i2c_lcd.lcd_init() i2c_lcd.lcd_string("-Kursy kryptowalut-",i2c_lcd.LCD_LINE_1) i2c_lcd.lcd_string("---Aktualny kurs---",i2c_lcd.LCD_LINE_2) r = 0 while True: #btc print('btc') r = requests.get('https://api.cryptonator.com/api/ticker/btc-usd') crypto = r.json()['ticker']['price'] crypto = float(crypto) crypto = round(crypto, 2) crypto = str(crypto) i2c_lcd.lcd_string("------Bitcoina------",i2c_lcd.LCD_LINE_3) i2c_lcd.lcd_string(" $"+crypto,i2c_lcd.LCD_LINE_4) time.sleep(space) #eth print('eth') r = requests.get('https://api.cryptonator.com/api/ticker/eth-usd') crypto = r.json()['ticker']['price'] crypto = float(crypto) crypto = round(crypto, 2) crypto = str(crypto) i2c_lcd.lcd_string(" $"+crypto,i2c_lcd.LCD_LINE_4) i2c_lcd.lcd_string("------Ethereum------",i2c_lcd.LCD_LINE_3) time.sleep(space) #bch print('bch') r = requests.get('https://api.cryptonator.com/api/ticker/bch-usd') crypto = r.json()['ticker']['price'] crypto = float(crypto) crypto = round(crypto, 2) crypto = str(crypto) i2c_lcd.lcd_string(" $"+crypto,i2c_lcd.LCD_LINE_4) i2c_lcd.lcd_string("----BitcoinCasha----",i2c_lcd.LCD_LINE_3) time.sleep(space) #ltc print('ltc') r = requests.get('https://api.cryptonator.com/api/ticker/ltc-usd') crypto = r.json()['ticker']['price'] crypto = float(crypto) crypto = round(crypto, 2) crypto = str(crypto) i2c_lcd.lcd_string("------Litecoina------",i2c_lcd.LCD_LINE_3) i2c_lcd.lcd_string(" $"+crypto,i2c_lcd.LCD_LINE_4) time.sleep(space) #doge print("doge") r = requests.get('https://api.cryptonator.com/api/ticker/doge-usd') crypto = r.json()['ticker']['price'] crypto = float(crypto) crypto = round(crypto, 6) crypto = str(crypto) i2c_lcd.lcd_string(" $"+crypto,i2c_lcd.LCD_LINE_4) i2c_lcd.lcd_string("------Dogecoina-----",i2c_lcd.LCD_LINE_3) time.sleep(space) - po zapisaniu uruchamiamy program: sudo python crypto.py - jeśli wszystko wykonaliśmy poprawnie powinniśmy ujrzeć coś takiego: Gotowe możemy monitorować kurs kryptowalut
  10. lukaszd82

    Stacja lutownicza RL-1

    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
  11. Cześć. Dzisiaj chciałbym opisać mój moduł sprawdzania jakości powietrza. Czujnik postanowiłem zbudować z czystej ciekawości, jakim to powietrzem oddychamy w zimie. Wyniki niestety są zatrważające. Ale po kolei. Zastosowałem u w tym urządzeniu następujące elementy: czujnik PMS5003, nodeMCU wraz z podstawką, wyświetlacz LCD 16x2 , przetwornicę zasilającą, moduł przekaźników; czujnik DHT11, gniazdo USB, gniazdo zasilania, wentylator, serwomechanizmy, moduł RTC, i kilka drobiazgów, rurek, przewodów.... Czujnik został zbudowany jako osobne urządzenie ale połączone z moim "systemem" automatyki domowej. Urządzenie aktualnie jest zamontowane na półeczce na ścianie, przez którą są przeprowadzone przewody powietrzne dolotowy z zewnątrz i wylotowy. Takie rozwiązanie jest spowodowane tym, że zastosowany czujnik, zresztą podobnie jak wszystkie tego typu, przekłamuje wyniki w warunkach wysokiej wilgotności powietrza. Zamysł był więc taki, by obudowa z czujnikiem znajdowała się w ogrzewanym pomieszczeniu, a powietrze potrzebne do pomiaru urządzenie pobierało sobie samo z zewnątrz, po czym po samoistnym nagrzaniu w komorze czujnika, został wykonany pomiar i następnie wymiana powietrza w komorze pomiarowej urządzenia. Jak to wygląda w praktyce. Obudowa jest podzielona na dwie komory, w przedniej znajduje się cała elektronika, zasilanie, wyświetlacz, ta część jest wentylowana pprzez otwory w obudowie. Zaś w tylnej szczelnie odgrodzonej komorze znajduje się czujnik PMS i moduł przekaźnika. Do tej tylnej komory, doprowadzone są ww. przewody powietrzne, a w kanale dolotowym zamontowany jest wentylator. Dodatkowo za ścianą na tych kanałach zamontowane są zawory odcinające przepływ powietrza sterowane serwomechanizmami. Zawory te mają na celu uniemożliwienie samoczynnej cyrkulacji powietrza w kanałach, w czasie np. silnych wiatrów, a tym samym również wychładzania i komory czujnika i pomieszczenia w którym zamontowany jest wylot powietrza. Zasada działania. Cały proces zaczyna się od wykonaniu pomiaru przez czujnik DHT11, jeśli wilgotność powietrza jest niższa niż zadana(np.75%), zostaje wybudzony czujnik, pracuje przez 30 sekund, a następnie jest wykonywany pomiar. Po wykonaniu pomiaru czujnik jest usypiany, a do modułu zaworów odcinających zostaje podane napięcie. W następnym kroku serwomechanizmy otwierają dolot, wylot i zostaje włączony wentylator na minutę, by wymienić powietrze w komorze. Po minucie wyłączamy wentylator, zamykamy kanały i odcinamy zasialnie serw. Wszystkie te czynności są anonsowane na wyswietlaczu. Po całym tym etapie, wyświetlacz przechodzi w tryb standardowej pracy, t.j. naprzemiennego wyświetlania parametrów ostatniego odczytu i godziny oraz daty. W tym czasie co dwie minuty czujnik DHT11 dokonuje pomiarów. Jednakże dopiero po 10 minutach od uśpienia czujnika instrukcja warunkowa sprawdza czy wilgotność jest na odpowiednim poziomie i jeśli tak to wybudzamy czujnik i cały cykl zaczyna się od nowa. W urządzeniu jest wgrany szkic dzięki któremu nodeMCU wysyła dane na serwer Blynka, dzięki czemu mogę mieć dostęp do tych danych 24h/allOverThe World Udało mi się też po raz pierwszy zawrzeć w tym szkicu funkcjonalność OTA, czyli mam możliwość wgrywania oprogamowania poprzez wi-fi. Wprawdzie w czasie wstępnych prac zamontowałem z boku urządzenia gniazdo USB służące właśnie programowaniu, to dzięki OTA stało sie ono zbędne(?). Pomimo tego, że cała obudowa jest zamontowana do wspomnianych kanałów powietrznych, sposób przyłączenia (na wtyk), powoduje, że czujnik ten stał się również przenośny i może służyć do badania jakości powietrza w różnych dziwnych miejscach, w pracy, w kotłowni.... Kilka zdjęć: Oczywiście jest też filmik: Dziękuję za uwagę, pozdrawiam wszystkich forumowiczów Forbota którzy przyczynili się do powstania tego czujnika
  12. 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
  13. Pochwale się jeszcze jednym tym razem nieco mniejszym projektem. Jakiś czas temu wykonałem własne arduino uno oraz pokaże, w jaki sposób programuje się taką płytkę. A wydaje mi się to dość ciekawy temat, ponieważ wgrywam tak kod bez wcześniej wypalonego bootloadera. Moje własne arduino powstało z następujących elementów: Płytka uniwersalna 5x7cm mikrokontroler ATmega 328 rezonator kwarcowy 16MHz podstawowe elementy takie jak rezystory, kondensatory, dioda LED,przycisk tact switch oraz złącza goldpin Do samego programowania potrzebny jest jeszcze odpowiedni programator USBasp osobiście korzystam z takiej konstrukcji. Na zdjęciach można także zobaczyć, że na płytce znajduje się złącze DC 2,5mm oraz stabilizator 7805 nie są one jednak używane. Sama konstrukcja mojego arduino jest dość prosta. Mamy tutaj miktokontroler ATmega 328 do którego wyjść zostały podpięte i opisane złącza goldpin(wszystko opisane zostało zgodnie z pinami oryginalnego arduino). Dodatkowo na płytce znajduje się przycisk RESET oraz zielona dioda LED sygnalizująca zasilanie. Niezbędnym elementem jest rezonator kwarcowy 16MHz bez niego nasza płytka nie będzie działać. Jeżeli ktoś postanowi zbudować podobną płytkę polecam umieścić mikrokontroler na odpowiedniej podstawce. Programowanie takiego układu jak już wcześniej wspomniałem odbywa się za pomocą programatora USBasp. Jednak sam proces programowania wygląda nieco inaczej. Po pierwsze w zakładce narzędzia wybieramy tylko płytkę jako arduino uno inne opcje nas nie interesują. Gdy napiszemy już nasz kod klikamy przycisk 'zweryfikuj'. Następnie musimy połączyć naszą płytkę z programatorem oraz uruchomić program, który umożliwi nam przesłanie kodu w formacie pliku hex na nasz mikrokontroler osobiście korzystam z MkAvrCalculator (niestety darmowa wersja nie obsługuje układu ATmega 328). Należy upewnić się, że układ pracuje przy zegarze 16MHz. Teraz możemy już wybrać plik z kodem, który chcemy przesłać. Środowisko arduino IDE zapisuje swoje pliki dla akurat skompilowanego programu w folderze tymczasowym systemu windows i to właśnie tam szukamy plików hex. Folder ten w systemie windows 7 znajduje się pod adresem %UserProfile%\AppData\Local\Temp %WinDir%\Temp. Możemy tam znaleźć folder arduino_build, który to zawiera dwa pliki w formacie hex. Jeden z nich jest z dopiskiem bootloader drugi bez. Jako plik, który chcemy przesłać wybieramy ten bez dopisku bootloader. Na samym końcu możemy już zaprogramować nasz układ. Ciekawostką jest to, że program przesłany w taki sposób uruchamia się znacznie szybciej niż w przypadku oryginalnego arduino. Dodatkowo umieszczam kilka zdjęć wykonanej płytki oraz miejsce, w którym to znajduje się na co dzień.
  14. 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
  15. Hej wszystkim, temat może nie dotyka robotyki, ale elektroniki jak najbardziej :). Jestem zapalonym graczem Airsoft, a jako że hobbistycznie bawię się elektroniką, czasem pracuję nad gadżetami które urozmaicaną rozgrywkę. Opracowałem i wykonałem 3 sztuki urządzeń które pozwalają na na zorganizowanie krótkiego scenariusza (30 do 120 minut) dla dwóch drużyn. Celem graczy jest zebranie większej ilości airsoftcoin z urządzeń niż zdobędzie przeciwnik. Każde urządzenie posiada 2 parametry do ustawienia: Ilość Airsoftcoinów do wykopania Czas wykopania pojedynczego Airsoftcoina Urządzenie podczas gry może znajdować się w jednym z trzech stanów: 1) GOTOWY - Urządzenie posiada gotowy do przejęcia Airsoftcoin. Urządzenie jest w tym stanie podczas startu rozgrywki. Świecą się oba przyciski, co 15 sekund słychać piknięcia a urządzenie jest gotowe do interakcji z graczem. Aby zdobyć punkt, gracz musi podbiec i ręką wcisnąć przycisk koloru jego drużyny. Gdy to zrobi z pozostałej puli zdejmowany jest 1 punkt który naliczany jest jego drużynie a urządzenie przechodzi do kolejnego stanu. Jeżeli są jeszcze punkty w puli, przechodzi do stanu (2) KOPANIE. Jeżeli pula jest wyczerpana, przechodzi w stan (3) WYCZERPANY 2) KOPANIE - Urządzenie kopie kolejny Airsoftcoin z bloku. Na wyświetlaczu widać czas który został do zakończenia kopania, przyciski są zgaszone a urządzenie milczy. Gracz nie może wejść w interakcje z urządzeniem. Gdy czas się skończy, urządzanie zapika i ponownie wejdzie w stan (1) GOTOWY 3) WYCZERPANY - Urządzenie rozkopało cały blok Airsoftcoin i nie jest już użyteczne w dalszej części rozgrywki. Przyciski są zgaszone, urządzenie milczy a podświetlenie ekranu miga. Gracz nie może wejść w interakcje z urządzeniem. Po zakończeniu całej rozgrywki można sczytać i podsumować punkty. Filmik opisujący działanie: Link do przykładowego scenariusza: http://www.taktycznyszczecin.pl/viewtopic.php?f=10&t=5615 Filmik z rozgrywki (nie jest mój, ale załączam za zgodą autora. Zawiera kilka niecenzuralnych słów. Polecam obejrzeć na luzie, lub wyłączyć głos i napisy): Budowa mechaniczna: Jeżeli obejrzeliście chociaż część filmiku, to zauważyliście pewnie że urządzenie musi mieć pewną wytrzymałość. Prędzej czy później urządzenie komuś spadnie, ktoś inny się o nie potknie i przyjmie sporo plastikowych kulek. Podstawą jest ta obudowa Kardexowa, i przyznam że nie widzę lepszej alternatywy. Ma idealne wymiary żeby pomieścić zawartość, a co ważniejsze jest idealna na wysokość dla dość długich przycisków. Jej obróbka jest przyjemna, ale sam materiał na tyle mocny że wytrzyma nawet strzał z bliska z repliki o mocy ~2J. Ekran zabezpieczyłem prostokątem z płyty plexi. Ten element nie jest już tak wytrzymały jak sama obudowa, ale myślę że wystarczy. Rykoszet, czy strzał z daleka powinna wytrzymać. Jako przyciski zdecydowałem się użyć ten model i przyznam że tutaj też nie widzę lepszych alternatyw. Po pierwsze, są wystarczająco duże żeby łatwo je było wcisnąć. Po drugie, są na przełącznikach krańcowych, co sprawia że mają wyraźny "klik" i nawet pod wpływem adrenaliny i w rękawiczkach jest się pewnym czy wciśnięcie zaskoczyło czy nie. Po trzecie idealne otwory pod te przyciski robi otwornica pod zawiasy w szafkach. Nie trzeba kombinować czy mierzyć. Szybkie przyłożenie wkrętarki w odpowiednim miejscu i już możemy montować. No i po czwarte, mają wbudowane diody, więc jednocześnie sygnalizują stan. Jedynym minusem jest zasilanie do 12V, więc przylutowałem oporniki tak żeby wyciągało niecałe 20mah przy 5V. Tutaj nawet lekko jaśniejsze świecenie jest na plus, szczególnie na dworze. Ostatnim stricte mechanicznym elementem jest włącznik. W tym momencie muszę nadmienić, że nie jest to pierwsza wersja urządzenia i na zdjęciach widać zalepione kable klejem na gorąco w prototypie. Pierwsze podejście to było zastosowanie zworki i goldpinu. Niestety, ta pierwsza nie raz się zgubiła i było to rozwiązanie bardzo zawodne. Po jeszcze innym, również nieudanym rozwiązaniu w innym urządzeniu, wpadłem na pomysł z włącznikiem kluczykowym i okazało się to strzałęm w dziesiątkę. Oczywiście dla chcącego nie jest trudno przełączyć go nożem, czy śrubokrętem, ale tacy ludzie nie grają. Za to jako zabezpieczenie przeciw przypadkowemu wyłączeniu i wygodnemu włączaniu, wypada rewelacyjnie. Wszystkie elementy zostały przyklejone klejem na gorąco, a wyświetlacz dodatkowo śrubkami. Prawie wszystkie połączenia są lutowane. Wiem że może się to wydać przesadą i problemem z ewentualną naprawą, ale zdarzały się już sytuacje rozłączenia z goldpinów, więc zdecydowałem się na to rozwiązanie jako na najbardziej pewne. Skoro i tak ja to zrobiłem, to z naprawą nie będę miał przecież problemów. Jedynym nielutowanym połączeniem elektrycznym jest podłączenie przetwornicy z resztą zasilania. Skorzystałem ze standardowego portu USB, bo raz że akurat takie przetwornice miałem, a dwa że mogę rozłączyć w ten sposób pierwszą i drugą część obudowy co przydaje się przy majsterkowaniu. Minusem jest brak wodoodporności, ale to zbyt duży problem żebym mógł go amatorsko rozwiązać. Rozwiązaniem jest owijanie urządzeń które mogą zostać wystawione na deszcz w koszulki do dokumentów i zaklejenie taśmą. Obudowa mieści się idealnie, nie blokuje przycisków i widać wyświetlacz. Elektronika: Sercem jest klon arduino nano. Oczywiście arduino uno też jest zgodne i służyło do prototypownia, ale ten model jest tańszy, mniejszy i łatwiejszy w lutowaniu połączeń. 2 wejścia i 2 wyjścia zapewniają mi przyciski omówione w części o mechanice, więc je już tutaj pominę. Kolejnym wyjściem, jest moduł buzzera. Można go śmiało zastąpić zwykłym buzerem z tranzystorem i rezystorem, ale szedłem na łatwiznę. Wyświetlacz to najprostszy 2x16 z konwerterem I2C. Można poradzić sobie bez konwertera kosztem ilości kabli, ale tak jak wspomniałem, idę na łatwiznę i myślę że tak jest też bardziej solidnie. Do ustawiania parametrów urządzenia użyłem prostego odbiornika podczerwieni TSOP31238 i pilota. To rozwiązanie jest o tyle fajne, że pilot jest malutki i można ustawiać 3 urządzenia jednocześnie. Sam odbiornik jest w obudowie zalepiony klejem na gorąco. Klej po wyschnięciu jest biały, ale przepuszcza światło podczerwone. Zasilanie: Generalnie sekcja zasilania składa się z akumulatora jednoogniwowego li-on/li-po i prostownicy 5V z wyjściem USB. Akumulatory pochodzą ze starej komórki i baterii laptopowej. Ładowanie zależy od urządzenia. W pierwszej wersji zastosowałem prosty moduł ładowarki ogniw i ładuje go zwykłą ładowarką do komórkowi. Dwa modele powstałe później, mają wyjście t-deans wyprowadzone na zewnątrz które jest bezpośrednio połączone z ogniwem. Chciałem zastosować też te moduły ładowarek, ale akurat mi się skończyły więc improwizowałem. Ma to tą zaletę że ładuje je tą samą ładowarką co baterie do replik, a dodatkowo wyświetlacz pokazuje mi ile naładowało, przez co mogę określić czy wystarczy na cały dzień rozgrywek. Po 3 godzinach rozgrywki ładowałem je prądem maksymalnym 0.5A i ładowanie zakończyło na 216 mah. Ogniwa z laptopów miały fabrycznie 2800mah, a komórkowa 6000mah, więc spokojnie wystarczą nawet na cały dzień gry w zimę. Programowanie: Programowałem to dość nietypowo w C++. Oryginalny edytor Arduino to bardziej notatnik niż prawdziwe narzędzie, za to w żadnym normalnym IDE nie udało mi się skompilować i wgrać schematu. Zrobiłem więc standardowy projekt arduino, z jedną biblioteką w jego katalogu i sama biblioteka była już w C++. Sam plik .ino odpalał jedynie kod z wejściowy z kodu "biblioteki" którą mogłem edytować w Clion EAP. Kilka zdjęć: Po lewej urządzenie z żeńskim t-deans pozwalającym ładować ładowarką do modelarskich pakietów li-po. Po prawej wejście micro usb i widać zaklejone stare kable z goldpinem, które przedłużone z powrotem wchodzą do środka. Stary klej trzymał zbyt mocno żebym mógł się go pozbyć. Szare przełączniki kluczykowe tworzą połączenie pomiędzy ogniwem a przetwornicą. Zaklejone odbiorniki podczerwieni. Pomimo białego kleju, światło podczerwone świetnie przechodzi. Widok od środka. Po lewej ogniwo z komórki i ładowanie z wbudowanej ładowarki. Po prawej zasilanie z ogniwa z laptopa. Walec otulony koszulką termokurczliwą na połączeniu to kondensator 1000uF. Po lewej wyłączone urządzenie, po prawej uruchomione i w stanie GOTOWY. Urządzenie w stanie KOPANIE, po wciśnięciu czerwonego przycisku. Zielona drużyna ma 0 punktów, czerwona 1 i w puli pozostało 14. Za 2 minuty i 57 sekund ponownie przejdzie w stan GOTOWY. Podsumowanie: Projekt ma 2 główne zalety: Po pierwsze, jest mega prosty. Z gotowym programem i podstawową umiejętnością lutowania myślę że spokojnie może go wykonać osoba która elektroniką się zbytnio nie interesuje. Jest praktyczny. Po zbudowaniu nie stoi na półce, ale jest używany jak na urządzenie użytkowe przystało. Pewnie znajdą się zgryźliwi którzy stwierdzą że to zbyt banalne lub znajdą błędy, ale nie odbierze mi to satysfakcji. Mam nawet w planach dopracować opis wykonania i opublikować razem z kodem źródłowym. Zapraszam do komentowania, dzielenia się uwagami i zadawania pytań. Dodaje uproszczony schemat i kod źródłowy: https://bitbucket.org/krzysiek050/asg_airsoftcounter
  16. Daniil

    Gra 2048 na Arduino

    Pewnego wieczoru chciałem zrobić zabawkę na arduino. Bez wahania postanowiłem zrobić grę 2048. Zrobiłem to! Teraz chcę pokazać proces. Przed pracą opowiem ci kilka słów na temat gry. Została stworzona przez Gabriele Cirulli - 19-letniego włoskiego dewelopera. Gra została napisana w celu ćwiczenia programowania. Mimo że osiągnęła wielki sukces, facet nie kontynuował tworzenia gier. W oryginale znajduje się pole 4 * 4, na którym z prawdopodobieństwem 91% pojawia się kafelek "2" i 9% liczba "4". Celem gry jest zdobycie kafla 2048, przenoszenie wszystkiego na jedną ze stron. Nasza gra będzie wersją uproszczoną. Będzie tylko dwójka, po osiągnięciu 2048 gra się skończy i nie będziesz mógł prowadzić zapisów. To wszystko - pole dla twoich ulepszeń. Zacznijmy od składników. Sercem zabawki jest płytka arduino nano - tania mała płytka. Aby kontrolować potrzebujesz 5 przycisków. 4 wskazują kierunki boków i jeden do przeładowania. Każdy z nich potrzebuje rezystora na 10 kOm. Informaja będzie wyświetlana na ekranie calowym. Pierwszą częścią pracy jest podłączenie wyświetlacza do arduino. Znajdź adres ekranu i2c. Aby to zrobić, pobierz szkic I2C SCANNER. Podłączamy ekran zgodnie z tabelą. Płyta -> Ekran GND ->GND 5V->VCC SCL->A5 SDA->A4 Szkic jest załadowany, ekran jest podłączony. Otwórz monitor szeregowy. Tutaj widzimy adres i2c ekranu. Radzę napisać czarny znacznik z tyłu ekranu. Teraz przygotuj go do wyświetlania danych. Zainstaluj dwie biblioteki (adafruit ssd1306, adafruit gfx). W folderze z biblioteką znajduje się wspaniały plik Adafruit_SSD1306.h. Otwórz go. Tutaj musisz odkomentować linię z rozmiarem twojego ekranu. Po uporządkowaniu wyświetlacza pobierz i otwórz szkic. Kilka słów o algorytmie. Gra rozpoczyna się i tworzy się kafelek "2". Można go rzucać w dowolnym kierunku. Po każdym ruchu na bok, wszystkie płytki powinny zostać przybite do ściany, po złożeniu razem, należy je ponownie przybić do ściany, a wkońcu w przypadkowym miejscu wyrzucić numer 2. Jeśli nie ma pustych miejsc i nie można ułożyć kilku płytek, pojawia się napis GAMEOVER. Jeśli kafelek 2048 zostanie złożony, pojawi się zwycięski komunikat. W void loop znajduje się spora część skomentowanego kodu. Jest potrzebny do debugowania. Jest odpowiedzialny za uzyskanie liczby od 1 do 4 i przesłanie płytek we właściwym kierunku. Konieczne jest określenie pinów, do których podłączone są przyciski i adres ekranu. Teraz możesz zmontować urządzenie na breadboard'e i wypróbować algorytmy. Jeśli robisz wszystko "zgodnie z twoim rozumem", musisz zamówić produkcję płytki z obwodem drukowanym, na której umieścisz nasze komponenty. Ale w przypadku pierwszego prototypu wystarczy go zmontować na płytce prototypowej. Bierzemy zieloną płytkę makietową 5 * 7 cm jako podstawę. Przylutuj na niej Arduino. Nad nim robimy złącze ekranu. Rozmieść scl, sda na a4, a5 - będzie wygodniej lutować. Przyciski lutujemy z rezystorami. Wstaw ekran. Rysujemy strzałki. Graj Demonstracja
  17. atlantis86

    Jeszcze jeden zegar nixie

    Lampy nixie to chyba najczęściej powracający temat wśród amatorskich projektów elektronicznych. Myśl o skonstruowaniu zegara z takim wyświetlaczem chodziła mi po głowie już wiele lat temu, w tym celu zaopatrzyłem się w zestaw lamp IN-14. Niestety z powodu braku czasu i dużej ilości projektów o wyższym priorytecie zadanie to ciągle było odkładane na później. Może to i lepiej, bo w międzyczasie miłośnicy amatorskiej elektroniki zyskali dostęp do całkiem ciekawych elementów, które mogłem wykorzystać w projekcie. Prezentowany zegar powstał w 2017 roku. Jego głównym elementem jest mikrokontroler Atmega644, który wykonuje wszystkie operacje związane z odmierzaniem czasu i obsługą multipleksowanego wyświetlacza. Dodatkowo zegar został wyposażony w moduł WiFi z układem ESP8266, pracujący pod kontrolą własnego programu. Zadaniem modułu jest cykliczne sprawdzanie czasu na serwerze NTP i korygowanie ustawień lokalnego RTC. Urządzenie posiada też układ scalony FT232, dodający możliwość konfiguracji przez USB. Stałe napięcie około 180V jest generowane za pomocą przetwornicy boost na układzie MC34063A. Oprogramowanie zegara zostało wyposażone w funkcję automatycznego wykrywania czasu letniego i zimowego. Na płycie czołowej znajduje się przełącznik umożliwiający włączenie trybu, w którym wyświetlany jest czas UTC - funkcja ta została dodana w związku z moimi radioamatorskimi i krótkofalarskimi zainteresowaniami. Konstrukcja została zamontowana wewnątrz obudowy ze sklejki wycinanej laserowo. Fizycznie urządzenie składa się z dwóch osobnych płyt, Jedna z nich mieści zestaw lamp nixie, druga elektronikę sterującą.
  18. dkradke

    Sterownik pieca CO

    Kolega modernizując u siebie w mieszkaniu system ogrzewania poprosił mnie o wykonanie jakiegoś sterownika do pieca CO wraz ze sterowaniem dmuchawy. Tak powstał niewielki regulator, który miał mieć na celu prostotę i czytelność. Główne elementy użyte do budowy sterownika to: LCD 2x16 HD44780 ATMEGA8 - zastosowany procesor DS18B20 - czujnik mierzący temperaturę na piecu przekaźnik na 5V taki jak tutaj: przekaźnik Głównym zadaniem jest uruchamianie pompy obiegowej na podstawie zadanej temperatury na piecu. Dodatkową funkcją jest tryb rozpalania, który w początkowej fazie uruchamia dmuchawę. Jest to bardzo przydatna opcja, przyspieszająca proces rozpalania w piecu. Sterowanie jest bardzo proste, odbywa się z wykorzystaniem tylko trzech przycisków. W podstawowym widoku regulujemy zadaną temperaturę na piecu, która decyduje o tym czy pompa ma zacząć pracować czy nie. Regulator jest prostą nastawą z histerezą. Po wejściu w menu możemy dodatkowo zmienić: temperaturę wyłączenia dmuchawy. Jeżeli piec jest zimny i włączymy opcję rozpalania to po osiągnięciu już stosunkowo niewielkiej temperatury dmuchawa zostanie wyłączona histerezę pracy regulatora maksymalne czasy pracy pompy i dmuchawy Wszystko zostało zamknięte w obudowie natynkowej, a sterownik umieszczony obok pieca w pomieszczeniu gospodarczym. Układ składa się z dwóch płytek rozdzielając część wysokiego napięcia i sterowania. Zdecydowałem się na umieszczenie kompletnego zasilania w urządzeniu, transformator, bezpiecznik i kilka dodatkowych elementów. Powodem tego było to, że sterownik jest używany przez kogoś innego a dołączany zasilacz może się zgubić i wtedy nie mam kontroli na tym jaki zamiennik zostanie użyty. Tutaj jest pokazany schemat i wzór płytki: Płytka została wykonana w domowych warunkach metodą żelazkową. Dla poprawy czytelności wykorzystałem możliwość definiowania własnych znaków co pozwoliło uzyskać duże cyfry widoczne z daleka. Niżej pokazuje jak uzyskać takie efekt. - najpierw musimy zdefiniować poszczególne elementy cyfr i ładujemy je do pamięci wyświetlacza uint8_t BigDigitDefChar[][8] = { {15,7,32,32,32,32,3,7}, {32,32,32,32,32,32,7,15}, {28,30,30,30,30,30,30,28}, {7,15,15,15,15,15,15,7}, {31,31,32,32,32,32,32,32}, {32,32,32,32,32,32,31,31}, {31,31,32,32,32,32,31,31}, {30,28,32,32,32,32,24,28} }; for(uint8_t i=0;i<8;i++) lcd_defchar(i,BigDigitDefChar[i]); - następnie tworzymy tablicę która poskleja nam te segmenty w cyfry char* BigDigit[][2]={ {"\x83\x84\x82","\x83\x85\x82"}, //0 {" \x82"," \x82"}, //1 {"\x80\x86\x82","\x83\x85\x85"}, //2 {"\x80\x86\x82","\x81\x85\x82"}, //3 {"\x83\x85\x82"," \x82"}, //4 {"\x83\x86\x87","\x81\x85\x82"}, //5 {"\x83\x86\x87","\x83\x85\x82"}, //6 {"\x83\x84\x82"," \x82"}, //7 {"\x83\x86\x82","\x83\x85\x82"}, //8 {"\x83\x86\x82","\x81\x85\x82"} //9 }; - teraz już tylko wystarczy użyć odpowiedniej funkcji do wyświetlania. Funkcja ta korzysta z obsługi R/W i odczytuje stan busy flag co pozwala na odczytanie pozycji kursora. Jeśli ktoś będzie chciał podłączyć R/W do GND to musi przerobić tą funkcję tak aby przekazać do niej pozycję kursora void lcd_big_int(int val) { uint8_t pp,x,y; char bufor[17]; char *wsk=itoa(val, bufor, 10); //zamieniamy całą liczbę na pojedyncze znaki ACSII np. 1234 -> '1','2','3','4' register uint8_t znak; while ( (znak=*(wsk++)) ) //pętla jest powtarzana po wszystkich indeksach tablicy bufor, aż napotka '\0' { pp = check_BF() & 0b01111111; //odczytujemy aktualną pozycję kursora - busy flag wyświetlacza y = pp & 0xF0; //wyodrębniamy nr wiersza x = pp & 0x0F; //wyodrębniamy pozycję x znak -= 0x30; //zamieniamy kod ascii na rzeczywistą wartość dziesiętną np '7' -> 7; będzie to nasz indeks do tablicy lcd_str(BigDigit[znak][0]); //ładujemy na wyświetlacz górną część cyfry lcd_write_cmd( (0x80 + y + 0x40 + x) ); //wracamy kursorem na domyślną pozycję x, ale o jeden wiersz niżej lcd_str(BigDigit[znak][1]); //ładujemy na wyświetlacz dolną część cyfry lcd_write_cmd( (0x80 + y + x + 0x03) ); //ustawiamy kursor zaraz za cyfrą w wierszu domyślnym, czyli takim w którym wywołano funkcję } } uint8_t check_BF(void) { CLR_RS; return _lcd_read_byte(); } Jest to prosty sposób na bardzo fajne wyświetlanie liczb, które są widoczne z daleka.
  19. Witam, mój system powstał z praktycznej potrzeby zautomatyzowania systemu podlewania i w celu rozpoczęcia przygody z elektroniką – wyszedłem z założenia, że jak teraz nie zrozumiem, jak działa to wszystko co jest dookoła, to za chwilę będzie to tak złożone, że nie zdążę już tego zrozumieć I generalnie myślę, że się udało – zrobiłem dokładnie to, co zamierzałem i w dodatku działa OPIS DZIAŁANIA SYSTEMU System w założeniu miał być jak najprostszy (tzn. działać przy jak najmniejszej potrzebie ingerencji człowieka w porównaniu do skomplikowanych systemów programowalnych, które są na rynku). Steruje on trzema liniami rozprowadzonymi w ogrodzie: woda w kranach, zraszacze trawników, linie kroplujące. Sterowanie odbywa się za pomocą elektrozaworów zasilanych z przekaźników (moduł 4 przekaźników). Przekaźnikami steruje Arduino na podstawie: włączenia/wyłączenia przełącznika, upłynięcia maksymalnego czasu określonego dla każdej linii (po upłynięciu tego czasu zawór zostaje zamknięty). System jest zasilany wodą z zestawu hydroforowego (żeby było odpowiednie ciśnienie), który pobiera wodę z ze zbiornika na deszczówkę (ZBIORNIK 1). Ponieważ nie jest on zbyt duży (3 m3) to istniała konieczność dopompowywania wody z drugiego zbiornika na deszczówkę (ten już ma 12 m3). Moje rozwiązanie opiera się na zamontowaniu w zbiorniku 1 dwóch czujników poziomu cieczy i pozwala na automatyczne dopompowywanie wody ze zbiornika 2 do zbiornika 1, gdy w tym poziom spadnie poniżej dolnego czujnika. Pompa, która jest w zbiorniku 2 wyłącza się, gdy poziom w zbiorniku 1 podniesie się powyżej górnego czujnika. REALIZACJA Do sterowania zaworami wykorzystałem Arduino. Początkowo plan był taki, żeby wszystko zrobić bez mikrokontrolera. Jednak Arduino jest mi potrzebne w drugiej wersji urządzenia (już się buduje), o której napisze poniżej. Na czystej elektronice (bez programowania) oparłem moduł sygnalizacji poziomu i uzupełniania wody w zbiorniku. Bazując na dwóch czujnikach poziomu wody mogę określić trzy stany wody w zbiorniku: niski, średni, wysoki. Zależało mi, żeby pompa uzupełniająca wodę zaczynała pompować, gdy woda w zbiorniku osiągnie poziom niski, a kończyła, gdy osiągnie stan wysoki. Poprzez umieszczenie czujników jak najdalej od siebie, uzyskałem samoczynne uzupełnianie zbiornika. Do tego wykorzystałem dwa układy scalone: bramkę OR oraz NAND co pozwoliło zastosować trzy diody oznaczające poziom wody. Logika włączania tych diod jest następująca: Bramkę NAND wykorzystałem dodatkowo jako przerzutnik bistabilny, który pamięta czy pompa jest włączona, czy wyłączona. Oto płytka sporządzona samodzielnie na potrzeby projektu: KONSTRUKCJA Całe urządzenie udało się zamknąć w standardowej obudowie hermetycznej z wyprowadzeniem przewodów do zasilania, podłączenia zaworów, czujników poziomu wody i przewodu sterującego pompą. Do wykonanie „wtyczek” do zaworów wykorzystałem tworzywo, które mięknie w 60 stopniach i w ciepłej wodzie robi się plastyczne – można wszystko ulepić. Chodziło o to, że przy zaworach, jak najbliżej, powinny się znaleźć diody prostownicze i dlatego zrobiłem wtyczki z zatopionymi diodami. Jest to bardzo wygodne przy rozmontowywaniu systemu na zimę. Działanie systemu widać na poniższym filmie (na uchwycie wiszą czujniki poziomu wody). System działał już jeden sezon, także jest sprawdzony. PLANY NA PRZYSZŁOŚĆ Druga wersja urządzenia będzie miała dołączone czujniki deszczu i wilgotności gleby, będą pobierane komunikaty pogodowe z lotniska i będzie sterowanie zaworami przez wifi z telefonu. Chcę także dodać obsługę kalendarza do określenia czasu godziny, gdy system ma się włączać. Długość podlewania będzie sterowana czujnikami wilgotności i deszczu a włączenie podlewania uzależnione od przewidywanej pogody. Myślę, że więcej do systemu podlewania nie jest potrzebne. Musze powiedzieć, że budowa tego urządzenia dała mi wiele satysfakcji, bo nie zajmuję się zawodowo elektroniką ani programowaniem. Chciałbym szczególnie podziękować Trekerowi za kursy, dzięki którym było łatwo zacząć przygodę z elektroniką oraz Markowi za cenne uwagi i przekazaną wiedzę.
  20. atlantis86

    Jeszcze jeden zegar binarny

    Amatorską elektroniką zainteresowałem się po raz pierwszy w połowie lat dziewięćdziesiątych, będąc jeszcze dzieciakiem ze szkoły podstawowej. Moja aktywność na tym polu ograniczała się wówczas głównie do składania cudzych konstrukcji z pojedynczych tranzystorów, analogowych układów scalonych czy bramek logicznych. Brakowało mi wiedzy i narzędzi, aby zająć się czymś poważniejszym. Szczególnie wejście w świat mikrokontrolerów nie wchodziło w grę - zakup programatora i podręczników z kieszonkowego nie wchodził w grę, a i same elementy do tanich nie należały. Największą popularnością cieszyła się wówczas rodzina 8051, szczególnie w wykonaniu firmy Atmel (np. AT89C2051 albo AT89C51). Tematem mikrokontrolerów zająłem się wiele lat później, na początku obecnej dekady, standardowo zaczynając od AVR-ów. Kilka lat temu przy okazji zakupów na Allegro zauważyłem jednak w ofercie jednego ze sprzedawców stare układy AT89C51, co spowodowało natychmiastowy "atak" nostalgii. Od razu zamówiłem kilka sztuk. Dopiero potem zorientowałem się, że nie dysponuję programatorem. Na szczęście okazało się, że te można bez większych problemów kupić na najpopularniejszym chińskim serwisie aukcyjnym. Czekając na przesyłkę zorientowałem się w temacie programowania tych mikrokontrolerów w czasach współczesnych, wczytując się w dokumentację kompilatora SDCC. Po kilku tygodniach dysponowałem już podstawami wiedzy i zestawem narzędzi potrzebnych do realizacji projektu. Na tym etapie musiałem odpowiedzieć sobie na pytanie o jego temat. Szukałem czegoś, co byłoby popularną konstrukcją wśród amatorów elektroników w czasach, gdy ja zaczynałem zajmować się tym hobby. Zegar binarny zdawał się być oczywistą odpowiedzią. Urządzenie powstawało głównie wieczorami, w ciągu kilku tygodni. Składają się na nie dwie jednostronne płytki drukowane. Pierwsza zawiera wyświetlacz oparty na LED-ach oraz zestaw przycisków, druga logikę sterującą. Składają się na nią mikrokontroler AT89C51, zegar czasu rzeczywistego DS1307 z gniazdem baterii podtrzymującej, układ zasilania oraz niewielki głośnik piezoelektryczny. Przeznaczenie tego ostatniego jest dość specyficzne - co sekundę, przy odświeżaniu zawartości wyświetlacza generuje on dźwięk przypominający "tykanie" klasycznego zegara mechanicznego. Celem projektu było stworzenie urządzenia w stylu lat dziewięćdziesiątych, bez współczesnych ulepszeń w stylu automatycznej synchronizacji czasu za pomocą łączności sieciowej albo modułu GSM. Zegar nie robi nic poza wyświetlaniem czasu w formie binarnej (a właściwie BCD), a ustawia się go ręcznie. Oprogramowanie sterujące zostało napisane w języku C i skompilowane za pomocą kompilatora SDCC, szczelnie wypełniając dostępne 4kB pamięci flash mikrokontrolera.Obudowa urządzenia została wycięta laserowo. Za pomocą tego samego narzędzia został na niej wygrawerowany rysunek. Obecnie w realizacji (z uwagi na brak czasu i ważniejsze projekty) jest projekt bliźniaczego zegara, który tym razem będzie korzystał ze współczesnej elektroniki, opartej na module ESP8266.
  21. W ramach pracy magisterskiej wykonałem dedykowany sterownik do stacji uzdatniania wody, jako alternatywę dla sterowników PLC. Sam temat pracy został zaproponowany przeze mnie dlatego, że lubię robić coś bardziej kreatywnego niż pisanie suchego tekstu. Promotorowi bardzo się to spodobało i nie było żadnego problemu aby przystąpić do tego zagadnienia. Pewnie niektórzy się zastanowią dlaczego akurat stacja uzdatniania wody? W tamtym czasie pracowałem w automatyce przemysłowej i głównie robiliśmy właśnie takie obiekty. Zawsze były one robione na sterownikach PLC, są to drogie zabawki. Pomyślałem, że można zrobić prototyp takiego dedykowanego sterownika do tego rodzaju pracy, a w przyszłości dostosować go do różnych obiektów, gdzie jest różna ilość zaworów, pomp, zbiorników itp, ale zawsze jest ta sama część wspólna czyli sterowanie samym procesem uzdatniania. Sterownik został oparty o procesor Atmega128, a wszystko zostało dopasowane do obudowy na szynę DIN Z104J. Podstawowe cechy to: 32 wejścia cyfrowe 16 wyjść cyfrowych 5 wejść analogowych zegar RTC RS485 zdalny dostęp przez przeglądarkę www Sam procesor ma zbyt małą ilość wyprowadzeń aby obsłużyć wszystkie sygnały sterujące. Aby zwiększyć ilości wejść/wyjść wykorzystałem ekspandery na I2C - PCF8574. Podzieliłem całość na logiczne moduły, podobnie jak to jest w sterownikach PLC: 4 moduły DI - cyfrowe sygnały wejściowe 2 moduły DO - cyfrowe sygnały wyjściowe 1 moduł AI - analogowe sygnały wejściowe moduł RS485 Na wejściach cyfrowych do zabezpieczenia zastosowałem optoizolatory takie jak są wykorzystane np. tutaj TLP281. Na poniższym schemacie przedstawiony jest jeden taki blok. Masy są rozdzielone, co może w prost nie wynika ze schematu. Układ wyjściowy jest zrealizowany w oparciu o UDN2987 Moduł Analogowy został skonstruowany tak aby przyjmować sygnały prądowe 4..20mA. Jest to przemysłowy standard najczęściej wykorzystywany w czujnikach. Cechuje go prostota obsługi i uniwersalność, a fakt, że dolny zakres pomiarowy to 4mA ułatwia to detekcję wadliwego czujnika. W celu pokazania całego procesu uzdatniania wody wykonałem model o wymiarach 100cm x 50cm ukazujący różne etapy pracy takiej stacji, jak: uzdatnianie płukanie zbiorników ze złożem uzdatniającym napowietrzanie zbiorników napełnianie zbiornika retencyjnego chlorowanie układu w celu dezynfekcji dostarczanie uzdatnionej wody do odbiorców Na makiecie umieszczone zostały diody sygnalizujące otwarcie poszczególnych zaworów, co pozwala w łatwy sposób zaobserwować jak zachodzi cały proces pracy takiej stacji. Zamontowane są również potencjometry przy przepływomierzach, są one wpięte w pętle prądową aby zachować zgodność z prawdziwymi czujnikami przepływu. Na tej podstawie można zliczać ile wody zostało uzdatnionej, dobierać interwały pracy i wyznaczać potrzebę płukania filtrów. Całe sterowanie wykonałem w oparciu o web serwer z wykorzystaniem ASP.NET, tworząc taką mini SCADe. Wizualizacja wiernie odzwierciedla cały model. Serwer to aplikacja na system Windows, do którego podpięty jest moduł USB <-> RS485 zapewniający komunikację ze sterownikiem. Mamy podgląd na żywo całego procesu, dane są odświeżane automatycznie na bieżąco. W aplikacji możemy ustawić wszystkie parametry pracy sterownika, podglądać alarmy i włączać na żądanie wybrane etapy takie jak płukanie filtrów czy pobieranie wody ze studni głębinowej. Sam proces uzdatniania wody może nie jest technologicznie skomplikowany, ale jest bardzo ciekawy od strony automatyki. Jako ciekawostkę dodam, że złoże które znajduje się w zbiornikach filtrujących to po prostu odpowiednie kruszywo wiążące konkretne cząsteczki z wody, najczęściej jest to odżelaziacz i odmanganiacz.
  22. Masz gotowy wspaniały bulbulator oparty na chipie ESP8266 (np na modułach WiFi ESP8266 Wemos NodeMCU V3 32MB, ArduCam ESP8266-12E WiFi IoT, Adafruit Feather Huzzah ESP8266, Adafruit Huzzah ESP8266, SparkFun Thing - Dev Board - moduł WiFi ESP8266). Tworzy on stronę WWW, którą możesz zdalnie doglądać jego pracy. Niestety posiadasz łącze stałe ze zmiennym IP. W jaki sposób możesz więc połączyć się z nim będąc poza domem? Z pomocą przychodzą usługi typu Dynamic DNS. Jedną z nich jest polski serwis https://freedns.42.pl, z którego od lat korzystam. Zapewnia on przykładowy skrypt Pythona do uaktualniania rekordów DNS. Niestety nie skorzystamy z niego bezpośrednio w Arduino. Musimy więc napisać własny szkic. Celem podejrzenia danych wysyłanych do serwera nieco zmodyfikowałem gotowy skrypt Pythona podmieniając server = "https://freedns.42.pl/xmlrpc.php" na adres localhost swojego własnego programu napisanego w C++, który zapisał nagłówek i dane przekazywane do serwera. Tak oto powstał szkic Arduino zawierający trzy funkcje: publicIP() - sprawdzająca aktualne publiczne IP gethostbyname(String host) - sprawdzająca IP przypisane do domeny w rekordach DNS - rekord adresów (A) updateDynDNS() - odpowiedzialna za uaktualnienie wpisu w serwisie FreeDNS Możemy teraz cyklicznie wywoływać w pętli loop polecenia: String myIP = publicIP(); String hostIP = gethostbyname(dnsset.subdomain + "." + dnsset.domain); if (myIP != hostIP) { dnsset.newaddress = myIP; updateDynDNS(); Serial.println("FreeDNS IP: " + hostIP); Serial.println("Public IP: " + myIP); } Sprawdzamy więc nasze aktualne publiczne IP, potem IP przypisane do domeny w DNS. Jeśli się nie zgadzają - wtedy uruchamiamy "machinę" odpowiedzialną za komunikację z FreeDNS. Polecam użyć jakiegoś timera czy skorzystać z funkcji millis(), nie blokującego działanie innych funkcji delay() Cały kod źródłowy programu: #include <ESP8266HTTPClient.h> #include <ESP8266WiFi.h> #include <WiFiClientSecure.h> struct FreeDNSsettings { String domain; String subdomain; String newaddress; String user; String password; String ttl; } dnsset; void setup() { dnsset.domain = "TwojaDomena.pl"; dnsset.subdomain = "Nazwa subdomeny"; dnsset.user = "Uzytkownik w serwisie freedns.42.pl"; dnsset.password = "haslo uzytkownika"; dnsset.ttl = "120"; Serial.begin(9600); //Serial connection WiFi.softAPdisconnect(); WiFi.disconnect(); WiFi.mode(WIFI_STA); WiFi.begin("Siec WiFi", "i haslo do niej"); //WiFi connection while (WiFi.status() != WL_CONNECTED) { //Wait for the WiFI connection completion delay(500); Serial.println("Waiting for connection"); } } void loop() { if (WiFi.status() == WL_CONNECTED) { //Check WiFi connection status String myIP = publicIP(); String hostIP = gethostbyname(dnsset.subdomain + "." + dnsset.domain); if (myIP != hostIP) { dnsset.newaddress = myIP; updateDynDNS(); Serial.println("FreeDNS IP: " + hostIP); Serial.println("Public IP: " + myIP); } } else { Serial.println("Error in WiFi connection"); } delay(15 * 60 * 1000); } String publicIP() { String myIP; HTTPClient http; http.begin("http://ip.42.pl/raw"); //Specify request destination int httpCode = http.GET(); //Send the request if (httpCode > 0) { //Check the returning code myIP = http.getString(); //Get the request response payload } return myIP; } String gethostbyname(String host) { IPAddress ipAddress; WiFi.hostByName(host.c_str(), ipAddress); return String(ipAddress[0]) + String(".") + \ String(ipAddress[1]) + String(".") + \ String(ipAddress[2]) + String(".") + \ String(ipAddress[3]); } void updateDynDNS() { String xml = "<?xml version='1.0'?>\r\n" "<methodCall>\r\n" "<methodName>xname.updateArecord</methodName>\r\n" "<params>\r\n" "<param>\r\n" "<value><struct>\r\n" "<member>\r\n" "<name>name</name>\r\n" "<value><string>" + dnsset.subdomain + "</string></value>\r\n" "</member>\r\n" "<member>\r\n" "<name>zone</name>\r\n" "<value><string>" + dnsset.domain + "</string></value>\r\n" "</member>\r\n" "<member>\r\n" "<name>newaddress</name>\r\n" "<value><string>" + dnsset.newaddress + "</string></value>\r\n" "</member>\r\n" "<member>\r\n" "<name>oldaddress</name>\r\n" "<value><string>*</string></value>\r\n" "</member>\r\n" "<member>\r\n" "<name>updatereverse</name>\r\n" "<value><string>0</string></value>\r\n" "</member>\r\n" "<member>\r\n" "<name>user</name>\r\n" "<value><string>" + dnsset.user + "</string></value>\r\n" "</member>\r\n" "<member>\r\n" "<name>ttl</name>\r\n" "<value><string>" + dnsset.ttl + "</string></value>\r\n" "</member>\r\n" "<member>\r\n" "<name>password</name>\r\n" "<value><string>" + dnsset.password + "</string></value>\r\n" "</member>\r\n" "</struct></value>\r\n" "</param>\r\n" "</params>\r\n" "</methodCall>"; String http = "POST /xmlrpc.php HTTP/1.1\r\n" "Host: freedns.42.pl\r\n" "Accept-Encoding: gzip\r\n" "Content-Type: text/xml\r\n" "User-Agent: Python-xmlrpc/3.5\r\n" "Content-Length: " + String(xml.length()) + "\r\n" "\r\n"; xml = http + xml; WiFiClientSecure client; IPAddress ipAddress; WiFi.hostByName("freedns.42.pl", ipAddress); client.connect(ipAddress, 443); client.print(xml); } Biblioteka WiFiClientSecure występuje w środowisku ESP8266 relatywnie od niedawna. Jeśli macie problemy z kompilacją szkicu właśnie z jej powodu - uaktualnijcie obsługę ESP w Arduino IDE. Po niewielkich modyfikacjach przypuszczalnie (niestety chwilowo nie mogę tego sprawdzić) uaktualniacz DNS działać będzie również z mikrokontrolerem ESP32. Chyba wystarczy podmienić nazwy dołączanych bibliotek na: #include <HTTPClient.h> #include <WiFi.h> #include <WiFiClientSecure.h>
  23. Niewątpliwie procesory, bądź mikroprocesory stanowią ogromną część elektroniki użytkowej. Prawie w każdym urządzeniu, poczynając od najprostszych, a kończąc na najbardziej zaawansowanych komputerach, najważniejsza jest jednostka centralna. Czasy największej świetności ośmiobitowe procesory mają już za sobą, ale nadal stanowią ważną część elektroniki. Wiele urządzeń nadal z nich korzysta. Moją przygodę z elektroniką cyfrową rozpocząłem od programowania mikroprocesorów firmy Atmel były to dokładniej procesory Atmega8 oraz Atmega328. Mimo wielkich możliwości jakie dają mikrokontrolery bardziej interesowała mnie strona hardware’owa tych układów. Na ich podstawie oraz procesorów takich jak Intel 4004, 8080 stopniowo poznawałem budowę oraz działanie mikroprocesorów. W pewnym momencie stwierdziłem że nie jest to takie trudne i sam zbuduję własny procesor. Był to DCE 4 (D-digital, C-computer, E-electronic, 4 ponieważ była to jednostka czterobitowa). Następnie rozpocząłem prace nad ośmiobitowym procesorem DCE 84. Jednak i on z upływem czasu wydał mi się bardzo prosty. Prezentowany mikroprocesor DCE 812 zaprojektowałem korzystając z rozwiązań zastosowanych w DCE 84 bazując na pełnej architekturze harwardzkiej (gdzie pamięć dla programu i danych jest fizycznie rozdzielona). Schemat blokowy układu można znaleźć poniżej. Do budowy zostały użyte podstawowe układy logiczne wykonane w technologii CMOS (przykładowo bramki AND) oraz gotowe układy pamięci RAM (UL6516 2k x 8bit) oraz ROM(dwa układy 28c64 8k x 8bit) , ponieważ budowa własnych pamięci nie była możliwa z powodu braku czasu i środków. Elementy takie jak ALU, układ sterowania, zegar, oraz obsługa pamięci i poszczególnych rejestrów roboczych została zaprojektowana przeze mnie od podstaw. Fizycznie układ powstał stosunkowo niedawno i nie obyło się bez komplikacji. Zmiana układu obsługującego pamięć RAM sprawiła, że układ działa zgodnie z założeniami. Pozwala on na wykonywanie podstawowych działań matematycznych oraz prostych programów stworzonych w języku C++ i przekonwertowanych na polecenia dla tego procesora. Najbardziej zaawansowanym programem, który udało mi się uruchomić było generowanie kolejnych liczb z ciągu Fibonacciego. Praca mikroprocesora zostaje rozpoczęta od wciśnięcia fizycznego przycisku RESET, który ustawia stan "0" na wyjściach wszystkich wewnętrznych rejestrów. Uzyskujemy poprzez to adres zero na wyjściu licznika rozkazów co powoduje rozpoczęcie pracy od pierwszego wprowadzonego rozkazu (lista rozkazów widoczna na zdjęciu poniżej). Następnie układ zaczyna liczyć od 0 do 15 wewnątrz układu sterowania do każdej z tych mikrooperacji przypisane jest odpowiednie działanie zgodne z rozkazem wprowadzonym do pamięci ROM może to być np. zapis do rejestru B, reset licznika rozkazów. Po wykonaniu wszystkich mikrooperacji licznik rozkazów zwiększa swoją wartość o jeden co skutkuje przejściem do kolejnego rozkazu i cały cykl wykonywany jest ponownie. Programowanie procesora realizowane jest poprzez odpowiednie przełączniki które umożliwiają przełączanie układu między stanem pracy a programowaniem. Wprowadzanie danych oraz wybieranie adresów również realizowane jest w ten sposób. Odpowiednie przełączniki służą również do sterowania zegarem procesora. Generowanie impulsów może odbywać się automatycznie z częstotliwością ok. 10Hz lub manualnie poprzez wciśnięcie przycisku. Obecnie projektuje kolejną wersje własnego procesora tym razem staram się wszystko umieścić w jednym układzie FPGA (Korzystam z tej płytki). Postępy w pracach można obserwować na moim blogu https://rafal-bartoszak.blogspot.com/ Dodatkowo wstawiam też link do filmu gdzie można zobaczyć działanie układu.
  24. Witam forumowiczów, na wstępie wspomnę iż dopiero rozpoczynam swoją przygodę z elektroniką toteż proszę o wyrozumiałość jeśli pojawi się taka potrzeba. Mam do przygotowania urządzenie którego opis przygotowałem poniżej. Urządzenie ma posiadać wbudowaną pamięć w której przechowywane będą pliki audio oraz pliki tekstowe (.txt, .xlsx, .csv, itp.) które powinny mieć możliwość łatwej aktualizacji (np. podłączenie tabletu lub telefonu przez bluetooth lub usb / wifi / wbudowany slot na kartę SIM i aktualizacja przez internet (preferowane jeśli cena nie okaże się zaporowa)). Pamięć nie powinna być potrzebna większa niż 100 megabajtów. Urządzenie ma być zamknięte w niesprecyzowanej jeszcze obudowie z jednym przyciskiem zewnętrznym po naciśnięciu którego na podstawie zawartości plików tekstowych oraz aktualnej godziny odtwarzany ma być wybrany przez algorytm plik audio. Urządzenie powinno być dostosowane do działania w warunkach zewnętrznych. Zasilanie urządzenia ma pochodzić z sieci energetycznej, ewentualnie z baterii połączonej z panelem fotowoltaicznym. W pierwszej kolejności muszę ustalić platformę która będzie najlepsza (najtańsza ze spełniających założenia). Po wstępnym sprawdzeniu rozwiązań doszedłem do wniosku, że najlepszą platformą do realizacji powyższego zadania będzie Arduino ewentualnie Raspberry pi‎. Oba rozwiązania wydają się oferować wszystko czego potrzebuję. Czy mam rację i powinienem wybrać jedno z tych rozwiązań? Może coś przeoczyłem i wspomniane rozwiązania uniemożliwiają realizację któregoś z opisanych wymagań? Czy może jest jakieś inne które spełni wymagania a w realizacji okaże się tańsze? Z góry dziękuję za zainteresowanie i odpowiedź. W przypadku zainteresowania wątkiem chętnie będę go kontynuować ponieważ wybór rozwiązania to dopiero pierwszy krok na długiej drodze do powstania prototypu.
  25. Jednym z moich pierwszych "poważniejszych" projektów, jakie zrealizowałem w ramach nauki programowania mikrokontrolerów był EtherGeiger - sieciowy detektor promieniowania jonizującego. Projekt stworzony w 2014 roku miał być swoistym żartem, nawiązującym swoją tematyką do Fallouta i post-apokaliptycznych filmów science-fiction. Wszystko zaczęło się od zakupionego na Allegro radzieckiego detektora Geigera typu STS-5. Przyrząd ten wymaga do działania wysokiego napięcia, w okolicy 400V. Jest ono wytwarzane przez przetwornicę typu flyback, pracującą na popularnym układzie MC34063A. Sercem pierwszej wersji urządzenia był mikrokontroler Atmega328, a za komunikację ze światem zewnętrznym odpowiadał układ ENC28J60, zwykle stosowany w popularnych modułach, tutaj przylutowany bezpośrednio do płytki urządzenia. Oprogramowanie sterujące pracą urządzenia zostało napisane w języku C, przy pomocy środowiska Atmel Studio. Poza pomiarem promieniowania tła urządzenie zbierało także informacje o temperaturze otoczenia, ciśnieniu atmosferycznym i wilgotności względnej. Wykorzystane zostały w tym celu moduły BMP280 oraz DHT11/DHT22. Wyniki pomiarów były przekazywane do serwera odpalonego na Raspberry Pi, który był odpowiedzialny za ich zapisywanie. W przypadku wykrycia wartości przekraczającej ustaloną wcześniej normę, oprogramowanie wysłałoby powiadomienie na telefon, za pośrednictwem serwisu Pushover. Projekt będący w zamierzeniach jedynie żartem (o pewnej wartości dydaktycznej) dwukrotnie okazał się być bardzo przydatny, gdy do mediów społecznościowych zaczęły trafiać fake newsy mówiące o awariach elektrowni atomowych i chmurze radioaktywnego pyłu, zmierzającego rzekomo nad Polskę. W ubiegłym roku projekt doczekał się nowej wersji, opartej na mikrokontrolerze PIC32MX270F265B. Pozwoliło to na dodanie nowych funkcji, m.in. wyposażenie urządzenia w PenDrive'a do lokalnego zapisywania pomiarów (w przypadku jego braku dane są zapisywane we wbudowanej pamięci SPI Flash). Zastosowany został także pojedynczy czujnik temperatury, ciśnienia i wilgotności, typu BME280. Planowana jest także rozbudowa tej wersji o dodatkową płytkę z wyświetlaczem LCD.
×