Przeszukaj forum

Dzień dobry, mam : ESP8266 + NodeMCU v3 modul-wifi-esp8266-nodemcu-v3 umiem podłączyć ( i odczytywać wartości ) z kilku czujników temperatury ... sukces 🙂 ale nie umiem poradzić sobie z tym aby z innych płytek shelly pm1 1 generacja ( oczywiście z adapterem i zew czujnikiem temp ) shelly-1-pm pobierać wartości aktualne temperatur i odczytywać na tej w/w płytce "ESP8266 + NodeMCU v3" Co chcę uzyskać , po co tak chcę zrobić ? Shelly działają poprawnie , wysyłają poprawnie do chmury shelly , mogę się logowac tam lokalnie i ale w taki sposób widzę tylko aktualne temperatury i temperaturę min i max w konkretnej godzinie, nie widzę jak zmienia się temperatura w ciągu godziny. Poza lokalnym panelem w shelly mozna też wywołać status ( http://ip/status ) , są tam te wartości aktualne ale i pozostałe inne dane urzadzenia. ......................................{ "0":{"hwID":"tu-chyba-id-czujnika0","tC":39.50,"tF":103.10}, "1":{"hwID":"tu-chyba-id-czujnika1","tC":41.44,"tF":106.59} }...................................... Nie wiem jak ruszyć dalej. Czy ktoś jest w stanie podpowiedzieć ?

Od dawna interesowały mnie pomiary warunków meteorologicznych w mojej miejscowości, pierwsza stacja meteorologiczna, którą zbudowałem około roku 2010, wykonana była na mikrokontrolerze Atmega32. Do komunikacji z światem wykorzystywała moduł LAN Wiznet 7010a. Stacja ta była oprogramowana w języku BASCOM. Projekt który chcę zaprezentować dzisiaj działa już od roku 2018 i został oprogramowany w środowisku Arduino. Stacja została podzielona na 2 moduły, pierwszy pomiarowy oparty jest na klonie Arduino Nano oraz drugi odbiorczy którego sercem jest ESP8266 NodeMCU v3, służy on również do wyświetlania aktualnych pomiarów na wyświetlaczu LED dot matrix o wymiarach 8x56 punktów. Na pracach stolarskich się nie będziemy skupiać napiszę tylko że klatka meteorologiczna została wykonana z drewna sosnowego i umieszczona na wysokości 2 m. Moduł Pomiarowy Czujniki jakie zastosowałem to dwie sztuki DS18B20 pierwszy zajmuje się pomiarem temperatury przy gruncie na wysokości 5cm, drugi pełni rolę zapasowego czujnika temperatury na wypadek uszkodzenia się głównego czujnika BME280. Do pomiaru prędkości wiatru wykorzystuję wiatromierz firmy Maplin na jeden obrót wiatromierza przypadają 2 impulsy z kontaktronu który jest w nim zamontowany, producent dostarcza również odpowiedni wzór według którego można obliczyć rpm oraz prędkość wiatru w km/h. Dane mierzone przez wiatromierz możemy podzielić na dwie wartości, pierwsza to chwilowa prędkość, druga prędkość w porywach, aby uśrednić wartości mierzone program zlicza impulsy z 5s a następnie dokonuje odpowiednich obliczeń. Zebrane dane przesyłane są do drugiego urządzenia poprzez moduły radiowe które działają na częstotliwości 433,92 MHz. W tym celu zastosowana została biblioteka RCSwitch. Każda mierzona wartość jest wysyłana jako osobna transmisja. aby rozróżnić pomiary z konkretnych czujników mierzona wartość mnożona jest przez 100 a następnie dodawana jest liczba 100 000 dla pierwszego czujnika, 200 000 dla drugiego itd. Przykład kodu który realizuje tę funkcję poniżej: // temperatura sensor BME codetosend = temp * 100 + (1 * 100000); mySwitch.send(codetosend, 24); // wilgotnosc sensor BME codetosend = hum * 100 + (2 * 100000); mySwitch.send(codetosend, 24); Moduł Wewnętrzny Obudowa, która idealnie nadawała się do implementacji wewnętrznego modułu pochodzi z tunera IPTV Motorola VIP1910-9. Przedni panel został wykonany z ciemnego półprzepuszczalnego plastiku który idealnie nadaje się do umieszczenia w nim wyświetlacza. Sercem urządzenia jest układ ESP8266. "Moduł wewnętrzny" został również wyposażony w czujnik temperatury oraz wilgotności DHT22, dodatkowo w celu prezentacji zmierzonych wartości dołączone zostało 7 szt. modułów wyświetlacza LED dot matrix z układem MAX7219. Do obsługi tej matrycy zastosowałem bibliotekę Max72xxPanel.h która współpracuje z biblioteką Adafruit_GFX.h w ten sposób nie byłem zmuszony implementować do rozwiązania własnych czcionek. Matryca ta oprócz modułowej konstrukcji umożliwia również sterowaniem jasnością podświetlania, w tym celu aby uprzyjemnić użytkowanie w porach nocnych odbiornik został wyposażony w fotorezystor dzięki któremu potrafi określić natężenie oświetlenia otoczenia i odpowiednie ustawienie podświetlenia. Na wyświetlaczu w pierwszej kolejności wyświetlam aktualną godzinę oraz temperaturę wewnątrz pomieszczenia oraz wilgotność, po około jednej minucie wyświetlane są informacje odczytane z stacji meteo czyli temperatura wilgotność i ciśnienie, postanowiłem nie wyświetlać tutaj informacji dotyczących prędkości wiatru oraz temperatury przy gruncie. Decyzję tą podjąłem na podstawie użytkowania innego podobnego rozwiązania, akurat jak chcemy odczytać godzinę to wyświetlane są inne informacje. Dodatkowo w godzinach nocnych, które zostały ustawione w sztywnych ramach czasowych między 21:00 a 7:00 informacje odczytane z stacji meteo zostały okrojone tylko do temperatury. W projekcie zostały zastosowane 2 rodzaje animacji pierwsza z nich, przesuwa tekst z prawej strony wyświetlacza na lewą, z możliwością zatrzymania w interesujących momentach. Drugi rodzaj to pionowa animacja. Mikrokontroler również poprzez protokół NTP i bibliotekę time.h pobiera aktualną godzinę i datę. Za odbiór danych z pierwszego układu odpowiedzialny jest moduł radiowy którego obsługą tak jak w poprzednim module zajmuje się biblioteka RCswitch. Poniżej fragment programu który demonstruje w jaki sposób odbierane i dekodowane są dane: rc = mySwitch.getReceivedValue(); // czujnik temperatury powietrza BME280 if (abs(rc)>=50000&& abs(rc)<150000) { rc=(rc-100000)/100; if (rc > -50 and rc < 60) { temp1 = rc; Serial.print("Czujnik BME280 - temperatura: \t"); Serial.println(rc); matrix.drawPixel(55,0,1); matrix.write(); } } // czujnik wilgotności BME280 if (abs(rc)>=150000 && abs(rc)<250000) { rc=(rc-200000)/100; if (rc > 5 and rc <= 100) { hum = rc; Serial.print("Czujnik BME280 - wilgotnowsc: \t"); Serial.println(rc); matrix.drawPixel(55,1,1); matrix.write(); } } Dzięki zastosowaniu zewnętrznej anteny oraz odbiornika opartego na superheterodynie, zasięg w otwartym terenie to około 250 m. Po odebraniu danych z pierwszego układu poprzez moduł radiowy następuje przekazanie ich do serwera z systemem Domoticz. Domoticz to bardzo lekki system automatyki domowej, który pozwala monitorować i konfigurować różne urządzenia, przełączniki, czujniki takie jak temperatura, opady deszczu, wiatr, promieniowanie ultrafioletowe (UV), zużycie energii elektrycznej, zużycie gazu, zużycie wody i wiele więcej. Wykresy dostępne są również na stronie www http://meteo.palowice.net Poniżej film z działania odbiornika, smużenie animacji które występuje na filmiku ludzie oko nie rejestruje. Gdyby kogoś interesował kod to również zamieszczam: meteo.zip

Interaktywna zabawka dla kotów gwarantująca zabawę w każdej chwili, żaden kot nie oprze się uciekającej czerwonej kropce. Jest to niewielkie pudełeczko z wbudowanym modułem wifi i banalnie prostą obsługą. Główne funkcje: sterowanie dowolnym urządzeniem z przeglądarką internetową. losowe ruchy lasera o zmiennej prędkości. ustawianie czasu jak długo ma działać. ustawianie harmonogramów automatycznego włączenia. regulacja jasności lasera. regulacja zakresu ruchu i prędkości lasera. możliwość sterowania z dowolnego miejsca na świecie przez internet. sterowanie za pomocą google asystenta. prosta konfiguracja. Zabawka może być zasilana dowolną ładowarką od telefonu, może to być również powerbank. Przy pierwszym uruchomieniu zabawki, zostanie uruchomiona nowa sieć wifi ..::LASERCAT::.. wystarczy połączyć się z nią i wskazać naszą sieć domową, a po zrestartowaniu urządzenie automatycznie podłączy się do niej i już możemy korzystać z zabawki. Z tyłu znajduje się wejście zasilania micro USB, jak w telefonie oraz przycisk. Krótkie wciśnięcie to włączenie/wyłączenie lasera, przytrzymanie przez 3 sek. powoduje rozłączenie obecnej sieci wifi i uruchomienie ponownej konfiguracji. Gdy urządzenie jest już podłączone do naszej sieci wifi to po wpisaniu adresu zabawki w przeglądarce internetowej zobaczymy panel sterujący: Zastosowany laser jest małej mocy, taki sam jak w innych tego typu zabawkach czy bazarkowych wskaźnikach. Dodatkowo dla bezpieczeństwa jest możliwość ustawienia mocy świecenia lasera od 0% do 100%. Pozostałe ustawienia pozwolą dostosować zakres ruchów do miejsca w którym znajduje się zabawka i określić czy kropka ma się poruszać tylko po podłodze, czy częściowo wchodzić na ścianę co może dostarczyć dodatkowej frajdy dla kota. Schemat jest bardzo prosty: Widok płytki PCB: Jak zwykle w garażowym zaciszu metodą "żelazkową" - elektronicy używają żelazka zdecydowanie częściej jak ich partnerki 😅 - powstaje mała płytka. Płytka została zabezpieczona przed utlenianiem lakierem PVB16. Całą robotę wykonuje tutaj tani i lubiany układ ESP8266, który posiada moduł WiFi. Dioda laserowa jest zasilana źródłem prądowym dodatkowo kluczowanym z PWM-a co pozwala płynnie regulować jasność od 0% do 100%. Skoro już bebechy mam, to teraz trzeba to wszystko złożyć w całość. Obudowę wykonałem ze sklejki wyciętej laserowo, składanej na wczepy palcowe. No to składamy: Dodanie serwomechanizmów do których przyczepiony jest laser. Oczywiście bez trytytki projekt by się nie udał 😏 No i sprzęt jest gotowy, ale co nam po sprzęcie jak on zupełnie nie wie co ma robić? Nie wie, że teraz trzeba machać tym laserkiem tak żeby kot ganiał w tę i we w tę 😉 Trzeba to wszystko zaprogramować. Uruchamiamy nasze ulubione IDE czyli Visual Studio Code z wtyczką PlatformIO i zaczynamy pisać program. Soft został napisany z wykorzystaniem Arduino Core, a na całość składa się kilka części: główny program sterujący silniczkami, wyznaczanie losowych ścieżek. serwer www, który udostępnia ładny panel sterowania. konfiguracja sieci WiFi z wykorzystaniem Captive Portal. multicast DNS. stworzenie strony www (html + css + javascript). obsługa komunikacji po websockecie. zdalne wgrywanie plików przez stronę www, np. zmiana wyglądu głównej strony. zdalna aktualizacja oprogramowania bez zbędnych kabli. W oczekiwaniu na gotowe oprogramowanie tester cierpliwie czeka. Panel sterujący dostępny z poziomu przeglądarki internetowej nie jest hostowany nigdzie na zewnątrz, całość znajduje się w zabawce, wykorzystałem bootstrapa plus kilka dodatkowych komponentów. Zastosowany mDNS pozwala połączyć się z urządzeniem wpisując w przeglądarce adres "lasercat.local" zamiast adresu IP. Niestety na chwilę obecną android nie wspiera tego typu rozwiązań, ale na iPhonach działa to bardzo dobrze. Na filmie mała prezentacja z trochę już wybawionym głównym testerem Elroyem 🙂 a poniżej pokazano jak można włączyć zabawkę po prostu mówiąc do telefonu "Ok Google, włącz laser"

Witam chcę aby moja płytka esp8266 wyświetliła mi dares mac. Lecz po załadowaniu programu ten wykonuje się w pętli i wyświetla tylko końcówkę adresu mac. Arduino ide 2.2.1 #include <ESP8266WiFi.h> void setup(){ Serial.begin(115200); Serial.println(); Serial.print("ESP8266 Board MAC Address: "); Serial.println(WiFi.macAddress()); } void loop(){ } A podczas załadowywania i kompilacji kodu konsola wyświetla następujące informacje: "/Users/wojteknowak/Library/Arduino15/packages/esp8266/tools/python3/3.7.2-post1/python3" -I "/Users/wojteknowak/Library/Arduino15/packages/esp8266/hardware/esp8266/3.1.2/tools/upload.py" --chip esp8266 --port "/dev/cu.usbserial-120" --baud "115200" "" --before default_reset --after hard_reset write_flash 0x0 "/private/var/folders/l7/t8lbg_612y1_t6_rzt9m_f6h0000gp/T/arduino/sketches/6EC888AB277E4E894591D3001568582D/WiFiScan.ino.bin" esptool.py v3.0 Serial port /dev/cu.usbserial-120 Connecting.... Chip is ESP8266EX Features: WiFi Crystal is 26MHz MAC: 48:3f:da:40:59:d4 Uploading stub... Running stub... Stub running... Configuring flash size... Auto-detected Flash size: 4MB Compressed 270848 bytes to 199167... Writing at 0x00000000... (7 %) Writing at 0x00004000... (15 %) Writing at 0x00008000... (23 %) Writing at 0x0000c000... (30 %) Writing at 0x00010000... (38 %) Writing at 0x00014000... (46 %) Writing at 0x00018000... (53 %) Writing at 0x0001c000... (61 %) Writing at 0x00020000... (69 %) Writing at 0x00024000... (76 %) Writing at 0x00028000... (84 %) Writing at 0x0002c000... (92 %) Writing at 0x00030000... (100 %) Wrote 270848 bytes (199167 compressed) at 0x00000000 in 19.3 seconds (effective 112.2 kbit/s)... Hash of data verified. Leaving... Hard resetting via RTS pin...

Cześć, urządzenie do monitorowania pogody to chyba najbardziej popularny i pewnie oklepany temat ale chciałem spróbować zrobić je samemu zwłaszcza, że można to zrobić na wiele sposobów. Jest to pierwsza wersja rozwojowa i już widzę, że będę musiał wprowadzić jedną poprawkę ale o tym w podsumowaniu. Projekt zakłada monitorowanie: temperatury wilgotności jasności (aby w przyszłości można było skorelować ją z temperaturą) poziomu naładowania akumulatora Całość chciałem oprzeć na jednym mikrokontrolerze zapewniającym odczyt danych z czujników wraz z dostępem do sieci, który dodatkowo mógłby być zasilany z akumulatora. Nie chciałem też projektować dedykowanego PCB ani używać gotowego układu w postaci Arduino Uno, bo to dość duża płytka no i nie jest tania. Mój wybór padł na układ ESP8266 (w wersji NodeMCU v3), ponieważ spełnia praktycznie wszystkie wymagania i ma większe możliwości niż gołe Arduino. Poza tym chciałem poznać i sprawdzić skryptowy język Lua dla NodeMCU, który podobno jest przeznaczony do IoT (Internet of Things). Jako czujnika temperatury i wilgotności użyłem AM2320, który ma dość duży zakres temperatur (-40°C do 80°C) oraz łatwo da się programować w Lua. Jeszcze się nie zdecydowałem w jakiej obudowie umieszczę ESP ale całość z czujnikiem wygląda tak: Zastosowane elemety: ESP8266 (w wersji NodeMCU v3) AM2320 Akumulator Li-Pol Akyga 980mAh 3,7V Ładowarka Li-Pol TP4056 pojedyncza cela 1S 3,7V microUSB z zabezpieczeniami Fotorezystor 10-20kΩ 2x BC547; 3x 10kΩ; 2x 100kΩ; 1x 220kΩ Niestety układ ESP posiada tylko jeden pin dla przetwornika ADC o oznaczeniu A0, dlatego szukałem w internecie jak można go współdzielić do pomiaru jasności fotorezystora i poziomu akumulatora. Jednak jedyne co znalazłem to sposoby na odczyt z różnych czujników (fotorezystor, termistor, itp) za pomocą wystawiania logicznej jedynki na porcie D (wystawione "1" daje zasilanie na czujnik, a "0" nie) podpiętej do danego czujnika. Musiałem więc wymyślić własne rozwiązanie, które nie jest idealne ale działa: Jedynka wystawiona na pin D5 pozwala na odczyt wartości napięcia z fotorezystora, a zero podaje napięcie z akumulatora. Zworka JP1 pozwala na odłączenie akumulatora od zasilania ESP co jest przydatne podczas programowania, wówczas ESP zasilany jest z portu USB. Czujniki umieściłem w obudowie i przykleiłem do ramy okiennej: Program umieszczony w ESP odczytuje wartości z czujników co minutę i udostępnia w postaci strony internetowej Podsumowanie: Ze względu na to, że na płytce NodeMCU użyty jest stabilizator 3,3V pozwalający podawać mu napięcie niewiele większe niż na wyjściu to założyłem, że zasilanie bezpośrednio z akumulatora wystarczy tak długo aż napięcie akumulatora zbliży się do 3,3V. Nie spowoduje to całkowitego rozładowania, więc jest bezpieczne a układ się sam wyłączy. Mimo, że układ sprawuje się dobrze to jednak zauważyłem, że czasami działa niestabilnie i po bliższym przyjrzeniu się schematowi płytki NodeMCU zauważyłem podłączoną diodę pomiędzy VIN a zasilaniem ESP, która powoduje spadek napięcia o 0,7V. Prawdopodobnie ma ona zabezpieczać przed zamianą biegunów zasilania ale dodatkowo wprowadza spadek napięcia, który w przypadku zasilania z portu USB nie ma znaczenia. W kolejnej wersji dodam przetwornicę 5V i zobaczę jak wtedy będzie działać. Jeżeli ktoś z kolegów lub koleżanek znalazł sposób jak lepiej rozwiązać pomiar napięcia z czujnika i akumulatora przy pomocy pinu A0 bez użycia dodatkowego przetwornika ADC, to chętnie poczytam. Docelowo chciałbym przechowywać pomiary na malince i mieć podgląd danych historycznych ale jeszcze nie znalazłem odpowiedniego oprogramowania, bo albo jest zbyt złożone w konfiguracji i ciężkie dla maliny albo zbyt proste. Oprogramowanie ESPHome użyte w projekcie "Zabezpieczenie akumulatora 3,7V Li-Pol - hardware & software" wygląda ciekawie, więc może się nada, zobaczymy. sp_code.zip

W zeszłym tygodniu zabrałem się za kolejny ciekawy projekt, miernik poziomu jakości powietrza z pomiarem podstawowych parametrów pogodowych. Nie będę się rozpisywał na temat projektu gdyż jest on doskonale opisany przez autora na stronie: https://github.com/hackerspace-silesia/Smogomierz, ja osobiście korzystałem z tej instrukcji. Części: WiFi ESP8266 NodeMCU v3 czujnik cząstek stałych PM 1, 2.5 i 10 - PMS7003 adapter do czujnika PMS czujnik temperatury, wilgotności i ciśnienia BME280 Złożenie całości zajmuje nie więcej niż 15 minut. W kolejnym kroku ładujemy kod (zgodnie z instrukcją) ja skorzystałem z gotowej paczki Smogly. System po skonfigurowaniu przez panel WWW jest gotowy do współpracy z popularnymi serwisami monitorującymi typu AirMonitor, aui.eco, Luftdaten.info czy thingspeak (z którego w moim przypadku korzystam jako pośrednika danych w celu ich wysyłki do 'Ramki cyfrowej - centrum informacji' - opisywanej w innym wątku. Po zamontowaniu całości w obudowie, zapewnieniu przepływu powietrza, całość działa bez zarzutu (aktualnie w trakcie testowania). W celu codziennego monitorowania parametrów najbardziej sprawdzi się wg mnie serwis aqi.eco, z którym smogly działa bez problemów. Serwis aqi.eco automatycznie generuje dedykowaną stronę dla każdego czujnika na której można sprawdzić bieżące odczyty oraz historię długoterminową na wykresach. W serwisie jest też dostępna mapa czujników w Polsce i Europie. Po testach podzielę się z Państwem wrażeniami i opinią.

Dzisiaj znów coś software-only: biblioteczka do prostej komunikacji UDP, taka po prostu konsola udp. Działa na obu ESP. Na pececie do komunikacji można użyć netcata (Linux, cygwin, pewnie Mac też), załączonego programu ardumon.py (Linux), i prawdopodobnie Ncat (Windows, nie mam jak sprawdzić). Biblioteczka jeszcze nie skończona, ale obiecałem koledze @SOYER że wrzucę 🙂 Można zacząć testować ESPUdpConsole.zip - feedback mile widziany.

Witam, Próbuję od jakiegoś tygodnie zflashować ESP8266ex które jest częścią płytki Arduino 2560+ESP 8266, wszystko łączy się z PC za pomocą UART >>> USB kontrolowany zworkami na płytce. Problem polega na tym że, nie mogę wgrać niczego innego na tę ESP niż ESP-easy. A zależy mi, żeby ESP na tej płytce pełniło funkcję serwera www podłączonego do sieci do którego za pomocą UART 3 (Połączenie Atmega2560 >>> ESP8266) będę przesyłał informacje z czujników. Ma ktoś może sprawdzony firmware lub instrukcję do tego jak to skonfigurować? Próbowałem wgrywać aktualny firmware AT od Esperriffa, ale nadal Monitor szeregowy wyświetla mi tylko krzaki i nie odpowiada na żadne komendy AT.

Cześć na esp8266 wrzuciłem ESP8266_Smogomierz_2.8.1_PMS_build_27.11.2021.bin, lecz po flashu płytka nie wstaje, brakuje wifi 😕 Niestety nie pojawia się oczekiwana sieć wifi ;/ Podpowie ktoś co może być nie tak? Flashuję tak: esptool.py -p /dev/ttyUSB0 --before default_reset --after hard_reset --chip esp8266 write_flash --flash_size=detect 0x1000 ESP8266_Smogomierz_2.8.1_PMS_build_27.11.2021.bin esptool.py v4.5.1 Serial port /dev/ttyUSB0 Connecting.... Chip is ESP8266EX Features: WiFi Crystal is 26MHz MAC: 30:83:98:85:a4:4e Uploading stub... Running stub... Stub running... Configuring flash size... Auto-detected Flash size: 4MB Flash will be erased from 0x00001000 to 0x000aafff... Compressed 695568 bytes to 461673... Wrote 695568 bytes (461673 compressed) at 0x00001000 in 40.7 seconds (effective 136.7 kbit/s)... Hash of data verified. Leaving... Hard resetting via RTS pin...

Swego czasu postanowiłem - dla oszczędności kasy i miejsca w obudowie - przerzucić się na proste moduły (typu ESP32-WROOM lub ESP12E). Na pierwszej doświadczalnej płytce miałem wszystkie elementy potrzebne do podłączenia konwertera USB-UART, ale w docelowych urządzeniach (np. czytak) absolutnie nie były one potrzebne. Postanowiłem stworzyć sobie taki własny pseudo-standard gniazda programowania i zrobić przejściówkę do popularnego konwertera HW-417. Nie będę się za dużo rozpisywał, napiszę tylko kilka rzeczy: Schemat całości to po prostu fragment ESP32 Dev Kit. Układ sprawdzony, działa zarówno z ESP32 (WROOM, WROVER) jak i ESP8266 (ESP-12E). Nie próbowałem robić żadnej specjalnej płytki, użyłem kawałka płytki uniwersalnej i części wyciągniętych z szuflady. Gniazdo programowania ma dodatkowy pin 3.3V. W tej chwili nie jest nigdzie podłączony, ale w planach mam przeróbkę płytki tak, aby można było podłączyć się albo do +5V z USB, albo do zewnętrznego zasilacza. Na zdjęciu widać, że wtyczka programatora jest ośmio- a nie sześciopinowa. Po prostu czytak ma dwa dodatkowe piny przeznaczone do podłączenia +5V do ładowania akumulatora (i bardzo się cieszę że to przewidziałem, bo z modułu ładowarki odpadło mi gniazdo USB). A ośmio[inowa żeńska wtyczka pasuje do sześciopinowego gniazda. Gniazdo do podłączenia ma 7 pinów, mimo iż sam konwerter ma sześć. Siódmy pin służy do podłączenia sygnału RTS. Niestety - wersja esptool-ftdi umożliwiająca wykorzystanie pinów DTR/CTS zamiast DTR/RTS nie jest rozwijana, a jakoś nie bardzo miałem czas żeby sprawdzić czy da się jakoś połączyć kod aktualnej wersji (CTS/RTS) z taką trochę zapomnianą gałęzią 😞 Zdjęcie kiedyś pokazywałem, ale dla przypomnienia jeszcze raz (na zdjęciu widać przewód łączący dolutowany do HW-417 pin RTS z przejściówka). Przejściówka sprawdza się zarówno przy programowaniu ESP32, jak i ESP8266. Ponieważ przewidziana jest do współpracy z esptool - powinna działać z Arduino IDE, PlatformIO jak i różnymi wynalazkami (jak mój "pyrduino"). Przyciski RESET i BOOT są tak na wszelki wypadek - esptool i tak steruje sygnałami RTS i DTR potrzebnymi do zresetowania płytki i/lub przejścia w stan uploadu.

Potrzebowałem zrobić kilka urządzeń IOT na ESP - 01 ponieważ nie miałem pod ręką żadnego tak zwanego "dongla" usb, musiałem coś wykombinować aby praca szła nieco sprawniej. Ponieważ druciarstwo i prowizorki są dobre tylko w przysłowiach, powstało to mini urządzenie. W samym schemacie jak i budowie niema nic nowego ani odkrywczego, nawet się zastanawiałem czy pokazywać to "cudo" tutaj, ale że faktycznie ułatwia mi pracę to niech już będzie, a może ktoś skorzysta. Zatem schemat to typowe podłączenie esp z trybem automatycznego wgrywania firmware, za pomocą zworek J1 i J2 można przełączyć piny UARTa na złącze J3. Na złączu J3 wyprowadziłem wszystkie dostępne GPIO z ESP01. Ja często robię tak że tylko pierwszą wersję oprogramowania wgrywam z UART później przeważnie używam FOTA UDP bo szybciej działa. Co do samego konwertera USB - UART wybrałem ten firmy msx ponieważ działa niezawodnie i pozwala osiągnąć wysokie transfery podczas flashowania do 3Mb/s. Schematic_espProg_2023-01-12.pdf Na koniec kilka zdjęć poglądowych. Do wszystkiego wydrukowałem niewielką obudowę, zastanawiałem się czy nie dorobić zaczepów do płytki stykowej jednak ostatecznie zrezygnowałem z tego pomysłu bo to jest tak małe że nie przeszkadza w normalnym użytkowaniu. Oczywiście nie od razu wszystko musiało zadziałać więc musiałem zrobić krosa TX/RX A tutaj prowizorka w pełnej krasie 🙂 Tu paczka plików jakby ktoś chciał sobie odtworzyć projekcik. Moduł nie zawiera elementów SMD - muszę gdzieś wyrobić stare zapasy - co myślę, jest pewnym ułatwieniem. Na PCB jest kilka zworek które są zaznaczone jako ścieżki na górnej warstwie. stl_f3d.zip espProg.zip

Witam. Wykorzystałem Platformio do wgrania plików przez Spiffs do esp8266. Pytanie jak zmienić wielkość pamięci np. z 1MB na 2 MB ?

Witam, w internecie zakupiłam zaskakująco tanio płytkę ESP8266 Wemos NodeMCU V3 z linka: https://shopee.pl/Moduł-NodeMCU-V3-Lua-WIFI-zintegrowany-ESP8266-dodatkowa-pamięć-32M-Flash-USB-CH340G-i.597261045.15003633781 . Zachęcona pozytywnymi opiniami zakupiłam płytki, wcześniej kupowałam z tego sklepu czujniki do Arduino i działały bez problemu. Niestety podłączając płytkę (a kupiłam ich 5) żadnej nie wykrywa komputer (ani Win8 ani Win11), przyciskając przycisk reset płytka się świeci, czujniki do niej podłączone świecą, więc zasilanie dociera. Kombinowałam z sterownikami, próbą instalacji flasha, zmianą prędkości portów na komputerach, różne porty USB, niestety nic nie pomaga. Komputery nie wykrywają urządzenia i dalej nie wiem jak to ruszyć. Jeśli złamałam jakiś regulamin przepraszam, jest to mój pierwszy post, szukałam podobnych tematów, ale nigdzie nie mogę znaleźć. Z góry dziękuję za odpowiedź i ciepło pozdrawiam 🙂

Witam, mam problem nagłej potrzeby. Prostu układ: esp8266 nodemcu v3 podłączony pod zasilacz impulsowy 12V przekaźnik 8 kanałowy z optoizolacją zasilany na 5V Z Zasilania 12V idzie też prąd na stabilizator 5V - ten zasila tylko i wyłącznie wejście Vcc płytki przekaźnika. problem jest taki, że przekaźnik normalnie działa w przypadku gdy styk IN1 załącze z arduino leonardo. Wszystko jest idealnie z arduino. Natomiast gdy spróbuję to samo zrobić z esp zamiast arduino, to na przekaźniku zapala się tylko LED że 1 styk został załączony, jednak nie słychać nawet charakterystycznego "trzasku" przełączania styku a sam kanał nie działa i nic się nie dzieje oprócz led sygnalizującego załączenie styku. Problem palący czasowo, ktos wie czemu arduino normalnie załącza styk na przekaźniku a esp już nie? I jak to rozwiązać?

Przeglądając listę możliwych integracji Home Assistant w większości jest tam to czego potrzebujemy. Sam byłem w szoku, gdy aplikacja podpowiedziała mi integrację z tunerem audio, o którym bym nawet nie pomyślał że się do tego nadaje. Problem pojawia się, gdy wymyślimy sobie własne DIY, które robi coś unikatowego i chcemy to podłączyć pod automatykę domowa. Jedną z metod jest użycie Template Switch (czyli takiego wirtualnego przełącznika) i powiązanie go funkcją lambda z np. komponentem magistrali UART i komunikowanie się z naszym DIY. Problem w tym, że będziemy musieli poświęcić cały układ WiFi na pomost pomiędzy DIY, a centralką HA. W tym artykule postaram się nakreślić, jak zacząć pisać własne komponenty do ESPHome. Przygotowanie Niby jest do tego instrukcja (custom sensor i custom generic component), ale mimo wszystko po przeczytaniu tego co tam zamieszczono, przejrzeniu przykładów, zapytaniu na oficjalnym kanale na Discordzie, odpowiedź znalazłem dopiero na szarym końcu internetu. Wyjdźmy od tego jak tworzymy aplikacje (wsad np. do ESP8266 tu ESP-01S). Mając postawiony HA i zainstalowany dodatek ESPHome, dodajemy nowy sprzęt: Wybieramy nazwę: Rodzaj płytki: Pomijamy wgrywanie, bo trzeba zmienić coś w konfiguracji. Wybieramy więc edit: Mamy tu kilka domyślnych ustawień: esphome: name: spectrum-display esp8266: board: esp01_1m # Enable logging logger: # Enable Home Assistant API api: ota: password: "xxx" wifi: ssid: !secret wifi_ssid password: !secret wifi_password # Enable fallback hotspot (captive portal) in case wifi connection fails ap: ssid: "xxx" password: "xxx" captive_portal: Nazwa - potrzebna do mDNS jako hostname. Niestety po aktualizacji coś słabo działa. Na stronie ESPHome sugeruje się używanie statycznego IP, które ma też przyspieszać łączenie: Dlatego dodajemy fragment dotyczący stałego IP: wifi: ssid: !secret wifi_ssid password: !secret wifi_password manual_ip: static_ip: 192.168.0.102 gateway: 192.168.0.1 subnet: 255.255.255.0 # Enable fallback hotspot (captive portal) in case wifi connection fails ap: ssid: "xxx" password: "xxx" Co w efekcie zobaczymy w logu: Hasło do WiFi mamy ustawione w ESPHome (secrets). Zapisujemy, wgrywamy podłączając urządzenie przez USB lub wgrywając używając OTA, oczywiście jeżeli znamy hasło i adres urządzenia. W moim przypadku jest ta druga opcja: Gotowe komponenty Komponent to pewna funkcjonalność (nawet bardzo rozbudowana). Np. może to być przełącznik światła dołączonego do konkretnego wyprowadzenia (patrz przykład). W przypadku bardziej rozbudowanych komponentów, np. obsłudze protokołu komunikacji, obsługa zawęża się do wskazania urządzenia (np. DS18B20 1-wire) i podania wyprowadzenia. Takich komponentów możemy dodawać wiele i będą działać niezależnie od siebie. To tak jakbyśmy uruchomili wiele współbieżnych procesów. W praktyce wygląda to bardziej jak kod Arduino, w którym przy pomocy funkcji millis() wykonujemy "współbieżnie" wiele funkcji. Podstawy za nami. Teraz konfigurację można wzbogacić o jakieś podstawowe komponenty. Przykładowo kod do sterowania diodą na płytce pod pinem 2: # Enable Home Assistant API api: light: - platform: binary name: "Onboard LED" output: onboard_led_out output: - id: onboard_led_out platform: gpio pin: GPIO2 Id posłuży nam do dodania tzw. encji czyli kontrolki na panelu widocznym w Home Assistant. Wgrywamy i przechodzimy do głównej strony i edytujemy widok panelu: Od razu widzimy encję: Modyfikujemy wedle uznania: i gotowe! Możemy poklikać w nowo dodany przycisk. Najpewniej logika przycisku będzie odwrócona ze względu na sposób podłączenia LED na płytce ESP-01S. Możemy zmienić to w konfiguracji: output: - id: onboard_led_out platform: gpio pin: GPIO2 inverted: true I działa 🙂 Własny komponent Napisanie własnego komponentu nie jest aż tak trudne. Autorzy uznali, że będą wzorować się na koncepcji kodu Arduino , w którym można wyróżnić bloki setup() i loop(). Problem w tym, że nie wiadomo gdzie zapisać te pliki. Na stronie z poradnikiem tworzenia własnych komponentów jest co prawda informacja: Ale niewiele to wnosi, bo nigdzie nie jest napisane gdzie jest ten katalog... Z pomocą przychodzi test przykładowej konfiguracji, w której chcę dodać jakiś plik: Czyli jest to ścieżka: /config/esphome/ Sprawdźmy jak wygląda zawartość tego katalogu, tylko zanim do teog przejdziemy, potrzeba nam SSH - bo w systemie HA nie ma domyślnie takich udogodnień. W repozytorium znajdujemy SSH, ustawiamy hasło i możemy się zalogować. Użytkownik root, hasło własne, port 22. Używam polecenie ls z dopiskiem -a, aby wyświetlić ukryte pliki i katalogi: la -a /config/esphome/ W tym miejscu można umieścić własne pliki bibliotek - tuż obok widzimy plik yaml konfiguracji. Ja swoje pliki umieszczam w katalogu custom_components tak by nie tworzyć bałaganu: Wewnątrz katalogu tworzę plik fps_meter.h: touch fps_meter.h Do pracy korzystam z WinSCP i VSC - zapis pliku w VSC od razu zdalnie go aktualizuje: Dla testu wpisuję kod służący do wyznaczania częstotliwości odświeżeni: #include "esphome.h" class FPSCounter : public Component, public Sensor { private: const unsigned long INTERVAL = 5000; unsigned long counter; unsigned long last_millis; float fps; public: float get_setup_priority() const override { return esphome::setup_priority::LATE; } void setup() override { last_millis = millis(); int last_button_state = HIGH; } void loop() override { if(millis() - last_millis > INTERVAL) { fps = (1000.0 * counter) / (millis() - last_millis); ESP_LOGD("FPS_COUNTER", "%lu sec passed, FPS: %f", INTERVAL, fps); publish_state(fps); counter = 0; last_millis = millis(); } ++counter; } }; I zapisuję. Do tego jak działa ten kod jeszcze wrócimy, ale na razie istotne jest, że w pętli wykonywane jest sprawdzenie częstości odświeżania i okresowo informacja wysyła jest do HA. Komponent jest czujnikiem (dziedziczy po klasie Sensor) ponieważ zwraca pewne informacje do centralki. Teraz trzeba użyć naszą klasę. Przechodzimy do konfiguracji i najpierw dodajemy plik biblioteki: esphome: name: spectrum-display includes: - custom_components/fps_meter.h oraz tworzymy komponent: api: sensor: - platform: custom lambda: |- auto fps_meter = new FPSCounter(); App.register_component(fps_meter); return {fps_meter}; sensors: name: "FPS counter" light: - platform: binary name: "Onboard LED" output: onboard_led_out output: - id: onboard_led_out platform: gpio pin: GPIO2 inverted: true Dodajemy typ sensor (to po czym dziedziczy nasz komponent), a w funkcji lambda korzystamy ze zdefiniowanej klasy FPSCounter. Dodajemy też nazwę, która może nam się przydać. Wgrywamy nowy kod i w logu zobaczymy, że coś zostało wyznaczone - mamy częstotliwość odświeżania około 60Hz: Możemy też znaleźć nasz "czujnik" wśród encji: i nasze obie kontrolki działają, powiedzmy "równolegle" 🙂 Kod programu Wracając na chwilę do kodu programu: #include "esphome.h" class FPSCounter : public Component, public Sensor { public: float get_setup_priority() const override { return esphome::setup_priority::LATE; } void setup() override { } void loop() override { }; widzimy, że szablon jest dość prosty. Tworzymy klasę, która dziedziczy po komponencie i sensorze, aby móc wysyłać informacje (dostępna staje się wtedy metoda publish_state(). Jak wspomniałem setup i loop to metody, które możemy uzupełnić kodem wykonywanym odpowiednio przy starcie i cyklicznie. get_setup_priority() służy ustaleniu jaki priorytet ma nasza klasa. Możliwych narzędzi jest naprawdę wiele, zainteresowanych odsyłam do lektury dokumentacji i analizy przykładów. Kod klasy możemy rozbić na osobne pliki .cpp i .h. Warto jeszcze wspomnieć o czymś, co mnie bardzo mocno zmyliło - o bibliotekach/narzędziach deweloperskich ESPHome. W kodzie widzimy, że dodajemy plik esphome.h, ale nie jest to biblioteka: W pliku tym mamy podlinkowane biblioteki, które będziemy używać, a sam plik wygenerowany zostanie automatycznie... zostanie, ponieważ nasza biblioteka jest w katalogu /config/esphome, ale przed kompilacją jest kopiowana do katalogu projektu: Czyli dla powtórzenia: nasze pliki bibliotek trzymamy w głównym katalogu np. /config/esphome/custom_components/ w pliku .yaml dodajemy ścieżkę: custom_components/plik_biblioteki.h w kodzie pliku plik_biblioteki.h dodajemy esphome.h jakby był tuż obok, bo przed kompilacją zostanie tam przekopiowany tworząc kod pamietamy żeby podlinkować zawartość katalogu src Kuszące może być edytowanie zawartości katalogu src jednak tu uwaga w pliku README.txt: THIS DIRECTORY IS AUTO-GENERATED, DO NOT MODIFY ESPHome automatically populates the build directory, and any changes to this directory will be removed the next time esphome is run. For modifying esphome's core files, please use a development esphome install, the custom_components folder or the external_components feature. Oznacza to, że ten katalog jest wygenerowany automatycznie na bazie pliku .yaml i nie powinniśmy w nim nic mieszać.

Dzisiaj kolej na automatykę domową. Od razu na wstępie: nie cierpię określenia "inteligentny dom". Po pierwsze w większości jest ono nadużywane (co to za "inteligencja", która sprowadza się do możliwości zapalenia światła w łazience przez telefon), po drugie mój dom nie ma być inteligentny: ma być przede wszystkim wygodny. Nie wiem jak dla was - ale dla mnie ważniejsze jest zdublowanie wyłącznika oświetlenia przy moim ulubionym fotelu gdzie zwykłem popijać kawusię i oglądać telewizję, niż kombinowanie z pilotami (które zawsze leżą poza zasięgiem ręki) czy smartfonami (gdzie trzeba włączyć aplikację i wybrać odpowiednią funkcję przedzierając się przez jakieś menu). Podobny system już miałem, ale był on jakoś mało rozbudowywalny, poza tym sterowanie nie było zbyt wygodne. Postanowiłem więc zrobić nowy od zera. Cały system składa się z następujących komponentów: Centralka - czyli moduł główny, z klawiaturą, wyświetlaczem, głośnikiem i innymi bajerami, sterująca bezpośrednio kotłem; Wyłączniki oświetlenia - każdy steruje jednym lub dwoma punktami, wyposażone w różnej maści wyłączniki, czujki i takie tam; Kontroler termometrów - najprostszy ze wszystkich modułów, jego zadaniem jest wyłącznie odczyt temperatury z trzech DS18B20 i przesyłanie wyników do centralki. Najpierw może o centralce. Centralka składa się z dwóch głównych układów: Raspberry Pi Zero 2 W jako główny "mózg" urządzenia i ESP-12E do komunikacji ze światem zewnętrznym (poprzez esp-now z pozostałymi modułami oraz poprzez panel sterujący z użytkownikiem). Ponieważ mój kocioł pozwala jedynie na sterowanie typu "włącz/wyłącz", elektrycznie sprawa jest stosunkowo prosta. Do sterowania służą dwa przekaźniki. Pozostawiłem stary sterownik Euroster 2000, ale w czasie pracy jest on odłączony. Do sterowania służą dwa przekaźniki: jeden odpowiada za odłączenie Eurostera gdy centralka jest gotowa do pracy - tzn. RPi się ładnie zabootował, wie która jest godzina, odczytał dane z pamięci EEPROM i FRAM i ma informacje z przynajmniej jednego termometru. Drugi to właściwy przekaźnik sterujący piecem. Układ wygląda mniej więcej tak: Jak widać, aby centralka mogła sterować kotłem, na pinie READY musi pojawić się jedynka. Rezystor 10k zapewnia, że tranzystor będzie zatkany również w przypadku, gdy pin będzie w stanie wysokiej impedancji lub RPi w ogóle nie będzie zasilany. Diody sygnalizują stan przekaźników: READY (zielona) to gotowość do pracy, FAIL (czerwona) to sygnalizacja przełączenia na Euroster, FIRE (niebieska) zapala się przy włączeniu kotła. Oprócz tego do RPi podłączone są: Konwerter I2S ze wzmacniaczem i głośnikiem Moduł zegara DS3231 z pamięcią EEPROM 4 kB Moduł FRAM 32 kB ESP8266 wraz z układem RESET/BOOT Natomiast ESP oprócz komunikacji z pozostałymi modułami obsługuje: wyświetlacz klawiaturę czujnik odległości czujnik temperatury i ciśnienia fotorezystor (jeszcze nie wiem po co, ale miałem wolne wejście analogowe) ESP8266 jest podłączony tak, żeby umożliwić zarówno współpracę układu z malinką, jak i zdalne programowanie: Ponieważ do programowania ESP8266 używam frameworku Arduino, teoretycznie można zainstalować Arduino IDE na malince (tak też zrobiłem na początku). Uznałem jednak, że nie jesto to zbyt wygodne. Dlatego też kompiluję program na lokalnym pececie z linuksem na pokładzie, a do malinki przesyłam tylko gotowy plik bin. I tu mała uwaga: nie podaję pełnego rozwiązania choćby z tego względu, że w rzeczywistości skrypty są bardziej skomplikowane, ale jest to związane ze specyfiją jinjretnego urządzenia i jego możliwości. Ale zasada działania jest mniej więcej taka, jak niżej. Do przesłania skompilowanego pliku używam swojego wrappera. Zewnętrzne polecenie to: ssh centralka.local /usr/local/bin/esprmt a na wejście podaję plik BIN. Oczywiście połączenie ssh musi być skonfigurowane tak, aby nie trzeba było wpisywać hasła (czyli za pomocą kluczy). Na samej malince jest to już bardziej skomplikowane. Najpierw trzeba było napisać kawałek programu, który zresetuje ESP i wprowadzi w tryb programowania. W tym celu stworzyłem plik /etc/default/esp zawierający opisy pinów: boot=24 prog=23 Program w pythonie wygląda tak: #!/usr/bin/env python #coding: utf-8 cfg={} for line in open('/etc/default/esp'): line=line.strip().split('=') if len(line) == 2: cfg[line[0].strip()] = line[1].strip() bootp=int(cfg['boot']) progp=int(cfg['prog']) import sys arg = sys.argv[1] if arg not in ('boot','prog'): raise Exception('Bad arg') import RPi.GPIO as GPIO, time GPIO.setmode(GPIO.BCM) GPIO.setwarnings(False) GPIO.setup(bootp, GPIO.OUT) GPIO.setup(progp, GPIO.OUT) if arg == 'boot': GPIO.output(progp, 0) GPIO.output(bootp, 1) time.sleep(0.1) GPIO.output(bootp, 0) else: GPIO.output(bootp, 1) time.sleep(0.1) GPIO.output(progp, 1) time.sleep(0.1) GPIO.output(bootp, 0) time.sleep(0.1) GPIO.output(progp, 0) time.sleep(0.1) Po zapisaniu do /usr/local/bin/espy i nadaniu praw do uruchomienia mogę wykonać reset ESP poleceniem: espy boot lub wprowadzić w tryb programowania: espy prog Teraz tylko wystarczy wrzucić program do ESP. Do tego służy skrypt /usr/local/bin/esprmt: #!/bin/bash cat >/tmp/upload.bin /usr/local/bin/espy prog /home/pi/.arduino15/packages/esp8266/tools/python3/3.7.2-post1/python3 -I \ /home/pi/.arduino15/packages/esp8266/hardware/esp8266/3.0.2/tools/upload.py \ --chip esp8266 --port /dev/ttyS0 --baud 230400 \ --before no_reset_no_sync --after soft_reset \ write_flash 0x0 /tmp/upload.bin No i trochę o możliwościach. Ponieważ prekursorem urządzenia był po prostu regulator temperatury (na RPI 1B), i tu kontrola temperatura pozostała głównym zadaniem. Piec może pracować w następujących cyklach: zwykły dzień (rano i wieczorem cieplej, w nocy i w typowych godzinach wyjścia temperatura spada, poza tym w dzień utrzymane 18°). Ze względu na specyfikę naszej pracy na każdy dzień tygodnia mogę ustalić oddzielny program. dzień świąteczny. Jest taki sam jak program "niedziela", w stosunku do zwykłego dnia przesunięta jest godzina poranna (trochę później się wstaje) i nie ma godzin wyjścia. jestem w domu - jak zwykły dzień, ale bez godzin wyjścia wychodzę od-do (godziny wyjścia ustalane indywidualnie) wyjazd (utrzymana stała temperatura nie mniej niż 13°) program indywidualny (tu mogę zaprogramować dokładnie kiedy chcę mieć jaką temperaturę). Cykl pieca na bieżący dzień mogę sobie ustawić z klawiatury wybierając po prostu właściwą pozycję z menu: Oczywiście mogę sobie ustawić dowolne cykle na przyszłość - do tego służy kalendarz. Wszystkie święta (stałe i ruchome) są uwzględniane automatycznie, jak na zdjęciu poniżej: Ważną funkcją jest również możliwość chwilowego włączenia/wyłączenia pieca. W tym trybie mogę ustawić na stałe stan zapalony/zgaszony. Po upływie 5 minut, jeśli nie wcisnąłem żadnego klawisza, urządzenie powraca do trybu automatycznego. Algorytm ustalania temperatury jest stosunkowo prosty, ale wymagał wprowadzenia empirycznych danych, uzyskanych na podstawie obserwacji z poprzedniego sezonu grzewczego. Po prostu: Jeśli temperatura jest niższa niż zadana minus histereza piec jest włączony (rozpoczynamy grzanie) Jeśli piec pracuje a temperatura nie przekracza wartości zadanej plus histereza, piec jest włączony (kontynuujemy grzanie) Jeśli z obliczeń wypada, że trzeba rozpocząć grzanie aby o określonej porze osiągnąć odpowiednią temperaturę piec jest włączony (rozpoczynamy grzanie). W przeciwnym razie piec jest wyłączony. Dochodzą tu dodatkowe czynniki - np. temperatura na zewnątrz wpływająca na czas konieczny do ogrzania mieszkania. Również mimo, iż program uruchamiany jest z crona co minutę, jeśli od ostatniego przełączenia pieca minęło mniej niż pięć minut piec nie będzie przełączany. Wszystkie parametry niedostępne z klawiatury mogę sobie ustawić przeglądarką w sieci domowej. Przykładowo ustawianie programu grzania na konkretny dzień wygląda tak: Oprócz kontroli temperatury centralka ma jeszcze kilka przydatnych funkcji. Wbudowany syntezator mowy (kedrigern) może oznajmić godzinę, temperaturę na zewnątrz czy wygłosić prognozę pogody na dwa dni. Czujnik odległości odpowiada za włączenie wyświetlacza tylko wtedy, gdy ktoś stoi przed centralką. Ponieważ część punktów oświetleniowych w mieszkaniu wyposażona jest w moduły ESP8266, może również zapalać/gasić światło (np. automatycznie zapalić lampkę w sypialni o właściwej porze). Zastosowałem tu czujnik ToF - może się to wydawać przesadą, ale cała centralka wisi w przejściu, i żaden czujnik odbiciowy nie zapewnił mi prawidłowego wykrycia (tzn. nie reagowania na ścianę naprzeciw przy jednoczesnym wykryciu czegoś w pewnej minimalnej odległości). Ale trochę więcej o tych modułach. Taki najprostszy moduł to sterowanie oświetleniem w tzw. "saloniku". Mam tu dwie linie oświetlenia górnego i boczny kinkiet. Z przyczyn technicznych moduły są dwa: jeden po stronie wersalki z przekaźnikiem sterującym kinkietem, drugi w miejscu oryginalnego wyłącznika oświetlenia. Ponieważ moduły komunikują się ze sobą (bez pośrednictwa centralki), każdy z nich może sterować dowolną z trzech linii. Każdy moduł posiada zasilacz, jeden lub dwa przekaźniki (użyłem tu subminiaturowych z dopuszczalnym prądem obciążenia 0.5A, mam nadzieję że przy mocy LED max. 14 W/linię i połączonych równolegle stykach to wystarczy) sterowanych przez BC-817 (takie miałem w szufladzie) oraz oczywiście ESP8266. Użyłem tu "gołych" ESP-12E. Trochę problemów miałem z wyłącznikami. Ponieważ są to przyciski chwilowe - aż chciałoby się użyć przycisków sterujących do rolet. Niestety - nigdzie nie znalazłem takich które mi odpowiadają (na trzy rolety) więc zrobiłem je sam ze zwykłych tact-switchy. Chyba nawet lepiej wyszło: wyłącznik ma grubość ok. centymetra - czyli mniej więcej tyle, ile wystaje ze ściany zwykły wyłącznik podtynkowy. A oto efekt: Jak widać, do wyłącznika doprowadzone są tylko dwa przewody - jest to po prostu typowa klawiatura rezystancyjna. Odpowiednio dobierając rezystory mógłbym teoretycznie osiągnąć niezależny odczyt wszystkich trzech kanałów, ale musiałbym za dużo kombinować. Pominąłem więc niektóre kombinacje (np. wciśnięcie wszystkich trzech) i udało mi się zrobić to na zwykłych rezystorkach (tych z szuflady). Wyłącznik ma następujące funkcje: pojedyncze wciśnięcie klawisza - zapalenie (na górze) lub zgaszenie (na dole) linii; jeśli zapalane jest oświetlenie sufitowe, automatycznie gaszony jest kinkiet na ścianie; podwójne wciśnięcie klawisza na górze - zapalenie linii i wygaszenie pozostałych; podwójne wciśnięcie dowolnego klawisza na dole - zgaszenie wszystkich linii; dłuższe wciśnięcie niebieskiego klawisza na górze - przełączenie lampki stojącej w sypialni (syntezator anonsuje stan zapalona/zgaszona); dłuższe wciśnięcie dowolnego klawisza na dole - zaanonsowanie godziny i temperatury na zewnątrz przez syntezator; dłuższe wciśnięcie lewego i prawego klawisza na dole - odczytanie pogody (przed godziną 16:00 na dziś i jutro, po 16:00 na jutro i pojutrze). Moduł oświetlenia przedpokoju ma trochę inne funkcje. Przede wszystkim wyposażony jest w czujkę PIR, automatycznie zapalając światło kiedy ktoś się w przedpokoju pojawia. Za pomocą wyłącznika można również ręcznie zapalić czy zgasić światło (przydaje się, bo czujka nie widzi całego pomieszczenia, niestety nie mogłem się pozbyć martwej strefy przy szafie) lub nawet całkowicie wyłaczyć czujkę. Sama obudowa do czujki jest chyba jedynym "uniwersalnym" rozwiązaniem, tak więc przy okazji zamieszczam pliki STL i SCAD: czujka.zip. I to chyba by było na tyle - nie chcę się rozpisywać, bo o tym można książkę napisać. W razie jakichś pytań jestem do dyspozycji.

Cześć, dziś pokażę Wam, w jaki sposób złożyć do kupy moduł ESP8266 (w tym wypadku płytkę WeMos D1 mini) oraz matrycę LED na sterowniku MAX7219. Oprócz tego będziemy potrzebować paru przewodów połączeniowych, lutownicy z cyną, obudowy do zegarka oraz przewód microUSB do zasilenia naszego układu. Całość projektu jest dostępna w repozytorium na moim Githubie. Obudowa Jako obudowę użyłem sklejki o grubości 6 milimetrów, którą zamówiłem na aukcji Allegro razem z docięciem. Całość obudowy z dostawą kosztowała mnie mniej niż 40 złotych. Zaprojektowałem obudowę korzystając z programu Inkscape. Następnie została ona sklejona i pokryta lakierobejcą w kolorze jasnego dębu. Na front obudowy nakleiłem mleczną plexi o grubości 3 mm, którą dostałem w lokalnym sklepie za 5 złotych. Elektronika Tutaj będzie dużo łatwiej, gdyż wystarczy połączyć tylko odpowiednie piny. Połączyłem zgodnie z adnotacją w bibliotekach do obsługi MAX7219. Należy pamiętać, że WeMos D1 operuje na napięciu 3.3V na szczęście sterownik MAX7219 akceptuje je i nie będzie problemu aby układ ruszył. Na zdjęciu połączenie za pomocą przewodów z haczykami. Kod programu Przed kompilacją programu, należy dodać do Arduino IDE obsługę płytek opartych na ESP8266 (opisał to SOYER w tym temacie). Będziemy potrzebować trzech bibliotek, które nie są standardowo dołączone do Arduino IDE: MD_MAX72XX - dzięki której nasz procesor skomunikuje się ze sterownikiem MAX7219 MD_Parola - biblioteka rozszerzająca funkcje MD_MAX72XX NTPClient - dzięki niej zyskamy możliwość pobierania czasu z Internetu bez potrzeby używania modułu RTC. Po dodaniu bibliotek, kod wygląda następująco: #include <MD_Parola.h> #include <MD_MAX72xx.h> #include <SPI.h> #include <ESP8266WiFi.h> #include <NTPClient.h> #include <ESP8266WebServer.h> #include <WiFiUdp.h> #define HARDWARE_TYPE MD_MAX72XX::FC16_HW #define MAX_DEVICES 4 #define CLK_PIN D5 // or SCK #define DATA_PIN D7 // or MOSI #define CS_PIN D8 // or SS MD_Parola P = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES); WiFiUDP ntpUDP; const char *ssid = ""; const char *password = ""; NTPClient timeClient(ntpUDP, "0.pl.pool.ntp.org", 3600, 60000); WiFiServer server(80); uint8_t frameDelay = 25; textEffect_t scrollEffect = PA_SCROLL_LEFT; #define BUF_SIZE 512 char curMessage[BUF_SIZE]; char newMessage[BUF_SIZE]; bool time_interval = false; String data; unsigned int run_seconds = 0; String timeCheck(){ timeClient.update(); data = timeClient.getFormattedTime(); data.toCharArray(newMessage, BUF_SIZE); P.displayText(newMessage, PA_CENTER, 0, 0, PA_PRINT, PA_NO_EFFECT); return data; } String wifiCheck(){ WiFiClient client = server.available(); while(client.available()){ String req = client.readStringUntil('\r'); req = req.substring(5,req.length()-9); req.replace("%20", " "); client.flush(); String s = "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n<!DOCTYPE HTML>\r\n<html>\r\nReq: " + req + "</html>\n"; client.print(s); delay(1); client.stop(); switch(req[0]){ case 's': data = req.substring(2); P.displayScroll(curMessage, PA_LEFT, PA_SCROLL_LEFT, frameDelay); return data; break; case 'i': data = req.substring(2); P.setIntensity(data); break; } } } void setup() { P.begin(); P.displayClear(); P.displaySuspend(false); P.displayScroll(curMessage, PA_LEFT, PA_SCROLL_LEFT, frameDelay); P.setIntensity(0); curMessage[0] = newMessage[0] = '\0'; WiFi.begin(ssid, password); while ( WiFi.status() != WL_CONNECTED ) { delay ( 500 ); } timeClient.begin(); server.begin(); sprintf(curMessage, "%03d:%03d:%03d:%03d", WiFi.localIP()[0], WiFi.localIP()[1], WiFi.localIP()[2], WiFi.localIP()[3]); } void loop() { if ( (millis()/1000 - run_seconds) > 30 ){ run_seconds = millis()/1000; time_interval = true; } if (time_interval){ data = timeCheck(); time_interval = false; } data = wifiCheck(); data.toCharArray(newMessage, BUF_SIZE); if (P.displayAnimate()) { strcpy(curMessage, newMessage); P.displayReset(); } } W zależności od zakupionego modułu trzeba będzie wybrać wersję hardware sterownika MAX7219. Definiujemy ją w linijce 10: #define HARDWARE_TYPE MD_MAX72XX::FC16_HW Obecnie dostępne typy sprzętowe to: FC16_HW, PAROLA_HW, GENERIC_HW, ICSTATION_HW. Musimy tutaj dobrać wartość eksperymentalnie. Niewłaściwy typ sprzętowy powoduje błąd w kolejnosci wyświetlania oraz w kolejności animacji poszczególnych pikseli matrycy. Dodatkowa opcja (własny tekst) W kodzie dociekliwi zobaczą, że jest możliwość wyświetlenia własnego tekstu. Po uruchomieniu programu na wyświetlaczu przewinie się adres IP, który WeMos uzyskał z naszego routera. Po otworzeniu strony z poziomu przeglądarki (lub wywołaniu polecenia curl) na stronę: http://<IP>/s=<TEXT> na wyświetlaczu będzie on przewijany od prawej do lewej strony przez maksymalnie 30 sekund. Dodatkowa opcja (zmiana jasności wyświetlacza) Można również zmienić jasność wyświetlacza, albo na stałe (w kodzie linijka: 86) P.setIntensity(<liczba z zakresu 0-15>); lub poprzez stronę www pod adresem: http://<IP>/i=<LICZBA Z ZAKRESU 0-15> gdzie 0 - to wartość minimalna, a 15 odpowiada za maksymalny poziom świecenia. Zegarek prezentuje się następująco: obudowa.pdf

MOTYWACJA Jest to pierwszy projekt z wykorzystaniem ESP8266, chociaż jakiekolwiek arduino poradziłoby sobie z tym bez problemu 🙂Zamysłem projektu była obserwowanie poboru prądu w pewnym czasie na monitorze komputera. Bardzo podobną rzecz posiada Daniel Rakowiecki, dosyć dużo mu pomaga w czasie naprawy 😉 OPIS DZIAŁANIA Projekt ma za zadanie zmierzyć prąd pobierany przez urządzenie badane. Układ INA219 mierzy spadek napięcia na rezystorze bocznikującym 0,1Ω. Następnie wysyła dane po magistrali I2C do NODEMCU V3.0 a µC wysyła na wyświetlacz monochromatyczny OLED oraz po UART do komputera. Używając np. kreślarki z Arduino Ide można zaobserwować w miarę fajny wykresik 🙂 A ESP wybrałem ponieważ jest tani (około 15 zł). Maksymalny "bezpieczny" prąd to 3,2A. A schemat ideowy wygląda tak: I troszkę zdjęć: ORAZ KOD PROGRAMU W programowaniu jestem strasznym laikiem, więc proszę o wyrozumiałość 😉 Inspirowałem się kilkoma stworzeniami podobnych konstrukcji na Youtubie. #include <Wire.h> #include <Adafruit_INA219.h> #include <SPI.h> #include <Adafruit_GFX.h> #include <Adafruit_SSD1306.h> Adafruit_INA219 ina219; #define SCREEN_WIDTH 128 #define SCREEN_HEIGHT 64 #define OLED_RESET Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET); int current_mA = 0; float busvoltage = 0; float shuntvoltage = 0.0; float loadVoltage_V = 0.0; void setup(void) { ina219.begin(); Serial.begin(9600); display.begin(SSD1306_SWITCHCAPVCC, 0x3C); display.clearDisplay(); display.setTextSize(2); display.setTextColor(WHITE); display.setCursor(0,10); display.println("LOADING"); display.display(); display.setTextSize(1); display.setCursor(0,50); display.println("POWERED BY ZIMOL03"); display.setCursor(0,0); display.println("v1.1"); display.display(); delay(300); for ( int width=0 ; width<115 ; width++) { display.fillRect(0, 30, width, 15, WHITE); display.display(); delay(150); width = width + 2; width++; } } void loop(void) { shuntvoltage = ina219.getShuntVoltage_mV(); current_mA = ina219.getCurrent_mA(); busvoltage = ina219.getBusVoltage_V(); loadVoltage_V = busvoltage + (shuntvoltage / 1000); Serial.println(current_mA); display.clearDisplay(); voltCurrent(); delay(25); } void voltCurrent() { display.setTextSize(3); display.setTextColor(WHITE); display.setCursor(0, 10); display.print(current_mA); display.print("mA"); display.setCursor(0, 40); display.print(loadVoltage_V); display.print("V"); display.display(); } A DOKŁADNOŚĆ? No tu już jest troszkę gorzej. W szkole przy użyciu w miarę dokładnego amperomierza analogowego pomierzyłem trochę prądów*: No jest dosyć duża rozbieżność, niestety. Pewnie można byłoby polepszyć dokładność; zmienić rezystor na taki, który ma TCR bardzo mały, dokładność lepszą, dorobić lepsze rozpraszanie ciepła itd. *Trochę mało czasu miałem, dlatego badanie odbywało się co 500mA 😉 PODSUMOWANIE Urządzonko może głownie przydać się jako dodatek do zasilacza laboratoryjnego, ale także w szkołach przy badaniu różnych układów np. na pracowni elektrycznej. Uczniowi na pewno będzie trochę łatwiej przy rysowaniu charakterystyk 🙂

Po kursie Arduino chcesz nauczyć się czegoś jeszcze? Albo chcesz zrobić inteligenty dom? A może Arduino po prostu ci nie wystarcza - na to wszystko jest rozwiązanie! ESP8266 to wydajny i tani mikrokontroler. Znajdziemy go na wielu płytkach, od małego 01 na NodeMCU kończąc. Dzisiaj zobaczymy jakie są rodzaje płytek, co w sobie ukrywa kostka mikrokontrolera, oraz spróbujemy przygotować środowisko i wgrać Blinka. Niestety, tak nie robimy - tylko zewrzemy piny. Spis treści serii artykułów: 1. Omówienie, i przygotowanie środowiska 2. Zapoznanie z nowym środowiskiem, praca jako Arduino, prosty serwer WWW 3. Przyspieszony kurs na webmastera 4. Wykresy, zapis do SPIFFS, mini smart-dom 5. Odbiór danych z przeglądarki, stałe IP, łączenie modułów ESP Ten wpis brał udział konkursie na najlepszy artykuł o elektronice lub programowaniu. Sprawdź wyniki oraz listę wszystkich prac » Partnerem tej edycji konkursu (marzec 2020) był popularny producent obwodów drukowanych, firma PCBWay. Możliwości ESP8266 Uznałem, że najlepiej będzie zestawić NodeMCU v3 z Arduino UNO. Najważniejsze informacje podałem w tabeli. Pamiętamy, że ESP pracuje na napięciu 3.3v. Kiedy podłączałem do 5V (nie róbcie tego w domu) się tylko grzał, ale lepiej tego nie róbcie. ESP ma także pamięć FLASH w oddzielnej kostce - co pozwala na dużą jej pojemność (zależy to od wersji modułu). Co więcej, interfejsy możemy zdefiniować na (prawie) każdym pinie. ESP pracuje o wiele szybciej od Arduino - bo aż na 80MHz (z możliwością do 160!), i przede wszystkim ESP jest 32 bitowe. No, i ESP się lekko grzeje, ale to nic złego. Warianty ESP8266 Ten mały mikrokontroler możemy znaleźć na równie małych płytkach, lub znacznie większych i rozbudowanych modułach. Jednym z mniejszych, samodzielnych modułów jest ESP12. Posiada wiele wyprowadzeń, lecz nie jest (nawet z przejściówką) zbyt przyjazny dla płytki stykowej. Posiada natomiast aż 4MB pamięci FLASH (wersja ESP12F). Będzie to optymalny wybór dla rozwiązań wbudowanych (np. własnych płytek). ESP12 Jeżeli natomiast szukamy czegoś równie małego, ale bardziej przyjaznego dla nas, tutaj nadchodzi ESP01. Ten mały modulik ma niestety mniej pamięci (niebieska wersja 512kB, czarna 1MB), oraz tylko 8 wyprowadzonych pinów - lecz do konkretnego zastosowania, np. gniazdka z przekaźnikiem, wystarczy. ESP01 (niebieski) ESP03 i ESP07 to uboższe wersje ESP12, ale posiadają ceramiczną antenę - a ESP07 nawet złącze do zewnętrznej anteny. ESP07 Pozostałe moduły rzadko się spotyka, różnią się jedynie ilością wyprowadzeń, rozmiarem, i sposobem montażu. Przygotowanie ESP do programowania W zależności od tego, jaki moduł wybrałeś, będziesz musiał albo przylutować przewody do jego wyprowadzeń, lub podłączyć się przewodami do płytki stykowej. Dlatego na początek nauki, najlepiej zakupić NodeMCU (płytkę deweloperską z ESP12 na pokładzie), Wemos (troszkę mniejsze płytki z ESP12) - mają wszystko wbudowane. Jeżeli taką płytkę wybrałeś, możesz pominąć ten krok. Mając "surowe" ESP12 lub 01, musisz je odpowiednio podłączyć. Połączenie ESP01 z konwerterem USB ↔ UART. Rozpiska pinów dla ESP01. Do tego będziemy potrzebować dwóch przycisków tact switch, kondensatora elektrolitycznego (z zakresu 100-1000µF), dwóch rezystorów 10kΩ, przewodów, oraz oczywiście ESP i konwertera. Pokazałem to na przykładzie ESP01, ale każdy ESP też ma takie wyprowadzenia: pin CH_PD łączymy na stałe do napięcia zasilania przez rezystor 10kΩ pin RST podciągamy do VCC rezystorem 10kΩ, oraz podpinamy przycisk zwierający do masy pin GPIO0 podpinamy do przycisku zwierającego z masą między VCC a GND dajemy kondensator pin RX konwertera łączymy z pinem TX ESP, a pin TX konwertera z pinem RX ESP piny VCC i GND ESP łączymy z pinami VCC i GND konwertera napięcie na konwerterze ustawiamy na 3.3V! Na NodeMCU także znajdziemy dwa przyciski. Przycisk RST odpowiada ze reset mikrokontrolera - tak samo jak w Arduino. Ale co robi przycisk PRG? Otóż, jeżeli na pin GPIO0 podamy logiczne 0 podczas startu mikrokontrolera, wprowadzimy go w tryb programowania. Dzięki temu będziemy mogli wgrać do niego nasz kod. Jeżeli nie mamy zainstalowanych sterowników dla konwertera (np. CH340), powinniśmy je pobrać i zainstalować. Przygotowanie środowiska ESP możemy programować na dwa sposoby, w języku lua - oraz klasycznie, jak arduino, w c++. Opiszę wam sposób jak programować ESP jako Arduino - a do tego potrzebne będzie Arduino IDE. Jeżeli jeszcze takowego nie mamy, pobieramy najnowszą wersję stąd, po czym instalujemy. Dokładny proces instalacji został opisany na kursie Arduino - jeżeli mamy już zainstalowane środowisko, uruchamiamy je, a następnie przechodzimy do zakładki Plik → Preferencje. Powinno nam się otworzyć nowe okno. Szukamy okienka "Dodatkowe adresy URL do menedżera płytek", i wklejamy ten adres: https://arduino.esp8266.com/stable/package_esp8266com_index.json Całość powinna teraz wyglądać tak: Klikamy OK - następnie przechodzimy do zakładki Narzędzia → Płytka → Menedżer płytek Szukamy "esp8266", i klikamy Instaluj. Pobrane zostanie ok. 100MB danych. Od teraz możemy wybrać płytkę ESP jak zwykłą płytkę Arduino. ALE! Jeżeli już kiedyś programowałeś, w innym IDE, zapewne wiesz, że Arduino IDE jest troszkę przestarzałe. Brak autouzupełniania, podpowiedzi, rozbudowanego systemu plików, GIT, i innych funkcji. Jest na to sposób! Dlatego w tym poradniku także opiszę instalację i konfigurację Microsoft Visual Studio Code do pracy z Arduino. Dzięki temu będzie o wiele prościej i wygodniej pisać programy. Pobieramy zatem najnowsze VS Studio Code z tej strony. Jak widać jest ono dostępne na Windowsa, Linuxa, i MacOS. Po pobraniu i zainstalowaniu, powinniśmy zobaczyć taki widok: Jeżeli ciemny motyw nam nie odpowiada, możemy to zmienić naciskając koło zębate (lewy, dolny róg) i "Color Theme" - jasny motyw to Light+. Problemem dla niektórych może być język angielski - lecz w informatyce jest on niezbędny do funkcjonowania. Nie ma problemu aby wrócić do spolszczonego Arduino IDE. Jeżeli jednak chcesz zostać przy VS Code, musimy zainstalować rozszerzenie Platform.io. Dokładniej masz to opisane w tym forbotowym artykule. Po zainstalowaniu Platformio, klikamy magiczny przycisk F1 (musimy go zapamiętać!), i ukazuje nam się to okno: Znajdziemy tam wszystkie funkcje znane z Arduino IDE! Teraz możemy podpiąć nasz konwerter lub NodeMCU do komputera. Tworzymy nowy projekt, i szukamy po lewej pliku platformio.ini. Tam możemy wybrać inną płytkę niż ta, którą wybraliśmy podczas tworzenia projektu. Możemy także ustalić inne rzeczy - więcej w dokumentacji. Otwieramy podfolder src, i szukamy pliku main.cpp. Otworzyło nam się nowe okno - pierwsze co widzimy, to biblioteka Arduino. Dołączy ona wszystkie funkcje z starego IDE. Wklejamy poniższy kod. Największą różnicą ESP w stosunku do Arduino, jest tutaj zapalenie poprzez ustawienie LOW na pinie. #include <Arduino.h> void setup() { pinMode(LED_BUILTIN, OUTPUT); //pin drugi jako wyjście } void loop() { digitalWrite(LED_BUILTIN, LOW); //zapalamy diodę delay(1000); //czekamy sekundę digitalWrite(LED_BUILTIN, HIGH); //gasimy diodę delay(1000); //czekamy sekundę } Teraz przyszedł moment na wgranie szkicu. Klikamy przycisk PRG (gdzieniegdzie opisywany jako FLASH), trzymamy, a następnie RESET, i puszczamy. Dioda powinna raz mrugnąć - oznacza to, że ESP jest gotowe do zaprogramowania. Klikamy zatem znowu F1, a następnie "Platformio: Upload". Cierpliwie czekamy, aż program się wgra. Kiedy zobaczymy ten komunikat: Przyciskamy przycisk reset na naszej płytce - i dioda powinna zacząć mrugać. Na dole, po lewej, na niebieskim pasku są także małe ikonki pozwalające wgrać szkic. Gratulacje, udało Ci się zaprogramować ESP! Możesz je teraz wykorzystać jako moduł Wifi, samodzielne urządzenie, zastosowań jest tyle ile dla Arduino, a nawet i więcej. Udało Ci się także skonfigurować poprawnie VS Code do pracy z płytkami Arduino (i nie tylko!). W następnym odcinku zobaczymy co tak naprawdę oferuje przesiadka na VS Code, oraz spróbujemy połączyć się przez Wifi. Liźniemy nawet trochę HTMLa z CSSem, aby postawić stronę WWW! W przypadku jakichkolwiek problemów, nie bójcie się pisać komentarzy. Spis treści serii artykułów: 1. Omówienie, i przygotowanie środowiska 2. Zapoznanie z nowym środowiskiem, praca jako Arduino, prosty serwer WWW 3. Przyspieszony kurs na webmastera 4. Wykresy, zapis do SPIFFS, mini smart-dom 5. Odbiór danych z przeglądarki, stałe IP, łączenie modułów ESP

Kojarzycie jakieś gotowce na ESP8266 (mam Wemos d1 mini konkretnie) by miało już webserver, formularze do konfiguracji (wifi, etc), możliwość wgrania nowego firmware OTA? To brzmi jak taki standardowy pakiet, ale szperałem za szablonami i znalazłem tylko takie coś https://gist.github.com/DeanCording/5308e474d909f7d70613722fd86b09bb ale to nie do końca to. Nie chciałem wyważać otwartych drzwi. Obecnie mam wgraną Tasmotę*, ale ona ma pewne minusy i chciałem zastąpić swoim softem, ale nie chce mi się klepać tych generycznych rzeczy.. obstawiam, że ktoś mógł już to zrobić 🙂 * konkretnie to ESP robi za bramkę między licznikiem energii, a RPi i po MQTT raportuje impulsy.. jednak info o liczbie impulsów i czasie pomiędzy 2 ostatnimi umie wysyłać nie częściej niż raz na 10s, a chciałbym po każdym impulsie, bo obecny sposób i zapis tego w InfluxDB dość mocno utrudnia rysowanie sensownych danych w Grafanie.

Opis konstrukcji Dość modny ostatnio temat, poruszający jakość powietrza, powstał w celu wykonania pomiarów wpływu kominka w domu na zapylenie. W ten oto sposób powstała stacja pogodowa z prezentacją pomiarów na LCD 2004 z I2C oraz możliwością udostępnienia danych dla Domoticz lub ThingSpeak. Sercem stacji jest układ ESP8266-12F na adapterze ESP Shild. Całość umieszczono na PCB zaprojektowanym w EAGLE. Płytka jest zaprojektowana w sposób umożliwiający szybką wymianę poszczególnych elementów. Może być ona wykorzystywana do programowania ESP z wykorzystaniem złącza PROG (po podpięciu się konwerterem USB-UART), jak również w innych projektach wykorzystujących I2C, wejście analogowe ESP, wejścia cyfrowe. Jako zasilanie wykorzystałem zasilacz 12V 1A, których mam kilkanaście. Dla potrzeb zasilania czujników potrzebujemy zasilania 5V o wydajności prądowej ok 1A. W tym celu wykorzystano przetwornicę impulsową step down - przetwornica DC-DC Mini 360 . Przetwornica, jak i inne elementy jest wymienna (na goldpinach). Takie rozwiązanie wymusiło stosowanie tego samego układu w innych projektach, gdzie miałem dostępne zasilania 24-30VDC). Projekt spodobał się znajomym, więc płytka została od razu wykonana w kilku egzemplarzach na frezarce mojego wykonania. Wygląd PCB od strony druku można zobaczyć na zdjęciach. Realizacja pomiarów: W założeniach miałem mierzyć tylko zawartość pyłów ale w szufladach zalegało jeszcze kilka innych czujników. Stąd też dodatkowe pomiary. Pyły: PM1; PM2,5; PM10 - czujnik PMS5003 Ciśnienie, temperatura, wilgotność - czujnik BME280 Wskaźnik CO2 - czujnik MQ135 Wyniki prezentowane są na LCD oraz przez WiFI korzystając z oprogramowania EasyEsp. Istnieje możliwość konfiguracji oprogramowania w celu przesyłania pomiarów do Domoticz lub ThingSpeak. Oprogramowanie W założeniach miałem napisać własny soft wykorzystując biblioteki dostępne dla Arduino IDE, ale z braku czasu poszedłem na łatwiznę i wykorzystałem EasyEsp. Soft wgrywamy za pomocą oprogramowania Esp8266Flasher - wykorzystujemy połączenie po USB - UART (złącze PROG na PCB). Konfiguracja Proces konfiguracji jest dokonywany z poziomu strony WWW oprogramowania ESPEasy i jest dość intuicyjny. Wszystkie parametry wpisujemy w zakładkach odpowiedzialnych za obsługę sieci, czujników iitp. Oczywiście proces konfiguracji opisany jest dokładnie na stronie projektu ESPEasy. Dla osób nie obeznanych w tej tematyce zamieszczam plik konfiguracyjny mojego projektu wraz z dokumentacją zdjęciową (Konfiguracja ESP). Podsumowanie Na chwilę obecną brak jest obudowy, ale układ powstał jako prototyp i każdy adresat układu ma ją wykonać we własnym zakresie. Sam zrobię to jak skończę inne projekty. Konstrukcja ma sporo wad: 1. Brak kalibracji czujników. 2. Pomiar MQ135 to tylko wskazanie przesunięte o 400 ppm (~poziom CO2 w atmosferze, nie uwzględniam wpływu temperatury i wilgotności). 3. Brak dzielnika napięcia na A0 (ESP ma pomiar 0-1V, MQ135 może dać do 5 V przy 5000 ppm), jednak zakładam, że nie będę miał stężenia ponad 1000ppm w domu. Później przetnę ścieżkę na PCB i dam dzielnik na analogu (co niestety zmniejszy dokładność pomiarów) lub zabezpieczę wejście analogowe diodą zenera. 4. Gotowe oprogramowanie z wieloma wadami, w planach zmiana na własny soft i wysyłanie informacji na Cayenne IOT. Zalety: 1. Prosta modułowa konstrukcja, uniwersalna płytka PCB stosowana przeze mnie w innych projektach. 2. Gotowy soft możliwy do wgrania i konfiguracji dla zupełnych laików. Jeśli ktoś jest zainteresowany dodatkowymi materiałami, to proszę o kontakt PW. W załączniku zamieszczam: 1. EAGLE - schemat w EAGLE 9.1.2 wraz z rysunkiem ścieżek. 2. ESP - oprogramowanie w wykorzystanej wersji. 3. ESP8266Flasher - soft do wgrania oprogramowania. Podczas testów pomiar pyłów miałem na zewnątrz przy mrozach ponad 300 szczytowo i pokrywało się to z lokalną stacją w Połańcu (odchyłka była w granicach 5%). Czujnik PM5003 pracuje u mnie w cyklu 60 sekund pomiary/ 30 minut uśpienie. Żywotność czujnika laserowego to 8000 h. Częstszych pomiarów nie potrzebuję do swoich potrzeb. Czas 60 sekund wystarcza do odpowiedniego wygrzania czujnika i ustabilizowania się pomiarów. Cała stacja pobiera zaraz po starcie ok. 3 W, a po nagrzaniu czujnika MQ135 pobór energii spada do ok. 1,8 W. ESP8266Flasher.zip EAGLE.zip ESP.zip Konfiguracja_ESPEasy.zip

Witam. Znalazłem na YouTube stacje pogodową. W podpisie pod filmem jest adres do kodu źródłowego który należy otworzyć w Arduino IDE, wpisać/zmienić w 3 linijkach dane i działa. Ja jako zielony szczypiorek na wiosnę. -Spróbujmy Wczoraj przyszły zamówione komponenty, więc wierząc w swoje siły przysiadłem fałda pościągałem, po instalowałem i po spędzeniu w sumie 7h udało mi się dojść jakich bibliotek mi brakuje. Lecz przy kompilacji wywala mi błąd. Mam płytkę Nodemcu CH340G V3 i ekranik MSP 2401 lub MSP 2042 Według LcdWiki sterownik który jest podany w kodzie powinien pasować. A wywala błąd. Może ze złej biblioteki korzystam? Będę wdzięczny za jakąkolwiek pomoc/wskazówkę co jest nie tak. esp8266-weather-station-color.zip

W innym wątku opisałem jak wykonałem zdalny moduł otwierania bramy współpracujący z sterownikiem HB5, tutaj przedstawię jak przy pomocy modułów radiowych 433Mhz można odczytać kod nadawany przez pilot oraz nadać go powtórnie w celu sterowania bramą. Do całej zabawy potrzebna będzie nam biblioteka RCSwitch.h oraz jakaś płytka kompatybilna z Arduino. Wgrywamy przykład ReceiveDemo_Simple uruchamiamy monitor portu szeregowego i wciskamy przycisk na naszym pilocie powinien pojawić nam się kod który wysyła nasz pilot. W ten oto prosty sposób odczytaliśmy kod do naszego sterownika, który następnie możemy nadać. Na samym początku miałem plan zrobić tylko pilot do bramy ale projekt rozrósł się i tak oto na swoim pokładzie posiada: czujnik temperatury wilgotności oraz ciśnienia BME280 wyświetlacz oled SSD 1306 zegar czasu rzeczywistego DS1307 Wszystkie powyższe moduły komunikują się z mikrokontrolerem poprzez magistralę szeregową i2c co znacznie uprościło konstrukcję i pozwoliło uniknąć zbędnego okablowania. Do przewijania ekranów i wyświetlania tylu informacji wykorzystałem bibliotekę OLEDDisplayUi.h której działanie widać na poniższym filmie. Zostało przygotowanych 5 ekranów (Zegar analgoowy, zegar cyfrowy, temperatura, wilgotność i ciśnienie) a po wciśnięciu przycisku jest wyświetlany napis “BRAMA” oraz zostaje nadany kod otwarcia/zamknięcia bramy. Aby uniknąć konieczności ustawiania zegara, czas synchronizuje się automatycznie z moim domowym serwerem NTP, za każdym razem gdy mikrokontroler znajdzie się w zasięgu sieci WIFI. Najwięcej czasu zajęła mi rzecz która wydawała się najprostsza czyli ustawienie strefy czasowej 🙂 tak przynajmniej mi się wydaje. Zobaczymy za kilka tygodni. Zasięg pilota jest bardzo zadowalający, urządzenie jest zamontowane wewnątrz pojazdu w centralnej części konsoli w Fordzie Focusie a otwarcie bramy z 150m nie stanowi dla niego problemu Obudowa została zaprojektowana w sketchupie oraz wydrukowana z PLA, lato w samochodzie przeżyła lecz temperatury zrobiły swoje i w niektórych miejscach można było zauważyć odkształcenia. W planach jest wydruk z PET-G lub ABS. Poniżej kilka zdjęć jak wszystko zostało upchnięte: Przygotowana została również mniejsza wersja do Forda Fiesty z Arduino Pro Mini, montuje się ją w centralnej części kokpitu, w miejsce gdzie można włożyć karty do bankomatu. Oczywiście kod programu udostępniam: OLEDAuto.zip

Witam! Jestem początkujący w tematyce Arduino i Esp dlatego zdecydowałem się opisać mój problem na forum. Rozpocząłem pracę z ESP8266. Mimo wielu prób nie mogę uzyskać odpowiedzi na komendy AT ( testowałem dla wszystkich ustawień bauds). Co może być tego przyczyną ?? Układ zmontowałem zgodnie z: https://www.youtube.com/watch?v=bQ54De84Ww4&t=195s Czy wie ktoś może jaka może być przyczyna takiego problemu ? Dziękuję za pomoc!

Witam. Mam problemy z obsługą I2C na NodeMcu v3. NodeMCU v3 podłączony z LCM1602 tak jak na schemacie poniżej z tym że LCM1602 dostaje zasilanie 5V zasilacza, a GND z NodeMCU, LCM1602 i zasilacza są połączone razem. LCM1602 docelowo podłączony jest do wyświetlacza 20x4. 1. Po odpaleniu I2cScanner otrzymuję: Scanning... Unknown error at address 0x01 Unknown error at address 0x02 .... No I2C devices found 2. Po odpaleniu I2CexpDiag z https://github.com/duinoWitchery/hd44780 dostaję: Serial Initialized -------------------------------------------------------------------- I2CexpDiag - i2c LCD i/o expander backpack diagnostic tool -------------------------------------------------------------------- hd44780 lib version: 1.3.2 -------------------------------------------------------------------- Reported Arduino Revision: 1.8.16 Arduino Board: ESP8266_NODEMCU_ESP12E CPU ARCH: ESP8266 - F_CPU: 80000000 -------------------------------------------------------------------- SDA digital pin: 4 (GPIO4) SCL digital pin: 5 (GPIO5) -------------------------------------------------------------------- Checking for required external I2C pull-up on SDA - STUCK LOW Checking for required external I2C pull-up on SCL - STUCK LOW ******************************************************************** ERROR: SDA or SCL stuck pin ******************************************************************** I2C bus not usable Testowałem również na przypadkach gdzie na dwóch różnych expanderach LCM1602, gdzie nie ma podłączonego wyświetlacza i zasilacza, a zasilanie LCM1602 jest z pinu NodeMCU 3V, korzystałem również z różnych przewodów - efekt ten sam. Sprawdziłem też piny D1 i D2 - są zdrowe (jest prawidłowe napięcie gdy ustawiony jest stan wysoki, a po podłączeniu diody i odpaleniu testowego programu prawidłowo mruga). Ponadto sprawdziłem też to samo na innym ESP8266 - tym razem pod postacią Wemos D1 mini - tam sytuacja również jest taka sama. Czy pominąłem jakiś krok? Jakieś sugestie?